动力学与时间演化

薛定谔方程

该模块提供了用于求解幺正薛定谔方程的求解器。

sesolve(

H: QobjEvoLike,

psi0: Qobj,

tlist: ArrayLike,

_e_ops=None,

_args=None,

_options=None,

*,

e_ops: EopsLike | list[EopsLike] | dict[Any, EopsLike] = None,

args: dict[str, Any] = None,

options: dict[str, Any] = None,

**kwargs,

) → Result[source]

给定哈密顿量的状态向量或酉矩阵的薛定谔方程演化。

使用给定的哈密顿量（H）演化状态向量（psi0），通过积分定义系统的常微分方程组。或者，在求解薛定谔算子方程时演化一个幺正矩阵。

输出是在任意时间点（tlist）的状态向量或酉矩阵，或者是提供的算符（e_ops）的期望值。如果e_ops是一个回调函数，它会在tlist中的每个时间点被调用，时间和状态作为参数，并且该函数不使用任何返回值。e_ops不能与求解薛定谔算符方程一起使用。

时间依赖的操作符

对于时间依赖的问题，H 和 c_ops 可以是一个 QobjEvo 或可以被解释为 QobjEvo 的对象，例如一个 (Qobj, Coefficient) 对的列表或一个函数。

Parameters:

HQobj, QobjEvo, QobjEvo compatible format.

系统的哈密顿量作为Qobj或QobjEvo用于时间依赖的哈密顿量。接受[Qobj, Coefficient]的列表或可调用对象，这些对象可以转换为QobjEvo。

psi0Qobj

初始状态向量（ket）或初始酉算子 psi0 = U

tlistlist / array

时间列表为 \(t\)。

e_opsQobj, callable, list or dict, optional

单个操作符，或操作符的列表或字典，用于评估期望值。操作符可以是Qobj、QobjEvo或具有签名f(t: float, state: Qobj) -> Any的可调用对象。

argsdict, optional

时间依赖哈密顿量的参数字典

optionsdict, optional

求解器的选项字典。

store_final_state : bool

Whether or not to store the final state of the evolution in the result class.
store_states : bool, None

Whether or not to store the state vectors or density matrices. On None the states will be saved if no expectation operators are given.
normalize_output : bool

Normalize output state to hide ODE numerical errors. Only normalize the state if the initial state is already normalized.
progress_bar : str {‘text’, ‘enhanced’, ‘tqdm’, ‘’}

How to present the solver progress. ‘tqdm’ uses the python module of the same name and raise an error if not installed. Empty string or False will disable the bar.
progress_kwargs : dict

kwargs to pass to the progress_bar. Qutip’s bars use chunk_size.
method : str [“adams”, “bdf”, “lsoda”, “dop853”, “vern9”, etc.]

Which differential equation integration method to use.
atol, rtol : float

Absolute and relative tolerance of the ODE integrator.
nsteps : int

Maximum number of (internally defined) steps allowed in one tlist step.
max_step : float

Maximum lenght of one internal step. When using pulses, it should be less than half the width of the thinnest pulse.

根据集成方法的不同，可能支持其他选项，请参阅Integrator。

Returns:

result: Result: 类 Result 的一个实例，其中包含一个 数组列表 result.expect，表示由 tlist 指定的时间的期望值，和/或一个列表 result.states，表示与 tlist 中的时间对应的状态向量或密度矩阵 [如果 e_ops 是一个空列表或在选项中有 store_states=True]。

krylovsolve( H: Qobj, psi0: Qobj, tlist: ArrayLike, krylov_dim: int, _e_ops=None, _args=None, _options=None, *, e_ops: dict[Any, Qobj | QobjEvo | Callable[[float, Qobj], Any]] = None, args: dict[str, Any] = None, options: dict[str, Any] = None, ) → Result[源代码]

使用Krylov方法对时间无关哈密顿量的状态向量进行薛定谔方程演化。

通过在一组小维度的Krylov子空间（m << dim(H)）上获得时间演化算子的投影，演化状态向量（“psi0”）以找到哈密顿量（“H”）的时间演化算子的近似值。

输出是在任意时间点（tlist）的状态向量或酉矩阵，或者是提供的操作符（e_ops）的期望值。如果e_ops是一个回调函数，它会在tlist中的每个时间点被调用，时间和状态作为参数，并且该函数不使用任何返回值。e_ops不能与求解薛定谔算子方程一起使用。

Parameters:

HQobj, QobjEvo, QobjEvo compatible format.

系统的哈密顿量作为Qobj或QobjEvo用于时间依赖的哈密顿量。接受[Qobj, Coefficient]的列表或可调用对象，这些对象可以转换为QobjEvo。

psi0Qobj

初始状态向量（ket）

tlistlist / array

时间列表为 \(t\)。

krylov_dim: int

用于时间演化近似的Krylov近似子空间的维度。

e_opsQobj, callable, or list, optional

单个操作符或操作符列表，用于评估期望值或可调用对象或可调用对象列表。可调用对象的签名必须为f(t: float, state: Qobj)。有关操作符期望值的更多详细信息，请参见expect。

argsdict, optional

时间依赖哈密顿量的参数字典

optionsdict, optional

求解器的选项字典。

store_final_state : bool

Whether or not to store the final state of the evolution in the result class.
store_states : bool, None

Whether or not to store the state vectors or density matrices. On None the states will be saved if no expectation operators are given.
normalize_output : bool

Normalize output state to hide ODE numerical errors. Only normalize the state if the initial state is already normalized.
progress_bar : str {‘text’, ‘enhanced’, ‘tqdm’, ‘’}

How to present the solver progress. ‘tqdm’ uses the python module of the same name and raise an error if not installed. Empty string or False will disable the bar.
progress_kwargs : dict

kwargs to pass to the progress_bar. Qutip’s bars use chunk_size.
atol: float

Absolute tolerance of the ODE integrator.
nsteps : int

Maximum number of (internally defined) steps allowed in one tlist step.
min_step, max_step : float

Miniumum and maximum lenght of one internal step.
always_compute_step: bool

If True, the step lenght is computed each time a new Krylov subspace is computed. Otherwise it is computed only once when creating the integrator.
sub_system_tol: float

Tolerance to detect an happy breakdown. An happy breakdown happens when the initial ket is in a subspace of the Hamiltonian smaller than krylov_dim.

Returns:

result: Result: 类 Result 的一个实例，包含一个期望值的 数组列表 result.expect，这些期望值对应于 tlist 中指定的时间，和/或一个状态向量或密度矩阵的列表 result.states，这些状态对应于 tlist 中的时间 [如果 e_ops 是一个空列表或选项中的 store_states=True]。

class SESolver( H: Qobj | QobjEvo, *, options: dict[str, Any] = None, )[源代码]

基础类：Solver

给定哈密顿量的状态向量或酉矩阵的薛定谔方程演化。

Parameters:

HQobj, QobjEvo: 系统的哈密顿量作为Qobj或QobjEvo用于时间依赖的哈密顿量。接受[Qobj, Coefficient]的列表或可调用对象，这些对象可以转换为QobjEvo。
optionsdict, optional: 求解器的选项，请参阅 SESolver.options 和 Integrator 以获取所有选项的列表。

Attributes:

stats: dict: 进化过程中的多样化诊断统计。

classmethod ExpectFeedback( operator: Qobj | QobjEvo, default: Any = 0.0, )

用于时间依赖算子的演化瞬时状态的期望值。

当用作参数时：

QobjEvo([op, func], args={"E0": Solver.ExpectFeedback(oper)})

func 将在演化过程中接收 expect(oper, state) 作为 E0。

Parameters:

operatorQobj, QobjEvo: 用于计算期望值的运算符。
defaultfloat, default0.: 设置时使用的初始值。

classmethod StateFeedback( default: Qobj | Data = None, raw_data: bool = False, prop: bool = False, )[来源]

用于时间依赖算子的演化状态。

当用作参数时：

QobjEvo([op, func], args={"state": SESolver.StateFeedback()})

func 将在演化过程中接收 state 作为键。

Parameters:

defaultQobj or qutip.core.data.Data, defaultNone: 系统设置时使用的初始值。
propbool, defaultFalse: 在使用sesolve计算传播器时设置为True。
raw_databool, defaultFalse: 如果为True，将传递原始矩阵而不是Qobj。对于密度矩阵，矩阵可以是列堆叠或方形的，具体取决于积分方法。

property options: dict

求解器的选项：

store_final_state: bool, default: False: 是否在结果类中存储演化的最终状态。
store_states: bool, default: None: 是否存储状态向量或密度矩阵。在None的情况下，如果没有给出期望算子，状态将被保存。
normalize_output: bool, default: True: 将输出状态归一化以隐藏ODE数值误差。
progress_bar: str {“text”, “enhanced”, “tqdm”, “”}, default: “”: 如何展示求解器的进度。 ‘tqdm’ 使用同名的 Python 模块，如果未安装则会引发错误。空字符串或 False 将禁用进度条。
progress_kwargs: dict, default: {“chunk_size”: 10}: 传递给进度条的参数。Qutip的进度条使用 chunk_size。
method: str, default: “adams”: 使用哪种常微分方程积分方法。

run( state0: Qobj, tlist: ArrayLike, *, e_ops: EopsLike | list[EopsLike] | dict[Any, EopsLike] = None, args: dict[str, Any] = None, ) → Result

进行量子系统的演化。

对于时间 tlist[0] 的 state0，按照 rhs 的指示进行演化，并在 tlist 中的每个时间点将状态和/或期望值存储在 Result 中。演化方法和存储结果由 options 决定。

Parameters:

state0Qobj: 演化的初始状态。
tlistlist of double: 保存演化结果（状态和/或期望）的时间。列表的第一个元素是演化的初始时间。列表中的每个时间必须递增，但不需要均匀分布。
argsdict, optional: 更改演化的args的右侧。
e_opsQobj, QobjEvo, callable, list, or dict optional: 单个、列表或字典的 Qobj、QobjEvo 或可调用对象，用于计算期望值。函数必须具有签名 f(t : float, state : Qobj) -> expect。

Returns:

resultsResult: 进化的结果。状态和/或期望将被保存。您可以在选项中控制保存的数据。

start(state0: Qobj, t0: Number) → None

设置步骤演化的初始状态和时间。

Parameters:

state0Qobj: 演化的初始状态。
t0double: 演化的初始时间。

step( t: Number, *, args: dict[str, Any] = None, copy: bool = True, ) → Qobj

将状态演化到 t 并返回状态作为 Qobj。

Parameters:

tdouble: 进化到的时间，必须高于上次调用。
argsdict, optional {None}: 更新系统的args。更改从间隔的开始生效。更改args可能会减慢演化速度。
copybool, optional {True}: 是否返回数据的副本或ODE求解器中的数据。

注释

状态必须首先通过调用start或 run来初始化。如果调用了run，step将从上次的时间和状态继续。

property sys_dims

系统使用的空间维度：

qutip.basis(sovler.dims) 将为此求解器创建具有适当维度的状态。

主方程

该模块提供了Lindblad主方程和von Neumann方程的求解器。

mesolve(

H: QobjEvoLike,

rho0: Qobj,

tlist: ArrayLike,

c_ops: Qobj | QobjEvo | list[QobjEvoLike] = None,

_e_ops=None,

_args=None,

_options=None,

*,

e_ops: EopsLike | list[EopsLike] | dict[Any, EopsLike] = None,

args: dict[str, Any] = None,

options: dict[str, Any] = None,

**kwargs,

) → Result[source]

给定哈密顿量和一组坍缩算符或李雅普诺夫算符的密度矩阵的主方程演化。

使用给定的哈密顿量或李雅普诺夫量（H）和一组可选的坍缩算子（c_ops），通过积分定义系统的常微分方程组来演化状态向量或密度矩阵（rho0）。在没有坍缩算子的情况下，系统根据哈密顿量的幺正演化进行演化。

输出可以是任意时间点的状态向量 (tlist)，或者是提供的算符的期望值 (e_ops)。如果e_ops是一个回调函数，它会在每个时间点被调用 tlist，并将时间和状态作为参数传递，该函数不使用任何返回值。

如果H或c_ops中的Qobj元素是超算子，它们将被视为对总系统Liouvillian的直接贡献。这允许解决不在标准Lindblad形式中的主方程。

时间依赖的操作符

对于时间依赖的问题，H 和 c_ops 可以是一个 QobjEvo 或可以被解释为 QobjEvo 的对象，例如一个 (Qobj, Coefficient) 对的列表或一个函数。

其他选项

可以通过options参数设置mesolve的额外选项。许多ODE积分选项可以通过这种方式设置，并且store_states和store_final_state选项可以用来存储状态，即使通过e_ops参数请求了期望值。

Parameters:

HQobj, QobjEvo, QobjEvo compatible format.

可能是时间依赖的系统Liouvillian或Hamiltonian，作为Qobj或QobjEvo。也可以接受[Qobj, Coefficient]的列表或可调用对象，这些对象可以转换为QobjEvo。

rho0Qobj

初始密度矩阵或状态向量（ket）。

tlistlist / array

时间列表为 \(t\)。

c_opslist of (QobjEvo, QobjEvo compatible format)

单个坍缩算符，或坍缩算符列表，或Liouvillian超算符列表。None等同于空列表。

e_opsQobj, callable, list or dict, optional

单个操作符，或操作符的列表或字典，用于评估期望值。操作符可以是Qobj、QobjEvo或具有签名f(t: float, state: Qobj) -> Any的可调用对象。

argsdict, optional

时间依赖哈密顿量和坍缩算子的参数字典。

optionsdict, optional

求解器的选项字典。

store_final_state : bool

Whether or not to store the final state of the evolution in the result class.
store_states : bool, None

Whether or not to store the state vectors or density matrices. On None the states will be saved if no expectation operators are given.
normalize_output : bool

Normalize output state to hide ODE numerical errors. Only normalize the state if the initial state is already normalized.
progress_bar : str {‘text’, ‘enhanced’, ‘tqdm’, ‘’}

How to present the solver progress. ‘tqdm’ uses the python module of the same name and raise an error if not installed. Empty string or False will disable the bar.
progress_kwargs : dict

kwargs to pass to the progress_bar. Qutip’s bars use chunk_size.
method : str [“adams”, “bdf”, “lsoda”, “dop853”, “vern9”, etc.]

Which differential equation integration method to use.
atol, rtol : float

Absolute and relative tolerance of the ODE integrator.
nsteps : int

Maximum number of (internally defined) steps allowed in one tlist step.
max_step : float

Maximum lenght of one internal step. When using pulses, it should be less than half the width of the thinnest pulse.

根据集成方法的不同，可能支持其他选项，请参阅Integrator。

Returns:

result: Result: 类 Result 的一个实例，其中包含一个 数组列表 result.expect，表示由 tlist 指定的时间的期望值，和/或一个列表 result.states，表示与 tlist 中的时间对应的状态向量或密度矩阵 [如果 e_ops 是一个空列表或在选项中有 store_states=True]。

注释

当没有给出崩溃运算符且H不是超运算符时，它将默认使用sesolve。

class MESolver( H: Qobj | QobjEvo, c_ops: Qobj | QobjEvo | list[Qobj | QobjEvo] = None, *, options: dict = None, )[源代码]

基础类: SESolver

给定哈密顿量和一组坍缩算符或李雅普诺夫算符的密度矩阵的主方程演化。

使用给定的哈密顿量或李维量 (H) 和一组可选的坍缩算子 (c_ops)，通过积分定义系统的常微分方程组来演化密度矩阵 (rho0)。

如果H或c_ops中的Qobj元素是超算符，它们将被视为对总系统Liouvillian的直接贡献。这允许解决不在标准Lindblad形式中的主方程。

Parameters:

HQobj, QobjEvo: 可能是时间依赖的系统Liouvillian或Hamiltonian，作为Qobj或QobjEvo。也接受[Qobj, Coefficient]列表或可调用对象，这些对象可以转换为QobjEvo。
c_opslist of Qobj, QobjEvo: 单个坍缩算符，或坍缩算符列表，或Liouvillian超算符列表。None等同于空列表。
optionsdict, optional: 求解器的选项，请参阅 MESolver.options 和 Integrator 以获取所有选项的列表。

Attributes:

stats: dict: 进化过程中的多样化诊断统计。

classmethod ExpectFeedback( operator: Qobj | QobjEvo, default: Any = 0.0, )

用于时间依赖算子的演化瞬时状态的期望值。

当用作参数时：

QobjEvo([op, func], args={"E0": Solver.ExpectFeedback(oper)})

func 将在演化过程中接收 expect(oper, state) 作为 E0。

Parameters:

operatorQobj, QobjEvo: 用于计算期望值的运算符。
defaultfloat, default0.: 设置时使用的初始值。

classmethod StateFeedback( default: Qobj | Data = None, raw_data: bool = False, prop: bool = False, )[source]

用于时间依赖算子的演化状态。

当用作参数时：

QobjEvo([op, func], args={"state": MESolver.StateFeedback()})

func 将在演化过程中接收密度矩阵作为 state。

Parameters:

defaultQobj or qutip.core.data.Data, defaultNone: 系统设置时使用的初始值。
propbool, defaultFalse: 在计算传播器时设置为True。默认情况下，传播器将采用其形状而不是状态。
raw_databool, defaultFalse: 如果为True，将传递原始矩阵而不是Qobj。对于密度矩阵，矩阵可以是列堆叠或方形的，具体取决于积分方法。

property options: dict

求解器的选项：

store_final_state: bool, default: False: 是否在结果类中存储演化的最终状态。
store_states: bool, default: None: 是否存储状态向量或密度矩阵。在None的情况下，如果没有给出期望算子，状态将被保存。
normalize_output: bool, default: True: 将输出状态归一化以隐藏ODE数值误差。
progress_bar: str {“text”, “enhanced”, “tqdm”, “”}, default: “”: 如何展示求解器的进度。 ‘tqdm’ 使用同名的 Python 模块，如果未安装则会引发错误。空字符串或 False 将禁用进度条。
progress_kwargs: dict, default: {“chunk_size”: 10}: 传递给进度条的参数。Qutip的进度条使用 chunk_size。
method: str, default: “adams”: 使用哪种常微分方程积分方法。

