T
Name TDDeltaKickTime
Section Time-Dependent::Response
Type float
Default 0.0
The delta-perturbation that can be applied by making use of the TDDeltaStrength variable,
can be applied at the time given by this variable. Usually, this time is zero, since one wants
to apply the delta pertubation or "kick" at a system at equilibrium, and no other time-dependent
external potential is used. However, one may want to apply a kick on top of a laser field,
for example.
Name TDDeltaStrength
Section Time-Dependent::Response
Type float
Default 0
When no laser is applied, a delta (in time) perturbation with
strength TDDeltaStrength can be applied. This is used to
calculate, e.g., the linear optical spectra. If the ions are
allowed to move, the kick will affect them also.
The electric field is $-(\hbar k / e) \delta(t)$ for a dipole with
zero wavevector, where k = TDDeltaStrength, which causes
the wavefunctions instantaneously to acquire a phase $e^{ikx}$.
The unit is inverse length.
Name TDDeltaStrengthMode
Section Time-Dependent::Response
Type integer
Default kick_density
When calculating the density response via real-time propagation,
one needs to perform an initial kick on the KS system, at
time zero. Depending on what kind of response property one wants to obtain,
this kick may be done in several modes. For use to calculate triplet excitations,
see MJT Oliveira, A Castro, MAL Marques, and A Rubio, J. Nanoscience and Nanotechnology 8, 3392 (2008).
Options:
- kick_density:
The total density of the system is perturbed. This mode is appropriate for electric dipole response, as for optical absorption.
- kick_spin:
The individual spin densities are perturbed oppositely. Note that this mode is only possible if the run is done in spin-polarized mode, or with spinors. This mode is appropriate for the paramagnetic dipole response, which can couple to triplet excitations.
- kick_spin_and_density:
A combination of the two above. Note that this mode is only possible if the run is done in spin-polarized mode, or with spinors. This mode is intended for use with symmetries to obtain both of the responses at once, at described in the reference above.
- kick_magnon:
Rotates the magnetization. Only works for spinors. Can be used in a supercell or my making use of the generalized Bloch theorem. In the later case (see SpiralBoundaryConditions) spin-orbit coupling cannot be used.
Name TDDeltaUserDefined
Section Time-Dependent::Response
Type string
By default, the kick function will be a dipole. This will change if (1) the variable
TDDeltaUserDefined is present in the inp file, or (2) if the block TDKickFunction
is present in the inp file. If both are present in the inp file, the TDKickFunction
block will be ignored. The value of TDDeltaUserDefined should be a string describing
the function that is going to be used as delta perturbation.
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 TDEasyAxis
Section Time-Dependent::Response::Dipole
Type block
For magnon kicks only.
This variable defines the direction of the easy axis of the crystal.
The magnetization is kicked in the plane transverse to this vector
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 TDExcitedStatesToProject
Section Time-Dependent::TD Output
Type block
[WARNING: This is a very experimental feature]
To be used with TDOutput = populations.
The population of the excited states
(as defined by <Phi_I|Phi(t)> where |Phi(t)> is the many-body time-dependent state at
time t, and |Phi_I> is the excited state of interest) can be approximated – it is not clear
how well – by substituting for those real many-body states the time-dependent Kohn-Sham
determinant and some modification of the Kohn-Sham ground-state determinant (e.g.,
a simple HOMO-LUMO substitution, or the Casida ansatz for excited states in linear-response
theory. If you set TDOutput to contain populations, you may ask for these approximated
populations for a number of excited states, which will be described in the files specified
in this block: each line should be the name of a file that contains one excited state.
This file structure is the one written by the casida run mode, in the files in the directory *_excitations. The file describes the "promotions" from occupied to unoccupied levels that change the initial Slater determinant structure specified in ground_state. These promotions are a set of electron-hole pairs. Each line in the file, after an optional header, has four columns:
i a $\sigma$ weight
where i should be an occupied state, a an unoccupied one, and $\sigma$ the spin of the corresponding orbital. This pair is then associated with a creation-annihilation pair $a^{\dagger}{a,\sigma} a{i,\sigma}$, so that the excited state will be a linear combination in the form:
$\left|{\rm ExcitedState}\right> = \sum weight(i,a,\sigma) a^{\dagger}{a,\sigma} a{i,\sigma} \left|{\rm GroundState}\right>$
where weight is the number in the fourth column.
These weights should be normalized to one; otherwise the routine
will normalize them, and write a warning.
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). Two more variables control the performance of the method: the maximum dimension of this subspace (controlled by variable TDExpOrder), and the stopping criterion (controlled by variable TDLanczosTol). The smaller the stopping criterion, the more precisely the exponential is calculated, but also the larger the dimension of the Arnoldi subspace. If the maximum dimension allowed by TDExpOrder is not enough to meet the criterion, the above-mentioned warning is emitted.
- 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. As in the latter case, TDExpOrder determines the order of the expansion.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 = standard or chebyshev,
the order to which the exponential is expanded. For the Lanczos approximation,
it is the Lanczos-subspace dimension.
Name TDExternalFields
Section Time-Dependent
Type block
The block TDExternalFields describes the type and shape of time-dependent
external perturbations that are applied to the system, in the form
$f(x,y,z) \cos(\omega t + \phi (t)) g(t)$, where $f(x,y,z)$ is defined by
by a field type and polarization or a scalar potential, as below; $\omega$
is defined by omega; $g(t)$ is defined by
envelope_function_name; and $\phi(t)$ is the (time-dependent) phase from phase.
These perturbations are only applied for time-dependent runs. If you want the value of the perturbation at time zero to be applied for time-independent runs, use TimeZero = yes.
Each line of the block describes an external field; this way you can actually have more than one laser (e.g. a "pump" and a "probe").
There are two ways to specify $f(x,y,z)$ but both use the same omega | envelope_function_name [| phase] for the time-dependence. The float omega will be the carrier frequency of the pulse (in energy units). The envelope of the field is a time-dependent function whose definition must be given in a TDFunctions block. envelope_function_name is a string (and therefore it must be surrounded by quotation marks) that must match one of the function names given in the first column of the TDFunctions block. phase is optional and is taken to be zero if not provided, and is also a string specifying a time-dependent function.
(A) type = electric field, magnetic field, vector_potential
For these cases, the syntax is:
%TDExternalFields
type | nx | ny | nz | omega | envelope_function_name | phase
%
The vector_potential option (constant in space) permits us to describe an electric perturbation in the velocity gauge. The three (possibly complex) numbers (nx, ny, nz) mark the polarization direction of the field. By default, (nx, ny, nz) are defined in Cartesian space. However, it is possible for solids to define them using the Miller indices. This can be achieved by defining the block MillerIndicesBasis.
(B) type = scalar_potential
%TDExternalFields
scalar_potential | "spatial_expression" | omega | envelope_function_name | phase
%
The scalar potential is any expression of the spatial coordinates given by the string "spatial_expression", allowing a field beyond the dipole approximation.
For DFTB runs, only fields of type type = electric field are allowed for the moment, and the type keyword is omitted.
A NOTE ON UNITS:
It is very common to describe the strength of a laser field by its intensity, rather than using the electric-field amplitude. In atomic units (or, more precisely, in any Gaussian system of units), the relationship between instantaneous electric field and intensity is: $ I(t) = \frac{c}{8\pi} E^2(t) $.
It is common to read intensities in W/cm$^2$. The dimensions of intensities are [W]/(L$^2$T), where [W] are the dimensions of energy. The relevant conversion factors are:
Hartree / ($a_0^2$ atomic_time) = $6.4364086 \times 10^{15} \mathrm{W/cm}^2$
eV / ( Å$^2 (\hbar$/eV) ) = $2.4341348 \times 10^{12} \mathrm{W/cm}^2$
If, in atomic units, we set the electric-field amplitude to $E_0$, then the intensity is:
$ I_0 = 3.51 \times 10^{16} \mathrm{W/cm}^2 (E_0^2) $
If, working with Units = ev_angstrom, we set $E_0$, then the intensity is:
$ I_0 = 1.327 \times 10^{13} (E_0^2) \mathrm{W/cm}^2 $
Options:
- electric_field:
The external field is an electric field, the usual case when we want to describe a laser in the length gauge.
- magnetic_field:
The external field is a (homogeneous) time-dependent magnetic field.
- vector_potential:
The external field is a time-dependent homogeneous vector potential, which may describe a laser field in the velocity gauge.
- scalar_potential:
The external field is an arbitrary scalar potential, which may describe an inhomogeneous electrical field.
Name TDFloquetDimension
Section Time-Dependent::TD Output
Type integer
Default -1
Order of Floquet Hamiltonian. If negative number is given, downfolding is performed.
Name TDFloquetFrequency
Section Time-Dependent::TD Output
Type float
Default 0
Frequency for the Floquet analysis, this should be the carrier frequency or integer multiples of it.
Other options will work, but likely be nonsense.
Name TDFloquetSample
Section Time-Dependent::TD Output
Type integer
Default 20
Number of points on which one Floquet cycle is sampled in the time-integral of the Floquet analysis.
Name TDFreezeDFTUOccupations
Section Time-Dependent
Type logical
Default no
The occupation matrices than enters in the DFT+U potential
are not evolved during the time evolution.
Name TDFreezeHXC
Section Time-Dependent
Type logical
Default no
The electrons are evolved as independent particles feeling the Hartree and
exchange-correlation potentials from the ground-state electronic configuration.
Name TDFreezeOrbitals
Section Time-Dependent
Type integer
Default 0
(Experimental) You have the possibility of "freezing" a number of orbitals during a time-propagation.
The Hartree and exchange-correlation potential due to these orbitals (which
will be the lowest-energy ones) will be added during the propagation, but the orbitals
will not be propagated.
Options:
- sae:
Single-active-electron approximation. This option is only valid for time-dependent calculations (CalculationMode = td). Also, the nuclei should not move. The idea is that all orbitals except the last one are frozen. The orbitals are to be read from a previous ground-state calculation. The active orbital is then treated as independent (whether it contains one electron or two) -- although it will feel the Hartree and exchange-correlation potentials from the ground-state electronic configuration.It is almost equivalent to setting TDFreezeOrbitals = N-1, where N is the number of orbitals, but not completely.
Name TDFreezeU
Section Time-Dependent
Type logical
Default no
The effective U of DFT+U is not evolved during the time evolution.
Name TDFunctions
Section Time-Dependent
Type block
This block specifies the shape of a "time-dependent function", such as the
envelope needed when using the TDExternalFields block. Each line in the block
specifies one function. The first element of each line will be a string
that defines the name of the function. The second element specifies which type
of function we are using; in the following we provide an example for each of the
possible types:
Options:
- tdf_cw:
%TDFunctions
"function-name" | tdf_cw | amplitude
%The function is just a constant of value amplitude: $ f(t) $ = amplitude
- tdf_gaussian:
%TDFunctions
"function-name" | tdf_gaussian | amplitude | tau0 | t0
%The function is a Gaussian, $ f(t) = F_0 \exp( - (t-t_0)^2/(2\tau_0^2) ) $, where $F_0$ = amplitude.
- tdf_cosinoidal:
%TDFunctions
"function-name" | tdf_cosinoidal | amplitude | tau0 | t0
%$ f(t) = F_0 \cos( \frac{\pi}{2} \frac{t-2\tau_0-t_0}{\tau0} ) $
If $ | t - t_0 | > \tau_0 $, then $ f(t) = 0 $.
- tdf_trapezoidal:
%TDFunctions
"function-name" | tdf_trapezoidal | amplitude | tau0 | t0 | tau1
%This function is a trapezoidal centered around t0. The shape is determined by tau0 and tau1. The function ramps linearly for tau1 time units, stays constant for tau0 time units, and then decays to zero linearly again for tau1 time units.
- tdf_from_file:
%TDFunctions
"function-name" | tdf_from_file | "filename"
%The temporal shape of the function is contained in a file called filename. This file should contain three columns: first column is time, second and third column are the real part and the imaginary part of the temporal function f(t).
- tdf_from_expr:
%TDFunctions
"function-name" | tdf_from_expr | "expression"
%The temporal shape of the field is given as an expression (e.g., cos(2.0*t). The letter t means time, obviously. The expression is used to construct the function f that defines the field.
Name TDGlobalForce
Section Time-Dependent
Type string
If this variable is set, a global time-dependent force will be
applied to the ions in the x direction during a time-dependent
run. This variable defines the base name of the force, that
should be defined in the TDFunctions block. This force
does not affect the electrons directly.
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 TDKickFunction
Section Time-Dependent::Response
Type block
If the block TDKickFunction is present in the input file, and the variable
TDDeltaUserDefined is not present in the input file, the kick function to
be applied at time zero of the time-propagation will not be a "dipole" function
(i.e. $\phi \rightarrow e^{ikx} \phi$, but a general multipole in the form $r^l Y_{lm}(r)$.
Each line has three columns: integers l and m that defines the multipole, and a weight. Any number of lines may be given, and the kick will be the sum of those multipoles with the given weights.
This feature allows calculation of quadrupole, octupole, etc., response functions.
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 TDMomentumTransfer
Section Time-Dependent::Response
Type block
Momentum-transfer vector for the calculation of the dynamic structure factor.
When this variable is set, a non-dipole field is applied, and an output file
ftchd is created (it contains the Fourier transform of the charge density
at each time). The type of the applied external field can be set by
an optional last number. Possible options are qexp (default), qcos,
qsin, or qcos+qsin. In the formulae below,
$\vec{q}$ is the momentum-transfer vector.
Options:
- qexp:
External field is $e^{i \vec{q} \cdot \vec{r}}$.
- qcos:
External field is $\cos \left( i \vec{q} \cdot \vec{r} \right)$.
- qsin:
External field is $\sin \left( i \vec{q} \cdot \vec{r} \right)$.
- qbessel:
External field is $j_l \left( \vec{q} \cdot \vec{r} \right) Y_{lm} \left(\vec{r} \right)$. In this case, the block has to include two extra values (l and m).
Name TDMultipleMomentumTransfer
Section Time-Dependent::Response
Type block
For magnon kicks only.
A simple way to specify momentum-transfer vectors for the calculation of
the magnetization dynamics. This variable should be used for a supercell.
For each reciprocal lattice vectors, the code will kick the original magnetization
using all the multiples of it.
The syntax reads:
%TDMultipleMomentumTransfer
N_x | N_y | N_z
%
and will include the (2N_x+1)(2N_y+1)(2N_z+1) multiples vectors of the reciprocal
lattice vectors of the current cell.
Name TDMultipoleLmax
Section Time-Dependent::TD Output
Type integer
Default 1
Maximum electric multipole of the density output to the file td.general/multipoles
during a time-dependent simulation. Must be non-negative.
Name TDOutput
Section Time-Dependent::TD Output
Type block
Default multipoles + energy (+ others depending on other options)
Defines what should be output during the time-dependent
simulation. Many of the options can increase the computational
cost of the simulation, so only use the ones that you need. In
most cases the default value is enough, as it is adapted to the
details of the TD run. If the ions are allowed to be moved, additionally
the geometry and the temperature are output. If a laser is
included it will output by default.
Note: the output files generated by this option are updated every RestartWriteInterval steps.
Example:
%TDOutput
multipoles
energy
%
Options:
- multipoles:
Outputs the (electric) multipole moments of the density to the file td.general/multipoles. This is required to, e.g., calculate optical absorption spectra of finite systems. The maximum value of $l$ can be set with the variable TDMultipoleLmax.
- angular:
Outputs the orbital angular momentum of the system to td.general/angular, which can be used to calculate circular dichroism.
- spin:
(Experimental) Outputs the expectation value of the spin, which can be used to calculate magnetic circular dichroism.
- populations:
(Experimental) Outputs the projection of the time-dependent Kohn-Sham Slater determinant onto the ground state (or approximations to the excited states) to the file td.general/populations. Note that the calculation of populations is expensive in memory and computer time, so it should only be used if it is really needed. See TDExcitedStatesToProject.
- geometry:
If set (and if the atoms are allowed to move), outputs the coordinates, velocities, and forces of the atoms to the the file td.general/coordinates. On by default if MoveIons = yes.
- dipole_acceleration:
When set, outputs the acceleration of the electronic dipole, calculated from the Ehrenfest theorem, in the file td.general/acceleration. This file can then be processed by the utility oct-harmonic-spectrum in order to obtain the harmonic spectrum.
- laser:
If set, outputs the laser field to the file td.general/laser. On by default if TDExternalFields is set.
- energy:
If set, octopus outputs the different components of the energy to the file td.general/energy. Will be zero except for every TDEnergyUpdateIter iterations.
- td_occup:
(Experimental) If set, outputs the projections of the time-dependent Kohn-Sham wavefunctions onto the static (zero-time) wavefunctions to the file td.general/projections.XXX. Only use this option if you really need it, as it might be computationally expensive. See TDProjStateStart. The output interval of this quantity is controled by the variable TDOutputComputeInterval In case of states parallelization, all the ground-state states are stored by each task.
- local_mag_moments:
If set, outputs the local magnetic moments, integrated in sphere centered around each atom. The radius of the sphere can be set with LocalMagneticMomentsSphereRadius.
- gauge_field:
If set, outputs the vector gauge field corresponding to a spatially uniform (but time-dependent) external electrical potential. This is only useful in a time-dependent periodic run. On by default if GaugeVectorField is set.
- temperature:
If set, the ionic temperature at each step is printed. On by default if MoveIons = yes.
- ftchd:
Write Fourier transform of the electron density to the file ftchd.X, where X depends on the kick (e.g. with sin-shaped perturbation X=sin). This is needed for calculating the dynamic structure factor. In the case that the kick mode is qbessel, the written quantity is integral over density, multiplied by spherical Bessel function times real spherical harmonic. On by default if TDMomentumTransfer is set.
- dipole_velocity:
When set, outputs the dipole velocity, calculated from the Ehrenfest theorem, in the file td.general/velocity. This file can then be processed by the utility oct-harmonic-spectrum in order to obtain the harmonic spectrum.
- eigenvalues:
Write the KS eigenvalues.
- ionization_channels:
Write the multiple-ionization channels using the KS orbital densities as proposed in C. Ullrich, Journal of Molecular Structure: THEOCHEM 501, 315 (2000).
- total_current:
Output the total current (average of the current density over the cell).
- partial_charges:
Bader and Hirshfeld partial charges. The output file is called 'td.general/partial_charges'.
- td_kpoint_occup:
Project propagated Kohn-Sham states to the states at t=0 given in the directory restart_proj (see %RestartOptions). This is an alternative to the option td_occup, with a formating more suitable for k-points and works only in k- and/or state parallelization
- td_floquet:
Compute non-interacting Floquet bandstructure according to further options: TDFloquetFrequency, TDFloquetSample, TDFloquetDimension. This is done only once per td-run at t=0. works only in k- and/or state parallelization
- n_excited_el:
Output the number of excited electrons, based on the projections of the time evolved wave-functions on the ground-state wave-functions. The output interval of this quantity is controled by the variable TDOutputComputeInterval
- coordinates_sep:
Writes geometries in a separate file.
- velocities_sep:
Writes velocities in a separate file.
- forces_sep:
Writes forces in a separate file.
- total_heat_current:
Output the total heat current (average of the heat current density over the cell).
- total_magnetization:
Writes the total magnetization, where the total magnetization is calculated at the momentum defined by TDMomentumTransfer. This is used to extract the magnon frequency in case of a magnon kick.
- photons_q:
Writes photons_q in a separate file.
- maxwell_field:
Writes total electric field (if coupling is in length_geuge) or vector potential (if coupling is in velocity_gauge) coming from the interaction with Maxwell systems (only if Maxwell-TDDFT coupling is in dipole).
- norm_ks_orbitals:
Writes the norm of each Kohn-Sham orbital. The data is ordered per row as: Iteration time (state 1 kpoint 1) (state2 kpoint1) ... (state-Nstates kpoint1) (state1 kpoint2) ... (state-Nstates kpoint-nkpt) noting that the kpoint index will also include the spin index for spin-polarised calculations.
Name TDOutputComputeInterval
Section Time-Dependent::TD Output
Type integer
Default 50
The TD output requested are computed
when the iteration number is a multiple of the TDOutputComputeInterval variable.
Must be >= 0. If it is 0, then no output is written.
Implemented only for projections and number of excited electrons for the moment.
Name TDOutputDFTU
Section Time-Dependent::TD Output
Type flag
Default none
Defines what should be output during the time-dependent
simulation, related to DFT+U.
Note: the output files generated by this option are updated
every RestartWriteInterval steps.
Options:
- effective_u:
Writes the effective U for each orbital set as a function of time.
Name TDOutputResolveStates
Section Time-Dependent::TD Output
Type logical
Default No
Defines whether the output should be resolved by states.
So far only TDOutput = multipoles is supported.
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 TDPolarization
Section Time-Dependent::Response::Dipole
Type block
The (real) polarization of the delta electric field. Normally
one needs three perpendicular polarization directions to calculate a
spectrum (unless symmetry is used).
The format of the block is:
%TDPolarization
pol1x | pol1y | pol1z
pol2x | pol2y | pol2z
pol3x | pol3y | pol3z
%
Octopus uses both this block and the variable TDPolarizationDirection to determine the polarization vector for the run. For example, if TDPolarizationDirection=2 the polarization (pol2x, pol2y, pol2z) would be used. These directions may not be in periodic directions.
The default value for TDPolarization is the three Cartesian unit vectors (1,0,0), (0,1,0), and (0,0,1).
Note that the directions do not necessarily need to be perpendicular when symmetries are used.
WARNING: If you want to obtain the cross-section tensor, the TDPolarization block must be exactly the same for the run in each direction. The direction must be selected by the TDPolarizationDirection variable.
Name TDPolarizationDirection
Section Time-Dependent::Response::Dipole
Type integer
When a delta potential is included in a time-dependent run, this
variable defines in which direction the field will be applied
by selecting one of the lines of TDPolarization. In a
typical run (without using symmetry), the TDPolarization block
would contain the three Cartesian unit vectors (the default
value), and one would make 3 runs varying
TDPolarization from 1 to 3.
If one is using symmetry, TDPolarization should run only from 1
to TDPolarizationEquivAxes.
Name TDPolarizationEquivAxes
Section Time-Dependent::Response::Dipole
Type integer
Default 0
Defines how many of the TDPolarization axes are equivalent. This information is stored in a file and then
used by oct-propagation_spectrum to rebuild the full polarizability tensor from just the
first TDPolarizationEquivAxes directions. This variable is also used by CalculationMode = vdw.
Name TDPolarizationWprime
Section Time-Dependent::Response::Dipole
Type block
This block is needed only when
TDPolarizationEquivAxes is set to 3. In such a case,
the three directions (pol1, pol2, and pol3) defined in
the TDPolarization block should be related by symmetry
operations. If A is the symmetry operation that takes you
from pol1 to pol2, then TDPolarizationWprime
should be set to the direction defined by A$^{-1}$pol3.
For more information see MJT Oliveira
et al., J. Nanoscience and Nanotechnology 8,
3392 (2008).
Name TDProjStateStart
Section Time-Dependent::TD Output
Type integer
Default 1
To be used with TDOutput = td_occup. Not available if TDOutput = populations.
Only output projections to states above TDProjStateStart. Usually one is only interested
in particle-hole projections around the HOMO, so there is no need to calculate (and store)
the projections of all TD states onto all static states. This sets a lower limit. The upper limit
is set by the number of states in the propagation and the number of unoccupied states
available.
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 TDReducedMomentumTransfer
Section Time-Dependent::Response
Type block
The same as TDMomentumTransfer, but the momentum is specified in reduced coordinates.
Only available for magnon kicks at the moment, and only with an exponential kick.
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 TDScissor
Section Time-Dependent
Type float
Default 0.0
(experimental) If set, a scissor operator will be applied in the
Hamiltonian, shifting the excitation energies by the amount
specified. By default, it is not applied.
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 TDSystemPropagator
Section Time-Dependent::Propagation
Type integer
Default static
A variable to set the propagator in the multisystem framework.
This is a temporary solution, and should be replaced by the
TDPropagator variable.
Options:
- static:
(Experimental) Do not propagate the system in time.
- verlet:
(Experimental) Verlet propagator.
- beeman:
(Experimental) Beeman propagator without predictor-corrector.
- beeman_scf:
(Experimental) Beeman propagator with predictor-corrector scheme.
- exp_mid_2step:
(Experimental) Exponential midpoint propagator without predictor-corrector.
- exp_mid_2step_scf:
(Experimental) Exponential midpoint propagator with predictor-corrector scheme.
- prop_aetrs:
(Experimental) Approximate ETRS propagator
- prop_rk4:
(Experimental) RK4 propagator
- prop_expmid:
(Experimental) Exponential midpoint propagator with extrapolation.
- prop_leapfrog:
(Experimental) Leap frog algorithm
- prop_bomd:
(Experimental) Born-Oppenheimer MD propagator for the matter system.
Name TDTDMFrequencies
Section Utilities::oct-tdtdm
Type block
This block defines for which frequencies the analysis is performed.
Each row of the block indicates a frequency.
Name TDTDMHoleCoordinates
Section Utilities::oct-tdtdm
Type float
The position of the hole used to compute the TDTDM,
in Cartesian coordinates.
Note that the code will use the closest grid point.
The coordinates of the hole are specified in the following way
%TDTDMHoleCoordinates
hole_x | hole_y | hole_z
%
If TDTDMHoleCoordinates or TDTDMHoleReducedCoordinates are not specified,
the code will use the coordinate of the first atom in the cell.
Name TDTDMHoleReducedCoordinates
Section Utilities::oct-tdtdm
Type float
Same as TDTDMHoleCoordinates, except that coordinates are given in reduced coordinates
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.
The default value is the maximum value that we have found
empirically that is stable for the spacing $h$:
$dt = 0.0426 - 0.207 h + 0.808 h^2$
(from parabolic fit to Fig. 4 of http://dx.doi.org/10.1021/ct800518j,
probably valid for 3D systems only).
However, you might need to adjust this value.
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 TestBatchOps
Section Calculation Modes::Test
Type flag
Default ops_axpy + ops_scal + ops_nrm2
Decides which part of the Hamiltonian is applied.
Options:
- ops_axpy:
Tests batch_axpy operation
- ops_scal:
Tests batch_scal operation
- ops_nrm2:
Tests batch_nrm2 operation
- ops_dotp_matrix:
Tests X(mesh_batch_dotp_matrix)
- ops_dotp_self:
Tests X(mesh_batch_dotp_self)
- ops_dotp_vector:
Tests X(mesh_batch_dotp_vector)
Name TestHamiltonianApply
Section Calculation Modes::Test
Type integer
Default term_all
Decides which part of the Hamiltonian is applied.
Options:
- term_all:
Apply the full Hamiltonian.
- term_kinetic:
Apply only the kinetic operator
- term_local_potential:
Apply only the local potential.
- term_non_local_potential:
Apply only the non_local potential.
Name TestMaxBlockSize
Section Calculation Modes::Test
Type integer
Default 128
Some tests can work with multiple blocksizes, in this case of
range of blocksizes will be tested. This variable sets the lower
bound of that range.
Currently this variable is only used by the derivatives test.
Name TestMinBlockSize
Section Calculation Modes::Test
Type integer
Default 1
Some tests can work with multiple blocksizes, in this case of
range of blocksizes will be tested. This variable sets the lower
bound of that range.
Currently this variable is only used by the derivatives test.
Name TestMode
Section Calculation Modes::Test
Type integer
Default hartree
Decides what kind of test should be performed.
Options:
- hartree:
Tests the Poisson solvers used to calculate the Hartree potential.
- derivatives:
Tests and benchmarks the implementation of the finite-difference operators, used to calculate derivatives.
- orthogonalization:
Tests the implementation of the orthogonalization routines.
- interpolation:
Test the interpolation routines.
- ion_interaction:
Tests the ion-ion interaction routines.
- projector:
Tests the code that applies the nonlocal part of the pseudopotentials in case of spin-orbit coupling
- dft_u:
Tests the DFT+U part of the code for projections on the basis.
- hamiltonian_apply:
Tests the application of the Hamiltonian, or a part of it
- density_calc:
Calculation of the density.
- exp_apply:
Tests the exponential of the Hamiltonian
- boundaries:
Tests the boundaries conditions
- subspace_diag:
Tests the subspace diagonalization
- batch_ops:
Tests the batch operations
- clock:
Tests for clock
- linear_solver:
Tests the linear solvers
- cgal:
Tests for cgal interface
- dense_eigensolver:
Tests for dense eigensolvers (especially parallel ones)
- grid_interpolation:
Tests for grid interpolation and multigrid methods.
- iihash:
Tests for the integer-integer hash table.
- sihash:
Tests for the string-integer hash table.
- sphash:
Tests for the string-polymorphic hash table.
- mpiwrappers:
Tests for the MPI wrappers with large integer displacements.
- regridding:
Tests the regridding between two different grids.
- helmholtz_decomposition:
Test for the Helmholtz decomposition subroutines
- vecpot_analytical:
Tests analytically the vector potential from B field.
- current_density:
Tests the different contributions to the total electronic current density
Name TestRepetitions
Section Calculation Modes::Test
Type integer
Default 1
This variable controls the behavior of oct-test for performance
benchmarking purposes. It sets the number of times the
computational kernel of a test will be executed, in order to
provide more accurate timings.
Currently this variable is used by the hartree_test,
derivatives, and projector tests.
Name TestType
Section Calculation Modes::Test
Type integer
Default all
Decides on what type of values the test should be performed.
Options:
- real:
Test for double-precision real functions.
- complex:
- all:
Tests for double-precision real and complex functions.
Name TestVectorPotentialType
Section Calculation Modes::Test
Type integer
Default bounded
Select whether bounded or unbounded type will be used for vector potential tests
Options:
- bounded:
Analytical Vector Potential formulation is bounded by spatial gaussian
- unbounded:
Analytical Vector Potential is not bounded
Name TheoryLevel
Section Hamiltonian
Type integer
The calculations can be run with different "theory levels" that
control how electrons are simulated. The default is
dft. When hybrid functionals are requested, through
the XCFunctional variable, the default is
hartree_fock.
Options:
- independent_particles:
Particles will be considered as independent, i.e. as non-interacting. This mode is mainly used for testing purposes, as the code is usually much faster with independent_particles.
- hartree:
Calculation within the Hartree method (experimental). Note that, contrary to popular belief, the Hartree potential is self-interaction-free. Therefore, this run mode will not yield the same result as kohn-sham without exchange-correlation.
- hartree_fock:
This is the traditional Hartree-Fock scheme. Like the Hartree scheme, it is fully self-interaction-free.
- kohn_sham:
This is the default density-functional theory scheme. Note that you can also use hybrid functionals in this scheme, but they will be handled the "DFT" way, i.e., solving the OEP equation.
- generalized_kohn_sham:
This is similar to the kohn-sham scheme, except that this allows for nonlocal operators. This is the default mode to run hybrid functionals, meta-GGA functionals, or DFT+U. It can be more convenient to use kohn-sham DFT within the OEP scheme to get similar (but not the same) results. Note that within this scheme you can use a correlation functional, or a hybrid functional (see XCFunctional). In the latter case, you will be following the quantum-chemistry recipe to use hybrids.
- rdmft:
(Experimental) Reduced Density Matrix functional theory.
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.
Name TimeZero
Section Hamiltonian
Type logical
Default no
(Experimental) If set to yes, the ground state and other time
dependent calculation will assume that they are done at time
zero, so that all time depedent field at that time will be
included.
Name TotalStates
Section States
Type integer
Default 0
This variable sets the total number of states that Octopus will
use. This is normally not necessary since by default Octopus
sets the number of states to the minimum necessary to hold the
electrons present in the system. (This default behavior is
obtained by setting TotalStates to 0).
If you want to add some unoccupied states, probably it is more convenient to use the variable
ExtraStates.
Name TransformStates
Section States
Type block
Default no
Before starting the td calculation, the initial states (that are
read from the restart/gs directory, which should have been
generated in a previous ground-state calculation) can be "transformed"
among themselves. The block TransformStates gives the transformation matrix
to be used. The number of rows and columns of the matrix should equal the number
of the states present in the time-dependent calculation (the independent
spin and k-point subspaces are all transformed equally); the number of
columns should be equal to the number of states present in the
restart/gs directory. This number may be different: for example,
one could have run previously in unocc mode in order to obtain unoccupied
Kohn-Sham states, and therefore restart/gs will contain more states.
These states can be used in the transformation.
Note that the code will not check the orthonormality of the new states!
Each line provides the coefficients of the new states, in terms of
the old ones. The coefficients are complex, but the imaginary part will be
ignored for real wavefunctions.
Note: This variable cannot be used when parallel in states.
Name TransientAbsorptionReference
Section Utilities::oct-propagation_spectrum
Type string
Default “."
In case of delayed kick, the calculation of the transient absorption requires
to substract a reference calculation, containing the gauge-field without the kick
This reference must be computed using GaugeFieldPropagate=yes and to have
TDOutput = gauge_field.
This variables defined the directory in which the reference gauge_field field is,
relative to the current folder
Name TransientMagnetizationReference
Section Utilities::oct-spin_susceptibility
Type string
Default “."
In case of delayed kick, the calculation of the transient spin susceptibility requires
to substract a reference calculation, containing dynamics of the magnetization without the kick
This reference must be computed having
TDOutput = total_magnetization.
This variables defined the directory in which the reference total_magnetization file is,
relative to the current folder
Name TransverseFieldCalculation
Section Maxwell
Type integer
Default no
This variable selects the method for the calculation of the transverse field.
Options:
- helmholtz:
Transverse field calculated from Helmholtz decompisition (unreliable at the moment).
- total_minus_long:
Total field minus longitudinal field.