Propagation
Name ArnoldiOrthogonalization
Section Time-Dependent::Propagation
Type integer
The orthogonalization method used for the Arnoldi procedure.
Only for TDExponentialMethod = lanczos.
Options:
- cgs:
Classical Gram-Schmidt (CGS) orthogonalization.
The algorithm is defined in Giraud et al., Computers and Mathematics with Applications 50, 1069 (2005).
- drcgs:
Classical Gram-Schmidt orthogonalization with double-step reorthogonalization.
The algorithm is taken from Giraud et al., Computers and Mathematics with Applications 50, 1069 (2005).
According to this reference, this is much more precise than CGS or MGS algorithms.
Name InteractionTiming
Section Time-Dependent::Propagation
Type integer
Default timing_exact
A parameter to determine if interactions should use the quantities
at the exact iteration or if retardation is allowed.
Options:
- timing_exact:
Only allow interactions at the exact iterations required by the algorithms behing executed
- timing_retarded:
Allow retarded interactions
Name IonsConstantVelocity
Section Time-Dependent::Propagation
Type logical
Default no
(Experimental) If this variable is set to yes, the ions will
move with a constant velocity given by the initial
conditions. They will not be affected by any forces.
Name IonsTimeDependentDisplacements
Section Time-Dependent::Propagation
Type block
(Experimental) This variable allows you to specify a
time-dependent function describing the displacement of the ions
from their equilibrium position: $r(t) = r_0 + \Delta
r(t)$. Specify the displacements dx(t), dy(t), dz(t) as
follows, for some or all of the atoms:
%IonsTimeDependentDisplacements
atom_index | "dx(t)" | "dy(t)" | "dz(t)"
%
The displacement functions are time-dependent functions and should match one
of the function names given in the first column of the TDFunctions block.
If this block is set, the ions will not be affected by any forces.
Name MoveIons
Section Time-Dependent::Propagation
Type logical
This variable controls whether atoms are moved during a time
propagation run. The default is yes when the ion velocity is
set explicitly or implicitly, otherwise is no.
Name RecalculateGSDuringEvolution
Section Time-Dependent::Propagation
Type logical
Default no
In order to calculate some information about the system along the
evolution (e.g. projection onto the ground-state KS determinant,
projection of the TDKS spin-orbitals onto the ground-state KS
spin-orbitals), the ground-state KS orbitals are needed. If the
ionic potential changes – that is, the ions move – one may want
to recalculate the ground state. You may do this by setting this
variable.
The recalculation is not done every time step, but only every
RestartWriteInterval time steps.
Name TDChebyshevTol
Section Time-Dependent::Propagation
Type float
Default 1e-5
An internal tolerance variable for the Chebyshev method. The smaller, the more
precisely the exponential is calculated and the more iterations are needed, i.e.,
it becomes more expensive. The expansion is terminated once the error estimate
is below this tolerance.
Name TDDynamics
Section Time-Dependent::Propagation
Type integer
Default ehrenfest
Type of dynamics to follow during a time propagation.
For BO, you must set MoveIons = yes.
Options:
- ehrenfest:
Ehrenfest dynamics.
- bo:
Born-Oppenheimer (Experimental).
Name TDEnergyUpdateIter
Section Time-Dependent::Propagation
Type integer
This variable controls after how many iterations Octopus
updates the total energy during a time-propagation run. For
iterations where the energy is not updated, the last calculated
value is reported. If you set this variable to 1, the energy
will be calculated in each step.
Name TDExponentialMethod
Section Time-Dependent::Propagation
Type integer
Default taylor
Method used to numerically calculate the exponential of the Hamiltonian,
a core part of the full algorithm used to approximate the evolution
operator, specified through the variable TDPropagator.
In the case of using the Magnus method, described below, the action of the exponential
of the Magnus operator is also calculated through the algorithm specified
by this variable.
Options:
- lanczos:
Allows for larger time-steps.
However, the larger the time-step, the longer the computational time per time-step.
In certain cases, if the time-step is too large, the code will emit a warning
whenever it considers that the evolution may not be properly proceeding --
the Lanczos process did not converge. The method consists in a Krylov
subspace approximation of the action of the exponential
(see M. Hochbruck and C. Lubich, SIAM J. Numer. Anal. 34, 1911 (1997) for details).
The performance of the method is controlled by the tolerance (controlled by TDLanczosTol).
The smaller the tolerance, the more precisely the exponential
is calculated, but also the larger the dimension of the Arnoldi
subspace. If the maximum dimension (currently 200) is not enough to meet the criterion,
the above-mentioned warning is emitted.
Be aware that the larger the required dimension of the Krylov subspace, the larger
the memory required for this method. So if you run out of memory, try to reduce
the time step.
- taylor:
This method amounts to a straightforward application of the definition of
the exponential of an operator, in terms of its Taylor expansion.
$\exp_{\rm STD} (-i\delta t H) = \sum_{i=0}^{k} {(-i\delta t)^i\over{i!}} H^i.$
The order k is determined by variable TDExpOrder. Some numerical considerations from Jeff Giansiracusa and George F. Bertsch suggest the 4th order as especially suitable and stable.
- chebyshev:
In principle, the Chebyshev expansion
of the exponential represents it more accurately than the canonical or standard expansion.
TDChebyshevTol determines the tolerance to which the expansion is computed.
There exists a closed analytic form for the coefficients of the exponential in terms of Chebyshev polynomials:
$\exp_{\rm CHEB} \left( -i\delta t H \right) = \sum_{k=0}^{\infty} (2-\delta_{k0})(-i)^{k}J_k(\delta t) T_k(H),$
where $J_k$ are the Bessel functions of the first kind, and H has to be previously scaled to $[-1,1]$. See H. Tal-Ezer and R. Kosloff, J. Chem. Phys. 81, 3967 (1984); R. Kosloff, Annu. Rev. Phys. Chem. 45, 145 (1994); C. W. Clenshaw, MTAC 9, 118 (1955).
Name TDExpOrder
Section Time-Dependent::Propagation
Type integer
Default 4
For TDExponentialMethod = taylor,
the order to which the exponential is expanded.
Name TDIonicTimeScale
Section Time-Dependent::Propagation
Type float
Default 1.0
This variable defines the factor between the timescale of ionic
and electronic movement. It allows reasonably fast
Born-Oppenheimer molecular-dynamics simulations based on
Ehrenfest dynamics. The value of this variable is equivalent to
the role of $\mu$ in Car-Parrinello. Increasing it
linearly accelerates the time step of the ion
dynamics, but also increases the deviation of the system from the
Born-Oppenheimer surface. The default is 1, which means that both
timescales are the same. Note that a value different than 1
implies that the electrons will not follow physical behaviour.
According to our tests, values around 10 are reasonable, but it will depend on your system, mainly on the width of the gap.
Important: The electronic time step will be the value of TDTimeStep divided by this variable, so if you have determined an optimal electronic time step (that we can call dte), it is recommended that you define your time step as:
TDTimeStep = dte * TDIonicTimeScale
so you will always use the optimal electronic time step
(more details).
Name TDLanczosTol
Section Time-Dependent::Propagation
Type float
Default 1e-5
An internal tolerance variable for the Lanczos method. The smaller, the more
precisely the exponential is calculated, and also the bigger the dimension
of the Krylov subspace needed to perform the algorithm. One should carefully
make sure that this value is not too big, or else the evolution will be
wrong.
Name TDMaxSteps
Section Time-Dependent::Propagation
Type integer
Default 1500
Number of time-propagation steps that will be performed. You
cannot use this variable together with TDPropagationTime.
Name TDPhotonicTimeScale
Section Time-Dependent::Propagation
Type float
Default 1.0
This variable defines the factor between the timescale of photonic
and electronic movement.
for more details see the documentation of TDIonicTimeScale
If you also use TDIonicTimeScale, we advise to set
TDPhotonicTimeScale = TDIonicTimeScale, in the case the
photon frequency is in a vibrational energy range.
Important: The electronic time step will be the value of
TDTimeStep divided by this variable, so if you have determined an
optimal electronic time step (that we can call dte), it is
recommended that you define your time step as:
TDTimeStep = dte * TDPhotonicTimeScale
so you will always use the optimal electronic time step
(more details).
Name TDPropagationTime
Section Time-Dependent::Propagation
Type float
The length of the time propagation. You cannot set this variable
at the same time as TDMaxSteps. By default this variable will
not be used.
The units for this variable are $\hbar$/Hartree (or $\hbar$/eV if you
selected ev_angstrom as input units). The approximate conversions to
femtoseconds are 1 fs = 41.34 $\hbar$/Hartree = 1.52 $\hbar$/eV.
Name TDPropagator
Section Time-Dependent::Propagation
Type integer
Default etrs
This variable determines which algorithm will be used to approximate
the evolution operator $U(t+\delta t, t)$. That is, given
$\psi(\tau)$ and $H(\tau)$ for $\tau \le t$,
calculate $t+\delta t$. Note that in general the Hamiltonian
is not known at times in the interior of the interval $[t,t+\delta t]$.
This is due to the self-consistent nature of the time-dependent Kohn-Sham problem:
the Hamiltonian at a given time $\tau$ is built from the
"solution" wavefunctions at that time.
Some methods, however, do require the knowledge of the Hamiltonian at some point of the interval $[t,t+\delta t]$. This problem is solved by making use of extrapolation: given a number $l$ of time steps previous to time $t$, this information is used to build the Hamiltonian at arbitrary times within $[t,t+\delta t]$. To be fully precise, one should then proceed self-consistently: the obtained Hamiltonian at time $t+\delta t$ may then be used to interpolate the Hamiltonian, and repeat the evolution algorithm with this new information. Whenever iterating the procedure does not change the solution wavefunctions, the cycle is stopped. In practice, in Octopus we perform a second-order extrapolation without a self-consistency check, except for the first two iterations, where obviously the extrapolation is not reliable.
The proliferation of methods is certainly excessive. The reason for it is that
the propagation algorithm is currently a topic of active development. We
hope that in the future the optimal schemes are clearly identified. In the
mean time, if you do not feel like testing, use the default choices and
make sure the time step is small enough.
Options:
- etrs:
The idea is to make use of time-reversal symmetry from the beginning:
$ \exp \left(-i\delta t H_{n} / 2 \right)\psi_n = \exp \left(i\delta t H_{n+1} / 2 \right)\psi_{n+1}, $
and then invert to obtain:
$ \psi_{n+1} = \exp \left(-i\delta t H_{n+1} / 2 \right) \exp \left(-i\delta t H_{n} / 2 \right)\psi_{n}. $
But we need to know $H_{n+1}$, which can only be known exactly through the solution $\psi_{n+1}$. What we do is to estimate it by performing a single exponential: $\psi^{}{n+1}=\exp \left( -i\delta t H{n} \right) \psi_n$, and then $H_{n+1} = H[\psi^{}_{n+1}]$. Thus no extrapolation is performed in this case.
- aetrs:
Approximated Enforced Time-Reversal Symmetry (AETRS).
A modification of previous method to make it faster.
It is based on extrapolation of the time-dependent potentials. It is faster
by about 40%.
The only difference is the procedure to estimate $H_{n+1}$: in this case
it is extrapolated via a second-order polynomial by making use of the
Hamiltonian at time $t-2\delta t$, $t-\delta t$ and $t$.
- caetrs:
(experimental) Corrected Approximated Enforced Time-Reversal
Symmetry (AETRS), this is the previous propagator but including
a correction step to the exponential.
- exp_mid:
Exponential Midpoint Rule (EM).
This is maybe the simplest method, but it is very well grounded theoretically:
it is unitary (if the exponential is performed correctly) and preserves
time-reversal symmetry (if the self-consistency problem is dealt with correctly).
It is defined as:
$
U_{\rm EM}(t+\delta t, t) = \exp \left( -i\delta t H_{t+\delta t/2}\right)\,.
$
- crank_nicholson:
- crank_nicolson:
Classical Crank-Nicolson propagator.
$
(1 + i\delta t H_{n+1/2} / 2) \psi_{n+1} = (1 - i\delta t H_{n+1/2} / 2) \psi_{n}
$
- crank_nicholson_sparskit:
- crank_nicolson_sparskit:
Classical Crank-Nicolson propagator. Requires the SPARSKIT library.
$
(1 + i\delta t H_{n+1/2} / 2) \psi_{n+1} = (1 - i\delta t H_{n+1/2} / 2) \psi_{n}
$
- magnus:
Magnus Expansion (M4).
This is the most sophisticated approach. It is a fourth-order scheme (a feature
which it shares with the ST scheme; the other schemes are in principle second-order).
It is tailored for making use of very large time steps, or equivalently,
dealing with problem with very high-frequency time-dependence.
It is still in a experimental state; we are not yet sure of when it is
advantageous.
- qoct_tddft_propagator:
WARNING: EXPERIMENTAL
- runge_kutta4:
WARNING: EXPERIMENTAL. Implicit Gauss-Legendre 4th order Runge-Kutta.
- runge_kutta2:
WARNING: EXPERIMENTAL. Implicit 2nd order Runge-Kutta (trapezoidal rule).
Similar, but not identical, to Crank-Nicolson method.
- expl_runge_kutta4:
WARNING: EXPERIMENTAL. Explicit RK4 method.
- cfmagnus4:
WARNING EXPERIMENTAL
Name TDSCFThreshold
Section Time-Dependent::Propagation
Type float
Default 1.0e-6
Since the KS propagator is non-linear, each propagation step
should be performed self-consistently. In practice, for most
purposes this is not necessary, except perhaps in the first
iterations. This variable holds the number of propagation steps
for which the propagation is done self-consistently.
The self consistency has to be measured against some accuracy
threshold. This variable controls the value of that threshold.
Name TDStepsWithSelfConsistency
Section Time-Dependent::Propagation
Type integer
Default 0
Since the KS propagator is non-linear, each propagation step
should be performed self-consistently. In practice, for most
purposes this is not necessary, except perhaps in the first
iterations. This variable holds the number of propagation steps
for which the propagation is done self-consistently.
The special value all_steps forces self-consistency to
be imposed on all propagation steps. A value of 0 means that
self-consistency will not be imposed. The default is 0.
Options:
- all_steps:
Self-consistency is imposed for all propagation steps.
Name TDTimeStep
Section Time-Dependent::Propagation
Type float
The time-step for the time propagation. For most propagators you
want to use the largest value that is possible without the
evolution becoming unstable.
While prior versions of Octopus used to have a default time step, however,
this now needs to be systematically defined.
Name TemperatureFunction
Section Time-Dependent::Propagation
Type integer
Default “temperature”
If a thermostat is used, this variable indicates the name of the
function in the TDFunctions block that will be used to control the
temperature. The values of the temperature are given in
degrees Kelvin.
Name Thermostat
Section Time-Dependent::Propagation
Type integer
Default none
This variable selects the type of thermostat applied to
control the ionic temperature.
Options:
- none:
No thermostat is applied. This is the default.
- velocity_scaling:
Velocities are scaled to control the temperature.
- nose_hoover:
Nose-Hoover thermostat.
Name ThermostatMass
Section Time-Dependent::Propagation
Type float
Default 1.0
This variable sets the fictitious mass for the Nose-Hoover
thermostat.