run( state0: Qobj, tlist: ArrayLike, *, e_ops: EopsLike | list[EopsLike] | dict[Any, EopsLike] = None, args: dict[str, Any] = None, ) → Result

进行量子系统的演化。

对于时间 tlist[0] 的 state0，按照 rhs 的指示进行演化，并在 tlist 中的每个时间点将状态和/或期望值存储在 Result 中。演化方法和存储结果由 options 决定。

Parameters:

state0Qobj: 演化的初始状态。
tlistlist of double: 保存演化结果（状态和/或期望）的时间。列表的第一个元素是演化的初始时间。列表中的每个时间必须递增，但不需要均匀分布。
argsdict, optional: 更改演化的args的右侧。
e_opsQobj, QobjEvo, callable, list, or dict optional: 单个、列表或字典的 Qobj、QobjEvo 或可调用对象，用于计算期望值。函数必须具有签名 f(t : float, state : Qobj) -> expect。

Returns:

resultsResult: 进化的结果。状态和/或期望将被保存。您可以在选项中控制保存的数据。

start(state0: Qobj, t0: Number) → None

设置步骤演化的初始状态和时间。

Parameters:

state0Qobj: 演化的初始状态。
t0double: 演化的初始时间。

step( t: Number, *, args: dict[str, Any] = None, copy: bool = True, ) → Qobj

将状态演化到 t 并返回状态作为 Qobj。

Parameters:

tdouble: 进化到的时间，必须高于上次调用。
argsdict, optional {None}: 更新系统的args。更改从间隔的开始生效。更改args可能会减慢演化速度。
copybool, optional {True}: 是否返回数据的副本或ODE求解器中的数据。

注释

状态必须首先通过调用start或 run来初始化。如果调用了run，step将从上次的时间和状态继续。

property sys_dims

系统使用的空间维度：

qutip.basis(sovler.dims) 将为此求解器创建具有适当维度的状态。

class Result(

e_ops: dict[Any, Qobj | QobjEvo | Callable[[float, Qobj], Any]],

options: ResultOptions,

*,

solver: str = None,

stats: dict[str, Any] = None,

**kw,

)[源代码]

用于存储求解器结果的基类。

Parameters:

e_opsQobj, QobjEvo, function or list or dict of these

e_ops 参数定义了在每个时间步 t 要记录的值集合。如果元素是 Qobj 或 QobjEvo，则记录的值是该算符在 t 时刻状态的期望值。如果元素是一个函数 f，则记录的值是 f(t, state)。

这些值记录在此结果对象的 e_data 和 expect 属性中。e_data 是一个字典，而 expect 是一个列表，其中每个项目包含相应 e_op 的值。

optionsdict

此结果类的选项。

solverstr or None

生成这些结果的求解器的名称。

statsdict or None

求解器在生成这些结果时产生的统计信息。请注意，求解器在生成结果时可能会直接更新统计信息。

kwdict

特定于结果子类的附加参数。

Attributes:

timeslist

记录期望值和状态的时间列表。

stateslist of Qobj

每个时间 t 的状态（如果请求了状态的记录）。

final_stateQobj:

最终状态（如果请求了最终状态的记录）。

expectlist of arrays of expectation values

一个包含每个e_op值的列表。列表的顺序与提供的e_ops顺序相同，如果没有提供e_ops，则列表为空。

每个元素本身是一个列表，并包含相应的e_op的值，每个时间点在.times中都有一个值。

相同的值列表可以通过.e_data字典访问，原始的e_ops可以通过.e_ops属性访问。

e_datadict

一个包含每个e_op值的字典。如果e_ops是以字典形式提供的，则键与该字典中的键相同。否则，键是e_op在.expect列表中的索引。

返回的期望值列表与.expect返回的列表相同。

e_opsdict

一个包含提供的e_ops作为ExpectOp实例的字典。字典的键与.e_data相同。每个值都是一个对象，其中.e_ops[k](t, state)计算在时间t和给定state下的e_op k的值，并且.e_ops[k].op是用于创建e_op的原始对象。

solverstr or None

生成这些结果的求解器的名称。

statsdict or None

求解器在生成这些结果时产生的统计信息。

optionsdict

此结果类的选项。

蒙特卡罗演化

mcsolve(

H: QobjEvoLike,

state: Qobj,

tlist: ArrayLike,

c_ops: QobjEvoLike | list[QobjEvoLike] = (),

_e_ops=None,

_ntraj=None,

*,

e_ops: EopsLike | list[EopsLike] | dict[Any, EopsLike] = None,

ntraj: int = 500,

args: dict[str, Any] = None,

options: dict[str, Any] = None,

seeds: int | SeedSequence | list[int | SeedSequence] = None,

target_tol: float | tuple[float, float] | list[tuple[float, float]] = None,

timeout: float = None,

**kwargs,

) → McResult[源代码]

给定哈密顿量和一组坍缩算符的状态向量 \(|\psi \rangle\) 的蒙特卡罗演化。底层ODE求解器的选项由Options类提供。

Parameters:

HQobj, QobjEvo, list, callable.

系统哈密顿量作为Qobj，QobjEvo。它也可以是QobjEvo接受的任何输入类型（参见QobjEvo的文档）。 H也可以是一个超算子（liouvillian），如果某些崩溃算子需要确定性处理。

stateQobj

初始状态向量或密度矩阵。

tlistarray_like

记录结果的时间。

c_opslist

一个list，包含QobjEvo接受的任何输入类型的崩溃运算符（参见QobjEvo的文档）。即使H是超算子，它们也必须是运算符。如果未提供任何运算符，求解器将默认使用sesolve或mesolve。

e_opsQobj, callable, list or dict, optional

单个操作符，或操作符的列表或字典，用于评估期望值。操作符可以是Qobj、QobjEvo或具有签名f(t: float, state: Qobj) -> Any的可调用对象。

ntrajint, default: 500

要运行的最大轨迹数。如果通过timeout关键字传递了时间限制或达到了目标容差，可能会提前结束，请参见target_tol。

argsdict, optional

时间依赖的哈密顿量和崩溃算子项的参数。

optionsdict, optional

求解器的选项字典。

store_final_state : bool

Whether or not to store the final state of the evolution in the result class.
store_states : bool, None

Whether or not to store the state vectors or density matrices. On None the states will be saved if no expectation operators are given.
progress_bar : str {‘text’, ‘enhanced’, ‘tqdm’, ‘’}

How to present the solver progress. ‘tqdm’ uses the python module of the same name and raise an error if not installed. Empty string or False will disable the bar.
progress_kwargs : dict

kwargs to pass to the progress_bar. Qutip’s bars use chunk_size.
method : str [“adams”, “bdf”, “lsoda”, “dop853”, “vern9”, etc.]

Which differential equation integration method to use.
atol, rtol : float

Absolute and relative tolerance of the ODE integrator.
nsteps : int

Maximum number of (internally defined) steps allowed in one tlist step.
max_step : float

Maximum length of one internal step. When using pulses, it should be less than half the width of the thinnest pulse.
keep_runs_results : bool, [False]

Whether to store results from all trajectories or just store the averages.
map : str {“serial”, “parallel”, “loky”, “mpi”}

How to run the trajectories. “parallel” uses the multiprocessing module to run in parallel while “loky” and “mpi” use the “loky” and “mpi4py” modules to do so.
num_cpus : int

Number of cpus to use when running in parallel. None detect the number of available cpus.
norm_t_tol, norm_tol, norm_steps : float, float, int

Parameters used to find the collapse location. norm_t_tol and norm_tol are the tolerance in time and norm respectively. An error will be raised if the collapse could not be found within norm_steps tries.
mc_corr_eps : float

Small number used to detect non-physical collapse caused by numerical imprecision.
improved_sampling : Bool

Whether to use the improved sampling algorithm from Abdelhafez et al. PRA (2019)

其他选项列在 options下。根据所选的微分方程积分方法，可能会有更多选项可用，请参阅 Integrator。

seedsint, SeedSequence, list, optional

随机数生成器的种子。它可以是一个用于为每个轨迹生成种子的单个种子，也可以是一个种子列表，每个轨迹一个种子。种子保存在结果中，并且可以通过以下方式重复使用：

seeds=prev_result.seeds

target_tolfloat, tuple, list, optional

进化的目标容差。进化将计算轨迹，直到期望值的误差低于此容差。使用的最大轨迹数由ntraj给出。误差使用jackknife重采样计算。target_tol可以是绝对容差或一对绝对和相对容差，按此顺序。最后，它可以是每个e_ops的一对(atol, rtol)的列表。

timeoutfloat, optional

演化的最大时间，单位为秒。当达到此时间时，将不再计算轨迹。

Returns:

resultsMcResult: 存储模拟所有结果的对象。保存哪些结果取决于e_ops的存在和使用的选项。collapse和photocurrent可用于蒙特卡罗模拟结果。如果初始条件是混合的，结果会有额外的属性initial_states和ntraj_per_initial_state。

注释

当达到ntraj、timeout和target_tol之间的第一个结束条件时，模拟将结束。如果初始条件是混合的，target_tol不被支持。如果初始条件是混合的，并且结束条件不是ntraj，则此函数返回的结果应被视为无效。

class MCSolver( H: Qobj | QobjEvo, c_ops: Qobj | QobjEvo | list[Qobj | QobjEvo], *, options: dict[str, Any] = None, )[源代码]

基础类：MultiTrajSolver

蒙特卡罗求解器用于求解给定哈密顿量和坍缩算子集的状态向量 \(|\psi \rangle\)。底层ODE求解器的选项由Options类提供。

Parameters:

HQobj, QobjEvo, list, callable.: 系统哈密顿量作为Qobj，QobjEvo。它也可以是QobjEvo接受的任何输入类型（参见QobjEvo的文档）。 H也可以是一个超算子（liouvillian），如果某些崩溃算子需要确定性处理。
c_opslist: 一个list，包含QobjEvo接受的任何输入类型的崩溃运算符（参见QobjEvo的文档）。即使H是超算子，它们也必须是运算符。
optionsdict, [optional]: 演化的选项。

classmethod CollapseFeedback(default: list = None)[来源]

时间依赖系统的轨迹参数崩溃。

当用作参数时：

QobjEvo([op, func], args={"cols": MCSolver.CollapseFeedback()})

func 将接收一个 (time, operator number) 的列表，作为轨迹每次折叠的 cols。

注意

在步骤之间更新参数时，无法将CollapseFeedback添加到正在运行的求解器中：solver.step(..., args={})。

Parameters:

defaultlist, default[]: 在求解器外部使用的参数值。

classmethod ExpectFeedback( operator: Qobj | QobjEvo, default: Any = 0.0, )

用于时间依赖算子的演化瞬时状态的期望值。

当用作参数时：

QobjEvo([op, func], args={"E0": Solver.ExpectFeedback(oper)})

func 将在演化过程中接收 expect(oper, state) 作为 E0。

Parameters:

operatorQobj, QobjEvo: 用于计算期望值的运算符。
defaultfloat, default0.: 设置时使用的初始值。

classmethod StateFeedback( default: Qobj | Data = None, raw_data: bool = False, prop: bool = False, )[来源]

用于时间依赖算子的演化状态。

当用作参数时：

QobjEvo([op, func], args={"state": MCSolver.StateFeedback()})

func 将在演化过程中接收密度矩阵作为 state。

Parameters:

defaultQobj or qutip.core.data.Data, defaultNone: 系统设置时使用的初始值。
openbool, default False: 当使用蒙特卡洛求解器处理开放系统时，设置为True。
raw_databool, defaultFalse: 如果为True，将传递原始矩阵而不是Qobj。对于密度矩阵，矩阵可以是列堆叠或方形的，具体取决于积分方法。

property options: dict

蒙特卡洛求解器的选项：

store_final_state: bool, default: False: 是否在结果类中存储演化的最终状态。
store_states: bool, default: None: 是否存储状态向量或密度矩阵。在None的情况下，如果没有给出期望算子，状态将被保存。
progress_bar: str {‘text’, ‘enhanced’, ‘tqdm’, ‘’}, default: “text”: 如何展示求解器的进度。 ‘tqdm’ 使用同名的 Python 模块，如果未安装则会引发错误。空字符串或 False 将禁用进度条。
progress_kwargs: dict, default: {“chunk_size”:10}: 传递给进度条的参数。Qutip的进度条使用 chunk_size。
keep_runs_results: bool, default: False: 是否存储所有轨迹的结果或仅存储平均值。
method: str, default: “adams”: 使用哪种微分方程积分方法。
map: str {“serial”, “parallel”, “loky”, “mpi”}, default: “serial”: 如何运行轨迹。“parallel”使用multiprocessing模块并行运行，而“loky”和“mpi”则分别使用“loky”和“mpi4py”模块来实现。
mpi_options: dict, default: {}: 仅当映射为“mpi”时适用。此字典将作为关键字参数传递给mpi4py.futures.MPIPoolExecutor构造函数。请注意，max_workers参数通过num_cpus选项单独提供。
num_cpus: None, int: 并行运行时使用的CPU数量。None 检测可用的CPU数量。
bitgenerator: {None, “MT19937”, “PCG64”, “PCG64DXSM”, …}: 使用哪个numpy.random的bitgenerator。使用None时，将使用您numpy版本的默认值。
mc_corr_eps: float, default: 1e-10: 用于检测由数值不精确引起的非物理崩溃的小数值。
norm_t_tol: float, default: 1e-6: 在查找崩溃时使用的时间容差。
norm_tol: float, default: 1e-4: 在寻找崩溃时使用的范数容差。
norm_steps: int, default: 5: 查找崩溃的最大尝试次数。
improved_sampling: Bool, default: False: 是否使用Abdelhafez等人提出的改进采样算法 PRA (2019)

进行量子系统的演化。

对于时间 tlist[0] 的 state，进行最多 ntraj 次蒙特卡洛演化的模拟。对于 tlist 中的每个时间，将状态和/或期望值存储在 MultiTrajResult 中。演化方法和存储结果由 options 决定。

Parameters:

state{Qobj, list of (Qobj, float)}: 演化的初始状态。可以是纯态或统计系综。系综可以作为密度矩阵提供，也可以作为元组列表提供。在后一种情况下，每个元组的第一个元素是纯态，第二个元素是其权重，即描述该状态下系综比例的0到1之间的数字。所有权重的总和必须为一。
tlistlist of double: 保存演化结果（状态和/或期望）的时间。列表的第一个元素是演化的初始时间。列表中的时间必须按递增顺序排列，但不需要均匀分布。
ntraj{int, list of int}: 要添加的轨迹数量。如果初始状态是纯态，这必须是一个单一的数字。如果初始状态是一个混合系综，指定为纯态列表，此参数也可以是一个具有相同条目数的数字列表。然后它指定每个纯态的轨迹数量。如果初始状态是混合的并且此参数是单一数字，则它指定轨迹的总数，这些轨迹将自动分布在初始系综上。
argsdict, optional: 更改演化的args的右侧。
e_opsQobj, callable, list or dict, optional: 单个操作符，或操作符的列表或字典，用于评估期望值。操作符可以是Qobj、QobjEvo或具有签名f(t: float, state: Qobj) -> Any的可调用对象。
timeoutfloat, optional: 轨迹运行的最大时间（以秒为单位）。一旦达到这个时间，即使轨迹数量少于ntraj，模拟也会结束。在选项中设置的映射函数可以中断正在运行的轨迹或等待其完成。设置为任意高数值以禁用此功能。
target_tol{float, tuple, list}, optional: 进化的目标容差。进化将计算轨迹，直到期望值的误差低于此容差。使用的最大轨迹数由ntraj给出。误差是使用jackknife重采样计算的。target_tol可以是绝对容差或一对绝对和相对容差，按此顺序。最后，它可以是每个e_ops的(atol, rtol)对的列表。
seeds{int, SeedSequence, list}, optional: 每个轨迹的种子或种子列表。

Returns:

resultsMcResult: 演化的结果。状态和/或期望将被保存。您可以在选项中控制保存的数据。如果初始条件是混合的，结果将具有额外的属性 initial_states 和 ntraj_per_initial_state。

start( state0: Qobj, t0: float, seed: int | SeedSequence = None, )

设置步骤演化的初始状态和时间。

Parameters:

stateQobj: 演化的初始状态。
t0double: 演化的初始时间。
seedint, SeedSequence, list, optional: 随机数生成器的种子。它可以是一个用于为每个轨迹生成种子的单一种子，也可以是一个种子列表，每个轨迹一个种子。

注释

使用步骤演化时，一次只能计算一个轨迹。

step( t: float, *, args: dict[str, Any] = None, copy: bool = True, ) → Qobj

将状态演化到 t 并返回状态作为 Qobj。

Parameters:

tdouble: 进化到的时间，必须高于上次调用。
argsdict, optional: 更新系统的args。更改从间隔的开始生效。更改args可能会减慢演化速度。
copybool, default: True: 是否返回数据的副本或ODE求解器中的数据。

property sys_dims

系统使用的空间维度：

qutip.basis(sovler.dims) 将为此求解器创建具有适当维度的状态。

nm_mcsolve(

H: QobjEvoLike,

state: Qobj,

tlist: ArrayLike,

ops_and_rates: list[tuple[Qobj, CoefficientLike]] = (),

_e_ops=None,

_ntraj=None,

*,

e_ops: EopsLike | list[EopsLike] | dict[Any, EopsLike] = None,

ntraj: int = 500,

args: dict[str, Any] = None,

options: dict[str, Any] = None,

seeds: int | SeedSequence | list[int | SeedSequence] = None,

target_tol: float | tuple[float, float] | list[tuple[float, float]] = None,

timeout: float = None,

**kwargs,

) → NmmcResult[源代码]

对应于具有可能为负的“速率”的Lindblad方程的Monte-Carlo演化。此函数的使用类似于mcsolve，但c_ops参数被替换为ops_and_rates参数，以允许负速率。底层ODE求解器的选项由Options类提供。

Parameters:

HQobj, QobjEvo, list, callable.

系统哈密顿量作为Qobj，QobjEvo。它也可以是QobjEvo接受的任何输入类型（参见QobjEvo的文档）。 H也可以是一个超算子（liouvillian），如果某些崩溃算子需要确定性处理。

stateQobj

初始状态向量或密度矩阵。

tlistarray_like

