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 ADF(EngineBlock):
r"""
:ivar A1Fit: STO-Fit keyword: distance between atoms, in Angstrom. The symmetric fit approximation is applied only for atoms farther apart.
:vartype A1Fit: float | FloatKey
:ivar AOMat2File: Write PMatrix, Fock matrix, and overlap matrix on AO basis to file for future analysis purposes
:vartype AOMat2File: BoolType | BoolKey
:ivar AORCOnly: Debug option AOResponse.
:vartype AORCOnly: BoolType | BoolKey
:ivar AORXCOnly: Debug option AOResponse.
:vartype AORXCOnly: BoolType | BoolKey
:ivar AORun: Expert option not to write orbitals to file for TDDFT.
:vartype AORun: BoolType | BoolKey
:ivar AccurateGradients: Print the nuclear gradients with more digits than usual.
:vartype AccurateGradients: BoolType | BoolKey
:ivar AddDiffuseFit: STO-Fit keyword: One can get more diffuse fit functions by setting this to True.
:vartype AddDiffuseFit: BoolType | BoolKey
:ivar AllDipMat: Print all dipole matrix elements between occupied and virtual Kohn-Sham orbitals.
:vartype AllDipMat: BoolType | BoolKey
:ivar AllPoints: ADF makes use of symmetry in the numerical integrations. Points are generated for the irreducible wedge, a symmetry unique sub region of space. Optionally the symmetry equivalent points are also used. This is achieved by setting this key to True.
:vartype AllPoints: BoolType | BoolKey
:ivar AllWaals: Expert to write all van der Waals tensors in Response..
:vartype AllWaals: BoolType | BoolKey
:ivar Allow: Controlled aborts can in some cases be overruled. Of course, the checks have been inserted for good reasons and one should realize that ignoring them probably produces incorrect results or may lead to a program-crash.
:vartype Allow: str | StringKey
:ivar AltLinVXC:
:vartype AltLinVXC: BoolType | BoolKey
:ivar AltOrthon: Expert option for alternative orthogonalization.
:vartype AltOrthon: BoolType | BoolKey
:ivar AltRhof: Expert option for Response.
:vartype AltRhof: BoolType | BoolKey
:ivar AtomicChargesTypeForAMS: Type of atomic charges to be used by AMS.
Note that some of these atomic charges are computed and printed by default in ADF.
Hirshfeld charges are available only for default atomic fragments.
:vartype AtomicChargesTypeForAMS: Literal["Mulliken", "Hirshfeld", "CM5", "Voronoi", "MDC-M", "MDC-D", "MDC-Q", "QTAIM"]
:ivar Balance: Measure the actual speed of the nodes in the parallel machine
:vartype Balance: BoolType | BoolKey
:ivar BasValZero: Debug option
:vartype BasValZero: BoolType | BoolKey
:ivar Blapt: Debug option for calculating post-SCF functional.
:vartype Blapt: BoolType | BoolKey
:ivar BoysOld: Option for localizing orbitals using old scheme.
:vartype BoysOld: BoolType | BoolKey
:ivar C2Coef: Print C2Coef to output
:vartype C2Coef: BoolType | BoolKey
:ivar CM5: Calculate the charge model 5 (CM5) analysis.
:vartype CM5: BoolType | BoolKey
:ivar CalcOverlapOnly: Calculate overlaps of primitive basis and stops after computing them.
:vartype CalcOverlapOnly: BoolType | BoolKey
:ivar CalcTotalEnergy: Whether or not to calculate the total energy.
:vartype CalcTotalEnergy: BoolType | BoolKey
:ivar ChkDisFal: Debug option not to ise distance effects, probably not working correct anymore.
:vartype ChkDisFal: BoolType | BoolKey
:ivar ColTDDFT: Debug option to see the effect of a collinear kernel TDDFT in case of spin-orbit coupling
:vartype ColTDDFT: BoolType | BoolKey
:ivar CommTiming: Only perform parallel timing test on the gather, broadcast and combine routines.
:vartype CommTiming: BoolType | BoolKey
:ivar ComplexAcl: Expert key for AOresponse spin-orbit coupled.
:vartype ComplexAcl: BoolType | BoolKey
:ivar CoreTables: Undocumented and unused option for using CoreTables.
:vartype CoreTables: BoolType | BoolKey
:ivar CoulombFit: Undocumented and unused option for using old HF exchange integrals also for Coulomb.
:vartype CoulombFit: BoolType | BoolKey
:ivar Create: Keywords for create run. {Atomtype Datafile}
:vartype Create: str | StringKey
:ivar DRho241: Debug key for Response.
:vartype DRho241: BoolType | BoolKey
:ivar Debug: The amount of printed output is regulated with the keys Print, NoPrint, EPrint and Debug.
:vartype Debug: str | StringKey
:ivar DeltaEpStrip: TDDFT Excitations expert key.
:vartype DeltaEpStrip: BoolType | BoolKey
:ivar DensPrep: Undocumented option for FDE for sum-of-fragments density in SCF.
:vartype DensPrep: BoolType | BoolKey
:ivar Diffuse: Adding diffuse integration points in case of the old Voronoi numerical integration grid.
:vartype Diffuse: BoolType | BoolKey
:ivar DipoleLength: Use dipole-length elements for perturbing (external) integrals in CURRENT response
:vartype DipoleLength: BoolType | BoolKey
:ivar DipoleResponse:
:vartype DipoleResponse: BoolType | BoolKey
:ivar DumpBasisOnly: Dump basis and fit set files use for each atom.
:vartype DumpBasisOnly: BoolType | BoolKey
:ivar EGOXAlpha: Debug key for excited GO in excitations.
:vartype EGOXAlpha: BoolType | BoolKey
:ivar EnergyTest: Expert key for total energy.
:vartype EnergyTest: BoolType | BoolKey
:ivar ExactDensity: Use the exact density (as opposed to the fitted density) for the computation of the exchange-correlation potential
:vartype ExactDensity: BoolType | BoolKey
:ivar ExtendedPopan: Calculate the Mayer bond orders and Mulliken atom-atom populations per l-value
:vartype ExtendedPopan: BoolType | BoolKey
:ivar FitAlfa: Debug key for Response.
:vartype FitAlfa: BoolType | BoolKey
:ivar FitExcit:
:vartype FitExcit: BoolType | BoolKey
:ivar FitFile: Only to be used in Create runs for STOFIT. Specify a file on which the fit functions are specified.
:vartype FitFile: str | StringKey
:ivar Fitelstat: In energy decomposition analysis use fitted density for electrostatic energy.
:vartype Fitelstat: BoolType | BoolKey
:ivar Fithyppol: Use fitted density in TDDFT for hyperpolarizability calculation.
:vartype Fithyppol: BoolType | BoolKey
:ivar Fitmeta: SCF: use fitted density for post-SCF meta-GGA functionals.
:vartype Fitmeta: BoolType | BoolKey
:ivar Fitsecder: SCF: use fitted density for second derivative density.
:vartype Fitsecder: BoolType | BoolKey
:ivar ForceALDA: In spin-flip TDDFT, the XC kernel can be calculated directly from the XC potential. To use the LDA potential for the XC kernel, which roughly corresponds to the ALDA in ordinary TDDFT, one must specify the key
:vartype ForceALDA: BoolType | BoolKey
:ivar FragMetaGGAToten: By setting this to true the difference in the metahybrid or metagga exchange-correlation energies between the molecule and its fragments will be calculated using the molecular integration grid, which is more accurate than the default, but is much more time consuming.
:vartype FragMetaGGAToten: BoolType | BoolKey
:ivar FullFock: Calculate the full Fock matrix each SCF iteration (instead of the difference with the previous cycle).
:vartype FullFock: BoolType | BoolKey
:ivar FullTotEn:
:vartype FullTotEn: BoolType | BoolKey
:ivar Fuzzy_BO:
:vartype Fuzzy_BO: BoolType | BoolKey
:ivar GZip: GZip the corresponding tape (possibly working only for TAPE21)
:vartype GZip: str | StringKey
:ivar Gradient: Force calculation of gradients of the total energy with respect to the nuclear coordinates, just as in a geometry optimization.
This is useful if you want to perform a single point calculation and get gradients for that specific geometry.
:vartype Gradient: BoolType | BoolKey
:ivar HFAtomsPerPass: Memory usage option for old HF scheme
:vartype HFAtomsPerPass: int | IntKey
:ivar HFDependency: Extra Dependency trick for old Hartree-Fock exchange integrals.
:vartype HFDependency: BoolType | BoolKey
:ivar HFMaxMemory: Memory usage option for old HF scheme
:vartype HFMaxMemory: int | IntKey
:ivar HartreeFock: Compute hybrid meta-GGA energy functionals (if METAGGA key is True)
:vartype HartreeFock: BoolType | BoolKey
:ivar Hilbert: Option for localization of numerical integration points.
:vartype Hilbert: BoolType | BoolKey
:ivar IgnoreOverlap: Expert option. Ignore that atoms are close.
:vartype IgnoreOverlap: BoolType | BoolKey
:ivar ImportEmbPot: File containing an external embedding potential (FDE calculations only)
:vartype ImportEmbPot: str | StringKey
:ivar ImportGrid: FDE option for importing numerical integration grid.
:vartype ImportGrid: str | StringKey
:ivar IntegralsToFile: Write all 4-center integrals to direct access file (DIRAC). or in FCIdump/Serenity format. Default is None
:vartype IntegralsToFile: Literal["None", "FCIdump", "Dirac", "SERENITY"]
:ivar IsotopicShift: Untested
:vartype IsotopicShift: str | StringKey
:ivar KSSpectrum: Old key. TDDFT excitations, calculate single-orbital transitions.
:vartype KSSpectrum: BoolType | BoolKey
:ivar LB4: Debug option for unrestricted spin-orbit coupling.
:vartype LB4: BoolType | BoolKey
:ivar Lap1: Debug option for calculating post-SCF functional.
:vartype Lap1: BoolType | BoolKey
:ivar MBlockSmall: For TDDFT excitations with Davidson: Option to use only 1 extra trial vector at a time.
:vartype MBlockSmall: BoolType | BoolKey
:ivar MOExactDensity: In SCF use exact density for MOs.
:vartype MOExactDensity: BoolType | BoolKey
:ivar MetaGGA:
:vartype MetaGGA: BoolType | BoolKey
:ivar NewDIIS: For old SCF routine: use newDIIS.
:vartype NewDIIS: BoolType | BoolKey
:ivar NoBeckeGrid: If true ADF will use the Voronoi numerical integration grid.
:vartype NoBeckeGrid: BoolType | BoolKey
:ivar NoFDEPot: Expert FDE option.
:vartype NoFDEPot: BoolType | BoolKey
:ivar NoFragDp: Debug option for orthogonalization and dependency.
:vartype NoFragDp: BoolType | BoolKey
:ivar NoGTerm: Debug option in Response.
:vartype NoGTerm: BoolType | BoolKey
:ivar NoPrint: The amount of printed output is regulated with the keys Print, NoPrint, EPrint and Debug.
:vartype NoPrint: str | StringKey
:ivar NoSharedArrays: To disable the use of shared memory.
:vartype NoSharedArrays: BoolType | BoolKey
:ivar NoSymFit: Do not use only an A1 symmetric fit.
:vartype NoSymFit: BoolType | BoolKey
:ivar NoTotEn:
:vartype NoTotEn: BoolType | BoolKey
:ivar NuclearModel: Model for the nuclear charge distribution.
To see effects from your choice you will need to use a basis set with extra steep functions. For example you can find these in the ZORA/TZ2P-J basis directory.
:vartype NuclearModel: Literal["PointCharge", "Gaussian"]
:ivar NumericalQuality: Set the quality of several important technical aspects of an ADF calculation (with the notable exception of the basis set). It sets the quality of: BeckeGrid (numerical integration) and ZlmFit (density fitting). 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 OPop_Analysis:
:vartype OPop_Analysis: str | StringKey
:ivar Occupations: Occupations options
:vartype Occupations: str | StringKey
:ivar OrbitalsCoulombInteraction: Compute the Coulomb interaction energy between the density of two orbitals. After the key, specify the indices of the two orbitals for which you want to compute the Coulomb interaction energy. Can only be used for spin-restricted calculations. Cannot be used in case of Symmetry (use Symmetry NoSym).
:vartype OrbitalsCoulombInteraction: Iterable[int] | IntListKey
:ivar OrthFragPrep: Expert FDE option.
:vartype OrthFragPrep: BoolType | BoolKey
:ivar PartialZORA: Untested and undocumented key to use partial ZORA.
:vartype PartialZORA: str | StringKey
:ivar Print: The amount of printed output is regulated with the keys Print, NoPrint, EPrint and Debug.
:vartype Print: str | StringKey
:ivar ProgConv: Use progressive convergence in SCF, icw LinearScaling%ProgConv not equal 0.
:vartype ProgConv: BoolType | BoolKey
:ivar QTens: Calculate the the Nuclear Electric Quadrupole Hyperfine interaction (Q-tensor, NQCC, NQI), related to the Electric Field Gradient (EFG).
:vartype QTens: BoolType | BoolKey
:ivar RConfine: Used for making confinement potential in order to make DFTB parameters. Obsolete.
:vartype RConfine: Iterable[float] | FloatListKey
:ivar RESPPMATSAVE: Needed for SubResponse (EO) calculations. Hacked by JN. Restored by Pengchong Liu
:vartype RESPPMATSAVE: BoolType | BoolKey
:ivar RESTOCC:
:vartype RESTOCC: BoolType | BoolKey
:ivar RemoveAllFragVirtuals: Remove all virtual fragment orbitals.
:vartype RemoveAllFragVirtuals: BoolType | BoolKey
:ivar RemoveOtherFragVirtuals: Remove all virtual fragment orbitals, except on first fragment.
:vartype RemoveOtherFragVirtuals: BoolType | BoolKey
:ivar ResponseFormalism: Set to RESPONSE or AORESPONSE.
:vartype ResponseFormalism: Literal["Auto", "Response", "AOResponse"]
:ivar SFTDDFT: Calculate spin-flip excitation energies (requires TDA and FORCEALDA keys).
:vartype SFTDDFT: BoolType | BoolKey
:ivar SOMCD: MCD option. Required for a calculation of MCD temperature-dependent C terms. The calculation must be an unrestricted and scalar relativistic ZORA.
:vartype SOMCD: BoolType | BoolKey
:ivar STContrib: For an analysis of spin-orbit coupled excitations in terms of scalar relativistic singlet and triplet excitations. In order to get this analysis one needs to perform a scalar relativistic TDDFT calculation of excitation energies on the closed shell molecule first, and use the resulting adf.rkf as a fragment in the spin-orbit coupled TDDFT calculation of excitation energies, including this keyword STCONTRIB.
:vartype STContrib: BoolType | BoolKey
:ivar STOFit: Computation of the Coulomb potential with the pair fit method.
:vartype STOFit: BoolType | BoolKey
:ivar Save: A sequence of file names separated by blanks or commas. Possible file names are TAPE10, TAPE13, TAPE14.
:vartype Save: str | StringKey
:ivar SharcOverlap:
:vartype SharcOverlap: BoolType | BoolKey
:ivar Skip: Expert key. To restrict which parts of the program are actually executed.
:vartype Skip: str | StringKey
:ivar SpinPolarization: The spin polarization of the system, which is the number of spin-alpha electrons in excess of spin-beta electrons. Specification is only meaningful in a spin-unrestricted calculation. However, specification is not meaningful in an unrestricted Spin-Orbit coupled calculation using the (non-)collinear approximation.
:vartype SpinPolarization: float | FloatKey
:ivar StopAfter:
:vartype StopAfter: str | StringKey
:ivar Symmetry: Use (sub)symmetry with this Schoenflies symbol. Can only be used for molecules. Orientation should be correct for the (sub)symmetry. Coordinates must be symmetric within SymmetryTolerance.
:vartype Symmetry: Literal["AUTO", "NOSYM", "ATOM", "C(LIN)", "D(LIN)", "C(I)", "C(S)", "C(2)", "C(2V)", "C(3V)", "C(4V)", "C(5V)", "C(6V)", "C(7V)", "C(8V)", "C(2H)", "D(2)", "D(3)", "D(4)", "D(5)", "D(6)", "D(7)", "D(8)", "D(2D)", "D(3D)", "D(4D)", "D(5D)", "D(6D)", "D(7D)", "D(8D)", "D(2H)", "D(3H)", "D(4H)", "D(5H)", "D(6H)", "D(7H)", "D(8H)", "O(H)", "T(D)"]
:ivar SymmetryTolerance: Tolerance used to detect symmetry in the system. If symmetry Schoenflies symbol is specified, the coordinates must be symmetric within this tolerance.
:vartype SymmetryTolerance: float | FloatKey
:ivar TDA: Use the Tamm-Dancoff approximation (TDA) (requires the EXCITATIONS block key)
:vartype TDA: BoolType | BoolKey
:ivar TDDFTSO:
:vartype TDDFTSO: BoolType | BoolKey
:ivar TIDegeneracyThreshold: If the orbital energy of the fragment MO is within this threshold with fragment HOMO or LUMO energy, then this fragment MO is included in the calculation of the transfer integrals. Relevant in case there is (near) degeneracy.
:vartype TIDegeneracyThreshold: float | FloatKey
:ivar Title: Title of the calculation.
:vartype Title: str | StringKey
:ivar TotalEnergy: Calculate the total energy.
Normally only the bonding energy with respect to the fragments is calculated.
The total energy will be less accurate then the bonding energy (about two decimal places), and is not compatible with some options.
In most cases the total energy will not be needed.
:vartype TotalEnergy: BoolType | BoolKey
:ivar TransferIntegrals: Calculate the charge transfer integrals, spatial overlap integrals and site energies.
Charge transfer integrals can be used in models that calculate transport properties.
:vartype TransferIntegrals: BoolType | BoolKey
:ivar Unrestricted: By default, a spin-restricted calculation is performed where the spin alpha and spin beta orbitals are spatially the same.
:vartype Unrestricted: BoolType | BoolKey
:ivar UnrestrictedFragments: Use fragments calculated a spin-unrestricted calculation: the spin alpha and spin beta orbitals may be spatially different.
The total spin polarization of your fragments must match the spin polarization of your final molecule.
:vartype UnrestrictedFragments: BoolType | BoolKey
:ivar UsePseudoDiag: Expert option for diagonalization in SCF.
:vartype UsePseudoDiag: BoolType | BoolKey
:ivar UseSPCode: Use Patchkovskii routines for PBE
:vartype UseSPCode: BoolType | BoolKey
:ivar VectorLength: Specify a different batch size for the integration points here (default: 128 on most machines and 2047 on vector machines).
:vartype VectorLength: int | IntKey
:ivar ZExact: Expert option in TDDFT excitations.
:vartype ZExact: BoolType | BoolKey
:ivar ZFS: Calculate the zero-field splitting (ZFS) of an open shell ground state. An unrestricted calculation is required and a spin larger than 1/2, and no no spatial degeneracy. Scalar relativistic ZORA is required.
:vartype ZFS: str | StringKey
:ivar grad_no_fragment_potentials: FDE option.
:vartype grad_no_fragment_potentials: BoolType | BoolKey
:ivar hydrogenbonds: Option for SFO population analysis to print small numbers.
:vartype hydrogenbonds: BoolType | BoolKey
:ivar nocalcs2: Do not calculate expectation value S**2 (spin).
:vartype nocalcs2: BoolType | BoolKey
:ivar nomorton: Debug option for localization of numerical integration points.
:vartype nomorton: BoolType | BoolKey
:ivar nopm5rho: Debug option for response.
:vartype nopm5rho: BoolType | BoolKey
:ivar notstcoe: Option not to test orthonormal basis set.
:vartype notstcoe: BoolType | BoolKey
:ivar nouseactivefrag: Do not use orbital data from active fragment in first cycle SCF.
:vartype nouseactivefrag: BoolType | BoolKey
:ivar novkpot: Debug option for AOResponse.
:vartype novkpot: BoolType | BoolKey
:ivar noxcprint: Do not print XC energy terms.
:vartype noxcprint: BoolType | BoolKey
:ivar oldblockedsmat: Use old way to calculate overlap matrix.
:vartype oldblockedsmat: BoolType | BoolKey
:ivar oldorthon: Use old orthogonalization routine.
:vartype oldorthon: BoolType | BoolKey
:ivar plap3: Debug option for calculating post-SCF functional.
:vartype plap3: BoolType | BoolKey
:ivar prtallten: Debug option for response.
:vartype prtallten: BoolType | BoolKey
:ivar readepsilons: Debug option for TDDFT. Read extra orbitals.
:vartype readepsilons: BoolType | BoolKey
:ivar rhobelpotimport: Key for FDE-MD.
:vartype rhobelpotimport: BoolType | BoolKey
:ivar riskyfast: Debug option to skip some post-SCF properties, like bond energy.
:vartype riskyfast: BoolType | BoolKey
:ivar scaledkinfunctionals: FDE option.
:vartype scaledkinfunctionals: BoolType | BoolKey
:ivar sfotrans: Old key for SFO analysis TDDFT excitations.
:vartype sfotrans: BoolType | BoolKey
:ivar skorthon: Debug option to skip ETALOW.
:vartype skorthon: BoolType | BoolKey
:ivar sozero: Debug option to set spin-orbit matrix to zero.
:vartype sozero: BoolType | BoolKey
:ivar switchcoe: Debug option for orthogonalization.
:vartype switchcoe: BoolType | BoolKey
:ivar symexcit: Debug option for TDDFT excitations.
:vartype symexcit: BoolType | BoolKey
:ivar symresp: Debug option for TDDFT response.
:vartype symresp: BoolType | BoolKey
:ivar testsub1: Debug option excitations and subexci.
:vartype testsub1: BoolType | BoolKey
:ivar totenskip: Debug option to skip toten.
:vartype totenskip: BoolType | BoolKey
:ivar useortp: Use orth density matrices instead of previous density matrix.
:vartype useortp: BoolType | BoolKey
:ivar usesumfragp: Use sum fragment density matrices instead of previous density matrix.
:vartype usesumfragp: BoolType | BoolKey
:ivar xonly: Option for spin-orbit coupled AOresponse.
:vartype xonly: BoolType | BoolKey
:ivar xyonly: Option for spin-orbit coupled AOresponse.
:vartype xyonly: BoolType | BoolKey
:ivar xzonly: Option for spin-orbit coupled AOresponse.
:vartype xzonly: BoolType | BoolKey
:ivar yonly: Option for spin-orbit coupled AOresponse.
:vartype yonly: BoolType | BoolKey
:ivar yzonly: Option for spin-orbit coupled AOresponse.
:vartype yzonly: BoolType | BoolKey
:ivar zonly: Option for spin-orbit coupled AOresponse.
:vartype zonly: BoolType | BoolKey
:ivar AOResponse: If the block key AORESPONSE is used, by default, the polarizability is calculated. Note that if the molecule has symmetry the key ALLPOINTS should be included
:vartype AOResponse: ADF._AOResponse
:ivar AnalyticalFreq: Define options for analytical frequencies.
:vartype AnalyticalFreq: ADF._AnalyticalFreq
:ivar Aromaticity: Calculate aromaticity indicators, i.e. the matrix of localization/delocalization indices (LI-DI), Iring (ring index) and MCI (multi center index) aromaticity indices.
:vartype Aromaticity: ADF._Aromaticity
:ivar Basis: Definition of the basis set
:vartype Basis: ADF._Basis
:ivar BeckeGrid: Options for the numerical integration grid.
:vartype BeckeGrid: ADF._BeckeGrid
:ivar BondOrders: Options for the calculation of bond orders. Note: the calculation of bond orders should be requested via the Properties%BondOrders input option in the AMS driver input.
:vartype BondOrders: ADF._BondOrders
:ivar CDFT: CDFT is a tool for carrying out DFT calculations in the presence of a constraint.
:vartype CDFT: ADF._CDFT
:ivar CVNDFT: The CVNDFT block key regulates the execution of the CV(n)-DFT code, which calculates the singlet or triplet electronic excitations for the closed shell molecules.
:vartype CVNDFT: ADF._CVNDFT
:ivar ConceptualDFT: Conceptual DFT Properties
:vartype ConceptualDFT: ADF._ConceptualDFT
:ivar ConstructPot: Reads a density from a TAPE41 file and constructs numerically the corresponding potential to it
:vartype ConstructPot: ADF._ConstructPot
:ivar CorePotentials: With the key COREPOTENTIALS you specify the core file and (optionally) which sections pertain to the distinct atom types in the molecule.
:vartype CorePotentials: str | Sequence[str] | FreeBlock
:ivar CurrentResponse:
:vartype CurrentResponse: ADF._CurrentResponse
:ivar DIMPAR: In this block, the parameters for the DIM atoms are defined in DIM/QM calculations.
:vartype DIMPAR: str | Sequence[str] | FreeBlock
:ivar DIMQM: Input for DIM/QM
:vartype DIMQM: str | Sequence[str] | FreeBlock
:ivar Dependency:
:vartype Dependency: ADF._Dependency
:ivar EPrint: Print switches that require more specification than just off or on
:vartype EPrint: ADF._EPrint
:ivar ESR:
:vartype ESR: ADF._ESR
:ivar ETSNOCV: Perform ETS-NOCV analysis.
:vartype ETSNOCV: ADF._ETSNOCV
:ivar ElectronTransfer: Block key for charge transfer integrals with FDE.
:vartype ElectronTransfer: ADF._ElectronTransfer
:ivar EnergyFrag:
:vartype EnergyFrag: str | Sequence[str] | FreeBlock
:ivar Excitations: Excitation energies: UV/Vis
:vartype Excitations: ADF._Excitations
:ivar ExcitedEDA: Options for excited energy decomposition (EDA).
:vartype ExcitedEDA: ADF._ExcitedEDA
:ivar ExcitedGO: Excited state geometry optimization
:vartype ExcitedGO: ADF._ExcitedGO
:ivar ExcitonTransfer: Block key for exciton transfer integrals with ROSE or FOCDFT.
:vartype ExcitonTransfer: ADF._ExcitonTransfer
:ivar Externals: Legacy support of the older DRF code.
:vartype Externals: str | Sequence[str] | FreeBlock
:ivar FDE: Frozen Density Embedding options
:vartype FDE: ADF._FDE
:ivar FDEFragments: Definitions of the FDE fragment types.
:vartype FDEFragments: str | Sequence[str] | FreeBlock
:ivar FOCDFT: Localize orbitals on fragments and constrain charge and spin polarization on fragments.
:vartype FOCDFT: ADF._FOCDFT
:ivar Fitnadkin: FDE option.
:vartype Fitnadkin: str | Sequence[str] | FreeBlock
:ivar FragOccupations: Simulation of unrestricted fragments with the key FRAGOCCUPATIONS. Fragments need to be calculated spin-restricted. One can specify occupation numbers as if these fragments are calculated spin-unrestricted. The sum of spin-alpha and spin-beta occupations must, for each fragment orbital in each irrep separately, be equal to the total spin-restricted occupation of that orbital in the fragment.
:vartype FragOccupations: str | Sequence[str] | FreeBlock
:ivar Fragments: Definitions of the fragment type/files: {FragmentName FragmentFile}. In the block header one can specify the directory where the fragment files are located
:vartype Fragments: str | Sequence[str] | FreeBlock
:ivar GPU: Set GPU options
:vartype GPU: ADF._GPU
:ivar GW: Perform a GW calculation. G0W0 is the default for GW%SelfConsistency.
:vartype GW: ADF._GW
:ivar IQA: Total energy decomposition based on the interacting quantum atoms (IQA) approach and using QTAIM real-space partition.
:vartype IQA: ADF._IQA
:ivar Integration: Options for the Voronoi numerical integration scheme
:vartype Integration: ADF._Integration
:ivar IrrepOccupations: Explicit occupation numbers per irrep
:vartype IrrepOccupations: str | Sequence[str] | FreeBlock
:ivar LinearScaling:
:vartype LinearScaling: ADF._LinearScaling
:ivar LocOrb: The computation of localized orbitals is controlled with this block-type key
:vartype LocOrb: str | Sequence[str] | FreeBlock
:ivar MBPT: Technical aspects of the MP2 algorithm.
:vartype MBPT: ADF._MBPT
:ivar MDC: Options for Multipole Derived Charges (MDC)
:vartype MDC: ADF._MDC
:ivar ModifyExcitation:
:vartype ModifyExcitation: ADF._ModifyExcitation
:ivar ModifyStartPotential: Modify the starting spin-dependent potential for unrestricted calculations.
:vartype ModifyStartPotential: str | Sequence[str] | FreeBlock
:ivar Nanoparticle: To include the presence of a nanoparticle near the system
:vartype Nanoparticle: ADF._Nanoparticle
:ivar PertLoc: Perturbed localized molecular orbitals, correct to first order in an applied field, can be calculated in case of AORESPONSE. Can be used if the applied field changes the density in first order.
:vartype PertLoc: ADF._PertLoc
:ivar PolTDDFT: POLTDDFT is a fast algorithm to solve the TDDFT equations in the space of the density fitting auxiliary basis set. The (real and imaginary part of the) diagonal of the polarizability tensor and rotatory strengths will be calculated, which can be used to calculate the photoabsorption and circular dichroism (CD) spectra.
:vartype PolTDDFT: ADF._PolTDDFT
:ivar QMFQ: Block input key for QM/FQ(FMu).
:vartype QMFQ: ADF._QMFQ
:ivar QTAIM: This block is used to request a topological analysis of the gradient field of the electron density, also known as the Bader's analysis. If this block is specified without any sub-key, only local properties are calculated.
:vartype QTAIM: ADF._QTAIM
:ivar RIHartreeFock:
:vartype RIHartreeFock: ADF._RIHartreeFock
:ivar RISM: 3D-RISM-related input keys.
:vartype RISM: str | Sequence[str] | FreeBlock
:ivar ROSE: Options for orbital localization
:vartype ROSE: ADF._ROSE
:ivar RadialCoreGrid: For each atom the charge densities and the coulomb potentials of frozen core and valence electrons are computed in a radial grid. The radial grid consists of a sequence of r-values, defined by a smallest value, a constant multiplication factor to obtain each successive r-value, and the total number of points. Equivalently it can be characterized by the smallest r-value, the largest r-value, and the number of points; from these data the program computes then the constant multiplication factor.
:vartype RadialCoreGrid: ADF._RadialCoreGrid
:ivar Relativity: Options for relativistic effects.
:vartype Relativity: ADF._Relativity
:ivar RemoveFragOrbitals: Block key to remove selected virtual fragment orbitals.
:vartype RemoveFragOrbitals: str | Sequence[str] | FreeBlock
:ivar Response: The calculation of frequency-dependent (hyper)polarizabilities and related properties (Raman, ORD)
:vartype Response: ADF._Response
:ivar Restart: Options for restarts
:vartype Restart: ADF._Restart
:ivar SCF: Control aspects of the Self Consistent Field procedure
:vartype SCF: ADF._SCF
:ivar SCRF: SCRF is no longer supported. Use AMS2023 or earlier.
:vartype SCRF: str | Sequence[str] | FreeBlock
:ivar SOPert: Key for perturbative inclusion of spin-orbit coupling.
:vartype SOPert: ADF._SOPert
:ivar SelectExcitation:
:vartype SelectExcitation: ADF._SelectExcitation
:ivar SlaterDeterminants: The calculation of the one-determinant states based on the AOC reference state is controlled with this key.
:vartype SlaterDeterminants: str | Sequence[str] | FreeBlock
:ivar Solvation:
:vartype Solvation: ADF._Solvation
:ivar SpinOrbitMagnetization: Starting artificial spin-orbit magnetization at first SCF cycle
:vartype SpinOrbitMagnetization: ADF._SpinOrbitMagnetization
:ivar SubExci: Subsystem TDDFT (FDE)
:vartype SubExci: ADF._SubExci
:ivar SubResponse: Untested and undocumented
:vartype SubResponse: str | Sequence[str] | FreeBlock
:ivar Tails: Obsolete option for linear scaling and distance effects. We recommend using the LinearScaling key instead.
:vartype Tails: ADF._Tails
:ivar VSCRF: VSCRF is no longer supported. Use AMS2023 or earlier.
:vartype VSCRF: str | Sequence[str] | FreeBlock
:ivar XC: Definition of the XC.
:vartype XC: ADF._XC
:ivar XES: X-ray emission spectroscopy
:vartype XES: ADF._XES
:ivar ZlmFit: Options for the density fitting scheme 'ZlmFit'.
:vartype ZlmFit: ADF._ZlmFit
"""
[docs] class _AOResponse(FixedBlock):
r"""
If the block key AORESPONSE is used, by default, the polarizability is calculated. Note that if the molecule has symmetry the key ALLPOINTS should be included
:ivar 2ANTISYM:
:vartype 2ANTISYM: BoolType | BoolKey
:ivar ALDA: Use ALDA only
:vartype ALDA: BoolType | BoolKey
:ivar Alpha: Calculate linear response
:vartype Alpha: BoolType | BoolKey
:ivar Beta: Will use 2n+1 rule to calculate beta.
:vartype Beta: BoolType | BoolKey
:ivar CALCTRANSFORMPROP: Transformation Properties of Polarizabilities
:vartype CALCTRANSFORMPROP: str | StringKey
:ivar CHANGESIGN:
:vartype CHANGESIGN: BoolType | BoolKey
:ivar Components: Limit the tensor components to the specified ones. Using this option may save the computation time. Options: XX, XY, XZ, YX, YY, YZ, ZX, ZY, ZZ
:vartype Components: str | StringKey
:ivar Cubic: Calculate cubic response
:vartype Cubic: BoolType | BoolKey
:ivar Damp: Specify damping for non-acceleration iteration
:vartype Damp: float | FloatKey
:ivar Debug: Debug level for AOResponse.
:vartype Debug: int | IntKey
:ivar DoNothing: Do nothing.
:vartype DoNothing: BoolType | BoolKey
:ivar EFIOR:
:vartype EFIOR: BoolType | BoolKey
:ivar EFISHG:
:vartype EFISHG: BoolType | BoolKey
:ivar EFPLOT:
:vartype EFPLOT: BoolType | BoolKey
:ivar EL_DIPOLE_EL_DIPOLE:
:vartype EL_DIPOLE_EL_DIPOLE: str | StringKey
:ivar EL_DIPOLE_EL_OCTUPOLE:
:vartype EL_DIPOLE_EL_OCTUPOLE: str | StringKey
:ivar EL_DIPOLE_EL_QUADRUPOLE:
:vartype EL_DIPOLE_EL_QUADRUPOLE: str | StringKey
:ivar EL_DIPOLE_MAG_DIPOLE:
:vartype EL_DIPOLE_MAG_DIPOLE: str | StringKey
:ivar EL_DIPOLE_MAG_QUADRUPOLE:
:vartype EL_DIPOLE_MAG_QUADRUPOLE: str | StringKey
:ivar EL_QUADRUPOLE_EL_QUADRUPOLE:
:vartype EL_QUADRUPOLE_EL_QUADRUPOLE: str | StringKey
:ivar EL_QUADRUPOLE_MAG_DIPOLE:
:vartype EL_QUADRUPOLE_MAG_DIPOLE: str | StringKey
:ivar EOPE:
:vartype EOPE: BoolType | BoolKey
:ivar FitAODeriv: Use FITAODERIV for Coulomb potential
:vartype FitAODeriv: BoolType | BoolKey
:ivar Frequencies: List of frequencies of incident light, the perturbing field, at which the time-dependent properties will be calculated.
:vartype Frequencies: Iterable[float] | FloatListKey
:ivar GIAO: Use gauge-included atomic orbitals
:vartype GIAO: BoolType | BoolKey
:ivar Gamma: Will use 2n+1 rule to calculate gamma.
:vartype Gamma: BoolType | BoolKey
:ivar HirshPol: Hirshfeld Polarizability of fragments
:vartype HirshPol: BoolType | BoolKey
:ivar IDRI:
:vartype IDRI: BoolType | BoolKey
:ivar LifeTime: Specify the resonance peak width (damping) in Hartree units. Typically the lifetime of the excited states is approximated with a common phenomenological damping parameter. Values are best obtained by fitting absorption data for the molecule, however, the values do not vary a lot between similar molecules, so it is not hard to estimate values. A value of 0.004 Hartree was used in Ref. [266].
:vartype LifeTime: float | FloatKey
:ivar MAG_DIPOLE_MAG_DIPOLE:
:vartype MAG_DIPOLE_MAG_DIPOLE: str | StringKey
:ivar MagOptRot: Calculate magneto-optical rotation
:vartype MagOptRot: BoolType | BoolKey
:ivar MagneticPert: Use magnetic field as a perturbation
:vartype MagneticPert: BoolType | BoolKey
:ivar NBO: Perform NBO analysis
:vartype NBO: BoolType | BoolKey
:ivar NoCore: if NOCORE is set we skip the core potential in diamagnetic term and/or in the unperturbed density of the CPKS solvers
:vartype NoCore: BoolType | BoolKey
:ivar OCCOCC: occ-occ block response (not GIAO) - Experimental
:vartype OCCOCC: BoolType | BoolKey
:ivar OKE:
:vartype OKE: BoolType | BoolKey
:ivar ONLYANTISYM:
:vartype ONLYANTISYM: BoolType | BoolKey
:ivar ONLYSYM:
:vartype ONLYSYM: BoolType | BoolKey
:ivar OPTICALR:
:vartype OPTICALR: BoolType | BoolKey
:ivar OnlyPot: Calculation only potential for debugging purposes
:vartype OnlyPot: BoolType | BoolKey
:ivar OpticalRotation: Calculate optical rotation
:vartype OpticalRotation: BoolType | BoolKey
:ivar PBE0LDA:
:vartype PBE0LDA: BoolType | BoolKey
:ivar QuadBeta: Quadrupole operators with beta tensor
:vartype QuadBeta: BoolType | BoolKey
:ivar QuadPert: Calculate quadrupole-quadrupole polarizability
:vartype QuadPert: BoolType | BoolKey
:ivar Quadratic: Calculate quadratic response
:vartype Quadratic: BoolType | BoolKey
:ivar Quadrupole: Calculate dipole-quadrupole polarizability
:vartype Quadrupole: BoolType | BoolKey
:ivar REVPBE:
:vartype REVPBE: BoolType | BoolKey
:ivar Raman:
:vartype Raman: BoolType | BoolKey
:ivar SCF: Specify CPKS parameters such as the degree of convergence and the maximum number of iterations: NOCYC - disable self-consistence altogetherNOACCEL - disable convergence accelerationCONV - convergence criterion for CPKS. The default value is 10-6 . The value is relative to the uncoupled result (i.e. to the value without self-consistence).ITER - maximum number of CPKS iterations, 50 by default.Specifying ITER=0 has the same effect as specifying NOCYC.
:vartype SCF: str | StringKey
:ivar SHG:
:vartype SHG: BoolType | BoolKey
:ivar STATIC:
:vartype STATIC: BoolType | BoolKey
:ivar THG:
:vartype THG: BoolType | BoolKey
:ivar TPA:
:vartype TPA: BoolType | BoolKey
:ivar Traceless: Traceless quadrupole tensors
:vartype Traceless: BoolType | BoolKey
:ivar VROA: Calculate Vibrational Raman Optical Activity.
:vartype VROA: BoolType | BoolKey
:ivar VelocityOrd: Use VelocityOrd without GIAOs
:vartype VelocityOrd: BoolType | BoolKey
:ivar XAlpha: Xalpha potential
:vartype XAlpha: BoolType | BoolKey
:ivar EFG: Perform a Mulliken type analysis of the EFG principal components, and an analysis in terms of canonical MOs.
:vartype EFG: ADF._AOResponse._EFG
"""
[docs] class _EFG(FixedBlock):
r"""
Perform a Mulliken type analysis of the EFG principal components, and an analysis in terms of canonical MOs.
:ivar Atom: The number of the nucleus at which the EFG is to be analyzed (ADF input ordering).
:vartype Atom: int | IntKey
:ivar Dump: Dump EFG data to file.
:vartype Dump: BoolType | BoolKey
:ivar NBO: Perform an NBO/NLMO analysis of the EFG. Requires a series of calculations. See documentation.
:vartype NBO: BoolType | BoolKey
:ivar Nuc: The number of the nucleus at which the EFG is to be analyzed (ADF internal atom ordering).
:vartype Nuc: int | IntKey
:ivar Thresh: The threshold for printing the EFG-NBO contributions. The default is 0.05, which means that only orbitals with absolute value contribution larger than 5% of the total EFG are printed. To increase the number of contributions printed, specify a smaller threshold.
:vartype Thresh: float | FloatKey
"""
def __post_init__(self):
self.Atom: int | IntKey = IntKey(name='Atom', comment='The number of the nucleus at which the EFG is to be analyzed (ADF input ordering).', default=1)
self.Dump: BoolType | BoolKey = BoolKey(name='Dump', comment='Dump EFG data to file.', hidden=True, default=False)
self.NBO: BoolType | BoolKey = BoolKey(name='NBO', comment='Perform an NBO/NLMO analysis of the EFG. Requires a series of calculations. See documentation.', default=False)
self.Nuc: int | IntKey = IntKey(name='Nuc', comment='The number of the nucleus at which the EFG is to be analyzed (ADF internal atom ordering).', default=1)
self.Thresh: float | FloatKey = FloatKey(name='Thresh', comment='The threshold for printing the EFG-NBO contributions. The default is 0.05, which means that only orbitals with absolute value contribution larger than 5% of the total EFG are printed. To increase the number of contributions printed, specify a smaller threshold.', default=0.05)
def __post_init__(self):
self.TWOANTISYM: BoolType | BoolKey = BoolKey(name='2ANTISYM', hidden=True, default=False)
self.ALDA: BoolType | BoolKey = BoolKey(name='ALDA', comment='Use ALDA only', default=False)
self.Alpha: BoolType | BoolKey = BoolKey(name='Alpha', comment='Calculate linear response', default=False)
self.Beta: BoolType | BoolKey = BoolKey(name='Beta', comment='Will use 2n+1 rule to calculate beta.', default=False)
self.CALCTRANSFORMPROP: str | StringKey = StringKey(name='CALCTRANSFORMPROP', comment='Transformation Properties of Polarizabilities')
self.CHANGESIGN: BoolType | BoolKey = BoolKey(name='CHANGESIGN', hidden=True, default=False)
self.Components: str | StringKey = StringKey(name='Components', comment='Limit the tensor components to the specified ones. Using this option may save the computation time. Options: XX, XY, XZ, YX, YY, YZ, ZX, ZY, ZZ')
self.Cubic: BoolType | BoolKey = BoolKey(name='Cubic', comment='Calculate cubic response', default=False)
self.Damp: float | FloatKey = FloatKey(name='Damp', comment='Specify damping for non-acceleration iteration', default=0.4)
self.Debug: int | IntKey = IntKey(name='Debug', comment='Debug level for AOResponse.', default=0)
self.DoNothing: BoolType | BoolKey = BoolKey(name='DoNothing', comment='Do nothing.', default=False)
self.EFIOR: BoolType | BoolKey = BoolKey(name='EFIOR', default=False)
self.EFISHG: BoolType | BoolKey = BoolKey(name='EFISHG', default=False)
self.EFPLOT: BoolType | BoolKey = BoolKey(name='EFPLOT', default=False)
self.EL_DIPOLE_EL_DIPOLE: str | StringKey = StringKey(name='EL_DIPOLE_EL_DIPOLE')
self.EL_DIPOLE_EL_OCTUPOLE: str | StringKey = StringKey(name='EL_DIPOLE_EL_OCTUPOLE')
self.EL_DIPOLE_EL_QUADRUPOLE: str | StringKey = StringKey(name='EL_DIPOLE_EL_QUADRUPOLE')
self.EL_DIPOLE_MAG_DIPOLE: str | StringKey = StringKey(name='EL_DIPOLE_MAG_DIPOLE')
self.EL_DIPOLE_MAG_QUADRUPOLE: str | StringKey = StringKey(name='EL_DIPOLE_MAG_QUADRUPOLE')
self.EL_QUADRUPOLE_EL_QUADRUPOLE: str | StringKey = StringKey(name='EL_QUADRUPOLE_EL_QUADRUPOLE')
self.EL_QUADRUPOLE_MAG_DIPOLE: str | StringKey = StringKey(name='EL_QUADRUPOLE_MAG_DIPOLE')
self.EOPE: BoolType | BoolKey = BoolKey(name='EOPE', default=False)
self.FitAODeriv: BoolType | BoolKey = BoolKey(name='FitAODeriv', comment='Use FITAODERIV for Coulomb potential', default=False)
self.Frequencies: Iterable[float] | FloatListKey = FloatListKey(name='Frequencies', comment='List of frequencies of incident light, the perturbing field, at which the time-dependent properties will be calculated.', default=[0.0], unit='eV', gui_type='range')
self.GIAO: BoolType | BoolKey = BoolKey(name='GIAO', comment='Use gauge-included atomic orbitals', default=False)
self.Gamma: BoolType | BoolKey = BoolKey(name='Gamma', comment='Will use 2n+1 rule to calculate gamma.', default=False)
self.HirshPol: BoolType | BoolKey = BoolKey(name='HirshPol', comment='Hirshfeld Polarizability of fragments', default=False)
self.IDRI: BoolType | BoolKey = BoolKey(name='IDRI', default=False)
self.LifeTime: float | FloatKey = FloatKey(name='LifeTime', comment='Specify the resonance peak width (damping) in Hartree units. Typically the lifetime of the excited states is approximated with a common phenomenological damping parameter. Values are best obtained by fitting absorption data for the molecule, however, the values do not vary a lot between similar molecules, so it is not hard to estimate values. A value of 0.004 Hartree was used in Ref. [266].', unit='Hartree')
self.MAG_DIPOLE_MAG_DIPOLE: str | StringKey = StringKey(name='MAG_DIPOLE_MAG_DIPOLE')
self.MagOptRot: BoolType | BoolKey = BoolKey(name='MagOptRot', comment='Calculate magneto-optical rotation', default=False)
self.MagneticPert: BoolType | BoolKey = BoolKey(name='MagneticPert', comment='Use magnetic field as a perturbation', default=False)
self.NBO: BoolType | BoolKey = BoolKey(name='NBO', comment='Perform NBO analysis', default=False)
self.NoCore: BoolType | BoolKey = BoolKey(name='NoCore', comment='if NOCORE is set we skip the core potential in diamagnetic term and/or in the unperturbed density of the CPKS solvers', default=False)
self.OCCOCC: BoolType | BoolKey = BoolKey(name='OCCOCC', comment='occ-occ block response (not GIAO) - Experimental', hidden=True, default=False)
self.OKE: BoolType | BoolKey = BoolKey(name='OKE', default=False)
self.ONLYANTISYM: BoolType | BoolKey = BoolKey(name='ONLYANTISYM', hidden=True, default=False)
self.ONLYSYM: BoolType | BoolKey = BoolKey(name='ONLYSYM', hidden=True, default=False)
self.OPTICALR: BoolType | BoolKey = BoolKey(name='OPTICALR', default=False)
self.OnlyPot: BoolType | BoolKey = BoolKey(name='OnlyPot', comment='Calculation only potential for debugging purposes', hidden=True, default=False)
self.OpticalRotation: BoolType | BoolKey = BoolKey(name='OpticalRotation', comment='Calculate optical rotation', default=False)
self.PBE0LDA: BoolType | BoolKey = BoolKey(name='PBE0LDA', hidden=True, default=False)
self.QuadBeta: BoolType | BoolKey = BoolKey(name='QuadBeta', comment='Quadrupole operators with beta tensor', default=False)
self.QuadPert: BoolType | BoolKey = BoolKey(name='QuadPert', comment='Calculate quadrupole-quadrupole polarizability', default=False)
self.Quadratic: BoolType | BoolKey = BoolKey(name='Quadratic', comment='Calculate quadratic response', default=False)
self.Quadrupole: BoolType | BoolKey = BoolKey(name='Quadrupole', comment='Calculate dipole-quadrupole polarizability', default=False)
self.REVPBE: BoolType | BoolKey = BoolKey(name='REVPBE', hidden=True, default=False)
self.Raman: BoolType | BoolKey = BoolKey(name='Raman', default=False)
self.SCF: str | StringKey = StringKey(name='SCF', comment='Specify CPKS parameters such as the degree of convergence and the maximum number of iterations: NOCYC - disable self-consistence altogetherNOACCEL - disable convergence accelerationCONV - convergence criterion for CPKS. The default value is 10-6 . The value is relative to the uncoupled result (i.e. to the value without self-consistence).ITER - maximum number of CPKS iterations, 50 by default.Specifying ITER=0 has the same effect as specifying NOCYC.')
self.SHG: BoolType | BoolKey = BoolKey(name='SHG', default=False)
self.STATIC: BoolType | BoolKey = BoolKey(name='STATIC', default=False)
self.THG: BoolType | BoolKey = BoolKey(name='THG', default=False)
self.TPA: BoolType | BoolKey = BoolKey(name='TPA', default=False)
self.Traceless: BoolType | BoolKey = BoolKey(name='Traceless', comment='Traceless quadrupole tensors', default=False)
self.VROA: BoolType | BoolKey = BoolKey(name='VROA', comment='Calculate Vibrational Raman Optical Activity. ', default=False)
self.VelocityOrd: BoolType | BoolKey = BoolKey(name='VelocityOrd', comment='Use VelocityOrd without GIAOs', default=False)
self.XAlpha: BoolType | BoolKey = BoolKey(name='XAlpha', comment='Xalpha potential', default=False)
self.EFG: ADF._AOResponse._EFG = self._EFG(name='EFG', comment='Perform a Mulliken type analysis of the EFG principal components, and an analysis in terms of canonical MOs.')
[docs] class _AnalyticalFreq(FixedBlock):
r"""
Define options for analytical frequencies.
:ivar B1Size: Sparse grid max memory size
:vartype B1Size: float | FloatKey
:ivar B1Thresh: MMGF_DENB1 and MMGF_GRADB1 cutoff values
:vartype B1Thresh: float | FloatKey
:ivar Check_CPKS_From_Iteration: Solution of the CPKS equations is an iterative process, and convergence is achieved if the difference between U1 matrix of successive iterations falls below a certain threshold. This key can be used to determine at which iteration the checking should start taking place.
:vartype Check_CPKS_From_Iteration: int | IntKey
:ivar Debug: For debugging purposes. Options: fit, hessian, b1, densities, numbers, symmetry, all.
:vartype Debug: str | StringKey
:ivar Hessian: Whether the final Hessian is obtained by reflecting or averaging?
:vartype Hessian: Literal["reflect", "average"]
:ivar Max_CPKS_Iterations: Calculating the analytical frequencies requires the solution of the Coupled Perturbed Kohn-Sham (CPKS) equations, which is an iterative process. If convergence is not achieved (a warning will be printed in the output if this is the case) then this subkey can be used to increase the number of iterations, although convergence is not guaranteed. The user required accuracy of the U1 matrix, as well as the ADF integration accuracy, can effect the rates of convergence.
:vartype Max_CPKS_Iterations: int | IntKey
:ivar Nuc: By default, when calculating the frequencies analytically, the derivatives of the energy with respect to all nuclei are calculated. This gives a complete Hessian (second derivative) matrix, from which the vibrational frequencies of the molecule can be calculated. However, there may be certain cases where only derivatives with respect to a subset of all the nuclei are required. In this case it is a considerable saving in time if only a partial Hessian is calculated. With this subkey, a list of the nuclei for which the derivatives are required can be specified. However, the frequencies in this case are not the vibrational frequencies of the molecule, but may be used in guiding certain transition state searches
:vartype Nuc: Iterable[int] | IntListKey
:ivar Print: Primarily for debugging purposes. Options: eigs, u1, parts. Choosing EIGS results in the print out of the MO eigenvectors, while U1 results in the print out of the U1 matrices. Except for small molecules this will result in a lot of data being output, and so they are not recommended. Choosing PARTS results in the print out of various sub-hessians that add up to give the final analytical hessian.
:vartype Print: str | StringKey
:ivar PrintNormalModeAnalysis: Request ADF to print analysis of the normal modes independently of AMS.
:vartype PrintNormalModeAnalysis: BoolType | BoolKey
:ivar Test: Test COSMO
:vartype Test: str | StringKey
:ivar U1_Accuracy: Solution of the CPKS equations is an iterative process, and convergence is achieved if the difference between U1 matrix of successive iterations falls below a certain threshold. This subkey can be used to set the threshold. The accuracy of the U1 will be 10**(-x). So, the higher the number the more accurate the U1 will be. While this parameter effects the accuracy of the frequencies, other factors also effect the accuracy of the frequencies, especially the ADF integration accuracy.
:vartype U1_Accuracy: float | FloatKey
"""
def __post_init__(self):
self.B1Size: float | FloatKey = FloatKey(name='B1Size', comment='Sparse grid max memory size')
self.B1Thresh: float | FloatKey = FloatKey(name='B1Thresh', comment='MMGF_DENB1 and MMGF_GRADB1 cutoff values', default=1e-10)
self.Check_CPKS_From_Iteration: int | IntKey = IntKey(name='Check_CPKS_From_Iteration', comment='Solution of the CPKS equations is an iterative process, and convergence is achieved if the difference between U1 matrix of successive iterations falls below a certain threshold. This key can be used to determine at which iteration the checking should start taking place. ', default=1)
self.Debug: str | StringKey = StringKey(name='Debug', comment='For debugging purposes. Options: fit, hessian, b1, densities, numbers, symmetry, all.')
self.Hessian: Literal["reflect", "average"] = MultipleChoiceKey(name='Hessian', comment='Whether the final Hessian is obtained by reflecting or averaging?', default='reflect', choices=['reflect', 'average'])
self.Max_CPKS_Iterations: int | IntKey = IntKey(name='Max_CPKS_Iterations', comment='Calculating the analytical frequencies requires the solution of the Coupled Perturbed Kohn-Sham (CPKS) equations, which is an iterative process. If convergence is not achieved (a warning will be printed in the output if this is the case) then this subkey can be used to increase the number of iterations, although convergence is not guaranteed. The user required accuracy of the U1 matrix, as well as the ADF integration accuracy, can effect the rates of convergence.', default=20)
self.Nuc: Iterable[int] | IntListKey = IntListKey(name='Nuc', comment='By default, when calculating the frequencies analytically, the derivatives of the energy with respect to all nuclei are calculated. This gives a complete Hessian (second derivative) matrix, from which the vibrational frequencies of the molecule can be calculated. However, there may be certain cases where only derivatives with respect to a subset of all the nuclei are required. In this case it is a considerable saving in time if only a partial Hessian is calculated. With this subkey, a list of the nuclei for which the derivatives are required can be specified. However, the frequencies in this case are not the vibrational frequencies of the molecule, but may be used in guiding certain transition state searches', hidden=True)
self.Print: str | StringKey = StringKey(name='Print', comment='Primarily for debugging purposes. Options: eigs, u1, parts. Choosing EIGS results in the print out of the MO eigenvectors, while U1 results in the print out of the U1 matrices. Except for small molecules this will result in a lot of data being output, and so they are not recommended. Choosing PARTS results in the print out of various sub-hessians that add up to give the final analytical hessian.')
self.PrintNormalModeAnalysis: BoolType | BoolKey = BoolKey(name='PrintNormalModeAnalysis', comment='Request ADF to print analysis of the normal modes independently of AMS.', default=False)
self.Test: str | StringKey = StringKey(name='Test', comment='Test COSMO', hidden=True)
self.U1_Accuracy: float | FloatKey = FloatKey(name='U1_Accuracy', comment='Solution of the CPKS equations is an iterative process, and convergence is achieved if the difference between U1 matrix of successive iterations falls below a certain threshold. This subkey can be used to set the threshold. The accuracy of the U1 will be 10**(-x). So, the higher the number the more accurate the U1 will be. While this parameter effects the accuracy of the frequencies, other factors also effect the accuracy of the frequencies, especially the ADF integration accuracy.', default=5.0)
[docs] class _Aromaticity(FixedBlock):
r"""
Calculate aromaticity indicators, i.e. the matrix of localization/delocalization indices (LI-DI), Iring (ring index) and MCI (multi center index) aromaticity indices.
:ivar RingAtoms: List of the atom numbers that form a ring. For each ring a separate line.
:vartype RingAtoms: Iterable[int] | IntListKey
"""
def __post_init__(self):
self.RingAtoms: Iterable[int] | IntListKey = IntListKey(name='RingAtoms', comment='List of the atom numbers that form a ring. For each ring a separate line.', unique=False)
[docs] class _Basis(FixedBlock):
r"""
Definition of the basis set
:ivar Core: Select the size of the frozen core you want to use.
Small and Large will be interpreted within the basis sets available (of the selected quality), and might refer to the same core in some cases.
If you specify 'None' you are guaranteed to have an all-electron basis set.
:vartype Core: Literal["None", "Small", "Medium", "Large"]
:ivar CreateOutput: If true, the output of the atomic create runs will be printed to standard output. If false, it will be saved to the file CreateAtoms.out in the AMS results folder.
:vartype CreateOutput: BoolType | BoolKey
:ivar FitType: Expert option.
Select the auxiliary fit to be used for STOfit or old Hartree-Fock RI scheme.
The fit set for a given atom is taken from the all-electron basis set file for the specified choice, for the same element as the atom.
By default (Auto) the fit set is taken from the original basis set file.
:vartype FitType: Literal["Auto", "SZ", "DZ", "DZP", "TZP", "TZ2P", "QZ4P", "TZ2P+", "TZ2P-J", "QZ4P-J", "ZORA/SZ", "ZORA/DZ", "ZORA/DZP", "ZORA/TZP", "ZORA/TZ2P", "ZORA/QZ4P", "ZORA/TZ2P+", "ZORA/TZ2P-J", "ZORA/QZ4P-J", "ZORA/jcpl", "AUG/ASZ", "AUG/ADZ", "AUG/ADZP", "AUG/ATZP", "AUG/ATZ2P", "ET/ET-pVQZ", "ET/ET-QZ+5P", "ET/ET-QZ3P", "ET/ET-QZ3P-1DIFFUSE", "ET/ET-QZ3P-2DIFFUSE", "ET/ET-QZ3P-3DIFFUSE"]
:ivar Path: The name of an alternative directory with basis sets to use. ADF looks for appropriate basis sets only within this directory. Default $AMSRESOURCES/ADF.
:vartype Path: str | 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: Quad Z, 4 pol functions, all-electron
AUG: Augmented (extra diffuse functions)
ET: Even tempered all electron basis sets
J: Extra tight functions
These descriptions are meant to give an indication of the quality,
but remember that ADF uses Slater type functions.
For standard calculations (energies, geometries, etc.) the relative quality is:
SZ < DZ < DZP < TZP < TZ2P < ET-pVQZ < QZ4P
The basis set chosen will apply to all atom types in your molecule. If no matching basis set is found, ADF will try to use a basis set of better quality.
For TDDFT applications and small negatively charged atoms or molecules, use basis sets with extra diffuse functions.
J: TZ2P-J, QZ4P-J: for use in ESR hyperfine or NMR spin-spin couplings.
Use the Basis panel to select a basis set per atom type, and to see what basis set actually will be used.
:vartype Type: Literal["SZ", "DZ", "DZP", "TZP", "TZ2P", "QZ4P", "TZ2P+", "TZ2P-J", "QZ4P-J", "mTZ2P", "ZORA/SZ", "ZORA/DZ", "ZORA/DZP", "ZORA/TZP", "ZORA/TZ2P", "ZORA/QZ4P", "ZORA/TZ2P+", "ZORA/TZ2P-J", "ZORA/QZ4P-J", "ZORA/mTZ2P", "ZORA/jcpl", "AUG/ASZ", "AUG/ADZ", "AUG/ADZP", "AUG/ATZP", "AUG/ATZ2P", "ET/ET-pVQZ", "ET/ET-QZ+5P", "ET/ET-QZ3P", "ET/ET-QZ3P-1DIFFUSE", "ET/ET-QZ3P-2DIFFUSE", "ET/ET-QZ3P-3DIFFUSE", "Corr/TZ3P", "Corr/QZ6P", "Corr/ATZ3P", "Corr/AQZ6P", "Corr/dATZ3P", "Corr/dAQZ6P", "POLTDDFT/DZ", "POLTDDFT/DZP", "POLTDDFT/TZP"]
:ivar PerAtomType: Defines the basis set for all atoms of a particular type.
:vartype PerAtomType: ADF._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: ADF._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 of the basis set file (the path can either absolute or relative to $AMSRESOURCES/ADF). Note that one should include ZORA in the path for relativistic calculations, for example 'ZORA/QZ4P/Au'. 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", "TZ2P+", "TZ2P-J", "QZ4P-J", "mTZ2P", "ZORA/SZ", "ZORA/DZ", "ZORA/DZP", "ZORA/TZP", "ZORA/TZ2P", "ZORA/QZ4P", "ZORA/TZ2P+", "ZORA/TZ2P-J", "ZORA/QZ4P-J", "ZORA/mTZ2P", "ZORA/jcpl", "AUG/ASZ", "AUG/ADZ", "AUG/ADZP", "AUG/ATZP", "AUG/ATZ2P", "ET/ET-pVQZ", "ET/ET-QZ+5P", "ET/ET-QZ3P", "ET/ET-QZ3P-1DIFFUSE", "ET/ET-QZ3P-2DIFFUSE", "ET/ET-QZ3P-3DIFFUSE", "Corr/TZ3P", "Corr/QZ6P", "Corr/ATZ3P", "Corr/AQZ6P", "Corr/dATZ3P", "Corr/dAQZ6P", "POLTDDFT/DZ", "POLTDDFT/DZP", "POLTDDFT/TZP"]
"""
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'], hiddenchoices=['Medium'])
self.File: str | Path | StringKey = PathStringKey(name='File', comment="The path of the basis set file (the path can either absolute or relative to $AMSRESOURCES/ADF). Note that one should include ZORA in the path for relativistic calculations, for example 'ZORA/QZ4P/Au'. 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", "TZ2P+", "TZ2P-J", "QZ4P-J", "mTZ2P", "ZORA/SZ", "ZORA/DZ", "ZORA/DZP", "ZORA/TZP", "ZORA/TZ2P", "ZORA/QZ4P", "ZORA/TZ2P+", "ZORA/TZ2P-J", "ZORA/QZ4P-J", "ZORA/mTZ2P", "ZORA/jcpl", "AUG/ASZ", "AUG/ADZ", "AUG/ADZP", "AUG/ATZP", "AUG/ATZ2P", "ET/ET-pVQZ", "ET/ET-QZ+5P", "ET/ET-QZ3P", "ET/ET-QZ3P-1DIFFUSE", "ET/ET-QZ3P-2DIFFUSE", "ET/ET-QZ3P-3DIFFUSE", "Corr/TZ3P", "Corr/QZ6P", "Corr/ATZ3P", "Corr/AQZ6P", "Corr/dATZ3P", "Corr/dAQZ6P", "POLTDDFT/DZ", "POLTDDFT/DZP", "POLTDDFT/TZP"] = MultipleChoiceKey(name='Type', comment='The basis sets to be used.', choices=['SZ', 'DZ', 'DZP', 'TZP', 'TZ2P', 'QZ4P', 'TZ2P+', 'TZ2P-J', 'QZ4P-J', 'mTZ2P', 'ZORA/SZ', 'ZORA/DZ', 'ZORA/DZP', 'ZORA/TZP', 'ZORA/TZ2P', 'ZORA/QZ4P', 'ZORA/TZ2P+', 'ZORA/TZ2P-J', 'ZORA/QZ4P-J', 'ZORA/mTZ2P', 'ZORA/jcpl', 'AUG/ASZ', 'AUG/ADZ', 'AUG/ADZP', 'AUG/ATZP', 'AUG/ATZ2P', 'ET/ET-pVQZ', 'ET/ET-QZ+5P', 'ET/ET-QZ3P', 'ET/ET-QZ3P-1DIFFUSE', 'ET/ET-QZ3P-2DIFFUSE', 'ET/ET-QZ3P-3DIFFUSE', 'Corr/TZ3P', 'Corr/QZ6P', 'Corr/ATZ3P', 'Corr/AQZ6P', 'Corr/dATZ3P', 'Corr/dAQZ6P', 'POLTDDFT/DZ', 'POLTDDFT/DZP', 'POLTDDFT/TZP'], hiddenchoices=['TZ2P+', 'ZORA/SZ', 'ZORA/DZ', 'ZORA/DZP', 'ZORA/TZP', 'ZORA/TZ2P', 'ZORA/QZ4P', 'ZORA/TZ2P+', 'ZORA/TZ2P-J', 'ZORA/QZ4P-J', 'ZORA/mTZ2P', 'ZORA/jcpl', 'ET/ET-QZ+5P', 'Corr/dATZ3P', 'Corr/dAQZ6P'], gui_type='submenus AUG AUG/* ET ET/* J *-J POLTDDFT POLTDDFT/*')
[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 of the basis set file (the path can either absolute or relative to $AMSRESOURCES/ADF). Note that one should include ZORA in the path for relativistic calculations, for example 'ZORA/QZ4P/Au'. 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", "TZ2P+", "TZ2P-J", "QZ4P-J", "mTZ2P", "ZORA/SZ", "ZORA/DZ", "ZORA/DZP", "ZORA/TZP", "ZORA/TZ2P", "ZORA/QZ4P", "ZORA/TZ2P+", "ZORA/TZ2P-J", "ZORA/QZ4P-J", "ZORA/mTZ2P", "ZORA/jcpl", "AUG/ASZ", "AUG/ADZ", "AUG/ADZP", "AUG/ATZP", "AUG/ATZ2P", "ET/ET-pVQZ", "ET/ET-QZ+5P", "ET/ET-QZ3P", "ET/ET-QZ3P-1DIFFUSE", "ET/ET-QZ3P-2DIFFUSE", "ET/ET-QZ3P-3DIFFUSE", "Corr/TZ3P", "Corr/QZ6P", "Corr/ATZ3P", "Corr/AQZ6P", "Corr/dATZ3P", "Corr/dAQZ6P", "POLTDDFT/DZ", "POLTDDFT/DZP", "POLTDDFT/TZP"]
"""
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'], hiddenchoices=['Medium'])
self.File: str | Path | StringKey = PathStringKey(name='File', comment="The path of the basis set file (the path can either absolute or relative to $AMSRESOURCES/ADF). Note that one should include ZORA in the path for relativistic calculations, for example 'ZORA/QZ4P/Au'. 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", "TZ2P+", "TZ2P-J", "QZ4P-J", "mTZ2P", "ZORA/SZ", "ZORA/DZ", "ZORA/DZP", "ZORA/TZP", "ZORA/TZ2P", "ZORA/QZ4P", "ZORA/TZ2P+", "ZORA/TZ2P-J", "ZORA/QZ4P-J", "ZORA/mTZ2P", "ZORA/jcpl", "AUG/ASZ", "AUG/ADZ", "AUG/ADZP", "AUG/ATZP", "AUG/ATZ2P", "ET/ET-pVQZ", "ET/ET-QZ+5P", "ET/ET-QZ3P", "ET/ET-QZ3P-1DIFFUSE", "ET/ET-QZ3P-2DIFFUSE", "ET/ET-QZ3P-3DIFFUSE", "Corr/TZ3P", "Corr/QZ6P", "Corr/ATZ3P", "Corr/AQZ6P", "Corr/dATZ3P", "Corr/dAQZ6P", "POLTDDFT/DZ", "POLTDDFT/DZP", "POLTDDFT/TZP"] = MultipleChoiceKey(name='Type', comment='The basis sets to be used.', default='DZ', choices=['SZ', 'DZ', 'DZP', 'TZP', 'TZ2P', 'QZ4P', 'TZ2P+', 'TZ2P-J', 'QZ4P-J', 'mTZ2P', 'ZORA/SZ', 'ZORA/DZ', 'ZORA/DZP', 'ZORA/TZP', 'ZORA/TZ2P', 'ZORA/QZ4P', 'ZORA/TZ2P+', 'ZORA/TZ2P-J', 'ZORA/QZ4P-J', 'ZORA/mTZ2P', 'ZORA/jcpl', 'AUG/ASZ', 'AUG/ADZ', 'AUG/ADZP', 'AUG/ATZP', 'AUG/ATZ2P', 'ET/ET-pVQZ', 'ET/ET-QZ+5P', 'ET/ET-QZ3P', 'ET/ET-QZ3P-1DIFFUSE', 'ET/ET-QZ3P-2DIFFUSE', 'ET/ET-QZ3P-3DIFFUSE', 'Corr/TZ3P', 'Corr/QZ6P', 'Corr/ATZ3P', 'Corr/AQZ6P', 'Corr/dATZ3P', 'Corr/dAQZ6P', 'POLTDDFT/DZ', 'POLTDDFT/DZP', 'POLTDDFT/TZP'], hiddenchoices=['TZ2P+', 'ZORA/SZ', 'ZORA/DZ', 'ZORA/DZP', 'ZORA/TZP', 'ZORA/TZ2P', 'ZORA/QZ4P', 'ZORA/TZ2P+', 'ZORA/TZ2P-J', 'ZORA/QZ4P-J', 'ZORA/mTZ2P', 'ZORA/jcpl', 'ET/ET-QZ+5P', 'Corr/dATZ3P', 'Corr/dAQZ6P'], gui_type='submenus AUG AUG/* ET ET/* J *-J POLTDDFT POLTDDFT/*')
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 and Large will be interpreted within the basis sets available (of the selected quality), and might refer to the same core in some cases.\n\nIf you specify 'None' you are guaranteed to have an all-electron basis set.", gui_name='Frozen core:', default='Large', choices=['None', 'Small', 'Medium', 'Large'], hiddenchoices=['Medium'])
self.CreateOutput: BoolType | BoolKey = BoolKey(name='CreateOutput', comment='If true, the output of the atomic create runs will be printed to standard output. If false, it will be saved to the file CreateAtoms.out in the AMS results folder.', default=False)
self.FitType: Literal["Auto", "SZ", "DZ", "DZP", "TZP", "TZ2P", "QZ4P", "TZ2P+", "TZ2P-J", "QZ4P-J", "ZORA/SZ", "ZORA/DZ", "ZORA/DZP", "ZORA/TZP", "ZORA/TZ2P", "ZORA/QZ4P", "ZORA/TZ2P+", "ZORA/TZ2P-J", "ZORA/QZ4P-J", "ZORA/jcpl", "AUG/ASZ", "AUG/ADZ", "AUG/ADZP", "AUG/ATZP", "AUG/ATZ2P", "ET/ET-pVQZ", "ET/ET-QZ+5P", "ET/ET-QZ3P", "ET/ET-QZ3P-1DIFFUSE", "ET/ET-QZ3P-2DIFFUSE", "ET/ET-QZ3P-3DIFFUSE"] = MultipleChoiceKey(name='FitType', comment='Expert option.\n\nSelect the auxiliary fit to be used for STOfit or old Hartree-Fock RI scheme.\n\nThe fit set for a given atom is taken from the all-electron basis set file for the specified choice, for the same element as the atom.\n\nBy default (Auto) the fit set is taken from the original basis set file.', gui_name='STO fit set:', default='Auto', choices=['Auto', 'SZ', 'DZ', 'DZP', 'TZP', 'TZ2P', 'QZ4P', 'TZ2P+', 'TZ2P-J', 'QZ4P-J', 'ZORA/SZ', 'ZORA/DZ', 'ZORA/DZP', 'ZORA/TZP', 'ZORA/TZ2P', 'ZORA/QZ4P', 'ZORA/TZ2P+', 'ZORA/TZ2P-J', 'ZORA/QZ4P-J', 'ZORA/jcpl', 'AUG/ASZ', 'AUG/ADZ', 'AUG/ADZP', 'AUG/ATZP', 'AUG/ATZ2P', 'ET/ET-pVQZ', 'ET/ET-QZ+5P', 'ET/ET-QZ3P', 'ET/ET-QZ3P-1DIFFUSE', 'ET/ET-QZ3P-2DIFFUSE', 'ET/ET-QZ3P-3DIFFUSE'], hiddenchoices=['TZ2P+', 'ZORA/SZ', 'ZORA/DZ', 'ZORA/DZP', 'ZORA/TZP', 'ZORA/TZ2P', 'ZORA/QZ4P', 'ZORA/TZ2P+', 'ZORA/TZ2P-J', 'ZORA/QZ4P-J', 'ZORA/jcpl', 'ET/ET-QZ+5P'], gui_type='submenus AUG AUG/* ET ET/* J *-J')
self.Path: str | StringKey = StringKey(name='Path', comment='The name of an alternative directory with basis sets to use. ADF looks for appropriate basis sets only within this directory. Default $AMSRESOURCES/ADF.')
self.Type: Literal["SZ", "DZ", "DZP", "TZP", "TZ2P", "QZ4P", "TZ2P+", "TZ2P-J", "QZ4P-J", "mTZ2P", "ZORA/SZ", "ZORA/DZ", "ZORA/DZP", "ZORA/TZP", "ZORA/TZ2P", "ZORA/QZ4P", "ZORA/TZ2P+", "ZORA/TZ2P-J", "ZORA/QZ4P-J", "ZORA/mTZ2P", "ZORA/jcpl", "AUG/ASZ", "AUG/ADZ", "AUG/ADZP", "AUG/ATZP", "AUG/ATZ2P", "ET/ET-pVQZ", "ET/ET-QZ+5P", "ET/ET-QZ3P", "ET/ET-QZ3P-1DIFFUSE", "ET/ET-QZ3P-2DIFFUSE", "ET/ET-QZ3P-3DIFFUSE", "Corr/TZ3P", "Corr/QZ6P", "Corr/ATZ3P", "Corr/AQZ6P", "Corr/dATZ3P", "Corr/dAQZ6P", "POLTDDFT/DZ", "POLTDDFT/DZP", "POLTDDFT/TZP"] = 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: Quad Z, 4 pol functions, all-electron\nAUG: Augmented (extra diffuse functions)\nET: Even tempered all electron basis sets\nJ: Extra tight functions\n\nThese descriptions are meant to give an indication of the quality,\nbut remember that ADF uses Slater type functions.\n\nFor standard calculations (energies, geometries, etc.) the relative quality is:\n\nSZ < DZ < DZP < TZP < TZ2P < ET-pVQZ < QZ4P\n\nThe basis set chosen will apply to all atom types in your molecule. If no matching basis set is found, ADF will try to use a basis set of better quality.\n\nFor TDDFT applications and small negatively charged atoms or molecules, use basis sets with extra diffuse functions.\n\nJ: TZ2P-J, QZ4P-J: for use in ESR hyperfine or NMR spin-spin couplings.\n\nUse the Basis panel to select a basis set per atom type, and to see what basis set actually will be used.', gui_name='Basis set:', default='DZ', choices=['SZ', 'DZ', 'DZP', 'TZP', 'TZ2P', 'QZ4P', 'TZ2P+', 'TZ2P-J', 'QZ4P-J', 'mTZ2P', 'ZORA/SZ', 'ZORA/DZ', 'ZORA/DZP', 'ZORA/TZP', 'ZORA/TZ2P', 'ZORA/QZ4P', 'ZORA/TZ2P+', 'ZORA/TZ2P-J', 'ZORA/QZ4P-J', 'ZORA/mTZ2P', 'ZORA/jcpl', 'AUG/ASZ', 'AUG/ADZ', 'AUG/ADZP', 'AUG/ATZP', 'AUG/ATZ2P', 'ET/ET-pVQZ', 'ET/ET-QZ+5P', 'ET/ET-QZ3P', 'ET/ET-QZ3P-1DIFFUSE', 'ET/ET-QZ3P-2DIFFUSE', 'ET/ET-QZ3P-3DIFFUSE', 'Corr/TZ3P', 'Corr/QZ6P', 'Corr/ATZ3P', 'Corr/AQZ6P', 'Corr/dATZ3P', 'Corr/dAQZ6P', 'POLTDDFT/DZ', 'POLTDDFT/DZP', 'POLTDDFT/TZP'], hiddenchoices=['TZ2P+', 'ZORA/SZ', 'ZORA/DZ', 'ZORA/DZP', 'ZORA/TZP', 'ZORA/TZ2P', 'ZORA/QZ4P', 'ZORA/TZ2P+', 'ZORA/TZ2P-J', 'ZORA/QZ4P-J', 'ZORA/mTZ2P', 'ZORA/jcpl', 'ET/ET-QZ+5P', 'Corr/dATZ3P', 'Corr/dAQZ6P'], gui_type='literal choices; submenus AUG AUG/* Corr Corr/* ET ET/* J *-J POLTDDFT POLTDDFT/*')
self.PerAtomType: ADF._Basis._PerAtomType = self._PerAtomType(name='PerAtomType', comment='Defines the basis set for all atoms of a particular type.', unique=False)
self.PerRegion: ADF._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 _BeckeGrid(FixedBlock):
r"""
Options for the numerical integration grid.
:ivar AllowAngularBoost: Allow automatic augmentation of the Lebedev spherical grid for highly coordinated atoms.
:vartype AllowAngularBoost: BoolType | BoolKey
: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 QPNear: Only relevant if you have specified point charges in the input file. ADF generates grids only about those point charges that are close to any real atoms. The criterion, input with the qpnear subkey, is the closest distance between the point charge at hand and any real atom.
:vartype QPNear: float | FloatKey
: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 ADF 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 QualityPerRegion: Sets the grid quality for all atoms in a region. If specified, this overwrites the globally set quality.
:vartype QualityPerRegion: ADF._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.', default=True)
self.InnerShellsPruning: BoolType | BoolKey = BoolKey(name='InnerShellsPruning', comment='Allow automatic pruning of the Lebedev spherical grid for shells close to the nuclei.', default=True)
self.PartitionFunPruning: BoolType | BoolKey = BoolKey(name='PartitionFunPruning', comment='Allow pruning of integration points based on the value of the partition function.', default=True)
self.QPNear: float | FloatKey = FloatKey(name='QPNear', comment='Only relevant if you have specified point charges in the input file. ADF generates grids only about those point charges that are close to any real atoms. The criterion, input with the qpnear subkey, is the closest distance between the point charge at hand and any real atom.', unit='Angstrom')
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 ADF 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.')
self.QualityPerRegion: ADF._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 _BondOrders(FixedBlock):
r"""
Options for the calculation of bond orders. Note: the calculation of bond orders should be requested via the Properties%BondOrders input option in the AMS driver input.
:ivar Calculate: Whether or not the bond orders should be calculated. This is for internal use/debug purposes, except for multi-atomic fragments. In case of atomic fragments one should request the bond orders at the AMS driver level via the Properties%BondOrders input option. For multi-atomic fragments, however, one should not request the bond orders at the AMS driver level, but instead use this key.
:vartype Calculate: BoolType | BoolKey
:ivar PrintAll: If 'Yes', all five types of bond orders (i.e. Nalewajski-Mrozek-1,2 & 3, Mayer and Gopinathan-Jug) will be printed to the output. Otherwise only the Nalewajski-Mrozek-3 and the type requested in BondOrders%TypeForAMS will be printed.
:vartype PrintAll: BoolType | BoolKey
:ivar PrintTolerance: Only bond orders larger than this threshold will be printed in the output (this treshold applies only to the printing in the 'BOND-ORDER ANALYSIS' section of the ADF output.
:vartype PrintTolerance: float | FloatKey
:ivar TypeForAMS: The type of bond order that will be saved, printed and used by AMS.
Nalewajski-Mrozek-1,2: bond orders calculated from two-electron valence indices based on partitioning of tr(Delta_P^2) using 3-index set or 4-index set respectively. Nalewajski-Mrozek-3: bond-orders calculated from valence indices based on partitioning of tr(P*Delta_P). Inter-atomic bond orders are not defined with non-atomic fragments.
:vartype TypeForAMS: Literal["Nalewajski-Mrozek-1", "Nalewajski-Mrozek-2", "Nalewajski-Mrozek-3", "Mayer", "Gopinathan-Jug"]
"""
def __post_init__(self):
self.Calculate: BoolType | BoolKey = BoolKey(name='Calculate', comment='Whether or not the bond orders should be calculated. This is for internal use/debug purposes, except for multi-atomic fragments. In case of atomic fragments one should request the bond orders at the AMS driver level via the Properties%BondOrders input option. For multi-atomic fragments, however, one should not request the bond orders at the AMS driver level, but instead use this key. ', default=False)
self.PrintAll: BoolType | BoolKey = BoolKey(name='PrintAll', comment="If 'Yes', all five types of bond orders (i.e. Nalewajski-Mrozek-1,2 & 3, Mayer and Gopinathan-Jug) will be printed to the output. Otherwise only the Nalewajski-Mrozek-3 and the type requested in BondOrders%TypeForAMS will be printed.", default=False)
self.PrintTolerance: float | FloatKey = FloatKey(name='PrintTolerance', comment="Only bond orders larger than this threshold will be printed in the output (this treshold applies only to the printing in the 'BOND-ORDER ANALYSIS' section of the ADF output.", default=0.2)
self.TypeForAMS: Literal["Nalewajski-Mrozek-1", "Nalewajski-Mrozek-2", "Nalewajski-Mrozek-3", "Mayer", "Gopinathan-Jug"] = MultipleChoiceKey(name='TypeForAMS', comment='The type of bond order that will be saved, printed and used by AMS.\n\nNalewajski-Mrozek-1,2: bond orders calculated from two-electron valence indices based on partitioning of tr(Delta_P^2) using 3-index set or 4-index set respectively. Nalewajski-Mrozek-3: bond-orders calculated from valence indices based on partitioning of tr(P*Delta_P). Inter-atomic bond orders are not defined with non-atomic fragments.', gui_name='Bond order type for AMS:', default='Nalewajski-Mrozek-3', choices=['Nalewajski-Mrozek-1', 'Nalewajski-Mrozek-2', 'Nalewajski-Mrozek-3', 'Mayer', 'Gopinathan-Jug'])
[docs] class _CDFT(FixedBlock):
r"""
CDFT is a tool for carrying out DFT calculations in the presence of a constraint.
:ivar AllAtoms: If AllAtoms is true, then TheAtoms is overridden and all the atoms in the active fragment are included in the set.
:vartype AllAtoms: BoolType | BoolKey
:ivar AnalyticalHessian: This will calculate the analytical derivative of the energy w.r.t. the Lagrange multiplier up to the specified SCF iteration. This key is not recommended due to the high computational cost that comes with it. The calculation is equivalent to a ground state Hessian, and it is carried out with the full sum-over-states formula.
:vartype AnalyticalHessian: int | IntKey
:ivar ChargeAndSpin: will constrain both the charge and the spin
:vartype ChargeAndSpin: BoolType | BoolKey
:ivar Constraints: The values of the constraints. If CHARGEANDSPIN, constraints to the alpha and beta electrons need to be specified sequentially. One more electron => CONSTRAINTS -1.0. One less electron => CONSTRAINTS 1.0. If the CDFT type is EXCITEDCDFT, CONSTRAINTS=1.0 is recommended. Other values are technically possible but have not been tested yet.
:vartype Constraints: Iterable[float] | FloatListKey
:ivar DoNotOptimize: If true, the multipliers chosen in INITIALMULTIPLIERS will not be optimized and will be constant throughout the entire SCF procedure.
:vartype DoNotOptimize: BoolType | BoolKey
:ivar ExcitedCDFT: will generate an excited state with CONSTRAINTS number of ALPHA electrons constrained to occupy the virtual space of a ground state reference calculation. This is the essence of the eXcited Constrained DFT (XCDFT) method(P. Ramos, M. Pavanello, Low-lying excited states by constrained DFT, Journal of Chemical Physics 148, 144103 (2018) https://doi.org/10.1063/1.5018615) for the calculation of low-lying single excitations. XCDFT is found to correctly reproduce the energy surface topology at conical intersections between the ground state and the first singly excited state and can also accounts for the condensed phase effects in solvated chromophores where typical Delta SCF methods variationally collapse.
:vartype ExcitedCDFT: BoolType | BoolKey
:ivar InitialMultipliers: If available, a guess for the Lagrange multipliers can be entered.
:vartype InitialMultipliers: Iterable[float] | FloatListKey
:ivar MaxIter: Maximum number of CDFT iterations. CDFT carries out a loop nested inside the SCF cycle.
:vartype MaxIter: int | IntKey
:ivar Metric: Relevant for XCDFT. In the XCDFT method orthogonality is not imposed between the KS-orbitals of ground and excited states. If METRIC is specified, the degree of mixing of the single excited state with the ground state or high-order excitations is calculated. Three parameters are calculated: p, m and d. The parameters p and m will give information about the amount of mixing with the ground state, while parameter d will determine the mixing with high order excitations. Additional information about the origin of these parameters can be found in the literature (P. Ramos, M. Pavanello, Low-lying excited states by constrained DFT, Journal of Chemical Physics 148, 144103 (2018) https://doi.org/10.1063/1.5018615)
:vartype Metric: BoolType | BoolKey
:ivar NAtomsPerSet: The number of atoms in each moiety (set).
:vartype NAtomsPerSet: Iterable[int] | IntListKey
:ivar NConstraints: This specifies the number of sets of atoms to be considered. For example, if the user wishes to constrain a positive charge on one part of the system, and a negative charge on another part, NCONSTRAINTS should be set to two. There is no limit on the number of constraints. However, SCF convergence becomes an issue with more than 2 constraints. Note: NCONSTRAINTS>1 is untested.
:vartype NConstraints: int | IntKey
:ivar OnlyCharge: Will constrain only the charge, letting spin relax (and potentially delocalize)
:vartype OnlyCharge: BoolType | BoolKey
:ivar OnlySpin: Will constrain only the spin
:vartype OnlySpin: BoolType | BoolKey
:ivar PopType: The population analysis chosen for determining the constraint.
:vartype PopType: Literal["yukawalike", "fuzzyvoronoibecke", "fuzzyvoronoifermi"]
:ivar Print: Print level and debugging.
:vartype Print: Literal["low", "medium", "high"]
:ivar SelfConsistent: Self-Consistent CDFT
:vartype SelfConsistent: BoolType | BoolKey
:ivar StepSize: The amount of the Lagrange multipliers step taken in each CDFT iteration
:vartype StepSize: float | FloatKey
:ivar TheAtoms: The atom numbers of the moieties in the input geometry order. If NCONSTRAINTS is larger than 1, the sets of atoms are entered as a single list.
:vartype TheAtoms: Iterable[int] | IntListKey
:ivar Threshold: The threshold for convergence of the CDFT constraints. The tighter the SCF convergence criteria, the tighter the THRESHOLD should be.
:vartype Threshold: float | FloatKey
"""
def __post_init__(self):
self.AllAtoms: BoolType | BoolKey = BoolKey(name='AllAtoms', comment='If AllAtoms is true, then TheAtoms is overridden and all the atoms in the active fragment are included in the set.', default=False)
self.AnalyticalHessian: int | IntKey = IntKey(name='AnalyticalHessian', comment='This will calculate the analytical derivative of the energy w.r.t. the Lagrange multiplier up to the specified SCF iteration. This key is not recommended due to the high computational cost that comes with it. The calculation is equivalent to a ground state Hessian, and it is carried out with the full sum-over-states formula.', default=0)
self.ChargeAndSpin: BoolType | BoolKey = BoolKey(name='ChargeAndSpin', comment='will constrain both the charge and the spin', default=False)
self.Constraints: Iterable[float] | FloatListKey = FloatListKey(name='Constraints', comment='The values of the constraints. If CHARGEANDSPIN, constraints to the alpha and beta electrons need to be specified sequentially. One more electron => CONSTRAINTS -1.0. One less electron => CONSTRAINTS 1.0. If the CDFT type is EXCITEDCDFT, CONSTRAINTS=1.0 is recommended. Other values are technically possible but have not been tested yet.')
self.DoNotOptimize: BoolType | BoolKey = BoolKey(name='DoNotOptimize', comment='If true, the multipliers chosen in INITIALMULTIPLIERS will not be optimized and will be constant throughout the entire SCF procedure.', default=False)
self.ExcitedCDFT: BoolType | BoolKey = BoolKey(name='ExcitedCDFT', comment='will generate an excited state with CONSTRAINTS number of ALPHA electrons constrained to occupy the virtual space of a ground state reference calculation. This is the essence of the eXcited Constrained DFT (XCDFT) method(P. Ramos, M. Pavanello, Low-lying excited states by constrained DFT, Journal of Chemical Physics 148, 144103 (2018) https://doi.org/10.1063/1.5018615) for the calculation of low-lying single excitations. XCDFT is found to correctly reproduce the energy surface topology at conical intersections between the ground state and the first singly excited state and can also accounts for the condensed phase effects in solvated chromophores where typical Delta SCF methods variationally collapse.', default=False)
self.InitialMultipliers: Iterable[float] | FloatListKey = FloatListKey(name='InitialMultipliers', comment='If available, a guess for the Lagrange multipliers can be entered.')
self.MaxIter: int | IntKey = IntKey(name='MaxIter', comment='Maximum number of CDFT iterations. CDFT carries out a loop nested inside the SCF cycle.', default=200)
self.Metric: BoolType | BoolKey = BoolKey(name='Metric', comment='Relevant for XCDFT. In the XCDFT method orthogonality is not imposed between the KS-orbitals of ground and excited states. If METRIC is specified, the degree of mixing of the single excited state with the ground state or high-order excitations is calculated. Three parameters are calculated: p, m and d. The parameters p and m will give information about the amount of mixing with the ground state, while parameter d will determine the mixing with high order excitations. Additional information about the origin of these parameters can be found in the literature (P. Ramos, M. Pavanello, Low-lying excited states by constrained DFT, Journal of Chemical Physics 148, 144103 (2018) https://doi.org/10.1063/1.5018615)', default=False)
self.NAtomsPerSet: Iterable[int] | IntListKey = IntListKey(name='NAtomsPerSet', comment='The number of atoms in each moiety (set).')
self.NConstraints: int | IntKey = IntKey(name='NConstraints', comment='This specifies the number of sets of atoms to be considered. For example, if the user wishes to constrain a positive charge on one part of the system, and a negative charge on another part, NCONSTRAINTS should be set to two. There is no limit on the number of constraints. However, SCF convergence becomes an issue with more than 2 constraints. Note: NCONSTRAINTS>1 is untested.', default=1)
self.OnlyCharge: BoolType | BoolKey = BoolKey(name='OnlyCharge', comment='Will constrain only the charge, letting spin relax (and potentially delocalize)', default=True)
self.OnlySpin: BoolType | BoolKey = BoolKey(name='OnlySpin', comment='Will constrain only the spin', default=False)
self.PopType: Literal["yukawalike", "fuzzyvoronoibecke", "fuzzyvoronoifermi"] = MultipleChoiceKey(name='PopType', comment='The population analysis chosen for determining the constraint.', default='yukawalike', choices=['yukawalike', 'fuzzyvoronoibecke', 'fuzzyvoronoifermi'])
self.Print: Literal["low", "medium", "high"] = MultipleChoiceKey(name='Print', comment='Print level and debugging.', default='low', choices=['low', 'medium', 'high'])
self.SelfConsistent: BoolType | BoolKey = BoolKey(name='SelfConsistent', comment='Self-Consistent CDFT ', default=False)
self.StepSize: float | FloatKey = FloatKey(name='StepSize', comment='The amount of the Lagrange multipliers step taken in each CDFT iteration', default=0.5)
self.TheAtoms: Iterable[int] | IntListKey = IntListKey(name='TheAtoms', comment='The atom numbers of the moieties in the input geometry order. If NCONSTRAINTS is larger than 1, the sets of atoms are entered as a single list.')
self.Threshold: float | FloatKey = FloatKey(name='Threshold', comment='The threshold for convergence of the CDFT constraints. The tighter the SCF convergence criteria, the tighter the THRESHOLD should be.', default=1e-10)
[docs] class _CVNDFT(FixedBlock):
r"""
The CVNDFT block key regulates the execution of the CV(n)-DFT code, which calculates the singlet or triplet electronic excitations for the closed shell molecules.
:ivar Iteration: The maximum number of iterations
:vartype Iteration: int | IntKey
:ivar Tolerance: The convergence criterion, i.e. the SCF-CV(infinity)-DFT procedure stops when the given accuracy is achieved.
:vartype Tolerance: float | FloatKey
:ivar CV_DFT: The simplest case: the TDDFT transition density U-vector is substituted into the infinite order CV(infinity)-DFT excitation energy
:vartype CV_DFT: ADF._CVNDFT._CV_DFT
:ivar DSCF_CV_DFT: The simplest case: the TDDFT transition density U-vector is substituted into the infinite order CV(infinity)-DFT excitation energy
:vartype DSCF_CV_DFT: ADF._CVNDFT._DSCF_CV_DFT
:ivar RSCF_CV_DFT: The simplest case: the TDDFT transition density U-vector is substituted into the infinite order CV(infinity)-DFT excitation energy
:vartype RSCF_CV_DFT: ADF._CVNDFT._RSCF_CV_DFT
:ivar R_CV_DFT: The simplest case: the TDDFT transition density U-vector is substituted into the infinite order CV(infinity)-DFT excitation energy
:vartype R_CV_DFT: ADF._CVNDFT._R_CV_DFT
:ivar SCF_CV_DFT: The simplest case: the TDDFT transition density U-vector is substituted into the infinite order CV(infinity)-DFT excitation energy
:vartype SCF_CV_DFT: ADF._CVNDFT._SCF_CV_DFT
"""
[docs] class _CV_DFT(FixedBlock):
r"""
The simplest case: the TDDFT transition density U-vector is substituted into the infinite order CV(infinity)-DFT excitation energy
:ivar InitGuess: Initial guess
:vartype InitGuess: Literal["TDDFT", "SOR"]
"""
def __post_init__(self):
self.InitGuess: Literal["TDDFT", "SOR"] = MultipleChoiceKey(name='InitGuess', comment='Initial guess', default='TDDFT', choices=['TDDFT', 'SOR'])
[docs] class _DSCF_CV_DFT(FixedBlock):
r"""
The simplest case: the TDDFT transition density U-vector is substituted into the infinite order CV(infinity)-DFT excitation energy
:ivar DampOrbRelax: The mix_relax parameter defines the relative weight of the new relaxation vector that is added to the one from the previous iteration.
:vartype DampOrbRelax: float | FloatKey
:ivar DampVariable: Damping condition
:vartype DampVariable: BoolType | BoolKey
:ivar Damping: Damping
:vartype Damping: float | FloatKey
:ivar InitGuess: Initial guess
:vartype InitGuess: Literal["TDDFT", "SOR"]
:ivar Optimize: Gradient optimization method
:vartype Optimize: Literal["SVD", "SOR", "COL"]
:ivar RelaxAlpha: The SCF cycle number at which the relaxation of alpha orbitals starts.
:vartype RelaxAlpha: int | IntKey
:ivar RelaxBeta: The SCF cycle number at which the relaxation of beta orbitals starts.
:vartype RelaxBeta: int | IntKey
"""
def __post_init__(self):
self.DampOrbRelax: float | FloatKey = FloatKey(name='DampOrbRelax', comment='The mix_relax parameter defines the relative weight of the new relaxation vector that is added to the one from the previous iteration.', default=0.2)
self.DampVariable: BoolType | BoolKey = BoolKey(name='DampVariable', comment='Damping condition', default=False)
self.Damping: float | FloatKey = FloatKey(name='Damping', comment='Damping', default=0.2)
self.InitGuess: Literal["TDDFT", "SOR"] = MultipleChoiceKey(name='InitGuess', comment='Initial guess', default='SOR', choices=['TDDFT', 'SOR'])
self.Optimize: Literal["SVD", "SOR", "COL"] = MultipleChoiceKey(name='Optimize', comment='Gradient optimization method', default='SVD', choices=['SVD', 'SOR', 'COL'])
self.RelaxAlpha: int | IntKey = IntKey(name='RelaxAlpha', comment='The SCF cycle number at which the relaxation of alpha orbitals starts.', default=1)
self.RelaxBeta: int | IntKey = IntKey(name='RelaxBeta', comment='The SCF cycle number at which the relaxation of beta orbitals starts.', default=1)
[docs] class _RSCF_CV_DFT(FixedBlock):
r"""
The simplest case: the TDDFT transition density U-vector is substituted into the infinite order CV(infinity)-DFT excitation energy
:ivar DampOrbRelax: The mix_relax parameter defines the relative weight of the new relaxation vector that is added to the one from the previous iteration.
:vartype DampOrbRelax: float | FloatKey
:ivar DampVariable: Damping condition
:vartype DampVariable: BoolType | BoolKey
:ivar Damping: Damping
:vartype Damping: float | FloatKey
:ivar InitGuess: Initial guess
:vartype InitGuess: Literal["TDDFT", "SOR"]
:ivar RelaxAlpha: The SCF cycle number at which the relaxation of alpha orbitals starts.
:vartype RelaxAlpha: int | IntKey
:ivar RelaxBeta: The SCF cycle number at which the relaxation of beta orbitals starts.
:vartype RelaxBeta: int | IntKey
"""
def __post_init__(self):
self.DampOrbRelax: float | FloatKey = FloatKey(name='DampOrbRelax', comment='The mix_relax parameter defines the relative weight of the new relaxation vector that is added to the one from the previous iteration.', default=0.2)
self.DampVariable: BoolType | BoolKey = BoolKey(name='DampVariable', comment='Damping condition', default=False)
self.Damping: float | FloatKey = FloatKey(name='Damping', comment='Damping', default=0.2)
self.InitGuess: Literal["TDDFT", "SOR"] = MultipleChoiceKey(name='InitGuess', comment='Initial guess', default='TDDFT', choices=['TDDFT', 'SOR'])
self.RelaxAlpha: int | IntKey = IntKey(name='RelaxAlpha', comment='The SCF cycle number at which the relaxation of alpha orbitals starts.', default=1)
self.RelaxBeta: int | IntKey = IntKey(name='RelaxBeta', comment='The SCF cycle number at which the relaxation of beta orbitals starts.', default=1)
[docs] class _R_CV_DFT(FixedBlock):
r"""
The simplest case: the TDDFT transition density U-vector is substituted into the infinite order CV(infinity)-DFT excitation energy
:ivar DampOrbRelax: The mix_relax parameter defines the relative weight of the new relaxation vector that is added to the one from the previous iteration.
:vartype DampOrbRelax: float | FloatKey
:ivar DampVariable: Damping condition
:vartype DampVariable: BoolType | BoolKey
:ivar InitGuess: Initial guess
:vartype InitGuess: Literal["TDDFT", "SOR"]
:ivar RelaxAlpha: The SCF cycle number at which the relaxation of alpha orbitals starts.
:vartype RelaxAlpha: int | IntKey
:ivar RelaxBeta: The SCF cycle number at which the relaxation of beta orbitals starts.
:vartype RelaxBeta: int | IntKey
"""
def __post_init__(self):
self.DampOrbRelax: float | FloatKey = FloatKey(name='DampOrbRelax', comment='The mix_relax parameter defines the relative weight of the new relaxation vector that is added to the one from the previous iteration.', default=0.2)
self.DampVariable: BoolType | BoolKey = BoolKey(name='DampVariable', comment='Damping condition', default=False)
self.InitGuess: Literal["TDDFT", "SOR"] = MultipleChoiceKey(name='InitGuess', comment='Initial guess', default='TDDFT', choices=['TDDFT', 'SOR'])
self.RelaxAlpha: int | IntKey = IntKey(name='RelaxAlpha', comment='The SCF cycle number at which the relaxation of alpha orbitals starts.', default=1)
self.RelaxBeta: int | IntKey = IntKey(name='RelaxBeta', comment='The SCF cycle number at which the relaxation of beta orbitals starts.', default=1)
[docs] class _SCF_CV_DFT(FixedBlock):
r"""
The simplest case: the TDDFT transition density U-vector is substituted into the infinite order CV(infinity)-DFT excitation energy
:ivar DampVariable: Damping condition
:vartype DampVariable: BoolType | BoolKey
:ivar Damping: Damping
:vartype Damping: float | FloatKey
:ivar InitGuess: Initial guess
:vartype InitGuess: Literal["TDDFT", "SOR"]
"""
def __post_init__(self):
self.DampVariable: BoolType | BoolKey = BoolKey(name='DampVariable', comment='Damping condition', default=False)
self.Damping: float | FloatKey = FloatKey(name='Damping', comment='Damping', default=0.2)
self.InitGuess: Literal["TDDFT", "SOR"] = MultipleChoiceKey(name='InitGuess', comment='Initial guess', default='TDDFT', choices=['TDDFT', 'SOR'])
def __post_init__(self):
self.Iteration: int | IntKey = IntKey(name='Iteration', comment='The maximum number of iterations', default=50)
self.Tolerance: float | FloatKey = FloatKey(name='Tolerance', comment='The convergence criterion, i.e. the SCF-CV(infinity)-DFT procedure stops when the given accuracy is achieved.', default=0.0001)
self.CV_DFT: ADF._CVNDFT._CV_DFT = self._CV_DFT(name='CV_DFT', comment='The simplest case: the TDDFT transition density U-vector is substituted into the infinite order CV(infinity)-DFT excitation energy', header=True)
self.DSCF_CV_DFT: ADF._CVNDFT._DSCF_CV_DFT = self._DSCF_CV_DFT(name='DSCF_CV_DFT', comment='The simplest case: the TDDFT transition density U-vector is substituted into the infinite order CV(infinity)-DFT excitation energy', header=True)
self.RSCF_CV_DFT: ADF._CVNDFT._RSCF_CV_DFT = self._RSCF_CV_DFT(name='RSCF_CV_DFT', comment='The simplest case: the TDDFT transition density U-vector is substituted into the infinite order CV(infinity)-DFT excitation energy', header=True)
self.R_CV_DFT: ADF._CVNDFT._R_CV_DFT = self._R_CV_DFT(name='R_CV_DFT', comment='The simplest case: the TDDFT transition density U-vector is substituted into the infinite order CV(infinity)-DFT excitation energy', header=True)
self.SCF_CV_DFT: ADF._CVNDFT._SCF_CV_DFT = self._SCF_CV_DFT(name='SCF_CV_DFT', comment='The simplest case: the TDDFT transition density U-vector is substituted into the infinite order CV(infinity)-DFT excitation energy', header=True)
[docs] class _ConceptualDFT(FixedBlock):
r"""
Conceptual DFT Properties
:ivar AnalysisLevel: Set the level of the ConceptualDFT analysis:
Normal - global descriptors only,
Extended - both global and condensed (QTAIM) local descriptors,
Full - all descriptors including non local ones.
:vartype AnalysisLevel: Literal["Normal", "Extended", "Full"]
:ivar AtomsToDo: Define a subset of atoms for which properties are calculated. If the [Domains] block is present then this list specifies which atoms are used to define the domains bounding box.
:vartype AtomsToDo: Iterable[int] | IntListKey
:ivar Electronegativity: Calculate atomic electronegativities. Requires an all-electron calculation (no frozen core), triggers the TotalEnergy and increases the [AnalysisLevel] to at least Extended.
:vartype Electronegativity: BoolType | BoolKey
:ivar Enabled: Calculate Conceptual DFT properties.
:vartype Enabled: BoolType | BoolKey
:ivar Domains: Calculate integrated properties for the domains (same sign) of the dual descriptor.
:vartype Domains: ADF._ConceptualDFT._Domains
"""
[docs] class _Domains(FixedBlock):
r"""
Calculate integrated properties for the domains (same sign) of the dual descriptor.
:ivar Border: Set the extent of the Cartesian grid. Extent is the distance between a face of the grid's bounding box and the most outlying atom in the corresponding direction. If the [AtomsToDo] key is present, the bounding box is created around the specified atoms.
:vartype Border: float | FloatKey
:ivar Display: Domains for which the integrated DD value is smaller (in magnitude) than the specified value are omitted from the printed output.
:vartype Display: float | FloatKey
:ivar Enabled: Calculate properties of reactivity domains.
:vartype Enabled: BoolType | BoolKey
:ivar Ensemble: Statistical ensemble for DD domains. Canonical: DD values are calculated using the statistical canonical ensemble. GrandCanonical: DD values are calculated using the statistical grand canonical ensemble. The grand canonical DD corresponds to (S^2 f(2) - (gamma/eta^3) f^0), where f(2) is the canonical DD, gamma and eta - the hyper-hardness and hardness of the chemical system, respectively, and f^0 is the mean Fukui function. This statistical ensemble is a natural choice when comparing two chemical systems with a different number of electrons.
:vartype Ensemble: Literal["Canonical", "GrandCanonical"]
:ivar Radius: This option adds a sphere around each nucleus, excluding all points inside it. This can help to separate domains around an atom or to exclude core electrons. Be careful when using this option. In particular, the radius of the sphere should exceed two or three times the [Spacing] value to be effective. By default, no spheres are added.
:vartype Radius: float | FloatKey
:ivar Spacing: Specifies spacing (distance between neighboring points) of the rectangular Cartesian grid used when searching for DD domains. It may be useful to specify a smaller value (or increase the size of the grid, see [Border] key) if a substantial part of the electronic density is accounted for.
:vartype Spacing: float | FloatKey
:ivar Threshold: Arbitrary value of dual descriptor used to separate DD domains (values below this threshold are ignored).
:vartype Threshold: float | FloatKey
"""
def __post_init__(self):
self.Border: float | FloatKey = FloatKey(name='Border', comment="Set the extent of the Cartesian grid. Extent is the distance between a face of the grid's bounding box and the most outlying atom in the corresponding direction. If the [AtomsToDo] key is present, the bounding box is created around the specified atoms.", default=7.0, unit='Bohr')
self.Display: float | FloatKey = FloatKey(name='Display', comment='Domains for which the integrated DD value is smaller (in magnitude) than the specified value are omitted from the printed output.', default=0.005)
self.Enabled: BoolType | BoolKey = BoolKey(name='Enabled', comment='Calculate properties of reactivity domains.', gui_name='Properties of reactivity domains:', default=False)
self.Ensemble: Literal["Canonical", "GrandCanonical"] = MultipleChoiceKey(name='Ensemble', comment='Statistical ensemble for DD domains. Canonical: DD values are calculated using the statistical canonical ensemble. GrandCanonical: DD values are calculated using the statistical grand canonical ensemble. The grand canonical DD corresponds to (S^2 f(2) - (gamma/eta^3) f^0), where f(2) is the canonical DD, gamma and eta - the hyper-hardness and hardness of the chemical system, respectively, and f^0 is the mean Fukui function. This statistical ensemble is a natural choice when comparing two chemical systems with a different number of electrons.', default='Canonical', choices=['Canonical', 'GrandCanonical'])
self.Radius: float | FloatKey = FloatKey(name='Radius', comment='This option adds a sphere around each nucleus, excluding all points inside it. This can help to separate domains around an atom or to exclude core electrons. Be careful when using this option. In particular, the radius of the sphere should exceed two or three times the [Spacing] value to be effective. By default, no spheres are added.', default=0.0)
self.Spacing: float | FloatKey = FloatKey(name='Spacing', comment='Specifies spacing (distance between neighboring points) of the rectangular Cartesian grid used when searching for DD domains. It may be useful to specify a smaller value (or increase the size of the grid, see [Border] key) if a substantial part of the electronic density is accounted for.', default=0.1, unit='Bohr')
self.Threshold: float | FloatKey = FloatKey(name='Threshold', comment='Arbitrary value of dual descriptor used to separate DD domains (values below this threshold are ignored).', default=0.001)
def __post_init__(self):
self.AnalysisLevel: Literal["Normal", "Extended", "Full"] = MultipleChoiceKey(name='AnalysisLevel', comment='Set the level of the ConceptualDFT analysis:\n\n Normal - global descriptors only,\n\n Extended - both global and condensed (QTAIM) local descriptors,\n\n Full - all descriptors including non local ones.', default='Normal', choices=['Normal', 'Extended', 'Full'])
self.AtomsToDo: Iterable[int] | IntListKey = IntListKey(name='AtomsToDo', comment='Define a subset of atoms for which properties are calculated. If the [Domains] block is present then this list specifies which atoms are used to define the domains bounding box.', gui_name='Include atoms:', isatomlist=True)
self.Electronegativity: BoolType | BoolKey = BoolKey(name='Electronegativity', comment='Calculate atomic electronegativities. Requires an all-electron calculation (no frozen core), triggers the TotalEnergy and increases the [AnalysisLevel] to at least Extended.', gui_name='Atomic electronegativities:', default=False)
self.Enabled: BoolType | BoolKey = BoolKey(name='Enabled', comment='Calculate Conceptual DFT properties.', gui_name='Conceptual DFT (FMO): Calculate', default=False)
self.Domains: ADF._ConceptualDFT._Domains = self._Domains(name='Domains', comment='Calculate integrated properties for the domains (same sign) of the dual descriptor.')
[docs] class _ConstructPot(FixedBlock):
r"""
Reads a density from a TAPE41 file and constructs numerically the corresponding potential to it
:ivar CPBasis:
:vartype CPBasis: BoolType | BoolKey
:ivar CPGrid:
:vartype CPGrid: BoolType | BoolKey
:ivar Converge:
:vartype Converge: float | FloatKey
:ivar CutNegativeDens:
:vartype CutNegativeDens: float | FloatKey
:ivar Damp:
:vartype Damp: float | FloatKey
:ivar DensConv:
:vartype DensConv: float | FloatKey
:ivar EigenShift:
:vartype EigenShift: float | FloatKey
:ivar FitBas:
:vartype FitBas: BoolType | BoolKey
:ivar FixedLambda:
:vartype FixedLambda: BoolType | BoolKey
:ivar ImportDens: Filename of density...
:vartype ImportDens: str | StringKey
:ivar Lambda:
:vartype Lambda: float | FloatKey
:ivar PotBas: Filename...
:vartype PotBas: str | StringKey
:ivar PotProj:
:vartype PotProj: str | StringKey
:ivar ProjChange:
:vartype ProjChange: float | FloatKey
:ivar ProjSmallDens:
:vartype ProjSmallDens: float | FloatKey
:ivar QPiterations:
:vartype QPiterations: int | IntKey
:ivar SVD:
:vartype SVD: BoolType | BoolKey
:ivar SmallEigThresh:
:vartype SmallEigThresh: float | FloatKey
:ivar StartPot: Filename of potential...
:vartype StartPot: str | StringKey
:ivar StepSize:
:vartype StepSize: float | FloatKey
:ivar TIKH:
:vartype TIKH: float | FloatKey
"""
def __post_init__(self):
self.CPBasis: BoolType | BoolKey = BoolKey(name='CPBasis', default=True)
self.CPGrid: BoolType | BoolKey = BoolKey(name='CPGrid', default=False)
self.Converge: float | FloatKey = FloatKey(name='Converge', default=1e-06)
self.CutNegativeDens: float | FloatKey = FloatKey(name='CutNegativeDens', default=0.0001)
self.Damp: float | FloatKey = FloatKey(name='Damp', default=1.0)
self.DensConv: float | FloatKey = FloatKey(name='DensConv')
self.EigenShift: float | FloatKey = FloatKey(name='EigenShift', default=0.01)
self.FitBas: BoolType | BoolKey = BoolKey(name='FitBas', default=True)
self.FixedLambda: BoolType | BoolKey = BoolKey(name='FixedLambda', default=False)
self.ImportDens: str | StringKey = StringKey(name='ImportDens', comment='Filename of density...')
self.Lambda: float | FloatKey = FloatKey(name='Lambda', default=0.01)
self.PotBas: str | StringKey = StringKey(name='PotBas', comment='Filename...')
self.PotProj: str | StringKey = StringKey(name='PotProj')
self.ProjChange: float | FloatKey = FloatKey(name='ProjChange', default=-1.0)
self.ProjSmallDens: float | FloatKey = FloatKey(name='ProjSmallDens', default=1e-50)
self.QPiterations: int | IntKey = IntKey(name='QPiterations', default=1000)
self.SVD: BoolType | BoolKey = BoolKey(name='SVD', default=False)
self.SmallEigThresh: float | FloatKey = FloatKey(name='SmallEigThresh', default=0.0001)
self.StartPot: str | StringKey = StringKey(name='StartPot', comment='Filename of potential...')
self.StepSize: float | FloatKey = FloatKey(name='StepSize', default=1.0)
self.TIKH: float | FloatKey = FloatKey(name='TIKH', default=0.0)
[docs] class _CorePotentials(FreeBlock):
r"""
With the key COREPOTENTIALS you specify the core file and (optionally) which sections pertain to the distinct atom types in the molecule.
"""
def __post_init__(self):
pass
[docs] class _CurrentResponse(FixedBlock):
r"""
:ivar CDSpec:
:vartype CDSpec: BoolType | BoolKey
:ivar Damping:
:vartype Damping: float | FloatKey
:ivar GTensor:
:vartype GTensor: BoolType | BoolKey
:ivar Magnet:
:vartype Magnet: BoolType | BoolKey
:ivar NCT:
:vartype NCT: float | FloatKey
:ivar NMRShielding:
:vartype NMRShielding: BoolType | BoolKey
:ivar NoVK:
:vartype NoVK: BoolType | BoolKey
:ivar PARTVK:
:vartype PARTVK: float | FloatKey
:ivar Parabolic:
:vartype Parabolic: float | FloatKey
:ivar QIANVignale:
:vartype QIANVignale: BoolType | BoolKey
:ivar Static:
:vartype Static: BoolType | BoolKey
"""
def __post_init__(self):
self.CDSpec: BoolType | BoolKey = BoolKey(name='CDSpec', default=False)
self.Damping: float | FloatKey = FloatKey(name='Damping', default=0.0)
self.GTensor: BoolType | BoolKey = BoolKey(name='GTensor', default=False)
self.Magnet: BoolType | BoolKey = BoolKey(name='Magnet', default=False)
self.NCT: float | FloatKey = FloatKey(name='NCT', default=0.0)
self.NMRShielding: BoolType | BoolKey = BoolKey(name='NMRShielding', default=False)
self.NoVK: BoolType | BoolKey = BoolKey(name='NoVK', default=False)
self.PARTVK: float | FloatKey = FloatKey(name='PARTVK', default=1.0)
self.Parabolic: float | FloatKey = FloatKey(name='Parabolic', default=0.0)
self.QIANVignale: BoolType | BoolKey = BoolKey(name='QIANVignale', default=False)
self.Static: BoolType | BoolKey = BoolKey(name='Static', default=False)
[docs] class _DIMPAR(FreeBlock):
r"""
In this block, the parameters for the DIM atoms are defined in DIM/QM calculations.
"""
def __post_init__(self):
pass
[docs] class _DIMQM(FreeBlock):
r"""
Input for DIM/QM
"""
def __post_init__(self):
pass
[docs] class _Dependency(FixedBlock):
r"""
:ivar Enabled: Used to make the basis or fit set linearly independent, up to the threshold specified below.
This is typically important when you have many diffuse functions in your basis or fit set.
:vartype Enabled: BoolType | BoolKey
:ivar bas: A criterion applied to the overlap matrix of unoccupied normalized SFOs. Eigenvectors corresponding to smaller eigenvalues are eliminated from the valence space.
Note: if you choose a very coarse value, you will remove too many degrees of freedom in the basis set, while if you choose it too strict, the numerical problems may not be countered adequately.
:vartype bas: float | FloatKey
:ivar eig: Merely a technical parameter. When the DEPENDENCY key is activated, any rejected basis functions (i.e.: linear combinations that correspond with small eigenvalues in the virtual SFOs overlap matrix) are normally processed until diagonalization of the Fock matrix takes place. At that point, all matrix elements corresponding to rejected functions are set to zero (off-diagonal) and BigEig (diagonal).
In AMSinput you must check the Fix Linear dependency check box for this option to be used.
:vartype eig: float | FloatKey
:ivar fit: Similar to Dependency%bas.
The criterion is now applied to the overlap matrix of fit functions.
The fit coefficients, which give the approximate expansion of the charge density in terms of the fit functions (for the evaluation of the coulomb potential) are set to zero for fit functions (i.e.: combinations of) corresponding to small-eigenvalue eigenvectors of the fit overlap matrix.
:vartype fit: float | FloatKey
"""
def __post_init__(self):
self.Enabled: BoolType | BoolKey = BoolKey(name='Enabled', comment='Used to make the basis or fit set linearly independent, up to the threshold specified below.\nThis is typically important when you have many diffuse functions in your basis or fit set.', gui_name='Fix dependencies:', default=False)
self.bas: float | FloatKey = FloatKey(name='bas', comment='A criterion applied to the overlap matrix of unoccupied normalized SFOs. Eigenvectors corresponding to smaller eigenvalues are eliminated from the valence space.\n\nNote: if you choose a very coarse value, you will remove too many degrees of freedom in the basis set, while if you choose it too strict, the numerical problems may not be countered adequately.', gui_name='Threshold for basis:', default=0.0001)
self.eig: float | FloatKey = FloatKey(name='eig', comment='Merely a technical parameter. When the DEPENDENCY key is activated, any rejected basis functions (i.e.: linear combinations that correspond with small eigenvalues in the virtual SFOs overlap matrix) are normally processed until diagonalization of the Fock matrix takes place. At that point, all matrix elements corresponding to rejected functions are set to zero (off-diagonal) and BigEig (diagonal).\n\nIn AMSinput you must check the Fix Linear dependency check box for this option to be used.', default=100000000.0)
self.fit: float | FloatKey = FloatKey(name='fit', comment='Similar to Dependency%bas.\n\nThe criterion is now applied to the overlap matrix of fit functions.\n\nThe fit coefficients, which give the approximate expansion of the charge density in terms of the fit functions (for the evaluation of the coulomb potential) are set to zero for fit functions (i.e.: combinations of) corresponding to small-eigenvalue eigenvectors of the fit overlap matrix.', gui_name='Threshold for fit:', default=1e-10)
[docs] class _EPrint(FixedBlock):
r"""
Print switches that require more specification than just off or on
:ivar AtomPop: Mulliken population analysis on a per-atom basis
:vartype AtomPop: str | StringKey
:ivar BASPop: Mulliken population analysis on a per-bas-function basis
:vartype BASPop: str | StringKey
:ivar Eigval: One-electron orbital energies
:vartype Eigval: str | StringKey
:ivar Fit: Fit functions and fit coefficients
:vartype Fit: str | StringKey
:ivar Frag: Building of the molecule from fragments
:vartype Frag: str | StringKey
:ivar FragPop: Mulliken population analysis on a per fragment basis
:vartype FragPop: str | StringKey
:ivar Freq: Intermediate results in the computation of frequencies (see debug: freq).
:vartype Freq: str | StringKey
:ivar GeoStep: Geometry updates (Optimization, Transition State, ...)
:vartype GeoStep: str | StringKey
:ivar NumInt: Numerical Integration
:vartype NumInt: str | StringKey
:ivar OrbPopEr: Energy Range (ER) in hartree units for the OrbPop subkey
:vartype OrbPopEr: str | StringKey
:ivar Repeat: Repetition of output in Geometry iterations (SCF, optimization, ...)
:vartype Repeat: str | StringKey
:ivar SCF: Self Consistent Field procedure
:vartype SCF: str | StringKey
:ivar SFO: Information related to the Symmetrized Fragment Orbitals and the analysis
:vartype SFO: str | StringKey
:ivar TF: Transition Field method
:vartype TF: str | StringKey
:ivar OrbPop: (Mulliken type) population analysis for individual MOs
:vartype OrbPop: str | Sequence[str] | FreeBlock
"""
[docs] class _OrbPop(FreeBlock):
r"""
(Mulliken type) population analysis for individual MOs
"""
def __post_init__(self):
pass
def __post_init__(self):
self.AtomPop: str | StringKey = StringKey(name='AtomPop', comment='Mulliken population analysis on a per-atom basis')
self.BASPop: str | StringKey = StringKey(name='BASPop', comment='Mulliken population analysis on a per-bas-function basis')
self.Eigval: str | StringKey = StringKey(name='Eigval', comment='One-electron orbital energies')
self.Fit: str | StringKey = StringKey(name='Fit', comment='Fit functions and fit coefficients')
self.Frag: str | StringKey = StringKey(name='Frag', comment='Building of the molecule from fragments')
self.FragPop: str | StringKey = StringKey(name='FragPop', comment='Mulliken population analysis on a per fragment basis')
self.Freq: str | StringKey = StringKey(name='Freq', comment='Intermediate results in the computation of frequencies (see debug: freq).')
self.GeoStep: str | StringKey = StringKey(name='GeoStep', comment='Geometry updates (Optimization, Transition State, ...)')
self.NumInt: str | StringKey = StringKey(name='NumInt', comment='Numerical Integration')
self.OrbPopEr: str | StringKey = StringKey(name='OrbPopEr', comment='Energy Range (ER) in hartree units for the OrbPop subkey')
self.Repeat: str | StringKey = StringKey(name='Repeat', comment='Repetition of output in Geometry iterations (SCF, optimization, ...)')
self.SCF: str | StringKey = StringKey(name='SCF', comment='Self Consistent Field procedure')
self.SFO: str | StringKey = StringKey(name='SFO', comment='Information related to the Symmetrized Fragment Orbitals and the analysis')
self.TF: str | StringKey = StringKey(name='TF', comment='Transition Field method')
self.OrbPop: str | Sequence[str] | FreeBlock = self._OrbPop(name='OrbPop', comment='(Mulliken type) population analysis for individual MOs', header=True)
[docs] class _ESR(FixedBlock):
r"""
:ivar AnaPol: Expert option for ESR.
:vartype AnaPol: BoolType | BoolKey
:ivar Enabled: Calculate ESR (g- and/or A tensors)
:vartype Enabled: BoolType | BoolKey
:ivar GaugeOrigin: Can be used in ESR to set gauge origin.
:vartype GaugeOrigin: Iterable[float] | FloatListKey
:ivar NoESRfcsd: Debug option in ESR.
:vartype NoESRfcsd: BoolType | BoolKey
:ivar NoESRpso: Debug option in ESR.
:vartype NoESRpso: BoolType | BoolKey
:ivar PARANMR: Paramagnetic part NMR shielding.
:vartype PARANMR: BoolType | BoolKey
:ivar nogiao: Debug option for ESR g-tensor
:vartype nogiao: BoolType | BoolKey
"""
def __post_init__(self):
self.AnaPol: BoolType | BoolKey = BoolKey(name='AnaPol', comment='Expert option for ESR.', hidden=True, default=False)
self.Enabled: BoolType | BoolKey = BoolKey(name='Enabled', comment='Calculate ESR (g- and/or A tensors)', default=False)
self.GaugeOrigin: Iterable[float] | FloatListKey = FloatListKey(name='GaugeOrigin', comment='Can be used in ESR to set gauge origin.', hidden=True)
self.NoESRfcsd: BoolType | BoolKey = BoolKey(name='NoESRfcsd', comment='Debug option in ESR.', hidden=True, default=False)
self.NoESRpso: BoolType | BoolKey = BoolKey(name='NoESRpso', comment='Debug option in ESR.', hidden=True, default=False)
self.PARANMR: BoolType | BoolKey = BoolKey(name='PARANMR', comment='Paramagnetic part NMR shielding.', default=False)
self.nogiao: BoolType | BoolKey = BoolKey(name='nogiao', comment='Debug option for ESR g-tensor', hidden=True, default=False)
[docs] class _ETSNOCV(FixedBlock):
r"""
Perform ETS-NOCV analysis.
:ivar DEBUGTV: For T/V debugging
:vartype DEBUGTV: BoolType | BoolKey
:ivar EKMin: The threshold for orbital interaction energy contributions corresponding to deformation density components originating from each NOCV-pairs
:vartype EKMin: float | FloatKey
:ivar ENOCV: The threshold for NOCV-eigenvalues
:vartype ENOCV: float | FloatKey
:ivar Enabled: Perform ETS-NOCV analysis.
:vartype Enabled: BoolType | BoolKey
:ivar RhoKMin: The threshold for population analysis of each deformation density contribution in terms of individual SFOs.
:vartype RhoKMin: float | FloatKey
:ivar TVanalysis: Perform T/V decomposition
:vartype TVanalysis: BoolType | BoolKey
"""
def __post_init__(self):
self.DEBUGTV: BoolType | BoolKey = BoolKey(name='DEBUGTV', comment='For T/V debugging', hidden=True, default=False)
self.EKMin: float | FloatKey = FloatKey(name='EKMin', comment='The threshold for orbital interaction energy contributions corresponding to deformation density components originating from each NOCV-pairs', gui_name='Energy threshold:', default=2.0, unit='kcal/mol')
self.ENOCV: float | FloatKey = FloatKey(name='ENOCV', comment='The threshold for NOCV-eigenvalues', gui_name='NOCVs with ev larger than:', default=0.05)
self.Enabled: BoolType | BoolKey = BoolKey(name='Enabled', comment='Perform ETS-NOCV analysis.', default=False)
self.RhoKMin: float | FloatKey = FloatKey(name='RhoKMin', comment='The threshold for population analysis of each deformation density contribution in terms of individual SFOs.', gui_name='Population threshold:', default=0.01)
self.TVanalysis: BoolType | BoolKey = BoolKey(name='TVanalysis', comment='Perform T/V decomposition', gui_name='T/V analysis', default=False)
[docs] class _ElectronTransfer(FixedBlock):
r"""
Block key for charge transfer integrals with FDE.
:ivar CDFT:
:vartype CDFT: BoolType | BoolKey
:ivar Debug:
:vartype Debug: BoolType | BoolKey
:ivar Disjoint:
:vartype Disjoint: BoolType | BoolKey
:ivar FDE:
:vartype FDE: BoolType | BoolKey
:ivar InvThr:
:vartype InvThr: float | FloatKey
:ivar Joint:
:vartype Joint: BoolType | BoolKey
:ivar KNADD:
:vartype KNADD: BoolType | BoolKey
:ivar NonCT:
:vartype NonCT: BoolType | BoolKey
:ivar NumFrag:
:vartype NumFrag: int | IntKey
:ivar Print:
:vartype Print: str | StringKey
"""
def __post_init__(self):
self.CDFT: BoolType | BoolKey = BoolKey(name='CDFT', default=False)
self.Debug: BoolType | BoolKey = BoolKey(name='Debug', default=False)
self.Disjoint: BoolType | BoolKey = BoolKey(name='Disjoint')
self.FDE: BoolType | BoolKey = BoolKey(name='FDE', default=False)
self.InvThr: float | FloatKey = FloatKey(name='InvThr', default=0.001)
self.Joint: BoolType | BoolKey = BoolKey(name='Joint')
self.KNADD: BoolType | BoolKey = BoolKey(name='KNADD', default=False)
self.NonCT: BoolType | BoolKey = BoolKey(name='NonCT', default=False)
self.NumFrag: int | IntKey = IntKey(name='NumFrag')
self.Print: str | StringKey = StringKey(name='Print')
[docs] class _EnergyFrag(FreeBlock):
r"""
"""
def __post_init__(self):
pass
[docs] class _Excitations(FixedBlock):
r"""
Excitation energies: UV/Vis
:ivar AAS: Use the molecular orbitals from a DFT ground state calculation as input to an excited state calculation with TDDFT-aas coupling matrices
:vartype AAS: BoolType | BoolKey
:ivar AASALPHA: optimal alpha value for TDDFT-aas method
:vartype AASALPHA: float | FloatKey
:ivar ALLXASMOMENTS: To be used in combination with XAS. This will print out all the individual transition moments used within the calculation of the total oscillator strength
:vartype ALLXASMOMENTS: BoolType | BoolKey
:ivar ALLXASQUADRUPOLE: To be used in combination with XAS.This will print out the individual oscillator strength components to the total oscillator strength.
:vartype ALLXASQUADRUPOLE: BoolType | BoolKey
:ivar Allowed: Treat only those irreducible representations for which the oscillator strengths will be nonzero (as opposed to all)
:vartype Allowed: BoolType | BoolKey
:ivar AlsoRestricted: Include also excitation energies in which a spin-restricted exchange-correlation kernel is used
:vartype AlsoRestricted: BoolType | BoolKey
:ivar Analytical: The required integrals for the CD spectrum are calculated analytically, instead of numerically. Only used in case of CD spectrum
:vartype Analytical: BoolType | BoolKey
:ivar AsympCor:
:vartype AsympCor: float | FloatKey
:ivar BSE: Solve the static Bethe-Salpeter equation based on a GW calculation
:vartype BSE: BoolType | BoolKey
:ivar BSEscreening: Solve the static Bethe-Salpeter equation based on a GW-BSE calculation, i.e. the screening entering the excitation calculation is calculated at the BSE level of theory instead of the RPA.
:vartype BSEscreening: BoolType | BoolKey
:ivar CDSpectrum: Compute the rotatory strengths for the calculated excitations, in order to simulate Circular Dichroism (CD) spectra
:vartype CDSpectrum: BoolType | BoolKey
:ivar DBSE: Solve the dynamic Bethe-Salpeter equation based on a GW calculation in the diagonal approximation for the GW kernel
:vartype DBSE: BoolType | BoolKey
:ivar DTensor: MCD gtensor
:vartype DTensor: str | StringKey
:ivar Descriptors: Compute charge-transfer descriptors and SFO analysis
:vartype Descriptors: BoolType | BoolKey
:ivar Descriptors_CT_AT_Rab: Atomic distance criterion used for the calculation of CT_AT descriptors
:vartype Descriptors_CT_AT_Rab: float | FloatKey
:ivar ESESTDM: Compute transition dipole moments between excited states
:vartype ESESTDM: BoolType | BoolKey
:ivar FullKernel: Use the non-ALDA kernel (with XCFUN)
:vartype FullKernel: BoolType | BoolKey
:ivar GTensor: MCD gtensor
:vartype GTensor: str | StringKey
:ivar HDA: Activate the diagonal HF exchange approximation.
This is only relevant if a (meta-)hybrid is used in the SCF.
:vartype HDA: BoolType | BoolKey
:ivar HDA_CutOff: This is cutoff based on differences in energy between eps_virt-eps_occ, to reduce number of diagonal HF exchange integrals.
:vartype HDA_CutOff: float | FloatKey
:ivar Iterations: The maximum number of attempts within which the Davidson algorithm has to converge
:vartype Iterations: int | IntKey
:ivar KFWrite: If kfwrite is 0 then do not write contributions, transition densities, and restart vectors to TAPE21, since this can lead to a huge TAPE21, especially if many excitations are calculated. 3 means that contributions, transition densities, and restart vectors are written to TAPE21.
:vartype KFWrite: int | IntKey
:ivar Lowest: Number of lowest excitations to compute
:vartype Lowest: Iterable[int] | IntListKey
:ivar MAXPRINTED: The maximum number of printed contributions
:vartype MAXPRINTED: int | IntKey
:ivar MCD: TODO: Magnetic Circular Dichroism
:vartype MCD: str | StringKey
:ivar NTO: Compute the Natural Transition Orbitals
:vartype NTO: BoolType | BoolKey
:ivar N_HDA_integral: Maximum number of HDA integrals
:vartype N_HDA_integral: int | IntKey
:ivar N_SFO: Number of SFO analyzed and printed
:vartype N_SFO: int | IntKey
:ivar Nospinsocd: Turn off calculation of spin operator matrices in spin-orbit relativistic CD spectrum calculations
:vartype Nospinsocd: BoolType | BoolKey
:ivar OnlySing: Compute only singlet-singlet excitations
:vartype OnlySing: BoolType | BoolKey
:ivar OnlyTrip: Compute only singlet-triplet excitations
:vartype OnlyTrip: BoolType | BoolKey
:ivar Orthonormality: The Davidson algorithm orthonormalizes its trial vectors. Increasing the default orthonormality criterion increases the CPU time somewhat, but is another useful check on the reliability of the results.
:vartype Orthonormality: float | FloatKey
:ivar Residu:
:vartype Residu: float | FloatKey
:ivar SDKernelType: Choose specific kernel approximation in case of ROKS-SD-TDA or ROKS-SD-CIS.
:vartype SDKernelType: Literal["Collinear", "NonCollinear", "QuasiNonCollinear"]
:ivar SFOAnalysis: Do SFO analysis
:vartype SFOAnalysis: BoolType | BoolKey
:ivar SOSFreq:
:vartype SOSFreq: float | FloatKey
:ivar STDA: Simplified Tamm-Dancoff approach
:vartype STDA: BoolType | BoolKey
:ivar STDDFT: Simplified time-dependent DFT
:vartype STDDFT: BoolType | BoolKey
:ivar ScaleCoul: Scaling of Coulomb kernel with scale parameter
:vartype ScaleCoul: float | FloatKey
:ivar ScaleHF: Scaling of the HF part of the kernel with scale parameter
:vartype ScaleHF: float | FloatKey
:ivar ScaleXC: Scaling of the XC-kernel (excluding a possible HF-part) with scale parameter
:vartype ScaleXC: float | FloatKey
:ivar Select: Rather than selecting the first nmcdterm transitions for consideration individual transitions can be selected through the SELECT keyword
:vartype Select: str | StringKey
:ivar SingleOrbTrans: keyword to use only orbital energy differences
:vartype SingleOrbTrans: BoolType | BoolKey
:ivar TD-DFTB: Use the molecular orbitals from a DFT ground state calculation as input to an excited state calculation with TD-DFTB coupling matrices
:vartype TD-DFTB: BoolType | BoolKey
:ivar TDA-DFTB: Use the molecular orbitals from a DFT ground state calculation as input to an excited state calculation with TDA-DFTB coupling matrices
:vartype TDA-DFTB: BoolType | BoolKey
:ivar THRESHPRINTED: Loop until 100 x THRESHPRINTED percent of the transition is found or MAXPRINTED contributions are printed
:vartype THRESHPRINTED: float | FloatKey
:ivar Tolerance:
:vartype Tolerance: float | FloatKey
:ivar Vectors: The maximum number of trial vectors in the Davidson algorithm for which space is allocated. If this number is small less memory will be needed, but the trial vector space is smaller and has to be collapsed more often, at the expense of CPU time. The default if usually adequate.
:vartype Vectors: int | IntKey
:ivar Velocity: Calculates the dipole-velocity representation of the oscillator strength. If applicable, the dipole-velocity representation of the rotatory strength is calculated. Default the dipole-length representation of the oscillator strength and rotatory strength is calculated
:vartype Velocity: BoolType | BoolKey
:ivar XAS: Calculation of the higher order multipole moment integrals and the calculation of the quadrupole oscillator strengths. This will only print the total oscillator strength and the excitation energy.
:vartype XAS: BoolType | BoolKey
:ivar Davidson: Use the Davidson procedure
:vartype Davidson: str | Sequence[str] | FreeBlock
:ivar Exact: The most straightforward procedure is a direct diagonalization of the matrix from which the excitation energies and oscillator strengths are obtained. Since the matrix may become very large, this option is possible only for very small molecules
:vartype Exact: str | Sequence[str] | FreeBlock
:ivar RoksTddftType: Excitation energies from RoksTddft: UV/Vis
:vartype RoksTddftType: ADF._Excitations._RoksTddftType
"""
[docs] class _Davidson(FreeBlock):
r"""
Use the Davidson procedure
"""
def __post_init__(self):
pass
[docs] class _Exact(FreeBlock):
r"""
The most straightforward procedure is a direct diagonalization of the matrix from which the excitation energies and oscillator strengths are obtained. Since the matrix may become very large, this option is possible only for very small molecules
"""
def __post_init__(self):
pass
[docs] class _RoksTddftType(FixedBlock):
r"""
Excitation energies from RoksTddft: UV/Vis
:ivar Calculate: Specifies the types of RoksTddft methods to target several target spins: spin-down (SD), same-spin (SS), and/or spin-up (SU).
:vartype Calculate: Literal["None", "SD", "SS", "SU", "SD-SS", "SS-SU", "SD-SS-SU"]
:ivar SDType: Specifies the flavor to be used in the case of SD-type RoksTddft
:vartype SDType: Literal["None", "SD-TDA", "SD-CIS", "QSD-TDA"]
:ivar SSType: Specifies the flavor to be used in the case of SS-type RoksTddft
:vartype SSType: Literal["None", "R-TDA", "S-TDA", "X-TDA"]
:ivar SUType: Specifies the flavor to be used in the case of SF-type RoksTddft
:vartype SUType: Literal["None", "SF-TDA"]
"""
def __post_init__(self):
self.Calculate: Literal["None", "SD", "SS", "SU", "SD-SS", "SS-SU", "SD-SS-SU"] = MultipleChoiceKey(name='Calculate', comment='Specifies the types of RoksTddft methods to target several target spins: spin-down (SD), same-spin (SS), and/or spin-up (SU).', gui_name='RoksTddft Calculate:', default='SS', choices=['None', 'SD', 'SS', 'SU', 'SD-SS', 'SS-SU', 'SD-SS-SU'], hiddenchoices=['None', 'SD-SS', 'SS-SU', 'SD-SS-SU'])
self.SDType: Literal["None", "SD-TDA", "SD-CIS", "QSD-TDA"] = MultipleChoiceKey(name='SDType', comment='Specifies the flavor to be used in the case of SD-type RoksTddft', gui_name='RoksTddft SD-Type:', default='QSD-TDA', choices=['None', 'SD-TDA', 'SD-CIS', 'QSD-TDA'], hiddenchoices=['None', 'SD-TDA', 'SD-CIS', 'QSD-TDA'])
self.SSType: Literal["None", "R-TDA", "S-TDA", "X-TDA"] = MultipleChoiceKey(name='SSType', comment='Specifies the flavor to be used in the case of SS-type RoksTddft', gui_name='RoksTddft SS-Type:', default='S-TDA', choices=['None', 'R-TDA', 'S-TDA', 'X-TDA'], hiddenchoices=['None'])
self.SUType: Literal["None", "SF-TDA"] = MultipleChoiceKey(name='SUType', comment='Specifies the flavor to be used in the case of SF-type RoksTddft', gui_name='RoksTddft SU-Type:', default='SF-TDA', choices=['None', 'SF-TDA'], hiddenchoices=['None'])
def __post_init__(self):
self.AAS: BoolType | BoolKey = BoolKey(name='AAS', comment='Use the molecular orbitals from a DFT ground state calculation as input to an excited state calculation with TDDFT-aas coupling matrices', default=False)
self.AASALPHA: float | FloatKey = FloatKey(name='AASALPHA', comment='optimal alpha value for TDDFT-aas method', hidden=True, default=0.2)
self.ALLXASMOMENTS: BoolType | BoolKey = BoolKey(name='ALLXASMOMENTS', comment='To be used in combination with XAS. This will print out all the individual transition moments used within the calculation of the total oscillator strength', default=False)
self.ALLXASQUADRUPOLE: BoolType | BoolKey = BoolKey(name='ALLXASQUADRUPOLE', comment='To be used in combination with XAS.This will print out the individual oscillator strength components to the total oscillator strength.', default=False)
self.Allowed: BoolType | BoolKey = BoolKey(name='Allowed', comment='Treat only those irreducible representations for which the oscillator strengths will be nonzero (as opposed to all)', default=False)
self.AlsoRestricted: BoolType | BoolKey = BoolKey(name='AlsoRestricted', comment='Include also excitation energies in which a spin-restricted exchange-correlation kernel is used')
self.Analytical: BoolType | BoolKey = BoolKey(name='Analytical', comment='The required integrals for the CD spectrum are calculated analytically, instead of numerically. Only used in case of CD spectrum', default=False)
self.AsympCor: float | FloatKey = FloatKey(name='AsympCor', default=500.0)
self.BSE: BoolType | BoolKey = BoolKey(name='BSE', comment='Solve the static Bethe-Salpeter equation based on a GW calculation', default=False)
self.BSEscreening: BoolType | BoolKey = BoolKey(name='BSEscreening', comment='Solve the static Bethe-Salpeter equation based on a GW-BSE calculation, i.e. the screening entering the excitation calculation is calculated at the BSE level of theory instead of the RPA.', hidden=True, default=False)
self.CDSpectrum: BoolType | BoolKey = BoolKey(name='CDSpectrum', comment='Compute the rotatory strengths for the calculated excitations, in order to simulate Circular Dichroism (CD) spectra', default=False)
self.DBSE: BoolType | BoolKey = BoolKey(name='DBSE', comment='Solve the dynamic Bethe-Salpeter equation based on a GW calculation in the diagonal approximation for the GW kernel', hidden=True, default=False)
self.DTensor: str | StringKey = StringKey(name='DTensor', comment='MCD gtensor')
self.Descriptors: BoolType | BoolKey = BoolKey(name='Descriptors', comment='Compute charge-transfer descriptors and SFO analysis', default=False)
self.Descriptors_CT_AT_Rab: float | FloatKey = FloatKey(name='Descriptors_CT_AT_Rab', comment='Atomic distance criterion used for the calculation of CT_AT descriptors', default=2.0)
self.ESESTDM: BoolType | BoolKey = BoolKey(name='ESESTDM', comment='Compute transition dipole moments between excited states', default=False)
self.FullKernel: BoolType | BoolKey = BoolKey(name='FullKernel', comment='Use the non-ALDA kernel (with XCFUN)', default=False)
self.GTensor: str | StringKey = StringKey(name='GTensor', comment='MCD gtensor')
self.HDA: BoolType | BoolKey = BoolKey(name='HDA', comment='Activate the diagonal HF exchange approximation.\n\nThis is only relevant if a (meta-)hybrid is used in the SCF.', gui_name='Hybrid diagonal approximation:', default=False)
self.HDA_CutOff: float | FloatKey = FloatKey(name='HDA_CutOff', comment='This is cutoff based on differences in energy between eps_virt-eps_occ, to reduce number of diagonal HF exchange integrals.', gui_name='HDA cutoff:', default=10000000.0, unit='eV')
self.Iterations: int | IntKey = IntKey(name='Iterations', comment='The maximum number of attempts within which the Davidson algorithm has to converge', default=200)
self.KFWrite: int | IntKey = IntKey(name='KFWrite', comment='If kfwrite is 0 then do not write contributions, transition densities, and restart vectors to TAPE21, since this can lead to a huge TAPE21, especially if many excitations are calculated. 3 means that contributions, transition densities, and restart vectors are written to TAPE21.', default=3)
self.Lowest: Iterable[int] | IntListKey = IntListKey(name='Lowest', comment='Number of lowest excitations to compute', gui_name='Number of excitations:', default=[10])
self.MAXPRINTED: int | IntKey = IntKey(name='MAXPRINTED', comment='The maximum number of printed contributions', hidden=True, default=20)
self.MCD: str | StringKey = StringKey(name='MCD', comment='TODO: Magnetic Circular Dichroism')
self.NTO: BoolType | BoolKey = BoolKey(name='NTO', comment='Compute the Natural Transition Orbitals', default=False)
self.N_HDA_integral: int | IntKey = IntKey(name='N_HDA_integral', comment='Maximum number of HDA integrals', default=1000000000)
self.N_SFO: int | IntKey = IntKey(name='N_SFO', comment='Number of SFO analyzed and printed', default=40)
self.Nospinsocd: BoolType | BoolKey = BoolKey(name='Nospinsocd', comment='Turn off calculation of spin operator matrices in spin-orbit relativistic CD spectrum calculations', hidden=True, default=False)
self.OnlySing: BoolType | BoolKey = BoolKey(name='OnlySing', comment='Compute only singlet-singlet excitations')
self.OnlyTrip: BoolType | BoolKey = BoolKey(name='OnlyTrip', comment='Compute only singlet-triplet excitations')
self.Orthonormality: float | FloatKey = FloatKey(name='Orthonormality', comment='The Davidson algorithm orthonormalizes its trial vectors. Increasing the default orthonormality criterion increases the CPU time somewhat, but is another useful check on the reliability of the results.', default=1e-06)
self.Residu: float | FloatKey = FloatKey(name='Residu', default=1e-06, unit='Hartree')
self.SDKernelType: Literal["Collinear", "NonCollinear", "QuasiNonCollinear"] = MultipleChoiceKey(name='SDKernelType', comment='Choose specific kernel approximation in case of ROKS-SD-TDA or ROKS-SD-CIS.', hidden=True, default='NonCollinear', choices=['Collinear', 'NonCollinear', 'QuasiNonCollinear'])
self.SFOAnalysis: BoolType | BoolKey = BoolKey(name='SFOAnalysis', comment='Do SFO analysis', default=False)
self.SOSFreq: float | FloatKey = FloatKey(name='SOSFreq')
self.STDA: BoolType | BoolKey = BoolKey(name='STDA', comment='Simplified Tamm-Dancoff approach', default=False)
self.STDDFT: BoolType | BoolKey = BoolKey(name='STDDFT', comment='Simplified time-dependent DFT', default=False)
self.ScaleCoul: float | FloatKey = FloatKey(name='ScaleCoul', comment='Scaling of Coulomb kernel with scale parameter', default=1.0)
self.ScaleHF: float | FloatKey = FloatKey(name='ScaleHF', comment='Scaling of the HF part of the kernel with scale parameter', default=1.0)
self.ScaleXC: float | FloatKey = FloatKey(name='ScaleXC', comment='Scaling of the XC-kernel (excluding a possible HF-part) with scale parameter', default=1.0)
self.Select: str | StringKey = StringKey(name='Select', comment='Rather than selecting the first nmcdterm transitions for consideration individual transitions can be selected through the SELECT keyword')
self.SingleOrbTrans: BoolType | BoolKey = BoolKey(name='SingleOrbTrans', comment='keyword to use only orbital energy differences', default=False)
self.TD_DFTB: BoolType | BoolKey = BoolKey(name='TD-DFTB', comment='Use the molecular orbitals from a DFT ground state calculation as input to an excited state calculation with TD-DFTB coupling matrices', default=False)
self.TDA_DFTB: BoolType | BoolKey = BoolKey(name='TDA-DFTB', comment='Use the molecular orbitals from a DFT ground state calculation as input to an excited state calculation with TDA-DFTB coupling matrices', default=False)
self.THRESHPRINTED: float | FloatKey = FloatKey(name='THRESHPRINTED', comment='Loop until 100 x THRESHPRINTED percent of the transition is found or MAXPRINTED contributions are printed', hidden=True, default=0.998)
self.Tolerance: float | FloatKey = FloatKey(name='Tolerance', default=1e-06, unit='Hartree')
self.Vectors: int | IntKey = IntKey(name='Vectors', comment='The maximum number of trial vectors in the Davidson algorithm for which space is allocated. If this number is small less memory will be needed, but the trial vector space is smaller and has to be collapsed more often, at the expense of CPU time. The default if usually adequate.')
self.Velocity: BoolType | BoolKey = BoolKey(name='Velocity', comment='Calculates the dipole-velocity representation of the oscillator strength. If applicable, the dipole-velocity representation of the rotatory strength is calculated. Default the dipole-length representation of the oscillator strength and rotatory strength is calculated', gui_name='Velocity representation:', default=False)
self.XAS: BoolType | BoolKey = BoolKey(name='XAS', comment='Calculation of the higher order multipole moment integrals and the calculation of the quadrupole oscillator strengths. This will only print the total oscillator strength and the excitation energy.', default=False)
self.Davidson: str | Sequence[str] | FreeBlock = self._Davidson(name='Davidson', comment='Use the Davidson procedure', header=True)
self.Exact: str | Sequence[str] | FreeBlock = self._Exact(name='Exact', comment='The most straightforward procedure is a direct diagonalization of the matrix from which the excitation energies and oscillator strengths are obtained. Since the matrix may become very large, this option is possible only for very small molecules', header=True)
self.RoksTddftType: ADF._Excitations._RoksTddftType = self._RoksTddftType(name='RoksTddftType', comment='Excitation energies from RoksTddft: UV/Vis', extra_info='not_in_fragment')
[docs] class _ExcitedEDA(FixedBlock):
r"""
Options for excited energy decomposition (EDA).
:ivar Calc: None: No calculation of parts of excited EDA.
Electrostatic: calculate electrostatic part EDA excited state.
Pauli: calculate Pauli repulsion part of excited state.
:vartype Calc: Literal["None", "Electrostatic", "Pauli", "All"]
:ivar ElectrostaticFile: Path to adf.rkf file from which ADF reads electrostatic part excited EDA.
:vartype ElectrostaticFile: str | StringKey
:ivar PauliFile: Path to adf.rkf file from which ADF reads Pauli repulsion part excited EDA.
:vartype PauliFile: str | StringKey
"""
def __post_init__(self):
self.Calc: Literal["None", "Electrostatic", "Pauli", "All"] = MultipleChoiceKey(name='Calc', comment='None: No calculation of parts of excited EDA.\n\nElectrostatic: calculate electrostatic part EDA excited state.\n\nPauli: calculate Pauli repulsion part of excited state.', default='None', choices=['None', 'Electrostatic', 'Pauli', 'All'])
self.ElectrostaticFile: str | StringKey = StringKey(name='ElectrostaticFile', comment='Path to adf.rkf file from which ADF reads electrostatic part excited EDA.', default='')
self.PauliFile: str | StringKey = StringKey(name='PauliFile', comment='Path to adf.rkf file from which ADF reads Pauli repulsion part excited EDA.', default='')
[docs] class _ExcitedGO(FixedBlock):
r"""
Excited state geometry optimization
:ivar ALLGRADIENTS:
:vartype ALLGRADIENTS: BoolType | BoolKey
:ivar EigenFollow: This key tries to follow the eigenvector in excited state geometry optimizations
:vartype EigenFollow: BoolType | BoolKey
:ivar Output: The amount of output printed. A higher value requests more detailed output
:vartype Output: int | IntKey
:ivar Singlet: Singlet-singlet excitation is considered
:vartype Singlet: BoolType | BoolKey
:ivar State: Choose the excitation for which the gradient is to be evaluated: 'State Irreplab nstate'. 'Irreplab' is the label from the TDDFT calculation. NOTE: the TDDFT module uses a different notation for some representation names, for example, A' is used instead of AA. 'nstate': this value indicates that the nstate-th transition of symmetry Irreplab is to be evaluated. Default is the first fully symmetric transition.
:vartype State: str | StringKey
:ivar Triplet: Singlet-triplet excitation is considered
:vartype Triplet: BoolType | BoolKey
:ivar CPKS: Some control parameters for the CPKS(Z-vector) part of the TDDFT gradients calculation
:vartype CPKS: ADF._ExcitedGO._CPKS
:ivar SING_GRADS:
:vartype SING_GRADS: str | Sequence[str] | FreeBlock
:ivar TRIP_GRADS:
:vartype TRIP_GRADS: str | Sequence[str] | FreeBlock
"""
[docs] class _CPKS(FixedBlock):
r"""
Some control parameters for the CPKS(Z-vector) part of the TDDFT gradients calculation
:ivar Eps: Convergence requirement of the CPKS
:vartype Eps: float | FloatKey
:ivar IterOut: Details of the CPKS calculation are printed every iter iterations
:vartype IterOut: int | IntKey
:ivar NoPreConiter: maximum number of iterations allowed for the unpreconditioned solver.
:vartype NoPreConiter: int | IntKey
:ivar PreConiter: maximum number of iterations allowed for the preconditioned solver
:vartype PreConiter: int | IntKey
"""
def __post_init__(self):
self.Eps: float | FloatKey = FloatKey(name='Eps', comment='Convergence requirement of the CPKS', default=0.0001)
self.IterOut: int | IntKey = IntKey(name='IterOut', comment='Details of the CPKS calculation are printed every iter iterations', default=5)
self.NoPreConiter: int | IntKey = IntKey(name='NoPreConiter', comment='maximum number of iterations allowed for the unpreconditioned solver. ', default=200)
self.PreConiter: int | IntKey = IntKey(name='PreConiter', comment='maximum number of iterations allowed for the preconditioned solver', default=30)
[docs] class _SING_GRADS(FreeBlock):
r"""
"""
def __post_init__(self):
pass
[docs] class _TRIP_GRADS(FreeBlock):
r"""
"""
def __post_init__(self):
pass
def __post_init__(self):
self.ALLGRADIENTS: BoolType | BoolKey = BoolKey(name='ALLGRADIENTS', default=False)
self.EigenFollow: BoolType | BoolKey = BoolKey(name='EigenFollow', comment='This key tries to follow the eigenvector in excited state geometry optimizations', default=False)
self.Output: int | IntKey = IntKey(name='Output', comment='The amount of output printed. A higher value requests more detailed output', default=0)
self.Singlet: BoolType | BoolKey = BoolKey(name='Singlet', comment='Singlet-singlet excitation is considered', default=True)
self.State: str | StringKey = StringKey(name='State', comment="Choose the excitation for which the gradient is to be evaluated: 'State Irreplab nstate'. 'Irreplab' is the label from the TDDFT calculation. NOTE: the TDDFT module uses a different notation for some representation names, for example, A' is used instead of AA. 'nstate': this value indicates that the nstate-th transition of symmetry Irreplab is to be evaluated. Default is the first fully symmetric transition. ")
self.Triplet: BoolType | BoolKey = BoolKey(name='Triplet', comment='Singlet-triplet excitation is considered', default=False)
self.CPKS: ADF._ExcitedGO._CPKS = self._CPKS(name='CPKS', comment='Some control parameters for the CPKS(Z-vector) part of the TDDFT gradients calculation')
self.SING_GRADS: str | Sequence[str] | FreeBlock = self._SING_GRADS(name='SING_GRADS')
self.TRIP_GRADS: str | Sequence[str] | FreeBlock = self._TRIP_GRADS(name='TRIP_GRADS')
[docs] class _ExcitonTransfer(FixedBlock):
r"""
Block key for exciton transfer integrals with ROSE or FOCDFT.
:ivar CoupleFinalStates: Calculate delocalized excited states in the basis of the localized excited states that are calculated, thus couple the localized excited states.
:vartype CoupleFinalStates: BoolType | BoolKey
:ivar Debug: Print extra output for debug purposes
:vartype Debug: BoolType | BoolKey
:ivar FullRun: Include run without restriction of localization of occupied and/or virtual orbitals.
:vartype FullRun: BoolType | BoolKey
:ivar LocalCouplingsOnly: Only account for couplings between local diabatic states
:vartype LocalCouplingsOnly: BoolType | BoolKey
:ivar Localize: Localize OccupiedAndVirtual means that separately purely localized excitations and purely charge-transfer excitations are calculated. Localize OccupiedOnly means that an excitation may have local and charge-transfer character, but the excitation only has contributions from occupied orbitals on one fragment. Only relevant in case block key FOCDFT is used or ROSE orbitals are used.
:vartype Localize: Literal["OccupiedOnly", "OccupiedAndVirtual"]
:ivar Lowest: Number of lowest excitations to compute for each fragment. These are purely local excitations if the Localize OccupiedAndVirtual key is specified.
:vartype Lowest: Iterable[int] | IntListKey
:ivar LowestCT: Number of lowest charge-transfer excitations to compute for each fragment. Only relevant if the Localize OccupiedAndVirtual key is also specified.
:vartype LowestCT: Iterable[int] | IntListKey
:ivar Output: Amount of output
:vartype Output: Literal["AllCouplings", "FilteredCouplings", "AllAndFilteredCouplings"]
:ivar SecondOrder: Include 2nd-order correction to electronic couplings
:vartype SecondOrder: BoolType | BoolKey
:ivar UseFragments: In case of Rose or FOCDFT only, one can specify the fragment numbers of 2 fragments. Then calculate only excitations from occupied orbitals on fragment one to virtual orbitals on fragment two. If not specified calculate all possible excitations.
:vartype UseFragments: Iterable[int] | IntListKey
:ivar FilteredCouplings: Details on filter used for electronic couplings in the output
:vartype FilteredCouplings: ADF._ExcitonTransfer._FilteredCouplings
"""
[docs] class _FilteredCouplings(FixedBlock):
r"""
Details on filter used for electronic couplings in the output
:ivar MaxEnergy: Max. energy (in eV) of diabatic states
:vartype MaxEnergy: float | FloatKey
:ivar MaxEnergyDiff: Max. energy difference (in eV) between diabatic states
:vartype MaxEnergyDiff: float | FloatKey
:ivar MinCoupling: Min. coupling value (in meV) that is printed
:vartype MinCoupling: float | FloatKey
:ivar MinEnergy: Min. energy (in eV) of diabatic states
:vartype MinEnergy: float | FloatKey
"""
def __post_init__(self):
self.MaxEnergy: float | FloatKey = FloatKey(name='MaxEnergy', comment='Max. energy (in eV) of diabatic states', default=10.0, unit='eV')
self.MaxEnergyDiff: float | FloatKey = FloatKey(name='MaxEnergyDiff', comment='Max. energy difference (in eV) between diabatic states', default=0.5, unit='eV')
self.MinCoupling: float | FloatKey = FloatKey(name='MinCoupling', comment='Min. coupling value (in meV) that is printed', default=0.1)
self.MinEnergy: float | FloatKey = FloatKey(name='MinEnergy', comment='Min. energy (in eV) of diabatic states', default=0.0, unit='eV')
def __post_init__(self):
self.CoupleFinalStates: BoolType | BoolKey = BoolKey(name='CoupleFinalStates', comment='Calculate delocalized excited states in the basis of the localized excited states that are calculated, thus couple the localized excited states.', default=False)
self.Debug: BoolType | BoolKey = BoolKey(name='Debug', comment='Print extra output for debug purposes', hidden=True, default=False)
self.FullRun: BoolType | BoolKey = BoolKey(name='FullRun', comment='Include run without restriction of localization of occupied and/or virtual orbitals.', default=False)
self.LocalCouplingsOnly: BoolType | BoolKey = BoolKey(name='LocalCouplingsOnly', comment='Only account for couplings between local diabatic states', default=False)
self.Localize: Literal["OccupiedOnly", "OccupiedAndVirtual"] = MultipleChoiceKey(name='Localize', comment='Localize OccupiedAndVirtual means that separately purely localized excitations and purely charge-transfer excitations are calculated. Localize OccupiedOnly means that an excitation may have local and charge-transfer character, but the excitation only has contributions from occupied orbitals on one fragment. Only relevant in case block key FOCDFT is used or ROSE orbitals are used.', default='OccupiedOnly', choices=['OccupiedOnly', 'OccupiedAndVirtual'])
self.Lowest: Iterable[int] | IntListKey = IntListKey(name='Lowest', comment='Number of lowest excitations to compute for each fragment. These are purely local excitations if the Localize OccupiedAndVirtual key is specified.', gui_name='Number of excitations:')
self.LowestCT: Iterable[int] | IntListKey = IntListKey(name='LowestCT', comment='Number of lowest charge-transfer excitations to compute for each fragment. Only relevant if the Localize OccupiedAndVirtual key is also specified.', gui_name='Number of charge-transfer excitations:')
self.Output: Literal["AllCouplings", "FilteredCouplings", "AllAndFilteredCouplings"] = MultipleChoiceKey(name='Output', comment='Amount of output', default='AllCouplings', choices=['AllCouplings', 'FilteredCouplings', 'AllAndFilteredCouplings'])
self.SecondOrder: BoolType | BoolKey = BoolKey(name='SecondOrder', comment='Include 2nd-order correction to electronic couplings', default=False)
self.UseFragments: Iterable[int] | IntListKey = IntListKey(name='UseFragments', comment='In case of Rose or FOCDFT only, one can specify the fragment numbers of 2 fragments. Then calculate only excitations from occupied orbitals on fragment one to virtual orbitals on fragment two. If not specified calculate all possible excitations.', hidden=True)
self.FilteredCouplings: ADF._ExcitonTransfer._FilteredCouplings = self._FilteredCouplings(name='FilteredCouplings', comment='Details on filter used for electronic couplings in the output')
[docs] class _Externals(FreeBlock):
r"""
Legacy support of the older DRF code.
"""
def __post_init__(self):
pass
[docs] class _FDE(FixedBlock):
r"""
Frozen Density Embedding options
:ivar AMOLFDE: placeholder
:vartype AMOLFDE: BoolType | BoolKey
:ivar CAPDENSCONV: placeholder
:vartype CAPDENSCONV: float | FloatKey
:ivar CAPPOTBASIS: placeholder
:vartype CAPPOTBASIS: BoolType | BoolKey
:ivar CAPPOTLINESEARCH: placeholder
:vartype CAPPOTLINESEARCH: BoolType | BoolKey
:ivar CAPRADIUS: placeholder
:vartype CAPRADIUS: float | FloatKey
:ivar CJCORR: Option to switch on a long-distance correction
:vartype CJCORR: float | FloatKey
:ivar Coulomb: Neglecting completely vt[rhoA,rhoB] (vt[rhoA,rhoB] equals zero) together with the exchange-correlation component of the embedding potential introduced by Wesolowski and Warshel.
:vartype Coulomb: BoolType | BoolKey
:ivar Dipole: placeholder
:vartype Dipole: BoolType | BoolKey
:ivar E00: placeholder
:vartype E00: BoolType | BoolKey
:ivar EIGENSHIFT: placeholder
:vartype EIGENSHIFT: float | FloatKey
:ivar ENERGY: placeholder
:vartype ENERGY: BoolType | BoolKey
:ivar EXTERNALORTHO: Used to specify the use of external orthogonality (EO) in the FDE block
:vartype EXTERNALORTHO: float | FloatKey
:ivar EXTPRINTENERGY: placeholder
:vartype EXTPRINTENERGY: BoolType | BoolKey
:ivar FULLGRID: placeholder
:vartype FULLGRID: BoolType | BoolKey
:ivar FreezeAndThawCycles: This keyword duplicates RelaxCycles
:vartype FreezeAndThawCycles: int | IntKey
:ivar FreezeAndThawDensType: placeholder
:vartype FreezeAndThawDensType: str | StringKey
:ivar FreezeAndThawPostSCF: This keyword duplicates RelaxPostSCF
:vartype FreezeAndThawPostSCF: BoolType | BoolKey
:ivar GGA97: placeholder
:vartype GGA97: BoolType | BoolKey
:ivar GGAPotCFD: The correlation approximant is used in the construction of the embedding potential. The same correlation approximants as in the XC key are available.
:vartype GGAPotCFD: str | StringKey
:ivar GGAPotXFD: The exchange approximant is used in the construction of the embedding potential. The same exchange approximants as in the XC key are available.
:vartype GGAPotXFD: str | StringKey
:ivar LAMBDATIKH: placeholder
:vartype LAMBDATIKH: float | FloatKey
:ivar LBDAMP: placeholder
:vartype LBDAMP: float | FloatKey
:ivar LBMAXSTEP: placeholder
:vartype LBMAXSTEP: float | FloatKey
:ivar LLP91: placeholder
:vartype LLP91: BoolType | BoolKey
:ivar LLP91S: placeholder
:vartype LLP91S: BoolType | BoolKey
:ivar NDSD: placeholder
:vartype NDSD: str | StringKey
:ivar NOCAPSEPCONV: placeholder
:vartype NOCAPSEPCONV: BoolType | BoolKey
:ivar NOFDKERN: placeholder
:vartype NOFDKERN: BoolType | BoolKey
:ivar OL91A: placeholder
:vartype OL91A: BoolType | BoolKey
:ivar OL91B: placeholder
:vartype OL91B: BoolType | BoolKey
:ivar ONEGRID: placeholder
:vartype ONEGRID: BoolType | BoolKey
:ivar P92: placeholder
:vartype P92: BoolType | BoolKey
:ivar PBE2: placeholder
:vartype PBE2: BoolType | BoolKey
:ivar PBE3: placeholder
:vartype PBE3: BoolType | BoolKey
:ivar PBE4: placeholder
:vartype PBE4: BoolType | BoolKey
:ivar PDFT: placeholder
:vartype PDFT: BoolType | BoolKey
:ivar PRINTEACHCYCLE: placeholder
:vartype PRINTEACHCYCLE: BoolType | BoolKey
:ivar PRINTRHO2: placeholder
:vartype PRINTRHO2: BoolType | BoolKey
:ivar PW86K: placeholder
:vartype PW86K: BoolType | BoolKey
:ivar PW91K: placeholder
:vartype PW91K: BoolType | BoolKey
:ivar PW91Kscaled: placeholder
:vartype PW91Kscaled: BoolType | BoolKey
:ivar RHO1FITTED: placeholder
:vartype RHO1FITTED: BoolType | BoolKey
:ivar RelaxCycles: This gives the maximum number of freeze-and-thaw cycles that are performed for this fragment. If the maximum number given in the FDE block is smaller, or if convergence is reached earlier, then fewer cycles are performed.
:vartype RelaxCycles: int | IntKey
:ivar RelaxDensType: placeholder
:vartype RelaxDensType: str | StringKey
:ivar RelaxPostSCF: this option is included, several post-SCF properties will be calculated after each freeze-and-thaw cycle. These are otherwise only calculated in the last cycle.
:vartype RelaxPostSCF: BoolType | BoolKey
:ivar SCFCONVTHRESH: placeholder
:vartype SCFCONVTHRESH: float | FloatKey
:ivar SDFTEnergy: placeholder
:vartype SDFTEnergy: BoolType | BoolKey
:ivar SHORTPRINTENERGY: placeholder
:vartype SHORTPRINTENERGY: BoolType | BoolKey
:ivar SMALLEIGTHRESH: placeholder
:vartype SMALLEIGTHRESH: float | FloatKey
:ivar TF9W: placeholder
:vartype TF9W: BoolType | BoolKey
:ivar THAKKAR92: placeholder
:vartype THAKKAR92: BoolType | BoolKey
:ivar THOMASFERMI: Local-density-approximation form of vt[rhoA,rhoB] derived from Thomas-Fermi expression for Ts[rho]
:vartype THOMASFERMI: BoolType | BoolKey
:ivar TW02: placeholder
:vartype TW02: BoolType | BoolKey
:ivar WEIZ: placeholder
:vartype WEIZ: BoolType | BoolKey
:ivar XCFun: Use XCFUN for nonadditive functionals
:vartype XCFun: BoolType | BoolKey
:ivar XCNAdd:
:vartype XCNAdd: str | StringKey
"""
def __post_init__(self):
self.AMOLFDE: BoolType | BoolKey = BoolKey(name='AMOLFDE', comment='placeholder', default=False)
self.CAPDENSCONV: float | FloatKey = FloatKey(name='CAPDENSCONV', comment='placeholder', default=0.0001)
self.CAPPOTBASIS: BoolType | BoolKey = BoolKey(name='CAPPOTBASIS', comment='placeholder', default=False)
self.CAPPOTLINESEARCH: BoolType | BoolKey = BoolKey(name='CAPPOTLINESEARCH', comment='placeholder', default=False)
self.CAPRADIUS: float | FloatKey = FloatKey(name='CAPRADIUS', comment='placeholder', default=3.0)
self.CJCORR: float | FloatKey = FloatKey(name='CJCORR', comment='Option to switch on a long-distance correction', default=0.1)
self.Coulomb: BoolType | BoolKey = BoolKey(name='Coulomb', comment='Neglecting completely vt[rhoA,rhoB] (vt[rhoA,rhoB] equals zero) together with the exchange-correlation component of the embedding potential introduced by Wesolowski and Warshel.')
self.Dipole: BoolType | BoolKey = BoolKey(name='Dipole', comment='placeholder', default=False)
self.E00: BoolType | BoolKey = BoolKey(name='E00', comment='placeholder')
self.EIGENSHIFT: float | FloatKey = FloatKey(name='EIGENSHIFT', comment='placeholder', default=0.01)
self.ENERGY: BoolType | BoolKey = BoolKey(name='ENERGY', comment='placeholder', default=False)
self.EXTERNALORTHO: float | FloatKey = FloatKey(name='EXTERNALORTHO', comment='Used to specify the use of external orthogonality (EO) in the FDE block', default=1000000.0)
self.EXTPRINTENERGY: BoolType | BoolKey = BoolKey(name='EXTPRINTENERGY', comment='placeholder', default=False)
self.FULLGRID: BoolType | BoolKey = BoolKey(name='FULLGRID', comment='placeholder', default=False)
self.FreezeAndThawCycles: int | IntKey = IntKey(name='FreezeAndThawCycles', comment='This keyword duplicates RelaxCycles')
self.FreezeAndThawDensType: str | StringKey = StringKey(name='FreezeAndThawDensType', comment='placeholder')
self.FreezeAndThawPostSCF: BoolType | BoolKey = BoolKey(name='FreezeAndThawPostSCF', comment='This keyword duplicates RelaxPostSCF')
self.GGA97: BoolType | BoolKey = BoolKey(name='GGA97', comment='placeholder')
self.GGAPotCFD: str | StringKey = StringKey(name='GGAPotCFD', comment='The correlation approximant is used in the construction of the embedding potential. The same correlation approximants as in the XC key are available.')
self.GGAPotXFD: str | StringKey = StringKey(name='GGAPotXFD', comment='The exchange approximant is used in the construction of the embedding potential. The same exchange approximants as in the XC key are available.')
self.LAMBDATIKH: float | FloatKey = FloatKey(name='LAMBDATIKH', comment='placeholder', default=0.1)
self.LBDAMP: float | FloatKey = FloatKey(name='LBDAMP', comment='placeholder', default=0.25)
self.LBMAXSTEP: float | FloatKey = FloatKey(name='LBMAXSTEP', comment='placeholder', default=0.05)
self.LLP91: BoolType | BoolKey = BoolKey(name='LLP91', comment='placeholder')
self.LLP91S: BoolType | BoolKey = BoolKey(name='LLP91S', comment='placeholder')
self.NDSD: str | StringKey = StringKey(name='NDSD', comment='placeholder')
self.NOCAPSEPCONV: BoolType | BoolKey = BoolKey(name='NOCAPSEPCONV', comment='placeholder')
self.NOFDKERN: BoolType | BoolKey = BoolKey(name='NOFDKERN', comment='placeholder', default=True)
self.OL91A: BoolType | BoolKey = BoolKey(name='OL91A', comment='placeholder')
self.OL91B: BoolType | BoolKey = BoolKey(name='OL91B', comment='placeholder')
self.ONEGRID: BoolType | BoolKey = BoolKey(name='ONEGRID', comment='placeholder', default=False)
self.P92: BoolType | BoolKey = BoolKey(name='P92', comment='placeholder')
self.PBE2: BoolType | BoolKey = BoolKey(name='PBE2', comment='placeholder')
self.PBE3: BoolType | BoolKey = BoolKey(name='PBE3', comment='placeholder')
self.PBE4: BoolType | BoolKey = BoolKey(name='PBE4', comment='placeholder')
self.PDFT: BoolType | BoolKey = BoolKey(name='PDFT', comment='placeholder', default=False)
self.PRINTEACHCYCLE: BoolType | BoolKey = BoolKey(name='PRINTEACHCYCLE', comment='placeholder', default=False)
self.PRINTRHO2: BoolType | BoolKey = BoolKey(name='PRINTRHO2', comment='placeholder', default=False)
self.PW86K: BoolType | BoolKey = BoolKey(name='PW86K', comment='placeholder')
self.PW91K: BoolType | BoolKey = BoolKey(name='PW91K', comment='placeholder')
self.PW91Kscaled: BoolType | BoolKey = BoolKey(name='PW91Kscaled', comment='placeholder')
self.RHO1FITTED: BoolType | BoolKey = BoolKey(name='RHO1FITTED', comment='placeholder', default=False)
self.RelaxCycles: int | IntKey = IntKey(name='RelaxCycles', comment='This gives the maximum number of freeze-and-thaw cycles that are performed for this fragment. If the maximum number given in the FDE block is smaller, or if convergence is reached earlier, then fewer cycles are performed.', default=5)
self.RelaxDensType: str | StringKey = StringKey(name='RelaxDensType', comment='placeholder', default=' ')
self.RelaxPostSCF: BoolType | BoolKey = BoolKey(name='RelaxPostSCF', comment=' this option is included, several post-SCF properties will be calculated after each freeze-and-thaw cycle. These are otherwise only calculated in the last cycle.', default=False)
self.SCFCONVTHRESH: float | FloatKey = FloatKey(name='SCFCONVTHRESH', comment='placeholder', default=0.001)
self.SDFTEnergy: BoolType | BoolKey = BoolKey(name='SDFTEnergy', comment='placeholder', default=False)
self.SHORTPRINTENERGY: BoolType | BoolKey = BoolKey(name='SHORTPRINTENERGY', comment='placeholder', default=False)
self.SMALLEIGTHRESH: float | FloatKey = FloatKey(name='SMALLEIGTHRESH', comment='placeholder', default=0.0001)
self.TF9W: BoolType | BoolKey = BoolKey(name='TF9W', comment='placeholder')
self.THAKKAR92: BoolType | BoolKey = BoolKey(name='THAKKAR92', comment='placeholder')
self.THOMASFERMI: BoolType | BoolKey = BoolKey(name='THOMASFERMI', comment='Local-density-approximation form of vt[rhoA,rhoB] derived from Thomas-Fermi expression for Ts[rho]')
self.TW02: BoolType | BoolKey = BoolKey(name='TW02', comment='placeholder')
self.WEIZ: BoolType | BoolKey = BoolKey(name='WEIZ', comment='placeholder')
self.XCFun: BoolType | BoolKey = BoolKey(name='XCFun', comment='Use XCFUN for nonadditive functionals', default=False)
self.XCNAdd: str | StringKey = StringKey(name='XCNAdd')
[docs] class _FDEFragments(FreeBlock):
r"""
Definitions of the FDE fragment types.
"""
def __post_init__(self):
pass
[docs] class _FOCDFT(FixedBlock):
r"""
Localize orbitals on fragments and constrain charge and spin polarization on fragments.
:ivar Charge: Constrain charge on fragments. Number of charges should be the same as number of fragments, and sum should add up to total charge.
:vartype Charge: Iterable[float] | FloatListKey
:ivar Debug: Debug.
:vartype Debug: BoolType | BoolKey
:ivar SpinPolarization: Constrain spin polarization on fragments. Number of spin polarization values should be the same as number of fragments, and sum should add up to total spin polarization. Calculation should be spin unrestricted.
:vartype SpinPolarization: Iterable[float] | FloatListKey
:ivar ElectronTransfer:
:vartype ElectronTransfer: ADF._FOCDFT._ElectronTransfer
"""
[docs] class _ElectronTransfer(FixedBlock):
r"""
:ivar Charge: Constrain charge on fragments for the second calculation. Number of charges should be the same as number of fragments, and sum should add up to total charge.
:vartype Charge: Iterable[float] | FloatListKey
:ivar OffDiagonalHF: Off diagonal HF matrix elements.
:vartype OffDiagonalHF: BoolType | BoolKey
:ivar OffDiagonalHFValue: Amount of HF in case off diagonal HF matrix elements.
:vartype OffDiagonalHFValue: float | FloatKey
:ivar SpinPolarization: Constrain spin polarization on fragments for the second calculation. Number of spin polarization values should be the same as number of fragments, and sum should add up to total spin polarization. Calculation should be spin unrestricted.
:vartype SpinPolarization: Iterable[float] | FloatListKey
"""
def __post_init__(self):
self.Charge: Iterable[float] | FloatListKey = FloatListKey(name='Charge', comment='Constrain charge on fragments for the second calculation. Number of charges should be the same as number of fragments, and sum should add up to total charge.')
self.OffDiagonalHF: BoolType | BoolKey = BoolKey(name='OffDiagonalHF', comment='Off diagonal HF matrix elements.', gui_name='Off diagonal HF:', default=False)
self.OffDiagonalHFValue: float | FloatKey = FloatKey(name='OffDiagonalHFValue', comment='Amount of HF in case off diagonal HF matrix elements.', gui_name='Off diagonal HF value:', default=1.0)
self.SpinPolarization: Iterable[float] | FloatListKey = FloatListKey(name='SpinPolarization', comment='Constrain spin polarization on fragments for the second calculation. Number of spin polarization values should be the same as number of fragments, and sum should add up to total spin polarization. Calculation should be spin unrestricted.')
def __post_init__(self):
self.Charge: Iterable[float] | FloatListKey = FloatListKey(name='Charge', comment='Constrain charge on fragments. Number of charges should be the same as number of fragments, and sum should add up to total charge.')
self.Debug: BoolType | BoolKey = BoolKey(name='Debug', comment='Debug.', hidden=True, default=False)
self.SpinPolarization: Iterable[float] | FloatListKey = FloatListKey(name='SpinPolarization', comment='Constrain spin polarization on fragments. Number of spin polarization values should be the same as number of fragments, and sum should add up to total spin polarization. Calculation should be spin unrestricted.')
self.ElectronTransfer: ADF._FOCDFT._ElectronTransfer = self._ElectronTransfer(name='ElectronTransfer')
[docs] class _Fitnadkin(FreeBlock):
r"""
FDE option.
"""
def __post_init__(self):
pass
[docs] class _FragOccupations(FreeBlock):
r"""
Simulation of unrestricted fragments with the key FRAGOCCUPATIONS. Fragments need to be calculated spin-restricted. One can specify occupation numbers as if these fragments are calculated spin-unrestricted. The sum of spin-alpha and spin-beta occupations must, for each fragment orbital in each irrep separately, be equal to the total spin-restricted occupation of that orbital in the fragment.
"""
def __post_init__(self):
pass
[docs] class _Fragments(FreeBlock):
r"""
Definitions of the fragment type/files: {FragmentName FragmentFile}. In the block header one can specify the directory where the fragment files are located
"""
def __post_init__(self):
pass
[docs] class _GPU(FixedBlock):
r"""
Set GPU options
:ivar Enabled: Use a CUDA-compatible GPU.
:vartype Enabled: BoolType | BoolKey
:ivar UseDevices: Use only specified devices for this calculation. Multiple devices will be distributed evenly among MPI ranks.
:vartype UseDevices: Iterable[int] | IntListKey
"""
def __post_init__(self):
self.Enabled: BoolType | BoolKey = BoolKey(name='Enabled', comment='Use a CUDA-compatible GPU.', gui_name='Use GPU:', default=False)
self.UseDevices: Iterable[int] | IntListKey = IntListKey(name='UseDevices', comment='Use only specified devices for this calculation. Multiple devices will be distributed evenly among MPI ranks.', gui_name='Only use devices:')
[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: ADF._GW._AnalyticalIntegration
:ivar Converge: Sets convergence criteria for the GW calculation in self-consistent case
:vartype Converge: ADF._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: ADF._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: ADF._GW._Converge = self._Converge(name='Converge', comment='Sets convergence criteria for the GW calculation in self-consistent case')
[docs] class _IQA(FixedBlock):
r"""
Total energy decomposition based on the interacting quantum atoms (IQA) approach and using QTAIM real-space partition.
:ivar Accuracy: Placeholder
:vartype Accuracy: float | FloatKey
:ivar AtomsToDo: Define a subset of atoms for which the IQA atom-atom interactions are calculated (no intra-atomic terms).
If left empty, all atoms will be included (full IQA).
:vartype AtomsToDo: Iterable[int] | IntListKey
:ivar Enabled: Calculate the total energy decomposition using the interacting quantum atoms (IQA) approach and the QTAIM real-space partitioning.
:vartype Enabled: BoolType | BoolKey
:ivar Interactions: Placeholder
:vartype Interactions: Literal["inter", "all", "debug"]
:ivar Print: Minimal output (default) or verbose mode (detailed energy decomposition)
:vartype Print: Literal["normal", "verbose"]
"""
def __post_init__(self):
self.Accuracy: float | FloatKey = FloatKey(name='Accuracy', comment='Placeholder', hidden=True, default=1e-12)
self.AtomsToDo: Iterable[int] | IntListKey = IntListKey(name='AtomsToDo', comment='Define a subset of atoms for which the IQA atom-atom interactions are calculated (no intra-atomic terms).\n\nIf left empty, all atoms will be included (full IQA).', gui_name='Include atoms:', isatomlist=True)
self.Enabled: BoolType | BoolKey = BoolKey(name='Enabled', comment='Calculate the total energy decomposition using the interacting quantum atoms (IQA) approach and the QTAIM real-space partitioning.', gui_name='Calculate: Interacting Quantum Atoms (IQA)', default=False)
self.Interactions: Literal["inter", "all", "debug"] = MultipleChoiceKey(name='Interactions', comment='Placeholder', hidden=True, default='all', choices=['inter', 'all', 'debug'])
self.Print: Literal["normal", "verbose"] = MultipleChoiceKey(name='Print', comment='Minimal output (default) or verbose mode (detailed energy decomposition)', default='verbose', choices=['normal', 'verbose'])
[docs] class _Integration(FixedBlock):
r"""
Options for the Voronoi numerical integration scheme
:ivar ACCINT: The main precision parameter Its value defines the number of significant digits by which an internal set of standard integrals must be evaluated. The number and distribution of integration points is tuned accordingly. For normal applications this should yield a nearly optimal (given the underlying method) generation of points and weights. The default depends on the run type.
:vartype ACCINT: Iterable[float] | FloatListKey
:ivar ACCOUT: The region of space further away from the atoms, outside the polyhedrons, has its own precision parameter. By default accout=accint.
:vartype ACCOUT: float | FloatKey
:ivar ACCPYR: Similarly this subkey sets the test level for the parts of the pyramids outside the atomic sphere. Default: accpyr=accint.
:vartype ACCPYR: float | FloatKey
:ivar ACCPYU: The truncated pyramids are mathematically transformed into unit cubes. A product Gauss integration formula is applied to the cubes, with three (test precision) parameters for the three dimensions. Accpyw controls the direction that is essentially the radial integration from the surface of the atomic sphere to the base of the pyramid. The other two control the orthogonal directions (angular). By default all three equal accpyr.
:vartype ACCPYU: float | FloatKey
:ivar ACCPYV: The truncated pyramids are mathematically transformed into unit cubes. A product Gauss integration formula is applied to the cubes, with three (test precision) parameters for the three dimensions. Accpyw controls the direction that is essentially the radial integration from the surface of the atomic sphere to the base of the pyramid. The other two control the orthogonal directions (angular). By default all three equal accpyr.
:vartype ACCPYV: float | FloatKey
:ivar ACCPYW: The truncated pyramids are mathematically transformed into unit cubes. A product Gauss integration formula is applied to the cubes, with three (test precision) parameters for the three dimensions. Accpyw controls the direction that is essentially the radial integration from the surface of the atomic sphere to the base of the pyramid. The other two control the orthogonal directions (angular). By default all three equal accpyr.
:vartype ACCPYW: float | FloatKey
:ivar ACCSPH: The polyhedron method of generating integration points partitions space in atomic polyhedrons, partitioned in pyramids with their tops at the atom in the center of the polyhedron. A core like atomic sphere is constructed around the atom; this truncates the tops of the pyramids. accsph specifies the test precision for the generation of points within the spheres. By default accsph=accint.
:vartype ACCSPH: float | FloatKey
:ivar DISHUL: Sets the distance between the outermost nuclei of the molecule and the boundary planes that define the boundary between the polyhedrons and the outer region. By default dishul=2.3*R, where R is the radius of the largest atomic sphere in the molecule.
:vartype DISHUL: float | FloatKey
:ivar FRANGE: The outward range of the outer region: integration is not performed to infinity but to a distance frange from the outermost atoms, where all functions can be assumed to be essentially zero. By default frange is derived both from accint, the general precision parameter, and from the present chemical elements: heavier atoms have longer-range functions than hydrogen say. The precise relations can be found in the implementation.
:vartype FRANGE: float | FloatKey
:ivar LINROT: This parameter is significant only for symmetries with an axis of infinite rotational symmetry: C and D It is the highest rotational quantum number around this axis that occurs among the integrands. This depends on the employed basis functions and fit functions. By default the program finds this out for itself.
:vartype LINROT: int | IntKey
:ivar LINTEG: The maximum angular momentum quantum number of integrands centered on an atom of that type (one value for each atom type). This depends on the basis functions and on the fit functions. By default the program checks the function sets and sets the linteg values accordingly. This subkey is applied for the generation of grid points in the atomic spheres.
:vartype LINTEG: Iterable[int] | IntListKey
:ivar NOUTER: This outer region is treated by a product formula: outwards times parallel. The latter involves two dimensions: the surface of the molecule say. The outward integration is performed with Gauss-Legendre quadrature, in a few separate steps. The lengths of the steps are not equal, they increase by constant factors. The total length is fixed. The number of steps is controlled with this subkey; default: 2.
:vartype NOUTER: int | IntKey
:ivar OUTPAR: Similarly the integration in the directions parallel to the surface of the atomic system is controlled by a parameter. See the implementation for details.
:vartype OUTPAR: float | FloatKey
:ivar OUTRAD: The parameter that defines the number of Gauss-Legendre integration points for each outward step. The precise relation between the actual number of points and this subkey, and the default relation between outrad and accout can be found in the implementation.
:vartype OUTRAD: float | FloatKey
:ivar QPNEAR: If you specify point charges in the input file, there are two considerations implied for the numerical integration grid. First, since the point charges create a Coulomb singularity. The integrands (of for instance the basis function products against the Coulomb potential) can only be evaluated with high precision if the grid around the point charges has spherical symmetry and uses local spherical coordinates, exactly as is done for the atomic nuclei. Second, the point charges do not carry fit or basis functions, hence they play only a role in the more diffuse tails of the actual functions involved in integrals. Therefore, a relative low precision of the integral part close to the point charge may have little effect on the total integration accuracy. Since additional ‘spherical centers’ with their own surrounding grids increase the total number of points significantly, typically a few thousands per Coulomb center, this may result in high computational effort. Therefore, the program generates spherical grids only about those point charges that are close to the other atoms. The criterion, input with the qpnear subkey, is the closest distance between the point charge at hand and any real atom. Default 4.0 Angstrom.
:vartype QPNEAR: float | FloatKey
:ivar RSPHER: Gives the radii of the atomic spheres, one value for each atom type. By default, the radii are derived from the chemical element (heavier atoms get larger spheres) and from the environment: the sphere must not be too large for the atomic cell (polyhedron).
:vartype RSPHER: Iterable[float] | FloatListKey
"""
def __post_init__(self):
self.ACCINT: Iterable[float] | FloatListKey = FloatListKey(name='ACCINT', comment='The main precision parameter Its value defines the number of significant digits by which an internal set of standard integrals must be evaluated. The number and distribution of integration points is tuned accordingly. For normal applications this should yield a nearly optimal (given the underlying method) generation of points and weights. The default depends on the run type.')
self.ACCOUT: float | FloatKey = FloatKey(name='ACCOUT', comment='The region of space further away from the atoms, outside the polyhedrons, has its own precision parameter. By default accout=accint.')
self.ACCPYR: float | FloatKey = FloatKey(name='ACCPYR', comment='Similarly this subkey sets the test level for the parts of the pyramids outside the atomic sphere. Default: accpyr=accint.')
self.ACCPYU: float | FloatKey = FloatKey(name='ACCPYU', comment='The truncated pyramids are mathematically transformed into unit cubes. A product Gauss integration formula is applied to the cubes, with three (test precision) parameters for the three dimensions. Accpyw controls the direction that is essentially the radial integration from the surface of the atomic sphere to the base of the pyramid. The other two control the orthogonal directions (angular). By default all three equal accpyr.')
self.ACCPYV: float | FloatKey = FloatKey(name='ACCPYV', comment='The truncated pyramids are mathematically transformed into unit cubes. A product Gauss integration formula is applied to the cubes, with three (test precision) parameters for the three dimensions. Accpyw controls the direction that is essentially the radial integration from the surface of the atomic sphere to the base of the pyramid. The other two control the orthogonal directions (angular). By default all three equal accpyr.')
self.ACCPYW: float | FloatKey = FloatKey(name='ACCPYW', comment='The truncated pyramids are mathematically transformed into unit cubes. A product Gauss integration formula is applied to the cubes, with three (test precision) parameters for the three dimensions. Accpyw controls the direction that is essentially the radial integration from the surface of the atomic sphere to the base of the pyramid. The other two control the orthogonal directions (angular). By default all three equal accpyr.')
self.ACCSPH: float | FloatKey = FloatKey(name='ACCSPH', comment='The polyhedron method of generating integration points partitions space in atomic polyhedrons, partitioned in pyramids with their tops at the atom in the center of the polyhedron. A core like atomic sphere is constructed around the atom; this truncates the tops of the pyramids. accsph specifies the test precision for the generation of points within the spheres. By default accsph=accint.')
self.DISHUL: float | FloatKey = FloatKey(name='DISHUL', comment='Sets the distance between the outermost nuclei of the molecule and the boundary planes that define the boundary between the polyhedrons and the outer region. By default dishul=2.3*R, where R is the radius of the largest atomic sphere in the molecule.', unit='Bohr')
self.FRANGE: float | FloatKey = FloatKey(name='FRANGE', comment='The outward range of the outer region: integration is not performed to infinity but to a distance frange from the outermost atoms, where all functions can be assumed to be essentially zero. By default frange is derived both from accint, the general precision parameter, and from the present chemical elements: heavier atoms have longer-range functions than hydrogen say. The precise relations can be found in the implementation.', unit='Bohr')
self.LINROT: int | IntKey = IntKey(name='LINROT', comment='This parameter is significant only for symmetries with an axis of infinite rotational symmetry: C and D It is the highest rotational quantum number around this axis that occurs among the integrands. This depends on the employed basis functions and fit functions. By default the program finds this out for itself.')
self.LINTEG: Iterable[int] | IntListKey = IntListKey(name='LINTEG', comment='The maximum angular momentum quantum number of integrands centered on an atom of that type (one value for each atom type). This depends on the basis functions and on the fit functions. By default the program checks the function sets and sets the linteg values accordingly. This subkey is applied for the generation of grid points in the atomic spheres.')
self.NOUTER: int | IntKey = IntKey(name='NOUTER', comment='This outer region is treated by a product formula: outwards times parallel. The latter involves two dimensions: the surface of the molecule say. The outward integration is performed with Gauss-Legendre quadrature, in a few separate steps. The lengths of the steps are not equal, they increase by constant factors. The total length is fixed. The number of steps is controlled with this subkey; default: 2.')
self.OUTPAR: float | FloatKey = FloatKey(name='OUTPAR', comment='Similarly the integration in the directions parallel to the surface of the atomic system is controlled by a parameter. See the implementation for details.')
self.OUTRAD: float | FloatKey = FloatKey(name='OUTRAD', comment='The parameter that defines the number of Gauss-Legendre integration points for each outward step. The precise relation between the actual number of points and this subkey, and the default relation between outrad and accout can be found in the implementation.')
self.QPNEAR: float | FloatKey = FloatKey(name='QPNEAR', comment='If you specify point charges in the input file, there are two considerations implied for the numerical integration grid. First, since the point charges create a Coulomb singularity. The integrands (of for instance the basis function products against the Coulomb potential) can only be evaluated with high precision if the grid around the point charges has spherical symmetry and uses local spherical coordinates, exactly as is done for the atomic nuclei. Second, the point charges do not carry fit or basis functions, hence they play only a role in the more diffuse tails of the actual functions involved in integrals. Therefore, a relative low precision of the integral part close to the point charge may have little effect on the total integration accuracy. Since additional ‘spherical centers’ with their own surrounding grids increase the total number of points significantly, typically a few thousands per Coulomb center, this may result in high computational effort. Therefore, the program generates spherical grids only about those point charges that are close to the other atoms. The criterion, input with the qpnear subkey, is the closest distance between the point charge at hand and any real atom. Default 4.0 Angstrom.', unit='Angstrom')
self.RSPHER: Iterable[float] | FloatListKey = FloatListKey(name='RSPHER', comment='Gives the radii of the atomic spheres, one value for each atom type. By default, the radii are derived from the chemical element (heavier atoms get larger spheres) and from the environment: the sphere must not be too large for the atomic cell (polyhedron).', unit='Bohr')
[docs] class _IrrepOccupations(FreeBlock):
r"""
Explicit occupation numbers per irrep
"""
def __post_init__(self):
pass
[docs] class _LinearScaling(FixedBlock):
r"""
:ivar Cutoff_Coulomb: determines the radii for the fit functions in the evaluation of the (short-range part of) the Coulomb potential.
:vartype Cutoff_Coulomb: float | FloatKey
:ivar Cutoff_Fit: determines how many atom pairs are taken into account in the calculation of the fit integrals and the density fit procedure. If the value is too low, charge will not be conserved and the density fitting procedure will become unreliable. This parameter is relevant for the timings of the FITINT and RHOFIH routines of ADF.
:vartype Cutoff_Fit: float | FloatKey
:ivar Cutoff_Multipoles: determines the cut-offs in the multipole (long-range) part of the Coulomb potential
:vartype Cutoff_Multipoles: float | FloatKey
:ivar HF_Fit: Parameter for HF exchange
:vartype HF_Fit: float | FloatKey
:ivar Overlap_Int: determines the overlap criterion for pairs of AOs in the calculation of the Fock-matrix in a block of points. Indirectly it determines what the cut-off radii for AO's should be. The value of ovint has a strong influence on the timing for the evaluation of the Fock matrix, which is very important for the overall timings
:vartype Overlap_Int: float | FloatKey
:ivar ProgConv: determines how the overall accuracy changes during the SCF procedure
:vartype ProgConv: float | FloatKey
"""
def __post_init__(self):
self.Cutoff_Coulomb: float | FloatKey = FloatKey(name='Cutoff_Coulomb', comment='determines the radii for the fit functions in the evaluation of the (short-range part of) the Coulomb potential. ')
self.Cutoff_Fit: float | FloatKey = FloatKey(name='Cutoff_Fit', comment='determines how many atom pairs are taken into account in the calculation of the fit integrals and the density fit procedure. If the value is too low, charge will not be conserved and the density fitting procedure will become unreliable. This parameter is relevant for the timings of the FITINT and RHOFIH routines of ADF.')
self.Cutoff_Multipoles: float | FloatKey = FloatKey(name='Cutoff_Multipoles', comment='determines the cut-offs in the multipole (long-range) part of the Coulomb potential')
self.HF_Fit: float | FloatKey = FloatKey(name='HF_Fit', comment='Parameter for HF exchange')
self.Overlap_Int: float | FloatKey = FloatKey(name='Overlap_Int', comment="determines the overlap criterion for pairs of AOs in the calculation of the Fock-matrix in a block of points. Indirectly it determines what the cut-off radii for AO's should be. The value of ovint has a strong influence on the timing for the evaluation of the Fock matrix, which is very important for the overall timings")
self.ProgConv: float | FloatKey = FloatKey(name='ProgConv', comment='determines how the overall accuracy changes during the SCF procedure')
[docs] class _LocOrb(FreeBlock):
r"""
The computation of localized orbitals is controlled with this block-type key
"""
def __post_init__(self):
pass
[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 _MDC(FixedBlock):
r"""
Options for Multipole Derived Charges (MDC)
:ivar Debug: Print debug information on MDC
:vartype Debug: BoolType | BoolKey
:ivar ExpMCD: Exponent for MDC
:vartype ExpMCD: float | FloatKey
:ivar IncDum: Parameter for including dummy atoms as positions for distributed charges
:vartype IncDum: int | IntKey
:ivar MDCExp: kind of weight function to be used (Gaussian or Slater[=default])
:vartype MDCExp: int | IntKey
:ivar TolMDC: Numerical accuracy parameter
:vartype TolMDC: float | FloatKey
"""
def __post_init__(self):
self.Debug: BoolType | BoolKey = BoolKey(name='Debug', comment='Print debug information on MDC', default=False)
self.ExpMCD: float | FloatKey = FloatKey(name='ExpMCD', comment='Exponent for MDC', default=3.0)
self.IncDum: int | IntKey = IntKey(name='IncDum', comment='Parameter for including dummy atoms as positions for distributed charges', default=0)
self.MDCExp: int | IntKey = IntKey(name='MDCExp', comment='kind of weight function to be used (Gaussian or Slater[=default])', default=1)
self.TolMDC: float | FloatKey = FloatKey(name='TolMDC', comment='Numerical accuracy parameter', default=1e-09)
[docs] class _ModifyExcitation(FixedBlock):
r"""
:ivar DipStrength:
:vartype DipStrength: float | FloatKey
:ivar GRIMMEAEX:
:vartype GRIMMEAEX: float | FloatKey
:ivar GRIMMEALPHA:
:vartype GRIMMEALPHA: float | FloatKey
:ivar GRIMMEBETA:
:vartype GRIMMEBETA: float | FloatKey
:ivar GRIMMEDEMAX:
:vartype GRIMMEDEMAX: float | FloatKey
:ivar GRIMMEPERTC:
:vartype GRIMMEPERTC: BoolType | BoolKey
:ivar GRIMMETPMIN:
:vartype GRIMMETPMIN: float | FloatKey
:ivar HighExcit:
:vartype HighExcit: float | FloatKey
:ivar NOGRIMMEPERTC:
:vartype NOGRIMMEPERTC: BoolType | BoolKey
:ivar NOverlap:
:vartype NOverlap: int | IntKey
:ivar OscStrength: Use only pairs of an occupied and virtual orbital as guess vectors, for which the oscillator strength of the single-orbital transition is larger than this value
:vartype OscStrength: float | FloatKey
:ivar SetLargeEnergy: The orbital energies of the uninteresting occupied orbitals are changed to -epsbig Hartree, and the orbital energies of the uninteresting virtual orbitals are changed to epsbig Hartree
:vartype SetLargeEnergy: float | FloatKey
:ivar SetOccEnergy: All occupied orbitals that have to be used will change their orbital energy to this value. In practice only useful if one has selected one occupied orbital energy, and one want to change this to another value. Default: the orbital energies of the occupied orbitals that are used are not changed.
:vartype SetOccEnergy: float | FloatKey
:ivar UseOccRange: Use only occupied orbitals which have orbital energies between the two numbers.
:vartype UseOccRange: Iterable[float] | FloatListKey
:ivar UseOccVirtNumbers: Use only pairs of an occupied and virtual orbital as guess vectors, for which in the sorted list of the orbital energy differences, the number of the single-orbital transition is between the two numbers.
:vartype UseOccVirtNumbers: Iterable[int] | IntListKey
:ivar UseOccVirtRange: Use only pairs of an occupied and virtual orbital, for which the orbital energy difference is between the two numbers
:vartype UseOccVirtRange: Iterable[float] | FloatListKey
:ivar UseScaledZORA: Use everywhere the scaled ZORA orbital energies instead of the ZORA orbital energies in the TDDFT equations. This can improve deep core excitation energies. Only valid if ZORA is used.
:vartype UseScaledZORA: BoolType | BoolKey
:ivar UseVirtRange: Use only virtual orbitals which have orbital energies between the two numbers
:vartype UseVirtRange: Iterable[float] | FloatListKey
:ivar UseOccupied: Use only the occupied orbitals which are specified
:vartype UseOccupied: str | Sequence[str] | FreeBlock
:ivar UseVirtual: Use only the virtual orbitals which are specified
:vartype UseVirtual: str | Sequence[str] | FreeBlock
"""
[docs] class _UseOccupied(FreeBlock):
r"""
Use only the occupied orbitals which are specified
"""
def __post_init__(self):
pass
[docs] class _UseVirtual(FreeBlock):
r"""
Use only the virtual orbitals which are specified
"""
def __post_init__(self):
pass
def __post_init__(self):
self.DipStrength: float | FloatKey = FloatKey(name='DipStrength')
self.GRIMMEAEX: float | FloatKey = FloatKey(name='GRIMMEAEX')
self.GRIMMEALPHA: float | FloatKey = FloatKey(name='GRIMMEALPHA')
self.GRIMMEBETA: float | FloatKey = FloatKey(name='GRIMMEBETA')
self.GRIMMEDEMAX: float | FloatKey = FloatKey(name='GRIMMEDEMAX')
self.GRIMMEPERTC: BoolType | BoolKey = BoolKey(name='GRIMMEPERTC')
self.GRIMMETPMIN: float | FloatKey = FloatKey(name='GRIMMETPMIN')
self.HighExcit: float | FloatKey = FloatKey(name='HighExcit')
self.NOGRIMMEPERTC: BoolType | BoolKey = BoolKey(name='NOGRIMMEPERTC')
self.NOverlap: int | IntKey = IntKey(name='NOverlap', default=0)
self.OscStrength: float | FloatKey = FloatKey(name='OscStrength', comment='Use only pairs of an occupied and virtual orbital as guess vectors, for which the oscillator strength of the single-orbital transition is larger than this value')
self.SetLargeEnergy: float | FloatKey = FloatKey(name='SetLargeEnergy', comment='The orbital energies of the uninteresting occupied orbitals are changed to -epsbig Hartree, and the orbital energies of the uninteresting virtual orbitals are changed to epsbig Hartree', default=1000000.0, unit='Hartree')
self.SetOccEnergy: float | FloatKey = FloatKey(name='SetOccEnergy', comment='All occupied orbitals that have to be used will change their orbital energy to this value. In practice only useful if one has selected one occupied orbital energy, and one want to change this to another value. Default: the orbital energies of the occupied orbitals that are used are not changed.')
self.UseOccRange: Iterable[float] | FloatListKey = FloatListKey(name='UseOccRange', comment='Use only occupied orbitals which have orbital energies between the two numbers.', unit='Hartree')
self.UseOccVirtNumbers: Iterable[int] | IntListKey = IntListKey(name='UseOccVirtNumbers', comment='Use only pairs of an occupied and virtual orbital as guess vectors, for which in the sorted list of the orbital energy differences, the number of the single-orbital transition is between the two numbers.')
self.UseOccVirtRange: Iterable[float] | FloatListKey = FloatListKey(name='UseOccVirtRange', comment='Use only pairs of an occupied and virtual orbital, for which the orbital energy difference is between the two numbers', unit='Hartree')
self.UseScaledZORA: BoolType | BoolKey = BoolKey(name='UseScaledZORA', comment='Use everywhere the scaled ZORA orbital energies instead of the ZORA orbital energies in the TDDFT equations. This can improve deep core excitation energies. Only valid if ZORA is used.', default=False)
self.UseVirtRange: Iterable[float] | FloatListKey = FloatListKey(name='UseVirtRange', comment='Use only virtual orbitals which have orbital energies between the two numbers', unit='Hartree')
self.UseOccupied: str | Sequence[str] | FreeBlock = self._UseOccupied(name='UseOccupied', comment='Use only the occupied orbitals which are specified')
self.UseVirtual: str | Sequence[str] | FreeBlock = self._UseVirtual(name='UseVirtual', comment='Use only the virtual orbitals which are specified')
[docs] class _ModifyStartPotential(FreeBlock):
r"""
Modify the starting spin-dependent potential for unrestricted calculations.
"""
def __post_init__(self):
pass
[docs] class _Nanoparticle(FixedBlock):
r"""
To include the presence of a nanoparticle near the system
:ivar TransitionPotential: Evaluate the transition potential due to a nanoparticle
:vartype TransitionPotential: BoolType | BoolKey
"""
def __post_init__(self):
self.TransitionPotential: BoolType | BoolKey = BoolKey(name='TransitionPotential', comment='Evaluate the transition potential due to a nanoparticle', default=False)
[docs] class _PertLoc(FixedBlock):
r"""
Perturbed localized molecular orbitals, correct to first order in an applied field, can be calculated in case of AORESPONSE. Can be used if the applied field changes the density in first order.
:ivar Alfa: Analyze the static or dynamic polarizability
:vartype Alfa: BoolType | BoolKey
:ivar BField: The perturbation is a magnetic field. Should be consistent with AORESPONSE
:vartype BField: BoolType | BoolKey
:ivar Beta: Analyze the optical rotation parameter beta. The relation to G' is beta = -G'/omega. The optical rotation parameter beta is calculated directly and has a well-defined static limit, i.e. omega can be zero or non-zero
:vartype Beta: BoolType | BoolKey
:ivar Diag: Only analyze the diagonal of the response tensor
:vartype Diag: BoolType | BoolKey
:ivar Dynamic: Should be used for a frequency dependent perturbation field.
:vartype Dynamic: BoolType | BoolKey
:ivar EField: The perturbation is an electric field
:vartype EField: BoolType | BoolKey
:ivar Fulltens: The full tensor is analyzed
:vartype Fulltens: BoolType | BoolKey
:ivar GPrime: Analyze the G' (gyration) tensor, for optical rotation dispersion. Requires a frequency dependent perturbation field, with a frequency (omega) unequal to zero.
:vartype GPrime: BoolType | BoolKey
:ivar Static: should be used for a static field
:vartype Static: BoolType | BoolKey
"""
def __post_init__(self):
self.Alfa: BoolType | BoolKey = BoolKey(name='Alfa', comment='Analyze the static or dynamic polarizability', default=False)
self.BField: BoolType | BoolKey = BoolKey(name='BField', comment='The perturbation is a magnetic field. Should be consistent with AORESPONSE', default=False)
self.Beta: BoolType | BoolKey = BoolKey(name='Beta', comment="Analyze the optical rotation parameter beta. The relation to G' is beta = -G'/omega. The optical rotation parameter beta is calculated directly and has a well-defined static limit, i.e. omega can be zero or non-zero", default=False)
self.Diag: BoolType | BoolKey = BoolKey(name='Diag', comment='Only analyze the diagonal of the response tensor', default=True)
self.Dynamic: BoolType | BoolKey = BoolKey(name='Dynamic', comment='Should be used for a frequency dependent perturbation field.', default=False)
self.EField: BoolType | BoolKey = BoolKey(name='EField', comment='The perturbation is an electric field', default=True)
self.Fulltens: BoolType | BoolKey = BoolKey(name='Fulltens', comment='The full tensor is analyzed', default=False)
self.GPrime: BoolType | BoolKey = BoolKey(name='GPrime', comment="Analyze the G' (gyration) tensor, for optical rotation dispersion. Requires a frequency dependent perturbation field, with a frequency (omega) unequal to zero.", default=False)
self.Static: BoolType | BoolKey = BoolKey(name='Static', comment='should be used for a static field', default=True)
[docs] class _PolTDDFT(FixedBlock):
r"""
POLTDDFT is a fast algorithm to solve the TDDFT equations in the space of the density fitting auxiliary basis set. The (real and imaginary part of the) diagonal of the polarizability tensor and rotatory strengths will be calculated, which can be used to calculate the photoabsorption and circular dichroism (CD) spectra.
:ivar Analysis: An analysis of the absorption and CD spectrum in terms of single orbital transitions.
:vartype Analysis: BoolType | BoolKey
:ivar CutOff: For a given point in the spectrum, only include pairs of an occupied and virtual orbital, for which the orbital energy difference is lower than the energy of the point in the spectrum plus cutoff.
:vartype CutOff: float | FloatKey
:ivar Enabled: Calculate UV/Vis and CD spectrum from the imaginary part of the polarizability tensor at any given photon energy. This avoids the bottleneck of Davidson diagonalization.
:vartype Enabled: BoolType | BoolKey
:ivar FreqRange: Specifies a frequency range of frequencies of incident light, the perturbing field, at which the complex dynamical polarizability will be calculated. 2 numbers: an upper and a lower bound. Use subkey NFreq to specify the number of frequencies.
:vartype FreqRange: Iterable[float] | FloatListKey
:ivar HDA_fitted: Use fit functions to calculate HDA (Hybrid diagonal approximation), only relevant for hybrids.
:vartype HDA_fitted: BoolType | BoolKey
:ivar KGrid: Keyword KGRID is used to discretize the energy scale for calculating the complex dynamical polarizability. Only pairs of an occupied and virtual orbital are included, for which the orbital energy difference is lower than this value. Use key NGRID to set the number of points within the energy grid.
:vartype KGrid: float | FloatKey
:ivar Lambda: Jacob's scaling factor for the study of plasmonic resonances.
This factor, 0<lambda<1, turns on the coupling matrix K.
:vartype Lambda: float | FloatKey
:ivar Lifetime: Specify the resonance peak width (damping).
Typically the lifetime of the excited states is approximated with a common phenomenological damping parameter. Values are best obtained by fitting absorption data for the molecule, however, the values do not vary a lot between similar molecules, so it is not hard to estimate values.
:vartype Lifetime: float | FloatKey
:ivar NFreq: NFreq is the number of frequencies of incident light, the perturbing field, at which the complex dynamical polarizability will be calculated. Use FreqRange to specify the frequency range.
:vartype NFreq: int | IntKey
:ivar NGrid: Ngrid is the number of points within the energy grid.
:vartype NGrid: int | IntKey
:ivar N_FitOrb: The number of vectors containing the coefficients we use to expand the projection of each fitting function over the electron density (of a particular molecular orbital) as a linear combination of overlap matrices between fitting functions pair
:vartype N_FitOrb: int | IntKey
:ivar N_HDA_integral:
:vartype N_HDA_integral: int | IntKey
:ivar N_SubMatricesAk:
:vartype N_SubMatricesAk: int | IntKey
:ivar Print_Int_Time: Print detailed timing during calculation of integrals of Tape63 and Tape64
:vartype Print_Int_Time: int | IntKey
:ivar RegionsForAnalysis: Names of regions for analysis per region using the fragment projection analysis approach. Will split the absorption and CD spectrum in region_i -> region_j terms.
:vartype RegionsForAnalysis: str | StringKey
:ivar Velocity: If True, ADF calculates the dipole moment in velocity gauge.
If false: dipole-length representation is used
:vartype Velocity: BoolType | BoolKey
:ivar Irrep: Subblock key for selecting which symmetry irreps of the excitations to calculate (all excitations by default). In the subkey data block list the symmetry irrep labels, like B1, for example
:vartype Irrep: str | Sequence[str] | FreeBlock
"""
[docs] class _Irrep(FreeBlock):
r"""
Subblock key for selecting which symmetry irreps of the excitations to calculate (all excitations by default). In the subkey data block list the symmetry irrep labels, like B1, for example
"""
def __post_init__(self):
pass
def __post_init__(self):
self.Analysis: BoolType | BoolKey = BoolKey(name='Analysis', comment='An analysis of the absorption and CD spectrum in terms of single orbital transitions.', default=False)
self.CutOff: float | FloatKey = FloatKey(name='CutOff', comment='For a given point in the spectrum, only include pairs of an occupied and virtual orbital, for which the orbital energy difference is lower than the energy of the point in the spectrum plus cutoff.', default=4.0, unit='eV')
self.Enabled: BoolType | BoolKey = BoolKey(name='Enabled', comment='Calculate UV/Vis and CD spectrum from the imaginary part of the polarizability tensor at any given photon energy. This avoids the bottleneck of Davidson diagonalization.', gui_name='UV/Vis and CD spectrum:', default=False)
self.FreqRange: Iterable[float] | FloatListKey = FloatListKey(name='FreqRange', comment='Specifies a frequency range of frequencies of incident light, the perturbing field, at which the complex dynamical polarizability will be calculated. 2 numbers: an upper and a lower bound. Use subkey NFreq to specify the number of frequencies.', default=[0.0, 5.0], unit='eV')
self.HDA_fitted: BoolType | BoolKey = BoolKey(name='HDA_fitted', comment='Use fit functions to calculate HDA (Hybrid diagonal approximation), only relevant for hybrids. ', gui_name='Fitted HDA:', default=False)
self.KGrid: float | FloatKey = FloatKey(name='KGrid', comment='Keyword KGRID is used to discretize the energy scale for calculating the complex dynamical polarizability. Only pairs of an occupied and virtual orbital are included, for which the orbital energy difference is lower than this value. Use key NGRID to set the number of points within the energy grid.', default=9.0, unit='eV')
self.Lambda: float | FloatKey = FloatKey(name='Lambda', comment="Jacob's scaling factor for the study of plasmonic resonances.\n\nThis factor, 0<lambda<1, turns on the coupling matrix K.", default=1.0)
self.Lifetime: float | FloatKey = FloatKey(name='Lifetime', comment='Specify the resonance peak width (damping).\n\nTypically the lifetime of the excited states is approximated with a common phenomenological damping parameter. Values are best obtained by fitting absorption data for the molecule, however, the values do not vary a lot between similar molecules, so it is not hard to estimate values.', default=0.1, unit='eV')
self.NFreq: int | IntKey = IntKey(name='NFreq', comment='NFreq is the number of frequencies of incident light, the perturbing field, at which the complex dynamical polarizability will be calculated. Use FreqRange to specify the frequency range.', default=100)
self.NGrid: int | IntKey = IntKey(name='NGrid', comment='Ngrid is the number of points within the energy grid.', default=180)
self.N_FitOrb: int | IntKey = IntKey(name='N_FitOrb', comment='The number of vectors containing the coefficients we use to expand the projection of each fitting function over the electron density (of a particular molecular orbital) as a linear combination of overlap matrices between fitting functions pair', default=1000000000)
self.N_HDA_integral: int | IntKey = IntKey(name='N_HDA_integral', default=1000000000)
self.N_SubMatricesAk: int | IntKey = IntKey(name='N_SubMatricesAk', default=1000000000)
self.Print_Int_Time: int | IntKey = IntKey(name='Print_Int_Time', comment='Print detailed timing during calculation of integrals of Tape63 and Tape64', default=0)
self.RegionsForAnalysis: str | StringKey = StringKey(name='RegionsForAnalysis', comment='Names of regions for analysis per region using the fragment projection analysis approach. Will split the absorption and CD spectrum in region_i -> region_j terms.')
self.Velocity: BoolType | BoolKey = BoolKey(name='Velocity', comment='If True, ADF calculates the dipole moment in velocity gauge.\n\nIf false: dipole-length representation is used', gui_name='Velocity representation:', default=False)
self.Irrep: str | Sequence[str] | FreeBlock = self._Irrep(name='Irrep', comment='Subblock key for selecting which symmetry irreps of the excitations to calculate (all excitations by default). In the subkey data block list the symmetry irrep labels, like B1, for example', header=True)
[docs] class _QMFQ(FixedBlock):
r"""
Block input key for QM/FQ(FMu).
:ivar DEBUG: The DEBUG subkey will print additional information from the FQ subroutines.
:vartype DEBUG: BoolType | BoolKey
:ivar FDERESP: In response calculations (TD), the polarization contribution of the FDE part is introduced at the FQ level [See F. Egidi et al. J. Chem. Phys. 2021, 154, 164107].
:vartype FDERESP: BoolType | BoolKey
:ivar Forcefield: Version of the FQ family of polarizable forcefields
:vartype Forcefield: Literal["FQ", "FQ_RQ", "FQFMU", "FQFMU_RQRMU", "NOPOL"]
:ivar Frozen: Expert option. Do not introduce polarization effect in response calculations.
:vartype Frozen: BoolType | BoolKey
:ivar Kernel: Expert option. KERNEL can be used to choose the functional form of the charge-charge interaction kernel between MM atoms. Recommended is to use the default OHNO. The COUL screening is the standard Coulomb interaction 1/r. The OHNO choice introduce the Ohno functional (see [K. Ohno, Theoret. Chim. Acta 2, 219 (1964)]), which depends on a parameter n that is set equal to 2. Finally, the GAUS screening models each FQ charge by means of a spherical Gaussian-type distribution, and the interaction kernel is obtained accordingly. For QM/FQFMU only GAUS SCREEN is implemented.
:vartype Kernel: Literal["OHNO", "COUL", "GAUS"]
:ivar MolCharge: Total charge of each fragment (FQ only)
:vartype MolCharge: float | FloatKey
:ivar NOGROUNDSTATE: Avoid introducing FQ effects on ground state calculations
:vartype NOGROUNDSTATE: BoolType | BoolKey
:ivar NonEle: Whether to include non-electrostatic contributions to the energy. Default is the Lennard-Jones (LJ) model.
:vartype NonEle: Literal["LJ", "None"]
:ivar QMSCREEN: Expert option. QMSCREEN can be used to choose the functional form of the charge-charge interaction kernel between MM atoms and the QM density. The screening types available are ERF (error function), EXP (exponential), GAUS (Gaussian), or NONE. The default is GAUS.
:vartype QMSCREEN: Literal["ERF", "EXP", "GAUS", "NONE"]
:ivar QMSCREENFACTOR: Expert option. Sets the QM/MM interaction kernel screening length. Recommended is to use the default value 0.2 with the GAUS QM/MM screening function.
:vartype QMSCREENFACTOR: float | FloatKey
:ivar AtomType: Definition of atomic types in MM environment
:vartype AtomType: ADF._QMFQ._AtomType
:ivar Coords: Coordinates and fragment information (FQ only)
:vartype Coords: str | Sequence[str] | FreeBlock
:ivar Repulsion: Definition of parameters for Pauli repulsion (see JCTC ....)
:vartype Repulsion: ADF._QMFQ._Repulsion
:ivar Solver:
:vartype Solver: ADF._QMFQ._Solver
"""
[docs] class _AtomType(FixedBlock):
r"""
Definition of atomic types in MM environment
:ivar Alpha: Polarizability of FQFMU atom
:vartype Alpha: float | FloatKey
:ivar Charge: MM fixed charge (non-polarizable only)
:vartype Charge: float | FloatKey
:ivar Chi: Electronegativity of FQ atom
:vartype Chi: float | FloatKey
:ivar Eta: Chemical Hardness of FQ atom
:vartype Eta: float | FloatKey
:ivar RMU: Variance for FQFMU_RQRMU Gaussians
:vartype RMU: float | FloatKey
:ivar RQ: Variance for FQ_RQ Gaussians
:vartype RQ: float | FloatKey
:ivar Symbol: Symbol associated with atom type
:vartype Symbol: str | StringKey
"""
def __post_init__(self):
self.Alpha: float | FloatKey = FloatKey(name='Alpha', comment='Polarizability of FQFMU atom')
self.Charge: float | FloatKey = FloatKey(name='Charge', comment='MM fixed charge (non-polarizable only)')
self.Chi: float | FloatKey = FloatKey(name='Chi', comment='Electronegativity of FQ atom')
self.Eta: float | FloatKey = FloatKey(name='Eta', comment='Chemical Hardness of FQ atom')
self.RMU: float | FloatKey = FloatKey(name='RMU', comment='Variance for FQFMU_RQRMU Gaussians', hidden=True)
self.RQ: float | FloatKey = FloatKey(name='RQ', comment='Variance for FQ_RQ Gaussians', hidden=True)
self.Symbol: str | StringKey = StringKey(name='Symbol', comment='Symbol associated with atom type')
[docs] class _Coords(FreeBlock):
r"""
Coordinates and fragment information (FQ only)
"""
def __post_init__(self):
pass
[docs] class _Repulsion(FixedBlock):
r"""
Definition of parameters for Pauli repulsion (see JCTC ....)
:ivar AtomDistance: Each fictitious Slater function is added only if the associated MM atom is closer than the AtomDistance threshold (in Angstrom) to a QM atom
:vartype AtomDistance: float | FloatKey
:ivar Basis: Slater type basis function to add on a specific atom type in the environment.
:vartype Basis: ADF._QMFQ._Repulsion._Basis
"""
[docs] class _Basis(FixedBlock):
r"""
Slater type basis function to add on a specific atom type in the environment.
:ivar AngMom: Angular momentum
:vartype AngMom: int | IntKey
:ivar AtomType: Atom Type on which the basis function has to be added
:vartype AtomType: str | StringKey
:ivar Coeff: Coefficient of the basis function
:vartype Coeff: float | FloatKey
:ivar Exp: Exponent of the basis function
:vartype Exp: float | FloatKey
"""
def __post_init__(self):
self.AngMom: int | IntKey = IntKey(name='AngMom', comment='Angular momentum')
self.AtomType: str | StringKey = StringKey(name='AtomType', comment='Atom Type on which the basis function has to be added')
self.Coeff: float | FloatKey = FloatKey(name='Coeff', comment='Coefficient of the basis function')
self.Exp: float | FloatKey = FloatKey(name='Exp', comment='Exponent of the basis function')
def __post_init__(self):
self.AtomDistance: float | FloatKey = FloatKey(name='AtomDistance', comment='Each fictitious Slater function is added only if the associated MM atom is closer than the AtomDistance threshold (in Angstrom) to a QM atom', default=5.0)
self.Basis: ADF._QMFQ._Repulsion._Basis = self._Basis(name='Basis', comment='Slater type basis function to add on a specific atom type in the environment. ', unique=False)
[docs] class _Solver(FixedBlock):
r"""
:ivar Algorithm:
:vartype Algorithm: Literal["DIRECT", "ITER"]
:ivar Debug:
:vartype Debug: BoolType | BoolKey
:ivar NumIt:
:vartype NumIt: int | IntKey
:ivar THRESH:
:vartype THRESH: float | FloatKey
"""
def __post_init__(self):
self.Algorithm: Literal["DIRECT", "ITER"] = MultipleChoiceKey(name='Algorithm', default='DIRECT', choices=['DIRECT', 'ITER'])
self.Debug: BoolType | BoolKey = BoolKey(name='Debug', default=False)
self.NumIt: int | IntKey = IntKey(name='NumIt', default=100)
self.THRESH: float | FloatKey = FloatKey(name='THRESH', default=1e-06)
def __post_init__(self):
self.DEBUG: BoolType | BoolKey = BoolKey(name='DEBUG', comment='The DEBUG subkey will print additional information from the FQ subroutines.', hidden=True, default=False)
self.FDERESP: BoolType | BoolKey = BoolKey(name='FDERESP', comment='In response calculations (TD), the polarization contribution of the FDE part is introduced at the FQ level [See F. Egidi et al. J. Chem. Phys. 2021, 154, 164107].', default=False)
self.Forcefield: Literal["FQ", "FQ_RQ", "FQFMU", "FQFMU_RQRMU", "NOPOL"] = MultipleChoiceKey(name='Forcefield', comment='Version of the FQ family of polarizable forcefields', default='FQ', choices=['FQ', 'FQ_RQ', 'FQFMU', 'FQFMU_RQRMU', 'NOPOL'], hiddenchoices=['FQ_RQ', 'FQFMU_RQRMU', 'NOPOL'])
self.Frozen: BoolType | BoolKey = BoolKey(name='Frozen', comment='Expert option. Do not introduce polarization effect in response calculations.', default=False)
self.Kernel: Literal["OHNO", "COUL", "GAUS"] = MultipleChoiceKey(name='Kernel', comment='Expert option. KERNEL can be used to choose the functional form of the charge-charge interaction kernel between MM atoms. Recommended is to use the default OHNO. The COUL screening is the standard Coulomb interaction 1/r. The OHNO choice introduce the Ohno functional (see [K. Ohno, Theoret. Chim. Acta 2, 219 (1964)]), which depends on a parameter n that is set equal to 2. Finally, the GAUS screening models each FQ charge by means of a spherical Gaussian-type distribution, and the interaction kernel is obtained accordingly. For QM/FQFMU only GAUS SCREEN is implemented. ', default='OHNO', choices=['OHNO', 'COUL', 'GAUS'])
self.MolCharge: float | FloatKey = FloatKey(name='MolCharge', comment='Total charge of each fragment (FQ only)', default=0.0)
self.NOGROUNDSTATE: BoolType | BoolKey = BoolKey(name='NOGROUNDSTATE', comment='Avoid introducing FQ effects on ground state calculations', hidden=True, default=False)
self.NonEle: Literal["LJ", "None"] = MultipleChoiceKey(name='NonEle', comment='Whether to include non-electrostatic contributions to the energy. Default is the Lennard-Jones (LJ) model.', default='LJ', choices=['LJ', 'None'])
self.QMSCREEN: Literal["ERF", "EXP", "GAUS", "NONE"] = MultipleChoiceKey(name='QMSCREEN', comment='Expert option. QMSCREEN can be used to choose the functional form of the charge-charge interaction kernel between MM atoms and the QM density. The screening types available are ERF (error function), EXP (exponential), GAUS (Gaussian), or NONE. The default is GAUS.', default='GAUS', choices=['ERF', 'EXP', 'GAUS', 'NONE'])
self.QMSCREENFACTOR: float | FloatKey = FloatKey(name='QMSCREENFACTOR', comment='Expert option. Sets the QM/MM interaction kernel screening length. Recommended is to use the default value 0.2 with the GAUS QM/MM screening function.', default=0.2)
self.AtomType: ADF._QMFQ._AtomType = self._AtomType(name='AtomType', comment='Definition of atomic types in MM environment', unique=False)
self.Coords: str | Sequence[str] | FreeBlock = self._Coords(name='Coords', comment='Coordinates and fragment information (FQ only)')
self.Repulsion: ADF._QMFQ._Repulsion = self._Repulsion(name='Repulsion', comment='Definition of parameters for Pauli repulsion (see JCTC ....)', hidden=True)
self.Solver: ADF._QMFQ._Solver = self._Solver(name='Solver', hidden=True)
[docs] class _QTAIM(FixedBlock):
r"""
This block is used to request a topological analysis of the gradient field of the electron density, also known as the Bader's analysis. If this block is specified without any sub-key, only local properties are calculated.
:ivar AnalysisLevel: Set the level of the QTAIM analysis:
Normal - topology analysis and properties at the density critical points,
Extended - same as Normal plus condensed atomic descriptors,
Full - same as Extended plus non-local descriptors.
:vartype AnalysisLevel: Literal["Normal", "Extended", "Full"]
:ivar AtomsToDo: List of atoms for which condensed descriptors are to be calculated. By default all atoms are included.
:vartype AtomsToDo: Iterable[int] | IntListKey
:ivar Enabled: Calculate QTAIM (also known as Bader) properties.
:vartype Enabled: BoolType | BoolKey
:ivar Energy: Calculate atomic energies. Requires an all-electron calculation (no frozen core), triggers the TotalEnergy and increases the [AnalysisLevel] to at least Extended.
:vartype Energy: BoolType | BoolKey
:ivar Source: Calculate the Source Function at BCPs and RCPs.
:vartype Source: BoolType | BoolKey
:ivar Spacing: Specifies spacing of the initial Cartesian grid when searching for critical points. It may be useful to specify a smaller value than the default if some critical points are missed. This will result in a more accurate but slower calculation.
:vartype Spacing: float | FloatKey
"""
def __post_init__(self):
self.AnalysisLevel: Literal["Normal", "Extended", "Full"] = MultipleChoiceKey(name='AnalysisLevel', comment='Set the level of the QTAIM analysis: \n\n Normal - topology analysis and properties at the density critical points, \n\n Extended - same as Normal plus condensed atomic descriptors, \n\n Full - same as Extended plus non-local descriptors.', default='Normal', choices=['Normal', 'Extended', 'Full'])
self.AtomsToDo: Iterable[int] | IntListKey = IntListKey(name='AtomsToDo', comment='List of atoms for which condensed descriptors are to be calculated. By default all atoms are included.', gui_name='Include atoms:', isatomlist=True)
self.Enabled: BoolType | BoolKey = BoolKey(name='Enabled', comment='Calculate QTAIM (also known as Bader) properties.', gui_name='Perform QTAIM analysis:', default=False)
self.Energy: BoolType | BoolKey = BoolKey(name='Energy', comment='Calculate atomic energies. Requires an all-electron calculation (no frozen core), triggers the TotalEnergy and increases the [AnalysisLevel] to at least Extended.', gui_name='Atomic energies:', default=False)
self.Source: BoolType | BoolKey = BoolKey(name='Source', comment='Calculate the Source Function at BCPs and RCPs.', gui_name='Source Function:', default=False)
self.Spacing: float | FloatKey = FloatKey(name='Spacing', comment='Specifies spacing of the initial Cartesian grid when searching for critical points. It may be useful to specify a smaller value than the default if some critical points are missed. This will result in a more accurate but slower calculation.', default=0.5, unit='Bohr')
[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: ADF._RIHartreeFock._ExplicitThresholds
:ivar FitGenerationDetails: Technical details about how the RI Hartree-Fock fit functions are generated.
:vartype FitGenerationDetails: ADF._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: ADF._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: ADF._RIHartreeFock._ExplicitThresholds = self._ExplicitThresholds(name='ExplicitThresholds', comment='Override the thresholds as implied by the ThresholdQuality.')
self.FitGenerationDetails: ADF._RIHartreeFock._FitGenerationDetails = self._FitGenerationDetails(name='FitGenerationDetails', comment='Technical details about how the RI Hartree-Fock fit functions are generated.')
self.QualityPerRegion: ADF._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 _RISM(FreeBlock):
r"""
3D-RISM-related input keys.
"""
def __post_init__(self):
pass
[docs] class _ROSE(FixedBlock):
r"""
Options for orbital localization
:ivar Additional_virtuals_cutoff: Specifies the energy threshold to determine the number of additional hard virtuals to localize for the supermolecule. If not specified the default value is used.
:vartype Additional_virtuals_cutoff: float | FloatKey
:ivar Exponent: The value of the exponent (for the default Pipek-Mezey type of localization, the exponent is equal to 2. A higher value of 3 or 4 is sometimes useful.).
:vartype Exponent: int | IntKey
:ivar Frag_bias: Expert key. Specifies the bias applied to each fragment when assigning the localized orbitals to a particular fragment. Use a negative value for default behavior for a given fragment. If not specified, or if the number of items is unequal the number of fragments, a default bias is used.
:vartype Frag_bias: Iterable[float] | FloatListKey
:ivar Frag_threshold: Specifies energy threshold to determine number of reference hard virtuals to use for the fragments (needed to localize the additional hard virtuals). The total number of reference virtuals should be larger than the number of virtual MOs to localize (similar to having more reference valence orbitals than occupied valence orbitals to localize), so it is advisable to use a relatively high value for this parameter. If not specified the default value is used.
:vartype Frag_threshold: float | FloatKey
:ivar Frag_valence: Expert key. Specifies the number of valence orbitals for each fragment. Use a negative value for default behavior for a given fragment. If not specified, or if the number of items is unequal the number of fragments, by default the code generates the valence space for each fragment as the sum of valence orbitals of individual atoms within each fragment.
:vartype Frag_valence: Iterable[int] | IntListKey
:ivar FragmentFile: Path (either absolute or relative) of each fragment file. The number of fragments used to project on will be number of occurrences of this key.
:vartype FragmentFile: str | Path | StringKey
:ivar GWenergies: Use GW energies instead of DFT energies.
:vartype GWenergies: BoolType | BoolKey
:ivar GWorbitals: Use GW orbitals instead of DFT orbitals.
:vartype GWorbitals: BoolType | BoolKey
:ivar Version: Expert key, specifies version of the IAO generation. If not specified a default value is used.
:vartype Version: Literal["Stndrd_2013", "Simple_2013", "Simple_2014"]
:ivar nfragments: Expert key, preferably use the FragmentFile key for each fragment instead, and do not use this key. If the FragmentFile key is not used, then with this key one can specify the number of fragments used to project on. If this key is used the fragment file names should be called frag1.rkf, frag2.rkf, etcetera, and should be present at the directory where ams is started.
:vartype nfragments: int | IntKey
"""
def __post_init__(self):
self.Additional_virtuals_cutoff: float | FloatKey = FloatKey(name='Additional_virtuals_cutoff', comment='Specifies the energy threshold to determine the number of additional hard virtuals to localize for the supermolecule. If not specified the default value is used.', gui_name='Additional virtuals cutoff:', default=2.0, unit='Hartree')
self.Exponent: int | IntKey = IntKey(name='Exponent', comment='The value of the exponent (for the default Pipek-Mezey type of localization, the exponent is equal to 2. A higher value of 3 or 4 is sometimes useful.).')
self.Frag_bias: Iterable[float] | FloatListKey = FloatListKey(name='Frag_bias', comment='Expert key. Specifies the bias applied to each fragment when assigning the localized orbitals to a particular fragment. Use a negative value for default behavior for a given fragment. If not specified, or if the number of items is unequal the number of fragments, a default bias is used.')
self.Frag_threshold: float | FloatKey = FloatKey(name='Frag_threshold', comment='Specifies energy threshold to determine number of reference hard virtuals to use for the fragments (needed to localize the additional hard virtuals). The total number of reference virtuals should be larger than the number of virtual MOs to localize (similar to having more reference valence orbitals than occupied valence orbitals to localize), so it is advisable to use a relatively high value for this parameter. If not specified the default value is used.', gui_name='Frag threshold:', default=10.0, unit='Hartree')
self.Frag_valence: Iterable[int] | IntListKey = IntListKey(name='Frag_valence', comment='Expert key. Specifies the number of valence orbitals for each fragment. Use a negative value for default behavior for a given fragment. If not specified, or if the number of items is unequal the number of fragments, by default the code generates the valence space for each fragment as the sum of valence orbitals of individual atoms within each fragment.')
self.FragmentFile: str | Path | StringKey = PathStringKey(name='FragmentFile', comment='Path (either absolute or relative) of each fragment file. The number of fragments used to project on will be number of occurrences of this key.', unique=False, ispath=True)
self.GWenergies: BoolType | BoolKey = BoolKey(name='GWenergies', comment='Use GW energies instead of DFT energies.', hidden=True, default=False)
self.GWorbitals: BoolType | BoolKey = BoolKey(name='GWorbitals', comment='Use GW orbitals instead of DFT orbitals.', hidden=True, default=False)
self.Version: Literal["Stndrd_2013", "Simple_2013", "Simple_2014"] = MultipleChoiceKey(name='Version', comment='Expert key, specifies version of the IAO generation. If not specified a default value is used.', choices=['Stndrd_2013', 'Simple_2013', 'Simple_2014'])
self.nfragments: int | IntKey = IntKey(name='nfragments', comment='Expert key, preferably use the FragmentFile key for each fragment instead, and do not use this key. If the FragmentFile key is not used, then with this key one can specify the number of fragments used to project on. If this key is used the fragment file names should be called frag1.rkf, frag2.rkf, etcetera, and should be present at the directory where ams is started.', default=2)
[docs] class _RadialCoreGrid(FixedBlock):
r"""
For each atom the charge densities and the coulomb potentials of frozen core and valence electrons are computed in a radial grid. The radial grid consists of a sequence of r-values, defined by a smallest value, a constant multiplication factor to obtain each successive r-value, and the total number of points. Equivalently it can be characterized by the smallest r-value, the largest r-value, and the number of points; from these data the program computes then the constant multiplication factor.
:ivar NRad: The number of radial grid points
:vartype NRad: int | IntKey
:ivar RMax: The largest distance in the radial grid
:vartype RMax: float | FloatKey
:ivar RMin: The shortest distance used in the radial grid
:vartype RMin: float | FloatKey
"""
def __post_init__(self):
self.NRad: int | IntKey = IntKey(name='NRad', comment='The number of radial grid points', default=5000)
self.RMax: float | FloatKey = FloatKey(name='RMax', comment='The largest distance in the radial grid', default=100.0, unit='Angstrom')
self.RMin: float | FloatKey = FloatKey(name='RMin', comment='The shortest distance used in the radial grid', default=1e-06, unit='Angstrom')
[docs] class _Relativity(FixedBlock):
r"""
Options for relativistic effects.
:ivar Formalism: Note that if Level is None, no relativistic effects are taken into account, irrespective of the chosen formalism.
Pauli stands for the Pauli Hamiltonian.
ZORA means the Zero Order Regular Approximated Hamiltonian, recommended.
X2C and RA-X2C both stand for an exact transformation of the 4-component Dirac equation to 2-components.
X2C is the modified Dirac equation by Dyall.
RA-X2C is the regular approach to the modified Dirac equation.
:vartype Formalism: Literal["Pauli", "ZORA", "X2C", "RA-X2C"]
:ivar Level: None: No relativistic effects.
Scalar: Scalar relativistic.
This option comes at very little cost.
Spin-Orbit: Spin-orbit coupled.
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 subkey.
:vartype Level: Literal["None", "Scalar", "Spin-Orbit"]
:ivar Potential: Starting from ADF2017 instead of SAPA (the Sum of neutral Atomic potential Approximation) MAPA is used by default for ZORA. The MAPA (the Minimum of neutral Atomic potential Approximation) at a point is the minimum of the neutral Atomic potentials at that point. Advantage of MAPA over SAPA is that the gauge dependence of ZORA is reduced. The ZORA gauge dependency is small for almost all properties, except for the electron density very close to a heavy nucleus. The electron density very close to a heavy nucleus can be used for the interpretation of isomer shifts in Mossbauer spectroscopy.
:vartype Potential: Literal["MAPA", "SAPA"]
:ivar SOUExact: Expert option for unrestricted spin-orbit coupled calculations.
:vartype SOUExact: BoolType | BoolKey
:ivar SpinOrbitMagnetization: Relevant only for spin-orbit coupling and if unrestricted key has been activated.
Most XC functionals have as one ingredient the spin polarization in case of unrestricted calculations. Normally the direction of the spin quantization axis is arbitrary and conveniently chosen to be the z-axis.
However, in a spin-orbit calculation the direction matters, and it is arbitrary to put the z-component of the magnetization vector into the XC functional. There is also the exotic option to choose the quantization axis along the x or y axis.
It is also possible to plug the size of the magnetization vector into the XC functional. This is called the non-collinear approach.
- NonCollinear: the non-collinear method.
- CollinearXYZ: use the x, y, or z component as spin polarization for the XC functional.
- Collinear: the same as CollinearZ.
:vartype SpinOrbitMagnetization: Literal["NonCollinear", "Collinear", "CollinearX", "CollinearY", "CollinearZ"]
"""
def __post_init__(self):
self.Formalism: Literal["Pauli", "ZORA", "X2C", "RA-X2C"] = MultipleChoiceKey(name='Formalism', comment='Note that if Level is None, no relativistic effects are taken into account, irrespective of the chosen formalism.\n\nPauli stands for the Pauli Hamiltonian.\n\nZORA means the Zero Order Regular Approximated Hamiltonian, recommended.\n\nX2C and RA-X2C both stand for an exact transformation of the 4-component Dirac equation to 2-components.\n\nX2C is the modified Dirac equation by Dyall.\n\nRA-X2C is the regular approach to the modified Dirac equation.', default='ZORA', choices=['Pauli', 'ZORA', 'X2C', 'RA-X2C'])
self.Level: Literal["None", "Scalar", "Spin-Orbit"] = MultipleChoiceKey(name='Level', comment='None: No relativistic effects.\n\nScalar: Scalar relativistic.\nThis option comes at very little cost.\n\nSpin-Orbit: Spin-orbit coupled.\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 subkey.', gui_name='Relativity:', default='Scalar', choices=['None', 'Scalar', 'Spin-Orbit'])
self.Potential: Literal["MAPA", "SAPA"] = MultipleChoiceKey(name='Potential', comment='Starting from ADF2017 instead of SAPA (the Sum of neutral Atomic potential Approximation) MAPA is used by default for ZORA. The MAPA (the Minimum of neutral Atomic potential Approximation) at a point is the minimum of the neutral Atomic potentials at that point. Advantage of MAPA over SAPA is that the gauge dependence of ZORA is reduced. The ZORA gauge dependency is small for almost all properties, except for the electron density very close to a heavy nucleus. The electron density very close to a heavy nucleus can be used for the interpretation of isomer shifts in Mossbauer spectroscopy.', default='MAPA', choices=['MAPA', 'SAPA'])
self.SOUExact: BoolType | BoolKey = BoolKey(name='SOUExact', comment='Expert option for unrestricted spin-orbit coupled calculations.', hidden=True, default=False)
self.SpinOrbitMagnetization: Literal["NonCollinear", "Collinear", "CollinearX", "CollinearY", "CollinearZ"] = MultipleChoiceKey(name='SpinOrbitMagnetization', comment='Relevant only for spin-orbit coupling and if unrestricted key has been activated.\n\nMost XC functionals have as one ingredient the spin polarization in case of unrestricted calculations. Normally the direction of the spin quantization axis is arbitrary and conveniently chosen to be the z-axis.\n\nHowever, in a spin-orbit calculation the direction matters, and it is arbitrary to put the z-component of the magnetization vector into the XC functional. There is also the exotic option to choose the quantization axis along the x or y axis.\n\nIt is also possible to plug the size of the magnetization vector into the XC functional. This is called the non-collinear approach.\n\n- NonCollinear: the non-collinear method.\n- CollinearXYZ: use the x, y, or z component as spin polarization for the XC functional.\n- Collinear: the same as CollinearZ.', default='CollinearZ', choices=['NonCollinear', 'Collinear', 'CollinearX', 'CollinearY', 'CollinearZ'])
[docs] class _RemoveFragOrbitals(FreeBlock):
r"""
Block key to remove selected virtual fragment orbitals.
"""
def __post_init__(self):
pass
[docs] class _Response(FixedBlock):
r"""
The calculation of frequency-dependent (hyper)polarizabilities and related properties (Raman, ORD)
:ivar ALLCOMPONENTS:
:vartype ALLCOMPONENTS: BoolType | BoolKey
:ivar ALLHYPER:
:vartype ALLHYPER: BoolType | BoolKey
:ivar ALPHAINANG:
:vartype ALPHAINANG: BoolType | BoolKey
:ivar ANALYTIC:
:vartype ANALYTIC: BoolType | BoolKey
:ivar AllCycles: Convergence printout
:vartype AllCycles: BoolType | BoolKey
:ivar AllTensor: Higher dispersion coefficients are also calculated
:vartype AllTensor: BoolType | BoolKey
:ivar C8:
:vartype C8: BoolType | BoolKey
:ivar CUTTAILS:
:vartype CUTTAILS: BoolType | BoolKey
:ivar DYNAHYP:
:vartype DYNAHYP: BoolType | BoolKey
:ivar Dipole:
:vartype Dipole: BoolType | BoolKey
:ivar DmpDII:
:vartype DmpDII: float | FloatKey
:ivar DmpRsp:
:vartype DmpRsp: float | FloatKey
:ivar ERABSX:
:vartype ERABSX: float | FloatKey
:ivar ERRALF:
:vartype ERRALF: float | FloatKey
:ivar ERRTMX:
:vartype ERRTMX: float | FloatKey
:ivar EpsRho: Rho threshold
:vartype EpsRho: float | FloatKey
:ivar FXCALPHA:
:vartype FXCALPHA: float | FloatKey
:ivar Frequencies: List of frequencies of incident light, the perturbing field, at which the time-dependent properties will be calculated.
:vartype Frequencies: Iterable[float] | FloatListKey
:ivar GXCALPHA:
:vartype GXCALPHA: float | FloatKey
:ivar HyperPol:
:vartype HyperPol: float | FloatKey
:ivar IFILES: Integration run including external files. Used for Van der Waals dispersion coefficients calculations.
:vartype IFILES: int | IntKey
:ivar IPRESP:
:vartype IPRESP: int | IntKey
:ivar IReal:
:vartype IReal: int | IntKey
:ivar KSORBRUN:
:vartype KSORBRUN: BoolType | BoolKey
:ivar MAGNETICPERT:
:vartype MAGNETICPERT: BoolType | BoolKey
:ivar MAXWAALS:
:vartype MAXWAALS: int | IntKey
:ivar NCycMx:
:vartype NCycMx: int | IntKey
:ivar NUMERIC:
:vartype NUMERIC: BoolType | BoolKey
:ivar OPTICALROTATION:
:vartype OPTICALROTATION: BoolType | BoolKey
:ivar Octupole:
:vartype Octupole: BoolType | BoolKey
:ivar Quadrupole:
:vartype Quadrupole: BoolType | BoolKey
:ivar Raman:
:vartype Raman: BoolType | BoolKey
:ivar STARTREALGR:
:vartype STARTREALGR: BoolType | BoolKey
:ivar SYMRUN:
:vartype SYMRUN: BoolType | BoolKey
:ivar Temperature: Wavelength of incoming light is equal to the wavelength at which the calculation is performed and temperature is equal to room temperature (300K) Total Raman band is default, not the Q-branch of diatomic. (Relevant for Raman scattering cross section)
:vartype Temperature: float | FloatKey
:ivar VANDERWAALS:
:vartype VANDERWAALS: int | IntKey
:ivar VERDET: For numerical differentiation d alfa(omega) /d omega, needed for Verdet constant, the default frequencies are omega + dverdt and omega - dverdt
:vartype VERDET: float | FloatKey
"""
def __post_init__(self):
self.ALLCOMPONENTS: BoolType | BoolKey = BoolKey(name='ALLCOMPONENTS')
self.ALLHYPER: BoolType | BoolKey = BoolKey(name='ALLHYPER')
self.ALPHAINANG: BoolType | BoolKey = BoolKey(name='ALPHAINANG')
self.ANALYTIC: BoolType | BoolKey = BoolKey(name='ANALYTIC')
self.AllCycles: BoolType | BoolKey = BoolKey(name='AllCycles', comment='Convergence printout', default=False)
self.AllTensor: BoolType | BoolKey = BoolKey(name='AllTensor', comment='Higher dispersion coefficients are also calculated', default=False)
self.C8: BoolType | BoolKey = BoolKey(name='C8')
self.CUTTAILS: BoolType | BoolKey = BoolKey(name='CUTTAILS')
self.DYNAHYP: BoolType | BoolKey = BoolKey(name='DYNAHYP')
self.Dipole: BoolType | BoolKey = BoolKey(name='Dipole')
self.DmpDII: float | FloatKey = FloatKey(name='DmpDII', default=0.8)
self.DmpRsp: float | FloatKey = FloatKey(name='DmpRsp', default=0.9)
self.ERABSX: float | FloatKey = FloatKey(name='ERABSX', default=1e-06)
self.ERRALF: float | FloatKey = FloatKey(name='ERRALF', default=1e-05)
self.ERRTMX: float | FloatKey = FloatKey(name='ERRTMX', default=1e-06)
self.EpsRho: float | FloatKey = FloatKey(name='EpsRho', comment='Rho threshold')
self.FXCALPHA: float | FloatKey = FloatKey(name='FXCALPHA')
self.Frequencies: Iterable[float] | FloatListKey = FloatListKey(name='Frequencies', comment='List of frequencies of incident light, the perturbing field, at which the time-dependent properties will be calculated.', default=[0.0], unit='eV', gui_type='range')
self.GXCALPHA: float | FloatKey = FloatKey(name='GXCALPHA')
self.HyperPol: float | FloatKey = FloatKey(name='HyperPol', default=0.0, unit='Hartree')
self.IFILES: int | IntKey = IntKey(name='IFILES', comment='Integration run including external files. Used for Van der Waals dispersion coefficients calculations.', default=0)
self.IPRESP: int | IntKey = IntKey(name='IPRESP', default=1)
self.IReal: int | IntKey = IntKey(name='IReal', default=1)
self.KSORBRUN: BoolType | BoolKey = BoolKey(name='KSORBRUN')
self.MAGNETICPERT: BoolType | BoolKey = BoolKey(name='MAGNETICPERT')
self.MAXWAALS: int | IntKey = IntKey(name='MAXWAALS', default=8)
self.NCycMx: int | IntKey = IntKey(name='NCycMx', default=30)
self.NUMERIC: BoolType | BoolKey = BoolKey(name='NUMERIC')
self.OPTICALROTATION: BoolType | BoolKey = BoolKey(name='OPTICALROTATION')
self.Octupole: BoolType | BoolKey = BoolKey(name='Octupole')
self.Quadrupole: BoolType | BoolKey = BoolKey(name='Quadrupole')
self.Raman: BoolType | BoolKey = BoolKey(name='Raman')
self.STARTREALGR: BoolType | BoolKey = BoolKey(name='STARTREALGR')
self.SYMRUN: BoolType | BoolKey = BoolKey(name='SYMRUN')
self.Temperature: float | FloatKey = FloatKey(name='Temperature', comment='Wavelength of incoming light is equal to the wavelength at which the calculation is performed and temperature is equal to room temperature (300K) Total Raman band is default, not the Q-branch of diatomic. (Relevant for Raman scattering cross section) ', default=300.0, unit='Kelvin')
self.VANDERWAALS: int | IntKey = IntKey(name='VANDERWAALS')
self.VERDET: float | FloatKey = FloatKey(name='VERDET', comment='For numerical differentiation d alfa(omega) /d omega, needed for Verdet constant, the default frequencies are omega + dverdt and omega - dverdt', default=0.01)
[docs] class _Restart(FixedBlock):
r"""
Options for restarts
:ivar NoOrb: Do not use orbitals from the restart file
:vartype NoOrb: BoolType | BoolKey
:ivar NoSCF: Do not use any fit coefficients from the restart file as a first approximation to the (fitted) SCF density for the new calculation. Instead, the sum-of-fragments density will be used, as in a non-restart run. Note, typically noSCF should be used in combination with noORB.
:vartype NoSCF: BoolType | BoolKey
:ivar NoSmear: Do not use any electron smearing data from the restart file.
:vartype NoSmear: BoolType | BoolKey
:ivar SpinFlip: Select the atoms for which the spin is to be flipped upon restart.
:vartype SpinFlip: Iterable[int] | IntListKey
"""
def __post_init__(self):
self.NoOrb: BoolType | BoolKey = BoolKey(name='NoOrb', comment='Do not use orbitals from the restart file', gui_name='Ignore orbitals:', default=False)
self.NoSCF: BoolType | BoolKey = BoolKey(name='NoSCF', comment='Do not use any fit coefficients from the restart file as a first approximation to the (fitted) SCF density for the new calculation. Instead, the sum-of-fragments density will be used, as in a non-restart run. Note, typically noSCF should be used in combination with noORB.', gui_name='Ignore SCF fit coefficients:', default=False)
self.NoSmear: BoolType | BoolKey = BoolKey(name='NoSmear', comment='Do not use any electron smearing data from the restart file.', gui_name='Ignore smearing:', default=False)
self.SpinFlip: Iterable[int] | IntListKey = IntListKey(name='SpinFlip', comment='Select the atoms for which the spin is to be flipped upon restart.', gui_name='Spin flip on restart for:', isatomlist=True)
[docs] class _SCF(FixedBlock):
r"""
Control aspects of the Self Consistent Field procedure
:ivar AccelerationMethod: SCF acceleration method.
The default method is ADIIS, which is actually a mix of A-DIIS and SDIIS: A-DIIS is used at the start of the SCF and SDIIS is used closer to convergence, with a smooth switching function.
The other methods are from the LIST family developed by Alex Wang and co-workers. They may perform better than the default in some situations.
Setting AccelerationMethod to SDIIS effectively disables A-DIIS and is equivalent to the legacy mixing+DIIS method.
:vartype AccelerationMethod: Literal["ADIIS", "fDIIS", "LISTb", "LISTf", "LISTi", "MESA", "SDIIS"]
:ivar Converge: The criterion to stop the SCF updates.
The tested error is the commutator of the Fock matrix and the P-matrix (=density matrix in the representation of the basis functions) from which the F-matrix was obtained. This commutator is zero when absolute self-consistency is reached. Convergence is considered reached when the maximum element falls below SCFcnv and the norm of the matrix below 10*SCFcnv. The default is fairly strict.
A second criterion which plays a role when the SCF procedure has difficulty converging. When in any SCF procedure the currently applicable criterion does not seem to be achievable, the program stops the SCF. When the secondary criterion (sconv2) has been met, only a warning is issued and the program continues normally.
:vartype Converge: Iterable[float] | FloatListKey
:ivar EDIIS: Use the Energy-DIIS SCF acceleration method. This key also triggers the OldSCF. The Energy-DIIS should not be used because it is not supported by the new SCF module, is not any better than methods from the LIST family and can be very slow.
:vartype EDIIS: BoolType | BoolKey
:ivar Iterations: The maximum number of SCF cycles allowed.
:vartype Iterations: int | IntKey
:ivar LShift: The level shifting parameter.
The diagonal elements of the Fock matrix, in the representation of the orbitals of the previous iteration, are raised by vshift hartree energy units for the virtual orbitals. This may help to solve convergence problems when during the SCF iterations charge is sloshing back and forth between different orbitals that are close in energy and all located around the Fermi level.
Level shifting is not supported in the case of Spin-Orbit coupling.
At the moment properties that use virtuals, like excitation energies, response properties, NMR calculations, will give incorrect results if level shifting is applied.
:vartype LShift: float | FloatKey
:ivar LShift_cyc: Specifies that level shifting is not turned on before the given SCF cycle number (for the start-up geometry).
:vartype LShift_cyc: int | IntKey
:ivar LShift_err: Specifies that level shifting will be turned off by the program as soon as the SCF error drops below a threshold.
:vartype LShift_err: float | FloatKey
:ivar MESA:
:vartype MESA: str | StringKey
:ivar Mixing: When none of the SCF acceleration methods is active, the next Fock matrix is determined F = mixing * F_n + (1-mixing)F_(n-1).
:vartype Mixing: float | FloatKey
:ivar Mixing1: The mixing parameter at the 1st SCF cycle.
:vartype Mixing1: float | FloatKey
:ivar NoADIIS: Disables A-DIIS and switches SCF to a damping+DIIS scheme.
:vartype NoADIIS: BoolType | BoolKey
:ivar OldSCF: Disable the default SCF algorithm and use the old SCF algorithm.
The default SCF improves performance for big systems on big machines (when your calculation uses many tasks).
It is also recommended for machines with slow disk I/O as it writes less data to disk.
The default convergence method supported is A-DIIS, but LISTi is also supported.
:vartype OldSCF: BoolType | BoolKey
:ivar ScalableSCF: Use new scalable scf.
:vartype ScalableSCF: BoolType | BoolKey
:ivar ScalableSO: Use new scalable scf for spin-orbit coupling.
:vartype ScalableSO: BoolType | BoolKey
:ivar ADIIS: Settings for the ADIIS method.
:vartype ADIIS: ADF._SCF._ADIIS
:ivar ARH: The Augmented Roothaan-Hall method has been developed by T. Helgaker and coworkers.
:vartype ARH: ADF._SCF._ARH
:ivar DIIS: The maximum number of SCF cycles allowed.
:vartype DIIS: ADF._SCF._DIIS
:ivar ROSCF: Settings for the ROSCF method.
:vartype ROSCF: ADF._SCF._ROSCF
"""
[docs] class _ADIIS(FixedBlock):
r"""
Settings for the ADIIS method.
:ivar Thresh1: If ErrMax > Thresh1 then only A-DIIS coefficients are used to determine the next Fock matrix.
Below this threshold a weighted mix of A-DIIS and DIIS coefficients will be used.
:vartype Thresh1: float | FloatKey
:ivar Thresh2: If ErrMax < Thresh2 then only SDIIS coefficients are used.
Below this threshold a weighted mix of A-DIIS and DIIS coefficients will be used.
:vartype Thresh2: float | FloatKey
"""
def __post_init__(self):
self.Thresh1: float | FloatKey = FloatKey(name='Thresh1', comment='If ErrMax > Thresh1 then only A-DIIS coefficients are used to determine the next Fock matrix.\n\nBelow this threshold a weighted mix of A-DIIS and DIIS coefficients will be used.', default=0.1)
self.Thresh2: float | FloatKey = FloatKey(name='Thresh2', comment='If ErrMax < Thresh2 then only SDIIS coefficients are used.\n\nBelow this threshold a weighted mix of A-DIIS and DIIS coefficients will be used.', default=0.001)
[docs] class _ARH(FixedBlock):
r"""
The Augmented Roothaan-Hall method has been developed by T. Helgaker and coworkers.
:ivar CGiter: Sets the maximum number of micro-iterations.
:vartype CGiter: int | IntKey
:ivar Conv: ARH convergence criterion. When the RMS gradient and its maximum components are both lower than the criterion, the ARH procedure will be considered converged.
:vartype Conv: float | FloatKey
:ivar ETestLim:
:vartype ETestLim: float | FloatKey
:ivar Enabled: Use ARH.
:vartype Enabled: BoolType | BoolKey
:ivar Final: If enabled, only one Fock matrix diagonalization will be performed after the ARH solution is found to get the orbitals.
No further SCF iterations will be performed.
If not enabled, the regular SCF method will continue after the ARH solution is found.
:vartype Final: BoolType | BoolKey
:ivar Iter: Maximum number of ARH iteration to perform. Please note that in difficult cases a huge number of iterations may be required for complete SCF convergence
:vartype Iter: int | IntKey
:ivar LvlShIter:
:vartype LvlShIter: int | IntKey
:ivar MaxTrustR:
:vartype MaxTrustR: float | FloatKey
:ivar MinTrustR:
:vartype MinTrustR: float | FloatKey
:ivar NOTRANSPCG:
:vartype NOTRANSPCG: BoolType | BoolKey
:ivar NSAVED: The number of saved density and Fock matrices used for augmentation of the electronic Hessian.
A larger value should be used in difficult cases when the number of orbitals very close to the Fermi level is large.
:vartype NSAVED: int | IntKey
:ivar NoPrecond:
:vartype NoPrecond: BoolType | BoolKey
:ivar PRECOND:
:vartype PRECOND: BoolType | BoolKey
:ivar SHIFTED:
:vartype SHIFTED: BoolType | BoolKey
:ivar START:
:vartype START: int | IntKey
:ivar SWITCHING: Turn OFF to avoid switching from the normal CG to a trust-radius minimization in reduced space.
Turning off this option helps to reduce the total number of SCF cycles is some cases.
Thus, if this option is turned off a NOSWITCHING key will be added (see User's Guide).
:vartype SWITCHING: BoolType | BoolKey
:ivar TRANSPCG:
:vartype TRANSPCG: BoolType | BoolKey
:ivar TRUSTR:
:vartype TRUSTR: float | FloatKey
"""
def __post_init__(self):
self.CGiter: int | IntKey = IntKey(name='CGiter', comment='Sets the maximum number of micro-iterations.', default=20)
self.Conv: float | FloatKey = FloatKey(name='Conv', comment='ARH convergence criterion. When the RMS gradient and its maximum components are both lower than the criterion, the ARH procedure will be considered converged. ', default=0.0001)
self.ETestLim: float | FloatKey = FloatKey(name='ETestLim', default=1e-10)
self.Enabled: BoolType | BoolKey = BoolKey(name='Enabled', comment='Use ARH.', default=False)
self.Final: BoolType | BoolKey = BoolKey(name='Final', comment='If enabled, only one Fock matrix diagonalization will be performed after the ARH solution is found to get the orbitals.\nNo further SCF iterations will be performed.\n\nIf not enabled, the regular SCF method will continue after the ARH solution is found.', default=False)
self.Iter: int | IntKey = IntKey(name='Iter', comment='Maximum number of ARH iteration to perform. Please note that in difficult cases a huge number of iterations may be required for complete SCF convergence', default=500)
self.LvlShIter: int | IntKey = IntKey(name='LvlShIter', default=100)
self.MaxTrustR: float | FloatKey = FloatKey(name='MaxTrustR', default=0.5)
self.MinTrustR: float | FloatKey = FloatKey(name='MinTrustR', default=0.0001)
self.NOTRANSPCG: BoolType | BoolKey = BoolKey(name='NOTRANSPCG', default=False)
self.NSAVED: int | IntKey = IntKey(name='NSAVED', comment='The number of saved density and Fock matrices used for augmentation of the electronic Hessian.\n\nA larger value should be used in difficult cases when the number of orbitals very close to the Fermi level is large.', default=8)
self.NoPrecond: BoolType | BoolKey = BoolKey(name='NoPrecond', default=False)
self.PRECOND: BoolType | BoolKey = BoolKey(name='PRECOND', default=True)
self.SHIFTED: BoolType | BoolKey = BoolKey(name='SHIFTED', default=False)
self.START: int | IntKey = IntKey(name='START', default=2)
self.SWITCHING: BoolType | BoolKey = BoolKey(name='SWITCHING', comment="Turn OFF to avoid switching from the normal CG to a trust-radius minimization in reduced space.\n\nTurning off this option helps to reduce the total number of SCF cycles is some cases.\n\nThus, if this option is turned off a NOSWITCHING key will be added (see User's Guide).", default=True)
self.TRANSPCG: BoolType | BoolKey = BoolKey(name='TRANSPCG', default=False)
self.TRUSTR: float | FloatKey = FloatKey(name='TRUSTR', default=0.5)
[docs] class _DIIS(FixedBlock):
r"""
The maximum number of SCF cycles allowed.
:ivar BFac: By default, the latest vector is not favored in the DIIS algorithm (value 0.0). A sensible value would be 0.2.
:vartype BFac: float | FloatKey
:ivar CX: The DIIS space is reduced when very large DIIS coefficients appear. The value is the threshold.
:vartype CX: float | FloatKey
:ivar CXX: When very large DIIS coefficients appear, switch to traditional damping. The value is the threshold.
:vartype CXX: float | FloatKey
:ivar Cyc: When A-DIIS is disabled, the Pulay DIIS will start at this iteration irrespective of the DIIS OK value.
:vartype Cyc: int | IntKey
:ivar N: The number of expansion vectors used for accelerating the SCF. The number of previous cycles taken into the linear combination is then n-1 (the new computed potential is also involved in the linear combination)
:vartype N: int | IntKey
:ivar Ok: The Pulay DIIS starting criterion, when A-DIIS is disabled,
:vartype Ok: float | FloatKey
"""
def __post_init__(self):
self.BFac: float | FloatKey = FloatKey(name='BFac', comment='By default, the latest vector is not favored in the DIIS algorithm (value 0.0). A sensible value would be 0.2.', gui_name='Bias DIIS towards latest vector with:', default=0.0)
self.CX: float | FloatKey = FloatKey(name='CX', comment='The DIIS space is reduced when very large DIIS coefficients appear. The value is the threshold.', gui_name='Reduce DIIS space when coefs >', default=5.0)
self.CXX: float | FloatKey = FloatKey(name='CXX', comment='When very large DIIS coefficients appear, switch to traditional damping. The value is the threshold.', gui_name='No DIIS (but damping) when coefs >', default=25.0)
self.Cyc: int | IntKey = IntKey(name='Cyc', comment='When A-DIIS is disabled, the Pulay DIIS will start at this iteration irrespective of the DIIS OK value.', gui_name='Start DIIS anyway at cycle:', default=5)
self.N: int | IntKey = IntKey(name='N', comment='The number of expansion vectors used for accelerating the SCF. The number of previous cycles taken into the linear combination is then n-1 (the new computed potential is also involved in the linear combination)', gui_name='Size of DIIS space:', default=10)
self.Ok: float | FloatKey = FloatKey(name='Ok', comment='The Pulay DIIS starting criterion, when A-DIIS is disabled,', gui_name='Start DIIS when max [F,P] <', default=0.5)
[docs] class _ROSCF(FixedBlock):
r"""
Settings for the ROSCF method.
:ivar Alpha: Coefficients to build the alpha-spin orbital contribution to the diagonal closed-, open-, and virtual-shell blocks of the Fock matrix. The beta-spin orbital contributions are 1.0 minus the alpha ones.
:vartype Alpha: Iterable[float] | FloatListKey
"""
def __post_init__(self):
self.Alpha: Iterable[float] | FloatListKey = FloatListKey(name='Alpha', comment='Coefficients to build the alpha-spin orbital contribution to the diagonal closed-, open-, and virtual-shell blocks of the Fock matrix. The beta-spin orbital contributions are 1.0 minus the alpha ones.', default=[0.5, 0.5, 0.5], gui_type='nfloat 3')
def __post_init__(self):
self.AccelerationMethod: Literal["ADIIS", "fDIIS", "LISTb", "LISTf", "LISTi", "MESA", "SDIIS"] = MultipleChoiceKey(name='AccelerationMethod', comment='SCF acceleration method.\n\nThe default method is ADIIS, which is actually a mix of A-DIIS and SDIIS: A-DIIS is used at the start of the SCF and SDIIS is used closer to convergence, with a smooth switching function.\n\nThe other methods are from the LIST family developed by Alex Wang and co-workers. They may perform better than the default in some situations.\n\nSetting AccelerationMethod to SDIIS effectively disables A-DIIS and is equivalent to the legacy mixing+DIIS method.', default='ADIIS', choices=['ADIIS', 'fDIIS', 'LISTb', 'LISTf', 'LISTi', 'MESA', 'SDIIS'])
self.Converge: Iterable[float] | FloatListKey = FloatListKey(name='Converge', comment='The criterion to stop the SCF updates.\n\nThe tested error is the commutator of the Fock matrix and the P-matrix (=density matrix in the representation of the basis functions) from which the F-matrix was obtained. This commutator is zero when absolute self-consistency is reached. Convergence is considered reached when the maximum element falls below SCFcnv and the norm of the matrix below 10*SCFcnv. The default is fairly strict.\n\nA second criterion which plays a role when the SCF procedure has difficulty converging. When in any SCF procedure the currently applicable criterion does not seem to be achievable, the program stops the SCF. When the secondary criterion (sconv2) has been met, only a warning is issued and the program continues normally.', default=[1e-06, 0.001])
self.EDIIS: BoolType | BoolKey = BoolKey(name='EDIIS', comment='Use the Energy-DIIS SCF acceleration method. This key also triggers the OldSCF. The Energy-DIIS should not be used because it is not supported by the new SCF module, is not any better than methods from the LIST family and can be very slow.', hidden=True, default=False)
self.Iterations: int | IntKey = IntKey(name='Iterations', comment='The maximum number of SCF cycles allowed.', gui_name='Maximum number of SCF cycles:', default=300)
self.LShift: float | FloatKey = FloatKey(name='LShift', comment='The level shifting parameter.\n\nThe diagonal elements of the Fock matrix, in the representation of the orbitals of the previous iteration, are raised by vshift hartree energy units for the virtual orbitals. This may help to solve convergence problems when during the SCF iterations charge is sloshing back and forth between different orbitals that are close in energy and all located around the Fermi level.\n\nLevel shifting is not supported in the case of Spin-Orbit coupling.\n\nAt the moment properties that use virtuals, like excitation energies, response properties, NMR calculations, will give incorrect results if level shifting is applied.', gui_name='Level shift:', default=0.0, unit='Hartree')
self.LShift_cyc: int | IntKey = IntKey(name='LShift_cyc', comment='Specifies that level shifting is not turned on before the given SCF cycle number (for the start-up geometry).', default=1)
self.LShift_err: float | FloatKey = FloatKey(name='LShift_err', comment='Specifies that level shifting will be turned off by the program as soon as the SCF error drops below a threshold.', default=0.0)
self.MESA: str | StringKey = StringKey(name='MESA')
self.Mixing: float | FloatKey = FloatKey(name='Mixing', comment='When none of the SCF acceleration methods is active, the next Fock matrix is determined F = mixing * F_n + (1-mixing)F_(n-1).', gui_name='Mixing (% new vector included):', default=0.2)
self.Mixing1: float | FloatKey = FloatKey(name='Mixing1', comment='The mixing parameter at the 1st SCF cycle.', gui_name='Mixing 1st SCF cycle:', default=0.2)
self.NoADIIS: BoolType | BoolKey = BoolKey(name='NoADIIS', comment='Disables A-DIIS and switches SCF to a damping+DIIS scheme.', hidden=True, default=False)
self.OldSCF: BoolType | BoolKey = BoolKey(name='OldSCF', comment='Disable the default SCF algorithm and use the old SCF algorithm.\n\nThe default SCF improves performance for big systems on big machines (when your calculation uses many tasks).\n\nIt is also recommended for machines with slow disk I/O as it writes less data to disk.\n\nThe default convergence method supported is A-DIIS, but LISTi is also supported.', default=False)
self.ScalableSCF: BoolType | BoolKey = BoolKey(name='ScalableSCF', comment='Use new scalable scf.', hidden=True, default=True)
self.ScalableSO: BoolType | BoolKey = BoolKey(name='ScalableSO', comment='Use new scalable scf for spin-orbit coupling.', hidden=True, default=True)
self.ADIIS: ADF._SCF._ADIIS = self._ADIIS(name='ADIIS', comment='Settings for the ADIIS method.', hidden=True)
self.ARH: ADF._SCF._ARH = self._ARH(name='ARH', comment='The Augmented Roothaan-Hall method has been developed by T. Helgaker and coworkers.', hidden=True)
self.DIIS: ADF._SCF._DIIS = self._DIIS(name='DIIS', comment='The maximum number of SCF cycles allowed.')
self.ROSCF: ADF._SCF._ROSCF = self._ROSCF(name='ROSCF', comment='Settings for the ROSCF method.')
[docs] class _SCRF(FreeBlock):
r"""
SCRF is no longer supported. Use AMS2023 or earlier.
"""
def __post_init__(self):
pass
[docs] class _SOPert(FixedBlock):
r"""
Key for perturbative inclusion of spin-orbit coupling.
:ivar EShift: The actually calculated eigenvalues are calculated up to the maximum singlet-singlet or singlet-triplet scalar relativistic excitation energy plus eshift (in Hartree).
:vartype EShift: float | FloatKey
:ivar GSCorr: The singlet ground state is included, which means that spin-orbit coupling can also have some effect on energy of the ground state. The spin-orbit matrix in this case is on basis of the ground state and the singlet and triplet excited states.
:vartype GSCorr: BoolType | BoolKey
:ivar NCalc: Number of spin-orbit coupled excitation energies to be calculated. Default (and maximum) value: 4 times the number of scalar relativistic singlet-singlet excitations.
:vartype NCalc: int | IntKey
:ivar error: Debug option for perturbative spin-orbit coupling.
:vartype error: BoolType | BoolKey
"""
def __post_init__(self):
self.EShift: float | FloatKey = FloatKey(name='EShift', comment='The actually calculated eigenvalues are calculated up to the maximum singlet-singlet or singlet-triplet scalar relativistic excitation energy plus eshift (in Hartree).', default=0.2)
self.GSCorr: BoolType | BoolKey = BoolKey(name='GSCorr', comment='The singlet ground state is included, which means that spin-orbit coupling can also have some effect on energy of the ground state. The spin-orbit matrix in this case is on basis of the ground state and the singlet and triplet excited states.', gui_name='Include GS:', default=True)
self.NCalc: int | IntKey = IntKey(name='NCalc', comment='Number of spin-orbit coupled excitation energies to be calculated. Default (and maximum) value: 4 times the number of scalar relativistic singlet-singlet excitations.')
self.error: BoolType | BoolKey = BoolKey(name='error', comment='Debug option for perturbative spin-orbit coupling.', hidden=True, default=False)
[docs] class _SelectExcitation(FixedBlock):
r"""
:ivar DipStrength:
:vartype DipStrength: float | FloatKey
:ivar GRIMMEAEX:
:vartype GRIMMEAEX: float | FloatKey
:ivar GRIMMEALPHA:
:vartype GRIMMEALPHA: float | FloatKey
:ivar GRIMMEBETA:
:vartype GRIMMEBETA: float | FloatKey
:ivar GRIMMEDEMAX:
:vartype GRIMMEDEMAX: float | FloatKey
:ivar GRIMMEPERTC:
:vartype GRIMMEPERTC: BoolType | BoolKey
:ivar GRIMMETPMIN:
:vartype GRIMMETPMIN: float | FloatKey
:ivar HighExcit:
:vartype HighExcit: float | FloatKey
:ivar NOGRIMMEPERTC:
:vartype NOGRIMMEPERTC: BoolType | BoolKey
:ivar NOverlap:
:vartype NOverlap: int | IntKey
:ivar OscStrength: Use only pairs of an occupied and virtual orbital as guess vectors, for which the oscillator strength of the single-orbital transition is larger than this value
:vartype OscStrength: float | FloatKey
:ivar SetLargeEnergy: The orbital energies of the uninteresting occupied orbitals are changed to -epsbig Hartree, and the orbital energies of the uninteresting virtual orbitals are changed to epsbig Hartree
:vartype SetLargeEnergy: float | FloatKey
:ivar SetOccEnergy: All occupied orbitals that have to be used will change their orbital energy to this value. In practice only useful if one has selected one occupied orbital energy, and one want to change this to another value. Default: the orbital energies of the occupied orbitals that are used are not changed.
:vartype SetOccEnergy: float | FloatKey
:ivar UseOccRange: Use only occupied orbitals which have orbital energies between the two numbers.
:vartype UseOccRange: Iterable[float] | FloatListKey
:ivar UseOccVirtNumbers: Use only pairs of an occupied and virtual orbital as guess vectors, for which in the sorted list of the orbital energy differences, the number of the single-orbital transition is between the two numbers.
:vartype UseOccVirtNumbers: Iterable[int] | IntListKey
:ivar UseOccVirtRange: Use only pairs of an occupied and virtual orbital, for which the orbital energy difference is between the two numbers
:vartype UseOccVirtRange: Iterable[float] | FloatListKey
:ivar UseScaledZORA: Use everywhere the scaled ZORA orbital energies instead of the ZORA orbital energies in the TDDFT equations. This can improve deep core excitation energies. Only valid if ZORA is used.
:vartype UseScaledZORA: BoolType | BoolKey
:ivar UseVirtRange: Use only virtual orbitals which have orbital energies between the two numbers
:vartype UseVirtRange: Iterable[float] | FloatListKey
:ivar UseOccupied: Use only the occupied orbitals which are specified
:vartype UseOccupied: str | Sequence[str] | FreeBlock
:ivar UseVirtual: Use only the virtual orbitals which are specified
:vartype UseVirtual: str | Sequence[str] | FreeBlock
"""
[docs] class _UseOccupied(FreeBlock):
r"""
Use only the occupied orbitals which are specified
"""
def __post_init__(self):
pass
[docs] class _UseVirtual(FreeBlock):
r"""
Use only the virtual orbitals which are specified
"""
def __post_init__(self):
pass
def __post_init__(self):
self.DipStrength: float | FloatKey = FloatKey(name='DipStrength')
self.GRIMMEAEX: float | FloatKey = FloatKey(name='GRIMMEAEX')
self.GRIMMEALPHA: float | FloatKey = FloatKey(name='GRIMMEALPHA')
self.GRIMMEBETA: float | FloatKey = FloatKey(name='GRIMMEBETA')
self.GRIMMEDEMAX: float | FloatKey = FloatKey(name='GRIMMEDEMAX')
self.GRIMMEPERTC: BoolType | BoolKey = BoolKey(name='GRIMMEPERTC')
self.GRIMMETPMIN: float | FloatKey = FloatKey(name='GRIMMETPMIN')
self.HighExcit: float | FloatKey = FloatKey(name='HighExcit')
self.NOGRIMMEPERTC: BoolType | BoolKey = BoolKey(name='NOGRIMMEPERTC')
self.NOverlap: int | IntKey = IntKey(name='NOverlap', default=0)
self.OscStrength: float | FloatKey = FloatKey(name='OscStrength', comment='Use only pairs of an occupied and virtual orbital as guess vectors, for which the oscillator strength of the single-orbital transition is larger than this value')
self.SetLargeEnergy: float | FloatKey = FloatKey(name='SetLargeEnergy', comment='The orbital energies of the uninteresting occupied orbitals are changed to -epsbig Hartree, and the orbital energies of the uninteresting virtual orbitals are changed to epsbig Hartree', default=1000000.0, unit='Hartree')
self.SetOccEnergy: float | FloatKey = FloatKey(name='SetOccEnergy', comment='All occupied orbitals that have to be used will change their orbital energy to this value. In practice only useful if one has selected one occupied orbital energy, and one want to change this to another value. Default: the orbital energies of the occupied orbitals that are used are not changed.')
self.UseOccRange: Iterable[float] | FloatListKey = FloatListKey(name='UseOccRange', comment='Use only occupied orbitals which have orbital energies between the two numbers.', unit='Hartree')
self.UseOccVirtNumbers: Iterable[int] | IntListKey = IntListKey(name='UseOccVirtNumbers', comment='Use only pairs of an occupied and virtual orbital as guess vectors, for which in the sorted list of the orbital energy differences, the number of the single-orbital transition is between the two numbers.')
self.UseOccVirtRange: Iterable[float] | FloatListKey = FloatListKey(name='UseOccVirtRange', comment='Use only pairs of an occupied and virtual orbital, for which the orbital energy difference is between the two numbers', unit='Hartree')
self.UseScaledZORA: BoolType | BoolKey = BoolKey(name='UseScaledZORA', comment='Use everywhere the scaled ZORA orbital energies instead of the ZORA orbital energies in the TDDFT equations. This can improve deep core excitation energies. Only valid if ZORA is used.', default=False)
self.UseVirtRange: Iterable[float] | FloatListKey = FloatListKey(name='UseVirtRange', comment='Use only virtual orbitals which have orbital energies between the two numbers', unit='Hartree')
self.UseOccupied: str | Sequence[str] | FreeBlock = self._UseOccupied(name='UseOccupied', comment='Use only the occupied orbitals which are specified')
self.UseVirtual: str | Sequence[str] | FreeBlock = self._UseVirtual(name='UseVirtual', comment='Use only the virtual orbitals which are specified')
[docs] class _SlaterDeterminants(FreeBlock):
r"""
The calculation of the one-determinant states based on the AOC reference state is controlled with this key.
"""
def __post_init__(self):
pass
[docs] class _Solvation(FixedBlock):
r"""
:ivar ARO:
:vartype ARO: float | FloatKey
:ivar Acid:
:vartype Acid: float | FloatKey
:ivar Ass:
:vartype Ass: BoolType | BoolKey
:ivar Base:
:vartype Base: float | FloatKey
:ivar BornC: Coulomb constant for Born
:vartype BornC: float | FloatKey
:ivar C-Mat:
:vartype C-Mat: str | StringKey
:ivar COSKFAtoms: This subkey COSKFATOMS specifies for which nuclei the segments in the COSMO section of the COSKF file should be used. Default all nuclei should be used, i.e. as for omitting the subkey COSKFATOMS. The numbers refer to the input ordering in the ADF calculation.
:vartype COSKFAtoms: Iterable[int] | IntListKey
:ivar Charged:
:vartype Charged: str | StringKey
:ivar Chgal:
:vartype Chgal: float | FloatKey
:ivar CsmRsp:
:vartype CsmRsp: BoolType | BoolKey
:ivar Cust:
:vartype Cust: str | StringKey
:ivar Debug:
:vartype Debug: str | StringKey
:ivar Disc:
:vartype Disc: str | StringKey
:ivar Div:
:vartype Div: str | StringKey
:ivar EPS:
:vartype EPS: float | FloatKey
:ivar ForceCosmo:
:vartype ForceCosmo: str | StringKey
:ivar HALO:
:vartype HALO: float | FloatKey
:ivar Lpr:
:vartype Lpr: BoolType | BoolKey
:ivar NoAss:
:vartype NoAss: BoolType | BoolKey
:ivar NoCsmRsp:
:vartype NoCsmRsp: BoolType | BoolKey
:ivar NoLpr:
:vartype NoLpr: BoolType | BoolKey
:ivar NoPVec:
:vartype NoPVec: BoolType | BoolKey
:ivar PVec:
:vartype PVec: BoolType | BoolKey
:ivar PrintSM12:
:vartype PrintSM12: BoolType | BoolKey
:ivar RadSolv:
:vartype RadSolv: float | FloatKey
:ivar Ref:
:vartype Ref: float | FloatKey
:ivar SCF:
:vartype SCF: str | StringKey
:ivar SM12SolvationPotential: Partial Charges to use in SCRF for SM12
:vartype SM12SolvationPotential: Literal["cm5", "chelpg"]
:ivar Solv: Solvent details
:vartype Solv: str | StringKey
:ivar Surf: Defines the type of cavity to be used.
:vartype Surf: Literal["wsurf", "asurf", "esurf", "klamt", "delley", "wsurf nokeep", "asurf nokeep", "esurf nokeep", "klamt nokeep", "delley nokeep"]
:ivar Tens:
:vartype Tens: float | FloatKey
:ivar RADII:
:vartype RADII: str | Sequence[str] | FreeBlock
"""
[docs] class _RADII(FreeBlock):
r"""
"""
def __post_init__(self):
pass
def __post_init__(self):
self.ARO: float | FloatKey = FloatKey(name='ARO')
self.Acid: float | FloatKey = FloatKey(name='Acid')
self.Ass: BoolType | BoolKey = BoolKey(name='Ass')
self.Base: float | FloatKey = FloatKey(name='Base')
self.BornC: float | FloatKey = FloatKey(name='BornC', comment='Coulomb constant for Born')
self.C_Mat: str | StringKey = StringKey(name='C-Mat')
self.COSKFAtoms: Iterable[int] | IntListKey = IntListKey(name='COSKFAtoms', comment='This subkey COSKFATOMS specifies for which nuclei the segments in the COSMO section of the COSKF file should be used. Default all nuclei should be used, i.e. as for omitting the subkey COSKFATOMS. The numbers refer to the input ordering in the ADF calculation.', unique=False)
self.Charged: str | StringKey = StringKey(name='Charged')
self.Chgal: float | FloatKey = FloatKey(name='Chgal')
self.CsmRsp: BoolType | BoolKey = BoolKey(name='CsmRsp')
self.Cust: str | StringKey = StringKey(name='Cust')
self.Debug: str | StringKey = StringKey(name='Debug')
self.Disc: str | StringKey = StringKey(name='Disc')
self.Div: str | StringKey = StringKey(name='Div')
self.EPS: float | FloatKey = FloatKey(name='EPS')
self.ForceCosmo: str | StringKey = StringKey(name='ForceCosmo')
self.HALO: float | FloatKey = FloatKey(name='HALO')
self.Lpr: BoolType | BoolKey = BoolKey(name='Lpr')
self.NoAss: BoolType | BoolKey = BoolKey(name='NoAss')
self.NoCsmRsp: BoolType | BoolKey = BoolKey(name='NoCsmRsp')
self.NoLpr: BoolType | BoolKey = BoolKey(name='NoLpr')
self.NoPVec: BoolType | BoolKey = BoolKey(name='NoPVec')
self.PVec: BoolType | BoolKey = BoolKey(name='PVec')
self.PrintSM12: BoolType | BoolKey = BoolKey(name='PrintSM12')
self.RadSolv: float | FloatKey = FloatKey(name='RadSolv')
self.Ref: float | FloatKey = FloatKey(name='Ref')
self.SCF: str | StringKey = StringKey(name='SCF')
self.SM12SolvationPotential: Literal["cm5", "chelpg"] = MultipleChoiceKey(name='SM12SolvationPotential', comment='Partial Charges to use in SCRF for SM12', default='chelpg', choices=['cm5', 'chelpg'])
self.Solv: str | StringKey = StringKey(name='Solv', comment='Solvent details')
self.Surf: Literal["wsurf", "asurf", "esurf", "klamt", "delley", "wsurf nokeep", "asurf nokeep", "esurf nokeep", "klamt nokeep", "delley nokeep"] = MultipleChoiceKey(name='Surf', comment='Defines the type of cavity to be used.', default='delley', choices=['wsurf', 'asurf', 'esurf', 'klamt', 'delley', 'wsurf nokeep', 'asurf nokeep', 'esurf nokeep', 'klamt nokeep', 'delley nokeep'])
self.Tens: float | FloatKey = FloatKey(name='Tens')
self.RADII: str | Sequence[str] | FreeBlock = self._RADII(name='RADII')
[docs] class _SpinOrbitMagnetization(FixedBlock):
r"""
Starting artificial spin-orbit magnetization at first SCF cycle
:ivar Strength: Strength of artificial spin-polarization at first SCF cycle
:vartype Strength: float | FloatKey
:ivar PerRegion: Defines the starting spin-polarization direction for all atoms in a region. Note that if this keyword is used multiple times, the chosen regions may not overlap.
:vartype PerRegion: ADF._SpinOrbitMagnetization._PerRegion
"""
[docs] class _PerRegion(FixedBlock):
r"""
Defines the starting spin-polarization direction for all atoms in a region. Note that if this keyword is used multiple times, the chosen regions may not overlap.
:ivar Direction: The starting spin-polarization direction for a region.
:vartype Direction: Iterable[float] | FloatListKey
:ivar Region: The identifier of the region for which to define the starting spin-polarization direction.
:vartype Region: str | StringKey
:ivar Strength: Strength of artificial spin-polarization in this region
:vartype Strength: float | FloatKey
"""
def __post_init__(self):
self.Direction: Iterable[float] | FloatListKey = FloatListKey(name='Direction', comment='The starting spin-polarization direction for a region.', default=[0.0, 0.0, 1.0], gui_type='nfloat 3')
self.Region: str | StringKey = StringKey(name='Region', comment='The identifier of the region for which to define the starting spin-polarization direction.', gui_type='region')
self.Strength: float | FloatKey = FloatKey(name='Strength', comment='Strength of artificial spin-polarization in this region', default=0.2, unit='Hartree')
def __post_init__(self):
self.Strength: float | FloatKey = FloatKey(name='Strength', comment='Strength of artificial spin-polarization at first SCF cycle', default=0.2, unit='Hartree')
self.PerRegion: ADF._SpinOrbitMagnetization._PerRegion = self._PerRegion(name='PerRegion', comment='Defines the starting spin-polarization direction for all atoms in a region. Note that if this keyword is used multiple times, the chosen regions may not overlap.', unique=False)
[docs] class _SubExci(FixedBlock):
r"""
Subsystem TDDFT (FDE)
:ivar CICoupl: Within the Tamm-Dancoff Approximation, the couplings between localized excited states on different subsystems correspond directly to so-called exciton couplings. The CICOUPL keyword, in conjunction with TDA, prints these exciton couplings. It is also possible to use CICOUPL with full FDEc-TDDFT. In that case, the excitonic couplings between monomers are reconstructed from an effective 2x2 CIS-like eigenvalue problem.
:vartype CICoupl: BoolType | BoolKey
:ivar COULKERNEL:
:vartype COULKERNEL: BoolType | BoolKey
:ivar COUPLBLOCK:
:vartype COUPLBLOCK: BoolType | BoolKey
:ivar COUPLSYS:
:vartype COUPLSYS: Iterable[int] | IntListKey
:ivar CPLTAPE:
:vartype CPLTAPE: str | StringKey
:ivar CThres: all excitations of all subsystems (present on the fragment TAPE21 files) with an excitation energy that differs by less than coupling_threshold. From one of the reference states are selected to be included in the coupling. Note that additional excited states of system 1 may be included here.
:vartype CThres: float | FloatKey
:ivar DIPVEL:
:vartype DIPVEL: BoolType | BoolKey
:ivar DiagType:
:vartype DiagType: Literal["EXACT"]
:ivar EIGPRINT:
:vartype EIGPRINT: int | IntKey
:ivar ETHRES: Threshold for effective coupling
:vartype ETHRES: float | FloatKey
:ivar EXTERNALORTHO: EO factor
:vartype EXTERNALORTHO: float | FloatKey
:ivar FULLGRID:
:vartype FULLGRID: BoolType | BoolKey
:ivar InvGuess: Type of states to be coupled
:vartype InvGuess: Literal["EigVal-OrbDiff", "OrbDiff-OrbDiff", "Exact"]
:ivar LOCALFXCK:
:vartype LOCALFXCK: BoolType | BoolKey
:ivar Lowest: The selection of the excited states to be coupled consists of two steps
:vartype Lowest: int | IntKey
:ivar NITER:
:vartype NITER: int | IntKey
:ivar NOINTERSOLV:
:vartype NOINTERSOLV: BoolType | BoolKey
:ivar NOSOLVCCHECK:
:vartype NOSOLVCCHECK: BoolType | BoolKey
:ivar ONEGRID:
:vartype ONEGRID: BoolType | BoolKey
:ivar OptStates: If the keyword OPTSTATES is given, only those excited states of the first subsystem are considered as reference states that are given in this list.
:vartype OptStates: Iterable[int] | IntListKey
:ivar PFRAGOUT:
:vartype PFRAGOUT: BoolType | BoolKey
:ivar PTHRES:
:vartype PTHRES: float | FloatKey
:ivar SETDIAG:
:vartype SETDIAG: float | FloatKey
:ivar SFThres: To reduce the computational effort, it is possible to ignore the effect of orbital pairs with coefficients less than solutionfactor_threshold in the solution factors (TDDFT eigenvectors) of the underlying uncoupled calculation in the construction of the exact trial densities during the calculation of the coupling matrix elements. These orbital pair contributions are not ignored in the subsequent calculation of transition moments, oscillator, and rotational strengths.
:vartype SFThres: float | FloatKey
:ivar SMARTGRID:
:vartype SMARTGRID: BoolType | BoolKey
:ivar Stat2CPL: Type of states to be coupled
:vartype Stat2CPL: Literal["OnlyKnown"]
:ivar TCOMEGA: Transpose construction of Omega matrix
:vartype TCOMEGA: BoolType | BoolKey
:ivar TDA: TDA specifies the use of the Tamm-Dancoff-Approximation (Tamm-Dancoff approximation) in the underlying uncoupled FDE-TDDFT calculations. Contrary to the full SUBEXCI-TDDFT variant, SUBEXCI-TDA allows for the usage of hybrid functionals in the underlying uncoupled FDE-TDDFT calculations.
:vartype TDA: BoolType | BoolKey
:ivar TKINKERNEL:
:vartype TKINKERNEL: BoolType | BoolKey
:ivar XCKERNEL:
:vartype XCKERNEL: BoolType | BoolKey
"""
def __post_init__(self):
self.CICoupl: BoolType | BoolKey = BoolKey(name='CICoupl', comment='Within the Tamm-Dancoff Approximation, the couplings between localized excited states on different subsystems correspond directly to so-called exciton couplings. The CICOUPL keyword, in conjunction with TDA, prints these exciton couplings. It is also possible to use CICOUPL with full FDEc-TDDFT. In that case, the excitonic couplings between monomers are reconstructed from an effective 2x2 CIS-like eigenvalue problem.', default=False)
self.COULKERNEL: BoolType | BoolKey = BoolKey(name='COULKERNEL', default=True)
self.COUPLBLOCK: BoolType | BoolKey = BoolKey(name='COUPLBLOCK', default=False)
self.COUPLSYS: Iterable[int] | IntListKey = IntListKey(name='COUPLSYS')
self.CPLTAPE: str | StringKey = StringKey(name='CPLTAPE')
self.CThres: float | FloatKey = FloatKey(name='CThres', comment='all excitations of all subsystems (present on the fragment TAPE21 files) with an excitation energy that differs by less than coupling_threshold. From one of the reference states are selected to be included in the coupling. Note that additional excited states of system 1 may be included here.', default=30.0, unit='eV')
self.DIPVEL: BoolType | BoolKey = BoolKey(name='DIPVEL', default=False)
self.DiagType: Literal["EXACT"] = MultipleChoiceKey(name='DiagType', default='EXACT', choices=['EXACT'])
self.EIGPRINT: int | IntKey = IntKey(name='EIGPRINT', default=100)
self.ETHRES: float | FloatKey = FloatKey(name='ETHRES', comment='Threshold for effective coupling', default=0.0, unit='eV')
self.EXTERNALORTHO: float | FloatKey = FloatKey(name='EXTERNALORTHO', comment='EO factor ', default=1000000.0)
self.FULLGRID: BoolType | BoolKey = BoolKey(name='FULLGRID', default=False)
self.InvGuess: Literal["EigVal-OrbDiff", "OrbDiff-OrbDiff", "Exact"] = MultipleChoiceKey(name='InvGuess', comment='Type of states to be coupled', default='EigVal-OrbDiff', choices=['EigVal-OrbDiff', 'OrbDiff-OrbDiff', 'Exact'])
self.LOCALFXCK: BoolType | BoolKey = BoolKey(name='LOCALFXCK', default=False)
self.Lowest: int | IntKey = IntKey(name='Lowest', comment='The selection of the excited states to be coupled consists of two steps', default=10)
self.NITER: int | IntKey = IntKey(name='NITER', default=1)
self.NOINTERSOLV: BoolType | BoolKey = BoolKey(name='NOINTERSOLV', default=False)
self.NOSOLVCCHECK: BoolType | BoolKey = BoolKey(name='NOSOLVCCHECK', default=False)
self.ONEGRID: BoolType | BoolKey = BoolKey(name='ONEGRID', default=False)
self.OptStates: Iterable[int] | IntListKey = IntListKey(name='OptStates', comment='If the keyword OPTSTATES is given, only those excited states of the first subsystem are considered as reference states that are given in this list.')
self.PFRAGOUT: BoolType | BoolKey = BoolKey(name='PFRAGOUT', default=False)
self.PTHRES: float | FloatKey = FloatKey(name='PTHRES', default=1.0)
self.SETDIAG: float | FloatKey = FloatKey(name='SETDIAG')
self.SFThres: float | FloatKey = FloatKey(name='SFThres', comment='To reduce the computational effort, it is possible to ignore the effect of orbital pairs with coefficients less than solutionfactor_threshold in the solution factors (TDDFT eigenvectors) of the underlying uncoupled calculation in the construction of the exact trial densities during the calculation of the coupling matrix elements. These orbital pair contributions are not ignored in the subsequent calculation of transition moments, oscillator, and rotational strengths. ', default=1e-05)
self.SMARTGRID: BoolType | BoolKey = BoolKey(name='SMARTGRID', default=False)
self.Stat2CPL: Literal["OnlyKnown"] = MultipleChoiceKey(name='Stat2CPL', comment='Type of states to be coupled', default='OnlyKnown', choices=['OnlyKnown'])
self.TCOMEGA: BoolType | BoolKey = BoolKey(name='TCOMEGA', comment='Transpose construction of Omega matrix', default=False)
self.TDA: BoolType | BoolKey = BoolKey(name='TDA', comment='TDA specifies the use of the Tamm-Dancoff-Approximation (Tamm-Dancoff approximation) in the underlying uncoupled FDE-TDDFT calculations. Contrary to the full SUBEXCI-TDDFT variant, SUBEXCI-TDA allows for the usage of hybrid functionals in the underlying uncoupled FDE-TDDFT calculations.', default=False)
self.TKINKERNEL: BoolType | BoolKey = BoolKey(name='TKINKERNEL', default=True)
self.XCKERNEL: BoolType | BoolKey = BoolKey(name='XCKERNEL', default=True)
[docs] class _SubResponse(FreeBlock):
r"""
Untested and undocumented
"""
def __post_init__(self):
pass
[docs] class _Tails(FixedBlock):
r"""
Obsolete option for linear scaling and distance effects. We recommend using the LinearScaling key instead.
:ivar Bas: Parameter related to the threshold for the calculation of basis functions on a block of integration points. A higher value implies higher precision. The default depends on the Integration numerical quality.
:vartype Bas: float | FloatKey
:ivar Fit: Parameter related to the threshold for the calculation of fit functions on a block of integration points. A higher value implies higher precision. The default depends on the Integration numerical quality.
:vartype Fit: float | FloatKey
"""
def __post_init__(self):
self.Bas: float | FloatKey = FloatKey(name='Bas', comment='Parameter related to the threshold for the calculation of basis functions on a block of integration points. A higher value implies higher precision. The default depends on the Integration numerical quality.')
self.Fit: float | FloatKey = FloatKey(name='Fit', comment='Parameter related to the threshold for the calculation of fit functions on a block of integration points. A higher value implies higher precision. The default depends on the Integration numerical quality.')
[docs] class _VSCRF(FreeBlock):
r"""
VSCRF is no longer supported. Use AMS2023 or earlier.
"""
def __post_init__(self):
pass
[docs] class _XC(FixedBlock):
r"""
Definition of the XC.
:ivar Dispersion: Dispersion corrections.
:vartype Dispersion: str | StringKey
: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 GCPparameters: Applying parameters for the geometrical counter poise correction.
:vartype GCPparameters: str | StringKey
:ivar GGA: Specifies the GGA part of the XC Functional
:vartype GGA: str | StringKey
:ivar HartreeFock: Use the Hartree-Fock exchange should be used during the SCF.
:vartype HartreeFock: BoolType | BoolKey
:ivar Hybrid: Specifies the hybrid functional that should be used during the SCF.
:vartype Hybrid: str | StringKey
:ivar LDA: Defines the LDA part of the XC functional
:vartype LDA: str | StringKey
:ivar LibXC: Use the LibXC library with the specified functional.
:vartype LibXC: str | StringKey
:ivar MP2: Calculate the MP2 correlation energy after the HF SCF is completed.
:vartype MP2: BoolType | BoolKey
:ivar MetaGGA: Specifies that a meta-GGA should be used during the SCF
:vartype MetaGGA: str | StringKey
:ivar MetaHybrid: Specifies the meta-hybrid functional that should be used during the SCF.
:vartype MetaHybrid: str | StringKey
:ivar Model: Model potential to be used
:vartype Model: str | StringKey
:ivar NoLibXC: Prevent the usage of the LibXC library
:vartype NoLibXC: BoolType | BoolKey
:ivar OEP: Defines the optimized effective potential expanded into a set of the fit functions
:vartype OEP: str | StringKey
:ivar RPA: Specifies that RPA is used an possibly also a post-RPA method. By default, RPA is not used.
:vartype RPA: Literal["None", "Direct", "Sigma", "SOSEX", "SOSSX"]
:ivar RangeSep: Range separated hybrids parameters
:vartype RangeSep: str | StringKey
:ivar XCFun: Use the XCFun library
:vartype XCFun: BoolType | BoolKey
:ivar gCP: Use the geometrical counter poise correction.
:vartype gCP: str | StringKey
"""
def __post_init__(self):
self.Dispersion: str | StringKey = StringKey(name='Dispersion', comment='Dispersion corrections.')
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.GCPparameters: str | StringKey = StringKey(name='GCPparameters', comment='Applying parameters for the geometrical counter poise correction.')
self.GGA: str | StringKey = StringKey(name='GGA', comment='Specifies the GGA part of the XC Functional')
self.HartreeFock: BoolType | BoolKey = BoolKey(name='HartreeFock', comment='Use the Hartree-Fock exchange should be used during the SCF.', default=False)
self.Hybrid: str | StringKey = StringKey(name='Hybrid', comment='Specifies the hybrid functional that should be used during the SCF.')
self.LDA: str | StringKey = StringKey(name='LDA', comment='Defines the LDA part of the XC functional')
self.LibXC: str | StringKey = StringKey(name='LibXC', comment='Use the LibXC library with the specified functional.')
self.MP2: BoolType | BoolKey = BoolKey(name='MP2', comment='Calculate the MP2 correlation energy after the HF SCF is completed.', default=False)
self.MetaGGA: str | StringKey = StringKey(name='MetaGGA', comment='Specifies that a meta-GGA should be used during the SCF')
self.MetaHybrid: str | StringKey = StringKey(name='MetaHybrid', comment='Specifies the meta-hybrid functional that should be used during the SCF.')
self.Model: str | StringKey = StringKey(name='Model', comment='Model potential to be used')
self.NoLibXC: BoolType | BoolKey = BoolKey(name='NoLibXC', comment='Prevent the usage of the LibXC library', default=False)
self.OEP: str | StringKey = StringKey(name='OEP', comment='Defines the optimized effective potential expanded into a set of the fit functions')
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, RPA is not used.', default='None', choices=['None', 'Direct', 'Sigma', 'SOSEX', 'SOSSX'])
self.RangeSep: str | StringKey = StringKey(name='RangeSep', comment='Range separated hybrids parameters')
self.XCFun: BoolType | BoolKey = BoolKey(name='XCFun', comment='Use the XCFun library', default=False)
self.gCP: str | StringKey = StringKey(name='gCP', comment='Use the geometrical counter poise correction.')
[docs] class _XES(FixedBlock):
r"""
X-ray emission spectroscopy
:ivar AllXESMoments: Print out all the individual transition moments used within the calculation of the total oscillator strength
:vartype AllXESMoments: BoolType | BoolKey
:ivar AllXESQuadrupole: Print out the individual oscillator strength components to the total oscillator strength
:vartype AllXESQuadrupole: BoolType | BoolKey
:ivar CoreHole: selection of the acceptor orbital for the calculation of the emission oscillator strengths. For example 'CoreHole A1 2' calculates oscillator strengths to the orbital 2 in irrep A1.
In AMSinput you may also use the notation 2A1 (so first the orbital number, next the symmetry)
:vartype CoreHole: str | StringKey
:ivar Enabled: Calculate the X-ray emission energies to a core orbital.
By default it calculates the emission to the first orbital in the first symmetry.
:vartype Enabled: BoolType | BoolKey
"""
def __post_init__(self):
self.AllXESMoments: BoolType | BoolKey = BoolKey(name='AllXESMoments', comment='Print out all the individual transition moments used within the calculation of the total oscillator strength', gui_name='Print: All XES Moments', default=False)
self.AllXESQuadrupole: BoolType | BoolKey = BoolKey(name='AllXESQuadrupole', comment='Print out the individual oscillator strength components to the total oscillator strength', gui_name=': All XES Quadrupole', default=False)
self.CoreHole: str | StringKey = StringKey(name='CoreHole', comment="selection of the acceptor orbital for the calculation of the emission oscillator strengths. For example 'CoreHole A1 2' calculates oscillator strengths to the orbital 2 in irrep A1.\n\nIn AMSinput you may also use the notation 2A1 (so first the orbital number, next the symmetry)", gui_name='Acceptor orbital:')
self.Enabled: BoolType | BoolKey = BoolKey(name='Enabled', comment='Calculate the X-ray emission energies to a core orbital.\n\nBy default it calculates the emission to the first orbital in the first symmetry.', gui_name='Calculate XES:', default=False)
[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.
:vartype DensityThreshold: float | FloatKey
:ivar GridAngOrder:
:vartype GridAngOrder: int | IntKey
:ivar GridRadialFactor:
:vartype GridRadialFactor: float | FloatKey
:ivar PartitionFunThreshold:
:vartype PartitionFunThreshold: float | FloatKey
:ivar PotentialThreshold:
:vartype PotentialThreshold: float | FloatKey
:ivar Pruning:
: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 lExpansion:
:vartype lExpansion: int | IntKey
:ivar lMargin:
:vartype lMargin: int | IntKey
:ivar QualityPerRegion: Sets the ZlmFit quality for all atoms in a region. If specified, this overwrites the globally set quality.
:vartype QualityPerRegion: ADF._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.', default=1e-07)
self.GridAngOrder: int | IntKey = IntKey(name='GridAngOrder', default=21)
self.GridRadialFactor: float | FloatKey = FloatKey(name='GridRadialFactor', default=1.0)
self.PartitionFunThreshold: float | FloatKey = FloatKey(name='PartitionFunThreshold', default=0.0)
self.PotentialThreshold: float | FloatKey = FloatKey(name='PotentialThreshold', default=1e-07)
self.Pruning: BoolType | BoolKey = BoolKey(name='Pruning', default=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.", default='Auto', choices=['Auto', 'Basic', 'Normal', 'Good', 'VeryGood', 'Excellent'])
self.lExpansion: int | IntKey = IntKey(name='lExpansion', default=4)
self.lMargin: int | IntKey = IntKey(name='lMargin', default=4)
self.QualityPerRegion: ADF._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.A1Fit: float | FloatKey = FloatKey(name='A1Fit', comment='STO-Fit keyword: distance between atoms, in Angstrom. The symmetric fit approximation is applied only for atoms farther apart.', gui_name='Symmetric fit for distance >:', default=10.0, unit='Angstrom')
self.AOMat2File: BoolType | BoolKey = BoolKey(name='AOMat2File', comment='Write PMatrix, Fock matrix, and overlap matrix on AO basis to file for future analysis purposes', default=False, extra_info='not_in_fragment')
self.AORCOnly: BoolType | BoolKey = BoolKey(name='AORCOnly', comment='Debug option AOResponse.', hidden=True, default=False, extra_info='not_in_fragment')
self.AORXCOnly: BoolType | BoolKey = BoolKey(name='AORXCOnly', comment='Debug option AOResponse.', hidden=True, default=False, extra_info='not_in_fragment')
self.AORun: BoolType | BoolKey = BoolKey(name='AORun', comment='Expert option not to write orbitals to file for TDDFT.', hidden=True, default=False, extra_info='not_in_fragment')
self.AccurateGradients: BoolType | BoolKey = BoolKey(name='AccurateGradients', comment='Print the nuclear gradients with more digits than usual.', default=False, extra_info='not_in_fragment')
self.AddDiffuseFit: BoolType | BoolKey = BoolKey(name='AddDiffuseFit', comment='STO-Fit keyword: One can get more diffuse fit functions by setting this to True.', gui_name='Add diffuse functions in fit: Yes', default=False)
self.AllDipMat: BoolType | BoolKey = BoolKey(name='AllDipMat', comment='Print all dipole matrix elements between occupied and virtual Kohn-Sham orbitals.', default=False, extra_info='not_in_fragment')
self.AllPoints: BoolType | BoolKey = BoolKey(name='AllPoints', comment='ADF makes use of symmetry in the numerical integrations. Points are generated for the irreducible wedge, a symmetry unique sub region of space. Optionally the symmetry equivalent points are also used. This is achieved by setting this key to True.', gui_name='Force use of all points:', default=False, extra_info='not_in_fragment')
self.AllWaals: BoolType | BoolKey = BoolKey(name='AllWaals', comment='Expert to write all van der Waals tensors in Response..', hidden=True, default=False, extra_info='not_in_fragment')
self.Allow: str | StringKey = StringKey(name='Allow', comment='Controlled aborts can in some cases be overruled. Of course, the checks have been inserted for good reasons and one should realize that ignoring them probably produces incorrect results or may lead to a program-crash.', unique=False, extra_info='not_in_fragment')
self.AltLinVXC: BoolType | BoolKey = BoolKey(name='AltLinVXC', hidden=True, default=False, extra_info='not_in_fragment')
self.AltOrthon: BoolType | BoolKey = BoolKey(name='AltOrthon', comment='Expert option for alternative orthogonalization.', hidden=True, default=False, extra_info='not_in_fragment')
self.AltRhof: BoolType | BoolKey = BoolKey(name='AltRhof', comment='Expert option for Response.', hidden=True, default=False, extra_info='not_in_fragment')
self.AtomicChargesTypeForAMS: Literal["Mulliken", "Hirshfeld", "CM5", "Voronoi", "MDC-M", "MDC-D", "MDC-Q", "QTAIM"] = MultipleChoiceKey(name='AtomicChargesTypeForAMS', comment='Type of atomic charges to be used by AMS.\n\nNote that some of these atomic charges are computed and printed by default in ADF.\n\nHirshfeld charges are available only for default atomic fragments.', gui_name='Atomic charges for AMS:', default='Mulliken', choices=['Mulliken', 'Hirshfeld', 'CM5', 'Voronoi', 'MDC-M', 'MDC-D', 'MDC-Q', 'QTAIM'], extra_info='not_in_fragment')
self.Balance: BoolType | BoolKey = BoolKey(name='Balance', comment='Measure the actual speed of the nodes in the parallel machine', default=False, extra_info='not_in_fragment')
self.BasValZero: BoolType | BoolKey = BoolKey(name='BasValZero', comment='Debug option', hidden=True, default=False, extra_info='not_in_fragment')
self.Blapt: BoolType | BoolKey = BoolKey(name='Blapt', comment='Debug option for calculating post-SCF functional.', hidden=True, default=False, extra_info='not_in_fragment')
self.BoysOld: BoolType | BoolKey = BoolKey(name='BoysOld', comment='Option for localizing orbitals using old scheme.', hidden=True, default=False, extra_info='not_in_fragment')
self.C2Coef: BoolType | BoolKey = BoolKey(name='C2Coef', comment='Print C2Coef to output', hidden=True, default=False, extra_info='not_in_fragment')
self.CM5: BoolType | BoolKey = BoolKey(name='CM5', comment='Calculate the charge model 5 (CM5) analysis.', gui_name=': CM5 charges', default=False, extra_info='not_in_fragment')
self.CalcOverlapOnly: BoolType | BoolKey = BoolKey(name='CalcOverlapOnly', comment='Calculate overlaps of primitive basis and stops after computing them.', default=False, extra_info='not_in_fragment')
self.CalcTotalEnergy: BoolType | BoolKey = BoolKey(name='CalcTotalEnergy', comment='Whether or not to calculate the total energy.', hidden=True, default=False, extra_info='not_in_fragment')
self.ChkDisFal: BoolType | BoolKey = BoolKey(name='ChkDisFal', comment='Debug option not to ise distance effects, probably not working correct anymore.', hidden=True, default=False, extra_info='not_in_fragment')
self.ColTDDFT: BoolType | BoolKey = BoolKey(name='ColTDDFT', comment='Debug option to see the effect of a collinear kernel TDDFT in case of spin-orbit coupling', hidden=True, default=False, extra_info='not_in_fragment')
self.CommTiming: BoolType | BoolKey = BoolKey(name='CommTiming', comment='Only perform parallel timing test on the gather, broadcast and combine routines.', hidden=True, default=False, extra_info='not_in_fragment')
self.ComplexAcl: BoolType | BoolKey = BoolKey(name='ComplexAcl', comment='Expert key for AOresponse spin-orbit coupled.', hidden=True, default=False, extra_info='not_in_fragment')
self.CoreTables: BoolType | BoolKey = BoolKey(name='CoreTables', comment='Undocumented and unused option for using CoreTables.', hidden=True, default=False)
self.CoulombFit: BoolType | BoolKey = BoolKey(name='CoulombFit', comment='Undocumented and unused option for using old HF exchange integrals also for Coulomb.', hidden=True, default=False, extra_info='not_in_fragment')
self.Create: str | StringKey = StringKey(name='Create', comment='Keywords for create run. {Atomtype Datafile}')
self.DRho241: BoolType | BoolKey = BoolKey(name='DRho241', comment='Debug key for Response.', hidden=True, default=False, extra_info='not_in_fragment')
self.Debug: str | StringKey = StringKey(name='Debug', comment='The amount of printed output is regulated with the keys Print, NoPrint, EPrint and Debug.', unique=False, extra_info='not_in_fragment')
self.DeltaEpStrip: BoolType | BoolKey = BoolKey(name='DeltaEpStrip', comment='TDDFT Excitations expert key.', hidden=True, default=False, extra_info='not_in_fragment')
self.DensPrep: BoolType | BoolKey = BoolKey(name='DensPrep', comment='Undocumented option for FDE for sum-of-fragments density in SCF.', hidden=True, default=False, extra_info='not_in_fragment')
self.Diffuse: BoolType | BoolKey = BoolKey(name='Diffuse', comment='Adding diffuse integration points in case of the old Voronoi numerical integration grid.', default=False)
self.DipoleLength: BoolType | BoolKey = BoolKey(name='DipoleLength', comment='Use dipole-length elements for perturbing (external) integrals in CURRENT response', default=False, extra_info='not_in_fragment')
self.DipoleResponse: BoolType | BoolKey = BoolKey(name='DipoleResponse', default=False, extra_info='not_in_fragment')
self.DumpBasisOnly: BoolType | BoolKey = BoolKey(name='DumpBasisOnly', comment='Dump basis and fit set files use for each atom.', default=False)
self.EGOXAlpha: BoolType | BoolKey = BoolKey(name='EGOXAlpha', comment='Debug key for excited GO in excitations.', hidden=True, default=False, extra_info='not_in_fragment')
self.EnergyTest: BoolType | BoolKey = BoolKey(name='EnergyTest', comment='Expert key for total energy.', hidden=True, default=False, extra_info='not_in_fragment')
self.ExactDensity: BoolType | BoolKey = BoolKey(name='ExactDensity', comment='Use the exact density (as opposed to the fitted density) for the computation of the exchange-correlation potential', default=False)
self.ExtendedPopan: BoolType | BoolKey = BoolKey(name='ExtendedPopan', comment='Calculate the Mayer bond orders and Mulliken atom-atom populations per l-value ', gui_name=': Extended population analysis', default=False, extra_info='not_in_fragment')
self.FitAlfa: BoolType | BoolKey = BoolKey(name='FitAlfa', comment='Debug key for Response.', hidden=True, default=False, extra_info='not_in_fragment')
self.FitExcit: BoolType | BoolKey = BoolKey(name='FitExcit', default=False, extra_info='not_in_fragment')
self.FitFile: str | StringKey = StringKey(name='FitFile', comment='Only to be used in Create runs for STOFIT. Specify a file on which the fit functions are specified.', hidden=True)
self.Fitelstat: BoolType | BoolKey = BoolKey(name='Fitelstat', comment='In energy decomposition analysis use fitted density for electrostatic energy.', hidden=True, default=False, extra_info='not_in_fragment')
self.Fithyppol: BoolType | BoolKey = BoolKey(name='Fithyppol', comment='Use fitted density in TDDFT for hyperpolarizability calculation.', hidden=True, default=False, extra_info='not_in_fragment')
self.Fitmeta: BoolType | BoolKey = BoolKey(name='Fitmeta', comment='SCF: use fitted density for post-SCF meta-GGA functionals.', hidden=True, default=False, extra_info='not_in_fragment')
self.Fitsecder: BoolType | BoolKey = BoolKey(name='Fitsecder', comment='SCF: use fitted density for second derivative density.', hidden=True, default=False, extra_info='not_in_fragment')
self.ForceALDA: BoolType | BoolKey = BoolKey(name='ForceALDA', comment='In spin-flip TDDFT, the XC kernel can be calculated directly from the XC potential. To use the LDA potential for the XC kernel, which roughly corresponds to the ALDA in ordinary TDDFT, one must specify the key', default=False, extra_info='not_in_fragment')
self.FragMetaGGAToten: BoolType | BoolKey = BoolKey(name='FragMetaGGAToten', comment='By setting this to true the difference in the metahybrid or metagga exchange-correlation energies between the molecule and its fragments will be calculated using the molecular integration grid, which is more accurate than the default, but is much more time consuming.', gui_name='XC energy difference (for meta XCs): Use molecular grid', default=False, extra_info='not_in_fragment')
self.FullFock: BoolType | BoolKey = BoolKey(name='FullFock', comment='Calculate the full Fock matrix each SCF iteration (instead of the difference with the previous cycle).', gui_name='Full Fock matrix: Always', default=False, extra_info='not_in_fragment')
self.FullTotEn: BoolType | BoolKey = BoolKey(name='FullTotEn', default=False, extra_info='not_in_fragment')
self.Fuzzy_BO: BoolType | BoolKey = BoolKey(name='Fuzzy_BO', default=False, extra_info='not_in_fragment')
self.GZip: str | StringKey = StringKey(name='GZip', comment='GZip the corresponding tape (possibly working only for TAPE21)', extra_info='not_in_fragment')
self.Gradient: BoolType | BoolKey = BoolKey(name='Gradient', comment='Force calculation of gradients of the total energy with respect to the nuclear coordinates, just as in a geometry optimization.\n\nThis is useful if you want to perform a single point calculation and get gradients for that specific geometry.', hidden=True, default=False, extra_info='not_in_fragment')
self.HFAtomsPerPass: int | IntKey = IntKey(name='HFAtomsPerPass', comment='Memory usage option for old HF scheme')
self.HFDependency: BoolType | BoolKey = BoolKey(name='HFDependency', comment='Extra Dependency trick for old Hartree-Fock exchange integrals.', hidden=True, default=False)
self.HFMaxMemory: int | IntKey = IntKey(name='HFMaxMemory', comment='Memory usage option for old HF scheme')
self.HartreeFock: BoolType | BoolKey = BoolKey(name='HartreeFock', comment='Compute hybrid meta-GGA energy functionals (if METAGGA key is True)', default=False, extra_info='not_in_fragment')
self.Hilbert: BoolType | BoolKey = BoolKey(name='Hilbert', comment='Option for localization of numerical integration points.', hidden=True, default=False, extra_info='not_in_fragment')
self.IgnoreOverlap: BoolType | BoolKey = BoolKey(name='IgnoreOverlap', comment='Expert option. Ignore that atoms are close.', default=False, extra_info='not_in_fragment')
self.ImportEmbPot: str | StringKey = StringKey(name='ImportEmbPot', comment='File containing an external embedding potential (FDE calculations only)', extra_info='not_in_fragment')
self.ImportGrid: str | StringKey = StringKey(name='ImportGrid', comment='FDE option for importing numerical integration grid.', extra_info='not_in_fragment')
self.IntegralsToFile: Literal["None", "FCIdump", "Dirac", "SERENITY"] = MultipleChoiceKey(name='IntegralsToFile', comment='Write all 4-center integrals to direct access file (DIRAC). or in FCIdump/Serenity format. Default is None', hidden=True, default='None', choices=['None', 'FCIdump', 'Dirac', 'SERENITY'], extra_info='not_in_fragment')
self.IsotopicShift: str | StringKey = StringKey(name='IsotopicShift', comment='Untested', extra_info='not_in_fragment')
self.KSSpectrum: BoolType | BoolKey = BoolKey(name='KSSpectrum', comment='Old key. TDDFT excitations, calculate single-orbital transitions.', hidden=True, default=False, extra_info='not_in_fragment')
self.LB4: BoolType | BoolKey = BoolKey(name='LB4', comment='Debug option for unrestricted spin-orbit coupling.', hidden=True, default=False, extra_info='not_in_fragment')
self.Lap1: BoolType | BoolKey = BoolKey(name='Lap1', comment='Debug option for calculating post-SCF functional.', hidden=True, default=False, extra_info='not_in_fragment')
self.MBlockSmall: BoolType | BoolKey = BoolKey(name='MBlockSmall', comment='For TDDFT excitations with Davidson: Option to use only 1 extra trial vector at a time.', hidden=True, default=False, extra_info='not_in_fragment')
self.MOExactDensity: BoolType | BoolKey = BoolKey(name='MOExactDensity', comment='In SCF use exact density for MOs.', hidden=True, default=False, extra_info='not_in_fragment')
self.MetaGGA: BoolType | BoolKey = BoolKey(name='MetaGGA', default=False, extra_info='not_in_fragment')
self.NewDIIS: BoolType | BoolKey = BoolKey(name='NewDIIS', comment='For old SCF routine: use newDIIS.', hidden=True, default=False, extra_info='not_in_fragment')
self.NoBeckeGrid: BoolType | BoolKey = BoolKey(name='NoBeckeGrid', comment='If true ADF will use the Voronoi numerical integration grid.', default=False)
self.NoFDEPot: BoolType | BoolKey = BoolKey(name='NoFDEPot', comment='Expert FDE option.', default=False, extra_info='not_in_fragment')
self.NoFragDp: BoolType | BoolKey = BoolKey(name='NoFragDp', comment='Debug option for orthogonalization and dependency.', hidden=True, default=False, extra_info='not_in_fragment')
self.NoGTerm: BoolType | BoolKey = BoolKey(name='NoGTerm', comment='Debug option in Response.', hidden=True, default=False, extra_info='not_in_fragment')
self.NoPrint: str | StringKey = StringKey(name='NoPrint', comment='The amount of printed output is regulated with the keys Print, NoPrint, EPrint and Debug.', unique=False, extra_info='not_in_fragment')
self.NoSharedArrays: BoolType | BoolKey = BoolKey(name='NoSharedArrays', comment='To disable the use of shared memory.', default=False)
self.NoSymFit: BoolType | BoolKey = BoolKey(name='NoSymFit', comment='Do not use only an A1 symmetric fit.', default=False)
self.NoTotEn: BoolType | BoolKey = BoolKey(name='NoTotEn', default=False, extra_info='not_in_fragment')
self.NuclearModel: Literal["PointCharge", "Gaussian"] = MultipleChoiceKey(name='NuclearModel', comment='Model for the nuclear charge distribution.\n\nTo see effects from your choice you will need to use a basis set with extra steep functions. For example you can find these in the ZORA/TZ2P-J basis directory.', default='PointCharge', choices=['PointCharge', 'Gaussian'])
self.NumericalQuality: Literal["Basic", "Normal", "Good", "VeryGood", "Excellent"] = MultipleChoiceKey(name='NumericalQuality', comment="Set the quality of several important technical aspects of an ADF calculation (with the notable exception of the basis set). It sets the quality of: BeckeGrid (numerical integration) and ZlmFit (density fitting). 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.OPop_Analysis: str | StringKey = StringKey(name='OPop_Analysis', extra_info='not_in_fragment')
self.Occupations: str | StringKey = StringKey(name='Occupations', comment='Occupations options', extra_info='not_in_fragment')
self.OrbitalsCoulombInteraction: Iterable[int] | IntListKey = IntListKey(name='OrbitalsCoulombInteraction', comment='Compute the Coulomb interaction energy between the density of two orbitals. After the key, specify the indices of the two orbitals for which you want to compute the Coulomb interaction energy. Can only be used for spin-restricted calculations. Cannot be used in case of Symmetry (use Symmetry NoSym).', unique=False, extra_info='not_in_fragment')
self.OrthFragPrep: BoolType | BoolKey = BoolKey(name='OrthFragPrep', comment='Expert FDE option.', default=False, extra_info='not_in_fragment')
self.PartialZORA: str | StringKey = StringKey(name='PartialZORA', comment='Untested and undocumented key to use partial ZORA.', hidden=True)
self.Print: str | StringKey = StringKey(name='Print', comment='The amount of printed output is regulated with the keys Print, NoPrint, EPrint and Debug.', unique=False, extra_info='not_in_fragment')
self.ProgConv: BoolType | BoolKey = BoolKey(name='ProgConv', comment='Use progressive convergence in SCF, icw LinearScaling%ProgConv not equal 0.', hidden=True, default=True, extra_info='not_in_fragment')
self.QTens: BoolType | BoolKey = BoolKey(name='QTens', comment='Calculate the the Nuclear Electric Quadrupole Hyperfine interaction (Q-tensor, NQCC, NQI), related to the Electric Field Gradient (EFG).', default=False, extra_info='not_in_fragment')
self.RConfine: Iterable[float] | FloatListKey = FloatListKey(name='RConfine', comment='Used for making confinement potential in order to make DFTB parameters. Obsolete.', hidden=True, extra_info='not_in_fragment')
self.RESPPMATSAVE: BoolType | BoolKey = BoolKey(name='RESPPMATSAVE', comment='Needed for SubResponse (EO) calculations. Hacked by JN. Restored by Pengchong Liu', default=False)
self.RESTOCC: BoolType | BoolKey = BoolKey(name='RESTOCC', default=False, extra_info='not_in_fragment')
self.RemoveAllFragVirtuals: BoolType | BoolKey = BoolKey(name='RemoveAllFragVirtuals', comment='Remove all virtual fragment orbitals.', default=False, extra_info='not_in_fragment')
self.RemoveOtherFragVirtuals: BoolType | BoolKey = BoolKey(name='RemoveOtherFragVirtuals', comment='Remove all virtual fragment orbitals, except on first fragment.', default=False, extra_info='not_in_fragment')
self.ResponseFormalism: Literal["Auto", "Response", "AOResponse"] = MultipleChoiceKey(name='ResponseFormalism', comment='Set to RESPONSE or AORESPONSE.', default='Auto', choices=['Auto', 'Response', 'AOResponse'], extra_info='not_in_fragment')
self.SFTDDFT: BoolType | BoolKey = BoolKey(name='SFTDDFT', comment='Calculate spin-flip excitation energies (requires TDA and FORCEALDA keys).', gui_name='Spin-flip excitations:', default=False, extra_info='not_in_fragment')
self.SOMCD: BoolType | BoolKey = BoolKey(name='SOMCD', comment='MCD option. Required for a calculation of MCD temperature-dependent C terms. The calculation must be an unrestricted and scalar relativistic ZORA.', default=False, extra_info='not_in_fragment')
self.STContrib: BoolType | BoolKey = BoolKey(name='STContrib', comment='For an analysis of spin-orbit coupled excitations in terms of scalar relativistic singlet and triplet excitations. In order to get this analysis one needs to perform a scalar relativistic TDDFT calculation of excitation energies on the closed shell molecule first, and use the resulting adf.rkf as a fragment in the spin-orbit coupled TDDFT calculation of excitation energies, including this keyword STCONTRIB.', default=False, extra_info='not_in_fragment')
self.STOFit: BoolType | BoolKey = BoolKey(name='STOFit', comment='Computation of the Coulomb potential with the pair fit method.', default=False)
self.Save: str | StringKey = StringKey(name='Save', comment='A sequence of file names separated by blanks or commas. Possible file names are TAPE10, TAPE13, TAPE14.', unique=False, extra_info='not_in_fragment')
self.SharcOverlap: BoolType | BoolKey = BoolKey(name='SharcOverlap', default=False, extra_info='not_in_fragment')
self.Skip: str | StringKey = StringKey(name='Skip', comment='Expert key. To restrict which parts of the program are actually executed.', unique=False, extra_info='not_in_fragment')
self.SpinPolarization: float | FloatKey = FloatKey(name='SpinPolarization', comment='The spin polarization of the system, which is the number of spin-alpha electrons in excess of spin-beta electrons. Specification is only meaningful in a spin-unrestricted calculation. However, specification is not meaningful in an unrestricted Spin-Orbit coupled calculation using the (non-)collinear approximation.')
self.StopAfter: str | StringKey = StringKey(name='StopAfter', extra_info='not_in_fragment')
self.Symmetry: Literal["AUTO", "NOSYM", "ATOM", "C(LIN)", "D(LIN)", "C(I)", "C(S)", "C(2)", "C(2V)", "C(3V)", "C(4V)", "C(5V)", "C(6V)", "C(7V)", "C(8V)", "C(2H)", "D(2)", "D(3)", "D(4)", "D(5)", "D(6)", "D(7)", "D(8)", "D(2D)", "D(3D)", "D(4D)", "D(5D)", "D(6D)", "D(7D)", "D(8D)", "D(2H)", "D(3H)", "D(4H)", "D(5H)", "D(6H)", "D(7H)", "D(8H)", "O(H)", "T(D)"] = MultipleChoiceKey(name='Symmetry', comment='Use (sub)symmetry with this Schoenflies symbol. Can only be used for molecules. Orientation should be correct for the (sub)symmetry. Coordinates must be symmetric within SymmetryTolerance.', default='AUTO', choices=['AUTO', 'NOSYM', 'ATOM', 'C(LIN)', 'D(LIN)', 'C(I)', 'C(S)', 'C(2)', 'C(2V)', 'C(3V)', 'C(4V)', 'C(5V)', 'C(6V)', 'C(7V)', 'C(8V)', 'C(2H)', 'D(2)', 'D(3)', 'D(4)', 'D(5)', 'D(6)', 'D(7)', 'D(8)', 'D(2D)', 'D(3D)', 'D(4D)', 'D(5D)', 'D(6D)', 'D(7D)', 'D(8D)', 'D(2H)', 'D(3H)', 'D(4H)', 'D(5H)', 'D(6H)', 'D(7H)', 'D(8H)', 'O(H)', 'T(D)'])
self.SymmetryTolerance: float | FloatKey = FloatKey(name='SymmetryTolerance', comment='Tolerance used to detect symmetry in the system. If symmetry Schoenflies symbol is specified, the coordinates must be symmetric within this tolerance.', default=1e-07)
self.TDA: BoolType | BoolKey = BoolKey(name='TDA', comment='Use the Tamm-Dancoff approximation (TDA) (requires the EXCITATIONS block key)', default=False, extra_info='not_in_fragment')
self.TDDFTSO: BoolType | BoolKey = BoolKey(name='TDDFTSO', default=False, extra_info='not_in_fragment')
self.TIDegeneracyThreshold: float | FloatKey = FloatKey(name='TIDegeneracyThreshold', comment='If the orbital energy of the fragment MO is within this threshold with fragment HOMO or LUMO energy, then this fragment MO is included in the calculation of the transfer integrals. Relevant in case there is (near) degeneracy.', default=0.1, unit='eV', extra_info='not_in_fragment')
self.Title: str | StringKey = StringKey(name='Title', comment='Title of the calculation.', default='*** (NO TITLE) ***')
self.TotalEnergy: BoolType | BoolKey = BoolKey(name='TotalEnergy', comment='Calculate the total energy.\n\nNormally only the bonding energy with respect to the fragments is calculated.\n\nThe total energy will be less accurate then the bonding energy (about two decimal places), and is not compatible with some options.\n\nIn most cases the total energy will not be needed.', gui_name='Print: Total Energy', default=False)
self.TransferIntegrals: BoolType | BoolKey = BoolKey(name='TransferIntegrals', comment='Calculate the charge transfer integrals, spatial overlap integrals and site energies.\n\nCharge transfer integrals can be used in models that calculate transport properties.', gui_name=': Charge transfer integrals (for transport properties)', default=False, extra_info='not_in_fragment')
self.Unrestricted: BoolType | BoolKey = BoolKey(name='Unrestricted', comment='By default, a spin-restricted calculation is performed where the spin alpha and spin beta orbitals are spatially the same.', default=False)
self.UnrestrictedFragments: BoolType | BoolKey = BoolKey(name='UnrestrictedFragments', comment='Use fragments calculated a spin-unrestricted calculation: the spin alpha and spin beta orbitals may be spatially different.\n\nThe total spin polarization of your fragments must match the spin polarization of your final molecule.', default=False, extra_info='not_in_fragment')
self.UsePseudoDiag: BoolType | BoolKey = BoolKey(name='UsePseudoDiag', comment='Expert option for diagonalization in SCF.', hidden=True, default=False, extra_info='not_in_fragment')
self.UseSPCode: BoolType | BoolKey = BoolKey(name='UseSPCode', comment='Use Patchkovskii routines for PBE', default=False)
self.VectorLength: int | IntKey = IntKey(name='VectorLength', comment='Specify a different batch size for the integration points here (default: 128 on most machines and 2047 on vector machines).', gui_name='Vectorlength (blocksize):')
self.ZExact: BoolType | BoolKey = BoolKey(name='ZExact', comment='Expert option in TDDFT excitations.', default=False, extra_info='not_in_fragment')
self.ZFS: str | StringKey = StringKey(name='ZFS', comment='Calculate the zero-field splitting (ZFS) of an open shell ground state. An unrestricted calculation is required and a spin larger than 1/2, and no no spatial degeneracy. Scalar relativistic ZORA is required.', extra_info='not_in_fragment')
self.grad_no_fragment_potentials: BoolType | BoolKey = BoolKey(name='grad_no_fragment_potentials', comment='FDE option.', hidden=True, default=False, extra_info='not_in_fragment')
self.hydrogenbonds: BoolType | BoolKey = BoolKey(name='hydrogenbonds', comment='Option for SFO population analysis to print small numbers.', default=False, extra_info='not_in_fragment')
self.nocalcs2: BoolType | BoolKey = BoolKey(name='nocalcs2', comment='Do not calculate expectation value S**2 (spin).', hidden=True, default=False, extra_info='not_in_fragment')
self.nomorton: BoolType | BoolKey = BoolKey(name='nomorton', comment='Debug option for localization of numerical integration points.', hidden=True, default=False, extra_info='not_in_fragment')
self.nopm5rho: BoolType | BoolKey = BoolKey(name='nopm5rho', comment='Debug option for response.', hidden=True, default=False, extra_info='not_in_fragment')
self.notstcoe: BoolType | BoolKey = BoolKey(name='notstcoe', comment='Option not to test orthonormal basis set.', hidden=True, default=False, extra_info='not_in_fragment')
self.nouseactivefrag: BoolType | BoolKey = BoolKey(name='nouseactivefrag', comment='Do not use orbital data from active fragment in first cycle SCF.', hidden=True, default=False, extra_info='not_in_fragment')
self.novkpot: BoolType | BoolKey = BoolKey(name='novkpot', comment='Debug option for AOResponse.', hidden=True, default=False, extra_info='not_in_fragment')
self.noxcprint: BoolType | BoolKey = BoolKey(name='noxcprint', comment='Do not print XC energy terms.', hidden=True, default=False, extra_info='not_in_fragment')
self.oldblockedsmat: BoolType | BoolKey = BoolKey(name='oldblockedsmat', comment='Use old way to calculate overlap matrix.', hidden=True, default=False)
self.oldorthon: BoolType | BoolKey = BoolKey(name='oldorthon', comment='Use old orthogonalization routine.', hidden=True, default=False)
self.plap3: BoolType | BoolKey = BoolKey(name='plap3', comment='Debug option for calculating post-SCF functional.', hidden=True, default=False, extra_info='not_in_fragment')
self.prtallten: BoolType | BoolKey = BoolKey(name='prtallten', comment='Debug option for response.', hidden=True, default=False, extra_info='not_in_fragment')
self.readepsilons: BoolType | BoolKey = BoolKey(name='readepsilons', comment='Debug option for TDDFT. Read extra orbitals.', hidden=True, default=False, extra_info='not_in_fragment')
self.rhobelpotimport: BoolType | BoolKey = BoolKey(name='rhobelpotimport', comment='Key for FDE-MD.', hidden=True, default=False, extra_info='not_in_fragment')
self.riskyfast: BoolType | BoolKey = BoolKey(name='riskyfast', comment='Debug option to skip some post-SCF properties, like bond energy. ', hidden=True, default=False, extra_info='not_in_fragment')
self.scaledkinfunctionals: BoolType | BoolKey = BoolKey(name='scaledkinfunctionals', comment='FDE option.', default=False, extra_info='not_in_fragment')
self.sfotrans: BoolType | BoolKey = BoolKey(name='sfotrans', comment='Old key for SFO analysis TDDFT excitations.', hidden=True, default=False, extra_info='not_in_fragment')
self.skorthon: BoolType | BoolKey = BoolKey(name='skorthon', comment='Debug option to skip ETALOW.', hidden=True, default=False, extra_info='not_in_fragment')
self.sozero: BoolType | BoolKey = BoolKey(name='sozero', comment='Debug option to set spin-orbit matrix to zero.', default=False, extra_info='not_in_fragment')
self.switchcoe: BoolType | BoolKey = BoolKey(name='switchcoe', comment='Debug option for orthogonalization.', hidden=True, default=False, extra_info='not_in_fragment')
self.symexcit: BoolType | BoolKey = BoolKey(name='symexcit', comment='Debug option for TDDFT excitations.', hidden=True, default=False, extra_info='not_in_fragment')
self.symresp: BoolType | BoolKey = BoolKey(name='symresp', comment='Debug option for TDDFT response.', hidden=True, default=False, extra_info='not_in_fragment')
self.testsub1: BoolType | BoolKey = BoolKey(name='testsub1', comment='Debug option excitations and subexci.', hidden=True, default=False, extra_info='not_in_fragment')
self.totenskip: BoolType | BoolKey = BoolKey(name='totenskip', comment='Debug option to skip toten.', hidden=True, default=False, extra_info='not_in_fragment')
self.useortp: BoolType | BoolKey = BoolKey(name='useortp', comment='Use orth density matrices instead of previous density matrix.', hidden=True, default=False, extra_info='not_in_fragment')
self.usesumfragp: BoolType | BoolKey = BoolKey(name='usesumfragp', comment='Use sum fragment density matrices instead of previous density matrix.', hidden=True, default=False, extra_info='not_in_fragment')
self.xonly: BoolType | BoolKey = BoolKey(name='xonly', comment='Option for spin-orbit coupled AOresponse.', hidden=True, default=False, extra_info='not_in_fragment')
self.xyonly: BoolType | BoolKey = BoolKey(name='xyonly', comment='Option for spin-orbit coupled AOresponse.', hidden=True, default=False, extra_info='not_in_fragment')
self.xzonly: BoolType | BoolKey = BoolKey(name='xzonly', comment='Option for spin-orbit coupled AOresponse.', hidden=True, default=False, extra_info='not_in_fragment')
self.yonly: BoolType | BoolKey = BoolKey(name='yonly', comment='Option for spin-orbit coupled AOresponse.', hidden=True, default=False, extra_info='not_in_fragment')
self.yzonly: BoolType | BoolKey = BoolKey(name='yzonly', comment='Option for spin-orbit coupled AOresponse.', hidden=True, default=False, extra_info='not_in_fragment')
self.zonly: BoolType | BoolKey = BoolKey(name='zonly', comment='Option for spin-orbit coupled AOresponse.', hidden=True, default=False, extra_info='not_in_fragment')
self.AOResponse: ADF._AOResponse = self._AOResponse(name='AOResponse', comment='If the block key AORESPONSE is used, by default, the polarizability is calculated. Note that if the molecule has symmetry the key ALLPOINTS should be included', extra_info='not_in_fragment')
self.AnalyticalFreq: ADF._AnalyticalFreq = self._AnalyticalFreq(name='AnalyticalFreq', comment='Define options for analytical frequencies.', extra_info='not_in_fragment')
self.Aromaticity: ADF._Aromaticity = self._Aromaticity(name='Aromaticity', comment='Calculate aromaticity indicators, i.e. the matrix of localization/delocalization indices (LI-DI), Iring (ring index) and MCI (multi center index) aromaticity indices.', extra_info='not_in_fragment')
self.Basis: ADF._Basis = self._Basis(name='Basis', comment='Definition of the basis set')
self.BeckeGrid: ADF._BeckeGrid = self._BeckeGrid(name='BeckeGrid', comment='Options for the numerical integration grid.')
self.BondOrders: ADF._BondOrders = self._BondOrders(name='BondOrders', comment='Options for the calculation of bond orders. Note: the calculation of bond orders should be requested via the Properties%BondOrders input option in the AMS driver input.', extra_info='not_in_fragment')
self.CDFT: ADF._CDFT = self._CDFT(name='CDFT', comment='CDFT is a tool for carrying out DFT calculations in the presence of a constraint.', extra_info='not_in_fragment')
self.CVNDFT: ADF._CVNDFT = self._CVNDFT(name='CVNDFT', comment='The CVNDFT block key regulates the execution of the CV(n)-DFT code, which calculates the singlet or triplet electronic excitations for the closed shell molecules.', extra_info='not_in_fragment')
self.ConceptualDFT: ADF._ConceptualDFT = self._ConceptualDFT(name='ConceptualDFT', comment='Conceptual DFT Properties', extra_info='not_in_fragment')
self.ConstructPot: ADF._ConstructPot = self._ConstructPot(name='ConstructPot', comment='Reads a density from a TAPE41 file and constructs numerically the corresponding potential to it', extra_info='not_in_fragment')
self.CorePotentials: str | Sequence[str] | FreeBlock = self._CorePotentials(name='CorePotentials', comment='With the key COREPOTENTIALS you specify the core file and (optionally) which sections pertain to the distinct atom types in the molecule.', header=True)
self.CurrentResponse: ADF._CurrentResponse = self._CurrentResponse(name='CurrentResponse', extra_info='not_in_fragment')
self.DIMPAR: str | Sequence[str] | FreeBlock = self._DIMPAR(name='DIMPAR', comment='In this block, the parameters for the DIM atoms are defined in DIM/QM calculations.', extra_info='not_in_fragment')
self.DIMQM: str | Sequence[str] | FreeBlock = self._DIMQM(name='DIMQM', comment='Input for DIM/QM', extra_info='not_in_fragment')
self.Dependency: ADF._Dependency = self._Dependency(name='Dependency', extra_info='not_in_fragment')
self.EPrint: ADF._EPrint = self._EPrint(name='EPrint', comment='Print switches that require more specification than just off or on', extra_info='not_in_fragment')
self.ESR: ADF._ESR = self._ESR(name='ESR', extra_info='not_in_fragment')
self.ETSNOCV: ADF._ETSNOCV = self._ETSNOCV(name='ETSNOCV', comment='Perform ETS-NOCV analysis.', extra_info='not_in_fragment')
self.ElectronTransfer: ADF._ElectronTransfer = self._ElectronTransfer(name='ElectronTransfer', comment='Block key for charge transfer integrals with FDE.', extra_info='not_in_fragment')
self.EnergyFrag: str | Sequence[str] | FreeBlock = self._EnergyFrag(name='EnergyFrag', extra_info='not_in_fragment')
self.Excitations: ADF._Excitations = self._Excitations(name='Excitations', comment='Excitation energies: UV/Vis', extra_info='not_in_fragment')
self.ExcitedEDA: ADF._ExcitedEDA = self._ExcitedEDA(name='ExcitedEDA', comment='Options for excited energy decomposition (EDA).')
self.ExcitedGO: ADF._ExcitedGO = self._ExcitedGO(name='ExcitedGO', comment='Excited state geometry optimization', extra_info='not_in_fragment')
self.ExcitonTransfer: ADF._ExcitonTransfer = self._ExcitonTransfer(name='ExcitonTransfer', comment='Block key for exciton transfer integrals with ROSE or FOCDFT.', extra_info='not_in_fragment')
self.Externals: str | Sequence[str] | FreeBlock = self._Externals(name='Externals', comment='Legacy support of the older DRF code.', extra_info='not_in_fragment')
self.FDE: ADF._FDE = self._FDE(name='FDE', comment='Frozen Density Embedding options', header=True, extra_info='not_in_fragment')
self.FDEFragments: str | Sequence[str] | FreeBlock = self._FDEFragments(name='FDEFragments', comment='Definitions of the FDE fragment types.', extra_info='not_in_fragment')
self.FOCDFT: ADF._FOCDFT = self._FOCDFT(name='FOCDFT', comment='Localize orbitals on fragments and constrain charge and spin polarization on fragments.', extra_info='not_in_fragment')
self.Fitnadkin: str | Sequence[str] | FreeBlock = self._Fitnadkin(name='Fitnadkin', comment='FDE option.', hidden=True, extra_info='not_in_fragment')
self.FragOccupations: str | Sequence[str] | FreeBlock = self._FragOccupations(name='FragOccupations', comment='Simulation of unrestricted fragments with the key FRAGOCCUPATIONS. Fragments need to be calculated spin-restricted. One can specify occupation numbers as if these fragments are calculated spin-unrestricted. The sum of spin-alpha and spin-beta occupations must, for each fragment orbital in each irrep separately, be equal to the total spin-restricted occupation of that orbital in the fragment.', extra_info='not_in_fragment')
self.Fragments: str | Sequence[str] | FreeBlock = self._Fragments(name='Fragments', comment='Definitions of the fragment type/files: {FragmentName FragmentFile}. In the block header one can specify the directory where the fragment files are located', header=True, extra_info='not_in_fragment')
self.GPU: ADF._GPU = self._GPU(name='GPU', comment='Set GPU options')
self.GW: ADF._GW = self._GW(name='GW', comment='Perform a GW calculation. G0W0 is the default for GW%SelfConsistency.', extra_info='not_in_fragment')
self.IQA: ADF._IQA = self._IQA(name='IQA', comment='Total energy decomposition based on the interacting quantum atoms (IQA) approach and using QTAIM real-space partition.', extra_info='not_in_fragment')
self.Integration: ADF._Integration = self._Integration(name='Integration', comment='Options for the Voronoi numerical integration scheme')
self.IrrepOccupations: str | Sequence[str] | FreeBlock = self._IrrepOccupations(name='IrrepOccupations', comment='Explicit occupation numbers per irrep', extra_info='not_in_fragment')
self.LinearScaling: ADF._LinearScaling = self._LinearScaling(name='LinearScaling', header=True)
self.LocOrb: str | Sequence[str] | FreeBlock = self._LocOrb(name='LocOrb', comment='The computation of localized orbitals is controlled with this block-type key', header=True, extra_info='not_in_fragment')
self.MBPT: ADF._MBPT = self._MBPT(name='MBPT', comment='Technical aspects of the MP2 algorithm.', extra_info='not_in_fragment')
self.MDC: ADF._MDC = self._MDC(name='MDC', comment='Options for Multipole Derived Charges (MDC)', hidden=True, extra_info='not_in_fragment')
self.ModifyExcitation: ADF._ModifyExcitation = self._ModifyExcitation(name='ModifyExcitation', extra_info='not_in_fragment')
self.ModifyStartPotential: str | Sequence[str] | FreeBlock = self._ModifyStartPotential(name='ModifyStartPotential', comment='Modify the starting spin-dependent potential for unrestricted calculations.', header=True, extra_info='not_in_fragment')
self.Nanoparticle: ADF._Nanoparticle = self._Nanoparticle(name='Nanoparticle', comment='To include the presence of a nanoparticle near the system', hidden=True, extra_info='not_in_fragment')
self.PertLoc: ADF._PertLoc = self._PertLoc(name='PertLoc', comment='Perturbed localized molecular orbitals, correct to first order in an applied field, can be calculated in case of AORESPONSE. Can be used if the applied field changes the density in first order.', extra_info='not_in_fragment')
self.PolTDDFT: ADF._PolTDDFT = self._PolTDDFT(name='PolTDDFT', comment='POLTDDFT is a fast algorithm to solve the TDDFT equations in the space of the density fitting auxiliary basis set. The (real and imaginary part of the) diagonal of the polarizability tensor and rotatory strengths will be calculated, which can be used to calculate the photoabsorption and circular dichroism (CD) spectra.', extra_info='not_in_fragment')
self.QMFQ: ADF._QMFQ = self._QMFQ(name='QMFQ', comment='Block input key for QM/FQ(FMu).', extra_info='not_in_fragment')
self.QTAIM: ADF._QTAIM = self._QTAIM(name='QTAIM', comment="This block is used to request a topological analysis of the gradient field of the electron density, also known as the Bader's analysis. If this block is specified without any sub-key, only local properties are calculated.", extra_info='not_in_fragment')
self.RIHartreeFock: ADF._RIHartreeFock = self._RIHartreeFock(name='RIHartreeFock')
self.RISM: str | Sequence[str] | FreeBlock = self._RISM(name='RISM', comment='3D-RISM-related input keys.', header=True, extra_info='not_in_fragment')
self.ROSE: ADF._ROSE = self._ROSE(name='ROSE', comment='Options for orbital localization', extra_info='not_in_fragment')
self.RadialCoreGrid: ADF._RadialCoreGrid = self._RadialCoreGrid(name='RadialCoreGrid', comment='For each atom the charge densities and the coulomb potentials of frozen core and valence electrons are computed in a radial grid. The radial grid consists of a sequence of r-values, defined by a smallest value, a constant multiplication factor to obtain each successive r-value, and the total number of points. Equivalently it can be characterized by the smallest r-value, the largest r-value, and the number of points; from these data the program computes then the constant multiplication factor.')
self.Relativity: ADF._Relativity = self._Relativity(name='Relativity', comment='Options for relativistic effects.')
self.RemoveFragOrbitals: str | Sequence[str] | FreeBlock = self._RemoveFragOrbitals(name='RemoveFragOrbitals', comment='Block key to remove selected virtual fragment orbitals.', extra_info='not_in_fragment')
self.Response: ADF._Response = self._Response(name='Response', comment='The calculation of frequency-dependent (hyper)polarizabilities and related properties (Raman, ORD)', extra_info='not_in_fragment')
self.Restart: ADF._Restart = self._Restart(name='Restart', comment='Options for restarts', extra_info='not_in_fragment')
self.SCF: ADF._SCF = self._SCF(name='SCF', comment='Control aspects of the Self Consistent Field procedure', extra_info='not_in_fragment')
self.SCRF: str | Sequence[str] | FreeBlock = self._SCRF(name='SCRF', comment='SCRF is no longer supported. Use AMS2023 or earlier.', extra_info='not_in_fragment')
self.SOPert: ADF._SOPert = self._SOPert(name='SOPert', comment='Key for perturbative inclusion of spin-orbit coupling.', extra_info='not_in_fragment')
self.SelectExcitation: ADF._SelectExcitation = self._SelectExcitation(name='SelectExcitation', extra_info='not_in_fragment')
self.SlaterDeterminants: str | Sequence[str] | FreeBlock = self._SlaterDeterminants(name='SlaterDeterminants', comment='The calculation of the one-determinant states based on the AOC reference state is controlled with this key.', header=True, extra_info='not_in_fragment')
self.Solvation: ADF._Solvation = self._Solvation(name='Solvation', header=True, extra_info='not_in_fragment')
self.SpinOrbitMagnetization: ADF._SpinOrbitMagnetization = self._SpinOrbitMagnetization(name='SpinOrbitMagnetization', comment='Starting artificial spin-orbit magnetization at first SCF cycle')
self.SubExci: ADF._SubExci = self._SubExci(name='SubExci', comment='Subsystem TDDFT (FDE)', extra_info='not_in_fragment')
self.SubResponse: str | Sequence[str] | FreeBlock = self._SubResponse(name='SubResponse', comment='Untested and undocumented', hidden=True, extra_info='not_in_fragment')
self.Tails: ADF._Tails = self._Tails(name='Tails', comment='Obsolete option for linear scaling and distance effects. We recommend using the LinearScaling key instead.', extra_info='not_in_fragment')
self.VSCRF: str | Sequence[str] | FreeBlock = self._VSCRF(name='VSCRF', comment='VSCRF is no longer supported. Use AMS2023 or earlier.', extra_info='not_in_fragment')
self.XC: ADF._XC = self._XC(name='XC', comment='Definition of the XC.')
self.XES: ADF._XES = self._XES(name='XES', comment='X-ray emission spectroscopy', extra_info='not_in_fragment')
self.ZlmFit: ADF._ZlmFit = self._ZlmFit(name='ZlmFit', comment="Options for the density fitting scheme 'ZlmFit'.")
