from __future__ import annotations
from pathlib import Path
from typing import Iterable, Literal, Sequence
from scm.pisa.block import DriverBlock,EngineBlock,FixedBlock,FreeBlock,InputBlock
from scm.pisa.key import BoolKey,FloatKey,FloatListKey,IntKey,IntListKey,MultipleChoiceKey,PathStringKey,StringKey,BoolType
[docs]class BAND(EngineBlock):
r"""
:ivar Allow: Debugging feature to let the program continue even when intermediate results seem to be wrong or very inaccurate
:vartype Allow: str | StringKey
:ivar BerryPhase: Boolean that determines whether the dipole as determined through the Berry phase approach should be calculated.
:vartype BerryPhase: BoolType | BoolKey
:ivar CPVector: The code is vectorized and this key can be used to set the vector length
:vartype CPVector: int | IntKey
:ivar Debug: Enables debug printing for the subroutine name(s) specified here.
:vartype Debug: str | StringKey
:ivar DefaultsConvention: There has been a big change in many default settings with the 2014 release. This lets you switch to the old defaults.
:vartype DefaultsConvention: str | StringKey
:ivar DumpBasisOnly: Dump basis and fit set files use for each atom.
:vartype DumpBasisOnly: BoolType | BoolKey
:ivar EigThreshold: Threshold for printing the eigenvectors coefficients (Print Eigens)
:vartype EigThreshold: float | FloatKey
:ivar EnforcedSpinPolarization: Enforce a specific spin-polarization instead of occupying according to the aufbau principle. The spin-polarization is the difference between the number of alpha and beta electron.
Thus, a value of 1 means that there is one more alpha electron than beta electrons.
The number may be anything, including zero, which may be of interest when searching for a spin-flipped pair, that may otherwise end up in the (more stable) parallel solution.
:vartype EnforcedSpinPolarization: float | FloatKey
:ivar FormFactors: Number of stars of K-vectors for which the form factors are computed
:vartype FormFactors: int | IntKey
:ivar IntegrationMethod: Choose the real-space numerical integration method. Note: the Voronoi integration scheme is deprecated.
:vartype IntegrationMethod: Literal["Becke", "Voronoi"]
:ivar KGrp0: Undocumented.
:vartype KGrp0: int | IntKey
:ivar KGrpX: Absolute upper bound on the number of k-points processed together. This only affects the computational performance.
:vartype KGrpX: int | IntKey
:ivar ModifyAlternativeElements: When using alternative elements (using the nuclear_charge attribute) set the element to the nearest integer Z. If you specify an H atom with a nuclear_charge of 2.9 it is replaced by a Li atom with the same nuclear charge.
:vartype ModifyAlternativeElements: BoolType | BoolKey
:ivar NUElstat: Number of outward (parabolic) integration points (for elliptical integration of the electrostatic interaction)
:vartype NUElstat: int | IntKey
:ivar NVElstat: Number of angular (elliptic) integration points (for elliptical integration of the electrostatic interaction)
:vartype NVElstat: int | IntKey
:ivar NeutralizingDensity: For charged systems an artificial compensating density can be used to make it neutral again. This fictitious density only affects the Coulomb potential.
For charged periodic systems neutralization is required, as otherwise the Coulomb potential diverges.
:vartype NeutralizingDensity: Literal["None", "rho(atoms)", "rho(valence/atoms)", "rho(neutralizing/atoms)", "rho(homogeneous)"]
:ivar NuclearModel: Specify what model to use for the nucleus.
For the Gaussian model the nuclear radius is calculated according to the work of Visscher and Dyall (L. Visscher, and K.G. Dyall, Dirac-Fock atomic electronic structure calculations using different nuclear charge distributions, Atomic Data and Nuclear Data Tables 67, 207 (1997))
:vartype NuclearModel: Literal["PointCharge", "Gaussian", "Uniform"]
:ivar NumericalQuality: Set the quality of several important technical aspects of a BAND calculation (with the notable exception of the basis set). It sets the quality of: BeckeGrid (numerical integration), ZlmFit (density fitting), KSpace (reciprocal space integration), and SoftConfinement (basis set confinement). Note: the quality defined in the block of a specific technical aspects supersedes the value defined in NumericalQuality (e.g. if I specify 'NumericalQuality Basic' and 'BeckeGrid%Quality Good', the quality of the BeckeGrid will be 'Good')
:vartype NumericalQuality: Literal["Basic", "Normal", "Good", "VeryGood", "Excellent"]
:ivar PEDA: If present in combination with the fragment block, the decomposition of the interaction energy between fragments is invoked.
:vartype PEDA: BoolType | BoolKey
:ivar PopThreshold: Threshold for printing Mulliken population terms. Works with 'Print orbpop'
:vartype PopThreshold: float | FloatKey
:ivar PotentialNoise: The initial potential for the SCF procedure is constructed from a sum-of-atoms density. Added to this is some small noise in the numerical values of the potential in the points of the integration grid. The purpose of the noise is to help the program break the initial symmetry, if that would lower the energy, by effectively inducing small differences between (initially) degenerate orbitals.
:vartype PotentialNoise: float | FloatKey
:ivar Print: One or more strings (separated by blanks) from a pre-defined set may be typed after the key. This induces printing of various kinds of information, usually only used for debugging and checking. The set of recognized strings frequently changes (mainly expands) in the course of software-developments. Useful arguments may be symmetry, and fit.
:vartype Print: str | StringKey
:ivar Save: Save scratch files or extra data that would be otherwise deleted at the end of the calculation. e.g. 'TAPE10' (containing the integration grid) or 'DensityMatrix'
:vartype Save: str | StringKey
:ivar SelectedAtoms: With this key you can select atoms. This has an effect on a few of options, like NMR and EFG.
:vartype SelectedAtoms: Iterable[int] | IntListKey
:ivar SetLoggingLevel: Undocumented.
:vartype SetLoggingLevel: str | StringKey
:ivar Skip: Skip the specified part of the Band calculation (expert/debug option).
:vartype Skip: str | StringKey
:ivar StopAfter: Specifies that the program is stopped after execution of a specified program-part (subroutine).
:vartype StopAfter: str | StringKey
:ivar StoreHamAsMol: Undocumented, used for (at least) NEGF.
:vartype StoreHamAsMol: BoolType | BoolKey
:ivar StoreHamiltonian: Undocumented.
:vartype StoreHamiltonian: BoolType | BoolKey
:ivar StoreHamiltonian2: determine the tight-binding representation of the overlap an fock matrix. Used for (at least) NEGF.
:vartype StoreHamiltonian2: BoolType | BoolKey
:ivar SubSymmetry: The indices of the symmetry operators to maintain.
:vartype SubSymmetry: Iterable[int] | IntListKey
:ivar Title: Title of the calculation, which will be printed in the output file.
:vartype Title: str | StringKey
:ivar Unrestricted: Controls whether Band should perform a spin-unrestricted calculation. Spin-unrestricted calculations are computationally roughly twice as expensive as spin-restricted.
:vartype Unrestricted: BoolType | BoolKey
:ivar UnrestrictedOnlyReference: Undocumented.
:vartype UnrestrictedOnlyReference: BoolType | BoolKey
:ivar UnrestrictedReference: Undocumented.
:vartype UnrestrictedReference: BoolType | BoolKey
:ivar UnrestrictedStartup: Undocumented.
:vartype UnrestrictedStartup: BoolType | BoolKey
:ivar UseInversionSymmetryInReciprocalSpace: Whether to use inversion symmetry in reciprocal space. This is almost always a valid assumption.
:vartype UseInversionSymmetryInReciprocalSpace: BoolType | BoolKey
:ivar UseSymmetry: Whether or not to exploit symmetry during the calculation.
:vartype UseSymmetry: BoolType | BoolKey
:ivar AIMCriticalPoints: Compute the critical points of the density (Atoms In Molecules). The algorithm starts from a regular mesh of points, and from each of these it walks towards its corresponding critical point.
:vartype AIMCriticalPoints: BAND._AIMCriticalPoints
:ivar ATensor: Hyperfine A-tensor.
:vartype ATensor: BAND._ATensor
:ivar Align: Alignment of the potential of the system. Old NEGF.
:vartype Align: BAND._Align
:ivar AtomType: Explicit basis set definition for given atom type.
:vartype AtomType: BAND._AtomType
:ivar BField: The effect of a magnetic filed can be approximated by the following potential: mu * sigma_i * B, where mu is the Bohr magneton, sigma_i are the Pauli matrices and B is the magnetic field
:vartype BField: BAND._BField
:ivar BZPath: Definition of the user-defined path in the Brillouin zone for band structure plotting.
:vartype BZPath: BAND._BZPath
:ivar BandStructure: Options for the calculation of the band structure.
:vartype BandStructure: BAND._BandStructure
:ivar Basis: Definition of the basis set
:vartype Basis: BAND._Basis
:ivar BasisMisc: Miscellaneous options related to basis
:vartype BasisMisc: BAND._BasisMisc
:ivar BeckeGrid: Options for the numerical integration grid, which is a refined version of the fuzzy cells integration scheme developed by Becke.
:vartype BeckeGrid: BAND._BeckeGrid
:ivar Bias: Old NEGF. No longer supported
:vartype Bias: BAND._Bias
:ivar CDFT: Constrained DFT Implementation in Transport. Old NEGF.
:vartype CDFT: BAND._CDFT
:ivar Comment: The content of this block will be copied to the output header as a comment to the calculation.
:vartype Comment: str | Sequence[str] | FreeBlock
:ivar Convergence: Options and parameters related to the convergence behavior of the SCF procedure.
:vartype Convergence: BAND._Convergence
:ivar DFTBConfinementPotential: Specify the confinement potentials (used for DFTB parametrization)
:vartype DFTBConfinementPotential: BAND._DFTBConfinementPotential
:ivar DIIS: Parameters for the DIIS procedure to obtain the SCF solution
:vartype DIIS: BAND._DIIS
:ivar DIRIS: Same options as DIIS key, except that this one applies to the DIIS procedure used in the Dirac subprogram, for numerical single atom calculations, which constructs the radial tables for the NAOs.
:vartype DIRIS: BAND._DIRIS
:ivar DOS: Density-Of-States (DOS) options
:vartype DOS: BAND._DOS
:ivar DensityPlot: Plots of the density. Goes together with the Restart%DensityPlot and Grid keys.
:vartype DensityPlot: str | Sequence[str] | FreeBlock
:ivar Dependency: Criteria for linear dependency of the basis and fit set
:vartype Dependency: BAND._Dependency
:ivar DiracOptions: Options for the atomic Dirac calculations.
:vartype DiracOptions: BAND._DiracOptions
:ivar Dispersion: Technical options for dispersion-corrected functionals.
:vartype Dispersion: BAND._Dispersion
:ivar DosBas: Used to specify the fragment basis for the DOS.
:vartype DosBas: str | Sequence[str] | FreeBlock
:ivar EFG: The electronic charge density causes an electric field, and the gradient of this field couples with the nuclear quadrupole moment, that some (non-spherical) nuclei have and can be measured by several spectroscopic techniques. The EFG tensor is the second derivative of the Coulomb potential at the nuclei. For each atom it is a 3x3 symmetric and traceless matrix. Diagonalization of this matrix gives three eigenvalues, which are usually ordered by their decreasing absolute size and denoted as V_{xx}, V_{yy}, V_{zz}. The result is summarized by the largest eigenvalue and the asymmetry parameter.
:vartype EFG: BAND._EFG
:ivar ESR: Zeeman g-tensor. The Zeeman g-tensor is implemented using two-component approach of Van Lenthe and co-workers in which the g-tensor is computed from a pair of spinors related to each other by time-reversal symmetry. Note: the following options are necessary for ESR: 'Relativistic zora spin' and 'Kspace 1'
:vartype ESR: BAND._ESR
:ivar EffectiveMass: In a semi-conductor, the mobility of electrons and holes is related to the curvature of the bands at the top of the valence band and the bottom of the conduction band.
With the effective mass option, this curvature is obtained by numerical differentiation.
The estimation is done with the specified step size, and twice the specified step size, and both results are printed to give a hint on the accuracy. The easiest way to use this key is to enabled it without specifying any extra options.
:vartype EffectiveMass: BAND._EffectiveMass
:ivar ElectronHole: Allows one to specify an occupied band which shall be depopulated, where the electrons are then moved to the Fermi level. For a spin-restricted calculation 2 electrons are shifted and for a spin-unrestricted calculation only one electron is shifted.
:vartype ElectronHole: BAND._ElectronHole
:ivar EmbeddingPotential: An external potential can be read in and will be added to the effective Kohn-Sham potential. It has to be on the becke grid
:vartype EmbeddingPotential: BAND._EmbeddingPotential
:ivar Excitations: Excitation energies: UV/Vis
:vartype Excitations: BAND._Excitations
:ivar Fermi: Technical parameter used in determining the Fermi energy, which is carried out at each cycle of the SCF procedure.
:vartype Fermi: BAND._Fermi
:ivar FermiSurface: Calculation of the Fermi surface for metals
:vartype FermiSurface: BAND._FermiSurface
:ivar FitMethod: Undocumented
:vartype FitMethod: BAND._FitMethod
:ivar FracOp: Parameters from input for fractional occupations
:vartype FracOp: BAND._FracOp
:ivar FragOccupations: Undocumented
:vartype FragOccupations: str | Sequence[str] | FreeBlock
:ivar Fragment: Defines a fragment. You can define several fragments for a calculation.
:vartype Fragment: BAND._Fragment
:ivar FragmentEnergyTerms: Undocumented
:vartype FragmentEnergyTerms: str | Sequence[str] | FreeBlock
:ivar FuzzyPotential: Atomic (fuzzy cell) based, external, electric potential. See example.
:vartype FuzzyPotential: str | Sequence[str] | FreeBlock
:ivar FuzzyUnitCellGrid: Undocumented.
:vartype FuzzyUnitCellGrid: BAND._FuzzyUnitCellGrid
:ivar GMix: Undocumented. Old NEGF.
:vartype GMix: BAND._GMix
:ivar GW: Perform a GW calculation. G0W0 is the default for GW%SelfConsistency.
:vartype GW: BAND._GW
:ivar Gate: Undocumented. Old NEGF.
:vartype Gate: BAND._Gate
:ivar Gradients: Options for nuclear gradients and strain derivatives calculations.
:vartype Gradients: BAND._Gradients
:ivar Grid: Options for the regular grid used for plotting (e.g. density plot). Used ICW the restart option.
:vartype Grid: BAND._Grid
:ivar GridBasedAIM: Invoke the ultra fast grid based Bader analysis.
:vartype GridBasedAIM: BAND._GridBasedAIM
:ivar GrossPopulations: Partial DOS (pDOS) are generated for the gross populations listed under this key. See example.
:vartype GrossPopulations: str | Sequence[str] | FreeBlock
:ivar HardConfinement: Obsolete basis functions confinement method. Use SoftConfinement instead.
:vartype HardConfinement: BAND._HardConfinement
:ivar HubbardU: Options for Hubbard-corrected DFT calculations.
:vartype HubbardU: BAND._HubbardU
:ivar Integration: Options for the Voronoi numerical integration scheme. Deprecated. Use BeckeGrid instead.
:vartype Integration: BAND._Integration
:ivar KSpace: Options for the k-space integration (i.e. the grid used to sample the Brillouin zone)
:vartype KSpace: BAND._KSpace
:ivar LDOS: Local Density-Of-States information. This can be used to generate STM images in the Tersoff-Hamann approximation (see https://doi.org/10.1103/PhysRevB.31.805)
:vartype LDOS: BAND._LDOS
:ivar MBPT: Technical aspects of the MP2 algorithm.
:vartype MBPT: BAND._MBPT
:ivar MolecularNMR: Options for the calculations of the NMR shielding tensor for molecules, excluding periodic systems. Implements the Schreckenbach method like ADF.
:vartype MolecularNMR: BAND._MolecularNMR
:ivar MultiSecantConfig: Parameters for the Multi-secant SCF convergence method.
:vartype MultiSecantConfig: BAND._MultiSecantConfig
:ivar NEGF: Options for the NEGF (non-equilibrium green function) transport calculation.
:vartype NEGF: BAND._NEGF
:ivar NMR: Options for the calculations of the NMR shielding tensor.
:vartype NMR: BAND._NMR
:ivar NOCVOrbitalPlot: Goes together with the Restart%NOCVOrbitalPlot and Grid keys. See example.
:vartype NOCVOrbitalPlot: str | Sequence[str] | FreeBlock
:ivar NOCVdRhoPlot: Goes together with the Restart%NOCVdRhoPlot and Grid keys. See example.
:vartype NOCVdRhoPlot: str | Sequence[str] | FreeBlock
:ivar NOPROrbitalPlot: Undocumented.
:vartype NOPROrbitalPlot: str | Sequence[str] | FreeBlock
:ivar NOPRdRhoPlot: Undocumented.
:vartype NOPRdRhoPlot: str | Sequence[str] | FreeBlock
:ivar NeutralizingDensityDetails:
:vartype NeutralizingDensityDetails: BAND._NeutralizingDensityDetails
:ivar NewResponse: The TD-CDFT calculation to obtain the dielectric function is computed when this block is present in the input. Several important settings can be defined here.
:vartype NewResponse: BAND._NewResponse
:ivar NewResponseKSpace: Modify the details for the integration weights evaluation in reciprocal space for each single-particle transition. Only influencing the NewResponse code.
:vartype NewResponseKSpace: BAND._NewResponseKSpace
:ivar NewResponseSCF: Details for the linear-response self-consistent optimization cycle. Only influencing the NewResponse code.
:vartype NewResponseSCF: BAND._NewResponseSCF
:ivar NonCollinearMagnetizationModule: Undocumented.
:vartype NonCollinearMagnetizationModule: BAND._NonCollinearMagnetizationModule
:ivar Occupations: Allows one to input specific occupations numbers. Applies only for calculations that use only one k-point (i.e. pseudo-molecule calculations). See example.
:vartype Occupations: str | Sequence[str] | FreeBlock
:ivar OldResponse: Options for the old TD-CDFT implementation.
:vartype OldResponse: BAND._OldResponse
:ivar OrbitalLabels: Undocumented.
:vartype OrbitalLabels: str | Sequence[str] | FreeBlock
:ivar OrbitalPlot: Goes together with the Restart%OrbitalPlot and Grid keys. See Example.
:vartype OrbitalPlot: str | Sequence[str] | FreeBlock
:ivar Output: Control the output.
:vartype Output: BAND._Output
:ivar OverlapPopulations: Overlap population weighted DOS (OPWDOS), also known as the crystal orbital overlap population (COOP).
:vartype OverlapPopulations: str | Sequence[str] | FreeBlock
:ivar PEDANOCV: Options for the decomposition of the orbital relaxation (pEDA).
:vartype PEDANOCV: BAND._PEDANOCV
:ivar PEDANOPR: Undocumented.
:vartype PEDANOPR: BAND._PEDANOPR
:ivar PeriodicRIHartreeFock: Technical options for periodic Hartree Fock.
:vartype PeriodicRIHartreeFock: BAND._PeriodicRIHartreeFock
:ivar PeriodicSolvation: Additional options for simulations of periodic structures with solvation.
:vartype PeriodicSolvation: BAND._PeriodicSolvation
:ivar Programmer: Miscellaneous technical options.
:vartype Programmer: BAND._Programmer
:ivar PropertiesAtNuclei: A number of properties can be obtained near the nucleus. An average is taken over a tiny sphere around the nucleus. The following properties are available: vxc[rho(fit)], rho(fit), rho(scf), v(coulomb/scf), rho(deformation/fit), rho(deformation/scf).
:vartype PropertiesAtNuclei: str | Sequence[str] | FreeBlock
:ivar RIHartreeFock:
:vartype RIHartreeFock: BAND._RIHartreeFock
:ivar RadialDefaults: Options for the logarithmic radial grid of the basis functions used in the subprogram Dirac
:vartype RadialDefaults: BAND._RadialDefaults
:ivar Relativity: Options for relativistic effects.
:vartype Relativity: BAND._Relativity
:ivar ResponseInducedDensityPlot: Goes together with Restart%ResponseInducedDensityPlot and Grid.
:vartype ResponseInducedDensityPlot: str | Sequence[str] | FreeBlock
:ivar Restart: Tells the program that it should restart with the restart file, and what to restart.
:vartype Restart: BAND._Restart
:ivar SCF: Controls technical SCF parameters.
:vartype SCF: BAND._SCF
:ivar Screening: For the periodic solvation potential and for the old (not default anymore) fitting method, BAND performs lattice summations which are in practice truncated. The precision of the lattice summations is controlled by the options in this block.
:vartype Screening: BAND._Screening
:ivar SlakoConfig: Undocumented.
:vartype SlakoConfig: BAND._SlakoConfig
:ivar SoftConfinement: In order to make the basis functions more compact, the radial part of the basis functions is multiplied by a Fermi-Dirac (FD) function (this 'confinement' is done for efficiency and numerical stability reasons). A FD function goes from one to zero, controlled by two parameters. It has a value 0.5 at Radius, and the decay width is Delta.
:vartype SoftConfinement: BAND._SoftConfinement
:ivar Solvation: Options for the COSMO (Conductor like Screening Model) solvation model.
:vartype Solvation: BAND._Solvation
:ivar SolvationSM12: Options for Solvation Model 12 (SM12).
:vartype SolvationSM12: BAND._SolvationSM12
:ivar StrainDerivatives: Undocumented.
:vartype StrainDerivatives: BAND._StrainDerivatives
:ivar Tails: Ignore function tails.
:vartype Tails: BAND._Tails
:ivar TechnicalCOSMO: Some options to develop cosmo for charged periodic systems
:vartype TechnicalCOSMO: BAND._TechnicalCOSMO
:ivar TestParameters: Undocumented.
:vartype TestParameters: BAND._TestParameters
:ivar Transport: Old NEGF. No longer supported
:vartype Transport: BAND._Transport
:ivar XC: Exchange Correlation functionals
:vartype XC: BAND._XC
:ivar ZlmFit: Options for the density fitting scheme 'ZlmFit'.
:vartype ZlmFit: BAND._ZlmFit
"""
[docs] class _AIMCriticalPoints(FixedBlock):
r"""
Compute the critical points of the density (Atoms In Molecules). The algorithm starts from a regular mesh of points, and from each of these it walks towards its corresponding critical point.
:ivar Enabled: Compute the critical points of the density (Atoms In Molecules). The algorithm starts from a regular mesh of points, and from each of these it walks towards its corresponding critical point.
:vartype Enabled: BoolType | BoolKey
:ivar EqvPointsTol: If the distance between two critical points is smaller than this value, the two critical points are considered to be the same point.
:vartype EqvPointsTol: float | FloatKey
:ivar GridPadding: How much extra space is added to the starting guess domain in the search for the critical points
:vartype GridPadding: float | FloatKey
:ivar GridSpacing: The distance between the initial trial points.
:vartype GridSpacing: float | FloatKey
"""
def __post_init__(self):
self.Enabled: BoolType | BoolKey = BoolKey(name='Enabled', comment='Compute the critical points of the density (Atoms In Molecules). The algorithm starts from a regular mesh of points, and from each of these it walks towards its corresponding critical point.', gui_name=': Critical points and bond paths', default=False)
self.EqvPointsTol: float | FloatKey = FloatKey(name='EqvPointsTol', comment='If the distance between two critical points is smaller than this value, the two critical points are considered to be the same point.', default=0.27, unit='Bohr')
self.GridPadding: float | FloatKey = FloatKey(name='GridPadding', comment='How much extra space is added to the starting guess domain in the search for the critical points', default=0.7, unit='Bohr')
self.GridSpacing: float | FloatKey = FloatKey(name='GridSpacing', comment='The distance between the initial trial points.', default=0.5, unit='Bohr')
[docs] class _ATensor(FixedBlock):
r"""
Hyperfine A-tensor.
:ivar Enabled: Compute the hyperfine A-tensor.
Note: Unrestricted calculation is required.
:vartype Enabled: BoolType | BoolKey
"""
def __post_init__(self):
self.Enabled: BoolType | BoolKey = BoolKey(name='Enabled', comment='Compute the hyperfine A-tensor.\n\nNote: Unrestricted calculation is required.', gui_name=':A-tensor', default=False)
[docs] class _Align(FixedBlock):
r"""
Alignment of the potential of the system. Old NEGF.
:ivar StartAlign: Undocumented.
:vartype StartAlign: int | IntKey
:ivar cdiis: Undocumented.
:vartype cdiis: BoolType | BoolKey
:ivar cdiisDamp: Undocumented.
:vartype cdiisDamp: float | FloatKey
:ivar cdiisPrint: Undocumented.
:vartype cdiisPrint: BoolType | BoolKey
:ivar emCharge: Undocumented.
:vartype emCharge: float | FloatKey
:ivar mix: Undocumented.
:vartype mix: float | FloatKey
:ivar pmatShift: Undocumented.
:vartype pmatShift: BoolType | BoolKey
"""
def __post_init__(self):
self.StartAlign: int | IntKey = IntKey(name='StartAlign', comment='Undocumented.', default=10)
self.cdiis: BoolType | BoolKey = BoolKey(name='cdiis', comment='Undocumented.', default=False)
self.cdiisDamp: float | FloatKey = FloatKey(name='cdiisDamp', comment='Undocumented.', default=0.01)
self.cdiisPrint: BoolType | BoolKey = BoolKey(name='cdiisPrint', comment='Undocumented.', default=False)
self.emCharge: float | FloatKey = FloatKey(name='emCharge', comment='Undocumented.', default=0.0)
self.mix: float | FloatKey = FloatKey(name='mix', comment='Undocumented.', default=0.01)
self.pmatShift: BoolType | BoolKey = BoolKey(name='pmatShift', comment='Undocumented.', default=False)
[docs] class _AtomType(FixedBlock):
r"""
Explicit basis set definition for given atom type.
:ivar AutomaticGaussians: Definition of the automatic gaussians
:vartype AutomaticGaussians: str | Sequence[str] | FreeBlock
:ivar BasisFunctions: Definition of the extra Slater-type orbitals
:vartype BasisFunctions: str | Sequence[str] | FreeBlock
:ivar ContractedGaussians: Definition of the contracted gaussians
:vartype ContractedGaussians: str | Sequence[str] | FreeBlock
:ivar Dirac: Specification of the numerical ('Herman-Skillman') free atom, which defines the initial guess for the SCF density, and which also (optionally) supplies Numerical Atomic Orbitals (NOs) as basis functions
:vartype Dirac: str | Sequence[str] | FreeBlock
:ivar FitFunctions: Slater-type fit functions. Obsolete feature.
:vartype FitFunctions: str | Sequence[str] | FreeBlock
"""
[docs] class _AutomaticGaussians(FreeBlock):
r"""
Definition of the automatic gaussians
"""
def __post_init__(self):
pass
[docs] class _BasisFunctions(FreeBlock):
r"""
Definition of the extra Slater-type orbitals
"""
def __post_init__(self):
pass
[docs] class _ContractedGaussians(FreeBlock):
r"""
Definition of the contracted gaussians
"""
def __post_init__(self):
pass
[docs] class _Dirac(FreeBlock):
r"""
Specification of the numerical ('Herman-Skillman') free atom, which defines the initial guess for the SCF density, and which also (optionally) supplies Numerical Atomic Orbitals (NOs) as basis functions
"""
def __post_init__(self):
pass
[docs] class _FitFunctions(FreeBlock):
r"""
Slater-type fit functions. Obsolete feature.
"""
def __post_init__(self):
pass
def __post_init__(self):
self.AutomaticGaussians: str | Sequence[str] | FreeBlock = self._AutomaticGaussians(name='AutomaticGaussians', comment='Definition of the automatic gaussians')
self.BasisFunctions: str | Sequence[str] | FreeBlock = self._BasisFunctions(name='BasisFunctions', comment='Definition of the extra Slater-type orbitals')
self.ContractedGaussians: str | Sequence[str] | FreeBlock = self._ContractedGaussians(name='ContractedGaussians', comment='Definition of the contracted gaussians')
self.Dirac: str | Sequence[str] | FreeBlock = self._Dirac(name='Dirac', comment="Specification of the numerical ('Herman-Skillman') free atom, which defines the initial guess for the SCF density, and which also (optionally) supplies Numerical Atomic Orbitals (NOs) as basis functions", header=True)
self.FitFunctions: str | Sequence[str] | FreeBlock = self._FitFunctions(name='FitFunctions', comment='Slater-type fit functions. Obsolete feature.')
[docs] class _BField(FixedBlock):
r"""
The effect of a magnetic filed can be approximated by the following potential: mu * sigma_i * B, where mu is the Bohr magneton, sigma_i are the Pauli matrices and B is the magnetic field
:ivar Bx: Value of the x component of the BField
:vartype Bx: float | FloatKey
:ivar By: Value of the y component of the BField
:vartype By: float | FloatKey
:ivar Bz: Value of the z component of the BField
:vartype Bz: float | FloatKey
:ivar Dipole: Use an atomic dipole as magnetic field instead of a uniform magnetic field.
:vartype Dipole: BoolType | BoolKey
:ivar DipoleAtom: Atom on which the magnetic dipole should be centered (if using the dipole option)
:vartype DipoleAtom: int | IntKey
:ivar Method: There are two terms coupling to an external magnetic field.
One is the intrinsic spin of the electron, called S-dot-B, the other one is the orbital momentum call L-dot-B.
The L.B is implemented non-relativistically, using GIAOs in the case of a homogeneous magnetic field (not for the dipole case).
:vartype Method: Literal["NR_SDOTB", "NR_LDOTB", "NR_SDOTB_LDOTB"]
:ivar Unit: Unit of magnetic filed. The a.u. is the SI version of a.u.
:vartype Unit: Literal["tesla", "a.u."]
"""
def __post_init__(self):
self.Bx: float | FloatKey = FloatKey(name='Bx', comment='Value of the x component of the BField', default=0.0, unit='Tesla')
self.By: float | FloatKey = FloatKey(name='By', comment='Value of the y component of the BField', default=0.0, unit='Tesla')
self.Bz: float | FloatKey = FloatKey(name='Bz', comment='Value of the z component of the BField', default=0.0, unit='Tesla')
self.Dipole: BoolType | BoolKey = BoolKey(name='Dipole', comment='Use an atomic dipole as magnetic field instead of a uniform magnetic field.', gui_name='Bfield is: Atomic dipole', default=False)
self.DipoleAtom: int | IntKey = IntKey(name='DipoleAtom', comment='Atom on which the magnetic dipole should be centered (if using the dipole option)', gui_name='on atom number:', default=1)
self.Method: Literal["NR_SDOTB", "NR_LDOTB", "NR_SDOTB_LDOTB"] = MultipleChoiceKey(name='Method', comment='There are two terms coupling to an external magnetic field.\n\nOne is the intrinsic spin of the electron, called S-dot-B, the other one is the orbital momentum call L-dot-B.\n\nThe L.B is implemented non-relativistically, using GIAOs in the case of a homogeneous magnetic field (not for the dipole case).', default='NR_SDOTB', choices=['NR_SDOTB', 'NR_LDOTB', 'NR_SDOTB_LDOTB'])
self.Unit: Literal["tesla", "a.u."] = MultipleChoiceKey(name='Unit', comment='Unit of magnetic filed. The a.u. is the SI version of a.u.', default='tesla', choices=['tesla', 'a.u.'])
[docs] class _BZPath(FixedBlock):
r"""
Definition of the user-defined path in the Brillouin zone for band structure plotting.
:ivar kmesh: Undocumented
:vartype kmesh: int | IntKey
:ivar path: Definition of the k-points in a path. The vertices of your path should be defined in fractional coordinates (wrt the reciprocal lattice vectors)
:vartype path: str | Sequence[str] | FreeBlock
"""
[docs] class _path(FreeBlock):
r"""
Definition of the k-points in a path. The vertices of your path should be defined in fractional coordinates (wrt the reciprocal lattice vectors)
"""
def __post_init__(self):
pass
def __post_init__(self):
self.kmesh: int | IntKey = IntKey(name='kmesh', comment='Undocumented', hidden=True, default=5)
self.path: str | Sequence[str] | FreeBlock = self._path(name='path', comment='Definition of the k-points in a path. The vertices of your path should be defined in fractional coordinates (wrt the reciprocal lattice vectors)', unique=False)
[docs] class _BandStructure(FixedBlock):
r"""
Options for the calculation of the band structure.
:ivar Automatic: If True, BAND will automatically generate the standard path through the Brillouin zone.
If False BAND will use the user-defined path in BZPath.
:vartype Automatic: BoolType | BoolKey
:ivar DeltaK: Step (in reciprocal space) for band structure interpolation.
Using a smaller number (e.g. 0.03) will result in smoother band curves at the cost of an increased computation time.
:vartype DeltaK: float | FloatKey
:ivar Enabled: If True, Band will calculate the band structure and save it to file for visualization.
:vartype Enabled: BoolType | BoolKey
:ivar EnergyAboveFermi: Bands with minimum energy larger then FermiEnergy + EnergyAboveFermi are not saved to file. Increasing the value of EnergyAboveFermi will result in more unoccupied bands to be saved to file for visualization.
:vartype EnergyAboveFermi: float | FloatKey
:ivar EnergyBelowFermi: Bands with maximum energy smaller then FermiEnergy - EnergyBelowFermi are not saved to file. Increasing the value of EnergyBelowFermi will result in more occupied core bands to be saved to file for visualization. Note: EnergyBelowFermi should be a positive number!
:vartype EnergyBelowFermi: float | FloatKey
:ivar FatBands: If True, BAND will compute the fat bands (only if BandStructure%Enabled is True).
The Fat Bands are the periodic equivalent of the Mulliken population analysis.
:vartype FatBands: BoolType | BoolKey
:ivar KPathFinderConvention: This option determines how the path through the Brillouin zone is generated when using the automatic k-point mode.
Available options:
• ``Setyawan-Curtarolo`` (default for 1D and 2D lattices): Uses our built-in KPath program to find a path through high-symmetry points based on the method by Setyawan and Curtarolo (https://doi.org/10.1016/j.commatsci.2010.05.010). For 2D lattices, the path is derived from the intersection of the 3D Brillouin zone with a plane. For 1D lattices, the path is simply Gamma-Z.
• ``Hinuma``: Uses the external SeeKPath utility to generate the k-path (https://github.com/giovannipizzi/seekpath and https://doi.org/10.1016/j.commatsci.2016.10.015).
:vartype KPathFinderConvention: Literal["Setyawan-Curtarolo", "Hinuma"]
:ivar UseSymmetry: If True, only the irreducible wedge of the Wigner-Seitz cell is sampled.
If False, the whole (inversion-unique) Wigner-Seitz cell is sampled.
Note: The Symmetry key does not influence the symmetry of the band structure sampling. Only available for Setyawan and Curtarolo convention (see ``KPathFinderConvention``).
:vartype UseSymmetry: BoolType | BoolKey
"""
def __post_init__(self):
self.Automatic: BoolType | BoolKey = BoolKey(name='Automatic', comment='If True, BAND will automatically generate the standard path through the Brillouin zone.\n\nIf False BAND will use the user-defined path in BZPath.', gui_name='Automatic generate path:', default=True)
self.DeltaK: float | FloatKey = FloatKey(name='DeltaK', comment='Step (in reciprocal space) for band structure interpolation.\n\nUsing a smaller number (e.g. 0.03) will result in smoother band curves at the cost of an increased computation time.', gui_name='Interpolation delta-K:', default=0.1, unit='1/Bohr')
self.Enabled: BoolType | BoolKey = BoolKey(name='Enabled', comment='If True, Band will calculate the band structure and save it to file for visualization.', gui_name='Calculate band structure:', default=False)
self.EnergyAboveFermi: float | FloatKey = FloatKey(name='EnergyAboveFermi', comment='Bands with minimum energy larger then FermiEnergy + EnergyAboveFermi are not saved to file. Increasing the value of EnergyAboveFermi will result in more unoccupied bands to be saved to file for visualization.', gui_name='Energy above Fermi level:', default=0.75, unit='Hartree')
self.EnergyBelowFermi: float | FloatKey = FloatKey(name='EnergyBelowFermi', comment='Bands with maximum energy smaller then FermiEnergy - EnergyBelowFermi are not saved to file. Increasing the value of EnergyBelowFermi will result in more occupied core bands to be saved to file for visualization. Note: EnergyBelowFermi should be a positive number!', gui_name='Energy below Fermi level:', default=10.0, unit='Hartree')
self.FatBands: BoolType | BoolKey = BoolKey(name='FatBands', comment='If True, BAND will compute the fat bands (only if BandStructure%Enabled is True).\n\nThe Fat Bands are the periodic equivalent of the Mulliken population analysis.', gui_name='Calculate fatbands:', default=True)
self.KPathFinderConvention: Literal["Setyawan-Curtarolo", "Hinuma"] = MultipleChoiceKey(name='KPathFinderConvention', comment='This option determines how the path through the Brillouin zone is generated when using the automatic k-point mode.\n\nAvailable options:\n\n• ``Setyawan-Curtarolo`` (default for 1D and 2D lattices): Uses our built-in KPath program to find a path through high-symmetry points based on the method by Setyawan and Curtarolo (https://doi.org/10.1016/j.commatsci.2010.05.010). For 2D lattices, the path is derived from the intersection of the 3D Brillouin zone with a plane. For 1D lattices, the path is simply Gamma-Z.\n\n• ``Hinuma``: Uses the external SeeKPath utility to generate the k-path (https://github.com/giovannipizzi/seekpath and https://doi.org/10.1016/j.commatsci.2016.10.015).', default='Setyawan-Curtarolo', choices=['Setyawan-Curtarolo', 'Hinuma'])
self.UseSymmetry: BoolType | BoolKey = BoolKey(name='UseSymmetry', comment='If True, only the irreducible wedge of the Wigner-Seitz cell is sampled.\n\nIf False, the whole (inversion-unique) Wigner-Seitz cell is sampled.\n\nNote: The Symmetry key does not influence the symmetry of the band structure sampling. Only available for Setyawan and Curtarolo convention (see ``KPathFinderConvention``).', gui_name='Use symmetry:', default=True)
[docs] class _Basis(FixedBlock):
r"""
Definition of the basis set
:ivar Core: Select the size of the frozen core you want to use.
Small, Medium, and Large will be interpreted within the basis sets available (of the selected quality), and might refer to the same core in some cases.
:vartype Core: Literal["None", "Small", "Medium", "Large"]
:ivar Folder: Path to a folder containing the basis set files. This can be used for special use-defined basis sets. Cannot be used in combination with 'Type'
:vartype Folder: str | Path | StringKey
:ivar Type: Select the basis set to use.
SZ : Single Z
DZ : Double Z
DZP : Double Z, 1 polarization function
TZP : Triple Z, 1 polarization function
TZ2P : Triple Z, 2 polarization functions
QZ4P : Quadruple Z, 4 polarization function
The basis set chosen will apply to all atoms in your structure. If a matching basis is not found a better type might be used.
:vartype Type: Literal["SZ", "DZ", "DZP", "TZP", "TZ2P", "QZ4P", "QZ5P", "V", "STO/TZ2P", "STO/SZ", "STO/DZ", "STO/DZP", "STO/QZ4P", "AUTOGAUSS", "CORR/QZ6P", "CORR/TZ3P", "CORR/QZ6P_GH", "CORR/TZ3P_G", "GTO/CC-PWCVQZ", "GTO/CC-PV5Z", "GTO/DEF2-QZVPPD", "GTO/CC-PV6Z", "GTO/CC-PVQZ", "GTO/CC-PVTZ", "GTO/CC-PVDZ", "GTO/DEF2-SVP", "GTO/DEF2-TZVP", "GTO/DEF2-TZVPP", "GTO/DEF2-QZVP", "GTO/AUG-CC-PVDZ", "GTO/AUG-CC-PVTZ", "GTO/AUG-CC-PVQZ", "GTO/POB-TZVP"]
:ivar PerAtomType: Defines the basis set for all atoms of a particular type.
:vartype PerAtomType: BAND._Basis._PerAtomType
:ivar PerRegion: Defines the basis set for all atoms in a region. If specified, this overwrites the values set with the Basis%Type and Basis%PerAtomType keywords for atoms in that region. Note that if this keyword is used multiple times, the chosen regions may not overlap.
:vartype PerRegion: BAND._Basis._PerRegion
"""
[docs] class _PerAtomType(FixedBlock):
r"""
Defines the basis set for all atoms of a particular type.
:ivar Core: Size of the frozen core.
:vartype Core: Literal["None", "Small", "Medium", "Large"]
:ivar File: The path to the basis set file. The path can be absolute or relative to $AMSRESOURCES/Band. Specifying the path to the basis file explicitly overrides the automatic basis file selection via the Type and Core subkeys.
:vartype File: str | Path | StringKey
:ivar Symbol: The symbol for which to define the basis set.
:vartype Symbol: str | StringKey
:ivar Type: The basis sets to be used.
:vartype Type: Literal["SZ", "DZ", "DZP", "TZP", "TZ2P", "QZ4P", "V"]
"""
def __post_init__(self):
self.Core: Literal["None", "Small", "Medium", "Large"] = MultipleChoiceKey(name='Core', comment='Size of the frozen core.', choices=['None', 'Small', 'Medium', 'Large'])
self.File: str | Path | StringKey = PathStringKey(name='File', comment='The path to the basis set file. The path can be absolute or relative to $AMSRESOURCES/Band. Specifying the path to the basis file explicitly overrides the automatic basis file selection via the Type and Core subkeys.', ispath=True)
self.Symbol: str | StringKey = StringKey(name='Symbol', comment='The symbol for which to define the basis set.')
self.Type: Literal["SZ", "DZ", "DZP", "TZP", "TZ2P", "QZ4P", "V"] = MultipleChoiceKey(name='Type', comment='The basis sets to be used.', choices=['SZ', 'DZ', 'DZP', 'TZP', 'TZ2P', 'QZ4P', 'V'], hiddenchoices=['V'])
[docs] class _PerRegion(FixedBlock):
r"""
Defines the basis set for all atoms in a region. If specified, this overwrites the values set with the Basis%Type and Basis%PerAtomType keywords for atoms in that region. Note that if this keyword is used multiple times, the chosen regions may not overlap.
:ivar Core: Size of the frozen core.
:vartype Core: Literal["None", "Small", "Medium", "Large"]
:ivar File: The path to the basis set file. The path can be absolute or relative to $AMSRESOURCES/Band. Specifying the path to the basis file explicitly overrides the automatic basis file selection via the Type and Core subkeys.
:vartype File: str | Path | StringKey
:ivar Region: The identifier of the region for which to define the basis set. Note that this may also be a region expression, e.g. 'myregion+myotherregion' (the union of two regions).
:vartype Region: str | StringKey
:ivar Type: The basis sets to be used.
:vartype Type: Literal["SZ", "DZ", "DZP", "TZP", "TZ2P", "QZ4P", "V"]
"""
def __post_init__(self):
self.Core: Literal["None", "Small", "Medium", "Large"] = MultipleChoiceKey(name='Core', comment='Size of the frozen core.', default='Large', choices=['None', 'Small', 'Medium', 'Large'])
self.File: str | Path | StringKey = PathStringKey(name='File', comment='The path to the basis set file. The path can be absolute or relative to $AMSRESOURCES/Band. Specifying the path to the basis file explicitly overrides the automatic basis file selection via the Type and Core subkeys.', ispath=True)
self.Region: str | StringKey = StringKey(name='Region', comment="The identifier of the region for which to define the basis set. Note that this may also be a region expression, e.g. 'myregion+myotherregion' (the union of two regions).", gui_type='region')
self.Type: Literal["SZ", "DZ", "DZP", "TZP", "TZ2P", "QZ4P", "V"] = MultipleChoiceKey(name='Type', comment='The basis sets to be used.', default='DZ', choices=['SZ', 'DZ', 'DZP', 'TZP', 'TZ2P', 'QZ4P', 'V'], hiddenchoices=['V'])
def __post_init__(self):
self.Core: Literal["None", "Small", "Medium", "Large"] = MultipleChoiceKey(name='Core', comment='Select the size of the frozen core you want to use.\n\nSmall, Medium, and Large will be interpreted within the basis sets available (of the selected quality), and might refer to the same core in some cases.', gui_name='Frozen core:', default='Large', choices=['None', 'Small', 'Medium', 'Large'])
self.Folder: str | Path | StringKey = PathStringKey(name='Folder', comment="Path to a folder containing the basis set files. This can be used for special use-defined basis sets. Cannot be used in combination with 'Type'", ispath=True)
self.Type: Literal["SZ", "DZ", "DZP", "TZP", "TZ2P", "QZ4P", "QZ5P", "V", "STO/TZ2P", "STO/SZ", "STO/DZ", "STO/DZP", "STO/QZ4P", "AUTOGAUSS", "CORR/QZ6P", "CORR/TZ3P", "CORR/QZ6P_GH", "CORR/TZ3P_G", "GTO/CC-PWCVQZ", "GTO/CC-PV5Z", "GTO/DEF2-QZVPPD", "GTO/CC-PV6Z", "GTO/CC-PVQZ", "GTO/CC-PVTZ", "GTO/CC-PVDZ", "GTO/DEF2-SVP", "GTO/DEF2-TZVP", "GTO/DEF2-TZVPP", "GTO/DEF2-QZVP", "GTO/AUG-CC-PVDZ", "GTO/AUG-CC-PVTZ", "GTO/AUG-CC-PVQZ", "GTO/POB-TZVP"] = MultipleChoiceKey(name='Type', comment='Select the basis set to use.\n\nSZ : Single Z\nDZ : Double Z\nDZP : Double Z, 1 polarization function\nTZP : Triple Z, 1 polarization function\nTZ2P : Triple Z, 2 polarization functions\nQZ4P : Quadruple Z, 4 polarization function\n\nThe basis set chosen will apply to all atoms in your structure. If a matching basis is not found a better type might be used.', gui_name='Basis set:', default='DZ', choices=['SZ', 'DZ', 'DZP', 'TZP', 'TZ2P', 'QZ4P', 'QZ5P', 'V', 'STO/TZ2P', 'STO/SZ', 'STO/DZ', 'STO/DZP', 'STO/QZ4P', 'AUTOGAUSS', 'CORR/QZ6P', 'CORR/TZ3P', 'CORR/QZ6P_GH', 'CORR/TZ3P_G', 'GTO/CC-PWCVQZ', 'GTO/CC-PV5Z', 'GTO/DEF2-QZVPPD', 'GTO/CC-PV6Z', 'GTO/CC-PVQZ', 'GTO/CC-PVTZ', 'GTO/CC-PVDZ', 'GTO/DEF2-SVP', 'GTO/DEF2-TZVP', 'GTO/DEF2-TZVPP', 'GTO/DEF2-QZVP', 'GTO/AUG-CC-PVDZ', 'GTO/AUG-CC-PVTZ', 'GTO/AUG-CC-PVQZ', 'GTO/POB-TZVP'], hiddenchoices=['V', 'AUTOGAUSS', 'QZ5P', 'GTO/CC-PWCVQZ', 'CORR/TZ3P_G', 'CORR/QZ6P_GH'], gui_type='literal choices; submenus STO STO/* CORR CORR/* GTO GTO/*')
self.PerAtomType: BAND._Basis._PerAtomType = self._PerAtomType(name='PerAtomType', comment='Defines the basis set for all atoms of a particular type.', unique=False)
self.PerRegion: BAND._Basis._PerRegion = self._PerRegion(name='PerRegion', comment='Defines the basis set for all atoms in a region. If specified, this overwrites the values set with the Basis%Type and Basis%PerAtomType keywords for atoms in that region. Note that if this keyword is used multiple times, the chosen regions may not overlap.', unique=False)
[docs] class _BasisMisc(FixedBlock):
r"""
Miscellaneous options related to basis
:ivar FreezeCore: Undocumented.
:vartype FreezeCore: BoolType | BoolKey
:ivar NewFrag: Undocumented.
:vartype NewFrag: BoolType | BoolKey
:ivar PrepareFragment: Undocumented.
:vartype PrepareFragment: BoolType | BoolKey
:ivar SimpleFrag: Undocumented.
:vartype SimpleFrag: BoolType | BoolKey
:ivar SlaterNR: Undocumented.
:vartype SlaterNR: BoolType | BoolKey
"""
def __post_init__(self):
self.FreezeCore: BoolType | BoolKey = BoolKey(name='FreezeCore', comment='Undocumented.', default=True)
self.NewFrag: BoolType | BoolKey = BoolKey(name='NewFrag', comment='Undocumented.')
self.PrepareFragment: BoolType | BoolKey = BoolKey(name='PrepareFragment', comment='Undocumented.')
self.SimpleFrag: BoolType | BoolKey = BoolKey(name='SimpleFrag', comment='Undocumented.')
self.SlaterNR: BoolType | BoolKey = BoolKey(name='SlaterNR', comment='Undocumented.')
[docs] class _BeckeGrid(FixedBlock):
r"""
Options for the numerical integration grid, which is a refined version of the fuzzy cells integration scheme developed by Becke.
:ivar AllowAngularBoost: Allow automatic augmentation of the Lebedev spherical grid for highly coordinated atoms.
:vartype AllowAngularBoost: BoolType | BoolKey
:ivar CutOffDistancePointCharges: In case of external point charges the grid puts also centers there. For charges far away from the QM density this is not needed.
:vartype CutOffDistancePointCharges: float | FloatKey
:ivar InnerShellsPruning: Allow automatic pruning of the Lebedev spherical grid for shells close to the nuclei.
:vartype InnerShellsPruning: BoolType | BoolKey
:ivar PartitionFunPruning: Allow pruning of integration points based on the value of the partition function.
:vartype PartitionFunPruning: BoolType | BoolKey
:ivar Quality: Quality of the integration grid. For a description of the various qualities and the associated numerical accuracy see reference. If 'Auto', the quality defined in the 'NumericalQuality' will be used.
:vartype Quality: Literal["Auto", "Basic", "Normal", "Good", "VeryGood", "Excellent"]
:ivar RadialGridBoost: The number of radial grid points will be boosted by this factor. Some XC functionals require very accurate radial integration grids, so BAND will automatically boost the radial grid by a factor 3 for the following numerically sensitive functionals: LibXC M05, LibXC M05-2X, LibXC M06-2X, LibXC M06-HF, LibXC M06-L, LibXC M08-HX, LibXC M08-SO, LibXC M11-L, LibXC MS0, LibXC MS1, LibXC MS2, LibXC MS2H, LibXC MVS, LibXC MVSH, LibXC N12, LibXC N12-SX, LibXC SOGGA11, LibXC SOGGA11-X, LibXC TH1, LibXC TH2, LibXC WB97, LibXC WB97X, MetaGGA M06L, MetaHybrid M06-2X, MetaHybrid M06-HF, MetaGGA MVS.
:vartype RadialGridBoost: float | FloatKey
:ivar UserCoreL: Technical grid parameter: Lebedev angular grid order for core shells.
:vartype UserCoreL: int | IntKey
:ivar UserExterL: Technical grid parameter: Lebedev angular grid order for exterl shells.
:vartype UserExterL: int | IntKey
:ivar UserExterLBoost: Technical grid parameter.
:vartype UserExterLBoost: int | IntKey
:ivar UserInter1l: Technical grid parameter: Lebedev angular grid order for first inner core shells.
:vartype UserInter1l: int | IntKey
:ivar UserInter2l: Technical grid parameter: Lebedev angular grid order for second inner core shells.
:vartype UserInter2l: int | IntKey
:ivar UserRadMulFactor: Technical grid parameter: Multiplication factor for number of radial grid points.
:vartype UserRadMulFactor: float | FloatKey
:ivar QualityPerRegion: Sets the grid quality for all atoms in a region. If specified, this overwrites the globally set quality.
:vartype QualityPerRegion: BAND._BeckeGrid._QualityPerRegion
"""
[docs] class _QualityPerRegion(FixedBlock):
r"""
Sets the grid quality for all atoms in a region. If specified, this overwrites the globally set quality.
:ivar Quality: The region's integration grid quality.
:vartype Quality: Literal["Basic", "Normal", "Good", "VeryGood", "Excellent"]
:ivar Region: The identifier of the region for which to set the quality.
:vartype Region: str | StringKey
"""
def __post_init__(self):
self.Quality: Literal["Basic", "Normal", "Good", "VeryGood", "Excellent"] = MultipleChoiceKey(name='Quality', comment="The region's integration grid quality.", choices=['Basic', 'Normal', 'Good', 'VeryGood', 'Excellent'])
self.Region: str | StringKey = StringKey(name='Region', comment='The identifier of the region for which to set the quality.', gui_type='region')
def __post_init__(self):
self.AllowAngularBoost: BoolType | BoolKey = BoolKey(name='AllowAngularBoost', comment='Allow automatic augmentation of the Lebedev spherical grid for highly coordinated atoms.', hidden=True, default=True)
self.CutOffDistancePointCharges: float | FloatKey = FloatKey(name='CutOffDistancePointCharges', comment='In case of external point charges the grid puts also centers there. For charges far away from the QM density this is not needed.', hidden=True, default=10.0)
self.InnerShellsPruning: BoolType | BoolKey = BoolKey(name='InnerShellsPruning', comment='Allow automatic pruning of the Lebedev spherical grid for shells close to the nuclei.', hidden=True, default=True)
self.PartitionFunPruning: BoolType | BoolKey = BoolKey(name='PartitionFunPruning', comment='Allow pruning of integration points based on the value of the partition function.', hidden=True, default=True)
self.Quality: Literal["Auto", "Basic", "Normal", "Good", "VeryGood", "Excellent"] = MultipleChoiceKey(name='Quality', comment="Quality of the integration grid. For a description of the various qualities and the associated numerical accuracy see reference. If 'Auto', the quality defined in the 'NumericalQuality' will be used.", default='Auto', choices=['Auto', 'Basic', 'Normal', 'Good', 'VeryGood', 'Excellent'])
self.RadialGridBoost: float | FloatKey = FloatKey(name='RadialGridBoost', comment='The number of radial grid points will be boosted by this factor. Some XC functionals require very accurate radial integration grids, so BAND will automatically boost the radial grid by a factor 3 for the following numerically sensitive functionals: LibXC M05, LibXC M05-2X, LibXC M06-2X, LibXC M06-HF, LibXC M06-L, LibXC M08-HX, LibXC M08-SO, LibXC M11-L, LibXC MS0, LibXC MS1, LibXC MS2, LibXC MS2H, LibXC MVS, LibXC MVSH, LibXC N12, LibXC N12-SX, LibXC SOGGA11, LibXC SOGGA11-X, LibXC TH1, LibXC TH2, LibXC WB97, LibXC WB97X, MetaGGA M06L, MetaHybrid M06-2X, MetaHybrid M06-HF, MetaGGA MVS.', default=1.0)
self.UserCoreL: int | IntKey = IntKey(name='UserCoreL', comment='Technical grid parameter: Lebedev angular grid order for core shells.', hidden=True, default=53)
self.UserExterL: int | IntKey = IntKey(name='UserExterL', comment='Technical grid parameter: Lebedev angular grid order for exterl shells.', hidden=True, default=53)
self.UserExterLBoost: int | IntKey = IntKey(name='UserExterLBoost', comment='Technical grid parameter.', hidden=True, default=53)
self.UserInter1l: int | IntKey = IntKey(name='UserInter1l', comment='Technical grid parameter: Lebedev angular grid order for first inner core shells.', hidden=True, default=53)
self.UserInter2l: int | IntKey = IntKey(name='UserInter2l', comment='Technical grid parameter: Lebedev angular grid order for second inner core shells.', hidden=True, default=53)
self.UserRadMulFactor: float | FloatKey = FloatKey(name='UserRadMulFactor', comment='Technical grid parameter: Multiplication factor for number of radial grid points.', hidden=True, default=20.0)
self.QualityPerRegion: BAND._BeckeGrid._QualityPerRegion = self._QualityPerRegion(name='QualityPerRegion', comment='Sets the grid quality for all atoms in a region. If specified, this overwrites the globally set quality.', unique=False)
[docs] class _Bias(FixedBlock):
r"""
Old NEGF. No longer supported
:ivar block: Undocumented.
:vartype block: BoolType | BoolKey
:ivar deltax: Undocumented.
:vartype deltax: float | FloatKey
:ivar deltay: Undocumented.
:vartype deltay: float | FloatKey
:ivar deltaz: Undocumented.
:vartype deltaz: float | FloatKey
:ivar iterative: Undocumented.
:vartype iterative: BoolType | BoolKey
:ivar phi1: Undocumented.
:vartype phi1: float | FloatKey
:ivar phi2: Undocumented.
:vartype phi2: float | FloatKey
:ivar plot: Undocumented.
:vartype plot: int | IntKey
:ivar tc1: Undocumented.
:vartype tc1: float | FloatKey
:ivar tc2: Undocumented.
:vartype tc2: float | FloatKey
:ivar x1: Undocumented.
:vartype x1: float | FloatKey
:ivar x2: Undocumented.
:vartype x2: float | FloatKey
:ivar y1: Undocumented.
:vartype y1: float | FloatKey
:ivar y2: Undocumented.
:vartype y2: float | FloatKey
:ivar z1: Undocumented.
:vartype z1: float | FloatKey
:ivar z2: Undocumented.
:vartype z2: float | FloatKey
"""
def __post_init__(self):
self.block: BoolType | BoolKey = BoolKey(name='block', comment='Undocumented.', default=False)
self.deltax: float | FloatKey = FloatKey(name='deltax', comment='Undocumented.', default=0.1)
self.deltay: float | FloatKey = FloatKey(name='deltay', comment='Undocumented.', default=0.1)
self.deltaz: float | FloatKey = FloatKey(name='deltaz', comment='Undocumented.', default=0.1)
self.iterative: BoolType | BoolKey = BoolKey(name='iterative', comment='Undocumented.', default=False)
self.phi1: float | FloatKey = FloatKey(name='phi1', comment='Undocumented.', default=0.0)
self.phi2: float | FloatKey = FloatKey(name='phi2', comment='Undocumented.', default=0.0)
self.plot: int | IntKey = IntKey(name='plot', comment='Undocumented.', default=1000)
self.tc1: float | FloatKey = FloatKey(name='tc1', comment='Undocumented.', default=0.0)
self.tc2: float | FloatKey = FloatKey(name='tc2', comment='Undocumented.', default=0.0)
self.x1: float | FloatKey = FloatKey(name='x1', comment='Undocumented.', default=0.0)
self.x2: float | FloatKey = FloatKey(name='x2', comment='Undocumented.', default=0.0)
self.y1: float | FloatKey = FloatKey(name='y1', comment='Undocumented.', default=0.0)
self.y2: float | FloatKey = FloatKey(name='y2', comment='Undocumented.', default=0.0)
self.z1: float | FloatKey = FloatKey(name='z1', comment='Undocumented.', default=0.0)
self.z2: float | FloatKey = FloatKey(name='z2', comment='Undocumented.', default=0.0)
[docs] class _CDFT(FixedBlock):
r"""
Constrained DFT Implementation in Transport. Old NEGF.
:ivar basfnc: lsat basis function of contacts+EM-ex-Mol, next basfnc = 1st on Mol
:vartype basfnc: int | IntKey
:ivar basislim: Sets basisfunction to start constraining from, overrides previous
:vartype basislim: int | IntKey
:ivar cdftmix: Mixing strength
:vartype cdftmix: float | FloatKey
:ivar field: Field strength
:vartype field: float | FloatKey
:ivar qexcess: Excess charge
:vartype qexcess: float | FloatKey
:ivar startcdft: Sets starting iteration
:vartype startcdft: int | IntKey
"""
def __post_init__(self):
self.basfnc: int | IntKey = IntKey(name='basfnc', comment='lsat basis function of contacts+EM-ex-Mol, next basfnc = 1st on Mol', default=1)
self.basislim: int | IntKey = IntKey(name='basislim', comment='Sets basisfunction to start constraining from, overrides previous', default=0)
self.cdftmix: float | FloatKey = FloatKey(name='cdftmix', comment='Mixing strength', default=0.01)
self.field: float | FloatKey = FloatKey(name='field', comment='Field strength', default=0.01)
self.qexcess: float | FloatKey = FloatKey(name='qexcess', comment='Excess charge', default=0.0)
self.startcdft: int | IntKey = IntKey(name='startcdft', comment='Sets starting iteration', default=3)
[docs] class _Convergence(FixedBlock):
r"""
Options and parameters related to the convergence behavior of the SCF procedure.
:ivar Boltzmann: Undocumented
:vartype Boltzmann: int | IntKey
:ivar Criterion: Criterion for termination of the SCF procedure. The default depends on the NumericalQuality and on the number of atoms in the system.
Can be used for EngineAutomations
:vartype Criterion: float | FloatKey
:ivar CriterionFactor: Multiply Criterion (which depends on system and quality) with this factor.
Can be used for EngineAutomations
:vartype CriterionFactor: float | FloatKey
:ivar Degenerate: Smooths (slightly) occupation numbers around the Fermi level, so as to insure that nearly-degenerate states get (nearly-) identical occupations. Be aware: In case of problematic SCF convergence the program will turn this key on automatically, unless the key 'Nodegenerate' is set in input. The smoothing depends on the argument to this key, which can be considered a 'degeneration width'. When the argument reads default, the program will use the value 1e-4 a.u. for the energy width.
:vartype Degenerate: str | StringKey
:ivar EDegen: Undocumented
:vartype EDegen: float | FloatKey
:ivar ElectronicTemperature: (KT) Specify this key for a gradient independent electronic temperature
:vartype ElectronicTemperature: float | FloatKey
:ivar InitialDensity: The SCF is started with a guess of the density. There are the following choices RHO: the sum of atomic density. PSI: construct an initial eigensystem by occupying the atomic orbitals. The guessed eigensystem is orthonormalized, and from this the density is calculated/
:vartype InitialDensity: Literal["rho", "psi", "frompot"]
:ivar LessDegenerate: If smoothing of occupations over nearly degenerate orbitals is applied (see Degenerate key), then, if this key is set in the input file, the program will limit the smoothing energy range to 1e-4 a.u. as soon as the SCF has converged 'halfway', i.e. when the SCF error has decreased to the square root of its convergence criterion.
:vartype LessDegenerate: BoolType | BoolKey
:ivar ModestCriterion: If this is specified band will consider the SCF converged if the error is below this criterion (after using the maximum number of iterations).
:vartype ModestCriterion: float | FloatKey
:ivar NoDegenerate: This key prevents any internal automatic setting of the key DEGENERATE.
:vartype NoDegenerate: BoolType | BoolKey
:ivar NumBoltz: The electronic temperature is done with a Riemann Stieltjes numerical integration, between zero and one occupation. This defines the number of points to be used.
:vartype NumBoltz: int | IntKey
:ivar SpinFlip: List here the atoms for which you want the initial spin polarization to be flipped. This way you can distinguish between ferromagnetic and anti ferromagnetic states. Currently, it is not allowed to give symmetry equivalent atoms a different spin orientation. To achieve that you have to break the symmetry.
:vartype SpinFlip: Iterable[int] | IntListKey
:ivar SpinFlipEnabled: If set to False, the keys SpinFlip and SpinFlipRegion are ignored. Only useful/convenient when trying to compare in a script the effect of spin flip.
:vartype SpinFlipEnabled: BoolType | BoolKey
:ivar SpinFlipRegion: Specify here the region for which you want the initial spin polarization to be flipped. This way you can distinguish between ferromagnetic and anti ferromagnetic states. Currently, it is not allowed to give symmetry equivalent atoms a different spin orientation. To achieve that you have to break the symmetry.
:vartype SpinFlipRegion: str | StringKey
:ivar StartWithMaxSpin: To break the initial perfect symmetry of up and down densities there are two strategies. One is to occupy the numerical orbitals in a maximum spin configuration. The alternative is to add a constant to the potential. See also Vsplit key.
:vartype StartWithMaxSpin: BoolType | BoolKey
:ivar StartWithMaxSpinForSO: Same as the StartWithMaxSpin option. In case of spin-orbit band always used to split the potential. Now will use maxspin in case of SpinFlip. With this option it will always do that.
:vartype StartWithMaxSpinForSO: BoolType | BoolKey
:ivar Temperature: Undocumented
:vartype Temperature: float | FloatKey
"""
def __post_init__(self):
self.Boltzmann: int | IntKey = IntKey(name='Boltzmann', comment='Undocumented', hidden=True, default=2)
self.Criterion: float | FloatKey = FloatKey(name='Criterion', comment='Criterion for termination of the SCF procedure. The default depends on the NumericalQuality and on the number of atoms in the system.\nCan be used for EngineAutomations')
self.CriterionFactor: float | FloatKey = FloatKey(name='CriterionFactor', comment='Multiply Criterion (which depends on system and quality) with this factor.\nCan be used for EngineAutomations', default=1.0)
self.Degenerate: str | StringKey = StringKey(name='Degenerate', comment="Smooths (slightly) occupation numbers around the Fermi level, so as to insure that nearly-degenerate states get (nearly-) identical occupations. Be aware: In case of problematic SCF convergence the program will turn this key on automatically, unless the key 'Nodegenerate' is set in input. The smoothing depends on the argument to this key, which can be considered a 'degeneration width'. When the argument reads default, the program will use the value 1e-4 a.u. for the energy width.", default='default')
self.EDegen: float | FloatKey = FloatKey(name='EDegen', comment='Undocumented', hidden=True, default=0.0001)
self.ElectronicTemperature: float | FloatKey = FloatKey(name='ElectronicTemperature', comment='(KT) Specify this key for a gradient independent electronic temperature', default=0.0, unit='Hartree')
self.InitialDensity: Literal["rho", "psi", "frompot"] = MultipleChoiceKey(name='InitialDensity', comment='The SCF is started with a guess of the density. There are the following choices RHO: the sum of atomic density. PSI: construct an initial eigensystem by occupying the atomic orbitals. The guessed eigensystem is orthonormalized, and from this the density is calculated/', default='rho', choices=['rho', 'psi', 'frompot'])
self.LessDegenerate: BoolType | BoolKey = BoolKey(name='LessDegenerate', comment="If smoothing of occupations over nearly degenerate orbitals is applied (see Degenerate key), then, if this key is set in the input file, the program will limit the smoothing energy range to 1e-4 a.u. as soon as the SCF has converged 'halfway', i.e. when the SCF error has decreased to the square root of its convergence criterion.", default=False)
self.ModestCriterion: float | FloatKey = FloatKey(name='ModestCriterion', comment='If this is specified band will consider the SCF converged if the error is below this criterion (after using the maximum number of iterations).', default=-1.0)
self.NoDegenerate: BoolType | BoolKey = BoolKey(name='NoDegenerate', comment='This key prevents any internal automatic setting of the key DEGENERATE.', default=False)
self.NumBoltz: int | IntKey = IntKey(name='NumBoltz', comment='The electronic temperature is done with a Riemann Stieltjes numerical integration, between zero and one occupation. This defines the number of points to be used.', default=10)
self.SpinFlip: Iterable[int] | IntListKey = IntListKey(name='SpinFlip', comment='List here the atoms for which you want the initial spin polarization to be flipped. This way you can distinguish between ferromagnetic and anti ferromagnetic states. Currently, it is not allowed to give symmetry equivalent atoms a different spin orientation. To achieve that you have to break the symmetry.', gui_name='Flip spin for atoms:', isatomlist=True)
self.SpinFlipEnabled: BoolType | BoolKey = BoolKey(name='SpinFlipEnabled', comment='If set to False, the keys SpinFlip and SpinFlipRegion are ignored. Only useful/convenient when trying to compare in a script the effect of spin flip.', default=True)
self.SpinFlipRegion: str | StringKey = StringKey(name='SpinFlipRegion', comment='Specify here the region for which you want the initial spin polarization to be flipped. This way you can distinguish between ferromagnetic and anti ferromagnetic states. Currently, it is not allowed to give symmetry equivalent atoms a different spin orientation. To achieve that you have to break the symmetry.', unique=False, gui_name='Flip spin for region:', gui_type='region')
self.StartWithMaxSpin: BoolType | BoolKey = BoolKey(name='StartWithMaxSpin', comment='To break the initial perfect symmetry of up and down densities there are two strategies. One is to occupy the numerical orbitals in a maximum spin configuration. The alternative is to add a constant to the potential. See also Vsplit key.', default=True)
self.StartWithMaxSpinForSO: BoolType | BoolKey = BoolKey(name='StartWithMaxSpinForSO', comment='Same as the StartWithMaxSpin option. In case of spin-orbit band always used to split the potential. Now will use maxspin in case of SpinFlip. With this option it will always do that.', default=False)
self.Temperature: float | FloatKey = FloatKey(name='Temperature', comment='Undocumented', hidden=True, default=10.0)
[docs] class _DFTBConfinementPotential(FixedBlock):
r"""
Specify the confinement potentials (used for DFTB parametrization)
:ivar alpha: Undocumented.
:vartype alpha: float | FloatKey
:ivar exponent: Undocumented.
:vartype exponent: float | FloatKey
:ivar r0: Undocumented.
:vartype r0: float | FloatKey
"""
def __post_init__(self):
self.alpha: float | FloatKey = FloatKey(name='alpha', comment='Undocumented.', default=1.0)
self.exponent: float | FloatKey = FloatKey(name='exponent', comment='Undocumented.', default=1.0)
self.r0: float | FloatKey = FloatKey(name='r0', comment='Undocumented.', default=1.2345)
[docs] class _DIIS(FixedBlock):
r"""
Parameters for the DIIS procedure to obtain the SCF solution
:ivar Adaptable: Change automatically the value of dimix during the SCF.
:vartype Adaptable: BoolType | BoolKey
:ivar Alpha: Undocumented
:vartype Alpha: float | FloatKey
:ivar CHuge: When the largest coefficient in the DIIS expansion exceeds this value, damping is applied
:vartype CHuge: float | FloatKey
:ivar CLarge: When the largest DIIS coefficient exceeds this value, the oldest DIIS vector is removed and the procedure re-applied
:vartype CLarge: float | FloatKey
:ivar ComStr: Undocumented
:vartype ComStr: str | StringKey
:ivar Condition: The condition number of the DIIS matrix, the largest eigenvalue divided by the smallest, must not exceed this value. If this value is exceeded, this vector will be removed.
:vartype Condition: float | FloatKey
:ivar DiMix: Mixing parameter for the DIIS procedure
:vartype DiMix: float | FloatKey
:ivar DiMixMax: For adaptive diis: A negative value means automatic, see DiMixatnvctrx. If positive it is an absolute upper bound for (adaptive) dimix
:vartype DiMixMax: float | FloatKey
:ivar DiMixMin: An absolute lower bound for adaptive dimix.
:vartype DiMixMin: float | FloatKey
:ivar DiMixatnvctrx: Adaptive dimix. When only one vector is used the maximum is one, when the full history is used it is this value (Exponential decay).
:vartype DiMixatnvctrx: float | FloatKey
:ivar DiMixdecayfac: Undocumented
:vartype DiMixdecayfac: float | FloatKey
:ivar EDIIS: Use EDIIS
:vartype EDIIS: BoolType | BoolKey
:ivar EDIISModCycle: Undocumented
:vartype EDIISModCycle: int | IntKey
:ivar GrowthFactor: Undocumented
:vartype GrowthFactor: float | FloatKey
:ivar Method: Undocumented
:vartype Method: int | IntKey
:ivar NCycleDamp: Number of initial iterations where damping is applied, before any DIIS is considered
:vartype NCycleDamp: int | IntKey
:ivar NVctrx: Maximum number of DIIS expansion vectors
:vartype NVctrx: int | IntKey
:ivar NumAverage: Undocumented
:vartype NumAverage: int | IntKey
:ivar Print: Output printing level for DIIS
:vartype Print: int | IntKey
:ivar ShrinkFactor: Undocumented
:vartype ShrinkFactor: float | FloatKey
:ivar Variant: Which variant to use. In case of problematic SCF convergence, first try MultiSecant, and if that does not work the LISTi is the advised method. Note: LIST is computationally more expensive per SCF iteration than DIIS.
:vartype Variant: Literal["DIIS", "LISTi", "LISTb", "LISTd"]
"""
def __post_init__(self):
self.Adaptable: BoolType | BoolKey = BoolKey(name='Adaptable', comment='Change automatically the value of dimix during the SCF.', default=True)
self.Alpha: float | FloatKey = FloatKey(name='Alpha', comment='Undocumented', hidden=True, default=0.0)
self.CHuge: float | FloatKey = FloatKey(name='CHuge', comment='When the largest coefficient in the DIIS expansion exceeds this value, damping is applied', gui_name='No DIIS (but damping) when coefs >', default=20.0)
self.CLarge: float | FloatKey = FloatKey(name='CLarge', comment=' When the largest DIIS coefficient exceeds this value, the oldest DIIS vector is removed and the procedure re-applied', gui_name='Reduce DIIS space when coefs >', default=20.0)
self.ComStr: str | StringKey = StringKey(name='ComStr', comment='Undocumented', hidden=True, default=' ')
self.Condition: float | FloatKey = FloatKey(name='Condition', comment='The condition number of the DIIS matrix, the largest eigenvalue divided by the smallest, must not exceed this value. If this value is exceeded, this vector will be removed.', default=1000000.0)
self.DiMix: float | FloatKey = FloatKey(name='DiMix', comment='Mixing parameter for the DIIS procedure', gui_name='Bias DIIS towards latest vector with:', default=0.2)
self.DiMixMax: float | FloatKey = FloatKey(name='DiMixMax', comment='For adaptive diis: A negative value means automatic, see DiMixatnvctrx. If positive it is an absolute upper bound for (adaptive) dimix', default=-1.0)
self.DiMixMin: float | FloatKey = FloatKey(name='DiMixMin', comment='An absolute lower bound for adaptive dimix.', default=0.01)
self.DiMixatnvctrx: float | FloatKey = FloatKey(name='DiMixatnvctrx', comment='Adaptive dimix. When only one vector is used the maximum is one, when the full history is used it is this value (Exponential decay).', hidden=True, default=0.2)
self.DiMixdecayfac: float | FloatKey = FloatKey(name='DiMixdecayfac', comment='Undocumented', hidden=True, default=1.0)
self.EDIIS: BoolType | BoolKey = BoolKey(name='EDIIS', comment='Use EDIIS', hidden=True, default=False)
self.EDIISModCycle: int | IntKey = IntKey(name='EDIISModCycle', comment='Undocumented', hidden=True, default=1)
self.GrowthFactor: float | FloatKey = FloatKey(name='GrowthFactor', comment='Undocumented', hidden=True, default=1.1)
self.Method: int | IntKey = IntKey(name='Method', comment='Undocumented', hidden=True, default=1)
self.NCycleDamp: int | IntKey = IntKey(name='NCycleDamp', comment='Number of initial iterations where damping is applied, before any DIIS is considered', gui_name='Do not start DIIS before cycle:', default=1)
self.NVctrx: int | IntKey = IntKey(name='NVctrx', comment='Maximum number of DIIS expansion vectors', gui_name='Size of DIIS space:', default=20)
self.NumAverage: int | IntKey = IntKey(name='NumAverage', comment='Undocumented', hidden=True, default=1)
self.Print: int | IntKey = IntKey(name='Print', comment='Output printing level for DIIS', hidden=True, default=0)
self.ShrinkFactor: float | FloatKey = FloatKey(name='ShrinkFactor', comment='Undocumented', hidden=True, default=0.9090909091)
self.Variant: Literal["DIIS", "LISTi", "LISTb", "LISTd"] = MultipleChoiceKey(name='Variant', comment='Which variant to use. In case of problematic SCF convergence, first try MultiSecant, and if that does not work the LISTi is the advised method. Note: LIST is computationally more expensive per SCF iteration than DIIS.', default='DIIS', choices=['DIIS', 'LISTi', 'LISTb', 'LISTd'])
[docs] class _DIRIS(FixedBlock):
r"""
Same options as DIIS key, except that this one applies to the DIIS procedure used in the Dirac subprogram, for numerical single atom calculations, which constructs the radial tables for the NAOs.
:ivar adaptable: See DIIS.
:vartype adaptable: BoolType | BoolKey
:ivar alpha: See DIIS.
:vartype alpha: float | FloatKey
:ivar chuge: See DIIS.
:vartype chuge: float | FloatKey
:ivar clarge: See DIIS.
:vartype clarge: float | FloatKey
:ivar comstr: See DIIS.
:vartype comstr: str | StringKey
:ivar condition: See DIIS.
:vartype condition: float | FloatKey
:ivar dimix: See DIIS.
:vartype dimix: float | FloatKey
:ivar dimixdecayfac: See DIIS.
:vartype dimixdecayfac: float | FloatKey
:ivar ediis: See DIIS.
:vartype ediis: BoolType | BoolKey
:ivar ediismodcycle: See DIIS.
:vartype ediismodcycle: int | IntKey
:ivar method: See DIIS.
:vartype method: int | IntKey
:ivar ncycledamp: See DIIS.
:vartype ncycledamp: int | IntKey
:ivar numaverage: See DIIS.
:vartype numaverage: int | IntKey
:ivar nvctrx: See DIIS.
:vartype nvctrx: int | IntKey
:ivar potential: See DIIS.
:vartype potential: BoolType | BoolKey
:ivar print: See DIIS.
:vartype print: int | IntKey
:ivar variant: See DIIS.
:vartype variant: str | StringKey
"""
def __post_init__(self):
self.adaptable: BoolType | BoolKey = BoolKey(name='adaptable', comment='See DIIS.', default=False)
self.alpha: float | FloatKey = FloatKey(name='alpha', comment='See DIIS.', default=0.0)
self.chuge: float | FloatKey = FloatKey(name='chuge', comment='See DIIS.', default=50.0)
self.clarge: float | FloatKey = FloatKey(name='clarge', comment='See DIIS.', default=20.0)
self.comstr: str | StringKey = StringKey(name='comstr', comment='See DIIS.', default=' ')
self.condition: float | FloatKey = FloatKey(name='condition', comment='See DIIS.', default=1000000.0)
self.dimix: float | FloatKey = FloatKey(name='dimix', comment='See DIIS.', default=1.0)
self.dimixdecayfac: float | FloatKey = FloatKey(name='dimixdecayfac', comment='See DIIS.', default=1.0)
self.ediis: BoolType | BoolKey = BoolKey(name='ediis', comment='See DIIS.', default=False)
self.ediismodcycle: int | IntKey = IntKey(name='ediismodcycle', comment='See DIIS.', default=1)
self.method: int | IntKey = IntKey(name='method', comment='See DIIS.', default=1)
self.ncycledamp: int | IntKey = IntKey(name='ncycledamp', comment='See DIIS.', default=5)
self.numaverage: int | IntKey = IntKey(name='numaverage', comment='See DIIS.', default=1)
self.nvctrx: int | IntKey = IntKey(name='nvctrx', comment='See DIIS.', default=20)
self.potential: BoolType | BoolKey = BoolKey(name='potential', comment='See DIIS.', default=False)
self.print: int | IntKey = IntKey(name='print', comment='See DIIS.', default=0)
self.variant: str | StringKey = StringKey(name='variant', comment='See DIIS.', default='diis')
[docs] class _DOS(FixedBlock):
r"""
Density-Of-States (DOS) options
:ivar AbsoluteMaxMin: When DOS%Min and DOS%Max are used: should they be absolute or relative to the fermi level.
:vartype AbsoluteMaxMin: BoolType | BoolKey
:ivar CalcDOS: Whether or not to calculate the density of states.
:vartype CalcDOS: BoolType | BoolKey
:ivar CalcPDOS: Whether or not to calculate the partial DOS (projections on basis functions). This can be significantly more expensive than calculating the total DOS
:vartype CalcPDOS: BoolType | BoolKey
:ivar CalcPopulationAnalysis: Whether or not to calculate the population analysis. Population analysis can become very expensive when there are many symmetry operators, such as in a super cell.
:vartype CalcPopulationAnalysis: BoolType | BoolKey
:ivar CompensateDeltaE: Only relevant when IntegrateDeltaE=yes. If set to true then after integrating each interval over DeltaE the result is divided by DeltaE, so that the unit is DOS.
:vartype CompensateDeltaE: BoolType | BoolKey
:ivar DeltaE: Energy step for the DOS grid. Using a smaller value (e.g. half the default value) will result in a finer sampling of the DOS.
:vartype DeltaE: float | FloatKey
:ivar Enabled: Obsolete key whether or not to calculate the density of states.
:vartype Enabled: BoolType | BoolKey
:ivar Energies: Number of equidistant energy-values for the DOS grid. This keyword is superseded by the 'DeltaE' keyword.
:vartype Energies: int | IntKey
:ivar File: Write the DOS (plain text format) to the specified file instead of writing it to the standard output.
:vartype File: str | Path | StringKey
:ivar IntegrateDeltaE: This subkey handles which algorithm is used to calculate the data-points in the plotted DOS. If true, the data-points represent an integral over the states in an energy interval. Here, the energy interval depends on the number of Energies and the user-defined upper and lower energy for the calculation of the DOS. The result has as unit [number of states / (energy interval * unit cell)]. If false, the data-points do represent the number of states for a specific energy and the resulting plot is equal to the DOS per unit cell (unit: [1/energy]). Since the resulting plot can be a wild function and one might miss features of the DOS due to the step length between the energies, the default is set to the integration algorithm.
:vartype IntegrateDeltaE: BoolType | BoolKey
:ivar Max: User defined upper bound energy (with respect to the Fermi energy)
:vartype Max: float | FloatKey
:ivar MaxBandSliceSize: Undocumented.
:vartype MaxBandSliceSize: int | IntKey
:ivar MaxFuncSliceSize: Undocumented.
:vartype MaxFuncSliceSize: int | IntKey
:ivar Min: User defined lower bound energy (with respect to the Fermi energy)
:vartype Min: float | FloatKey
:ivar ReduceSymmetryOperatorsForIBZExpansion: To expand the eigensystem to the whole BZ either all or a minimal set can be used. If it can be reduced this is the faster option.
:vartype ReduceSymmetryOperatorsForIBZExpansion: BoolType | BoolKey
:ivar StoreCoopPerBasPair: Calculate the COOP (crystal orbital overlap population).
:vartype StoreCoopPerBasPair: BoolType | BoolKey
:ivar UseSharedArrays: Undocumented.
:vartype UseSharedArrays: BoolType | BoolKey
"""
def __post_init__(self):
self.AbsoluteMaxMin: BoolType | BoolKey = BoolKey(name='AbsoluteMaxMin', comment='When DOS%Min and DOS%Max are used: should they be absolute or relative to the fermi level.', hidden=True, default=False)
self.CalcDOS: BoolType | BoolKey = BoolKey(name='CalcDOS', comment='Whether or not to calculate the density of states.', gui_name='Calculate DOS:', default=True)
self.CalcPDOS: BoolType | BoolKey = BoolKey(name='CalcPDOS', comment='Whether or not to calculate the partial DOS (projections on basis functions). This can be significantly more expensive than calculating the total DOS', gui_name='Calculate PDOS:', default=False)
self.CalcPopulationAnalysis: BoolType | BoolKey = BoolKey(name='CalcPopulationAnalysis', comment='Whether or not to calculate the population analysis. Population analysis can become very expensive when there are many symmetry operators, such as in a super cell.', gui_name='Calculate Mulliken charges', default=True)
self.CompensateDeltaE: BoolType | BoolKey = BoolKey(name='CompensateDeltaE', comment='Only relevant when IntegrateDeltaE=yes. If set to true then after integrating each interval over DeltaE the result is divided by DeltaE, so that the unit is DOS.', default=True)
self.DeltaE: float | FloatKey = FloatKey(name='DeltaE', comment='Energy step for the DOS grid. Using a smaller value (e.g. half the default value) will result in a finer sampling of the DOS.', gui_name='Delta E:', default=0.005, unit='Hartree')
self.Enabled: BoolType | BoolKey = BoolKey(name='Enabled', comment='Obsolete key whether or not to calculate the density of states.', hidden=True, gui_name='Calculate DOS:', default=False)
self.Energies: int | IntKey = IntKey(name='Energies', comment="Number of equidistant energy-values for the DOS grid. This keyword is superseded by the 'DeltaE' keyword.")
self.File: str | Path | StringKey = PathStringKey(name='File', comment='Write the DOS (plain text format) to the specified file instead of writing it to the standard output.', ispath=True, gui_type='-inpath')
self.IntegrateDeltaE: BoolType | BoolKey = BoolKey(name='IntegrateDeltaE', comment='This subkey handles which algorithm is used to calculate the data-points in the plotted DOS. If true, the data-points represent an integral over the states in an energy interval. Here, the energy interval depends on the number of Energies and the user-defined upper and lower energy for the calculation of the DOS. The result has as unit [number of states / (energy interval * unit cell)]. If false, the data-points do represent the number of states for a specific energy and the resulting plot is equal to the DOS per unit cell (unit: [1/energy]). Since the resulting plot can be a wild function and one might miss features of the DOS due to the step length between the energies, the default is set to the integration algorithm.', default=True)
self.Max: float | FloatKey = FloatKey(name='Max', comment='User defined upper bound energy (with respect to the Fermi energy)', unit='Hartree')
self.MaxBandSliceSize: int | IntKey = IntKey(name='MaxBandSliceSize', comment='Undocumented.', hidden=True, default=32)
self.MaxFuncSliceSize: int | IntKey = IntKey(name='MaxFuncSliceSize', comment='Undocumented.', hidden=True, default=128)
self.Min: float | FloatKey = FloatKey(name='Min', comment='User defined lower bound energy (with respect to the Fermi energy)', unit='Hartree')
self.ReduceSymmetryOperatorsForIBZExpansion: BoolType | BoolKey = BoolKey(name='ReduceSymmetryOperatorsForIBZExpansion', comment='To expand the eigensystem to the whole BZ either all or a minimal set can be used. If it can be reduced this is the faster option.', hidden=True, default=True)
self.StoreCoopPerBasPair: BoolType | BoolKey = BoolKey(name='StoreCoopPerBasPair', comment='Calculate the COOP (crystal orbital overlap population).', gui_name='Calculate COOP:', default=False)
self.UseSharedArrays: BoolType | BoolKey = BoolKey(name='UseSharedArrays', comment='Undocumented.', hidden=True, default=True)
[docs] class _DensityPlot(FreeBlock):
r"""
Plots of the density. Goes together with the Restart%DensityPlot and Grid keys.
"""
def __post_init__(self):
pass
[docs] class _Dependency(FixedBlock):
r"""
Criteria for linear dependency of the basis and fit set
:ivar AllowBasisDependency: Project out the dependent part of the basis set (associated with small eigenvalues of the overlap matrix).
:vartype AllowBasisDependency: BoolType | BoolKey
:ivar Basis: Criteria for linear dependency of the basis: smallest eigenvalue of the overlap matrix of normalized Bloch functions.
:vartype Basis: float | FloatKey
:ivar Core: The program verifies that the frozen core approximation is reasonable, by checking the smallest eigen value of the overlap matrix of the core (Bloch) orbitals (which should ideally be one) is bigger than this criterion.
:vartype Core: float | FloatKey
:ivar CoreValence: Criterion for dependency of the core functions on the valence basis. The maximum overlap between any two normalized functions in the two respective function spaces should not exceed 1.0-corevalence
:vartype CoreValence: float | FloatKey
:ivar Fit: Criterion for dependency of the total set of fit functions. The value monitored is the smallest eigenvalue of the overlap matrix of normalized Bloch sums of symmetrized fit functions.
:vartype Fit: float | FloatKey
:ivar KeepShapeForDependencyFix: If AllowBasisDependency=true, this triggers the most simple fix, where all matrices retain their shape.
:vartype KeepShapeForDependencyFix: BoolType | BoolKey
"""
def __post_init__(self):
self.AllowBasisDependency: BoolType | BoolKey = BoolKey(name='AllowBasisDependency', comment='Project out the dependent part of the basis set (associated with small eigenvalues of the overlap matrix).', default=True)
self.Basis: float | FloatKey = FloatKey(name='Basis', comment='Criteria for linear dependency of the basis: smallest eigenvalue of the overlap matrix of normalized Bloch functions.', gui_name='Dependency criterion:', default=1e-08)
self.Core: float | FloatKey = FloatKey(name='Core', comment='The program verifies that the frozen core approximation is reasonable, by checking the smallest eigen value of the overlap matrix of the core (Bloch) orbitals (which should ideally be one) is bigger than this criterion.', default=0.8)
self.CoreValence: float | FloatKey = FloatKey(name='CoreValence', comment='Criterion for dependency of the core functions on the valence basis. The maximum overlap between any two normalized functions in the two respective function spaces should not exceed 1.0-corevalence', default=1e-05)
self.Fit: float | FloatKey = FloatKey(name='Fit', comment='Criterion for dependency of the total set of fit functions. The value monitored is the smallest eigenvalue of the overlap matrix of normalized Bloch sums of symmetrized fit functions.', default=5e-06)
self.KeepShapeForDependencyFix: BoolType | BoolKey = BoolKey(name='KeepShapeForDependencyFix', comment='If AllowBasisDependency=true, this triggers the most simple fix, where all matrices retain their shape.', hidden=True, default=False)
[docs] class _DiracOptions(FixedBlock):
r"""
Options for the atomic Dirac calculations.
:ivar DumpAllTables: Dump many functions during the SCF on a file call dirac.rkf. Works only for one atom. xxx
:vartype DumpAllTables: BoolType | BoolKey
:ivar UseDidervInDigradRel: For scalar zora dv/dr is used to get the analytical second derivative of the large component. It can also be obtained by numerical differentiation of dpsi/dr
:vartype UseDidervInDigradRel: BoolType | BoolKey
:ivar convergence: Convergence criterion, based on input/output density difference.
:vartype convergence: float | FloatKey
:ivar damping: Undocumented.
:vartype damping: float | FloatKey
:ivar maxcycles: Maximum number of self-consistent attempts to be made.
:vartype maxcycles: int | IntKey
:ivar rnuc: Undocumented.
:vartype rnuc: float | FloatKey
:ivar rwell: Undocumented.
:vartype rwell: float | FloatKey
:ivar spinor: Undocumented.
:vartype spinor: BoolType | BoolKey
:ivar vwell: Undocumented.
:vartype vwell: float | FloatKey
"""
def __post_init__(self):
self.DumpAllTables: BoolType | BoolKey = BoolKey(name='DumpAllTables', comment='Dump many functions during the SCF on a file call dirac.rkf. Works only for one atom. xxx', hidden=True, default=False)
self.UseDidervInDigradRel: BoolType | BoolKey = BoolKey(name='UseDidervInDigradRel', comment='For scalar zora dv/dr is used to get the analytical second derivative of the large component. It can also be obtained by numerical differentiation of dpsi/dr', hidden=True, default=False)
self.convergence: float | FloatKey = FloatKey(name='convergence', comment='Convergence criterion, based on input/output density difference.', default=1e-08)
self.damping: float | FloatKey = FloatKey(name='damping', comment='Undocumented.', default=0.65)
self.maxcycles: int | IntKey = IntKey(name='maxcycles', comment='Maximum number of self-consistent attempts to be made.', default=300)
self.rnuc: float | FloatKey = FloatKey(name='rnuc', comment='Undocumented.', default=0.0)
self.rwell: float | FloatKey = FloatKey(name='rwell', comment='Undocumented.', default=0.0)
self.spinor: BoolType | BoolKey = BoolKey(name='spinor', comment='Undocumented.', default=False)
self.vwell: float | FloatKey = FloatKey(name='vwell', comment='Undocumented.', default=0.0)
[docs] class _Dispersion(FixedBlock):
r"""
Technical options for dispersion-corrected functionals.
:ivar CutOffDistance: Undocumented
:vartype CutOffDistance: float | FloatKey
"""
def __post_init__(self):
self.CutOffDistance: float | FloatKey = FloatKey(name='CutOffDistance', comment='Undocumented', default=100.0)
[docs] class _DosBas(FreeBlock):
r"""
Used to specify the fragment basis for the DOS.
"""
def __post_init__(self):
pass
[docs] class _EFG(FixedBlock):
r"""
The electronic charge density causes an electric field, and the gradient of this field couples with the nuclear quadrupole moment, that some (non-spherical) nuclei have and can be measured by several spectroscopic techniques. The EFG tensor is the second derivative of the Coulomb potential at the nuclei. For each atom it is a 3x3 symmetric and traceless matrix. Diagonalization of this matrix gives three eigenvalues, which are usually ordered by their decreasing absolute size and denoted as V_{xx}, V_{yy}, V_{zz}. The result is summarized by the largest eigenvalue and the asymmetry parameter.
:ivar Enabled: Compute the EFG tensor (for nuclear quadrupole interaction).
:vartype Enabled: BoolType | BoolKey
"""
def __post_init__(self):
self.Enabled: BoolType | BoolKey = BoolKey(name='Enabled', comment='Compute the EFG tensor (for nuclear quadrupole interaction).', gui_name='EFG (electric field gradient): Calculate', default=False)
[docs] class _ESR(FixedBlock):
r"""
Zeeman g-tensor. The Zeeman g-tensor is implemented using two-component approach of Van Lenthe and co-workers in which the g-tensor is computed from a pair of spinors related to each other by time-reversal symmetry. Note: the following options are necessary for ESR: 'Relativistic zora spin' and 'Kspace 1'
:ivar Enabled: Compute Zeeman g-tensor.
The Zeeman g-tensor is implemented using two-component approach of Van Lenthe and co-workers in which the g-tensor is computed from a pair of spinors related to each other by time-reversal symmetry.
Note: the following options are necessary for ESR: 'Relativistic zora spin' and 'Kspace 1'
:vartype Enabled: BoolType | BoolKey
"""
def __post_init__(self):
self.Enabled: BoolType | BoolKey = BoolKey(name='Enabled', comment="Compute Zeeman g-tensor.\n\nThe Zeeman g-tensor is implemented using two-component approach of Van Lenthe and co-workers in which the g-tensor is computed from a pair of spinors related to each other by time-reversal symmetry.\n\nNote: the following options are necessary for ESR: 'Relativistic zora spin' and 'Kspace 1'", gui_name='ESR: g-tensor', default=False)
[docs] class _EffectiveMass(FixedBlock):
r"""
In a semi-conductor, the mobility of electrons and holes is related to the curvature of the bands at the top of the valence band and the bottom of the conduction band.
With the effective mass option, this curvature is obtained by numerical differentiation.
The estimation is done with the specified step size, and twice the specified step size, and both results are printed to give a hint on the accuracy. The easiest way to use this key is to enabled it without specifying any extra options.
:ivar Enabled: Compute the EffectiveMass.
:vartype Enabled: BoolType | BoolKey
:ivar KPointCoord: Coordinate of the k-points for which you would like to compute the effective mass.
:vartype KPointCoord: Iterable[float] | FloatListKey
:ivar NumAbove: Number of bands to take into account above the Fermi level.
:vartype NumAbove: int | IntKey
:ivar NumBelow: Number of bands to take into account below the Fermi level.
:vartype NumBelow: int | IntKey
:ivar StepSize: Size of the step taken in reciprocal space to perform the numerical differentiation
:vartype StepSize: float | FloatKey
:ivar UseBandStructureInfoFromPath: The (automatic) location of the HOMO and LUMO can be determined via band interpolation, or from the path as used by the BandStructure feature. The latter works better when they are located on the path. See also comments in the BandStructure block. To reproduce results from before ams2025 set to no.
:vartype UseBandStructureInfoFromPath: BoolType | BoolKey
"""
def __post_init__(self):
self.Enabled: BoolType | BoolKey = BoolKey(name='Enabled', comment='Compute the EffectiveMass.', gui_name='Effective mass:', default=False)
self.KPointCoord: Iterable[float] | FloatListKey = FloatListKey(name='KPointCoord', comment='Coordinate of the k-points for which you would like to compute the effective mass.', unique=False, gui_name='At K-point:', unit='1/Bohr')
self.NumAbove: int | IntKey = IntKey(name='NumAbove', comment='Number of bands to take into account above the Fermi level.', gui_name='Include N bands above:', default=1)
self.NumBelow: int | IntKey = IntKey(name='NumBelow', comment='Number of bands to take into account below the Fermi level.', gui_name='Include N bands below:', default=1)
self.StepSize: float | FloatKey = FloatKey(name='StepSize', comment='Size of the step taken in reciprocal space to perform the numerical differentiation', default=0.001)
self.UseBandStructureInfoFromPath: BoolType | BoolKey = BoolKey(name='UseBandStructureInfoFromPath', comment='The (automatic) location of the HOMO and LUMO can be determined via band interpolation, or from the path as used by the BandStructure feature. The latter works better when they are located on the path. See also comments in the BandStructure block. To reproduce results from before ams2025 set to no.', default=True)
[docs] class _ElectronHole(FixedBlock):
r"""
Allows one to specify an occupied band which shall be depopulated, where the electrons are then moved to the Fermi level. For a spin-restricted calculation 2 electrons are shifted and for a spin-unrestricted calculation only one electron is shifted.
:ivar BandIndex: Which occupied band shall be depopulated.
:vartype BandIndex: int | IntKey
:ivar SpinIndex: Defines the spin of the shifted electron (1 or 2).
:vartype SpinIndex: int | IntKey
"""
def __post_init__(self):
self.BandIndex: int | IntKey = IntKey(name='BandIndex', comment='Which occupied band shall be depopulated.')
self.SpinIndex: int | IntKey = IntKey(name='SpinIndex', comment='Defines the spin of the shifted electron (1 or 2).')
[docs] class _EmbeddingPotential(FixedBlock):
r"""
An external potential can be read in and will be added to the effective Kohn-Sham potential. It has to be on the becke grid
:ivar Filename: Name of the file containing the embedding potential.
:vartype Filename: str | StringKey
:ivar PotentialName: Name of variable containing the potential.
:vartype PotentialName: str | StringKey
"""
def __post_init__(self):
self.Filename: str | StringKey = StringKey(name='Filename', comment='Name of the file containing the embedding potential.', default=' ')
self.PotentialName: str | StringKey = StringKey(name='PotentialName', comment='Name of variable containing the potential.', default=' ')
[docs] class _Excitations(FixedBlock):
r"""
Excitation energies: UV/Vis
:ivar BSE: Solve the static Bethe-Salpeter equation based on a GW calculation
:vartype BSE: BoolType | BoolKey
"""
def __post_init__(self):
self.BSE: BoolType | BoolKey = BoolKey(name='BSE', comment='Solve the static Bethe-Salpeter equation based on a GW calculation', hidden=True, default=False)
[docs] class _Fermi(FixedBlock):
r"""
Technical parameter used in determining the Fermi energy, which is carried out at each cycle of the SCF procedure.
:ivar Delta: Convergence criterion: upper and lower bounds for the Fermi energy and the corresponding integrated charge volumes must be equal within delta.
:vartype Delta: float | FloatKey
:ivar Eps: After convergence of the Fermi energy search procedure, a final estimate is defined by interpolation and the corresponding integrated charge volume is tested. It should be exact, to machine precision. Tested is that it deviates not more than eps.
:vartype Eps: float | FloatKey
:ivar MaxTry: Maximum number of attempts to locate the Fermi energy. The procedure is iterative in nature, narrowing the energy band in which the Fermi energy must lie, between an upper and a lower bound. If the procedure has not converged sufficiently within MaxTry iterations, the program takes a reasonable value and constructs the charge density by interpolation between the functions corresponding to the last used upper and lower bounds for the Fermi energy.
:vartype MaxTry: int | IntKey
:ivar RefinePostSCFFactor: Use a finer k-grid after the scf to calculate a refined fermi level. Makes only sense for metals. Works like DoubleCount. Use 1,2,3
:vartype RefinePostSCFFactor: int | IntKey
"""
def __post_init__(self):
self.Delta: float | FloatKey = FloatKey(name='Delta', comment='Convergence criterion: upper and lower bounds for the Fermi energy and the corresponding integrated charge volumes must be equal within delta.', default=0.0001)
self.Eps: float | FloatKey = FloatKey(name='Eps', comment='After convergence of the Fermi energy search procedure, a final estimate is defined by interpolation and the corresponding integrated charge volume is tested. It should be exact, to machine precision. Tested is that it deviates not more than eps.', default=1e-10)
self.MaxTry: int | IntKey = IntKey(name='MaxTry', comment='Maximum number of attempts to locate the Fermi energy. The procedure is iterative in nature, narrowing the energy band in which the Fermi energy must lie, between an upper and a lower bound. If the procedure has not converged sufficiently within MaxTry iterations, the program takes a reasonable value and constructs the charge density by interpolation between the functions corresponding to the last used upper and lower bounds for the Fermi energy.', default=15)
self.RefinePostSCFFactor: int | IntKey = IntKey(name='RefinePostSCFFactor', comment='Use a finer k-grid after the scf to calculate a refined fermi level. Makes only sense for metals. Works like DoubleCount. Use 1,2,3')
[docs] class _FermiSurface(FixedBlock):
r"""
Calculation of the Fermi surface for metals
:ivar AvoidDuplicates: Undocumented.
:vartype AvoidDuplicates: BoolType | BoolKey
:ivar CaseA: Undocumented.
:vartype CaseA: BoolType | BoolKey
:ivar CaseB: Undocumented.
:vartype CaseB: BoolType | BoolKey
:ivar CaseC: Undocumented.
:vartype CaseC: BoolType | BoolKey
:ivar ConjugateGradient: Undocumented.
:vartype ConjugateGradient: BoolType | BoolKey
:ivar Enabled: Calculate the Fermi surface if the system has no band gap (i.e. is a metal). The result can be visualized with amsbands.
:vartype Enabled: BoolType | BoolKey
:ivar KIntegForSymmetricKGrid: If the (default) regular k-grid is used, a symmetric one is created to determine the Fermi surface. If this key is not specified an automatic value of kInteg is used. Odd values trigger quadratic interpolation.
:vartype KIntegForSymmetricKGrid: int | IntKey
:ivar NMesh: Improves the matching of the interpolated quadratic surface. For better results it makes more sense to increases KIntegForSymmetricKGrid.
:vartype NMesh: int | IntKey
:ivar Symmetry: Undocumented.
:vartype Symmetry: str | StringKey
:ivar UniqueWedgeOnly: Undocumented.
:vartype UniqueWedgeOnly: BoolType | BoolKey
"""
def __post_init__(self):
self.AvoidDuplicates: BoolType | BoolKey = BoolKey(name='AvoidDuplicates', comment='Undocumented.', hidden=True, default=True)
self.CaseA: BoolType | BoolKey = BoolKey(name='CaseA', comment='Undocumented.', hidden=True, default=True)
self.CaseB: BoolType | BoolKey = BoolKey(name='CaseB', comment='Undocumented.', hidden=True, default=True)
self.CaseC: BoolType | BoolKey = BoolKey(name='CaseC', comment='Undocumented.', hidden=True, default=True)
self.ConjugateGradient: BoolType | BoolKey = BoolKey(name='ConjugateGradient', comment='Undocumented.', hidden=True)
self.Enabled: BoolType | BoolKey = BoolKey(name='Enabled', comment='Calculate the Fermi surface if the system has no band gap (i.e. is a metal). The result can be visualized with amsbands.', gui_name='Calculate Fermi surface:', default=False)
self.KIntegForSymmetricKGrid: int | IntKey = IntKey(name='KIntegForSymmetricKGrid', comment='If the (default) regular k-grid is used, a symmetric one is created to determine the Fermi surface. If this key is not specified an automatic value of kInteg is used. Odd values trigger quadratic interpolation.', default=-1)
self.NMesh: int | IntKey = IntKey(name='NMesh', comment='Improves the matching of the interpolated quadratic surface. For better results it makes more sense to increases KIntegForSymmetricKGrid.', default=7)
self.Symmetry: str | StringKey = StringKey(name='Symmetry', comment='Undocumented.', hidden=True)
self.UniqueWedgeOnly: BoolType | BoolKey = BoolKey(name='UniqueWedgeOnly', comment='Undocumented.', hidden=True, default=False)
[docs] class _FitMethod(FixedBlock):
r"""
Undocumented
:ivar ConstrainCharge: Undocumented
:vartype ConstrainCharge: BoolType | BoolKey
:ivar ConstrainWiths: Undocumented
:vartype ConstrainWiths: BoolType | BoolKey
:ivar Divide: Undocumented
:vartype Divide: str | StringKey
:ivar Method: Undocumented
:vartype Method: str | StringKey
:ivar PruneDivisions: Undocumented
:vartype PruneDivisions: BoolType | BoolKey
:ivar RScale: Undocumented
:vartype RScale: float | FloatKey
:ivar RepeatDivisions: Undocumented
:vartype RepeatDivisions: BoolType | BoolKey
:ivar StoreFinalFitTra: Undocumented
:vartype StoreFinalFitTra: BoolType | BoolKey
:ivar UseSharedarrays: Undocumented
:vartype UseSharedarrays: BoolType | BoolKey
"""
def __post_init__(self):
self.ConstrainCharge: BoolType | BoolKey = BoolKey(name='ConstrainCharge', comment='Undocumented', default=True)
self.ConstrainWiths: BoolType | BoolKey = BoolKey(name='ConstrainWiths', comment='Undocumented', default=True)
self.Divide: str | StringKey = StringKey(name='Divide', comment='Undocumented', default='cluster')
self.Method: str | StringKey = StringKey(name='Method', comment='Undocumented', default='automatic')
self.PruneDivisions: BoolType | BoolKey = BoolKey(name='PruneDivisions', comment='Undocumented', default=True)
self.RScale: float | FloatKey = FloatKey(name='RScale', comment='Undocumented', default=1.3)
self.RepeatDivisions: BoolType | BoolKey = BoolKey(name='RepeatDivisions', comment='Undocumented', default=False)
self.StoreFinalFitTra: BoolType | BoolKey = BoolKey(name='StoreFinalFitTra', comment='Undocumented', default=False)
self.UseSharedarrays: BoolType | BoolKey = BoolKey(name='UseSharedarrays', comment='Undocumented', default=True)
[docs] class _FracOp(FixedBlock):
r"""
Parameters from input for fractional occupations
:ivar Criterion: Undocumented
:vartype Criterion: float | FloatKey
:ivar Dirac: Undocumented
:vartype Dirac: BoolType | BoolKey
:ivar Gammix: Undocumented
:vartype Gammix: float | FloatKey
:ivar Maxgam: Undocumented
:vartype Maxgam: int | IntKey
:ivar Maxscf: Undocumented
:vartype Maxscf: int | IntKey
:ivar Print: Undocumented
:vartype Print: int | IntKey
:ivar SCF: Undocumented
:vartype SCF: BoolType | BoolKey
"""
def __post_init__(self):
self.Criterion: float | FloatKey = FloatKey(name='Criterion', comment='Undocumented', default=0.02)
self.Dirac: BoolType | BoolKey = BoolKey(name='Dirac', comment='Undocumented', default=False)
self.Gammix: float | FloatKey = FloatKey(name='Gammix', comment='Undocumented', default=0.0)
self.Maxgam: int | IntKey = IntKey(name='Maxgam', comment='Undocumented', default=5)
self.Maxscf: int | IntKey = IntKey(name='Maxscf', comment='Undocumented', default=4)
self.Print: int | IntKey = IntKey(name='Print', comment='Undocumented', default=1)
self.SCF: BoolType | BoolKey = BoolKey(name='SCF', comment='Undocumented', default=False)
[docs] class _FragOccupations(FreeBlock):
r"""
Undocumented
"""
def __post_init__(self):
pass
[docs] class _Fragment(FixedBlock):
r"""
Defines a fragment. You can define several fragments for a calculation.
:ivar Filename: Filename of the fragment. Absolute path or path relative to the executing directory.
:vartype Filename: str | StringKey
:ivar Region: Region name.
:vartype Region: str | StringKey
:ivar AtomMapping: Format 'indexFragAt indexCurrentAt'. One has to associate the atoms of the fragment to the atoms of the current calculation. So, for each atom of the fragment the indexFragAt has to be associated uniquely to the indexCurrentAt for the current calculation.
:vartype AtomMapping: str | Sequence[str] | FreeBlock
:ivar Labels: This gives the possibility to introduce labels for the fragment orbitals. See examples.
:vartype Labels: str | Sequence[str] | FreeBlock
"""
[docs] class _AtomMapping(FreeBlock):
r"""
Format 'indexFragAt indexCurrentAt'. One has to associate the atoms of the fragment to the atoms of the current calculation. So, for each atom of the fragment the indexFragAt has to be associated uniquely to the indexCurrentAt for the current calculation.
"""
def __post_init__(self):
pass
[docs] class _Labels(FreeBlock):
r"""
This gives the possibility to introduce labels for the fragment orbitals. See examples.
"""
def __post_init__(self):
pass
def __post_init__(self):
self.Filename: str | StringKey = StringKey(name='Filename', comment='Filename of the fragment. Absolute path or path relative to the executing directory.')
self.Region: str | StringKey = StringKey(name='Region', comment='Region name.')
self.AtomMapping: str | Sequence[str] | FreeBlock = self._AtomMapping(name='AtomMapping', comment="Format 'indexFragAt indexCurrentAt'. One has to associate the atoms of the fragment to the atoms of the current calculation. So, for each atom of the fragment the indexFragAt has to be associated uniquely to the indexCurrentAt for the current calculation.")
self.Labels: str | Sequence[str] | FreeBlock = self._Labels(name='Labels', comment='This gives the possibility to introduce labels for the fragment orbitals. See examples.')
[docs] class _FragmentEnergyTerms(FreeBlock):
r"""
Undocumented
"""
def __post_init__(self):
pass
[docs] class _FuzzyPotential(FreeBlock):
r"""
Atomic (fuzzy cell) based, external, electric potential. See example.
"""
def __post_init__(self):
pass
[docs] class _FuzzyUnitCellGrid(FixedBlock):
r"""
Undocumented.
:ivar AtomRadiusLSG: Undocumented.
:vartype AtomRadiusLSG: float | FloatKey
:ivar CellPartitionDelta: Undocumented.
:vartype CellPartitionDelta: float | FloatKey
:ivar CellPartitionInterpolationCubic: Undocumented.
:vartype CellPartitionInterpolationCubic: BoolType | BoolKey
:ivar CellPartitionInterpolationMesh: Undocumented.
:vartype CellPartitionInterpolationMesh: int | IntKey
:ivar CellPartitionVersion: Undocumented.
:vartype CellPartitionVersion: int | IntKey
:ivar CentralizeNaturalLSG: Undocumented.
:vartype CentralizeNaturalLSG: BoolType | BoolKey
:ivar InterpolateCellPartition: Undocumented.
:vartype InterpolateCellPartition: BoolType | BoolKey
:ivar NumIntExtraL: Undocumented.
:vartype NumIntExtraL: int | IntKey
:ivar NumIntExtraRad: Undocumented.
:vartype NumIntExtraRad: int | IntKey
:ivar PartitionFunctionTol: Undocumented.
:vartype PartitionFunctionTol: float | FloatKey
:ivar PruneLatticeSummedGrid: Undocumented.
:vartype PruneLatticeSummedGrid: BoolType | BoolKey
:ivar ReduceAccuracyLSG: Undocumented.
:vartype ReduceAccuracyLSG: BoolType | BoolKey
:ivar SimpleLatticeSummedGrid: Undocumented.
:vartype SimpleLatticeSummedGrid: BoolType | BoolKey
"""
def __post_init__(self):
self.AtomRadiusLSG: float | FloatKey = FloatKey(name='AtomRadiusLSG', comment='Undocumented.', default=0.0)
self.CellPartitionDelta: float | FloatKey = FloatKey(name='CellPartitionDelta', comment='Undocumented.', default=4.0)
self.CellPartitionInterpolationCubic: BoolType | BoolKey = BoolKey(name='CellPartitionInterpolationCubic', comment='Undocumented.', default=False)
self.CellPartitionInterpolationMesh: int | IntKey = IntKey(name='CellPartitionInterpolationMesh', comment='Undocumented.', default=100)
self.CellPartitionVersion: int | IntKey = IntKey(name='CellPartitionVersion', comment='Undocumented.', default=2)
self.CentralizeNaturalLSG: BoolType | BoolKey = BoolKey(name='CentralizeNaturalLSG', comment='Undocumented.', default=False)
self.InterpolateCellPartition: BoolType | BoolKey = BoolKey(name='InterpolateCellPartition', comment='Undocumented.', default=False)
self.NumIntExtraL: int | IntKey = IntKey(name='NumIntExtraL', comment='Undocumented.', default=0)
self.NumIntExtraRad: int | IntKey = IntKey(name='NumIntExtraRad', comment='Undocumented.', default=0)
self.PartitionFunctionTol: float | FloatKey = FloatKey(name='PartitionFunctionTol', comment='Undocumented.', default=1e-08)
self.PruneLatticeSummedGrid: BoolType | BoolKey = BoolKey(name='PruneLatticeSummedGrid', comment='Undocumented.', default=True)
self.ReduceAccuracyLSG: BoolType | BoolKey = BoolKey(name='ReduceAccuracyLSG', comment='Undocumented.', default=False)
self.SimpleLatticeSummedGrid: BoolType | BoolKey = BoolKey(name='SimpleLatticeSummedGrid', comment='Undocumented.', default=False)
[docs] class _GMix(FixedBlock):
r"""
Undocumented. Old NEGF.
:ivar ExtraMix: Undocumented.
:vartype ExtraMix: float | FloatKey
:ivar MinMix: Undocumented.
:vartype MinMix: float | FloatKey
:ivar StopMix: Undocumented.
:vartype StopMix: int | IntKey
"""
def __post_init__(self):
self.ExtraMix: float | FloatKey = FloatKey(name='ExtraMix', comment='Undocumented.', default=1.0)
self.MinMix: float | FloatKey = FloatKey(name='MinMix', comment='Undocumented.', default=0.0)
self.StopMix: int | IntKey = IntKey(name='StopMix', comment='Undocumented.', default=1000)
[docs] class _GW(FixedBlock):
r"""
Perform a GW calculation. G0W0 is the default for GW%SelfConsistency.
:ivar AdaptiveMixing: Requests to use adaptive mixing instead of DIIS and sets the staring mixing parameter for mixing of Green's function in case of self-consistency.
Adapative mixing is recommended in case a qsGW calculation does not converge with DIIS.
It is ignored in non-selfconsistent calculation and overwritten by DIIS when DIIS is also present.
:vartype AdaptiveMixing: Iterable[float] | FloatListKey
:ivar DIIS: Requests to use DIIS. This is the Default. Number of expansion coefficients can be requested as well. Ignored in non-selfconsistent calculation
:vartype DIIS: int | IntKey
:ivar Enabled: Enable the calculation of the GW quasi-particle energies.
:vartype Enabled: BoolType | BoolKey
:ivar ExpansionOrder: Order of the expansion of the screened interaction on the SOS-GF(n) method. order 2 (=SOS-GF2) is the default
:vartype ExpansionOrder: int | IntKey
:ivar FixedGridSizes: In a self-consistent GW calculation, recalculate Grids but keep them the same size during the SCF procedure.
:vartype FixedGridSizes: BoolType | BoolKey
:ivar FixedGrids: In a self-consistent GW calculation, do not recalculate Grids. Can be useful in case of convergence problems. Only relevant for qsGW and qsGW0. In case of evGW and evGW0, the grids are always kept fixed.
:vartype FixedGrids: BoolType | BoolKey
:ivar G3W2: Only relevant when self-energy is one of GF2 or G3W2: Full requests that the second-order term is evaluated for the full self-energy matrix. This is very expensive and should only be done for small systems. Diagonal requests, that only the Diagonal of the self-energy matrix is updated. Perturbative means, that only a second-order screened exchange correction is evaluated after the GW calculation is completed. For a G0W0 calculation, all of these options are equivalent.
:vartype G3W2: Literal["Full", "Diagonal", "Perturbative"]
:ivar LinearMixing: Requests to use linear mixing instead of DIIS and sets the mixing parameter for linear mixing of Green's function in case of self-consistency.
It is ignored in non-selfconsistent calculation and overwritten by DIIS when DIIS is also present.
:vartype LinearMixing: Iterable[float] | FloatListKey
:ivar LinearizeQPequations: Instead of solving the non-linear QP equations in a G0W0 (or evGW calculation) by bisection exacly, linearize them by first-order Taylor expansion.
This is not recommended since it does not save computational time when used together with analytical continuation (as implemented in AMS). It might however be useful for benchmarking or for validating results.
If the results os the linearization differ by a lot (for instance, more than 0.1 eV in frontier QP energies) from the non-linearized results, this might indicate that the GW calculation is not reliable.
:vartype LinearizeQPequations: BoolType | BoolKey
:ivar OffDiagonalEFermi: Analytically continue the off-diagonal elements of the KSF2 qsGW Hamiltonian at the Fermi-energy instead of omega=0. Typically leads to slightly lower QP energies, i.e. higher ionization potentials. The HOMO-LUMO gaps are typically not affected.
:vartype OffDiagonalEFermi: BoolType | BoolKey
:ivar Polarizability: Sets the expression for the Polarizability used in the GW calculation.
RPA is the Default and amounts to a standard GW calculation.
BSE denotes screening in the Bethe-Salpeter-equation formalism.
:vartype Polarizability: Literal["RPA", "BSE", "G4W1", "G4V1", "TDHF"]
:ivar PrintAllSolutions: Print out all solutions for all requested states. Detects multiple solutions of the QP equations.
:vartype PrintAllSolutions: BoolType | BoolKey
:ivar PrintImaginaryAxisData: If true, print out the self-energy on the imaginary axis.
:vartype PrintImaginaryAxisData: BoolType | BoolKey
:ivar PrintSpectralFunction: Plot the self-energy as a function of frequency. Automatically done in case of analytical continuation. However, this is expensive in the analytical integration formalism.
:vartype PrintSpectralFunction: BoolType | BoolKey
:ivar PrintZfactor:
:vartype PrintZfactor: BoolType | BoolKey
:ivar QPHamiltonian: The quasi-particle Hamiltonian can be constructed in different ways.
KSF1 refers to the original construction by Kotani, Van Schilfgaarde anf Faleev (KSF) which is also implemented in TURBOMOLE.
KSF2 refers to an alternative construction by KSF.
KSF1 is not recommended since it is numerically less stable than KSF2 in case analytical continuation is used (the default).
In case the analytical integration algorithm is used, only KSF1 is implemented. Therefore, make sure that KSF1 is specified. The results are typically very similar.
The QP energies at which the matrix elements are evaluated can be tweaked further, see the two subsequent keys: However, KSF2 is recommended since it typically leads to QP energies with the best agreement with experiment.
Ignored when not a quasi-particle self-consistent GW calculation is performed
:vartype QPHamiltonian: Literal["KSF1", "KSF2", "SRG", "LQSGW"]
:ivar Scaling: Scale factor for the polarizability in the screened interaction SOS-GF2. Default = 1.0 (corresponds to no scaling)
:vartype Scaling: float | FloatKey
:ivar ScissorShift: Only calculate the HOMO and LUMO QP energies and shift the remaining QP energies by the same amount.
This is a rather crude approximation and not recommended.
It might again be useful for benchmarking purposes.
:vartype ScissorShift: BoolType | BoolKey
:ivar SelfConsistency: Sets the level of self-consistency in a GW calculation.
G0W0 calculates a one-shot, perturbative correction to the KS eigenvalues.
In evGW and evGW0, the quasi-particle energies are updated until self-consistency is reached.
evGW0 requests that the Green's function is evaluated self-consistently but not the screened interaction.
In qsGW, the density is updated as well, however, the self-energy is mapped to a static effective potential and the Dyson equation is solved by diagonalization instead of inversion. The results of a qsGW are independent of the choice of the underlying exchange-correlation functional and are usually the most accurate ones.
The same is done in qsGW0, but the screened interaction is not updated.
:vartype SelfConsistency: Literal["None", "G0W0", "EVGW0", "EVGW", "QSGW0", "QSGW"]
:ivar SelfConsistentSigmaVertex: If active, evaluate the vertex correction in Sigma in qsGW self-consistent. Only supported for GWGammaInf so far
:vartype SelfConsistentSigmaVertex: BoolType | BoolKey
:ivar SelfEnergy: Controls the form of the self-energy.
GW is the default and corresponds to the standard GW calculation.
G3W2 is a GW calculation plus a perturbative second-order statically screened exchange correction (second order expansion in the self-energy). Note, that there the self-energy is always static.
:vartype SelfEnergy: Literal["HF", "GW", "G3W2", "SOSEX", "GWGamma", "G3W2dynamic", "GWGammaInf", "GWGammaInfDyn"]
:ivar TabulateGridPoints: pretabulate grid points for numerical integration.
:vartype TabulateGridPoints: BoolType | BoolKey
:ivar nIterations: The maximum number of iterations within the (partially or fully) self-consistent GW calculation has to converge.
Ignored when Formalism is set to G0W0
:vartype nIterations: Iterable[int] | IntListKey
:ivar nLowest: Number of lowest occupied QP levels to be evaluated, overwrites nStates'
:vartype nLowest: int | IntKey
:ivar nStates: Number of Quasiparticle States to be printed to output.
The default is 5 states which in this case means that min(5, Number of particle states) occupied and min(5, Number of hole states) hole states are printed. The whole list of states can be printed by setting this parameter to -1'
:vartype nStates: int | IntKey
:ivar preconditionQSGW: If true, the QSGW equations are solved but prior to each diagonalization, i.e. a G0W0 calculation is performed to find the optimal QP energies at which to analytically continue the self-energy.
This is in principle a more consistent construction than KSF1 or KSF2 since the diagonal elements are consistent with G0W0.
In KSF1 and KSF2, the diagonal elements are evaluated at the QP energies from the previous iteration which is equivalent to a zeroth-order Taylor expansion of the diagonal elements around the previous QP energies.\Enabling this option typically leads to slightly lower QP energies.
:vartype preconditionQSGW: BoolType | BoolKey
:ivar AnalyticalIntegration: Use analytical integration to calculate the self-energy. Very slow, unless the system is very small but useful to check the accuracy of the frequency integration
:vartype AnalyticalIntegration: BAND._GW._AnalyticalIntegration
:ivar Converge: Sets convergence criteria for the GW calculation in self-consistent case
:vartype Converge: BAND._GW._Converge
"""
[docs] class _AnalyticalIntegration(FixedBlock):
r"""
Use analytical integration to calculate the self-energy. Very slow, unless the system is very small but useful to check the accuracy of the frequency integration
:ivar Enabled: Enable the calculation of the GW quasi-particle energies via analytical integration.
:vartype Enabled: BoolType | BoolKey
:ivar SpectralFunctionResolution: Number of points at which spectral function is evaluated.
:vartype SpectralFunctionResolution: int | IntKey
:ivar TDA: Solve the linear response equations in the Tamm-Dancoff approximation.
:vartype TDA: BoolType | BoolKey
:ivar eta: Artificial (positive) broadening parameter for evaluation of self-energy in analytical integration.
Ideally should be as small as possible but this might lead to convergence issues in partially self-consistent approaches.
In this case, a value of up to 0.1 is possible.
:vartype eta: float | FloatKey
:ivar printBSEexcitationsInLastIteration: Print out BSE excitations in the last iteration in a qsGW calculation. Can be used in the BAND engine.
In ADF, one should instead just calculate excitation energies using the excitation block.
:vartype printBSEexcitationsInLastIteration: BoolType | BoolKey
"""
def __post_init__(self):
self.Enabled: BoolType | BoolKey = BoolKey(name='Enabled', comment='Enable the calculation of the GW quasi-particle energies via analytical integration.', gui_name='analytical integration:', default=False)
self.SpectralFunctionResolution: int | IntKey = IntKey(name='SpectralFunctionResolution', comment='Number of points at which spectral function is evaluated.', default=800)
self.TDA: BoolType | BoolKey = BoolKey(name='TDA', comment='Solve the linear response equations in the Tamm-Dancoff approximation.', default=False)
self.eta: float | FloatKey = FloatKey(name='eta', comment='Artificial (positive) broadening parameter for evaluation of self-energy in analytical integration.\n\nIdeally should be as small as possible but this might lead to convergence issues in partially self-consistent approaches.\n\nIn this case, a value of up to 0.1 is possible.', default=0.001)
self.printBSEexcitationsInLastIteration: BoolType | BoolKey = BoolKey(name='printBSEexcitationsInLastIteration', comment='Print out BSE excitations in the last iteration in a qsGW calculation. Can be used in the BAND engine.\n\nIn ADF, one should instead just calculate excitation energies using the excitation block.', hidden=True, default=False)
[docs] class _Converge(FixedBlock):
r"""
Sets convergence criteria for the GW calculation in self-consistent case
:ivar Density: First Criterion for self-consistency procedure to terminate.
Criterion is the trace of the density matrix. Ignored in non-selfconsistent Calculation and in eigenvalue self-consistent GW
It is possible to run a qsGW calculation with an inner SCF loop which updates the static part of the elf-energy only. This can be useful to accelerate the convergence in case linear mixing is used. It is not recommended to use linear mixing, so it is also not recommended to use that inner loop as well. The second number in this list specifies the convergence criterion for the inner SCF loop.
:vartype Density: Iterable[float] | FloatListKey
:ivar HOMO: Criterion for self-consistency procedure to terminate.
The self-consistent GW calculation terminates, when the difference between the HOMO QP energies between 2 consecutive iterations is below this number.
The LUMO energy converged faster than the HOMO energy so when the HOMO energy is converged according to this criterion, the LUMO energy will be converged as well.
In non-selfconsistent Calculation, this criterion is ignored.
:vartype HOMO: float | FloatKey
"""
def __post_init__(self):
self.Density: Iterable[float] | FloatListKey = FloatListKey(name='Density', comment='First Criterion for self-consistency procedure to terminate.\n\nCriterion is the trace of the density matrix. Ignored in non-selfconsistent Calculation and in eigenvalue self-consistent GW\n\nIt is possible to run a qsGW calculation with an inner SCF loop which updates the static part of the elf-energy only. This can be useful to accelerate the convergence in case linear mixing is used. It is not recommended to use linear mixing, so it is also not recommended to use that inner loop as well. The second number in this list specifies the convergence criterion for the inner SCF loop.', default=[1e-08, 1e-05], gui_type='nfloat 2')
self.HOMO: float | FloatKey = FloatKey(name='HOMO', comment='Criterion for self-consistency procedure to terminate.\n\nThe self-consistent GW calculation terminates, when the difference between the HOMO QP energies between 2 consecutive iterations is below this number.\n\nThe LUMO energy converged faster than the HOMO energy so when the HOMO energy is converged according to this criterion, the LUMO energy will be converged as well.\n\nIn non-selfconsistent Calculation, this criterion is ignored.', gui_name='HOMO energy convergence:', default=0.003, unit='eV')
def __post_init__(self):
self.AdaptiveMixing: Iterable[float] | FloatListKey = FloatListKey(name='AdaptiveMixing', comment="Requests to use adaptive mixing instead of DIIS and sets the staring mixing parameter for mixing of Green's function in case of self-consistency.\n\nAdapative mixing is recommended in case a qsGW calculation does not converge with DIIS.\n\nIt is ignored in non-selfconsistent calculation and overwritten by DIIS when DIIS is also present.", gui_type='nfloat 1')
self.DIIS: int | IntKey = IntKey(name='DIIS', comment='Requests to use DIIS. This is the Default. Number of expansion coefficients can be requested as well. Ignored in non-selfconsistent calculation', default=10)
self.Enabled: BoolType | BoolKey = BoolKey(name='Enabled', comment='Enable the calculation of the GW quasi-particle energies.', gui_name='Calculate GW quasi-particle energies:', default=False)
self.ExpansionOrder: int | IntKey = IntKey(name='ExpansionOrder', comment='Order of the expansion of the screened interaction on the SOS-GF(n) method. order 2 (=SOS-GF2) is the default', hidden=True, default=2)
self.FixedGridSizes: BoolType | BoolKey = BoolKey(name='FixedGridSizes', comment='In a self-consistent GW calculation, recalculate Grids but keep them the same size during the SCF procedure.', hidden=True, default=True)
self.FixedGrids: BoolType | BoolKey = BoolKey(name='FixedGrids', comment='In a self-consistent GW calculation, do not recalculate Grids. Can be useful in case of convergence problems. Only relevant for qsGW and qsGW0. In case of evGW and evGW0, the grids are always kept fixed.', hidden=True, default=False)
self.G3W2: Literal["Full", "Diagonal", "Perturbative"] = MultipleChoiceKey(name='G3W2', comment='Only relevant when self-energy is one of GF2 or G3W2: Full requests that the second-order term is evaluated for the full self-energy matrix. This is very expensive and should only be done for small systems. Diagonal requests, that only the Diagonal of the self-energy matrix is updated. Perturbative means, that only a second-order screened exchange correction is evaluated after the GW calculation is completed. For a G0W0 calculation, all of these options are equivalent.', hidden=True, default='Perturbative', choices=['Full', 'Diagonal', 'Perturbative'])
self.LinearMixing: Iterable[float] | FloatListKey = FloatListKey(name='LinearMixing', comment="Requests to use linear mixing instead of DIIS and sets the mixing parameter for linear mixing of Green's function in case of self-consistency.\n\nIt is ignored in non-selfconsistent calculation and overwritten by DIIS when DIIS is also present.", gui_type='nfloat 1')
self.LinearizeQPequations: BoolType | BoolKey = BoolKey(name='LinearizeQPequations', comment='Instead of solving the non-linear QP equations in a G0W0 (or evGW calculation) by bisection exacly, linearize them by first-order Taylor expansion.\n\nThis is not recommended since it does not save computational time when used together with analytical continuation (as implemented in AMS). It might however be useful for benchmarking or for validating results.\n\nIf the results os the linearization differ by a lot (for instance, more than 0.1 eV in frontier QP energies) from the non-linearized results, this might indicate that the GW calculation is not reliable.', default=False)
self.OffDiagonalEFermi: BoolType | BoolKey = BoolKey(name='OffDiagonalEFermi', comment='Analytically continue the off-diagonal elements of the KSF2 qsGW Hamiltonian at the Fermi-energy instead of omega=0. Typically leads to slightly lower QP energies, i.e. higher ionization potentials. The HOMO-LUMO gaps are typically not affected.', hidden=True, default=False)
self.Polarizability: Literal["RPA", "BSE", "G4W1", "G4V1", "TDHF"] = MultipleChoiceKey(name='Polarizability', comment='Sets the expression for the Polarizability used in the GW calculation.\n\nRPA is the Default and amounts to a standard GW calculation.\n\nBSE denotes screening in the Bethe-Salpeter-equation formalism.', default='RPA', choices=['RPA', 'BSE', 'G4W1', 'G4V1', 'TDHF'])
self.PrintAllSolutions: BoolType | BoolKey = BoolKey(name='PrintAllSolutions', comment='Print out all solutions for all requested states. Detects multiple solutions of the QP equations.', default=False)
self.PrintImaginaryAxisData: BoolType | BoolKey = BoolKey(name='PrintImaginaryAxisData', comment='If true, print out the self-energy on the imaginary axis.', hidden=True, default=False)
self.PrintSpectralFunction: BoolType | BoolKey = BoolKey(name='PrintSpectralFunction', comment='Plot the self-energy as a function of frequency. Automatically done in case of analytical continuation. However, this is expensive in the analytical integration formalism.', default=False)
self.PrintZfactor: BoolType | BoolKey = BoolKey(name='PrintZfactor', hidden=True, default=False)
self.QPHamiltonian: Literal["KSF1", "KSF2", "SRG", "LQSGW"] = MultipleChoiceKey(name='QPHamiltonian', comment='The quasi-particle Hamiltonian can be constructed in different ways.\n\nKSF1 refers to the original construction by Kotani, Van Schilfgaarde anf Faleev (KSF) which is also implemented in TURBOMOLE.\n\nKSF2 refers to an alternative construction by KSF.\n\nKSF1 is not recommended since it is numerically less stable than KSF2 in case analytical continuation is used (the default).\n\nIn case the analytical integration algorithm is used, only KSF1 is implemented. Therefore, make sure that KSF1 is specified. The results are typically very similar.\n\nThe QP energies at which the matrix elements are evaluated can be tweaked further, see the two subsequent keys: However, KSF2 is recommended since it typically leads to QP energies with the best agreement with experiment.\n\nIgnored when not a quasi-particle self-consistent GW calculation is performed', default='KSF2', choices=['KSF1', 'KSF2', 'SRG', 'LQSGW'])
self.Scaling: float | FloatKey = FloatKey(name='Scaling', comment='Scale factor for the polarizability in the screened interaction SOS-GF2. Default = 1.0 (corresponds to no scaling)', hidden=True, default=1.0)
self.ScissorShift: BoolType | BoolKey = BoolKey(name='ScissorShift', comment='Only calculate the HOMO and LUMO QP energies and shift the remaining QP energies by the same amount.\n\nThis is a rather crude approximation and not recommended.\n\nIt might again be useful for benchmarking purposes.', default=False)
self.SelfConsistency: Literal["None", "G0W0", "EVGW0", "EVGW", "QSGW0", "QSGW"] = MultipleChoiceKey(name='SelfConsistency', comment="Sets the level of self-consistency in a GW calculation.\n\nG0W0 calculates a one-shot, perturbative correction to the KS eigenvalues.\n\nIn evGW and evGW0, the quasi-particle energies are updated until self-consistency is reached.\n\nevGW0 requests that the Green's function is evaluated self-consistently but not the screened interaction.\n\nIn qsGW, the density is updated as well, however, the self-energy is mapped to a static effective potential and the Dyson equation is solved by diagonalization instead of inversion. The results of a qsGW are independent of the choice of the underlying exchange-correlation functional and are usually the most accurate ones.\n\nThe same is done in qsGW0, but the screened interaction is not updated.", default='G0W0', choices=['None', 'G0W0', 'EVGW0', 'EVGW', 'QSGW0', 'QSGW'], hiddenchoices=['None'])
self.SelfConsistentSigmaVertex: BoolType | BoolKey = BoolKey(name='SelfConsistentSigmaVertex', comment='If active, evaluate the vertex correction in Sigma in qsGW self-consistent. Only supported for GWGammaInf so far', hidden=True, default=False)
self.SelfEnergy: Literal["HF", "GW", "G3W2", "SOSEX", "GWGamma", "G3W2dynamic", "GWGammaInf", "GWGammaInfDyn"] = MultipleChoiceKey(name='SelfEnergy', comment='Controls the form of the self-energy. \n\nGW is the default and corresponds to the standard GW calculation.\n\nG3W2 is a GW calculation plus a perturbative second-order statically screened exchange correction (second order expansion in the self-energy). Note, that there the self-energy is always static.', default='GW', choices=['HF', 'GW', 'G3W2', 'SOSEX', 'GWGamma', 'G3W2dynamic', 'GWGammaInf', 'GWGammaInfDyn'])
self.TabulateGridPoints: BoolType | BoolKey = BoolKey(name='TabulateGridPoints', comment='pretabulate grid points for numerical integration.', hidden=True, default=False)
self.nIterations: Iterable[int] | IntListKey = IntListKey(name='nIterations', comment='The maximum number of iterations within the (partially or fully) self-consistent GW calculation has to converge.\n\nIgnored when Formalism is set to G0W0', gui_name='Number of iterations:', default=[10], gui_type='nint 1')
self.nLowest: int | IntKey = IntKey(name='nLowest', comment="Number of lowest occupied QP levels to be evaluated, overwrites nStates'", gui_name='N Lowest:', default=1)
self.nStates: int | IntKey = IntKey(name='nStates', comment="Number of Quasiparticle States to be printed to output.\n\nThe default is 5 states which in this case means that min(5, Number of particle states) occupied and min(5, Number of hole states) hole states are printed. The whole list of states can be printed by setting this parameter to -1'", gui_name='N states:', default=5)
self.preconditionQSGW: BoolType | BoolKey = BoolKey(name='preconditionQSGW', comment='If true, the QSGW equations are solved but prior to each diagonalization, i.e. a G0W0 calculation is performed to find the optimal QP energies at which to analytically continue the self-energy.\n\nThis is in principle a more consistent construction than KSF1 or KSF2 since the diagonal elements are consistent with G0W0.\n\nIn KSF1 and KSF2, the diagonal elements are evaluated at the QP energies from the previous iteration which is equivalent to a zeroth-order Taylor expansion of the diagonal elements around the previous QP energies.\\Enabling this option typically leads to slightly lower QP energies.', hidden=True, default=False)
self.AnalyticalIntegration: BAND._GW._AnalyticalIntegration = self._AnalyticalIntegration(name='AnalyticalIntegration', comment='Use analytical integration to calculate the self-energy. Very slow, unless the system is very small but useful to check the accuracy of the frequency integration')
self.Converge: BAND._GW._Converge = self._Converge(name='Converge', comment='Sets convergence criteria for the GW calculation in self-consistent case')
[docs] class _Gate(FixedBlock):
r"""
Undocumented. Old NEGF.
:ivar Basfnc: Undocumented.
:vartype Basfnc: int | IntKey
:ivar Phi: Undocumented.
:vartype Phi: float | FloatKey
:ivar Phia: Undocumented.
:vartype Phia: float | FloatKey
:ivar Phib: Undocumented.
:vartype Phib: float | FloatKey
:ivar Plot: Undocumented.
:vartype Plot: int | IntKey
"""
def __post_init__(self):
self.Basfnc: int | IntKey = IntKey(name='Basfnc', comment='Undocumented.', default=1000)
self.Phi: float | FloatKey = FloatKey(name='Phi', comment='Undocumented.', default=0.0)
self.Phia: float | FloatKey = FloatKey(name='Phia', comment='Undocumented.', default=0.0)
self.Phib: float | FloatKey = FloatKey(name='Phib', comment='Undocumented.', default=0.0)
self.Plot: int | IntKey = IntKey(name='Plot', comment='Undocumented.', default=1)
[docs] class _Gradients(FixedBlock):
r"""
Options for nuclear gradients and strain derivatives calculations.
:ivar AccurateNucGradKin: Undocumented.
:vartype AccurateNucGradKin: BoolType | BoolKey
:ivar AddCoulombAndXC: Undocumented.
:vartype AddCoulombAndXC: BoolType | BoolKey
:ivar CoreOrthApprox: Undocumented.
:vartype CoreOrthApprox: int | IntKey
:ivar CoreOrthPartialInt: Undocumented.
:vartype CoreOrthPartialInt: BoolType | BoolKey
:ivar FastNucGradRho: Undocumented.
:vartype FastNucGradRho: BoolType | BoolKey
:ivar KgrpxNucGradRho: Undocumented.
:vartype KgrpxNucGradRho: int | IntKey
:ivar LatticeStepSize: Undocumented.
:vartype LatticeStepSize: float | FloatKey
:ivar MetaGGAUpdateOption: How to update metaGGA nuclear gradient terms. Option 1 is the original implementation. Option 2 is faster and requires less memory
:vartype MetaGGAUpdateOption: int | IntKey
:ivar NeglectCoreCoreTerm: Undocumented.
:vartype NeglectCoreCoreTerm: BoolType | BoolKey
:ivar NucGradAtomGroupSize: Avoid handling the nuclear gradient of the basis set of all atoms at once. A negative value means: handle all at once. Currently only affects MetaGGA calculations.
:vartype NucGradAtomGroupSize: int | IntKey
:ivar NucGradElstatOption: Undocumented.
:vartype NucGradElstatOption: int | IntKey
:ivar NucGradexcoption: Undocumented.
:vartype NucGradexcoption: int | IntKey
:ivar NucGradkinoption: Undocumented.
:vartype NucGradkinoption: int | IntKey
:ivar OldIO: Undocumented.
:vartype OldIO: int | IntKey
:ivar StrainDerivatives: Undocumented.
:vartype StrainDerivatives: BoolType | BoolKey
:ivar StrainDerunitcellintegraloption: Undocumented.
:vartype StrainDerunitcellintegraloption: int | IntKey
:ivar StrainDerwholespaceintegraloption: Undocumented.
:vartype StrainDerwholespaceintegraloption: int | IntKey
:ivar ViaVOC: Undocumented.
:vartype ViaVOC: BoolType | BoolKey
:ivar WipeOneCenterTerms: Undocumented.
:vartype WipeOneCenterTerms: BoolType | BoolKey
"""
def __post_init__(self):
self.AccurateNucGradKin: BoolType | BoolKey = BoolKey(name='AccurateNucGradKin', comment='Undocumented.', default=False)
self.AddCoulombAndXC: BoolType | BoolKey = BoolKey(name='AddCoulombAndXC', comment='Undocumented.', default=False)
self.CoreOrthApprox: int | IntKey = IntKey(name='CoreOrthApprox', comment='Undocumented.', default=1)
self.CoreOrthPartialInt: BoolType | BoolKey = BoolKey(name='CoreOrthPartialInt', comment='Undocumented.', default=True)
self.FastNucGradRho: BoolType | BoolKey = BoolKey(name='FastNucGradRho', comment='Undocumented.', default=True)
self.KgrpxNucGradRho: int | IntKey = IntKey(name='KgrpxNucGradRho', comment='Undocumented.', default=1)
self.LatticeStepSize: float | FloatKey = FloatKey(name='LatticeStepSize', comment='Undocumented.', default=0.012)
self.MetaGGAUpdateOption: int | IntKey = IntKey(name='MetaGGAUpdateOption', comment='How to update metaGGA nuclear gradient terms. Option 1 is the original implementation. Option 2 is faster and requires less memory', default=2)
self.NeglectCoreCoreTerm: BoolType | BoolKey = BoolKey(name='NeglectCoreCoreTerm', comment='Undocumented.', default=False)
self.NucGradAtomGroupSize: int | IntKey = IntKey(name='NucGradAtomGroupSize', comment='Avoid handling the nuclear gradient of the basis set of all atoms at once. A negative value means: handle all at once. Currently only affects MetaGGA calculations.', default=1)
self.NucGradElstatOption: int | IntKey = IntKey(name='NucGradElstatOption', comment='Undocumented.', default=2)
self.NucGradexcoption: int | IntKey = IntKey(name='NucGradexcoption', comment='Undocumented.', default=2)
self.NucGradkinoption: int | IntKey = IntKey(name='NucGradkinoption', comment='Undocumented.', default=8)
self.OldIO: int | IntKey = IntKey(name='OldIO', comment='Undocumented.', default=1)
self.StrainDerivatives: BoolType | BoolKey = BoolKey(name='StrainDerivatives', comment='Undocumented.', default=False)
self.StrainDerunitcellintegraloption: int | IntKey = IntKey(name='StrainDerunitcellintegraloption', comment='Undocumented.', default=3)
self.StrainDerwholespaceintegraloption: int | IntKey = IntKey(name='StrainDerwholespaceintegraloption', comment='Undocumented.', default=5)
self.ViaVOC: BoolType | BoolKey = BoolKey(name='ViaVOC', comment='Undocumented.', default=False)
self.WipeOneCenterTerms: BoolType | BoolKey = BoolKey(name='WipeOneCenterTerms', comment='Undocumented.', default=True)
[docs] class _Grid(FixedBlock):
r"""
Options for the regular grid used for plotting (e.g. density plot). Used ICW the restart option.
:ivar ExtendX: Extend the default regular grid along the x-direction by the specified amount: [x_min, x_max] => [x_min - ExtendX/2, x_max + ExtendX/2].
:vartype ExtendX: float | FloatKey
:ivar ExtendY: Extend the default regular grid along the y-direction by the specified amount: [y_min, y_max] => [y_min - ExtendY/2, y_max + ExtendY/2].
:vartype ExtendY: float | FloatKey
:ivar ExtendZ: Extend the default regular grid along the z-direction by the specified amount: [z_min, z_max] => [z_min - ExtendZ/2, z_max + ExtendZ/2].
:vartype ExtendZ: float | FloatKey
:ivar FileName: Read in the grid from a file. The file format of the grid is: three numbers per line (defining the x, y and z coordinates of the points).
:vartype FileName: str | StringKey
:ivar Type: The default regular grids.
:vartype Type: Literal["coarse", "medium", "fine"]
:ivar UserDefined: One can define the regular grid specification in this block. See example. Default unit is Bohr
:vartype UserDefined: str | Sequence[str] | FreeBlock
"""
[docs] class _UserDefined(FreeBlock):
r"""
One can define the regular grid specification in this block. See example. Default unit is Bohr
"""
def __post_init__(self):
pass
def __post_init__(self):
self.ExtendX: float | FloatKey = FloatKey(name='ExtendX', comment='Extend the default regular grid along the x-direction by the specified amount: [x_min, x_max] => [x_min - ExtendX/2, x_max + ExtendX/2].', default=0.0, unit='Bohr')
self.ExtendY: float | FloatKey = FloatKey(name='ExtendY', comment='Extend the default regular grid along the y-direction by the specified amount: [y_min, y_max] => [y_min - ExtendY/2, y_max + ExtendY/2].', default=0.0, unit='Bohr')
self.ExtendZ: float | FloatKey = FloatKey(name='ExtendZ', comment='Extend the default regular grid along the z-direction by the specified amount: [z_min, z_max] => [z_min - ExtendZ/2, z_max + ExtendZ/2].', default=0.0, unit='Bohr')
self.FileName: str | StringKey = StringKey(name='FileName', comment='Read in the grid from a file. The file format of the grid is: three numbers per line (defining the x, y and z coordinates of the points).', default=' ')
self.Type: Literal["coarse", "medium", "fine"] = MultipleChoiceKey(name='Type', comment='The default regular grids.', default='coarse', choices=['coarse', 'medium', 'fine'])
self.UserDefined: str | Sequence[str] | FreeBlock = self._UserDefined(name='UserDefined', comment='One can define the regular grid specification in this block. See example. Default unit is Bohr', header=True)
[docs] class _GridBasedAIM(FixedBlock):
r"""
Invoke the ultra fast grid based Bader analysis.
:ivar Enabled: Invoke the ultra fast grid based Bader analysis.
:vartype Enabled: BoolType | BoolKey
:ivar Iterations: The maximum number of steps that may be taken to find the nuclear attractor for a grid point.
:vartype Iterations: int | IntKey
:ivar SmallDensity: Value below which the density is ignored. This should not be chosen too small because it may lead to unassignable grid points.
:vartype SmallDensity: float | FloatKey
:ivar UseStartDensity: Whether the analysis is performed on the startup density (True) or on the final density (False).
:vartype UseStartDensity: BoolType | BoolKey
"""
def __post_init__(self):
self.Enabled: BoolType | BoolKey = BoolKey(name='Enabled', comment='Invoke the ultra fast grid based Bader analysis.', gui_name='Bader (AIM): Atomic properties', default=False)
self.Iterations: int | IntKey = IntKey(name='Iterations', comment='The maximum number of steps that may be taken to find the nuclear attractor for a grid point.', default=40)
self.SmallDensity: float | FloatKey = FloatKey(name='SmallDensity', comment='Value below which the density is ignored. This should not be chosen too small because it may lead to unassignable grid points.', default=1e-06)
self.UseStartDensity: BoolType | BoolKey = BoolKey(name='UseStartDensity', comment='Whether the analysis is performed on the startup density (True) or on the final density (False).', default=False)
[docs] class _GrossPopulations(FreeBlock):
r"""
Partial DOS (pDOS) are generated for the gross populations listed under this key. See example.
"""
def __post_init__(self):
pass
[docs] class _HardConfinement(FixedBlock):
r"""
Obsolete basis functions confinement method. Use SoftConfinement instead.
:ivar delta: Undocumented.
:vartype delta: float | FloatKey
:ivar radius: Undocumented.
:vartype radius: float | FloatKey
"""
def __post_init__(self):
self.delta: float | FloatKey = FloatKey(name='delta', comment='Undocumented.', default=0.0)
self.radius: float | FloatKey = FloatKey(name='radius', comment='Undocumented.', default=0.0)
[docs] class _HubbardU(FixedBlock):
r"""
Options for Hubbard-corrected DFT calculations.
:ivar Enabled: Whether or not to apply the Hubbard Hamiltonian. Can be useful to turn of Hubbard in a script with a single variable.
:vartype Enabled: BoolType | BoolKey
:ivar IgnoreForPEDA: Ignore the hubbard energy term when calculating the energy of psi_0 for the energy decomposition analysis (EDA).
:vartype IgnoreForPEDA: BoolType | BoolKey
:ivar LValue: For each atom type specify the l value (0 - s orbitals, 1 - p orbitals, 2 - d orbitals). A negative value is interpreted as no l-value.
:vartype LValue: str | StringKey
:ivar PrintOccupations: Whether or not to print the occupations during the SCF.
:vartype PrintOccupations: BoolType | BoolKey
:ivar UValue: For each atom type specify the U value (in atomic units). A value of 0.0 is interpreted as no U.
:vartype UValue: str | StringKey
:ivar UseDiagonalOccupations: Undocumented.
:vartype UseDiagonalOccupations: BoolType | BoolKey
:ivar UseNAO: Undocumented.
:vartype UseNAO: BoolType | BoolKey
:ivar Atom: Specify Hubbard parameters (U,l) for a certain element
:vartype Atom: BAND._HubbardU._Atom
:ivar Region: Specify Hubbard parameters (U,l) for all atoms in a certain region
:vartype Region: BAND._HubbardU._Region
"""
[docs] class _Atom(FixedBlock):
r"""
Specify Hubbard parameters (U,l) for a certain element
:ivar Element: Name of the element, such as Cu or Zn
:vartype Element: str | StringKey
:ivar LValue: L value of the shell to apply the Hubbard model to
:vartype LValue: Literal["s", "p", "d", "f"]
:ivar UValue: Hubbard U value.
:vartype UValue: float | FloatKey
"""
def __post_init__(self):
self.Element: str | StringKey = StringKey(name='Element', comment='Name of the element, such as Cu or Zn', gui_type='element')
self.LValue: Literal["s", "p", "d", "f"] = MultipleChoiceKey(name='LValue', comment='L value of the shell to apply the Hubbard model to', default='s', choices=['s', 'p', 'd', 'f'])
self.UValue: float | FloatKey = FloatKey(name='UValue', comment='Hubbard U value.', default=0.0, unit='Hartree')
[docs] class _Region(FixedBlock):
r"""
Specify Hubbard parameters (U,l) for all atoms in a certain region
:ivar LValue: L value of the shell to apply the Hubbard model to
:vartype LValue: Literal["s", "p", "d", "f"]
:ivar Name: Name of the region
:vartype Name: str | StringKey
:ivar UValue: Hubbard U value.
:vartype UValue: float | FloatKey
"""
def __post_init__(self):
self.LValue: Literal["s", "p", "d", "f"] = MultipleChoiceKey(name='LValue', comment='L value of the shell to apply the Hubbard model to', default='s', choices=['s', 'p', 'd', 'f'])
self.Name: str | StringKey = StringKey(name='Name', comment='Name of the region', gui_type='region')
self.UValue: float | FloatKey = FloatKey(name='UValue', comment='Hubbard U value.', default=0.0, unit='Hartree')
def __post_init__(self):
self.Enabled: BoolType | BoolKey = BoolKey(name='Enabled', comment='Whether or not to apply the Hubbard Hamiltonian. Can be useful to turn of Hubbard in a script with a single variable.', hidden=True, default=True)
self.IgnoreForPEDA: BoolType | BoolKey = BoolKey(name='IgnoreForPEDA', comment='Ignore the hubbard energy term when calculating the energy of psi_0 for the energy decomposition analysis (EDA).', hidden=True, gui_name='Ignore for PEDA:', default=False)
self.LValue: str | StringKey = StringKey(name='LValue', comment='For each atom type specify the l value (0 - s orbitals, 1 - p orbitals, 2 - d orbitals). A negative value is interpreted as no l-value.', hidden=True, default='')
self.PrintOccupations: BoolType | BoolKey = BoolKey(name='PrintOccupations', comment='Whether or not to print the occupations during the SCF.', default=True)
self.UValue: str | StringKey = StringKey(name='UValue', comment='For each atom type specify the U value (in atomic units). A value of 0.0 is interpreted as no U.', hidden=True, default='')
self.UseDiagonalOccupations: BoolType | BoolKey = BoolKey(name='UseDiagonalOccupations', comment='Undocumented.', hidden=True, default=True)
self.UseNAO: BoolType | BoolKey = BoolKey(name='UseNAO', comment='Undocumented.', hidden=True, default=True)
self.Atom: BAND._HubbardU._Atom = self._Atom(name='Atom', comment='Specify Hubbard parameters (U,l) for a certain element', unique=False)
self.Region: BAND._HubbardU._Region = self._Region(name='Region', comment='Specify Hubbard parameters (U,l) for all atoms in a certain region', unique=False)
[docs] class _Integration(FixedBlock):
r"""
Options for the Voronoi numerical integration scheme. Deprecated. Use BeckeGrid instead.
:ivar AccInt: General parameter controlling the accuracy of the Voronoi integration grid. A value of 3 would be basic quality and a value of 7 would be good quality.
:vartype AccInt: float | FloatKey
:ivar AccOut: Integration accuracy for the outer region.
:vartype AccOut: float | FloatKey
:ivar AccPyr: Undocumented.
:vartype AccPyr: float | FloatKey
:ivar AccPyu: Undocumented.
:vartype AccPyu: float | FloatKey
:ivar AccPyv: Undocumented.
:vartype AccPyv: float | FloatKey
:ivar AccPyw: Undocumented.
:vartype AccPyw: float | FloatKey
:ivar AccSph: Integration accuracy for the atomic sphere regions.
:vartype AccSph: float | FloatKey
:ivar AccZae: Undocumented.
:vartype AccZae: float | FloatKey
:ivar Add: Undocumented.
:vartype Add: int | IntKey
:ivar AllElectron: Undocumented.
:vartype AllElectron: BoolType | BoolKey
:ivar DisHul: Undocumented.
:vartype DisHul: float | FloatKey
:ivar FRange: Undocumented.
:vartype FRange: float | FloatKey
:ivar LInteg: Undocumented.
:vartype LInteg: str | StringKey
:ivar LinRot: Undocumented.
:vartype LinRot: int | IntKey
:ivar NOuter: Undocumented.
:vartype NOuter: int | IntKey
:ivar NumMulangsph: Undocumented.
:vartype NumMulangsph: float | FloatKey
:ivar NumMulout: Undocumented.
:vartype NumMulout: float | FloatKey
:ivar NumMulpyr: Undocumented.
:vartype NumMulpyr: int | IntKey
:ivar NumMulpyruv: Undocumented.
:vartype NumMulpyruv: float | FloatKey
:ivar NumMulpyrw: Undocumented.
:vartype NumMulpyrw: float | FloatKey
:ivar NumMulradsph: Undocumented.
:vartype NumMulradsph: float | FloatKey
:ivar NumMulsph: Undocumented.
:vartype NumMulsph: int | IntKey
:ivar Ord: Undocumented.
:vartype Ord: int | IntKey
:ivar OutPar: Undocumented.
:vartype OutPar: float | FloatKey
:ivar OutRad: Undocumented.
:vartype OutRad: float | FloatKey
:ivar Slow: Undocumented.
:vartype Slow: BoolType | BoolKey
:ivar TSTF: Undocumented.
:vartype TSTF: BoolType | BoolKey
"""
def __post_init__(self):
self.AccInt: float | FloatKey = FloatKey(name='AccInt', comment='General parameter controlling the accuracy of the Voronoi integration grid. A value of 3 would be basic quality and a value of 7 would be good quality.', default=3.5)
self.AccOut: float | FloatKey = FloatKey(name='AccOut', comment='Integration accuracy for the outer region.', hidden=True)
self.AccPyr: float | FloatKey = FloatKey(name='AccPyr', comment='Undocumented.', hidden=True)
self.AccPyu: float | FloatKey = FloatKey(name='AccPyu', comment='Undocumented.', hidden=True)
self.AccPyv: float | FloatKey = FloatKey(name='AccPyv', comment='Undocumented.', hidden=True)
self.AccPyw: float | FloatKey = FloatKey(name='AccPyw', comment='Undocumented.', hidden=True)
self.AccSph: float | FloatKey = FloatKey(name='AccSph', comment='Integration accuracy for the atomic sphere regions.', hidden=True)
self.AccZae: float | FloatKey = FloatKey(name='AccZae', comment='Undocumented.', hidden=True)
self.Add: int | IntKey = IntKey(name='Add', comment='Undocumented.', hidden=True)
self.AllElectron: BoolType | BoolKey = BoolKey(name='AllElectron', comment='Undocumented.', hidden=True, default=False)
self.DisHul: float | FloatKey = FloatKey(name='DisHul', comment='Undocumented.', hidden=True)
self.FRange: float | FloatKey = FloatKey(name='FRange', comment='Undocumented.', hidden=True)
self.LInteg: str | StringKey = StringKey(name='LInteg', comment='Undocumented.', hidden=True)
self.LinRot: int | IntKey = IntKey(name='LinRot', comment='Undocumented.', hidden=True)
self.NOuter: int | IntKey = IntKey(name='NOuter', comment='Undocumented.', hidden=True)
self.NumMulangsph: float | FloatKey = FloatKey(name='NumMulangsph', comment='Undocumented.', hidden=True, default=1.0)
self.NumMulout: float | FloatKey = FloatKey(name='NumMulout', comment='Undocumented.', hidden=True, default=1.0)
self.NumMulpyr: int | IntKey = IntKey(name='NumMulpyr', comment='Undocumented.', hidden=True, default=1)
self.NumMulpyruv: float | FloatKey = FloatKey(name='NumMulpyruv', comment='Undocumented.', hidden=True, default=1.0)
self.NumMulpyrw: float | FloatKey = FloatKey(name='NumMulpyrw', comment='Undocumented.', hidden=True, default=1.0)
self.NumMulradsph: float | FloatKey = FloatKey(name='NumMulradsph', comment='Undocumented.', hidden=True, default=1.0)
self.NumMulsph: int | IntKey = IntKey(name='NumMulsph', comment='Undocumented.', hidden=True, default=1)
self.Ord: int | IntKey = IntKey(name='Ord', comment='Undocumented.', hidden=True)
self.OutPar: float | FloatKey = FloatKey(name='OutPar', comment='Undocumented.', hidden=True)
self.OutRad: float | FloatKey = FloatKey(name='OutRad', comment='Undocumented.', hidden=True)
self.Slow: BoolType | BoolKey = BoolKey(name='Slow', comment='Undocumented.', hidden=True)
self.TSTF: BoolType | BoolKey = BoolKey(name='TSTF', comment='Undocumented.', hidden=True)
[docs] class _KSpace(FixedBlock):
r"""
Options for the k-space integration (i.e. the grid used to sample the Brillouin zone)
:ivar Analytical: For analytical integration the BZ is split into simplices, whereover the bands are interpolated, ater which the integrals can be performed analytically.
Alternatively, the set of eigenvalues in the discrete set of k-points are just handled as distinct molecular orbitals.
Using analytical=no can improve SCF convergence in combination with smearing/temperature.
:vartype Analytical: BoolType | BoolKey
:ivar Quality: Select the quality of the K-space grid used to sample the Brillouin Zone. If 'Auto', the quality defined in the 'NumericalQuality' will be used. If 'GammaOnly', only one point (the gamma point) will be used.
The actual number of K points generated depends on this option and on the size of the unit cell. The larger the real space cell, the fewer K points will be generated.
The CPU-time and accuracy strongly depend on this option.
:vartype Quality: Literal["Auto", "GammaOnly", "Basic", "Normal", "Good", "VeryGood", "Excellent"]
:ivar Type: The type of k-space integration grid used to sample the Brillouin zone (BZ) used.
'Regular': simple regular grid.
'Symmetric': symmetric grid for the irreducible wedge of the first BZ (useful when high-symmetry points in the BZ are needed to capture the correct physics of the system, graphene being a notable example).
:vartype Type: Literal["Regular", "Symmetric"]
:ivar Regular: Options for the regular k-space integration grid.
:vartype Regular: BAND._KSpace._Regular
:ivar Symmetric: Options for the symmetric k-space integration grid.
:vartype Symmetric: BAND._KSpace._Symmetric
"""
[docs] class _Regular(FixedBlock):
r"""
Options for the regular k-space integration grid.
:ivar DoubleCount: Increase for each dimension the grid. A sequence of doubling, with a special meaning for grid with odd numbers. Useful when checking k-space convergence.
:vartype DoubleCount: int | IntKey
:ivar KMesh: Undocumented.
:vartype KMesh: int | IntKey
:ivar NumberOfPoints: Use a regular grid with the specified number of k-points along each reciprocal lattice vector.
For 1D periodic systems you should specify only one number, for 2D systems two numbers, and for 3D systems three numbers.
:vartype NumberOfPoints: Iterable[int] | IntListKey
:ivar PreferEvenNumberOfPoints: In case of an automatic grid normally odd numbers will be generated (1,3,5,9), suitable for a quadratic grid. With this option the suggested odd numbers will be increased by one, unless it is one.
:vartype PreferEvenNumberOfPoints: BoolType | BoolKey
:ivar SplitCubeInSix: Undocumented.
:vartype SplitCubeInSix: BoolType | BoolKey
:ivar SplitLongest: Undocumented.
:vartype SplitLongest: BoolType | BoolKey
:ivar SplitPermutation: Undocumented.
:vartype SplitPermutation: int | IntKey
"""
def __post_init__(self):
self.DoubleCount: int | IntKey = IntKey(name='DoubleCount', comment='Increase for each dimension the grid. A sequence of doubling, with a special meaning for grid with odd numbers. Useful when checking k-space convergence.', hidden=True, default=0)
self.KMesh: int | IntKey = IntKey(name='KMesh', comment='Undocumented.', hidden=True, default=4)
self.NumberOfPoints: Iterable[int] | IntListKey = IntListKey(name='NumberOfPoints', comment='Use a regular grid with the specified number of k-points along each reciprocal lattice vector.\n\nFor 1D periodic systems you should specify only one number, for 2D systems two numbers, and for 3D systems three numbers.')
self.PreferEvenNumberOfPoints: BoolType | BoolKey = BoolKey(name='PreferEvenNumberOfPoints', comment='In case of an automatic grid normally odd numbers will be generated (1,3,5,9), suitable for a quadratic grid. With this option the suggested odd numbers will be increased by one, unless it is one.', hidden=True, default=False)
self.SplitCubeInSix: BoolType | BoolKey = BoolKey(name='SplitCubeInSix', comment='Undocumented.', hidden=True, default=False)
self.SplitLongest: BoolType | BoolKey = BoolKey(name='SplitLongest', comment='Undocumented.', hidden=True, default=False)
self.SplitPermutation: int | IntKey = IntKey(name='SplitPermutation', comment='Undocumented.', hidden=True, default=-1)
[docs] class _Symmetric(FixedBlock):
r"""
Options for the symmetric k-space integration grid.
:ivar KInteg: Specify the accuracy for the Symmetric method.
1: absolutely minimal (only the G-point is used)
2: linear tetrahedron method, coarsest spacing
3: quadratic tetrahedron method, coarsest spacing
4,6,... (even): linear tetrahedron method
5,7.... (odd): quadratic method
The tetrahedron method is usually by far inferior.
:vartype KInteg: int | IntKey
:ivar KMesh: Undocumented.
:vartype KMesh: int | IntKey
"""
def __post_init__(self):
self.KInteg: int | IntKey = IntKey(name='KInteg', comment='Specify the accuracy for the Symmetric method.\n\n1: absolutely minimal (only the G-point is used)\n2: linear tetrahedron method, coarsest spacing\n3: quadratic tetrahedron method, coarsest spacing\n4,6,... (even): linear tetrahedron method\n5,7.... (odd): quadratic method\n\nThe tetrahedron method is usually by far inferior.', gui_name='Accuracy:')
self.KMesh: int | IntKey = IntKey(name='KMesh', comment='Undocumented.', hidden=True, default=2)
def __post_init__(self):
self.Analytical: BoolType | BoolKey = BoolKey(name='Analytical', comment='For analytical integration the BZ is split into simplices, whereover the bands are interpolated, ater which the integrals can be performed analytically.\n\nAlternatively, the set of eigenvalues in the discrete set of k-points are just handled as distinct molecular orbitals.\n\nUsing analytical=no can improve SCF convergence in combination with smearing/temperature.', default=True)
self.Quality: Literal["Auto", "GammaOnly", "Basic", "Normal", "Good", "VeryGood", "Excellent"] = MultipleChoiceKey(name='Quality', comment="Select the quality of the K-space grid used to sample the Brillouin Zone. If 'Auto', the quality defined in the 'NumericalQuality' will be used. If 'GammaOnly', only one point (the gamma point) will be used. \n\nThe actual number of K points generated depends on this option and on the size of the unit cell. The larger the real space cell, the fewer K points will be generated.\n\nThe CPU-time and accuracy strongly depend on this option.", gui_name='K-space:', default='Auto', choices=['Auto', 'GammaOnly', 'Basic', 'Normal', 'Good', 'VeryGood', 'Excellent'])
self.Type: Literal["Regular", "Symmetric"] = MultipleChoiceKey(name='Type', comment="The type of k-space integration grid used to sample the Brillouin zone (BZ) used.\n\n'Regular': simple regular grid.\n\n'Symmetric': symmetric grid for the irreducible wedge of the first BZ (useful when high-symmetry points in the BZ are needed to capture the correct physics of the system, graphene being a notable example).", gui_name='K-space grid type:', default='Regular', choices=['Regular', 'Symmetric'])
self.Regular: BAND._KSpace._Regular = self._Regular(name='Regular', comment='Options for the regular k-space integration grid.')
self.Symmetric: BAND._KSpace._Symmetric = self._Symmetric(name='Symmetric', comment='Options for the symmetric k-space integration grid.')
[docs] class _LDOS(FixedBlock):
r"""
Local Density-Of-States information. This can be used to generate STM images in the Tersoff-Hamann approximation (see https://doi.org/10.1103/PhysRevB.31.805)
:ivar DeltaNeg: Lower bound energy (Shift-DeltaNeg)
:vartype DeltaNeg: float | FloatKey
:ivar DeltaPos: Upper bound energy (Shift+DeltaPos)
:vartype DeltaPos: float | FloatKey
:ivar Shift: The energy bias with respect to the Fermi level.
:vartype Shift: float | FloatKey
"""
def __post_init__(self):
self.DeltaNeg: float | FloatKey = FloatKey(name='DeltaNeg', comment='Lower bound energy (Shift-DeltaNeg)', default=0.0001, unit='Hartree')
self.DeltaPos: float | FloatKey = FloatKey(name='DeltaPos', comment='Upper bound energy (Shift+DeltaPos)', default=0.0001, unit='Hartree')
self.Shift: float | FloatKey = FloatKey(name='Shift', comment='The energy bias with respect to the Fermi level.', default=0.0, unit='Hartree')
[docs] class _MBPT(FixedBlock):
r"""
Technical aspects of the MP2 algorithm.
:ivar Dependency: If true, to improve numerical stability, almost linearly-dependent combination of basis functions are removed from the Green's function that are used in the MBPT equations. Disabling this key is strongly discouraged. Its value can however be changed. The key to adjust this value is RiHartreeFock%DependencyThreshold
:vartype Dependency: BoolType | BoolKey
:ivar Enabled: Enable the calculation of the MP2 energy.
:vartype Enabled: BoolType | BoolKey
:ivar ExcludeCore: If active, excludes core states from the calculation of the optimal imaginary time and frequency grids.
The core states are still included in all parts of the calculations.
In case a frozen care calculation is performed, this key is ignored.
For MP2 and double hybrid calculation, it defaults to false. For RPA and GW calculations, it defaults to true.
:vartype ExcludeCore: BoolType | BoolKey
:ivar FitSetQuality: Specifies the fit set to be used in the MBPT calculation.
'Normal' quality is generally sufficient for basis sets up to and including TZ2P.
For larger basis sets (or for benchmarking purposes) a 'VeryGood' fit set is recommended. Note that the FitSetQuality heavily influences the computational cost of the calculation.
If not specified or 'Auto', the RIHartreeFock%FitSetQuality is used.
:vartype FitSetQuality: Literal["Auto", "VeryBasic", "Basic", "Normal", "Good", "VeryGood"]
:ivar Formalism: Specifies the formalism for the calculation of the MP2 correlation energy.
'LT' means Laplace Transformed MP2 (also referred to as AO-PARI-MP2),
'RI' means that a conventional RI-MP2 is carried out.
If 'Auto', LT will be used in case of DOD double hybrids and SOS MP2, and RI will be used in all other cases.
'All' means that both RI and LT formalisms are used in the calculation.
For a RPA or GW calculation, the formalism is always LT, irrespective of the formalism specified with this key.
:vartype Formalism: Literal["Auto", "RI", "LT", "All"]
:ivar FrequencyGridType: Use Gauss-legendre grid for imaginary frequency integration in RPA and GW calculations instead of the usually used Least-Square optimized ones. Has the advantage that it can be systematically converged and an arbitrary number of grid points can be used. Typically more grid points will be needed to get the same level of accuracy. However, the convergence of the results with the size of the grid can be more systematic. These grids can only be used when Formalism is set to RI.
:vartype FrequencyGridType: Literal["LeastSquare", "GaussLegendre"]
:ivar IntegrationQuality: Specifies the integration quality to be used in the MBPT calculation. If not specified, the RIHartreeFock%IntegrationQuality is used.
:vartype IntegrationQuality: Literal["VeryBasic", "Basic", "Normal", "Good", "VeryGood"]
:ivar PrintOutSigma: Print out additional output for sigma-functional for parametrization.
:vartype PrintOutSigma: BoolType | BoolKey
:ivar SigmaFunctionalParametrization: Only relevant if a sigma-functional calculation is performed. Possible choices for the parametrization of the sigma-functional. Not all options are supported for all functionals.
:vartype SigmaFunctionalParametrization: Literal["W1", "W2", "S1", "S2", "S1re"]
:ivar ThresholdQuality: Controls the distances between atomic centers for which the product of two basis functions is not fitted any more. Especially for spatially extended, large systems, 'VERYBASIC' and 'BASIC' can lead to large computational savings, but the fit is also more approximate. If not specified, the RIHartreeFock%ThresholdQuality is used.
:vartype ThresholdQuality: Literal["VeryBasic", "Basic", "Normal", "Good", "VeryGood", "Excellent"]
:ivar UseScaledZORA: If true, use the scaled ZORA orbital energies instead of the ZORA orbital energies in the MBPT equations.
:vartype UseScaledZORA: BoolType | BoolKey
:ivar cutOfftransition: Energy above which states are ignored in a MBPT calculation (must be a positive number). The default energy is chosen so high, that all states are included except for the ones which have been removed.
:vartype cutOfftransition: float | FloatKey
:ivar frozencore: Freeze core states in correlation part of MBPT calculation
:vartype frozencore: BoolType | BoolKey
:ivar nCore: Number of core states which will be excluded from the correlated calculation.
Will be ignored if frozencore is false.
In case nothing is specified, the number of core levels will be determined automatically.
Needs to be smaller than the number of occupied states.
:vartype nCore: int | IntKey
:ivar nFreqIntegration: Number of imaginary frequency points for G3W2 integration
:vartype nFreqIntegration: int | IntKey
:ivar nFrequency: Number of imaginary frequency points. This key is only relevant for RPA and GW and will be ignored if used in an AO-PARI-MP2 calculation. 12 Points is the default for a RPA calculation. It is technically possible to use a different number of imaginary frequency points than for imaginary time. The maximum number of points which can be requested for imaginary frequency integration is 42. Important note: The computation time and memory requirements roughly scale linearly with the number of imaginary frequency points. However, memory can be an issue for RPA and GW when the number of imaginary frequency points is high. In case a job crashes, it is advised to increase the number of nodes since the necessary memory distributes over all nodes.
:vartype nFrequency: int | IntKey
:ivar nLambda: Size of coupling constant integration grid for SOSEX variants in RPA. Default is 4 points
:vartype nLambda: int | IntKey
:ivar nTime: Number of imaginary time points (only relevant in case the Laplace Transformed (LT) formalism is used).
In the many-body-perturbation theory module in ADF, the polarizability (or Kohn-Sham density response function) is evaluated in imaginary time to exploit sparsity in the AO basis. For MP2, this is often referred to as a Laplace transform. For MP2, 9 points are the default. This is a safe choice, guaranteeing accuracies higher than 1 Kj/mol for most systems (For many simple organic systems, 6 points are sufficient for good accuracy).
Only for systems with a very small HOMO-LUMO gap or low-lying core states (heavy elements starting from the 4th row of the periodic table) more points might be necessary.
In principle, the same considerations apply for RPA and GW as well, however, the accuracy requirements are somewhat higher and 12 point are the default for RPA. In a GW calculation, the number of points is adjusted according to the numerical quality. Using less than 9 points is strongly discouraged except for the simplest molecules.
In ADF2019, it can happen that the algorithm determining the imaginary time grid does not converge. In this case, the usual reason is that the number of points is too small and more points need to be specified. Starting from AMS2020, this does not happen any more. In case the imaginary time grid does not converge, the number of points is automatically adjusted until it does.
The computation time of AO-PARI-MP2, RPA, and GW scales linearly with the number of imaginary time points.
:vartype nTime: int | IntKey
:ivar useGreenXgrids: Use GreenX library to generate grid points. This is recommended for larger number of grid points (> 20). Up to 34 points can be requested.
:vartype useGreenXgrids: BoolType | BoolKey
"""
def __post_init__(self):
self.Dependency: BoolType | BoolKey = BoolKey(name='Dependency', comment="If true, to improve numerical stability, almost linearly-dependent combination of basis functions are removed from the Green's function that are used in the MBPT equations. Disabling this key is strongly discouraged. Its value can however be changed. The key to adjust this value is RiHartreeFock%DependencyThreshold", default=True)
self.Enabled: BoolType | BoolKey = BoolKey(name='Enabled', comment='Enable the calculation of the MP2 energy.', hidden=True, default=False)
self.ExcludeCore: BoolType | BoolKey = BoolKey(name='ExcludeCore', comment='If active, excludes core states from the calculation of the optimal imaginary time and frequency grids.\n\nThe core states are still included in all parts of the calculations.\n\nIn case a frozen care calculation is performed, this key is ignored.\n\nFor MP2 and double hybrid calculation, it defaults to false. For RPA and GW calculations, it defaults to true.')
self.FitSetQuality: Literal["Auto", "VeryBasic", "Basic", "Normal", "Good", "VeryGood"] = MultipleChoiceKey(name='FitSetQuality', comment="Specifies the fit set to be used in the MBPT calculation.\n\n'Normal' quality is generally sufficient for basis sets up to and including TZ2P.\n\nFor larger basis sets (or for benchmarking purposes) a 'VeryGood' fit set is recommended. Note that the FitSetQuality heavily influences the computational cost of the calculation.\n\nIf not specified or 'Auto', the RIHartreeFock%FitSetQuality is used.", default='Auto', choices=['Auto', 'VeryBasic', 'Basic', 'Normal', 'Good', 'VeryGood'])
self.Formalism: Literal["Auto", "RI", "LT", "All"] = MultipleChoiceKey(name='Formalism', comment="Specifies the formalism for the calculation of the MP2 correlation energy.\n\n'LT' means Laplace Transformed MP2 (also referred to as AO-PARI-MP2),\n\n'RI' means that a conventional RI-MP2 is carried out.\n\nIf 'Auto', LT will be used in case of DOD double hybrids and SOS MP2, and RI will be used in all other cases.\n\n'All' means that both RI and LT formalisms are used in the calculation.\n\nFor a RPA or GW calculation, the formalism is always LT, irrespective of the formalism specified with this key.", default='Auto', choices=['Auto', 'RI', 'LT', 'All'])
self.FrequencyGridType: Literal["LeastSquare", "GaussLegendre"] = MultipleChoiceKey(name='FrequencyGridType', comment='Use Gauss-legendre grid for imaginary frequency integration in RPA and GW calculations instead of the usually used Least-Square optimized ones. Has the advantage that it can be systematically converged and an arbitrary number of grid points can be used. Typically more grid points will be needed to get the same level of accuracy. However, the convergence of the results with the size of the grid can be more systematic. These grids can only be used when Formalism is set to RI.', default='LeastSquare', choices=['LeastSquare', 'GaussLegendre'])
self.IntegrationQuality: Literal["VeryBasic", "Basic", "Normal", "Good", "VeryGood"] = MultipleChoiceKey(name='IntegrationQuality', comment='Specifies the integration quality to be used in the MBPT calculation. If not specified, the RIHartreeFock%IntegrationQuality is used.', choices=['VeryBasic', 'Basic', 'Normal', 'Good', 'VeryGood'])
self.PrintOutSigma: BoolType | BoolKey = BoolKey(name='PrintOutSigma', comment='Print out additional output for sigma-functional for parametrization. ', hidden=True, default=False)
self.SigmaFunctionalParametrization: Literal["W1", "W2", "S1", "S2", "S1re"] = MultipleChoiceKey(name='SigmaFunctionalParametrization', comment='Only relevant if a sigma-functional calculation is performed. Possible choices for the parametrization of the sigma-functional. Not all options are supported for all functionals.', default='S1re', choices=['W1', 'W2', 'S1', 'S2', 'S1re'])
self.ThresholdQuality: Literal["VeryBasic", "Basic", "Normal", "Good", "VeryGood", "Excellent"] = MultipleChoiceKey(name='ThresholdQuality', comment="Controls the distances between atomic centers for which the product of two basis functions is not fitted any more. Especially for spatially extended, large systems, 'VERYBASIC' and 'BASIC' can lead to large computational savings, but the fit is also more approximate. If not specified, the RIHartreeFock%ThresholdQuality is used.", choices=['VeryBasic', 'Basic', 'Normal', 'Good', 'VeryGood', 'Excellent'])
self.UseScaledZORA: BoolType | BoolKey = BoolKey(name='UseScaledZORA', comment='If true, use the scaled ZORA orbital energies instead of the ZORA orbital energies in the MBPT equations.', default=True)
self.cutOfftransition: float | FloatKey = FloatKey(name='cutOfftransition', comment='Energy above which states are ignored in a MBPT calculation (must be a positive number). The default energy is chosen so high, that all states are included except for the ones which have been removed.', hidden=True, default=20000000000.0)
self.frozencore: BoolType | BoolKey = BoolKey(name='frozencore', comment='Freeze core states in correlation part of MBPT calculation', default=False)
self.nCore: int | IntKey = IntKey(name='nCore', comment='Number of core states which will be excluded from the correlated calculation.\n\nWill be ignored if frozencore is false.\n\nIn case nothing is specified, the number of core levels will be determined automatically.\n\nNeeds to be smaller than the number of occupied states.', gui_name='Number of core levels:', default=0)
self.nFreqIntegration: int | IntKey = IntKey(name='nFreqIntegration', comment='Number of imaginary frequency points for G3W2 integration', gui_name='N freq points for G3W2 integration:', default=32)
self.nFrequency: int | IntKey = IntKey(name='nFrequency', comment='Number of imaginary frequency points. This key is only relevant for RPA and GW and will be ignored if used in an AO-PARI-MP2 calculation. 12 Points is the default for a RPA calculation. It is technically possible to use a different number of imaginary frequency points than for imaginary time. The maximum number of points which can be requested for imaginary frequency integration is 42. Important note: The computation time and memory requirements roughly scale linearly with the number of imaginary frequency points. However, memory can be an issue for RPA and GW when the number of imaginary frequency points is high. In case a job crashes, it is advised to increase the number of nodes since the necessary memory distributes over all nodes.', gui_name='N freq points:', default=12)
self.nLambda: int | IntKey = IntKey(name='nLambda', comment='Size of coupling constant integration grid for SOSEX variants in RPA. Default is 4 points', gui_name='Number of lambda points:', default=1)
self.nTime: int | IntKey = IntKey(name='nTime', comment='Number of imaginary time points (only relevant in case the Laplace Transformed (LT) formalism is used).\n\nIn the many-body-perturbation theory module in ADF, the polarizability (or Kohn-Sham density response function) is evaluated in imaginary time to exploit sparsity in the AO basis. For MP2, this is often referred to as a Laplace transform. For MP2, 9 points are the default. This is a safe choice, guaranteeing accuracies higher than 1 Kj/mol for most systems (For many simple organic systems, 6 points are sufficient for good accuracy).\n\nOnly for systems with a very small HOMO-LUMO gap or low-lying core states (heavy elements starting from the 4th row of the periodic table) more points might be necessary.\n\nIn principle, the same considerations apply for RPA and GW as well, however, the accuracy requirements are somewhat higher and 12 point are the default for RPA. In a GW calculation, the number of points is adjusted according to the numerical quality. Using less than 9 points is strongly discouraged except for the simplest molecules.\n\nIn ADF2019, it can happen that the algorithm determining the imaginary time grid does not converge. In this case, the usual reason is that the number of points is too small and more points need to be specified. Starting from AMS2020, this does not happen any more. In case the imaginary time grid does not converge, the number of points is automatically adjusted until it does.\n\nThe computation time of AO-PARI-MP2, RPA, and GW scales linearly with the number of imaginary time points.', gui_name='Number of time points:')
self.useGreenXgrids: BoolType | BoolKey = BoolKey(name='useGreenXgrids', comment='Use GreenX library to generate grid points. This is recommended for larger number of grid points (> 20). Up to 34 points can be requested.', default=False)
[docs] class _MolecularNMR(FixedBlock):
r"""
Options for the calculations of the NMR shielding tensor for molecules, excluding periodic systems. Implements the Schreckenbach method like ADF.
:ivar Enabled: Compute NMR shielding.
:vartype Enabled: BoolType | BoolKey
"""
def __post_init__(self):
self.Enabled: BoolType | BoolKey = BoolKey(name='Enabled', comment='Compute NMR shielding.', default=False)
[docs] class _MultiSecantConfig(FixedBlock):
r"""
Parameters for the Multi-secant SCF convergence method.
:ivar CMax: Maximum coefficient allowed in expansion
:vartype CMax: float | FloatKey
:ivar InitialSigmaN: This is a lot like a mix factor: bigger means bolder
:vartype InitialSigmaN: float | FloatKey
:ivar MaxSigmaN: Upper bound for the SigmaN parameter
:vartype MaxSigmaN: float | FloatKey
:ivar MaxVectors: Maximum number of previous cycles to be used
:vartype MaxVectors: int | IntKey
:ivar MinSigmaN: Lower bound for the SigmaN parameter
:vartype MinSigmaN: float | FloatKey
:ivar PredictGreed: Currently not used.
:vartype PredictGreed: BoolType | BoolKey
:ivar Renormalize: Whether to renormalize matrix An with Psi. Affects regularization.
:vartype Renormalize: BoolType | BoolKey
:ivar SigmaRegularize: Prevent division by zero by adding a small number. Makes most sense when using renormalization.
:vartype SigmaRegularize: float | FloatKey
:ivar Tweak1: Stick closer too the article: sigmaN < R abs(p)/abs(g) rather than sigmaN < R abs(u)/abs(p), where u is the unpredicted part, p the predicted part and g is the current error
:vartype Tweak1: BoolType | BoolKey
:ivar Tweak2: assume x = x + H error rather than x = x - H error
:vartype Tweak2: BoolType | BoolKey
:ivar Variant: There are several version of the Multi secant method.
:vartype Variant: Literal["MSB2"]
"""
def __post_init__(self):
self.CMax: float | FloatKey = FloatKey(name='CMax', comment='Maximum coefficient allowed in expansion', gui_name='Max coeff:', default=20.0)
self.InitialSigmaN: float | FloatKey = FloatKey(name='InitialSigmaN', comment='This is a lot like a mix factor: bigger means bolder', gui_name='Initial:', default=0.1)
self.MaxSigmaN: float | FloatKey = FloatKey(name='MaxSigmaN', comment='Upper bound for the SigmaN parameter', gui_name='Max:', default=0.3)
self.MaxVectors: int | IntKey = IntKey(name='MaxVectors', comment='Maximum number of previous cycles to be used', gui_name='Number of cycles to use:', default=20)
self.MinSigmaN: float | FloatKey = FloatKey(name='MinSigmaN', comment='Lower bound for the SigmaN parameter', gui_name='Min:', default=0.01)
self.PredictGreed: BoolType | BoolKey = BoolKey(name='PredictGreed', comment='Currently not used.', hidden=True, default=False)
self.Renormalize: BoolType | BoolKey = BoolKey(name='Renormalize', comment='Whether to renormalize matrix An with Psi. Affects regularization.', hidden=True, default=False)
self.SigmaRegularize: float | FloatKey = FloatKey(name='SigmaRegularize', comment='Prevent division by zero by adding a small number. Makes most sense when using renormalization.', hidden=True, default=1e-12)
self.Tweak1: BoolType | BoolKey = BoolKey(name='Tweak1', comment='Stick closer too the article: sigmaN < R abs(p)/abs(g) rather than sigmaN < R abs(u)/abs(p), where u is the unpredicted part, p the predicted part and g is the current error', hidden=True, default=False)
self.Tweak2: BoolType | BoolKey = BoolKey(name='Tweak2', comment='assume x = x + H error rather than x = x - H error', hidden=True, default=False)
self.Variant: Literal["MSB2"] = MultipleChoiceKey(name='Variant', comment='There are several version of the Multi secant method.', hidden=True, default='MSB2', choices=['MSB2'])
[docs] class _NEGF(FixedBlock):
r"""
Options for the NEGF (non-equilibrium green function) transport calculation.
:ivar AlignChargeTol: In an alignment run you want to get the number of electrons in the center right. This number specifies the criterion for that.
:vartype AlignChargeTol: float | FloatKey
:ivar AlignmentFile: Band result file (.rkf) corresponding to the alignment calculation.
:vartype AlignmentFile: str | StringKey
:ivar Alpha: A charge error needs to be translated in a potential shift. DeltaV = alpha * DeltaQ
:vartype Alpha: float | FloatKey
:ivar ApplyShift1: Apply the main shift, obtained from comparing matrix elements in the leads with those from the tight-binding run. Strongly recommended.
:vartype ApplyShift1: BoolType | BoolKey
:ivar ApplyShift2: Apply the smaller alignment shift. This requires an extra alignment run. Usually this shift is smaller.
:vartype ApplyShift2: BoolType | BoolKey
:ivar AutoContour: Use automatic contour integral.
:vartype AutoContour: BoolType | BoolKey
:ivar BiasPotential: Apply a bias potential (atomic units). Can be negative. One has to specify the ramp potential with the FuzzyPotential key. This is mostly conveniently done with the GUI.
:vartype BiasPotential: float | FloatKey
:ivar BoundOccupationMethod: See text. Only relevant with NonEqDensityMethod equal 2 or 3.
:vartype BoundOccupationMethod: int | IntKey
:ivar CDIIS: Make the normal DIIS procedure aware of the align charge error
:vartype CDIIS: BoolType | BoolKey
:ivar CheckOverlapTol: BAND checks how well the TB overlap matrix S(R=0) represents the overlap matrix in the lead region. Elements corresponding to the outer layer are neglected, because when using a frozen core they have bigger errors.
:vartype CheckOverlapTol: float | FloatKey
:ivar ContourQuality: The density matrix is calculated numerically via a contour integral. Changing the quality influences the number of points. This influences a lot the performance.
:vartype ContourQuality: Literal["basic", "normal", "good", "verygood"]
:ivar DEContourInt: The energy interval for the contour grid. Defaults depends on the contour quality
:vartype DEContourInt: float | FloatKey
:ivar DERealAxisInt: The energy interval for the real axis grid. Defaults depends on the contour quality.
:vartype DERealAxisInt: float | FloatKey
:ivar DeltaPhi0: Undocumented.
:vartype DeltaPhi0: float | FloatKey
:ivar DeltaPhi1: Undocumented.
:vartype DeltaPhi1: float | FloatKey
:ivar DoAlignment: Set this to True if you want to do an align run. Between the leads there should be lead material. The GUI can be of help here.
:vartype DoAlignment: BoolType | BoolKey
:ivar EMax: The maximum energy for the transmission grid (with respect to the Fermi level of the lead)
:vartype EMax: float | FloatKey
:ivar EMin: The minimum energy for the transmission grid (with respect to the Fermi level of the lead)
:vartype EMin: float | FloatKey
:ivar Eta: Small value used for the contour integral: stay at least this much above the real axis. This value is also used for the evaluation of the Transmission and dos.
:vartype Eta: float | FloatKey
:ivar IgnoreOuterLayer: Whether or not to ignore the outer layer.
:vartype IgnoreOuterLayer: BoolType | BoolKey
:ivar KT: k-Boltzmann times temperature.
:vartype KT: float | FloatKey
:ivar LeadFile: File containing the tight binding representation of the lead.
:vartype LeadFile: str | StringKey
:ivar ModuloAlignCycle: Undocumented.
:vartype ModuloAlignCycle: int | IntKey
:ivar NE: The number of energies for the transmission energy grid.
:vartype NE: int | IntKey
:ivar NMovingAverage: Undocumented.
:vartype NMovingAverage: int | IntKey
:ivar NonEqDensityMethod: See text.
:vartype NonEqDensityMethod: int | IntKey
:ivar OverwriteLeadFock: Undocumented.
:vartype OverwriteLeadFock: BoolType | BoolKey
:ivar PlotInterval: Undocumented.
:vartype PlotInterval: int | IntKey
:ivar SGFFile: The result from the SGF program. Contains the Fermi energy of the lead.
:vartype SGFFile: str | StringKey
:ivar SGFTol: Undocumented.
:vartype SGFTol: float | FloatKey
:ivar StartAlignCycle: Undocumented.
:vartype StartAlignCycle: int | IntKey
:ivar YContourInt: The density is calculated via a contour integral. This value specifies how far above the real axis the (horizontal part of the) contour runs. The value is rounded in such a way that it goes exactly halfway between two Fermi poles. There is a trade off: making it bigger makes the integrand more smooth, but the number of enclosed poles increases. For low temperatures it makes sense to lower this value, and use a smaller deContourInt.
:vartype YContourInt: float | FloatKey
:ivar YRealaxisInt: The non-Equilibrium density is calculated near the real axis.
:vartype YRealaxisInt: float | FloatKey
"""
def __post_init__(self):
self.AlignChargeTol: float | FloatKey = FloatKey(name='AlignChargeTol', comment='In an alignment run you want to get the number of electrons in the center right. This number specifies the criterion for that.', default=0.1)
self.AlignmentFile: str | StringKey = StringKey(name='AlignmentFile', comment='Band result file (.rkf) corresponding to the alignment calculation.', default=' ')
self.Alpha: float | FloatKey = FloatKey(name='Alpha', comment='A charge error needs to be translated in a potential shift. DeltaV = alpha * DeltaQ', default=1e-05)
self.ApplyShift1: BoolType | BoolKey = BoolKey(name='ApplyShift1', comment='Apply the main shift, obtained from comparing matrix elements in the leads with those from the tight-binding run. Strongly recommended.', default=True)
self.ApplyShift2: BoolType | BoolKey = BoolKey(name='ApplyShift2', comment='Apply the smaller alignment shift. This requires an extra alignment run. Usually this shift is smaller.', default=True)
self.AutoContour: BoolType | BoolKey = BoolKey(name='AutoContour', comment='Use automatic contour integral.', default=True)
self.BiasPotential: float | FloatKey = FloatKey(name='BiasPotential', comment='Apply a bias potential (atomic units). Can be negative. One has to specify the ramp potential with the FuzzyPotential key. This is mostly conveniently done with the GUI.', default=0.0)
self.BoundOccupationMethod: int | IntKey = IntKey(name='BoundOccupationMethod', comment='See text. Only relevant with NonEqDensityMethod equal 2 or 3.', default=1)
self.CDIIS: BoolType | BoolKey = BoolKey(name='CDIIS', comment='Make the normal DIIS procedure aware of the align charge error', default=False)
self.CheckOverlapTol: float | FloatKey = FloatKey(name='CheckOverlapTol', comment='BAND checks how well the TB overlap matrix S(R=0) represents the overlap matrix in the lead region. Elements corresponding to the outer layer are neglected, because when using a frozen core they have bigger errors.', default=0.01)
self.ContourQuality: Literal["basic", "normal", "good", "verygood"] = MultipleChoiceKey(name='ContourQuality', comment='The density matrix is calculated numerically via a contour integral. Changing the quality influences the number of points. This influences a lot the performance.', default='good', choices=['basic', 'normal', 'good', 'verygood'])
self.DEContourInt: float | FloatKey = FloatKey(name='DEContourInt', comment='The energy interval for the contour grid. Defaults depends on the contour quality', default=-1.0)
self.DERealAxisInt: float | FloatKey = FloatKey(name='DERealAxisInt', comment='The energy interval for the real axis grid. Defaults depends on the contour quality.', default=-1.0)
self.DeltaPhi0: float | FloatKey = FloatKey(name='DeltaPhi0', comment='Undocumented.', default=0.0)
self.DeltaPhi1: float | FloatKey = FloatKey(name='DeltaPhi1', comment='Undocumented.', default=0.0)
self.DoAlignment: BoolType | BoolKey = BoolKey(name='DoAlignment', comment='Set this to True if you want to do an align run. Between the leads there should be lead material. The GUI can be of help here.', default=False)
self.EMax: float | FloatKey = FloatKey(name='EMax', comment='The maximum energy for the transmission grid (with respect to the Fermi level of the lead)', default=5.0, unit='eV')
self.EMin: float | FloatKey = FloatKey(name='EMin', comment='The minimum energy for the transmission grid (with respect to the Fermi level of the lead)', default=-5.0, unit='eV')
self.Eta: float | FloatKey = FloatKey(name='Eta', comment='Small value used for the contour integral: stay at least this much above the real axis. This value is also used for the evaluation of the Transmission and dos.', default=1e-05)
self.IgnoreOuterLayer: BoolType | BoolKey = BoolKey(name='IgnoreOuterLayer', comment='Whether or not to ignore the outer layer.', default=True)
self.KT: float | FloatKey = FloatKey(name='KT', comment='k-Boltzmann times temperature.', default=0.001)
self.LeadFile: str | StringKey = StringKey(name='LeadFile', comment='File containing the tight binding representation of the lead.', default=' ')
self.ModuloAlignCycle: int | IntKey = IntKey(name='ModuloAlignCycle', comment='Undocumented.', hidden=True, default=3)
self.NE: int | IntKey = IntKey(name='NE', comment='The number of energies for the transmission energy grid.', default=100)
self.NMovingAverage: int | IntKey = IntKey(name='NMovingAverage', comment='Undocumented.', hidden=True, default=1)
self.NonEqDensityMethod: int | IntKey = IntKey(name='NonEqDensityMethod', comment='See text.', default=1)
self.OverwriteLeadFock: BoolType | BoolKey = BoolKey(name='OverwriteLeadFock', comment='Undocumented.', hidden=True, default=True)
self.PlotInterval: int | IntKey = IntKey(name='PlotInterval', comment='Undocumented.', hidden=True, default=1000)
self.SGFFile: str | StringKey = StringKey(name='SGFFile', comment='The result from the SGF program. Contains the Fermi energy of the lead.', default=' ')
self.SGFTol: float | FloatKey = FloatKey(name='SGFTol', comment='Undocumented.', hidden=True, default=1e-08)
self.StartAlignCycle: int | IntKey = IntKey(name='StartAlignCycle', comment='Undocumented.', hidden=True, default=10)
self.YContourInt: float | FloatKey = FloatKey(name='YContourInt', comment='The density is calculated via a contour integral. This value specifies how far above the real axis the (horizontal part of the) contour runs. The value is rounded in such a way that it goes exactly halfway between two Fermi poles. There is a trade off: making it bigger makes the integrand more smooth, but the number of enclosed poles increases. For low temperatures it makes sense to lower this value, and use a smaller deContourInt.', default=0.3)
self.YRealaxisInt: float | FloatKey = FloatKey(name='YRealaxisInt', comment='The non-Equilibrium density is calculated near the real axis.', default=1e-05)
[docs] class _NMR(FixedBlock):
r"""
Options for the calculations of the NMR shielding tensor.
:ivar Correct_rmu: Undocumented.
:vartype Correct_rmu: BoolType | BoolKey
:ivar Correction_r: Undocumented.
:vartype Correction_r: BoolType | BoolKey
:ivar Debug_r_corr: Undocumented.
:vartype Debug_r_corr: BoolType | BoolKey
:ivar Enabled: Compute NMR shielding.
:vartype Enabled: BoolType | BoolKey
:ivar MS0: Undocumented.
:vartype MS0: float | FloatKey
:ivar NMRAtom: The index of the atom atom (in input order) for which NMR should be computed.
:vartype NMRAtom: int | IntKey
:ivar Numeric: Undocumented.
:vartype Numeric: BoolType | BoolKey
:ivar Obsolete: Undocumented.
:vartype Obsolete: BoolType | BoolKey
:ivar OnlyNDimBasPnt: Undocumented.
:vartype OnlyNDimBasPnt: BoolType | BoolKey
:ivar Original: Undocumented.
:vartype Original: BoolType | BoolKey
:ivar PrintK: Undocumented.
:vartype PrintK: BoolType | BoolKey
:ivar Print_jp: Print paramagnetic current.
:vartype Print_jp: BoolType | BoolKey
:ivar SharedArrayColumnLock: Undocumented.
:vartype SharedArrayColumnLock: BoolType | BoolKey
:ivar SuperCell: This is the switch between the two methods, either the super cell (true), or the single-dipole method (false)
:vartype SuperCell: BoolType | BoolKey
:ivar Test: Key for printing all intrinsic tensors.
:vartype Test: BoolType | BoolKey
:ivar Test_E: Test of energy levels.
:vartype Test_E: BoolType | BoolKey
:ivar Test_S: Test of overlap matrix.
:vartype Test_S: BoolType | BoolKey
:ivar UpdateForBlockOption: Undocumented.
:vartype UpdateForBlockOption: int | IntKey
:ivar UseSharedMemory: Whether or not to use shared memory in the NMR calculation.
:vartype UseSharedMemory: BoolType | BoolKey
"""
def __post_init__(self):
self.Correct_rmu: BoolType | BoolKey = BoolKey(name='Correct_rmu', comment='Undocumented.', hidden=True, default=True)
self.Correction_r: BoolType | BoolKey = BoolKey(name='Correction_r', comment='Undocumented.', default=True)
self.Debug_r_corr: BoolType | BoolKey = BoolKey(name='Debug_r_corr', comment='Undocumented.', hidden=True, default=True)
self.Enabled: BoolType | BoolKey = BoolKey(name='Enabled', comment='Compute NMR shielding.', default=False)
self.MS0: float | FloatKey = FloatKey(name='MS0', comment='Undocumented.', default=0.01)
self.NMRAtom: int | IntKey = IntKey(name='NMRAtom', comment='The index of the atom atom (in input order) for which NMR should be computed.', default=0)
self.Numeric: BoolType | BoolKey = BoolKey(name='Numeric', comment='Undocumented.', default=False)
self.Obsolete: BoolType | BoolKey = BoolKey(name='Obsolete', comment='Undocumented.', hidden=True, default=False)
self.OnlyNDimBasPnt: BoolType | BoolKey = BoolKey(name='OnlyNDimBasPnt', comment='Undocumented.', hidden=True, default=False)
self.Original: BoolType | BoolKey = BoolKey(name='Original', comment='Undocumented.', default=False)
self.PrintK: BoolType | BoolKey = BoolKey(name='PrintK', comment='Undocumented.', hidden=True)
self.Print_jp: BoolType | BoolKey = BoolKey(name='Print_jp', comment='Print paramagnetic current.')
self.SharedArrayColumnLock: BoolType | BoolKey = BoolKey(name='SharedArrayColumnLock', comment='Undocumented.', hidden=True, default=True)
self.SuperCell: BoolType | BoolKey = BoolKey(name='SuperCell', comment='This is the switch between the two methods, either the super cell (true), or the single-dipole method (false)', default=True)
self.Test: BoolType | BoolKey = BoolKey(name='Test', comment='Key for printing all intrinsic tensors.')
self.Test_E: BoolType | BoolKey = BoolKey(name='Test_E', comment='Test of energy levels.')
self.Test_S: BoolType | BoolKey = BoolKey(name='Test_S', comment='Test of overlap matrix.')
self.UpdateForBlockOption: int | IntKey = IntKey(name='UpdateForBlockOption', comment='Undocumented.', hidden=True, default=1)
self.UseSharedMemory: BoolType | BoolKey = BoolKey(name='UseSharedMemory', comment='Whether or not to use shared memory in the NMR calculation.', default=True)
[docs] class _NOCVOrbitalPlot(FreeBlock):
r"""
Goes together with the Restart%NOCVOrbitalPlot and Grid keys. See example.
"""
def __post_init__(self):
pass
[docs] class _NOCVdRhoPlot(FreeBlock):
r"""
Goes together with the Restart%NOCVdRhoPlot and Grid keys. See example.
"""
def __post_init__(self):
pass
[docs] class _NOPROrbitalPlot(FreeBlock):
r"""
Undocumented.
"""
def __post_init__(self):
pass
[docs] class _NOPRdRhoPlot(FreeBlock):
r"""
Undocumented.
"""
def __post_init__(self):
pass
[docs] class _NeutralizingDensityDetails(FixedBlock):
r"""
:ivar DiffuseFactor: The bigger this number, the more diffuse (extended) the neutralizing density becomes. Works only for rho(neutralizing/atoms)
:vartype DiffuseFactor: float | FloatKey
:ivar IncludeSelfTerm: The energy should contain the self term for consistent energy and gradients.
:vartype IncludeSelfTerm: BoolType | BoolKey
:ivar HomogeneousDensity: xxx
:vartype HomogeneousDensity: BAND._NeutralizingDensityDetails._HomogeneousDensity
"""
[docs] class _HomogeneousDensity(FixedBlock):
r"""
xxx
:ivar Origin:
:vartype Origin: Iterable[float] | FloatListKey
:ivar Range:
:vartype Range: float | FloatKey
:ivar Width:
:vartype Width: float | FloatKey
"""
def __post_init__(self):
self.Origin: Iterable[float] | FloatListKey = FloatListKey(name='Origin', default=[0.0, 0.0, 0.0], unit='Bohr')
self.Range: float | FloatKey = FloatKey(name='Range', default=10.0, unit='Bohr')
self.Width: float | FloatKey = FloatKey(name='Width', default=1.0, unit='Bohr')
def __post_init__(self):
self.DiffuseFactor: float | FloatKey = FloatKey(name='DiffuseFactor', comment='The bigger this number, the more diffuse (extended) the neutralizing density becomes. Works only for rho(neutralizing/atoms)', default=1.0)
self.IncludeSelfTerm: BoolType | BoolKey = BoolKey(name='IncludeSelfTerm', comment='The energy should contain the self term for consistent energy and gradients.', hidden=True, default=False)
self.HomogeneousDensity: BAND._NeutralizingDensityDetails._HomogeneousDensity = self._HomogeneousDensity(name='HomogeneousDensity', comment='xxx')
[docs] class _NewResponse(FixedBlock):
r"""
The TD-CDFT calculation to obtain the dielectric function is computed when this block is present in the input. Several important settings can be defined here.
:ivar ActiveESpace: Modifies the energy threshold (DeltaE^{max}_{thresh} = omega_{high} + ActiveESpace) for which single orbital transitions (DeltaEpsilon_{ia} = Epsilon_{a}^{virtual} - Epsilon_{i}^{occupied}) are taken into account.
:vartype ActiveESpace: float | FloatKey
:ivar ActiveXYZ: Expects a string consisting of three letters of either 'T' (for true) or 'F' (for false) where the first is for the X-, the second for the Y- and the third for the Z-component of the response properties. If true, then the response properties for this component will be evaluated.
:vartype ActiveXYZ: str | StringKey
:ivar DensityCutOff: For 1D and 2D systems the unit cell volume is undefined. Here, the volume is calculated as the volume bordered by the isosurface for the value DensityCutoff of the total density.
:vartype DensityCutOff: float | FloatKey
:ivar EShift: Energy shift of the virtual crystal orbitals.
:vartype EShift: float | FloatKey
:ivar FreqHigh: Upper limit of the frequency range for which response properties are calculated (omega_{high}).
:vartype FreqHigh: float | FloatKey
:ivar FreqLow: Lower limit of the frequency range for which response properties are calculated. (omega_{low})
:vartype FreqLow: float | FloatKey
:ivar NFreq: Number of frequencies for which a linear response TD-CDFT calculation is performed.
:vartype NFreq: int | IntKey
:ivar BugFixes: Allows the user to control bug fixes to check older results
:vartype BugFixes: BAND._NewResponse._BugFixes
"""
[docs] class _BugFixes(FixedBlock):
r"""
Allows the user to control bug fixes to check older results
:ivar CopyTiaOldAlda: NFreq was reduced by one in case of old alda. Does not influence the calculation, but changes band.rkf used by the gui
:vartype CopyTiaOldAlda: BoolType | BoolKey
:ivar NoScissorsInJia: The scissors operator lifts the virtual eigenvalues, but this should not be done while calculating the Jia matrix.
Relates (logically inversely) to OldResponse%Bugfixes%NewAldaShift.
:vartype NoScissorsInJia: BoolType | BoolKey
:ivar PotTimesTwo: Undocumented.
:vartype PotTimesTwo: BoolType | BoolKey
:ivar SignJia2: Undocumented.
:vartype SignJia2: BoolType | BoolKey
:ivar SwapPiaPai: Undocumented.
:vartype SwapPiaPai: BoolType | BoolKey
:ivar WeightsTimesTwo: Multiply k-space weights times two. No effect when UseOldResponseWeights=yes
:vartype WeightsTimesTwo: BoolType | BoolKey
"""
def __post_init__(self):
self.CopyTiaOldAlda: BoolType | BoolKey = BoolKey(name='CopyTiaOldAlda', comment='NFreq was reduced by one in case of old alda. Does not influence the calculation, but changes band.rkf used by the gui', hidden=True, default=False)
self.NoScissorsInJia: BoolType | BoolKey = BoolKey(name='NoScissorsInJia', comment='The scissors operator lifts the virtual eigenvalues, but this should not be done while calculating the Jia matrix.\n Relates (logically inversely) to OldResponse%Bugfixes%NewAldaShift.', hidden=True, default=True)
self.PotTimesTwo: BoolType | BoolKey = BoolKey(name='PotTimesTwo', comment='Undocumented.', hidden=True, default=True)
self.SignJia2: BoolType | BoolKey = BoolKey(name='SignJia2', comment='Undocumented.', hidden=True, default=True)
self.SwapPiaPai: BoolType | BoolKey = BoolKey(name='SwapPiaPai', comment='Undocumented.', hidden=True, default=True)
self.WeightsTimesTwo: BoolType | BoolKey = BoolKey(name='WeightsTimesTwo', comment='Multiply k-space weights times two. No effect when UseOldResponseWeights=yes', hidden=True, default=True)
def __post_init__(self):
self.ActiveESpace: float | FloatKey = FloatKey(name='ActiveESpace', comment='Modifies the energy threshold (DeltaE^{max}_{thresh} = omega_{high} + ActiveESpace) for which single orbital transitions (DeltaEpsilon_{ia} = Epsilon_{a}^{virtual} - Epsilon_{i}^{occupied}) are taken into account.', gui_name='Active energy space:', default=5.0, unit='eV')
self.ActiveXYZ: str | StringKey = StringKey(name='ActiveXYZ', comment="Expects a string consisting of three letters of either 'T' (for true) or 'F' (for false) where the first is for the X-, the second for the Y- and the third for the Z-component of the response properties. If true, then the response properties for this component will be evaluated.", default='t')
self.DensityCutOff: float | FloatKey = FloatKey(name='DensityCutOff', comment='For 1D and 2D systems the unit cell volume is undefined. Here, the volume is calculated as the volume bordered by the isosurface for the value DensityCutoff of the total density.', gui_name='Volume cutoff:', default=0.001)
self.EShift: float | FloatKey = FloatKey(name='EShift', comment='Energy shift of the virtual crystal orbitals.', gui_name='Shift:', default=0.0, unit='eV')
self.FreqHigh: float | FloatKey = FloatKey(name='FreqHigh', comment='Upper limit of the frequency range for which response properties are calculated (omega_{high}).', default=3.0, unit='eV')
self.FreqLow: float | FloatKey = FloatKey(name='FreqLow', comment='Lower limit of the frequency range for which response properties are calculated. (omega_{low})', default=1.0, unit='eV')
self.NFreq: int | IntKey = IntKey(name='NFreq', comment='Number of frequencies for which a linear response TD-CDFT calculation is performed.', default=5)
self.BugFixes: BAND._NewResponse._BugFixes = self._BugFixes(name='BugFixes', comment='Allows the user to control bug fixes to check older results', hidden=True)
[docs] class _NewResponseKSpace(FixedBlock):
r"""
Modify the details for the integration weights evaluation in reciprocal space for each single-particle transition. Only influencing the NewResponse code.
:ivar Eta: Defines the small, finite imaginary number i*eta which is necessary in the context of integration weights for single-particle transitions in reciprocal space.
:vartype Eta: float | FloatKey
:ivar HardIntegral: Undocumented.
:vartype HardIntegral: BoolType | BoolKey
:ivar NSlices: Undocumented.
:vartype NSlices: int | IntKey
:ivar SubSimp: determines into how many sub-integrals each integration around a k point is split. This is only true for so-called quadratic integration grids. The larger the number the better the convergence behavior for the sampling in reciprocal space. Note: the computing time for the weights is linear for 1D, quadratic for 2D and cubic for 3D!
:vartype SubSimp: int | IntKey
:ivar UseOldResponseWeights: Call the old code to generate the response weights. If true then all other arguments of NewResponseKSpace are ignored
:vartype UseOldResponseWeights: BoolType | BoolKey
"""
def __post_init__(self):
self.Eta: float | FloatKey = FloatKey(name='Eta', comment='Defines the small, finite imaginary number i*eta which is necessary in the context of integration weights for single-particle transitions in reciprocal space.', default=1e-05)
self.HardIntegral: BoolType | BoolKey = BoolKey(name='HardIntegral', comment='Undocumented.', hidden=True, default=True)
self.NSlices: int | IntKey = IntKey(name='NSlices', comment='Undocumented.', hidden=True, default=3)
self.SubSimp: int | IntKey = IntKey(name='SubSimp', comment='determines into how many sub-integrals each integration around a k point is split. This is only true for so-called quadratic integration grids. The larger the number the better the convergence behavior for the sampling in reciprocal space. Note: the computing time for the weights is linear for 1D, quadratic for 2D and cubic for 3D!', default=3)
self.UseOldResponseWeights: BoolType | BoolKey = BoolKey(name='UseOldResponseWeights', comment='Call the old code to generate the response weights. If true then all other arguments of NewResponseKSpace are ignored', hidden=True, default=False)
[docs] class _NewResponseSCF(FixedBlock):
r"""
Details for the linear-response self-consistent optimization cycle. Only influencing the NewResponse code.
:ivar Bootstrap: defines if the Berger2015 kernel (Bootstrap 1) is used or not (Bootstrap 0). If you chose the Berger2015 kernel, you have to set NewResponseSCF%XC to '0'. Since it shall be used in combination with the bare Coulomb response only. Note: The evaluation of response properties using the Berger2015 is recommend for 3D systems only!
:vartype Bootstrap: int | IntKey
:ivar COApproach: The program automatically decides to calculate the integrals and induced densities via the Bloch expanded atomic orbitals (AO approach) or via the cyrstal orbitals (CO approach). The option COApproach overrules this decision.
:vartype COApproach: BoolType | BoolKey
:ivar COApproachBoost: Keeps the grid data of the Crystal Orbitals in memory.
Requires significantly more memory for a speedup of the calculation. One might have to use multiple computing nodes to not run into memory problems.
:vartype COApproachBoost: BoolType | BoolKey
:ivar Criterion: For the SCF convergence the RMS of the induced density change is tested. If this value is below the Criterion the SCF is finished.
Furthermore, one can find the calculated electric susceptibility for each SCF step in the output and can therefore decide if the default value is too loose or too strict.
:vartype Criterion: float | FloatKey
:ivar LowFreqAlgo: Numerically more stable results for frequencies lower than 1.0 eV. Note: for a graphene monolayer the conical intersection results in a very small band gap (zero band gap semi-conductor). This leads ta a failing low frequency algorithm. One can then chose to use the algorithm as originally proposed by Kootstra by setting the input value to *false*. But, this can result in unreliable results for frequencies lower than 1.0 eV!
:vartype LowFreqAlgo: BoolType | BoolKey
:ivar NCycle: Number of SCF cycles for each frequency to be evaluated.
:vartype NCycle: int | IntKey
:ivar XC: Influences if the bare induced Coulomb response (XC 0) is used for the effective, induced potential or the induced potential derived from the ALDA kernel as well (XC 1).
:vartype XC: int | IntKey
:ivar DIIS: Parameters influencing the DIIS self-consistency method
:vartype DIIS: BAND._NewResponseSCF._DIIS
"""
[docs] class _DIIS(FixedBlock):
r"""
Parameters influencing the DIIS self-consistency method
:ivar Enabled: If not enabled simple mixing without DIIS acceleration will be used.
:vartype Enabled: BoolType | BoolKey
:ivar MaxSamples: Specifies the maximum number of samples considered during the direct inversion of iteration of subspace (DIIS) extrapolation of the atomic charges during the SCC iterations. A smaller number of samples potentially leads to a more aggressive convergence acceleration, while a larger number often guarantees a more stable iteration. Due to often occurring linear dependencies within the set of sample vectors, the maximum number of samples is reached only in very rare cases.
:vartype MaxSamples: int | IntKey
:ivar MaximumCoefficient: When the diis expansion coefficients exceed this threshold, the solution is rejected. The vector space is too crowded. The oldest vector is discarded, and the expansion is re-evaluated.
:vartype MaximumCoefficient: float | FloatKey
:ivar MinSamples: When bigger than one, this affects the shrinking of the DIIS space on linear dependence. It will not reduce to a smaller space than MinSamples unless there is extreme dependency.
:vartype MinSamples: int | IntKey
:ivar MixingFactor: The parameter used to mix the DIIS linear combination of previously sampled atomic charge vectors with an analogous linear combination of charge vectors resulting from population analysis combination. It can assume real values between 0 and 1.
:vartype MixingFactor: float | FloatKey
"""
def __post_init__(self):
self.Enabled: BoolType | BoolKey = BoolKey(name='Enabled', comment='If not enabled simple mixing without DIIS acceleration will be used.', default=True)
self.MaxSamples: int | IntKey = IntKey(name='MaxSamples', comment='Specifies the maximum number of samples considered during the direct inversion of iteration of subspace (DIIS) extrapolation of the atomic charges during the SCC iterations. A smaller number of samples potentially leads to a more aggressive convergence acceleration, while a larger number often guarantees a more stable iteration. Due to often occurring linear dependencies within the set of sample vectors, the maximum number of samples is reached only in very rare cases.', default=10)
self.MaximumCoefficient: float | FloatKey = FloatKey(name='MaximumCoefficient', comment='When the diis expansion coefficients exceed this threshold, the solution is rejected. The vector space is too crowded. The oldest vector is discarded, and the expansion is re-evaluated.', default=10.0)
self.MinSamples: int | IntKey = IntKey(name='MinSamples', comment='When bigger than one, this affects the shrinking of the DIIS space on linear dependence. It will not reduce to a smaller space than MinSamples unless there is extreme dependency.', default=-1)
self.MixingFactor: float | FloatKey = FloatKey(name='MixingFactor', comment='The parameter used to mix the DIIS linear combination of previously sampled atomic charge vectors with an analogous linear combination of charge vectors resulting from population analysis combination. It can assume real values between 0 and 1.', default=0.2)
def __post_init__(self):
self.Bootstrap: int | IntKey = IntKey(name='Bootstrap', comment="defines if the Berger2015 kernel (Bootstrap 1) is used or not (Bootstrap 0). If you chose the Berger2015 kernel, you have to set NewResponseSCF%XC to '0'. Since it shall be used in combination with the bare Coulomb response only. Note: The evaluation of response properties using the Berger2015 is recommend for 3D systems only!", default=0)
self.COApproach: BoolType | BoolKey = BoolKey(name='COApproach', comment='The program automatically decides to calculate the integrals and induced densities via the Bloch expanded atomic orbitals (AO approach) or via the cyrstal orbitals (CO approach). The option COApproach overrules this decision.', default=True)
self.COApproachBoost: BoolType | BoolKey = BoolKey(name='COApproachBoost', comment='Keeps the grid data of the Crystal Orbitals in memory.\n\nRequires significantly more memory for a speedup of the calculation. One might have to use multiple computing nodes to not run into memory problems.', gui_name='CO Approach Boost:', default=False)
self.Criterion: float | FloatKey = FloatKey(name='Criterion', comment='For the SCF convergence the RMS of the induced density change is tested. If this value is below the Criterion the SCF is finished.\n\nFurthermore, one can find the calculated electric susceptibility for each SCF step in the output and can therefore decide if the default value is too loose or too strict.', default=0.001)
self.LowFreqAlgo: BoolType | BoolKey = BoolKey(name='LowFreqAlgo', comment='Numerically more stable results for frequencies lower than 1.0 eV. Note: for a graphene monolayer the conical intersection results in a very small band gap (zero band gap semi-conductor). This leads ta a failing low frequency algorithm. One can then chose to use the algorithm as originally proposed by Kootstra by setting the input value to *false*. But, this can result in unreliable results for frequencies lower than 1.0 eV!', gui_name='Low Frequency Algorithm:', default=True)
self.NCycle: int | IntKey = IntKey(name='NCycle', comment='Number of SCF cycles for each frequency to be evaluated.', gui_name='Cycles:', default=20)
self.XC: int | IntKey = IntKey(name='XC', comment='Influences if the bare induced Coulomb response (XC 0) is used for the effective, induced potential or the induced potential derived from the ALDA kernel as well (XC 1).', default=1)
self.DIIS: BAND._NewResponseSCF._DIIS = self._DIIS(name='DIIS', comment='Parameters influencing the DIIS self-consistency method')
[docs] class _NonCollinearMagnetizationModule(FixedBlock):
r"""
Undocumented.
:ivar DoBackForthTest: Transform 2x2 matrices to the Pauli vector representation and back.
:vartype DoBackForthTest: BoolType | BoolKey
:ivar DotProductBugfix: About a forgotten dagger in the dot product code.
:vartype DotProductBugfix: BoolType | BoolKey
:ivar SignFix: Try to get a sign in the up and down projections. Otherwise the size of m is by definition always in the up direction, i.e. only the size of m matters.
:vartype SignFix: BoolType | BoolKey
"""
def __post_init__(self):
self.DoBackForthTest: BoolType | BoolKey = BoolKey(name='DoBackForthTest', comment='Transform 2x2 matrices to the Pauli vector representation and back.', default=False)
self.DotProductBugfix: BoolType | BoolKey = BoolKey(name='DotProductBugfix', comment='About a forgotten dagger in the dot product code.', default=True)
self.SignFix: BoolType | BoolKey = BoolKey(name='SignFix', comment='Try to get a sign in the up and down projections. Otherwise the size of m is by definition always in the up direction, i.e. only the size of m matters.', default=False)
[docs] class _Occupations(FreeBlock):
r"""
Allows one to input specific occupations numbers. Applies only for calculations that use only one k-point (i.e. pseudo-molecule calculations). See example.
"""
def __post_init__(self):
pass
[docs] class _OldResponse(FixedBlock):
r"""
Options for the old TD-CDFT implementation.
:ivar Berger2015: Use the parameter-free polarization functional by A. Berger (Phys. Rev. Lett. 115, 137402). This is possible for 3D insulators and metals. Note: The evaluation of response properties using the Berger2015 is recommend for 3D systems only!
:vartype Berger2015: BoolType | BoolKey
:ivar CNT: Use the CNT parametrization for the longitudinal and transverse kernels of the XC kernel of the homogeneous electron gas. Use this in conjunction with the NewVK option.
:vartype CNT: BoolType | BoolKey
:ivar CNVI: The first convergence criterion for the change in the fit coefficients for the fit functions, when fitting the density.
:vartype CNVI: float | FloatKey
:ivar CNVJ: the second convergence criterion for the change in the fit coefficients for the fit functions, when fitting the density.
:vartype CNVJ: float | FloatKey
:ivar DIISMixFactor: Undocumented.
:vartype DIISMixFactor: float | FloatKey
:ivar Ebndtl: the energy band tolerance, for determination which routines to use for calculating the numerical integration weights, when the energy band posses no or to less dispersion.
:vartype Ebndtl: float | FloatKey
:ivar Enabled: If true, the response function will be calculated using the old TD-CDFT implementation
:vartype Enabled: BoolType | BoolKey
:ivar Endfr: The upper bound frequency of the frequency range over which the dielectric function is calculated
:vartype Endfr: float | FloatKey
:ivar Ifxc: Integer defining the XC kernel. 0: ALDA, 1: Freq. dependent, 2: LB94
:vartype Ifxc: int | IntKey
:ivar Isz: Integer indicating whether or not scalar zeroth order relativistic effects are included in the TDCDFT calculation. 0 = relativistic effects are not included, 1 = relativistic effects are included. The current implementation does NOT work with the option XC%SpinOrbitMagnetization equal NonCollinear
:vartype Isz: int | IntKey
:ivar Iyxc: integer for printing yxc-tensor (see http://aip.scitation.org/doi/10.1063/1.1385370). 0 = not printed, 1 = printed.
:vartype Iyxc: int | IntKey
:ivar Mac: Undocumented.
:vartype Mac: BoolType | BoolKey
:ivar MinDIISSpace: Ensure that the size of the DIIS space does not shrink below this value (if bigger than one). It seems that DIIS with two vectors never converges. Setting this to 3 is reasonable
:vartype MinDIISSpace: int | IntKey
:ivar MixFactor: Undocumented.
:vartype MixFactor: float | FloatKey
:ivar NVirt: Undocumented.
:vartype NVirt: int | IntKey
:ivar Nct: Undocumented.
:vartype Nct: BoolType | BoolKey
:ivar NewVK: Use the slightly modified version of the VK kernel (see https://aip.scitation.org/doi/10.1063/1.1385370). When using this option one uses effectively the static option, even for metals, so one should check carefully the convergence with the KSPACE parameter.
:vartype NewVK: BoolType | BoolKey
:ivar Newalda: Undocumented.
:vartype Newalda: BoolType | BoolKey
:ivar Nfreq: the number of frequencies for which a linear response TD-CDFT calculation is performed.
:vartype Nfreq: int | IntKey
:ivar NonLoc: Undocumented.
:vartype NonLoc: BoolType | BoolKey
:ivar QV: Use the QV parametrization for the longitudinal and transverse kernels of the XC kernel of the homogeneous electron gas. Use this in conjunction with the NewVK option. (see reference).
:vartype QV: BoolType | BoolKey
:ivar QV0: Undocumented.
:vartype QV0: BoolType | BoolKey
:ivar Rice: Undocumented.
:vartype Rice: BoolType | BoolKey
:ivar Shift: energy shift for the virtual crystal orbitals.
:vartype Shift: float | FloatKey
:ivar Static: An alternative method that allows an analytic evaluation of the static response (normally the static response is approximated by a finite small frequency value). This option should only be used for non-relativistic calculations on insulators, and it has no effect on metals. Note: experience shows that KSPACE convergence can be slower.
:vartype Static: BoolType | BoolKey
:ivar Strtfr: is the lower bound frequency of the frequency range over which the dielectric function is calculated.
:vartype Strtfr: float | FloatKey
:ivar VK: Undocumented.
:vartype VK: BoolType | BoolKey
:ivar BugFixes: Allows the user to control bug fixes to check older results
:vartype BugFixes: BAND._OldResponse._BugFixes
"""
[docs] class _BugFixes(FixedBlock):
r"""
Allows the user to control bug fixes to check older results
:ivar NewAldaShift: When using NewAlda combined with an scissors shift, the current was incorrect. fact = 1/(e_i-e_a)
:vartype NewAldaShift: BoolType | BoolKey
"""
def __post_init__(self):
self.NewAldaShift: BoolType | BoolKey = BoolKey(name='NewAldaShift', comment='When using NewAlda combined with an scissors shift, the current was incorrect. fact = 1/(e_i-e_a)', hidden=True, default=False)
def __post_init__(self):
self.Berger2015: BoolType | BoolKey = BoolKey(name='Berger2015', comment='Use the parameter-free polarization functional by A. Berger (Phys. Rev. Lett. 115, 137402). This is possible for 3D insulators and metals. Note: The evaluation of response properties using the Berger2015 is recommend for 3D systems only!', default=False)
self.CNT: BoolType | BoolKey = BoolKey(name='CNT', comment='Use the CNT parametrization for the longitudinal and transverse kernels of the XC kernel of the homogeneous electron gas. Use this in conjunction with the NewVK option.')
self.CNVI: float | FloatKey = FloatKey(name='CNVI', comment='The first convergence criterion for the change in the fit coefficients for the fit functions, when fitting the density.', default=0.001)
self.CNVJ: float | FloatKey = FloatKey(name='CNVJ', comment='the second convergence criterion for the change in the fit coefficients for the fit functions, when fitting the density.', default=0.001)
self.DIISMixFactor: float | FloatKey = FloatKey(name='DIISMixFactor', comment='Undocumented.', hidden=True, default=0.6)
self.Ebndtl: float | FloatKey = FloatKey(name='Ebndtl', comment='the energy band tolerance, for determination which routines to use for calculating the numerical integration weights, when the energy band posses no or to less dispersion.', default=0.001, unit='Hartree')
self.Enabled: BoolType | BoolKey = BoolKey(name='Enabled', comment='If true, the response function will be calculated using the old TD-CDFT implementation', default=False)
self.Endfr: float | FloatKey = FloatKey(name='Endfr', comment='The upper bound frequency of the frequency range over which the dielectric function is calculated', default=3.0, unit='eV')
self.Ifxc: int | IntKey = IntKey(name='Ifxc', comment='Integer defining the XC kernel. 0: ALDA, 1: Freq. dependent, 2: LB94', hidden=True, default=0)
self.Isz: int | IntKey = IntKey(name='Isz', comment='Integer indicating whether or not scalar zeroth order relativistic effects are included in the TDCDFT calculation. 0 = relativistic effects are not included, 1 = relativistic effects are included. The current implementation does NOT work with the option XC%SpinOrbitMagnetization equal NonCollinear', default=0)
self.Iyxc: int | IntKey = IntKey(name='Iyxc', comment='integer for printing yxc-tensor (see http://aip.scitation.org/doi/10.1063/1.1385370). 0 = not printed, 1 = printed.', default=0)
self.Mac: BoolType | BoolKey = BoolKey(name='Mac', comment='Undocumented.', hidden=True)
self.MinDIISSpace: int | IntKey = IntKey(name='MinDIISSpace', comment='Ensure that the size of the DIIS space does not shrink below this value (if bigger than one). It seems that DIIS with two vectors never converges. Setting this to 3 is reasonable', hidden=True, default=-1)
self.MixFactor: float | FloatKey = FloatKey(name='MixFactor', comment='Undocumented.', hidden=True, default=0.95)
self.NVirt: int | IntKey = IntKey(name='NVirt', comment='Undocumented.', hidden=True, default=1)
self.Nct: BoolType | BoolKey = BoolKey(name='Nct', comment='Undocumented.', hidden=True)
self.NewVK: BoolType | BoolKey = BoolKey(name='NewVK', comment='Use the slightly modified version of the VK kernel (see https://aip.scitation.org/doi/10.1063/1.1385370). When using this option one uses effectively the static option, even for metals, so one should check carefully the convergence with the KSPACE parameter.')
self.Newalda: BoolType | BoolKey = BoolKey(name='Newalda', comment='Undocumented.', hidden=True)
self.Nfreq: int | IntKey = IntKey(name='Nfreq', comment='the number of frequencies for which a linear response TD-CDFT calculation is performed.', default=5)
self.NonLoc: BoolType | BoolKey = BoolKey(name='NonLoc', comment='Undocumented.', hidden=True)
self.QV: BoolType | BoolKey = BoolKey(name='QV', comment='Use the QV parametrization for the longitudinal and transverse kernels of the XC kernel of the homogeneous electron gas. Use this in conjunction with the NewVK option. (see reference).')
self.QV0: BoolType | BoolKey = BoolKey(name='QV0', comment='Undocumented.', hidden=True)
self.Rice: BoolType | BoolKey = BoolKey(name='Rice', comment='Undocumented.', hidden=True)
self.Shift: float | FloatKey = FloatKey(name='Shift', comment='energy shift for the virtual crystal orbitals.', default=0.0, unit='eV')
self.Static: BoolType | BoolKey = BoolKey(name='Static', comment='An alternative method that allows an analytic evaluation of the static response (normally the static response is approximated by a finite small frequency value). This option should only be used for non-relativistic calculations on insulators, and it has no effect on metals. Note: experience shows that KSPACE convergence can be slower.')
self.Strtfr: float | FloatKey = FloatKey(name='Strtfr', comment='is the lower bound frequency of the frequency range over which the dielectric function is calculated.', default=1.0, unit='eV')
self.VK: BoolType | BoolKey = BoolKey(name='VK', comment='Undocumented.', hidden=True)
self.BugFixes: BAND._OldResponse._BugFixes = self._BugFixes(name='BugFixes', comment='Allows the user to control bug fixes to check older results', hidden=True)
[docs] class _OrbitalLabels(FreeBlock):
r"""
Undocumented.
"""
def __post_init__(self):
pass
[docs] class _OrbitalPlot(FreeBlock):
r"""
Goes together with the Restart%OrbitalPlot and Grid keys. See Example.
"""
def __post_init__(self):
pass
[docs] class _Output(FixedBlock):
r"""
Control the output.
:ivar Print:
:vartype Print: BAND._Output._Print
"""
[docs] class _Print(FixedBlock):
r"""
:ivar Level:
:vartype Level: Literal["None", "Error", "Warning", "Minimal", "Normal", "Detail", "TooMuchDetail"]
:ivar Section:
:vartype Section: Literal["Prepare", "SCF", "Properties"]
"""
def __post_init__(self):
self.Level: Literal["None", "Error", "Warning", "Minimal", "Normal", "Detail", "TooMuchDetail"] = MultipleChoiceKey(name='Level', choices=['None', 'Error', 'Warning', 'Minimal', 'Normal', 'Detail', 'TooMuchDetail'])
self.Section: Literal["Prepare", "SCF", "Properties"] = MultipleChoiceKey(name='Section', choices=['Prepare', 'SCF', 'Properties'])
def __post_init__(self):
self.Print: BAND._Output._Print = self._Print(name='Print', unique=False)
[docs] class _OverlapPopulations(FreeBlock):
r"""
Overlap population weighted DOS (OPWDOS), also known as the crystal orbital overlap population (COOP).
"""
def __post_init__(self):
pass
[docs] class _PEDANOCV(FixedBlock):
r"""
Options for the decomposition of the orbital relaxation (pEDA).
:ivar EigvalThresh: The threshold controls that for all NOCV deformation densities with NOCV eigenvalues larger than EigvalThresh the energy contribution will be calculated and the respective pEDA-NOCV results will be printed in the output
:vartype EigvalThresh: float | FloatKey
:ivar Enabled: If true in combination with the fragment blocks and the pEDA key, the decomposition of the orbital relaxation term is performed.
:vartype Enabled: BoolType | BoolKey
"""
def __post_init__(self):
self.EigvalThresh: float | FloatKey = FloatKey(name='EigvalThresh', comment='The threshold controls that for all NOCV deformation densities with NOCV eigenvalues larger than EigvalThresh the energy contribution will be calculated and the respective pEDA-NOCV results will be printed in the output', gui_name='Use NOCVs with ev larger than:', default=0.001)
self.Enabled: BoolType | BoolKey = BoolKey(name='Enabled', comment='If true in combination with the fragment blocks and the pEDA key, the decomposition of the orbital relaxation term is performed.', gui_name='Perform PEDA-NOCV analysis:', default=False)
[docs] class _PEDANOPR(FixedBlock):
r"""
Undocumented.
:ivar EigvalThresh: Eigenvectors for Pauli repulsion (NOPR). Analogous to the NOCV concept. Splits up the Pauli repulsion step in orbital contributions.
:vartype EigvalThresh: float | FloatKey
"""
def __post_init__(self):
self.EigvalThresh: float | FloatKey = FloatKey(name='EigvalThresh', comment='Eigenvectors for Pauli repulsion (NOPR). Analogous to the NOCV concept. Splits up the Pauli repulsion step in orbital contributions.', hidden=True, default=0.001)
[docs] class _PeriodicRIHartreeFock(FixedBlock):
r"""
Technical options for periodic Hartree Fock.
:ivar AllowLinearScaling: Use function ranges and multipoles.
:vartype AllowLinearScaling: BoolType | BoolKey
:ivar AllowMultipoleExpansion: Use the multipole expansion if possible.
:vartype AllowMultipoleExpansion: BoolType | BoolKey
:ivar AllowOddKGrid: Allow the user to specify an odd k-grid. This does not work well with HartreeFock.
:vartype AllowOddKGrid: BoolType | BoolKey
:ivar AllowPartialMultipoleExpansion: Use the partial multipole expansion if possible. This has only effect if AllowMultipoleExpansion=yes.
:vartype AllowPartialMultipoleExpansion: BoolType | BoolKey
:ivar AnalyzeCells: Determine the cell loop ranges needed and stop.
:vartype AnalyzeCells: BoolType | BoolKey
:ivar AvoidPeriodicKMatR: Undocumented.
:vartype AvoidPeriodicKMatR: BoolType | BoolKey
:ivar AvoidPeriodicPMatR: Undocumented.
:vartype AvoidPeriodicPMatR: BoolType | BoolKey
:ivar CellLoopPrecision: The range of the density matrix, R(P), combined with the range of basis products, R(C), determines the cell range contributing to the exchange matrix. The cell range used is.
Minimal: R(P).
Medium: R(P)+R(C).
All: R(P)+2R(C)
:vartype CellLoopPrecision: Literal["Minimal", "Medium", "Full"]
:ivar CheckRelativeLatticeIndex: Compare result of fast and slow routine to obtain the relative lattice index.
:vartype CheckRelativeLatticeIndex: BoolType | BoolKey
:ivar ExactLMaxMultiPerAtom: Used to be a hardcodes lMaxMulti=3. If specified it is determined per atom from the RIHF fit functions.
:vartype ExactLMaxMultiPerAtom: BoolType | BoolKey
:ivar FitCoeffThreshold: Threshold to be applied for the fit coefficients, ignore blocks for which all (abs) elements are smaller than this threshold.
:vartype FitCoeffThreshold: float | FloatKey
:ivar Iterator: With the option Dynamic one thread may be sacrified to distribute the work, and is the default when using more than 16 cores, otherwise Hybrid is used. With Hybrid more detailed timings are possible, even if using more than one (shared memory) node.
:vartype Iterator: Literal["Auto", "Static", "Hybrid", "Dynamic"]
:ivar M1Threshold: Threshold to be applied for the M1 matrix appearing in the I,II, and III terms. A negative value means no threshold.
:vartype M1Threshold: float | FloatKey
:ivar MaxCellForP: Apply a maximum to the the number of cells for P(R), mostly useful for 1D systems.
:vartype MaxCellForP: int | IntKey
:ivar MergeIterators: If true, calculate terms I,II,III,and IV in parallel, otherwise term IV is done separately.
:vartype MergeIterators: BoolType | BoolKey
:ivar NCellsToUse: Hack to explicitly control the number of cells to be used.
:vartype NCellsToUse: int | IntKey
:ivar PrintKDistanceDecay: The decay of the norm of K with respect to the distance cell order.
:vartype PrintKDistanceDecay: BoolType | BoolKey
:ivar PrintKShellDecay: The decay of the norm of K with respect to the shell cell order.
:vartype PrintKShellDecay: BoolType | BoolKey
:ivar PrintKTopoDecay: The decay of the norm of K with respect to the topological cell order.
:vartype PrintKTopoDecay: BoolType | BoolKey
:ivar RemapPMatR: Possibly move elements from one cell to another, minimizing the distance between the atom pairs.
:vartype RemapPMatR: BoolType | BoolKey
:ivar RemapPMatRNew: Possibly move elements from one cell to another, minimizing the distance between the atom pairs.
:vartype RemapPMatRNew: BoolType | BoolKey
:ivar SaveKMatR: Undocumented.
:vartype SaveKMatR: BoolType | BoolKey
:ivar SortFitFunctions: Sort the RIHartreeFock fit functions per atom, based on the range. This is needed when allowing for partial multipole atom pairs.
:vartype SortFitFunctions: BoolType | BoolKey
:ivar SupportPostProcessing: Store some info in a RIHartreeFock section, that can be useful for python post processing/analysis.
:vartype SupportPostProcessing: BoolType | BoolKey
:ivar UpdateVersion: Which implementation to use for the update123 and update4 routines.
:vartype UpdateVersion: int | IntKey
:ivar UseHalfKGrid: Let all RIHF settings be based on the assumption that the k-grid was twice as coarse. What will be more accurate is P(R), but it gets the range as if the coarser k-grid was used.
:vartype UseHalfKGrid: BoolType | BoolKey
:ivar UseHelper: Provide the RIHartreeFock with knowledge about loop bounds.
:vartype UseHelper: BoolType | BoolKey
:ivar UseInverseCellSymmetry: If true, only half of the K(R) is calculated, and the rest is obtained from K(-R)=transpose(K(R)).
:vartype UseInverseCellSymmetry: BoolType | BoolKey
:ivar UseLatticeShiftForPairs: Apply a pair based minimum image convention.
:vartype UseLatticeShiftForPairs: BoolType | BoolKey
:ivar UseM1V: Multiply M1 by V, being faster for term II.
:vartype UseM1V: BoolType | BoolKey
:ivar lMaxMulti: Apply a maximum to the lMaxMulti. If negative the key is ignored.
:vartype lMaxMulti: int | IntKey
:ivar BugFixes: Allows the user to control bug fixes to check older results
:vartype BugFixes: BAND._PeriodicRIHartreeFock._BugFixes
"""
[docs] class _BugFixes(FixedBlock):
r"""
Allows the user to control bug fixes to check older results
:ivar HalfCells: AvoidPeriodicPMatR wiped too many cells. Better to use kt-1 rather than kUnique
:vartype HalfCells: BoolType | BoolKey
"""
def __post_init__(self):
self.HalfCells: BoolType | BoolKey = BoolKey(name='HalfCells', comment='AvoidPeriodicPMatR wiped too many cells. Better to use kt-1 rather than kUnique', hidden=True, default=True)
def __post_init__(self):
self.AllowLinearScaling: BoolType | BoolKey = BoolKey(name='AllowLinearScaling', comment='Use function ranges and multipoles.', default=True)
self.AllowMultipoleExpansion: BoolType | BoolKey = BoolKey(name='AllowMultipoleExpansion', comment='Use the multipole expansion if possible.', default=False)
self.AllowOddKGrid: BoolType | BoolKey = BoolKey(name='AllowOddKGrid', comment='Allow the user to specify an odd k-grid. This does not work well with HartreeFock.', hidden=True, default=False)
self.AllowPartialMultipoleExpansion: BoolType | BoolKey = BoolKey(name='AllowPartialMultipoleExpansion', comment='Use the partial multipole expansion if possible. This has only effect if AllowMultipoleExpansion=yes.', default=False)
self.AnalyzeCells: BoolType | BoolKey = BoolKey(name='AnalyzeCells', comment='Determine the cell loop ranges needed and stop.', default=False)
self.AvoidPeriodicKMatR: BoolType | BoolKey = BoolKey(name='AvoidPeriodicKMatR', comment='Undocumented.', default=False)
self.AvoidPeriodicPMatR: BoolType | BoolKey = BoolKey(name='AvoidPeriodicPMatR', comment='Undocumented.', default=False)
self.CellLoopPrecision: Literal["Minimal", "Medium", "Full"] = MultipleChoiceKey(name='CellLoopPrecision', comment='The range of the density matrix, R(P), combined with the range of basis products, R(C), determines the cell range contributing to the exchange matrix. The cell range used is.\n Minimal: R(P).\n Medium: R(P)+R(C).\n All: R(P)+2R(C)', default='Full', choices=['Minimal', 'Medium', 'Full'])
self.CheckRelativeLatticeIndex: BoolType | BoolKey = BoolKey(name='CheckRelativeLatticeIndex', comment='Compare result of fast and slow routine to obtain the relative lattice index.', hidden=True, default=False)
self.ExactLMaxMultiPerAtom: BoolType | BoolKey = BoolKey(name='ExactLMaxMultiPerAtom', comment='Used to be a hardcodes lMaxMulti=3. If specified it is determined per atom from the RIHF fit functions.', default=False)
self.FitCoeffThreshold: float | FloatKey = FloatKey(name='FitCoeffThreshold', comment='Threshold to be applied for the fit coefficients, ignore blocks for which all (abs) elements are smaller than this threshold.', hidden=True, default=-1.0)
self.Iterator: Literal["Auto", "Static", "Hybrid", "Dynamic"] = MultipleChoiceKey(name='Iterator', comment='With the option Dynamic one thread may be sacrified to distribute the work, and is the default when using more than 16 cores, otherwise Hybrid is used. With Hybrid more detailed timings are possible, even if using more than one (shared memory) node.', hidden=True, default='Auto', choices=['Auto', 'Static', 'Hybrid', 'Dynamic'])
self.M1Threshold: float | FloatKey = FloatKey(name='M1Threshold', comment='Threshold to be applied for the M1 matrix appearing in the I,II, and III terms. A negative value means no threshold.', hidden=True, default=-1.0)
self.MaxCellForP: int | IntKey = IntKey(name='MaxCellForP', comment='Apply a maximum to the the number of cells for P(R), mostly useful for 1D systems.', hidden=True, default=-1)
self.MergeIterators: BoolType | BoolKey = BoolKey(name='MergeIterators', comment='If true, calculate terms I,II,III,and IV in parallel, otherwise term IV is done separately.', default=False)
self.NCellsToUse: int | IntKey = IntKey(name='NCellsToUse', comment='Hack to explicitly control the number of cells to be used.', hidden=True)
self.PrintKDistanceDecay: BoolType | BoolKey = BoolKey(name='PrintKDistanceDecay', comment='The decay of the norm of K with respect to the distance cell order.', default=False)
self.PrintKShellDecay: BoolType | BoolKey = BoolKey(name='PrintKShellDecay', comment='The decay of the norm of K with respect to the shell cell order.', default=False)
self.PrintKTopoDecay: BoolType | BoolKey = BoolKey(name='PrintKTopoDecay', comment='The decay of the norm of K with respect to the topological cell order.', default=False)
self.RemapPMatR: BoolType | BoolKey = BoolKey(name='RemapPMatR', comment='Possibly move elements from one cell to another, minimizing the distance between the atom pairs.', default=False)
self.RemapPMatRNew: BoolType | BoolKey = BoolKey(name='RemapPMatRNew', comment='Possibly move elements from one cell to another, minimizing the distance between the atom pairs.', default=False)
self.SaveKMatR: BoolType | BoolKey = BoolKey(name='SaveKMatR', comment='Undocumented.', default=False)
self.SortFitFunctions: BoolType | BoolKey = BoolKey(name='SortFitFunctions', comment='Sort the RIHartreeFock fit functions per atom, based on the range. This is needed when allowing for partial multipole atom pairs.', default=False)
self.SupportPostProcessing: BoolType | BoolKey = BoolKey(name='SupportPostProcessing', comment='Store some info in a RIHartreeFock section, that can be useful for python post processing/analysis.', hidden=True, default=False)
self.UpdateVersion: int | IntKey = IntKey(name='UpdateVersion', comment='Which implementation to use for the update123 and update4 routines.', hidden=True, default=1)
self.UseHalfKGrid: BoolType | BoolKey = BoolKey(name='UseHalfKGrid', comment='Let all RIHF settings be based on the assumption that the k-grid was twice as coarse. What will be more accurate is P(R), but it gets the range as if the coarser k-grid was used.', default=False)
self.UseHelper: BoolType | BoolKey = BoolKey(name='UseHelper', comment='Provide the RIHartreeFock with knowledge about loop bounds.', default=False)
self.UseInverseCellSymmetry: BoolType | BoolKey = BoolKey(name='UseInverseCellSymmetry', comment='If true, only half of the K(R) is calculated, and the rest is obtained from K(-R)=transpose(K(R)).', default=False)
self.UseLatticeShiftForPairs: BoolType | BoolKey = BoolKey(name='UseLatticeShiftForPairs', comment='Apply a pair based minimum image convention.', default=False)
self.UseM1V: BoolType | BoolKey = BoolKey(name='UseM1V', comment='Multiply M1 by V, being faster for term II.', default=False)
self.lMaxMulti: int | IntKey = IntKey(name='lMaxMulti', comment='Apply a maximum to the lMaxMulti. If negative the key is ignored.', hidden=True)
self.BugFixes: BAND._PeriodicRIHartreeFock._BugFixes = self._BugFixes(name='BugFixes', comment='Allows the user to control bug fixes to check older results', hidden=True)
[docs] class _PeriodicSolvation(FixedBlock):
r"""
Additional options for simulations of periodic structures with solvation.
:ivar MaxDisttounitcell: Undocumented.
:vartype MaxDisttounitcell: float | FloatKey
:ivar NStar: This option, expecting an integer number (>2), handles the accuracy for the construction of the COMSO surface. The larger the given number the more accurate the construction.
:vartype NStar: int | IntKey
:ivar RemovePointsWithNegativeZ: Whether the COSMO surface is constructed on both sides of a surface.
If one is only interested in the solvation effect on the upper side of a surface (in the Z direction), then this option should be set to 'True'
:vartype RemovePointsWithNegativeZ: BoolType | BoolKey
:ivar RestartPoints: Undocumented.
:vartype RestartPoints: BoolType | BoolKey
:ivar RestartWithPointApprox: Undocumented.
:vartype RestartWithPointApprox: BoolType | BoolKey
:ivar ReusePoints: Undocumented.
:vartype ReusePoints: BoolType | BoolKey
:ivar SmartScreening: Undocumented.
:vartype SmartScreening: BoolType | BoolKey
:ivar SymmetrizeSurfacePoints: Whether or not the COSMO point should be symmetrized
:vartype SymmetrizeSurfacePoints: BoolType | BoolKey
"""
def __post_init__(self):
self.MaxDisttounitcell: float | FloatKey = FloatKey(name='MaxDisttounitcell', comment='Undocumented.', hidden=True, default=13.0)
self.NStar: int | IntKey = IntKey(name='NStar', comment='This option, expecting an integer number (>2), handles the accuracy for the construction of the COMSO surface. The larger the given number the more accurate the construction.', default=4)
self.RemovePointsWithNegativeZ: BoolType | BoolKey = BoolKey(name='RemovePointsWithNegativeZ', comment="Whether the COSMO surface is constructed on both sides of a surface.\n\nIf one is only interested in the solvation effect on the upper side of a surface (in the Z direction), then this option should be set to 'True'", gui_name='Only above slab:', default=False)
self.RestartPoints: BoolType | BoolKey = BoolKey(name='RestartPoints', comment='Undocumented.', hidden=True, default=False)
self.RestartWithPointApprox: BoolType | BoolKey = BoolKey(name='RestartWithPointApprox', comment='Undocumented.', hidden=True, default=False)
self.ReusePoints: BoolType | BoolKey = BoolKey(name='ReusePoints', comment='Undocumented.', hidden=True, default=False)
self.SmartScreening: BoolType | BoolKey = BoolKey(name='SmartScreening', comment='Undocumented.', hidden=True, default=True)
self.SymmetrizeSurfacePoints: BoolType | BoolKey = BoolKey(name='SymmetrizeSurfacePoints', comment='Whether or not the COSMO point should be symmetrized', default=True)
[docs] class _Programmer(FixedBlock):
r"""
Miscellaneous technical options.
:ivar Allowtailsforresponse: Undocumented.
:vartype Allowtailsforresponse: BoolType | BoolKey
:ivar Atomicenergyinmolgrid: Undocumented.
:vartype Atomicenergyinmolgrid: BoolType | BoolKey
:ivar BandEigSysOption: 1) orig version, 2) uses SCMMatrix.
:vartype BandEigSysOption: int | IntKey
:ivar Bandcosmoevaluatoroption: Undocumented.
:vartype Bandcosmoevaluatoroption: int | IntKey
:ivar Basgrad: Undocumented.
:vartype Basgrad: BoolType | BoolKey
:ivar Baskin: Undocumented.
:vartype Baskin: BoolType | BoolKey
:ivar Bassecder: Undocumented.
:vartype Bassecder: BoolType | BoolKey
:ivar Blockpropertyioformatoption: Undocumented.
:vartype Blockpropertyioformatoption: int | IntKey
:ivar Calctau: Undocumented.
:vartype Calctau: BoolType | BoolKey
:ivar Determinesvocmethod: Undocumented.
:vartype Determinesvocmethod: int | IntKey
:ivar Didervcompat: Undocumented.
:vartype Didervcompat: BoolType | BoolKey
:ivar DiracPotentialCutoff: When V (times R) is smaller than this, set potential to zero. (coulomb potential of spherical atoms in dirac routine)
:vartype DiracPotentialCutoff: float | FloatKey
:ivar DirectBas: Calculate basis functions and their derivatives on the fly, and do not store basis functions on disk.
:vartype DirectBas: BoolType | BoolKey
:ivar Directfit: Undocumented.
:vartype Directfit: BoolType | BoolKey
:ivar Dkbas: Undocumented.
:vartype Dkbas: BoolType | BoolKey
:ivar DynamicBlockIterator: This causes the iteration over the blocks to be dynamic. Technically all grid based functions will be stored in shared arrays. Might be faster when there is load imbalance. Can be considered for large/sparse systems. Does not work too wel with too many cores per node.
:vartype DynamicBlockIterator: BoolType | BoolKey
:ivar Enablescratcharraymodule: Undocumented.
:vartype Enablescratcharraymodule: BoolType | BoolKey
:ivar Exactgradrho: Undocumented.
:vartype Exactgradrho: BoolType | BoolKey
:ivar Exactgradrhopostscf: Undocumented.
:vartype Exactgradrhopostscf: BoolType | BoolKey
:ivar Exactrho: Undocumented.
:vartype Exactrho: BoolType | BoolKey
:ivar Exactsharedarraylocking: Undocumented.
:vartype Exactsharedarraylocking: BoolType | BoolKey
:ivar Fastatmfnc: Undocumented.
:vartype Fastatmfnc: BoolType | BoolKey
:ivar Fastfitort: Undocumented.
:vartype Fastfitort: BoolType | BoolKey
:ivar Fitgrad: Undocumented.
:vartype Fitgrad: BoolType | BoolKey
:ivar Frageif: Undocumented.
:vartype Frageif: BoolType | BoolKey
:ivar Functionsetdotproductemploysym: Undocumented.
:vartype Functionsetdotproductemploysym: BoolType | BoolKey
:ivar Functionsetdotproducteps: Undocumented.
:vartype Functionsetdotproducteps: float | FloatKey
:ivar Functionsetdotproductoption: Undocumented.
:vartype Functionsetdotproductoption: int | IntKey
:ivar Functionsetincrementeps: Undocumented.
:vartype Functionsetincrementeps: float | FloatKey
:ivar Functionsetincrementkeepsorted: Undocumented.
:vartype Functionsetincrementkeepsorted: BoolType | BoolKey
:ivar Functionsetoverlapemploysym: Undocumented.
:vartype Functionsetoverlapemploysym: BoolType | BoolKey
:ivar Functionsetoverlaplockcolumn: Undocumented.
:vartype Functionsetoverlaplockcolumn: BoolType | BoolKey
:ivar Functionsetoverlapoption: Undocumented.
:vartype Functionsetoverlapoption: int | IntKey
:ivar Functionsetoverlapslicesize: Undocumented.
:vartype Functionsetoverlapslicesize: int | IntKey
:ivar Functionsettransformeps: Undocumented.
:vartype Functionsettransformeps: float | FloatKey
:ivar Functionsettransformoption: Undocumented.
:vartype Functionsettransformoption: int | IntKey
:ivar Genericpmatoption: Undocumented.
:vartype Genericpmatoption: int | IntKey
:ivar HuntForSpinorbitBug: On some platforms either the Lowdin ortho fails or the CheckCore.
:vartype HuntForSpinorbitBug: BoolType | BoolKey
:ivar Inverthermitianmatrixmethod: Undocumented.
:vartype Inverthermitianmatrixmethod: int | IntKey
:ivar KMIOMaxSectionSize: Normally this should be the maximum number of elements that a kf varialbe can hold.
:vartype KMIOMaxSectionSize: float | FloatKey
:ivar Kequivtol: Undocumented.
:vartype Kequivtol: float | FloatKey
:ivar Kinviagrad: Undocumented.
:vartype Kinviagrad: BoolType | BoolKey
:ivar KmioFinalStorageMode: How the eigensystem is saved at the end of the calculation on the main result file.
:vartype KmioFinalStorageMode: int | IntKey
:ivar Kmioforcecomplex: Undocumented.
:vartype Kmioforcecomplex: BoolType | BoolKey
:ivar Kmiostoragemode: Undocumented.
:vartype Kmiostoragemode: int | IntKey
:ivar LogGap: Show the band gap in the logfile at each cycle.
:vartype LogGap: BoolType | BoolKey
:ivar Mapatomstounitcell: Undocumented.
:vartype Mapatomstounitcell: BoolType | BoolKey
:ivar Nucgradvocoption: Undocumented.
:vartype Nucgradvocoption: int | IntKey
:ivar Oldgetvocbasis: Undocumented.
:vartype Oldgetvocbasis: BoolType | BoolKey
:ivar OptimizePointDistribution: Undocumented.
:vartype OptimizePointDistribution: BoolType | BoolKey
:ivar OptimizePointDistributionStrategy: ?.
:vartype OptimizePointDistributionStrategy: int | IntKey
:ivar Pmathistory: Undocumented.
:vartype Pmathistory: BoolType | BoolKey
:ivar PrepareBasLinAlgOption: Variations for the matrix processing part of PrepareBas. Possible values: 1 or 2.
:vartype PrepareBasLinAlgOption: int | IntKey
:ivar RemoveRigidMotions: Whether or not to remove rigid motions from gradient.
:vartype RemoveRigidMotions: BoolType | BoolKey
:ivar ReorderPoints: Whether or not to reorder the real space points by localization.
:vartype ReorderPoints: BoolType | BoolKey
:ivar Rhograd: Undocumented.
:vartype Rhograd: BoolType | BoolKey
:ivar SharedMemorySandwichingThreshold: When the nr. of basis functions exceeds this threshold shared memory will be used to calculate matrix elements.
Unless UseSharedMemoryForSandwiching is explicitly set in the input.
:vartype SharedMemorySandwichingThreshold: int | IntKey
:ivar Simplexdividemethod: Undocumented.
:vartype Simplexdividemethod: int | IntKey
:ivar StopAfterFirstEigsys: Stop after the first call to eigsys is completed, useful for timings, in particular for HartreeFock.
:vartype StopAfterFirstEigsys: BoolType | BoolKey
:ivar StoreDOSPerBas: Whether or not to store the parial DOS per basis function. This allows you to view any partial DOS with amsspectra and amsbands. Requires the CalcPDOS option to be on.
:vartype StoreDOSPerBas: BoolType | BoolKey
:ivar StoreOrbitals: Copy information on band.rkf needed for orbital plotting and restarts. This can be a lot of information. DOS and BandStructure require StoreOrbitals=true.
:vartype StoreOrbitals: BoolType | BoolKey
:ivar StoreZlmFitEachSCFCycle: Write ZlmFit info to band.rkf, normally only done at the last cycle.
:vartype StoreZlmFitEachSCFCycle: BoolType | BoolKey
:ivar Storebandinternalham: Undocumented.
:vartype Storebandinternalham: BoolType | BoolKey
:ivar Storeoriginalbloch: Undocumented.
:vartype Storeoriginalbloch: BoolType | BoolKey
:ivar Testparameter: Undocumented.
:vartype Testparameter: int | IntKey
:ivar UpdateSTDVec: Shift atoms so that center of mass is at zero. As a results the detected symmetry may be higher.
:vartype UpdateSTDVec: BoolType | BoolKey
:ivar UseDiracCoulomb: Affects dirac subroutine. In 2023 a spline-based routine was made replacing the original code that employed a (necessary) 10-6 CutOff. To emulate pre ams2023 calculations set this key to false.
:vartype UseDiracCoulomb: BoolType | BoolKey
:ivar UseSharedMemoryForSandwiching: When calculating matrix elements the array will be shared. This saves memory at the cost of locking overhead.
If not specified this will depend on the threshold SharedMemorySandwichingThreshold
:vartype UseSharedMemoryForSandwiching: BoolType | BoolKey
:ivar UseTurnoverRuleForXcMatrix: Undocumented.
:vartype UseTurnoverRuleForXcMatrix: BoolType | BoolKey
:ivar UseTurnoverRuleForXcMatrixDirac: Affects which potential to use in Dirac in case of libxc and UseTurnoverRuleForXcMatrix=true.
:vartype UseTurnoverRuleForXcMatrixDirac: BoolType | BoolKey
:ivar Usenewtailroutines: Undocumented.
:vartype Usenewtailroutines: BoolType | BoolKey
:ivar Usesharedmemory: When running more then one task, share memory between those tasks. This saves a lot of memory.
Only disable it in case of problems.
:vartype Usesharedmemory: BoolType | BoolKey
:ivar Usestofit: Undocumented.
:vartype Usestofit: BoolType | BoolKey
:ivar Usezlmfit: Undocumented.
:vartype Usezlmfit: BoolType | BoolKey
:ivar VOCBasEvaluator4OptimizeOrdering: Make sure that the sparse functions are ordered (idtail is ascending).
:vartype VOCBasEvaluator4OptimizeOrdering: BoolType | BoolKey
:ivar Wipeonecenterterms: Undocumented.
:vartype Wipeonecenterterms: BoolType | BoolKey
"""
def __post_init__(self):
self.Allowtailsforresponse: BoolType | BoolKey = BoolKey(name='Allowtailsforresponse', comment='Undocumented.', hidden=True, default=True)
self.Atomicenergyinmolgrid: BoolType | BoolKey = BoolKey(name='Atomicenergyinmolgrid', comment='Undocumented.', hidden=True, default=True)
self.BandEigSysOption: int | IntKey = IntKey(name='BandEigSysOption', comment='1) orig version, 2) uses SCMMatrix.', hidden=True, default=2)
self.Bandcosmoevaluatoroption: int | IntKey = IntKey(name='Bandcosmoevaluatoroption', comment='Undocumented.', hidden=True, default=2)
self.Basgrad: BoolType | BoolKey = BoolKey(name='Basgrad', comment='Undocumented.', hidden=True, default=False)
self.Baskin: BoolType | BoolKey = BoolKey(name='Baskin', comment='Undocumented.', hidden=True, default=True)
self.Bassecder: BoolType | BoolKey = BoolKey(name='Bassecder', comment='Undocumented.', hidden=True, default=False)
self.Blockpropertyioformatoption: int | IntKey = IntKey(name='Blockpropertyioformatoption', comment='Undocumented.', hidden=True, default=1)
self.Calctau: BoolType | BoolKey = BoolKey(name='Calctau', comment='Undocumented.', hidden=True, default=False)
self.Determinesvocmethod: int | IntKey = IntKey(name='Determinesvocmethod', comment='Undocumented.', hidden=True, default=2)
self.Didervcompat: BoolType | BoolKey = BoolKey(name='Didervcompat', comment='Undocumented.', hidden=True, default=False)
self.DiracPotentialCutoff: float | FloatKey = FloatKey(name='DiracPotentialCutoff', comment='When V (times R) is smaller than this, set potential to zero. (coulomb potential of spherical atoms in dirac routine)', hidden=True, default=1e-08)
self.DirectBas: BoolType | BoolKey = BoolKey(name='DirectBas', comment='Calculate basis functions and their derivatives on the fly, and do not store basis functions on disk.', hidden=True, default=True)
self.Directfit: BoolType | BoolKey = BoolKey(name='Directfit', comment='Undocumented.', hidden=True, default=False)
self.Dkbas: BoolType | BoolKey = BoolKey(name='Dkbas', comment='Undocumented.', hidden=True, default=False)
self.DynamicBlockIterator: BoolType | BoolKey = BoolKey(name='DynamicBlockIterator', comment='This causes the iteration over the blocks to be dynamic. Technically all grid based functions will be stored in shared arrays. Might be faster when there is load imbalance. Can be considered for large/sparse systems. Does not work too wel with too many cores per node.', hidden=True, default=False)
self.Enablescratcharraymodule: BoolType | BoolKey = BoolKey(name='Enablescratcharraymodule', comment='Undocumented.', hidden=True, default=False)
self.Exactgradrho: BoolType | BoolKey = BoolKey(name='Exactgradrho', comment='Undocumented.', hidden=True, default=False)
self.Exactgradrhopostscf: BoolType | BoolKey = BoolKey(name='Exactgradrhopostscf', comment='Undocumented.', hidden=True, default=False)
self.Exactrho: BoolType | BoolKey = BoolKey(name='Exactrho', comment='Undocumented.', hidden=True, default=True)
self.Exactsharedarraylocking: BoolType | BoolKey = BoolKey(name='Exactsharedarraylocking', comment='Undocumented.', hidden=True, default=True)
self.Fastatmfnc: BoolType | BoolKey = BoolKey(name='Fastatmfnc', comment='Undocumented.', hidden=True, default=True)
self.Fastfitort: BoolType | BoolKey = BoolKey(name='Fastfitort', comment='Undocumented.', hidden=True, default=True)
self.Fitgrad: BoolType | BoolKey = BoolKey(name='Fitgrad', comment='Undocumented.', hidden=True, default=True)
self.Frageif: BoolType | BoolKey = BoolKey(name='Frageif', comment='Undocumented.', hidden=True)
self.Functionsetdotproductemploysym: BoolType | BoolKey = BoolKey(name='Functionsetdotproductemploysym', comment='Undocumented.', hidden=True, default=True)
self.Functionsetdotproducteps: float | FloatKey = FloatKey(name='Functionsetdotproducteps', comment='Undocumented.', hidden=True, default=1e-10)
self.Functionsetdotproductoption: int | IntKey = IntKey(name='Functionsetdotproductoption', comment='Undocumented.', hidden=True, default=2)
self.Functionsetincrementeps: float | FloatKey = FloatKey(name='Functionsetincrementeps', comment='Undocumented.', hidden=True, default=1e-10)
self.Functionsetincrementkeepsorted: BoolType | BoolKey = BoolKey(name='Functionsetincrementkeepsorted', comment='Undocumented.', hidden=True, default=False)
self.Functionsetoverlapemploysym: BoolType | BoolKey = BoolKey(name='Functionsetoverlapemploysym', comment='Undocumented.', hidden=True, default=False)
self.Functionsetoverlaplockcolumn: BoolType | BoolKey = BoolKey(name='Functionsetoverlaplockcolumn', comment='Undocumented.', hidden=True, default=True)
self.Functionsetoverlapoption: int | IntKey = IntKey(name='Functionsetoverlapoption', comment='Undocumented.', hidden=True, default=3)
self.Functionsetoverlapslicesize: int | IntKey = IntKey(name='Functionsetoverlapslicesize', comment='Undocumented.', hidden=True, default=32)
self.Functionsettransformeps: float | FloatKey = FloatKey(name='Functionsettransformeps', comment='Undocumented.', hidden=True, default=1e-10)
self.Functionsettransformoption: int | IntKey = IntKey(name='Functionsettransformoption', comment='Undocumented.', hidden=True, default=2)
self.Genericpmatoption: int | IntKey = IntKey(name='Genericpmatoption', comment='Undocumented.', hidden=True, default=2)
self.HuntForSpinorbitBug: BoolType | BoolKey = BoolKey(name='HuntForSpinorbitBug', comment='On some platforms either the Lowdin ortho fails or the CheckCore.', hidden=True, default=False)
self.Inverthermitianmatrixmethod: int | IntKey = IntKey(name='Inverthermitianmatrixmethod', comment='Undocumented.', hidden=True, default=3)
self.KMIOMaxSectionSize: float | FloatKey = FloatKey(name='KMIOMaxSectionSize', comment='Normally this should be the maximum number of elements that a kf varialbe can hold.', hidden=True)
self.Kequivtol: float | FloatKey = FloatKey(name='Kequivtol', comment='Undocumented.', hidden=True, default=0.001)
self.Kinviagrad: BoolType | BoolKey = BoolKey(name='Kinviagrad', comment='Undocumented.', hidden=True, default=False)
self.KmioFinalStorageMode: int | IntKey = IntKey(name='KmioFinalStorageMode', comment='How the eigensystem is saved at the end of the calculation on the main result file.', hidden=True, default=4)
self.Kmioforcecomplex: BoolType | BoolKey = BoolKey(name='Kmioforcecomplex', comment='Undocumented.', hidden=True, default=False)
self.Kmiostoragemode: int | IntKey = IntKey(name='Kmiostoragemode', comment='Undocumented.', hidden=True, default=2)
self.LogGap: BoolType | BoolKey = BoolKey(name='LogGap', comment='Show the band gap in the logfile at each cycle.', hidden=True, default=True)
self.Mapatomstounitcell: BoolType | BoolKey = BoolKey(name='Mapatomstounitcell', comment='Undocumented.', hidden=True, default=True)
self.Nucgradvocoption: int | IntKey = IntKey(name='Nucgradvocoption', comment='Undocumented.', hidden=True, default=1)
self.Oldgetvocbasis: BoolType | BoolKey = BoolKey(name='Oldgetvocbasis', comment='Undocumented.', hidden=True, default=False)
self.OptimizePointDistribution: BoolType | BoolKey = BoolKey(name='OptimizePointDistribution', comment='Undocumented.', hidden=True, default=False)
self.OptimizePointDistributionStrategy: int | IntKey = IntKey(name='OptimizePointDistributionStrategy', comment='?.', hidden=True, default=1)
self.Pmathistory: BoolType | BoolKey = BoolKey(name='Pmathistory', comment='Undocumented.', hidden=True, default=False)
self.PrepareBasLinAlgOption: int | IntKey = IntKey(name='PrepareBasLinAlgOption', comment='Variations for the matrix processing part of PrepareBas. Possible values: 1 or 2.', hidden=True, default=1)
self.RemoveRigidMotions: BoolType | BoolKey = BoolKey(name='RemoveRigidMotions', comment='Whether or not to remove rigid motions from gradient.', hidden=True, default=True)
self.ReorderPoints: BoolType | BoolKey = BoolKey(name='ReorderPoints', comment='Whether or not to reorder the real space points by localization.', hidden=True, default=True)
self.Rhograd: BoolType | BoolKey = BoolKey(name='Rhograd', comment='Undocumented.', hidden=True, default=True)
self.SharedMemorySandwichingThreshold: int | IntKey = IntKey(name='SharedMemorySandwichingThreshold', comment='When the nr. of basis functions exceeds this threshold shared memory will be used to calculate matrix elements.\n\nUnless UseSharedMemoryForSandwiching is explicitly set in the input.', gui_name='Shared mem sandwiching thld:', default=5000)
self.Simplexdividemethod: int | IntKey = IntKey(name='Simplexdividemethod', comment='Undocumented.', hidden=True, default=1)
self.StopAfterFirstEigsys: BoolType | BoolKey = BoolKey(name='StopAfterFirstEigsys', comment='Stop after the first call to eigsys is completed, useful for timings, in particular for HartreeFock.', hidden=True, default=False)
self.StoreDOSPerBas: BoolType | BoolKey = BoolKey(name='StoreDOSPerBas', comment='Whether or not to store the parial DOS per basis function. This allows you to view any partial DOS with amsspectra and amsbands. Requires the CalcPDOS option to be on.', default=True)
self.StoreOrbitals: BoolType | BoolKey = BoolKey(name='StoreOrbitals', comment='Copy information on band.rkf needed for orbital plotting and restarts. This can be a lot of information. DOS and BandStructure require StoreOrbitals=true.', default=True)
self.StoreZlmFitEachSCFCycle: BoolType | BoolKey = BoolKey(name='StoreZlmFitEachSCFCycle', comment='Write ZlmFit info to band.rkf, normally only done at the last cycle.', hidden=True, default=False)
self.Storebandinternalham: BoolType | BoolKey = BoolKey(name='Storebandinternalham', comment='Undocumented.', hidden=True, default=False)
self.Storeoriginalbloch: BoolType | BoolKey = BoolKey(name='Storeoriginalbloch', comment='Undocumented.', hidden=True, default=False)
self.Testparameter: int | IntKey = IntKey(name='Testparameter', comment='Undocumented.', hidden=True, default=10)
self.UpdateSTDVec: BoolType | BoolKey = BoolKey(name='UpdateSTDVec', comment='Shift atoms so that center of mass is at zero. As a results the detected symmetry may be higher.', default=True)
self.UseDiracCoulomb: BoolType | BoolKey = BoolKey(name='UseDiracCoulomb', comment='Affects dirac subroutine. In 2023 a spline-based routine was made replacing the original code that employed a (necessary) 10-6 CutOff. To emulate pre ams2023 calculations set this key to false.', hidden=True, default=True)
self.UseSharedMemoryForSandwiching: BoolType | BoolKey = BoolKey(name='UseSharedMemoryForSandwiching', comment='When calculating matrix elements the array will be shared. This saves memory at the cost of locking overhead.\n\nIf not specified this will depend on the threshold SharedMemorySandwichingThreshold', gui_name='Use shared memory:', default=True)
self.UseTurnoverRuleForXcMatrix: BoolType | BoolKey = BoolKey(name='UseTurnoverRuleForXcMatrix', comment='Undocumented.', default=False)
self.UseTurnoverRuleForXcMatrixDirac: BoolType | BoolKey = BoolKey(name='UseTurnoverRuleForXcMatrixDirac', comment='Affects which potential to use in Dirac in case of libxc and UseTurnoverRuleForXcMatrix=true.', hidden=True, default=False)
self.Usenewtailroutines: BoolType | BoolKey = BoolKey(name='Usenewtailroutines', comment='Undocumented.', hidden=True, default=True)
self.Usesharedmemory: BoolType | BoolKey = BoolKey(name='Usesharedmemory', comment='When running more then one task, share memory between those tasks. This saves a lot of memory.\n\nOnly disable it in case of problems.', gui_name='Use shared memory:', default=True)
self.Usestofit: BoolType | BoolKey = BoolKey(name='Usestofit', comment='Undocumented.', hidden=True, default=True)
self.Usezlmfit: BoolType | BoolKey = BoolKey(name='Usezlmfit', comment='Undocumented.', hidden=True, default=False)
self.VOCBasEvaluator4OptimizeOrdering: BoolType | BoolKey = BoolKey(name='VOCBasEvaluator4OptimizeOrdering', comment='Make sure that the sparse functions are ordered (idtail is ascending).', hidden=True, default=True)
self.Wipeonecenterterms: BoolType | BoolKey = BoolKey(name='Wipeonecenterterms', comment='Undocumented.', hidden=True, default=False)
[docs] class _PropertiesAtNuclei(FreeBlock):
r"""
A number of properties can be obtained near the nucleus. An average is taken over a tiny sphere around the nucleus. The following properties are available: vxc[rho(fit)], rho(fit), rho(scf), v(coulomb/scf), rho(deformation/fit), rho(deformation/scf).
"""
def __post_init__(self):
pass
[docs] class _RIHartreeFock(FixedBlock):
r"""
:ivar DependencyCoreRange: Basis functions may be given a core character based on the range. For now only active in Band and only if present in the input
:vartype DependencyCoreRange: float | FloatKey
:ivar DependencyThreshold: To improve numerical stability, almost linearly-dependent combination of basis functions are removed from the Hartree-Fock exchange matrix.
If you obtain unphysically large bond energy in an Hybrid calculation, or an unphysically low correlation energy in an RPA, MP2, or double hybrid calculation, you might try setting the DependencyThreshold to a larger value (e.g. 3.0E-3)
Note, that in GW calculations and GW-BSE calculations the default for this key is 5.0e-3.
:vartype DependencyThreshold: float | FloatKey
:ivar DoAlternativeDependencyTrick: Only applies to band. Do trick on the density matrix being input to HFEval, rather than on the K-matrix.
:vartype DoAlternativeDependencyTrick: BoolType | BoolKey
:ivar DoDependencyTrick: Available only in BAND, turns on and off the RIHartreeFock dependency trick.
:vartype DoDependencyTrick: BoolType | BoolKey
:ivar FitSetQuality: The quality of auxiliary fit set employed in the RI scheme.
If 'Auto', the value of the RIHartreeFock Quality option will be used.
Normal quality is generally sufficient for basis sets up to and including TZ2P.
For larger basis sets (or for benchmarking purposes) a VeryGood fit set is recommended.
Note that the FitSetQuality heavily influences the computational cost of the calculation.
:vartype FitSetQuality: Literal["Auto", "VeryBasic", "Basic", "Normal", "Good", "VeryGood", "Excellent", "FromBasisProducts"]
:ivar IntegrationQuality: Quality of the numerical integration for evaluating the integrals between basis functions and fit functions. If IntegrationQuality is not defined in input, the value defined in RIHartreeFock%Quality will be used.
:vartype IntegrationQuality: Literal["VeryBasic", "Basic", "Normal", "Good", "VeryGood", "Excellent"]
:ivar Quality: Numerical accuracy of the RI procedure. If 'Auto', the quality specified in the 'NumericalQuality' will be used.
:vartype Quality: Literal["Auto", "VeryBasic", "Basic", "Normal", "Good", "VeryGood", "Excellent"]
:ivar ResponseQuality: Numerical accuracy of the RI procedure for the Response module.
:vartype ResponseQuality: Literal["VeryBasic", "Basic", "Normal", "Good", "VeryGood", "Excellent"]
:ivar ThresholdQuality: Linear scaling thresholds (also used for determining at what range the multiple approximation is used). To disable all linear scaling thresholds set this to Excellent.
:vartype ThresholdQuality: Literal["VeryBasic", "Basic", "Normal", "Good", "VeryGood", "Excellent"]
:ivar UseCoulombMetricForDependency: Use Coulomb metric for the Dependency Trick (band only)
:vartype UseCoulombMetricForDependency: BoolType | BoolKey
:ivar UseMe: Set to False if you want to use the old RI scheme (ADF only)
:vartype UseMe: BoolType | BoolKey
:ivar ExplicitThresholds: Override the thresholds as implied by the ThresholdQuality.
:vartype ExplicitThresholds: BAND._RIHartreeFock._ExplicitThresholds
:ivar FitGenerationDetails: Technical details about how the RI Hartree-Fock fit functions are generated.
:vartype FitGenerationDetails: BAND._RIHartreeFock._FitGenerationDetails
:ivar QualityPerRegion: Sets the fit-set quality for all atoms in a region. If specified, this overwrites the globally set quality.
:vartype QualityPerRegion: BAND._RIHartreeFock._QualityPerRegion
"""
[docs] class _ExplicitThresholds(FixedBlock):
r"""
Override the thresholds as implied by the ThresholdQuality.
:ivar Basis: Threshold for the basis functions.
:vartype Basis: float | FloatKey
:ivar Fit: Threshold for the fit functions.
:vartype Fit: float | FloatKey
:ivar Potential: Threshold for the potential of the functions.
:vartype Potential: float | FloatKey
"""
def __post_init__(self):
self.Basis: float | FloatKey = FloatKey(name='Basis', comment='Threshold for the basis functions.\n\n')
self.Fit: float | FloatKey = FloatKey(name='Fit', comment='Threshold for the fit functions.\n\n')
self.Potential: float | FloatKey = FloatKey(name='Potential', comment='Threshold for the potential of the functions.\n\n')
[docs] class _FitGenerationDetails(FixedBlock):
r"""
Technical details about how the RI Hartree-Fock fit functions are generated.
:ivar BoostL: Add extra max(l)+1 diffuse function
When l denotes the highest angular momentum present in the primary basis,
FromBasisProducts will generate auxiliary fit functions with up to 2l angular momentum.
When this key is set to true, the maximum angular momentum in the auxiliary fit set becomes 2l+2.
Typically, this option is not needed and when precision issues arise, it is rather advised to adjust the OneCenterDependencyThreshold key to a smaller value.
:vartype BoostL: BoolType | BoolKey
:ivar LapackWorkAround: GetFitFunctionsForAtomType diagonalization done with Lapack instead of Scalapack
:vartype LapackWorkAround: BoolType | BoolKey
:ivar Method: The way in which fit functions are generated. The main distinction is whether it depends on the basis functions used.
When FromBasisProducts is used, the auxiliary basis is generated directly from the products of primary basis functions.
This has the advantage that the auxiliary fit adapts automatically to the basis set size.
Especially for basis sets of QZ quality or larger, this is often necessary to obtain highly precise correlation energies using RPA or double hybrids
FromBasisProducts option is also useful for GW or BSE calculations with basis sets of QZ quality or larger.
:vartype Method: Literal["Auto", "FromBasisProducts"]
:ivar OneCenterDependencyThreshold: This key is only active when FromBasisProducts is chosen as method to generate the auxiliary basis.
This threshold controls the size, and at the samw time, the precision of the auxiliary basis set. A smaller number leads to a larger auxiliary fit set.
The default value of 1e-8 is typically sufficient to converge correlation energies and QP energies to a very high precision.
It corresponds to an auxiliary basis which is typically 8-9 times larger than the primary basis.
:vartype OneCenterDependencyThreshold: float | FloatKey
:ivar UseBandRadialGrid: Only applies to band. The band logarithmic grid ranges (by default) from 1e-6 to 100 with 3000 points. Otherwise 300 points will be used.
For 0-periodicity (molecules) it is advisable to set this key to false since lots of memory is needed to evaluate all necessary integrals.
:vartype UseBandRadialGrid: BoolType | BoolKey
"""
def __post_init__(self):
self.BoostL: BoolType | BoolKey = BoolKey(name='BoostL', comment='Add extra max(l)+1 diffuse function\n\nWhen l denotes the highest angular momentum present in the primary basis,\n\nFromBasisProducts will generate auxiliary fit functions with up to 2l angular momentum.\n\nWhen this key is set to true, the maximum angular momentum in the auxiliary fit set becomes 2l+2.\n\nTypically, this option is not needed and when precision issues arise, it is rather advised to adjust the OneCenterDependencyThreshold key to a smaller value.', default=False)
self.LapackWorkAround: BoolType | BoolKey = BoolKey(name='LapackWorkAround', comment=' GetFitFunctionsForAtomType diagonalization done with Lapack instead of Scalapack', default=False)
self.Method: Literal["Auto", "FromBasisProducts"] = MultipleChoiceKey(name='Method', comment='The way in which fit functions are generated. The main distinction is whether it depends on the basis functions used.\n\nWhen FromBasisProducts is used, the auxiliary basis is generated directly from the products of primary basis functions.\n\nThis has the advantage that the auxiliary fit adapts automatically to the basis set size.\n\nEspecially for basis sets of QZ quality or larger, this is often necessary to obtain highly precise correlation energies using RPA or double hybrids\n\nFromBasisProducts option is also useful for GW or BSE calculations with basis sets of QZ quality or larger.\n\n', default='Auto', choices=['Auto', 'FromBasisProducts'])
self.OneCenterDependencyThreshold: float | FloatKey = FloatKey(name='OneCenterDependencyThreshold', comment='This key is only active when FromBasisProducts is chosen as method to generate the auxiliary basis.\n\nThis threshold controls the size, and at the samw time, the precision of the auxiliary basis set. A smaller number leads to a larger auxiliary fit set.\n\nThe default value of 1e-8 is typically sufficient to converge correlation energies and QP energies to a very high precision.\n\nIt corresponds to an auxiliary basis which is typically 8-9 times larger than the primary basis.', default=1e-08)
self.UseBandRadialGrid: BoolType | BoolKey = BoolKey(name='UseBandRadialGrid', comment='Only applies to band. The band logarithmic grid ranges (by default) from 1e-6 to 100 with 3000 points. Otherwise 300 points will be used.\n\nFor 0-periodicity (molecules) it is advisable to set this key to false since lots of memory is needed to evaluate all necessary integrals.', default=True)
[docs] class _QualityPerRegion(FixedBlock):
r"""
Sets the fit-set quality for all atoms in a region. If specified, this overwrites the globally set quality.
:ivar Quality: This region's quality of the auxiliary fit set employed in the RI scheme.
:vartype Quality: Literal["VeryBasic", "Basic", "Normal", "Good", "VeryGood", "Excellent"]
:ivar Region: The identifier of the region for which to set the quality.
:vartype Region: str | StringKey
"""
def __post_init__(self):
self.Quality: Literal["VeryBasic", "Basic", "Normal", "Good", "VeryGood", "Excellent"] = MultipleChoiceKey(name='Quality', comment="This region's quality of the auxiliary fit set employed in the RI scheme.", choices=['VeryBasic', 'Basic', 'Normal', 'Good', 'VeryGood', 'Excellent'])
self.Region: str | StringKey = StringKey(name='Region', comment='The identifier of the region for which to set the quality.', gui_type='region')
def __post_init__(self):
self.DependencyCoreRange: float | FloatKey = FloatKey(name='DependencyCoreRange', comment='Basis functions may be given a core character based on the range. For now only active in Band and only if present in the input')
self.DependencyThreshold: float | FloatKey = FloatKey(name='DependencyThreshold', comment='To improve numerical stability, almost linearly-dependent combination of basis functions are removed from the Hartree-Fock exchange matrix.\n\nIf you obtain unphysically large bond energy in an Hybrid calculation, or an unphysically low correlation energy in an RPA, MP2, or double hybrid calculation, you might try setting the DependencyThreshold to a larger value (e.g. 3.0E-3)\n\nNote, that in GW calculations and GW-BSE calculations the default for this key is 5.0e-3.', default=0.001, extra_info='not_in_fragment')
self.DoAlternativeDependencyTrick: BoolType | BoolKey = BoolKey(name='DoAlternativeDependencyTrick', comment='Only applies to band. Do trick on the density matrix being input to HFEval, rather than on the K-matrix.', hidden=True, default=False)
self.DoDependencyTrick: BoolType | BoolKey = BoolKey(name='DoDependencyTrick', comment='Available only in BAND, turns on and off the RIHartreeFock dependency trick.', hidden=True, default=True)
self.FitSetQuality: Literal["Auto", "VeryBasic", "Basic", "Normal", "Good", "VeryGood", "Excellent", "FromBasisProducts"] = MultipleChoiceKey(name='FitSetQuality', comment="The quality of auxiliary fit set employed in the RI scheme.\n\nIf 'Auto', the value of the RIHartreeFock Quality option will be used.\n\nNormal quality is generally sufficient for basis sets up to and including TZ2P.\n\nFor larger basis sets (or for benchmarking purposes) a VeryGood fit set is recommended.\n\nNote that the FitSetQuality heavily influences the computational cost of the calculation.", default='Auto', choices=['Auto', 'VeryBasic', 'Basic', 'Normal', 'Good', 'VeryGood', 'Excellent', 'FromBasisProducts'])
self.IntegrationQuality: Literal["VeryBasic", "Basic", "Normal", "Good", "VeryGood", "Excellent"] = MultipleChoiceKey(name='IntegrationQuality', comment='Quality of the numerical integration for evaluating the integrals between basis functions and fit functions. If IntegrationQuality is not defined in input, the value defined in RIHartreeFock%Quality will be used.', choices=['VeryBasic', 'Basic', 'Normal', 'Good', 'VeryGood', 'Excellent'])
self.Quality: Literal["Auto", "VeryBasic", "Basic", "Normal", "Good", "VeryGood", "Excellent"] = MultipleChoiceKey(name='Quality', comment="Numerical accuracy of the RI procedure. If 'Auto', the quality specified in the 'NumericalQuality' will be used.", default='Auto', choices=['Auto', 'VeryBasic', 'Basic', 'Normal', 'Good', 'VeryGood', 'Excellent'])
self.ResponseQuality: Literal["VeryBasic", "Basic", "Normal", "Good", "VeryGood", "Excellent"] = MultipleChoiceKey(name='ResponseQuality', comment='Numerical accuracy of the RI procedure for the Response module.', choices=['VeryBasic', 'Basic', 'Normal', 'Good', 'VeryGood', 'Excellent'])
self.ThresholdQuality: Literal["VeryBasic", "Basic", "Normal", "Good", "VeryGood", "Excellent"] = MultipleChoiceKey(name='ThresholdQuality', comment='Linear scaling thresholds (also used for determining at what range the multiple approximation is used). To disable all linear scaling thresholds set this to Excellent.', choices=['VeryBasic', 'Basic', 'Normal', 'Good', 'VeryGood', 'Excellent'])
self.UseCoulombMetricForDependency: BoolType | BoolKey = BoolKey(name='UseCoulombMetricForDependency', comment='Use Coulomb metric for the Dependency Trick (band only)', hidden=True, default=False)
self.UseMe: BoolType | BoolKey = BoolKey(name='UseMe', comment='Set to False if you want to use the old RI scheme (ADF only)', default=True)
self.ExplicitThresholds: BAND._RIHartreeFock._ExplicitThresholds = self._ExplicitThresholds(name='ExplicitThresholds', comment='Override the thresholds as implied by the ThresholdQuality.')
self.FitGenerationDetails: BAND._RIHartreeFock._FitGenerationDetails = self._FitGenerationDetails(name='FitGenerationDetails', comment='Technical details about how the RI Hartree-Fock fit functions are generated.')
self.QualityPerRegion: BAND._RIHartreeFock._QualityPerRegion = self._QualityPerRegion(name='QualityPerRegion', comment='Sets the fit-set quality for all atoms in a region. If specified, this overwrites the globally set quality.', unique=False)
[docs] class _RadialDefaults(FixedBlock):
r"""
Options for the logarithmic radial grid of the basis functions used in the subprogram Dirac
:ivar AdjustRMinForFunctional: Some functionals have numerically unstable potentials near the nucleus for light elements: Enlarge rmin for lighter elements. If not specified then the option will be set for the OLYP and HTBS functionals
:vartype AdjustRMinForFunctional: BoolType | BoolKey
:ivar DiDervViaSpline: replace old diderv with DiDervViaSpline
:vartype DiDervViaSpline: BoolType | BoolKey
:ivar NR: Number of radial points. With very high values (like 30000) the Dirac subprogram may not converge.
:vartype NR: int | IntKey
:ivar NRPerType: If present overrides NR. The list needs to be as long as there are atom types
:vartype NRPerType: Iterable[int] | IntListKey
:ivar RMax: Upper bound of the logarithmic radial grid
:vartype RMax: float | FloatKey
:ivar RMin: Lower bound of the logarithmic radial grid
:vartype RMin: float | FloatKey
:ivar RMinPerType: If specified overrides RMin. The list needs to be as long as there are atom types (different elements)
:vartype RMinPerType: Iterable[float] | FloatListKey
"""
def __post_init__(self):
self.AdjustRMinForFunctional: BoolType | BoolKey = BoolKey(name='AdjustRMinForFunctional', comment='Some functionals have numerically unstable potentials near the nucleus for light elements: Enlarge rmin for lighter elements. If not specified then the option will be set for the OLYP and HTBS functionals', hidden=True, default=False)
self.DiDervViaSpline: BoolType | BoolKey = BoolKey(name='DiDervViaSpline', comment='replace old diderv with DiDervViaSpline', hidden=True, default=False)
self.NR: int | IntKey = IntKey(name='NR', comment='Number of radial points. With very high values (like 30000) the Dirac subprogram may not converge.', default=3000)
self.NRPerType: Iterable[int] | IntListKey = IntListKey(name='NRPerType', comment='If present overrides NR. The list needs to be as long as there are atom types')
self.RMax: float | FloatKey = FloatKey(name='RMax', comment='Upper bound of the logarithmic radial grid', default=100.0, unit='Bohr')
self.RMin: float | FloatKey = FloatKey(name='RMin', comment='Lower bound of the logarithmic radial grid', default=1e-06, unit='Bohr')
self.RMinPerType: Iterable[float] | FloatListKey = FloatListKey(name='RMinPerType', comment='If specified overrides RMin. The list needs to be as long as there are atom types (different elements)', unit='Bohr')
[docs] class _Relativity(FixedBlock):
r"""
Options for relativistic effects.
:ivar Level: None: No relativistic effects.
Scalar: Scalar relativistic ZORA.
This option comes at very little cost.
SpinOrbit: Spin-orbit coupled ZORA.
This is the best level of theory, but it is (4-8 times) more expensive than a normal calculation. Spin-orbit effects are generally quite small, unless there are very heavy atoms in your system, especially with p valence electrons (like Pb).
See also the SpinOrbitMagnetization key.
:vartype Level: Literal["None", "Scalar", "Spin-Orbit"]
:ivar Potential: Undocumented
:vartype Potential: Literal["APA", "SAPA"]
"""
def __post_init__(self):
self.Level: Literal["None", "Scalar", "Spin-Orbit"] = MultipleChoiceKey(name='Level', comment='None: No relativistic effects.\n\nScalar: Scalar relativistic ZORA.\nThis option comes at very little cost.\n\nSpinOrbit: Spin-orbit coupled ZORA.\nThis is the best level of theory, but it is (4-8 times) more expensive than a normal calculation. Spin-orbit effects are generally quite small, unless there are very heavy atoms in your system, especially with p valence electrons (like Pb).\n\nSee also the SpinOrbitMagnetization key.', gui_name='Relativity (ZORA):', default='Scalar', choices=['None', 'Scalar', 'Spin-Orbit'])
self.Potential: Literal["APA", "SAPA"] = MultipleChoiceKey(name='Potential', comment='Undocumented', hidden=True, default='APA', choices=['APA', 'SAPA'])
[docs] class _ResponseInducedDensityPlot(FreeBlock):
r"""
Goes together with Restart%ResponseInducedDensityPlot and Grid.
"""
def __post_init__(self):
pass
[docs] class _Restart(FixedBlock):
r"""
Tells the program that it should restart with the restart file, and what to restart.
:ivar BandStructure: Calculate the band structure from a previous calculation. Does not work with model potentials and Hubbard.
:vartype BandStructure: BoolType | BoolKey
:ivar COSMO: Restart the COSMO charges.
:vartype COSMO: BoolType | BoolKey
:ivar CheckAtomicPositions: If set to True: For restarting the SCF the atomic positions will be checked, and may not deviate too much.
:vartype CheckAtomicPositions: BoolType | BoolKey
:ivar DOS: Calculate the DOS from a previous calculation. Does not work with model potentials and Hubbard.
:vartype DOS: BoolType | BoolKey
:ivar DensityPlot: Goes together with the DensityPlot block and Grid blocks
:vartype DensityPlot: BoolType | BoolKey
:ivar FermiSurface: Undocumented.
:vartype FermiSurface: BoolType | BoolKey
:ivar File: Name of the restart file. The file should be a band.rkf file from a previous run.
:vartype File: str | Path | StringKey
:ivar IgnoreBadGeometry: Undocumented.
:vartype IgnoreBadGeometry: BoolType | BoolKey
:ivar LoadEigenSystem: At each step of the SCF load the section eigensystem from the restart file, forcing constant eigenvalues and vectors.
:vartype LoadEigenSystem: BoolType | BoolKey
:ivar NOCVOrbitalPlot: Goes together with the NOCVOrbitalPlot and Grid blocks.
:vartype NOCVOrbitalPlot: BoolType | BoolKey
:ivar NOCVdRhoPlot: Goes together with the NOCVdRhoPlot and Grid blocks.
:vartype NOCVdRhoPlot: BoolType | BoolKey
:ivar NoPrdRhoPlot: Undocumented.
:vartype NoPrdRhoPlot: BoolType | BoolKey
:ivar NoprOrbitalPlot: Undocumented.
:vartype NoprOrbitalPlot: BoolType | BoolKey
:ivar OrbitalPlot: Goes together with the OrbitalPlot and Grid
:vartype OrbitalPlot: BoolType | BoolKey
:ivar ResponseInducedDensityPlot: Goes together with the ResponseInducedDensityPlot and Grid blocks.
:vartype ResponseInducedDensityPlot: BoolType | BoolKey
:ivar SCF: Continue the SCF procedure using the orbital coefficients and occupations from the restart file.
:vartype SCF: BoolType | BoolKey
:ivar UseDensityMatrix: If set to True: For restarting the SCF the density matrix will be used. Requires you to set 'Save DensityMatrix' in the previous run.
:vartype UseDensityMatrix: BoolType | BoolKey
:ivar VTKFile: If specified a vtk file with be created with this name. If the extension is '.txt', a text file is created. Setting it to 'CUBE' one or more (one for each component) files in the cube format are generated with an automatic naming scheme.
:vartype VTKFile: str | StringKey
:ivar VoronoiGrid: Copy the section Num In Params to the current file.
:vartype VoronoiGrid: BoolType | BoolKey
"""
def __post_init__(self):
self.BandStructure: BoolType | BoolKey = BoolKey(name='BandStructure', comment='Calculate the band structure from a previous calculation. Does not work with model potentials and Hubbard.', default=False)
self.COSMO: BoolType | BoolKey = BoolKey(name='COSMO', comment='Restart the COSMO charges.', hidden=True, default=False)
self.CheckAtomicPositions: BoolType | BoolKey = BoolKey(name='CheckAtomicPositions', comment='If set to True: For restarting the SCF the atomic positions will be checked, and may not deviate too much.', default=True)
self.DOS: BoolType | BoolKey = BoolKey(name='DOS', comment='Calculate the DOS from a previous calculation. Does not work with model potentials and Hubbard.', default=False)
self.DensityPlot: BoolType | BoolKey = BoolKey(name='DensityPlot', comment='Goes together with the DensityPlot block and Grid blocks', default=False)
self.FermiSurface: BoolType | BoolKey = BoolKey(name='FermiSurface', comment='Undocumented.', hidden=True, default=False)
self.File: str | Path | StringKey = PathStringKey(name='File', comment='Name of the restart file. The file should be a band.rkf file from a previous run.', gui_name='Restart using:', default='', ispath=True, gui_type='.rkf {{{BAND Result Files} .rkf} {{Any Files} *}} absolute')
self.IgnoreBadGeometry: BoolType | BoolKey = BoolKey(name='IgnoreBadGeometry', comment='Undocumented.', hidden=True, default=False)
self.LoadEigenSystem: BoolType | BoolKey = BoolKey(name='LoadEigenSystem', comment='At each step of the SCF load the section eigensystem from the restart file, forcing constant eigenvalues and vectors.', gui_name='Load: eigen system', default=False)
self.NOCVOrbitalPlot: BoolType | BoolKey = BoolKey(name='NOCVOrbitalPlot', comment='Goes together with the NOCVOrbitalPlot and Grid blocks.', default=False)
self.NOCVdRhoPlot: BoolType | BoolKey = BoolKey(name='NOCVdRhoPlot', comment='Goes together with the NOCVdRhoPlot and Grid blocks.', default=False)
self.NoPrdRhoPlot: BoolType | BoolKey = BoolKey(name='NoPrdRhoPlot', comment='Undocumented.', hidden=True, default=False)
self.NoprOrbitalPlot: BoolType | BoolKey = BoolKey(name='NoprOrbitalPlot', comment='Undocumented.', hidden=True, default=False)
self.OrbitalPlot: BoolType | BoolKey = BoolKey(name='OrbitalPlot', comment='Goes together with the OrbitalPlot and Grid', default=False)
self.ResponseInducedDensityPlot: BoolType | BoolKey = BoolKey(name='ResponseInducedDensityPlot', comment='Goes together with the ResponseInducedDensityPlot and Grid blocks.', default=False)
self.SCF: BoolType | BoolKey = BoolKey(name='SCF', comment='Continue the SCF procedure using the orbital coefficients and occupations from the restart file.', gui_name='Restart: SCF', default=False)
self.UseDensityMatrix: BoolType | BoolKey = BoolKey(name='UseDensityMatrix', comment="If set to True: For restarting the SCF the density matrix will be used. Requires you to set 'Save DensityMatrix' in the previous run.", default=False)
self.VTKFile: str | StringKey = StringKey(name='VTKFile', comment="If specified a vtk file with be created with this name. If the extension is '.txt', a text file is created. Setting it to 'CUBE' one or more (one for each component) files in the cube format are generated with an automatic naming scheme.", default=' ')
self.VoronoiGrid: BoolType | BoolKey = BoolKey(name='VoronoiGrid', comment='Copy the section Num In Params to the current file.', default=False)
[docs] class _SCF(FixedBlock):
r"""
Controls technical SCF parameters.
:ivar ApplyVSplitToDensity: Undocumented.
:vartype ApplyVSplitToDensity: BoolType | BoolKey
:ivar Eigenstates: The program knows two alternative ways to evaluate the charge density iteratively in the SCF procedure: from the P-matrix, and directly from the squared occupied eigenstates. By default the program actually uses both at least one time and tries to take the most efficient. If present, Eigenstates turns off this comparison and lets the program stick to one method (from the eigenstates).
:vartype Eigenstates: BoolType | BoolKey
:ivar Iterations: The maximum number of SCF iterations to be performed.
:vartype Iterations: int | IntKey
:ivar LoadPreviousSCFMixing: Load dimix and mixing from the previous SCF procedure, for instance during a geometry optimization.
:vartype LoadPreviousSCFMixing: BoolType | BoolKey
:ivar Method: Choose the general scheme used to converge the density in the SCF. In case of scf problems one can try the MultiSecant alternative at no extra cost per SCF cycle. For more details see the DIIS and MultiSecantConfig block.
:vartype Method: Literal["DIIS", "MultiSecant", "MultiStepper"]
:ivar Mixing: Initial 'damping' parameter in the SCF procedure, for the iterative update of the potential: new potential = old potential + mix (computed potential-old potential). Note: the program automatically adapts Mixing during the SCF iterations, in an attempt to find the optimal mixing value.
:vartype Mixing: float | FloatKey
:ivar MultiStepperPresetPath: Name of file containing a SCFMultiStepper key block. This will be used if no Explicit SCFMultiStepper block is in the input, and Method=MultiStepper.
If the path is not absolute, it is relative to $AMSHOME/data/presets/multi_stepper'
:vartype MultiStepperPresetPath: str | Path | StringKey
:ivar NComponentsForNonColDIIS: For a non-collinear calculation: use all 8 components for the DIIS error metric. Possible choices: 2,4,8. With option=2 information is discarded. Option=4 or 8 are nearly identical except that the off diag weights are a bit different. Before the key was introduced two components were used.
:vartype NComponentsForNonColDIIS: int | IntKey
:ivar NewEigenstates: Undocumented.
:vartype NewEigenstates: BoolType | BoolKey
:ivar NewPMatrix: Undocumented.
:vartype NewPMatrix: BoolType | BoolKey
:ivar PMatrix: If present, evaluate the charge density from the P-matrix. See also the key Eigenstates.
:vartype PMatrix: BoolType | BoolKey
:ivar PrintAllOccupiedBands: When printing the ranges of the bands, include all occupied ones.
:vartype PrintAllOccupiedBands: BoolType | BoolKey
:ivar PrintAllVirtualBands: When printing the ranges of the bands, include all virtual ones.
:vartype PrintAllVirtualBands: BoolType | BoolKey
:ivar PrintAlwaysBandRanges: Normally the ranges of the bands are only printed at the last SCF cycle
:vartype PrintAlwaysBandRanges: BoolType | BoolKey
:ivar Rate: Minimum rate of convergence for the SCF procedure. If progress is too slow the program will take measures (such as smearing out occupations around the Fermi level, see key Degenerate of block Convergence) or, if everything seems to fail, it will stop
:vartype Rate: float | FloatKey
:ivar SkipDiagonalization: Undocumented.
:vartype SkipDiagonalization: BoolType | BoolKey
:ivar TryDensityMethods: Undocumented.
:vartype TryDensityMethods: str | StringKey
:ivar VSplit: To disturb degeneracy of alpha and beta spin MOs the value of this key is added to the beta spin potential at the startup.
:vartype VSplit: float | FloatKey
:ivar SCFMultiStepper: To solve the self-consistent problem multiple steppers can be tried during stints using the ones that give the best progress.
:vartype SCFMultiStepper: BAND._SCF._SCFMultiStepper
"""
[docs] class _SCFMultiStepper(FixedBlock):
r"""
To solve the self-consistent problem multiple steppers can be tried during stints using the ones that give the best progress.
:ivar AlwaysChangeStepper: When the progress is fine there is no reason to change the stepper. In practice this is always set to true, because also the Stepper%ExpectedSlope can be used to achieve similar behavior.
:vartype AlwaysChangeStepper: BoolType | BoolKey
:ivar ErrorGrowthAbortFactor: Abort stint when the error grows too much, compared to the error at the start of the stint.
:vartype ErrorGrowthAbortFactor: float | FloatKey
:ivar FractionalStepFactor: Multiply the step by this factor. If smaller than zero this is not used.
:vartype FractionalStepFactor: float | FloatKey
:ivar MinStintCyclesForAbort: Look at ErrorGrowthAbortFactor only when a number of steps has been completed since the start of the stint. A value of 0 means always.
:vartype MinStintCyclesForAbort: int | IntKey
:ivar StintLength: A stepper is active during a number of SCF cycles, called a stint.
:vartype StintLength: int | IntKey
:ivar UsePreviousStintForErrorGrowthAbort: The error is normally checked against the first error of the stint. With this option that will be the one from the previous stint, if performed with the same stepper.
:vartype UsePreviousStintForErrorGrowthAbort: BoolType | BoolKey
:ivar Stepper: ??
:vartype Stepper: BAND._SCF._SCFMultiStepper._Stepper
"""
[docs] class _Stepper(FixedBlock):
r"""
??
:ivar AbortSlope: If the slope (at the end of a stint) is larger than this: abort the stepper
:vartype AbortSlope: float | FloatKey
:ivar AlwaysAbortAtBeginOfStint: For debugging only: no matter what abort this stepper at the begin of the stint (doing only one step).
:vartype AlwaysAbortAtBeginOfStint: BoolType | BoolKey
:ivar AlwaysAbortAtEndOfStint: For debugging only: no matter what abort this stepper at the end of the stint.
:vartype AlwaysAbortAtEndOfStint: BoolType | BoolKey
:ivar ErrorGrowthAbortFactor: Abort stint when the error grows too much, compared to the error at the start of the stint. Overrides global ErrorGrowthAbortFactor when set to a value > 0
:vartype ErrorGrowthAbortFactor: float | FloatKey
:ivar ExpectedSlope: If the slope of the total SCF is better than this keep on going.
:vartype ExpectedSlope: float | FloatKey
:ivar FractionalStepFactor: Multiply the step by this factor. If smaller than zero this is not used.
:vartype FractionalStepFactor: float | FloatKey
:ivar InitialMixFromPreviousStint: Similar to MixFromPreviousStint, but only done the first time that a stepper is used.
:vartype InitialMixFromPreviousStint: BoolType | BoolKey
:ivar MaxInitialError: Only use the stepper when error is smaller than this.
:vartype MaxInitialError: float | FloatKey
:ivar MaxIterationNumber: Stepper will only be active for iterations smaller than this number. (Negative value means: Ignore this option)
:vartype MaxIterationNumber: int | IntKey
:ivar MaxStintNumber: Stepper will only be active for stints smaller than this number. (Negative value means: Ignore this option)
:vartype MaxStintNumber: int | IntKey
:ivar MaxStints: Maximum number of stints that a stepper should be used.
:vartype MaxStints: int | IntKey
:ivar MinInitialError: Only use the stepper when error is larger than this.
:vartype MinInitialError: float | FloatKey
:ivar MinIterationNumber: Stepper will only be active for iterations larger than this number.
:vartype MinIterationNumber: int | IntKey
:ivar MinStintCyclesForAbort: Look at ErrorGrowthAbortFactor only when a number of steps has been completed since the start of the stint. A value of 0 means always. Overrides global value.
:vartype MinStintCyclesForAbort: int | IntKey
:ivar MinStintNumber: Stepper will only be active for stints larger than this number.
:vartype MinStintNumber: int | IntKey
:ivar MixFromPreviousStint: When starting a new stint use the mix from the previous stepper, even if it is of another type.
:vartype MixFromPreviousStint: BoolType | BoolKey
:ivar StintLength: Override global StintLength.
:vartype StintLength: int | IntKey
:ivar DIISStepper: DIIS stepper
:vartype DIISStepper: BAND._SCF._SCFMultiStepper._Stepper._DIISStepper
:ivar MixAdapter: Generic mix adapter
:vartype MixAdapter: BAND._SCF._SCFMultiStepper._Stepper._MixAdapter
:ivar MixStepper: Simple mixing stepper, only using the previous (in/out) density.
:vartype MixStepper: BAND._SCF._SCFMultiStepper._Stepper._MixStepper
:ivar MultiSecantStepper: Multi secant stepper.
:vartype MultiSecantStepper: BAND._SCF._SCFMultiStepper._Stepper._MultiSecantStepper
"""
[docs] class _DIISStepper(FixedBlock):
r"""
DIIS stepper
:ivar EDIIS: Use energy DIIS. The energy is used as extra info and only interpolation is done (all coefficients in the interval [0,1]).
:vartype EDIIS: BoolType | BoolKey
:ivar EDIISAlpha: The extra energy vector is weighed by this factor. .
:vartype EDIISAlpha: float | FloatKey
:ivar MaxBMatrixRange: If larger than zero: limit the ratio between the oldest and last diagonal B matrix element.
:vartype MaxBMatrixRange: float | FloatKey
:ivar MaxCoefficient: The largest allowed value of the expansion coefficients. If exceed the number of vectors is reduces until the criterion is met.
:vartype MaxCoefficient: float | FloatKey
:ivar MaxConditionNumber: If larger than zero: check condition number of the B matrix. If too large reduce nVectors.
:vartype MaxConditionNumber: float | FloatKey
:ivar MaxVectors: Maximum number of previous densities to be used (size of the history).
:vartype MaxVectors: int | IntKey
:ivar MinLastCoefficient: If larger than zero: If the most recent vector gets a (abs) coefficient smaller than this the mix is boosted.
:vartype MinLastCoefficient: float | FloatKey
:ivar MinVectors: Try to prevent to make nVectors shrink below this value, by allowing for significantly larger coefficients.
:vartype MinVectors: int | IntKey
:ivar Mix: Also known as greed. It determines the amount of output density to be used. May be changed by the MixAdapter.
:vartype Mix: float | FloatKey
:ivar RescaleBMatrix: Rescale the B matrix so that is's values are of the same order as those of the constraints.
:vartype RescaleBMatrix: BoolType | BoolKey
:ivar UseHalfMixForFirstCycle: Use half the mix factor at iteration 1 (if applicable).
:vartype UseHalfMixForFirstCycle: BoolType | BoolKey
"""
def __post_init__(self):
self.EDIIS: BoolType | BoolKey = BoolKey(name='EDIIS', comment='Use energy DIIS. The energy is used as extra info and only interpolation is done (all coefficients in the interval [0,1]).', hidden=True, default=False)
self.EDIISAlpha: float | FloatKey = FloatKey(name='EDIISAlpha', comment='The extra energy vector is weighed by this factor. .', default=0.01)
self.MaxBMatrixRange: float | FloatKey = FloatKey(name='MaxBMatrixRange', comment='If larger than zero: limit the ratio between the oldest and last diagonal B matrix element.', hidden=True, default=-1.0)
self.MaxCoefficient: float | FloatKey = FloatKey(name='MaxCoefficient', comment='The largest allowed value of the expansion coefficients. If exceed the number of vectors is reduces until the criterion is met.', default=20.0)
self.MaxConditionNumber: float | FloatKey = FloatKey(name='MaxConditionNumber', comment='If larger than zero: check condition number of the B matrix. If too large reduce nVectors.', hidden=True, default=-1.0)
self.MaxVectors: int | IntKey = IntKey(name='MaxVectors', comment='Maximum number of previous densities to be used (size of the history).', default=10)
self.MinLastCoefficient: float | FloatKey = FloatKey(name='MinLastCoefficient', comment='If larger than zero: If the most recent vector gets a (abs) coefficient smaller than this the mix is boosted.', hidden=True, default=-1.0)
self.MinVectors: int | IntKey = IntKey(name='MinVectors', comment='Try to prevent to make nVectors shrink below this value, by allowing for significantly larger coefficients.', default=-1)
self.Mix: float | FloatKey = FloatKey(name='Mix', comment='Also known as greed. It determines the amount of output density to be used. May be changed by the MixAdapter.', default=0.2)
self.RescaleBMatrix: BoolType | BoolKey = BoolKey(name='RescaleBMatrix', comment="Rescale the B matrix so that is's values are of the same order as those of the constraints.", hidden=True, default=True)
self.UseHalfMixForFirstCycle: BoolType | BoolKey = BoolKey(name='UseHalfMixForFirstCycle', comment='Use half the mix factor at iteration 1 (if applicable).', hidden=True, default=True)
[docs] class _MixAdapter(FixedBlock):
r"""
Generic mix adapter
:ivar CorrelateMixWithSlope: For the last two mixing factors the one with the best slope is preferred.
:vartype CorrelateMixWithSlope: BoolType | BoolKey
:ivar ErrorGrowthPanicFactor: When the error increases more than this factor, this mix is reduced a lot.
:vartype ErrorGrowthPanicFactor: float | FloatKey
:ivar GrowWhenSpaceGrows: Has only effect when the error goes down. If nVectors increases grow the mix factor, otherwise do not change the mix
:vartype GrowWhenSpaceGrows: BoolType | BoolKey
:ivar GrowthFactor: When the mix is considered too low it is multiplied by this factor. Otherwise it is divided by it.
:vartype GrowthFactor: float | FloatKey
:ivar MaxMix: Do not grow the mix above this value.
:vartype MaxMix: float | FloatKey
:ivar MinMix: Do not shrink the mix below this value.
:vartype MinMix: float | FloatKey
:ivar NTrialMixFactors: Only used with Type=Trial. Must be an odd number.
:vartype NTrialMixFactors: int | IntKey
:ivar TrialMode: How are the NTrialMixFactors chosen?
:vartype TrialMode: Literal["CurrentMixCentered", "FullRange"]
:ivar Type: Adapt the mix factor based on the observed progress (slope).
:vartype Type: Literal["Error", "Energy", "UnpredictedStep", "Trial"]
"""
def __post_init__(self):
self.CorrelateMixWithSlope: BoolType | BoolKey = BoolKey(name='CorrelateMixWithSlope', comment='For the last two mixing factors the one with the best slope is preferred.', hidden=True, default=False)
self.ErrorGrowthPanicFactor: float | FloatKey = FloatKey(name='ErrorGrowthPanicFactor', comment='When the error increases more than this factor, this mix is reduced a lot.', default=10.0)
self.GrowWhenSpaceGrows: BoolType | BoolKey = BoolKey(name='GrowWhenSpaceGrows', comment='Has only effect when the error goes down. If nVectors increases grow the mix factor, otherwise do not change the mix', hidden=True, default=True)
self.GrowthFactor: float | FloatKey = FloatKey(name='GrowthFactor', comment='When the mix is considered too low it is multiplied by this factor. Otherwise it is divided by it.', default=1.1)
self.MaxMix: float | FloatKey = FloatKey(name='MaxMix', comment='Do not grow the mix above this value.', default=0.3)
self.MinMix: float | FloatKey = FloatKey(name='MinMix', comment='Do not shrink the mix below this value.', default=0.1)
self.NTrialMixFactors: int | IntKey = IntKey(name='NTrialMixFactors', comment='Only used with Type=Trial. Must be an odd number.', default=3)
self.TrialMode: Literal["CurrentMixCentered", "FullRange"] = MultipleChoiceKey(name='TrialMode', comment='How are the NTrialMixFactors chosen?', default='CurrentMixCentered', choices=['CurrentMixCentered', 'FullRange'])
self.Type: Literal["Error", "Energy", "UnpredictedStep", "Trial"] = MultipleChoiceKey(name='Type', comment='Adapt the mix factor based on the observed progress (slope).', default='Error', choices=['Error', 'Energy', 'UnpredictedStep', 'Trial'])
[docs] class _MixStepper(FixedBlock):
r"""
Simple mixing stepper, only using the previous (in/out) density.
:ivar Mix: ???.
:vartype Mix: float | FloatKey
"""
def __post_init__(self):
self.Mix: float | FloatKey = FloatKey(name='Mix', comment='???.', default=0.1)
[docs] class _MultiSecantStepper(FixedBlock):
r"""
Multi secant stepper.
:ivar AlphaMSR1: For the MSR1 variant: W = Y + alpha S.
:vartype AlphaMSR1: float | FloatKey
:ivar MaxCoefficient: ???.
:vartype MaxCoefficient: float | FloatKey
:ivar MaxConditionNumber: If set larger than zero this condition number of the matrix to be inverted will be checked. If exceeded the space is reduced.
:vartype MaxConditionNumber: float | FloatKey
:ivar MaxVectors: ???.
:vartype MaxVectors: int | IntKey
:ivar Mix: ???.
:vartype Mix: float | FloatKey
:ivar PredictGreed: Try to predict the optimal greed.
:vartype PredictGreed: BoolType | BoolKey
:ivar ScaleYTY: Scale matrix before inversion
:vartype ScaleYTY: BoolType | BoolKey
:ivar SigmaRegularize: Prevent division by zero by adding a small number. Makes most sense when using renormalization.
:vartype SigmaRegularize: float | FloatKey
:ivar Variant: There are several version of the Multi secant method.
:vartype Variant: Literal["MSB1", "MSB2", "MSR1", "MSR1s"]
"""
def __post_init__(self):
self.AlphaMSR1: float | FloatKey = FloatKey(name='AlphaMSR1', comment='For the MSR1 variant: W = Y + alpha S.', hidden=True, default=0.1)
self.MaxCoefficient: float | FloatKey = FloatKey(name='MaxCoefficient', comment='???.', default=20.0)
self.MaxConditionNumber: float | FloatKey = FloatKey(name='MaxConditionNumber', comment='If set larger than zero this condition number of the matrix to be inverted will be checked. If exceeded the space is reduced.', hidden=True, default=-1.0)
self.MaxVectors: int | IntKey = IntKey(name='MaxVectors', comment='???.', default=10)
self.Mix: float | FloatKey = FloatKey(name='Mix', comment='???.', default=0.2)
self.PredictGreed: BoolType | BoolKey = BoolKey(name='PredictGreed', comment='Try to predict the optimal greed.', hidden=True, default=False)
self.ScaleYTY: BoolType | BoolKey = BoolKey(name='ScaleYTY', comment='Scale matrix before inversion', hidden=True, default=True)
self.SigmaRegularize: float | FloatKey = FloatKey(name='SigmaRegularize', comment='Prevent division by zero by adding a small number. Makes most sense when using renormalization.', hidden=True, default=1e-12)
self.Variant: Literal["MSB1", "MSB2", "MSR1", "MSR1s"] = MultipleChoiceKey(name='Variant', comment='There are several version of the Multi secant method.', default='MSB2', choices=['MSB1', 'MSB2', 'MSR1', 'MSR1s'])
def __post_init__(self):
self.AbortSlope: float | FloatKey = FloatKey(name='AbortSlope', comment='If the slope (at the end of a stint) is larger than this: abort the stepper', default=100.0)
self.AlwaysAbortAtBeginOfStint: BoolType | BoolKey = BoolKey(name='AlwaysAbortAtBeginOfStint', comment='For debugging only: no matter what abort this stepper at the begin of the stint (doing only one step).', hidden=True, default=False)
self.AlwaysAbortAtEndOfStint: BoolType | BoolKey = BoolKey(name='AlwaysAbortAtEndOfStint', comment='For debugging only: no matter what abort this stepper at the end of the stint.', hidden=True, default=False)
self.ErrorGrowthAbortFactor: float | FloatKey = FloatKey(name='ErrorGrowthAbortFactor', comment='Abort stint when the error grows too much, compared to the error at the start of the stint. Overrides global ErrorGrowthAbortFactor when set to a value > 0', default=-1.0)
self.ExpectedSlope: float | FloatKey = FloatKey(name='ExpectedSlope', comment='If the slope of the total SCF is better than this keep on going.', default=-100.0)
self.FractionalStepFactor: float | FloatKey = FloatKey(name='FractionalStepFactor', comment='Multiply the step by this factor. If smaller than zero this is not used.', default=-1.0)
self.InitialMixFromPreviousStint: BoolType | BoolKey = BoolKey(name='InitialMixFromPreviousStint', comment='Similar to MixFromPreviousStint, but only done the first time that a stepper is used.', hidden=True, default=False)
self.MaxInitialError: float | FloatKey = FloatKey(name='MaxInitialError', comment='Only use the stepper when error is smaller than this.')
self.MaxIterationNumber: int | IntKey = IntKey(name='MaxIterationNumber', comment='Stepper will only be active for iterations smaller than this number. (Negative value means: Ignore this option)', default=-1)
self.MaxStintNumber: int | IntKey = IntKey(name='MaxStintNumber', comment='Stepper will only be active for stints smaller than this number. (Negative value means: Ignore this option)', default=-1)
self.MaxStints: int | IntKey = IntKey(name='MaxStints', comment='Maximum number of stints that a stepper should be used.', hidden=True, default=-1)
self.MinInitialError: float | FloatKey = FloatKey(name='MinInitialError', comment='Only use the stepper when error is larger than this.')
self.MinIterationNumber: int | IntKey = IntKey(name='MinIterationNumber', comment='Stepper will only be active for iterations larger than this number.', default=-1)
self.MinStintCyclesForAbort: int | IntKey = IntKey(name='MinStintCyclesForAbort', comment='Look at ErrorGrowthAbortFactor only when a number of steps has been completed since the start of the stint. A value of 0 means always. Overrides global value.', default=0)
self.MinStintNumber: int | IntKey = IntKey(name='MinStintNumber', comment='Stepper will only be active for stints larger than this number.', default=-1)
self.MixFromPreviousStint: BoolType | BoolKey = BoolKey(name='MixFromPreviousStint', comment='When starting a new stint use the mix from the previous stepper, even if it is of another type.', hidden=True, default=False)
self.StintLength: int | IntKey = IntKey(name='StintLength', comment='Override global StintLength.')
self.DIISStepper: BAND._SCF._SCFMultiStepper._Stepper._DIISStepper = self._DIISStepper(name='DIISStepper', comment='DIIS stepper')
self.MixAdapter: BAND._SCF._SCFMultiStepper._Stepper._MixAdapter = self._MixAdapter(name='MixAdapter', comment='Generic mix adapter')
self.MixStepper: BAND._SCF._SCFMultiStepper._Stepper._MixStepper = self._MixStepper(name='MixStepper', comment='Simple mixing stepper, only using the previous (in/out) density.')
self.MultiSecantStepper: BAND._SCF._SCFMultiStepper._Stepper._MultiSecantStepper = self._MultiSecantStepper(name='MultiSecantStepper', comment='Multi secant stepper.')
def __post_init__(self):
self.AlwaysChangeStepper: BoolType | BoolKey = BoolKey(name='AlwaysChangeStepper', comment='When the progress is fine there is no reason to change the stepper. In practice this is always set to true, because also the Stepper%ExpectedSlope can be used to achieve similar behavior.', default=False)
self.ErrorGrowthAbortFactor: float | FloatKey = FloatKey(name='ErrorGrowthAbortFactor', comment='Abort stint when the error grows too much, compared to the error at the start of the stint.', default=1000.0)
self.FractionalStepFactor: float | FloatKey = FloatKey(name='FractionalStepFactor', comment='Multiply the step by this factor. If smaller than zero this is not used.', default=-1.0)
self.MinStintCyclesForAbort: int | IntKey = IntKey(name='MinStintCyclesForAbort', comment='Look at ErrorGrowthAbortFactor only when a number of steps has been completed since the start of the stint. A value of 0 means always.', default=0)
self.StintLength: int | IntKey = IntKey(name='StintLength', comment='A stepper is active during a number of SCF cycles, called a stint.', default=10)
self.UsePreviousStintForErrorGrowthAbort: BoolType | BoolKey = BoolKey(name='UsePreviousStintForErrorGrowthAbort', comment='The error is normally checked against the first error of the stint. With this option that will be the one from the previous stint, if performed with the same stepper.', default=False)
self.Stepper: BAND._SCF._SCFMultiStepper._Stepper = self._Stepper(name='Stepper', comment='??', unique=False, header=True)
def __post_init__(self):
self.ApplyVSplitToDensity: BoolType | BoolKey = BoolKey(name='ApplyVSplitToDensity', comment='Undocumented.', hidden=True, default=False)
self.Eigenstates: BoolType | BoolKey = BoolKey(name='Eigenstates', comment='The program knows two alternative ways to evaluate the charge density iteratively in the SCF procedure: from the P-matrix, and directly from the squared occupied eigenstates. By default the program actually uses both at least one time and tries to take the most efficient. If present, Eigenstates turns off this comparison and lets the program stick to one method (from the eigenstates).')
self.Iterations: int | IntKey = IntKey(name='Iterations', comment='The maximum number of SCF iterations to be performed.', gui_name='Maximum number of cycles:', default=300)
self.LoadPreviousSCFMixing: BoolType | BoolKey = BoolKey(name='LoadPreviousSCFMixing', comment='Load dimix and mixing from the previous SCF procedure, for instance during a geometry optimization.', hidden=True, default=True)
self.Method: Literal["DIIS", "MultiSecant", "MultiStepper"] = MultipleChoiceKey(name='Method', comment='Choose the general scheme used to converge the density in the SCF. In case of scf problems one can try the MultiSecant alternative at no extra cost per SCF cycle. For more details see the DIIS and MultiSecantConfig block.', default='MultiStepper', choices=['DIIS', 'MultiSecant', 'MultiStepper'])
self.Mixing: float | FloatKey = FloatKey(name='Mixing', comment="Initial 'damping' parameter in the SCF procedure, for the iterative update of the potential: new potential = old potential + mix (computed potential-old potential). Note: the program automatically adapts Mixing during the SCF iterations, in an attempt to find the optimal mixing value.", default=0.075)
self.MultiStepperPresetPath: str | Path | StringKey = PathStringKey(name='MultiStepperPresetPath', comment="Name of file containing a SCFMultiStepper key block. This will be used if no Explicit SCFMultiStepper block is in the input, and Method=MultiStepper.\nIf the path is not absolute, it is relative to $AMSHOME/data/presets/multi_stepper'", default='DFTB/default2023.inc', ispath=True, gui_type='{} {} data/presets/multi_stepper relative')
self.NComponentsForNonColDIIS: int | IntKey = IntKey(name='NComponentsForNonColDIIS', comment='For a non-collinear calculation: use all 8 components for the DIIS error metric. Possible choices: 2,4,8. With option=2 information is discarded. Option=4 or 8 are nearly identical except that the off diag weights are a bit different. Before the key was introduced two components were used.', hidden=True, default=4)
self.NewEigenstates: BoolType | BoolKey = BoolKey(name='NewEigenstates', comment='Undocumented.', hidden=True)
self.NewPMatrix: BoolType | BoolKey = BoolKey(name='NewPMatrix', comment='Undocumented.', hidden=True)
self.PMatrix: BoolType | BoolKey = BoolKey(name='PMatrix', comment='If present, evaluate the charge density from the P-matrix. See also the key Eigenstates.')
self.PrintAllOccupiedBands: BoolType | BoolKey = BoolKey(name='PrintAllOccupiedBands', comment='When printing the ranges of the bands, include all occupied ones.', default=True)
self.PrintAllVirtualBands: BoolType | BoolKey = BoolKey(name='PrintAllVirtualBands', comment='When printing the ranges of the bands, include all virtual ones.', default=False)
self.PrintAlwaysBandRanges: BoolType | BoolKey = BoolKey(name='PrintAlwaysBandRanges', comment='Normally the ranges of the bands are only printed at the last SCF cycle', default=False)
self.Rate: float | FloatKey = FloatKey(name='Rate', comment='Minimum rate of convergence for the SCF procedure. If progress is too slow the program will take measures (such as smearing out occupations around the Fermi level, see key Degenerate of block Convergence) or, if everything seems to fail, it will stop', default=0.99)
self.SkipDiagonalization: BoolType | BoolKey = BoolKey(name='SkipDiagonalization', comment='Undocumented.', hidden=True)
self.TryDensityMethods: str | StringKey = StringKey(name='TryDensityMethods', comment='Undocumented.', hidden=True, default='1')
self.VSplit: float | FloatKey = FloatKey(name='VSplit', comment='To disturb degeneracy of alpha and beta spin MOs the value of this key is added to the beta spin potential at the startup.', default=0.05)
self.SCFMultiStepper: BAND._SCF._SCFMultiStepper = self._SCFMultiStepper(name='SCFMultiStepper', comment='To solve the self-consistent problem multiple steppers can be tried during stints using the ones that give the best progress.', extra_info='not_in_fragment')
[docs] class _Screening(FixedBlock):
r"""
For the periodic solvation potential and for the old (not default anymore) fitting method, BAND performs lattice summations which are in practice truncated. The precision of the lattice summations is controlled by the options in this block.
:ivar AutoStarFactor: Undocumented.
:vartype AutoStarFactor: float | FloatKey
:ivar CutOff: Criterion for negligibility of tails in the construction of Bloch sums. Default depends on Accuracy.
:vartype CutOff: float | FloatKey
:ivar DMadel: One of the parameters that define the screening of Coulomb-potentials in lattice sums. Depends by default on Accuracy, rmadel, and rcelx. One should consult the literature for more information
:vartype DMadel: float | FloatKey
:ivar DMadelFactor: Undocumented.
:vartype DMadelFactor: float | FloatKey
:ivar DMadelPowFactor: Undocumented.
:vartype DMadelPowFactor: float | FloatKey
:ivar FermFC: Undocumented.
:vartype FermFC: float | FloatKey
:ivar LatticeBased: Undocumented.
:vartype LatticeBased: BoolType | BoolKey
:ivar NoDirectionalScreening: Real space lattice sums of slowly (or non-) convergent terms, such as the Coulomb potential, are computed by a screening technique. In previous releases, the screening was applied to all (long-range) Coulomb expressions. Screening is only applied in the periodicity directions. This key restores the original situation: screening in all directions
:vartype NoDirectionalScreening: BoolType | BoolKey
:ivar RCelx: Max. distance of lattice site from which tails of atomic functions will be taken into account for the Bloch sums. Default depends on Accuracy.
:vartype RCelx: float | FloatKey
:ivar RMadel: One of the parameters that define screening of the Coulomb potentials in lattice summations. Depends by default on Accuracy, dmadel, rcelx. One should consult the literature for more information.
:vartype RMadel: float | FloatKey
"""
def __post_init__(self):
self.AutoStarFactor: float | FloatKey = FloatKey(name='AutoStarFactor', comment='Undocumented.', hidden=True, default=2.0)
self.CutOff: float | FloatKey = FloatKey(name='CutOff', comment='Criterion for negligibility of tails in the construction of Bloch sums. Default depends on Accuracy.')
self.DMadel: float | FloatKey = FloatKey(name='DMadel', comment='One of the parameters that define the screening of Coulomb-potentials in lattice sums. Depends by default on Accuracy, rmadel, and rcelx. One should consult the literature for more information')
self.DMadelFactor: float | FloatKey = FloatKey(name='DMadelFactor', comment='Undocumented.', hidden=True, default=0.2)
self.DMadelPowFactor: float | FloatKey = FloatKey(name='DMadelPowFactor', comment='Undocumented.', hidden=True, default=0.5)
self.FermFC: float | FloatKey = FloatKey(name='FermFC', comment='Undocumented.', hidden=True)
self.LatticeBased: BoolType | BoolKey = BoolKey(name='LatticeBased', comment='Undocumented.', hidden=True, default=False)
self.NoDirectionalScreening: BoolType | BoolKey = BoolKey(name='NoDirectionalScreening', comment='Real space lattice sums of slowly (or non-) convergent terms, such as the Coulomb potential, are computed by a screening technique. In previous releases, the screening was applied to all (long-range) Coulomb expressions. Screening is only applied in the periodicity directions. This key restores the original situation: screening in all directions')
self.RCelx: float | FloatKey = FloatKey(name='RCelx', comment='Max. distance of lattice site from which tails of atomic functions will be taken into account for the Bloch sums. Default depends on Accuracy.')
self.RMadel: float | FloatKey = FloatKey(name='RMadel', comment='One of the parameters that define screening of the Coulomb potentials in lattice summations. Depends by default on Accuracy, dmadel, rcelx. One should consult the literature for more information.')
[docs] class _SlakoConfig(FixedBlock):
r"""
Undocumented.
:ivar approximation: Undocumented.
:vartype approximation: str | StringKey
:ivar atompotentialshift: Undocumented.
:vartype atompotentialshift: float | FloatKey
:ivar confinement: Undocumented.
:vartype confinement: str | StringKey
:ivar numcores1: Undocumented.
:vartype numcores1: int | IntKey
:ivar numcores2: Undocumented.
:vartype numcores2: int | IntKey
:ivar runtype: Undocumented.
:vartype runtype: str | StringKey
"""
def __post_init__(self):
self.approximation: str | StringKey = StringKey(name='approximation', comment='Undocumented.', default='sumdensities')
self.atompotentialshift: float | FloatKey = FloatKey(name='atompotentialshift', comment='Undocumented.', default=0.0)
self.confinement: str | StringKey = StringKey(name='confinement', comment='Undocumented.', default='monomial')
self.numcores1: int | IntKey = IntKey(name='numcores1', comment='Undocumented.', default=0)
self.numcores2: int | IntKey = IntKey(name='numcores2', comment='Undocumented.', default=0)
self.runtype: str | StringKey = StringKey(name='runtype', comment='Undocumented.', default='integrals')
[docs] class _SoftConfinement(FixedBlock):
r"""
In order to make the basis functions more compact, the radial part of the basis functions is multiplied by a Fermi-Dirac (FD) function (this 'confinement' is done for efficiency and numerical stability reasons). A FD function goes from one to zero, controlled by two parameters. It has a value 0.5 at Radius, and the decay width is Delta.
:ivar Analytical: Undocumented
:vartype Analytical: BoolType | BoolKey
:ivar AssumeLatticeDependent: Bit of a hack to store the fact that the confinement was affected by the lattice. This allows later for disabling analytical stress if so.
:vartype AssumeLatticeDependent: BoolType | BoolKey
:ivar Delta: Explicitly specify the delta parameter of the Fermi-Dirac function (if not specified, it will be 0.1*Radius).
:vartype Delta: float | FloatKey
:ivar Method: Undocumented.
:vartype Method: str | StringKey
:ivar Quality: In order to make the basis functions more compact, the radial part of the basis functions is multiplied by a Fermi-Dirac (FD) function (this 'confinement' is done for efficiency and numerical stability reasons). A FD function goes from one to zero, controlled by two parameters. It has a value 0.5 at Radius, and the decay width is Delta.
This key sets the two parameters 'Radius' and 'Delta'.
Basic: Radius=7.0, Delta=0.7;
Normal: Radius=10.0, Delta=1.0;
Good: Radius=20.0, Delta=2.0;
VeryGood and Excellent: no confinement at all.
If 'Auto', the quality defined in the 'NumericalQuality' will be used.
:vartype Quality: Literal["Auto", "Basic", "Normal", "Good", "VeryGood", "Excellent"]
:ivar Radius: Explicitly specify the radius parameter of the Fermi-Dirac function.
:vartype Radius: float | FloatKey
:ivar RadiusPerType: Undocumented.
:vartype RadiusPerType: str | StringKey
"""
def __post_init__(self):
self.Analytical: BoolType | BoolKey = BoolKey(name='Analytical', comment='Undocumented', hidden=True, default=True)
self.AssumeLatticeDependent: BoolType | BoolKey = BoolKey(name='AssumeLatticeDependent', comment='Bit of a hack to store the fact that the confinement was affected by the lattice. This allows later for disabling analytical stress if so.', hidden=True, default=False)
self.Delta: float | FloatKey = FloatKey(name='Delta', comment='Explicitly specify the delta parameter of the Fermi-Dirac function (if not specified, it will be 0.1*Radius).', unit='Bohr')
self.Method: str | StringKey = StringKey(name='Method', comment='Undocumented.', hidden=True, default='manual')
self.Quality: Literal["Auto", "Basic", "Normal", "Good", "VeryGood", "Excellent"] = MultipleChoiceKey(name='Quality', comment="In order to make the basis functions more compact, the radial part of the basis functions is multiplied by a Fermi-Dirac (FD) function (this 'confinement' is done for efficiency and numerical stability reasons). A FD function goes from one to zero, controlled by two parameters. It has a value 0.5 at Radius, and the decay width is Delta.\n\n This key sets the two parameters 'Radius' and 'Delta'.\n\nBasic: Radius=7.0, Delta=0.7;\nNormal: Radius=10.0, Delta=1.0;\nGood: Radius=20.0, Delta=2.0;\nVeryGood and Excellent: no confinement at all.\n\nIf 'Auto', the quality defined in the 'NumericalQuality' will be used.", gui_name='Confinement:', default='Auto', choices=['Auto', 'Basic', 'Normal', 'Good', 'VeryGood', 'Excellent'])
self.Radius: float | FloatKey = FloatKey(name='Radius', comment='Explicitly specify the radius parameter of the Fermi-Dirac function.', unit='Bohr')
self.RadiusPerType: str | StringKey = StringKey(name='RadiusPerType', comment='Undocumented.', hidden=True, default=' ')
[docs] class _Solvation(FixedBlock):
r"""
Options for the COSMO (Conductor like Screening Model) solvation model.
:ivar CVec: Choose how to calculate the Coulomb interaction matrix between the molecule and the point charges on the surface:
- EXACT: use exact density, and integrate against the potential of the point charges. This may have inaccuracies when integration points are close to the point charges.
- FITPOT: evaluate the molecular potential at the positions of the point charges, and multiply with these charges.
:vartype CVec: Literal["EXACT", "FITPOT"]
:ivar Enabled: Use the Conductor like Screening Model (COSMO) to include solvent effects.
:vartype Enabled: BoolType | BoolKey
:ivar SCF: Determine the point charges either Variational (VAR) or after the SCF as a Perturbation (PERT).
:vartype SCF: Literal["VAR", "PERT", "NONE"]
:ivar Surf: Within the COSMO model the molecule is contained in a molecule shaped cavity.
Select one of the following surfaces to define the cavity:
- Wsurf: Van der Waals surface
- Asurf: solvent accessible surface
- Esurf: solvent excluding surface
- Klamt: Klamt surface
- Delley: Delley surface.
:vartype Surf: Literal["Delley", "Wsurf", "Asurf", "Esurf", "Klamt"]
:ivar Charge: Select the algorithm to determine the charges.
:vartype Charge: BAND._Solvation._Charge
:ivar Radii: The values are the radii of the atomic spheres. If not specified the default values are those by Allinger. Format: 'AtomType value'. e.g.: 'H 0.7'
:vartype Radii: str | Sequence[str] | FreeBlock
:ivar Solvent: Solvent details
:vartype Solvent: BAND._Solvation._Solvent
"""
[docs] class _Charge(FixedBlock):
r"""
Select the algorithm to determine the charges.
:ivar Conv: Charge convergence threshold in iterative COSMO solution.
:vartype Conv: float | FloatKey
:ivar Corr: Correct for outlying charge.
:vartype Corr: BoolType | BoolKey
:ivar Iter: Maximum number of iterations to solve COSMO equations.
:vartype Iter: int | IntKey
:ivar Method: INVER: matrix inversion, CONJ: biconjugate gradient method.
The CONJ method is guaranteed to converge with small memory requirements and is normally the preferred method.
:vartype Method: Literal["CONJ", "INVER"]
"""
def __post_init__(self):
self.Conv: float | FloatKey = FloatKey(name='Conv', comment='Charge convergence threshold in iterative COSMO solution.', default=1e-08)
self.Corr: BoolType | BoolKey = BoolKey(name='Corr', comment='Correct for outlying charge.', gui_name='Correct for outlying charge:', default=True)
self.Iter: int | IntKey = IntKey(name='Iter', comment='Maximum number of iterations to solve COSMO equations.', default=1000)
self.Method: Literal["CONJ", "INVER"] = MultipleChoiceKey(name='Method', comment='INVER: matrix inversion, CONJ: biconjugate gradient method.\n\nThe CONJ method is guaranteed to converge with small memory requirements and is normally the preferred method.', gui_name='Charge determination method:', default='CONJ', choices=['CONJ', 'INVER'])
[docs] class _Radii(FreeBlock):
r"""
The values are the radii of the atomic spheres. If not specified the default values are those by Allinger. Format: 'AtomType value'. e.g.: 'H 0.7'
"""
def __post_init__(self):
pass
[docs] class _Solvent(FixedBlock):
r"""
Solvent details
:ivar Del: Del is the value of Klamt's delta_sol parameter, only relevant in case of Klamt surface.
:vartype Del: float | FloatKey
:ivar Emp: Emp is the empirical scaling factor x for the energy scaling.
:vartype Emp: float | FloatKey
:ivar Eps: User-defined dielectric constant of the solvent (overrides the Eps value of the solvent defined in 'Name')
:vartype Eps: float | FloatKey
:ivar Name: Name of a pre-defined solvent. A solvent is characterized by the dielectric constant (Eps) and the solvent radius (Rad).
:vartype Name: Literal["AceticAcid", "Acetone", "Acetonitrile", "Ammonia", "Aniline", "Benzene", "BenzylAlcohol", "Bromoform", "Butanol", "isoButanol", "tertButanol", "CarbonDisulfide", "CarbonTetrachloride", "Chloroform", "Cyclohexane", "Cyclohexanone", "Dichlorobenzene", "DiethylEther", "Dioxane", "DMFA", "DMSO", "Ethanol", "EthylAcetate", "Dichloroethane", "EthyleneGlycol", "Formamide", "FormicAcid", "Glycerol", "HexamethylPhosphoramide", "Hexane", "Hydrazine", "Methanol", "MethylEthylKetone", "Dichloromethane", "Methylformamide", "Methypyrrolidinone", "Nitrobenzene", "Nitrogen", "Nitromethane", "PhosphorylChloride", "IsoPropanol", "Pyridine", "Sulfolane", "Tetrahydrofuran", "Toluene", "Triethylamine", "TrifluoroaceticAcid", "Water"]
:ivar Rad: User-defined radius of the solvent molecule (overrides the Rad value of the solvent defined in 'Name').
:vartype Rad: float | FloatKey
"""
def __post_init__(self):
self.Del: float | FloatKey = FloatKey(name='Del', comment="Del is the value of Klamt's delta_sol parameter, only relevant in case of Klamt surface.")
self.Emp: float | FloatKey = FloatKey(name='Emp', comment='Emp is the empirical scaling factor x for the energy scaling.')
self.Eps: float | FloatKey = FloatKey(name='Eps', comment="User-defined dielectric constant of the solvent (overrides the Eps value of the solvent defined in 'Name')")
self.Name: Literal["AceticAcid", "Acetone", "Acetonitrile", "Ammonia", "Aniline", "Benzene", "BenzylAlcohol", "Bromoform", "Butanol", "isoButanol", "tertButanol", "CarbonDisulfide", "CarbonTetrachloride", "Chloroform", "Cyclohexane", "Cyclohexanone", "Dichlorobenzene", "DiethylEther", "Dioxane", "DMFA", "DMSO", "Ethanol", "EthylAcetate", "Dichloroethane", "EthyleneGlycol", "Formamide", "FormicAcid", "Glycerol", "HexamethylPhosphoramide", "Hexane", "Hydrazine", "Methanol", "MethylEthylKetone", "Dichloromethane", "Methylformamide", "Methypyrrolidinone", "Nitrobenzene", "Nitrogen", "Nitromethane", "PhosphorylChloride", "IsoPropanol", "Pyridine", "Sulfolane", "Tetrahydrofuran", "Toluene", "Triethylamine", "TrifluoroaceticAcid", "Water"] = MultipleChoiceKey(name='Name', comment='Name of a pre-defined solvent. A solvent is characterized by the dielectric constant (Eps) and the solvent radius (Rad).', gui_name='Solvent:', default='Water', choices=['AceticAcid', 'Acetone', 'Acetonitrile', 'Ammonia', 'Aniline', 'Benzene', 'BenzylAlcohol', 'Bromoform', 'Butanol', 'isoButanol', 'tertButanol', 'CarbonDisulfide', 'CarbonTetrachloride', 'Chloroform', 'Cyclohexane', 'Cyclohexanone', 'Dichlorobenzene', 'DiethylEther', 'Dioxane', 'DMFA', 'DMSO', 'Ethanol', 'EthylAcetate', 'Dichloroethane', 'EthyleneGlycol', 'Formamide', 'FormicAcid', 'Glycerol', 'HexamethylPhosphoramide', 'Hexane', 'Hydrazine', 'Methanol', 'MethylEthylKetone', 'Dichloromethane', 'Methylformamide', 'Methypyrrolidinone', 'Nitrobenzene', 'Nitrogen', 'Nitromethane', 'PhosphorylChloride', 'IsoPropanol', 'Pyridine', 'Sulfolane', 'Tetrahydrofuran', 'Toluene', 'Triethylamine', 'TrifluoroaceticAcid', 'Water'])
self.Rad: float | FloatKey = FloatKey(name='Rad', comment="User-defined radius of the solvent molecule (overrides the Rad value of the solvent defined in 'Name').", unit='Angstrom')
def __post_init__(self):
self.CVec: Literal["EXACT", "FITPOT"] = MultipleChoiceKey(name='CVec', comment='Choose how to calculate the Coulomb interaction matrix between the molecule and the point charges on the surface:\n\n- EXACT: use exact density, and integrate against the potential of the point charges. This may have inaccuracies when integration points are close to the point charges.\n\n- FITPOT: evaluate the molecular potential at the positions of the point charges, and multiply with these charges.', gui_name='Calculate Coulomb interaction:', default='EXACT', choices=['EXACT', 'FITPOT'])
self.Enabled: BoolType | BoolKey = BoolKey(name='Enabled', comment='Use the Conductor like Screening Model (COSMO) to include solvent effects.', gui_name='Include COSMO solvation:', default=False)
self.SCF: Literal["VAR", "PERT", "NONE"] = MultipleChoiceKey(name='SCF', comment='Determine the point charges either Variational (VAR) or after the SCF as a Perturbation (PERT).', gui_name='Handle charges:', default='VAR', choices=['VAR', 'PERT', 'NONE'])
self.Surf: Literal["Delley", "Wsurf", "Asurf", "Esurf", "Klamt"] = MultipleChoiceKey(name='Surf', comment='Within the COSMO model the molecule is contained in a molecule shaped cavity.\n\nSelect one of the following surfaces to define the cavity:\n\n- Wsurf: Van der Waals surface\n- Asurf: solvent accessible surface\n- Esurf: solvent excluding surface\n- Klamt: Klamt surface\n- Delley: Delley surface.', gui_name='Surface type:', default='Delley', choices=['Delley', 'Wsurf', 'Asurf', 'Esurf', 'Klamt'])
self.Charge: BAND._Solvation._Charge = self._Charge(name='Charge', comment='Select the algorithm to determine the charges.')
self.Radii: str | Sequence[str] | FreeBlock = self._Radii(name='Radii', comment="The values are the radii of the atomic spheres. If not specified the default values are those by Allinger. Format: 'AtomType value'. e.g.: 'H 0.7'")
self.Solvent: BAND._Solvation._Solvent = self._Solvent(name='Solvent', comment='Solvent details')
[docs] class _SolvationSM12(FixedBlock):
r"""
Options for Solvation Model 12 (SM12).
:ivar ARO: Square of the fraction of non-hydrogen atoms in the solvent that are aromatic carbon atoms (carbon aromaticity)
:vartype ARO: float | FloatKey
:ivar Acid: Abraham hydrogen bond acidity parameter
:vartype Acid: float | FloatKey
:ivar Base: Abraham hydrogen bond basicity parameter
:vartype Base: float | FloatKey
:ivar BornC: Coulomb constant for General Born Approximation
:vartype BornC: float | FloatKey
:ivar Chgal: Exponential of Pauli's bond order
:vartype Chgal: float | FloatKey
:ivar Cust: Custom solvent input
:vartype Cust: str | StringKey
:ivar Debug: Prints a lot of information about every pass on CDS and ENP code, keywords: ENP, CDS
:vartype Debug: str | StringKey
:ivar EPS: The dielectric constant
:vartype EPS: float | FloatKey
:ivar Enabled: Whether to use the Solvation Model 12 (SM12) in the calculation.
:vartype Enabled: BoolType | BoolKey
:ivar HALO: Square of the fraction of non-hydrogen atoms in the solvent molecule that are F, Cl, or Br (electronegative halogenicity)
:vartype HALO: float | FloatKey
:ivar Kappa: Factor for Debye screening
:vartype Kappa: float | FloatKey
:ivar PostSCF: Whether to apply the solvation potential during the SCF or only calculate the solvation energy after the SCF.
:vartype PostSCF: BoolType | BoolKey
:ivar PotentialFactor:
:vartype PotentialFactor: float | FloatKey
:ivar PrintSM12: Prints out an in-depth breakdown of solvation energies
:vartype PrintSM12: BoolType | BoolKey
:ivar RadSolv: The radius distance between the solute and solvent
:vartype RadSolv: float | FloatKey
:ivar Ref: Refractive index of solvent
:vartype Ref: float | FloatKey
:ivar Solv: List of predefined solvents
:vartype Solv: Literal["ACETICACID", "ACETONITRILE", "ACETOPHENONE", "ANILINE", "ANISOLE", "BENZENE", "BENZONITRILE", "BENZYLALCOHOL", "BROMOBENZENE", "BROMOETHANE", "BROMOFORM", "BROMOOCTANE", "N-BUTANOL", "SEC-BUTANOL", "BUTANONE", "BUTYLACETATE", "N-BUTYLBENZENE", "SEC-BUTYLBENZENE", "T-BUTYLBENZENE", "CARBONDISULFIDE", "CARBONTETRACHLORIDE", "CHLOROBENZENE", "CHLOROFORM", "CHLOROHEXANE", "M-CRESOL", "CYCLOHEXANE", "CYCLOHEXANONE", "DECALIN", "DECANE", "DECANOL", "1-2-DIBROMOETHANE", "DIBUTYLETHER", "O-DICHLOROBENZENE", "1-2-DICHLOROETHANE", "DIETHYLETHER", "DIISOPROPYLETHER", "N-N-DIMETHYLACETAMIDE", "N-N-DIMETHYLFORMAMIDE", "2-6-DIMETHYLPYRIDINE", "DIMETHYLSULFOXIDE", "DODECANE", "ETHANOL", "ETHOXYBENZENE", "ETHYLACETATE", "ETHYLBENZENE", "FLUOROBENZENE", "1-FLUORO-N-OCTANE", "HEPTANE", "HEPTANOL", "HEXADECANE", "HEXADECYLIODIDE", "HEXANE", "HEXANOL", "IODOBENZENE", "ISOBUTANOL", "ISOOCTANE", "ISOPROPANOL", "ISOPROPYLBENZENE", "P-ISOPROPYLTOLUENE", "MESITYLENE", "METHANOL", "METHOXYETHANOL", "METHYLENECHLORIDE", "N-METHYLFORMAMIDE", "2-METHYLPYRIDINE", "4-METHYL-2-PENTANONE", "NITROBENZENE", "NITROETHANE", "NITROMETHANE", "O-NITROTOLUENE", "NONANE", "NONANOL", "OCTANE", "OCTANOL", "PENTADECANE", "PENTANE", "PENTANOL", "PERFLUOROBENZENE", "PHENYLETHER", "PROPANOL", "PYRIDINE", "TETRACHLOROETHENE", "TETRAHYDROFURAN", "TETRAHYDROTHIOPHENEDIOXIDE", "TETRALIN", "TOLUENE", "TRIBUTYLPHOSPHATE", "TRIETHYLAMINE", "1-2-4-TRIMETHYLBENZENE", "UNDECANE", "WATER", "XYLENE", "1-2-DIBROMOETHANE_WATER", "1-2-DICHLOROETHANE_WATER", "BENZENE_WATER", "CARBONTETRACHLORIDE_WATER", "CHLOROBENZENE_WATER", "CHLOROFORM_WATER", "CYCLOHEXANE_WATER", "DIBUTYLETHER_WATER", "DIETHYLETHER_WATER", "ETHYLACETATE_WATER", "HEPTANE_WATER", "HEXANE_WATER", "NITROBENZENE_WATER", "OCTANOL_WATER"]
:ivar SuperTrafoDiag: Used for the generation of the super cell.
:vartype SuperTrafoDiag: int | IntKey
:ivar SuperTrafoDiagCM5: Used for the generation of the super cell with CM5 charges.
:vartype SuperTrafoDiagCM5: int | IntKey
:ivar Tens: Macroscopic surface tension of the solvent at the air/solvent interface at 298K (cal*mol^-1*Ang^-2)
:vartype Tens: float | FloatKey
:ivar BornRadiusConfig:
:vartype BornRadiusConfig: BAND._SolvationSM12._BornRadiusConfig
:ivar TopologicalExtrapolation: Method to extrapolate the long range Coulomb potential, needed for periodic calculations
:vartype TopologicalExtrapolation: BAND._SolvationSM12._TopologicalExtrapolation
"""
[docs] class _BornRadiusConfig(FixedBlock):
r"""
:ivar MaxCellDistance: Max distance from the centra cell used when computing the Born radii for periodic systems
:vartype MaxCellDistance: float | FloatKey
:ivar PointsPerBohr:
:vartype PointsPerBohr: int | IntKey
:ivar UseLegendreGrid:
:vartype UseLegendreGrid: BoolType | BoolKey
"""
def __post_init__(self):
self.MaxCellDistance: float | FloatKey = FloatKey(name='MaxCellDistance', comment='Max distance from the centra cell used when computing the Born radii for periodic systems', default=30.0, unit='Bohr')
self.PointsPerBohr: int | IntKey = IntKey(name='PointsPerBohr', default=10)
self.UseLegendreGrid: BoolType | BoolKey = BoolKey(name='UseLegendreGrid', default=True)
[docs] class _TopologicalExtrapolation(FixedBlock):
r"""
Method to extrapolate the long range Coulomb potential, needed for periodic calculations
:ivar FirstCell: First cell for the topological extrapolation of the long range part of the Coulomb Potential.
:vartype FirstCell: int | IntKey
:ivar LastCell: Last cell for the topological extrapolation of the long range part of the Coulomb Potential.
:vartype LastCell: int | IntKey
:ivar Order: Order of the topological extrapolation of the long range part of the Coulomb Potential.
:vartype Order: int | IntKey
"""
def __post_init__(self):
self.FirstCell: int | IntKey = IntKey(name='FirstCell', comment='First cell for the topological extrapolation of the long range part of the Coulomb Potential.', default=5)
self.LastCell: int | IntKey = IntKey(name='LastCell', comment='Last cell for the topological extrapolation of the long range part of the Coulomb Potential.', default=10)
self.Order: int | IntKey = IntKey(name='Order', comment='Order of the topological extrapolation of the long range part of the Coulomb Potential.', default=3)
def __post_init__(self):
self.ARO: float | FloatKey = FloatKey(name='ARO', comment='Square of the fraction of non-hydrogen atoms in the solvent that are aromatic carbon atoms (carbon aromaticity)', default=0.0)
self.Acid: float | FloatKey = FloatKey(name='Acid', comment='Abraham hydrogen bond acidity parameter', default=0.82)
self.Base: float | FloatKey = FloatKey(name='Base', comment='Abraham hydrogen bond basicity parameter', default=0.35)
self.BornC: float | FloatKey = FloatKey(name='BornC', comment='Coulomb constant for General Born Approximation', default=3.7)
self.Chgal: float | FloatKey = FloatKey(name='Chgal', comment="Exponential of Pauli's bond order", default=2.474)
self.Cust: str | StringKey = StringKey(name='Cust', comment='Custom solvent input')
self.Debug: str | StringKey = StringKey(name='Debug', comment='Prints a lot of information about every pass on CDS and ENP code, keywords: ENP, CDS')
self.EPS: float | FloatKey = FloatKey(name='EPS', comment='The dielectric constant', default=78.36)
self.Enabled: BoolType | BoolKey = BoolKey(name='Enabled', comment='Whether to use the Solvation Model 12 (SM12) in the calculation.', gui_name='Include SM12 solvation:', default=False)
self.HALO: float | FloatKey = FloatKey(name='HALO', comment='Square of the fraction of non-hydrogen atoms in the solvent molecule that are F, Cl, or Br (electronegative halogenicity)', default=0.0)
self.Kappa: float | FloatKey = FloatKey(name='Kappa', comment='Factor for Debye screening', default=0.0)
self.PostSCF: BoolType | BoolKey = BoolKey(name='PostSCF', comment='Whether to apply the solvation potential during the SCF or only calculate the solvation energy after the SCF.', default=False)
self.PotentialFactor: float | FloatKey = FloatKey(name='PotentialFactor', hidden=True, default=-2.0)
self.PrintSM12: BoolType | BoolKey = BoolKey(name='PrintSM12', comment='Prints out an in-depth breakdown of solvation energies', default=False)
self.RadSolv: float | FloatKey = FloatKey(name='RadSolv', comment='The radius distance between the solute and solvent', default=0.4)
self.Ref: float | FloatKey = FloatKey(name='Ref', comment='Refractive index of solvent', default=1.3328)
self.Solv: Literal["ACETICACID", "ACETONITRILE", "ACETOPHENONE", "ANILINE", "ANISOLE", "BENZENE", "BENZONITRILE", "BENZYLALCOHOL", "BROMOBENZENE", "BROMOETHANE", "BROMOFORM", "BROMOOCTANE", "N-BUTANOL", "SEC-BUTANOL", "BUTANONE", "BUTYLACETATE", "N-BUTYLBENZENE", "SEC-BUTYLBENZENE", "T-BUTYLBENZENE", "CARBONDISULFIDE", "CARBONTETRACHLORIDE", "CHLOROBENZENE", "CHLOROFORM", "CHLOROHEXANE", "M-CRESOL", "CYCLOHEXANE", "CYCLOHEXANONE", "DECALIN", "DECANE", "DECANOL", "1-2-DIBROMOETHANE", "DIBUTYLETHER", "O-DICHLOROBENZENE", "1-2-DICHLOROETHANE", "DIETHYLETHER", "DIISOPROPYLETHER", "N-N-DIMETHYLACETAMIDE", "N-N-DIMETHYLFORMAMIDE", "2-6-DIMETHYLPYRIDINE", "DIMETHYLSULFOXIDE", "DODECANE", "ETHANOL", "ETHOXYBENZENE", "ETHYLACETATE", "ETHYLBENZENE", "FLUOROBENZENE", "1-FLUORO-N-OCTANE", "HEPTANE", "HEPTANOL", "HEXADECANE", "HEXADECYLIODIDE", "HEXANE", "HEXANOL", "IODOBENZENE", "ISOBUTANOL", "ISOOCTANE", "ISOPROPANOL", "ISOPROPYLBENZENE", "P-ISOPROPYLTOLUENE", "MESITYLENE", "METHANOL", "METHOXYETHANOL", "METHYLENECHLORIDE", "N-METHYLFORMAMIDE", "2-METHYLPYRIDINE", "4-METHYL-2-PENTANONE", "NITROBENZENE", "NITROETHANE", "NITROMETHANE", "O-NITROTOLUENE", "NONANE", "NONANOL", "OCTANE", "OCTANOL", "PENTADECANE", "PENTANE", "PENTANOL", "PERFLUOROBENZENE", "PHENYLETHER", "PROPANOL", "PYRIDINE", "TETRACHLOROETHENE", "TETRAHYDROFURAN", "TETRAHYDROTHIOPHENEDIOXIDE", "TETRALIN", "TOLUENE", "TRIBUTYLPHOSPHATE", "TRIETHYLAMINE", "1-2-4-TRIMETHYLBENZENE", "UNDECANE", "WATER", "XYLENE", "1-2-DIBROMOETHANE_WATER", "1-2-DICHLOROETHANE_WATER", "BENZENE_WATER", "CARBONTETRACHLORIDE_WATER", "CHLOROBENZENE_WATER", "CHLOROFORM_WATER", "CYCLOHEXANE_WATER", "DIBUTYLETHER_WATER", "DIETHYLETHER_WATER", "ETHYLACETATE_WATER", "HEPTANE_WATER", "HEXANE_WATER", "NITROBENZENE_WATER", "OCTANOL_WATER"] = MultipleChoiceKey(name='Solv', comment='List of predefined solvents', gui_name='Solvent:', default='WATER', choices=['ACETICACID', 'ACETONITRILE', 'ACETOPHENONE', 'ANILINE', 'ANISOLE', 'BENZENE', 'BENZONITRILE', 'BENZYLALCOHOL', 'BROMOBENZENE', 'BROMOETHANE', 'BROMOFORM', 'BROMOOCTANE', 'N-BUTANOL', 'SEC-BUTANOL', 'BUTANONE', 'BUTYLACETATE', 'N-BUTYLBENZENE', 'SEC-BUTYLBENZENE', 'T-BUTYLBENZENE', 'CARBONDISULFIDE', 'CARBONTETRACHLORIDE', 'CHLOROBENZENE', 'CHLOROFORM', 'CHLOROHEXANE', 'M-CRESOL', 'CYCLOHEXANE', 'CYCLOHEXANONE', 'DECALIN', 'DECANE', 'DECANOL', '1-2-DIBROMOETHANE', 'DIBUTYLETHER', 'O-DICHLOROBENZENE', '1-2-DICHLOROETHANE', 'DIETHYLETHER', 'DIISOPROPYLETHER', 'N-N-DIMETHYLACETAMIDE', 'N-N-DIMETHYLFORMAMIDE', '2-6-DIMETHYLPYRIDINE', 'DIMETHYLSULFOXIDE', 'DODECANE', 'ETHANOL', 'ETHOXYBENZENE', 'ETHYLACETATE', 'ETHYLBENZENE', 'FLUOROBENZENE', '1-FLUORO-N-OCTANE', 'HEPTANE', 'HEPTANOL', 'HEXADECANE', 'HEXADECYLIODIDE', 'HEXANE', 'HEXANOL', 'IODOBENZENE', 'ISOBUTANOL', 'ISOOCTANE', 'ISOPROPANOL', 'ISOPROPYLBENZENE', 'P-ISOPROPYLTOLUENE', 'MESITYLENE', 'METHANOL', 'METHOXYETHANOL', 'METHYLENECHLORIDE', 'N-METHYLFORMAMIDE', '2-METHYLPYRIDINE', '4-METHYL-2-PENTANONE', 'NITROBENZENE', 'NITROETHANE', 'NITROMETHANE', 'O-NITROTOLUENE', 'NONANE', 'NONANOL', 'OCTANE', 'OCTANOL', 'PENTADECANE', 'PENTANE', 'PENTANOL', 'PERFLUOROBENZENE', 'PHENYLETHER', 'PROPANOL', 'PYRIDINE', 'TETRACHLOROETHENE', 'TETRAHYDROFURAN', 'TETRAHYDROTHIOPHENEDIOXIDE', 'TETRALIN', 'TOLUENE', 'TRIBUTYLPHOSPHATE', 'TRIETHYLAMINE', '1-2-4-TRIMETHYLBENZENE', 'UNDECANE', 'WATER', 'XYLENE', '1-2-DIBROMOETHANE_WATER', '1-2-DICHLOROETHANE_WATER', 'BENZENE_WATER', 'CARBONTETRACHLORIDE_WATER', 'CHLOROBENZENE_WATER', 'CHLOROFORM_WATER', 'CYCLOHEXANE_WATER', 'DIBUTYLETHER_WATER', 'DIETHYLETHER_WATER', 'ETHYLACETATE_WATER', 'HEPTANE_WATER', 'HEXANE_WATER', 'NITROBENZENE_WATER', 'OCTANOL_WATER'])
self.SuperTrafoDiag: int | IntKey = IntKey(name='SuperTrafoDiag', comment='Used for the generation of the super cell.', hidden=True, default=5)
self.SuperTrafoDiagCM5: int | IntKey = IntKey(name='SuperTrafoDiagCM5', comment='Used for the generation of the super cell with CM5 charges.', hidden=True, default=3)
self.Tens: float | FloatKey = FloatKey(name='Tens', comment='Macroscopic surface tension of the solvent at the air/solvent interface at 298K (cal*mol^-1*Ang^-2)', default=103.62)
self.BornRadiusConfig: BAND._SolvationSM12._BornRadiusConfig = self._BornRadiusConfig(name='BornRadiusConfig')
self.TopologicalExtrapolation: BAND._SolvationSM12._TopologicalExtrapolation = self._TopologicalExtrapolation(name='TopologicalExtrapolation', comment='Method to extrapolate the long range Coulomb potential, needed for periodic calculations')
[docs] class _StrainDerivatives(FixedBlock):
r"""
Undocumented.
:ivar Analytical: Whether or not to use analytical strain derivatives. By default this is determined automatically, and used if possible.
:vartype Analytical: BoolType | BoolKey
:ivar AnalyticalElectrostatic: Undocumented.
:vartype AnalyticalElectrostatic: BoolType | BoolKey
:ivar Analyticalkinetic: Undocumented.
:vartype Analyticalkinetic: BoolType | BoolKey
:ivar Analyticalpulay: Undocumented.
:vartype Analyticalpulay: BoolType | BoolKey
:ivar Analyticalxc: Undocumented.
:vartype Analyticalxc: BoolType | BoolKey
:ivar CalcRhoDef0FitError: Does not affect the results, but prints the fit error and a first order error estimation for the stress. Can be very expensive.
:vartype CalcRhoDef0FitError: BoolType | BoolKey
:ivar Celltopoorder: Undocumented.
:vartype Celltopoorder: int | IntKey
:ivar Coreorthoption: Undocumented.
:vartype Coreorthoption: int | IntKey
:ivar Fitrho0numintextrarad: Undocumented.
:vartype Fitrho0numintextrarad: int | IntKey
:ivar Fitrho0prune: Undocumented.
:vartype Fitrho0prune: BoolType | BoolKey
:ivar Kinviadagger: Undocumented.
:vartype Kinviadagger: BoolType | BoolKey
:ivar Lmaxmultipoleexpansion: Undocumented.
:vartype Lmaxmultipoleexpansion: int | IntKey
:ivar Naiveelstat: Undocumented.
:vartype Naiveelstat: BoolType | BoolKey
:ivar NoPairSetKCoordsToZero: This used to be the case, do not know why. It seems to have no effect.
:vartype NoPairSetKCoordsToZero: BoolType | BoolKey
:ivar Numericaldefdef: Undocumented.
:vartype Numericaldefdef: BoolType | BoolKey
:ivar Numericaldefdeflong: Undocumented.
:vartype Numericaldefdeflong: BoolType | BoolKey
:ivar Pairgridlowerangularorder: Undocumented.
:vartype Pairgridlowerangularorder: int | IntKey
:ivar Pairgridradpointsincrease: Undocumented.
:vartype Pairgridradpointsincrease: int | IntKey
:ivar Renormalizechargefitrho0: Undocumented.
:vartype Renormalizechargefitrho0: BoolType | BoolKey
:ivar Shiftmultipoleorigin: Undocumented.
:vartype Shiftmultipoleorigin: BoolType | BoolKey
:ivar Skipinlgwsmodule: Undocumented.
:vartype Skipinlgwsmodule: BoolType | BoolKey
:ivar SubtractAtomicXC: Derive stress from xc energy difference of molecule versus atoms.
:vartype SubtractAtomicXC: BoolType | BoolKey
:ivar Usesymmetry: Undocumented.
:vartype Usesymmetry: BoolType | BoolKey
:ivar Usevstrainderrho: Undocumented.
:vartype Usevstrainderrho: BoolType | BoolKey
:ivar fitrho0numintextral: Undocumented.
:vartype fitrho0numintextral: int | IntKey
"""
def __post_init__(self):
self.Analytical: BoolType | BoolKey = BoolKey(name='Analytical', comment='Whether or not to use analytical strain derivatives. By default this is determined automatically, and used if possible.')
self.AnalyticalElectrostatic: BoolType | BoolKey = BoolKey(name='AnalyticalElectrostatic', comment='Undocumented.', default=False)
self.Analyticalkinetic: BoolType | BoolKey = BoolKey(name='Analyticalkinetic', comment='Undocumented.', default=False)
self.Analyticalpulay: BoolType | BoolKey = BoolKey(name='Analyticalpulay', comment='Undocumented.', default=False)
self.Analyticalxc: BoolType | BoolKey = BoolKey(name='Analyticalxc', comment='Undocumented.', default=False)
self.CalcRhoDef0FitError: BoolType | BoolKey = BoolKey(name='CalcRhoDef0FitError', comment='Does not affect the results, but prints the fit error and a first order error estimation for the stress. Can be very expensive.', hidden=True, default=False)
self.Celltopoorder: int | IntKey = IntKey(name='Celltopoorder', comment='Undocumented.', default=20)
self.Coreorthoption: int | IntKey = IntKey(name='Coreorthoption', comment='Undocumented.', default=2)
self.Fitrho0numintextrarad: int | IntKey = IntKey(name='Fitrho0numintextrarad', comment='Undocumented.', default=0)
self.Fitrho0prune: BoolType | BoolKey = BoolKey(name='Fitrho0prune', comment='Undocumented.', default=True)
self.Kinviadagger: BoolType | BoolKey = BoolKey(name='Kinviadagger', comment='Undocumented.', default=False)
self.Lmaxmultipoleexpansion: int | IntKey = IntKey(name='Lmaxmultipoleexpansion', comment='Undocumented.', default=4)
self.Naiveelstat: BoolType | BoolKey = BoolKey(name='Naiveelstat', comment='Undocumented.', default=False)
self.NoPairSetKCoordsToZero: BoolType | BoolKey = BoolKey(name='NoPairSetKCoordsToZero', comment='This used to be the case, do not know why. It seems to have no effect.', hidden=True, default=False)
self.Numericaldefdef: BoolType | BoolKey = BoolKey(name='Numericaldefdef', comment='Undocumented.', default=True)
self.Numericaldefdeflong: BoolType | BoolKey = BoolKey(name='Numericaldefdeflong', comment='Undocumented.', default=False)
self.Pairgridlowerangularorder: int | IntKey = IntKey(name='Pairgridlowerangularorder', comment='Undocumented.', default=5)
self.Pairgridradpointsincrease: int | IntKey = IntKey(name='Pairgridradpointsincrease', comment='Undocumented.', default=0)
self.Renormalizechargefitrho0: BoolType | BoolKey = BoolKey(name='Renormalizechargefitrho0', comment='Undocumented.', default=False)
self.Shiftmultipoleorigin: BoolType | BoolKey = BoolKey(name='Shiftmultipoleorigin', comment='Undocumented.', default=True)
self.Skipinlgwsmodule: BoolType | BoolKey = BoolKey(name='Skipinlgwsmodule', comment='Undocumented.', default=True)
self.SubtractAtomicXC: BoolType | BoolKey = BoolKey(name='SubtractAtomicXC', comment='Derive stress from xc energy difference of molecule versus atoms.', default=True)
self.Usesymmetry: BoolType | BoolKey = BoolKey(name='Usesymmetry', comment='Undocumented.', default=False)
self.Usevstrainderrho: BoolType | BoolKey = BoolKey(name='Usevstrainderrho', comment='Undocumented.', default=False)
self.fitrho0numintextral: int | IntKey = IntKey(name='fitrho0numintextral', comment='Undocumented.', default=0)
[docs] class _Tails(FixedBlock):
r"""
Ignore function tails.
:ivar Bas: Cut off the basis functions when smaller than the specified threshold.
:vartype Bas: float | FloatKey
:ivar Confine: Define a soft confinement radius for all functions. The value can be chosen larger than Tails%Bas. It never exceeds the SoftConfinement%Radius value.
:vartype Confine: float | FloatKey
:ivar Core: ToDo
:vartype Core: float | FloatKey
:ivar Coulomb: ToDo
:vartype Coulomb: BoolType | BoolKey
:ivar Fit: ToDo
:vartype Fit: float | FloatKey
:ivar Multipole: ToDo
:vartype Multipole: float | FloatKey
:ivar Rosa: Increase the radius of contracted functions. A factor is used that decays from 2 to 1.
:vartype Rosa: BoolType | BoolKey
:ivar Screening: ToDo
:vartype Screening: float | FloatKey
:ivar Verbose: Feedback, in particular on the confinement.
:vartype Verbose: BoolType | BoolKey
"""
def __post_init__(self):
self.Bas: float | FloatKey = FloatKey(name='Bas', comment='Cut off the basis functions when smaller than the specified threshold.', gui_name='Basis functions:', default=1e-06)
self.Confine: float | FloatKey = FloatKey(name='Confine', comment='Define a soft confinement radius for all functions. The value can be chosen larger than Tails%Bas. It never exceeds the SoftConfinement%Radius value.', hidden=True, default=0.0)
self.Core: float | FloatKey = FloatKey(name='Core', comment='ToDo', hidden=True, default=-1.0)
self.Coulomb: BoolType | BoolKey = BoolKey(name='Coulomb', comment='ToDo', hidden=True, default=False)
self.Fit: float | FloatKey = FloatKey(name='Fit', comment='ToDo', hidden=True, default=0.0)
self.Multipole: float | FloatKey = FloatKey(name='Multipole', comment='ToDo', hidden=True, default=1e-08)
self.Rosa: BoolType | BoolKey = BoolKey(name='Rosa', comment='Increase the radius of contracted functions. A factor is used that decays from 2 to 1.', hidden=True, default=False)
self.Screening: float | FloatKey = FloatKey(name='Screening', comment='ToDo', hidden=True, default=0.0001)
self.Verbose: BoolType | BoolKey = BoolKey(name='Verbose', comment='Feedback, in particular on the confinement.', hidden=True, default=False)
[docs] class _TechnicalCOSMO(FixedBlock):
r"""
Some options to develop cosmo for charged periodic systems
:ivar AddCOSMOPotentialToZlmFit: Should the cosmo potential be calculated via ZlmFit?. Merely for technical tests
:vartype AddCOSMOPotentialToZlmFit: BoolType | BoolKey
:ivar CalcEnergyForChargedPeriodicCase: Use new energy expression suitable for charged periodic systems.
:vartype CalcEnergyForChargedPeriodicCase: BoolType | BoolKey
:ivar ChargeConstraintViaEnergy: The charge constraint can be done via a Lagrange multiplier, or by eliminating one charge from the energy.
:vartype ChargeConstraintViaEnergy: BoolType | BoolKey
:ivar ExcludeNuBugFix: There was a bug skipping for all nu==mu, not checking icell = 1
:vartype ExcludeNuBugFix: BoolType | BoolKey
:ivar ExtrapolateChargeDerivativePotential: Use topological extrapolation for the calculation of the charge derivative of the (surface) potential.
:vartype ExtrapolateChargeDerivativePotential: BoolType | BoolKey
:ivar IncludeCOSMOPotentialInZlmFit: Solve COSMO and include cosmo pot in ZlmFit potential. This makes sense for the charge periodic COSMO case.
:vartype IncludeCOSMOPotentialInZlmFit: BoolType | BoolKey
:ivar NeutralizeSurfaceCharges: Add Q/N to surface charges.
:vartype NeutralizeSurfaceCharges: BoolType | BoolKey
:ivar SolveChargesForChargedPeriodicCase: Use new energy expression suitable for charged periodic systems to determine the charges.
:vartype SolveChargesForChargedPeriodicCase: BoolType | BoolKey
:ivar UseFullEnergyExpression: Use the energy expression that is valid for any q vector.
:vartype UseFullEnergyExpression: BoolType | BoolKey
"""
def __post_init__(self):
self.AddCOSMOPotentialToZlmFit: BoolType | BoolKey = BoolKey(name='AddCOSMOPotentialToZlmFit', comment='Should the cosmo potential be calculated via ZlmFit?. Merely for technical tests', default=False)
self.CalcEnergyForChargedPeriodicCase: BoolType | BoolKey = BoolKey(name='CalcEnergyForChargedPeriodicCase', comment='Use new energy expression suitable for charged periodic systems.', default=False)
self.ChargeConstraintViaEnergy: BoolType | BoolKey = BoolKey(name='ChargeConstraintViaEnergy', comment='The charge constraint can be done via a Lagrange multiplier, or by eliminating one charge from the energy.', default=False)
self.ExcludeNuBugFix: BoolType | BoolKey = BoolKey(name='ExcludeNuBugFix', comment='There was a bug skipping for all nu==mu, not checking icell = 1', default=False)
self.ExtrapolateChargeDerivativePotential: BoolType | BoolKey = BoolKey(name='ExtrapolateChargeDerivativePotential', comment='Use topological extrapolation for the calculation of the charge derivative of the (surface) potential.', default=False)
self.IncludeCOSMOPotentialInZlmFit: BoolType | BoolKey = BoolKey(name='IncludeCOSMOPotentialInZlmFit', comment='Solve COSMO and include cosmo pot in ZlmFit potential. This makes sense for the charge periodic COSMO case.', default=False)
self.NeutralizeSurfaceCharges: BoolType | BoolKey = BoolKey(name='NeutralizeSurfaceCharges', comment='Add Q/N to surface charges.', default=False)
self.SolveChargesForChargedPeriodicCase: BoolType | BoolKey = BoolKey(name='SolveChargesForChargedPeriodicCase', comment='Use new energy expression suitable for charged periodic systems to determine the charges.', default=False)
self.UseFullEnergyExpression: BoolType | BoolKey = BoolKey(name='UseFullEnergyExpression', comment='Use the energy expression that is valid for any q vector.', default=False)
[docs] class _TestParameters(FixedBlock):
r"""
Undocumented.
:ivar Integer: Undocumented.
:vartype Integer: int | IntKey
:ivar IntegerList: Undocumented.
:vartype IntegerList: str | StringKey
:ivar Logical: Undocumented.
:vartype Logical: BoolType | BoolKey
:ivar String: Undocumented.
:vartype String: str | StringKey
"""
def __post_init__(self):
self.Integer: int | IntKey = IntKey(name='Integer', comment='Undocumented.', default=1)
self.IntegerList: str | StringKey = StringKey(name='IntegerList', comment='Undocumented.')
self.Logical: BoolType | BoolKey = BoolKey(name='Logical', comment='Undocumented.', default=False)
self.String: str | StringKey = StringKey(name='String', comment='Undocumented.')
[docs] class _Transport(FixedBlock):
r"""
Old NEGF. No longer supported
:ivar c1atoms: count of number of atoms considered as contact 1
:vartype c1atoms: int | IntKey
:ivar c2atoms: count of number of atoms considered as contact 2
:vartype c2atoms: int | IntKey
:ivar contactshift: sets baseline deltaphi0
:vartype contactshift: float | FloatKey
:ivar defersigma: decides whether to load sigmas on the fly
:vartype defersigma: BoolType | BoolKey
:ivar easynegf: Undocumented.
:vartype easynegf: BoolType | BoolKey
:ivar freezestop: controls how long you might whether deltaphi0 floats in transport
:vartype freezestop: int | IntKey
:ivar hmatmixsteps: controls over how many steps to mix in bulk hmats after freezestop
:vartype hmatmixsteps: int | IntKey
:ivar nematoms: count of number of atoms considered as extended molecule
:vartype nematoms: int | IntKey
:ivar noshiftfloat: turns off deltaphi0 floating calculation in transport
:vartype noshiftfloat: BoolType | BoolKey
:ivar offsetshift: sets baseline deltaphi1
:vartype offsetshift: float | FloatKey
:ivar plot: Print option for dos and transmission
:vartype plot: int | IntKey
:ivar screw: controls negfs ability to adapt the scf, diis mixing parameters
:vartype screw: BoolType | BoolKey
:ivar testmatch: controls whether we should do extensive testing of hmat matches
:vartype testmatch: BoolType | BoolKey
:ivar transdir: Transport direction
:vartype transdir: int | IntKey
:ivar unresleads: turns on unrestricted calculation for the leads in transport
:vartype unresleads: BoolType | BoolKey
:ivar wbl: sets wide band limit coupling parameter
:vartype wbl: BoolType | BoolKey
:ivar wblflat: decides whether to do wbl with flat imaginary constant part, and sets it
:vartype wblflat: float | FloatKey
:ivar wblimonly: decides whether to do wbl sigma(fermi) with only imaginary part
:vartype wblimonly: BoolType | BoolKey
:ivar wblplotonly: decides whether to turn wbl of any kind off in scf cycle
:vartype wblplotonly: BoolType | BoolKey
:ivar wblrescale: decides whether to do wbl sigma rescaled from ellipse to flat band
:vartype wblrescale: BoolType | BoolKey
"""
def __post_init__(self):
self.c1atoms: int | IntKey = IntKey(name='c1atoms', comment='count of number of atoms considered as contact 1', default=1)
self.c2atoms: int | IntKey = IntKey(name='c2atoms', comment='count of number of atoms considered as contact 2', default=1)
self.contactshift: float | FloatKey = FloatKey(name='contactshift', comment='sets baseline deltaphi0', default=0.0)
self.defersigma: BoolType | BoolKey = BoolKey(name='defersigma', comment='decides whether to load sigmas on the fly', default=False)
self.easynegf: BoolType | BoolKey = BoolKey(name='easynegf', comment='Undocumented.', default=False)
self.freezestop: int | IntKey = IntKey(name='freezestop', comment='controls how long you might whether deltaphi0 floats in transport', default=0)
self.hmatmixsteps: int | IntKey = IntKey(name='hmatmixsteps', comment='controls over how many steps to mix in bulk hmats after freezestop', default=0)
self.nematoms: int | IntKey = IntKey(name='nematoms', comment='count of number of atoms considered as extended molecule', default=1)
self.noshiftfloat: BoolType | BoolKey = BoolKey(name='noshiftfloat', comment='turns off deltaphi0 floating calculation in transport', default=False)
self.offsetshift: float | FloatKey = FloatKey(name='offsetshift', comment='sets baseline deltaphi1', default=0.0)
self.plot: int | IntKey = IntKey(name='plot', comment='Print option for dos and transmission', default=1000)
self.screw: BoolType | BoolKey = BoolKey(name='screw', comment='controls negfs ability to adapt the scf, diis mixing parameters', default=False)
self.testmatch: BoolType | BoolKey = BoolKey(name='testmatch', comment='controls whether we should do extensive testing of hmat matches', default=False)
self.transdir: int | IntKey = IntKey(name='transdir', comment='Transport direction', default=3)
self.unresleads: BoolType | BoolKey = BoolKey(name='unresleads', comment='turns on unrestricted calculation for the leads in transport', default=False)
self.wbl: BoolType | BoolKey = BoolKey(name='wbl', comment='sets wide band limit coupling parameter', default=False)
self.wblflat: float | FloatKey = FloatKey(name='wblflat', comment='decides whether to do wbl with flat imaginary constant part, and sets it', default=0.01)
self.wblimonly: BoolType | BoolKey = BoolKey(name='wblimonly', comment='decides whether to do wbl sigma(fermi) with only imaginary part', default=False)
self.wblplotonly: BoolType | BoolKey = BoolKey(name='wblplotonly', comment='decides whether to turn wbl of any kind off in scf cycle', default=False)
self.wblrescale: BoolType | BoolKey = BoolKey(name='wblrescale', comment='decides whether to do wbl sigma rescaled from ellipse to flat band', default=False)
[docs] class _XC(FixedBlock):
r"""
Exchange Correlation functionals
:ivar DoubleHybrid: Specifies the double hybrid functional that should be used during the SCF.
:vartype DoubleHybrid: str | StringKey
:ivar EmpiricalScaling: Calculate the (SOS/SCS/SCSMI)-MP2 correlation energy.
:vartype EmpiricalScaling: Literal["None", "SOS", "SCS", "SCSMI"]
:ivar GALITSKIIMIGDAL: Calculate the Galitskii-Migdal correlation energy after the SCF is completed.
:vartype GALITSKIIMIGDAL: BoolType | BoolKey
:ivar GLLBKParameter: K parameter for the GLLB functionals. See equation (20) of the paper.
:vartype GLLBKParameter: float | FloatKey
:ivar HartreeFock: Stand alone HF calculation.
:vartype HartreeFock: BoolType | BoolKey
:ivar MP2: Calculate the MP2 correlation energy after the HF SCF is completed.
:vartype MP2: BoolType | BoolKey
:ivar RPA: Specifies that RPA is used an possibly also a post-RPA method. By default, direct RPA is used
:vartype RPA: Literal["None", "Direct", "Sigma", "SOSEX", "SOSSX"]
:ivar RangeSeparation: Intended to be used with HartreeFock (or hybrid functionals). Example: OMEGA= 0.110000 ALPHA= 0.250000 BETA= -0.250000 ERF-SHORTRANGE
:vartype RangeSeparation: str | StringKey
:ivar allowany: Undocumented.
:vartype allowany: BoolType | BoolKey
:ivar diracgga: GGA for the dirac .
:vartype diracgga: str | StringKey
:ivar dispersion: The dispersion correction model to be used.
:vartype dispersion: str | StringKey
:ivar gga: GGA XC functional.
:vartype gga: str | StringKey
:ivar lda: LDA XC functional.
:vartype lda: str | StringKey
:ivar libxc: Functional using the LicXC library.
:vartype libxc: str | StringKey
:ivar libxcdensitythreshold: Density threshold for LibXC functionals.
:vartype libxcdensitythreshold: float | FloatKey
:ivar metagga: MetaGG XC functional.
:vartype metagga: str | StringKey
:ivar mggaoepconvergence: Undocumented.
:vartype mggaoepconvergence: float | FloatKey
:ivar mggaoepmaxabortiter: Undocumented.
:vartype mggaoepmaxabortiter: int | IntKey
:ivar mggaoepmaxerrorincrease: Undocumented.
:vartype mggaoepmaxerrorincrease: float | FloatKey
:ivar mggaoepmaxiter: Undocumented.
:vartype mggaoepmaxiter: int | IntKey
:ivar mggaoepwaititer: Undocumented.
:vartype mggaoepwaititer: int | IntKey
:ivar model: Model potential. The possible choices are LB94, GLLB-SC, BGLLB-VWN, and BGLLB-LYP
:vartype model: str | StringKey
:ivar nlxcpot: Undocumented.
:vartype nlxcpot: str | StringKey
:ivar spinorbitmagnetization: Type of Spin-Orbit magnetization.
:vartype spinorbitmagnetization: str | StringKey
:ivar tb_mbjafactor: a parameter for the TB-MBJ model potential.
:vartype tb_mbjafactor: float | FloatKey
:ivar tb_mbjbfactor: b parameter for the TB-MBJ model potential..
:vartype tb_mbjbfactor: float | FloatKey
:ivar tb_mbjcfactor: c parameter for the TB-MBJ model potential..
:vartype tb_mbjcfactor: float | FloatKey
:ivar tb_mbjefactor: e parameter for the TB-MBJ model potential..
:vartype tb_mbjefactor: float | FloatKey
:ivar usexcfun: Whether ot not the XCFun library should be used.
:vartype usexcfun: BoolType | BoolKey
:ivar xcfun: Functional for the XCFun library.
:vartype xcfun: BoolType | BoolKey
:ivar DFTHalf: DFT-1/2 method for band gaps. See PRB vol 78,125116 2008. This method can be used in combination with any functional. For each active atom type (see ActiveAtomType) Band will perform SCF calculations at different screening cut-off values (see ScreeningCutOffs) and pick the cut-off value that maximizes the band gap. If multiple atom types are active, the screening cut-off optimizations are done one type at the time (in the same order as the ActiveAtomType blocks appear in the input).
:vartype DFTHalf: BAND._XC._DFTHalf
"""
[docs] class _DFTHalf(FixedBlock):
r"""
DFT-1/2 method for band gaps. See PRB vol 78,125116 2008. This method can be used in combination with any functional. For each active atom type (see ActiveAtomType) Band will perform SCF calculations at different screening cut-off values (see ScreeningCutOffs) and pick the cut-off value that maximizes the band gap. If multiple atom types are active, the screening cut-off optimizations are done one type at the time (in the same order as the ActiveAtomType blocks appear in the input).
:ivar Enabled: Whether the DFT-1/2 method will be used.
:vartype Enabled: BoolType | BoolKey
:ivar Prepare: Analyze the band structure to determine reasonable settings for an DFT-1/2 calculation. If this is possible the list of active atom types is written to the output. This can be used in a next run as the values for ActiveAtomType. The DFTHalf%Enabled key should be set to false
:vartype Prepare: BoolType | BoolKey
:ivar SelfConsistent: Apply the extra potential during the SCF, or only afterwards. Applying DFT-1/2 only post SCF increases the band gap, compared to the self-consistent one.
:vartype SelfConsistent: BoolType | BoolKey
:ivar ActiveAtomType: Use the DFT-1/2 method for the atom-type specified in this block.
:vartype ActiveAtomType: BAND._XC._DFTHalf._ActiveAtomType
"""
[docs] class _ActiveAtomType(FixedBlock):
r"""
Use the DFT-1/2 method for the atom-type specified in this block.
:ivar AtomType: Atom-type to use. You can activate all atom-types by specifying 'All'.
:vartype AtomType: str | StringKey
:ivar IonicCharge: The amount of charge to be removed from the atomic HOMO.
:vartype IonicCharge: float | FloatKey
:ivar ScreeningCutOffs: List of screening cut-offs (to screen the asymptotic IonicCharge/r potential). Band will loop over these values and find the cut-off that maximizes the band-gap. If only one number is provided, Band will simply use that value.
:vartype ScreeningCutOffs: Iterable[float] | FloatListKey
"""
def __post_init__(self):
self.AtomType: str | StringKey = StringKey(name='AtomType', comment="Atom-type to use. You can activate all atom-types by specifying 'All'.", gui_type='element {GetAtomTypes DFTHalf::GetTypes}')
self.IonicCharge: float | FloatKey = FloatKey(name='IonicCharge', comment='The amount of charge to be removed from the atomic HOMO.', default=0.5)
self.ScreeningCutOffs: Iterable[float] | FloatListKey = FloatListKey(name='ScreeningCutOffs', comment='List of screening cut-offs (to screen the asymptotic IonicCharge/r potential). Band will loop over these values and find the cut-off that maximizes the band-gap. If only one number is provided, Band will simply use that value.', default=[0.0, 1.0, 2.0, 3.0, 4.0, 5.0], unit='Bohr')
def __post_init__(self):
self.Enabled: BoolType | BoolKey = BoolKey(name='Enabled', comment='Whether the DFT-1/2 method will be used.', gui_name='Use method:', default=False)
self.Prepare: BoolType | BoolKey = BoolKey(name='Prepare', comment='Analyze the band structure to determine reasonable settings for an DFT-1/2 calculation. If this is possible the list of active atom types is written to the output. This can be used in a next run as the values for ActiveAtomType. The DFTHalf%Enabled key should be set to false', default=False)
self.SelfConsistent: BoolType | BoolKey = BoolKey(name='SelfConsistent', comment='Apply the extra potential during the SCF, or only afterwards. Applying DFT-1/2 only post SCF increases the band gap, compared to the self-consistent one.', default=True)
self.ActiveAtomType: BAND._XC._DFTHalf._ActiveAtomType = self._ActiveAtomType(name='ActiveAtomType', comment='Use the DFT-1/2 method for the atom-type specified in this block.', unique=False)
def __post_init__(self):
self.DoubleHybrid: str | StringKey = StringKey(name='DoubleHybrid', comment='Specifies the double hybrid functional that should be used during the SCF.')
self.EmpiricalScaling: Literal["None", "SOS", "SCS", "SCSMI"] = MultipleChoiceKey(name='EmpiricalScaling', comment='Calculate the (SOS/SCS/SCSMI)-MP2 correlation energy.', default='None', choices=['None', 'SOS', 'SCS', 'SCSMI'])
self.GALITSKIIMIGDAL: BoolType | BoolKey = BoolKey(name='GALITSKIIMIGDAL', comment='Calculate the Galitskii-Migdal correlation energy after the SCF is completed.', default=False)
self.GLLBKParameter: float | FloatKey = FloatKey(name='GLLBKParameter', comment='K parameter for the GLLB functionals. See equation (20) of the paper.', default=0.382)
self.HartreeFock: BoolType | BoolKey = BoolKey(name='HartreeFock', comment='Stand alone HF calculation.', default=False)
self.MP2: BoolType | BoolKey = BoolKey(name='MP2', comment='Calculate the MP2 correlation energy after the HF SCF is completed.', default=False)
self.RPA: Literal["None", "Direct", "Sigma", "SOSEX", "SOSSX"] = MultipleChoiceKey(name='RPA', comment='Specifies that RPA is used an possibly also a post-RPA method. By default, direct RPA is used', default='None', choices=['None', 'Direct', 'Sigma', 'SOSEX', 'SOSSX'])
self.RangeSeparation: str | StringKey = StringKey(name='RangeSeparation', comment='Intended to be used with HartreeFock (or hybrid functionals). Example: OMEGA= 0.110000 ALPHA= 0.250000 BETA= -0.250000 ERF-SHORTRANGE', default='')
self.allowany: BoolType | BoolKey = BoolKey(name='allowany', comment='Undocumented.', hidden=True, default=False)
self.diracgga: str | StringKey = StringKey(name='diracgga', comment='GGA for the dirac .', default=' ')
self.dispersion: str | StringKey = StringKey(name='dispersion', comment='The dispersion correction model to be used.', default='DEFAULT')
self.gga: str | StringKey = StringKey(name='gga', comment='GGA XC functional.', default='NONE')
self.lda: str | StringKey = StringKey(name='lda', comment='LDA XC functional.', default='VWN')
self.libxc: str | StringKey = StringKey(name='libxc', comment='Functional using the LicXC library.', default='NONE')
self.libxcdensitythreshold: float | FloatKey = FloatKey(name='libxcdensitythreshold', comment='Density threshold for LibXC functionals.', default=1e-10)
self.metagga: str | StringKey = StringKey(name='metagga', comment='MetaGG XC functional.', default='NONE')
self.mggaoepconvergence: float | FloatKey = FloatKey(name='mggaoepconvergence', comment='Undocumented.', hidden=True, default=1e-06)
self.mggaoepmaxabortiter: int | IntKey = IntKey(name='mggaoepmaxabortiter', comment='Undocumented.', hidden=True, default=0)
self.mggaoepmaxerrorincrease: float | FloatKey = FloatKey(name='mggaoepmaxerrorincrease', comment='Undocumented.', hidden=True, default=0.0)
self.mggaoepmaxiter: int | IntKey = IntKey(name='mggaoepmaxiter', comment='Undocumented.', hidden=True, default=100)
self.mggaoepwaititer: int | IntKey = IntKey(name='mggaoepwaititer', comment='Undocumented.', hidden=True, default=0)
self.model: str | StringKey = StringKey(name='model', comment='Model potential. The possible choices are LB94, GLLB-SC, BGLLB-VWN, and BGLLB-LYP', default='LB94')
self.nlxcpot: str | StringKey = StringKey(name='nlxcpot', comment='Undocumented.', hidden=True, default='NONE')
self.spinorbitmagnetization: str | StringKey = StringKey(name='spinorbitmagnetization', comment='Type of Spin-Orbit magnetization.', default='collinearz')
self.tb_mbjafactor: float | FloatKey = FloatKey(name='tb_mbjafactor', comment='a parameter for the TB-MBJ model potential.', default=-1.23456789)
self.tb_mbjbfactor: float | FloatKey = FloatKey(name='tb_mbjbfactor', comment='b parameter for the TB-MBJ model potential..', default=-1.23456789)
self.tb_mbjcfactor: float | FloatKey = FloatKey(name='tb_mbjcfactor', comment='c parameter for the TB-MBJ model potential..', default=-1.23456789)
self.tb_mbjefactor: float | FloatKey = FloatKey(name='tb_mbjefactor', comment='e parameter for the TB-MBJ model potential..', default=-1.23456789)
self.usexcfun: BoolType | BoolKey = BoolKey(name='usexcfun', comment='Whether ot not the XCFun library should be used.', default=False)
self.xcfun: BoolType | BoolKey = BoolKey(name='xcfun', comment='Functional for the XCFun library.', default=False)
self.DFTHalf: BAND._XC._DFTHalf = self._DFTHalf(name='DFTHalf', comment='DFT-1/2 method for band gaps. See PRB vol 78,125116 2008. This method can be used in combination with any functional. For each active atom type (see ActiveAtomType) Band will perform SCF calculations at different screening cut-off values (see ScreeningCutOffs) and pick the cut-off value that maximizes the band gap. If multiple atom types are active, the screening cut-off optimizations are done one type at the time (in the same order as the ActiveAtomType blocks appear in the input).')
[docs] class _ZlmFit(FixedBlock):
r"""
Options for the density fitting scheme 'ZlmFit'.
:ivar AllowBoost: Allow automatic atom-dependent tuning of maximum l of spherical harmonics expansion. Whether or not this boost is needed for a given atom is based on an heuristic estimate of how complex the density around that atom is.
:vartype AllowBoost: BoolType | BoolKey
:ivar DensityThreshold: Threshold below which the electron density is considered to be negligible. Depends on Quality and is normally 1.0e-7
:vartype DensityThreshold: float | FloatKey
:ivar FGaussianW: Only for 3D periodic systems. Width of the Gaussian functions replacing the S and P Zlms for Fourier transform.
:vartype FGaussianW: float | FloatKey
:ivar FGridSpacing: Only for 3D periodic systems. Spacing for the Fourier grid. By default, this depends on the quality.
:vartype FGridSpacing: float | FloatKey
:ivar FKSpaceCutOff: Only for 3D periodic systems. Cut-off of the grid in k-space for the Fourier transform.
:vartype FKSpaceCutOff: float | FloatKey
:ivar FirstTopoCell: First cell for the topological extrapolation of the long range part of the Coulomb Potential.
:vartype FirstTopoCell: int | IntKey
:ivar GridAngOrder: Lebedev angular order for the fitting grid.
:vartype GridAngOrder: int | IntKey
:ivar GridRadialFactor: User defined value for determining how many radial points are used in the interpolation grid. By default, this depends on the quality, and normally is 1.0
:vartype GridRadialFactor: float | FloatKey
:ivar LMargin: User-defined l-margin, i.e., l_max for fitting is max(lMargin + l_max_basis_function, 2*l_max_basis_function). Depends on Quality and normally is 4
:vartype LMargin: int | IntKey
:ivar LastTopoCell: Last cell for the topological extrapolation of the long range part of the Coulomb Potential.
:vartype LastTopoCell: int | IntKey
:ivar NumStarsPartitionFun: Number of cell stars to consider when computing the partition function.
:vartype NumStarsPartitionFun: int | IntKey
:ivar OrderTopoTrick: Order of the topological extrapolation of the long range part of the Coulomb Potential.
:vartype OrderTopoTrick: int | IntKey
:ivar PartitionFunThreshold: Threshold for the partition functions: if an integration point has a partition function weight smaller than this threshold, it will be discarded.
:vartype PartitionFunThreshold: float | FloatKey
:ivar PotentialThreshold: Depends on the Quality. For band it is normally 1.0e-8, ten times smaller than for molecules.
:vartype PotentialThreshold: float | FloatKey
:ivar Pruning: Undocumented. Depends on the Quality, normally true
:vartype Pruning: BoolType | BoolKey
:ivar Quality: Quality of the density-fitting approximation. For a description of the various qualities and the associated numerical accuracy see reference. If 'Auto', the quality defined in the 'NumericalQuality' will be used.
:vartype Quality: Literal["Auto", "Basic", "Normal", "Good", "VeryGood", "Excellent"]
:ivar RenormalizeChargeMethod: Undocumented.
:vartype RenormalizeChargeMethod: int | IntKey
:ivar UseBlockProperty: Undocumented.
:vartype UseBlockProperty: BoolType | BoolKey
:ivar QualityPerRegion: Sets the ZlmFit quality for all atoms in a region. If specified, this overwrites the globally set quality.
:vartype QualityPerRegion: BAND._ZlmFit._QualityPerRegion
"""
[docs] class _QualityPerRegion(FixedBlock):
r"""
Sets the ZlmFit quality for all atoms in a region. If specified, this overwrites the globally set quality.
:ivar Quality: The region's quality of the ZlmFit.
:vartype Quality: Literal["Basic", "Normal", "Good", "VeryGood", "Excellent"]
:ivar Region: The identifier of the region for which to set the quality.
:vartype Region: str | StringKey
"""
def __post_init__(self):
self.Quality: Literal["Basic", "Normal", "Good", "VeryGood", "Excellent"] = MultipleChoiceKey(name='Quality', comment="The region's quality of the ZlmFit.", choices=['Basic', 'Normal', 'Good', 'VeryGood', 'Excellent'])
self.Region: str | StringKey = StringKey(name='Region', comment='The identifier of the region for which to set the quality.', gui_type='region')
def __post_init__(self):
self.AllowBoost: BoolType | BoolKey = BoolKey(name='AllowBoost', comment='Allow automatic atom-dependent tuning of maximum l of spherical harmonics expansion. Whether or not this boost is needed for a given atom is based on an heuristic estimate of how complex the density around that atom is.', default=True)
self.DensityThreshold: float | FloatKey = FloatKey(name='DensityThreshold', comment='Threshold below which the electron density is considered to be negligible. Depends on Quality and is normally 1.0e-7')
self.FGaussianW: float | FloatKey = FloatKey(name='FGaussianW', comment='Only for 3D periodic systems. Width of the Gaussian functions replacing the S and P Zlms for Fourier transform. ', default=1.0)
self.FGridSpacing: float | FloatKey = FloatKey(name='FGridSpacing', comment='Only for 3D periodic systems. Spacing for the Fourier grid. By default, this depends on the quality.')
self.FKSpaceCutOff: float | FloatKey = FloatKey(name='FKSpaceCutOff', comment='Only for 3D periodic systems. Cut-off of the grid in k-space for the Fourier transform.')
self.FirstTopoCell: int | IntKey = IntKey(name='FirstTopoCell', comment='First cell for the topological extrapolation of the long range part of the Coulomb Potential.', default=5)
self.GridAngOrder: int | IntKey = IntKey(name='GridAngOrder', comment='Lebedev angular order for the fitting grid.', hidden=True)
self.GridRadialFactor: float | FloatKey = FloatKey(name='GridRadialFactor', comment='User defined value for determining how many radial points are used in the interpolation grid. By default, this depends on the quality, and normally is 1.0', hidden=True)
self.LMargin: int | IntKey = IntKey(name='LMargin', comment='User-defined l-margin, i.e., l_max for fitting is max(lMargin + l_max_basis_function, 2*l_max_basis_function). Depends on Quality and normally is 4')
self.LastTopoCell: int | IntKey = IntKey(name='LastTopoCell', comment='Last cell for the topological extrapolation of the long range part of the Coulomb Potential.', default=10)
self.NumStarsPartitionFun: int | IntKey = IntKey(name='NumStarsPartitionFun', comment='Number of cell stars to consider when computing the partition function.', default=5)
self.OrderTopoTrick: int | IntKey = IntKey(name='OrderTopoTrick', comment='Order of the topological extrapolation of the long range part of the Coulomb Potential.', default=3)
self.PartitionFunThreshold: float | FloatKey = FloatKey(name='PartitionFunThreshold', comment='Threshold for the partition functions: if an integration point has a partition function weight smaller than this threshold, it will be discarded.', default=0.0)
self.PotentialThreshold: float | FloatKey = FloatKey(name='PotentialThreshold', comment='Depends on the Quality. For band it is normally 1.0e-8, ten times smaller than for molecules.', hidden=True)
self.Pruning: BoolType | BoolKey = BoolKey(name='Pruning', comment='Undocumented. Depends on the Quality, normally true', hidden=True)
self.Quality: Literal["Auto", "Basic", "Normal", "Good", "VeryGood", "Excellent"] = MultipleChoiceKey(name='Quality', comment="Quality of the density-fitting approximation. For a description of the various qualities and the associated numerical accuracy see reference. If 'Auto', the quality defined in the 'NumericalQuality' will be used.", gui_name='Spline Zlm fit:', default='Auto', choices=['Auto', 'Basic', 'Normal', 'Good', 'VeryGood', 'Excellent'])
self.RenormalizeChargeMethod: int | IntKey = IntKey(name='RenormalizeChargeMethod', comment='Undocumented.', hidden=True, default=1)
self.UseBlockProperty: BoolType | BoolKey = BoolKey(name='UseBlockProperty', comment='Undocumented.', hidden=True, default=True)
self.QualityPerRegion: BAND._ZlmFit._QualityPerRegion = self._QualityPerRegion(name='QualityPerRegion', comment='Sets the ZlmFit quality for all atoms in a region. If specified, this overwrites the globally set quality.', unique=False)
def __post_init__(self):
self.Allow: str | StringKey = StringKey(name='Allow', comment='Debugging feature to let the program continue even when intermediate results seem to be wrong or very inaccurate', unique=False)
self.BerryPhase: BoolType | BoolKey = BoolKey(name='BerryPhase', comment='Boolean that determines whether the dipole as determined through the Berry phase approach should be calculated.', default=False)
self.CPVector: int | IntKey = IntKey(name='CPVector', comment='The code is vectorized and this key can be used to set the vector length', gui_name='Vectorlength (blocksize):', default=128)
self.Debug: str | StringKey = StringKey(name='Debug', comment='Enables debug printing for the subroutine name(s) specified here.', hidden=True, unique=False, extra_info='not_in_fragment')
self.DefaultsConvention: str | StringKey = StringKey(name='DefaultsConvention', comment='There has been a big change in many default settings with the 2014 release. This lets you switch to the old defaults.', hidden=True, default='POST2014')
self.DumpBasisOnly: BoolType | BoolKey = BoolKey(name='DumpBasisOnly', comment='Dump basis and fit set files use for each atom.', default=False)
self.EigThreshold: float | FloatKey = FloatKey(name='EigThreshold', comment='Threshold for printing the eigenvectors coefficients (Print Eigens)', default=0.01, extra_info='not_in_fragment')
self.EnforcedSpinPolarization: float | FloatKey = FloatKey(name='EnforcedSpinPolarization', comment='Enforce a specific spin-polarization instead of occupying according to the aufbau principle. The spin-polarization is the difference between the number of alpha and beta electron.\n\nThus, a value of 1 means that there is one more alpha electron than beta electrons.\n\nThe number may be anything, including zero, which may be of interest when searching for a spin-flipped pair, that may otherwise end up in the (more stable) parallel solution.', gui_name='Spin polarization:')
self.FormFactors: int | IntKey = IntKey(name='FormFactors', comment='Number of stars of K-vectors for which the form factors are computed', default=2, extra_info='not_in_fragment')
self.IntegrationMethod: Literal["Becke", "Voronoi"] = MultipleChoiceKey(name='IntegrationMethod', comment='Choose the real-space numerical integration method. Note: the Voronoi integration scheme is deprecated.', default='Becke', choices=['Becke', 'Voronoi'])
self.KGrp0: int | IntKey = IntKey(name='KGrp0', comment='Undocumented.', hidden=True, default=30)
self.KGrpX: int | IntKey = IntKey(name='KGrpX', comment='Absolute upper bound on the number of k-points processed together. This only affects the computational performance.', gui_name='Number of K-points at once:', default=5)
self.ModifyAlternativeElements: BoolType | BoolKey = BoolKey(name='ModifyAlternativeElements', comment='When using alternative elements (using the nuclear_charge attribute) set the element to the nearest integer Z. If you specify an H atom with a nuclear_charge of 2.9 it is replaced by a Li atom with the same nuclear charge.', default=False)
self.NUElstat: int | IntKey = IntKey(name='NUElstat', comment='Number of outward (parabolic) integration points (for elliptical integration of the electrostatic interaction)', default=50, extra_info='not_in_fragment')
self.NVElstat: int | IntKey = IntKey(name='NVElstat', comment='Number of angular (elliptic) integration points (for elliptical integration of the electrostatic interaction)', default=80, extra_info='not_in_fragment')
self.NeutralizingDensity: Literal["None", "rho(atoms)", "rho(valence/atoms)", "rho(neutralizing/atoms)", "rho(homogeneous)"] = MultipleChoiceKey(name='NeutralizingDensity', comment='For charged systems an artificial compensating density can be used to make it neutral again. This fictitious density only affects the Coulomb potential.\n For charged periodic systems neutralization is required, as otherwise the Coulomb potential diverges.', default='None', choices=['None', 'rho(atoms)', 'rho(valence/atoms)', 'rho(neutralizing/atoms)', 'rho(homogeneous)'])
self.NuclearModel: Literal["PointCharge", "Gaussian", "Uniform"] = MultipleChoiceKey(name='NuclearModel', comment='Specify what model to use for the nucleus.\n\nFor the Gaussian model the nuclear radius is calculated according to the work of Visscher and Dyall (L. Visscher, and K.G. Dyall, Dirac-Fock atomic electronic structure calculations using different nuclear charge distributions, Atomic Data and Nuclear Data Tables 67, 207 (1997))', default='PointCharge', choices=['PointCharge', 'Gaussian', 'Uniform'])
self.NumericalQuality: Literal["Basic", "Normal", "Good", "VeryGood", "Excellent"] = MultipleChoiceKey(name='NumericalQuality', comment="Set the quality of several important technical aspects of a BAND calculation (with the notable exception of the basis set). It sets the quality of: BeckeGrid (numerical integration), ZlmFit (density fitting), KSpace (reciprocal space integration), and SoftConfinement (basis set confinement). Note: the quality defined in the block of a specific technical aspects supersedes the value defined in NumericalQuality (e.g. if I specify 'NumericalQuality Basic' and 'BeckeGrid%Quality Good', the quality of the BeckeGrid will be 'Good')", default='Normal', choices=['Basic', 'Normal', 'Good', 'VeryGood', 'Excellent'])
self.PEDA: BoolType | BoolKey = BoolKey(name='PEDA', comment='If present in combination with the fragment block, the decomposition of the interaction energy between fragments is invoked.', default=False, extra_info='not_in_fragment')
self.PopThreshold: float | FloatKey = FloatKey(name='PopThreshold', comment="Threshold for printing Mulliken population terms. Works with 'Print orbpop'", default=0.01, extra_info='not_in_fragment')
self.PotentialNoise: float | FloatKey = FloatKey(name='PotentialNoise', comment='The initial potential for the SCF procedure is constructed from a sum-of-atoms density. Added to this is some small noise in the numerical values of the potential in the points of the integration grid. The purpose of the noise is to help the program break the initial symmetry, if that would lower the energy, by effectively inducing small differences between (initially) degenerate orbitals.', default=0.0001, extra_info='not_in_fragment')
self.Print: str | StringKey = StringKey(name='Print', comment='One or more strings (separated by blanks) from a pre-defined set may be typed after the key. This induces printing of various kinds of information, usually only used for debugging and checking. The set of recognized strings frequently changes (mainly expands) in the course of software-developments. Useful arguments may be symmetry, and fit.', unique=False, extra_info='not_in_fragment')
self.Save: str | StringKey = StringKey(name='Save', comment="Save scratch files or extra data that would be otherwise deleted at the end of the calculation. e.g. 'TAPE10' (containing the integration grid) or 'DensityMatrix'", unique=False, extra_info='not_in_fragment')
self.SelectedAtoms: Iterable[int] | IntListKey = IntListKey(name='SelectedAtoms', comment='With this key you can select atoms. This has an effect on a few of options, like NMR and EFG.', isatomlist=True, extra_info='not_in_fragment')
self.SetLoggingLevel: str | StringKey = StringKey(name='SetLoggingLevel', comment='Undocumented.', hidden=True, unique=False, extra_info='not_in_fragment')
self.Skip: str | StringKey = StringKey(name='Skip', comment='Skip the specified part of the Band calculation (expert/debug option).', unique=False, extra_info='not_in_fragment')
self.StopAfter: str | StringKey = StringKey(name='StopAfter', comment='Specifies that the program is stopped after execution of a specified program-part (subroutine).', default='BAND', extra_info='not_in_fragment')
self.StoreHamAsMol: BoolType | BoolKey = BoolKey(name='StoreHamAsMol', comment='Undocumented, used for (at least) NEGF.', default=False, extra_info='not_in_fragment')
self.StoreHamiltonian: BoolType | BoolKey = BoolKey(name='StoreHamiltonian', comment='Undocumented.', extra_info='not_in_fragment')
self.StoreHamiltonian2: BoolType | BoolKey = BoolKey(name='StoreHamiltonian2', comment='determine the tight-binding representation of the overlap an fock matrix. Used for (at least) NEGF.', default=False, extra_info='not_in_fragment')
self.SubSymmetry: Iterable[int] | IntListKey = IntListKey(name='SubSymmetry', comment='The indices of the symmetry operators to maintain.', extra_info='not_in_fragment')
self.Title: str | StringKey = StringKey(name='Title', comment='Title of the calculation, which will be printed in the output file.', default='')
self.Unrestricted: BoolType | BoolKey = BoolKey(name='Unrestricted', comment='Controls whether Band should perform a spin-unrestricted calculation. Spin-unrestricted calculations are computationally roughly twice as expensive as spin-restricted.', default=False)
self.UnrestrictedOnlyReference: BoolType | BoolKey = BoolKey(name='UnrestrictedOnlyReference', comment='Undocumented.', default=False)
self.UnrestrictedReference: BoolType | BoolKey = BoolKey(name='UnrestrictedReference', comment='Undocumented.', default=False)
self.UnrestrictedStartup: BoolType | BoolKey = BoolKey(name='UnrestrictedStartup', comment='Undocumented.', default=False)
self.UseInversionSymmetryInReciprocalSpace: BoolType | BoolKey = BoolKey(name='UseInversionSymmetryInReciprocalSpace', comment='Whether to use inversion symmetry in reciprocal space. This is almost always a valid assumption.', gui_name='Use inversion sym in recip space:', default=True)
self.UseSymmetry: BoolType | BoolKey = BoolKey(name='UseSymmetry', comment='Whether or not to exploit symmetry during the calculation.', default=True)
self.AIMCriticalPoints: BAND._AIMCriticalPoints = self._AIMCriticalPoints(name='AIMCriticalPoints', comment='Compute the critical points of the density (Atoms In Molecules). The algorithm starts from a regular mesh of points, and from each of these it walks towards its corresponding critical point.', extra_info='not_in_fragment')
self.ATensor: BAND._ATensor = self._ATensor(name='ATensor', comment='Hyperfine A-tensor.', extra_info='not_in_fragment')
self.Align: BAND._Align = self._Align(name='Align', comment='Alignment of the potential of the system. Old NEGF.', hidden=True, extra_info='not_in_fragment')
self.AtomType: BAND._AtomType = self._AtomType(name='AtomType', comment='Explicit basis set definition for given atom type.', unique=False, header=True)
self.BField: BAND._BField = self._BField(name='BField', comment='The effect of a magnetic filed can be approximated by the following potential: mu * sigma_i * B, where mu is the Bohr magneton, sigma_i are the Pauli matrices and B is the magnetic field')
self.BZPath: BAND._BZPath = self._BZPath(name='BZPath', comment='Definition of the user-defined path in the Brillouin zone for band structure plotting.', extra_info='not_in_fragment')
self.BandStructure: BAND._BandStructure = self._BandStructure(name='BandStructure', comment='Options for the calculation of the band structure.', extra_info='not_in_fragment')
self.Basis: BAND._Basis = self._Basis(name='Basis', comment='Definition of the basis set')
self.BasisMisc: BAND._BasisMisc = self._BasisMisc(name='BasisMisc', comment='Miscellaneous options related to basis', hidden=True)
self.BeckeGrid: BAND._BeckeGrid = self._BeckeGrid(name='BeckeGrid', comment='Options for the numerical integration grid, which is a refined version of the fuzzy cells integration scheme developed by Becke.')
self.Bias: BAND._Bias = self._Bias(name='Bias', comment='Old NEGF. No longer supported', hidden=True, extra_info='not_in_fragment')
self.CDFT: BAND._CDFT = self._CDFT(name='CDFT', comment='Constrained DFT Implementation in Transport. Old NEGF.', hidden=True, extra_info='not_in_fragment')
self.Comment: str | Sequence[str] | FreeBlock = self._Comment(name='Comment', comment='The content of this block will be copied to the output header as a comment to the calculation.')
self.Convergence: BAND._Convergence = self._Convergence(name='Convergence', comment='Options and parameters related to the convergence behavior of the SCF procedure.', extra_info='not_in_fragment')
self.DFTBConfinementPotential: BAND._DFTBConfinementPotential = self._DFTBConfinementPotential(name='DFTBConfinementPotential', comment='Specify the confinement potentials (used for DFTB parametrization)', hidden=True, unique=False, extra_info='not_in_fragment')
self.DIIS: BAND._DIIS = self._DIIS(name='DIIS', comment='Parameters for the DIIS procedure to obtain the SCF solution', extra_info='not_in_fragment')
self.DIRIS: BAND._DIRIS = self._DIRIS(name='DIRIS', comment='Same options as DIIS key, except that this one applies to the DIIS procedure used in the Dirac subprogram, for numerical single atom calculations, which constructs the radial tables for the NAOs.', hidden=True, extra_info='not_in_fragment')
self.DOS: BAND._DOS = self._DOS(name='DOS', comment='Density-Of-States (DOS) options', extra_info='not_in_fragment')
self.DensityPlot: str | Sequence[str] | FreeBlock = self._DensityPlot(name='DensityPlot', comment='Plots of the density. Goes together with the Restart%DensityPlot and Grid keys.', extra_info='not_in_fragment')
self.Dependency: BAND._Dependency = self._Dependency(name='Dependency', comment='Criteria for linear dependency of the basis and fit set', extra_info='not_in_fragment')
self.DiracOptions: BAND._DiracOptions = self._DiracOptions(name='DiracOptions', comment='Options for the atomic Dirac calculations.', hidden=True)
self.Dispersion: BAND._Dispersion = self._Dispersion(name='Dispersion', comment='Technical options for dispersion-corrected functionals.', hidden=True)
self.DosBas: str | Sequence[str] | FreeBlock = self._DosBas(name='DosBas', comment='Used to specify the fragment basis for the DOS.', extra_info='not_in_fragment')
self.EFG: BAND._EFG = self._EFG(name='EFG', comment='The electronic charge density causes an electric field, and the gradient of this field couples with the nuclear quadrupole moment, that some (non-spherical) nuclei have and can be measured by several spectroscopic techniques. The EFG tensor is the second derivative of the Coulomb potential at the nuclei. For each atom it is a 3x3 symmetric and traceless matrix. Diagonalization of this matrix gives three eigenvalues, which are usually ordered by their decreasing absolute size and denoted as V_{xx}, V_{yy}, V_{zz}. The result is summarized by the largest eigenvalue and the asymmetry parameter.', extra_info='not_in_fragment')
self.ESR: BAND._ESR = self._ESR(name='ESR', comment="Zeeman g-tensor. The Zeeman g-tensor is implemented using two-component approach of Van Lenthe and co-workers in which the g-tensor is computed from a pair of spinors related to each other by time-reversal symmetry. Note: the following options are necessary for ESR: 'Relativistic zora spin' and 'Kspace 1'", extra_info='not_in_fragment')
self.EffectiveMass: BAND._EffectiveMass = self._EffectiveMass(name='EffectiveMass', comment='In a semi-conductor, the mobility of electrons and holes is related to the curvature of the bands at the top of the valence band and the bottom of the conduction band.\n\nWith the effective mass option, this curvature is obtained by numerical differentiation.\n\nThe estimation is done with the specified step size, and twice the specified step size, and both results are printed to give a hint on the accuracy. The easiest way to use this key is to enabled it without specifying any extra options.', extra_info='not_in_fragment')
self.ElectronHole: BAND._ElectronHole = self._ElectronHole(name='ElectronHole', comment='Allows one to specify an occupied band which shall be depopulated, where the electrons are then moved to the Fermi level. For a spin-restricted calculation 2 electrons are shifted and for a spin-unrestricted calculation only one electron is shifted.', extra_info='not_in_fragment')
self.EmbeddingPotential: BAND._EmbeddingPotential = self._EmbeddingPotential(name='EmbeddingPotential', comment='An external potential can be read in and will be added to the effective Kohn-Sham potential. It has to be on the becke grid', extra_info='not_in_fragment')
self.Excitations: BAND._Excitations = self._Excitations(name='Excitations', comment='Excitation energies: UV/Vis', extra_info='not_in_fragment')
self.Fermi: BAND._Fermi = self._Fermi(name='Fermi', comment='Technical parameter used in determining the Fermi energy, which is carried out at each cycle of the SCF procedure.', extra_info='not_in_fragment')
self.FermiSurface: BAND._FermiSurface = self._FermiSurface(name='FermiSurface', comment='Calculation of the Fermi surface for metals', extra_info='not_in_fragment')
self.FitMethod: BAND._FitMethod = self._FitMethod(name='FitMethod', comment='Undocumented', hidden=True)
self.FracOp: BAND._FracOp = self._FracOp(name='FracOp', comment='Parameters from input for fractional occupations', hidden=True, extra_info='not_in_fragment')
self.FragOccupations: str | Sequence[str] | FreeBlock = self._FragOccupations(name='FragOccupations', comment='Undocumented', hidden=True, extra_info='not_in_fragment')
self.Fragment: BAND._Fragment = self._Fragment(name='Fragment', comment='Defines a fragment. You can define several fragments for a calculation.', unique=False, extra_info='not_in_fragment')
self.FragmentEnergyTerms: str | Sequence[str] | FreeBlock = self._FragmentEnergyTerms(name='FragmentEnergyTerms', comment='Undocumented', hidden=True, extra_info='not_in_fragment')
self.FuzzyPotential: str | Sequence[str] | FreeBlock = self._FuzzyPotential(name='FuzzyPotential', comment='Atomic (fuzzy cell) based, external, electric potential. See example.')
self.FuzzyUnitCellGrid: BAND._FuzzyUnitCellGrid = self._FuzzyUnitCellGrid(name='FuzzyUnitCellGrid', comment='Undocumented.')
self.GMix: BAND._GMix = self._GMix(name='GMix', comment='Undocumented. Old NEGF.', hidden=True, extra_info='not_in_fragment')
self.GW: BAND._GW = self._GW(name='GW', comment='Perform a GW calculation. G0W0 is the default for GW%SelfConsistency.', extra_info='not_in_fragment')
self.Gate: BAND._Gate = self._Gate(name='Gate', comment='Undocumented. Old NEGF.', hidden=True, extra_info='not_in_fragment')
self.Gradients: BAND._Gradients = self._Gradients(name='Gradients', comment='Options for nuclear gradients and strain derivatives calculations.', hidden=True, extra_info='not_in_fragment')
self.Grid: BAND._Grid = self._Grid(name='Grid', comment='Options for the regular grid used for plotting (e.g. density plot). Used ICW the restart option.', extra_info='not_in_fragment')
self.GridBasedAIM: BAND._GridBasedAIM = self._GridBasedAIM(name='GridBasedAIM', comment='Invoke the ultra fast grid based Bader analysis.', extra_info='not_in_fragment')
self.GrossPopulations: str | Sequence[str] | FreeBlock = self._GrossPopulations(name='GrossPopulations', comment='Partial DOS (pDOS) are generated for the gross populations listed under this key. See example.', extra_info='not_in_fragment')
self.HardConfinement: BAND._HardConfinement = self._HardConfinement(name='HardConfinement', comment='Obsolete basis functions confinement method. Use SoftConfinement instead.', hidden=True, unique=False)
self.HubbardU: BAND._HubbardU = self._HubbardU(name='HubbardU', comment='Options for Hubbard-corrected DFT calculations.')
self.Integration: BAND._Integration = self._Integration(name='Integration', comment='Options for the Voronoi numerical integration scheme. Deprecated. Use BeckeGrid instead.')
self.KSpace: BAND._KSpace = self._KSpace(name='KSpace', comment='Options for the k-space integration (i.e. the grid used to sample the Brillouin zone)')
self.LDOS: BAND._LDOS = self._LDOS(name='LDOS', comment='Local Density-Of-States information. This can be used to generate STM images in the Tersoff-Hamann approximation (see https://doi.org/10.1103/PhysRevB.31.805)', extra_info='not_in_fragment')
self.MBPT: BAND._MBPT = self._MBPT(name='MBPT', comment='Technical aspects of the MP2 algorithm.', extra_info='not_in_fragment')
self.MolecularNMR: BAND._MolecularNMR = self._MolecularNMR(name='MolecularNMR', comment='Options for the calculations of the NMR shielding tensor for molecules, excluding periodic systems. Implements the Schreckenbach method like ADF.', extra_info='not_in_fragment')
self.MultiSecantConfig: BAND._MultiSecantConfig = self._MultiSecantConfig(name='MultiSecantConfig', comment='Parameters for the Multi-secant SCF convergence method.', extra_info='not_in_fragment')
self.NEGF: BAND._NEGF = self._NEGF(name='NEGF', comment='Options for the NEGF (non-equilibrium green function) transport calculation.', extra_info='not_in_fragment')
self.NMR: BAND._NMR = self._NMR(name='NMR', comment='Options for the calculations of the NMR shielding tensor.', extra_info='not_in_fragment')
self.NOCVOrbitalPlot: str | Sequence[str] | FreeBlock = self._NOCVOrbitalPlot(name='NOCVOrbitalPlot', comment='Goes together with the Restart%NOCVOrbitalPlot and Grid keys. See example.', extra_info='not_in_fragment')
self.NOCVdRhoPlot: str | Sequence[str] | FreeBlock = self._NOCVdRhoPlot(name='NOCVdRhoPlot', comment='Goes together with the Restart%NOCVdRhoPlot and Grid keys. See example.', extra_info='not_in_fragment')
self.NOPROrbitalPlot: str | Sequence[str] | FreeBlock = self._NOPROrbitalPlot(name='NOPROrbitalPlot', comment='Undocumented.', hidden=True, extra_info='not_in_fragment')
self.NOPRdRhoPlot: str | Sequence[str] | FreeBlock = self._NOPRdRhoPlot(name='NOPRdRhoPlot', comment='Undocumented.', hidden=True, extra_info='not_in_fragment')
self.NeutralizingDensityDetails: BAND._NeutralizingDensityDetails = self._NeutralizingDensityDetails(name='NeutralizingDensityDetails')
self.NewResponse: BAND._NewResponse = self._NewResponse(name='NewResponse', comment='The TD-CDFT calculation to obtain the dielectric function is computed when this block is present in the input. Several important settings can be defined here.', extra_info='not_in_fragment')
self.NewResponseKSpace: BAND._NewResponseKSpace = self._NewResponseKSpace(name='NewResponseKSpace', comment='Modify the details for the integration weights evaluation in reciprocal space for each single-particle transition. Only influencing the NewResponse code.', extra_info='not_in_fragment')
self.NewResponseSCF: BAND._NewResponseSCF = self._NewResponseSCF(name='NewResponseSCF', comment='Details for the linear-response self-consistent optimization cycle. Only influencing the NewResponse code.', extra_info='not_in_fragment')
self.NonCollinearMagnetizationModule: BAND._NonCollinearMagnetizationModule = self._NonCollinearMagnetizationModule(name='NonCollinearMagnetizationModule', comment='Undocumented.', hidden=True, extra_info='not_in_fragment')
self.Occupations: str | Sequence[str] | FreeBlock = self._Occupations(name='Occupations', comment='Allows one to input specific occupations numbers. Applies only for calculations that use only one k-point (i.e. pseudo-molecule calculations). See example.', extra_info='not_in_fragment')
self.OldResponse: BAND._OldResponse = self._OldResponse(name='OldResponse', comment='Options for the old TD-CDFT implementation.', extra_info='not_in_fragment')
self.OrbitalLabels: str | Sequence[str] | FreeBlock = self._OrbitalLabels(name='OrbitalLabels', comment='Undocumented.', hidden=True, extra_info='not_in_fragment')
self.OrbitalPlot: str | Sequence[str] | FreeBlock = self._OrbitalPlot(name='OrbitalPlot', comment='Goes together with the Restart%OrbitalPlot and Grid keys. See Example.', extra_info='not_in_fragment')
self.Output: BAND._Output = self._Output(name='Output', comment='Control the output.', extra_info='not_in_fragment')
self.OverlapPopulations: str | Sequence[str] | FreeBlock = self._OverlapPopulations(name='OverlapPopulations', comment='Overlap population weighted DOS (OPWDOS), also known as the crystal orbital overlap population (COOP).', extra_info='not_in_fragment')
self.PEDANOCV: BAND._PEDANOCV = self._PEDANOCV(name='PEDANOCV', comment='Options for the decomposition of the orbital relaxation (pEDA).', extra_info='not_in_fragment')
self.PEDANOPR: BAND._PEDANOPR = self._PEDANOPR(name='PEDANOPR', comment='Undocumented.', hidden=True, extra_info='not_in_fragment')
self.PeriodicRIHartreeFock: BAND._PeriodicRIHartreeFock = self._PeriodicRIHartreeFock(name='PeriodicRIHartreeFock', comment='Technical options for periodic Hartree Fock.', extra_info='not_in_fragment')
self.PeriodicSolvation: BAND._PeriodicSolvation = self._PeriodicSolvation(name='PeriodicSolvation', comment='Additional options for simulations of periodic structures with solvation.')
self.Programmer: BAND._Programmer = self._Programmer(name='Programmer', comment='Miscellaneous technical options.', extra_info='not_in_fragment')
self.PropertiesAtNuclei: str | Sequence[str] | FreeBlock = self._PropertiesAtNuclei(name='PropertiesAtNuclei', comment='A number of properties can be obtained near the nucleus. An average is taken over a tiny sphere around the nucleus. The following properties are available: vxc[rho(fit)], rho(fit), rho(scf), v(coulomb/scf), rho(deformation/fit), rho(deformation/scf).', extra_info='not_in_fragment')
self.RIHartreeFock: BAND._RIHartreeFock = self._RIHartreeFock(name='RIHartreeFock')
self.RadialDefaults: BAND._RadialDefaults = self._RadialDefaults(name='RadialDefaults', comment='Options for the logarithmic radial grid of the basis functions used in the subprogram Dirac')
self.Relativity: BAND._Relativity = self._Relativity(name='Relativity', comment='Options for relativistic effects.')
self.ResponseInducedDensityPlot: str | Sequence[str] | FreeBlock = self._ResponseInducedDensityPlot(name='ResponseInducedDensityPlot', comment='Goes together with Restart%ResponseInducedDensityPlot and Grid.', extra_info='not_in_fragment')
self.Restart: BAND._Restart = self._Restart(name='Restart', comment='Tells the program that it should restart with the restart file, and what to restart.', extra_info='not_in_fragment')
self.SCF: BAND._SCF = self._SCF(name='SCF', comment='Controls technical SCF parameters.', extra_info='not_in_fragment')
self.Screening: BAND._Screening = self._Screening(name='Screening', comment='For the periodic solvation potential and for the old (not default anymore) fitting method, BAND performs lattice summations which are in practice truncated. The precision of the lattice summations is controlled by the options in this block.')
self.SlakoConfig: BAND._SlakoConfig = self._SlakoConfig(name='SlakoConfig', comment='Undocumented.', hidden=True)
self.SoftConfinement: BAND._SoftConfinement = self._SoftConfinement(name='SoftConfinement', comment="In order to make the basis functions more compact, the radial part of the basis functions is multiplied by a Fermi-Dirac (FD) function (this 'confinement' is done for efficiency and numerical stability reasons). A FD function goes from one to zero, controlled by two parameters. It has a value 0.5 at Radius, and the decay width is Delta.")
self.Solvation: BAND._Solvation = self._Solvation(name='Solvation', comment='Options for the COSMO (Conductor like Screening Model) solvation model.', extra_info='not_in_fragment')
self.SolvationSM12: BAND._SolvationSM12 = self._SolvationSM12(name='SolvationSM12', comment='Options for Solvation Model 12 (SM12).', extra_info='not_in_fragment')
self.StrainDerivatives: BAND._StrainDerivatives = self._StrainDerivatives(name='StrainDerivatives', comment='Undocumented.', extra_info='not_in_fragment')
self.Tails: BAND._Tails = self._Tails(name='Tails', comment='Ignore function tails.')
self.TechnicalCOSMO: BAND._TechnicalCOSMO = self._TechnicalCOSMO(name='TechnicalCOSMO', comment='Some options to develop cosmo for charged periodic systems', hidden=True)
self.TestParameters: BAND._TestParameters = self._TestParameters(name='TestParameters', comment='Undocumented.', hidden=True, extra_info='not_in_fragment')
self.Transport: BAND._Transport = self._Transport(name='Transport', comment='Old NEGF. No longer supported', hidden=True, extra_info='not_in_fragment')
self.XC: BAND._XC = self._XC(name='XC', comment='Exchange Correlation functionals')
self.ZlmFit: BAND._ZlmFit = self._ZlmFit(name='ZlmFit', comment="Options for the density fitting scheme 'ZlmFit'.")