记录结果的时间。

ops_and_rateslist

一个元组 (L, Gamma) 的 list，其中 Lindblad 算子 L 是一个 Qobj，而 Gamma 表示相应的速率，允许为负数。即使 H 是超算子，Lindblad 算子也必须是算子。如果没有给出，求解器将默认使用 sesolve 或 mesolve。每个速率 Gamma 可以只是一个数字（在恒定速率的情况下），或者可以使用 coefficient 接受的任何格式来指定。

e_opsQobj, callable, list or dict, optional

单个操作符，或操作符的列表或字典，用于评估期望值。操作符可以是Qobj、QobjEvo或具有签名f(t: float, state: Qobj) -> Any的可调用对象。

ntrajint, default: 500

要运行的最大轨迹数。如果通过timeout关键字传递了时间限制或达到了目标容差，可能会提前结束，请参见target_tol。

argsdict, optional

时间依赖的哈密顿量和崩溃算子项的参数。

optionsdict, optional

求解器的选项字典。

store_final_state : bool

Whether or not to store the final state of the evolution in the result class.
store_states : bool, None

Whether or not to store the state vectors or density matrices. On None the states will be saved if no expectation operators are given.
progress_bar : str {‘text’, ‘enhanced’, ‘tqdm’, ‘’}

How to present the solver progress. ‘tqdm’ uses the python module of the same name and raise an error if not installed. Empty string or False will disable the bar.
progress_kwargs : dict

kwargs to pass to the progress_bar. Qutip’s bars use chunk_size.
method : str [“adams”, “bdf”, “lsoda”, “dop853”, “vern9”, etc.]

Which differential equation integration method to use.
atol, rtol : float

Absolute and relative tolerance of the ODE integrator.
nsteps : int

Maximum number of (internally defined) steps allowed in one tlist step.
max_step : float

Maximum length of one internal step. When using pulses, it should be less than half the width of the thinnest pulse.
keep_runs_results : bool, [False]

Whether to store results from all trajectories or just store the averages.
map : str {“serial”, “parallel”, “loky”, “mpi”}

How to run the trajectories. “parallel” uses the multiprocessing module to run in parallel while “loky” and “mpi” use the “loky” and “mpi4py” modules to do so.
num_cpus : int

Number of cpus to use when running in parallel. None detect the number of available cpus.
norm_t_tol, norm_tol, norm_steps : float, float, int

Parameters used to find the collapse location. norm_t_tol and norm_tol are the tolerance in time and norm respectively. An error will be raised if the collapse could not be found within norm_steps tries.
improved_sampling : Bool

Whether to use the improved sampling algorithm from Abdelhafez et al. PRA (2019)
mc_corr_eps : float

Small number used to detect non-physical collapse caused by numerical imprecision.
completeness_rtol, completeness_atol : float, float

Parameters used in determining whether the given Lindblad operators satisfy a certain completeness relation. If they do not, an additional Lindblad operator is added automatically (with zero rate).
martingale_quad_limit : float or int

An upper bound on the number of subintervals used in the adaptive integration of the martingale.

请注意，目前不支持‘improved_sampling’选项。更多选项列在options下。根据所选的微分方程积分方法，可能会有更多选项可用，请参阅 Integrator。

seedsint, SeedSequence, list, optional

随机数生成器的种子。它可以是一个用于为每个轨迹生成种子的单个种子，也可以是一个种子列表，每个轨迹一个种子。种子保存在结果中，并且可以通过以下方式重复使用：

seeds=prev_result.seeds

target_tolfloat, tuple, list, optional

进化的目标容差。进化将计算轨迹，直到期望值的误差低于此容差。使用的最大轨迹数由ntraj给出。误差使用jackknife重采样计算。target_tol可以是绝对容差或一对绝对和相对容差，按此顺序。最后，它可以是每个e_ops的一对(atol, rtol)的列表。

timeoutfloat, optional

演化的最大时间（以秒为单位）。当达到此时间时，将不再计算轨迹。

Returns:

resultsNmmcResult: 存储模拟所有结果的对象。与mcsolve返回的结果相比，此结果包含额外的字段trace（如果设置了store_final_state，则还包含runs_trace）。请注意，单个轨迹上的状态未归一化。此字段包含它们的迹的平均值，在足够多的轨迹的极限下，它将收敛到一。如果初始条件是混合的，结果将具有额外的属性initial_states和ntraj_per_initial_state。

class NonMarkovianMCSolver( H: Qobj | QobjEvo, ops_and_rates: Sequence[tuple[Qobj, float | Coefficient]], *, options: dict[str, Any] = None, )[source]

基础类：MCSolver

用于具有可能为负的“速率”的Lindblad方程的蒙特卡罗求解器。MCSolver的c_ops参数被替换为ops_and_rates参数，以允许负速率。底层ODE求解器的选项由Options类提供。

Parameters:

HQobj, QobjEvo, list, callable.: 系统哈密顿量作为Qobj，QobjEvo。它也可以是QobjEvo接受的任何输入类型（参见QobjEvo文档）。 H也可以是一个超算子（liouvillian），如果某些崩溃算子需要确定性处理。
ops_and_rateslist: 一个元组 (L, Gamma) 的 list，其中 Lindblad 算子 L 是一个 Qobj，而 Gamma 表示相应的速率，允许为负数。即使 H 是一个超算子，Lindblad 算子也必须是算子。每个速率 Gamma 可以只是一个数字（在恒定速率的情况下），或者是一个 Coefficient。
optionsSolverOptions, [optional]: 演化的选项。

classmethod CollapseFeedback(default: list = None)

时间依赖系统的轨迹参数崩溃。

当用作参数时：

QobjEvo([op, func], args={"cols": MCSolver.CollapseFeedback()})

func 将接收一个 (time, operator number) 的列表，作为轨迹每次折叠的 cols。

注意

在步骤之间更新参数时，无法将CollapseFeedback添加到正在运行的求解器中：solver.step(..., args={})。

Parameters:

defaultlist, default[]: 在求解器外部使用的参数值。

classmethod ExpectFeedback( operator: Qobj | QobjEvo, default: Any = 0.0, )

用于时间依赖算子的演化瞬时状态的期望值。

当用作参数时：

QobjEvo([op, func], args={"E0": Solver.ExpectFeedback(oper)})

func 将在演化过程中接收 expect(oper, state) 作为 E0。

Parameters:

operatorQobj, QobjEvo: 用于计算期望值的运算符。
defaultfloat, default0.: 设置时使用的初始值。

classmethod StateFeedback( default: Qobj | Data = None, raw_data: bool = False, prop: bool = False, )

用于时间依赖算子的演化状态。

当用作参数时：

QobjEvo([op, func], args={"state": MCSolver.StateFeedback()})

func 将在演化过程中接收密度矩阵作为 state。

Parameters:

defaultQobj or qutip.core.data.Data, defaultNone: 系统设置时使用的初始值。
openbool, default False: 当使用蒙特卡洛求解器处理开放系统时，设置为True。
raw_databool, defaultFalse: 如果为True，将传递原始矩阵而不是Qobj。对于密度矩阵，矩阵可以是列堆叠或方形的，具体取决于积分方法。

current_martingale()[来源]: 返回沿当前轨迹的影响鞅的值。鞅的值是连续贡献和离散贡献的乘积。当前时间和发生的崩溃从内部积分器中读取。

property options: dict[str, Any]

非马尔可夫蒙特卡罗求解器的选项：

store_final_state: bool, default: False: 是否在结果类中存储演化的最终状态。
store_states: bool, default: None: 是否存储状态向量或密度矩阵。在None的情况下，如果没有给出期望算子，状态将被保存。
progress_bar: str {‘text’, ‘enhanced’, ‘tqdm’, ‘’}, default: “text”: 如何展示求解器的进度。 ‘tqdm’ 使用同名的 Python 模块，如果未安装则会引发错误。空字符串或 False 将禁用进度条。
progress_kwargs: dict, default: {“chunk_size”:10}: 传递给进度条的参数。Qutip的进度条使用 chunk_size。
keep_runs_results: bool, default: False: 是否存储所有轨迹的结果或仅存储平均值。
method: str, default: “adams”: 使用哪种微分方程积分方法。
map: str {“serial”, “parallel”, “loky”, “mpi”}, default: “serial”: 如何运行轨迹。“parallel”使用multiprocessing模块并行运行，而“loky”和“mpi”则分别使用“loky”和“mpi4py”模块来实现。
mpi_options: dict, default: {}: 仅当映射为“mpi”时适用。此字典将作为关键字参数传递给mpi4py.futures.MPIPoolExecutor构造函数。请注意，max_workers参数通过num_cpus选项单独提供。
num_cpus: None, int: 并行运行时使用的CPU数量。None 检测可用的CPU数量。
bitgenerator: {None, “MT19937”, “PCG64”, “PCG64DXSM”, …}: 使用哪个numpy.random的bitgenerator。使用None时，将使用您numpy版本的默认值。
mc_corr_eps: float, default: 1e-10: 用于检测由数值不精确引起的非物理崩溃的小数值。
norm_t_tol: float, default: 1e-6: 在查找崩溃时使用的时间容差。
norm_tol: float, default: 1e-4: 在寻找崩溃时使用的范数容差。
norm_steps: int, default: 5: 查找崩溃的最大尝试次数。
improved_sampling: Bool, default: False: 是否使用Abdelhafez等人提出的改进采样算法 PRA (2019)
completeness_rtol: float, default: 1e-5: 用于确定给定的Lindblad算子是否满足某种完备性关系。如果不满足，则会自动添加一个额外的Lindblad算子（速率为零）。
completeness_atol: float, default: 1e-8: 用于确定给定的Lindblad算子是否满足某种完备性关系。如果不满足，则会自动添加一个额外的Lindblad算子（速率为零）。
martingale_quad_limit: float or int, default: 100: 用于自适应积分中子区间数量的上限。

请注意，目前不支持‘improved_sampling’选项。

rate(t, i)[来源]

返回时间 t 的第 i 个未偏移的速率。

Parameters:

tfloat: 计算速率的时间。
iint: 计算哪个比率。

Returns:

ratefloat: 在时间 t 时的利率 i 的值。

rate_shift(t)[来源]

返回时间 t 的速率偏移。

速率偏移是 2 * abs(min([0, rate_1(t), rate_2(t), ...]))。

Parameters:

tfloat: 计算利率变化的时间。

Returns:

rate_shiftfloat: 速率偏移量。

run(

state: Qobj,

tlist: ArrayLike,

ntraj: int = 1,

*,

args: dict[str, Any] = None,

**kwargs,

)[source]

进行量子系统的演化。

对于时间 tlist[0] 的 state，按照 rhs 的指示进行演化，并在 tlist 中的每个时间点将状态和/或期望值存储在 MultiTrajResult 中。演化方法和存储结果由 options 决定。

Parameters:

stateQobj: 演化的初始状态。
tlistlist of double: 保存演化结果（状态和/或期望）的时间。列表的第一个元素是演化的初始时间。列表中的时间必须按递增顺序排列，但不需要均匀分布。
ntrajint: 要添加的轨迹数量。
argsdict, optional: 更改演化的args的右侧。
e_opslist: 用于计算期望值的Qobj或QobjEvo列表。或者，可以使用签名为f(t, state) -> expect的函数。
timeoutfloat, optional: 轨迹运行的最大时间（以秒为单位）。一旦达到这个时间，即使轨迹数量少于ntraj，模拟也会结束。在选项中设置的映射函数可以中断正在运行的轨迹或等待其完成。设置为任意高数值以禁用此功能。
target_tol{float, tuple, list}, optional: 进化的目标容差。进化将计算轨迹，直到期望值的误差低于此容差。使用的最大轨迹数由ntraj给出。误差是使用jackknife重采样计算的。target_tol可以是绝对容差或一对绝对和相对容差，按此顺序。最后，它可以是每个e_ops的(atol, rtol)对的列表。
seeds{int, SeedSequence, list}, optional: 每个轨迹的种子或种子列表。

Returns:

resultsMultiTrajResult: 进化的结果。状态和/或期望将被保存。您可以在选项中控制保存的数据。

sqrt_shifted_rate(t, i)[source]

返回时间 t 处第 i 个偏移率的平方根。

Parameters:

tfloat: 计算偏移率的时间。
iint: 要计算哪个偏移率。

Returns:

ratefloat: 在时间 t 时，速率 i 的偏移值的平方根。

start( state: Qobj, t0: float, seed: int | SeedSequence = None, )[source]

设置步骤演化的初始状态和时间。

Parameters:

stateQobj: 演化的初始状态。
t0double: 演化的初始时间。
seedint, SeedSequence, list, optional: 随机数生成器的种子。它可以是一个用于为每个轨迹生成种子的单一种子，也可以是一个种子列表，每个轨迹一个种子。

注释

使用步骤演化时，一次只能计算一个轨迹。

step( t: float, *, args: dict[str, Any] = None, copy: bool = True, ) → Qobj[源代码]

将状态演化到 t 并返回状态作为 Qobj。

Parameters:

tdouble: 进化到的时间，必须高于上次调用。
argsdict, optional: 更新系统的args。更改从间隔的开始生效。更改args可能会减慢演化速度。
copybool, default: True: 是否返回数据的副本或ODE求解器中的数据。

property sys_dims

系统使用的空间维度：

qutip.basis(sovler.dims) 将为此求解器创建具有适当维度的状态。

class McResult(

e_ops,

options: MultiTrajResultOptions,

*,

solver=None,

stats=None,

**kw,

)[源代码]

基础类：_McBaseResult

用于存储蒙特卡洛求解器结果的类。

Parameters:

e_opsQobj, QobjEvo, function or list or dict of these

e_ops 参数定义了在每个时间步 t 要记录的值集合。如果元素是 Qobj 或 QobjEvo，则记录的值是该算符在 t 时刻状态的期望值。如果元素是一个函数 f，则记录的值是 f(t, state)。

这些值记录在此结果对象的.expect属性中。.expect是一个列表，其中每个项目包含相应e_op的值。

optionsSolverResultsOptions

此结果类的选项。

solverstr or None

生成这些结果的求解器的名称。

statsdict

求解器在生成这些结果时产生的统计信息。请注意，求解器可能会在生成结果时直接更新统计信息。必须包含“num_collapse”的值。

kwdict

特定于结果子类的附加参数。

Attributes:

collapselist: 对于每次运行，列出每次崩溃作为一个元组，包含发生的时间和相应的c_ops索引。

property photocurrent: 平均光电流或演化的测量。

property runs_photocurrent: 每次运行的光电流或测量。

class NmmcResult(

e_ops,

options: MultiTrajResultOptions,

*,

solver=None,

stats=None,

**kw,

)[source]

基础类：_McBaseResult

用于存储非马尔可夫蒙特卡罗求解器结果的类。

Parameters:

e_opsQobj, QobjEvo, function or list or dict of these

e_ops 参数定义了在每个时间步 t 要记录的值集合。如果元素是 Qobj 或 QobjEvo，则记录的值是该算符在 t 时刻状态的期望值。如果元素是一个函数 f，则记录的值是 f(t, state)。

这些值记录在此结果对象的.expect属性中。.expect是一个列表，其中每个项目包含相应e_op的值。

optionsSolverResultsOptions

此结果类的选项。

solverstr or None

生成这些结果的求解器的名称。

statsdict

求解器在生成这些结果时产生的统计信息。请注意，求解器在生成结果时可能会直接更新统计信息。必须包含“num_collapse”的值。

kwdict

特定于结果子类的附加参数。

Attributes:

average_tracelist: 指的是 average_trace 或 runs_trace，取决于选项中是否设置了 keep_runs_results。
std_tracelist: 指的是 average_trace 或 runs_trace，取决于选项中是否设置了 keep_runs_results。
runs_tracelist of lists: 对于每个记录的轨迹，每个时间点的轨迹。只有在选项中设置了keep_runs_results时才会出现。

property average_trace: 指的是 average_trace 或 runs_trace，取决于在选项中是否设置了 keep_runs_results。

merge(other, p=None)[source]

合并两个多轨迹结果。

