TimeEvolutionAlgorithm

Inheritance Diagram

Inheritance diagram of tenpy.algorithms.algorithm.TimeEvolutionAlgorithm

Methods

TimeEvolutionAlgorithm.__init__(psi, model, …)

Initialize self.

TimeEvolutionAlgorithm.get_resume_data([…])

Return necessary data to resume a run() interrupted at a checkpoint.

TimeEvolutionAlgorithm.resume_run()

Resume a run that was interrupted.

TimeEvolutionAlgorithm.run()

Perform a real-time evolution of psi by N_steps`*`dt.

Class Attributes and Properties

TimeEvolutionAlgorithm.verbose

class tenpy.algorithms.algorithm.TimeEvolutionAlgorithm(psi, model, options, *, resume_data=None)[source]

Bases: tenpy.algorithms.algorithm.Algorithm

Common interface for (real) time evolution algorithms.

Parameters
  • psi – Tensor network to be updated by the algorithm.

  • model (Model | None) – Model with the representation of the hamiltonian suitable for the algorithm. None for algorithms which don’t require a model.

  • options (dict-like) – Optional parameters for the algorithm. In the online documentation, you can find the correct set of options in the Config Index.

  • resume_data (None | dict) – By default (None) ignored. If a dict, it should contain the data returned by get_resume_data() when intending to continue/resume an interrupted run.

Options

config TimeEvolutionAlgorithm
option summary

dt

Minimal time step by which to evolve.

N_steps

Number of time steps `dt` to evolve by in :meth:`run`. [...]

start_time

Initial value for :attr:`evolved_time`.

trunc_params (from Algorithm) in Algorithm

Truncation parameters as described in :cfg:config:`truncation`.

option start_time: float

Initial value for evolved_time.

option dt: float

Minimal time step by which to evolve.

option N_steps: int

Number of time steps dt to evolve by in run(). Adjusting dt and N_steps at the same time allows to keep the evolution time done in run() fixed. Further, e.g., the Trotter decompositions of order > 1 are slightly more efficient if more than one step is performed at once.

evolved_time

Indicating how long psi has been evolved, psi = exp(-i * evolved_time * H) psi(t=0). Not that the real-part of t is increasing for a real-time evolution, while the imaginary-part of t is decreasing for a imaginary time evolution.

Type

float | complex

get_resume_data(sequential_simulations=False)[source]

Return necessary data to resume a run() interrupted at a checkpoint.

At a checkpoint, you can save psi, model and options along with the data returned by this function. When the simulation aborts, you can resume it using this saved data with:

eng = AlgorithmClass(psi, model, options, resume_data=resume_data)
eng.resume_run()

An algorithm which doesn’t support this should override resume_run to raise an Error.

Parameters

sequential_simulations (bool) – If True, return only the data for re-initializing a sequential simulation run, where we “adiabatically” follow the evolution of a ground state (for variational algorithms), or do series of quenches (for time evolution algorithms); see run_seq_simulations().

Returns

resume_data – Dictionary with necessary data (apart from copies of psi, model, options) that allows to continue the simulation from where we are now.

Return type

dict

resume_run()[source]

Resume a run that was interrupted.

In case we saved an intermediate result at a checkpoint, this function allows to resume the run() of the algorithm (after re-initialization with the resume_data). Since most algorithms just have a while loop with break conditions, the default behaviour implemented here is to just call run().

run()[source]

Perform a real-time evolution of psi by N_steps`*`dt.

You probably want to call this in a loop.