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 PreAmsifiedADF(DriverBlock):
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:
:vartype AORCOnly: BoolType | BoolKey
:ivar AORXCOnly:
:vartype AORXCOnly: BoolType | BoolKey
:ivar AORun:
: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:
:vartype AllWaals: BoolType | BoolKey
:ivar Allow:
:vartype Allow: str | StringKey
:ivar AltLinVXC:
:vartype AltLinVXC: BoolType | BoolKey
:ivar AltOrthon:
:vartype AltOrthon: BoolType | BoolKey
:ivar AltRhof:
:vartype AltRhof: BoolType | BoolKey
:ivar AnaPol:
:vartype AnaPol: BoolType | BoolKey
: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:
:vartype Blapt: BoolType | BoolKey
:ivar BondOrder:
:vartype BondOrder: str | StringKey
:ivar BoySold:
:vartype BoySold: BoolType | BoolKey
:ivar C2Coef: Print C2Coef to output
:vartype C2Coef: BoolType | BoolKey
:ivar CDataFile: Untested and undocumented
:vartype CDataFile: str | StringKey
:ivar CM5: Calculate the charge model 5 (CM5) analysis.
:vartype CM5: BoolType | BoolKey
:ivar CRDFilemol: Untested and undocumented
:vartype CRDFilemol: str | StringKey
:ivar CRDFilemopac: Untested and undocumented
:vartype CRDFilemopac: str | StringKey
:ivar CRDFilexyz: Untested and undocumented
:vartype CRDFilexyz: str | StringKey
: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 Charge: Controls the net charge of the molecule and the net spin polarization. First number: The net total charge of the molecule, Second number: The net total spin polarization: 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 Charge: Iterable[float] | FloatListKey
:ivar ChkDisFal:
:vartype ChkDisFal: BoolType | BoolKey
:ivar ColTDDFT:
:vartype ColTDDFT: BoolType | BoolKey
:ivar Collinear: Use collinear approximation (only relevant in the case of Spin-Orbit coupling).
:vartype Collinear: BoolType | BoolKey
:ivar CommTiming:
:vartype CommTiming: BoolType | BoolKey
:ivar ComplexAcl:
:vartype ComplexAcl: BoolType | BoolKey
:ivar CoreTables:
:vartype CoreTables: BoolType | BoolKey
:ivar CoulombFit:
:vartype CoulombFit: BoolType | BoolKey
:ivar Create: Keywords for create run. {Atomtype Datafile}
:vartype Create: str | StringKey
:ivar DFTBParams:
:vartype DFTBParams: BoolType | BoolKey
:ivar DRho241:
:vartype DRho241: BoolType | BoolKey
:ivar Database: Untested and undocumented
:vartype Database: str | StringKey
:ivar Debug:
:vartype Debug: str | StringKey
:ivar DeltaEpStrip:
:vartype DeltaEpStrip: BoolType | BoolKey
:ivar DensPrep:
:vartype DensPrep: BoolType | BoolKey
:ivar Diffuse:
: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 EField: Electric field.
:vartype EField: str | StringKey
:ivar EGOXAlpha:
:vartype EGOXAlpha: BoolType | BoolKey
:ivar EnergyTest:
: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 ExtendPopAn:
:vartype ExtendPopAn: BoolType | BoolKey
:ivar ExtendedPopan: Calculate the Mayer bond orders and Mulliken atom-atom populations per l-value
:vartype ExtendedPopan: BoolType | BoolKey
:ivar FitAlfa:
:vartype FitAlfa: BoolType | BoolKey
:ivar FitExcit:
:vartype FitExcit: BoolType | BoolKey
:ivar FitFile:
:vartype FitFile: str | StringKey
:ivar Fitelstat:
:vartype Fitelstat: BoolType | BoolKey
:ivar Fithyppol:
:vartype Fithyppol: BoolType | BoolKey
:ivar Fitmeta:
:vartype Fitmeta: BoolType | BoolKey
:ivar Fitsecder:
: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 FullSCF:
:vartype FullSCF: BoolType | BoolKey
:ivar FullTotEn:
:vartype FullTotEn: BoolType | BoolKey
:ivar Fuzzy_BO:
:vartype Fuzzy_BO: BoolType | BoolKey
: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 GZip: GZip the corresponding tape (possibly working only for TAPE21)
:vartype GZip: str | StringKey
:ivar GaugeOrigin: Untested and undocumented
:vartype GaugeOrigin: Iterable[float] | FloatListKey
: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: Untested and undocumented
: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 HessTest: Print the force field derived initial Hessian.
:vartype HessTest: BoolType | BoolKey
:ivar Hilbert:
:vartype Hilbert: BoolType | BoolKey
:ivar IgnoreOverlap:
:vartype IgnoreOverlap: BoolType | BoolKey
:ivar ImportEmbPot: File containing an external embedding potential (FDE calculations only)
:vartype ImportEmbPot: str | StringKey
:ivar ImportGrid:
:vartype ImportGrid: str | StringKey
:ivar IsotopicShift: Untested
:vartype IsotopicShift: str | StringKey
:ivar KSSpectrum:
:vartype KSSpectrum: BoolType | BoolKey
:ivar LB4:
:vartype LB4: BoolType | BoolKey
:ivar Lap1:
:vartype Lap1: BoolType | BoolKey
:ivar LinTermVXC:
:vartype LinTermVXC: BoolType | BoolKey
:ivar MBlockBig:
:vartype MBlockBig: BoolType | BoolKey
:ivar MBlockSmall:
:vartype MBlockSmall: BoolType | BoolKey
:ivar MOExactDensity:
:vartype MOExactDensity: BoolType | BoolKey
:ivar MetaGGA:
:vartype MetaGGA: BoolType | BoolKey
:ivar NewDIIS:
:vartype NewDIIS: BoolType | BoolKey
:ivar NoBeckeGrid:
:vartype NoBeckeGrid: BoolType | BoolKey
:ivar NoESRfcsd:
:vartype NoESRfcsd: BoolType | BoolKey
:ivar NoESRpso:
:vartype NoESRpso: BoolType | BoolKey
:ivar NoFDEPot:
:vartype NoFDEPot: BoolType | BoolKey
:ivar NoFragDp:
:vartype NoFragDp: BoolType | BoolKey
:ivar NoGTerm:
:vartype NoGTerm: BoolType | BoolKey
:ivar NoPrint:
:vartype NoPrint: str | StringKey
:ivar NoSharedArrays:
:vartype NoSharedArrays: BoolType | BoolKey
:ivar NoSymFit:
:vartype NoSymFit: BoolType | BoolKey
:ivar NoTotEn:
:vartype NoTotEn: BoolType | BoolKey
:ivar NoUpdFac:
:vartype NoUpdFac: BoolType | BoolKey
:ivar NonCollinear: Use non-collinear approximation (only relevant in the case of Spin-Orbit coupling).
:vartype NonCollinear: 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 some elements you can find these in the ZORA/jcpl 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:
:vartype OrthFragPrep: BoolType | BoolKey
:ivar PartialZORA: Untested and undocumented
:vartype PartialZORA: str | StringKey
:ivar Print:
:vartype Print: str | StringKey
:ivar ProgConv:
: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: Untested and undocumented
:vartype RConfine: Iterable[float] | FloatListKey
:ivar RESTOCC:
:vartype RESTOCC: BoolType | BoolKey
:ivar RamanRange:
:vartype RamanRange: str | StringKey
:ivar ReducedMass: Print reduced mass for each normal mode
:vartype ReducedMass: BoolType | BoolKey
:ivar Relativistic: instructs ADF to take relativistic effects into account.
:vartype Relativistic: str | StringKey
:ivar RemoveAllFragVirtuals:
:vartype RemoveAllFragVirtuals: BoolType | BoolKey
:ivar SFTDDFT: Calculate spin-flip excitation energies (requires TDA and FORCEALDA keys).
:vartype SFTDDFT: BoolType | BoolKey
:ivar SOMCD:
:vartype SOMCD: BoolType | BoolKey
:ivar SOUExact:
:vartype SOUExact: BoolType | BoolKey
:ivar STContrib:
:vartype STContrib: BoolType | BoolKey
:ivar STOFit:
:vartype STOFit: BoolType | BoolKey
:ivar Save:
:vartype Save: str | StringKey
:ivar ScanFreq:
:vartype ScanFreq: str | StringKey
:ivar SharcOverlap:
:vartype SharcOverlap: BoolType | BoolKey
:ivar Skip:
:vartype Skip: str | StringKey
:ivar StopAfter:
:vartype StopAfter: str | StringKey
:ivar Symmetry: The Schonfliess symmetry symbol. A tolerance can be supplied.
:vartype Symmetry: str | StringKey
:ivar TDA: Use the Tamm-Dancoff approximation (TDA) (requires the EXCITATION block key)
:vartype TDA: BoolType | BoolKey
:ivar TDDFTSO:
:vartype TDDFTSO: BoolType | BoolKey
: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:
:vartype UsePseudoDiag: BoolType | BoolKey
:ivar UseSPCode: Use Patchkovskii routines for PBE
:vartype UseSPCode: BoolType | BoolKey
:ivar VCD: Calculate rotational strength during an analytical frequencies calculation.
:vartype VCD: 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:
:vartype ZExact: BoolType | BoolKey
:ivar ZFS:
:vartype ZFS: str | StringKey
:ivar gpuenabled:
:vartype gpuenabled: BoolType | BoolKey
:ivar grad_no_fragment_potentials:
:vartype grad_no_fragment_potentials: BoolType | BoolKey
:ivar grad_trf_btrf:
:vartype grad_trf_btrf: BoolType | BoolKey
:ivar hydrogenbonds:
:vartype hydrogenbonds: BoolType | BoolKey
:ivar nocalcs2:
:vartype nocalcs2: BoolType | BoolKey
:ivar nodrop:
:vartype nodrop: BoolType | BoolKey
:ivar noerror:
:vartype noerror: BoolType | BoolKey
:ivar nogiao:
:vartype nogiao: BoolType | BoolKey
:ivar nomorton:
:vartype nomorton: BoolType | BoolKey
:ivar nopm5rho:
:vartype nopm5rho: BoolType | BoolKey
:ivar notstcoe:
:vartype notstcoe: BoolType | BoolKey
:ivar nouseactivefrag:
:vartype nouseactivefrag: BoolType | BoolKey
:ivar novkpot:
:vartype novkpot: BoolType | BoolKey
:ivar noxcprint:
:vartype noxcprint: BoolType | BoolKey
:ivar oldblockedsmat:
:vartype oldblockedsmat: BoolType | BoolKey
:ivar oldorthon:
:vartype oldorthon: BoolType | BoolKey
:ivar peano:
:vartype peano: BoolType | BoolKey
:ivar plap3:
:vartype plap3: BoolType | BoolKey
:ivar prepvibron:
:vartype prepvibron: BoolType | BoolKey
:ivar prtallten:
:vartype prtallten: BoolType | BoolKey
:ivar prtiao:
:vartype prtiao: BoolType | BoolKey
:ivar quild_nocoords_in_log:
:vartype quild_nocoords_in_log: BoolType | BoolKey
:ivar readepsilons:
:vartype readepsilons: BoolType | BoolKey
:ivar readfcfile:
:vartype readfcfile: BoolType | BoolKey
:ivar rhobelpotimport:
:vartype rhobelpotimport: BoolType | BoolKey
:ivar riskyfast:
:vartype riskyfast: BoolType | BoolKey
:ivar scaledkinfunctionals:
:vartype scaledkinfunctionals: BoolType | BoolKey
:ivar sfguess:
:vartype sfguess: BoolType | BoolKey
:ivar sfotrans:
:vartype sfotrans: BoolType | BoolKey
:ivar skipcoulombpot:
:vartype skipcoulombpot: BoolType | BoolKey
:ivar skorthon:
:vartype skorthon: BoolType | BoolKey
:ivar solv:
:vartype solv: BoolType | BoolKey
:ivar soux:
:vartype soux: BoolType | BoolKey
:ivar souy:
:vartype souy: BoolType | BoolKey
:ivar sozero:
:vartype sozero: BoolType | BoolKey
:ivar switchcoe:
:vartype switchcoe: BoolType | BoolKey
:ivar symexcit:
:vartype symexcit: BoolType | BoolKey
:ivar symresp:
:vartype symresp: BoolType | BoolKey
:ivar testaor:
:vartype testaor: BoolType | BoolKey
:ivar testfit:
:vartype testfit: BoolType | BoolKey
:ivar testjob:
:vartype testjob: BoolType | BoolKey
:ivar testpscharge:
:vartype testpscharge: BoolType | BoolKey
:ivar testsub1:
:vartype testsub1: BoolType | BoolKey
:ivar totenskip:
:vartype totenskip: BoolType | BoolKey
:ivar trustsfguess:
:vartype trustsfguess: BoolType | BoolKey
:ivar userlegmn:
:vartype userlegmn: BoolType | BoolKey
:ivar usesumfragp:
:vartype usesumfragp: BoolType | BoolKey
:ivar xonly:
:vartype xonly: BoolType | BoolKey
:ivar xyonly:
:vartype xyonly: BoolType | BoolKey
:ivar xzonly:
:vartype xzonly: BoolType | BoolKey
:ivar yonly:
:vartype yonly: BoolType | BoolKey
:ivar yzonly:
:vartype yzonly: BoolType | BoolKey
:ivar zonly:
: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: PreAmsifiedADF._AOResponse
:ivar AnalyticalFreq: Calculate the harmonic frequencies analytically
:vartype AnalyticalFreq: PreAmsifiedADF._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: str | Sequence[str] | FreeBlock
:ivar AtomProps:
:vartype AtomProps: str | Sequence[str] | FreeBlock
:ivar Atoms: Atomic positions
:vartype Atoms: str | Sequence[str] | FreeBlock
:ivar Basis: Not to be used. Use $ADFBIN/adf (NOT adf.exe!) to run this job
:vartype Basis: str | Sequence[str] | FreeBlock
:ivar BeckeGrid: Options for the numerical integration grid.
:vartype BeckeGrid: PreAmsifiedADF._BeckeGrid
:ivar CDFT: CDFT is a tool for carrying out DFT calculations in the presence of a constraint.
:vartype CDFT: PreAmsifiedADF._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: PreAmsifiedADF._CVNDFT
:ivar ConceptualDFT: Conceptual DFT Properties
:vartype ConceptualDFT: PreAmsifiedADF._ConceptualDFT
:ivar Constraints:
:vartype Constraints: str | Sequence[str] | FreeBlock
:ivar ConstructPot: Reads a density from a TAPE41 file and constructs numerically the corresponding potential to it
:vartype ConstructPot: PreAmsifiedADF._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: PreAmsifiedADF._CurrentResponse
:ivar DIMPAR:
:vartype DIMPAR: str | Sequence[str] | FreeBlock
:ivar DIMQM:
:vartype DIMQM: str | Sequence[str] | FreeBlock
:ivar Dependency:
:vartype Dependency: PreAmsifiedADF._Dependency
:ivar EPrint: Print switches that require more specification than just off or on
:vartype EPrint: PreAmsifiedADF._EPrint
:ivar ESR:
:vartype ESR: PreAmsifiedADF._ESR
:ivar ETSNOCV: Perform ETS-NOCV analysis.
:vartype ETSNOCV: PreAmsifiedADF._ETSNOCV
:ivar ElectronTransfer:
:vartype ElectronTransfer: PreAmsifiedADF._ElectronTransfer
:ivar EnergyFrag:
:vartype EnergyFrag: str | Sequence[str] | FreeBlock
:ivar Excitations: Excitation energies: UV/Vis
:vartype Excitations: PreAmsifiedADF._Excitations
:ivar ExcitedGO: Excited state geometry optimization
:vartype ExcitedGO: PreAmsifiedADF._ExcitedGO
:ivar Externals: Legacy support of the older DRF code
:vartype Externals: str | Sequence[str] | FreeBlock
:ivar FDE: Frozen Density Embedding options
:vartype FDE: PreAmsifiedADF._FDE
:ivar Fitnadkin:
:vartype Fitnadkin: str | Sequence[str] | FreeBlock
:ivar FragOccupations:
: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 GUIBonds: The bonds used by the GUI (this does not affect the ADF calculation in any way)
:vartype GUIBonds: str | Sequence[str] | FreeBlock
:ivar GeoVar:
:vartype GeoVar: str | Sequence[str] | FreeBlock
:ivar Geometry: Geometry Optimizations procedure
:vartype Geometry: PreAmsifiedADF._Geometry
:ivar HessDiag: Diagonal Hessian elements... Placeholder
:vartype HessDiag: PreAmsifiedADF._HessDiag
:ivar IQA: Bond energy decomposition based on the interacting quantum atoms (IQA) approach and using QTAIM real-space partition.
:vartype IQA: PreAmsifiedADF._IQA
:ivar IRCStart:
:vartype IRCStart: str | Sequence[str] | FreeBlock
:ivar Integration: Options for the obsolete Voronoi numerical integration scheme
:vartype Integration: str | Sequence[str] | FreeBlock
:ivar IrrepOccupations: Explicit occupation numbers per irrep
:vartype IrrepOccupations: str | Sequence[str] | FreeBlock
:ivar LinearConstraints:
:vartype LinearConstraints: str | Sequence[str] | FreeBlock
:ivar LinearScaling:
:vartype LinearScaling: PreAmsifiedADF._LinearScaling
:ivar LocOrb:
:vartype LocOrb: str | Sequence[str] | FreeBlock
:ivar MDC: Options for Multipole Derived Charges (MDC)
:vartype MDC: PreAmsifiedADF._MDC
:ivar MP2: Technical aspects of the MP2 algorithm.
:vartype MP2: PreAmsifiedADF._MP2
:ivar ModifyExcitation:
:vartype ModifyExcitation: PreAmsifiedADF._ModifyExcitation
:ivar ModifyStartPotential:
:vartype ModifyStartPotential: str | Sequence[str] | FreeBlock
: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: PreAmsifiedADF._PertLoc
:ivar PointCharges: Point charges: {x y z q}
:vartype PointCharges: str | Sequence[str] | FreeBlock
:ivar PolTDDFT: TODO!
:vartype PolTDDFT: PreAmsifiedADF._PolTDDFT
:ivar QMMM:
:vartype QMMM: str | Sequence[str] | FreeBlock
: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: PreAmsifiedADF._QTAIM
:ivar RIHartreeFock:
:vartype RIHartreeFock: PreAmsifiedADF._RIHartreeFock
:ivar RISM: 3D-RISM-related input keys.
:vartype RISM: str | Sequence[str] | FreeBlock
: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: PreAmsifiedADF._RadialCoreGrid
:ivar RemoveFragOrbitals:
:vartype RemoveFragOrbitals: str | Sequence[str] | FreeBlock
:ivar Response: The calculation of frequency-dependent (hyper)polarizabilities and related properties (Raman, ORD)
:vartype Response: PreAmsifiedADF._Response
:ivar Restart: Options for restarts
:vartype Restart: PreAmsifiedADF._Restart
:ivar Restraint:
:vartype Restraint: str | Sequence[str] | FreeBlock
:ivar SCF: Control aspects of the Self Consistent Field procedure
:vartype SCF: PreAmsifiedADF._SCF
:ivar SCRF:
:vartype SCRF: str | Sequence[str] | FreeBlock
:ivar SICOEP:
:vartype SICOEP: str | Sequence[str] | FreeBlock
:ivar SOPert:
:vartype SOPert: PreAmsifiedADF._SOPert
:ivar SelectExcitation:
:vartype SelectExcitation: PreAmsifiedADF._SelectExcitation
:ivar SlaterDeterminants:
:vartype SlaterDeterminants: str | Sequence[str] | FreeBlock
:ivar Solvation:
:vartype Solvation: PreAmsifiedADF._Solvation
:ivar SubExci: Subsystem TDDFT (FDE)
:vartype SubExci: PreAmsifiedADF._SubExci
:ivar SubResponse: Untested and undocumented
:vartype SubResponse: str | Sequence[str] | FreeBlock
:ivar TSRC: Transition State Reaction Coordinate (TSRC)
:vartype TSRC: str | Sequence[str] | FreeBlock
:ivar Tails: Obsolete option for linear scaling and distance effects. We recommend using the LinearScaling key instead.
:vartype Tails: PreAmsifiedADF._Tails
:ivar Thermo: At the end of a completed Frequencies calculation, a survey is given of thermodynamic properties: Heat Capacity, Internal Energy, Entropy. The computed results assume an ideal gas, and electronic contributions are ignored. The latter is a serious omission if the electronic configuration is (almost) degenerate, but the effect is small whenever the energy difference with the next state is large compared to the vibrational frequencies
:vartype Thermo: PreAmsifiedADF._Thermo
:ivar Units: Definitions of the units.
:vartype Units: PreAmsifiedADF._Units
:ivar VSCRF:
:vartype VSCRF: str | Sequence[str] | FreeBlock
:ivar Vibron: Resonance Raman Input options
:vartype Vibron: PreAmsifiedADF._Vibron
:ivar XC: Definition of the XC.
:vartype XC: PreAmsifiedADF._XC
:ivar XES: X-ray emission spectroscopy
:vartype XES: PreAmsifiedADF._XES
:ivar ZlmFit: Options for the density fitting scheme 'ZlmFit'.
:vartype ZlmFit: PreAmsifiedADF._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 EFG:
:vartype EFG: str | StringKey
: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 FULLMAT:
:vartype FULLMAT: BoolType | BoolKey
:ivar FitAODeriv: Use FITAODERIV for Coulomb potential
:vartype FitAODeriv: BoolType | BoolKey
:ivar FreqRange: Usage: FREQRANGE freq1 freqN TotFreq units. This key is useful when it is necessary to specify more than 20 equally spaced frequencies for the response calculations. The first frequency is freq1 and the last one is freqN. The total number of frequencies including the first and the last one is TotFreq. The last item specifies the units: EV, HARTREE or ANGSTROM
:vartype FreqRange: str | StringKey
:ivar Frequency: Usage: FREQUENCY Nfreq freq1 freq2 ... freqN units. To calculate time-dependent properties, one needs to specify frequency of perturbation field. Here Nfreq specifies the number of frequencies that follow. The last item on the line specifies the units and is one of EV, HARTREE, ANGSTROM
:vartype Frequency: str | StringKey
: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 USEHP:
:vartype USEHP: 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
"""
def __post_init__(self):
self.TWOANTISYM: BoolType | BoolKey = BoolKey(name='2ANTISYM', 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', 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.EFG: str | StringKey = StringKey(name='EFG')
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.FULLMAT: BoolType | BoolKey = BoolKey(name='FULLMAT', default=False)
self.FitAODeriv: BoolType | BoolKey = BoolKey(name='FitAODeriv', comment='Use FITAODERIV for Coulomb potential', default=False)
self.FreqRange: str | StringKey = StringKey(name='FreqRange', comment='Usage: FREQRANGE freq1 freqN TotFreq units. This key is useful when it is necessary to specify more than 20 equally spaced frequencies for the response calculations. The first frequency is freq1 and the last one is freqN. The total number of frequencies including the first and the last one is TotFreq. The last item specifies the units: EV, HARTREE or ANGSTROM')
self.Frequency: str | StringKey = StringKey(name='Frequency', comment='Usage: FREQUENCY Nfreq freq1 freq2 ... freqN units. To calculate time-dependent properties, one needs to specify frequency of perturbation field. Here Nfreq specifies the number of frequencies that follow. The last item on the line specifies the units and is one of EV, HARTREE, ANGSTROM')
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', default=False)
self.OKE: BoolType | BoolKey = BoolKey(name='OKE', default=False)
self.ONLYANTISYM: BoolType | BoolKey = BoolKey(name='ONLYANTISYM', default=False)
self.ONLYSYM: BoolType | BoolKey = BoolKey(name='ONLYSYM', 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', default=False)
self.OpticalRotation: BoolType | BoolKey = BoolKey(name='OpticalRotation', comment='Calculate optical rotation', default=False)
self.PBE0LDA: BoolType | BoolKey = BoolKey(name='PBE0LDA', 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', 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.USEHP: BoolType | BoolKey = BoolKey(name='USEHP', 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)
[docs] class _AnalyticalFreq(FixedBlock):
r"""
Calculate the harmonic frequencies analytically
: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, raw_freq. 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. RAW_FREQ gives the eigenvalues of the initial force matrix, which are essentially the frequencies before rotational and translational degrees of freedom have been removed from the force matrix.
:vartype Print: str | StringKey
: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')
self.Print: str | StringKey = StringKey(name='Print', comment='Primarily for debugging purposes. Options: eigs, u1, parts, raw_freq. 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. RAW_FREQ gives the eigenvalues of the initial force matrix, which are essentially the frequencies before rotational and translational degrees of freedom have been removed from the force matrix.')
self.Test: str | StringKey = StringKey(name='Test', comment='Test COSMO')
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(FreeBlock):
r"""
Calculate aromaticity indicators, i.e. the matrix of localization/delocalization indices (LI-DI), Iring (ring index) and MCI (multi center index) aromaticity indices.
"""
def __post_init__(self):
pass
[docs] class _AtomProps(FreeBlock):
r"""
"""
def __post_init__(self):
pass
[docs] class _Atoms(FreeBlock):
r"""
Atomic positions
"""
def __post_init__(self):
pass
[docs] class _Basis(FreeBlock):
r"""
Not to be used. Use $ADFBIN/adf (NOT adf.exe!) to run this job
"""
def __post_init__(self):
pass
[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. Any input value is interpreted in the unit-of-length specified with the Units key
: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 BAND will automatically boost the radial grid by a factor 3 for the following numerically sensitive functionals: LibXC M05, LibXC M05-2X, LibXC M06-2X, LibXC M06-HF, LibXC M06-L, LibXC M08-HX, LibXC M08-SO, LibXC M11-L, LibXC MS0, LibXC MS1, LibXC MS2, LibXC MS2H, LibXC MVS, LibXC MVSH, LibXC N12, LibXC N12-SX, LibXC SOGGA11, LibXC SOGGA11-X, LibXC TH1, LibXC TH2, LibXC WB97, LibXC WB97X, MetaGGA M06L, MetaHybrid M06-2X, MetaHybrid M06-HF, MetaGGA MVS.
:vartype RadialGridBoost: float | FloatKey
:ivar AtomDepQuality: One can define a different grid quality for each atom.
:vartype AtomDepQuality: str | Sequence[str] | FreeBlock
"""
[docs] class _AtomDepQuality(FreeBlock):
r"""
One can define a different grid quality for each atom.
"""
def __post_init__(self):
pass
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. Any input value is interpreted in the unit-of-length specified with the Units key')
self.Quality: Literal["Auto", "Basic", "Normal", "Good", "VeryGood", "Excellent"] = MultipleChoiceKey(name='Quality', comment="Quality of the integration grid. For a description of the various qualities and the associated numerical accuracy see reference. If 'Auto', the quality defined in the 'NumericalQuality' will be used.", default='Auto', choices=['Auto', 'Basic', 'Normal', 'Good', 'VeryGood', 'Excellent'])
self.RadialGridBoost: float | FloatKey = FloatKey(name='RadialGridBoost', comment='The number of radial grid points will be boosted by this factor. Some XC functionals require very accurate radial integration grids, so BAND will automatically boost the radial grid by a factor 3 for the following numerically sensitive functionals: LibXC M05, LibXC M05-2X, LibXC M06-2X, LibXC M06-HF, LibXC M06-L, LibXC M08-HX, LibXC M08-SO, LibXC M11-L, LibXC MS0, LibXC MS1, LibXC MS2, LibXC MS2H, LibXC MVS, LibXC MVSH, LibXC N12, LibXC N12-SX, LibXC SOGGA11, LibXC SOGGA11-X, LibXC TH1, LibXC TH2, LibXC WB97, LibXC WB97X, MetaGGA M06L, MetaHybrid M06-2X, MetaHybrid M06-HF, MetaGGA MVS.')
self.AtomDepQuality: str | Sequence[str] | FreeBlock = self._AtomDepQuality(name='AtomDepQuality', comment='One can define a different grid quality for each atom.')
[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. EXCITEDCDFT has never been tested in closed-shell systems.
: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: metric parameter p, d and m that characterizes the quality of the XCDFT excitation.
: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. EXCITEDCDFT has never been tested in closed-shell systems.', 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='metric parameter p, d and m that characterizes the quality of the XCDFT excitation.', 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: PreAmsifiedADF._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: PreAmsifiedADF._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: PreAmsifiedADF._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: PreAmsifiedADF._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: PreAmsifiedADF._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: PreAmsifiedADF._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: PreAmsifiedADF._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: PreAmsifiedADF._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: PreAmsifiedADF._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: PreAmsifiedADF._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: PreAmsifiedADF._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: PreAmsifiedADF._ConceptualDFT._Domains = self._Domains(name='Domains', comment='Calculate integrated properties for the domains (same sign) of the dual descriptor.')
[docs] class _Constraints(FreeBlock):
r"""
"""
def __post_init__(self):
pass
[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"""
"""
def __post_init__(self):
pass
[docs] class _DIMQM(FreeBlock):
r"""
"""
def __post_init__(self):
pass
[docs] class _Dependency(FixedBlock):
r"""
: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).
: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.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. 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.', 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).', default=100000000.0)
self.fit: float | FloatKey = FloatKey(name='fit', comment='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. ', 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 Enabled: Calculate ESR (g- and/or A tensors)
:vartype Enabled: BoolType | BoolKey
"""
def __post_init__(self):
self.Enabled: BoolType | BoolKey = BoolKey(name='Enabled', comment='Calculate ESR (g- and/or A tensors)', default=False)
[docs] class _ETSNOCV(FixedBlock):
r"""
Perform ETS-NOCV analysis.
: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
"""
def __post_init__(self):
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)
[docs] class _ElectronTransfer(FixedBlock):
r"""
: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 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 CDSpectrum: Compute the rotatory strengths for the calculated excitations, in order to simulate Circular Dichroism (CD) spectra
:vartype CDSpectrum: 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 FullKernel: Use the non-ALDA kernel (with XCFUN)
:vartype FullKernel: BoolType | BoolKey
:ivar GTensor: MCD gtensor
:vartype GTensor: str | StringKey
: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 MCD: TODO: Magnetic Circular Dichroism
:vartype MCD: str | StringKey
:ivar NTO: Compute the Natural Transition Orbitals
:vartype NTO: BoolType | BoolKey
:ivar N_SFO: Number of SFO analyzed and printed
:vartype N_SFO: int | IntKey
: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 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 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
"""
[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
def __post_init__(self):
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.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.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.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.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', default=[10, 10])
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_SFO: int | IntKey = IntKey(name='N_SFO', comment='Number of SFO analyzed and printed', default=40)
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.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.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', 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)
[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: PreAmsifiedADF._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: PreAmsifiedADF._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 _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 CAPPOTDIIS: placeholder
:vartype CAPPOTDIIS: 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.CAPPOTDIIS: BoolType | BoolKey = BoolKey(name='CAPPOTDIIS', 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 _Fitnadkin(FreeBlock):
r"""
"""
def __post_init__(self):
pass
[docs] class _FragOccupations(FreeBlock):
r"""
"""
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 _GUIBonds(FreeBlock):
r"""
The bonds used by the GUI (this does not affect the ADF calculation in any way)
"""
def __post_init__(self):
pass
[docs] class _GeoVar(FreeBlock):
r"""
"""
def __post_init__(self):
pass
[docs] class _Geometry(FixedBlock):
r"""
Geometry Optimizations procedure
:ivar Branch: Code branch to be used.
:vartype Branch: Literal["New", "Old"]
:ivar CINEB: Climbing-Image Nudged Elastic Band
:vartype CINEB: int | IntKey
:ivar Constraints: Choice between enforcing constraints at each steps exactly or adding them to the optimization space as Lagrange multipliers.
:vartype Constraints: Literal["FullConverge", "PartialConverge"]
:ivar Externprogram:
:vartype Externprogram: str | StringKey
:ivar GEigenvalueThreshold: Threshold for delocalized coordinates singular value decomposition eigenvalues
:vartype GEigenvalueThreshold: float | FloatKey
:ivar GO: Just for compatibility. It is not actually parsed
:vartype GO: BoolType | BoolKey
:ivar GeoOpt: Just for compatibility. It is not actually parsed
:vartype GeoOpt: BoolType | BoolKey
:ivar HessUpd: Specifies how the Hessian matrix is updated, using the gradient values of the current and the previous geometry
:vartype HessUpd: Literal["Automatic", "BFGS", "MS", "DFP", "FS", "FARKAS", "FARKAS-BOFILL", "BOFILL", "HOSHINO", "POWELL", "BAKKEN-HELGAKER", "NONE"]
:ivar ImplicitHessianUpdate: Placeholder
:vartype ImplicitHessianUpdate: BoolType | BoolKey
:ivar InitHess: read a Hessian from a text files. The only argument is the name of the file containing the initial Hessian. The Hessian must be given in full, in non-mass-weighted Cartesian coordinates, and in atomic units.
:vartype InitHess: str | StringKey
:ivar Iterations: The maximum number of geometry iterations allowed to locate the desired structure. The default is max(30,2*Nfree), where Nfree is the number of free variables, which is typically close to 3*N(atoms).
:vartype Iterations: Iterable[int] | IntListKey
:ivar Lanczos: Transition state search
:vartype Lanczos: str | StringKey
:ivar LinearTransit: Linear transit
:vartype LinearTransit: int | IntKey
:ivar MBH: Mobile Block Hessian block names
:vartype MBH: str | StringKey
:ivar NEBOpt: Optimization type to use in NEB
:vartype NEBOpt: str | StringKey
:ivar NEBOptEnds: Optimize end points
:vartype NEBOptEnds: BoolType | BoolKey
:ivar NEBSpring:
:vartype NEBSpring: str | StringKey
:ivar Optim:
:vartype Optim: str | StringKey
:ivar QuasiNewton:
:vartype QuasiNewton: Literal["HighOrder", "Standard"]
:ivar SP: Single point
:vartype SP: BoolType | BoolKey
:ivar Vibron: Placeholder
:vartype Vibron: BoolType | BoolKey
:ivar Converge: Convergence criteria
:vartype Converge: PreAmsifiedADF._Geometry._Converge
:ivar DIIS: DIIS options
:vartype DIIS: PreAmsifiedADF._Geometry._DIIS
:ivar Frequencies: Calculation of frequencies via numerical differentiation
:vartype Frequencies: PreAmsifiedADF._Geometry._Frequencies
:ivar IRC: Intrinsic Reaction Coordinates
:vartype IRC: PreAmsifiedADF._Geometry._IRC
:ivar Step: Controls that changes in geometry from one cycle to another are not too large
:vartype Step: PreAmsifiedADF._Geometry._Step
:ivar TransitionState: Transition state search
:vartype TransitionState: PreAmsifiedADF._Geometry._TransitionState
"""
[docs] class _Converge(FixedBlock):
r"""
Convergence criteria
:ivar Angle: Refers to changes in bond- and dihedral angles, in degrees. This is only meaningful if optimization takes place in Z-matrix coordinates
:vartype Angle: float | FloatKey
:ivar E: The criterion for changes in the energy
:vartype E: float | FloatKey
:ivar Grad: The criterion for the nuclear gradients
:vartype Grad: float | FloatKey
:ivar Rad: Refers to changes in the Cartesian coordinates or bond lengths, depending on in what coordinates you optimize
:vartype Rad: float | FloatKey
"""
def __post_init__(self):
self.Angle: float | FloatKey = FloatKey(name='Angle', comment='Refers to changes in bond- and dihedral angles, in degrees. This is only meaningful if optimization takes place in Z-matrix coordinates', default=0.5, unit='Degree')
self.E: float | FloatKey = FloatKey(name='E', comment='The criterion for changes in the energy', default=0.001, unit='Hartree')
self.Grad: float | FloatKey = FloatKey(name='Grad', comment='The criterion for the nuclear gradients', default=0.001, unit='Hartree/Angstrom')
self.Rad: float | FloatKey = FloatKey(name='Rad', comment='Refers to changes in the Cartesian coordinates or bond lengths, depending on in what coordinates you optimize', default=0.01, unit='Angstrom')
[docs] class _DIIS(FixedBlock):
r"""
DIIS options
:ivar CYC: number of geometry cycles run before the DIIS starts to modify the geometry steps
:vartype CYC: int | IntKey
:ivar N: number of vectors used by the DIIS interpolation method
:vartype N: int | IntKey
"""
def __post_init__(self):
self.CYC: int | IntKey = IntKey(name='CYC', comment='number of geometry cycles run before the DIIS starts to modify the geometry steps', default=0)
self.N: int | IntKey = IntKey(name='N', comment='number of vectors used by the DIIS interpolation method', default=5)
[docs] class _Frequencies(FixedBlock):
r"""
Calculation of frequencies via numerical differentiation
:ivar Allowed: Another advantage of the symmetric displacements is that only a subset of frequencies can be calculated. The ALLOWED option requests computation of only IR-visible frequencies. This option is only useful for symmetric molecules where it can be a big time-saver.
:vartype Allowed: BoolType | BoolKey
:ivar DisAng: The displacements of the coordinates (angle)
:vartype DisAng: float | FloatKey
:ivar DisRad: The displacements of the coordinates (Cartesian and bond length)
:vartype DisRad: float | FloatKey
:ivar NoScan: Placeholder
:vartype NoScan: BoolType | BoolKey
:ivar NumDif: Must have the value between 1 and 4 and specifies the type of numerical differentiation that is applied to compute the force constants from gradients in slightly displaced geometries
:vartype NumDif: int | IntKey
:ivar ScanAll: Placeholder
:vartype ScanAll: BoolType | BoolKey
:ivar ScanRange: Placeholder
:vartype ScanRange: Iterable[float] | FloatListKey
:ivar Symm: Frequencies are calculated in symmetric displacements
:vartype Symm: BoolType | BoolKey
"""
def __post_init__(self):
self.Allowed: BoolType | BoolKey = BoolKey(name='Allowed', comment='Another advantage of the symmetric displacements is that only a subset of frequencies can be calculated. The ALLOWED option requests computation of only IR-visible frequencies. This option is only useful for symmetric molecules where it can be a big time-saver.', default=False)
self.DisAng: float | FloatKey = FloatKey(name='DisAng', comment='The displacements of the coordinates (angle)', default=1.0, unit='degrees')
self.DisRad: float | FloatKey = FloatKey(name='DisRad', comment='The displacements of the coordinates (Cartesian and bond length)', default=0.01, unit='Angstrom')
self.NoScan: BoolType | BoolKey = BoolKey(name='NoScan', comment='Placeholder', default=False)
self.NumDif: int | IntKey = IntKey(name='NumDif', comment='Must have the value between 1 and 4 and specifies the type of numerical differentiation that is applied to compute the force constants from gradients in slightly displaced geometries', default=2)
self.ScanAll: BoolType | BoolKey = BoolKey(name='ScanAll', comment='Placeholder', default=False)
self.ScanRange: Iterable[float] | FloatListKey = FloatListKey(name='ScanRange', comment='Placeholder', default=[-10000.0, 10000.0])
self.Symm: BoolType | BoolKey = BoolKey(name='Symm', comment='Frequencies are calculated in symmetric displacements', default=False)
[docs] class _IRC(FixedBlock):
r"""
Intrinsic Reaction Coordinates
:ivar Backward: Do backward path from the Transition State
:vartype Backward: BoolType | BoolKey
:ivar Barrier: lowerbound on barrier height
:vartype Barrier: float | FloatKey
:ivar Forward: Do forward path from the Transition State
:vartype Forward: BoolType | BoolKey
:ivar HessianEigenvector: Defines how the initial direction of the path is chosen to move away from the Transition State. It does not imply whether the first step along this direction is taken positively or negatively. See for this aspect the section about Forward/Backward IRC paths. The admissible values for start are: Grad: compute the gradient and take that direction right from the start. Obviously, if we start perfectly at the Transition State this will be meaningless since the gradient vanishes there completely. Read : the initial path direction is read in with the key IRCstart, see the section IRC Start Direction. Hess n : the initial path coincides with the n-th Hessian eigenvector (ordered by ascending eigenvalues); n must be an integer in the appropriate range. The default (omission of any start specification at all) is the first Hessian eigenvector, presumably corresponding to the path over the Transition State (negative Hessian eigenvalue!).
:vartype HessianEigenvector: int | IntKey
:ivar Points: The maximum number of IRC points computed in the run, for both paths together and including the initial (TS) central point (as far as applicable).
:vartype Points: int | IntKey
:ivar Start: Defines how the initial direction of the path is chosen to move away from the Transition State
:vartype Start: Literal["Hess", "Read", "Grad"]
:ivar Step: The (initial) step length when proceeding from one IRC point to another along the path.
:vartype Step: float | FloatKey
:ivar StepMax: The maximum step length that the program will select in the step-adjusting algorithm (the program will wither use the default or 10 times the initial step length, whichever is larger)
:vartype StepMax: float | FloatKey
:ivar StepMin: (the program will wither use the default or 0.3 times the initial step length, whichever is smaller)
:vartype StepMin: float | FloatKey
"""
def __post_init__(self):
self.Backward: BoolType | BoolKey = BoolKey(name='Backward', comment='Do backward path from the Transition State', default=True)
self.Barrier: float | FloatKey = FloatKey(name='Barrier', comment='lowerbound on barrier height', default=0.0, unit='kcal/mol')
self.Forward: BoolType | BoolKey = BoolKey(name='Forward', comment='Do forward path from the Transition State', default=True)
self.HessianEigenvector: int | IntKey = IntKey(name='HessianEigenvector', comment='Defines how the initial direction of the path is chosen to move away from the Transition State. It does not imply whether the first step along this direction is taken positively or negatively. See for this aspect the section about Forward/Backward IRC paths. The admissible values for start are: Grad: compute the gradient and take that direction right from the start. Obviously, if we start perfectly at the Transition State this will be meaningless since the gradient vanishes there completely. Read : the initial path direction is read in with the key IRCstart, see the section IRC Start Direction. Hess n : the initial path coincides with the n-th Hessian eigenvector (ordered by ascending eigenvalues); n must be an integer in the appropriate range. The default (omission of any start specification at all) is the first Hessian eigenvector, presumably corresponding to the path over the Transition State (negative Hessian eigenvalue!).', default=1)
self.Points: int | IntKey = IntKey(name='Points', comment='The maximum number of IRC points computed in the run, for both paths together and including the initial (TS) central point (as far as applicable).', default=100)
self.Start: Literal["Hess", "Read", "Grad"] = MultipleChoiceKey(name='Start', comment='Defines how the initial direction of the path is chosen to move away from the Transition State', default='Hess', choices=['Hess', 'Read', 'Grad'])
self.Step: float | FloatKey = FloatKey(name='Step', comment='The (initial) step length when proceeding from one IRC point to another along the path. ', default=0.2)
self.StepMax: float | FloatKey = FloatKey(name='StepMax', comment='The maximum step length that the program will select in the step-adjusting algorithm (the program will wither use the default or 10 times the initial step length, whichever is larger)', default=1.0)
self.StepMin: float | FloatKey = FloatKey(name='StepMin', comment='(the program will wither use the default or 0.3 times the initial step length, whichever is smaller)', default=0.03)
[docs] class _Step(FixedBlock):
r"""
Controls that changes in geometry from one cycle to another are not too large
:ivar Angle: Can only be used in combination with the old branch
:vartype Angle: float | FloatKey
:ivar Rad: Can only be used in combination with the old branch
:vartype Rad: float | FloatKey
:ivar TrustRadius: By default, the trust radius is set to 0.01 Bohr times the number of atoms with a minimum of 0.2 Bohr
:vartype TrustRadius: float | FloatKey
"""
def __post_init__(self):
self.Angle: float | FloatKey = FloatKey(name='Angle', comment='Can only be used in combination with the old branch', unit='Degree')
self.Rad: float | FloatKey = FloatKey(name='Rad', comment='Can only be used in combination with the old branch')
self.TrustRadius: float | FloatKey = FloatKey(name='TrustRadius', comment='By default, the trust radius is set to 0.01 Bohr times the number of atoms with a minimum of 0.2 Bohr', default=0.2, unit='Bohr')
[docs] class _TransitionState(FixedBlock):
r"""
Transition state search
:ivar LineSearchStep:
:vartype LineSearchStep: float | FloatKey
:ivar MinMode:
:vartype MinMode: BoolType | BoolKey
:ivar Mode: Which mode to follow
:vartype Mode: int | IntKey
"""
def __post_init__(self):
self.LineSearchStep: float | FloatKey = FloatKey(name='LineSearchStep', unit='Angstrom')
self.MinMode: BoolType | BoolKey = BoolKey(name='MinMode', default=False)
self.Mode: int | IntKey = IntKey(name='Mode', comment='Which mode to follow', default=0)
def __post_init__(self):
self.Branch: Literal["New", "Old"] = MultipleChoiceKey(name='Branch', comment='Code branch to be used.', choices=['New', 'Old'])
self.CINEB: int | IntKey = IntKey(name='CINEB', comment='Climbing-Image Nudged Elastic Band', default=8)
self.Constraints: Literal["FullConverge", "PartialConverge"] = MultipleChoiceKey(name='Constraints', comment='Choice between enforcing constraints at each steps exactly or adding them to the optimization space as Lagrange multipliers.', choices=['FullConverge', 'PartialConverge'])
self.Externprogram: str | StringKey = StringKey(name='Externprogram', unique=False)
self.GEigenvalueThreshold: float | FloatKey = FloatKey(name='GEigenvalueThreshold', comment='Threshold for delocalized coordinates singular value decomposition eigenvalues', default=1e-15)
self.GO: BoolType | BoolKey = BoolKey(name='GO', comment='Just for compatibility. It is not actually parsed')
self.GeoOpt: BoolType | BoolKey = BoolKey(name='GeoOpt', comment='Just for compatibility. It is not actually parsed')
self.HessUpd: Literal["Automatic", "BFGS", "MS", "DFP", "FS", "FARKAS", "FARKAS-BOFILL", "BOFILL", "HOSHINO", "POWELL", "BAKKEN-HELGAKER", "NONE"] = MultipleChoiceKey(name='HessUpd', comment='Specifies how the Hessian matrix is updated, using the gradient values of the current and the previous geometry', default='Automatic', choices=['Automatic', 'BFGS', 'MS', 'DFP', 'FS', 'FARKAS', 'FARKAS-BOFILL', 'BOFILL', 'HOSHINO', 'POWELL', 'BAKKEN-HELGAKER', 'NONE'])
self.ImplicitHessianUpdate: BoolType | BoolKey = BoolKey(name='ImplicitHessianUpdate', comment='Placeholder', default=False)
self.InitHess: str | StringKey = StringKey(name='InitHess', comment='read a Hessian from a text files. The only argument is the name of the file containing the initial Hessian. The Hessian must be given in full, in non-mass-weighted Cartesian coordinates, and in atomic units.')
self.Iterations: Iterable[int] | IntListKey = IntListKey(name='Iterations', comment='The maximum number of geometry iterations allowed to locate the desired structure. The default is max(30,2*Nfree), where Nfree is the number of free variables, which is typically close to 3*N(atoms).')
self.Lanczos: str | StringKey = StringKey(name='Lanczos', comment='Transition state search')
self.LinearTransit: int | IntKey = IntKey(name='LinearTransit', comment='Linear transit', default=5)
self.MBH: str | StringKey = StringKey(name='MBH', comment='Mobile Block Hessian block names')
self.NEBOpt: str | StringKey = StringKey(name='NEBOpt', comment='Optimization type to use in NEB', default='UNSPECIFIED')
self.NEBOptEnds: BoolType | BoolKey = BoolKey(name='NEBOptEnds', comment='Optimize end points', default=True)
self.NEBSpring: str | StringKey = StringKey(name='NEBSpring')
self.Optim: str | StringKey = StringKey(name='Optim', default='UNSPECIFIED')
self.QuasiNewton: Literal["HighOrder", "Standard"] = MultipleChoiceKey(name='QuasiNewton', default='Standard', choices=['HighOrder', 'Standard'])
self.SP: BoolType | BoolKey = BoolKey(name='SP', comment='Single point')
self.Vibron: BoolType | BoolKey = BoolKey(name='Vibron', comment='Placeholder', default=False)
self.Converge: PreAmsifiedADF._Geometry._Converge = self._Converge(name='Converge', comment='Convergence criteria')
self.DIIS: PreAmsifiedADF._Geometry._DIIS = self._DIIS(name='DIIS', comment='DIIS options')
self.Frequencies: PreAmsifiedADF._Geometry._Frequencies = self._Frequencies(name='Frequencies', comment='Calculation of frequencies via numerical differentiation')
self.IRC: PreAmsifiedADF._Geometry._IRC = self._IRC(name='IRC', comment='Intrinsic Reaction Coordinates')
self.Step: PreAmsifiedADF._Geometry._Step = self._Step(name='Step', comment='Controls that changes in geometry from one cycle to another are not too large')
self.TransitionState: PreAmsifiedADF._Geometry._TransitionState = self._TransitionState(name='TransitionState', comment='Transition state search')
[docs] class _HessDiag(FixedBlock):
r"""
Diagonal Hessian elements... Placeholder
:ivar Ang: Placeholder
:vartype Ang: float | FloatKey
:ivar Dih: Placeholder
:vartype Dih: float | FloatKey
:ivar Rad: Placeholder
:vartype Rad: float | FloatKey
"""
def __post_init__(self):
self.Ang: float | FloatKey = FloatKey(name='Ang', comment='Placeholder')
self.Dih: float | FloatKey = FloatKey(name='Dih', comment='Placeholder')
self.Rad: float | FloatKey = FloatKey(name='Rad', comment='Placeholder')
[docs] class _IQA(FixedBlock):
r"""
Bond 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.
If left empty, all atoms will be included.
:vartype AtomsToDo: Iterable[int] | IntListKey
:ivar Enabled: Calculate the bond 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["intra", "inter", "all"]
:ivar Print: For each atom pair, print energy terms:
Normal: total, covalent and ionic terms,
Verbose: all terms.
:vartype Print: Literal["Normal", "Verbose", "Debug"]
"""
def __post_init__(self):
self.Accuracy: float | FloatKey = FloatKey(name='Accuracy', comment='Placeholder', 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.\n\nIf left empty, all atoms will be included.', gui_name='Include atoms:', isatomlist=True)
self.Enabled: BoolType | BoolKey = BoolKey(name='Enabled', comment='Calculate the bond 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["intra", "inter", "all"] = MultipleChoiceKey(name='Interactions', comment='Placeholder', default='inter', choices=['intra', 'inter', 'all'])
self.Print: Literal["Normal", "Verbose", "Debug"] = MultipleChoiceKey(name='Print', comment='For each atom pair, print energy terms:\n\nNormal: total, covalent and ionic terms,\n\nVerbose: all terms.', default='Normal', choices=['Normal', 'Verbose', 'Debug'], hiddenchoices=['Debug'])
[docs] class _IRCStart(FreeBlock):
r"""
"""
def __post_init__(self):
pass
[docs] class _Integration(FreeBlock):
r"""
Options for the obsolete Voronoi numerical integration scheme
"""
def __post_init__(self):
pass
[docs] class _IrrepOccupations(FreeBlock):
r"""
Explicit occupation numbers per irrep
"""
def __post_init__(self):
pass
[docs] class _LinearConstraints(FreeBlock):
r"""
"""
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"""
"""
def __post_init__(self):
pass
[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 _MP2(FixedBlock):
r"""
Technical aspects of the MP2 algorithm.
:ivar Debug: Enable MP2 debug output.
:vartype Debug: BoolType | BoolKey
:ivar Enabled: Enable the calculation of the MP2 energy.
:vartype Enabled: BoolType | BoolKey
:ivar FitSetQuality: Specifies the fit set to be used in the MP2 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.
:vartype Formalism: Literal["Auto", "RI", "LT", "All"]
:ivar IntegrationQuality: Specifies the integration quality to be used in the MP2 calculation. If not specified, the RIHartreeFock%IntegrationQuality is used.
:vartype IntegrationQuality: Literal["VeryBasic", "Basic", "Normal", "Good", "VeryGood"]
:ivar Memory: If true, the more memory efficient variant of the algorithm is invoked (only implemented for SOS)
:vartype Memory: BoolType | BoolKey
:ivar MultipoleApproximation: If true, the multipole approximation for distant centers will be used.
:vartype MultipoleApproximation: BoolType | BoolKey
: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. This keyword is only meaningful when the LT formalism is used. If not specified, the RIHartreeFock%ThresholdQuality is used.
:vartype ThresholdQuality: Literal["VeryBasic", "Basic", "Normal", "Good", "VeryGood"]
:ivar ThresholdQualityHalf: Specifies the treshold for neglecting half-transformed fit coefficients. (only relevant if the LT formalism is used). In the AO-PARI-MP2 algorithm, fit coefficients are contracted with so-called pseudo density matrices. If all elements of the resulting half-transformed fitfunction tensor are smaller than the values specified with 'ThresholdQualityHalf', all following tensor-contractions with this tensor are not carried out. This keyword is only relevant for very large and spatially extended systems. A low value, i.e. 1.0E-6, can lead to a linear-scaling evaluation of the opposite-spin MP2 energy, but also results in rather inaccurate results.
:vartype ThresholdQualityHalf: float | FloatKey
:ivar ThresholdQualityHalfTimesC: Specifies the treshold for neglecting products of halt-transformed fit-coefficients with fitfunctions.
:vartype ThresholdQualityHalfTimesC: float | FloatKey
:ivar nLaplace: Number of laplace points (only relevant in case the Laplace Transformed (LT) formalism is used). Transforming the MP2 equations to the AO basis requires the numerical evaluation of an integral (often referred to as a Laplace transform). 9 points is a rather safe choice, guaranteeing for practically all systems a good accuracy. Only for systems with a very small HOMO-LUMO gap more points might be necessary. For many systems, 6 points are sufficient for good accuracy. The computation time of a AO-PARI-MP2 calculation scales linearly with the number of quadrature points. If the HOMO-LUMO gap approaches zero, it is possible that the algorithm determining the weights for the quadrature points does not converge. In these cases, the double-hybrid calculation is not meaningful anyway, as a non-zero HOMO-LUMO gap is required for accurate MP2 energies.
:vartype nLaplace: int | IntKey
"""
def __post_init__(self):
self.Debug: BoolType | BoolKey = BoolKey(name='Debug', comment='Enable MP2 debug output.', hidden=True, default=False)
self.Enabled: BoolType | BoolKey = BoolKey(name='Enabled', comment='Enable the calculation of the MP2 energy.', hidden=True, default=False)
self.FitSetQuality: Literal["Auto", "VeryBasic", "Basic", "Normal", "Good", "VeryGood"] = MultipleChoiceKey(name='FitSetQuality', comment="Specifies the fit set to be used in the MP2 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.", 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. '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.", default='Auto', choices=['Auto', 'RI', 'LT', 'All'])
self.IntegrationQuality: Literal["VeryBasic", "Basic", "Normal", "Good", "VeryGood"] = MultipleChoiceKey(name='IntegrationQuality', comment='Specifies the integration quality to be used in the MP2 calculation. If not specified, the RIHartreeFock%IntegrationQuality is used.', choices=['VeryBasic', 'Basic', 'Normal', 'Good', 'VeryGood'])
self.Memory: BoolType | BoolKey = BoolKey(name='Memory', comment='If true, the more memory efficient variant of the algorithm is invoked (only implemented for SOS)', hidden=True, default=False)
self.MultipoleApproximation: BoolType | BoolKey = BoolKey(name='MultipoleApproximation', comment='If true, the multipole approximation for distant centers will be used.', hidden=True, default=False)
self.ThresholdQuality: Literal["VeryBasic", "Basic", "Normal", "Good", "VeryGood"] = 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. This keyword is only meaningful when the LT formalism is used. If not specified, the RIHartreeFock%ThresholdQuality is used.", choices=['VeryBasic', 'Basic', 'Normal', 'Good', 'VeryGood'])
self.ThresholdQualityHalf: float | FloatKey = FloatKey(name='ThresholdQualityHalf', comment="Specifies the treshold for neglecting half-transformed fit coefficients. (only relevant if the LT formalism is used). In the AO-PARI-MP2 algorithm, fit coefficients are contracted with so-called pseudo density matrices. If all elements of the resulting half-transformed fitfunction tensor are smaller than the values specified with 'ThresholdQualityHalf', all following tensor-contractions with this tensor are not carried out. This keyword is only relevant for very large and spatially extended systems. A low value, i.e. 1.0E-6, can lead to a linear-scaling evaluation of the opposite-spin MP2 energy, but also results in rather inaccurate results.", default=1e-08)
self.ThresholdQualityHalfTimesC: float | FloatKey = FloatKey(name='ThresholdQualityHalfTimesC', comment='Specifies the treshold for neglecting products of halt-transformed fit-coefficients with fitfunctions.', default=1e-10)
self.nLaplace: int | IntKey = IntKey(name='nLaplace', comment='Number of laplace points (only relevant in case the Laplace Transformed (LT) formalism is used). Transforming the MP2 equations to the AO basis requires the numerical evaluation of an integral (often referred to as a Laplace transform). 9 points is a rather safe choice, guaranteeing for practically all systems a good accuracy. Only for systems with a very small HOMO-LUMO gap more points might be necessary. For many systems, 6 points are sufficient for good accuracy. The computation time of a AO-PARI-MP2 calculation scales linearly with the number of quadrature points. If the HOMO-LUMO gap approaches zero, it is possible that the algorithm determining the weights for the quadrature points does not converge. In these cases, the double-hybrid calculation is not meaningful anyway, as a non-zero HOMO-LUMO gap is required for accurate MP2 energies.', default=9)
[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"""
"""
def __post_init__(self):
pass
[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 _PointCharges(FreeBlock):
r"""
Point charges: {x y z q}
"""
def __post_init__(self):
pass
[docs] class _PolTDDFT(FixedBlock):
r"""
TODO!
: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: Keyword FREQRANGE is used to specify the equally spaced points in the spectrum for which one would like to calculate the complex dynamical polarizability. The first point is eVi (0 eV by default) and the last one is eVf (5 eV by default). The total number of points in the spectrum is nfreq (100 by default).
:vartype FreqRange: str | StringKey
: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 eVgrid (9 eV by default). Ngrid is the number of points within the energy grid (180 by default).
:vartype KGrid: str | StringKey
: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 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.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.', default=False)
self.FreqRange: str | StringKey = StringKey(name='FreqRange', comment='Keyword FREQRANGE is used to specify the equally spaced points in the spectrum for which one would like to calculate the complex dynamical polarizability. The first point is eVi (0 eV by default) and the last one is eVf (5 eV by default). The total number of points in the spectrum is nfreq (100 by default).')
self.KGrid: str | StringKey = StringKey(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 eVgrid (9 eV by default). Ngrid is the number of points within the energy grid (180 by default).')
self.Lambda: float | FloatKey = FloatKey(name='Lambda', comment="Jacob's scaling factor for the study of plasmonic resonances. This 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). 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.', default=0.1, unit='eV')
self.Velocity: BoolType | BoolKey = BoolKey(name='Velocity', comment='If True, ADF calculates the dipole moment in velocity gauge. If false: dipole-length representation is used', 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 _QMMM(FreeBlock):
r"""
"""
def __post_init__(self):
pass
[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 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.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 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, you might try setting the DependencyThreshold to a larger value (e.g. 3.0E-3)
:vartype DependencyThreshold: float | FloatKey
: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"]
: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 UseMe: Set to False if you want to use the old RI scheme
:vartype UseMe: BoolType | BoolKey
:ivar AtomDepQuality: One can define a different fit-set quality for each atom. The syntax for this free block is 'iAtom quality', where iAtom is the index of the atom in input order.
:vartype AtomDepQuality: str | Sequence[str] | FreeBlock
"""
[docs] class _AtomDepQuality(FreeBlock):
r"""
One can define a different fit-set quality for each atom. The syntax for this free block is 'iAtom quality', where iAtom is the index of the atom in input order.
"""
def __post_init__(self):
pass
def __post_init__(self):
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, you might try setting the DependencyThreshold to a larger value (e.g. 3.0E-3)', default=0.001)
self.FitSetQuality: Literal["Auto", "VeryBasic", "Basic", "Normal", "Good", "VeryGood", "Excellent"] = 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'])
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.UseMe: BoolType | BoolKey = BoolKey(name='UseMe', comment='Set to False if you want to use the old RI scheme', default=True)
self.AtomDepQuality: str | Sequence[str] | FreeBlock = self._AtomDepQuality(name='AtomDepQuality', comment="One can define a different fit-set quality for each atom. The syntax for this free block is 'iAtom quality', where iAtom is the index of the atom in input order.")
[docs] class _RISM(FreeBlock):
r"""
3D-RISM-related input keys.
"""
def __post_init__(self):
pass
[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 _RemoveFragOrbitals(FreeBlock):
r"""
"""
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 CONSTPOLYYN:
:vartype CONSTPOLYYN: float | FloatKey
: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 FRQBEG:
:vartype FRQBEG: float | FloatKey
:ivar FRQEND:
:vartype FRQEND: float | FloatKey
:ivar FXCALPHA:
:vartype FXCALPHA: float | FloatKey
:ivar FXCDRCONV:
:vartype FXCDRCONV: BoolType | BoolKey
:ivar FXCLB:
:vartype FXCLB: BoolType | BoolKey
:ivar GXCALPHA:
:vartype GXCALPHA: float | FloatKey
:ivar Hartree:
:vartype Hartree: BoolType | BoolKey
: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 LINVXCCONST:
:vartype LINVXCCONST: float | FloatKey
:ivar MAGNETICPERT:
:vartype MAGNETICPERT: BoolType | BoolKey
:ivar MAXWAALS:
:vartype MAXWAALS: int | IntKey
:ivar NCycMx:
:vartype NCycMx: int | IntKey
:ivar NFreq:
:vartype NFreq: int | IntKey
:ivar NOFXCDR:
:vartype NOFXCDR: BoolType | BoolKey
: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.CONSTPOLYYN: float | FloatKey = FloatKey(name='CONSTPOLYYN', default=0.006)
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.FRQBEG: float | FloatKey = FloatKey(name='FRQBEG', default=0.0, unit='eV')
self.FRQEND: float | FloatKey = FloatKey(name='FRQEND', default=0.0, unit='eV')
self.FXCALPHA: float | FloatKey = FloatKey(name='FXCALPHA')
self.FXCDRCONV: BoolType | BoolKey = BoolKey(name='FXCDRCONV')
self.FXCLB: BoolType | BoolKey = BoolKey(name='FXCLB')
self.GXCALPHA: float | FloatKey = FloatKey(name='GXCALPHA')
self.Hartree: BoolType | BoolKey = BoolKey(name='Hartree')
self.HyperPol: float | FloatKey = FloatKey(name='HyperPol')
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.LINVXCCONST: float | FloatKey = FloatKey(name='LINVXCCONST', default=0.4)
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.NFreq: int | IntKey = IntKey(name='NFreq', default=1)
self.NOFXCDR: BoolType | BoolKey = BoolKey(name='NOFXCDR')
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 File: The name of a file with restart data. The path (absolute or relative) to the file must be included if the file is not local to the directory where the calculation executes.
:vartype File: str | StringKey
:ivar NoExc: Do not use any Excitation data from the restart file.
:vartype NoExc: BoolType | BoolKey
:ivar NoGeo: Do not use the geometry - Cartesian, Z-matrix, etc. coordinates - from the restart file
:vartype NoGeo: BoolType | BoolKey
:ivar NoHes: Do not use any Hessian from the restart file.
:vartype NoHes: BoolType | BoolKey
: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: Indices of atoms in for which the flipping will be performed
:vartype SpinFlip: Iterable[int] | IntListKey
"""
def __post_init__(self):
self.File: str | StringKey = StringKey(name='File', comment='The name of a file with restart data. The path (absolute or relative) to the file must be included if the file is not local to the directory where the calculation executes.')
self.NoExc: BoolType | BoolKey = BoolKey(name='NoExc', comment='Do not use any Excitation data from the restart file.', default=False)
self.NoGeo: BoolType | BoolKey = BoolKey(name='NoGeo', comment='Do not use the geometry - Cartesian, Z-matrix, etc. coordinates - from the restart file', default=False)
self.NoHes: BoolType | BoolKey = BoolKey(name='NoHes', comment='Do not use any Hessian from the restart file.', default=False)
self.NoOrb: BoolType | BoolKey = BoolKey(name='NoOrb', comment='Do not use orbitals from the restart file', 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.', default=False)
self.NoSmear: BoolType | BoolKey = BoolKey(name='NoSmear', comment='Do not use any electron smearing data from the restart file.', default=False)
self.SpinFlip: Iterable[int] | IntListKey = IntListKey(name='SpinFlip', comment='Indices of atoms in for which the flipping will be performed')
[docs] class _Restraint(FreeBlock):
r"""
"""
def __post_init__(self):
pass
[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.
:vartype ScalableSO: BoolType | BoolKey
:ivar ADIIS: Settings for the ADIIS method.
:vartype ADIIS: PreAmsifiedADF._SCF._ADIIS
:ivar ARH: The Augmented Roothaan-Hall method has been developed by T. Helgaker and coworkers.
:vartype ARH: PreAmsifiedADF._SCF._ARH
:ivar DIIS: The maximum number of SCF cycles allowed.
:vartype DIIS: PreAmsifiedADF._SCF._DIIS
"""
[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)
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.', default=True)
self.ScalableSO: BoolType | BoolKey = BoolKey(name='ScalableSO', comment='Use new scalable scf.', default=True)
self.ADIIS: PreAmsifiedADF._SCF._ADIIS = self._ADIIS(name='ADIIS', comment='Settings for the ADIIS method.', hidden=True)
self.ARH: PreAmsifiedADF._SCF._ARH = self._ARH(name='ARH', comment='The Augmented Roothaan-Hall method has been developed by T. Helgaker and coworkers.', hidden=True)
self.DIIS: PreAmsifiedADF._SCF._DIIS = self._DIIS(name='DIIS', comment='The maximum number of SCF cycles allowed.')
[docs] class _SCRF(FreeBlock):
r"""
"""
def __post_init__(self):
pass
[docs] class _SICOEP(FreeBlock):
r"""
"""
def __post_init__(self):
pass
[docs] class _SOPert(FixedBlock):
r"""
:ivar EShift:
:vartype EShift: float | FloatKey
:ivar NCalc:
:vartype NCalc: int | IntKey
"""
def __post_init__(self):
self.EShift: float | FloatKey = FloatKey(name='EShift')
self.NCalc: int | IntKey = IntKey(name='NCalc')
[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"""
"""
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 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.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 _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 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.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 _TSRC(FreeBlock):
r"""
Transition State Reaction Coordinate (TSRC)
"""
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 _Thermo(FixedBlock):
r"""
At the end of a completed Frequencies calculation, a survey is given of thermodynamic properties: Heat Capacity, Internal Energy, Entropy. The computed results assume an ideal gas, and electronic contributions are ignored. The latter is a serious omission if the electronic configuration is (almost) degenerate, but the effect is small whenever the energy difference with the next state is large compared to the vibrational frequencies
:ivar P: The Pressure. A zero or negative pressure is adjusted by the program to a (very) small number 1e-4
:vartype P: float | FloatKey
:ivar TMax: Maximum temperature for the temperature range.
:vartype TMax: float | FloatKey
:ivar TMin: Minimum temperature for the temperature range.
:vartype TMin: float | FloatKey
:ivar nT: The number of steps by which the temperature interval is scanned.
By default (value 0) it is computed by the program from the temperature range (TMin, Tmax), such that the step size is as close as possible to 10 K. Note that the number of temperatures for which the calculations are done is one more than the number of temperature steps.
:vartype nT: int | IntKey
"""
def __post_init__(self):
self.P: float | FloatKey = FloatKey(name='P', comment='The Pressure. A zero or negative pressure is adjusted by the program to a (very) small number 1e-4', default=1.0, unit='atm')
self.TMax: float | FloatKey = FloatKey(name='TMax', comment='Maximum temperature for the temperature range.', default=298.15, unit='Kelvin')
self.TMin: float | FloatKey = FloatKey(name='TMin', comment='Minimum temperature for the temperature range.', default=298.15, unit='Kelvin')
self.nT: int | IntKey = IntKey(name='nT', comment='The number of steps by which the temperature interval is scanned.\n\nBy default (value 0) it is computed by the program from the temperature range (TMin, Tmax), such that the step size is as close as possible to 10 K. Note that the number of temperatures for which the calculations are done is one more than the number of temperature steps.', default=0)
[docs] class _Units(FixedBlock):
r"""
Definitions of the units.
:ivar angle: Units of angles
:vartype angle: Literal["degree", "radian"]
:ivar length: Units of length
:vartype length: Literal["bohr", "angstrom"]
"""
def __post_init__(self):
self.angle: Literal["degree", "radian"] = MultipleChoiceKey(name='angle', comment='Units of angles', choices=['degree', 'radian'])
self.length: Literal["bohr", "angstrom"] = MultipleChoiceKey(name='length', comment='Units of length', default='angstrom', choices=['bohr', 'angstrom'])
[docs] class _VSCRF(FreeBlock):
r"""
"""
def __post_init__(self):
pass
[docs] class _Vibron(FixedBlock):
r"""
Resonance Raman Input options
:ivar CALCCC: use ADF routines to calculate coupling constants (they only work for the linear coupling constants)
:vartype CALCCC: BoolType | BoolKey
:ivar CBTAPE:
:vartype CBTAPE: str | StringKey
:ivar CDVIBRON: CD spectra calculations
:vartype CDVIBRON: BoolType | BoolKey
:ivar CGRAD: calculate ground-state gradients in VIBRON runs
:vartype CGRAD: BoolType | BoolKey
:ivar DISPTYPE: default type of displacement
:vartype DISPTYPE: str | StringKey
:ivar DOMODES:
:vartype DOMODES: Iterable[int] | IntListKey
:ivar DONTMODES:
:vartype DONTMODES: Iterable[int] | IntListKey
:ivar DONTSTEPS:
:vartype DONTSTEPS: Iterable[int] | IntListKey
:ivar DOSTEPS:
:vartype DOSTEPS: Iterable[int] | IntListKey
:ivar DSCHEME: default diabatizing scheme
:vartype DSCHEME: str | StringKey
:ivar ELTHRES: lower boundary for excitation energy
:vartype ELTHRES: float | FloatKey
:ivar EUTHRES: upper boundary for excitation energy
:vartype EUTHRES: float | FloatKey
:ivar EXTAPE: excited state symmetry information input file
:vartype EXTAPE: str | StringKey
:ivar HARMGR: use harmonic approximation for ground state energy
:vartype HARMGR: BoolType | BoolKey
:ivar IGNORECHECK: ignore safety checks
:vartype IGNORECHECK: BoolType | BoolKey
:ivar NDTYPE: by default, always use 3-point central differences (i.e. two sided), but only compute linear couplings
:vartype NDTYPE: int | IntKey
:ivar NMTape: It specifies the name of a TAPE21 file from a previous frequency calculation. This TAPE21 file is needed to read the normal modes w.r.t. which the derivatives are computed. I.e., a separate frequency calculation must be carried out first.
:vartype NMTape: str | StringKey
:ivar NOINV: inversion of initial sadiab
:vartype NOINV: BoolType | BoolKey
:ivar NOTONLYSYM:
:vartype NOTONLYSYM: BoolType | BoolKey
:ivar NSTEPSC: Number of steps for PES scans
:vartype NSTEPSC: int | IntKey
:ivar ONLYSYM: calculate displacements along symmetric modes
:vartype ONLYSYM: BoolType | BoolKey
:ivar PDEBUG:
:vartype PDEBUG: BoolType | BoolKey
:ivar PESCAN:
:vartype PESCAN: Iterable[int] | IntListKey
:ivar PURIFY: purify excitation energies for excited states (leads to errors for non-totally symmetric modes in degenerate systems)
:vartype PURIFY: BoolType | BoolKey
:ivar RESRAMAN: perform resonance Raman calculations
:vartype RESRAMAN: BoolType | BoolKey
:ivar SAVERAWDAT:
:vartype SAVERAWDAT: int | IntKey
:ivar SAVEREFAO: save reference AO vectors
:vartype SAVEREFAO: BoolType | BoolKey
:ivar STOPAT: debug option: stop at a particular geometry step
:vartype STOPAT: int | IntKey
:ivar STPSIZE: Step size for numerical differentiation
:vartype STPSIZE: float | FloatKey
:ivar SelState: For advanced users it is furthermore possible to pick out certain states from the energy window, and only perform the mapping (and diabatization, if requested) and differentiation for them. Here list includes the number (in ascending excitation energy) of the excited state at the reference (equilibrium) structure.
:vartype SelState: Iterable[int] | IntListKey
:ivar TRANSDEF: use transpose definition of overlap matrix
:vartype TRANSDEF: BoolType | BoolKey
:ivar USERAWDAT:
:vartype USERAWDAT: BoolType | BoolKey
:ivar WINTREAT: do not increase energy window upon change of state no.
:vartype WINTREAT: str | StringKey
:ivar WRTMAG:
:vartype WRTMAG: BoolType | BoolKey
:ivar EShift: Empirical vertical shifts for the excitation energies
:vartype EShift: str | Sequence[str] | FreeBlock
:ivar UsSym: user-specified symmetry of excited states (at reference geometry)
:vartype UsSym: str | Sequence[str] | FreeBlock
"""
[docs] class _EShift(FreeBlock):
r"""
Empirical vertical shifts for the excitation energies
"""
def __post_init__(self):
pass
[docs] class _UsSym(FreeBlock):
r"""
user-specified symmetry of excited states (at reference geometry)
"""
def __post_init__(self):
pass
def __post_init__(self):
self.CALCCC: BoolType | BoolKey = BoolKey(name='CALCCC', comment='use ADF routines to calculate coupling constants (they only work for the linear coupling constants)', default=False)
self.CBTAPE: str | StringKey = StringKey(name='CBTAPE')
self.CDVIBRON: BoolType | BoolKey = BoolKey(name='CDVIBRON', comment='CD spectra calculations', default=False)
self.CGRAD: BoolType | BoolKey = BoolKey(name='CGRAD', comment='calculate ground-state gradients in VIBRON runs', default=False)
self.DISPTYPE: str | StringKey = StringKey(name='DISPTYPE', comment='default type of displacement', default='MASSWE')
self.DOMODES: Iterable[int] | IntListKey = IntListKey(name='DOMODES')
self.DONTMODES: Iterable[int] | IntListKey = IntListKey(name='DONTMODES')
self.DONTSTEPS: Iterable[int] | IntListKey = IntListKey(name='DONTSTEPS')
self.DOSTEPS: Iterable[int] | IntListKey = IntListKey(name='DOSTEPS')
self.DSCHEME: str | StringKey = StringKey(name='DSCHEME', comment='default diabatizing scheme', default='EIGVEC')
self.ELTHRES: float | FloatKey = FloatKey(name='ELTHRES', comment='lower boundary for excitation energy', default=0.0)
self.EUTHRES: float | FloatKey = FloatKey(name='EUTHRES', comment='upper boundary for excitation energy', default=10000000000.0)
self.EXTAPE: str | StringKey = StringKey(name='EXTAPE', comment='excited state symmetry information input file', default='UNKNOWN')
self.HARMGR: BoolType | BoolKey = BoolKey(name='HARMGR', comment='use harmonic approximation for ground state energy', default=False)
self.IGNORECHECK: BoolType | BoolKey = BoolKey(name='IGNORECHECK', comment='ignore safety checks', default=False)
self.NDTYPE: int | IntKey = IntKey(name='NDTYPE', comment='by default, always use 3-point central differences (i.e. two sided), but only compute linear couplings', default=2)
self.NMTape: str | StringKey = StringKey(name='NMTape', comment='It specifies the name of a TAPE21 file from a previous frequency calculation. This TAPE21 file is needed to read the normal modes w.r.t. which the derivatives are computed. I.e., a separate frequency calculation must be carried out first.', default='UNKNOWN')
self.NOINV: BoolType | BoolKey = BoolKey(name='NOINV', comment='inversion of initial sadiab', default=False)
self.NOTONLYSYM: BoolType | BoolKey = BoolKey(name='NOTONLYSYM', default=False)
self.NSTEPSC: int | IntKey = IntKey(name='NSTEPSC', comment='Number of steps for PES scans', default=1)
self.ONLYSYM: BoolType | BoolKey = BoolKey(name='ONLYSYM', comment='calculate displacements along symmetric modes', default=False)
self.PDEBUG: BoolType | BoolKey = BoolKey(name='PDEBUG', default=False)
self.PESCAN: Iterable[int] | IntListKey = IntListKey(name='PESCAN')
self.PURIFY: BoolType | BoolKey = BoolKey(name='PURIFY', comment='purify excitation energies for excited states (leads to errors for non-totally symmetric modes in degenerate systems)', default=False)
self.RESRAMAN: BoolType | BoolKey = BoolKey(name='RESRAMAN', comment='perform resonance Raman calculations', default=False)
self.SAVERAWDAT: int | IntKey = IntKey(name='SAVERAWDAT', default=0)
self.SAVEREFAO: BoolType | BoolKey = BoolKey(name='SAVEREFAO', comment='save reference AO vectors', default=False)
self.STOPAT: int | IntKey = IntKey(name='STOPAT', comment='debug option: stop at a particular geometry step', default=-1)
self.STPSIZE: float | FloatKey = FloatKey(name='STPSIZE', comment='Step size for numerical differentiation', default=0.1)
self.SelState: Iterable[int] | IntListKey = IntListKey(name='SelState', comment='For advanced users it is furthermore possible to pick out certain states from the energy window, and only perform the mapping (and diabatization, if requested) and differentiation for them. Here list includes the number (in ascending excitation energy) of the excited state at the reference (equilibrium) structure.')
self.TRANSDEF: BoolType | BoolKey = BoolKey(name='TRANSDEF', comment='use transpose definition of overlap matrix', default=False)
self.USERAWDAT: BoolType | BoolKey = BoolKey(name='USERAWDAT', default=False)
self.WINTREAT: str | StringKey = StringKey(name='WINTREAT', comment='do not increase energy window upon change of state no.', default='KEEPNO')
self.WRTMAG: BoolType | BoolKey = BoolKey(name='WRTMAG', default=False)
self.EShift: str | Sequence[str] | FreeBlock = self._EShift(name='EShift', comment='Empirical vertical shifts for the excitation energies')
self.UsSym: str | Sequence[str] | FreeBlock = self._UsSym(name='UsSym', comment='user-specified symmetry of excited states (at reference geometry)')
[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 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 RangeSep: Range separated hybrids parameters
:vartype RangeSep: str | StringKey
:ivar XCFun: Use the XCFun library
:vartype XCFun: BoolType | BoolKey
"""
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.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.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)
[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 ADFinput 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 ADFinput 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 AtomDepQuality: One can specify different ZlmFit-quality for different atoms, The syntax for this free block is 'iAtom quality', where iAtom is the index of the atom in input order. For the atoms that are not present in the AtomDepQuality sub-block, the quality defined in the Quality key will be used.
:vartype AtomDepQuality: str | Sequence[str] | FreeBlock
"""
[docs] class _AtomDepQuality(FreeBlock):
r"""
One can specify different ZlmFit-quality for different atoms, The syntax for this free block is 'iAtom quality', where iAtom is the index of the atom in input order. For the atoms that are not present in the AtomDepQuality sub-block, the quality defined in the Quality key will be used.
"""
def __post_init__(self):
pass
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.AtomDepQuality: str | Sequence[str] | FreeBlock = self._AtomDepQuality(name='AtomDepQuality', comment="One can specify different ZlmFit-quality for different atoms, The syntax for this free block is 'iAtom quality', where iAtom is the index of the atom in input order. For the atoms that are not present in the AtomDepQuality sub-block, the quality defined in the Quality key will be used.")
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)
self.AORCOnly: BoolType | BoolKey = BoolKey(name='AORCOnly', default=False)
self.AORXCOnly: BoolType | BoolKey = BoolKey(name='AORXCOnly', default=False)
self.AORun: BoolType | BoolKey = BoolKey(name='AORun', default=False)
self.AccurateGradients: BoolType | BoolKey = BoolKey(name='AccurateGradients', comment='Print the nuclear gradients with more digits than usual.', default=False)
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)
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)
self.AllWaals: BoolType | BoolKey = BoolKey(name='AllWaals', default=False)
self.Allow: str | StringKey = StringKey(name='Allow', comment=' ', unique=False)
self.AltLinVXC: BoolType | BoolKey = BoolKey(name='AltLinVXC', default=False)
self.AltOrthon: BoolType | BoolKey = BoolKey(name='AltOrthon', default=False)
self.AltRhof: BoolType | BoolKey = BoolKey(name='AltRhof', default=False)
self.AnaPol: BoolType | BoolKey = BoolKey(name='AnaPol', default=False)
self.Balance: BoolType | BoolKey = BoolKey(name='Balance', comment='Measure the actual speed of the nodes in the parallel machine', default=False)
self.BasValZero: BoolType | BoolKey = BoolKey(name='BasValZero', comment='Debug option', default=False)
self.Blapt: BoolType | BoolKey = BoolKey(name='Blapt', default=False)
self.BondOrder: str | StringKey = StringKey(name='BondOrder')
self.BoySold: BoolType | BoolKey = BoolKey(name='BoySold', default=False)
self.C2Coef: BoolType | BoolKey = BoolKey(name='C2Coef', comment='Print C2Coef to output', default=False)
self.CDataFile: str | StringKey = StringKey(name='CDataFile', comment='Untested and undocumented')
self.CM5: BoolType | BoolKey = BoolKey(name='CM5', comment='Calculate the charge model 5 (CM5) analysis.', gui_name=': CM5 charges', default=False)
self.CRDFilemol: str | StringKey = StringKey(name='CRDFilemol', comment='Untested and undocumented')
self.CRDFilemopac: str | StringKey = StringKey(name='CRDFilemopac', comment='Untested and undocumented')
self.CRDFilexyz: str | StringKey = StringKey(name='CRDFilexyz', comment='Untested and undocumented')
self.CalcOverlapOnly: BoolType | BoolKey = BoolKey(name='CalcOverlapOnly', comment='Calculate overlaps of primitive basis and stops after computing them.', default=False)
self.CalcTotalEnergy: BoolType | BoolKey = BoolKey(name='CalcTotalEnergy', comment='Whether or not to calculate the total energy.', default=False)
self.Charge: Iterable[float] | FloatListKey = FloatListKey(name='Charge', comment='Controls the net charge of the molecule and the net spin polarization. First number: The net total charge of the molecule, Second number: The net total spin polarization: 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.', default=[0.0, 0.0])
self.ChkDisFal: BoolType | BoolKey = BoolKey(name='ChkDisFal', default=False)
self.ColTDDFT: BoolType | BoolKey = BoolKey(name='ColTDDFT', default=False)
self.Collinear: BoolType | BoolKey = BoolKey(name='Collinear', comment='Use collinear approximation (only relevant in the case of Spin-Orbit coupling).', default=False)
self.CommTiming: BoolType | BoolKey = BoolKey(name='CommTiming', default=False)
self.ComplexAcl: BoolType | BoolKey = BoolKey(name='ComplexAcl', default=False)
self.CoreTables: BoolType | BoolKey = BoolKey(name='CoreTables', default=False)
self.CoulombFit: BoolType | BoolKey = BoolKey(name='CoulombFit', default=False)
self.Create: str | StringKey = StringKey(name='Create', comment='Keywords for create run. {Atomtype Datafile}')
self.DFTBParams: BoolType | BoolKey = BoolKey(name='DFTBParams', default=False)
self.DRho241: BoolType | BoolKey = BoolKey(name='DRho241', default=False)
self.Database: str | StringKey = StringKey(name='Database', comment='Untested and undocumented')
self.Debug: str | StringKey = StringKey(name='Debug', unique=False)
self.DeltaEpStrip: BoolType | BoolKey = BoolKey(name='DeltaEpStrip', default=False)
self.DensPrep: BoolType | BoolKey = BoolKey(name='DensPrep', default=False)
self.Diffuse: BoolType | BoolKey = BoolKey(name='Diffuse', default=False)
self.DipoleLength: BoolType | BoolKey = BoolKey(name='DipoleLength', comment='Use dipole-length elements for perturbing (external) integrals in CURRENT response', default=False)
self.DipoleResponse: BoolType | BoolKey = BoolKey(name='DipoleResponse', default=False)
self.EField: str | StringKey = StringKey(name='EField', comment='Electric field.', unit='Hartree / (e * Bohr)')
self.EGOXAlpha: BoolType | BoolKey = BoolKey(name='EGOXAlpha', default=False)
self.EnergyTest: BoolType | BoolKey = BoolKey(name='EnergyTest', default=False)
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.ExtendPopAn: BoolType | BoolKey = BoolKey(name='ExtendPopAn', 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=': Mayer bond orders', default=False)
self.FitAlfa: BoolType | BoolKey = BoolKey(name='FitAlfa', default=False)
self.FitExcit: BoolType | BoolKey = BoolKey(name='FitExcit', default=False)
self.FitFile: str | StringKey = StringKey(name='FitFile')
self.Fitelstat: BoolType | BoolKey = BoolKey(name='Fitelstat', default=False)
self.Fithyppol: BoolType | BoolKey = BoolKey(name='Fithyppol', default=False)
self.Fitmeta: BoolType | BoolKey = BoolKey(name='Fitmeta', default=False)
self.Fitsecder: BoolType | BoolKey = BoolKey(name='Fitsecder', default=False)
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)
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)
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)
self.FullSCF: BoolType | BoolKey = BoolKey(name='FullSCF', default=False)
self.FullTotEn: BoolType | BoolKey = BoolKey(name='FullTotEn', default=False)
self.Fuzzy_BO: BoolType | BoolKey = BoolKey(name='Fuzzy_BO', default=False)
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.', default=False)
self.GZip: str | StringKey = StringKey(name='GZip', comment='GZip the corresponding tape (possibly working only for TAPE21)')
self.GaugeOrigin: Iterable[float] | FloatListKey = FloatListKey(name='GaugeOrigin', comment='Untested and undocumented')
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.', gui_name='Calculate: Gradients', default=False)
self.HFAtomsPerPass: int | IntKey = IntKey(name='HFAtomsPerPass', comment='Memory usage option for old HF scheme')
self.HFDependency: BoolType | BoolKey = BoolKey(name='HFDependency', comment='Untested and undocumented', 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)
self.HessTest: BoolType | BoolKey = BoolKey(name='HessTest', comment='Print the force field derived initial Hessian.', default=False)
self.Hilbert: BoolType | BoolKey = BoolKey(name='Hilbert', default=False)
self.IgnoreOverlap: BoolType | BoolKey = BoolKey(name='IgnoreOverlap', default=False)
self.ImportEmbPot: str | StringKey = StringKey(name='ImportEmbPot', comment='File containing an external embedding potential (FDE calculations only)')
self.ImportGrid: str | StringKey = StringKey(name='ImportGrid')
self.IsotopicShift: str | StringKey = StringKey(name='IsotopicShift', comment='Untested')
self.KSSpectrum: BoolType | BoolKey = BoolKey(name='KSSpectrum', default=False)
self.LB4: BoolType | BoolKey = BoolKey(name='LB4', default=False)
self.Lap1: BoolType | BoolKey = BoolKey(name='Lap1', default=False)
self.LinTermVXC: BoolType | BoolKey = BoolKey(name='LinTermVXC', default=False)
self.MBlockBig: BoolType | BoolKey = BoolKey(name='MBlockBig', default=False)
self.MBlockSmall: BoolType | BoolKey = BoolKey(name='MBlockSmall', default=False)
self.MOExactDensity: BoolType | BoolKey = BoolKey(name='MOExactDensity', default=False)
self.MetaGGA: BoolType | BoolKey = BoolKey(name='MetaGGA', default=False)
self.NewDIIS: BoolType | BoolKey = BoolKey(name='NewDIIS', default=False)
self.NoBeckeGrid: BoolType | BoolKey = BoolKey(name='NoBeckeGrid', default=False)
self.NoESRfcsd: BoolType | BoolKey = BoolKey(name='NoESRfcsd', default=False)
self.NoESRpso: BoolType | BoolKey = BoolKey(name='NoESRpso', default=False)
self.NoFDEPot: BoolType | BoolKey = BoolKey(name='NoFDEPot', default=False)
self.NoFragDp: BoolType | BoolKey = BoolKey(name='NoFragDp', default=False)
self.NoGTerm: BoolType | BoolKey = BoolKey(name='NoGTerm', default=False)
self.NoPrint: str | StringKey = StringKey(name='NoPrint', unique=False)
self.NoSharedArrays: BoolType | BoolKey = BoolKey(name='NoSharedArrays', default=False)
self.NoSymFit: BoolType | BoolKey = BoolKey(name='NoSymFit', default=False)
self.NoTotEn: BoolType | BoolKey = BoolKey(name='NoTotEn', default=False)
self.NoUpdFac: BoolType | BoolKey = BoolKey(name='NoUpdFac', default=False)
self.NonCollinear: BoolType | BoolKey = BoolKey(name='NonCollinear', comment='Use non-collinear approximation (only relevant in the case of Spin-Orbit coupling).', default=False)
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 some elements you can find these in the ZORA/jcpl 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')
self.Occupations: str | StringKey = StringKey(name='Occupations', comment='Occupations options')
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)
self.OrthFragPrep: BoolType | BoolKey = BoolKey(name='OrthFragPrep', default=False)
self.PartialZORA: str | StringKey = StringKey(name='PartialZORA', comment='Untested and undocumented')
self.Print: str | StringKey = StringKey(name='Print', unique=False)
self.ProgConv: BoolType | BoolKey = BoolKey(name='ProgConv', default=True)
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)
self.RConfine: Iterable[float] | FloatListKey = FloatListKey(name='RConfine', comment='Untested and undocumented')
self.RESTOCC: BoolType | BoolKey = BoolKey(name='RESTOCC', default=False)
self.RamanRange: str | StringKey = StringKey(name='RamanRange')
self.ReducedMass: BoolType | BoolKey = BoolKey(name='ReducedMass', comment='Print reduced mass for each normal mode', default=False)
self.Relativistic: str | StringKey = StringKey(name='Relativistic', comment='instructs ADF to take relativistic effects into account.')
self.RemoveAllFragVirtuals: BoolType | BoolKey = BoolKey(name='RemoveAllFragVirtuals', default=False)
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)
self.SOMCD: BoolType | BoolKey = BoolKey(name='SOMCD', default=False)
self.SOUExact: BoolType | BoolKey = BoolKey(name='SOUExact', default=False)
self.STContrib: BoolType | BoolKey = BoolKey(name='STContrib', default=False)
self.STOFit: BoolType | BoolKey = BoolKey(name='STOFit', default=False)
self.Save: str | StringKey = StringKey(name='Save', unique=False)
self.ScanFreq: str | StringKey = StringKey(name='ScanFreq')
self.SharcOverlap: BoolType | BoolKey = BoolKey(name='SharcOverlap', default=False)
self.Skip: str | StringKey = StringKey(name='Skip', unique=False)
self.StopAfter: str | StringKey = StringKey(name='StopAfter')
self.Symmetry: str | StringKey = StringKey(name='Symmetry', comment='The Schonfliess symmetry symbol. A tolerance can be supplied.')
self.TDA: BoolType | BoolKey = BoolKey(name='TDA', comment='Use the Tamm-Dancoff approximation (TDA) (requires the EXCITATION block key)', default=False)
self.TDDFTSO: BoolType | BoolKey = BoolKey(name='TDDFTSO', default=False)
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)
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)
self.UsePseudoDiag: BoolType | BoolKey = BoolKey(name='UsePseudoDiag', default=False)
self.UseSPCode: BoolType | BoolKey = BoolKey(name='UseSPCode', comment='Use Patchkovskii routines for PBE', default=False)
self.VCD: BoolType | BoolKey = BoolKey(name='VCD', comment='Calculate rotational strength during an analytical frequencies calculation.', 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', default=False)
self.ZFS: str | StringKey = StringKey(name='ZFS')
self.gpuenabled: BoolType | BoolKey = BoolKey(name='gpuenabled', default=False)
self.grad_no_fragment_potentials: BoolType | BoolKey = BoolKey(name='grad_no_fragment_potentials', default=False)
self.grad_trf_btrf: BoolType | BoolKey = BoolKey(name='grad_trf_btrf', default=False)
self.hydrogenbonds: BoolType | BoolKey = BoolKey(name='hydrogenbonds', default=False)
self.nocalcs2: BoolType | BoolKey = BoolKey(name='nocalcs2', default=False)
self.nodrop: BoolType | BoolKey = BoolKey(name='nodrop', default=False)
self.noerror: BoolType | BoolKey = BoolKey(name='noerror', default=False)
self.nogiao: BoolType | BoolKey = BoolKey(name='nogiao', default=False)
self.nomorton: BoolType | BoolKey = BoolKey(name='nomorton', default=False)
self.nopm5rho: BoolType | BoolKey = BoolKey(name='nopm5rho', default=False)
self.notstcoe: BoolType | BoolKey = BoolKey(name='notstcoe', default=False)
self.nouseactivefrag: BoolType | BoolKey = BoolKey(name='nouseactivefrag', default=False)
self.novkpot: BoolType | BoolKey = BoolKey(name='novkpot', default=False)
self.noxcprint: BoolType | BoolKey = BoolKey(name='noxcprint', default=False)
self.oldblockedsmat: BoolType | BoolKey = BoolKey(name='oldblockedsmat', default=False)
self.oldorthon: BoolType | BoolKey = BoolKey(name='oldorthon', default=False)
self.peano: BoolType | BoolKey = BoolKey(name='peano', default=False)
self.plap3: BoolType | BoolKey = BoolKey(name='plap3', default=False)
self.prepvibron: BoolType | BoolKey = BoolKey(name='prepvibron', default=False)
self.prtallten: BoolType | BoolKey = BoolKey(name='prtallten', default=False)
self.prtiao: BoolType | BoolKey = BoolKey(name='prtiao', default=False)
self.quild_nocoords_in_log: BoolType | BoolKey = BoolKey(name='quild_nocoords_in_log', default=False)
self.readepsilons: BoolType | BoolKey = BoolKey(name='readepsilons', default=False)
self.readfcfile: BoolType | BoolKey = BoolKey(name='readfcfile', default=False)
self.rhobelpotimport: BoolType | BoolKey = BoolKey(name='rhobelpotimport', default=False)
self.riskyfast: BoolType | BoolKey = BoolKey(name='riskyfast', default=False)
self.scaledkinfunctionals: BoolType | BoolKey = BoolKey(name='scaledkinfunctionals', default=False)
self.sfguess: BoolType | BoolKey = BoolKey(name='sfguess', default=False)
self.sfotrans: BoolType | BoolKey = BoolKey(name='sfotrans', default=False)
self.skipcoulombpot: BoolType | BoolKey = BoolKey(name='skipcoulombpot', default=False)
self.skorthon: BoolType | BoolKey = BoolKey(name='skorthon', default=False)
self.solv: BoolType | BoolKey = BoolKey(name='solv', default=False)
self.soux: BoolType | BoolKey = BoolKey(name='soux', default=False)
self.souy: BoolType | BoolKey = BoolKey(name='souy', default=False)
self.sozero: BoolType | BoolKey = BoolKey(name='sozero', default=False)
self.switchcoe: BoolType | BoolKey = BoolKey(name='switchcoe', default=False)
self.symexcit: BoolType | BoolKey = BoolKey(name='symexcit', default=False)
self.symresp: BoolType | BoolKey = BoolKey(name='symresp', default=False)
self.testaor: BoolType | BoolKey = BoolKey(name='testaor', default=False)
self.testfit: BoolType | BoolKey = BoolKey(name='testfit', default=False)
self.testjob: BoolType | BoolKey = BoolKey(name='testjob', default=False)
self.testpscharge: BoolType | BoolKey = BoolKey(name='testpscharge', default=False)
self.testsub1: BoolType | BoolKey = BoolKey(name='testsub1', default=False)
self.totenskip: BoolType | BoolKey = BoolKey(name='totenskip', default=False)
self.trustsfguess: BoolType | BoolKey = BoolKey(name='trustsfguess', default=False)
self.userlegmn: BoolType | BoolKey = BoolKey(name='userlegmn', default=False)
self.usesumfragp: BoolType | BoolKey = BoolKey(name='usesumfragp', default=False)
self.xonly: BoolType | BoolKey = BoolKey(name='xonly', default=False)
self.xyonly: BoolType | BoolKey = BoolKey(name='xyonly', default=False)
self.xzonly: BoolType | BoolKey = BoolKey(name='xzonly', default=False)
self.yonly: BoolType | BoolKey = BoolKey(name='yonly', default=False)
self.yzonly: BoolType | BoolKey = BoolKey(name='yzonly', default=False)
self.zonly: BoolType | BoolKey = BoolKey(name='zonly', default=False)
self.AOResponse: PreAmsifiedADF._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')
self.AnalyticalFreq: PreAmsifiedADF._AnalyticalFreq = self._AnalyticalFreq(name='AnalyticalFreq', comment='Calculate the harmonic frequencies analytically')
self.Aromaticity: str | Sequence[str] | FreeBlock = 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.')
self.AtomProps: str | Sequence[str] | FreeBlock = self._AtomProps(name='AtomProps')
self.Atoms: str | Sequence[str] | FreeBlock = self._Atoms(name='Atoms', comment='Atomic positions', header=True)
self.Basis: str | Sequence[str] | FreeBlock = self._Basis(name='Basis', comment='Not to be used. Use $ADFBIN/adf (NOT adf.exe!) to run this job')
self.BeckeGrid: PreAmsifiedADF._BeckeGrid = self._BeckeGrid(name='BeckeGrid', comment='Options for the numerical integration grid.')
self.CDFT: PreAmsifiedADF._CDFT = self._CDFT(name='CDFT', comment='CDFT is a tool for carrying out DFT calculations in the presence of a constraint.')
self.CVNDFT: PreAmsifiedADF._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.')
self.ConceptualDFT: PreAmsifiedADF._ConceptualDFT = self._ConceptualDFT(name='ConceptualDFT', comment='Conceptual DFT Properties')
self.Constraints: str | Sequence[str] | FreeBlock = self._Constraints(name='Constraints')
self.ConstructPot: PreAmsifiedADF._ConstructPot = self._ConstructPot(name='ConstructPot', comment='Reads a density from a TAPE41 file and constructs numerically the corresponding potential to it')
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: PreAmsifiedADF._CurrentResponse = self._CurrentResponse(name='CurrentResponse')
self.DIMPAR: str | Sequence[str] | FreeBlock = self._DIMPAR(name='DIMPAR')
self.DIMQM: str | Sequence[str] | FreeBlock = self._DIMQM(name='DIMQM')
self.Dependency: PreAmsifiedADF._Dependency = self._Dependency(name='Dependency')
self.EPrint: PreAmsifiedADF._EPrint = self._EPrint(name='EPrint', comment='Print switches that require more specification than just off or on')
self.ESR: PreAmsifiedADF._ESR = self._ESR(name='ESR')
self.ETSNOCV: PreAmsifiedADF._ETSNOCV = self._ETSNOCV(name='ETSNOCV', comment='Perform ETS-NOCV analysis.')
self.ElectronTransfer: PreAmsifiedADF._ElectronTransfer = self._ElectronTransfer(name='ElectronTransfer')
self.EnergyFrag: str | Sequence[str] | FreeBlock = self._EnergyFrag(name='EnergyFrag')
self.Excitations: PreAmsifiedADF._Excitations = self._Excitations(name='Excitations', comment='Excitation energies: UV/Vis')
self.ExcitedGO: PreAmsifiedADF._ExcitedGO = self._ExcitedGO(name='ExcitedGO', comment='Excited state geometry optimization')
self.Externals: str | Sequence[str] | FreeBlock = self._Externals(name='Externals', comment='Legacy support of the older DRF code')
self.FDE: PreAmsifiedADF._FDE = self._FDE(name='FDE', comment='Frozen Density Embedding options', header=True)
self.Fitnadkin: str | Sequence[str] | FreeBlock = self._Fitnadkin(name='Fitnadkin', comment=' ')
self.FragOccupations: str | Sequence[str] | FreeBlock = self._FragOccupations(name='FragOccupations')
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)
self.GUIBonds: str | Sequence[str] | FreeBlock = self._GUIBonds(name='GUIBonds', comment='The bonds used by the GUI (this does not affect the ADF calculation in any way)')
self.GeoVar: str | Sequence[str] | FreeBlock = self._GeoVar(name='GeoVar')
self.Geometry: PreAmsifiedADF._Geometry = self._Geometry(name='Geometry', comment='Geometry Optimizations procedure')
self.HessDiag: PreAmsifiedADF._HessDiag = self._HessDiag(name='HessDiag', comment='Diagonal Hessian elements... Placeholder')
self.IQA: PreAmsifiedADF._IQA = self._IQA(name='IQA', comment='Bond energy decomposition based on the interacting quantum atoms (IQA) approach and using QTAIM real-space partition.')
self.IRCStart: str | Sequence[str] | FreeBlock = self._IRCStart(name='IRCStart')
self.Integration: str | Sequence[str] | FreeBlock = self._Integration(name='Integration', comment='Options for the obsolete Voronoi numerical integration scheme')
self.IrrepOccupations: str | Sequence[str] | FreeBlock = self._IrrepOccupations(name='IrrepOccupations', comment='Explicit occupation numbers per irrep')
self.LinearConstraints: str | Sequence[str] | FreeBlock = self._LinearConstraints(name='LinearConstraints')
self.LinearScaling: PreAmsifiedADF._LinearScaling = self._LinearScaling(name='LinearScaling', header=True)
self.LocOrb: str | Sequence[str] | FreeBlock = self._LocOrb(name='LocOrb', header=True)
self.MDC: PreAmsifiedADF._MDC = self._MDC(name='MDC', comment='Options for Multipole Derived Charges (MDC)')
self.MP2: PreAmsifiedADF._MP2 = self._MP2(name='MP2', comment='Technical aspects of the MP2 algorithm.')
self.ModifyExcitation: PreAmsifiedADF._ModifyExcitation = self._ModifyExcitation(name='ModifyExcitation')
self.ModifyStartPotential: str | Sequence[str] | FreeBlock = self._ModifyStartPotential(name='ModifyStartPotential', header=True)
self.PertLoc: PreAmsifiedADF._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.')
self.PointCharges: str | Sequence[str] | FreeBlock = self._PointCharges(name='PointCharges', comment='Point charges: {x y z q}')
self.PolTDDFT: PreAmsifiedADF._PolTDDFT = self._PolTDDFT(name='PolTDDFT', comment='TODO!')
self.QMMM: str | Sequence[str] | FreeBlock = self._QMMM(name='QMMM')
self.QTAIM: PreAmsifiedADF._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.")
self.RIHartreeFock: PreAmsifiedADF._RIHartreeFock = self._RIHartreeFock(name='RIHartreeFock')
self.RISM: str | Sequence[str] | FreeBlock = self._RISM(name='RISM', comment='3D-RISM-related input keys.', header=True)
self.RadialCoreGrid: PreAmsifiedADF._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.RemoveFragOrbitals: str | Sequence[str] | FreeBlock = self._RemoveFragOrbitals(name='RemoveFragOrbitals')
self.Response: PreAmsifiedADF._Response = self._Response(name='Response', comment='The calculation of frequency-dependent (hyper)polarizabilities and related properties (Raman, ORD)')
self.Restart: PreAmsifiedADF._Restart = self._Restart(name='Restart', comment='Options for restarts')
self.Restraint: str | Sequence[str] | FreeBlock = self._Restraint(name='Restraint')
self.SCF: PreAmsifiedADF._SCF = self._SCF(name='SCF', comment='Control aspects of the Self Consistent Field procedure')
self.SCRF: str | Sequence[str] | FreeBlock = self._SCRF(name='SCRF')
self.SICOEP: str | Sequence[str] | FreeBlock = self._SICOEP(name='SICOEP')
self.SOPert: PreAmsifiedADF._SOPert = self._SOPert(name='SOPert')
self.SelectExcitation: PreAmsifiedADF._SelectExcitation = self._SelectExcitation(name='SelectExcitation')
self.SlaterDeterminants: str | Sequence[str] | FreeBlock = self._SlaterDeterminants(name='SlaterDeterminants', header=True)
self.Solvation: PreAmsifiedADF._Solvation = self._Solvation(name='Solvation', header=True)
self.SubExci: PreAmsifiedADF._SubExci = self._SubExci(name='SubExci', comment='Subsystem TDDFT (FDE)')
self.SubResponse: str | Sequence[str] | FreeBlock = self._SubResponse(name='SubResponse', comment='Untested and undocumented')
self.TSRC: str | Sequence[str] | FreeBlock = self._TSRC(name='TSRC', comment='Transition State Reaction Coordinate (TSRC)')
self.Tails: PreAmsifiedADF._Tails = self._Tails(name='Tails', comment='Obsolete option for linear scaling and distance effects. We recommend using the LinearScaling key instead.')
self.Thermo: PreAmsifiedADF._Thermo = self._Thermo(name='Thermo', comment='At the end of a completed Frequencies calculation, a survey is given of thermodynamic properties: Heat Capacity, Internal Energy, Entropy. The computed results assume an ideal gas, and electronic contributions are ignored. The latter is a serious omission if the electronic configuration is (almost) degenerate, but the effect is small whenever the energy difference with the next state is large compared to the vibrational frequencies')
self.Units: PreAmsifiedADF._Units = self._Units(name='Units', comment='Definitions of the units.')
self.VSCRF: str | Sequence[str] | FreeBlock = self._VSCRF(name='VSCRF')
self.Vibron: PreAmsifiedADF._Vibron = self._Vibron(name='Vibron', comment='Resonance Raman Input options')
self.XC: PreAmsifiedADF._XC = self._XC(name='XC', comment='Definition of the XC.')
self.XES: PreAmsifiedADF._XES = self._XES(name='XES', comment='X-ray emission spectroscopy')
self.ZlmFit: PreAmsifiedADF._ZlmFit = self._ZlmFit(name='ZlmFit', comment="Options for the density fitting scheme 'ZlmFit'.")