如果这个结果代表一个集合 \(\rho\)，而 other 代表另一个集合 \(\rho'\)，那么合并的结果代表集合

\[\rho_{\mathrm{merge}} = p \rho + (1 - p) \rho'\]

其中 p 是一个介于 0 和 1 之间的参数。其默认值为 \(p_{\textrm{def}} = N / (N + N')\)，N 和 N’ 是两个结果对象中的轨迹数量。

Parameters:

otherMultiTrajResult: 要与此结果合并的多轨迹结果
pfloat [optional]: 此结果在组合中的相对权重。默认情况下，将选择使所有轨迹对合并结果的贡献相等。

property std_trace: 指的是 average_trace 或 runs_trace，取决于在选项中是否设置了 keep_runs_results。

property trace: 指的是 average_trace 或 runs_trace，取决于在选项中是否设置了 keep_runs_results。

Bloch-Redfield 主方程

该模块提供了Lindblad主方程和von Neumann方程的求解器。

brmesolve(

H: QobjEvoLike,

psi0: Qobj,

tlist: ArrayLike,

a_ops: list[tuple[QobjEvoLike, CoefficientLike]] = None,

sec_cutoff: float = 0.1,

*_pos_args,

c_ops: list[QobjEvoLike] = None,

e_ops: EopsLike | list[EopsLike] | dict[Any, EopsLike] = None,

args: dict[str, Any] = None,

options: dict[str, Any] = None,

**kwargs,

)[源代码]

使用Bloch-Redfield主方程求解系统的动力学，给定输入哈密顿量、厄米浴耦合项及其相关的谱函数，以及可能的Lindblad坍缩算子。

Parameters:

HQobj, QobjEvo

可能是时间依赖的系统Liouvillian或Hamiltonian，作为Qobj或QobjEvo。也接受[Qobj, Coefficient]的列表或可调用对象，可以转换为QobjEvo。

psi0: :obj:`.Qobj`

初始密度矩阵或状态向量（ket）。

tlistarray_like

评估演化的时间列表

a_opslist of (a_op, spectra)

与环境耦合的系统操作符的嵌套列表，以及相应的浴谱。

a_opQobj, QobjEvo, QobjEvo compatible format

与环境耦合的算子。必须是厄米的。

spectraCoefficient, str, func

相应的浴光谱响应。可以是一个使用‘w’参数的Coefficient，频率的函数或字符串。从numpy数组构建的系数被理解为w的函数，而不是t的函数。函数预期具有签名f(w)或f(t, w, **args)。

光谱函数可以依赖于t，如果对应的a_op是一个QobjEvo。

示例：

a_ops = [
    (a+a.dag(), ('w>0', args={"w": 0})),
    (QobjEvo(a+a.dag()), 'w > exp(-t)'),
    ([[b+b.dag(), lambda t: ...]], lambda w: ...)),
    (c+c.dag(), SpectraCoefficient(coefficient(array, tlist=ws))),
]

注意

Cubic_Spline has been replaced by:: spline = qutip.coefficient(array, tlist=times)

a_ops 是否依赖于时间是由操作符的类型决定的：Qobj 与 QobjEvo 而不是光谱的类型。

sec_cutofffloat, default: 0.1

用于世俗近似的截止值。如果在评估浴耦合项时不使用世俗近似，请使用-1。

*_pos_args

Temporary shim to update the signature from
(..., a_ops, e_ops, c_ops, args, sec_cutoff, options)
to
(..., a_ops, sec_cutoff, *, e_ops, c_ops, args, options)
making e_ops, c_ops, args and options keyword only
parameter from qutip 5.3.

c_opslist of (QobjEvo, QobjEvo compatible format), optional

崩溃操作符列表。

argsdict, optional

时间依赖哈密顿量和坍缩算子的参数字典。键w保留用于光谱函数。

e_opslist, dict, Qobj or callback function, optional

单个操作符，或操作符的列表或字典，用于评估期望值。操作符可以是Qobj、QobjEvo或具有签名f(t: float, state: Qobj) -> Any的可调用对象。可调用对象的签名必须是f(t: float, state: Qobj)。

optionsdict, optional

求解器的选项字典。

store_final_state : bool

Whether or not to store the final state of the evolution in the result class.
store_states : bool, None

Whether or not to store the state vectors or density matrices. On None the states will be saved if no expectation operators are given.
normalize_output : bool

Normalize output state to hide ODE numerical errors. Only normalize the state if the initial state is already normalized.
progress_bar : str {‘text’, ‘enhanced’, ‘tqdm’, ‘’}

How to present the solver progress. ‘tqdm’ uses the python module of the same name and raise an error if not installed. Empty string or False will disable the bar.
progress_kwargs : dict

kwargs to pass to the progress_bar. Qutip’s bars use chunk_size.
tensor_type : str [‘sparse’, ‘dense’, ‘data’]

Which data type to use when computing the brtensor. With a cutoff ‘sparse’ is usually the most efficient.
sparse_eigensolver : bool {False} Whether to use the sparse eigensolver
method : str [“adams”, “bdf”, “lsoda”, “dop853”, “vern9”, etc.] Which differential equation integration method to use.
atol, rtol : float

Absolute and relative tolerance of the ODE integrator.
nsteps : int

Maximum number of (internally defined) steps allowed in one tlist step.
max_step : float, 0

Maximum lenght of one internal step. When using pulses, it should be less than half the width of the thinnest pulse.

根据集成方法的不同，可能支持其他选项，请参阅Integrator。

Returns:

result: Result: 类 qutip.solver.Result 的一个实例，它包含在 e_ops 中给出的算符的期望值数组，或由 tlist 指定的时间点的状态列表。

基础类：Solver

给定哈密顿量和一组浴耦合算符的密度矩阵的Bloch Redfield方程演化。

Parameters:

HQobj, QobjEvo

可能是时间依赖的系统Liouvillian或Hamiltonian，作为Qobj或QobjEvo。也接受[Qobj, Coefficient]的列表或可调用对象，可以转换为QobjEvo。

a_opslist of (a_op, spectra)

与环境耦合的系统操作符的嵌套列表，以及相应的浴谱。

a_opQobj, QobjEvo: 与环境耦合的算子。必须是厄米的。
spectraCoefficient: 相应的浴光谱。作为使用‘w’参数的Coefficient。只有在a_op是QobjEvo时，才能依赖于t。 SpectraCoefficient可用于将依赖于t的系数转换为依赖于w的系数。

示例：

a_ops = [
    (a+a.dag(), coefficient('w>0', args={'w':0})),
    (QobjEvo([b+b.dag(), lambda t: ...]),
     coefficient(lambda t, w: ...), args={"w": 0}),
    (c+c.dag(), SpectraCoefficient(coefficient(array, tlist=ws))),
]

c_opslist of Qobj, QobjEvo

单个坍缩算子，或坍缩算子列表，或Lindblad耗散子列表。None等同于空列表。

optionsdict, optional

求解器的选项，请参阅 BRSolver.options 和 Integrator 以获取所有选项的列表。

sec_cutofffloat {0.1}

用于世俗近似的截止值。如果在评估浴耦合项时不使用世俗近似，请使用-1。

Attributes:

stats: dict: 进化过程中的多样化诊断统计。

classmethod ExpectFeedback( operator: Qobj | QobjEvo, default: Any = 0.0, )

用于时间依赖算子的演化瞬时状态的期望值。

当用作参数时：

QobjEvo([op, func], args={"E0": Solver.ExpectFeedback(oper)})

func 将在演化过程中接收 expect(oper, state) 作为 E0。

Parameters:

operatorQobj, QobjEvo: 用于计算期望值的运算符。
defaultfloat, default0.: 设置时使用的初始值。

classmethod StateFeedback(default=None, raw_data=False)[source]

用于时间依赖算子的演化状态。

当用作参数时：

QobjEvo([op, func], args={"state": BRMESolver.StateFeedback()})

func 将在演化过程中接收密度矩阵作为 state。

注意

状态将不在实验室基础上，而是在进化基础上。

Parameters:

defaultQobj or qutip.core.data.Data, defaultNone: 系统设置时使用的初始值。
raw_databool, defaultFalse: 如果为True，将传递原始矩阵而不是Qobj。对于密度矩阵，矩阵可以是列堆叠或方形的，具体取决于积分方法。

property options

布洛赫-雷德菲尔德求解器的选项：

store_final_state: bool, default: False: 是否在结果类中存储演化的最终状态。
store_states: bool, default: None: 是否存储状态向量或密度矩阵。在None的情况下，如果没有给出期望算子，状态将被保存。
normalize_output: bool, default: False: 将输出状态归一化以隐藏ODE数值误差。
progress_bar: str {‘text’, ‘enhanced’, ‘tqdm’, ‘’}, default: “”: 如何展示求解器的进度。 ‘tqdm’ 使用同名的 Python 模块，如果未安装则会引发错误。空字符串或 False 将禁用进度条。
progress_kwargs: dict, default: {“chunk_size”:10}: 传递给进度条的参数。Qutip的进度条使用 chunk_size。
tensor_type: str [‘sparse’, ‘dense’, ‘data’], default: “sparse”: 在计算brtensor时使用哪种数据类型。使用截止值‘sparse’通常是最有效的。
sparse_eigensolver: bool, default: False: 是否使用稀疏特征求解器
method: str, default: “adams”: 支持哪些ODE积分器方法。

run( state0: Qobj, tlist: ArrayLike, *, e_ops: EopsLike | list[EopsLike] | dict[Any, EopsLike] = None, args: dict[str, Any] = None, ) → Result

进行量子系统的演化。

对于时间 tlist[0] 的 state0，按照 rhs 的指示进行演化，并在 tlist 中的每个时间点将状态和/或期望值存储在 Result 中。演化方法和存储结果由 options 决定。

Parameters:

state0Qobj: 演化的初始状态。
tlistlist of double: 保存演化结果（状态和/或期望）的时间。列表的第一个元素是演化的初始时间。列表中的每个时间必须递增，但不需要均匀分布。
argsdict, optional: 更改演化的args的右侧。
e_opsQobj, QobjEvo, callable, list, or dict optional: 单个、列表或字典的 Qobj、QobjEvo 或可调用对象，用于计算期望值。函数必须具有签名 f(t : float, state : Qobj) -> expect。

Returns:

resultsResult: 进化的结果。状态和/或期望将被保存。您可以在选项中控制保存的数据。

start(state0: Qobj, t0: Number) → None

设置步骤演化的初始状态和时间。

Parameters:

state0Qobj: 演化的初始状态。
t0double: 演化的初始时间。

step( t: Number, *, args: dict[str, Any] = None, copy: bool = True, ) → Qobj

将状态演化到 t 并返回状态作为 Qobj。

Parameters:

tdouble: 进化到的时间，必须高于上次调用。
argsdict, optional {None}: 更新系统的args。更改从间隔的开始生效。更改args可能会减慢演化速度。
copybool, optional {True}: 是否返回数据的副本或ODE求解器中的数据。

注释

状态必须首先通过调用start或 run来初始化。如果调用了run，step将从上次的时间和状态继续。

property sys_dims

系统使用的空间维度：

qutip.basis(sovler.dims) 将为此求解器创建具有适当维度的状态。

Floquet 状态和 Floquet-Markov 主方程

floquet_tensor( H: QobjEvo | FloquetBasis, c_ops: list[Qobj], spectra_cb: list[Callable[[float], complex]], T: float = 0, w_th: float = 0.0, kmax: int = 5, nT: int = 100, ) → Qobj[source]

构建一个表示在Floquet基中的主方程的张量。

最简单的RWA近似 [Grifoni等人, 物理报告 304 229 (1998)]

Parameters:

HQobjEvo, FloquetBasis: 周期性哈密顿量的Floquet基系统。
c_opslist of Qobj: 崩溃操作符列表。
spectra_cblist callback functions: 计算噪声功率谱的回调函数列表，作为c_ops中崩溃操作符的频率函数。
Tfloat, optional: 哈密顿量的时间依赖周期。如果H是FloquetBasis对象，则此参数可选。
w_thfloat, default: 0.0: 以频率为单位的温度。
kmaxint, default: 5: 边带数量的截断（默认值为5）。
nTint, default: 100: 在一个周期内进行积分步骤的次数（用于计算X）。

Returns:

outputarray: Floquet-Markov主方程张量R。

fmmesolve( H: QobjEvoLike | FloquetBasis, rho0: Qobj, tlist: ArrayLike, c_ops: list[Qobj] = None, spectra_cb: list[Callable[[float], complex]] = None, T: float = 0.0, w_th: float = 0.0, *pos_args, e_ops: EopsLike | list[EopsLike] | dict[Any, EopsLike] = None, args: dict[str, Any] = None, options: dict[str, Any] = None, ) → FloquetResult[源代码]

使用Floquet-Markov主方程求解系统的动力学。

Parameters:

HQobj, QobjEvo, QobjEvo compatible format.

周期性系统的哈密顿量作为QobjEvo。也可以接受可以转换为QobjEvo的[Qobj, Coefficient]列表或可调用对象。

rho0 / psi0Qobj

初始密度矩阵或状态向量（ket）。

tlistlist / array

\(t\) 的时间列表。

c_opslist of Qobj, optional

崩溃操作符列表。不支持时间依赖的崩溃操作符。如果未提供，则回退到 fsesolve。

e_opslist of Qobj / callback function, optional

单个操作符，或操作符的列表或字典，用于评估期望值。操作符可以是Qobj、QobjEvo或具有签名f(t: float, state: Qobj) -> Any的可调用对象。有关操作符期望的更多详细信息，请参见expect。在计算期望值之前，状态会恢复到实验室基础。

spectra_cblist callback functions, default: lambda w: (w > 0)

计算噪声功率谱的回调函数列表，作为c_ops中崩溃操作符的频率函数。

Tfloat, default=tlist[-1]

哈密顿量的时间依赖周期。默认值 0 表示 'tlist' 跨越驱动的一个周期。

w_thfloat, default: 0.0

环境温度以频率为单位。例如，如果哈密顿量以2pi GHz为单位编写，并且温度以K给出，请使用以下转换：

温度 = 25e-3 # 单位 K h = 6.626e-34 kB = 1.38e-23 args[‘w_th’] = 温度 * (kB / h) * 2 * pi * 1e-9

argsdict, optional

时间依赖哈密顿量的参数字典

optionsdict, optional

求解器的选项字典。

store_final_state : bool

Whether or not to store the final state of the evolution in the result class.
store_states : bool, None

Whether or not to store the state vectors or density matrices. On None the states will be saved if no expectation operators are given.
store_floquet_states : bool

Whether or not to store the density matrices in the floquet basis in result.floquet_states.
normalize_output : bool

Normalize output state to hide ODE numerical errors. Only normalize the state if the initial state is already normalized.
progress_bar : str {‘text’, ‘enhanced’, ‘tqdm’, ‘’}

How to present the solver progress. ‘tqdm’ uses the python module of the same name and raise an error if not installed. Empty string or False will disable the bar.
progress_kwargs : dict

kwargs to pass to the progress_bar. Qutip’s bars use chunk_size.
method : str [“adams”, “bdf”, “lsoda”, “dop853”, “vern9”, etc.]

Which differential equation integration method to use.
atol, rtol : float

Absolute and relative tolerance of the ODE integrator.
nsteps : int

Maximum number of (internally defined) steps allowed in one tlist step.
max_step : float

Maximum lenght of one internal step. When using pulses, it should be less than half the width of the thinnest pulse.

根据集成方法的不同，可能支持其他选项，请参阅Integrator。

Returns:

result: Result: 类 Result 的一个实例，它包含由 tlist 指定的时间的期望值，和/或对应于这些时间的状态密度矩阵。

fsesolve( H: QobjEvoLike | FloquetBasis, psi0: Qobj, tlist: ArrayLike, T: float = 0.0, *pos_args, e_ops: EopsLike | list[EopsLike] | dict[Any, EopsLike] = None, args: dict[str, Any] = None, options: dict[str, Any] = None, ) → Result[source]

使用Floquet形式主义解决薛定谔方程。

Parameters:

HQobj, QobjEvo, QobjEvo compatible format.

周期性系统的哈密顿量作为QobjEvo。也可以接受可以转换为QobjEvo的[Qobj, Coefficient]列表或可调用对象。

psi0Qobj

初始状态向量（ket）。如果提供了操作符，

tlistlist / array

\(t\) 的时间列表。

Tfloat, default=tlist[-1]

哈密顿量的时间依赖性周期。

e_opslist or dict of Qobj / callback function, optional

单个操作符，或操作符的列表或字典，用于评估期望值。操作符可以是Qobj、QobjEvo或具有签名f(t: float, state: Qobj) -> Any的可调用对象。有关操作符期望的更多详细信息，请参见expect。

argsdictionary, optional

包含评估H所需的变量的字典。

optionsdict, optional

结果的选项。

store_final_state : bool

Whether or not to store the final state of the evolution in the result class.
store_states : bool, None

Whether or not to store the state vectors or density matrices. On None the states will be saved if no expectation operators are given.
normalize_output : bool

Normalize output state to hide ODE numerical errors. Only normalize the state if the initial state is already normalized.

Returns:

outputResult: 类 Result 的一个实例，它包含由 tlist 指定的时间的期望值数组或状态向量数组。

class FMESolver( floquet_basis: FloquetBasis, a_ops: list[tuple[Qobj, Callable[[float], float]]], w_th: float = 0.0, *, kmax: int = 5, nT: int = None, options: dict[str, Any] = None, )[source]

基础类：MESolver

Floquet-Markov主方程的求解器。

注意

操作符（c_ops 和 e_ops）是在实验室基础上。

Parameters:

floquet_basisFloquetBasis: 系统哈密顿量封装在FloquetBasis对象中。为floquet_basis选择与Floquet状态演化不同的积分器可以提高性能。
a_opslist of tuple(Qobj, callable): 崩溃算符列表及其对应的噪声功率谱函数。崩溃算符必须是一个Qobj，并且不能是时间依赖的。谱函数必须接受并返回一个numpy数组。
w_thfloat: 环境的温度，以哈密顿频率为单位。
kmaxint [5]: 边带数量的截断。
nTint [20*kmax]: 在一个周期内进行积分步骤的次数（用于计算X）。
optionsdict, optional: 求解器的选项，请参阅 FMESolver.options 和 Integrator 以获取所有选项的列表。

classmethod ExpectFeedback()[source]

期望在时间依赖的运算符中使用进化的状态。

FMESolver 未实现

classmethod StateFeedback()[源代码]

用于时间依赖算子的演化状态。

FMESolver 未实现

property options: dict

求解器的选项：

store_final_state: bool, default: False: 是否在结果类中存储演化的最终状态。
store_states: bool, default: None: 是否存储状态向量或密度矩阵。在None的情况下，如果没有给出期望算子，状态将被保存。
normalize_output: bool, default: True: 将输出状态归一化以隐藏ODE数值误差。
progress_bar: str {“text”, “enhanced”, “tqdm”, “”}, default: “”: 如何展示求解器的进度。 ‘tqdm’ 使用同名的 Python 模块，如果未安装则会引发错误。空字符串或 False 将禁用进度条。
progress_kwargs: dict, default: {“chunk_size”: 10}: 传递给进度条的参数。Qutip的进度条使用 chunk_size。
method: str, default: “adams”: 使用哪种常微分方程积分方法。

run( state0: Qobj, tlist: ArrayLike, *, floquet: bool = False, args: dict[str, Any] = None, e_ops: EopsLike | list[EopsLike] | dict[Any, EopsLike] = None, ) → FloquetResult[来源]

计算量子系统的演化。

对于时间 tlist[0] 的 state0，按照 rhs 的指示进行演化，并在 tlist 中的每个时间点将状态和/或期望值存储在 Result 中。演化方法和存储结果由 options 决定。

Parameters:

state0Qobj: 演化的初始状态。
tlistlist of double: 保存演化结果（状态和/或期望）的时间。列表的第一个元素是演化的初始时间。列表中的每个时间必须递增，但不需要均匀分布。
floquetbool, optional {False}: 初始状态是在Floquet基还是实验室基。
argsdict, optional: 不支持
e_opslist or dict, optional: 用于计算期望值的Qobj、QobjEvo或可调用对象的列表或字典。函数必须具有签名 f(t : float, state : Qobj) -> expect。

Returns:

resultsFloquetResult: 进化的结果。状态和/或期望将被保存。您可以在选项中控制保存的数据。

start( state0: Qobj, t0: float, *, floquet: bool = False, ) → None[source]

设置步骤演化的初始状态和时间。 options 在此步骤中读取演化的选项。

Parameters:

state0Qobj: 演化的初始状态。
t0double: 演化的初始时间。
floquetbool, optional {False}: 初始状态是在Floquet基还是实验室基。

step( t: float, *, args: dict[str, Any] = None, copy: bool = True, floquet: bool = False, ) → Qobj[来源]

将状态演化到 t 并返回状态作为 Qobj。

Parameters:

tdouble: 进化到的时间，必须高于上次调用。
copybool, optional {True}: 是否返回数据的副本或ODE求解器中的数据。
floquetbool, optional {False}: 是否在Floquet基或实验室基中返回状态。
argsdict, optional {None}: 不支持

注释

状态必须首先通过调用start或run来初始化。如果调用了run，step将从上次获取的时间和状态继续。

property sys_dims

系统使用的空间维度：

qutip.basis(sovler.dims) 将为此求解器创建具有适当维度的状态。

class FloquetBasis( H: QobjEvoLike, T: float, args: dict[str, Any] = None, options: dict[str, Any] = None, sparse: bool = False, sort: bool = True, precompute: ArrayLike = None, times: ArrayLike = None, )[source]

用于计算Floquet模式和状态的工具。

Attributes:

UPropagator: 哈密顿量在一个周期内的传播子。
evecsData: 矩阵，其中每一列是一个初始Floquet模式。
e_quasinp.ndarray[float]: 哈密顿量的准能量。

from_floquet_basis( floquet_basis: QobjOrData, t: float = 0, ) → QobjOrData[来源]

将Floquet基中的ket或密度矩阵在时间t转换到实验室基。

Parameters:

floquet_basisQobj, Data: 在时间 t 的 Floquet 基中的初始状态。可以是 ket 或密度矩阵。
tfloat [0]: 评估Floquet状态的时间。

Returns:

outputQobj, Data: 实验室基础中的状态。返回类型与输入状态的类型相同。

mode( t: float, data: Literal[False], ) → Qobj[source]

mode( t: float, data: Literal[True], ) → Data

计算时间 t 处的 Floquet 模式。

Parameters:

tfloat: 评估Floquet模式的时间。
databool [False]: 是否将状态作为单个数据矩阵或一组ket状态返回。

Returns:

outputlist[Qobj], Data: 时间 t 的 Floquet 状态列表或作为单个矩阵中的列的状态。

state( t: float, data: Literal[False], ) → Qobj[来源]

state( t: float, data: Literal[True], ) → Data

评估时间 t 的 Floquet 状态。

Parameters:

tfloat: 评估Floquet状态的时间。
databool [False]: 是否将状态作为单个数据矩阵或一组ket状态返回。

Returns:

outputlist[Qobj], Data: 时间 t 的 Floquet 状态列表或作为单个矩阵中的列的状态。

to_floquet_basis( lab_basis: QobjOrData, t: float = 0, ) → QobjOrData[源代码]

将实验室基中的ket或密度矩阵转换为时间t时的Floquet基。

Parameters:

lab_basisQobj, Data: 实验室基础中的初始状态。
tfloat [0]: 评估Floquet状态的时间。

Returns:

outputQobj, Data: Floquet基中的状态。返回类型与输入状态的类型相同。

随机薛定谔方程和主方程

smesolve(

H: QobjEvoLike,

rho0: Qobj,

tlist: ArrayLike,

c_ops: Qobj | QobjEvo | Sequence[QobjEvoLike] = (),

sc_ops: Qobj | QobjEvo | Sequence[QobjEvoLike] = (),

heterodyne: bool = False,

*,

e_ops: EopsLike | list[EopsLike] | dict[Any, EopsLike] = None,

args: dict[str, Any] = None,

ntraj: int = 500,

options: dict[str, Any] = None,

seeds: int | SeedSequence | Sequence[int | SeedSequence] = None,

target_tol: float | tuple[float, float] | list[tuple[float, float]] = None,

timeout: float = None,

**kwargs,

) → StochasticResult[source]

求解随机主方程。

Parameters:

HQobj, QobjEvo, QobjEvo compatible format.

系统的哈密顿量作为Qobj或QobjEvo用于时间依赖的哈密顿量。接受[Qobj, Coefficient]的列表或可调用对象，这些对象可以转换为QobjEvo。

rho0Qobj

初始密度矩阵或状态向量（ket）。

tlistlist / array

\(t\) 的时间列表。

c_opslist of (QobjEvo, QobjEvo compatible format), optional

确定性坍缩算子，它将贡献一个标准的Lindblad类型的耗散。

sc_opslist of (QobjEvo, QobjEvo compatible format)

随机崩溃操作符列表。

e_opsQobj, callable, list or dict, optional

单个操作符，或操作符的列表或字典，用于评估期望值。操作符可以是Qobj、QobjEvo或具有签名f(t: float, state: Qobj) -> Any的可调用对象。

argsdict, optional

时间依赖哈密顿量和坍缩算子的参数字典。

ntrajint, default: 500

要计算的轨迹数量。

heterodynebool, default: False

是否使用外差或内差检测。

seedsint, SeedSequence, list, optional

随机数生成器的种子。它可以是一个用于为每个轨迹生成种子的单个种子，也可以是一个种子列表，每个轨迹一个种子。种子保存在结果中，并且可以通过以下方式重复使用：

seeds=prev_result.seeds

使用并行映射时，轨迹可以重新排序。

target_tol{float, tuple, list}, optional

进化的目标容差。进化将计算轨迹，直到期望值的误差低于此容差。使用的最大轨迹数由ntraj给出。误差使用jackknife重采样计算。target_tol可以是绝对容差或一对绝对和相对容差，按此顺序。最后，它可以是每个e_ops的(atol, rtol)对的列表。

timeoutfloat, optional

演化的最大时间（以秒为单位）。当达到此时间时，将不再计算轨迹。覆盖同名的选项。

optionsdict, optional

求解器的选项字典。

store_final_state : bool

Whether or not to store the final state of the evolution in the result class.
store_states : bool, None

Whether or not to store the state vectors or density matrices. On None the states will be saved if no expectation operators are given.
store_measurement: str, {‘start’, ‘middle’, ‘end’, ‘’}

Whether and how to store the measurement for each trajectories. ‘start’, ‘middle’, ‘end’ indicate when in the interval the expectation value of the m_ops is taken.
keep_runs_results : bool

Whether to store results from all trajectories or just store the averages.
normalize_output : bool

Normalize output state to hide ODE numerical errors. Only normalize the state if the initial state is already normalized.
progress_bar : str {‘text’, ‘enhanced’, ‘tqdm’, ‘’}

How to present the solver progress. ‘tqdm’ uses the python module of the same name and raise an error if not installed. Empty string or False will disable the bar.
progress_kwargs : dict

kwargs to pass to the progress_bar. Qutip’s bars use chunk_size.
method : str

Which stochastic differential equation integration method to use. Main ones are {“euler”, “rouchon”, “platen”, “taylor1.5_imp”}
map : str {“serial”, “parallel”, “loky”, “mpi”}

How to run the trajectories. “parallel” uses the multiprocessing module to run in parallel while “loky” and “mpi” use the “loky” and “mpi4py” modules to do so.
num_cpus : NoneType, int

Number of cpus to use when running in parallel. None detect the number of available cpus.
dt : float

The finite steps lenght for the Stochastic integration method. Default change depending on the integrator.

更多选项列在 options下。根据所选的微分方程积分方法，可能会有更多选项可用，请参阅 SIntegrator。

Returns:

output: Result: 类 Result 的一个实例。

ssesolve(

H: QobjEvoLike,

psi0: Qobj,

tlist: ArrayLike,

sc_ops: QobjEvoLike | Sequence[QobjEvoLike] = (),

heterodyne: bool = False,

*,

e_ops: EopsLike | list[EopsLike] | dict[Any, EopsLike] = None,

args: dict[str, Any] = None,

ntraj: int = 500,

options: dict[str, Any] = None,

seeds: int | SeedSequence | Sequence[int | SeedSequence] = None,

target_tol: float | tuple[float, float] | list[tuple[float, float]] = None,

timeout: float = None,

**kwargs,

) → StochasticResult[源代码]

求解随机薛定谔方程。

Parameters:

HQobj, QobjEvo, QobjEvo compatible format.

系统的哈密顿量作为Qobj或QobjEvo用于时间依赖的哈密顿量。接受[Qobj, Coefficient]的列表或可调用对象，这些对象可以转换为QobjEvo。

psi0Qobj

初始状态向量（ket）。

tlistlist / array

\(t\) 的时间列表。

sc_opslist of (QobjEvo, QobjEvo compatible format)

随机崩溃操作符列表。

e_opsQobj, callable, list or dict, optional

单个操作符，或操作符的列表或字典，用于评估期望值。操作符可以是Qobj、QobjEvo或具有签名f(t: float, state: Qobj) -> Any的可调用对象。

argsdict, optional

时间依赖哈密顿量和坍缩算子的参数字典。

ntrajint, default: 500

要计算的轨迹数量。

heterodynebool, default: False

是否使用外差或内差检测。

seedsint, SeedSequence, list, optional

随机数生成器的种子。它可以是一个用于为每个轨迹生成种子的单个种子，也可以是一个种子列表，每个轨迹一个种子。种子保存在结果中，并且可以通过以下方式重复使用：

seeds=prev_result.seeds

target_tol{float, tuple, list}, optional

进化的目标容差。进化将计算轨迹，直到期望值的误差低于此容差。使用的最大轨迹数由ntraj给出。误差使用jackknife重采样计算。target_tol可以是绝对容差或一对绝对和相对容差，按此顺序。最后，它可以是每个e_ops的一对(atol, rtol)的列表。

timeoutfloat, optional

演化的最大时间，单位为秒。当达到此时间时，将不再计算轨迹。覆盖同名的选项。

optionsdict, optional

求解器的选项字典。

store_final_state : bool

Whether or not to store the final state of the evolution in the result class.
store_states : bool, None

Whether or not to store the state vectors or density matrices. On None the states will be saved if no expectation operators are given.
store_measurement: str, {‘start’, ‘middle’, ‘end’, ‘’}

Whether and how to store the measurement for each trajectories. ‘start’, ‘middle’, ‘end’ indicate when in the interval the expectation value of the m_ops is taken.
keep_runs_results : bool

Whether to store results from all trajectories or just store the averages.
normalize_output : bool

Normalize output state to hide ODE numerical errors. Only normalize the state if the initial state is already normalized.
progress_bar : str {‘text’, ‘enhanced’, ‘tqdm’, ‘’}

How to present the solver progress. ‘tqdm’ uses the python module of the same name and raise an error if not installed. Empty string or False will disable the bar.
progress_kwargs : dict

kwargs to pass to the progress_bar. Qutip’s bars use chunk_size.
method : str

Which stochastic differential equation integration method to use. Main ones are {“euler”, “rouchon”, “platen”, “taylor1.5_imp”}
map : str {“serial”, “parallel”, “loky”, “mpi”}

How to run the trajectories. “parallel” uses the multiprocessing module to run in parallel while “loky” and “mpi” use the “loky” and “mpi4py” modules to do so.
num_cpus : NoneType, int

Number of cpus to use when running in parallel. None detect the number of available cpus.
dt : float

The finite steps lenght for the Stochastic integration method. Default change depending on the integrator.

其他选项列在 options下。根据所选的微分方程积分方法，可能会有更多选项可用，请参阅 SIntegrator。

Returns:

output: Result: 类 Result 的一个实例。

class SMESolver( H: Qobj | QobjEvo, sc_ops: Sequence[Qobj | QobjEvo], heterodyne: bool, *, c_ops: Sequence[Qobj | QobjEvo] = (), options: dict[str, Any] = None, )[source]

随机主方程求解器。

Parameters:

HQobj, QobjEvo, QobjEvo compatible format.: 系统的哈密顿量作为Qobj或QobjEvo用于时间依赖的哈密顿量。接受[Qobj, Coefficient]的列表或可调用对象，这些对象可以转换为QobjEvo。
sc_opslist of (QobjEvo, QobjEvo compatible format): 随机崩溃操作符列表。
heterodynebool, default: False: 是否使用外差或内差检测。
optionsdict, optional: 求解器的选项，请参阅 SMESolver.options 和 SIntegrator 以获取所有选项的列表。

classmethod ExpectFeedback( operator: Qobj | QobjEvo, default: Any = 0.0, )

用于时间依赖算子的演化瞬时状态的期望值。

当用作参数时：

QobjEvo([op, func], args={"E0": Solver.ExpectFeedback(oper)})

func 将在演化过程中接收 expect(oper, state) 作为 E0。

Parameters:

operatorQobj, QobjEvo: 用于计算期望值的运算符。
defaultfloat, default0.: 设置时使用的初始值。

classmethod StateFeedback( default: Qobj | Data = None, raw_data: bool = False, )

用于时间依赖算子的演化状态。

当用作参数时：

QobjEvo([op, func], args={"state": SMESolver.StateFeedback()})

func 将在演化过程中接收密度矩阵作为 state。

注意

不支持rouchon方法。

Parameters:

defaultQobj or qutip.core.data.Data, defaultNone: 系统设置时使用的初始值。
raw_databool, defaultFalse: 如果为True，将传递原始矩阵而不是Qobj。对于密度矩阵，矩阵可以是列堆叠或方形的，具体取决于积分方法。

classmethod WienerFeedback( default: Callable[[float], ndarray[Any, dtype[float]]] = None, )

时间依赖系统的轨迹参数的Wiener函数。

当用作参数时：

QobjEvo([op, func], args={"W": SMESolver.WienerFeedback()})

func 将接收一个函数作为 W，该函数返回在 t 处的维纳过程值的数组。对于第 i 个 sc_ops，维纳过程是同调检测中的第 i 个元素，以及异调检测中的 (2i, 2i+1) 对过程。该过程是一个步长函数，步长为 options["dt"]。

注意

在步骤之间更新参数时，无法将WienerFeedback添加到正在运行的求解器中：solver.step(..., args={})。

Parameters:

defaultcallable, optional: 默认函数在求解器外部使用。当未传递时，使用返回np.array([0])的函数。

property options: dict[str, Any]

随机求解器的选项：

store_final_state: bool, default: False: 是否在结果类中存储演化的最终状态。
store_states: None, bool, default: None: 是否存储状态向量或密度矩阵。在None的情况下，如果没有给出期望算子，状态将被保存。
store_measurement: str, {‘start’, ‘middle’, ‘end’, ‘’}, default: “”: 是否以及如何存储每个轨迹的测量值。 ‘start’, ‘middle’, ‘end’ 表示在间隔中何时取 m_ops 的期望值。存储测量值还将存储每个轨迹的维纳过程或布朗噪声。
progress_bar: str {‘text’, ‘enhanced’, ‘tqdm’, ‘’}, default: “text”: 如何显示求解器的进度。'tqdm' 使用同名的 Python 模块，如果未安装则会引发错误。空字符串或 False 将禁用进度条。
progress_kwargs: dict, default: {“chunk_size”:10}: 传递给进度条的参数。Qutip的进度条使用 chunk_size。
keep_runs_results: bool, default: False: 是否存储所有轨迹的结果或仅存储平均值。
normalize_output: bool: 将输出状态归一化以隐藏ODE数值误差。
method: str, default: “platen”: 使用哪种微分方程积分方法。
map: str {“serial”, “parallel”, “loky”, “mpi”}, default: “serial”: 如何运行轨迹。“parallel”使用multiprocessing模块并行运行，而“loky”和“mpi”则分别使用“loky”和“mpi4py”模块来实现。
mpi_options: dict, default: {}: 仅当映射为“mpi”时适用。此字典将作为关键字参数传递给mpi4py.futures.MPIPoolExecutor构造函数。请注意，max_workers参数通过num_cpus选项单独提供。
num_cpus: None, int, default: None: 并行运行时使用的CPU数量。None 检测可用的CPU数量。
bitgenerator: {None, “MT19937”, “PCG64DXSM”, …}, default: None: 使用哪个numpy.random的bitgenerator。使用None时，将使用您numpy版本的默认值。

run( state: Qobj, tlist: ArrayLike, ntraj: int = 1, *, args: dict[str, Any] = None, e_ops: dict[Any, Qobj | QobjEvo | Callable[[float, Qobj], Any]] = None, target_tol: float | tuple[float, float] | list[tuple[float, float]] = None, timeout: float = None, seeds: int | SeedSequence | list[int | SeedSequence] = None, ) → MultiTrajResult

进行量子系统的演化。

对于时间 tlist[0] 的 state，按照 rhs 的指示进行演化，并在 tlist 中的每个时间点将状态和/或期望值存储在 MultiTrajResult 中。演化方法和存储结果由 options 决定。

Parameters:

stateQobj: 演化的初始状态。
tlistlist of double: 保存演化结果（状态和/或期望）的时间。列表的第一个元素是演化的初始时间。列表中的时间必须按递增顺序排列，但不需要均匀分布。
ntrajint: 要添加的轨迹数量。
argsdict, optional: 更改演化的args的右侧。
e_opslist: 用于计算期望值的Qobj或QobjEvo列表。或者，可以使用签名为f(t, state) -> expect的函数。
timeoutfloat, optional: 轨迹运行的最大时间（以秒为单位）。一旦达到这个时间，即使轨迹数量少于ntraj，模拟也会结束。在选项中设置的映射函数可以中断正在运行的轨迹或等待其完成。设置为任意高数值以禁用此功能。
target_tol{float, tuple, list}, optional: 进化的目标容差。进化将计算轨迹，直到期望值的误差低于此容差。使用的最大轨迹数由ntraj给出。误差是使用jackknife重采样计算的。target_tol可以是绝对容差或一对绝对和相对容差，按此顺序。最后，它可以是每个e_ops的(atol, rtol)对的列表。
seeds{int, SeedSequence, list}, optional: 每个轨迹的种子或种子列表。

Returns:

resultsMultiTrajResult: 进化的结果。状态和/或期望将被保存。您可以在选项中控制保存的数据。

run_from_experiment( state: Qobj, tlist: ArrayLike, noise: Sequence[float], *, args: dict[str, Any] = None, e_ops: EopsLike | list[EopsLike] | dict[Any, EopsLike] = None, measurement: bool = False, )

从给定的状态和噪声运行单个轨迹。

Parameters:

stateQobj

系统的初始状态。

tlistarray_like

用于评估状态的时间列表。tlist 必须均匀增加。

noisearray_like

每个时间步长和每个随机崩溃操作符的噪声。对于同调检测，noise[i, t_idx] 是第i个sc_ops在tlist[t_idx] 和 tlist[t_idx+1] 之间的维纳增量。对于异调检测，增加了一个额外的维度用于测量对：noise[i, j, t_idx]``其中 ``j 在 {0,1} 中。

argsdict, optional

传递给哈密顿量和坍缩算符的参数。

e_opsQobj, callable, list or dict, optional

单个操作符，或操作符的列表或字典，用于评估期望值。操作符可以是Qobj、QobjEvo或具有签名f(t: float, state: Qobj) -> Any的可调用对象。

measurementbool, defaultFalse

传递的噪声是维纳增量 dW（具有标准偏差 dt**0.5 的高斯噪声），还是测量值。

同调测量是：

noise[i][t] = dW/dt + expect(sc_ops[i] + sc_ops[i].dag, state[t])

外差测量是：

noise[i][0][t] = dW/dt * 2**0.5
  + expect(sc_ops[i] + sc_ops[i].dag, state[t])

noise[i][1][t] = dW/dt * 2**0.5
  -1j * expect(sc_ops[i] - sc_ops[i].dag, state[t])

请注意，此函数期望期望值在时间步长开始时获取，对应于“store_measurements”选项的“start”设置。

仅适用于有限的集成方法。

Returns:

resultStochasticTrajResult: 轨迹的结果。

注释

仅支持m_ops和dW_factors的默认值。

start( state0: Qobj, t0: float, seed: int | SeedSequence = None, )

设置步骤演化的初始状态和时间。

Parameters:

stateQobj: 演化的初始状态。
t0double: 演化的初始时间。
seedint, SeedSequence, list, optional: 随机数生成器的种子。它可以是一个用于为每个轨迹生成种子的单一种子，也可以是一个种子列表，每个轨迹一个种子。

注释

使用步骤演化时，一次只能计算一个轨迹。

step(t, *, args=None, copy=True, wiener_increment=False)

将状态演化到 t 并返回状态作为 Qobj。

Parameters:

tdouble: 进化到的时间，必须高于上次调用。
argsdict, optional: 更新系统的args。更改从间隔的开始生效。更改args可能会减慢演化速度。
copybool, default: True: 是否返回数据的副本或ODE求解器中的数据。
wiener_increment: bool, default: False: 是否除了状态之外还返回dW。

property sys_dims

系统使用的空间维度：

qutip.basis(sovler.dims) 将为此求解器创建具有适当维度的状态。

class SSESolver( H: Qobj | QobjEvo, sc_ops: Sequence[Qobj | QobjEvo], heterodyne: bool, *, c_ops: Sequence[Qobj | QobjEvo] = (), options: dict[str, Any] = None, )[source]

随机薛定谔方程求解器。

Parameters:

HQobj, QobjEvo, QobjEvo compatible format.: 系统的哈密顿量作为Qobj或QobjEvo用于时间依赖的哈密顿量。接受[Qobj, Coefficient]的列表或可调用对象，这些对象可以转换为QobjEvo。
c_opslist of (QobjEvo, QobjEvo compatible format): 确定性坍缩算子，它将贡献一个标准的Lindblad类型的耗散。
sc_opslist of (QobjEvo, QobjEvo compatible format): 随机崩溃操作符列表。
heterodynebool, default: False: 是否使用外差或内差检测。
optionsdict, optional: 求解器的选项，请参阅 SSESolver.options 和 SIntegrator 以获取所有选项的列表。

classmethod ExpectFeedback( operator: Qobj | QobjEvo, default: Any = 0.0, )

用于时间依赖算子的演化瞬时状态的期望值。

当用作参数时：

QobjEvo([op, func], args={"E0": Solver.ExpectFeedback(oper)})

func 将在演化过程中接收 expect(oper, state) 作为 E0。

Parameters:

operatorQobj, QobjEvo: 用于计算期望值的运算符。
defaultfloat, default0.: 设置时使用的初始值。

classmethod StateFeedback( default: Qobj | Data = None, raw_data: bool = False, )

用于时间依赖算子的演化状态。

当用作参数时：

QobjEvo([op, func], args={"state": SMESolver.StateFeedback()})

func 将在演化过程中接收密度矩阵作为 state。

注意

不支持rouchon方法。

Parameters:

defaultQobj or qutip.core.data.Data, defaultNone: 系统设置时使用的初始值。
raw_databool, defaultFalse: 如果为True，将传递原始矩阵而不是Qobj。对于密度矩阵，矩阵可以是列堆叠或方形的，具体取决于积分方法。

classmethod WienerFeedback( default: Callable[[float], ndarray[Any, dtype[float]]] = None, )

时间依赖系统的轨迹参数的Wiener函数。

当用作参数时：

QobjEvo([op, func], args={"W": SMESolver.WienerFeedback()})

func 将接收一个函数作为 W，该函数返回在 t 处的维纳过程值的数组。对于第 i 个 sc_ops，维纳过程是同调检测中的第 i 个元素，以及异调检测中的 (2i, 2i+1) 对过程。该过程是一个步长函数，步长为 options["dt"]。

注意

在步骤之间更新参数时，无法将WienerFeedback添加到正在运行的求解器中：solver.step(..., args={})。

Parameters:

defaultcallable, optional: 默认函数在求解器外部使用。当未传递时，使用返回np.array([0])的函数。

property options: dict[str, Any]

随机求解器的选项：

store_final_state: bool, default: False: 是否在结果类中存储演化的最终状态。
store_states: None, bool, default: None: 是否存储状态向量或密度矩阵。在None的情况下，如果没有给出期望算子，状态将被保存。
store_measurement: str, {‘start’, ‘middle’, ‘end’, ‘’}, default: “”: 是否以及如何存储每个轨迹的测量值。 ‘start’, ‘middle’, ‘end’ 表示在间隔中何时取 m_ops 的期望值。存储测量值还将存储每个轨迹的维纳过程或布朗噪声。
progress_bar: str {‘text’, ‘enhanced’, ‘tqdm’, ‘’}, default: “text”: 如何显示求解器的进度。'tqdm' 使用同名的 Python 模块，如果未安装则会引发错误。空字符串或 False 将禁用进度条。
progress_kwargs: dict, default: {“chunk_size”:10}: 传递给进度条的参数。Qutip的进度条使用 chunk_size。
keep_runs_results: bool, default: False: 是否存储所有轨迹的结果或仅存储平均值。
normalize_output: bool: 将输出状态归一化以隐藏ODE数值误差。
method: str, default: “platen”: 使用哪种微分方程积分方法。
map: str {“serial”, “parallel”, “loky”, “mpi”}, default: “serial”: 如何运行轨迹。“parallel”使用multiprocessing模块并行运行，而“loky”和“mpi”则分别使用“loky”和“mpi4py”模块来实现。
mpi_options: dict, default: {}: 仅当映射为“mpi”时适用。此字典将作为关键字参数传递给mpi4py.futures.MPIPoolExecutor构造函数。请注意，max_workers参数通过num_cpus选项单独提供。
num_cpus: None, int, default: None: 并行运行时使用的CPU数量。None 检测可用的CPU数量。
bitgenerator: {None, “MT19937”, “PCG64DXSM”, …}, default: None: 使用哪个numpy.random的bitgenerator。使用None时，将使用您numpy版本的默认值。

run( state: Qobj, tlist: ArrayLike, ntraj: int = 1, *, args: dict[str, Any] = None, e_ops: dict[Any, Qobj | QobjEvo | Callable[[float, Qobj], Any]] = None, target_tol: float | tuple[float, float] | list[tuple[float, float]] = None, timeout: float = None, seeds: int | SeedSequence | list[int | SeedSequence] = None, ) → MultiTrajResult

进行量子系统的演化。

对于时间 tlist[0] 的 state，按照 rhs 的指示进行演化，并在 tlist 中的每个时间点将状态和/或期望值存储在 MultiTrajResult 中。演化方法和存储结果由 options 决定。

Parameters:

stateQobj: 演化的初始状态。
tlistlist of double: 保存演化结果（状态和/或期望）的时间。列表的第一个元素是演化的初始时间。列表中的时间必须按递增顺序排列，但不需要均匀分布。
ntrajint: 要添加的轨迹数量。
argsdict, optional: 更改演化的args的右侧。
e_opslist: 用于计算期望值的Qobj或QobjEvo列表。或者，可以使用签名为f(t, state) -> expect的函数。
timeoutfloat, optional: 轨迹运行的最大时间（以秒为单位）。一旦达到这个时间，即使轨迹数量少于ntraj，模拟也会结束。在选项中设置的映射函数可以中断正在运行的轨迹或等待其完成。设置为任意高数值以禁用此功能。
target_tol{float, tuple, list}, optional: 进化的目标容差。进化将计算轨迹，直到期望值的误差低于此容差。使用的最大轨迹数由ntraj给出。误差是使用jackknife重采样计算的。target_tol可以是绝对容差或一对绝对和相对容差，按此顺序。最后，它可以是每个e_ops的(atol, rtol)对的列表。
seeds{int, SeedSequence, list}, optional: 每个轨迹的种子或种子列表。

Returns:

resultsMultiTrajResult: 进化的结果。状态和/或期望将被保存。您可以在选项中控制保存的数据。

run_from_experiment( state: Qobj, tlist: ArrayLike, noise: Sequence[float], *, args: dict[str, Any] = None, e_ops: EopsLike | list[EopsLike] | dict[Any, EopsLike] = None, measurement: bool = False, )

从给定的状态和噪声运行单个轨迹。

Parameters:

stateQobj

系统的初始状态。

tlistarray_like

用于评估状态的时间列表。tlist 必须均匀增加。

noisearray_like

每个时间步长和每个随机崩溃操作符的噪声。对于同调检测，noise[i, t_idx] 是第i个sc_ops在tlist[t_idx] 和 tlist[t_idx+1] 之间的维纳增量。对于异调检测，增加了一个额外的维度用于测量对：noise[i, j, t_idx]``其中 ``j 在 {0,1} 中。

argsdict, optional

传递给哈密顿量和坍缩算符的参数。

e_opsQobj, callable, list or dict, optional

单个操作符，或操作符的列表或字典，用于评估期望值。操作符可以是Qobj、QobjEvo或具有签名f(t: float, state: Qobj) -> Any的可调用对象。

measurementbool, defaultFalse

传递的噪声是维纳增量 dW（具有标准偏差 dt**0.5 的高斯噪声），还是测量值。

同调测量是：

noise[i][t] = dW/dt + expect(sc_ops[i] + sc_ops[i].dag, state[t])

外差测量是：

noise[i][0][t] = dW/dt * 2**0.5
  + expect(sc_ops[i] + sc_ops[i].dag, state[t])

noise[i][1][t] = dW/dt * 2**0.5
  -1j * expect(sc_ops[i] - sc_ops[i].dag, state[t])

请注意，此函数期望期望值在时间步长开始时获取，对应于“store_measurements”选项的“start”设置。

仅适用于有限的集成方法。

Returns:

resultStochasticTrajResult: 轨迹的结果。

注释

仅支持m_ops和dW_factors的默认值。

start( state0: Qobj, t0: float, seed: int | SeedSequence = None, )

设置步骤演化的初始状态和时间。

Parameters:

stateQobj: 演化的初始状态。
t0double: 演化的初始时间。
seedint, SeedSequence, list, optional: 随机数生成器的种子。它可以是一个用于为每个轨迹生成种子的单一种子，也可以是一个种子列表，每个轨迹一个种子。

注释

使用步骤演化时，一次只能计算一个轨迹。

step(t, *, args=None, copy=True, wiener_increment=False)

将状态演化到 t 并返回状态作为 Qobj。

Parameters:

tdouble: 进化到的时间，必须高于上次调用。
argsdict, optional: 更新系统的args。更改从间隔的开始生效。更改args可能会减慢演化速度。
copybool, default: True: 是否返回数据的副本或ODE求解器中的数据。
wiener_increment: bool, default: False: 是否除了状态之外还返回dW。

property sys_dims

系统使用的空间维度：

qutip.basis(sovler.dims) 将为此求解器创建具有适当维度的状态。

class MultiTrajResult(

e_ops,

options: MultiTrajResultOptions,

*,

solver=None,

stats=None,

**kw,

)[来源]

用于存储使用多条轨迹的求解器结果的基类。

Parameters:

e_opsQobj, QobjEvo, function or list or dict of these

e_ops 参数定义了在每个时间步 t 要记录的值集合。如果元素是 Qobj 或 QobjEvo，则记录的值是该算符在 t 时刻状态的期望值。如果元素是一个函数 f，则记录的值是 f(t, state)。

这些值记录在此结果对象的.expect属性中。.expect是一个列表，其中每个项目包含相应e_op的值。

函数 e_ops 必须返回一个数字，以便可以计算平均值。

optionsdict

此结果类的选项。

solverstr or None

生成这些结果的求解器的名称。

statsdict or None

求解器在生成这些结果时产生的统计信息。请注意，求解器在生成结果时可能会直接更新统计信息。

kwdict

特定于结果子类的附加参数。

Attributes:

timeslist

记录期望值和状态的时间列表。

average_stateslist of Qobj

状态平均值作为密度矩阵。

runs_stateslist of list of Qobj

每次运行的状态为 states[run][t]。

average_final_stateQobj:

每个轨迹的最后状态平均成一个密度矩阵。

runs_final_statelist of Qobj

每个轨迹的最终状态（如果请求了最终状态和轨迹的记录）。

average_expectlist of array of expectation values

一个包含每个e_op在每个轨迹上平均值的列表。列表的顺序与提供的e_ops顺序相同，如果没有提供e_ops，则列表为空。

每个元素本身是一个数组，并包含相应的e_op的值，每个时间点在.times中都有一个值。

std_expectlist of array of expectation values

一个包含每个轨迹上每个e_op的标准偏差的列表。列表的顺序与提供的e_ops的顺序相同，如果没有提供e_ops，则列表为空。

每个元素本身是一个数组，并包含相应的e_op的值，每个时间点在.times中都有一个值。

runs_expectlist of array of expectation values

一个包含每个轨迹的e_op值的列表。列表的顺序与e_ops提供的顺序相同，如果没有提供e_ops，则为空。仅在请求存储轨迹时可用。

元素的顺序是 runs_expect[e_ops][trajectory][time]。

每个元素本身是一个数组，并包含相应的e_op的值，每个时间点在.times中都有一个值。

average_e_datadict

一个包含每个e_op值的字典，这些值是在每个轨迹上平均得到的。如果e_ops是以字典形式提供的，那么键与字典中的键相同。否则，键是e_op在.expect列表中的索引。

返回的期望值列表与.expect返回的列表相同。

std_e_datadict

一个包含每个轨迹上每个e_op标准偏差的字典。如果e_ops是以字典形式提供的，则键与该字典中的键相同。否则，键是e_op在.expect列表中的索引。

返回的期望值列表与.expect返回的列表相同。

runs_e_datadict

一个包含每个轨迹的e_op值的字典。如果e_ops是以字典形式提供的，则键与该字典中的键相同。否则，键是e_op在.expect列表中的索引。仅在请求存储轨迹时可用。

元素的顺序是 runs_expect[e_ops][trajectory][time]。

返回的期望值列表与.expect返回的列表相同。

runs_weightslist

对于每个轨迹，该轨迹进入平均值的权重。

deterministic_weightslist

对于每个确定性轨迹，（当使用improved_sampling时）该轨迹进入平均值的权重。

solverstr or None

生成这些结果的求解器的名称。

num_trajectories: int

计算的轨迹数量。

seeds: list of SeedSequence

用于计算每个轨迹的种子。

trajectories: list of Result

如果选项 keep_runs_results 被设置，将列出所有轨迹。

deterministic_trajectories: list of Result

如果选项 improved_sampling 被设置，则列出无跳跃轨迹的列表。

statsdict or None

求解器在生成这些结果时产生的统计信息。

optionsSolverResultsOptions

此结果类的选项。

add_deterministic(trajectory, weight)[源代码]

添加一个不是随机生成的轨迹。这里提供的权重将用于此轨迹在所有平均值中的确切权重。

Parameters:

trajectoryResult: 确定性轨迹模拟的结果
weightfloat: 数字（通常在0和1之间），此轨迹的精确权重

property average_final_state: 每个轨迹的最后状态平均成一个密度矩阵。

property average_states: 状态平均值作为密度矩阵。

property final_state: 如果有可用的最终状态，则运行最终状态，否则取平均值。

merge(other, p=None)[来源]

合并两个多轨迹结果。

如果这个结果代表一个集合 \(\rho\)，而 other 代表另一个集合 \(\rho'\)，那么合并的结果代表集合

\[\rho_{\mathrm{merge}} = p \rho + (1 - p) \rho'\]

其中 p 是一个介于 0 和 1 之间的参数。其默认值为 \(p_{\textrm{def}} = N / (N + N')\)，N 和 N’ 是两个结果对象中的轨迹数量。

Parameters:

otherMultiTrajResult: 要与此结果合并的多轨迹结果
pfloat [optional]: 此结果在组合中的相对权重。默认情况下，将选择使所有轨迹对合并结果的贡献相等。

property runs_final_states: 每条轨迹的最后状态。

property runs_states: 每次运行的状态为 states[run][t]。

property states: 如果有最终状态则运行最终状态，否则运行平均值。

steady_state(N=0)[source]

将每次运行的最后N次状态的平均值作为密度矩阵。在适当的条件下，应该会收敛到稳态。

Parameters:

Nint [optional]: 从 tlist 末尾开始的状态数量进行平均。默认情况下，所有状态都将被平均。

非马尔可夫求解器

该模块包含非马尔可夫转移张量方法（TTM）的实现，该方法在[1]中引入。

[1] Javier Cerrillo 和 Jianshu Cao, 物理评论快报 112, 110401 (2014)

ttmsolve(dynmaps, state0, times, e_ops=(), num_learning=0, options=None)[source]

使用转移张量方法[1]扩展时间演化，基于一组预计算动态映射。

Parameters:

dynmapslist of Qobj, callable

预计算的动力学映射（超算子）列表，用于times的初始时间，或者是一个回调函数，该函数返回给定时间的超算子。

state0Qobj

初始密度矩阵或状态向量（ket）。

timesarray_like

计算结果的时刻列表 \(t_n\)。必须是均匀间隔的。

e_opsQobj, callable, or list, optional

单个操作符或操作符列表，用于评估期望值或可调用对象或可调用对象列表。可调用对象的签名必须为f(t: float, state: Qobj)。有关操作符期望的更多详细信息，请参见expect。

num_learningint, default: 0

当dynmaps是可调用对象时，用于构造dynmaps运算符的次数。

optionsdictionary, optional

求解器的选项字典。

store_final_state : bool 是否在结果类中存储演化的最终状态。
store_states : bool, None 是否存储状态向量或密度矩阵。在None的情况下，如果没有给出期望操作符，状态将被保存。
normalize_output : bool 将输出状态归一化以隐藏ODE数值误差。
threshold : float 停止的阈值。如果 \(||T_{n}-T_{n-1}||\) 低于阈值，则停止。

Returns:

output: Result: 类 Result 的一个实例。

[1]

哈维尔·塞里略和曹建树，物理评论快报 112, 110401 (2014) ..

积分器

来自多个来源（scipy、diffrax、自制等）的不同ODE求解器被qutip求解器使用。它们的选项被添加到求解器选项中：

class IntegratorScipyAdams(system, options)[源代码]

使用Scipy ode的积分器，采用adams方法的zvode积分器。由netlib提供的常微分方程求解器 (https://www.netlib.org/odepack)。

可与 method="adams" 一起使用

property options

zvode 积分器支持的选项：

atolfloat, default: 1e-8: 绝对容差。
rtolfloat, default: 1e-6: 相对容差。
orderint, default: 12, ‘adams’ or 5, ‘bdf’: 积分器的顺序 <=12 'adams', <=5 'bdf'
nstepsint, default: 2500: 最大内部步骤/调用次数。
first_stepfloat, default: 0: 初始步长的大小（0 = 自动）。
min_stepfloat, default: 0: 最小步长（0 = 自动）。
max_stepfloat, default: 0: 最大步长（0 = 自动）当使用脉冲时，改为最薄脉冲的一半，否则可能会跳过。

class IntegratorScipyBDF(system, options)[source]

使用Scipy ode的积分器，采用bdf方法的zvode积分器。由netlib提供的常微分方程求解器 (https://www.netlib.org/odepack)。

可与 method="bdf" 一起使用

property options

zvode 积分器支持的选项：

atolfloat, default: 1e-8: 绝对容差。
rtolfloat, default: 1e-6: 相对容差。
orderint, default: 12, ‘adams’ or 5, ‘bdf’: 积分器的顺序 <=12 'adams', <=5 'bdf'
nstepsint, default: 2500: 最大内部步骤/调用次数。
first_stepfloat, default: 0: 初始步长的大小（0 = 自动）。
min_stepfloat, default: 0: 最小步长（0 = 自动）。
max_stepfloat, default: 0: 最大步长（0 = 自动）当使用脉冲时，改为最薄脉冲的一半，否则可能会跳过。

class IntegratorScipylsoda(system, options)[source]

使用Scipy ode与lsoda积分器的积分器。ODE求解器由netlib提供 (https://www.netlib.org/odepack) 自动选择‘Adams’和‘BDF’方法来求解刚性和非刚性系统。

可与 method="lsoda" 一起使用

property options

lsoda 积分器支持的选项：

atolfloat, default: 1e-8: 绝对容差。
rtolfloat, default: 1e-6: 相对容差。
nstepsint, default: 2500: 最大内部步骤/调用次数。
max_order_nsint, default: 12: 非刚性情况下使用的最大阶数（<= 12）。
max_order_sint, default: 5: 在刚性情况下使用的最大阶数（<= 5）。
first_stepfloat, default: 0: 初始步长的大小（0 = 自动）。
max_stepfloat, default: 0: 最大步长（0 = 自动）当使用脉冲时，改为最薄脉冲的一半，否则可能会跳过。
min_stepfloat, default: 0: 最小步长（0 = 自动）

class IntegratorScipyDop853(system, options)[source]

使用Scipy ode与dop853积分器的积分器。Dormand & Prince的八阶龙格-库塔方法。使用来自[E. Hairer, S.P. Norsett和G. Wanner, 解常微分方程i. 非刚性问题. 第二版. 计算数学中的Springer系列, Springer-Verlag (1993)]的Fortran实现。

可与 method="dop853" 一起使用

property options

dop853 积分器支持的选项：

atolfloat, default: 1e-8: 绝对容差。
rtolfloat, default: 1e-6: 相对容差。
nstepsint, default: 2500: 最大内部步骤/调用次数。
first_stepfloat, default: 0: 初始步长的大小（0 = 自动）。
max_stepfloat, default: 0: 最大步长（0 = 自动）
ifactor, dfactorfloat, default: 6., 0.3: 一步中增加/减少步长的最大因子
betafloat, default: 0: 用于稳定步长控制的Beta参数。

有关更多详细信息，请参阅 scipy.integrate.ode ode

class IntegratorVern7(system, options)[source]

QuTiP 实现了 Verner 的“最有效”七阶 Runge-Kutta 方法。这些是具有可变步长和密集输出的 Runge-Kutta 方法。

该实现使用QuTiP的Data对象来表示状态，允许求解器以原生格式高效地使用稀疏、GPU或其他数据层对象。

请参阅 https://www.sfu.ca/~jverner/ 以获取方法的详细描述。

可与 method="vern7" 一起使用

property options

Verner 方法支持的选项：

atolfloat, default: 1e-8: 绝对容差。
rtolfloat, default: 1e-6: 相对容差。
nstepsint, default: 1000: 最大内部步骤/调用次数。
first_stepfloat, default: 0: 初始步长的大小（0 = 自动）。
min_stepfloat, default: 0: 最小步长（0 = 自动）。
max_stepfloat, default: 0: 最大步长（0 = 自动）当使用脉冲时，改为最薄脉冲的一半，否则可能会跳过。
interpolatebool, default: True: 是否使用插值步骤，大多数情况下更快。

class IntegratorVern9(system, options)[source]

QuTiP 实现了 Verner 的“最有效”的 9 阶 Runge-Kutta 方法。这些是具有可变步长和密集输出的 Runge-Kutta 方法。

实现使用QuTiP的Data对象来表示状态，允许求解器以其原生格式高效地使用稀疏、GPU或其他数据层对象。

请参阅https://www.sfu.ca/~jverner/以获取方法的详细描述。

可与 method="vern9" 一起使用

property options

Verner 方法支持的选项：

atolfloat, default: 1e-8: 绝对容差。
rtolfloat, default: 1e-6: 相对容差。
nstepsint, default: 1000: 最大内部步骤/调用次数。
first_stepfloat, default: 0: 初始步长的大小（0 = 自动）。
min_stepfloat, default: 0: 最小步长（0 = 自动）。
max_stepfloat, default: 0: 最大步长（0 = 自动）当使用脉冲时，改为最薄脉冲的一半，否则可能会跳过。
interpolatebool, default: True: 是否使用插值步骤，大多数情况下更快。

class IntegratorDiag(system, options)[source]

积分器通过对角化系统并解析求解来解决ODE。它只能解决常数系统，并且准备时间较长，但积分速度快。

可用于 method="diag"

property options

“diag”方法支持的选项：

eigensolver_dtypestr, default: “dense”: Qutip 数据类型 {“dense”, “csr”, 等} 用于计算本征态时使用。密集本征求解器通常更快且更稳定。

class IntegratorKrylov(system, options)[source]

通过在一组小维度的Krylov子空间（m << dim(H)）上获得时间演化算子的投影，演化状态向量（“psi0”）以找到哈密顿量（“H”）的时间演化算子的近似值。

property options

krylov方法支持的选项：

atolfloat, default: 1e-7: 绝对容差。
nstepsint, default: 100: 最大内部步骤/调用次数。
min_step, max_stepfloat, default: (1e-5, 1e5): 最小和最大步长。
krylov_dim: int, default: 0: 用于时间演化近似的Krylov近似子空间的维度。如果给出默认值0，则根据系统大小N计算维度，使用min(int((N + 100)**0.5), N-1)。
sub_system_tol: float, default: 1e-7: 检测到快乐崩溃的容忍度。当初始ket处于哈密顿量的子空间中，且该子空间小于krylov_dim时，会发生快乐崩溃。
always_compute_step: bool, default: False: 如果为True，每次计算新的Krylov子空间时都会计算步长。否则，仅在创建积分器时计算一次。

随机积分器

class RouchonSODE(rhs, options)[源代码]

保持密度矩阵正性的随机积分方法。参见公式 (4) Pierre Rouchon 和 Jason F. Ralpha， 高效的量子滤波用于量子反馈控制， arXiv:1410.5345 [quant-ph]， Phys. Rev. A 91, 012118, (2015).

订单：strong 1

注释

此方法应使用非常小的dt。与其他方法不同，当时间步长过大时，其他方法可能会返回不合理的状态（负特征值，Nans），而此方法将返回看似正常的状态。

property options

Rouchon 随机积分器支持的选项：

dtfloat, default: 0.001: 内部时间步长。
tolfloat, default: 1e-7: 相对容差。

class EulerSODE(rhs, options)[source]

欧拉方法对常微分方程到随机微分方程的一个简单推广。这是唯一一个可以处理非交换sc_ops的求解器。

订单: 0.5

property options

显式随机积分器支持的选项：

dtfloat, default: 0.001: 内部时间步长。
tolfloat, default: 1e-10: 时间步长的容差。

class Milstein_SODE(rhs, options)[source]

一阶强泰勒方案。更好地近似随机微分方程的数值解。参见Peter E. Kloeden和Exkhard Platen的《随机微分方程的数值解》第10.3章的公式(3.12)。

订单强 1.0

property options

显式随机积分器支持的选项：

dtfloat, default: 0.001: 内部时间步长。
tolfloat, default: 1e-10: 时间步长的容差。

class Taylor1_5_SODE(rhs, options)[source]

订单1.5强泰勒方案。使用更多Ito-Taylor展开项的求解器。参见Peter E. Kloeden和Exkhard Platen的《随机微分方程的数值解》第10.4章中的公式(4.6)。

订单强 1.5

property options

支持的选项由Order 1.5强泰勒随机积分器提供：

dtfloat, default: 0.001: 内部时间步长。
tolfloat, default: 1e-10: 相对容差。
derr_dtfloat, default: 1e-6: 用于计算哈密顿量和sc_ops导数的时间差分。

class Implicit_Milstein_SODE(rhs, options)[source]

一阶隐式强泰勒方案。用于数值模拟刚性随机微分方程的隐式米尔斯坦方案。参见Peter E. Kloeden和Exkhard Platen的随机微分方程的数值解第12.2章中的公式(2.11)，其中alpha=0.5。

订单强 1.0

property options

隐式随机积分器支持的选项：

dtfloat, default: 0.001: 内部时间步长。
tolfloat, default: 1e-10: 时间步长的容差。
solve_methodstr, default: None: 用于求解隐式步骤中Ax=b的方法。接受qutip.core.data.solve支持的方法。当系统为常数时，可以通过输入inv来使用矩阵A的逆。
solve_optionsdict, default: {}: 传递给qutip.core.data.solve调用的选项。

class Implicit_Taylor1_5_SODE(rhs, options)[源代码]

订单1.5隐式强泰勒方案。使用更多项的Ito-Taylor展开的求解器。参见Peter E. Kloeden和Exkhard Platen的随机微分方程的数值解第12.2章中的公式(2.18)，其中alpha=0.5。

订单强 1.5

property options

隐式顺序1.5强泰勒随机积分器支持的选项：

dtfloat, default: 0.001: 内部时间步长。
tolfloat, default: 1e-10: 时间步长的容差。
solve_methodstr, default: None: 用于求解隐式步骤中Ax=b的方法。接受qutip.core.data.solve支持的方法。当系统为常数时，可以通过输入inv来使用矩阵A的逆。
solve_optionsdict, default: {}: 传递给qutip.core.data.solve调用的选项。
derr_dtfloat, default: 1e-6: 用于计算哈密顿量和sc_ops导数的时间差分。

class PlatenSODE(rhs, options)[源代码]

显式方案，使用有限差分而不是解析导数创建米尔斯坦。还包含一些高阶项，因此在保持强阶1.0的同时，收敛性优于米尔斯坦。不需要导数。参见H.-P. Breuer和F. Petruccione的《开放量子系统理论》第7章公式(7.47)。

顺序：强 1，弱 2

property options

显式随机积分器支持的选项：

dtfloat, default: 0.001: 内部时间步长。
tolfloat, default: 1e-10: 时间步长的容差。

class Explicit1_5_SODE(rhs, options)[source]

显式1.5阶强格式。使用有限差分代替导数来重现1.5阶强泰勒格式。比taylor15慢，但在无法解析获得导数时可用。参见Peter E. Kloeden和Exkhard Platen的随机微分方程的数值解第11.2章的公式(2.13)。

订单：strong 1.5

property options

显式随机积分器支持的选项：

dtfloat, default: 0.001: 内部时间步长。
tolfloat, default: 1e-10: 时间步长的容差。

class PredCorr_SODE(rhs, options)[源代码]

将梯形方法推广到随机微分方程。比显式方法更稳定。参见Peter E. Kloeden和Exkhard Platen的随机微分方程的数值解第15.5章中的公式(5.4)。

订单强度 0.5，弱度 1.0
仅校正随机部分的代码（\(\alpha=0\)， \(\eta=1/2\)）：'pred-corr'，'predictor-corrector' 或 'pc-euler'
用于校正随机和确定性部分的代码 (\(\alpha=1/2\), \(\eta=1/2\)): 'pc-euler-imp', 'pc-euler-2' 或 'pred-corr-2'

property options

显式随机积分器支持的选项：

dtfloat, default: 0.001: 内部时间步长。
tolfloat, default: 1e-10: 时间步长的容差。
alphafloat, default: 0.: 漂移的隐式因子。 eff_drift ~= drift(t) * (1-alpha) + drift(t+dt) * alpha
etafloat, default: 0.5: 扩散的隐式因子。 eff_diffusion ~= diffusion(t) * (1-eta) + diffusion(t+dt) * eta

并行化

该模块提供了用于并行执行循环和函数映射的函数，使用内置的Python模块multiprocessing或loky并行执行库。

loky_pmap( task, values, task_args=None, task_kwargs=None, reduce_func=None, map_kw=None, progress_bar=None, progress_bar_kwargs={}, )[source]

并行执行将values映射到函数task的过程。这在功能上等同于：

result = [task(value, *task_args, **task_kwargs) for value in values]

使用loky模块代替multiprocessing。

Parameters:

taska Python function: 要为task_vec中的每个值调用的函数。
valuesarray / list: 用于评估task函数的值列表或数组。
task_argslist, optional: task 函数的可选附加参数。
task_kwargsdictionary, optional: 可选的额外关键字参数传递给task函数。
reduce_funcfunc, optional: 如果提供了，它将使用每个任务的输出进行调用，而不是将它们存储在列表中。请注意，结果传递给reduce_func的顺序是未定义的。它应该返回None或一个数字。当返回一个数字时，它表示剩余任务的估计数量。当返回值小于等于0时，映射将提前结束。
progress_barstr, optional: 进度条选项的字符串用于显示进度。
progress_bar_kwargsdict, optional: 进度条的选项。
map_kw: dict, optional: 包含以下条目的字典： - timeout: float, 整个映射的最大时间（秒）。 - num_cpus: int, 同时运行的作业数量。 - fail_fast: bool, 在第一个错误时中止。

Returns:

resultlist: 结果列表包含task(value, *task_args, **task_kwargs)的值，对于values中的每个值。如果提供了reduce_func，将返回一个空列表。

mpi_pmap( task, values, task_args=None, task_kwargs=None, reduce_func=None, map_kw=None, progress_bar=None, progress_bar_kwargs={}, )[source]

并行执行将values映射到函数task的过程。这在功能上等同于：

result = [task(value, *task_args, **task_kwargs) for value in values]

使用mpi4py模块通过MPI进程异步执行任务。有关更多信息，请查阅mpi4py的文档和mpi4py.MPIPoolExecutor类。

注意：为了与parallel_map的API保持一致，确定请求的工作进程数量的参数称为num_cpus。 map_kw[‘num_cpus’]的值作为max_workers参数传递给MPIPoolExecutor。如果未提供此参数，则使用环境变量QUTIP_NUM_PROCESSES。如果此环境变量也未设置，QuTiP将使用可能不适合MPI应用程序的默认值。

Parameters:

taska Python function: 要为task_vec中的每个值调用的函数。
valuesarray / list: 用于评估task函数的值列表或数组。
task_argslist, optional: task 函数的可选附加参数。
task_kwargsdictionary, optional: 可选的额外关键字参数传递给 task 函数。
reduce_funcfunc, optional: 如果提供了，它将使用每个任务的输出进行调用，而不是将它们存储在列表中。请注意，结果传递给reduce_func的顺序是未定义的。它应该返回None或一个数字。当返回一个数字时，它表示剩余任务的估计数量。当返回值小于等于0时，映射将提前结束。
progress_barstr, optional: 进度条选项的字符串用于显示进度。
progress_bar_kwargsdict, optional: 进度条的选项。
map_kw: dict, optional: 包含以下条目的字典： - timeout: float, 整个映射的最大时间（秒）。 - num_cpus: int, 同时运行的作业数量。 - fail_fast: bool, 在第一个错误时中止。 map_kw 的其余条目将传递给 mpi4py.MPIPoolExecutor 构造函数。

Returns:

resultlist: 结果列表包含values中每个值的task(value, *task_args, **task_kwargs)的值。如果提供了reduce_func，将返回一个空列表。

parallel_map( task, values, task_args=None, task_kwargs=None, reduce_func=None, map_kw=None, progress_bar=None, progress_bar_kwargs={}, )[source]

并行执行将values映射到函数task的过程。这在功能上等同于：

result = [task(value, *task_args, **task_kwargs) for value in values]

Parameters:

taska Python function: 要为task_vec中的每个值调用的函数。
valuesarray / list: 用于评估task函数的值列表或数组。
task_argslist, optional: task 函数的可选附加参数。
task_kwargsdictionary, optional: 可选的额外关键字参数传递给task函数。
reduce_funcfunc, optional: 如果提供了，它将使用每个任务的输出进行调用，而不是将它们存储在列表中。请注意，结果传递给reduce_func的顺序是未定义的。它应该返回None或一个数字。当返回一个数字时，它表示剩余任务的估计数量。当返回值小于等于0时，映射将提前结束。
progress_barstr, optional: 进度条选项的字符串用于显示进度。
progress_bar_kwargsdict, optional: 进度条的选项。
map_kw: dict, optional: 包含以下条目的字典： - timeout: float, 整个映射的最大时间（秒）。 - num_cpus: int, 同时运行的作业数量。 - fail_fast: bool, 在第一个错误时中止。

Returns:

resultlist: 结果列表包含task(value, *task_args, **task_kwargs)的值，针对values中的每个值。如果提供了reduce_func，将返回一个空列表。

serial_map( task, values, task_args=None, task_kwargs=None, reduce_func=None, map_kw=None, progress_bar=None, progress_bar_kwargs={}, )[source]

具有与parallel_map相同调用签名的串行映射函数，便于在串行和并行执行之间切换。这在功能上等同于：

result = [task(value, *task_args, **task_kwargs) for value in values]

此函数作为parallel_map的直接替代品。

Parameters:

taska Python function: 要为task_vec中的每个值调用的函数。
valuesarray / list: 用于评估task函数的值列表或数组。
task_argslist, optional: task 函数的可选附加参数。
task_kwargsdictionary, optional: 可选的额外关键字参数传递给 task 函数。
reduce_funcfunc, optional: 如果提供了，它将使用每个任务的输出调用，而不是将它们存储在列表中。它应该返回 None 或一个数字。当返回一个数字时，它表示剩余任务的估计数量。当返回值 <= 0 时，映射将提前结束。
progress_barstr, optional: 进度条选项的字符串用于显示进度。
progress_bar_kwargsdict, optional: 进度条的选项。
map_kw: dict, optional: 包含的字典： - timeout: float, 整个映射的最大时间（秒）。 - fail_fast: bool, 在第一次出错时抛出错误。

Returns:

resultlist: 结果列表包含每个values中的值的task(value, *task_args, **task_kwargs)的值。如果提供了reduce_func，将返回一个空列表。

传播器

propagator(

H: QobjEvoLike,

t: Number,

c_ops: QobjEvoLike | list[QobjEvoLike] = None,

args: dict[str, Any] = None,

options: dict[str, Any] = None,

**kwargs,

) → Qobj | list[Qobj][source]

计算密度矩阵或波函数的传播子U(t)，使得\(\psi(t) = U(t)\psi(0)\)或\(\rho_{\mathrm vec}(t) = U(t) \rho_{\mathrm vec}(0)\)，其中\(\rho_{\mathrm vec}\)是密度矩阵的向量表示。

Parameters:

HQobj, QobjEvo, QobjEvo compatible format: 可能是时间依赖的系统Liouvillian或Hamiltonian，作为Qobj或QobjEvo。也可以接受[Qobj, Coefficient]的list或可调用对象，这些对象可以被转换为QobjEvo。
tfloat or array-like: 用于评估传播器的时间或时间列表。如果传递了单个时间 t，则计算从 0 到 t 的传播器。当 t 是一个列表时，返回从列表中的第一个时间到 t 中每个元素的传播器。在这种情况下，第一个输出将始终是单位矩阵。
c_opslist, optional: 作为Qobj、QobjEvo或可以转换为QobjEvo的列表的崩溃操作符列表。
argsdictionary, optional: 时间依赖哈密顿量和坍缩算符的回调函数参数。
optionsdict, optional: 求解器的选项。
**kwargs: 从列表格式 H 创建 QobjEvo 时使用的额外参数。最常见的是基于数组的时间依赖性的 tlist 和 order。有关完整列表，请参见 QobjEvo。

Returns:

UQobj, list: 表示传播子 \(U(t)\) 的实例。当 t 是一个数字时返回一个 Qobj，当 t 是一个列表时返回一个列表。

注释

与 sesolve 或 mesolve 不同，t 中的输出时间不用于数组时间依赖系统。在这些情况下，tlist 必须作为关键字参数传递。tlist 和 t 可以有不同的长度和值。

propagator_steadystate(U: Qobj) → Qobj[source]

找到传播器\(U\)连续应用的稳态。

Parameters:

UQobj: 表示传播子的运算符。

Returns:

aQobj: 表示稳态密度矩阵的实例。

class Propagator( system: Qobj | QobjEvo | Solver, *, c_ops: QobjEvoLike | list[QobjEvoLike] = None, args: dict[str, Any] = None, options: dict[str, Any] = None, memoize: int = 10, tol: float = 1e-14, )[source]

系统的传播器生成器。

用法：

U = Propagator(H, c_ops)

psi_t = U(t) @ psi_0

保存一些先前计算过的传播子以加速后续计算。更改 args 将清除这些存储的传播子。

Parameters:

systemQobj, QobjEvo, Solver

可能是时间依赖的系统驱动演化，要么已经封装在求解器中，例如 SESolver 或 BRSolver，要么是作为 Qobj 的 Liouvillian 或 Hamiltonian，QobjEvo。也可以接受 [Qobj, Coefficient] 的 list 或可以转换为 QobjEvo 的可调用对象。

不支持运行非确定性的求解器，例如 MCSolver。

c_opslist, optional

Qobj 或 QobjEvo 崩溃操作符的列表。

argsdictionary, optional

时间依赖哈密顿量和坍缩算符的回调函数参数。

optionsdict, optional

求解器的选项。

memoizeint, default: 10

保存的最大传播者数量。

tolfloat, default: 1e-14

时间的绝对容差。如果之前计算过在容差范围内的时间的传播器，将返回该传播器。

注释

Propagator 不是一个 QobjEvo，因此它不能用于与 Qobj 或 QobjEvo 的操作。它可以被转换为 QobjEvo。

U = QobjEvo(Propagator(H))

__call__(t: float, t_start: float = 0, **args)[源代码]

获取从 t_start 到 t 的传播器。

Parameters:

tfloat

计算传播器的时间。

t_start: float [0]

Time at which the propagator start such that:: psi[t] = U.prop(t, t_start) @ psi[t_start]

argsdict

传递给时间依赖哈密顿量的参数。更新 args 从 t=0 开始生效，新的 args 将在未来的调用中使用。

inv(t: float, **args)[source]

Get the inverse of the propagator at t, such that: psi_0 = U.inv(t) @ psi_t

Parameters:

tfloat: 计算传播器的时间。
argsdict: 传递给时间依赖哈密顿量的参数。更新 args 从 t=0 开始生效，新的 args 将在未来的调用中使用。

其他动态函数

稳态求解器

pseudo_inverse(L, rhoss=None, w=None, method='splu', *, use_rcm=False, **kwargs)[source]

计算Liouvillian超算符的伪逆，可选地给定其稳态密度矩阵（如果未给定，则会计算）。

Parameters:

LQobj

用于计算伪逆的Liouvillian超算子。

rhossQobj, optional

作为Qobj实例的稳态密度矩阵，用于Liouvillian超算子L。

wdouble, optional

评估伪逆的频率。对于密集系统和大稀疏系统，可以为零。小稀疏系统在零频率时可能会失败。

sparsebool, optional

标志，指示在计算伪逆时是否使用稀疏或密集矩阵方法。

methodstr, optional

用于计算矩阵逆的方法。选择是使用scipy的同名函数‘pinv’，或者使用线性系统求解器。默认支持的求解器有：

“solve”, “lstsq” 来自 numpy.linalg 的密集求解器
“spsolve”, “gmres”, “lgmres”, “bicgstab”, “splu” 来自 scipy.sparse.linalg 的稀疏求解器
“mkl_spsolve”，由mkl实现的稀疏求解器。

qutip的扩展，如qutip-tensorflow，可以使用它们自己的求解器。当L使用这些数据后端时，请参阅相应库的linalg以获取可用的求解器。

use_rcmbool, default: False

使用反向Cuthill-Mckee重新排序来最小化Liouvillian的LU分解中的填充。

kwargsdictionary

用于设置求解器方法参数的额外关键字参数。

Returns:

RQobj: 返回表示L的伪逆的Qobj实例。

注释

通常，稀疏矩阵的逆矩阵会是密集的。如果你正在将逆矩阵应用于密度矩阵，那么最好将问题转化为Ax=b类型的问题，这样就不需要显式计算逆矩阵。参见C. Flindt的博士论文《纳米结构中的电子》第67页，可在线获取： https://orbit.dtu.dk/en/publications/electrons-in-nanostructures-coherent-manipulation-and-counting-st

还需注意的是，本文中伪逆的定义与仅使用numpy的pinv()不同，因为它包括在由投影器Q定义的子空间上的前后投影。

steadystate(A, c_ops=[], *, method='direct', solver=None, **kwargs)[source]

计算量子演化的稳态，受提供的哈密顿量或李维利安算子以及（如果提供了哈密顿量）一组坍缩算子的影响。

如果用户传递了一个哈密顿量，那么它将与崩溃算符列表一起被转换为Lindblad形式的Liouvillian算符。

Parameters:

AQobj

哈密顿或刘维尔算子。

c_op_listlist

一组崩溃操作符的列表。

methodstr, {“direct”, “eigen”, “svd”, “power”}, default: “direct”

允许的方法由两部分组成，稳态方法：

“direct”: 求解 L(rho_ss) = 0
“eigen”：特征值问题
“svd” : 奇异值分解
“power” : 逆幂法
“propagator” : 重复应用传播器

solverstr, optional

仅支持‘direct’和‘power’方法。在求解L(rho_ss) = 0方程时使用的求解器。默认支持的求解器有：

“solve”, “lstsq” 来自 numpy.linalg 的密集求解器
“spsolve”, “gmres”, “lgmres”, “bicgstab” 来自 scipy.sparse.linalg 的稀疏求解器
“mkl_spsolve” 由mkl实现的稀疏求解器。

qutip的扩展，如qutip-tensorflow，可以使用它们自己的求解器。当A和c_ops使用这些数据后端时，请参阅相应库的linalg以获取可用的求解器。

这些求解器的额外选项可以通过 **kw 传递。

use_rcmbool, default: False

使用反向Cuthill-Mckee重新排序来最小化Liouvillian的LU分解中的填充。与‘direct’或‘power’方法一起使用。

use_wbmbool, default: False

使用加权二分图匹配重新排序使Liouvillian对角占优。这仅对迭代预条件器有用。与‘direct’或‘power’方法一起使用。

weightfloat, optional

设置用于向线性求解器添加单位迹条件的元素的大小。如果用户未指定，则将其设置为Liouvillian元素的平均绝对值。与‘direct’方法一起使用。

power_tolfloat, default: 1e-12

使用‘power’方法时的解决方案容差。

power_maxiterint, default: 10

使用‘power’方法寻找解决方案时的最大迭代次数。

power_eps: double, default: 1e-15

在“power”方法中使用的小权重。

sparse: bool, default: True

是否使用“eigen”方法的稀疏特征求解器（默认稀疏）。对于“direct”和“power”方法，当未指定求解器时，用于设置是否使用“solve”或“spsolve”作为默认求解器。

rho: Qobj, default: None

“propagator”方法的初始状态。

propagator_T: float, default: 10

传播器方法的初始时间步长。每次迭代时间步长都会加倍。

propagator_tol: float, default: 1e-5

传播方法收敛的容差。如果步骤之间的状态希尔伯特距离小于此容差，则认为状态已收敛到稳态。

propagator_max_iter: int, default: 30

最大迭代次数直到收敛。如果状态未收敛，则会引发RuntimeError。

**kwargs

传递给线性系统求解器的额外选项。请参阅numpy.linalg或scipy.sparse.linalg中使用的求解器的文档，以查看支持哪些额外参数。

Returns:

dmqobj: 稳态密度矩阵。
infodict, optional: 包含有关解决方案的特定求解器信息的字典。

注释

SVD方法仅适用于密集算子（即小型系统）。

steadystate_floquet(

H_0,

c_ops,

Op_t,

w_d=1.0,

n_it=3,

sparse=False,

solver=None,

**kwargs,

)[source]

Calculates the effective steady state for a driven: 系统具有时间依赖的余弦项：

\[\mathcal{\hat{H}}(t) = \hat{H}_0 + \mathcal{\hat{O}} \cos(\omega_d t)\]

Parameters:

H_0Qobj

哈密顿或刘维尔算子。

c_opslist

一组崩溃操作符的列表。

Op_tQobj

交互操作符乘以余弦

w_dfloat, default: 1.0

驱动频率

n_itint, default: 3

求解器的迭代次数

sparsebool, default: False

使用稀疏算法求解稳态。

solverstr, optional

用于求解线性系统的求解器。默认支持的求解器有：

“solve”, “lstsq” 来自 numpy.linalg 的密集求解器
“spsolve”, “gmres”, “lgmres”, “bicgstab” 来自 scipy.sparse.linalg 的稀疏求解器
“mkl_spsolve” 由mkl实现的稀疏求解器。

对qutip的扩展，例如qutip-tensorflow，可能会提供它们自己的求解器。当H_0和c_ops使用这些数据后端时，请参阅它们的文档以了解它们可能提供的额外求解器的名称和详细信息。

**kwargs:

传递给线性系统求解器的额外选项。请参阅numpy.linalg或scipy.sparse.linalg中使用的求解器的文档，以查看支持哪些额外参数。

Returns:

dmqobj: 稳态密度矩阵。

注释

参见：Sze Meng Tan， https://painterlab.caltech.edu/wp-content/uploads/2019/06/qe_quantum_optics_toolbox.pdf，第16节

量子光学系统中的散射

量子光学系统中的光子散射

该模块包含一系列用于数值计算光子散射的函数，适用于与某些输出波导配置耦合的驱动任意系统。这些函数的实现紧密遵循K.A. Fischer等人提出的数学处理方法，详见《相干脉冲从量子光学系统中的散射》（2017年，arXiv:1710.02875）。

scattering_probability( H, psi0, n_emissions, c_ops, tlist, system_zero_state=None, construct_effective_hamiltonian=True, )[source]

计算在任意系统中散射n个光子的累积概率。此函数接受非线性时间间隔的数组。

Parameters:

HQobj or list: 系统-波导(s)的哈密顿量或有效哈密顿量，以Qobj或列表回调格式表示。如果未指定construct_effective_hamiltonian，则从H和c_ops构建有效哈密顿量。
psi0Qobj: 初始状态密度矩阵 \(\rho(t_0)\) 或状态向量 \(\psi(t_0)\)。
n_emissionsint: 系统发射的光子数量（进入任何波导组合）。
c_opslist: 每个波导的崩溃算子列表；这些算子假设包括自发衰减率，例如 \(\sigma = \sqrt \gamma \cdot a\)。
tlistarray_like: \(\tau_i\) 的时间列表。tlist 应包含 0 并超过脉冲持续时间/感兴趣的时间区域；tlist 不需要线性间隔。
system_zero_stateQobj, optional: 表示系统中零激发的状态。默认为 basis(systemDims, 0)。
construct_effective_hamiltonianbool, default: True: 是否应该从H和c_ops构建一个有效的哈密顿量： \(H_{eff} = H - \frac{i}{2} \sum_n \sigma_n^\dagger \sigma_n\) 默认值：True。

Returns:

scattering_probfloat: 在指定的时间范围内从系统中散射n个光子的概率。

temporal_basis_vector(waveguide_emission_indices, n_time_bins)[来源]

生成一个时间基向量，用于将指定时间仓的发射分配到指定的波导中。

Parameters:

waveguide_emission_indiceslist or tuple: 每个波导中光子发射发生的索引列表，例如 [[t1_wg1], [t1_wg2, t2_wg2], [], [t1_wg4, t2_wg4, t3_wg4]]。
n_time_binsint: 时间区间的数量；每个索引可以变化的范围。

Returns:

temporal_basis_vectorQobj: 表示在指定索引处光子散射的基向量。如果有W个波导，T个时间，和N个光子发射，那么基向量的维度为(W*T)^N。

temporal_scattered_state( H, psi0, n_emissions, c_ops, tlist, system_zero_state=None, construct_effective_hamiltonian=True, )[源代码]

计算投射到时间基上的散射n光子态。

Parameters:

HQobj or list: 系统-波导(s)的哈密顿量或有效哈密顿量，以Qobj或列表回调格式表示。如果未指定construct_effective_hamiltonian，则从H和c_ops构建有效哈密顿量。
psi0Qobj: 初始状态密度矩阵 \(\rho(t_0)\) 或状态向量 \(\psi(t_0)\)。
n_emissionsint: 要计算的光子发射数量。
c_opslist: 每个波导的崩溃算子列表；这些算子假设包括自发衰减率，例如 \(\sigma = \sqrt \gamma \cdot a\)
tlistarray_like: 时间列表为 \(\tau_i\)。tlist 应包含 0 并超过脉冲持续时间/感兴趣的时间区域。
system_zero_stateQobj, optional: 表示系统中零激发的状态。默认为 \(\psi(t_0)\)
construct_effective_hamiltonianbool, default: True: 是否应该从H和c_ops构建一个有效的哈密顿量： \(H_{eff} = H - \frac{i}{2} \sum_n \sigma_n^\dagger \sigma_n\) 默认值：True。

Returns:

phi_nQobj: 散射浴状态投影到由tlist给出的时间基上。如果有W个波导，T个时间，和N个光子发射，那么状态是一个维度为T^(W*N)的张量积状态。

动力学与时间演化

薛定谔方程

主方程

蒙特卡罗演化

Bloch-Redfield 主方程

Floquet 状态和 Floquet-Markov 主方程

随机薛定谔方程和主方程

非马尔可夫求解器

积分器

随机积分器

并行化

传播器

其他动态函数

相关函数

稳态求解器

量子光学系统中的散射