3. API Documentation
********************

The specification for all generated driver and engine classes which
are available in "scm.input_classes" can be found below.

Included for reference are also the base classes from "scm.pisa", but
as a regular user, you should not interact with these classes
directly.


3.1. Input Classes
==================


3.1.1. Drivers
--------------

class ACERXN

   Variables:
      * **Product** (*str** | **StringKey*) -- Make one or more
        product molecule.

      * **Reactant** (*str** | **StringKey*) -- Make one or more
        reactant molecule.

      * **BasicOptions** (*ACERXN._BasicOptions*) -- General options

      * **DistanceOptions** (*ACERXN._DistanceOptions*) --

      * **Engine** (*EngineBlock*) -- The input for the computational
        engine used to compute energy and forces.

      * **GeomGenRelatedScreeningOptions**
        (*ACERXN._GeomGenRelatedScreeningOptions*) -- Details of
        screening of intermediates in IntermediateGeneration. There
        are three screening moments: (1) During the propagation
        process, (2) After propagation but before geometry
        optimization, and (3) after geometry optimization. The
        screening options in this block are concerned with (3).

      * **IntermediateGeneration** (*ACERXN._IntermediateGeneration*)
        -- Options used exclusively in intermediate generation (Step
        1)

      * **Intermediates** (*ACERXN._Intermediates*) -- If needed
        specify intermediates.

      * **MappingOptions** (*ACERXN._MappingOptions*) -- The options
        used for the chemical distance computations. Currently only
        used in step2, but in future will also be available in step1.

      * **MatrixRelatedScreeningOptions**
        (*ACERXN._MatrixRelatedScreeningOptions*) -- Details of
        screening of intermediates in IntermediateGeneration. There
        are three screening moments: (1) During the propagation
        process, (2) After propagation but before geometry
        optimization, and (3) after geometry optimization. The
        screening options in this block are concerned with (2).

      * **MoleculeSpecificMatrixScreeningOptions**
        (*ACERXN._MoleculeSpecificMatrixScreeningOptions*) -- Molecule
        specific options that may be moved to System settings in
        future.

      * **NetworkCreation** (*ACERXN._NetworkCreation*) -- Options
        exclusively used for network creation (Step 2)

      * **NetworkMinimization** (*ACERXN._NetworkMinimization*) --
        Options exclusively used for network minimization (Step 3)

      * **ReactantFragmentation** (*ACERXN._ReactantFragmentation*) --
        Details on how the reactant is split into smallest fragments,
        and how those are assigned charges and stabilities

      * **RedundantOptions** (*ACERXN._RedundantOptions*) -- Options
        that in this version have only one possible value

      * **RunInfo** (*ACERXN._RunInfo*) -- General run and file-Info
        on creating an ACErxn network

      * **System** (*ACERXN._System*) -- Specification of the chemical
        system. For some applications more than one system may be
        present in the input. In this case, all systems except one
        must have a non-empty string ID specified after the System
        keyword. The system without an ID is considered the main one.

   class _BasicOptions

      General options

      Variables:
         * **AcceptSaturatedActiveAtoms** (*BoolType** | **BoolKey*)
           -- Accept atoms as active even if they are fully saturated
           in the minimal fragments. By default this is turned off.

         * **Covalent_Radii_Coeff** (*float** | **FloatKey*) -- The
           criterion for if a bond exists between a pair of atom.
           Example: Let D_ij is distance between atom i and atom j,
           R_i is covalent radius of atom i and R_j is covalent radius
           of atom j, if D_ij <= (Covalent_Radii_Coeff) x (R_i + R_j):
           bond exists else: bond does not exist (Dalton Trans., 2008,
           2832-2838).

         * **IM_MaxMolecule** (*int** | **IntKey*) -- It is the number
           of constituent molecules in one intermediate state.

         * **MaxJobs** (*int** | **IntKey*) -- The number of parallel
           calculations (geometry optimizations, matrix enumerations,
           and network construction processes).

         * **MinimumBondOrder** (*float** | **FloatKey*) -- The
           minimum bond order to be considered a bond

         * **NProc** (*int** | **IntKey*) -- The number of cores that
           are used for the QM geometry optimization for each
           molecule.

         * **SaveMoleculelist** (*BoolType** | **BoolKey*) -- Saves
           both screened and unscreened molecules to list, which is
           written to the Legacy output as Molecule_list

         * **TotalChargeMethod** (*Literal**[**"SumofFragments"**,
           **"Ionic"**]*) -- If SumofFragments the charge of the
           intermediate (sum of submolecules) is determined by summing
           the charges of constituent fragments. If Ionic the charge
           of the molecule is determined using bond orders.

   class _DistanceOptions

      Variables:
         **BDE_scaling** (*float** | **FloatKey*) --

   class _Engine

      The input for the computational engine used to compute energy
      and forces.

   class _GeomGenRelatedScreeningOptions

      Details of screening of intermediates in IntermediateGeneration.
      There are three screening moments: (1) During the propagation
      process, (2) After propagation but before geometry optimization,
      and (3) after geometry optimization. The screening options in
      this block are concerned with (3).

      Variables:
         * **DiscardAcyclic** (*BoolType** | **BoolKey*) -- Rings in
           the molecule are counted when the SMILES string is created
           (during 3D structure generation). After geometry
           optimization the screening of intermediates based on ring
           count takes place. If set to True, every molecule in
           intermediate must contain a ring. The default is False.

         * **EnergyScreening** (*BoolType** | **BoolKey*) -- During
           intermediate generation, after all geometry optimizations
           are completed, the generated intermediates can optionally
           be screened based on energy relative to the reactant. The
           related keyword is ,CutoffWRTReactantEnergy which must be
           set.

         * **MaxRingNumber** (*int** | **IntKey*) -- Rings in the
           molecule are counted when the SMILES string is created
           (during 3D structure generation). After geometry
           optimization the screening of intermediates based on ring
           count takes place. If set to a positive integer, then the
           number of rings in a single (sub)molecule must be smaller
           than the provided value.

         * **ScreenChangedConnectivity** (*BoolType** | **BoolKey*) --
           If the connectivity of an molecule has been changed during
           the AC->3D process, the corresponding intermediate will be
           screened.

         * **ScreenErrorTermination** (*BoolType** | **BoolKey*) -- If
           a calculation (UFF, DFTB, semi-empirical) is terminated
           with an error, the corresponding intermediate will be
           screened.

   class _IntermediateGeneration

      Options used exclusively in intermediate generation (Step 1)

      Variables:
         * **CompareCharge** (*BoolType** | **BoolKey*) -- When
           deciding if a molecule has already been computed/created,
           take into account the charge of the molecule

         * **FormBondsWithinFragment** (*BoolType** | **BoolKey*) --
           By default, bond-formation or bond-breaking between all
           atoms within a fragment is excluded in intermediate
           generation. If this keyword is set to true, it is possible
           to form new bonds within a fragment (e.g. create a ring
           from a chain), and to break them again. The original
           fragment bonds will always remain in tact.

         * **GenXYZ_MaxCycle** (*int** | **IntKey*) -- The number of
           adjacency matrix (AC) -> 3D process attempts

         * **MaxBondsBroken** (*int** | **IntKey*) -- When generating
           new intermediates Y from intermediate X, this is the
           maximum number of bonds that can be broken in X to form Y.

         * **MaxBondsFormed** (*int** | **IntKey*) -- When generating
           new intermediates Y from intermediate X, this is the
           maximum number of bonds that can be formed to create Y from
           X.

         * **MaxPropagation_Iteration** (*int** | **IntKey*) -- The
           maximum number of iterations in the propagation of
           intermediates. If set to default value of -1, ACErxn
           internally sets the value to 100. Generally, enumeration is
           terminated when no new intermediates are generated.

         * **Module** (*str** | **StringKey*) -- RDKit is the only
           option. The default in the original version of the code was
           OpenBabel.

         * **PropagationMethod** (*Literal**[**"Class"**,
           **"Function"**]*) -- Uses either the novel
           BondOrderMatrixGenerator for propagation and geometry
           recovery, or the old function PropogationFromReactant

         * **ScreenAndOptimizeIntermediates** (*BoolType** |
           **BoolKey*) -- If set to True, the generated intermediates
           will be screened based on a large set of criteria, the
           remaining intermediates will be converted to 3D structures,
           and optimized. If set to False, this entire step will be
           skipped, and 3D geometries and energies are never obtained.

         * **UsePlamsParallelization** (*BoolType** | **BoolKey*) --
           Use the novel GeometryGenerator class to generate 3D
           geometries from molecule bond matrices

         * **UseReactantGeometries** (*BoolType** | **BoolKey*) -- Use
           the geometries for the reactants as passed as input. If not
           true the reactant geometries will be generated from smiles.
           Only works in combination with PropagationMethod=class

         * **AmsOptions**
           (*ACERXN._IntermediateGeneration._AmsOptions*) -- Options
           related to engine calls

         * **GeometryGenerationOptions** (*ACERXN._IntermediateGenera
           tion._GeometryGenerationOptions*) --

         * **PruningOptions**
           (*ACERXN._IntermediateGeneration._PruningOptions*) --
           Details of screening of intermediates in
           IntermediateGeneration. There are three screening moments:
           (1) During the propagation process, (2) After propagation
           but before geometry optimization, and (3) after geometry
           optimization. The screening options in this block are
           concerned with (1).

      class _AmsOptions

         Options related to engine calls

         Variables:
            * **KeepAMSFiles** (*BoolType** | **BoolKey*) -- Keep the
              files of all AMS calculations in the plams_workdir
              folder

            * **KeepAMSRunning** (*BoolType** | **BoolKey*) -- Keep
              the AMS driver running in the background during the
              geometry optimizations

            * **QMcalculation** (*str** | **StringKey*) -- Filename
              that defines the method to calculate energy of the
              intermediates. Example: engine.in

            * **UFF_MaxTime** (*int** | **IntKey*) -- It can have zero
              or positive number. This is the maximum time for UFF
              during the AC->3D process

      class _GeometryGenerationOptions

         Variables:
            * **RDKitLogging** (*BoolType** | **BoolKey*) -- When the
              smilestrings are converted to coordinates using RDKit,
              logging can be switched on or off.

            * **SkipPreOptimization** (*BoolType** | **BoolKey*) --
              Skip the MM preoptimization step of geometry
              optimization, and do not use fragments in 3D structure
              generation. In the old code this was combined with
              canonical SMILES generation with OpenBabel, but RDKit
              has no such option.

      class _PruningOptions

         Details of screening of intermediates in
         IntermediateGeneration. There are three screening moments:
         (1) During the propagation process, (2) After propagation but
         before geometry optimization, and (3) after geometry
         optimization. The screening options in this block are
         concerned with (1).

         Variables:
            * **MaxRingSize** (*int** | **IntKey*) -- If the newly
              generated intermediate (or molecule) contains a ring
              larger than the provided value, it is screened.

            * **MinRingSize** (*int** | **IntKey*) -- If the newly
              generated intermediate (or molecule) contains a ring
              smaller than the provided value, it is screened.

            * **Pruning_Cyclics** (*BoolType** | **BoolKey*) -- If not
              set to the default value N, it is the number maximum
              number of rings allowed in an intermediate.

   class _Intermediates

      If needed specify intermediates.

      Variables:
         **Intermediate** (*str** | **StringKey*) -- If specify sub-
         intermediates.

   class _MappingOptions

      The options used for the chemical distance computations.
      Currently only used in step2, but in future will also be
      available in step1.

      Variables:
         * **Digression_Factor** (*int** | **IntKey*) -- It can have
           positive integer. It is delta in the expression for the
           maximum chemical distance of an intermediate form reactants
           and products

         * **Edge_Energy_Threshold** (*int** | **IntKey*) --
           Endergonic reactions whose energy difference is higher than
           Edge_Energy_Threshold are not connected as edges. Currently
           not in use.

         * **FullMapping** (*Literal**[**"Net"**, **"Y"**, **"N"**]*)
           -- Net: When calculating chemical distance, we only
           consider submolecules that change upon reaction. N: When
           calculating chemical distance, we only consider some parts
           of intermediate (based on the keyword Kthneighbor).

         * **Kthneighbor** (*int** | **IntKey*) -- When calculating
           chemical distance with FullMapping=N, ACErxn only considers
           atoms that are k unit away from the active atoms. The
           distance between two atoms are defined as the graphical
           distance (length of shortest path between two atoms)

         * **MaxDepth_Alpha** (*int** | **IntKey*) -- Completely
           equivalent to Digression_Factor, with the exception that it
           is not used with Digression_Screening in step 1.

         * **UseActiveBonds** (*BoolType** | **BoolKey*) -- During the
           mapping process (computing the chemical distance, assume
           only the active bonds can be broken or formed)

   class _MatrixRelatedScreeningOptions

      Details of screening of intermediates in IntermediateGeneration.
      There are three screening moments: (1) During the propagation
      process, (2) After propagation but before geometry optimization,
      and (3) after geometry optimization. The screening options in
      this block are concerned with (2).

      Variables:
         * **AllowAldehyde** (*BoolType** | **BoolKey*) -- Determines
           whether aldehyde anions are acceptable intermediates.
           Screened after propagation, and before geometry
           optimization.

         * **AllowCarbenes** (*BoolType** | **BoolKey*) -- Allow
           carbene molecules among the generated intermediates.

         * **AllowChargedAtoms** (*BoolType** | **BoolKey*) -- The
           atomic charges are automatically estimated during
           intermediate generation. If this keyword is set to False,
           then all estimated charges need to be zero.

         * **AllowChargedMolecules** (*BoolType** | **BoolKey*) -- The
           charges of all newly generated molecules are derived from
           the fragment charges. If this keyword is set to False, then
           all molecule charges need to be zero.

         * **ChargeConservation** (*BoolType** | **BoolKey*) -- Ensure
           that the estimated atomic charges of the newly generated
           intermediates match the charges of the submolecules. The
           latter are derived from the fragment charges.

         * **CheckElectronegativity** (*BoolType** | **BoolKey*) -- If
           an atom has a more positive charge than its more
           electronegative neighbor, the intermediate state will be
           screened. (except carbon monoxide). By default this is
           switched off.

         * **DigressionScreening** (*BoolType** | **BoolKey*) -- If
           set to True, ACErxn applies digression screening (screening
           based on the chemical distance of an intermediate from
           reactant and product) directly following each propagation
           step for the intermediate generation (before geometry
           optimization).

         * **DiscardAtomicOverCharge** (*BoolType** | **BoolKey*) --
           If set to True, a formal charge for an atom in a molecule
           smaller than -2 or bigger than +2 will result in screening
           of the intermediate.

         * **DiscardMolecularOverCharge** (*BoolType** | **BoolKey*)
           -- If the total charge for an molecule in a intermediate
           state is smaller than -2 or bigger than +2, it will be
           screened.

         * **MaxAllowedRadicals** (*int** | **IntKey*) -- If the value
           is positive, radical species are screened during
           enumeration. It counts the number of radicals and if the
           number exceeds the AllowRadical value, the intermediate is
           screened.

         * **MaxMetalElectronCount** (*int** | **IntKey*) -- It has an
           integer. It is the maximum number of counted electrons of
           metal (neutral counting)

         * **MaxTotalRingNumber** (*int** | **IntKey*) -- Before 3D
           structure generation the number of rings is also computed,
           using rdkit GetSymmSSSR(). If this key is a positive
           number, than the total number of rings in an intermediate
           (sum of submolecules) must be smaller then the provided
           number.

         * **MetalMaxCoordination** (*int** | **IntKey*) -- Restricts
           the maximal number of coordinations of transition metals.

         * **MetalMinCoordination** (*int** | **IntKey*) -- Restricts
           the minimal number of coordinations of transition metals.

         * **MinMetalElectronCount** (*int** | **IntKey*) -- It has an
           integer. It is the minimum number of counted electrons of
           metal (neutral counting)

         * **MinTotalRingNumber** (*int** | **IntKey*) -- Before 3D
           structure generation the number of rings is also computed,
           using rdkit GetSymmSSSR(). If this key is a positive
           number, than the total number of rings in an intermediate
           (sum of submolecules) must be larger then the provided
           number.

         * **SuperMoleculeCharge** (*float** | **FloatKey*) -- If
           TotalChargeMethod is set to Ionic, this is the total charge
           the intermediate (sum of submolecules) always needs to
           have.

   class _MoleculeSpecificMatrixScreeningOptions

      Molecule specific options that may be moved to System settings
      in future.

      Variables:
         * **Elements_NoTerminus** (*str** | **StringKey*) -- The name
           of an element. In the intermediates, elements of this type
           need to be bonded to more than 1 other atom. This key can
           occur multiple times

         * **ForbiddenMetalElectronCount** (*int** | **IntKey*) -- It
           prevents the metal from having certain electron counts
           (neutral counting). Multiple values can be provided by
           repeating this key multiple times. Note: Refer
           http://www.columbia.edu/cu/chemistry/groups/parkin/mlxz.htm
           for the statistics of the electron count of each metal.

         * **LigandElectronCount** (*int** | **IntKey*) -- When a
           transition metal complex is included in the intermediates
           state a user has to specify the ligand electrons
           contributed when using the neutral counting method. The key
           needs to be present a multiple of 2 times (the first
           instance is the index of an atom and the second is the
           corresponding electron contribution).

         * **RangeOfValences** (*ACERXN._MoleculeSpecificMatrixScreen
           ingOptions._RangeOfValences*) -- The user can provide the
           maximum and minimum number of bonds an atom of a certain
           element can have. If not set, default values are used.

      class _RangeOfValences

         The user can provide the maximum and minimum number of bonds
         an atom of a certain element can have. If not set, default
         values are used.

         Variables:
            * **Element** (*str** | **StringKey*) -- The element for
              which the maximum and/or minimum allowed number of bonds
              is set.

            * **MaxNumberOfBonds** (*int** | **IntKey*) -- The maximum
              number of bonds allowed for this element.

            * **MinNumberOfBonds** (*int** | **IntKey*) -- The minimum
              number of bonds allowed for this element.

   class _NetworkCreation

      Options exclusively used for network creation (Step 2)

      Variables:
         * **FindDelocalizedBonds** (*BoolType** | **BoolKey*) --
           Seems to write information on bond delocalization into the
           Intermediate objects before the network is created.

         * **Screening** (*ACERXN._NetworkCreation._Screening*) --
           Options related to the screening of intermediates

      class _Screening

         Options related to the screening of intermediates

         Variables:
            **CutoffWRTReactantEnergy** (*float** | **FloatKey*) -- It
            determines how much higher energy the intermediate state
            can have than the state of the reactant. If
            GeomGenRelatedScreeningOptions%EnergyScreening is set to
            True, then this value is already used at intermediate
            generation. Unit is kcal/mol.

   class _NetworkMinimization

      Options exclusively used for network minimization (Step 3)

      Variables:
         * **Barrier_cutoff** (*float** | **FloatKey*) --

         * **Pathlength_cutoff** (*int** | **IntKey*) -- If this value
           is positive, only those paths are collected whose lengths
           are less than or equal to the given value in step3.

         * **YenKSP_K** (*int** | **IntKey*) -- For given value k, the
           kth shortest paths are extracted in the final step of
           ACErxn.

   class _ReactantFragmentation

      Details on how the reactant is split into smallest fragments,
      and how those are assigned charges and stabilities

      Variables:
         **DepthElectronegativitySearch** (*int** | **IntKey*) -- The
         atoms in the reactant molecules are assigned charges based on
         the connectivity of the molecule and the electronegativity of
         the atoms. By default the electronegativity is assigned
         simply based on the element, but if the depth is selected
         larger than 1, the electronegativity of neighboring atoms (up
         to depth-1) is included in determining the final
         electronegativity value of the atoms. For example, in a
         regular C-C bond, the electrons in the bond are distributed
         equally over the two atoms. But if
         DepthElectronegativitySearch is selected higher than 1, then
         breaking the C-C bond in ethanol will result in a negatively
         charged C-OH group and a carbocation.

   class _RedundantOptions

      Options that in this version have only one possible value

      Variables:
         * **BH_or_Det** (*str** | **StringKey*) --

         * **Bond_Iteration_Method** (*str** | **StringKey*) --
           According to the input description by Jin Woo,
           'Propagation' is the only option, although the default in
           the ACE code is 'Binary'

         * **Command** (*str** | **StringKey*) -- Is not relevant when
           AMS is used

         * **CreateStereoIsomers** (*BoolType** | **BoolKey*) -- If
           True, stereo-chemistry of stereo centers is considered
           during 3D conversion. Not supported in current version.

         * **DFTB3** (*str** | **StringKey*) --

         * **DFTB_dispersion** (*str** | **StringKey*) --

         * **DistanceMethod** (*str** | **StringKey*) -- According to
           the input description by Jin Woo, 'ChemDist' is the only
           option, although the default in the ACE code is
           'BondSimilarity'

         * **Fragment_number** (*str** | **StringKey*) -- Fragment
           numbers for the reactive atoms need to be read at the
           bottom of the input file. Obsolete if not input file is
           used.

         * **GeomType** (*str** | **StringKey*) --

         * **GeomWriteFormat** (*str** | **StringKey*) -- According to
           the input description by Jin Woo, 'xyz' is the only option,
           although the default in the ACE code is 'g09'

         * **Reactive_Atoms** (*str** | **StringKey*) -- The atom
           indices of the reactive atoms in the fragments need to be
           read at the bottom of the input file. Obsolete if not input
           file is used

         * **Temperature** (*float** | **FloatKey*) -- It determines
           the temperature in Kelvin. It is calculation option for
           semi-empirical or DFTB.

         * **UseFragments** (*BoolType** | **BoolKey*) -- If the
           conversion from graph to 3D geometry using SMILES does not
           provide a stable geometry, then the 3D geometry is
           generated by combining the fragment geometries. If set to
           False this will be ignored in the new code (setting
           PropagationMethod to Class), while in the old code (setting
           PropagationMethod to Function) a method is called that does
           not seem to exist.

         * **skf_dir** (*str** | **StringKey*) -- It is the path of
           the directory that contains skf files. It is replaced by
           the content of the engine file referenced in QMcalculation

         * **BasinHopping** (*ACERXN._RedundantOptions._BasinHopping*)
           -- Options related to Basin Hopping

         * **Miscellaneous**
           (*ACERXN._RedundantOptions._Miscellaneous*) --

         * **PruningOptions**
           (*ACERXN._RedundantOptions._PruningOptions*) -- Redundant
           options related to pruning intermediates in step 1
           (intermediate generation)

         * **SpeciesNetOptions**
           (*ACERXN._RedundantOptions._SpeciesNetOptions*) --

      class _BasinHopping

         Options related to Basin Hopping

         Variables:
            * **BH_InternalRotation** (*BoolType** | **BoolKey*) --

            * **BH_Relaxation_Method** (*str** | **StringKey*) --

            * **PickOneFragment** (*BoolType** | **BoolKey*) --

            * **Read_MM_AtomType** (*str** | **StringKey*) --

            * **Spread_Direction** (*str** | **StringKey*) --

      class _Miscellaneous

         Variables:
            **GenerateQST2Input** (*BoolType** | **BoolKey*) --

      class _PruningOptions

         Redundant options related to pruning intermediates in step 1
         (intermediate generation)

         Variables:
            * **IM_MaxAtoms** (*int** | **IntKey*) --

            * **PruningUndervalence** (*BoolType** | **BoolKey*) --

      class _SpeciesNetOptions

         Variables:
            * **Bond_Pick** (*float** | **FloatKey*) --

            * **Reactant_Pick** (*float** | **FloatKey*) --

            * **Uniform_Pick** (*BoolType** | **BoolKey*) --

   class _RunInfo

      General run and file-Info on creating an ACErxn network

      Variables:
         * **MinNumberOfShortestPathsWritten** (*int** | **IntKey*) --
           The minimum number of shortest paths written to the
           shortest_paths.rkf file. Only relevant with
           Steps=All,Steps=MinimizeNetwork, or Steps=AnalyzeNetwork.

         * **RestartDir** (*str** | **Path** | **StringKey*) -- Path
           to the folder containing the restart RKF files

         * **Steps** (*Literal**[**"GenerateIntermediates"**,
           **"CreateNetwork"**, **"MinimizeNetwork"**,
           **"AnalyzeNetwork"**, **"All"**]*) -- Which of the three
           ACErxn steps to run ((1) GenerateIntermediates, (2)
           CreateNetwork, (3) MinimizeNetwork, (4) AnalyzeNetwork).
           The default is to run the first three.

         * **UseAllIntermediatesForPaths** (*BoolType** | **BoolKey*)
           -- If set (default), if two paths are found with the same
           chemical distance, then only the one including the most
           intermediates will be kept.

   class _System

      Specification of the chemical system. For some applications more
      than one system may be present in the input. In this case, all
      systems except one must have a non-empty string ID specified
      after the System keyword. The system without an ID is considered
      the main one.

      Variables:
         * **AllowCloseAtoms** (*BoolType** | **BoolKey*) -- If
           AllowCloseAtoms is set to False, the AMS driver will stop
           with an error if it detects almost-coinciding atomic
           coordinates. If set to True, the AMS driver will try to
           carry on with the calculation.

         * **Charge** (*float** | **FloatKey*) -- The system's total
           charge in atomic units.

         * **FractionalCoords** (*BoolType** | **BoolKey*) -- Whether
           the atomic coordinates in the Atoms block are given in
           fractional coordinates of the lattice vectors. Requires the
           presence of the Lattice block.

         * **GeometryFile** (*str** | **Path** | **StringKey*) -- Read
           the geometry from a file (instead of from Atoms and Lattice
           blocks). Supported formats: .xyz

         * **GuessBonds** (*BoolType** | **BoolKey*) -- Whether or not
           UFF bonds should be guessed.

         * **LatticeStrain** (*Iterable**[**float**] **|
           **FloatListKey*) -- Deform the input system by the
           specified strain. The strain elements are in Voigt
           notation, so one should specify 6 numbers for 3D periodic
           system (order: xx,yy,zz,yz,xz,xy), 3 numbers for 2D
           periodic systems (order: xx,yy,xy) or 1 number for 1D
           periodic systems.

         * **MapAtomsToUnitCell** (*BoolType** | **BoolKey*) -- For
           periodic systems the atoms will be moved to the central
           cell.

         * **ModifyAlternativeElements** (*BoolType** | **BoolKey*) --
           When using alternative elements (using the nuclear_charge
           attribute) set the element to the nearest integer Z. If you
           specify an H atom with a nuclear_charge of 2.9 it is
           replaced by a Li atom with the same nuclear charge.

         * **PerturbCoordinates** (*float** | **FloatKey*) -- Perturb
           the atomic coordinates by adding random numbers between
           [-PerturbCoordinates,PerturbCoordinates] to each Cartesian
           component. This can be useful if you want to break the
           symmetry of your system (e.g. for a geometry optimization).

         * **PerturbLattice** (*float** | **FloatKey*) -- Perturb the
           lattice vectors by applying random strain with matrix
           elements between [-PerturbLattice,PerturbLattice]. This can
           be useful if you want to deviate from an ideal symmetric
           geometry, for example if you look for a phase change due to
           high pressure.

         * **RandomizeAtomOrder** (*BoolType** | **BoolKey*) --
           Whether or not the order of the atoms should be randomly
           changed. Intended for some technical testing purposes only.
           Does not work with bond information.

         * **ShiftCoordinates** (*Iterable**[**float**] **|
           **FloatListKey*) -- Translate the atoms by the specified
           shift (three numbers).

         * **SuperCell** (*Iterable**[**int**] **| **IntListKey*) --
           Create a supercell of the input system (only possible for
           periodic systems). The integer numbers represent the
           diagonal elements of the supercell transformation; you
           should specify as many numbers as lattice vectors (i.e. 1
           number for 1D, 2 numbers for 2D and 3 numbers for 3D
           periodic systems).

         * **SuperCellTrafo** (*Iterable**[**int**] **| **IntListKey*)
           -- Create a supercell of the input system (only possible
           for periodic systems) \vec{a}_i' = \sum_j T_{ij} \vec{a}_j.
           The integer numbers represent the supercell transformation
           T_{ij}: 1 number for 1D PBC, 4 numbers for 2D PBC
           corresponding to a 2x2 matrix (order:
           (1,1),(1,2),(2,1),(2,2)) and 9 numbers for 3D PBC
           corresponding to a 3x3 matrix (order:
           (1,1),(1,2),(1,3),(2,1),(2,2),(2,3),(3,1),(3,2),(3,3)).

         * **Symmetrize** (*BoolType** | **BoolKey*) -- Whether to
           symmetrize the input structure. This might also
           rototranslate the structure into a standard orientation.
           This will symmetrize the atomic coordinates to machine
           precision. Useful if the system is almost symmetric or to
           rototranslate a symmetric molecule into a standard
           orientation.

         * **Symmetry** (*Literal**[**"AUTO"**, **"NOSYM"**,
           **"C**(**LIN**)**"**, **"D**(**LIN**)**"**,
           **"C**(**I**)**"**, **"C**(**S**)**"**, **"C**(**2**)**"**,
           **"C**(**3**)**"**, **"C**(**4**)**"**, **"C**(**5**)**"**,
           **"C**(**6**)**"**, **"C**(**7**)**"**, **"C**(**8**)**"**,
           **"C**(**2V**)**"**, **"C**(**3V**)**"**,
           **"C**(**4V**)**"**, **"C**(**5V**)**"**,
           **"C**(**6V**)**"**, **"C**(**7V**)**"**,
           **"C**(**8V**)**"**, **"C**(**2H**)**"**,
           **"C**(**3H**)**"**, **"C**(**4H**)**"**,
           **"C**(**5H**)**"**, **"C**(**6H**)**"**,
           **"C**(**7H**)**"**, **"C**(**8H**)**"**,
           **"D**(**2**)**"**, **"D**(**3**)**"**, **"D**(**4**)**"**,
           **"D**(**5**)**"**, **"D**(**6**)**"**, **"D**(**7**)**"**,
           **"D**(**8**)**"**, **"D**(**2D**)**"**,
           **"D**(**3D**)**"**, **"D**(**4D**)**"**,
           **"D**(**5D**)**"**, **"D**(**6D**)**"**,
           **"D**(**7D**)**"**, **"D**(**8D**)**"**,
           **"D**(**2H**)**"**, **"D**(**3H**)**"**,
           **"D**(**4H**)**"**, **"D**(**5H**)**"**,
           **"D**(**6H**)**"**, **"D**(**7H**)**"**,
           **"D**(**8H**)**"**, **"I"**, **"I**(**H**)**"**, **"O"**,
           **"O**(**H**)**"**, **"T"**, **"T**(**D**)**"**,
           **"T**(**H**)**"**, **"S**(**4**)**"**, **"S**(**6**)**"**,
           **"S**(**8**)**"**]*) -- Use (sub)symmetry with this
           Schoenflies symbol. Can only be used for molecules.
           Orientation should be correct for the (sub)symmetry. If
           used icw Symmetrize, the symmetrization will not reorient
           the molecule.

         * **Atoms** (*str** | **Sequence**[**str**] **| **FreeBlock*)
           -- The atom types and coordinates. Unit can be specified in
           the header. Default unit is Angstrom.

         * **BondOrders** (*str** | **Sequence**[**str**] **|
           **FreeBlock*) -- Defined bond orders. Each line should
           contain two atom indices, followed by the bond order (1,
           1.5, 2, 3 for single, aromatic, double and triple bonds)
           and (optionally) the cell shifts for periodic systems. May
           be used by MM engines and for defining constraints. If the
           system is periodic and none of the bonds have the cell
           shift defined then AMS will attempt to determine them
           following the minimum image convention.

         * **DefineRegion** (*ACERXN._System._DefineRegion*) --
           Defines a region of atoms using more comprehensive
           selecting methods

         * **ElectrostaticEmbedding**
           (*ACERXN._System._ElectrostaticEmbedding*) -- Container for
           electrostatic embedding options, which can be combined.

         * **Lattice** (*str** | **Sequence**[**str**] **|
           **FreeBlock*) -- Up to three lattice vectors. Unit can be
           specified in the header. Default unit is Angstrom.

         * **LoadForceFieldAtomTypes**
           (*ACERXN._System._LoadForceFieldAtomTypes*) -- This is a
           mechanism to set the ForceField.Type attribute in the
           input. This information is currently only used by the
           ForceField engine.

         * **LoadForceFieldCharges**
           (*ACERXN._System._LoadForceFieldCharges*) -- This is a
           mechanism to set the ForceField.Charge attribute in the
           input. This information is currently only used by the
           ForceField engine.

         * **Region** (*ACERXN._System._Region*) -- Properties for
           each region specified in the Atoms block.

      class _Atoms

         The atom types and coordinates. Unit can be specified in the
         header. Default unit is Angstrom.

      class _BondOrders

         Defined bond orders. Each line should contain two atom
         indices, followed by the bond order (1, 1.5, 2, 3 for single,
         aromatic, double and triple bonds) and (optionally) the cell
         shifts for periodic systems. May be used by MM engines and
         for defining constraints. If the system is periodic and none
         of the bonds have the cell shift defined then AMS will
         attempt to determine them following the minimum image
         convention.

      class _DefineRegion

         Defines a region of atoms using more comprehensive selecting
         methods

         Variables:
            * **AtomRange** (*Iterable**[**int**] **| **IntListKey*)
              -- Specifies a region by selecting all atoms with
              indices between a certain range (including the beginning
              and ending index). Input format is: beginIndex
              endingIndex

            * **Axis** (*Iterable**[**float**] **| **FloatListKey*) --
              Specifies a region by selecting all atoms in space above
              a certain threshold along an user-defined axis. Input
              format is: X-component, Y-component, Z-component,
              threshold

            * **Box** (*Iterable**[**float**] **| **FloatListKey*) --
              Specifies a region by selecting all atoms that are
              present inside a box in space. Input format is: Xmin,
              Xmax, Ymin, Ymax, Zmin, Zmax

            * **Name** (*str** | **StringKey*) -- Name of the specific
              region

      class _ElectrostaticEmbedding

         Container for electrostatic embedding options, which can be
         combined.

         Variables:
            * **ElectricField** (*Iterable**[**float**] **|
              **FloatListKey*) --

              External homogeneous electric field with three Cartesian
              components: ex, ey, ez, the default unit being V/Å.

              In atomic units: Hartree/(e bohr) = 51.422 V/Angstrom;
              the relation to SI units is: 1 Hartree/(e bohr) = 5.14
              ... e11 V/m.

              Supported by the engines adf, band, dftb and mopac.

              For periodic systems the field may only have nonzero
              components orthogonal to the direction(s) of periodicity
              (i.e. for 1D periodic system the x-component of the
              electric field should be zero, while for 2D periodic
              systems both the x and y components should be zero. This
              options cannot be used for 3D periodic systems.

            * **MultipolePotential** (*ACERXN._System._ElectrostaticE
              mbedding._MultipolePotential*) -- External point charges
              (and dipoles).

         class _MultipolePotential

            External point charges (and dipoles).

            Variables:
               * **ChargeModel** (*Literal**[**"Point"**,
                 **"Gaussian"**]*) -- A multipole may be represented
                 by a point (with a singular potential at its
                 location) or by a spherical Gaussian distribution.

               * **ChargeWidth** (*float** | **FloatKey*) -- The width
                 parameter in a.u. in case a Gaussian charge model is
                 chosen. A negative value means that the width will be
                 chosen automatically.

               * **Coordinates** (*str** | **Sequence**[**str**] **|
                 **FreeBlock*) --

                 Positions and values of the multipoles, one per line.
                 Each line has the following format:

                 x y z q, or x y z q µx µy µz.

                 Here x, y, z are the coordinates in Å, q is the
                 charge (in atomic units of charge) and µx, µy, µz are
                 the (optional) dipole moment components (in atomic
                 units, i.e. e*Bohr).

                 Periodic systems are not supported.

            class _Coordinates

               Positions and values of the multipoles, one per line.
               Each line has the following format:

               x y z q, or x y z q µx µy µz.

               Here x, y, z are the coordinates in Å, q is the charge
               (in atomic units of charge) and µx, µy, µz are the
               (optional) dipole moment components (in atomic units,
               i.e. e*Bohr).

               Periodic systems are not supported.

      class _Lattice

         Up to three lattice vectors. Unit can be specified in the
         header. Default unit is Angstrom.

      class _LoadForceFieldAtomTypes

         This is a mechanism to set the ForceField.Type attribute in
         the input. This information is currently only used by the
         ForceField engine.

         Variables:
            **File** (*str** | **StringKey*) -- Name of the (kf) file.
            It needs to be the result of a forcefield calculation.

      class _LoadForceFieldCharges

         This is a mechanism to set the ForceField.Charge attribute in
         the input. This information is currently only used by the
         ForceField engine.

         Variables:
            * **CheckGeometryRMSD** (*BoolType** | **BoolKey*) --
              Whether the geometry RMSD test should be performed, see
              MaxGeometryRMSD. Otherwise only basic tests are
              performed, such as number and atom types. Not doing the
              RMSD test allows you to load molecular charges in a
              periodic system.

            * **File** (*str** | **StringKey*) -- Name of the (kf)
              file

            * **MaxGeometryRMSD** (*float** | **FloatKey*) -- The
              geometry of the charge producing calculation is compared
              to the one of the region, and need to be the same within
              this tolerance.

            * **Region** (*str** | **StringKey*) -- Region for which
              the charges should be loaded

            * **Section** (*str** | **StringKey*) -- Section name of
              the kf file

            * **Variable** (*str** | **StringKey*) -- Variable name of
              the kf file

      class _Region

         Properties for each region specified in the Atoms block.

         Variables:
            **Properties** (*str** | **Sequence**[**str**] **|
            **FreeBlock*) -- Properties for each region specified in
            the Atoms block.

         class _Properties

            Properties for each region specified in the Atoms block.

class ADFNBO

   Variables:
      * **ADFFile** (*str** | **StringKey*) -- Path to TAPE21 file
        from which adfnbo reads data and to which adfnbo possibly
        writes data

      * **Copy** (*BoolType** | **BoolKey*) --

      * **Debug** (*BoolType** | **BoolKey*) --

      * **Fock** (*BoolType** | **BoolKey*) --

      * **NBOKeyList** (*str** | **StringKey*) -- $NBO keylist

      * **Read** (*BoolType** | **BoolKey*) --

      * **Spherical** (*BoolType** | **BoolKey*) --

      * **TAPE15File** (*str** | **StringKey*) -- Path to the TAPE15
        file from which adfnbo reads data

      * **TestJob** (*BoolType** | **BoolKey*) -- include extra
        options in FILE47, such as NRT (natural resonance theory)
        which is expensive for large molecules

      * **Write** (*BoolType** | **BoolKey*) --

      * **Choose** (*str** | **Sequence**[**str**] **| **FreeBlock*)
        --

   class _Choose

class AMS

   Variables:
      * **EngineRestart** (*str** | **Path** | **StringKey*) --

        The path to the file from which to restart the engine.

        Should be a proper engine result file (like adf.rkf, band.rkf
        etc), or the name of the results directory containing it.

      * **FallbackSolveAfterEngineFailure** (*BoolType** | **BoolKey*)
        -- If the engine fails to Solve, try to re-run the Solve
        without restarting the engine from the previous results. This
        generally decreases the engine failure rate. Only relevant
        certain tasks, such as GeometryOptimization,
        MolecularDynamics, Replay, IRC.

      * **LoadEngine** (*str** | **Path** | **StringKey*) -- The path
        to the file from which to load the engine configuration.
        Replaces the Engine block.

      * **RNGSeed** (*Iterable**[**int**] **| **IntListKey*) --
        Initial seed for the (pseudo)random number generator. This
        should be omitted in most calculations to avoid introducing
        bias into the results. If this is unset, the generator will be
        seeded randomly from external sources of entropy. If you want
        to exactly reproduce an older calculation, set this to the
        numbers printed in its output.

      * **Task** (*Literal**[**"GCMC"**, **"GeometryOptimization"**,
        **"Idle"**, **"IRC"**, **"MolecularDynamics"**, **"NEB"**,
        **"PESExploration"**, **"PESScan"**, **"Pipe"**, **"Replay"**,
        **"SinglePoint"**, **"SteepestDescent"**, **"TestEngine"**,
        **"TestSymmetry"**, **"TransitionStateSearch"**,
        **"VibrationalAnalysis"**]*) --

        Specify the computational task to perform:

        * Single Point: keep geometry as is

        * Geometry Optimization: minimize energy

        * Transition State: search for a transition state

        * IRC: intrinsic reaction coordinate

        * PES Scan: scan the potential energy surface

        * NEB: Nudged elastic band for reaction path optimization

        * Vibrational Analysis: perform one of the analysis types
          selected on the options page

        * Molecular Dynamics: perform MD simulation

        * GCMC: Grand Canonical Monte Carlo simulation

        * PES Exploration: automated potential energy surface
          exploration

        * Replay: recompute frames from the trajectory of a previously
          run job

      * **Test** (*Literal**[**"Symmetry"**, **"BareSymmetry"**,
        **"Bonds"**, **"SecondOrderBonds"**, **"AtomTyping"**,
        **"SystemMatching"**]*) -- various technical tests that will
        be done for the system

      * **UseSymmetry** (*BoolType** | **BoolKey*) -- Whether to use
        the system's symmetry in AMS. Symmetry is recognized within a
        tolerance as given in the Symmetry key.

      * **BondOrders** (*AMS._BondOrders*) -- Configures details
        regarding the calculation/guessing of bond orders. To request
        the calculation of bond orders, use the
        'Properties%BondOrders' key.

      * **Constraints** (*AMS._Constraints*) -- The Constraints block
        allows geometry optimizations and potential energy surface
        scans with constraints. The constraints do not have to be
        satisfied at the start of the calculation.

      * **ElasticTensor** (*AMS._ElasticTensor*) -- Options for
        numerical evaluation of the elastic tensor.

      * **Engine** (*EngineBlock*) -- The input for the computational
        engine. The header of the block determines the type of the
        engine.

      * **EngineAddons** (*AMS._EngineAddons*) -- This block
        configures all the engine add-ons.

      * **EngineDebugging** (*AMS._EngineDebugging*) -- This block
        contains some options useful for debugging the computational
        engines.

      * **ExitCondition** (*AMS._ExitCondition*) -- If any of the
        specified exitconditions are met, the AMS driver will exit
        cleanly.

      * **GCMC** (*AMS._GCMC*) --

        This block controls the Grand Canonical Monte Carlo (GCMC)
        task.

        By default, molecules are added at random positions in the
        simulation box. The initial position is controlled by

      * **GeometryOptimization** (*AMS._GeometryOptimization*) --
        Configures details of the geometry optimization and transition
        state searches.

      * **IEEEExceptions** (*AMS._IEEEExceptions*) -- Whether this
        works or not depends on the way the program is compiled
        (compiler and settings). Only useful for developers debugging
        some numerical issue.

      * **IRC** (*AMS._IRC*) -- Configures details of the Intrinsic
        Reaction Coordinate optimization.

      * **Idle** (*AMS._Idle*) -- Configures details of the idle task,
        which does nothing for a specified amount of time.

      * **LoadSystem** (*AMS._LoadSystem*) -- Block that controls
        reading the chemical system from a KF file instead of the
        [System] block.

      * **Log** (*str** | **Sequence**[**str**] **| **FreeBlock*) --
        Configures the debugging loggers. Syntax: 'Level LoggerName'.
        Possible Levels: All, Debug, Info, Warning, Error, Fatal.

      * **MolecularDynamics** (*AMS._MolecularDynamics*) -- Configures
        molecular dynamics (with the velocity-Verlet algorithm) with
        and without thermostats. This block allows to specify the
        details of the molecular dynamics calculation.

      * **Molecules** (*AMS._Molecules*) -- Configures details of the
        molecular composition analysis enabled by the
        Properties%Molecules block.

      * **NEB** (*AMS._NEB*) -- Configures details of the Nudged
        Elastic Band optimization.

      * **NormalModes** (*AMS._NormalModes*) -- Configures details of
        a normal modes calculation.

      * **NumericalDifferentiation** (*AMS._NumericalDifferentiation*)
        -- Define options for numerical differentiations, that is the
        numerical calculation of gradients, Hessian and the stress
        tensor for periodic systems.

      * **NumericalPhonons** (*AMS._NumericalPhonons*) -- Configures
        details of a numerical phonons calculation.

      * **PESExploration** (*AMS._PESExploration*) -- Configures
        details of the automated PES exploration methods.

      * **PESPointCharacter** (*AMS._PESPointCharacter*) -- Options
        for the characterization of PES points.

      * **PESScan** (*AMS._PESScan*) -- Configures the details of the
        potential energy surface scanning task.

      * **Phonons** (*AMS._Phonons*) -- Configures the phonons
        calculation.

      * **Print** (*AMS._Print*) -- This block controls the printing
        of additional information to stdout.

      * **Properties** (*AMS._Properties*) -- Configures which AMS
        level properties to calculate for SinglePoint calculations or
        other important geometries (e.g. at the end of an
        optimization).

      * **Raman** (*AMS._Raman*) -- Configures details of the Raman or
        VROA calculation.

      * **Replay** (*AMS._Replay*) -- Configures the details of the
        Replay task.

      * **Restraints** (*AMS._Restraints*) -- The Restraints block
        allows to add soft constraints to the system. A restraint is a
        potential energy function (a spring) attached to a certain
        coordinate, for example, an interatomic distance, with its
        minimum at the specified optimal value. A restraint is defined
        using one or two parameters: the ForceConstant and, for some
        types, the F(Inf) value. The ForceConstant parameter
        corresponds to second derivative of the restraint potential
        energy d2V(x)/dx^2 for any x (harmonic restraints) or only at
        at x=0 (other restraints). Here, x is a deviation from the
        restraint's optimal value.

      * **RigidMotions** (*AMS._RigidMotions*) -- Specify which rigid
        motions of the total system are allowed. An external field is
        not considered part of the system. Normally the automatic
        option is doing what you want. However this feature can be
        used as a means of geometry constraint.

      * **SCMLibrary** (*AMS._SCMLibrary*) -- Technical settings
        affecting src/lib

      * **SCMMatrix** (*AMS._SCMMatrix*) -- Technical settings for
        programs using the AMT matrix system. Currently this is only
        used by DFTB

      * **SerializedTensors** (*AMS._SerializedTensors*) -- Technical
        settings affecting the SerializedTensors module, currently
        only used for HartreeFock

      * **SteepestDescent** (*AMS._SteepestDescent*) -- Configures
        details of the steepest descent task.

      * **Symmetry** (*AMS._Symmetry*) -- Specifying details about the
        details of symmetry detection and usage.

      * **System** (*AMS._System*) -- Specification of the chemical
        system. For some applications more than one system may be
        present in the input. In this case, all systems except one
        must have a non-empty string ID specified after the System
        keyword. The system without an ID is considered the main one.

      * **Thermo** (*AMS._Thermo*) -- Options for thermodynamic
        properties (assuming an ideal gas). The properties are
        computed for all specified temperatures.

      * **TransitionStateSearch** (*AMS._TransitionStateSearch*) --
        Configures some details of the transition state search.

      * **VibrationalAnalysis** (*AMS._VibrationalAnalysis*) -- Input
        data for all vibrational analysis utilities in the AMS driver.

   class _BondOrders

      Configures details regarding the calculation/guessing of bond
      orders. To request the calculation of bond orders, use the
      'Properties%BondOrders' key.

      Variables:
         **Method** (*Literal**[**"Engine"**, **"Guess"**,
         **"EngineWithGuessFallback"**]*) --

         How to compute the bond orders when they are requested via
         the 'Properties%BondOrders' key.

         'Engine': let the engine compute the bond orders. The
         specific method used to compute the bond orders depends on
         the engine selected, and it may be configurable in the
         engine's input. Note: the calculation may stop if the engine
         cannot compute bond orders.

         'Guess': Use a bond guessing algorithm based on the system's
         geometry. This is the same algorithm that is used by the
         Graphical User Interface to guess bonds.

         'EngineWithGuessFallback': let the engine compute the bond
         orders (same as in 'Engine' option) but if the engine did not
         produce any bond orders, use the bond guessing algorithm as a
         fallback option.

   class _Constraints

      The Constraints block allows geometry optimizations and
      potential energy surface scans with constraints. The constraints
      do not have to be satisfied at the start of the calculation.

      Variables:
         * **All** (*str** | **StringKey*) --

           Fix multiple distances using one the following formats:
           All [bondOrder] bonds at1 at2 [to distance] All triangles
           at1 at2 at3

           The first option constrains all bonds between atoms at1 at2
           to a certain length, while the second - bonds at1-at2 and
           at2-at3 as well as the angle between them.

           The [bondOrder] can be a number or a string such as single,
           double, triple or aromatic. If it's omitted then any bond
           between specified atoms will be constrained. Atom names are
           case-sensitive and they must be as they are in the Atoms
           block, or an asterisk '*' denoting any atom. If the
           distance is omitted then the bond length from the initial
           geometry is used.

           Important: only the bonds present in the system at the
           start of the simulation can be constrained, which means
           that the bonds may need to be specified in the System
           block.

           Valid examples: All single bonds C C to 1.4 All bonds O H
           to 0.98 All bonds O H All bonds H * All triangles H * H

         * **Angle** (*str** | **StringKey*) -- Fix the angle between
           three atoms. Three atom indices followed by an angle in
           degrees.

         * **Atom** (*int** | **IntKey*) -- Fix the position of an
           atom. Just one integer referring to the index of the atom
           in the [System%Atoms] block.

         * **AtomList** (*Iterable**[**int**] **| **IntListKey*) --
           Fix positions of the specified atoms. A list of integers
           referring to indices of atoms in the [System%Atoms] block.

         * **Block** (*str** | **StringKey*) -- Name of the region to
           constrain as a rigid block. Regions are specified in the
           System%Atoms block.

         * **BlockAtoms** (*Iterable**[**int**] **| **IntListKey*) --
           List of atom indices for a block constraint, where the
           internal degrees of freedom are frozen.

         * **Coordinate** (*str** | **StringKey*) -- Fix a particular
           coordinate of an atom. Atom index followed by (x|y|z).

         * **DifDist** (*str** | **StringKey*) -- Four atom indices i
           j k l followed by the distance in Angstrom. This will
           constrain the difference R(ij)-R(kl) at the given value.

         * **Dihedral** (*str** | **StringKey*) -- Fix the dihedral
           angle between four atoms. Four atom indices followed by an
           angle in degrees.

         * **Distance** (*str** | **StringKey*) -- Fix the distance
           between two atoms. Two atom indices followed by the
           distance in Angstrom.

         * **EqualStrain** (*str** | **StringKey*) --

           Exclusively for lattice optimizations:

           Accepts a set of strain components [xx, xy, xz, yy, yz, zz]
           which are to be kept equal.

           The applied strain will be determined by the average of the
           corresponding stress tensors components.

           In AMSinput just check the corresponding check buttons.

         * **FixedRegion** (*str** | **StringKey*) -- Fix positions of
           all atoms in a region.

         * **FreezeStrain** (*str** | **StringKey*) --

           Exclusively for lattice optimizations:

           Freezes any lattice deformation corresponding to a
           particular component of the strain tensor.

           Accepts a set of strain components [xx, xy, xz, yy, yz, zz]
           to be frozen.

           In AMSinput just check the corresponding check buttons.

         * **SumDist** (*str** | **StringKey*) -- Four atom indices i
           j k l followed by the distance in Angstrom. This will
           constrain the sum R(ij)+R(kl) at the given value.

   class _ElasticTensor

      Options for numerical evaluation of the elastic tensor.

      Variables:
         * **ConvergenceQuality** (*Literal**[**"Normal"**,
           **"Good"**, **"VeryGood"**, **"Excellent"**]*) -- The
           tightness of the convergence of the geometry optimizations
           for each strain deformation. This should not be set higher
           than the overall convergence quality of the preceding
           geometry optimization configured by the
           "GeometryOptimization%Convergence%Quality" keyword.

         * **StrainStepSize** (*float** | **FloatKey*) -- Step size
           (relative) of strain deformations used for computing the
           elastic tensor numerically.

         * **Parallel** (*AMS._ElasticTensor._Parallel*) -- Options
           for double parallelization, which allows to split the
           available processor cores into groups working through all
           the available tasks in parallel, resulting in a better
           parallel performance. The keys in this block determine how
           to split the available processor cores into groups working
           in parallel.

      class _Parallel

         Options for double parallelization, which allows to split the
         available processor cores into groups working through all the
         available tasks in parallel, resulting in a better parallel
         performance. The keys in this block determine how to split
         the available processor cores into groups working in
         parallel.

         Variables:
            * **nCoresPerGroup** (*int** | **IntKey*) -- Number of
              cores in each working group.

            * **nGroups** (*int** | **IntKey*) -- Total number of
              processor groups. This is the number of tasks that will
              be executed in parallel.

            * **nNodesPerGroup** (*int** | **IntKey*) -- Number of
              nodes in each group. This option should only be used on
              homogeneous compute clusters, where all used compute
              nodes have the same number of processor cores.

   class _Engine

      The input for the computational engine. The header of the block
      determines the type of the engine.

   class _EngineAddons

      This block configures all the engine add-ons.

      Variables:
         * **Pressure** (*float** | **FloatKey*) -- Add a hydrostatic
           pressure term to the engine's energy and stress tensor. Can
           only be used for 3D periodic boundary conditions.

         * **AtomEnergies** (*str** | **Sequence**[**str**] **|
           **FreeBlock*) -- Add an element-dependent energy per atom.
           On each line, give the chemical element followed by the
           energy (in atomic units).

         * **D3Dispersion** (*AMS._EngineAddons._D3Dispersion*) --
           This block configures the add-on that adds the Grimme D3
           dispersion correction to the engine's energy, gradients,
           and stress tensor.

         * **D4Dispersion** (*AMS._EngineAddons._D4Dispersion*) --
           This block configures the addon that adds the Grimme
           D4(EEQ) dispersion correction to the engine's energy,
           gradients, stress tensor and Hessian.

         * **ExternalEngine** (*AMS._EngineAddons._ExternalEngine*) --
           External engine as an addon

         * **ExternalStress** (*AMS._EngineAddons._ExternalStress*) --
           This block configures the addon that adds external stress
           term to the engine's energy and stress tensor.

         * **PipeEngine** (*AMS._EngineAddons._PipeEngine*) -- Pipe
           engine as an addon

         * **Repulsion** (*AMS._EngineAddons._Repulsion*) -- This
           block configures an addon that adds a repulsive Weeks-
           Chandler-Andersen potential to all atom pairs.

         * **WallPotential** (*AMS._EngineAddons._WallPotential*) --
           This block configures the addon that adds a spherical wall
           potential to the engine's energy and gradients.

      class _AtomEnergies

         Add an element-dependent energy per atom. On each line, give
         the chemical element followed by the energy (in atomic
         units).

      class _D3Dispersion

         This block configures the add-on that adds the Grimme D3
         dispersion correction to the engine's energy, gradients, and
         stress tensor.

         Variables:
            * **Damping** (*Literal**[**"BJ"**, **"Zero"**]*) -- Type
              of damping: BJ (Becke-Johnson) or Zero. BJ is
              recommended for most applications.

            * **Enabled** (*BoolType** | **BoolKey*) -- Enables the D3
              dispersion correction addon.

            * **Functional** (*str** | **StringKey*) -- Use the D3
              parameterization by Grimme for a given xc-functional.
              Accepts the same values as the --func command line
              option of the official dftd3 program. Note: the naming
              convention is different from elsewhere in the AMS suite.
              For example, BLYP should be called b-lyp.

            * **a1** (*float** | **FloatKey*) -- The a1 parameter.
              Only used if Damping is set to BJ. If set, it overwrites
              the a1 value for the chosen functional.

            * **a2** (*float** | **FloatKey*) -- The a2 parameter.
              Only used if Damping is set to BJ. If set, it overwrites
              the a2 value for the chosen functional.

            * **alp** (*float** | **FloatKey*) -- The a2 parameter.
              Only used if Damping is set to BJ. If set, it overwrites
              the a2 value for the chosen functional.

            * **s6** (*float** | **FloatKey*) -- The s6 parameter,
              global scaling parameter. If set, it overwrites the s6
              value for the chosen functional.

            * **s8** (*float** | **FloatKey*) -- The s8 parameter. If
              set, it overwrites the s8 value for the chosen
              functional.

            * **sr6** (*float** | **FloatKey*) -- The sr6 parameter.
              Only used if Damping is set to Zero. If set, it
              overwrites the sr6 value for the chosen functional.

      class _D4Dispersion

         This block configures the addon that adds the Grimme D4(EEQ)
         dispersion correction to the engine's energy, gradients,
         stress tensor and Hessian.

         Variables:
            * **Enabled** (*BoolType** | **BoolKey*) -- Enables the D4
              dispersion correction addon.

            * **Functional** (*Literal**[**"HF"**, **"BLYP"**,
              **"BPBE"**, **"BP86"**, **"BPW"**, **"LB94"**,
              **"MPWLYP"**, **"MPWPW91"**, **"OLYP"**, **"OPBE"**,
              **"PBE"**, **"RPBE"**, **"REVPBE"**, **"PW86PBE"**,
              **"RPW86PBE"**, **"PW91"**, **"PW91P86"**, **"XLYP"**,
              **"B97"**, **"TPSS"**, **"REVTPSS"**, **"SCAN"**,
              **"B1LYP"**, **"B3LYP"**, **"BHLYP"**, **"B1P86"**,
              **"B3P86"**, **"B1PW91"**, **"B3PW91"**, **"O3LYP"**,
              **"REVPBE0"**, **"REVPBE38"**, **"PBE0"**, **"PWP1"**,
              **"PW1PW"**, **"MPW1PW91"**, **"MPW1LYP"**,
              **"PW6B95"**, **"TPSSH"**, **"TPSS0"**, **"X3LYP"**,
              **"M06L"**, **"M06"**, **"OMEGAB97"**, **"OMEGAB97X"**,
              **"CAM-B3LYP"**, **"LC-BLYP"**, **"LH07TSVWN"**,
              **"LH07SSVWN"**, **"LH12CTSSIRPW92"**,
              **"LH12CTSSIFPW92"**, **"LH14TCALPBE"**, **"B2PLYP"**,
              **"B2GPPLYP"**, **"MPW2PLYP"**, **"PWPB95"**,
              **"DSDBLYP"**, **"DSDPBE"**, **"DSDPBEB95"**,
              **"DSDPBEP86"**, **"DSDSVWN"**, **"DODBLYP"**,
              **"DODPBE"**, **"DODPBEB95"**, **"DODPBEP86"**,
              **"DODSVWN"**, **"PBE02"**, **"PBE0DH"**,
              **"DFTB**(**3ob**)**"**, **"DFTB**(**mio**)**"**,
              **"DFTB**(**pbc**)**"**, **"DFTB**(**matsci**)**"**,
              **"DFTB**(**ob2**)**"**, **"B1B95"**, **"MPWB1K"**,
              **"REVTPSSH"**, **"GLYP"**, **"REVPBE0DH"**,
              **"REVTPSS0"**, **"REVDSDPBEP86"**, **"REVDSDPBEPBE"**,
              **"REVDSDBLYP"**, **"REVDODPBEP86"**, **"B97M"**,
              **"OMEGAB97M"**, **"R2SCAN"**]*) -- Use the D4
              parameterization by Grimme for a given xc-functional.

            * **Verbosity** (*Literal**[**"Silent"**, **"Normal"**,
              **"Verbose"**, **"VeryVerbose"**]*) -- Controls the
              verbosity of the dftd4 code. Equivalent to the --silent
              and --verbose command line switches of the official
              dftd4 program.

            * **a1** (*float** | **FloatKey*) -- The a1 parameter, see
              D4 article. The physically reasonable range for a1 is
              [0.0,1.0]. If set, it overwrites the a1 value for the
              chosen functional.

            * **a2** (*float** | **FloatKey*) -- The a2 parameter, see
              D4 article. The physically reasonable range for a2 is
              [0.0,7.0]. If set, it overwrites the a2 value for the
              chosen functional.

            * **ga** (*float** | **FloatKey*) -- The ga parameter. GCP

            * **gc** (*float** | **FloatKey*) -- The gc parameter. GCP

            * **s6** (*float** | **FloatKey*) -- The s6 parameter, see
              D4 article. The physically reasonable range for s6 is
              [0.0,1.0]. If set, it overwrites the s6 value for the
              chosen functional.

            * **s8** (*float** | **FloatKey*) -- The s8 parameter, see
              D4 article. The physically reasonable range for s8 is
              [0.0,3.0]. If set, it overwrites the s8 value for the
              chosen functional.

            * **s9** (*float** | **FloatKey*) -- The s9 parameter, see
              D4 article. If set, it overwrites the s9 value for the
              chosen functional.

      class _ExternalEngine

         External engine as an addon

         Variables:
            **Execute** (*str** | **StringKey*) -- execute command

      class _ExternalStress

         This block configures the addon that adds external stress
         term to the engine's energy and stress tensor.

         Variables:
            * **StressTensorVoigt** (*Iterable**[**float**] **|
              **FloatListKey*) -- The elements of the external stress
              tensor in Voigt notation. One should specify 6 numbers
              for 3D periodic system (order: xx,yy,zz,yz,xz,xy), 3
              numbers for 2D periodic systems (order: xx,yy,xy) or 1
              number for 1D periodic systems.

            * **UpdateReferenceCell** (*BoolType** | **BoolKey*) --
              Whether ot not the reference cell should be updated
              every time the system changes (see documentation).

      class _PipeEngine

         Pipe engine as an addon

         Variables:
            **WorkerCommand** (*str** | **StringKey*) -- pipe worker
            command

      class _Repulsion

         This block configures an addon that adds a repulsive Weeks-
         Chandler-Andersen potential to all atom pairs.

         Variables:
            * **Enabled** (*BoolType** | **BoolKey*) --

              Enables the repulsive Weeks-Chandler-Andersen potential
              addon.

              When enabled, all atom pairs will experience repulsion E
              = 4*epsilon*( (sigma/r)^12 - (sigma/r)^6 + 1/4 ) at the
              distances shorter than about 1.12*sigma.

            * **Epsilon** (*float** | **FloatKey*) -- The epsilon
              parameter in the potential equation. It is equal to the
              amount of energy added at r=sigma.

            * **HydrogenSigmaScale** (*float** | **FloatKey*) -- The
              sigma parameter for a pair of atoms where one of them is
              hydrogen is scaled with the given factor. For H-H
              interactions the sigma is scaled with this value
              squared.

            * **Sigma** (*float** | **FloatKey*) -- The sigma
              parameter in the potential equation. The potential is
              exactly zero at the distances larger than about
              1.12*sigma

            * **SkinLength** (*float** | **FloatKey*) -- Technical
              parameter specifying skin length for the neighbor list
              generation. A larger value increases the neighbor list
              cutoff (and cost) but reduces the frequency it needs to
              be re-created.

      class _WallPotential

         This block configures the addon that adds a spherical wall
         potential to the engine's energy and gradients.

         Variables:
            * **Enabled** (*BoolType** | **BoolKey*) -- Enables the
              wall potential addon. When enabled, a spherical wall of
              radius [Radius] around the origin will be added. The
              force due to the potential will decay exponentially
              inside the wall, will be close to [Prefactor*Gradient]
              outside and exactly half of that at the wall.

            * **Gradient** (*float** | **FloatKey*) -- The radial
              gradient outside the sphere.

            * **Prefactor** (*float** | **FloatKey*) -- The multiplier
              for the overall strength of the potential.

            * **Radius** (*float** | **FloatKey*) -- The radius of the
              sphere, wherein the potential is close to zero.

   class _EngineDebugging

      This block contains some options useful for debugging the
      computational engines.

      Variables:
         * **AlwaysClaimSuccess** (*BoolType** | **BoolKey*) -- If an
           engine fails, pretend that it worked. This can be useful
           when you know that an SCF might fail.

         * **CheckInAndOutput** (*BoolType** | **BoolKey*) -- Enables
           some additional checks on the input and output of an
           engine, e.g. for NaN values.

         * **ForceContinousPES** (*BoolType** | **BoolKey*) -- If this
           option is set, the engine will always run in continuous PES
           mode. For many engines this disables the use of symmetry,
           as this one always leads to a discontinuous PES around the
           symmetric points: Basically there is jump in the PES at the
           point where the symmetry detection starts classifying the
           system as symmetric. Normally the continuous PES mode of
           the engine (often disabling the symmetry) is only used when
           doing numerical derivatives, but this flag forces the
           engine to continuously run in this mode.

         * **IgnoreEngineSupportsErrors** (*BoolType** | **BoolKey*)
           -- Pretend as if the engine supports anything requested.
           Use at your own risk.

         * **IgnoreGradientsRequest** (*BoolType** | **BoolKey*) -- If
           this option is set, the engine will not do analytical
           gradients if asked for it, so that gradients will have to
           be evaluated numerically by AMS.

         * **IgnorePreviousResults** (*BoolType** | **BoolKey*) -- If
           this option is set, the engine will not receive information
           from previous calculations. Typically this information is
           used to restart the self consistent procedure of the
           engine.

         * **IgnoreStressTensorRequest** (*BoolType** | **BoolKey*) --
           If this option is set, the engine will not calculate an
           analytical stress tensor if asked for it, so that the
           stress tensor will have to be evaluated numerically by AMS.

         * **NeverQuiet** (*BoolType** | **BoolKey*) -- Makes the
           engine ignore the request to work quietly.

         * **RandomFailureChance** (*float** | **FloatKey*) -- Makes
           the engine randomly report failures, even though the
           results are actually fine. Useful for testing error
           handling on the application level.

         * **RandomNoiseInEnergy** (*float** | **FloatKey*) -- Adds a
           random noise to the energy returned by the engine. The
           random contribution is drawn from [-r,r] where r is the
           value of this keyword.

         * **RandomNoiseInGradients** (*float** | **FloatKey*) -- Adds
           a random noise to the gradients returned by the engine. A
           random number in the range [-r,r] (where r is the value of
           this keyword) is drawn and added separately to each
           component of the gradient.

         * **RandomStopChance** (*float** | **FloatKey*) -- Makes the
           engine randomly stop. Can be used to simulate crashes.

   class _ExitCondition

      If any of the specified exitconditions are met, the AMS driver
      will exit cleanly.

      Variables:
         * **Type** (*Literal**[**"AtomsTooClose"**,
           **"EngineEnergyUncertainty"**,
           **"EngineGradientsUncertainty"**]*) -- The type of
           exitcondition specified

         * **AtomsTooClose** (*AMS._ExitCondition._AtomsTooClose*) --
           If any pair of atoms is closer than the specified minimum
           value, the program will exit cleanly.

         * **EngineEnergyUncertainty**
           (*AMS._ExitCondition._EngineEnergyUncertainty*) -- If the
           engine reports an uncertainty that is too high, the program
           will exit cleanly.

         * **EngineGradientsUncertainty**
           (*AMS._ExitCondition._EngineGradientsUncertainty*) -- If
           the engine reports an uncertainty in the magnitude of the
           nuclear gradient of any atom that is too high, the program
           will exit cleanly.

      class _AtomsTooClose

         If any pair of atoms is closer than the specified minimum
         value, the program will exit cleanly.

         Variables:
            * **MinimumDistance** (*float** | **FloatKey*) -- Two
              atoms closer than this threshold value are considered
              too close.

            * **PairCalculation** (*Literal**[**"NeighborList"**,
              **"DistanceMatrix"**]*) -- Two atoms closer than this
              threshold value are considered too close.

      class _EngineEnergyUncertainty

         If the engine reports an uncertainty that is too high, the
         program will exit cleanly.

         Variables:
            * **MaxUncertainty** (*float** | **FloatKey*) -- Threshold
              for Engine Energy Uncertainty divided by Normalization
              (by default the number of atoms)

            * **Normalization** (*float** | **FloatKey*) -- Divide the
              reported Engine Energy Uncertainty by this
              normalization. Will divide by the number of atoms if
              unset.

      class _EngineGradientsUncertainty

         If the engine reports an uncertainty in the magnitude of the
         nuclear gradient of any atom that is too high, the program
         will exit cleanly.

         Variables:
            **MaxUncertainty** (*float** | **FloatKey*) -- Threshold
            for Engine Gradients Uncertainty.

   class _GCMC

      This block controls the Grand Canonical Monte Carlo (GCMC) task.

      By default, molecules are added at random positions in the
      simulation box. The initial position is controlled by

      Variables:
         * **AccessibleVolume** (*float** | **FloatKey*) -- Volume
           available to GCMC, in cubic Angstroms. AccessibleVolume
           should be specified for "Accessible" and  "FreeAccessible"
           [VolumeOption].

         * **Ensemble** (*Literal**[**"Mu-VT"**, **"Mu-PT"**]*) --
           Select the MC ensemble: Mu-VT for fixed volume or Mu-PT for
           variable volume. When the Mu-PT ensemble is selected the
           [Pressure] and [VolumeChangeMax] should also be specified.

         * **Iterations** (*int** | **IntKey*) -- Number of GCMC
           moves.

         * **MapAtomsToOriginalCell** (*BoolType** | **BoolKey*) --
           Keeps the atom (mostly) in the original cell by mapping
           them back before the geometry optimizations.

         * **MaxDistance** (*float** | **FloatKey*) -- The max
           distance to other atoms of the system when adding the
           molecule.

         * **MinDistance** (*float** | **FloatKey*) -- Keep the
           minimal distance to other atoms of the system when adding
           the molecule.

         * **NonAccessibleVolume** (*float** | **FloatKey*) -- Volume
           not available to GCMC, in cubic Angstroms.
           NonAccessibleVolume may be specified for the "Free"
           [VolumeOption] to reduce the accessible volume.

         * **NumAttempts** (*int** | **IntKey*) -- Try
           inserting/moving the selected molecule up to the specified
           number of times or until all constraints are satisfied. If
           all attempts fail a message will be printed and the
           simulation will stop. If the MaxDistance-MinDistance
           interval is small this number may have to be large.

         * **Pressure** (*float** | **FloatKey*) -- Pressure used to
           calculate the energy correction in the Mu-PT ensemble. Set
           it to zero for incompressible solid systems unless at very
           high pressures.

         * **Restart** (*str** | **Path** | **StringKey*) -- Name of
           an RKF restart file. Upon restart, the information about
           the GCMC input parameters, the initial system (atomic
           coordinates, lattice, charge, etc.) and the MC molecules
           (both already inserted and to be inserted) are read from
           the restart file. The global GCMC input parameters and the
           MC Molecules can be modified from input. Any parameter not
           specified in the input will use its value from the restart
           file (i.e. not the default value). Molecules found in the
           restart file do not have to be present as named Systems in
           the input, however if there is a System present that
           matches the name of a molecule from restart then the
           System's geometry will replace that found in the restart
           file. It is also possible to specify new Molecules in the
           input, which will be added to the pool of the MC molecules
           from restart.

         * **Temperature** (*float** | **FloatKey*) -- Temperature of
           the simulation. Increase the temperature to improve the
           chance of accepting steps that result in a higher energy.

         * **UseGCPreFactor** (*BoolType** | **BoolKey*) -- Use the GC
           pre-exponential factor for probability.

         * **VolumeChangeMax** (*float** | **FloatKey*) -- Fractional
           value by which logarithm of the volume is allowed to change
           at each step. The new volume is then calculated as Vnew =
           exp(random(-1:1)*VolumeChangeMax)*Vold

         * **VolumeOption** (*Literal**[**"Free"**, **"Total"**,
           **"Accessible"**, **"FreeAccessible"**]*) -- Specifies the
           method to calculate the volume used to calculate the GC
           pre-exponential factor and the energy correction in the Mu-
           PT ensemble:  Free: V = totalVolume - occupiedVolume -
           NonAccessibleVolume;  Total: V = totalVolume;  Accessible:
           V = AccessibleVolume;  FreeAccessible: V = AccessibleVolume
           - occupiedVolume.  The AccessibleVolume and
           NonAccessibleVolume are specified in the input, the
           occupiedVolume is calculated as a sum of atomic volumes.

         * **Box** (*AMS._GCMC._Box*) --

           Boundaries of the insertion space, i.e. coordinates of the
           origin of an inserted molecule (coordinates of an atom of
           the inserted system may fall outside the box).

           For a periodic dimension it is given as a fraction of the
           simulation box (the full 0 to 1 range by default). For a
           non-periodic dimension it represents absolute Cartesian
           coordinates in Angstrom (the system's bounding box extended
           by the MaxDistance value by default).

         * **Molecule** (*AMS._GCMC._Molecule*) -- This block defines
           the molecule (or atom) that can be inserted/moved/deleted
           with the MC method. The coordinates should form a
           reasonable structure. The MC code uses these coordinates
           during the insertion step by giving them a random rotation,
           followed by a random translation to generate a random
           position of the molecule inside the box. Currently, there
           is no check to make sure all atoms of the molecule stay
           inside the simulation box. The program does check that the
           MaxDistance/MinDistance conditions are satisfied.

         * **Removables** (*str** | **Sequence**[**str**] **|
           **FreeBlock*) -- The Removables can be used to specify a
           list of molecules that can be removed or moved during this
           GCMC calculation. Molecules are specified one per line in
           the format following format:  MoleculeName atom1 atom2 ...
           The MoleculeName must match a name specified in one of the
           [Molecule] blocks. The atom indices refer to the whole
           input System and the number of atoms must match that in the
           specified Molecule. A suitable Removables block is written
           to the standard output after each accepted MC move. If you
           do so then you should also replace the initial atomic
           coordinates with the ones found in the same file. If a
           [Restart] key is present then the Removables block is
           ignored.

         * **SwapAtoms** (*AMS._GCMC._SwapAtoms*) -- Experimental:
           Occasionally swap the coordinates of a random pair of atoms
           from two regions.

      class _Box

         Boundaries of the insertion space, i.e. coordinates of the
         origin of an inserted molecule (coordinates of an atom of the
         inserted system may fall outside the box).

         For a periodic dimension it is given as a fraction of the
         simulation box (the full 0 to 1 range by default). For a non-
         periodic dimension it represents absolute Cartesian
         coordinates in Angstrom (the system's bounding box extended
         by the MaxDistance value by default).

         Variables:
            * **Amax** (*float** | **FloatKey*) -- Coordinate of the
              upper bound along the first axis.

            * **Amin** (*float** | **FloatKey*) -- Coordinate of the
              lower bound along the first axis.

            * **Bmax** (*float** | **FloatKey*) -- Coordinate of the
              upper bound along the second axis.

            * **Bmin** (*float** | **FloatKey*) -- Coordinate of the
              lower bound along the second axis.

            * **Cmax** (*float** | **FloatKey*) -- Coordinate of the
              upper bound along the third axis.

            * **Cmin** (*float** | **FloatKey*) -- Coordinate of the
              lower bound along the third axis.

      class _Molecule

         This block defines the molecule (or atom) that can be
         inserted/moved/deleted with the MC method. The coordinates
         should form a reasonable structure. The MC code uses these
         coordinates during the insertion step by giving them a random
         rotation, followed by a random translation to generate a
         random position of the molecule inside the box. Currently,
         there is no check to make sure all atoms of the molecule stay
         inside the simulation box. The program does check that the
         MaxDistance/MinDistance conditions are satisfied.

         Variables:
            * **ChemicalPotential** (*float** | **FloatKey*) --

              Chemical potential of the molecule (or atom) reservoir.

              It is used when calculating the Boltzmann accept/reject
              criteria after a MC move is executed. This value can be
              derived from first principles using statistical
              mechanics, or equivalently, it can be determined from
              thermochemical tables available in literature sources.
                 For example, the proper chemical potential for a GCMC
                 simulation in which single oxygen atoms are exchanged
                 with a reservoir of O2 gas, should equal 1/2 the
                 chemical potential of O2 at the temperature and
                 pressure of the reservoir:

              cmpot = Mu_O(T,P) = 1/2*Mu_O2(T,P) = 1/2 *
              [Mu_ref(T,P_ref) + kT*Log(P/Pref) - E_diss]

              where the reference chemical potential [Mu_ref(T,P_ref)]
              is the experimentally determined chemical potential of
              O2 at T and Pref; kT*Log(P/Pref) is the pressure
              correction to the free energy, and E_diss is the
              dissociation energy of the O2 molecule.

            * **NoAddRemove** (*BoolType** | **BoolKey*) --

              Set to True to tell the GCMC code to keep the number of
              molecules/atoms of this type fixed.

              It will thus disable Insert/Delete moves on this type,
              meaning it can only do a displacement move, or volume
              change move (for an NPT ensemble).

            * **SystemName** (*str** | **StringKey*) -- String ID of a
              named [System] to be inserted. The lattice specified
              with this System, if any, is ignored and the main
              system's lattice is used instead.

      class _Removables

         The Removables can be used to specify a list of molecules
         that can be removed or moved during this GCMC calculation.
         Molecules are specified one per line in the format following
         format:
            MoleculeName atom1 atom2 ...  The MoleculeName must match
            a name specified in one of the [Molecule] blocks. The atom
            indices refer to the whole input System and the number of
            atoms must match that in the specified Molecule. A
            suitable Removables block is written to the standard
            output after each accepted MC move. If you do so then you
            should also replace the initial atomic coordinates with
            the ones found in the same file. If a [Restart] key is
            present then the Removables block is ignored.

      class _SwapAtoms

         Experimental: Occasionally swap the coordinates of a random
         pair of atoms from two regions.

         Variables:
            * **Probability** (*float** | **FloatKey*) -- Probability
              of performing a swap move instead of any other GCMC move
              in a single GCMC iteration.

            * **Regions** (*str** | **StringKey*) -- Names of two
              regions to swap between (separated by a space).

   class _GeometryOptimization

      Configures details of the geometry optimization and transition
      state searches.

      Variables:
         * **CalcPropertiesOnlyIfConverged** (*BoolType** |
           **BoolKey*) -- Compute the properties requested in the
           'Properties' block, e.g. Frequencies or Phonons, only if
           the optimization (or transition state search) converged. If
           False, the properties will be computed even if the
           optimization did not converge.

         * **CoordinateType** (*Literal**[**"Auto"**,
           **"Delocalized"**, **"Cartesian"**]*) --

           Select the type of coordinates in which to perform the
           optimization. 'Auto' automatically selects the most
           appropriate CoordinateType for a given Method.

           If 'Auto' is selected, Delocalized coordinates will be used
           for the Quasi-Newton method, while Cartesian coordinates
           will be used for all other methods.

         * **KeepIntermediateResults** (*BoolType** | **BoolKey*) --
           Whether the full engine result files of all intermediate
           steps are stored on disk. By default only the last step is
           kept, and only if the geometry optimization converged. This
           can easily lead to huge amounts of data being stored on
           disk, but it can sometimes be convenient to closely monitor
           a tricky optimization, e.g. excited state optimizations
           going through conical intersections, etc. ...

         * **MaxIterations** (*int** | **IntKey*) -- The maximum
           number of geometry iterations allowed to converge to the
           desired structure.

         * **MaxRestarts** (*int** | **IntKey*) -- If a geometry
           optimization of a system with no symmetry operators (or
           with explicitly disabled symmetry: "UseSymmetry False") and
           enabled PES point characterization converges to a
           transition state (or higher order saddle point), it can be
           restarted automatically after a small displacement along
           the imaginary vibrational mode. In case the restarted
           optimization again does not find a minimum, this can happen
           multiple times in succession. This keyword sets the maximum
           number of restarts. The default value is 0, so the
           automatic restarting is disabled by default.

         * **Method** (*Literal**[**"Auto"**, **"Quasi-Newton"**,
           **"FIRE"**, **"L-BFGS"**, **"ConjugateGradients"**,
           **"Dimer"**]*) --

           Select the optimization algorithm employed for the geometry
           relaxation. Currently supported are:

           the Hessian-based Quasi-Newton-type BFGS algorithm,

           the fast inertial relaxation method (FIRE),

           the limited-memory BFGS method,

           and the conjugate gradients method. The default is to
           choose an appropriate method automatically based on the
           engine's speed, the system size and the supported
           optimization options.

         * **OptimizeLattice** (*BoolType** | **BoolKey*) -- Whether
           to also optimize the lattice for periodic structures. This
           is currently supported with the Quasi-Newton, FIRE, and
           L-BFGS optimizers.

         * **PretendConverged** (*BoolType** | **BoolKey*) -- Normally
           a non-converged geometry optimization is considered an
           error. If this keyword is set to True, the optimizer will
           only produce a warning and still claim that the
           optimization is converged. (This is mostly useful for
           scripting applications, where one might want to consider
           non-converged optimizations still successful jobs.)

         * **RestartDisplacement** (*float** | **FloatKey*) -- If a
           geometry optimization of a system with no symmetry
           operators (or with explicitly disabled symmetry:
           "UseSymmetry False") and enabled PES point characterization
           converges to a transition state (or higher order saddle
           point), it can be restarted automatically after a small
           displacement along the imaginary vibrational mode. This
           keywords sets the size of the displacement for the furthest
           moving atom.

         * **Convergence** (*AMS._GeometryOptimization._Convergence*)
           -- Convergence is monitored for up to 4 quantities: the
           energy change, the Cartesian gradients, the Cartesian step
           size, and for lattice optimizations the stress energy per
           atom. Convergence criteria can be specified separately for
           each of these items.

         * **Dimer** (*AMS._GeometryOptimization._Dimer*) -- Options
           for the Dimer method for transition state search.

         * **EngineAutomations**
           (*AMS._GeometryOptimization._EngineAutomations*) -- The
           optimizer can change some settings of the engine, based for
           instance on the error. The idea is to allow the engine to
           be a bit quicker at the start, and more accurate towards
           the end. Automations are always engine specific.

         * **FIRE** (*AMS._GeometryOptimization._FIRE*) -- This block
           configures the details of the FIRE optimizer. The keywords
           name correspond the the symbols used in the article
           describing the method, see PRL 97, 170201 (2006).

         * **HessianFree** (*AMS._GeometryOptimization._HessianFree*)
           -- Configures details of the Hessian-free (conjugate
           gradients or L-BFGS) geometry optimizer.

         * **InitialHessian**
           (*AMS._GeometryOptimization._InitialHessian*) -- Options
           for initial model Hessian when optimizing systems with the
           Quasi-Newton method.

         * **Quasi-Newton** (*AMS._GeometryOptimization._Quasi-
           Newton*) -- Configures details of the Quasi-Newton geometry
           optimizer.

      class _Convergence

         Convergence is monitored for up to 4 quantities: the energy
         change, the Cartesian gradients, the Cartesian step size, and
         for lattice optimizations the stress energy per atom.
         Convergence criteria can be specified separately for each of
         these items.

         Variables:
            * **Energy** (*float** | **FloatKey*) -- The criterion for
              changes in the energy. The energy is considered
              converged when the change in energy is smaller than this
              threshold times the number of atoms.

            * **Gradients** (*float** | **FloatKey*) -- Threshold for
              nuclear gradients.

            * **Quality** (*Literal**[**"VeryBasic"**, **"Basic"**,
              **"Normal"**, **"Good"**, **"VeryGood"**,
              **"Excellent"**, **"Custom"**]*) -- A quick way to
              change convergence thresholds: 'Good' will reduce all
              thresholds by an order of magnitude from their default
              value. 'VeryGood' will tighten them by two orders of
              magnitude. 'Basic' and 'VeryBasic' will increase the
              thresholds by one or two orders of magnitude
              respectively.

            * **Step** (*float** | **FloatKey*) -- The maximum
              Cartesian step allowed for a converged geometry.

            * **StressEnergyPerAtom** (*float** | **FloatKey*) --
              Threshold used when optimizing the lattice vectors. The
              stress is considered 'converged' when the maximum value
              of stress_tensor * cell_volume / number_of_atoms is
              smaller than this threshold (for 2D and 1D systems, the
              cell_volume is replaced by the cell_area and cell_length
              respectively).

      class _Dimer

         Options for the Dimer method for transition state search.

         Variables:
            * **AngleThreshold** (*float** | **FloatKey*) -- The
              rotation is considered converged when the the rotation
              angle falls below the specified threshold.

            * **DimerDelta** (*float** | **FloatKey*) -- Euclidian
              distance between the midpoint and the endpoint.

            * **ExtrapolateForces** (*BoolType** | **BoolKey*) -- Set
              to false to call engine to calculate forces at the
              extrapolated rotation angle instead of extrapolating
              them.

            * **LBFGSMaxVectors** (*int** | **IntKey*) -- Max number
              of vectors for the L-BFGS algorithm to save.

            * **MaxRotationIterations** (*int** | **IntKey*) --
              Maximum number of rotation iterations for a single
              translation step.

            * **Region** (*str** | **StringKey*) -- Include only atoms
              of the specified region(s) in the rotations, which
              allows searching for a transition state involving
              selected atoms only.

            * **RotationTrustRadius** (*float** | **FloatKey*) --
              L-BFGS trust radius during rotation iterations.

            * **TranslationTrustRadius** (*float** | **FloatKey*) --
              L-BFGS trust radius during translation iterations.

      class _EngineAutomations

         The optimizer can change some settings of the engine, based
         for instance on the error. The idea is to allow the engine to
         be a bit quicker at the start, and more accurate towards the
         end. Automations are always engine specific.

         Variables:
            * **Enabled** (*BoolType** | **BoolKey*) -- Whether or not
              automations are enabled at all.

            * **Gradient** (*AMS._GeometryOptimization._EngineAutomat
              ions._Gradient*) -- A gradient-based automation.

            * **Iteration** (*AMS._GeometryOptimization._EngineAutoma
              tions._Iteration*) -- Geometry step based automation.

         class _Gradient

            A gradient-based automation.

            Variables:
               * **FinalValue** (*float** | **FloatKey*) -- This value
                 will be used whenever the gradient is less than
                 GradientLow

               * **HighGradient** (*float** | **FloatKey*) -- Defines
                 a large gradient. When the actual gradient is between
                 GradientHigh and GradientLow a linear interpolation
                 scheme is used for kT (on a log scale).

               * **InitialValue** (*float** | **FloatKey*) -- This
                 value will be used at the first geometry, and
                 whenever the gradient is higher than GradientHigh

               * **LowGradient** (*float** | **FloatKey*) -- Defines a
                 small gradient, see GradientHigh

               * **UseLogInterpolation** (*BoolType** | **BoolKey*) --
                 Whether to use interpolation on a log (y) scale or
                 not

               * **Variable** (*str** | **StringKey*) -- variable to
                 be tweaked for the engine.

         class _Iteration

            Geometry step based automation.

            Variables:
               * **FinalValue** (*float** | **FloatKey*) --

               * **FirstIteration** (*int** | **IntKey*) -- When the
                 actual gradient is between the first and last
                 iteration, a linear interpolation is used.

               * **InitialValue** (*float** | **FloatKey*) -- This
                 value will be used when the iteration number is
                 smaller or equal to FirstIteration

               * **LastIteration** (*int** | **IntKey*) -- Where the
                 automation should reach the FinalValue

               * **UseLogInterpolation** (*BoolType** | **BoolKey*) --
                 Whether to use interpolation on a log (y) scale or
                 not

               * **Variable** (*str** | **StringKey*) -- variable to
                 be tweaked for the engine.

      class _FIRE

         This block configures the details of the FIRE optimizer. The
         keywords name correspond the the symbols used in the article
         describing the method, see PRL 97, 170201 (2006).

         Variables:
            * **AllowOverallRotation** (*BoolType** | **BoolKey*) --
              Whether or not the system is allowed to freely rotate
              during the optimization. This is relevant when
              optimizing structures in the presence of external
              fields.

            * **AllowOverallTranslation** (*BoolType** | **BoolKey*)
              -- Whether or not the system is allowed to translate
              during the optimization. This is relevant when
              optimizing structures in the presence of external
              fields.

            * **MapAtomsToUnitCell** (*BoolType** | **BoolKey*) -- Map
              the atoms to the central cell at each geometry step.

            * **NMin** (*int** | **IntKey*) -- Number of steps after
              stopping before increasing the time step again.

            * **alphaStart** (*float** | **FloatKey*) -- Steering
              coefficient.

            * **atomMass** (*float** | **FloatKey*) -- Fictitious
              atomic mass used for all atoms. There is no reason to
              change this, as it just corresponds to using a different
              integration timestep.

            * **dtMax** (*float** | **FloatKey*) -- Maximum time step
              used for the integration. For ReaxFF and APPLE&P, this
              value is reduced by 50%.

            * **dtStart** (*float** | **FloatKey*) -- Initial time
              step for the integration.

            * **fAlpha** (*float** | **FloatKey*) -- Reduction factor
              for the steering coefficient.

            * **fDec** (*float** | **FloatKey*) -- Reduction factor
              for reducing the time step in case of uphill movement.

            * **fInc** (*float** | **FloatKey*) -- Growth factor for
              the integration time step.

            * **strainMass** (*float** | **FloatKey*) -- Fictitious
              relative mass of the lattice degrees of freedom. This
              controls the stiffness of the lattice degrees of freedom
              relative to the atomic degrees of freedom, with smaller
              values resulting in a more aggressive optimization of
              the lattice.

      class _HessianFree

         Configures details of the Hessian-free (conjugate gradients
         or L-BFGS) geometry optimizer.

         Variables:
            **Step** (*AMS._GeometryOptimization._HessianFree._Step*)
            --

         class _Step

            Variables:
               * **MaxCartesianStep** (*float** | **FloatKey*) --
                 Limit on a single Cartesian component of the step.

               * **MinRadius** (*float** | **FloatKey*) -- Minimum
                 value for the trust radius.

               * **TrialStep** (*float** | **FloatKey*) -- Length of
                 the finite-difference step when determining
                 curvature. Should be smaller than the step
                 convergence criterion.

               * **TrustRadius** (*float** | **FloatKey*) -- Initial
                 value of the trust radius.

      class _InitialHessian

         Options for initial model Hessian when optimizing systems
         with the Quasi-Newton method.

         Variables:
            * **File** (*str** | **Path** | **StringKey*) -- KF file
              containing the initial Hessian (or the results dir.
              containing it). This can be used to load a Hessian
              calculated in a previously with the [Properties%Hessian]
              keyword.

            * **Type** (*Literal**[**"Auto"**, **"UnitMatrix"**,
              **"Swart"**, **"FromFile"**, **"Calculate"**,
              **"CalculateWithFastEngine"**]*) -- Select the type of
              initial Hessian. Auto: let the program pick an initial
              model Hessian. UnitMatrix: simplest initial model
              Hessian, just a unit matrix in the optimization
              coordinates. Swart: model Hessian from M. Swart.
              FromFile: load the Hessian from the results of a
              previous calculation (see InitialHessian%File).
              Calculate: compute the initial Hessian (this may be
              computationally expensive and it is mostly recommended
              for TransitionStateSearch calculations).
              CalculateWithFastEngine: compute the initial Hessian
              with a faster engine.

      class _Quasi_Newton

         Configures details of the Quasi-Newton geometry optimizer.

         Variables:
            * **EnforceConstraints** (*BoolType** | **BoolKey*) --
              Whether to enforce constraints at each steps exactly or
              add them to the optimization space as Lagrange
              multipliers.

            * **MaxGDIISVectors** (*int** | **IntKey*) -- Sets the
              maximum number of GDIIS vectors. Setting this to a
              number >0 enables the GDIIS method.

            * **UpdateTSVectorEveryStep** (*BoolType** | **BoolKey*)
              -- Whether to update the TS reaction coordinate at each
              step with the current eigenvector.

            * **Step** (*AMS._GeometryOptimization._Quasi-
              Newton._Step*) --

         class _Step

            Variables:
               * **TrustRadius** (*float** | **FloatKey*) -- Initial
                 value of the trust radius.

               * **VaryTrustRadius** (*BoolType** | **BoolKey*) --
                 Whether to allow the trust radius to change during
                 optimization. By default True during energy
                 minimization and False during transition state
                 search.

   class _IEEEExceptions

      Whether this works or not depends on the way the program is
      compiled (compiler and settings). Only useful for developers
      debugging some numerical issue.

      Variables:
         * **All** (*BoolType** | **BoolKey*) -- Activates all
           IEEEExceptions known to ams, see list below. The
           corresponding environment variable is
           SCM_IEEEException_All.

         * **DivideByZero** (*BoolType** | **BoolKey*) -- Stop program
           when a divide by zero exception occurs. The corresponding
           environment variable is SCM_IEEEException_DivideByZero.

         * **Invalid** (*BoolType** | **BoolKey*) -- Stop program when
           an invalid exception occurs. This may be about sqrt(-1).,
           or 0/0, and generally leads to a NaN. The corresponding
           environment variable is SCM_IEEEException_Invalid.

         * **Overflow** (*BoolType** | **BoolKey*) -- Stop program
           when an overflow exception occurs. The corresponding
           environment variable is SCM_IEEEException_Overflow

         * **Print** (*BoolType** | **BoolKey*) -- Print feedback on
           activated IEEEExceptions in the logfile. The corresponding
           environment variable is SCM_IEEEException_Print.

   class _IRC

      Configures details of the Intrinsic Reaction Coordinate
      optimization.

      Variables:
         * **CoordinateType** (*Literal**[**"Cartesian"**,
           **"Delocalized"**]*) -- Select the type of coordinates in
           which to perform the optimization. Note that the
           Delocalized option should be considered experimental.

         * **Direction** (*Literal**[**"Both"**, **"Forward"**,
           **"Backward"**]*) -- Select direction of the IRC path. The
           difference between the Forward and the Backward directions
           is determined by the sign of the largest component of the
           vibrational normal mode corresponding to the reaction
           coordinate at the transition state geometry. The Forward
           path correspond to the positive sign of the component. If
           Both is selected then first the Forward path is computed
           followed by the Backward one.

         * **KeepConvergedResults** (*BoolType** | **BoolKey*) -- Keep
           the binary RKF result file for every converged IRC point.
           These files may contain more information than the main
           ams.rkf result file.

         * **MaxIRCSteps** (*int** | **IntKey*) -- Soft limit on the
           number of IRC points to compute in each direction. After
           the specified number of IRC steps the program will switch
           to energy minimization and complete the path. This option
           should be used when you are interested only in the reaction
           path area near the transition state. Note that even if the
           soft limit has been hit and the calculation has completed,
           the IRC can still be restarted with a 'RedoBackward' or
           'RedoForward' option.

         * **MaxIterations** (*int** | **IntKey*) -- The maximum
           number of geometry iterations allowed to converge the inner
           IRC loop. If optimization does not converge within the
           specified number of steps, the calculation is aborted.

         * **MaxPoints** (*int** | **IntKey*) -- Hard limit on the
           number of IRC points to compute in each direction. After
           the specified number of IRC steps the program will stop
           with the current direction and switch to the next one. If
           both 'MaxPoints' and 'MaxIRCSteps' are set to the same
           value then 'MaxPoints' takes precedence, therefore this
           option should be used to set a limit on the number of IRC
           steps if you intend to use the results later for a restart.

         * **MinEnergyProfile** (*BoolType** | **BoolKey*) --
           Calculate minimum energy profile (i.e. no mass-weighting)
           instead of the IRC.

         * **MinPathLength** (*float** | **FloatKey*) -- Minimum
           length of the path required before switching to energy
           minimization. Use this to overcome a small kink or a
           shoulder on the path.

         * **Step** (*float** | **FloatKey*) -- IRC step size in mass-
           weighted coordinates, sqrt(amu)*bohr. One may have to
           increase this value when heavy atoms are involved in the
           reaction, or decrease it if the reactant or products are
           very close to the transition state.

         * **Convergence** (*AMS._IRC._Convergence*) -- Convergence at
           each given point is monitored for two items: the Cartesian
           gradient and the calculated step size. Convergence criteria
           can be specified separately for each of these items. The
           same criteria are used both in the inner IRC loop and when
           performing energy minimization at the path ends.

         * **InitialHessian** (*AMS._IRC._InitialHessian*) -- Options
           for initial Hessian at the transition state. The first
           eigenvalue of the initial Hessian defines direction of the
           first forward or backward step. This block is ignored when
           restarting from a previous IRC calculation because the
           initial Hessian found in the restart file is used.

         * **Restart** (*AMS._IRC._Restart*) -- Restart options. Upon
           restart, the information about the IRC input parameters and
           the initial system (atomic coordinates, lattice, charge,
           etc.) is read from the restart file. The IRC input
           parameters can be modified from input. Except for
           'MaxPoints' and 'Direction' all parameters not specified in
           the input will use their values from the restart file. The
           'MaxPoints' and 'Direction' will be reset to their
           respective default values if not specified in the input. By
           default, the IRC calculation will continue from the point
           where it left off. However, the 'RedoForward' and/or
           'RedoBackward' option can be used to enforce recalculation
           of a part of the reaction path, for example, using a
           different 'Step' value.

      class _Convergence

         Convergence at each given point is monitored for two items:
         the Cartesian gradient and the calculated step size.
         Convergence criteria can be specified separately for each of
         these items. The same criteria are used both in the inner IRC
         loop and when performing energy minimization at the path
         ends.

         Variables:
            * **Gradients** (*float** | **FloatKey*) -- Convergence
              criterion for the max component of the residual energy
              gradient.

            * **Step** (*float** | **FloatKey*) -- Convergence
              criterion for the max component of the step in the
              optimization coordinates.

      class _InitialHessian

         Options for initial Hessian at the transition state. The
         first eigenvalue of the initial Hessian defines direction of
         the first forward or backward step. This block is ignored
         when restarting from a previous IRC calculation because the
         initial Hessian found in the restart file is used.

         Variables:
            * **File** (*str** | **Path** | **StringKey*) -- If 'Type'
              is set to 'FromFile' then in this key you should specify
              the RKF file containing the initial Hessian (or the ams
              results dir. containing it). This can be used to load a
              Hessian calculated previously with the
              'Properties%Hessian' keyword. If you want to also use
              this file for the initial geometry then also specify it
              in a 'LoadSystem' block.

            * **Type** (*Literal**[**"Calculate"**, **"FromFile"**]*)
              -- Calculate the exact Hessian for the input geometry or
              load it from the results of a previous calculation.

      class _Restart

         Restart options. Upon restart, the information about the IRC
         input parameters and the initial system (atomic coordinates,
         lattice, charge, etc.) is read from the restart file. The IRC
         input parameters can be modified from input. Except for
         'MaxPoints' and 'Direction' all parameters not specified in
         the input will use their values from the restart file. The
         'MaxPoints' and 'Direction' will be reset to their respective
         default values if not specified in the input. By default, the
         IRC calculation will continue from the point where it left
         off. However, the 'RedoForward' and/or 'RedoBackward' option
         can be used to enforce recalculation of a part of the
         reaction path, for example, using a different 'Step' value.

         Variables:
            * **File** (*str** | **Path** | **StringKey*) -- Name of
              an RKF restart file generated by a previous IRC
              calculation. Do not use this key to provide an RKF file
              generated by a TransitionStateSearch or a SinglePoint
              calculation, use the 'LoadSystem' block instead.

            * **RedoBackward** (*int** | **IntKey*) -- IRC step number
              to start recalculating the backward path from. By
              default, if the backward path has not been completed
              then start after the last completed step. If the
              backward path has been completed and the 'RedoBackward'
              is omitted then no point on the backward path will be
              recomputed.

            * **RedoForward** (*int** | **IntKey*) -- IRC step number
              to start recalculating the forward path from. By
              default, if the forward path has not been completed then
              start after the last completed step. If the forward path
              has been completed and the 'RedoForward' is omitted then
              no point on the forward path will be recomputed.

   class _Idle

      Configures details of the idle task, which does nothing for a
      specified amount of time.

      Variables:
         **Time** (*int** | **IntKey*) -- Controls how long AMS will
         be idle before exiting.

   class _LoadSystem

      Block that controls reading the chemical system from a KF file
      instead of the [System] block.

      Variables:
         * **File** (*str** | **Path** | **StringKey*) -- The path of
           the KF file from which to load the system. It may also be
           the results directory containing it.

         * **Section** (*str** | **StringKey*) -- The section on the
           KF file from which to load the system.

   class _Log

      Configures the debugging loggers. Syntax: 'Level LoggerName'.
      Possible Levels: All, Debug, Info, Warning, Error, Fatal.

   class _MolecularDynamics

      Configures molecular dynamics (with the velocity-Verlet
      algorithm) with and without thermostats. This block allows to
      specify the details of the molecular dynamics calculation.

      Variables:
         * **CalcPressure** (*BoolType** | **BoolKey*) --

           Calculate the pressure in periodic systems.

           This may be computationally expensive for some engines that
           require numerical differentiation.

           Some other engines can calculate the pressure for
           negligible additional cost and will always do so, even if
           this option is disabled.

         * **CopyRestartTrajectory** (*BoolType** | **BoolKey*) -- If
           the keyword Restart is present, the content of the
           restartfile is copied to the ams.rkf file.

         * **NSteps** (*int** | **IntKey*) -- The number of steps to
           be taken in the MD simulation.

         * **Restart** (*str** | **Path** | **StringKey*) -- The path
           to the ams.rkf file from which to restart the simulation.

         * **TimeStep** (*float** | **FloatKey*) -- The time
           difference per step.

         * **AddMolecules** (*AMS._MolecularDynamics._AddMolecules*)
           --

           This block controls adding molecules to the system (a.k.a.
           the Molecule Gun). Multiple occurrences of this block are
           possible.

           By default, molecules are added at random positions in the
           simulation box with velocity matching the current system
           temperature. The initial position can be modified using one
           of the following keywords: Coords, CoordsBox,
           FractionalCoords, FractionalCoordsBox. The Coords and
           FractionalCoords keys can optionally be accompanied by
           CoordsSigma or FractionalCoordsSigma, respectively.

         * **ApplyForce** (*AMS._MolecularDynamics._ApplyForce*) --
           The ApplyForce keyword can be used to apply an arbitrary
           constant force to a certain (subgroups of) atoms in the
           system

         * **ApplyVelocity** (*AMS._MolecularDynamics._ApplyVelocity*)
           -- The ApplyVelocity keyword can be used to move an
           arbitrary group of atoms in the system with a constant net
           velocity

         * **Barostat** (*AMS._MolecularDynamics._Barostat*) -- This
           block allows to specify the use of a barostat during the
           simulation.

         * **BinLog** (*AMS._MolecularDynamics._BinLog*) -- This block
           controls writing the BinLog section in ams.rkf, which
           contains the selected MD state scalars and tensors from
           every MD step. No per-atom data is written. If you need the
           per-atom data then you can set the sampling frequency to 1
           and get the required data from the MDHistory section. The
           tensors are written per component, that is, the pressure
           tensor is written as six variables: PressureTensor_xx,
           PressureTensor_yy, etc.. To reduce the file size, all data
           is written in blocks.

         * **BondBoost** (*AMS._MolecularDynamics._BondBoost*) --
           Forced reaction (bond boost) definitions. Multiple
           BondBoost blocks may be specified, which will be treated
           independently.

         * **CRESTMTD** (*AMS._MolecularDynamics._CRESTMTD*) -- Input
           for CREST metadynamics simulation.

         * **CVHD** (*AMS._MolecularDynamics._CVHD*) -- Input for the
           Collective Variable-driven HyperDynamics (CVHD).

         * **CheckTemperature**
           (*AMS._MolecularDynamics._CheckTemperature*) -- Check at
           every time step if the temperature has exceeded a
           threshold. If it has, it is assumed the system exploded,
           and the simulation will stop.

         * **Checkpoint** (*AMS._MolecularDynamics._Checkpoint*) --
           Sets the frequency for storing the entire MD state
           necessary for restarting the calculation.

         * **CosineShear** (*AMS._MolecularDynamics._CosineShear*) --
           Apply an external acceleration to all atoms of a fluid
           using a periodic (cosine) function along a selected
           coordinate axis. This induces a periodic shear flow profile
           which can be used to determine the viscosity.

         * **Deformation** (*AMS._MolecularDynamics._Deformation*) --
           Deform the periodic lattice of the system during the
           simulation.

         * **Gravity** (*AMS._MolecularDynamics._Gravity*) -- Apply a
           constant acceleration in -z.

         * **HeatExchange** (*AMS._MolecularDynamics._HeatExchange*)
           -- Input for the heat-exchange non-equilibrium MD (T-NEMD).

         * **InitialVelocities**
           (*AMS._MolecularDynamics._InitialVelocities*) -- Sets the
           frequency for printing to stdout and storing the molecular
           configuration on the .rkf file.

         * **MovingRestraints**
           (*AMS._MolecularDynamics._MovingRestraints*) -- Define a
           set of moving restraints.

         * **PRD** (*AMS._MolecularDynamics._PRD*) -- This block is
           used for Parallel Replica Dynamics simulations.

         * **Plumed** (*AMS._MolecularDynamics._Plumed*) -- Input for
           PLUMED (version 2.5.0). The parallel option is still
           experimental.

         * **Preserve** (*AMS._MolecularDynamics._Preserve*) --
           Periodically remove numerical drift accumulated during the
           simulation to preserve different whole-system parameters.

         * **Print** (*AMS._MolecularDynamics._Print*) -- This block
           controls the printing of additional information to stdout.

         * **ReactionBoost** (*AMS._MolecularDynamics._ReactionBoost*)
           --

           Define a series of transitions between different states of
           the system.

           Each transition is defined by a TargetSystem and by a set
           of restraints that force the transition.

         * **Reactor** (*AMS._MolecularDynamics._Reactor*) -- Define
           one phase of the nanoreactor. A reactor is a region of
           space surrounded by an elastic wall. Atoms inside the
           region are not affected. Atoms outside it will be pushed
           back with force depending on the [ForceConstant] and the
           [MassScaled] flag.

         * **ReflectiveWall**
           (*AMS._MolecularDynamics._ReflectiveWall*) -- Apply a
           reflective wall in space

         * **Remap** (*AMS._MolecularDynamics._Remap*) -- Control
           periodic remapping (backtranslation) of atoms into the PBC
           box.

         * **RemoveMolecules**
           (*AMS._MolecularDynamics._RemoveMolecules*) -- This block
           controls removal of molecules from the system. Multiple
           occurrences of this block are possible.

         * **ReplicaExchange**
           (*AMS._MolecularDynamics._ReplicaExchange*) -- This block
           is used for (temperature) Replica Exchange MD (Parallel
           Tempering) simulations.

         * **Shake** (*AMS._MolecularDynamics._Shake*) -- Parameters
           of the Shake/Rattle algorithm.

         * **Thermostat** (*AMS._MolecularDynamics._Thermostat*) --
           This block allows to specify the use of a thermostat during
           the simulation. Depending on the selected thermostat type,
           different additional options may be needed to characterize
           the specific thermostat's behavior.

         * **Trajectory** (*AMS._MolecularDynamics._Trajectory*) --
           Sets the frequency for printing to stdout and storing the
           molecular configuration on the .rkf file.

         * **fbMC** (*AMS._MolecularDynamics._fbMC*) -- This block
           sets up force bias Monte Carlo interleaved with the
           molecular dynamics simulation.

      class _AddMolecules

         This block controls adding molecules to the system (a.k.a.
         the Molecule Gun). Multiple occurrences of this block are
         possible.

         By default, molecules are added at random positions in the
         simulation box with velocity matching the current system
         temperature. The initial position can be modified using one
         of the following keywords: Coords, CoordsBox,
         FractionalCoords, FractionalCoordsBox. The Coords and
         FractionalCoords keys can optionally be accompanied by
         CoordsSigma or FractionalCoordsSigma, respectively.

         Variables:
            * **AtomTemperature** (*float** | **FloatKey*) -- Add
              random velocity corresponding to the specified
              temperature to individual atoms of the molecule. This
              only affects rotational and internal degrees of freedom,
              not the net translational velocity of the inserted
              molecule as set by the other options.

            * **ContactDistance** (*float** | **FloatKey*) --
              Translate the bullet along the velocity vector until it
              comes within ContactDistance of any other atom.

            * **Coords** (*Iterable**[**float**] **| **FloatListKey*)
              --

              Place molecules at or around the specified Cartesian
              coordinates.

              This setting takes precedence over other ways to specify
              initial coordinates of the molecule: [CoordsBox],
              [FractionalCoords], and [FractionalCoordsBox].

            * **CoordsBox** (*Iterable**[**float**] **|
              **FloatListKey*) --

              Place molecules at random locations inside the specified
              box in Cartesian coordinates.

              Coordinates of the box corners are specified as: Xmin,
              Xmax, Ymin, Ymax, Zmin, Zmax. This setting is ignored if
              Coords is used.

              In AMSinput, if this field is not empty it will be used
              instead of the default Coords.

            * **CoordsSigma** (*Iterable**[**float**] **|
              **FloatListKey*) -- Sigma values (one per Cartesian
              axis) for a Gauss distribution of the initial
              coordinates. Can only be used together with Coords.

            * **DeviationAngle** (*float** | **FloatKey*) -- Randomly
              tilt the shooting direction up to this angle away from
              the VelocityDirection vector.

            * **Energy** (*float** | **FloatKey*) -- Initial kinetic
              energy of the molecule in the shooting direction.

            * **EnergySigma** (*float** | **FloatKey*) -- Sigma value
              for the Gauss distribution of the initial kinetic energy
              around the specified value. Should only be used together
              with Energy.

            * **FractionalCoords** (*Iterable**[**float**] **|
              **FloatListKey*) -- Place molecules at or around the
              specified fractional coordinates in the main system's
              lattice. For non-periodic dimensions a Cartesian value
              in Angstrom is expected. This setting is ignored if
              [Coords] or [CoordsBox] is used.

            * **FractionalCoordsBox** (*Iterable**[**float**] **|
              **FloatListKey*) --

              Place molecules at random locations inside the box
              specified as fractional coordinates in the main system's
              lattice.

              Coordinates of the box corners are specified as: Xmin,
              Xmax, Ymin, Ymax, Zmin, Zmax.

              For non-periodic dimensions the Cartesian value in
              Angstrom is expected.

              This setting is ignored if [Coords], [CoordsBox], or
              [FractionalCoords] is used.

            * **FractionalCoordsSigma** (*Iterable**[**float**] **|
              **FloatListKey*) -- Sigma values (one per axis) for a
              Gauss distribution of the initial coordinates. For non-
              periodic dimensions the Cartesian value in Angstrom is
              expected. Can only be used together with
              FractionalCoords.

            * **Frequency** (*int** | **IntKey*) --

              A molecule is added every [Frequency] steps after the
              StartStep.

              There is never a molecule added at step 0.

            * **MinDistance** (*float** | **FloatKey*) -- Keep the
              minimal distance to other atoms of the system when
              adding the molecule.

            * **MoleFraction** (*float** | **FloatKey*) --

              Defines a mixture to be deposited using one AddMolecules
              block per component.

              AMS will randomly alternate between any guns that have
              MoleFraction set. These need to all have the same
              settings for StartStep, StopStep and Frequency. Any
              additional AddMolecules blocks without MoleFraction will
              remain completely independent.

            * **NumAttempts** (*int** | **IntKey*) -- Try adding the
              molecule up to the specified number of times or until
              the MinDistance constraint is satisfied. If all attempts
              fail a message will be printed and the simulation will
              continue normally.

            * **Rotate** (*BoolType** | **BoolKey*) -- Rotate the
              molecule randomly before adding it to the system.

            * **StartStep** (*int** | **IntKey*) --

              Step number when the first molecule should be added.
              After that, molecules are added every Frequency steps.

              For example, ff StartStep=99 and Frequency=100 then a
              molecule will be added at steps 99, 199, 299, etc...

              No molecule will be added at step 0, so if StartStep=0
              the first molecule is added at the step number equal to
              [Frequency].

            * **StopStep** (*int** | **IntKey*) -- Do not add this
              molecule after the specified step.

            * **System** (*str** | **StringKey*) --

              String ID of the [System] that will be added with this
              'gun'.

              The lattice specified with this System is ignored and
              the main system's lattice is used instead.

              AMSinput adds the system at the coordinates of the
              System (thus setting Coords to the center of the
              System).

            * **Temperature** (*float** | **FloatKey*) -- Initial
              energy of the molecule in the shooting direction will
              correspond to the given temperature.

            * **TemperatureSigma** (*float** | **FloatKey*) -- Sigma
              value for the Gauss distribution of the initial
              temperature the specified value. Should only be used
              together with Temperature.

            * **Velocity** (*float** | **FloatKey*) -- Initial
              velocity of the molecule in the shooting direction.

            * **VelocityDirection** (*Iterable**[**float**] **|
              **FloatListKey*) --

              Velocity direction vector for aimed shooting. It will be
              random if not specified.

              In AMSinput add one or two atoms (which may be dummies).

              One atom: use vector from center of the system to add to
              that atom.

              Two atoms: use vector from the first to the second atom.

            * **VelocitySigma** (*float** | **FloatKey*) -- Sigma
              value for the Gauss distribution of the initial velocity
              around the specified value. Should only be used together
              with Velocity.

      class _ApplyForce

         The ApplyForce keyword can be used to apply an arbitrary
         constant force to a certain (subgroups of) atoms in the
         system

         Variables:
            * **CalculateViscosity** (*BoolType** | **BoolKey*) --
              Calculates Viscosity property yes/no. If yes is chosen,
              the global viscosity of the system is calculated and
              written into the RKF-file. The formula used for the
              viscosity calculation is eta = - Pxz / (dVx/dz)

            * **CalculateViscosityBins** (*int** | **IntKey*) --
              Amount of bins used to determine (dVx/dz)

            * **CalculateViscosityEnd** (*int** | **IntKey*) -- end
              index to select region in space to calculate (dVx/dz)

            * **CalculateViscosityStart** (*int** | **IntKey*) --
              Start index to select region in space to calculate
              (dVx/dz)

            * **Force** (*Iterable**[**float**] **| **FloatListKey*)
              -- Defines the constant force vector

            * **PerAtom** (*BoolType** | **BoolKey*) -- If enabled,
              the Force vector is applied separately to every atom in
              the selected Region, so that the total net force on the
              Region equals the value of Force times the number of
              atoms in Region. This was the behavior of ApplyForce in
              AMS2022. By default, with PerAtom disabled, the Force
              vector defines the total net force on the Region, so the
              force applied to each atom equals the value of Force
              divided by the number of atoms in Region.

            * **Region** (*str** | **StringKey*) -- Apply the constant
              force to all atoms in this region.

      class _ApplyVelocity

         The ApplyVelocity keyword can be used to move an arbitrary
         group of atoms in the system with a constant net velocity

         Variables:
            * **CalculateViscosity** (*BoolType** | **BoolKey*) --
              Calculates Viscosity property yes/no. If yes is chosen,
              the global viscosity of the system is calculated and
              written into the RKF-file. The formula used for the
              viscosity calculation is eta = - Pxz / (dVx/dz)

            * **CalculateViscosityBins** (*int** | **IntKey*) --
              Amount of bins used to determine (dVx/dz)

            * **CalculateViscosityEnd** (*int** | **IntKey*) -- end
              index to select region in space to calculate (dVx/dz)

            * **CalculateViscosityStart** (*int** | **IntKey*) --
              Start index to select region in space to calculate
              (dVx/dz)

            * **Components** (*Literal**[**"X"**, **"Y"**, **"Z"**,
              **"XY"**, **"YZ"**, **"XZ"**, **"XYZ"**]*) -- Select
              which components of the Velocity vector are used to set
              the corresponding components of the net velocity of the
              specified set of atoms. Any other components of Velocity
              are ignored and the motion of the selected atoms in
              those directions is unaffected by ApplyVelocity.

            * **Region** (*str** | **StringKey*) -- Applies the
              defined velocity to all atoms in this region.

            * **Velocity** (*Iterable**[**float**] **|
              **FloatListKey*) -- The constant velocity that will be
              applied to the specified atoms.

      class _Barostat

         This block allows to specify the use of a barostat during the
         simulation.

         Variables:
            * **BulkModulus** (*float** | **FloatKey*) --

              An estimate of the bulk modulus (inverse
              compressibility) of the system for the Berendsen
              barostat.

              This is only used to make Tau correspond to the true
              observed relaxation time constant. Values are commonly
              on the order of 10-100 GPa (1e10 to 1e11) for solids and
              1 GPa (1e9) for liquids (2.2e9 for water). Use 1e9 to
              match the behavior of standalone ReaxFF.

            * **ConstantVolume** (*BoolType** | **BoolKey*) --

              Keep the volume constant while allowing the box shape to
              change.

              This is currently supported only by the MTK barostat.

            * **Duration** (*Iterable**[**int**] **| **IntListKey*) --
              Specifies how many steps should a transition from a
              particular pressure to the next one in sequence take.

            * **Equal** (*Literal**[**"None"**, **"XYZ"**, **"XY"**,
              **"YZ"**, **"XZ"**]*) -- Enforce equal scaling of the
              selected set of dimensions. They will be barostatted as
              one dimension according to the average pressure over the
              components.

            * **Pressure** (*Iterable**[**float**] **|
              **FloatListKey*) --

              Specifies the target pressure.

              You can specify multiple pressures (separated by
              spaces). In that case the Duration field specifies how
              many steps to use for the transition from one p to the
              next p (using a linear ramp).

            * **Scale** (*Literal**[**"XYZ"**, **"Shape"**, **"X"**,
              **"Y"**, **"Z"**, **"XY"**, **"YZ"**, **"XZ"**]*) --
              Dimensions that should be scaled by the barostat to
              maintain pressure. Selecting Shape means that all three
              dimensions and also all the cell angles are allowed to
              change.

            * **Tau** (*float** | **FloatKey*) -- Specifies the time
              constant of the barostat.

            * **Type** (*Literal**[**"None"**, **"Berendsen"**,
              **"MTK"**]*) -- Selects the type of the barostat.

      class _BinLog

         This block controls writing the BinLog section in ams.rkf,
         which contains the selected MD state scalars and tensors from
         every MD step. No per-atom data is written. If you need the
         per-atom data then you can set the sampling frequency to 1
         and get the required data from the MDHistory section. The
         tensors are written per component, that is, the pressure
         tensor is written as six variables: PressureTensor_xx,
         PressureTensor_yy, etc.. To reduce the file size, all data is
         written in blocks.

         Variables:
            * **BiasEnergy** (*BoolType** | **BoolKey*) -- Write the
              CVHD bias energy at every time step.

            * **BoostFactor** (*BoolType** | **BoolKey*) -- Write the
              CVHD boost factor at every time step.

            * **ConservedEnergy** (*BoolType** | **BoolKey*) -- Write
              the conserved energy value at every time step.

            * **Density** (*BoolType** | **BoolKey*) -- Write the
              density at every time step.

            * **DipoleMoment** (*BoolType** | **BoolKey*) -- Write the
              dipole moment at every time step. Each component of the
              tensor is written in its own variable.

            * **Hypertime** (*BoolType** | **BoolKey*) -- Write the
              CVHD hypertime at every time step.

            * **KineticEnergy** (*BoolType** | **BoolKey*) -- Write
              the kinetic energy value at every time step.

            * **MaxBiasEnergy** (*BoolType** | **BoolKey*) -- Write
              the max CVHD bias energy at every time step.

            * **MaxBoostFactor** (*BoolType** | **BoolKey*) -- Write
              the max CVHD boost factor at every time step.

            * **PotentialEnergy** (*BoolType** | **BoolKey*) -- Write
              the potential energy value at every time step.

            * **Pressure** (*BoolType** | **BoolKey*) -- Write the
              pressure at every time step.

            * **PressureTensor** (*BoolType** | **BoolKey*) -- Write
              the pressure tensor in Voigt notation at every time
              step. Each component of the tensor is written in its own
              variable.

            * **Step** (*BoolType** | **BoolKey*) -- Write the step
              index during the simulation at every time step.

            * **Temperature** (*BoolType** | **BoolKey*) -- Write the
              temperature at every time step.

            * **Time** (*BoolType** | **BoolKey*) -- Write the
              simulation time (fs) at every time step.

            * **TotalEnergy** (*BoolType** | **BoolKey*) -- Write the
              total energy value at every time step.

            * **Volume** (*BoolType** | **BoolKey*) -- Write the
              simulation cell volume, area or length, depending on the
              system periodicity, at every time step.

      class _BondBoost

         Forced reaction (bond boost) definitions. Multiple BondBoost
         blocks may be specified, which will be treated independently.

         Variables:
            * **AddBond** (*str** | **StringKey*) -- [Reserved] Add a
              bond to the system or change its order. Specify two atom
              indices followed by the bond's order. The indices
              indicate positions of the atoms in the AtomNames key.
              Currently no engine will honor bond changes caused by
              this key.

            * **DistanceRestraint** (*str** | **StringKey*) --

              Specify two atom indices followed by the target distance
              in Angstrom, the first parameter and, optionally, the
              profile type and the second parameter.

              For periodic systems, restraints follow the minimum
              image convention.

              Each atom index indicates a position of the
              corresponding atom in the AtomNames key. Currently
              recognized restraint profile types: Harmonic (default),
              Hyperbolic, Erf, GaussianWell. The profile name can
              optionally be prefixed by "OneSided-", thus making this
              particular restraint one-sided. A one-sided restraint
              will only push or pull the distance towards its target
              value depending on the sign of the difference between
              the initial and the target distance. For example, if the
              initial distance is larger than the target one then the
              restraint will only push the value down. This is
              especially useful with moving restraints because then
              the restraint will effectively disappear as soon as the
              system crosses a barrier along the reaction path. By
              default, the restraints are two-sided, which means they
              will try to keep the distance between the two specified
              atoms near the (possibly moving) target value. For
              moving restraints, this means that after crossing a
              reaction barrier the system will slide slowly towards
              products held back by the restraints.

              The first parameter is the force constant for the
              Harmonic, Hyperbolic, and Erf profiles, or well depth
              for GaussianWell. The second parameter is the asymptotic
              force value F(Inf) for Hyperbolic and Erf profiles, or
              the factor before x^2 in the exponent for GaussianWell.

              Note: the GaussianWell restraint should be used with the
              Moving flag.

            * **Moving** (*BoolType** | **BoolKey*) --

              Move the restraints created with this BondBoost. The
              restraint value will start at the current coordinate's
              value and will move towards the optimum during the
              restraint's lifetime. The increment is calculated from
              the initial deviation and the [NSteps] parameter.

              This feature should be used with the GaussianWell
              restraint types.

            * **NSteps** (*int** | **IntKey*) -- Number of steps the
              restraints will remain active until removed. Atoms
              participating in one reaction are not available for the
              given number of steps.

            * **NumInstances** (*int** | **IntKey*) -- Number of
              reactions of this type taking place simultaneously.

            * **RemoveBond** (*str** | **StringKey*) -- [Reserved]
              Remove a bond from the system. Specify two atom indices.
              The indices indicate positions of the atoms in the
              AtomNames key. Currently no engine will honor bond
              changes caused by this key.

            * **SetAtomName** (*str** | **StringKey*) -- Change the
              specified atom's name. Specify atom index followed by
              the new name. The index indicates position of the atom
              in the AtomNames key. Note: this action will change the
              atom name only and not other properties (element name,
              mass, etc.). This may be useful to change atom names to
              affect future chain detections. The atom name length is
              limited to 32 characters.

            * **Units** (*Literal**[**"Default"**, **"MD"**]*) --
              Change energy, force and force constant units in the
              DistanceRestraint key from the default (atomic units) to
              those often used in the MD community (based on kcal/mol
              and Angstrom). Units for the optimum distances are not
              affected.

            * **Chain** (*AMS._MolecularDynamics._BondBoost._Chain*)
              -- Specifications of a chain of atoms. When a chain is
              detected the distance restraints will be activated. No
              other chain of this type will be detected while any
              restraints for this chain is active.

         class _Chain

            Specifications of a chain of atoms. When a chain is
            detected the distance restraints will be activated. No
            other chain of this type will be detected while any
            restraints for this chain is active.

            Variables:
               * **AtomNames** (*str** | **StringKey*) -- Atom names
                 specifying the chain. An atom name can optionally be
                 followed by '@' and a region name, in this case only
                 atoms of this type from the given region will be
                 matched. A leading '@' followed by a number indicates
                 that this position in the chain must be occupied by
                 the atom found earlier at the specified position in
                 the chain. For example "O H N C @1" indicates that
                 the last atom in the chain of the five atoms must be
                 the first oxygen, thus defining a 4-membered ring.
                 This is the only way to define a ring because
                 implicit rings will not be detected. For example, "O
                 H N C O" does not include rings.

               * **MaxDistances** (*Iterable**[**float**] **|
                 **FloatListKey*) -- Maximum distances for each pair
                 of atoms in the chain. The number of distances must
                 be one less than the number of AtomNames.

               * **MinDistances** (*Iterable**[**float**] **|
                 **FloatListKey*) -- Minimum distances for each pair
                 of atoms in the chain. The number of distances must
                 be one less than the number of AtomNames.

      class _CRESTMTD

         Input for CREST metadynamics simulation.

         Variables:
            * **AddEnergy** (*BoolType** | **BoolKey*) -- Add the bias
              energy to the potential energy (to match the gradients)

            * **Height** (*float** | **FloatKey*) -- The height of the
              Gaussians added

            * **NGaussiansMax** (*int** | **IntKey*) -- Maximum number
              of Gaussians stored

            * **NSteps** (*int** | **IntKey*) -- Interval of Gaussian
              placement

            * **Region** (*str** | **StringKey*) -- Restrict the range
              of atoms for RMSD calculation to the specified region.

            * **RestartFile** (*str** | **Path** | **StringKey*) --
              Filename for file from which to read data on Gaussians
              placed previously.

            * **Width** (*float** | **FloatKey*) -- The width of the
              Gaussians added in terms of the RMSD

            * **GaussianScaling**
              (*AMS._MolecularDynamics._CRESTMTD._GaussianScaling*) --
              Options for gradual introduction of the Gaussians

         class _GaussianScaling

            Options for gradual introduction of the Gaussians

            Variables:
               * **ScaleGaussians** (*BoolType** | **BoolKey*) --
                 Introduce the Gaussians gradually, using a scaling
                 function

               * **ScalingSlope** (*float** | **FloatKey*) -- Slope of
                 the scaling function for the Gaussians with respect
                 to time

      class _CVHD

         Input for the Collective Variable-driven HyperDynamics
         (CVHD).

         Variables:
            * **Frequency** (*int** | **IntKey*) -- Frequency of
              adding a new bias peak, in steps.  New bias is deposited
              every [Frequency] steps after [StartStep] if the
              following conditions are satisfied:  the current CV
              value is less than 0.9 (to avoid creating barriers at
              the transition state),  the step number is greater than
              or equal to [StartStep], and  the step number is less
              than or equal to [StopStep].

            * **MaxEvents** (*int** | **IntKey*) -- Max number of
              events to allow during dynamics. When this number is
              reached no new bias will be added for this input block.

            * **StartStep** (*int** | **IntKey*) -- If this key is
              specified, the first bias will be deposited at this
              step. Otherwise, the first bias peak is added at the
              step number equal to the Frequency parameter. The bias
              is never deposited at step 0.

            * **StopStep** (*int** | **IntKey*) -- No bias will be
              deposited after the specified step. The already
              deposited bias will continue to be applied until the
              reaction event occurs. After that no new CVHD will be
              started. By default, the CVHD runs for the whole
              duration of the MD calculation.

            * **WaitSteps** (*int** | **IntKey*) -- If the CV value
              becomes equal to 1 and remains at this value for this
              many steps then the reaction event is considered having
              taken place. After this, the collective variable will be
              reset and the bias will be removed.

            * **Bias** (*AMS._MolecularDynamics._CVHD._Bias*) -- The
              bias is built from a series of Gaussian peaks deposited
              on the collective variable axis every [Frequency] steps
              during MD. Each peak is characterized by its (possibly
              damped) height and the RMS width (standard deviation).

            * **ColVarBB** (*AMS._MolecularDynamics._CVHD._ColVarBB*)
              -- Description of a bond-breaking collective variable
              (CV) as described in [Bal & Neyts, JCTC, 11 (2015)]. A
              collective variable may consist of multiple ColVar
              blocks.

            * **ColVarBM** (*AMS._MolecularDynamics._CVHD._ColVarBM*)
              -- Description of a bond-making collective variable
              (CV). A collective variable may consist of multiple
              ColVar blocks.

         class _Bias

            The bias is built from a series of Gaussian peaks
            deposited on the collective variable axis every
            [Frequency] steps during MD. Each peak is characterized by
            its (possibly damped) height and the RMS width (standard
            deviation).

            Variables:
               * **DampingTemp** (*float** | **FloatKey*) -- During
                 well-tempered hyperdynamics the height of the added
                 bias is scaled down with an exp(-E/kT) factor
                 [PhysRevLett 100, 020603 (2008)], where E is the
                 current value of the bias at the given CV value and T
                 is the damping temperature DampingTemp. If
                 DampingTemp is zero then no damping is applied.

               * **Delta** (*float** | **FloatKey*) -- Standard
                 deviation parameter of the Gaussian bias peak.

               * **Height** (*float** | **FloatKey*) -- Height of the
                 Gaussian bias peak.

         class _ColVarBB

            Description of a bond-breaking collective variable (CV) as
            described in [Bal & Neyts, JCTC, 11 (2015)]. A collective
            variable may consist of multiple ColVar blocks.

            Variables:
               * **cutoff** (*float** | **FloatKey*) -- Bond order
                 cutoff. Bonds with BO below this value are ignored
                 when creating the initial bond list for the CV. The
                 bond list does not change during lifetime of the
                 variable even if some bond orders drop below the
                 cutoff.

               * **p** (*int** | **IntKey*) -- Exponent value p used
                 to calculate the p-norm for this CV.

               * **rmax** (*float** | **FloatKey*) -- Max bond
                 distance parameter Rmax used for calculating the CV.
                 It should be close to the transition-state distance
                 for the corresponding bond.

               * **rmin** (*float** | **FloatKey*) -- Min bond
                 distance parameter Rmin used for calculating the CV.
                 It should be close to equilibrium distance for the
                 corresponding bond.

               * **at1**
                 (*AMS._MolecularDynamics._CVHD._ColVarBB._at1*) --
                 Specifies the first bonded atom in the collective
                 variable.

               * **at2**
                 (*AMS._MolecularDynamics._CVHD._ColVarBB._at2*) --
                 Specifies the second bonded atom in the collective
                 variable.

            class _at1

               Specifies the first bonded atom in the collective
               variable.

               Variables:
                  * **region** (*str** | **StringKey*) -- Restrict the
                    selection of bonded atoms to a specific region. If
                    this is not set, atoms anywhere in the system will
                    be selected.

                  * **symbol** (*str** | **StringKey*) -- Atom type
                    name of the first atom of the bond. The name must
                    be as it appears in the System block. That is, if
                    the atom name contains an extension (e.g C.1) then
                    the full name including the extension must be used
                    here.

            class _at2

               Specifies the second bonded atom in the collective
               variable.

               Variables:
                  * **region** (*str** | **StringKey*) -- Restrict the
                    selection of bonded atoms to a specific region. If
                    this is not set, atoms anywhere in the system will
                    be selected.

                  * **symbol** (*str** | **StringKey*) -- Atom type
                    name of the second atom of the bond. The value is
                    allowed to be the same as [at1], in which case
                    bonds between atoms of the same type will be
                    included.

         class _ColVarBM

            Description of a bond-making collective variable (CV). A
            collective variable may consist of multiple ColVar blocks.

            Variables:
               * **cutoff** (*float** | **FloatKey*) -- Bond order
                 cutoff. Bonds with BO above this value are ignored
                 when creating the initial atom-pair list for the CV.
                 The list does not change during lifetime of the
                 variable even if some bond orders rise above the
                 cutoff.

               * **p** (*int** | **IntKey*) -- Exponent value p used
                 to calculate the p-norm for this CV.

               * **rmax** (*float** | **FloatKey*) -- Max bond
                 distance parameter Rmax used for calculating the CV.
                 It should be much larger than the corresponding Rmin.

               * **rmin** (*float** | **FloatKey*) -- Min bond
                 distance parameter Rmin used for calculating the CV.
                 It should be close to the transition-state distance
                 for the corresponding bond.

               * **at1**
                 (*AMS._MolecularDynamics._CVHD._ColVarBM._at1*) --
                 Specifies selection criteria for the first atom of a
                 pair in the collective variable.

               * **at2**
                 (*AMS._MolecularDynamics._CVHD._ColVarBM._at2*) --
                 Specifies selection criteria for the second atom of a
                 pair in the collective variable.

            class _at1

               Specifies selection criteria for the first atom of a
               pair in the collective variable.

               Variables:
                  * **region** (*str** | **StringKey*) -- Restrict the
                    selection to a specific region. If this is not
                    set, atoms anywhere in the system will be
                    selected.

                  * **symbol** (*str** | **StringKey*) -- Atom type
                    name of the first atom of the pair. The name must
                    be as it appears in the System block. That is, if
                    the atom name contains an extension (e.g C.1) then
                    the full name including the extension must be used
                    here.

            class _at2

               Specifies selection criteria for the second atom of a
               pair in the collective variable.

               Variables:
                  * **region** (*str** | **StringKey*) -- Restrict the
                    selection to a specific region. If this is not
                    set, atoms anywhere in the system will be
                    selected.

                  * **symbol** (*str** | **StringKey*) -- Atom type
                    name of the second atom of the pair. The value is
                    allowed to be the same as [at1], in which case
                    pairs of atoms of the same type will be included.

      class _CheckTemperature

         Check at every time step if the temperature has exceeded a
         threshold. If it has, it is assumed the system exploded, and
         the simulation will stop.

         Variables:
            * **Enabled** (*BoolType** | **BoolKey*) -- If enabled,
              the simulation will stop if the temperature becomes too
              large.

            * **MaxTemperature** (*float** | **FloatKey*) -- Maximum
              temperature the system can have. If larger, the
              simulation will stop.

      class _Checkpoint

         Sets the frequency for storing the entire MD state necessary
         for restarting the calculation.

         Variables:
            * **Frequency** (*int** | **IntKey*) --

              Write the MD state to the Molecule and MDResults
              sections on ams.rkf once every N steps. Setting this to
              zero disables checkpointing during the simulation, but
              one checkpoint at the very end of the simulation will
              always be written.

              NOTE: This no longer controls the frequency of writing
              MDStep*.rkf files, set Trajectory%EngineResultsFreq
              instead.

            * **WriteProperties** (*BoolType** | **BoolKey*) --

              Honor top-level Properties input block when writing
              engine results files.

              DEPRECATED: This input option will be removed in AMS2026
              and will be considered always enabled. If you rely on it
              being disabled, please contact SCM support.

      class _CosineShear

         Apply an external acceleration to all atoms of a fluid using
         a periodic (cosine) function along a selected coordinate
         axis. This induces a periodic shear flow profile which can be
         used to determine the viscosity.

         Variables:
            * **Acceleration** (*float** | **FloatKey*) -- Amplitude
              of the applied cosine shear acceleration profile. The
              default value should be a rough first guess for water
              and it needs to be adjusted by experimentation for other
              systems.

            * **Enabled** (*BoolType** | **BoolKey*) -- Apply a cosine
              shear acceleration profile for a NEMD calculation of
              viscosity.

            * **FlowDirection** (*Iterable**[**float**] **|
              **FloatListKey*) -- The direction in which to apply the
              shear acceleration, in Cartesian coordinates. The
              magnitude of this vector is ignored (AMS will normalize
              it internally). FlowDirection has to be perpendicular to
              ProfileAxis.

            * **ProfileAxis** (*Literal**[**"X"**, **"Y"**, **"Z"**]*)
              -- The Cartesian coordinate axis along which the cosine
              wave runs

      class _Deformation

         Deform the periodic lattice of the system during the
         simulation.

         Variables:
            * **LengthRate** (*Iterable**[**float**] **|
              **FloatListKey*) -- Relative rate of change of each
              lattice vector per step.

            * **LengthVelocity** (*Iterable**[**float**] **|
              **FloatListKey*) -- Change the length of each lattice
              vector with this velocity. With Type=Exponential,
              LengthVelocity is divided by the current lattice vector
              lengths on StartStep to determine a LengthRate, which is
              then applied on all subsequent steps. For Type Sine and
              Cosine, this defines the maximum velocity (at the
              inflection point).

            * **Period** (*float** | **FloatKey*) -- Period of
              oscillation for Type Sine and Cosine.

            * **ScaleAtoms** (*BoolType** | **BoolKey*) -- Scale the
              atomic positions together with the lattice vectors.
              Disable this to deform only the lattice, keeping the
              coordinates of atoms unchanged.

            * **StartStep** (*int** | **IntKey*) -- First step at
              which the deformation will be applied.

            * **StopStep** (*int** | **IntKey*) -- Last step at which
              the deformation will be applied. If unset or zero,
              nSteps will be used instead.

            * **TargetDensity** (*float** | **FloatKey*) --

              Target density of the system to be achieved by StopStep
              by isotropically rescaling the lattice.

              This can only be used for 3D-periodic systems. Note that
              the selected Type determines how the lengths of the
              lattice vectors will evolve (linearly or as a
              sine/cosine), the evolution of the volume or density is
              thus necessarily non-linear.

            * **TargetLength** (*Iterable**[**float**] **|
              **FloatListKey*) -- Target lengths of each lattice
              vector to be achieved by StopStep. The number of values
              should equal the periodicity of the system. If a value
              is zero, the corresponding lattice vector will not be
              modified.

            * **Type** (*Literal**[**"Linear"**, **"Exponential"**,
              **"Sine"**, **"Cosine"**]*) --

              Function defining the time dependence of the deformed
              lattice parameters.

              Linear increments the lattice parameters by the same
              absolute amount every timestep. Exponential multiplies
              the lattice parameters by the same factor every
              timestep. Only StrainRate, LengthRate, and
              LengthVelocity are supported for Type=Exponential. Sine
              deforms the system from the starting lattice to
              TargetLattice/TargetLength and then by the same amount
              to the opposite direction, while Cosine deforms the
              system from the starting lattice to the target and back.

            * **LatticeVelocity** (*str** | **Sequence**[**str**] **|
              **FreeBlock*) -- Velocity of individual lattice vector
              components in Angstrom/fs. The format is identical to
              the System%Lattice block. For Type Sine and Cosine, this
              defines the maximum velocity (at the inflection point).

            * **StrainRate** (*str** | **Sequence**[**str**] **|
              **FreeBlock*) -- Strain rate matrix to be applied on
              every step. The format is identical to the
              System%Lattice block.

            * **TargetLattice** (*str** | **Sequence**[**str**] **|
              **FreeBlock*) -- Target lattice vectors to be achieved
              by StopStep. The format is identical to the
              System%Lattice block.

         class _LatticeVelocity

            Velocity of individual lattice vector components in
            Angstrom/fs. The format is identical to the System%Lattice
            block. For Type Sine and Cosine, this defines the maximum
            velocity (at the inflection point).

         class _StrainRate

            Strain rate matrix to be applied on every step. The format
            is identical to the System%Lattice block.

         class _TargetLattice

            Target lattice vectors to be achieved by StopStep. The
            format is identical to the System%Lattice block.

      class _Gravity

         Apply a constant acceleration in -z.

         Variables:
            **Acceleration** (*float** | **FloatKey*) -- Magnitude of
            the applied acceleration.

      class _HeatExchange

         Input for the heat-exchange non-equilibrium MD (T-NEMD).

         Variables:
            * **HeatingRate** (*float** | **FloatKey*) -- Rate at
              which the energy is added to the Source and removed from
              the Sink. A heating rate of 1 Hartree/fs equals to about
              0.00436 Watt of power being transferred through the
              system.

            * **Method** (*Literal**[**"Simple"**, **"HEX"**,
              **"eHEX"**]*) --

              Heat exchange method used.

              Simple: kinetic energy of the atoms of the source and
              sink regions is modified irrespective of that of the
              center of mass (CoM) of the region (recommended for
              solids).

              HEX: kinetic energy of the atoms of these regions is
              modified keeping that of the corresponding CoM constant.

              eHEX: an enhanced version of HEX that conserves the
              total energy better (recommended for gases and liquids).

            * **StartStep** (*int** | **IntKey*) -- Index of the MD
              step at which the heat exchange will start.

            * **StopStep** (*int** | **IntKey*) -- Index of the MD
              step at which the heat exchange will stop.

            * **Sink** (*AMS._MolecularDynamics._HeatExchange._Sink*)
              -- Defines the heat sink region (where the heat will be
              removed).

            * **Source**
              (*AMS._MolecularDynamics._HeatExchange._Source*) --
              Defines the heat source region (where the heat will be
              added).

         class _Sink

            Defines the heat sink region (where the heat will be
            removed).

            Variables:
               * **AtomList** (*Iterable**[**int**] **| **IntListKey*)
                 --

                 The atoms that are part of the sink.

                 This key is ignored if the [Box] block or [Region]
                 key is present.

               * **FirstAtom** (*int** | **IntKey*) -- Index of the
                 first atom of the region. This key is ignored if the
                 [Box] block or the [AtomList] key is present.

               * **LastAtom** (*int** | **IntKey*) -- Index of the
                 last atom of the region. This key is ignored if the
                 [Box] block or the [AtomList] key is present.

               * **Region** (*str** | **StringKey*) --

                 The region that is the sink.

                 This key is ignored if the [Box] block is present.

               * **Show** (*BoolType** | **BoolKey*) -- Show the sink
                 in the AMSinput

               * **Box**
                 (*AMS._MolecularDynamics._HeatExchange._Sink._Box*)
                 -- Part of the simulation box (in fractional cell
                 coordinates) defining the heat sink. If this block is
                 specified, then by default, the whole box in each of
                 the three dimensions is used, which usually does not
                 make much sense. Normally, you will want to set the
                 bounds along one of the axes.

            class _Box

               Part of the simulation box (in fractional cell
               coordinates) defining the heat sink. If this block is
               specified, then by default, the whole box in each of
               the three dimensions is used, which usually does not
               make much sense. Normally, you will want to set the
               bounds along one of the axes.

               Variables:
                  * **Amax** (*float** | **FloatKey*) -- Coordinate of
                    the upper bound along the first axis.

                  * **Amin** (*float** | **FloatKey*) -- Coordinate of
                    the lower bound along the first axis.

                  * **Bmax** (*float** | **FloatKey*) -- Coordinate of
                    the upper bound along the second axis.

                  * **Bmin** (*float** | **FloatKey*) -- Coordinate of
                    the lower bound along the second axis.

                  * **Cmax** (*float** | **FloatKey*) -- Coordinate of
                    the upper bound along the third axis.

                  * **Cmin** (*float** | **FloatKey*) -- Coordinate of
                    the lower bound along the third axis.

         class _Source

            Defines the heat source region (where the heat will be
            added).

            Variables:
               * **AtomList** (*Iterable**[**int**] **| **IntListKey*)
                 --

                 The atoms that are part of the source.

                 This key is ignored if the [Box] block or [Region]
                 key is present.

               * **FirstAtom** (*int** | **IntKey*) -- Index of the
                 first atom of the region. This key is ignored if the
                 [Box] block or the [AtomList] key is present.

               * **LastAtom** (*int** | **IntKey*) -- Index of the
                 last atom of the region. This key is ignored if the
                 [Box] block or the [AtomList] key is present.

               * **Region** (*str** | **StringKey*) --

                 The region that is the source.

                 This key is ignored if the [Box] block is present.

               * **Show** (*BoolType** | **BoolKey*) -- Show the
                 source in the AMSinput

               * **Box**
                 (*AMS._MolecularDynamics._HeatExchange._Source._Box*)
                 -- Part of the simulation box (in fractional cell
                 coordinates) defining the heat source. If this block
                 is specified, then by default, the whole box in each
                 of the three dimensions is used, which usually does
                 not make much sense. Normally, you will want to set
                 the bounds along one of the axes. This block is
                 mutually exclusive with the FirstAtom/LastAtom
                 setting.

            class _Box

               Part of the simulation box (in fractional cell
               coordinates) defining the heat source. If this block is
               specified, then by default, the whole box in each of
               the three dimensions is used, which usually does not
               make much sense. Normally, you will want to set the
               bounds along one of the axes. This block is mutually
               exclusive with the FirstAtom/LastAtom setting.

               Variables:
                  * **Amax** (*float** | **FloatKey*) -- Coordinate of
                    the upper bound along the first axis.

                  * **Amin** (*float** | **FloatKey*) -- Coordinate of
                    the lower bound along the first axis.

                  * **Bmax** (*float** | **FloatKey*) -- Coordinate of
                    the upper bound along the second axis.

                  * **Bmin** (*float** | **FloatKey*) -- Coordinate of
                    the lower bound along the second axis.

                  * **Cmax** (*float** | **FloatKey*) -- Coordinate of
                    the upper bound along the third axis.

                  * **Cmin** (*float** | **FloatKey*) -- Coordinate of
                    the lower bound along the third axis.

      class _InitialVelocities

         Sets the frequency for printing to stdout and storing the
         molecular configuration on the .rkf file.

         Variables:
            * **File** (*str** | **Path** | **StringKey*) -- AMS RKF
              file containing the initial velocities.

            * **RandomVelocitiesMethod** (*Literal**[**"Exact"**,
              **"Boltzmann"**, **"Gromacs"**]*) --

              Specifies how are random velocities generated. Three
              methods are available.

              Exact: Velocities are scaled to exactly match set random
              velocities temperature.

              Boltzmann: Velocities are not scaled and sample Maxwell-
              Boltzmann distribution. However, the distribution is not
              corrected for constraints.

              Gromacs: Velocities are scaled to match set random
              velocities temperature, but removal of net momentum is
              performed only after the scaling. Resulting kinetic
              energy is lower based on how much net momentum the
              system had.

            * **Temperature** (*float** | **FloatKey*) --

              Sets the temperature for the Maxwell-Boltzmann
              distribution when the type of the initial velocities is
              set to random, in which case specifying this key is
              mandatory.

              AMSinput will use the first temperature of the first
              thermostat as default.

            * **Type** (*Literal**[**"Zero"**, **"Random"**,
              **"FromFile"**, **"Input"**]*) --

              Specifies the initial velocities to assign to the atoms.
              Three methods to assign velocities are available.

              Zero: All atom are at rest at the beginning of the
              calculation.

              Random: Initial atom velocities follow a Maxwell-
              Boltzmann distribution for the temperature given by the
              [MolecularDynamics%InitialVelocities%Temperature]
              keyword.

              FromFile: Load the velocities from a previous ams result
              file.

              Input: Atom's velocities are set to the values specified
              in the [MolecularDynamics%InitialVelocities%Values]
              block, which can be accessed via the Expert AMS panel in
              AMSinput.

            * **Values** (*str** | **Sequence**[**str**] **|
              **FreeBlock*) -- This block specifies the velocity of
              each atom, in Angstrom/fs, when
              [MolecularDynamics%InitialVelocities%Type] is set to
              Input. Each row must contain three floating point values
              (corresponding to the x,y,z component of the velocity
              vector) and a number of rows equal to the number of
              atoms must be present, given in the same order as the
              [System%Atoms] block.

         class _Values

            This block specifies the velocity of each atom, in
            Angstrom/fs, when
            [MolecularDynamics%InitialVelocities%Type] is set to
            Input. Each row must contain three floating point values
            (corresponding to the x,y,z component of the velocity
            vector) and a number of rows equal to the number of atoms
            must be present, given in the same order as the
            [System%Atoms] block.

      class _MovingRestraints

         Define a set of moving restraints.

         Variables:
            * **Change** (*Literal**[**"Linear"**, **"Sine"**,
              **"Cosine"**]*) --

              Type of function defining how the target restraint value
              will change over time:

              Linear - linearly between the StartValue and EndValue.
              Sine - oscillating around StartValue with an amplitude
              equal to the difference between EndValue and StartValue.
              Cosine - oscillating between StartValue and EndValue.

            * **Name** (*str** | **StringKey*) -- Optional name to be
              used for plotting.

            * **Period** (*float** | **FloatKey*) -- Period of
              oscillation for Sine and Cosine change types.

            * **RestraintType** (*Literal**[**"None"**,
              **"Harmonic"**, **"Hyperbolic"**, **"Erf"**,
              **"GaussianWell"**]*) -- Select type of the moving
              restraint profile. The force for Hyperbolic and Erf is
              bounded by a user-defined value, the latter converging
              to it faster than the former. The GaussianWell has a
              finite depth so it is suitable for cases when crossing a
              high reaction barrier is not desirable.

            * **StartStep** (*int** | **IntKey*) -- First step number
              at which the restraints will be applied.

            * **StopStep** (*int** | **IntKey*) -- Last step number at
              which the restraints will be applied.

            * **Distance**
              (*AMS._MolecularDynamics._MovingRestraints._Distance*)
              -- Define a distance restraint between pair of atoms.
              For linear-type

            * **Erf**
              (*AMS._MolecularDynamics._MovingRestraints._Erf*) --
              Define parameters for the Int(erf) restraint potential V
              = alpha*(beta*x*erf(beta*x) + (exp(-(beta*x)**2) -
              1)/sqrt(PI)). The alpha and beta parameters are computed
              from the user-defined ForceConstant and MaxForce.

            * **GaussianWell** (*AMS._MolecularDynamics._MovingRestra
              ints._GaussianWell*) -- Define parameters in the
              Gaussian well restraint potential
              V=-WellDepth*exp(-Sigma*(r-r0)^2).

            * **Harmonic**
              (*AMS._MolecularDynamics._MovingRestraints._Harmonic*)
              -- Define parameters for the harmonic potential
              V=0.5*FC*(r-r0)^2.

            * **Hyperbolic**
              (*AMS._MolecularDynamics._MovingRestraints._Hyperbolic*)
              -- Define parameters for the hyperbolic restraint
              potential V=alpha*(sqrt(1 + beta*x^2) - 1). The alpha
              and beta parameters are computed from the user-defined
              ForceConstant and MaxForce: beta=ForceConstant/MaxForce,
              alpha=MaxForce/beta

         class _Distance

            Define a distance restraint between pair of atoms. For
            linear-type

            Variables:
               * **Atom1** (*int** | **IntKey*) -- First atom of the
                 distance restraint.

               * **Atom2** (*int** | **IntKey*) -- Second atom of the
                 distance restraint.

               * **EndValue** (*float** | **FloatKey*) -- Linear:
                 final target distance. Sine: target distance at 1/4
                 of the period. Cosine: target distance at 1/2 of the
                 period.

               * **StartValue** (*float** | **FloatKey*) -- Initial
                 target distance.

         class _Erf

            Define parameters for the Int(erf) restraint potential V =
            alpha*(beta*x*erf(beta*x) + (exp(-(beta*x)**2) -
            1)/sqrt(PI)). The alpha and beta parameters are computed
            from the user-defined ForceConstant and MaxForce.

            Variables:
               * **ForceConstant** (*float** | **FloatKey*) -- The
                 force constant (second derivative of the potential)
                 at the optimum point.

               * **MaxForce** (*float** | **FloatKey*) -- Asymptotic
                 value of the force at the infinity.

         class _GaussianWell

            Define parameters in the Gaussian well restraint potential
            V=-WellDepth*exp(-Sigma*(r-r0)^2).

            Variables:
               * **Sigma** (*float** | **FloatKey*) -- Sigma parameter
                 in the potential expression.

               * **WellDepth** (*float** | **FloatKey*) -- WellDepth
                 parameter in the potential expression.

         class _Harmonic

            Define parameters for the harmonic potential
            V=0.5*FC*(r-r0)^2.

            Variables:
               **ForceConstant** (*float** | **FloatKey*) -- The FC
               parameter of the harmonic potential.

         class _Hyperbolic

            Define parameters for the hyperbolic restraint potential
            V=alpha*(sqrt(1 + beta*x^2) - 1). The alpha and beta
            parameters are computed from the user-defined
            ForceConstant and MaxForce: beta=ForceConstant/MaxForce,
            alpha=MaxForce/beta

            Variables:
               * **ForceConstant** (*float** | **FloatKey*) -- The
                 force constant (second derivative of the potential)
                 at the optimum point.

               * **MaxForce** (*float** | **FloatKey*) -- Asymptotic
                 value of the force at the infinity.

      class _PRD

         This block is used for Parallel Replica Dynamics simulations.

         Variables:
            * **CorrelatedSteps** (*int** | **IntKey*) -- How many
              steps to wait for correlated events after detecting an
              initial event.

            * **DephasingSteps** (*int** | **IntKey*) -- Spend this
              many steps dephasing the individual replicas after an
              event.

            * **nReplicas** (*int** | **IntKey*) -- Number of replicas
              to run in parallel.

            * **BondChange**
              (*AMS._MolecularDynamics._PRD._BondChange*) -- Detect
              changes to the bonding topology and bond orders returned
              by the engine.

            * **MolCount** (*AMS._MolecularDynamics._PRD._MolCount*)
              -- Detect changes to the molecular composition of the
              system.

         class _BondChange

            Detect changes to the bonding topology and bond orders
            returned by the engine.

            Variables:
               * **ChangeThreshold** (*float** | **FloatKey*) --
                 Trigger an event when the bond order of a bond
                 changes from the reference state by more than this
                 value.

               * **DissociationThreshold** (*float** | **FloatKey*) --
                 Trigger an event when a bond dissociates (its bond
                 order drops below this value while it was above
                 FormationThreshold in the reference state).

               * **FormationThreshold** (*float** | **FloatKey*) --
                 Trigger an event when a new bond forms (its bond
                 order exceeds this value while it was below
                 DissociationThreshold in the reference state).

         class _MolCount

            Detect changes to the molecular composition of the system.

      class _Plumed

         Input for PLUMED (version 2.5.0). The parallel option is
         still experimental.

         Variables:
            * **Input** (*str** | **Sequence**[**str**] **|
              **FreeBlock*) -- Input for PLUMED. Contents of this
              block is passed to PLUMED as is.

            * **Parallel**
              (*AMS._MolecularDynamics._Plumed._Parallel*) -- Options
              for double parallelization, which allows to split the
              available processor cores into groups working through
              all the available tasks in parallel, resulting in a
              better parallel performance. The keys in this block
              determine how to split the available processor cores
              into groups working in parallel.

         class _Input

            Input for PLUMED. Contents of this block is passed to
            PLUMED as is.

         class _Parallel

            Options for double parallelization, which allows to split
            the available processor cores into groups working through
            all the available tasks in parallel, resulting in a better
            parallel performance. The keys in this block determine how
            to split the available processor cores into groups working
            in parallel.

            Variables:
               * **nCoresPerGroup** (*int** | **IntKey*) -- Number of
                 cores in each working group.

               * **nGroups** (*int** | **IntKey*) -- Total number of
                 processor groups. This is the number of tasks that
                 will be executed in parallel.

               * **nNodesPerGroup** (*int** | **IntKey*) -- Number of
                 nodes in each group. This option should only be used
                 on homogeneous compute clusters, where all used
                 compute nodes have the same number of processor
                 cores.

      class _Preserve

         Periodically remove numerical drift accumulated during the
         simulation to preserve different whole-system parameters.

         Variables:
            * **AngularMomentum** (*BoolType** | **BoolKey*) -- Remove
              overall angular momentum of the system. This option is
              ignored for 2D and 3D-periodic systems, and disabled by
              default for systems which are not translationally
              invariant (for example when frozen atoms are present).

            * **CenterOfMass** (*BoolType** | **BoolKey*) -- Translate
              the system to keep its center of mass at the coordinate
              origin. This option is not very useful for 3D-periodic
              systems.

            * **Momentum** (*BoolType** | **BoolKey*) -- Remove
              overall (linear) momentum of the system. This is
              disabled by default for systems which are not
              translationally invariant (for example when frozen atoms
              are present).

      class _Print

         This block controls the printing of additional information to
         stdout.

         Variables:
            * **System** (*BoolType** | **BoolKey*) -- Print the
              chemical system before and after the simulation.

            * **Velocities** (*BoolType** | **BoolKey*) -- Print the
              atomic velocities before and after the simulation.

      class _ReactionBoost

         Define a series of transitions between different states of
         the system.

         Each transition is defined by a TargetSystem and by a set of
         restraints that force the transition.

         Variables:
            * **Change** (*Literal**[**"TargetCoordinate"**,
              **"Force"**, **"LogForce"**]*) --

              Select what to change during dynamics.

              By default, once the restraints are switched on, AMS
              will change the restraint's target coordinate towards
              its final value.

              If the [Force] or [LogForce] option is selected then the
              target coordinate is set to its final value immediately
              and instead the restraint force is gradually scaled from
              0 to 1. The scaling is either linear (Force) or
              logarithmic (LogForce).

            * **InitialFraction** (*float** | **FloatKey*) --

              Initial fraction of the boost variable.

              At the first boosting step, the restraint's target value
              (or force or log(force)) is equal to InitialFraction +
              1/NSteps.

            * **InterEquilibrationSteps** (*int** | **IntKey*) --
              Number of equilibration steps after reaching a target
              before setting up restraints for the next one.

            * **MinBondChange** (*float** | **FloatKey*) -- Minimal
              change in the distance for an individual restraint to be
              considered bond-breaking/making vs bonded.

            * **MinBondStrength** (*float** | **FloatKey*) -- Minimum
              strength (usually ranges from 0 to 1) for a bond to be
              considered.

            * **NSteps** (*int** | **IntKey*) -- Number of steps per
              target the restraints should be active for.

            * **PreEquilibrationSteps** (*int** | **IntKey*) -- Number
              of steps before enabling the first set of restraints.

            * **Region** (*str** | **StringKey*) -- Region to which
              the restraints should be limited.

            * **TargetSystem** (*str** | **StringKey*) --

              The target system's name for this transition. Multiple
              targets can be specified to request multiple transitions
              in one simulation.

              Note that only the lattice and the atomic coordinates of
              the target system are used and other properties (bonds,
              charge, etc.) are ignored. The target system's lattice
              is used only to determine connections and it cannot be
              restrained.

            * **Type** (*Literal**[**"None"**, **"Pair"**,
              **"RMSD"**]*) --

              Reaction Boost uses a series of transitions between
              different states of the system. Each transition is
              defined by a TargetSystem and by a set of restraints
              that force the transition.

              Select the type of the restraint set: -None: no Reaction
              Boost - Pair: use pair restraints - RMSD: use RMSD
              restraints.

              Pair restraints are defined per atom pair while the RMSD
              defines one collective restraint for all atoms and is
              thus suitable for very large systems.

              The pair restraints are further divided into four sub-
              types: bonding, non-bonding, bond-breaking and bond-
              making. The sub-type of restraints for each pair is
              determined automatically depending on whether the two
              atoms are bonded in the initial/final state.

              Parameters of the pair restraints are defined by
              [NonBondedRestraints], [BondedRestraints],
              [BondBreakingRestraints] and [BondMakingRestraints]
              blocks, while those of the RMSD restraint by the
              [RMSDRestraint] block.

            * **BondBreakingRestraints** (*AMS._MolecularDynamics._Re
              actionBoost._BondBreakingRestraints*) --

              Define parameters for moving restraints that are added
              for pairs of atoms that become disconnected during the
              transition.

              It is intended to make sure the corresponding bonds get
              broken, although this may not always be required because
              forming other bonds will likely get these bonds broken.

            * **BondMakingRestraints** (*AMS._MolecularDynamics._Reac
              tionBoost._BondMakingRestraints*) --

              Define parameters for moving restraints that are added
              for pairs of atoms that become connected during the
              transition.

              It is intended to make sure the bonds are created as
              required.

            * **BondedRestraints** (*AMS._MolecularDynamics._Reaction
              Boost._BondedRestraints*) --

              Define parameters for bonded restraints. A bonded
              restraint is added for each pair of atoms that are
              bonded both in the current and in the final state.

              It is intended to make sure they remain bonded during
              simulation.

            * **NonBondedRestraints** (*AMS._MolecularDynamics._React
              ionBoost._NonBondedRestraints*) --

              Define parameters for non-bonded restraints. A non-
              bonded restraint is added for each pair of atoms that
              are bonded neither in the current nor in the final
              state.

              It is intended to keep them from forming a bond
              unintentionally. They are represented by a repulsive
              potential

            * **RMSDRestraint**
              (*AMS._MolecularDynamics._ReactionBoost._RMSDRestraint*)
              -- Define a static restraint that pulls each atom to its
              position in the target system, but in contrast to the
              individual restraints, the force for this one depends on
              the total mass-weighted root-mean-squared distance
              (RMSD) between the two structures.

         class _BondBreakingRestraints

            Define parameters for moving restraints that are added for
            pairs of atoms that become disconnected during the
            transition.

            It is intended to make sure the corresponding bonds get
            broken, although this may not always be required because
            forming other bonds will likely get these bonds broken.

            Variables:
               * **Type** (*Literal**[**"None"**, **"Harmonic"**,
                 **"Hyperbolic"**, **"Erf"**, **"GaussianWell"**]*) --

                 Select type of the moving restraint profile.

                 Harmonic: V=0.5*FC*(r-r0)^2

                 Hyperbolic: V=alpha*(sqrt(1 + beta*x^2) - 1)

                 Erf: V = alpha*(beta*x*erf(beta*x) +
                 (exp(-(beta*x)**2) - 1)/sqrt(PI))

                 GaussianWell: V=WellDepth*(1-exp(-Sigma*(r-r0)^2))

                 Here beta=ForceConstant/MaxForce,
                 alpha=MaxForce/beta.

                 The force for Hyperbolic and Erf is bounded by a
                 user-defined value, the latter converging to it
                 faster than the former. The GaussianWell has a finite
                 depth so it is suitable for cases when crossing a
                 high reaction barrier is not desirable.

                 Moving restraints are added for pairs of atoms that
                 become disconnected during the transition.

                 It is intended to make sure the corresponding bonds
                 get broken, although this may not always be required
                 because forming other bonds will likely get these
                 bonds broken.

               * **Erf** (*AMS._MolecularDynamics._ReactionBoost._Bon
                 dBreakingRestraints._Erf*) -- Define parameters for
                 the Int(erf) potential V = alpha*(beta*x*erf(beta*x)
                 + (exp(-(beta*x)**2) - 1)/sqrt(PI)). The alpha and
                 beta parameters are computed from the user-defined
                 ForceConstant and MaxForce.

               * **GaussianWell** (*AMS._MolecularDynamics._ReactionB
                 oost._BondBreakingRestraints._GaussianWell*) --
                 Define parameters in the Gaussian well potential
                 V=-WellDepth*exp(-Sigma*(r-r0)^2).

               * **Harmonic** (*AMS._MolecularDynamics._ReactionBoost
                 ._BondBreakingRestraints._Harmonic*) -- Define
                 parameters for the harmonic potential
                 V=0.5*FC*(r-r0)^2.

               * **Hyperbolic** (*AMS._MolecularDynamics._ReactionBoo
                 st._BondBreakingRestraints._Hyperbolic*) -- Define
                 parameters for the hyperbolic potential
                 V=alpha*(sqrt(1 + beta*x^2) - 1). The alpha and beta
                 parameters are computed from the user-defined
                 ForceConstant and MaxForce:
                 beta=ForceConstant/MaxForce, alpha=MaxForce/beta

               * **Taper** (*AMS._MolecularDynamics._ReactionBoost._B
                 ondBreakingRestraints._Taper*) --

            class _Erf

               Define parameters for the Int(erf) potential V =
               alpha*(beta*x*erf(beta*x) + (exp(-(beta*x)**2) -
               1)/sqrt(PI)). The alpha and beta parameters are
               computed from the user-defined ForceConstant and
               MaxForce.

               Variables:
                  * **ForceConstant** (*float** | **FloatKey*) -- The
                    force constant (second derivative of the
                    potential) at the optimum point.

                  * **MaxForce** (*float** | **FloatKey*) --
                    Asymptotic value of the force at the infinity.

            class _GaussianWell

               Define parameters in the Gaussian well potential
               V=-WellDepth*exp(-Sigma*(r-r0)^2).

               Variables:
                  * **Sigma** (*float** | **FloatKey*) -- Sigma
                    parameter in the potential expression.

                  * **WellDepth** (*float** | **FloatKey*) --
                    WellDepth parameter in the potential expression.

            class _Harmonic

               Define parameters for the harmonic potential
               V=0.5*FC*(r-r0)^2.

               Variables:
                  **ForceConstant** (*float** | **FloatKey*) -- The FC
                  parameter of the harmonic potential.

            class _Hyperbolic

               Define parameters for the hyperbolic potential
               V=alpha*(sqrt(1 + beta*x^2) - 1). The alpha and beta
               parameters are computed from the user-defined
               ForceConstant and MaxForce:
               beta=ForceConstant/MaxForce, alpha=MaxForce/beta

               Variables:
                  * **ForceConstant** (*float** | **FloatKey*) -- The
                    force constant (second derivative of the
                    potential) at the optimum point.

                  * **MaxForce** (*float** | **FloatKey*) --
                    Asymptotic value of the force at the infinity.

            class _Taper

               Variables:
                  * **Enabled** (*BoolType** | **BoolKey*) -- Enable
                    tapering of the restraint potential and force
                    between the given range of bond distances. A 7-th
                    order tapering function on the actual (not
                    target!) distance will be used. The MaxDistance
                    must be greater than MinDistance.

                  * **MaxDistance** (*float** | **FloatKey*) -- Bond
                    length at which the restraint potential and force
                    decays to zero.

                  * **MinDistance** (*float** | **FloatKey*) -- Bond
                    length at which the restraint potential and force
                    will start decaying to zero.

         class _BondMakingRestraints

            Define parameters for moving restraints that are added for
            pairs of atoms that become connected during the
            transition.

            It is intended to make sure the bonds are created as
            required.

            Variables:
               * **Type** (*Literal**[**"None"**, **"Harmonic"**,
                 **"Hyperbolic"**, **"Erf"**, **"GaussianWell"**]*) --

                 Select type of the moving restraint profile.

                 Harmonic: V=0.5*FC*(r-r0)^2

                 Hyperbolic: V=alpha*(sqrt(1 + beta*x^2) - 1)

                 Erf: V = alpha*(beta*x*erf(beta*x) +
                 (exp(-(beta*x)**2) - 1)/sqrt(PI))

                 GaussianWell: V=-WellDepth*exp(-Sigma*(r-r0)^2)

                 Here beta=ForceConstant/MaxForce,
                 alpha=MaxForce/beta.

                 The force for Hyperbolic and Erf is bounded by a
                 user-defined value. The GaussianWell has a finite
                 depth so it is suitable for cases when crossing a
                 high reaction barrier is not desirable.

                 Moving restraints are added for pairs of atoms that
                 become connected during the transition.

                 It is intended to make sure the bonds are created as
                 required.

               * **Erf** (*AMS._MolecularDynamics._ReactionBoost._Bon
                 dMakingRestraints._Erf*) -- Define parameters for the
                 Int(erf) potential V = alpha*(beta*x*erf(beta*x) +
                 (exp(-(beta*x)**2) - 1)/sqrt(PI)). The alpha and beta
                 parameters are computed from the user-defined
                 ForceConstant and MaxForce.

               * **GaussianWell** (*AMS._MolecularDynamics._ReactionB
                 oost._BondMakingRestraints._GaussianWell*) -- Define
                 parameters in the Gaussian well potential
                 V=-WellDepth*exp(-Sigma*(r-r0)^2).

               * **Harmonic** (*AMS._MolecularDynamics._ReactionBoost
                 ._BondMakingRestraints._Harmonic*) -- Define
                 parameters for the harmonic potential
                 V=0.5*FC*(r-r0)^2.

               * **Hyperbolic** (*AMS._MolecularDynamics._ReactionBoo
                 st._BondMakingRestraints._Hyperbolic*) -- Define
                 parameters for the hyperbolic potential
                 V=alpha*(sqrt(1 + beta*x^2) - 1). The alpha and beta
                 parameters are computed from the user-defined
                 ForceConstant and MaxForce:
                 beta=ForceConstant/MaxForce, alpha=MaxForce/beta

            class _Erf

               Define parameters for the Int(erf) potential V =
               alpha*(beta*x*erf(beta*x) + (exp(-(beta*x)**2) -
               1)/sqrt(PI)). The alpha and beta parameters are
               computed from the user-defined ForceConstant and
               MaxForce.

               Variables:
                  * **ForceConstant** (*float** | **FloatKey*) -- The
                    force constant (second derivative of the
                    potential) at the optimum point.

                  * **MaxForce** (*float** | **FloatKey*) --
                    Asymptotic value of the force at the infinity.

            class _GaussianWell

               Define parameters in the Gaussian well potential
               V=-WellDepth*exp(-Sigma*(r-r0)^2).

               Variables:
                  * **Sigma** (*float** | **FloatKey*) -- Sigma
                    parameter in the potential expression.

                  * **WellDepth** (*float** | **FloatKey*) --
                    WellDepth parameter in the potential expression.

            class _Harmonic

               Define parameters for the harmonic potential
               V=0.5*FC*(r-r0)^2.

               Variables:
                  **ForceConstant** (*float** | **FloatKey*) -- The FC
                  parameter of the harmonic potential.

            class _Hyperbolic

               Define parameters for the hyperbolic potential
               V=alpha*(sqrt(1 + beta*x^2) - 1). The alpha and beta
               parameters are computed from the user-defined
               ForceConstant and MaxForce:
               beta=ForceConstant/MaxForce, alpha=MaxForce/beta

               Variables:
                  * **ForceConstant** (*float** | **FloatKey*) -- The
                    force constant (second derivative of the
                    potential) at the optimum point.

                  * **MaxForce** (*float** | **FloatKey*) --
                    Asymptotic value of the force at the infinity.

         class _BondedRestraints

            Define parameters for bonded restraints. A bonded
            restraint is added for each pair of atoms that are bonded
            both in the current and in the final state.

            It is intended to make sure they remain bonded during
            simulation.

            Variables:
               * **Type** (*Literal**[**"None"**, **"Harmonic"**]*) --

                 Select type of the bonded restraints:

                 Harmonic: V=0.5*FC*(r-r0)^2

                 A bonded restraint is added for each pair of atoms
                 that are bonded both in the current and in the final
                 state.

                 It is intended to make sure they remain bonded during
                 simulation.

               * **Harmonic** (*AMS._MolecularDynamics._ReactionBoost
                 ._BondedRestraints._Harmonic*) -- Define parameters
                 for the harmonic potential V=0.5*FC*(r-r0)^2.

            class _Harmonic

               Define parameters for the harmonic potential
               V=0.5*FC*(r-r0)^2.

               Variables:
                  **ForceConstant** (*float** | **FloatKey*) -- The FC
                  parameter of the harmonic potential.

         class _NonBondedRestraints

            Define parameters for non-bonded restraints. A non-bonded
            restraint is added for each pair of atoms that are bonded
            neither in the current nor in the final state.

            It is intended to keep them from forming a bond
            unintentionally. They are represented by a repulsive
            potential

            Variables:
               * **Type** (*Literal**[**"None"**, **"Exponential"**]*)
                 --

                 Select type of the non-bonded restraints:

                 Exponential: V=Epsilon*exp(-Sigma*r)

                 A non-bonded restraint is added for each pair of
                 atoms that are bonded neither in the current nor in
                 the final state.

                 It is intended to keep them from forming a bond
                 unintentionally. They are represented by a repulsive
                 potential.

               * **Exponential** (*AMS._MolecularDynamics._ReactionBo
                 ost._NonBondedRestraints._Exponential*) -- Define
                 parameters for the repulsive potential
                 V=Epsilon*exp(-Sigma*r).

            class _Exponential

               Define parameters for the repulsive potential
               V=Epsilon*exp(-Sigma*r).

               Variables:
                  * **Epsilon** (*float** | **FloatKey*) -- Epsilon
                    parameter in the repulsive potential expression.

                  * **Sigma** (*float** | **FloatKey*) -- Sigma
                    parameter in the repulsive potential expression.

         class _RMSDRestraint

            Define a static restraint that pulls each atom to its
            position in the target system, but in contrast to the
            individual restraints, the force for this one depends on
            the total mass-weighted root-mean-squared distance (RMSD)
            between the two structures.

            Variables:
               * **Type** (*Literal**[**"None"**, **"Harmonic"**,
                 **"Hyperbolic"**, **"Erf"**, **"GaussianWell"**]*) --

                 Select type of the RMSD restraint profile:

                 Harmonic: V=0.5*FC*(r-r0)^2

                 Hyperbolic: V=alpha*(sqrt(1 + beta*x^2) - 1)

                 Erf: V = alpha*(beta*x*erf(beta*x) +
                 (exp(-(beta*x)**2) - 1)/sqrt(PI),

                 GaussianWell: V=-WellDepth*exp(-Sigma*(r-r0)^2)

                 Here beta=ForceConstant/MaxForce,
                 alpha=MaxForce/beta.

                 The Harmonic profile can be problematic at large
                 deviations as it may result in large forces. The
                 force for Hyperbolic and Erf is bounded by a user-
                 defined value. The GaussianWell has a finite depth so
                 it is suitable for cases when crossing a high
                 reaction barrier is not desirable.

               * **Erf** (*AMS._MolecularDynamics._ReactionBoost._RMS
                 DRestraint._Erf*) -- Define parameters for the
                 Int(erf) potential V = alpha*(beta*x*erf(beta*x) +
                 (exp(-(beta*x)**2) - 1)/sqrt(PI)). The alpha and beta
                 parameters are computed from the user-defined
                 ForceConstant and MaxForce.

               * **GaussianWell** (*AMS._MolecularDynamics._ReactionB
                 oost._RMSDRestraint._GaussianWell*) -- Define
                 parameters in the Gaussian well potential
                 V=-WellDepth*exp(-Sigma*(r-r0)^2).

               * **Harmonic** (*AMS._MolecularDynamics._ReactionBoost
                 ._RMSDRestraint._Harmonic*) -- Define parameters for
                 the harmonic potential V=0.5*FC*(r-r0)^2.

               * **Hyperbolic** (*AMS._MolecularDynamics._ReactionBoo
                 st._RMSDRestraint._Hyperbolic*) -- Define parameters
                 for the hyperbolic potential V=alpha*(sqrt(1 +
                 beta*x^2) - 1). The alpha and beta parameters are
                 computed from the user-defined ForceConstant and
                 MaxForce: beta=ForceConstant/MaxForce,
                 alpha=MaxForce/beta

            class _Erf

               Define parameters for the Int(erf) potential V =
               alpha*(beta*x*erf(beta*x) + (exp(-(beta*x)**2) -
               1)/sqrt(PI)). The alpha and beta parameters are
               computed from the user-defined ForceConstant and
               MaxForce.

               Variables:
                  * **ForceConstant** (*float** | **FloatKey*) -- The
                    force constant (second derivative of the
                    potential) at the optimum point.

                  * **MaxForce** (*float** | **FloatKey*) --
                    Asymptotic value of the force at the infinity.

            class _GaussianWell

               Define parameters in the Gaussian well potential
               V=-WellDepth*exp(-Sigma*(r-r0)^2).

               Variables:
                  * **Sigma** (*float** | **FloatKey*) -- Sigma
                    parameter in the potential expression.

                  * **WellDepth** (*float** | **FloatKey*) --
                    WellDepth parameter in the potential expression.

            class _Harmonic

               Define parameters for the harmonic potential
               V=0.5*FC*(r-r0)^2.

               Variables:
                  **ForceConstant** (*float** | **FloatKey*) -- The FC
                  parameter of the harmonic potential.

            class _Hyperbolic

               Define parameters for the hyperbolic potential
               V=alpha*(sqrt(1 + beta*x^2) - 1). The alpha and beta
               parameters are computed from the user-defined
               ForceConstant and MaxForce:
               beta=ForceConstant/MaxForce, alpha=MaxForce/beta

               Variables:
                  * **ForceConstant** (*float** | **FloatKey*) -- The
                    force constant (second derivative of the
                    potential) at the optimum point.

                  * **MaxForce** (*float** | **FloatKey*) --
                    Asymptotic value of the force at the infinity.

      class _Reactor

         Define one phase of the nanoreactor. A reactor is a region of
         space surrounded by an elastic wall. Atoms inside the region
         are not affected. Atoms outside it will be pushed back with
         force depending on the [ForceConstant] and the [MassScaled]
         flag.

         Variables:
            * **ForceConstant** (*float** | **FloatKey*) -- Force
              constant of the reactor wall in Hartree/Bohr^2 (or
              Hartree/Bohr^2/Dalton if [MassScaled] is true).

            * **MassScaled** (*BoolType** | **BoolKey*) -- If this
              flag is disabled the force on an atom outside of the
              reactor depends only on the atomic coordinates and the
              force constant. Otherwise, the force is also multiplied
              by the mass of the atom. This means that atoms at the
              same distance from the wall will receive the same
              accelerate due to the wall potential.

            * **NSteps** (*int** | **IntKey*) -- Number of steps for
              which the reactor will remain active until disabled. The
              next reactor will be activated immediately after this.
              After the last reactor is disabled the cycle will
              repeat.

            * **Radius** (*float** | **FloatKey*) -- Radius of the
              reactor sphere.

      class _ReflectiveWall

         Apply a reflective wall in space

         Variables:
            * **Axis** (*Iterable**[**float**] **| **FloatListKey*) --
              Defines the normal vector perpendicular to the plane of
              the reflective wall. Any particle moving in this
              direction will be reflected back.

            * **Direction** (*Literal**[**"under"**, **"above"**]*) --
              Defines the direction of the reflective wall. under will
              keep the particles under the defined wall, and above
              will keep the particles above the defined wall

            * **Region** (*str** | **StringKey*) -- Apply the
              reflective wall to all atoms in this region.

            * **Thickness** (*float** | **FloatKey*) -- Any particle
              not deeper than Thickness beyond the reflective face of
              the wall will be reflected. Particles deeper than this
              will be ignored by the wall. This setting allows the
              placement of two walls back-to-back to create a two-
              sided wall that reflects in both directions (offset the
              position of each individual wall by Thickness so that
              their areas of influence do not overlap). Systems with
              very high speed particles (light atoms at high
              temperatures) need a higher Thickness to stop atoms from
              tunneling through the wall in a single timestep.

            * **Threshold** (*float** | **FloatKey*) -- Defines the
              threshold value determining the position of the
              reflective wall. If the dot product of a position of a
              particle with Axis exceeds Threshold, the particle will
              be reflected. This means that the plane of the wall
              passes through a point given by Axis times Threshold.

      class _Remap

         Control periodic remapping (backtranslation) of atoms into
         the PBC box.

         Variables:
            * **Range** (*Literal**[**"Auto"**, **"ZeroToOne"**,
              **"PlusMinusHalf"**, **"AroundCenter"**]*) --

              Select the range of fractional coordinates to which
              atoms are remapped.

              Auto: Use PlusMinusHalf if the geometrical center of the
              starting positions of all atoms lies between -0.25 and
              0.25 in fractional coordinates in all periodic
              directions, ZeroToOne otherwise.

              PlusMinusHalf: Remap atoms to lie between -0.5 and 0.5
              in fractional coordinates.

              ZeroToOne: Remap atoms to lie between 0 and 1 in
              fractional coordinates.

              AroundCenter: Remap atoms to lie within 0.5 in
              fractional coordinates around the geometrical center of
              the starting positions of all atoms.

            * **Type** (*Literal**[**"None"**, **"Atoms"**]*) --

              Select the method used to remap atoms into the unit
              cell.

              None: Disable remapping completely.

              Atoms: Remap any atoms that leave the unit cell.

      class _RemoveMolecules

         This block controls removal of molecules from the system.
         Multiple occurrences of this block are possible.

         Variables:
            * **Formula** (*str** | **StringKey*) --

              Molecular formula of the molecules that should be
              removed from the system.

              The order of elements in the formula is very important
              and the correct order is: C, H, all other elements in
              the strictly alphabetic order.  Element names are case-
              sensitive, spaces in the formula are not allowed. Digit
              '1' must be omitted.

              Valid formula examples: C2H6O, H2O, O2S. Invalid formula
              examples: C2H5OH, H2O1, OH, SO2. Invalid formulas are
              silently ignored.

              Use * to remove any molecule, which must be combined
              with SinkBox or SafeBox.

            * **Frequency** (*int** | **IntKey*) -- The specified
              molecules are removed every so many steps after the
              StartStep. There is never a molecule removed at step 0.

            * **StartStep** (*int** | **IntKey*) --

              Step number when molecules are removed for the first
              time. After that, molecules are removed every
              [Frequency] steps.

              For example, if StartStep=99 and Frequency=100 then
              molecules will be removed at steps 99, 199, 299, etc...

              No molecule will be removed at step 0, so if StartStep=0
              the first molecules are removed at the step number equal
              to [Frequency].

            * **StopStep** (*int** | **IntKey*) -- Do not remove the
              specified molecules after this step.

            * **SafeBox**
              (*AMS._MolecularDynamics._RemoveMolecules._SafeBox*) --
              Part of the simulation box where molecules may not be
              removed. Only one of the SinkBox or SafeBox blocks may
              be present. If this block is present the molecule will
              not be removed if any of its atoms is within the box.
              For a periodic dimension it is given as a fraction of
              the simulation box (the full 0 to 1 range by default).
              For a non-periodic dimension it represents absolute
              Cartesian coordinates in Angstrom.

            * **SinkBox**
              (*AMS._MolecularDynamics._RemoveMolecules._SinkBox*) --
              Part of the simulation box where matching molecules will
              be removed. By default, molecules matching the formula
              will be removed regardless of their location. If this
              block is present then such a molecule will only be
              removed if any of its atoms is within the box. For a
              periodic dimension it is given as a fraction of the
              simulation box (the full 0 to 1 range by default). For a
              non-periodic dimension it represents absolute Cartesian
              coordinates in Angstrom.

         class _SafeBox

            Part of the simulation box where molecules may not be
            removed. Only one of the SinkBox or SafeBox blocks may be
            present. If this block is present the molecule will not be
            removed if any of its atoms is within the box. For a
            periodic dimension it is given as a fraction of the
            simulation box (the full 0 to 1 range by default). For a
            non-periodic dimension it represents absolute Cartesian
            coordinates in Angstrom.

            Variables:
               * **Amax** (*float** | **FloatKey*) -- Coordinate of
                 the upper bound along the first axis.

               * **Amin** (*float** | **FloatKey*) -- Coordinate of
                 the lower bound along the first axis.

               * **Bmax** (*float** | **FloatKey*) -- Coordinate of
                 the upper bound along the second axis.

               * **Bmin** (*float** | **FloatKey*) -- Coordinate of
                 the lower bound along the second axis.

               * **Cmax** (*float** | **FloatKey*) -- Coordinate of
                 the upper bound along the third axis.

               * **Cmin** (*float** | **FloatKey*) -- Coordinate of
                 the lower bound along the third axis.

               * **FractionalCoordsBox** (*Iterable**[**float**] **|
                 **FloatListKey*) --

                 Do not remove molecules that are (partly) inside the
                 safe box.

                 Borders of the safe box specified as: Amin, Amax,
                 Bmin, Bmax, Cmin, Cmax.

                 For periodic dimensions fractional coordinates
                 between 0 and 1 and for non-periodic dimensions
                 Cartesian values in Angstrom are expected.

         class _SinkBox

            Part of the simulation box where matching molecules will
            be removed. By default, molecules matching the formula
            will be removed regardless of their location. If this
            block is present then such a molecule will only be removed
            if any of its atoms is within the box. For a periodic
            dimension it is given as a fraction of the simulation box
            (the full 0 to 1 range by default). For a non-periodic
            dimension it represents absolute Cartesian coordinates in
            Angstrom.

            Variables:
               * **Amax** (*float** | **FloatKey*) -- Coordinate of
                 the upper bound along the first axis.

               * **Amin** (*float** | **FloatKey*) -- Coordinate of
                 the lower bound along the first axis.

               * **Bmax** (*float** | **FloatKey*) -- Coordinate of
                 the upper bound along the second axis.

               * **Bmin** (*float** | **FloatKey*) -- Coordinate of
                 the lower bound along the second axis.

               * **Cmax** (*float** | **FloatKey*) -- Coordinate of
                 the upper bound along the third axis.

               * **Cmin** (*float** | **FloatKey*) -- Coordinate of
                 the lower bound along the third axis.

               * **FractionalCoordsBox** (*Iterable**[**float**] **|
                 **FloatListKey*) --

                 Remove molecules that are (partly) inside the sink
                 box.

                 Borders of the sink box specified as: Amin, Amax,
                 Bmin, Bmax, Cmin, Cmax.

                 For periodic dimensions fractional coordinates
                 between 0 and 1 and for non-periodic dimensions
                 Cartesian values in Angstrom are expected.

      class _ReplicaExchange

         This block is used for (temperature) Replica Exchange MD
         (Parallel Tempering) simulations.

         Variables:
            * **AllowWrongResults** (*BoolType** | **BoolKey*) --
              Allow combining Replica Exchange with other features
              when the combination is known to produce physically
              incorrect results.

            * **EWMALength** (*int** | **IntKey*) --

              Length of the exponentially weighted moving average used
              to smooth swap probabilities for monitoring.

              This value is equal to the inverse of the EWMA mixing
              factor.

            * **SwapFrequency** (*int** | **IntKey*) -- Attempt an
              exchange every N steps.

            * **TemperatureFactors** (*Iterable**[**float**] **|
              **FloatListKey*) --

              This is the ratio of the temperatures of two successive
              replicas.

              The first value sets the temperature of the second
              replica with respect to the first replica, the second
              value sets the temperature of the third replica with
              respect to the second one, and so on. If there are fewer
              values than nReplicas, the last value of
              TemperatureFactor is used for all the remaining
              replicas.

            * **Temperatures** (*Iterable**[**float**] **|
              **FloatListKey*) --

              List of temperatures for all replicas except for the
              first one.

              This is mutually exclusive with TemperatureFactors.
              Exactly nReplicas-1 temperature values need to be
              specified, in increasing order. The temperature of the
              first replica is given by [Thermostat%Temperature].

            * **nReplicas** (*int** | **IntKey*) -- Number of replicas
              to run in parallel.

      class _Shake

         Parameters of the Shake/Rattle algorithm.

         Variables:
            * **All** (*str** | **StringKey*) --

              Constraint description in one the following formats:
              All [bondOrder] bonds at1 at2 [to distance] All
              triangles at1 at2 at3

              The first option constrains all bonds between atoms at1
              at2 to a certain length, while the second - bonds
              at1-at2 and at2-at3 and the angle between them.

              The [bondOrder] can be a number or a string such as
              single, double, triple or aromatic. If it's omitted then
              all bonds between specified atoms will be constrained.
              Atom names are case-sensitive and they must be as they
              are in the Atoms block, or an asterisk '*' denoting any
              atom. The distance, if present, must be in Angstrom. If
              it is omitted then the bond length from the initial
              geometry is used.

              Important: only the bonds present in the system at
              certain points of the simulation (at the start or right
              after adding/removing atoms) can be constrained, which
              means that the bonds may need to be specified in the
              System block.

              Warning: the triangles constraint should be used with
              care because each constrained bond or angle means
              removing one degree of freedom from the dynamics. When
              there are too many constraints (for example, "All
              triangles H C H" in methane) some of them may be
              linearly dependent, which will lead to an error in the
              temperature computation.

              Valid examples: All single bonds C C to 1.4 All bonds O
              H to 0.98 All bonds O H All bonds H * All triangles H *
              H

            * **ConvergeR2** (*float** | **FloatKey*) -- Convergence
              criterion on the max squared difference, in atomic
              units.

            * **ConvergeRV** (*float** | **FloatKey*) -- Convergence
              criterion on the orthogonality of the constraint and the
              relative atomic velocity, in atomic units.

            * **ExcludeRegion** (*str** | **StringKey*) -- Exclude all
              atoms covered by this region expression from all
              constraints. If both atoms of a bond belong to
              ExcludeRegion, the bond will be kept unconstrained,
              regardless of Shake%All or engine-specific constraints.

            * **Iterations** (*int** | **IntKey*) -- Number of
              iterations.

            * **ShakeInitialCoordinates** (*BoolType** | **BoolKey*)
              -- Apply constraints before computing the first energy
              and gradients.

      class _Thermostat

         This block allows to specify the use of a thermostat during
         the simulation. Depending on the selected thermostat type,
         different additional options may be needed to characterize
         the specific thermostat's behavior.

         Variables:
            * **BerendsenApply** (*Literal**[**"Local"**,
              **"Global"**]*) --

              Select how to apply the scaling correction for the
              Berendsen thermostat:

              * per-atom-velocity (Local)

              * on the molecular system as a whole (Global).

            * **ChainLength** (*int** | **IntKey*) -- Number of
              individual thermostats forming the NHC thermostat

            * **Duration** (*Iterable**[**int**] **| **IntListKey*) --
              Specifies how many steps should a transition from a
              particular temperature to the next one in sequence take.

            * **ExcludedDirection** (*Literal**[**"None"**, **"X"**,
              **"Y"**, **"Z"**]*) -- Exclude a component of the
              velocities from rescaling by the thermostat. For example
              in NEMD simulations, when a shear force/velocity is
              applied in the x direction, the x-direction is often
              excluded from thermostatting. This currently only works
              for the Nose-Hoover thermostat.

            * **Friction** (*float** | **FloatKey*) -- Friction
              coefficient used in langevin dynamics

            * **Region** (*str** | **StringKey*) -- The identifier of
              the region to thermostat. The default *** applies the
              thermostat to the entire system. The value can by a
              plain region name, or a region expression, e.g.
              **-myregion* to thermostat all atoms that are not in
              myregion, or *regionA+regionB* to thermostat the union
              of the 'regionA' and 'regionB'. Note that if multiple
              thermostats are used, their regions may not overlap.

            * **ScaleFrequency** (*int** | **IntKey*) --

              Optional parameter used only by the Scale thermostat.

              If specified, the thermostat will be applied every N
              steps, using that step's ensemble temperature and the
              specified thermostat temperature to compute the scaling
              factor.

              If not specified, the thermostat will be applied at
              every step, using the mean temperature of the ensemble
              and the specified thermostat temperature to compute the
              scaling factor.

            * **Tau** (*float** | **FloatKey*) -- The time constant of
              the thermostat.

            * **Temperature** (*Iterable**[**float**] **|
              **FloatListKey*) --

              The target temperature of the thermostat.

              You can specify multiple temperatures (separated by
              spaces). In that case the Duration field specifies how
              many steps to use for the transition from one T to the
              next T (using a linear ramp). For NHC thermostat, the
              temperature may not be zero.

            * **Type** (*Literal**[**"None"**, **"Scale"**,
              **"Berendsen"**, **"NHC"**, **"Langevin"**]*) -- Selects
              the type of the thermostat.

      class _Trajectory

         Sets the frequency for printing to stdout and storing the
         molecular configuration on the .rkf file.

         Variables:
            * **EngineResultsFreq** (*int** | **IntKey*) -- Write
              MDStep*.rkf files with engine-specific results once
              every N steps. Setting this to zero disables writing
              engine results files except for one file at the end of
              the simulation. If this is set to a negative value, the
              value of Checkpoint%Frequency will be used instead.

            * **ExitConditionFreq** (*int** | **IntKey*) -- Check the
              exit conditions every N steps. By default this is done
              every SamplingFreq steps.

            * **PrintFreq** (*int** | **IntKey*) -- Print current
              thermodynamic properties to the output every N steps. By
              default this is done every SamplingFreq steps.

            * **SamplingFreq** (*int** | **IntKey*) -- Write the
              molecular geometry (and possibly other properties) to
              the ams.rkf file once every N steps.

            * **TProfileGridPoints** (*int** | **IntKey*) -- Number of
              points in the temperature profile. If TProfileGridPoints
              > 0, a temperature profile along each of the three
              lattice axes will be written to the .rkf file. The
              temperature at a given profile point is calculated as
              the total temperature of all atoms inside the
              corresponding slice of the simulation box, time-averaged
              over all MD steps since the previous snapshot.​ By
              default, no profile is generated.

            * **WriteBonds** (*BoolType** | **BoolKey*) -- Write
              detected bonds to the .rkf file.

            * **WriteCharges** (*BoolType** | **BoolKey*) -- Write
              current atomic point charges (if available) to the .rkf
              file. Disable this to reduce trajectory size if you do
              not need to analyze charges.

            * **WriteCoordinates** (*BoolType** | **BoolKey*) -- Write
              atomic coordinates to the .rkf file.

            * **WriteEngineGradients** (*BoolType** | **BoolKey*) --
              Write atomic gradients (negative of the atomic forces,
              as calculated by the engine) to the History section of
              ams.rkf.

            * **WriteMolecules** (*BoolType** | **BoolKey*) -- Write
              the results of molecule analysis to the .rkf file.

            * **WriteVelocities** (*BoolType** | **BoolKey*) -- Write
              velocities to the .rkf file. Disable this to reduce
              trajectory size if you do not need to analyze the
              velocities.

      class _fbMC

         This block sets up force bias Monte Carlo interleaved with
         the molecular dynamics simulation.

         Variables:
            * **Frequency** (*int** | **IntKey*) -- Run the fbMC
              procedure every Frequency MD steps.

            * **MassRoot** (*float** | **FloatKey*) -- Inverse of the
              exponent used to mass-weight fbMC steps.

            * **NSteps** (*int** | **IntKey*) -- Number of fbMC steps
              to perform on every invocation of the procedure.

            * **PrintFreq** (*int** | **IntKey*) -- Print current
              thermodynamic properties to the output every N fbMC
              steps. This defaults to the PrintFreq set in the
              Trajectory block. Setting this to zero disables printing
              fbMC steps.

            * **StartStep** (*int** | **IntKey*) -- First step at
              which the fbMC procedure may run.

            * **StepLength** (*float** | **FloatKey*) -- Maximum
              allowed displacement of the lightest atom in the system
              in each Cartesian coordinate in one fbMC step.

            * **StopStep** (*int** | **IntKey*) -- Last step at which
              the fbMC procedure may run. If unset or zero, there is
              no limit.

            * **Temperature** (*float** | **FloatKey*) -- Temperature
              used for fbMC.

            * **MolecularMoves**
              (*AMS._MolecularDynamics._fbMC._MolecularMoves*) -- Move
              molecules as rigid bodies in addition to normal atomic
              moves.

         class _MolecularMoves

            Move molecules as rigid bodies in addition to normal
            atomic moves.

            Variables:
               * **Enabled** (*BoolType** | **BoolKey*) -- Enable
                 moving molecules as rigid bodies based on net forces
                 and torques. Ordinary per-atom displacements will
                 then be based on residual atomic forces.

               * **RotationMethod** (*Literal**[**"Mees"**,
                 **"Rao"**]*) -- Select the fbMC method used to
                 generate molecular rotation moves.

               * **RotationStepAngle** (*float** | **FloatKey*) --
                 Maximum allowed angle of rotation of each molecule in
                 one fbMC step.

               * **TranslationStepLength** (*float** | **FloatKey*) --
                 Maximum allowed displacement of each molecule in each
                 Cartesian coordinate in one fbMC step.

   class _Molecules

      Configures details of the molecular composition analysis enabled
      by the Properties%Molecules block.

      Variables:
         * **AdsorptionSupportRegion** (*str** | **StringKey*) --
           Select region that will represent a support for adsorption
           analysis. Adsorbed molecules will receive an '(ads)' suffix
           after name of the element bonded to the support. Such
           elements will be listed separate from atoms of the same
           element not bonded to the support, for example, HOH(ads)
           for a water molecule bonded to a surface via one of its H
           atoms.

         * **BondOrderCutoff** (*float** | **FloatKey*) -- Bond order
           cutoff for analysis of the molecular composition. Bonds
           with bond order smaller than this value are neglected when
           determining the molecular composition.

   class _NEB

      Configures details of the Nudged Elastic Band optimization.

      Variables:
         * **Climbing** (*BoolType** | **BoolKey*) -- Use the climbing
           image algorithm to drive the highest image to the
           transition state.

         * **ClimbingThreshold** (*float** | **FloatKey*) -- Climbing
           image force threshold. If ClimbingThreshold > 0 and the max
           perpendicular force component is above the threshold then
           no climbing is performed at this step. This entry can be
           used to get a better approximation for the reaction path
           before starting the search for the transition state. A
           typical value is 0.01 Hartree/Bohr.

         * **DoubleNudge** (*Literal**[**"None"**, **"Henkelman"**,
           **"Trygubenko"**]*) -- Type of the double nudging method.

         * **Images** (*int** | **IntKey*) -- Number of NEB images
           (not counting the chain ends). Using more images will
           result in a smoother reaction path and can help with
           convergence problems, but it will also increase the
           computation time.

         * **Intermediates** (*str** | **StringKey*) --

           Define one or more intermediate systems.

           The molecule names are adjusted when saving so that the
           order of the intermediates is the order as they appear in
           the list here.

           If no intermediate systems are needed, select None

         * **InterpolateInternal** (*BoolType** | **BoolKey*) -- The
           initial NEB image geometries are calculated by
           interpolating between the initial and the final state. By
           default, for non-periodic systems the interpolation is
           performed in internal coordinates but the user can choose
           to do it in the Cartesian ones. For periodic systems the
           interpolation is always done in Cartesian coordinates. If
           PreOptimizeWithIDPP is set then the path may be further
           refined using the image-dependent pair potential (IDPP).

         * **InterpolateShortest** (*BoolType** | **BoolKey*) -- Allow
           interpolation across periodic cell boundaries. Set to false
           if an atom is intended to move more than half across the
           simulation box during reaction.

         * **InterpolationOption** (*int** | **IntKey*) --

           Select which internal coordinates will be interpolated:

           0 - automatic,
              1 - only distances,  2 - distances and near-linear
              valence angles,  3 - distances and all valence angles,
              4 - distances and dihedral angles,  99 - all coordinates

         * **Iterations** (*int** | **IntKey*) -- Maximum number of
           NEB iterations. The default value depends on the number of
           degrees of freedom (number of images, atoms, periodic
           dimensions).

         * **Jacobian** (*float** | **FloatKey*) -- Scaling factor
           used to convert the lattice strain to a NEB coordinate
           value. Default value: sqrt(N)*(V/N)^(1/d), where V -
           lattice volume (area for 2D, length for 1D), N - number of
           atoms, and d - number of periodic dimensions.

         * **MapAtomsToCell** (*BoolType** | **BoolKey*) -- Translate
           atoms to the [-0.5,0.5] cell before every step. This option
           cannot be disabled for SS-NEB.

         * **OldTangent** (*BoolType** | **BoolKey*) -- Turn on the
           old central difference tangent.

         * **OptimizeEnds** (*BoolType** | **BoolKey*) -- Start the
           NEB with optimization of the reactant and product
           geometries.

         * **OptimizeLattice** (*BoolType** | **BoolKey*) -- Turn on
           the solid-state NEB (SS-NEB).

         * **PreOptimizeWithIDPP** (*BoolType** | **BoolKey*) --
           (Experimental) When there is only initial and final system
           available, the image-dependent pair potential (IDPP, doi:
           10.1063/1.4878664) can be used to determine the initial NEB
           path by interpolating all interatomic distances between the
           two points and optimizing intermediate images towards them.
           The optimization starts from the geometries obtained using
           the selected interpolation options.

         * **ReOptimizeEnds** (*BoolType** | **BoolKey*) -- Re-
           optimize reactant and product geometries upon restart.

         * **Restart** (*str** | **Path** | **StringKey*) -- Provide
           an ams.rkf file from a previous NEB calculation to restart
           from. It can be an unfinished NEB calculation or one
           performed with different engine parameters.

         * **Skewness** (*float** | **FloatKey*) -- Degree of how much
           images are shifted towards or away from the TS, which may
           help tackle problems with a long reaction path (for example
           involving a loose adsorption complex) without needing too
           many images. A value greater than 1 will make sure that
           images are concentrated near the transition state. The
           optimal value depends on the path length, the number of
           images (larger [Skewness] may be needed for a longer path
           and fewer images). Technically [Skewness] is equal to the
           ratio between the optimized distances to the lower and the
           higher neighbor image on the path.

         * **Spring** (*float** | **FloatKey*) -- Spring force
           constant in atomic units.

         * **LoadPath** (*AMS._NEB._LoadPath*) -- Provide details
           about the trajectory to get the initial NEB path from.
           PESScan and NEB trajectories are supported. Only the last
           geometry for each point on the trajectory is considered.

         * **Parallel** (*AMS._NEB._Parallel*) -- Options for double
           parallelization, which allows to split the available
           processor cores into groups working through all the
           available tasks in parallel, resulting in a better parallel
           performance. The keys in this block determine how to split
           the available processor cores into groups working in
           parallel.

      class _LoadPath

         Provide details about the trajectory to get the initial NEB
         path from. PESScan and NEB trajectories are supported. Only
         the last geometry for each point on the trajectory is
         considered.

         Variables:
            * **File** (*str** | **Path** | **StringKey*) --

              Provide an ams.rkf file to load the initial path from.
              All geometries of this calculation, including initial
              and final, will be taken from the History section of the
              file.

              Note that for a PESScan it should be a 1D path.

            * **Geometries** (*Iterable**[**int**] **| **IntListKey*)
              -- Raw indices of the geometries from the History
              section. By default the last geometry of each path point
              is used.

            * **Points** (*Iterable**[**int**] **| **IntListKey*) --
              By default the whole path is used, which may sometimes
              be not desirable. For example when a PESScan revealed
              multiple barriers. In this case one can specify indices
              of the path points to be used. The last geometry of the
              specified path point will be loaded.

      class _Parallel

         Options for double parallelization, which allows to split the
         available processor cores into groups working through all the
         available tasks in parallel, resulting in a better parallel
         performance. The keys in this block determine how to split
         the available processor cores into groups working in
         parallel.

         Variables:
            * **nCoresPerGroup** (*int** | **IntKey*) -- Number of
              cores in each working group.

            * **nGroups** (*int** | **IntKey*) -- Total number of
              processor groups. This is the number of tasks that will
              be executed in parallel.

            * **nNodesPerGroup** (*int** | **IntKey*) -- Number of
              nodes in each group. This option should only be used on
              homogeneous compute clusters, where all used compute
              nodes have the same number of processor cores.

   class _NormalModes

      Configures details of a normal modes calculation.

      Variables:
         * **Displacements** (*Literal**[**"Cartesian"**,
           **"Symmetric"**, **"Block"**]*) --

           Type of displacements.

           In case of symmetric displacements it is possible to choose
           only the modes that have non-zero IR or Raman intensity.

           Block displacements take rigid blocks into account.

         * **Hessian** (*Literal**[**"Auto"**, **"Analytical"**,
           **"Numerical"**]*) -- Default Auto means that if possible
           by the engine the Hessian will be calculated analytically,
           else the Hessian will be calculated numerically by AMS.

         * **ReScanFreqRange** (*Iterable**[**float**] **|
           **FloatListKey*) -- Specifies a frequency range within
           which all modes will be scanned. 2 numbers: an upper and a
           lower bound.

         * **ReScanModes** (*BoolType** | **BoolKey*) -- Whether or
           not to scan imaginary modes after normal modes calculation
           has concluded.

         * **UseSymmetry** (*BoolType** | **BoolKey*) -- Whether or
           not to exploit the symmetry of the system in the normal
           modes calculation.

         * **BlockDisplacements**
           (*AMS._NormalModes._BlockDisplacements*) -- Configures
           details of a Block Normal Modes (a.k.a. Mobile Block
           Hessian, or MBH) calculation.

         * **SymmetricDisplacements**
           (*AMS._NormalModes._SymmetricDisplacements*) -- Configures
           details of the calculation of the frequencies and normal
           modes of vibration in symmetric displacements.

      class _BlockDisplacements

         Configures details of a Block Normal Modes (a.k.a. Mobile
         Block Hessian, or MBH) calculation.

         Variables:
            * **AngularDisplacement** (*float** | **FloatKey*) --
              Relative step size for rotational degrees of freedom
              during Block Normal Modes finite difference
              calculations. It will be scaled with the characteristic
              block size.

            * **BlockAtoms** (*Iterable**[**int**] **| **IntListKey*)
              -- List of atoms belonging to a block. You can have
              multiple BlockAtoms.

            * **BlockRegion** (*str** | **StringKey*) -- The region to
              to be considered a block. You can have multiple
              BlockRegions, also in combination with BlockAtoms.

            * **RadialDisplacement** (*float** | **FloatKey*) -- Step
              size for translational degrees of freedom during Block
              Normal Modes finite difference calculations.

            * **Parallel**
              (*AMS._NormalModes._BlockDisplacements._Parallel*) --
              Configuration for how the individual displacements are
              calculated in parallel.

         class _Parallel

            Configuration for how the individual displacements are
            calculated in parallel.

            Variables:
               * **nCoresPerGroup** (*int** | **IntKey*) -- Number of
                 cores in each working group.

               * **nGroups** (*int** | **IntKey*) -- Total number of
                 processor groups. This is the number of tasks that
                 will be executed in parallel.

               * **nNodesPerGroup** (*int** | **IntKey*) -- Number of
                 nodes in each group. This option should only be used
                 on homogeneous compute clusters, where all used
                 compute nodes have the same number of processor
                 cores.

      class _SymmetricDisplacements

         Configures details of the calculation of the frequencies and
         normal modes of vibration in symmetric displacements.

         Variables:
            **Type** (*Literal**[**"All"**, **"Infrared"**,
            **"Raman"**, **"InfraredAndRaman"**]*) --

            For symmetric molecules it is possible to choose only the
            modes that have non-zero IR or Raman intensity (or either
            of them) by symmetry.

            In order to calculate the Raman intensities the Raman
            property must be requested.

   class _NumericalDifferentiation

      Define options for numerical differentiations, that is the
      numerical calculation of gradients, Hessian and the stress
      tensor for periodic systems.

      Variables:
         * **NuclearStepSize** (*float** | **FloatKey*) -- Step size
           for numerical nuclear gradient calculation.

         * **StrainStepSize** (*float** | **FloatKey*) -- Step size
           (relative) for numerical stress tensor calculation.

         * **UseSymmetry** (*BoolType** | **BoolKey*) -- Whether or
           not to exploit the symmetry of the system for numerical
           differentiations.

         * **Parallel** (*AMS._NumericalDifferentiation._Parallel*) --
           Options for double parallelization, which allows to split
           the available processor cores into groups working through
           all the available tasks in parallel, resulting in a better
           parallel performance. The keys in this block determine how
           to split the available processor cores into groups working
           in parallel.

      class _Parallel

         Options for double parallelization, which allows to split the
         available processor cores into groups working through all the
         available tasks in parallel, resulting in a better parallel
         performance. The keys in this block determine how to split
         the available processor cores into groups working in
         parallel.

         Variables:
            * **nCoresPerGroup** (*int** | **IntKey*) -- Number of
              cores in each working group.

            * **nGroups** (*int** | **IntKey*) -- Total number of
              processor groups. This is the number of tasks that will
              be executed in parallel.

            * **nNodesPerGroup** (*int** | **IntKey*) -- Number of
              nodes in each group. This option should only be used on
              homogeneous compute clusters, where all used compute
              nodes have the same number of processor cores.

   class _NumericalPhonons

      Configures details of a numerical phonons calculation.

      Variables:
         * **AutomaticBZPath** (*BoolType** | **BoolKey*) -- If True,
           compute the phonon dispersion curve for the standard path
           through the Brillouin zone. If False, you must specify your
           custom path in the [BZPath] block.

         * **BornEffCharge** (*float** | **FloatKey*) -- Input option
           to give the Born effective charges of the species.

         * **DielectricConst** (*float** | **FloatKey*) -- Input
           option to give the static dielectric constant of the
           species.

         * **DoubleSided** (*BoolType** | **BoolKey*) -- By default a
           two-sided (or quadratic) numerical differentiation of the
           nuclear gradients is used. Using a single-sided (or linear)
           numerical differentiation is computationally faster but
           much less accurate. Note: In older versions of the program
           only the single-sided option was available.

         * **Interpolation** (*int** | **IntKey*) -- Use interpolation
           to generate smooth phonon plots.

         * **KPathFinderConvention** (*Literal**[**"Setyawan-
           Curtarolo"**, **"Hinuma"**]*) --

           This option determines how the path through the Brillouin
           zone is generated when using the automatic k-point mode.

           Available options:

           * "Setyawan-Curtarolo" (default for 1D and 2D lattices):
             Uses our built-in KPath program to find a path through
             high-symmetry points based on the method by Setyawan and
             Curtarolo
             (https://doi.org/10.1016/j.commatsci.2010.05.010). For 2D
             lattices, the path is derived from the intersection of
             the 3D Brillouin zone with a plane. For 1D lattices, the
             path is simply Gamma-Z.

           * "Hinuma": Uses the external SeeKPath utility to generate
             the k-path (https://github.com/giovannipizzi/seekpath and
             https://doi.org/10.1016/j.commatsci.2016.10.015).

         * **MaxTemperature** (*float** | **FloatKey*) -- Maximum
           temperature for the thermodynamic properties calculation
           (Internal Energy, Free Energy, Specific Heat, and Entropy).
           This value sets the upper limit of the temperature range
           considered. It is used in conjunction with "NTemperatures"
           to define the temperature grid. The calculation of
           thermodynamic properties is performed only if the phonon
           density of states (DOS) is requested (i.e., "Phonons%DOS"
           is set to "Yes").

         * **NDosEnergies** (*int** | **IntKey*) -- Nr. of energies
           used to calculate the phonon DOS used to integrate
           thermodynamic properties. For fast compute engines this may
           become time limiting and smaller values can be tried.

         * **NTemperatures** (*int** | **IntKey*) -- Number of
           temperature points to use in the thermodynamic properties
           calculation (Internal Energy, Free Energy, Specific Heat,
           and Entropy). This value, along with "MaxTemperature",
           determines the density of the temperature grid.  The
           temperatures will be distributed evenly between 0 Kelvin
           and 'MaxTemperature'. The calculation of thermodynamic
           properties is performed only if the phonon density of
           states (DOS) is requested (i.e., "Phonons%DOS" is set to
           "Yes").

         * **RequestContinuousPES** (*BoolType** | **BoolKey*) --
           Whether or not the engine should be instructed to disable
           symmetry. AMS versions older than AMS2024 would use the the
           hard coded value false.

         * **StepSize** (*float** | **FloatKey*) -- Step size to be
           taken to obtain the force constants (second derivative)
           from the analytical gradients numerically.

         * **UseSymmetry** (*BoolType** | **BoolKey*) -- Whether or
           not to exploit the symmetry of the system in the phonon
           calculation.

         * **BZPath** (*AMS._NumericalPhonons._BZPath*) -- If
           [NumericalPhonons%AutomaticBZPath] is false, the phonon
           dispersion curve will be computed for the user-defined path
           in the [BZPath] block. You should define the vertices of
           your path in fractional coordinates (with respect to the
           reciprocal lattice vectors) in the [Path] sub-block. If you
           want to make a jump in your path (i.e. have a discontinuous
           path), you need to specify a new [Path] sub-block.

         * **Parallel** (*AMS._NumericalPhonons._Parallel*) -- Options
           for double parallelization, which allows to split the
           available processor cores into groups working through all
           the available tasks in parallel, resulting in a better
           parallel performance. The keys in this block determine how
           to split the available processor cores into groups working
           in parallel.

         * **SuperCell** (*str** | **Sequence**[**str**] **|
           **FreeBlock*) -- Used for the phonon run. The super lattice
           is expressed in the lattice vectors. Most people will find
           a diagonal matrix easiest to understand.

      class _BZPath

         If [NumericalPhonons%AutomaticBZPath] is false, the phonon
         dispersion curve will be computed for the user-defined path
         in the [BZPath] block. You should define the vertices of your
         path in fractional coordinates (with respect to the
         reciprocal lattice vectors) in the [Path] sub-block. If you
         want to make a jump in your path (i.e. have a discontinuous
         path), you need to specify a new [Path] sub-block.

         Variables:
            **Path** (*str** | **Sequence**[**str**] **| **FreeBlock*)
            -- A section of a k space path. This block should contain
            multiple lines, and in each line you should specify one
            vertex of the path in fractional coordinates. Optionally,
            you can add text labels for your vertices at the end of
            each line.

         class _Path

            A section of a k space path. This block should contain
            multiple lines, and in each line you should specify one
            vertex of the path in fractional coordinates. Optionally,
            you can add text labels for your vertices at the end of
            each line.

      class _Parallel

         Options for double parallelization, which allows to split the
         available processor cores into groups working through all the
         available tasks in parallel, resulting in a better parallel
         performance. The keys in this block determine how to split
         the available processor cores into groups working in
         parallel.

         Variables:
            * **nCoresPerGroup** (*int** | **IntKey*) -- Number of
              cores in each working group.

            * **nGroups** (*int** | **IntKey*) -- Total number of
              processor groups. This is the number of tasks that will
              be executed in parallel.

            * **nNodesPerGroup** (*int** | **IntKey*) -- Number of
              nodes in each group. This option should only be used on
              homogeneous compute clusters, where all used compute
              nodes have the same number of processor cores.

      class _SuperCell

         Used for the phonon run. The super lattice is expressed in
         the lattice vectors. Most people will find a diagonal matrix
         easiest to understand.

   class _PESExploration

      Configures details of the automated PES exploration methods.

      Variables:
         * **CalculateEnergyReferences** (*BoolType** | **BoolKey*) --
           Calculates the energy references.

         * **CalculateFragments** (*BoolType** | **BoolKey*) -- The
           reference region must be defined using the
           StatesAlignment%ReferenceRegion keyword. This enables the
           distinction between two parts of the chemical system: the
           adsorbent, identified by the reference region, and the
           adsorbate, which comprises the remaining portion. This
           keyword initiates a geometry optimization calculation for
           both the adsorbate and adsorbent individually for each
           state in the database at the end of the execution.
           Fragmented states are included in the energy landscape.
           This keyword does not apply to LandscapeRefinement
           calculations.

         * **DynamicSeedStates** (*BoolType** | **BoolKey*) -- Whether
           subsequent expeditions may start from states discovered by
           previous expeditions. This should lead to a more
           comprehensive exploration of the potential energy surface.
           Disabling this will focus the PES exploration around the
           initial seed states.

         * **ExcludeReflectionAxes** (*Literal**[**"x"**, **"y"**,
           **"z"**, **"None"**]*) -- Determines which axial
           reflections ('x', 'y', or 'z') to exclude when generating
           symmetry images. This parameter is active only if
           [GenerateSymmetryImages] is *True*. The default 'z' axis
           exclusion is commonly used for 2D systems (e.g., slabs) to
           prevent unintended projection of binding sites across the
           slab plane.

         * **FiniteDifference** (*float** | **FloatKey*) -- The finite
           difference distance to use for Dimer, Hessian, Lanczos, and
           optimization methods.

         * **GenerateSymmetryImages** (*BoolType** | **BoolKey*) -- By
           activating this option, after concluding the energy
           landscape exploration process, it will create the complete
           set of symmetry-related copies by using the symmetry
           operators of the reference structure. SinglePoint
           calculations (including gradients and normal modes) are
           carried out for each new image structure obtained.

         * **Job** (*Literal**[**"ProcessSearch"**,
           **"BasinHopping"**, **"SaddleSearch"**,
           **"LandscapeRefinement"**, **"BindingSites"**,
           **"NudgedElasticBand"**, **"SystemMatching"**]*) -- Specify
           the PES exploration job to perform.

         * **NegativeEigenvalueTolerance** (*float** | **FloatKey*) --
           The threshold in Hessian eigenvalue below which a mode is
           considered imaginary, i.e. indicating a transition state.
           This is a small negative number, as very small negative
           eigenvalues may be due to numerical noise on an essentially
           flat PES and do not indicate true transition states. We
           need a more flexible value for this parameter in
           PESExploration because the high computational cost of the
           task typically forces us to reduce the engine precision,
           which increases the noise in the vibrational frequencies
           evaluation. [PESPointCharacter%NegativeEigenvalueTolerance]
           is overridden by this parameter.

         * **NumExpeditions** (*int** | **IntKey*) -- Sets the number
           of subsequent expeditions our job will consist of. Larger
           values result in a more comprehensive exploration of the
           potential energy surface, but will take more computational
           time.

         * **NumExplorers** (*int** | **IntKey*) -- Sets the number of
           independent PES explorers dispatched as part of each
           expedition. Larger values will result in a more
           comprehensive exploration of the potential energy surface,
           but will take more computational time. By default an
           appropriate number of explorers are executed in parallel.

         * **OptTSMethod** (*Literal**[**"SaddleSearch"**,
           **"NudgedElasticBand"**]*) -- When the full set of states
           in the energy landscape are optimized (see
           PESExploration%Job = GeometryOptimization), transition
           states can be optimized using either SaddleSearch or
           NudgedElasticBand methods. SaddleSearch uses information
           only from the current geometry of the TS; contrary,
           NudgedElasticBand ignores the current geometry and runs a
           Nudged-Elastic-Band calculation trying to connect the
           associated reactants and products if they are available.

         * **Potential** (*str** | **StringKey*) -- The PES to be
           explored. The default is to use a callback into AMS to
           evaluate the energy and gradients using an AMS engine. This
           can be changed here to give access to one of the EON
           client's builtin potentials. This has not been well tested
           by SCM.

         * **RandomSeed** (*int** | **IntKey*) -- Number used to
           initialize both the EON clients random number generators as
           well as the AMS global RNG. The latter is normally
           initialized with the RNGSeed keyword at the root level.
           Should be used by developers only. May or may not help to
           make more reproducible regression tests ...

         * **SelectedListedAtomsForPESPointCharacter** (*str** |
           **StringKey*) -- Uses the Hessian matrix elements only for
           the listed atoms to determine the PES point character of a
           located state during the exploration. If not specified, the
           full Hessian is used.

         * **SelectedRegionForPESPointCharacter** (*str** |
           **StringKey*) -- Uses the Hessian matrix elements only for
           the atoms in a particular region to determine the PES point
           character of a located state during the exploration. If not
           specified, the full Hessian is used.

         * **Temperature** (*float** | **FloatKey*) -- The temperature
           that the job will run at. This may be used in different
           ways depending on the job, e.g. acceptance probabilities
           for Monte-Carlo based jobs, thermostatting for dynamics
           based jobs, kinetic prefactors for jobs that find
           transition states. Some jobs may not use this temperature
           at all.

         * **WriteEngineGradients** (*BoolType** | **BoolKey*) --
           Write atomic gradients (negative of the atomic forces, as
           calculated by the engine) to the History section of
           ams.rkf.

         * **WriteHistory** (*Literal**[**"None"**, **"Converged"**,
           **"All"**]*) -- When to write the molecular geometry (and
           possibly other properties) to the history on the ams.rkf
           file. The default is to only write the converged geometries
           to the history. Can be changed to write no frames at all to
           the history, or write all frames (should only be used when
           testing because of the performance impact). Note that for
           parallel calculations, only the first group of processes
           writes to ams.rkf.

         * **BasinHopping** (*AMS._PESExploration._BasinHopping*) --
           Configures the details of the Basin Hopping subtask.

         * **BindingSites** (*AMS._PESExploration._BindingSites*) --
           Options related to the calculation of binding sites.

         * **Debug** (*AMS._PESExploration._Debug*) -- Options for
           debugging purposes. Should only be used by developers.

         * **Dynamics** (*AMS._PESExploration._Dynamics*) -- Settings
           for molecular dynamics, used by dynamics-based search
           methods.

         * **Hessian** (*AMS._PESExploration._Hessian*) -- Settings
           for Hessian calculations and vibrational analysis.

         * **LandscapeRefinement**
           (*AMS._PESExploration._LandscapeRefinement*) -- Configures
           details of the energy landscape refinement job.

         * **LoadEnergyLandscape**
           (*AMS._PESExploration._LoadEnergyLandscape*) -- Options
           related to the loading of an Energy Landscape from a
           previous calculation.

         * **LoadInitialSystems**
           (*AMS._PESExploration._LoadInitialSystems*) -- Load initial
           systems from different sources.

         * **NudgedElasticBand**
           (*AMS._PESExploration._NudgedElasticBand*) -- Options for
           the Nudged Elastic Band (NEB) method.

         * **Optimizer** (*AMS._PESExploration._Optimizer*) --
           Configures the details of the geometry optimizers used by
           the PES explorers.

         * **Parallel** (*AMS._PESExploration._Parallel*) -- Options
           for double parallelization, which allows to split the
           available processor cores into groups working through all
           the available tasks in parallel, resulting in a better
           parallel performance. The keys in this block determine how
           to split the available processor cores into groups working
           in parallel.

         * **ParallelReplica**
           (*AMS._PESExploration._ParallelReplica*) -- Settings for
           the Parallel Replica Dynamics method.

         * **Prefactor** (*AMS._PESExploration._Prefactor*) --
           Settings for calculating reaction rate pre-exponential
           factors.

         * **ProcessSearch** (*AMS._PESExploration._ProcessSearch*) --
           Input options specific to the process search procedure.

         * **SaddleSearch** (*AMS._PESExploration._SaddleSearch*) --
           Configuration for the Saddle Search procedure (used in
           SaddleSearch and ProcessSearch Jobs).

         * **StatesAlignment**
           (*AMS._PESExploration._StatesAlignment*) -- Configures
           details of how the energy landscape configurations are
           aligned respect to the main chemical system [System].

         * **StructureComparison**
           (*AMS._PESExploration._StructureComparison*) -- Settings
           for structure comparison.

      class _BasinHopping

         Configures the details of the Basin Hopping subtask.

         Variables:
            * **AdjustDisplacement** (*BoolType** | **BoolKey*) --
              Automatically adjust the displacement size to meet the
              target acceptance ratio.

            * **AdjustFraction** (*float** | **FloatKey*) -- The
              fraction by which to change the step size in order to
              meet the target acceptance ratio.

            * **AdjustPeriod** (*int** | **IntKey*) -- The number of
              Monte Carlo steps between adjustments of the step size.

            * **DisplaceAtomsInRegion** (*str** | **StringKey*) -- If
              you specify a region name here, only the atoms belonging
              to this region will be displaced during the basin
              hopping procedure. For more details on regions, see the
              documentation on the System definition.

            * **DisplaceListedAtoms** (*str** | **StringKey*) --
              Specifies a list of atom indices (e.g., '1 5 10') to be
              exclusively considered for displacement during the basin
              hopping steps. If empty, all atoms (or those in a
              specified region) are eligible.

            * **DisplaceListedTypes** (*str** | **StringKey*) --
              Specifies a list of atom types (e.g., 'H C') to be
              exclusively considered for displacement. Atoms of these
              types will be randomly moved.

            * **Displacement** (*float** | **FloatKey*) --
              Displacement in each degree of freedom.

            * **DisplacementAlgorithm** (*Literal**[**"Standard"**,
              **"Linear"**, **"Quadratic"**]*) -- Undocumented in EON.

            * **DisplacementDistribution** (*Literal**[**"Uniform"**,
              **"Gaussian"**]*) --

              The distribution used for the displacement of each atom.

              * Gaussian: The value of the "Displacement" keyword
                serves as the standard deviation of a Gaussian
                distribution used to draw the nuclear displacements
                from.

              * A random number is selected uniformly between
                "-Displacement" and "Displacement".

            * **InitialRandomStructureProbability** (*float** |
              **FloatKey*) -- Probability to generate an entirely
              random structure to start the Basin Hopping from.

            * **JumpMax** (*int** | **IntKey*) -- The number of
              consecutive rejected steps after which jump steps should
              be taken. This serves to provide a more global search
              when the structure is stuck in a certain basin. The
              number of jump steps is assigned in jump_steps. See
              paper on the Basin Hopping with Occasional Jumping
              algorithm by Iwamatsu and Okabe: Chem. Phys. Lett. 399
              396 (2004)

            * **JumpSteps** (*int** | **IntKey*) -- The number of jump
              steps to take after the "JumpMax" number of consecutive
              rejections have taken place.

            * **MainSystemAsSeed** (*BoolType** | **BoolKey*) -- If
              true, only the main system will be used as a seed state.
              The main system is not added to the database.

            * **PESPointCharacterization** (*BoolType** | **BoolKey*)
              -- If true, a PES point characterization based on a
              vibrational analysis is carried out to confirm each
              detected state is an actual local minimum (no imaginary
              frequencies). Conversely, if this option is false, the
              PES point characterization is avoided, which will assume
              that all located states are local minima (zero
              gradients). Enabling this option is very useful for
              large systems. It circumvents the need for computing and
              diagonalizing the Hessian matrix, a typically expensive
              computational process.

            * **PushApartDistance** (*float** | **FloatKey*) -- Push
              atoms apart until no atoms are closer than this
              distance. This criterion is enforced for the initial
              structure and all those generated by random
              displacements.

            * **QuenchingSteps** (*int** | **IntKey*) -- Undocumented
              in EON.

            * **RotateNonListedAtoms** (*BoolType** | **BoolKey*) --
              If true, each iteration randomly rotates all atoms as a
              rigid body, excluding those listed in
              [BasinHopping%DisplaceListedAtoms],
              [BasinHopping%DisplaceListedTypes], or
              [BasinHopping%DisplaceAtomsInRegion].

            * **SignificantStructure** (*BoolType** | **BoolKey*) --
              If true, the Significant Structure Basin Hopping (SSBH)
              variant instead of the Raw Structure Basin Hopping
              method (RSBH). In SSBH previously found structures are
              used as initial structures for further displacements,
              see Chem. Phys. Lett. 289, 463 (1998) for a comparison
              of the two approaches.

            * **SingleAtomDisplace** (*BoolType** | **BoolKey*) -- If
              true, only one atom is displaced per step. Otherwise all
              atoms of the structure are randomly displaced.

            * **Steps** (*int** | **IntKey*) -- Number of displace &
              optimize Monte-Carlo steps to take.

            * **StopEnergy** (*float** | **FloatKey*) -- Undocumented
              in EON.

            * **SwapProbability** (*float** | **FloatKey*) -- The
              probability in range [0,1] that a swapping step takes
              place instead of a displacement step. The swap step
              selects two atoms of different elements and swaps their
              position.

            * **TargetRatio** (*float** | **FloatKey*) -- The target
              acceptance ratio that will be used to determine whether
              to increase or decrease the step size.

            * **WriteUnique** (*BoolType** | **BoolKey*) -- If true,
              all unique states found will be included in the energy
              landscape, even the rejected ones. If false, only the
              lowest energy structure will be included in the energy
              landscape.

      class _BindingSites

         Options related to the calculation of binding sites.

         Variables:
            * **Calculate** (*BoolType** | **BoolKey*) -- Calculate
              binding sites at the end of a job. Not needed for
              Binding Sites job.

            * **DistanceDifference** (*float** | **FloatKey*) -- If
              the distance between two mapped binding-sites is larger
              than this threshold, the binding-sites are considered
              different. If not specified, its value will set equal to
              [PESExploration%StructureComparison%DistanceDifference]

            * **MaxCoordinationShellsForLabels** (*int** | **IntKey*)
              -- The binding site labels are given based on the
              coordination numbers of shells in the reference region,
              using the following format: N<int><int>..., e.g., the
              label 'N334' means 3 atoms in the first coordination
              shell, 3 in the second one, and 4 in the third one. This
              parameter controls the maximum number of shells to
              include.

            * **NeighborCutoff** (*float** | **FloatKey*) -- Atoms
              within this distance of each other are considered
              neighbors for the calculation of the binding sites. If
              not specified, its value will set equal to
              [PESExploration%StructureComparison%NeighborCutoff]

            * **PositioningMethod**
              (*Literal**[**"AdsorbedAtomCoords"**,
              **"ConstantDistance"**]*) -- Determines how the binding
              site's coordinates are defined. • AdsorbedAtomCoords:
              Use the exact coordinates of the adsorbed atom as the
              binding site. • ConstantDistance: Place the binding site
              at a fixed distance from the surface. This position is
              calculated along the vector that connects the surface to
              the atom. See the
              "[PESExploration%StructureComparison%SurfaceOffset]"
              option.

            * **ReferenceRegion** (*str** | **StringKey*) -- Defines
              the region that is considered as the reference for
              binding sites detection. Binding sites are projected on
              this region using the geometry from the reference
              system. If not specified, its value will set equal to
              [PESExploration%StatesAlignment%ReferenceRegion]

            * **SurfaceOffset** (*float** | **FloatKey*) -- Sets the
              binding site's distance from the surface. This value is
              only used when
              "[PESExploration%StructureComparison%PositioningMethod]"
              is set to "ConstantDistance". The distance is measured
              from a reference point on the surface, which is the
              centroid of the adsorbate's nearest neighbor atoms.

      class _Debug

         Options for debugging purposes. Should only be used by
         developers.

         Variables:
            **KeepBadSaddles** (*BoolType** | **BoolKey*) -- If true,
            saddles that do not meet the required criteria (e.g.,
            connecting to the correct minima) are still kept in the
            database for analysis.

      class _Dynamics

         Settings for molecular dynamics, used by dynamics-based
         search methods.

         Variables:
            * **Thermostat** (*Literal**[**"andersen"**,
              **"nose_hoover"**, **"langevin"**, **"none"**]*) --
              Selects the thermostat algorithm to control the
              simulation temperature.

            * **Time** (*float** | **FloatKey*) -- The total
              simulation time for the molecular dynamics trajectory in
              femtoseconds.

            * **TimeStep** (*float** | **FloatKey*) -- The integration
              time step for the molecular dynamics simulation in
              femtoseconds.

            * **Andersen** (*AMS._PESExploration._Dynamics._Andersen*)
              -- Settings for the Andersen thermostat.

            * **Langevin** (*AMS._PESExploration._Dynamics._Langevin*)
              -- Settings for the Langevin thermostat.

            * **Nose** (*AMS._PESExploration._Dynamics._Nose*) --
              Settings for the Nosé-Hoover thermostat.

         class _Andersen

            Settings for the Andersen thermostat.

            Variables:
               * **Alpha** (*float** | **FloatKey*) -- A coupling
                 parameter that influences the strength of the
                 Andersen thermostat.

               * **CollisionPeriod** (*float** | **FloatKey*) -- The
                 average time between stochastic collisions with the
                 heat bath in femtoseconds.

         class _Langevin

            Settings for the Langevin thermostat.

            Variables:
               **Friction** (*float** | **FloatKey*) -- The friction
               coefficient that determines the strength of the
               coupling to the heat bath.

         class _Nose

            Settings for the Nosé-Hoover thermostat.

            Variables:
               **Mass** (*float** | **FloatKey*) -- The fictitious
               mass of the extended degree of freedom that couples to
               the system.

      class _Hessian

         Settings for Hessian calculations and vibrational analysis.

         Variables:
            * **AtomList** (*str** | **StringKey*) -- Specifies which
              atoms to include in a partial Hessian calculation. Can
              be a list of indices (e.g., '1 2 3') or 'all'.

            * **ZeroFreqValue** (*float** | **FloatKey*) --
              Frequencies with a magnitude smaller than this value are
              considered to be zero. This helps filter out numerical
              noise associated with translational and rotational
              modes.

      class _LandscapeRefinement

         Configures details of the energy landscape refinement job.

         Variables:
            * **CalculateOnlyEnergies** (*BoolType** | **BoolKey*) --
              If true, the states' geometry is not optimized, and the
              final PES point characterization is ignored [PESExplora
              tion%LandscapeRefinement%IgnoreFinalPESPointCharacter].
              Only energy values are updated using the specified
              engine. Furthermore, normal modes and associated
              properties are copied from the previous calculation to
              avoid the typically high computational effort of the
              Hessian matrix calculation. Enabling this option implies
              that RunInitialSinglePoints='F',
              IgnoreFinalPESPointCharacter='T'.

            * **GenerateFragments** (*BoolType** | **BoolKey*) -- The
              reference region must be defined using the
              StatesAlignment%ReferenceRegion keyword. This enables
              the distinction between two parts of the chemical
              system: the adsorbent, identified by the reference
              region, and the adsorbate, which comprises the remaining
              portion. This keyword (if true) initiates a single-point
              calculation for both the adsorbate and adsorbent
              individually for each state in the database. Fragmented
              states are included in the energy landscape.

            * **IgnoreFinalPESPointCharacter** (*BoolType** |
              **BoolKey*) -- At the end of the energy landscape
              refinement job, each state is assigned a PES point
              character (MIN or TS) based on its vibrational
              frequencies before being included in the final database.
              States are only added if the PES point character after
              refinement remains unchanged. However, states are added
              without verifying if this option is "true". Nonetheless,
              vibrational frequencies are calculated and stored for
              future analysis. This option is especially useful when
              using computationally demanding engines. Because in
              those cases, precision and computational effort must be
              balanced, resulting in significant vibrational
              frequencies inaccuracies.

            * **IgnoreFinalPESPointCharacterForFragments**
              (*BoolType** | **BoolKey*) -- Same as
              "LandscapeRefinement%IgnoreFinalPESPointCharacter" but
              regarding the Fragments calculations, see option
              "LandscapeRefinement%CalculateFragments".

            * **Quiet** (*BoolType** | **BoolKey*) -- Suppress the
              output details of the geometry optimizations.

            * **RelaxFromSaddlePoint** (*BoolType** | **BoolKey*) --
              Relaxes the saddle point geometries following the
              imaginary mode to get both reactants and products.

            * **RunInitialSinglePoints** (*BoolType** | **BoolKey*) --
              If it is "true", just after loading the energy landscape
              to refine, the single energy point computations are
              disabled. Be aware that if you enable this, the output
              file's 'Initial Energy Landscape' section will display
              incorrect states' energy values. If the engine requires
              too much processing power, this option can help you save
              a small amount of time.

            * **TransitionStateSearchMethod** (*Literal**[**"Auto"**,
              **"Dimer"**]*) -- Sets the method to refine transition
              states.

            * **UseReactantsAndProductsForTSs** (*BoolType** |
              **BoolKey*) -- For the refinement of transition states,
              the reaction coordinate can be estimated using either
              the reactants or products (final system). By enabling
              this option, the difference between the initial and
              final geometries is utilized as the reaction coordinate.
              The final system with the lowest RMSD is chosen to
              determine this coordinate. For more details see the
              section [TransitionStateSearch].

      class _LoadEnergyLandscape

         Options related to the loading of an Energy Landscape from a
         previous calculation.

         Variables:
            * **ExcludeReflectionAxes** (*Literal**[**"x"**, **"y"**,
              **"z"**, **"None"**]*) -- Determines which axial
              reflections ('x', 'y', or 'z') to exclude when
              generating symmetry images. This parameter is active
              only if [BindingSites%GenerateSymmetryImages] is *True*.
              The default 'z' axis exclusion is commonly used for 2D
              systems (e.g., slabs) to prevent unintended projection
              of binding sites across the slab plane.

            * **GenerateSymmetryImages** (*BoolType** | **BoolKey*) --
              By activating this option, after loading the energy
              landscape, it will create the complete set of symmetry-
              related copies by using the symmetry operators of the
              reference structure. Be aware that rkf result files of
              the generated symmetry images are copies from the parent
              structures but only atomic coordinates are updated.

            * **KeepOnly** (*Iterable**[**int**] **| **IntListKey*) --
              Upon loading the Energy Landscape, only keep the states
              specified here. The states should be specified via a
              list of integers referring to the indices of the states
              you want to keep.

            * **Path** (*str** | **Path** | **StringKey*) -- AMS
              results folder to load an energy landscape from. In the
              text input file, you may alternatively specify a ".con"
              file in the native EON format.

            * **Remove** (*Iterable**[**int**] **| **IntListKey*) --
              Upon loading the Energy Landscape, remove (i.e. do not
              load) the states specified here. The states should be
              specified via a list of integers referring to the
              indices of the states you want to remove (i.e. the
              states you don't want to load).

            * **RemoveWithNoBindingSites** (*BoolType** | **BoolKey*)
              -- Upon loading the Energy Landscape, it removes states
              with no associated binding sites. Associated transition
              states are also removed. This is an advantageous option
              to remove physisorbed states automatically. Notice that
              it requires that the previous calculation was executed,
              enabling the option [BindingSites%Calculate].

            * **SeedStates** (*Iterable**[**int**] **| **IntListKey*)
              -- By default when you start a new PES Exploration from
              a loaded Energy Landscape, expeditions can start from
              any of the loaded minima. By using this input option,
              you can instruct the program to only use some of the
              states as 'expedition starting point'. The states that
              serve as 'expedition starting points' should be
              specified via a list of integers referring to the
              indices of the states.

      class _LoadInitialSystems

         Load initial systems from different sources.

         Variables:
            **FromKFHistory**
            (*AMS._PESExploration._LoadInitialSystems._FromKFHistory*)
            -- Load initial systems from the History section of kf
            files.

         class _FromKFHistory

            Load initial systems from the History section of kf files.

            Variables:
               * **Path** (*str** | **Path** | **StringKey*) -- AMS
                 results folder to load the initial systems from. In
                 the text input file, you may alternatively specify a
                 ".kf" file. By default, the "ams.kf" file will be
                 used.

               * **TargetPESPointCharacter** (*Literal**[**"MIN"**,
                 **"TS"**]*) -- Selects the PES point character for
                 all loaded systems.

      class _NudgedElasticBand

         Options for the Nudged Elastic Band (NEB) method.

         Variables:
            * **ClimbingImageConvergedOnly** (*BoolType** |
              **BoolKey*) -- If true, the climbing image is only
              activated after the rest of the NEB path has reached a
              pre-defined convergence threshold.

            * **ClimbingImageMethod** (*BoolType** | **BoolKey*) --
              Use the climbing image algorithm to drive the highest
              image to the transition state.

            * **ConvergedForce** (*float** | **FloatKey*) --
              Convergence threshold for nuclear gradients. Note:
              Special value of -1.0 means using the same convergence
              criterion as the PES explorer's geometry optimizer.

            * **DoublyNudged** (*BoolType** | **BoolKey*) -- Enables
              the Doubly Nudged Elastic Band (DNEB) method, which adds
              a perpendicular spring force to better maintain equal
              spacing between images.

            * **DoublyNudgedSwitching** (*BoolType** | **BoolKey*) --
              Enables a DNEB variant where the doubly-nudged force is
              switched on and off during the optimization.

            * **ElasticBand** (*BoolType** | **BoolKey*) -- If true, a
              plain Elastic Band (EB) calculation is performed, where
              the perpendicular component of the true force is not
              removed.

            * **Images** (*int** | **IntKey*) -- Number of NEB images
              between the two endpoints.

            * **MaxIterations** (*int** | **IntKey*) -- Maximum number
              of NEB iterations.

            * **OldTangent** (*BoolType** | **BoolKey*) -- Use the old
              central difference tangent.

            * **OptMethod** (*str** | **StringKey*) -- Specifies the
              optimization method to use for relaxing the NEB images.
              If empty, the global optimizer settings are used.

            * **Spring** (*float** | **FloatKey*) -- Spring force
              constant.

      class _Optimizer

         Configures the details of the geometry optimizers used by the
         PES explorers.

         Variables:
            * **ConvergedForce** (*float** | **FloatKey*) --
              Convergence threshold for nuclear gradients.

            * **ConvergenceMetric** (*Literal**[**"norm"**,
              **"max_atom"**, **"max_component"**]*) -- Determines how
              the EON client checks the convergence of the forces.
              "norm" uses the Frobenius norm of the (3,nFreeAtoms)
              forces array. "max_atom" takes the maximum norm2 of the
              nFreeAtoms individual force vectors on the free atoms.
              "max_component" just takes the maximum of all elements
              in the array. Don't change this at the moment, as it
              will break snapshot writing to the history section of
              ams.rkf.

            * **MaxIterations** (*int** | **IntKey*) -- Maximum number
              of iterations allowed for optimizations.

            * **MaxMove** (*float** | **FloatKey*) -- The maximum
              distance any atom is allowed to move in a single
              optimization step.

            * **MaxTimeStep** (*float** | **FloatKey*) -- The maximum
              allowed time step for the optimizer to prevent
              instability.

            * **Method** (*Literal**[**"CG"**, **"QM"**, **"LBFGS"**,
              **"FIRE"**, **"SD"**]*) -- Select the method for
              geometry optimizations.

            * **TimeStep** (*float** | **FloatKey*) -- The time step
              used in dynamics-based optimizers like FIRE. It
              influences the integration of motion.

            * **CG** (*AMS._PESExploration._Optimizer._CG*) --
              Settings for the Conjugate Gradient (CG) optimizer.

            * **LBFGS** (*AMS._PESExploration._Optimizer._LBFGS*) --
              Settings for the Limited-memory Broyden-Fletcher-
              Goldfarb-Shanno (LBFGS) optimizer.

            * **QM** (*AMS._PESExploration._Optimizer._QM*) --
              Settings for the Quick-Min (QM) optimizer.

            * **SD** (*AMS._PESExploration._Optimizer._SD*) --
              Settings for the Steepest Descent (SD) optimizer.

         class _CG

            Settings for the Conjugate Gradient (CG) optimizer.

            Variables:
               * **KnockOutMaxMove** (*BoolType** | **BoolKey*) -- If
                 true, the MaxMove constraint is ignored, potentially
                 allowing for larger steps.

               * **LineConverged** (*float** | **FloatKey*) -- The
                 convergence criterion for the line search portion of
                 the CG algorithm.

               * **LineSearch** (*BoolType** | **BoolKey*) -- If true,
                 performs a line search to find the optimal step size
                 along the conjugate direction.

               * **LineSearchMaxIter** (*int** | **IntKey*) -- The
                 maximum number of iterations allowed for the line
                 search.

               * **MaxIterBeforeReset** (*int** | **IntKey*) -- The
                 number of iterations after which the conjugate
                 gradient direction is reset to the steepest descent
                 direction. A value of 0 means it resets based on the
                 number of degrees of freedom.

               * **NoOvershooting** (*BoolType** | **BoolKey*) -- If
                 true, prevents the optimizer from overshooting the
                 minimum along the search direction.

         class _LBFGS

            Settings for the Limited-memory Broyden-Fletcher-Goldfarb-
            Shanno (LBFGS) optimizer.

            Variables:
               * **AngleReset** (*BoolType** | **BoolKey*) -- If true,
                 the LBFGS history is reset if the angle between
                 consecutive gradients is too large, indicating a
                 change in the potential energy surface curvature.

               * **AutoScale** (*BoolType** | **BoolKey*) -- If true,
                 automatically scales the step size based on previous
                 iterations.

               * **DistanceReset** (*BoolType** | **BoolKey*) -- If
                 true, the LBFGS history is reset if the step size
                 becomes excessively large.

               * **InverseCurvature** (*float** | **FloatKey*) -- An
                 initial guess for the inverse curvature (diagonal
                 elements of the inverse Hessian).

               * **Memory** (*int** | **IntKey*) -- The number of
                 previous steps (gradients and positions) to store for
                 approximating the inverse Hessian matrix.

         class _QM

            Settings for the Quick-Min (QM) optimizer.

            Variables:
               **SteepestDecent** (*BoolType** | **BoolKey*) -- If
               true, forces the optimizer to only take steepest
               descent steps, ignoring velocity information.

         class _SD

            Settings for the Steepest Descent (SD) optimizer.

            Variables:
               * **Alpha** (*float** | **FloatKey*) -- The scaling
                 factor for the step size in the direction of the
                 negative gradient.

               * **TwoPoint** (*BoolType** | **BoolKey*) -- If true,
                 uses information from two points to estimate a better
                 step size.

      class _Parallel

         Options for double parallelization, which allows to split the
         available processor cores into groups working through all the
         available tasks in parallel, resulting in a better parallel
         performance. The keys in this block determine how to split
         the available processor cores into groups working in
         parallel.

         Variables:
            * **nCoresPerGroup** (*int** | **IntKey*) -- Number of
              cores in each working group.

            * **nGroups** (*int** | **IntKey*) -- Total number of
              processor groups. This is the number of tasks that will
              be executed in parallel.

            * **nNodesPerGroup** (*int** | **IntKey*) -- Number of
              nodes in each group. This option should only be used on
              homogeneous compute clusters, where all used compute
              nodes have the same number of processor cores.

      class _ParallelReplica

         Settings for the Parallel Replica Dynamics method.

         Variables:
            * **DephaseLoopMax** (*int** | **IntKey*) -- The maximum
              number of times the dephasing procedure will be
              attempted.

            * **DephaseLoopStop** (*BoolType** | **BoolKey*) -- If
              true, the dephasing loop will stop early if a transition
              is detected during dephasing.

            * **DephaseTime** (*float** | **FloatKey*) -- The duration
              of the dephasing period, during which replicas evolve
              independently to lose correlation.

            * **PostTransitionTime** (*float** | **FloatKey*) -- The
              amount of time (in fs) the simulation continues to run
              after a transition is detected, to ensure the new state
              is stable.

            * **RefineTransition** (*BoolType** | **BoolKey*) -- If
              true, after a transition is detected, a saddle search is
              performed to precisely locate the transition state.

            * **StateCheckInterval** (*float** | **FloatKey*) -- The
              time interval (in fs) at which each replica is checked
              to see if a transition has occurred.

            * **StateSaveInterval** (*float** | **FloatKey*) -- The
              time interval (in fs) at which the state of the replicas
              is saved. A negative value disables this.

            * **StopAfterTransition** (*BoolType** | **BoolKey*) -- If
              true, the simulation will terminate after the first
              reactive event is successfully identified.

      class _Prefactor

         Settings for calculating reaction rate pre-exponential
         factors.

         Variables:
            **Rate** (*Literal**[**"HTST"**, **"QQHTST"**,
            **"None"**]*) -- Calculates reaction rate pre-exponential
            factors via: HTST (Harmonic Transition State Theory),
            QQHTST (quasi-quantum HTST), or None (disable
            calculation).

      class _ProcessSearch

         Input options specific to the process search procedure.

         Variables:
            * **MinimizationOffset** (*float** | **FloatKey*) -- After
              a saddle is found, images are placed on either side of
              the saddle along the mode and minimized to ensure that
              the saddle is connected to the original minimum and to
              locate the product state. MinimizationOffset is the
              distance those images are displaced from the saddle.

            * **MinimizeFirst** (*BoolType** | **BoolKey*) -- If true,
              every time a process search is run by a client the
              reactant will be minimized first before doing any saddle
              searches.

      class _SaddleSearch

         Configuration for the Saddle Search procedure (used in
         SaddleSearch and ProcessSearch Jobs).

         Variables:
            * **ConvergedForce** (*float** | **FloatKey*) --
              Convergence threshold for nuclear gradients. Note:
              Special value of -1.0 means using the same convergence
              criterion as the PES explorer's geometry optimizer.

            * **DisplaceAllAtoms** (*BoolType** | **BoolKey*) -- If
              true, the initial displacement is applied to all atoms
              in the system, rather than just those within a radius of
              a chosen epicenter.

            * **DisplaceAllListed** (*BoolType** | **BoolKey*) -- If
              true, all atoms specified in DisplaceListedAtoms or
              DisplaceListedTypes are displaced simultaneously.

            * **DisplaceAlongNoisyNormalModes** (*BoolType** |
              **BoolKey*) -- If true, atoms are displaced following
              the normal modes.

            * **DisplaceAlongNormalModesActiveModes** (*str** |
              **StringKey*) -- Sets the active modes to be used when
              the option [SaddleSearch%DisplaceAlongNormalModesWeight]
              is enabled. e.g. 1,2,3,5. By default, all normal modes
              are considered active.

            * **DisplaceAlongNormalModesWeight** (*float** |
              **FloatKey*) -- The probability of generating a
              displacement resulting in a random linear combination of
              the normal modes specified in
              [SaddleSearch%DisplaceAlongNormalModesActiveModes]. This
              parameter is a numeric value that should fall within the
              interval [0.0, 1.0].

            * **DisplaceAtomsInRegion** (*str** | **StringKey*) -- A
              string corresponding to the name of a region. When
              performing the initial random displacement, only
              displace atoms in the specified region.

            * **DisplaceAtomsInRegionWeight** (*float** | **FloatKey*)
              -- The probability of generating a displacement
              involving only atoms from the region specified in
              [SaddleSearch%DisplaceAtomsInRegion]. This parameter is
              a numeric value that should fall within the interval
              [0.0, 1.0].

            * **DisplaceLeastCoordinatedWeight** (*float** |
              **FloatKey*) -- Relative probability to displace with an
              epicenter that has a coordination number equal to the
              least-coordinated atom in the configuration.

            * **DisplaceListedAtomWeight** (*float** | **FloatKey*) --
              Relative probability to displace with an epicenter
              listed in displace_atomlist.

            * **DisplaceListedAtoms** (*str** | **StringKey*) -- Sets
              the active atoms to be used when the option
              [SaddleSearch%DisplaceAlongNormalModesWeight] is
              enabled. e.g. 1,2,3,5. By default, all normal modes are
              considered active.

            * **DisplaceListedTypeWeight** (*float** | **FloatKey*) --
              Relative probability to displace with an epicenter
              listed in displace_typelist.

            * **DisplaceListedTypes** (*str** | **StringKey*) -- A
              list of atom types (e.g., 'H O') to be considered as
              epicenters for displacement. Used with
              DisplaceListedTypeWeight.

            * **DisplaceMagnitude** (*float** | **FloatKey*) -- The
              standard deviation of the Gaussian displacement in each
              degree of freedom for the selected atoms.

            * **DisplaceMaxCoordination** (*int** | **IntKey*) -- The
              maximum coordination number for an atom to be eligible
              as an epicenter for an under-coordinated displacement.

            * **DisplaceMinNorm** (*float** | **FloatKey*) -- The
              minimum required norm (magnitude) of the initial
              displacement vector. If a randomly generated
              displacement is smaller than this, it is rescaled.

            * **DisplaceNotFCCHCPWeight** (*float** | **FloatKey*) --
              Relative probability to displace with an epicenter that
              is not FCC or HCP coordinated.

            * **DisplaceNotTCPBCCWeight** (*float** | **FloatKey*) --
              Relative probability to select an epicenter atom that
              does not have a Tetrahedrally Close-Packed (TCP) or
              Body-Centered Cubic (BCC) coordination environment.

            * **DisplaceNotTCPWeight** (*float** | **FloatKey*) --
              Relative probability to select an epicenter atom that
              does not have a Tetrahedrally Close-Packed (TCP)
              coordination environment.

            * **DisplaceRadius** (*float** | **FloatKey*) -- Atoms
              within this distance of the epicenter will be displaced.

            * **DisplaceRandomWeight** (*float** | **FloatKey*) --
              Relative probability to displace with a random
              epicenter.

            * **DisplaceUnderCoordinatedWeight** (*float** |
              **FloatKey*) -- Relative probability to displace with an
              epicenter with a coordination equal to or less than
              displace_max_coordination.

            * **DisplaceWaterWeight** (*float** | **FloatKey*) --
              Relative probability to select an oxygen atom from a
              water molecule as the epicenter for displacement.

            * **MaxEnergy** (*float** | **FloatKey*) -- The energy
              (relative to the starting point of the saddle search) at
              which a saddle search explorer considers the search bad
              and terminates it.

            * **MaxIterations** (*int** | **IntKey*) -- Maximum number
              of iterations for each saddle search run.

            * **Method** (*Literal**[**"min_mode"**, **"dynamics"**,
              **"basin_hopping"**, **"bgsd"**]*) -- Which saddle
              search method to use.

            * **MinEnergyBarrier** (*float** | **FloatKey*) -- Minimum
              energy barrier to accept a new transition state.

            * **MinModeMethod** (*Literal**[**"dimer"**,
              **"lanczos"**]*) -- The minimum-mode following method to
              use.

            * **RandomMode** (*BoolType** | **BoolKey*) -- If true,
              the initial displacement is a completely random vector.
              If false, it's based on other criteria.

            * **RelaxFromSaddlePoint** (*BoolType** | **BoolKey*) --
              Relaxes the saddle point geometries following the
              imaginary mode to get both reactants and products.

            * **RemoveRotation** (*BoolType** | **BoolKey*) -- If
              true, removes the rotational component from the initial
              displacement vector to prevent rigid body rotations.

            * **ZeroModeAbortCurvature** (*float** | **FloatKey*) --
              The threshold in the frequency below which the minimum
              mode is considered zero. The calculation is aborted if
              the negative mode becomes zero.

      class _StatesAlignment

         Configures details of how the energy landscape configurations
         are aligned respect to the main chemical system [System].

         Variables:
            * **DistanceDifference** (*float** | **FloatKey*) -- If
              the distance between two mapped atoms is larger than
              this threshold, the configuration is considered not
              aligned. If not specified, its value will set equal to
              [PESExploration%StructureComparison%DistanceDifference]

            * **ReferenceRegion** (*str** | **StringKey*) -- Defines
              the region that is considered as the reference for
              alignments. Atoms outside this region are ignored in the
              alignments.

            * **RemoveUnaligned** (*BoolType** | **BoolKey*) -- If
              enabled, states that cannot be aligned with the
              reference structure according to the specified criteria
              will be removed from the energy landscape.

      class _StructureComparison

         Settings for structure comparison.

         Variables:
            * **CheckRotation** (*BoolType** | **BoolKey*) -- Rotates
              the system optimally before comparing structures. The
              default is to do this only for molecular systems when
              there are no fixed atom constraints.

            * **CheckSymmetry** (*BoolType** | **BoolKey*) --
              Considers that two systems are equal if they are
              equivalent by symmetry.

            * **CovalentScale** (*float** | **FloatKey*) -- Scale
              factor for the covalent distances used in the
              neighboring detection. Only used if
              [StructureComparison%UseCovalent] is enabled. This is an
              experimental feature!

            * **DistanceDifference** (*float** | **FloatKey*) -- If
              the distance between two mapped atoms is larger than
              this threshold, the two configurations are considered
              different structures.

            * **EnergyDifference** (*float** | **FloatKey*) -- If the
              energy difference between two configurations is below
              this threshold, we perform a geometric check to confirm
              they are distinct structures.

            * **IndistinguishableAtoms** (*BoolType** | **BoolKey*) --
              If yes, the order of the atoms does not affect the
              structural comparison. Atoms of the same element are
              then indistinguishable.

            * **NeighborCutoff** (*float** | **FloatKey*) -- Defines
              the maximum distance at which atoms are considered
              neighbors. The default value is calculated as the mode
              of all interatomic distances within the main system,
              with a minimum effective value of 3.3 Å. This parameter
              is only active when [StructureComparison%CheckSymmetry]
              is false or [StructureComparison%UseCovalent] is false.

            * **RemoveTranslation** (*BoolType** | **BoolKey*) --
              Translates the system optimally before comparing
              structures. The default is to do this only when there
              are no fixed atom constraints.

            * **UseCovalent** (*BoolType** | **BoolKey*) -- Atoms are
              considered neighbors if the distance between them is
              lower than [StructureComparison%CovalentScale] times the
              covalent distance calculated following M. O'Keeffe and
              N.E. Brese, J. Am. Chem.Soc. 113 (1991) 3226. This
              option disables [StructureComparison%NeighborCutoff].
              This is an experimental feature!

   class _PESPointCharacter

      Options for the characterization of PES points.

      Variables:
         * **Displacement** (*float** | **FloatKey*) -- Controls the
           size of the displacements used for numerical
           differentiation: The displaced geometries are calculated by
           taking the original coordinates and adding the mass-
           weighted mode times the reduced mass of the mode times the
           value of this keyword.

         * **NegativeEigenvalueTolerance** (*float** | **FloatKey*) --
           The threshold in Hessian eigenvalue below which a mode is
           considered imaginary, i.e. indicating a transition state.
           This is a small negative number, as very small negative
           eigenvalues may be due to numerical noise on an essentially
           flat PES and do not indicate true transition states.

         * **NegativeFrequenciesTolerance** (*float** | **FloatKey*)
           -- The threshold in frequencies below which a mode is
           considered imaginary, i.e. indicating a transition state.
           Deprecated. Use NegativeEigenvalueTolerance instead.

         * **NumberOfModes** (*int** | **IntKey*) -- The number of
           (lowest) eigenvalues that should be checked.

         * **Tolerance** (*float** | **FloatKey*) -- Convergence
           tolerance for residual in iterative Davidson
           diagonalization.

   class _PESScan

      Configures the details of the potential energy surface scanning
      task.

      Variables:
         * **CalcPropertiesAtPESPoints** (*BoolType** | **BoolKey*) --
           Whether to perform an additional calculation with
           properties on all the sampled points of the PES. If this
           option is enabled AMS will produce a separate engine output
           file for every sampled PES point.

         * **FillUnconvergedGaps** (*BoolType** | **BoolKey*) -- After
           the initial pass over the PES, restart the unconverged
           points from converged neighboring points. This has no
           effect if the "Optimize" key is set to "False".

         * **Optimize** (*BoolType** | **BoolKey*) -- Whether to
           optimize the geometry at each point along the scan,
           relaxing all degrees of freedom except those being scanned
           or explicitly constrained.

         * **ScanCoordinate** (*AMS._PESScan._ScanCoordinate*) --
           Specifies a coordinate along which the potential energy
           surface is scanned. If this block contains multiple
           entries, these coordinates will be varied and scanned
           together as if they were one. Note that there can be only
           one ScanCoordinate containing a lattice scan in any PES
           scan job.

      class _ScanCoordinate

         Specifies a coordinate along which the potential energy
         surface is scanned. If this block contains multiple entries,
         these coordinates will be varied and scanned together as if
         they were one. Note that there can be only one ScanCoordinate
         containing a lattice scan in any PES scan job.

         Variables:
            * **Angle** (*str** | **StringKey*) -- Scan the angle
              between three atoms. Three atom indices followed by two
              real numbers delimiting the transit range in degrees.

            * **CellVolumeRange** (*Iterable**[**float**] **|
              **FloatListKey*) -- Two numbers for the initial and
              final cell volume. The cell is scaled isotropically
              between these values. Can not be used together with any
              other coordinate within the same ScanCoordinate block.

            * **CellVolumeScalingRange** (*Iterable**[**float**] **|
              **FloatListKey*) -- Two scaling factors for the initial
              and final cell volume. A value of '0.9 1.1' would result
              in an isotropic scaling between 90% and 110% of the cell
              volume of the input system. Can not be used together
              with any other coordinate within the same ScanCoordinate
              block.

            * **Coordinate** (*str** | **StringKey*) -- Scan a
              particular coordinate of an atom. Atom index followed by
              (x|y|z) followed by two real numbers delimiting the
              transit range.

            * **DifDist** (*str** | **StringKey*) -- Scan the
              difference distance between two pairs of atoms,
              R(12)-R(34). Four atom indices followed by two real
              numbers delimiting the transit range in Angstrom.

            * **Dihedral** (*str** | **StringKey*) -- Scan the
              dihedral angle between four atoms. Four atom indices
              followed by two real numbers delimiting the transit
              angle in degrees.

            * **Distance** (*str** | **StringKey*) -- Scan the
              distance between two atoms. Two atom indices followed by
              two real numbers delimiting the transit distance in
              Angstrom.

            * **FromStrainVoigt** (*Iterable**[**float**] **|
              **FloatListKey*) -- The elements of the initial lattice
              strain in Voigt notation. One should specify 6 numbers
              for 3D periodic system (order: xx,yy,zz,yz,xz,xy), 3
              numbers for 2D periodic systems (order: xx,yy,xy) or 1
              number for 1D periodic systems. Has to be used in
              combination with the ToStrainVoigt keyword and no other
              coordinate within the same ScanCoordinate block.

            * **LatticeARange** (*Iterable**[**float**] **|
              **FloatListKey*) -- Scans the length of the first
              lattice vector. Can be combined with the LatticeBRange
              and LatticeCRange keywords, but no other coordinates
              within the same ScanCoordinate.

            * **LatticeBRange** (*Iterable**[**float**] **|
              **FloatListKey*) -- Scans the length of the second
              lattice vector. Can be combined with the LatticeARange
              and LatticeCRange keyword, but no other coordinates
              within the same ScanCoordinate..

            * **LatticeCRange** (*Iterable**[**float**] **|
              **FloatListKey*) -- Scans the length of the third
              lattice vector. Can be combined with the LatticeARange
              and LatticeBRange keyword, but no other coordinates
              within the same ScanCoordinate..

            * **SumDist** (*str** | **StringKey*) -- Scan the sum of
              distances between two pairs of atoms, R(12)+R(34). Four
              atom indices followed by two real numbers delimiting the
              transit range in Angstrom.

            * **ToStrainVoigt** (*Iterable**[**float**] **|
              **FloatListKey*) -- The elements of the final lattice
              strain in Voigt notation. One should specify 6 numbers
              for 3D periodic system (order: xx,yy,zz,yz,xz,xy), 3
              numbers for 2D periodic systems (order: xx,yy,xy) or 1
              number for 1D periodic systems.

            * **nPoints** (*int** | **IntKey*) -- The number of points
              along the scanned coordinate. Must be greater or equal
              2.

            * **FromLattice** (*str** | **Sequence**[**str**] **|
              **FreeBlock*) -- Up to three lattice vectors to start
              the scan at. Has to be used in combination with the
              ToLattice keyword and no other coordinate within the
              same ScanCoordinate block. Unit can be specified in the
              header. Default unit is Angstrom.

            * **ToLattice** (*str** | **Sequence**[**str**] **|
              **FreeBlock*) -- Up to three lattice vectors to end the
              scan at. Unit can be specified in the header. Default
              unit is Angstrom.

         class _FromLattice

            Up to three lattice vectors to start the scan at. Has to
            be used in combination with the ToLattice keyword and no
            other coordinate within the same ScanCoordinate block.
            Unit can be specified in the header. Default unit is
            Angstrom.

         class _ToLattice

            Up to three lattice vectors to end the scan at. Unit can
            be specified in the header. Default unit is Angstrom.

   class _Phonons

      Configures the phonons calculation.

      Variables:
         * **BandStructure** (*BoolType** | **BoolKey*) -- Calculates
           and saves the phonon band structure for visualization.
           Further configuration options for analytical calculations
           may be available in the engine-specific settings
           ("Phonons%BandStructure").

         * **DOS** (*BoolType** | **BoolKey*) -- Calculates and saves
           the phonon density of states (DOS) for visualization.
           Further configuration options for analytical calculations
           may be available in the engine-specific settings
           ("Phonons%DOS").

         * **Method** (*Literal**[**"Auto"**, **"Analytical"**,
           **"Numerical"**]*) -- Determines how phonons are
           calculated. "Auto" selects the analytical method if
           supported by the engine, otherwise it defaults to numerical
           calculation. Configure numerical parameters in the
           "NumericalPhonons" section. Engine-specific options for
           analytical phonon calculations may be available in
           "Engine%Phonons".

   class _Print

      This block controls the printing of additional information to
      stdout.

      Variables:
         **Timers** (*Literal**[**"None"**, **"Normal"**,
         **"Detail"**, **"TooMuchDetail"**]*) -- Printing timing
         details to see how much time is spend in which part of the
         code.

   class _Properties

      Configures which AMS level properties to calculate for
      SinglePoint calculations or other important geometries (e.g. at
      the end of an optimization).

      Variables:
         * **BondOrders** (*BoolType** | **BoolKey*) --

           Requests the engine to calculate bond orders.

           For MM engines these might just be the defined bond orders
           that go into the force-field, while for QM engines, this
           might trigger a bond order analysis based on the electronic
           structure. For engines that do not have a bond order
           analysis method, a bond guessing algorithm will be used.
           See also the input options in the BondOrders block.

         * **Charges** (*BoolType** | **BoolKey*) -- Requests the
           engine to calculate the atomic charges.

         * **DipoleGradients** (*BoolType** | **BoolKey*) -- Requests
           the engine to calculate the nuclear gradients of the
           electric dipole moment of the molecule. This can only be
           requested for non-periodic systems.

         * **DipoleMoment** (*BoolType** | **BoolKey*) -- Requests the
           engine to calculate the electric dipole moment of the
           molecule. This can only be requested for non-periodic
           systems.

         * **ElasticTensor** (*BoolType** | **BoolKey*) -- Calculate
           the elastic tensor.

         * **GSES** (*BoolType** | **BoolKey*) -- Requests the engine
           to calculate the gradients of ground to excited state
           properties.

         * **Gradients** (*BoolType** | **BoolKey*) -- Calculate the
           nuclear gradients.

         * **Hessian** (*BoolType** | **BoolKey*) -- Whether or not to
           calculate the Hessian.

         * **Molecules** (*BoolType** | **BoolKey*) -- Requests an
           analysis of the molecular components of a system, based on
           the bond orders calculated by the engine.

         * **NormalModes** (*BoolType** | **BoolKey*) -- Calculate the
           frequencies and normal modes of vibration, as well as the
           corresponding IR intensities, if the engine supports these
           calculations natively or can calculate dipole moments.

         * **OrbitalsInfo** (*BoolType** | **BoolKey*) -- Basic
           molecular orbitals information: orbital energies,
           occupations, HOMO, LUMO and HOMO-LUMO gap.

         * **Other** (*BoolType** | **BoolKey*) -- Other (engine
           specific) properties. Details are configured in the engine
           block.

         * **PESPointCharacter** (*BoolType** | **BoolKey*) --
           Determine whether the sampled PES point is a minimum or
           saddle point. Note that for large systems this does not
           entail the calculation of the full Hessian and can
           therefore be used to quickly confirm the success of a
           geometry optimization or transition state search.

         * **Phonons** (*BoolType** | **BoolKey*) -- Calculate the
           phonons (for periodic systems).

         * **Polarizability** (*BoolType** | **BoolKey*) -- Requests
           the engine to calculate the polarizability tensor of the
           system.

         * **Raman** (*BoolType** | **BoolKey*) -- Requests
           calculation of Raman intensities for vibrational normal
           modes.

         * **SelectedRegionForHessian** (*str** | **StringKey*) --
           Compute the Hessian matrix elements only for the atoms in a
           particular region. If not specified, the Hessian will be
           computed for all atoms.

         * **StressTensor** (*BoolType** | **BoolKey*) -- Calculate
           the stress tensor.

         * **UncertaintyScore** (*BoolType** | **BoolKey*) -- Request
           the engine to state how (un)certain it is about its
           results. Higher number means less certain but specific
           implementation depends on engine.

         * **VCD** (*BoolType** | **BoolKey*) -- Requests calculation
           of VCD for vibrational normal modes.

         * **VROA** (*BoolType** | **BoolKey*) -- Requests calculation
           of VROA for vibrational normal modes.

   class _Raman

      Configures details of the Raman or VROA calculation.

      Variables:
         * **FreqRange** (*Iterable**[**float**] **| **FloatListKey*)
           -- Specifies a frequency range within which all modes will
           be scanned. 2 numbers: an upper and a lower bound.

         * **IncidentFrequency** (*float** | **FloatKey*) -- Frequency
           of incident light.

         * **LifeTime** (*float** | **FloatKey*) -- 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 typical
           value is 0.004 Hartree.

   class _Replay

      Configures the details of the Replay task.

      Variables:
         * **Atoms** (*Iterable**[**int**] **| **IntListKey*) -- List
           of atom indices to include in the replay. All other atoms
           will be removed before the calculation of energy (and
           possible other properties). If this keyword is not
           specified, all atoms will be used for the replay. This
           keyword can currently not be used for trajectory with a
           changing number of atoms between frames, e.g. MD
           trajectories with molecule guns and sinks.

         * **File** (*str** | **Path** | **StringKey*) -- Provide an
           ams.rkf file (or a .results folder) from a previously run
           job to replay. The file needs to contain a History section.

         * **Frames** (*Iterable**[**int**] **| **IntListKey*) --

           List of frames from the History section to recompute.

           If you use AMSmovie, you can use it to find the frame
           number, but add one since frame numbers in AMSmovie start
           at 0.

           If not specified the recomputed frames are determined
           automatically based on the task of the job that is being
           replayed: PES scans and NEB calculations will only have the
           converged points replayed, while all other tasks will have
           all frames recomputed.

           Specifying the frames to recompute in the input is probably
           only useful when replaying trajectories from
           MolecularDynamics calculations.

         * **StoreAllResultFiles** (*BoolType** | **BoolKey*) --

           If this option is enabled AMS will produce a separate
           engine output file for every replayed frame.

           While basic properties like energy, gradients, stress
           tensor, etc. are stored anyway on the History section in
           the AMS driver output file (if they were requested in the
           Properties block), engine specific properties (e.g.
           excitations energies from ADF) will only be available if
           the full result files are stored.

   class _Restraints

      The Restraints block allows to add soft constraints to the
      system. A restraint is a potential energy function (a spring)
      attached to a certain coordinate, for example, an interatomic
      distance, with its minimum at the specified optimal value. A
      restraint is defined using one or two parameters: the
      ForceConstant and, for some types, the F(Inf) value. The
      ForceConstant parameter corresponds to second derivative of the
      restraint potential energy d2V(x)/dx^2 for any x (harmonic
      restraints) or only at at x=0 (other restraints). Here, x is a
      deviation from the restraint's optimal value.

      Variables:
         * **Angle** (*str** | **StringKey*) -- Specify three atom
           indices i j k followed by an angle in degrees and,
           optionally, by the ForceConstant (default is 0.3 in a.u.),
           profile type and F(Inf) (in a.u.). This restraint will try
           to keep the i-j-k angle at the given value. For periodic
           systems this restraint follows the minimum image
           convention.

         * **DifDist** (*str** | **StringKey*) -- Specify four atom
           indices i j k l followed by the distance in Angstrom and,
           optionally, by the ForceConstant (default is 1.0 in a.u.),
           profile type and F(Inf) (in a.u.). This restraint will try
           to keep the difference R(ij)-R(kl) at the given value. For
           periodic systems this restraint follows the minimum image
           convention.

         * **Dihedral** (*str** | **StringKey*) -- Specify four atom
           indices i j k l followed by an angle in degrees and,
           optionally, by the ForceConstant (default is 0.1 in a.u.),
           profile type and F(Inf) (in a.u.). This restraint will try
           to keep the i-j-k-l dihedral angle at the given value. For
           periodic systems this restraint follows the minimum image
           convention.

         * **Distance** (*str** | **StringKey*) -- Specify two atom
           indices followed by the distance in Angstrom and,
           optionally, by the ForceConstant (default is 1.0 in a.u.),
           profile type and F(Inf) (in a.u.). This restraint will try
           to keep the distance between the two specified atoms at the
           given value. For periodic systems this restraint follows
           the minimum image convention.

         * **FInfinity** (*float** | **FloatKey*) --

           Specify the default asymptotic value for the restraint
           force for the Hyperbolic and Erf profiles, in Hartree/Bohr
           or Hartree/radian.

           A per-restraint value can be specified after the profile
           type on the corresponding restraint line.

         * **Profile** (*Literal**[**"Harmonic"**, **"Hyperbolic"**,
           **"Erf"**, **"GaussianWell"**]*) --

           Select the default type of restraint profile.

           The harmonic profile is most suitable for geometry
           optimizations but may result is very large forces that can
           be problematic in molecular dynamic.

           For MD simulations the Hyperbolic or Erf may be more
           suitable because the restraint force is bounded by a user-
           defined value.

           A per-restraint profile type can be specified after the
           ForceConstant value on the corresponding restraint line.

         * **SumDist** (*str** | **StringKey*) -- Specify four atom
           indices i j k l followed by the distance in Angstrom and,
           optionally, by the ForceConstant (default is 1.0 in a.u.),
           profile type and F(Inf) (in a.u.). This restraint will try
           to keep the sum R(ij)+R(kl) at the given value. For
           periodic systems this restraint follows the minimum image
           convention.

         * **Units** (*Literal**[**"Default"**, **"MD"**]*) -- Change
           units for energy, force and force constant values from the
           default (atomic units) to those often used in the MD
           community (based on kcal/mol and Angstrom). Units for the
           optimal distances are not affected and are always Angstrom.

   class _RigidMotions

      Specify which rigid motions of the total system are allowed. An
      external field is not considered part of the system. Normally
      the automatic option is doing what you want. However this
      feature can be used as a means of geometry constraint.

      Variables:
         * **AllowRotations** (*Literal**[**"Auto"**, **"None"**,
           **"All"**, **"X"**, **"Y"**, **"Z"**, **"XY"**, **"XZ"**,
           **"YZ"**]*) -- Which overall rotations of the system are
           allowed

         * **AllowTranslations** (*Literal**[**"Auto"**, **"None"**,
           **"All"**, **"X"**, **"Y"**, **"Z"**, **"XY"**, **"XZ"**,
           **"YZ"**]*) -- Which overall transitions of the system are
           allowed

         * **Tolerance** (*float** | **FloatKey*) -- Tolerance for
           detecting linear molecules. A large value means larger
           deviation from linearity is permitted.

   class _SCMLibrary

      Technical settings affecting src/lib

      Variables:
         **ShellBasedNAFS** (*BoolType** | **BoolKey*) -- Assume that
         the NAFS are ordered by shell, this allows for a faster
         evaluation.

   class _SCMMatrix

      Technical settings for programs using the AMT matrix system.
      Currently this is only used by DFTB

      Variables:
         * **Type** (*Literal**[**"Auto"**, **"Reference"**,
           **"ScaLapack"**, **"Elpa"**]*) -- Determines which
           implementation is used to support the AbstractMatrixType.

         * **DistributedMatrix** (*AMS._SCMMatrix._DistributedMatrix*)
           -- Technical settings for Distributed matrices

      class _DistributedMatrix

         Technical settings for Distributed matrices

         Variables:
            * **ColBlockSize** (*int** | **IntKey*) -- See comment of
              RowBlockSize.

            * **RowBlockSize** (*int** | **IntKey*) -- The matrix is
              divided into blocks of size RowBlockSize x ColBlockSize.
              The smaller the blocks the better the distribution, but
              at the expense of increased communication overhead

   class _SerializedTensors

      Technical settings affecting the SerializedTensors module,
      currently only used for HartreeFock

      Variables:
         * **AllowZeroSize** (*BoolType** | **BoolKey*) -- When the
           data is blocked, can the size be zero?

         * **IntegerDataBlockSize** (*int** | **IntKey*) -- Integer
           (meta) data per tensor may be aligned by using a blockSize,
           only relevant when sparseness is used.

         * **RealDataBlockSize** (*int** | **IntKey*) -- Real data per
           tensor may be aligned by using a blockSize

         * **SparseDataImplementation** (*int** | **IntKey*) --

           1. use three ftlDynArrays per tensor. 2) use one big shared
              array.

   class _SteepestDescent

      Configures details of the steepest descent task.

      Variables:
         * **GradientConvergence** (*float** | **FloatKey*) --

         * **StepSize** (*float** | **FloatKey*) -- Controls the size
           of the step to take. This number is multiplied with the
           force and added to the gradient.

   class _Symmetry

      Specifying details about the details of symmetry detection and
      usage.

      Variables:
         * **SymmetrizeTolerance** (*float** | **FloatKey*) --
           Tolerance used to detect symmetry in case symmetrize is
           requested.

         * **Tolerance** (*float** | **FloatKey*) -- Tolerance used to
           detect symmetry in the system.

   class _System

      Specification of the chemical system. For some applications more
      than one system may be present in the input. In this case, all
      systems except one must have a non-empty string ID specified
      after the System keyword. The system without an ID is considered
      the main one.

      Variables:
         * **AllowCloseAtoms** (*BoolType** | **BoolKey*) -- No longer
           functional. Just here for backwards compatibility.

         * **Charge** (*float** | **FloatKey*) -- The system's total
           charge in atomic units.

         * **FractionalCoords** (*BoolType** | **BoolKey*) -- Whether
           the atomic coordinates in the Atoms block are given in
           fractional coordinates of the lattice vectors. Requires the
           presence of the Lattice block.

         * **GeometryFile** (*str** | **Path** | **StringKey*) -- Read
           the geometry from a file (instead of from Atoms and Lattice
           blocks). Supported formats: .xyz

         * **GuessBonds** (*BoolType** | **BoolKey*) -- Equivalent to
           'Modify%GuessBonds'. Please update input file to use
           'Modify' block instead.

         * **LatticeStrain** (*Iterable**[**float**] **|
           **FloatListKey*) -- Equivalent to 'Modify%LatticeStrain'.
           Please update input file to use 'Modify' block instead.

         * **MapAtomsToUnitCell** (*BoolType** | **BoolKey*) --
           Equivalent to 'Modify%MapAtomsToUnitCell'. Please update
           input file to use 'Modify' block instead.

         * **PerturbCoordinates** (*float** | **FloatKey*) --
           Equivalent to 'Modify%PerturbCoordinates'. Please update
           input file to use 'Modify' block instead.

         * **PerturbLattice** (*float** | **FloatKey*) -- Equivalent
           to 'Modify%PerturbLattice'. Please update input file to use
           'Modify' block instead.

         * **ShiftCoordinates** (*Iterable**[**float**] **|
           **FloatListKey*) -- Equivalent to 'Modify%Translate', but
           in the unit of bohr by default. Please update input file to
           use 'Modify' block instead.

         * **SuperCell** (*Iterable**[**int**] **| **IntListKey*) --
           Equivalent to 'Modify%SuperCell'. Please update input file
           to use 'Modify' block instead.

         * **SuperCellTrafo** (*Iterable**[**int**] **| **IntListKey*)
           -- Equivalent to 'Modify%SuperCellTrafo'. Please update
           input file to use 'Modify' block instead.

         * **Symmetrize** (*BoolType** | **BoolKey*) -- Equivalent to
           'Modify%Symmetrize'. Please update input file to use
           'Modify' block instead.

         * **Atoms** (*str** | **Sequence**[**str**] **| **FreeBlock*)
           -- The atom types and coordinates. Unit can be specified in
           the header. Default unit is Angstrom.

         * **BondOrders** (*str** | **Sequence**[**str**] **|
           **FreeBlock*) -- Defined bond orders. Each line should
           contain two atom indices, followed by the bond order (1,
           1.5, 2, 3 for single, aromatic, double and triple bonds)
           and (optionally) the cell shifts for periodic systems. May
           be used by MM engines and for defining constraints. If the
           system is periodic and none of the bonds have the cell
           shift defined then AMS will attempt to determine them
           following the minimum image convention.

         * **ElectrostaticEmbedding**
           (*AMS._System._ElectrostaticEmbedding*) -- Container for
           electrostatic embedding options, which can be combined.

         * **Lattice** (*str** | **Sequence**[**str**] **|
           **FreeBlock*) -- Up to three lattice vectors. Unit can be
           specified in the header. Default unit is Angstrom.

         * **Modify** (*AMS._System._Modify*) -- Modifications to make
           to the chemical system after construction. This block is
           read like a script and the modifications applied top to
           bottom.

      class _Atoms

         The atom types and coordinates. Unit can be specified in the
         header. Default unit is Angstrom.

      class _BondOrders

         Defined bond orders. Each line should contain two atom
         indices, followed by the bond order (1, 1.5, 2, 3 for single,
         aromatic, double and triple bonds) and (optionally) the cell
         shifts for periodic systems. May be used by MM engines and
         for defining constraints. If the system is periodic and none
         of the bonds have the cell shift defined then AMS will
         attempt to determine them following the minimum image
         convention.

      class _ElectrostaticEmbedding

         Container for electrostatic embedding options, which can be
         combined.

         Variables:
            * **ElectricField** (*Iterable**[**float**] **|
              **FloatListKey*) --

              External homogeneous electric field with three Cartesian
              components: ex, ey, ez, the default unit being V/Å.

              In atomic units: Hartree/(e bohr) = 51.422 V/Angstrom;
              the relation to SI units is: 1 Hartree/(e bohr) = 5.14
              ... e11 V/m.

              Supported by the engines adf, band, dftb and mopac.

              For periodic systems the field may only have nonzero
              components orthogonal to the direction(s) of periodicity
              (i.e. for 1D periodic system the x-component of the
              electric field should be zero, while for 2D periodic
              systems both the x and y components should be zero. This
              options cannot be used for 3D periodic systems.

            * **MultipolePotential** (*AMS._System._ElectrostaticEmbe
              dding._MultipolePotential*) -- External point charges
              (and dipoles).

         class _MultipolePotential

            External point charges (and dipoles).

            Variables:
               * **ChargeModel** (*Literal**[**"Point"**,
                 **"Gaussian"**]*) -- A multipole may be represented
                 by a point (with a singular potential at its
                 location) or by a spherical Gaussian distribution.

               * **ChargeWidth** (*float** | **FloatKey*) -- The width
                 parameter in a.u. in case a Gaussian charge model is
                 chosen. A negative value means that the width will be
                 chosen automatically.

               * **Coordinates** (*str** | **Sequence**[**str**] **|
                 **FreeBlock*) --

                 Positions and values of the multipoles, one per line.
                 Each line has the following format:

                 x y z q, or x y z q µx µy µz.

                 Here x, y, z are the coordinates in Å, q is the
                 charge (in atomic units of charge) and µx, µy, µz are
                 the (optional) dipole moment components (in atomic
                 units, i.e. e*Bohr).

                 Periodic systems are not supported.

            class _Coordinates

               Positions and values of the multipoles, one per line.
               Each line has the following format:

               x y z q, or x y z q µx µy µz.

               Here x, y, z are the coordinates in Å, q is the charge
               (in atomic units of charge) and µx, µy, µz are the
               (optional) dipole moment components (in atomic units,
               i.e. e*Bohr).

               Periodic systems are not supported.

      class _Lattice

         Up to three lattice vectors. Unit can be specified in the
         header. Default unit is Angstrom.

      class _Modify

         Modifications to make to the chemical system after
         construction. This block is read like a script and the
         modifications applied top to bottom.

         Variables:
            * **EnableAtomAttributes** (*Literal**[**"gui"**,
              **"adf"**, **"band"**, **"forcefield"**, **"dftb"**,
              **"reaxff"**, **"qe"**]*) -- Enables an atomic attribute
              group. This is only necessary if you want a group
              enabled, but no atom in the input is using any attribute
              from that group.

            * **GuessBonds** (*BoolType** | **BoolKey*) -- Guesses
              bonds based on the atomic elements and the geometry.
              Keeps existing bonds.

            * **LatticeStrain** (*Iterable**[**float**] **|
              **FloatListKey*) -- Deform the input system by the
              specified strain. The strain elements are in Voigt
              notation, so one should specify 6 numbers for 3D
              periodic system (order: xx,yy,zz,yz,xz,xy), 3 numbers
              for 2D periodic systems (order: xx,yy,xy) or 1 number
              for 1D periodic systems.

            * **MapAtomsToUnitCell** (*Iterable**[**float**] **|
              **FloatListKey*) -- For periodic systems the atoms will
              be moved to the central unit cell where all their
              fractional coordinates are in the range
              [start_range,start_range+1). No mapping will take place
              along non-periodic directions. If just a single number
              is given, it corresponds to start_range. If multiple
              numbers are given, they should match the number of
              lattice vectors and will be used as start ranges along
              the individual lattice vectors. If no number is given at
              all, the mapping will be done to the [-0.5:0.5) cell.

            * **PerturbCoordinates** (*float** | **FloatKey*) --
              Perturb the atomic coordinates by adding random numbers
              between [-PerturbCoordinates,PerturbCoordinates] to each
              Cartesian component. This can be useful if you want to
              break the symmetry of your system (e.g. for a geometry
              optimization).

            * **PerturbLattice** (*float** | **FloatKey*) -- Perturb
              the lattice vectors by applying random strain with
              matrix elements between
              [-PerturbLattice,PerturbLattice]. This can be useful if
              you want to deviate from an ideal symmetric geometry,
              for example if you look for a phase change due to high
              pressure.

            * **SuperCell** (*Iterable**[**int**] **| **IntListKey*)
              -- Create a supercell of the input system (only possible
              for periodic systems). The integer numbers represent the
              diagonal elements of the supercell transformation; you
              should specify as many numbers as lattice vectors (i.e.
              1 number for 1D, 2 numbers for 2D and 3 numbers for 3D
              periodic systems).

            * **SuperCellTrafo** (*Iterable**[**int**] **|
              **IntListKey*) -- Create a supercell of the input system
              (only possible for periodic systems) \vec{a}_i' = \sum_j
              T_{ij} \vec{a}_j. The integer numbers represent the
              supercell transformation T_{ij}: 1 number for 1D PBC, 4
              numbers for 2D PBC corresponding to a 2x2 matrix (order:
              (1,1),(1,2),(2,1),(2,2)) and 9 numbers for 3D PBC
              corresponding to a 3x3 matrix (order:
              (1,1),(1,2),(1,3),(2,1),(2,2),(2,3),(3,1),(3,2),(3,3)).

            * **Symmetrize** (*BoolType** | **BoolKey*) -- Symmetrizes
              a system, using either the "symmetrize_molecule" or
              "symmetrize_cell" method, depending on periodicity.

            * **SymmetrizeMoleculeTo** (*str** | **StringKey*) --
              Symmetrizes a molecule to a particular symmetry given by
              a Schoenflies symbol. Symmetrizes the atomic coordinates
              to machine precision, but does NOT rototranslate the
              molecule in any way. If the symmetrization fails, an
              error will be raised.

            * **Translate** (*Iterable**[**float**] **|
              **FloatListKey*) -- Translate all atoms by a vector.

   class _Thermo

      Options for thermodynamic properties (assuming an ideal gas).
      The properties are computed for all specified temperatures.

      Variables:
         * **Pressure** (*float** | **FloatKey*) -- The pressure at
           which the thermodynamic properties are computed.

         * **Temperatures** (*Iterable**[**float**] **|
           **FloatListKey*) -- List of temperatures at which the
           thermodynamic properties will be calculated.

         * **UseSymmetryForEntropy** (*BoolType** | **BoolKey*) -- Use
           symmetry for the calculation of rotational entropy.

         * **LowFrequencyCorrector**
           (*AMS._Thermo._LowFrequencyCorrector*) -- Options for the
           dampener-powered free rotor interpolator that corrects
           thermodynamic quantities for low frequencies. See
           DOI:10.1021/jp509921r and DOI:10.1002/chem.201200497.

      class _LowFrequencyCorrector

         Options for the dampener-powered free rotor interpolator that
         corrects thermodynamic quantities for low frequencies. See
         DOI:10.1021/jp509921r and DOI:10.1002/chem.201200497.

         Variables:
            * **Alpha** (*float** | **FloatKey*) -- The exponent term
              used in the dampener.

            * **Frequency** (*float** | **FloatKey*) -- The frequency
              around which the dampener interpolates between harmonic
              oscillator and free rotor quantities.

            * **MomentOfInertia** (*float** | **FloatKey*) -- The
              moment of inertia used to restrict entropy results for
              very small frequencies (generally around less than 1
              cm-1).

   class _TransitionStateSearch

      Configures some details of the transition state search.

      Variables:
         * **ModeToFollow** (*int** | **IntKey*) -- In case of
           Transition State Search, here you can specify the index of
           the normal mode to follow (1 is the mode with the lowest
           frequency).

         * **ReactionCoordinate**
           (*AMS._TransitionStateSearch._ReactionCoordinate*) --
           Specify components of the transition state reaction
           coordinate (TSRC) as a linear combination of internal
           coordinates (distances or angles).

      class _ReactionCoordinate

         Specify components of the transition state reaction
         coordinate (TSRC) as a linear combination of internal
         coordinates (distances or angles).

         Variables:
            * **All** (*str** | **StringKey*) -- Dummy.

            * **Angle** (*str** | **StringKey*) -- The TSRC contains
              the valence angle between the given atoms. Three atom
              indices followed by the weight.

            * **Atom** (*str** | **StringKey*) -- Dummy.

            * **AtomList** (*str** | **StringKey*) -- Dummy.

            * **Block** (*str** | **StringKey*) -- Name of the region.
              Only atoms of the region will be included in the TSRC.
              It is useful when computing the reaction coordinate from
              the initial Hessian, in which case only part of the
              Hessian will be analyzed.

            * **BlockAtoms** (*Iterable**[**int**] **| **IntListKey*)
              -- List of atom indices. Only the listed atoms will be
              included in the TSRC. It is useful when computing the
              reaction coordinate from the initial Hessian, in which
              case only part of the Hessian will be analyzed.

            * **Coordinate** (*str** | **StringKey*) -- The TSRC
              contains Cartesian displacement of an atom: atom index
              followed by [x|y|z] and the weight.

            * **DifDist** (*str** | **StringKey*) -- Dummy.

            * **Dihedral** (*str** | **StringKey*) -- The TSRC
              contains the dihedral angle between the given atoms.
              Four atom indices followed by the weight.

            * **Distance** (*str** | **StringKey*) -- The TSRC
              contains the distance between the given atoms. Two atom
              indices followed by the weight.

            * **EqualStrain** (*str** | **StringKey*) -- Dummy.

            * **FixedRegion** (*str** | **StringKey*) -- Dummy.

            * **FreezeStrain** (*str** | **StringKey*) -- Dummy.

            * **SumDist** (*str** | **StringKey*) -- Dummy.

   class _VibrationalAnalysis

      Input data for all vibrational analysis utilities in the AMS
      driver.

      Variables:
         * **Displacement** (*float** | **FloatKey*) -- Step size for
           finite difference calculations.

         * **Quiet** (*BoolType** | **BoolKey*) -- Suppress run-time
           output

         * **Type** (*Literal**[**"ModeScanning"**,
           **"ModeTracking"**, **"ModeRefinement"**,
           **"VibronicStructure"**, **"VibronicStructureTracking"**,
           **"VibronicStructureRefinement"**, **"ResonanceRaman"**]*)
           -- Specifies the type of vibrational analysis that should
           be performed

         * **VSTRestartFile** (*str** | **Path** | **StringKey*) --
           Path to a .rkf file containing restart information for VST.

         * **AbsorptionSpectrum**
           (*AMS._VibrationalAnalysis._AbsorptionSpectrum*) --
           Settings related to the integration of the spectrum for
           vibronic tasks.

         * **ExcitationSettings**
           (*AMS._VibrationalAnalysis._ExcitationSettings*) -- Block
           that contains settings related to the excitation for
           vibronic tasks.

         * **ModeTracking** (*AMS._VibrationalAnalysis._ModeTracking*)
           -- Input data for Mode Tracking.

         * **NormalModes** (*AMS._VibrationalAnalysis._NormalModes*)
           -- All input related to processing of normal modes. Not
           available for vibronic structure tracking (as no modes are
           required there).

         * **ResonanceRaman**
           (*AMS._VibrationalAnalysis._ResonanceRaman*) -- Block that
           contains settings for the calculation of Resonance Raman
           calculations

      class _AbsorptionSpectrum

         Settings related to the integration of the spectrum for
         vibronic tasks.

         Variables:
            * **AbsorptionRange** (*Iterable**[**float**] **|
              **FloatListKey*) -- Specifies frequency range of the
              vibronic absorption spectrum to compute. 2 numbers: an
              upper and a lower bound.

            * **FrequencyGridPoints** (*int** | **IntKey*) -- Number
              of grid points to use for the spectrum

            * **IntegrationThreshold** (*float** | **FloatKey*) --
              Value of exponential damping in absorption cross-section
              used to define upper integration limit.

            * **LineWidth** (*float** | **FloatKey*) -- Lorentzian
              line-width.

            * **SpectrumOffset** (*Literal**[**"absolute"**,
              **"relative"**]*) -- Specifies whether provided
              frequency range are absolute frequencies or frequencies
              relative to computed 0-0 excitation energy.

            * **TimeStep** (*float** | **FloatKey*) -- Value of time
              step for spectrum integration.

      class _ExcitationSettings

         Block that contains settings related to the excitation for
         vibronic tasks.

         Variables:
            * **EnergyInline** (*float** | **FloatKey*) -- Vertical
              excitation energy, used when [ExcitationInfo] =
              [Inline].

            * **ExcitationFile** (*str** | **Path** | **StringKey*) --
              Path to a .rkf/.t21 file containing the excited state
              information (gradients, transition dipoles and
              energies).

            * **ExcitationInputFormat** (*Literal**[**"File"**,
              **"Inline"**]*) -- Select how the application should
              retrieve the excited state information (energy,
              gradient).

            * **GradientInline** (*str** | **Sequence**[**str**] **|
              **FreeBlock*) -- Excited state gradient at ground state
              equilibrium geometry, used when [ExcitationInfo] =
              [Inline].

            * **Singlet** (*str** | **Sequence**[**str**] **|
              **FreeBlock*) -- Symmetry labels + integer indices of
              desired singlet transitions (VG-FC absorption spectra
              support only 1 at a time)

            * **Triplet** (*str** | **Sequence**[**str**] **|
              **FreeBlock*) -- Symmetry labels + integer indices of
              desired triplet transitions (VG-FC absorption spectra
              support only 1 at a time)

         class _GradientInline

            Excited state gradient at ground state equilibrium
            geometry, used when [ExcitationInfo] = [Inline].

         class _Singlet

            Symmetry labels + integer indices of desired singlet
            transitions (VG-FC absorption spectra support only 1 at a
            time)

         class _Triplet

            Symmetry labels + integer indices of desired triplet
            transitions (VG-FC absorption spectra support only 1 at a
            time)

      class _ModeTracking

         Input data for Mode Tracking.

         Variables:
            * **GramSchmidt** (*BoolType** | **BoolKey*) -- Turn
              on/off gram-schmidt orthogonalization of new vectors to
              alter convergence.

            * **GramSchmidtIterations** (*int** | **IntKey*) --
              Maximum number of gram-schmidt orthogonalization steps
              per iteration.

            * **GramSchmidtTolerance** (*float** | **FloatKey*) --
              Tolerance for checking orthogonality when expanding the
              basis.

            * **HessianGuess** (*Literal**[**"Unit"**, **"File"**,
              **"CalculateWithFastEngine"**, **"Inline"**]*) -- Sets
              how to obtain the guess for the Hessian used in the
              preconditioner (if one is to be used).

            * **HessianPath** (*str** | **Path** | **StringKey*) --
              Path to a .rkf file containing the initial guess for the
              Hessian, used when [HessianGuess] = [File]. It may also
              be the name of the results folder containing the engine
              file.

            * **MaxIterations** (*int** | **IntKey*) -- Maximum number
              of allowed iterations.

            * **RemoveRigids** (*BoolType** | **BoolKey*) --
              Orthogonalize tracked vectors against rigid modes

            * **ToleranceForBasis** (*float** | **FloatKey*) --
              Convergence tolerance for the contribution of the newest
              basis vector to the tracked mode.

            * **ToleranceForNorm** (*float** | **FloatKey*) --
              Convergence tolerance for residual RMS value.

            * **ToleranceForResidual** (*float** | **FloatKey*) --
              Convergence tolerance for the maximum component of the
              residual vector.

            * **ToleranceForSpectrum** (*float** | **FloatKey*) --
              Convergence tolerance for the spectrum in Vibronic
              Structure Tracking.

            * **TrackingMethod** (*Literal**[**"OverlapInitial"**,
              **"DifferenceInitial"**, **"FreqInitial"**,
              **"IRInitial"**, **"OverlapPrevious"**,
              **"DifferencePrevious"**, **"FreqPrevious"**,
              **"IRPrevious"**, **"HighestFreq"**, **"HighestIR"**,
              **"LowestFreq"**, **"LowestResidual"**]*) -- Set the
              tracking method that will be used. Vibronic Structure
              Tracking uses Largest Displacement.

            * **UpdateMethod** (*Literal**[**"JD"**, **"D"**,
              **"I"**]*) -- Chooses the method for expanding the
              Krylov subspace: (I) No preconditioner (VST default),
              (D) Davidson or (JD) vdVorst-Sleijpen variant of Jacobi-
              Davidson (Mode tracking default).

            * **HessianInline** (*str** | **Sequence**[**str**] **|
              **FreeBlock*) -- Initial guess for the (non-mass-
              weighted) Hessian in a 3N x 3N block, used when
              [HessianGuess] = [Inline].

         class _HessianInline

            Initial guess for the (non-mass-weighted) Hessian in a 3N
            x 3N block, used when [HessianGuess] = [Inline].

      class _NormalModes

         All input related to processing of normal modes. Not
         available for vibronic structure tracking (as no modes are
         required there).

         Variables:
            * **MassWeightInlineMode** (*BoolType** | **BoolKey*) --
              MODE TRACKING ONLY: The supplied modes must be mass-
              weighted. This tells the program to mass-weight the
              supplied modes in case this has not yet been done. (True
              means the supplied modes will be mass-weighted by the
              program, e.g. the supplied modes are non-mass-weighted.)

            * **ModeFile** (*str** | **Path** | **StringKey*) -- Path
              to a .rkf or .t21 file containing the modes which are to
              be scanned. Which modes will be scanned is selected
              using the criteria from the [ModeSelect] block.) This
              key is optional for Resonance Raman and Vibronic
              Structure. These methods can also calculate the modes
              using the engine.

            * **ModeInputFormat** (*Literal**[**"File"**,
              **"Inline"**, **"Hessian"**]*) -- Set how the initial
              guesses for the modes are supplied. Only mode tracking
              supports the Inline and Hessian options.

            * **ScanModes** (*BoolType** | **BoolKey*) -- Supported
              by: Mode Tracking, Mode Refinement, Vibronic Structure
              Refinement: If enabled an additional displacement will
              be performed along the new modes at the end of the
              calculation to obtain refined frequencies and IR
              intensities. Equivalent to running the output file of
              the mode tracking calculation through the AMS
              ModeScanning task.

            * **ModeInline** (*str** | **Sequence**[**str**] **|
              **FreeBlock*) -- MODE TRACKING ONLY: Coordinates of the
              mode which will be tracked in a N x 3 block (same as for
              atoms), used when [ModeInputFormat] = [Inline]. Rows
              must be ordered in the same way as in the [System%Atoms]
              block. Mode Tracking only.

            * **ModeSelect**
              (*AMS._VibrationalAnalysis._NormalModes._ModeSelect*) --
              Pick which modes to read from file.

         class _ModeInline

            MODE TRACKING ONLY: Coordinates of the mode which will be
            tracked in a N x 3 block (same as for atoms), used when
            [ModeInputFormat] = [Inline]. Rows must be ordered in the
            same way as in the [System%Atoms] block. Mode Tracking
            only.

         class _ModeSelect

            Pick which modes to read from file.

            Variables:
               * **DisplacementBound** (*float** | **FloatKey*) --
                 Vibronic Structure (Refinement), Resonance Raman:
                 Select all modes with a dimensionless oscillator
                 displacement greater than the specified value.

               * **FreqAndIRRange** (*Iterable**[**float**] **|
                 **FloatListKey*) -- Specifies a combined frequency
                 and IR intensity range within which all modes will be
                 selected. First 2 numbers are the frequency range in
                 cm-1, last 2 numbers are the IR intensity range in
                 km/mol.

               * **FreqRange** (*Iterable**[**float**] **|
                 **FloatListKey*) -- Specifies a frequency range
                 within which all modes will be selected. 2 numbers:
                 an upper and a lower bound. Calculating all modes
                 higher than some frequency can be achieved by making
                 the upper bound very large.

               * **Full** (*BoolType** | **BoolKey*) -- Select all
                 modes. This only make sense for Mode Scanning
                 calculations.

               * **HighFreq** (*int** | **IntKey*) -- Select the N
                 modes with the highest frequencies.

               * **HighIR** (*int** | **IntKey*) -- Select the N modes
                 with the largest IR intensities.

               * **IRRange** (*Iterable**[**float**] **|
                 **FloatListKey*) -- Specifies an IR intensity range
                 within which all modes will be selected. 2 numbers:
                 an upper and a lower bound.

               * **ImFreq** (*BoolType** | **BoolKey*) -- Select all
                 modes with imaginary frequencies.

               * **LargestDisplacement** (*int** | **IntKey*) --
                 Vibronic Structure (Refinement), Resonance Raman:
                 Select the N modes with the largest VG-FC
                 displacement.

               * **LowFreq** (*int** | **IntKey*) -- Select the N
                 modes with the lowest frequencies. Includes imaginary
                 modes which are recorded with negative frequencies.

               * **LowFreqNoIm** (*int** | **IntKey*) -- Select the N
                 modes with the lowest non-negative frequencies.
                 Imaginary modes have negative frequencies and are
                 thus omitted here.

               * **LowIR** (*int** | **IntKey*) -- Select the N modes
                 with the smallest IR intensities.

               * **ModeNumber** (*Iterable**[**int**] **|
                 **IntListKey*) -- Indices of the modes to select.

      class _ResonanceRaman

         Block that contains settings for the calculation of Resonance
         Raman calculations

         Variables:
            * **IncidentFrequency** (*float** | **FloatKey*) --
              Frequency of incident light. Also used to determine most
              important excitation in case more than one is provided.

            * **LifeTime** (*float** | **FloatKey*) -- Lifetime of
              Raman excited state.

            * **MaximumStates** (*int** | **IntKey*) -- Maximum number
              of final states included in the spectrum.

            * **RamanOrder** (*int** | **IntKey*) -- Order up to which
              to compute Raman transitions

            * **RamanRange** (*Iterable**[**float**] **|
              **FloatListKey*) -- Specifies frequency range of the
              Raman spectrum to compute. 2 numbers: an upper and a
              lower bound.

class AMSBatch

   Variables:
      * **EngineRestart** (*str** | **Path** | **StringKey*) --

        The path to the file from which to restart the engine.

        Should be a proper engine result file (like adf.rkf, band.rkf
        etc), or the name of the results directory containing it.

      * **FallbackSolveAfterEngineFailure** (*BoolType** | **BoolKey*)
        -- If the engine fails to Solve, try to re-run the Solve
        without restarting the engine from the previous results. This
        generally decreases the engine failure rate. Only relevant
        certain tasks, such as GeometryOptimization,
        MolecularDynamics, Replay, IRC.

      * **LoadEngine** (*str** | **Path** | **StringKey*) -- The path
        to the file from which to load the engine configuration.
        Replaces the Engine block.

      * **RNGSeed** (*Iterable**[**int**] **| **IntListKey*) --
        Initial seed for the (pseudo)random number generator. This
        should be omitted in most calculations to avoid introducing
        bias into the results. If this is unset, the generator will be
        seeded randomly from external sources of entropy. If you want
        to exactly reproduce an older calculation, set this to the
        numbers printed in its output.

      * **Task** (*Literal**[**"GCMC"**, **"GeometryOptimization"**,
        **"Idle"**, **"IRC"**, **"MolecularDynamics"**, **"NEB"**,
        **"PESExploration"**, **"PESScan"**, **"Pipe"**, **"Replay"**,
        **"SinglePoint"**, **"SteepestDescent"**, **"TestEngine"**,
        **"TestSymmetry"**, **"TransitionStateSearch"**,
        **"VibrationalAnalysis"**]*) --

        Specify the computational task to perform:

        * Single Point: keep geometry as is

        * Geometry Optimization: minimize energy

        * Transition State: search for a transition state

        * IRC: intrinsic reaction coordinate

        * PES Scan: scan the potential energy surface

        * NEB: Nudged elastic band for reaction path optimization

        * Vibrational Analysis: perform one of the analysis types
          selected on the options page

        * Molecular Dynamics: perform MD simulation

        * GCMC: Grand Canonical Monte Carlo simulation

        * PES Exploration: automated potential energy surface
          exploration

        * Replay: recompute frames from the trajectory of a previously
          run job

      * **Test** (*Literal**[**"Symmetry"**, **"BareSymmetry"**,
        **"Bonds"**, **"SecondOrderBonds"**, **"AtomTyping"**,
        **"SystemMatching"**]*) -- various technical tests that will
        be done for the system

      * **UseSymmetry** (*BoolType** | **BoolKey*) -- Whether to use
        the system's symmetry in AMS. Symmetry is recognized within a
        tolerance as given in the Symmetry key.

      * **BondOrders** (*AMSBatch._BondOrders*) -- Configures details
        regarding the calculation/guessing of bond orders. To request
        the calculation of bond orders, use the
        'Properties%BondOrders' key.

      * **Constraints** (*AMSBatch._Constraints*) -- The Constraints
        block allows geometry optimizations and potential energy
        surface scans with constraints. The constraints do not have to
        be satisfied at the start of the calculation.

      * **ElasticTensor** (*AMSBatch._ElasticTensor*) -- Options for
        numerical evaluation of the elastic tensor.

      * **Engine** (*EngineBlock*) -- The input for the computational
        engine. The header of the block determines the type of the
        engine.

      * **EngineAddons** (*AMSBatch._EngineAddons*) -- This block
        configures all the engine add-ons.

      * **EngineDebugging** (*AMSBatch._EngineDebugging*) -- This
        block contains some options useful for debugging the
        computational engines.

      * **ExitCondition** (*AMSBatch._ExitCondition*) -- If any of the
        specified exitconditions are met, the AMS driver will exit
        cleanly.

      * **GCMC** (*AMSBatch._GCMC*) --

        This block controls the Grand Canonical Monte Carlo (GCMC)
        task.

        By default, molecules are added at random positions in the
        simulation box. The initial position is controlled by

      * **GeometryOptimization** (*AMSBatch._GeometryOptimization*) --
        Configures details of the geometry optimization and transition
        state searches.

      * **IEEEExceptions** (*AMSBatch._IEEEExceptions*) -- Whether
        this works or not depends on the way the program is compiled
        (compiler and settings). Only useful for developers debugging
        some numerical issue.

      * **IRC** (*AMSBatch._IRC*) -- Configures details of the
        Intrinsic Reaction Coordinate optimization.

      * **Idle** (*AMSBatch._Idle*) -- Configures details of the idle
        task, which does nothing for a specified amount of time.

      * **LoadSystem** (*AMSBatch._LoadSystem*) -- Block that controls
        reading the chemical system from a KF file instead of the
        [System] block.

      * **Log** (*str** | **Sequence**[**str**] **| **FreeBlock*) --
        Configures the debugging loggers. Syntax: 'Level LoggerName'.
        Possible Levels: All, Debug, Info, Warning, Error, Fatal.

      * **MolecularDynamics** (*AMSBatch._MolecularDynamics*) --
        Configures molecular dynamics (with the velocity-Verlet
        algorithm) with and without thermostats. This block allows to
        specify the details of the molecular dynamics calculation.

      * **Molecules** (*AMSBatch._Molecules*) -- Configures details of
        the molecular composition analysis enabled by the
        Properties%Molecules block.

      * **NEB** (*AMSBatch._NEB*) -- Configures details of the Nudged
        Elastic Band optimization.

      * **NormalModes** (*AMSBatch._NormalModes*) -- Configures
        details of a normal modes calculation.

      * **NumericalDifferentiation**
        (*AMSBatch._NumericalDifferentiation*) -- Define options for
        numerical differentiations, that is the numerical calculation
        of gradients, Hessian and the stress tensor for periodic
        systems.

      * **NumericalPhonons** (*AMSBatch._NumericalPhonons*) --
        Configures details of a numerical phonons calculation.

      * **PESExploration** (*AMSBatch._PESExploration*) -- Configures
        details of the automated PES exploration methods.

      * **PESPointCharacter** (*AMSBatch._PESPointCharacter*) --
        Options for the characterization of PES points.

      * **PESScan** (*AMSBatch._PESScan*) -- Configures the details of
        the potential energy surface scanning task.

      * **Phonons** (*AMSBatch._Phonons*) -- Configures the phonons
        calculation.

      * **Print** (*AMSBatch._Print*) -- This block controls the
        printing of additional information to stdout.

      * **Properties** (*AMSBatch._Properties*) -- Configures which
        AMS level properties to calculate for SinglePoint calculations
        or other important geometries (e.g. at the end of an
        optimization).

      * **Raman** (*AMSBatch._Raman*) -- Configures details of the
        Raman or VROA calculation.

      * **Replay** (*AMSBatch._Replay*) -- Configures the details of
        the Replay task.

      * **Restraints** (*AMSBatch._Restraints*) -- The Restraints
        block allows to add soft constraints to the system. A
        restraint is a potential energy function (a spring) attached
        to a certain coordinate, for example, an interatomic distance,
        with its minimum at the specified optimal value. A restraint
        is defined using one or two parameters: the ForceConstant and,
        for some types, the F(Inf) value. The ForceConstant parameter
        corresponds to second derivative of the restraint potential
        energy d2V(x)/dx^2 for any x (harmonic restraints) or only at
        at x=0 (other restraints). Here, x is a deviation from the
        restraint's optimal value.

      * **RigidMotions** (*AMSBatch._RigidMotions*) -- Specify which
        rigid motions of the total system are allowed. An external
        field is not considered part of the system. Normally the
        automatic option is doing what you want. However this feature
        can be used as a means of geometry constraint.

      * **SCMLibrary** (*AMSBatch._SCMLibrary*) -- Technical settings
        affecting src/lib

      * **SCMMatrix** (*AMSBatch._SCMMatrix*) -- Technical settings
        for programs using the AMT matrix system. Currently this is
        only used by DFTB

      * **SerializedTensors** (*AMSBatch._SerializedTensors*) --
        Technical settings affecting the SerializedTensors module,
        currently only used for HartreeFock

      * **SteepestDescent** (*AMSBatch._SteepestDescent*) --
        Configures details of the steepest descent task.

      * **Symmetry** (*AMSBatch._Symmetry*) -- Specifying details
        about the details of symmetry detection and usage.

      * **System** (*AMSBatch._System*) -- Specification of the
        chemical system. For some applications more than one system
        may be present in the input. In this case, all systems except
        one must have a non-empty string ID specified after the System
        keyword. The system without an ID is considered the main one.

      * **SystemsFromConformers** (*AMSBatch._SystemsFromConformers*)
        -- Constructs a series of systems (with identifiers
        'conformer1', 'conformer2', etc.) from a RKF or XYZ file from
        a Conformers run.

      * **SystemsFromPES** (*AMSBatch._SystemsFromPES*) -- Constructs
        a series of systems (with identifiers 'system1', 'system2',
        etc.) from a RKF file from Conformers, PESExploration, or
        PESScan run.

      * **SystemsFromSMILES** (*str** | **Sequence**[**str**] **|
        **FreeBlock*) -- Generates systems from SMILES strings using
        the plams.from_smiles() functions. Each line should contain
        first the system identifier separated by a comma from its
        SMILES string, e.g.: 'propanol, CCCO'

      * **SystemsFromTrajectory** (*AMSBatch._SystemsFromTrajectory*)
        -- Constructs a series of systems (with identifiers 'frame1',
        'frame2', etc.) from a trajectory file.

      * **Thermo** (*AMSBatch._Thermo*) -- Options for thermodynamic
        properties (assuming an ideal gas). The properties are
        computed for all specified temperatures.

      * **TransitionStateSearch** (*AMSBatch._TransitionStateSearch*)
        -- Configures some details of the transition state search.

      * **VibrationalAnalysis** (*AMSBatch._VibrationalAnalysis*) --
        Input data for all vibrational analysis utilities in the AMS
        driver.

   class _BondOrders

      Configures details regarding the calculation/guessing of bond
      orders. To request the calculation of bond orders, use the
      'Properties%BondOrders' key.

      Variables:
         **Method** (*Literal**[**"Engine"**, **"Guess"**,
         **"EngineWithGuessFallback"**]*) --

         How to compute the bond orders when they are requested via
         the 'Properties%BondOrders' key.

         'Engine': let the engine compute the bond orders. The
         specific method used to compute the bond orders depends on
         the engine selected, and it may be configurable in the
         engine's input. Note: the calculation may stop if the engine
         cannot compute bond orders.

         'Guess': Use a bond guessing algorithm based on the system's
         geometry. This is the same algorithm that is used by the
         Graphical User Interface to guess bonds.

         'EngineWithGuessFallback': let the engine compute the bond
         orders (same as in 'Engine' option) but if the engine did not
         produce any bond orders, use the bond guessing algorithm as a
         fallback option.

   class _Constraints

      The Constraints block allows geometry optimizations and
      potential energy surface scans with constraints. The constraints
      do not have to be satisfied at the start of the calculation.

      Variables:
         * **All** (*str** | **StringKey*) --

           Fix multiple distances using one the following formats:
           All [bondOrder] bonds at1 at2 [to distance] All triangles
           at1 at2 at3

           The first option constrains all bonds between atoms at1 at2
           to a certain length, while the second - bonds at1-at2 and
           at2-at3 as well as the angle between them.

           The [bondOrder] can be a number or a string such as single,
           double, triple or aromatic. If it's omitted then any bond
           between specified atoms will be constrained. Atom names are
           case-sensitive and they must be as they are in the Atoms
           block, or an asterisk '*' denoting any atom. If the
           distance is omitted then the bond length from the initial
           geometry is used.

           Important: only the bonds present in the system at the
           start of the simulation can be constrained, which means
           that the bonds may need to be specified in the System
           block.

           Valid examples: All single bonds C C to 1.4 All bonds O H
           to 0.98 All bonds O H All bonds H * All triangles H * H

         * **Angle** (*str** | **StringKey*) -- Fix the angle between
           three atoms. Three atom indices followed by an angle in
           degrees.

         * **Atom** (*int** | **IntKey*) -- Fix the position of an
           atom. Just one integer referring to the index of the atom
           in the [System%Atoms] block.

         * **AtomList** (*Iterable**[**int**] **| **IntListKey*) --
           Fix positions of the specified atoms. A list of integers
           referring to indices of atoms in the [System%Atoms] block.

         * **Block** (*str** | **StringKey*) -- Name of the region to
           constrain as a rigid block. Regions are specified in the
           System%Atoms block.

         * **BlockAtoms** (*Iterable**[**int**] **| **IntListKey*) --
           List of atom indices for a block constraint, where the
           internal degrees of freedom are frozen.

         * **Coordinate** (*str** | **StringKey*) -- Fix a particular
           coordinate of an atom. Atom index followed by (x|y|z).

         * **DifDist** (*str** | **StringKey*) -- Four atom indices i
           j k l followed by the distance in Angstrom. This will
           constrain the difference R(ij)-R(kl) at the given value.

         * **Dihedral** (*str** | **StringKey*) -- Fix the dihedral
           angle between four atoms. Four atom indices followed by an
           angle in degrees.

         * **Distance** (*str** | **StringKey*) -- Fix the distance
           between two atoms. Two atom indices followed by the
           distance in Angstrom.

         * **EqualStrain** (*str** | **StringKey*) --

           Exclusively for lattice optimizations:

           Accepts a set of strain components [xx, xy, xz, yy, yz, zz]
           which are to be kept equal.

           The applied strain will be determined by the average of the
           corresponding stress tensors components.

           In AMSinput just check the corresponding check buttons.

         * **FixedRegion** (*str** | **StringKey*) -- Fix positions of
           all atoms in a region.

         * **FreezeStrain** (*str** | **StringKey*) --

           Exclusively for lattice optimizations:

           Freezes any lattice deformation corresponding to a
           particular component of the strain tensor.

           Accepts a set of strain components [xx, xy, xz, yy, yz, zz]
           to be frozen.

           In AMSinput just check the corresponding check buttons.

         * **SumDist** (*str** | **StringKey*) -- Four atom indices i
           j k l followed by the distance in Angstrom. This will
           constrain the sum R(ij)+R(kl) at the given value.

   class _ElasticTensor

      Options for numerical evaluation of the elastic tensor.

      Variables:
         * **ConvergenceQuality** (*Literal**[**"Normal"**,
           **"Good"**, **"VeryGood"**, **"Excellent"**]*) -- The
           tightness of the convergence of the geometry optimizations
           for each strain deformation. This should not be set higher
           than the overall convergence quality of the preceding
           geometry optimization configured by the
           "GeometryOptimization%Convergence%Quality" keyword.

         * **StrainStepSize** (*float** | **FloatKey*) -- Step size
           (relative) of strain deformations used for computing the
           elastic tensor numerically.

         * **Parallel** (*AMSBatch._ElasticTensor._Parallel*) --
           Options for double parallelization, which allows to split
           the available processor cores into groups working through
           all the available tasks in parallel, resulting in a better
           parallel performance. The keys in this block determine how
           to split the available processor cores into groups working
           in parallel.

      class _Parallel

         Options for double parallelization, which allows to split the
         available processor cores into groups working through all the
         available tasks in parallel, resulting in a better parallel
         performance. The keys in this block determine how to split
         the available processor cores into groups working in
         parallel.

         Variables:
            * **nCoresPerGroup** (*int** | **IntKey*) -- Number of
              cores in each working group.

            * **nGroups** (*int** | **IntKey*) -- Total number of
              processor groups. This is the number of tasks that will
              be executed in parallel.

            * **nNodesPerGroup** (*int** | **IntKey*) -- Number of
              nodes in each group. This option should only be used on
              homogeneous compute clusters, where all used compute
              nodes have the same number of processor cores.

   class _Engine

      The input for the computational engine. The header of the block
      determines the type of the engine.

   class _EngineAddons

      This block configures all the engine add-ons.

      Variables:
         * **Pressure** (*float** | **FloatKey*) -- Add a hydrostatic
           pressure term to the engine's energy and stress tensor. Can
           only be used for 3D periodic boundary conditions.

         * **AtomEnergies** (*str** | **Sequence**[**str**] **|
           **FreeBlock*) -- Add an element-dependent energy per atom.
           On each line, give the chemical element followed by the
           energy (in atomic units).

         * **D3Dispersion** (*AMSBatch._EngineAddons._D3Dispersion*)
           -- This block configures the add-on that adds the Grimme D3
           dispersion correction to the engine's energy, gradients,
           and stress tensor.

         * **D4Dispersion** (*AMSBatch._EngineAddons._D4Dispersion*)
           -- This block configures the addon that adds the Grimme
           D4(EEQ) dispersion correction to the engine's energy,
           gradients, stress tensor and Hessian.

         * **ExternalEngine**
           (*AMSBatch._EngineAddons._ExternalEngine*) -- External
           engine as an addon

         * **ExternalStress**
           (*AMSBatch._EngineAddons._ExternalStress*) -- This block
           configures the addon that adds external stress term to the
           engine's energy and stress tensor.

         * **PipeEngine** (*AMSBatch._EngineAddons._PipeEngine*) --
           Pipe engine as an addon

         * **Repulsion** (*AMSBatch._EngineAddons._Repulsion*) -- This
           block configures an addon that adds a repulsive Weeks-
           Chandler-Andersen potential to all atom pairs.

         * **WallPotential** (*AMSBatch._EngineAddons._WallPotential*)
           -- This block configures the addon that adds a spherical
           wall potential to the engine's energy and gradients.

      class _AtomEnergies

         Add an element-dependent energy per atom. On each line, give
         the chemical element followed by the energy (in atomic
         units).

      class _D3Dispersion

         This block configures the add-on that adds the Grimme D3
         dispersion correction to the engine's energy, gradients, and
         stress tensor.

         Variables:
            * **Damping** (*Literal**[**"BJ"**, **"Zero"**]*) -- Type
              of damping: BJ (Becke-Johnson) or Zero. BJ is
              recommended for most applications.

            * **Enabled** (*BoolType** | **BoolKey*) -- Enables the D3
              dispersion correction addon.

            * **Functional** (*str** | **StringKey*) -- Use the D3
              parameterization by Grimme for a given xc-functional.
              Accepts the same values as the --func command line
              option of the official dftd3 program. Note: the naming
              convention is different from elsewhere in the AMS suite.
              For example, BLYP should be called b-lyp.

            * **a1** (*float** | **FloatKey*) -- The a1 parameter.
              Only used if Damping is set to BJ. If set, it overwrites
              the a1 value for the chosen functional.

            * **a2** (*float** | **FloatKey*) -- The a2 parameter.
              Only used if Damping is set to BJ. If set, it overwrites
              the a2 value for the chosen functional.

            * **alp** (*float** | **FloatKey*) -- The a2 parameter.
              Only used if Damping is set to BJ. If set, it overwrites
              the a2 value for the chosen functional.

            * **s6** (*float** | **FloatKey*) -- The s6 parameter,
              global scaling parameter. If set, it overwrites the s6
              value for the chosen functional.

            * **s8** (*float** | **FloatKey*) -- The s8 parameter. If
              set, it overwrites the s8 value for the chosen
              functional.

            * **sr6** (*float** | **FloatKey*) -- The sr6 parameter.
              Only used if Damping is set to Zero. If set, it
              overwrites the sr6 value for the chosen functional.

      class _D4Dispersion

         This block configures the addon that adds the Grimme D4(EEQ)
         dispersion correction to the engine's energy, gradients,
         stress tensor and Hessian.

         Variables:
            * **Enabled** (*BoolType** | **BoolKey*) -- Enables the D4
              dispersion correction addon.

            * **Functional** (*Literal**[**"HF"**, **"BLYP"**,
              **"BPBE"**, **"BP86"**, **"BPW"**, **"LB94"**,
              **"MPWLYP"**, **"MPWPW91"**, **"OLYP"**, **"OPBE"**,
              **"PBE"**, **"RPBE"**, **"REVPBE"**, **"PW86PBE"**,
              **"RPW86PBE"**, **"PW91"**, **"PW91P86"**, **"XLYP"**,
              **"B97"**, **"TPSS"**, **"REVTPSS"**, **"SCAN"**,
              **"B1LYP"**, **"B3LYP"**, **"BHLYP"**, **"B1P86"**,
              **"B3P86"**, **"B1PW91"**, **"B3PW91"**, **"O3LYP"**,
              **"REVPBE0"**, **"REVPBE38"**, **"PBE0"**, **"PWP1"**,
              **"PW1PW"**, **"MPW1PW91"**, **"MPW1LYP"**,
              **"PW6B95"**, **"TPSSH"**, **"TPSS0"**, **"X3LYP"**,
              **"M06L"**, **"M06"**, **"OMEGAB97"**, **"OMEGAB97X"**,
              **"CAM-B3LYP"**, **"LC-BLYP"**, **"LH07TSVWN"**,
              **"LH07SSVWN"**, **"LH12CTSSIRPW92"**,
              **"LH12CTSSIFPW92"**, **"LH14TCALPBE"**, **"B2PLYP"**,
              **"B2GPPLYP"**, **"MPW2PLYP"**, **"PWPB95"**,
              **"DSDBLYP"**, **"DSDPBE"**, **"DSDPBEB95"**,
              **"DSDPBEP86"**, **"DSDSVWN"**, **"DODBLYP"**,
              **"DODPBE"**, **"DODPBEB95"**, **"DODPBEP86"**,
              **"DODSVWN"**, **"PBE02"**, **"PBE0DH"**,
              **"DFTB**(**3ob**)**"**, **"DFTB**(**mio**)**"**,
              **"DFTB**(**pbc**)**"**, **"DFTB**(**matsci**)**"**,
              **"DFTB**(**ob2**)**"**, **"B1B95"**, **"MPWB1K"**,
              **"REVTPSSH"**, **"GLYP"**, **"REVPBE0DH"**,
              **"REVTPSS0"**, **"REVDSDPBEP86"**, **"REVDSDPBEPBE"**,
              **"REVDSDBLYP"**, **"REVDODPBEP86"**, **"B97M"**,
              **"OMEGAB97M"**, **"R2SCAN"**]*) -- Use the D4
              parameterization by Grimme for a given xc-functional.

            * **Verbosity** (*Literal**[**"Silent"**, **"Normal"**,
              **"Verbose"**, **"VeryVerbose"**]*) -- Controls the
              verbosity of the dftd4 code. Equivalent to the --silent
              and --verbose command line switches of the official
              dftd4 program.

            * **a1** (*float** | **FloatKey*) -- The a1 parameter, see
              D4 article. The physically reasonable range for a1 is
              [0.0,1.0]. If set, it overwrites the a1 value for the
              chosen functional.

            * **a2** (*float** | **FloatKey*) -- The a2 parameter, see
              D4 article. The physically reasonable range for a2 is
              [0.0,7.0]. If set, it overwrites the a2 value for the
              chosen functional.

            * **ga** (*float** | **FloatKey*) -- The ga parameter. GCP

            * **gc** (*float** | **FloatKey*) -- The gc parameter. GCP

            * **s6** (*float** | **FloatKey*) -- The s6 parameter, see
              D4 article. The physically reasonable range for s6 is
              [0.0,1.0]. If set, it overwrites the s6 value for the
              chosen functional.

            * **s8** (*float** | **FloatKey*) -- The s8 parameter, see
              D4 article. The physically reasonable range for s8 is
              [0.0,3.0]. If set, it overwrites the s8 value for the
              chosen functional.

            * **s9** (*float** | **FloatKey*) -- The s9 parameter, see
              D4 article. If set, it overwrites the s9 value for the
              chosen functional.

      class _ExternalEngine

         External engine as an addon

         Variables:
            **Execute** (*str** | **StringKey*) -- execute command

      class _ExternalStress

         This block configures the addon that adds external stress
         term to the engine's energy and stress tensor.

         Variables:
            * **StressTensorVoigt** (*Iterable**[**float**] **|
              **FloatListKey*) -- The elements of the external stress
              tensor in Voigt notation. One should specify 6 numbers
              for 3D periodic system (order: xx,yy,zz,yz,xz,xy), 3
              numbers for 2D periodic systems (order: xx,yy,xy) or 1
              number for 1D periodic systems.

            * **UpdateReferenceCell** (*BoolType** | **BoolKey*) --
              Whether ot not the reference cell should be updated
              every time the system changes (see documentation).

      class _PipeEngine

         Pipe engine as an addon

         Variables:
            **WorkerCommand** (*str** | **StringKey*) -- pipe worker
            command

      class _Repulsion

         This block configures an addon that adds a repulsive Weeks-
         Chandler-Andersen potential to all atom pairs.

         Variables:
            * **Enabled** (*BoolType** | **BoolKey*) --

              Enables the repulsive Weeks-Chandler-Andersen potential
              addon.

              When enabled, all atom pairs will experience repulsion E
              = 4*epsilon*( (sigma/r)^12 - (sigma/r)^6 + 1/4 ) at the
              distances shorter than about 1.12*sigma.

            * **Epsilon** (*float** | **FloatKey*) -- The epsilon
              parameter in the potential equation. It is equal to the
              amount of energy added at r=sigma.

            * **HydrogenSigmaScale** (*float** | **FloatKey*) -- The
              sigma parameter for a pair of atoms where one of them is
              hydrogen is scaled with the given factor. For H-H
              interactions the sigma is scaled with this value
              squared.

            * **Sigma** (*float** | **FloatKey*) -- The sigma
              parameter in the potential equation. The potential is
              exactly zero at the distances larger than about
              1.12*sigma

            * **SkinLength** (*float** | **FloatKey*) -- Technical
              parameter specifying skin length for the neighbor list
              generation. A larger value increases the neighbor list
              cutoff (and cost) but reduces the frequency it needs to
              be re-created.

      class _WallPotential

         This block configures the addon that adds a spherical wall
         potential to the engine's energy and gradients.

         Variables:
            * **Enabled** (*BoolType** | **BoolKey*) -- Enables the
              wall potential addon. When enabled, a spherical wall of
              radius [Radius] around the origin will be added. The
              force due to the potential will decay exponentially
              inside the wall, will be close to [Prefactor*Gradient]
              outside and exactly half of that at the wall.

            * **Gradient** (*float** | **FloatKey*) -- The radial
              gradient outside the sphere.

            * **Prefactor** (*float** | **FloatKey*) -- The multiplier
              for the overall strength of the potential.

            * **Radius** (*float** | **FloatKey*) -- The radius of the
              sphere, wherein the potential is close to zero.

   class _EngineDebugging

      This block contains some options useful for debugging the
      computational engines.

      Variables:
         * **AlwaysClaimSuccess** (*BoolType** | **BoolKey*) -- If an
           engine fails, pretend that it worked. This can be useful
           when you know that an SCF might fail.

         * **CheckInAndOutput** (*BoolType** | **BoolKey*) -- Enables
           some additional checks on the input and output of an
           engine, e.g. for NaN values.

         * **ForceContinousPES** (*BoolType** | **BoolKey*) -- If this
           option is set, the engine will always run in continuous PES
           mode. For many engines this disables the use of symmetry,
           as this one always leads to a discontinuous PES around the
           symmetric points: Basically there is jump in the PES at the
           point where the symmetry detection starts classifying the
           system as symmetric. Normally the continuous PES mode of
           the engine (often disabling the symmetry) is only used when
           doing numerical derivatives, but this flag forces the
           engine to continuously run in this mode.

         * **IgnoreEngineSupportsErrors** (*BoolType** | **BoolKey*)
           -- Pretend as if the engine supports anything requested.
           Use at your own risk.

         * **IgnoreGradientsRequest** (*BoolType** | **BoolKey*) -- If
           this option is set, the engine will not do analytical
           gradients if asked for it, so that gradients will have to
           be evaluated numerically by AMS.

         * **IgnorePreviousResults** (*BoolType** | **BoolKey*) -- If
           this option is set, the engine will not receive information
           from previous calculations. Typically this information is
           used to restart the self consistent procedure of the
           engine.

         * **IgnoreStressTensorRequest** (*BoolType** | **BoolKey*) --
           If this option is set, the engine will not calculate an
           analytical stress tensor if asked for it, so that the
           stress tensor will have to be evaluated numerically by AMS.

         * **NeverQuiet** (*BoolType** | **BoolKey*) -- Makes the
           engine ignore the request to work quietly.

         * **RandomFailureChance** (*float** | **FloatKey*) -- Makes
           the engine randomly report failures, even though the
           results are actually fine. Useful for testing error
           handling on the application level.

         * **RandomNoiseInEnergy** (*float** | **FloatKey*) -- Adds a
           random noise to the energy returned by the engine. The
           random contribution is drawn from [-r,r] where r is the
           value of this keyword.

         * **RandomNoiseInGradients** (*float** | **FloatKey*) -- Adds
           a random noise to the gradients returned by the engine. A
           random number in the range [-r,r] (where r is the value of
           this keyword) is drawn and added separately to each
           component of the gradient.

         * **RandomStopChance** (*float** | **FloatKey*) -- Makes the
           engine randomly stop. Can be used to simulate crashes.

   class _ExitCondition

      If any of the specified exitconditions are met, the AMS driver
      will exit cleanly.

      Variables:
         * **Type** (*Literal**[**"AtomsTooClose"**,
           **"EngineEnergyUncertainty"**,
           **"EngineGradientsUncertainty"**]*) -- The type of
           exitcondition specified

         * **AtomsTooClose**
           (*AMSBatch._ExitCondition._AtomsTooClose*) -- If any pair
           of atoms is closer than the specified minimum value, the
           program will exit cleanly.

         * **EngineEnergyUncertainty**
           (*AMSBatch._ExitCondition._EngineEnergyUncertainty*) -- If
           the engine reports an uncertainty that is too high, the
           program will exit cleanly.

         * **EngineGradientsUncertainty**
           (*AMSBatch._ExitCondition._EngineGradientsUncertainty*) --
           If the engine reports an uncertainty in the magnitude of
           the nuclear gradient of any atom that is too high, the
           program will exit cleanly.

      class _AtomsTooClose

         If any pair of atoms is closer than the specified minimum
         value, the program will exit cleanly.

         Variables:
            * **MinimumDistance** (*float** | **FloatKey*) -- Two
              atoms closer than this threshold value are considered
              too close.

            * **PairCalculation** (*Literal**[**"NeighborList"**,
              **"DistanceMatrix"**]*) -- Two atoms closer than this
              threshold value are considered too close.

      class _EngineEnergyUncertainty

         If the engine reports an uncertainty that is too high, the
         program will exit cleanly.

         Variables:
            * **MaxUncertainty** (*float** | **FloatKey*) -- Threshold
              for Engine Energy Uncertainty divided by Normalization
              (by default the number of atoms)

            * **Normalization** (*float** | **FloatKey*) -- Divide the
              reported Engine Energy Uncertainty by this
              normalization. Will divide by the number of atoms if
              unset.

      class _EngineGradientsUncertainty

         If the engine reports an uncertainty in the magnitude of the
         nuclear gradient of any atom that is too high, the program
         will exit cleanly.

         Variables:
            **MaxUncertainty** (*float** | **FloatKey*) -- Threshold
            for Engine Gradients Uncertainty.

   class _GCMC

      This block controls the Grand Canonical Monte Carlo (GCMC) task.

      By default, molecules are added at random positions in the
      simulation box. The initial position is controlled by

      Variables:
         * **AccessibleVolume** (*float** | **FloatKey*) -- Volume
           available to GCMC, in cubic Angstroms. AccessibleVolume
           should be specified for "Accessible" and  "FreeAccessible"
           [VolumeOption].

         * **Ensemble** (*Literal**[**"Mu-VT"**, **"Mu-PT"**]*) --
           Select the MC ensemble: Mu-VT for fixed volume or Mu-PT for
           variable volume. When the Mu-PT ensemble is selected the
           [Pressure] and [VolumeChangeMax] should also be specified.

         * **Iterations** (*int** | **IntKey*) -- Number of GCMC
           moves.

         * **MapAtomsToOriginalCell** (*BoolType** | **BoolKey*) --
           Keeps the atom (mostly) in the original cell by mapping
           them back before the geometry optimizations.

         * **MaxDistance** (*float** | **FloatKey*) -- The max
           distance to other atoms of the system when adding the
           molecule.

         * **MinDistance** (*float** | **FloatKey*) -- Keep the
           minimal distance to other atoms of the system when adding
           the molecule.

         * **NonAccessibleVolume** (*float** | **FloatKey*) -- Volume
           not available to GCMC, in cubic Angstroms.
           NonAccessibleVolume may be specified for the "Free"
           [VolumeOption] to reduce the accessible volume.

         * **NumAttempts** (*int** | **IntKey*) -- Try
           inserting/moving the selected molecule up to the specified
           number of times or until all constraints are satisfied. If
           all attempts fail a message will be printed and the
           simulation will stop. If the MaxDistance-MinDistance
           interval is small this number may have to be large.

         * **Pressure** (*float** | **FloatKey*) -- Pressure used to
           calculate the energy correction in the Mu-PT ensemble. Set
           it to zero for incompressible solid systems unless at very
           high pressures.

         * **Restart** (*str** | **Path** | **StringKey*) -- Name of
           an RKF restart file. Upon restart, the information about
           the GCMC input parameters, the initial system (atomic
           coordinates, lattice, charge, etc.) and the MC molecules
           (both already inserted and to be inserted) are read from
           the restart file. The global GCMC input parameters and the
           MC Molecules can be modified from input. Any parameter not
           specified in the input will use its value from the restart
           file (i.e. not the default value). Molecules found in the
           restart file do not have to be present as named Systems in
           the input, however if there is a System present that
           matches the name of a molecule from restart then the
           System's geometry will replace that found in the restart
           file. It is also possible to specify new Molecules in the
           input, which will be added to the pool of the MC molecules
           from restart.

         * **Temperature** (*float** | **FloatKey*) -- Temperature of
           the simulation. Increase the temperature to improve the
           chance of accepting steps that result in a higher energy.

         * **UseGCPreFactor** (*BoolType** | **BoolKey*) -- Use the GC
           pre-exponential factor for probability.

         * **VolumeChangeMax** (*float** | **FloatKey*) -- Fractional
           value by which logarithm of the volume is allowed to change
           at each step. The new volume is then calculated as Vnew =
           exp(random(-1:1)*VolumeChangeMax)*Vold

         * **VolumeOption** (*Literal**[**"Free"**, **"Total"**,
           **"Accessible"**, **"FreeAccessible"**]*) -- Specifies the
           method to calculate the volume used to calculate the GC
           pre-exponential factor and the energy correction in the Mu-
           PT ensemble:  Free: V = totalVolume - occupiedVolume -
           NonAccessibleVolume;  Total: V = totalVolume;  Accessible:
           V = AccessibleVolume;  FreeAccessible: V = AccessibleVolume
           - occupiedVolume.  The AccessibleVolume and
           NonAccessibleVolume are specified in the input, the
           occupiedVolume is calculated as a sum of atomic volumes.

         * **Box** (*AMSBatch._GCMC._Box*) --

           Boundaries of the insertion space, i.e. coordinates of the
           origin of an inserted molecule (coordinates of an atom of
           the inserted system may fall outside the box).

           For a periodic dimension it is given as a fraction of the
           simulation box (the full 0 to 1 range by default). For a
           non-periodic dimension it represents absolute Cartesian
           coordinates in Angstrom (the system's bounding box extended
           by the MaxDistance value by default).

         * **Molecule** (*AMSBatch._GCMC._Molecule*) -- This block
           defines the molecule (or atom) that can be
           inserted/moved/deleted with the MC method. The coordinates
           should form a reasonable structure. The MC code uses these
           coordinates during the insertion step by giving them a
           random rotation, followed by a random translation to
           generate a random position of the molecule inside the box.
           Currently, there is no check to make sure all atoms of the
           molecule stay inside the simulation box. The program does
           check that the MaxDistance/MinDistance conditions are
           satisfied.

         * **Removables** (*str** | **Sequence**[**str**] **|
           **FreeBlock*) -- The Removables can be used to specify a
           list of molecules that can be removed or moved during this
           GCMC calculation. Molecules are specified one per line in
           the format following format:  MoleculeName atom1 atom2 ...
           The MoleculeName must match a name specified in one of the
           [Molecule] blocks. The atom indices refer to the whole
           input System and the number of atoms must match that in the
           specified Molecule. A suitable Removables block is written
           to the standard output after each accepted MC move. If you
           do so then you should also replace the initial atomic
           coordinates with the ones found in the same file. If a
           [Restart] key is present then the Removables block is
           ignored.

         * **SwapAtoms** (*AMSBatch._GCMC._SwapAtoms*) --
           Experimental: Occasionally swap the coordinates of a random
           pair of atoms from two regions.

      class _Box

         Boundaries of the insertion space, i.e. coordinates of the
         origin of an inserted molecule (coordinates of an atom of the
         inserted system may fall outside the box).

         For a periodic dimension it is given as a fraction of the
         simulation box (the full 0 to 1 range by default). For a non-
         periodic dimension it represents absolute Cartesian
         coordinates in Angstrom (the system's bounding box extended
         by the MaxDistance value by default).

         Variables:
            * **Amax** (*float** | **FloatKey*) -- Coordinate of the
              upper bound along the first axis.

            * **Amin** (*float** | **FloatKey*) -- Coordinate of the
              lower bound along the first axis.

            * **Bmax** (*float** | **FloatKey*) -- Coordinate of the
              upper bound along the second axis.

            * **Bmin** (*float** | **FloatKey*) -- Coordinate of the
              lower bound along the second axis.

            * **Cmax** (*float** | **FloatKey*) -- Coordinate of the
              upper bound along the third axis.

            * **Cmin** (*float** | **FloatKey*) -- Coordinate of the
              lower bound along the third axis.

      class _Molecule

         This block defines the molecule (or atom) that can be
         inserted/moved/deleted with the MC method. The coordinates
         should form a reasonable structure. The MC code uses these
         coordinates during the insertion step by giving them a random
         rotation, followed by a random translation to generate a
         random position of the molecule inside the box. Currently,
         there is no check to make sure all atoms of the molecule stay
         inside the simulation box. The program does check that the
         MaxDistance/MinDistance conditions are satisfied.

         Variables:
            * **ChemicalPotential** (*float** | **FloatKey*) --

              Chemical potential of the molecule (or atom) reservoir.

              It is used when calculating the Boltzmann accept/reject
              criteria after a MC move is executed. This value can be
              derived from first principles using statistical
              mechanics, or equivalently, it can be determined from
              thermochemical tables available in literature sources.
                 For example, the proper chemical potential for a GCMC
                 simulation in which single oxygen atoms are exchanged
                 with a reservoir of O2 gas, should equal 1/2 the
                 chemical potential of O2 at the temperature and
                 pressure of the reservoir:

              cmpot = Mu_O(T,P) = 1/2*Mu_O2(T,P) = 1/2 *
              [Mu_ref(T,P_ref) + kT*Log(P/Pref) - E_diss]

              where the reference chemical potential [Mu_ref(T,P_ref)]
              is the experimentally determined chemical potential of
              O2 at T and Pref; kT*Log(P/Pref) is the pressure
              correction to the free energy, and E_diss is the
              dissociation energy of the O2 molecule.

            * **NoAddRemove** (*BoolType** | **BoolKey*) --

              Set to True to tell the GCMC code to keep the number of
              molecules/atoms of this type fixed.

              It will thus disable Insert/Delete moves on this type,
              meaning it can only do a displacement move, or volume
              change move (for an NPT ensemble).

            * **SystemName** (*str** | **StringKey*) -- String ID of a
              named [System] to be inserted. The lattice specified
              with this System, if any, is ignored and the main
              system's lattice is used instead.

      class _Removables

         The Removables can be used to specify a list of molecules
         that can be removed or moved during this GCMC calculation.
         Molecules are specified one per line in the format following
         format:
            MoleculeName atom1 atom2 ...  The MoleculeName must match
            a name specified in one of the [Molecule] blocks. The atom
            indices refer to the whole input System and the number of
            atoms must match that in the specified Molecule. A
            suitable Removables block is written to the standard
            output after each accepted MC move. If you do so then you
            should also replace the initial atomic coordinates with
            the ones found in the same file. If a [Restart] key is
            present then the Removables block is ignored.

      class _SwapAtoms

         Experimental: Occasionally swap the coordinates of a random
         pair of atoms from two regions.

         Variables:
            * **Probability** (*float** | **FloatKey*) -- Probability
              of performing a swap move instead of any other GCMC move
              in a single GCMC iteration.

            * **Regions** (*str** | **StringKey*) -- Names of two
              regions to swap between (separated by a space).

   class _GeometryOptimization

      Configures details of the geometry optimization and transition
      state searches.

      Variables:
         * **CalcPropertiesOnlyIfConverged** (*BoolType** |
           **BoolKey*) -- Compute the properties requested in the
           'Properties' block, e.g. Frequencies or Phonons, only if
           the optimization (or transition state search) converged. If
           False, the properties will be computed even if the
           optimization did not converge.

         * **CoordinateType** (*Literal**[**"Auto"**,
           **"Delocalized"**, **"Cartesian"**]*) --

           Select the type of coordinates in which to perform the
           optimization. 'Auto' automatically selects the most
           appropriate CoordinateType for a given Method.

           If 'Auto' is selected, Delocalized coordinates will be used
           for the Quasi-Newton method, while Cartesian coordinates
           will be used for all other methods.

         * **KeepIntermediateResults** (*BoolType** | **BoolKey*) --
           Whether the full engine result files of all intermediate
           steps are stored on disk. By default only the last step is
           kept, and only if the geometry optimization converged. This
           can easily lead to huge amounts of data being stored on
           disk, but it can sometimes be convenient to closely monitor
           a tricky optimization, e.g. excited state optimizations
           going through conical intersections, etc. ...

         * **MaxIterations** (*int** | **IntKey*) -- The maximum
           number of geometry iterations allowed to converge to the
           desired structure.

         * **MaxRestarts** (*int** | **IntKey*) -- If a geometry
           optimization of a system with no symmetry operators (or
           with explicitly disabled symmetry: "UseSymmetry False") and
           enabled PES point characterization converges to a
           transition state (or higher order saddle point), it can be
           restarted automatically after a small displacement along
           the imaginary vibrational mode. In case the restarted
           optimization again does not find a minimum, this can happen
           multiple times in succession. This keyword sets the maximum
           number of restarts. The default value is 0, so the
           automatic restarting is disabled by default.

         * **Method** (*Literal**[**"Auto"**, **"Quasi-Newton"**,
           **"FIRE"**, **"L-BFGS"**, **"ConjugateGradients"**,
           **"Dimer"**]*) --

           Select the optimization algorithm employed for the geometry
           relaxation. Currently supported are:

           the Hessian-based Quasi-Newton-type BFGS algorithm,

           the fast inertial relaxation method (FIRE),

           the limited-memory BFGS method,

           and the conjugate gradients method. The default is to
           choose an appropriate method automatically based on the
           engine's speed, the system size and the supported
           optimization options.

         * **OptimizeLattice** (*BoolType** | **BoolKey*) -- Whether
           to also optimize the lattice for periodic structures. This
           is currently supported with the Quasi-Newton, FIRE, and
           L-BFGS optimizers.

         * **PretendConverged** (*BoolType** | **BoolKey*) -- Normally
           a non-converged geometry optimization is considered an
           error. If this keyword is set to True, the optimizer will
           only produce a warning and still claim that the
           optimization is converged. (This is mostly useful for
           scripting applications, where one might want to consider
           non-converged optimizations still successful jobs.)

         * **RestartDisplacement** (*float** | **FloatKey*) -- If a
           geometry optimization of a system with no symmetry
           operators (or with explicitly disabled symmetry:
           "UseSymmetry False") and enabled PES point characterization
           converges to a transition state (or higher order saddle
           point), it can be restarted automatically after a small
           displacement along the imaginary vibrational mode. This
           keywords sets the size of the displacement for the furthest
           moving atom.

         * **Convergence**
           (*AMSBatch._GeometryOptimization._Convergence*) --
           Convergence is monitored for up to 4 quantities: the energy
           change, the Cartesian gradients, the Cartesian step size,
           and for lattice optimizations the stress energy per atom.
           Convergence criteria can be specified separately for each
           of these items.

         * **Dimer** (*AMSBatch._GeometryOptimization._Dimer*) --
           Options for the Dimer method for transition state search.

         * **EngineAutomations**
           (*AMSBatch._GeometryOptimization._EngineAutomations*) --
           The optimizer can change some settings of the engine, based
           for instance on the error. The idea is to allow the engine
           to be a bit quicker at the start, and more accurate towards
           the end. Automations are always engine specific.

         * **FIRE** (*AMSBatch._GeometryOptimization._FIRE*) -- This
           block configures the details of the FIRE optimizer. The
           keywords name correspond the the symbols used in the
           article describing the method, see PRL 97, 170201 (2006).

         * **HessianFree**
           (*AMSBatch._GeometryOptimization._HessianFree*) --
           Configures details of the Hessian-free (conjugate gradients
           or L-BFGS) geometry optimizer.

         * **InitialHessian**
           (*AMSBatch._GeometryOptimization._InitialHessian*) --
           Options for initial model Hessian when optimizing systems
           with the Quasi-Newton method.

         * **Quasi-Newton** (*AMSBatch._GeometryOptimization._Quasi-
           Newton*) -- Configures details of the Quasi-Newton geometry
           optimizer.

      class _Convergence

         Convergence is monitored for up to 4 quantities: the energy
         change, the Cartesian gradients, the Cartesian step size, and
         for lattice optimizations the stress energy per atom.
         Convergence criteria can be specified separately for each of
         these items.

         Variables:
            * **Energy** (*float** | **FloatKey*) -- The criterion for
              changes in the energy. The energy is considered
              converged when the change in energy is smaller than this
              threshold times the number of atoms.

            * **Gradients** (*float** | **FloatKey*) -- Threshold for
              nuclear gradients.

            * **Quality** (*Literal**[**"VeryBasic"**, **"Basic"**,
              **"Normal"**, **"Good"**, **"VeryGood"**,
              **"Excellent"**, **"Custom"**]*) -- A quick way to
              change convergence thresholds: 'Good' will reduce all
              thresholds by an order of magnitude from their default
              value. 'VeryGood' will tighten them by two orders of
              magnitude. 'Basic' and 'VeryBasic' will increase the
              thresholds by one or two orders of magnitude
              respectively.

            * **Step** (*float** | **FloatKey*) -- The maximum
              Cartesian step allowed for a converged geometry.

            * **StressEnergyPerAtom** (*float** | **FloatKey*) --
              Threshold used when optimizing the lattice vectors. The
              stress is considered 'converged' when the maximum value
              of stress_tensor * cell_volume / number_of_atoms is
              smaller than this threshold (for 2D and 1D systems, the
              cell_volume is replaced by the cell_area and cell_length
              respectively).

      class _Dimer

         Options for the Dimer method for transition state search.

         Variables:
            * **AngleThreshold** (*float** | **FloatKey*) -- The
              rotation is considered converged when the the rotation
              angle falls below the specified threshold.

            * **DimerDelta** (*float** | **FloatKey*) -- Euclidian
              distance between the midpoint and the endpoint.

            * **ExtrapolateForces** (*BoolType** | **BoolKey*) -- Set
              to false to call engine to calculate forces at the
              extrapolated rotation angle instead of extrapolating
              them.

            * **LBFGSMaxVectors** (*int** | **IntKey*) -- Max number
              of vectors for the L-BFGS algorithm to save.

            * **MaxRotationIterations** (*int** | **IntKey*) --
              Maximum number of rotation iterations for a single
              translation step.

            * **Region** (*str** | **StringKey*) -- Include only atoms
              of the specified region(s) in the rotations, which
              allows searching for a transition state involving
              selected atoms only.

            * **RotationTrustRadius** (*float** | **FloatKey*) --
              L-BFGS trust radius during rotation iterations.

            * **TranslationTrustRadius** (*float** | **FloatKey*) --
              L-BFGS trust radius during translation iterations.

      class _EngineAutomations

         The optimizer can change some settings of the engine, based
         for instance on the error. The idea is to allow the engine to
         be a bit quicker at the start, and more accurate towards the
         end. Automations are always engine specific.

         Variables:
            * **Enabled** (*BoolType** | **BoolKey*) -- Whether or not
              automations are enabled at all.

            * **Gradient** (*AMSBatch._GeometryOptimization._EngineAu
              tomations._Gradient*) -- A gradient-based automation.

            * **Iteration** (*AMSBatch._GeometryOptimization._EngineA
              utomations._Iteration*) -- Geometry step based
              automation.

         class _Gradient

            A gradient-based automation.

            Variables:
               * **FinalValue** (*float** | **FloatKey*) -- This value
                 will be used whenever the gradient is less than
                 GradientLow

               * **HighGradient** (*float** | **FloatKey*) -- Defines
                 a large gradient. When the actual gradient is between
                 GradientHigh and GradientLow a linear interpolation
                 scheme is used for kT (on a log scale).

               * **InitialValue** (*float** | **FloatKey*) -- This
                 value will be used at the first geometry, and
                 whenever the gradient is higher than GradientHigh

               * **LowGradient** (*float** | **FloatKey*) -- Defines a
                 small gradient, see GradientHigh

               * **UseLogInterpolation** (*BoolType** | **BoolKey*) --
                 Whether to use interpolation on a log (y) scale or
                 not

               * **Variable** (*str** | **StringKey*) -- variable to
                 be tweaked for the engine.

         class _Iteration

            Geometry step based automation.

            Variables:
               * **FinalValue** (*float** | **FloatKey*) --

               * **FirstIteration** (*int** | **IntKey*) -- When the
                 actual gradient is between the first and last
                 iteration, a linear interpolation is used.

               * **InitialValue** (*float** | **FloatKey*) -- This
                 value will be used when the iteration number is
                 smaller or equal to FirstIteration

               * **LastIteration** (*int** | **IntKey*) -- Where the
                 automation should reach the FinalValue

               * **UseLogInterpolation** (*BoolType** | **BoolKey*) --
                 Whether to use interpolation on a log (y) scale or
                 not

               * **Variable** (*str** | **StringKey*) -- variable to
                 be tweaked for the engine.

      class _FIRE

         This block configures the details of the FIRE optimizer. The
         keywords name correspond the the symbols used in the article
         describing the method, see PRL 97, 170201 (2006).

         Variables:
            * **AllowOverallRotation** (*BoolType** | **BoolKey*) --
              Whether or not the system is allowed to freely rotate
              during the optimization. This is relevant when
              optimizing structures in the presence of external
              fields.

            * **AllowOverallTranslation** (*BoolType** | **BoolKey*)
              -- Whether or not the system is allowed to translate
              during the optimization. This is relevant when
              optimizing structures in the presence of external
              fields.

            * **MapAtomsToUnitCell** (*BoolType** | **BoolKey*) -- Map
              the atoms to the central cell at each geometry step.

            * **NMin** (*int** | **IntKey*) -- Number of steps after
              stopping before increasing the time step again.

            * **alphaStart** (*float** | **FloatKey*) -- Steering
              coefficient.

            * **atomMass** (*float** | **FloatKey*) -- Fictitious
              atomic mass used for all atoms. There is no reason to
              change this, as it just corresponds to using a different
              integration timestep.

            * **dtMax** (*float** | **FloatKey*) -- Maximum time step
              used for the integration. For ReaxFF and APPLE&P, this
              value is reduced by 50%.

            * **dtStart** (*float** | **FloatKey*) -- Initial time
              step for the integration.

            * **fAlpha** (*float** | **FloatKey*) -- Reduction factor
              for the steering coefficient.

            * **fDec** (*float** | **FloatKey*) -- Reduction factor
              for reducing the time step in case of uphill movement.

            * **fInc** (*float** | **FloatKey*) -- Growth factor for
              the integration time step.

            * **strainMass** (*float** | **FloatKey*) -- Fictitious
              relative mass of the lattice degrees of freedom. This
              controls the stiffness of the lattice degrees of freedom
              relative to the atomic degrees of freedom, with smaller
              values resulting in a more aggressive optimization of
              the lattice.

      class _HessianFree

         Configures details of the Hessian-free (conjugate gradients
         or L-BFGS) geometry optimizer.

         Variables:
            **Step**
            (*AMSBatch._GeometryOptimization._HessianFree._Step*) --

         class _Step

            Variables:
               * **MaxCartesianStep** (*float** | **FloatKey*) --
                 Limit on a single Cartesian component of the step.

               * **MinRadius** (*float** | **FloatKey*) -- Minimum
                 value for the trust radius.

               * **TrialStep** (*float** | **FloatKey*) -- Length of
                 the finite-difference step when determining
                 curvature. Should be smaller than the step
                 convergence criterion.

               * **TrustRadius** (*float** | **FloatKey*) -- Initial
                 value of the trust radius.

      class _InitialHessian

         Options for initial model Hessian when optimizing systems
         with the Quasi-Newton method.

         Variables:
            * **File** (*str** | **Path** | **StringKey*) -- KF file
              containing the initial Hessian (or the results dir.
              containing it). This can be used to load a Hessian
              calculated in a previously with the [Properties%Hessian]
              keyword.

            * **Type** (*Literal**[**"Auto"**, **"UnitMatrix"**,
              **"Swart"**, **"FromFile"**, **"Calculate"**,
              **"CalculateWithFastEngine"**]*) -- Select the type of
              initial Hessian. Auto: let the program pick an initial
              model Hessian. UnitMatrix: simplest initial model
              Hessian, just a unit matrix in the optimization
              coordinates. Swart: model Hessian from M. Swart.
              FromFile: load the Hessian from the results of a
              previous calculation (see InitialHessian%File).
              Calculate: compute the initial Hessian (this may be
              computationally expensive and it is mostly recommended
              for TransitionStateSearch calculations).
              CalculateWithFastEngine: compute the initial Hessian
              with a faster engine.

      class _Quasi_Newton

         Configures details of the Quasi-Newton geometry optimizer.

         Variables:
            * **EnforceConstraints** (*BoolType** | **BoolKey*) --
              Whether to enforce constraints at each steps exactly or
              add them to the optimization space as Lagrange
              multipliers.

            * **MaxGDIISVectors** (*int** | **IntKey*) -- Sets the
              maximum number of GDIIS vectors. Setting this to a
              number >0 enables the GDIIS method.

            * **UpdateTSVectorEveryStep** (*BoolType** | **BoolKey*)
              -- Whether to update the TS reaction coordinate at each
              step with the current eigenvector.

            * **Step** (*AMSBatch._GeometryOptimization._Quasi-
              Newton._Step*) --

         class _Step

            Variables:
               * **TrustRadius** (*float** | **FloatKey*) -- Initial
                 value of the trust radius.

               * **VaryTrustRadius** (*BoolType** | **BoolKey*) --
                 Whether to allow the trust radius to change during
                 optimization. By default True during energy
                 minimization and False during transition state
                 search.

   class _IEEEExceptions

      Whether this works or not depends on the way the program is
      compiled (compiler and settings). Only useful for developers
      debugging some numerical issue.

      Variables:
         * **All** (*BoolType** | **BoolKey*) -- Activates all
           IEEEExceptions known to ams, see list below. The
           corresponding environment variable is
           SCM_IEEEException_All.

         * **DivideByZero** (*BoolType** | **BoolKey*) -- Stop program
           when a divide by zero exception occurs. The corresponding
           environment variable is SCM_IEEEException_DivideByZero.

         * **Invalid** (*BoolType** | **BoolKey*) -- Stop program when
           an invalid exception occurs. This may be about sqrt(-1).,
           or 0/0, and generally leads to a NaN. The corresponding
           environment variable is SCM_IEEEException_Invalid.

         * **Overflow** (*BoolType** | **BoolKey*) -- Stop program
           when an overflow exception occurs. The corresponding
           environment variable is SCM_IEEEException_Overflow

         * **Print** (*BoolType** | **BoolKey*) -- Print feedback on
           activated IEEEExceptions in the logfile. The corresponding
           environment variable is SCM_IEEEException_Print.

   class _IRC

      Configures details of the Intrinsic Reaction Coordinate
      optimization.

      Variables:
         * **CoordinateType** (*Literal**[**"Cartesian"**,
           **"Delocalized"**]*) -- Select the type of coordinates in
           which to perform the optimization. Note that the
           Delocalized option should be considered experimental.

         * **Direction** (*Literal**[**"Both"**, **"Forward"**,
           **"Backward"**]*) -- Select direction of the IRC path. The
           difference between the Forward and the Backward directions
           is determined by the sign of the largest component of the
           vibrational normal mode corresponding to the reaction
           coordinate at the transition state geometry. The Forward
           path correspond to the positive sign of the component. If
           Both is selected then first the Forward path is computed
           followed by the Backward one.

         * **KeepConvergedResults** (*BoolType** | **BoolKey*) -- Keep
           the binary RKF result file for every converged IRC point.
           These files may contain more information than the main
           ams.rkf result file.

         * **MaxIRCSteps** (*int** | **IntKey*) -- Soft limit on the
           number of IRC points to compute in each direction. After
           the specified number of IRC steps the program will switch
           to energy minimization and complete the path. This option
           should be used when you are interested only in the reaction
           path area near the transition state. Note that even if the
           soft limit has been hit and the calculation has completed,
           the IRC can still be restarted with a 'RedoBackward' or
           'RedoForward' option.

         * **MaxIterations** (*int** | **IntKey*) -- The maximum
           number of geometry iterations allowed to converge the inner
           IRC loop. If optimization does not converge within the
           specified number of steps, the calculation is aborted.

         * **MaxPoints** (*int** | **IntKey*) -- Hard limit on the
           number of IRC points to compute in each direction. After
           the specified number of IRC steps the program will stop
           with the current direction and switch to the next one. If
           both 'MaxPoints' and 'MaxIRCSteps' are set to the same
           value then 'MaxPoints' takes precedence, therefore this
           option should be used to set a limit on the number of IRC
           steps if you intend to use the results later for a restart.

         * **MinEnergyProfile** (*BoolType** | **BoolKey*) --
           Calculate minimum energy profile (i.e. no mass-weighting)
           instead of the IRC.

         * **MinPathLength** (*float** | **FloatKey*) -- Minimum
           length of the path required before switching to energy
           minimization. Use this to overcome a small kink or a
           shoulder on the path.

         * **Step** (*float** | **FloatKey*) -- IRC step size in mass-
           weighted coordinates, sqrt(amu)*bohr. One may have to
           increase this value when heavy atoms are involved in the
           reaction, or decrease it if the reactant or products are
           very close to the transition state.

         * **Convergence** (*AMSBatch._IRC._Convergence*) --
           Convergence at each given point is monitored for two items:
           the Cartesian gradient and the calculated step size.
           Convergence criteria can be specified separately for each
           of these items. The same criteria are used both in the
           inner IRC loop and when performing energy minimization at
           the path ends.

         * **InitialHessian** (*AMSBatch._IRC._InitialHessian*) --
           Options for initial Hessian at the transition state. The
           first eigenvalue of the initial Hessian defines direction
           of the first forward or backward step. This block is
           ignored when restarting from a previous IRC calculation
           because the initial Hessian found in the restart file is
           used.

         * **Restart** (*AMSBatch._IRC._Restart*) -- Restart options.
           Upon restart, the information about the IRC input
           parameters and the initial system (atomic coordinates,
           lattice, charge, etc.) is read from the restart file. The
           IRC input parameters can be modified from input. Except for
           'MaxPoints' and 'Direction' all parameters not specified in
           the input will use their values from the restart file. The
           'MaxPoints' and 'Direction' will be reset to their
           respective default values if not specified in the input. By
           default, the IRC calculation will continue from the point
           where it left off. However, the 'RedoForward' and/or
           'RedoBackward' option can be used to enforce recalculation
           of a part of the reaction path, for example, using a
           different 'Step' value.

      class _Convergence

         Convergence at each given point is monitored for two items:
         the Cartesian gradient and the calculated step size.
         Convergence criteria can be specified separately for each of
         these items. The same criteria are used both in the inner IRC
         loop and when performing energy minimization at the path
         ends.

         Variables:
            * **Gradients** (*float** | **FloatKey*) -- Convergence
              criterion for the max component of the residual energy
              gradient.

            * **Step** (*float** | **FloatKey*) -- Convergence
              criterion for the max component of the step in the
              optimization coordinates.

      class _InitialHessian

         Options for initial Hessian at the transition state. The
         first eigenvalue of the initial Hessian defines direction of
         the first forward or backward step. This block is ignored
         when restarting from a previous IRC calculation because the
         initial Hessian found in the restart file is used.

         Variables:
            * **File** (*str** | **Path** | **StringKey*) -- If 'Type'
              is set to 'FromFile' then in this key you should specify
              the RKF file containing the initial Hessian (or the ams
              results dir. containing it). This can be used to load a
              Hessian calculated previously with the
              'Properties%Hessian' keyword. If you want to also use
              this file for the initial geometry then also specify it
              in a 'LoadSystem' block.

            * **Type** (*Literal**[**"Calculate"**, **"FromFile"**]*)
              -- Calculate the exact Hessian for the input geometry or
              load it from the results of a previous calculation.

      class _Restart

         Restart options. Upon restart, the information about the IRC
         input parameters and the initial system (atomic coordinates,
         lattice, charge, etc.) is read from the restart file. The IRC
         input parameters can be modified from input. Except for
         'MaxPoints' and 'Direction' all parameters not specified in
         the input will use their values from the restart file. The
         'MaxPoints' and 'Direction' will be reset to their respective
         default values if not specified in the input. By default, the
         IRC calculation will continue from the point where it left
         off. However, the 'RedoForward' and/or 'RedoBackward' option
         can be used to enforce recalculation of a part of the
         reaction path, for example, using a different 'Step' value.

         Variables:
            * **File** (*str** | **Path** | **StringKey*) -- Name of
              an RKF restart file generated by a previous IRC
              calculation. Do not use this key to provide an RKF file
              generated by a TransitionStateSearch or a SinglePoint
              calculation, use the 'LoadSystem' block instead.

            * **RedoBackward** (*int** | **IntKey*) -- IRC step number
              to start recalculating the backward path from. By
              default, if the backward path has not been completed
              then start after the last completed step. If the
              backward path has been completed and the 'RedoBackward'
              is omitted then no point on the backward path will be
              recomputed.

            * **RedoForward** (*int** | **IntKey*) -- IRC step number
              to start recalculating the forward path from. By
              default, if the forward path has not been completed then
              start after the last completed step. If the forward path
              has been completed and the 'RedoForward' is omitted then
              no point on the forward path will be recomputed.

   class _Idle

      Configures details of the idle task, which does nothing for a
      specified amount of time.

      Variables:
         **Time** (*int** | **IntKey*) -- Controls how long AMS will
         be idle before exiting.

   class _LoadSystem

      Block that controls reading the chemical system from a KF file
      instead of the [System] block.

      Variables:
         * **File** (*str** | **Path** | **StringKey*) -- The path of
           the KF file from which to load the system. It may also be
           the results directory containing it.

         * **Section** (*str** | **StringKey*) -- The section on the
           KF file from which to load the system.

   class _Log

      Configures the debugging loggers. Syntax: 'Level LoggerName'.
      Possible Levels: All, Debug, Info, Warning, Error, Fatal.

   class _MolecularDynamics

      Configures molecular dynamics (with the velocity-Verlet
      algorithm) with and without thermostats. This block allows to
      specify the details of the molecular dynamics calculation.

      Variables:
         * **CalcPressure** (*BoolType** | **BoolKey*) --

           Calculate the pressure in periodic systems.

           This may be computationally expensive for some engines that
           require numerical differentiation.

           Some other engines can calculate the pressure for
           negligible additional cost and will always do so, even if
           this option is disabled.

         * **CopyRestartTrajectory** (*BoolType** | **BoolKey*) -- If
           the keyword Restart is present, the content of the
           restartfile is copied to the ams.rkf file.

         * **NSteps** (*int** | **IntKey*) -- The number of steps to
           be taken in the MD simulation.

         * **Restart** (*str** | **Path** | **StringKey*) -- The path
           to the ams.rkf file from which to restart the simulation.

         * **TimeStep** (*float** | **FloatKey*) -- The time
           difference per step.

         * **AddMolecules**
           (*AMSBatch._MolecularDynamics._AddMolecules*) --

           This block controls adding molecules to the system (a.k.a.
           the Molecule Gun). Multiple occurrences of this block are
           possible.

           By default, molecules are added at random positions in the
           simulation box with velocity matching the current system
           temperature. The initial position can be modified using one
           of the following keywords: Coords, CoordsBox,
           FractionalCoords, FractionalCoordsBox. The Coords and
           FractionalCoords keys can optionally be accompanied by
           CoordsSigma or FractionalCoordsSigma, respectively.

         * **ApplyForce** (*AMSBatch._MolecularDynamics._ApplyForce*)
           -- The ApplyForce keyword can be used to apply an arbitrary
           constant force to a certain (subgroups of) atoms in the
           system

         * **ApplyVelocity**
           (*AMSBatch._MolecularDynamics._ApplyVelocity*) -- The
           ApplyVelocity keyword can be used to move an arbitrary
           group of atoms in the system with a constant net velocity

         * **Barostat** (*AMSBatch._MolecularDynamics._Barostat*) --
           This block allows to specify the use of a barostat during
           the simulation.

         * **BinLog** (*AMSBatch._MolecularDynamics._BinLog*) -- This
           block controls writing the BinLog section in ams.rkf, which
           contains the selected MD state scalars and tensors from
           every MD step. No per-atom data is written. If you need the
           per-atom data then you can set the sampling frequency to 1
           and get the required data from the MDHistory section. The
           tensors are written per component, that is, the pressure
           tensor is written as six variables: PressureTensor_xx,
           PressureTensor_yy, etc.. To reduce the file size, all data
           is written in blocks.

         * **BondBoost** (*AMSBatch._MolecularDynamics._BondBoost*) --
           Forced reaction (bond boost) definitions. Multiple
           BondBoost blocks may be specified, which will be treated
           independently.

         * **CRESTMTD** (*AMSBatch._MolecularDynamics._CRESTMTD*) --
           Input for CREST metadynamics simulation.

         * **CVHD** (*AMSBatch._MolecularDynamics._CVHD*) -- Input for
           the Collective Variable-driven HyperDynamics (CVHD).

         * **CheckTemperature**
           (*AMSBatch._MolecularDynamics._CheckTemperature*) -- Check
           at every time step if the temperature has exceeded a
           threshold. If it has, it is assumed the system exploded,
           and the simulation will stop.

         * **Checkpoint** (*AMSBatch._MolecularDynamics._Checkpoint*)
           -- Sets the frequency for storing the entire MD state
           necessary for restarting the calculation.

         * **CosineShear**
           (*AMSBatch._MolecularDynamics._CosineShear*) -- Apply an
           external acceleration to all atoms of a fluid using a
           periodic (cosine) function along a selected coordinate
           axis. This induces a periodic shear flow profile which can
           be used to determine the viscosity.

         * **Deformation**
           (*AMSBatch._MolecularDynamics._Deformation*) -- Deform the
           periodic lattice of the system during the simulation.

         * **Gravity** (*AMSBatch._MolecularDynamics._Gravity*) --
           Apply a constant acceleration in -z.

         * **HeatExchange**
           (*AMSBatch._MolecularDynamics._HeatExchange*) -- Input for
           the heat-exchange non-equilibrium MD (T-NEMD).

         * **InitialVelocities**
           (*AMSBatch._MolecularDynamics._InitialVelocities*) -- Sets
           the frequency for printing to stdout and storing the
           molecular configuration on the .rkf file.

         * **MovingRestraints**
           (*AMSBatch._MolecularDynamics._MovingRestraints*) -- Define
           a set of moving restraints.

         * **PRD** (*AMSBatch._MolecularDynamics._PRD*) -- This block
           is used for Parallel Replica Dynamics simulations.

         * **Plumed** (*AMSBatch._MolecularDynamics._Plumed*) -- Input
           for PLUMED (version 2.5.0). The parallel option is still
           experimental.

         * **Preserve** (*AMSBatch._MolecularDynamics._Preserve*) --
           Periodically remove numerical drift accumulated during the
           simulation to preserve different whole-system parameters.

         * **Print** (*AMSBatch._MolecularDynamics._Print*) -- This
           block controls the printing of additional information to
           stdout.

         * **ReactionBoost**
           (*AMSBatch._MolecularDynamics._ReactionBoost*) --

           Define a series of transitions between different states of
           the system.

           Each transition is defined by a TargetSystem and by a set
           of restraints that force the transition.

         * **Reactor** (*AMSBatch._MolecularDynamics._Reactor*) --
           Define one phase of the nanoreactor. A reactor is a region
           of space surrounded by an elastic wall. Atoms inside the
           region are not affected. Atoms outside it will be pushed
           back with force depending on the [ForceConstant] and the
           [MassScaled] flag.

         * **ReflectiveWall**
           (*AMSBatch._MolecularDynamics._ReflectiveWall*) -- Apply a
           reflective wall in space

         * **Remap** (*AMSBatch._MolecularDynamics._Remap*) -- Control
           periodic remapping (backtranslation) of atoms into the PBC
           box.

         * **RemoveMolecules**
           (*AMSBatch._MolecularDynamics._RemoveMolecules*) -- This
           block controls removal of molecules from the system.
           Multiple occurrences of this block are possible.

         * **ReplicaExchange**
           (*AMSBatch._MolecularDynamics._ReplicaExchange*) -- This
           block is used for (temperature) Replica Exchange MD
           (Parallel Tempering) simulations.

         * **Shake** (*AMSBatch._MolecularDynamics._Shake*) --
           Parameters of the Shake/Rattle algorithm.

         * **Thermostat** (*AMSBatch._MolecularDynamics._Thermostat*)
           -- This block allows to specify the use of a thermostat
           during the simulation. Depending on the selected thermostat
           type, different additional options may be needed to
           characterize the specific thermostat's behavior.

         * **Trajectory** (*AMSBatch._MolecularDynamics._Trajectory*)
           -- Sets the frequency for printing to stdout and storing
           the molecular configuration on the .rkf file.

         * **fbMC** (*AMSBatch._MolecularDynamics._fbMC*) -- This
           block sets up force bias Monte Carlo interleaved with the
           molecular dynamics simulation.

      class _AddMolecules

         This block controls adding molecules to the system (a.k.a.
         the Molecule Gun). Multiple occurrences of this block are
         possible.

         By default, molecules are added at random positions in the
         simulation box with velocity matching the current system
         temperature. The initial position can be modified using one
         of the following keywords: Coords, CoordsBox,
         FractionalCoords, FractionalCoordsBox. The Coords and
         FractionalCoords keys can optionally be accompanied by
         CoordsSigma or FractionalCoordsSigma, respectively.

         Variables:
            * **AtomTemperature** (*float** | **FloatKey*) -- Add
              random velocity corresponding to the specified
              temperature to individual atoms of the molecule. This
              only affects rotational and internal degrees of freedom,
              not the net translational velocity of the inserted
              molecule as set by the other options.

            * **ContactDistance** (*float** | **FloatKey*) --
              Translate the bullet along the velocity vector until it
              comes within ContactDistance of any other atom.

            * **Coords** (*Iterable**[**float**] **| **FloatListKey*)
              --

              Place molecules at or around the specified Cartesian
              coordinates.

              This setting takes precedence over other ways to specify
              initial coordinates of the molecule: [CoordsBox],
              [FractionalCoords], and [FractionalCoordsBox].

            * **CoordsBox** (*Iterable**[**float**] **|
              **FloatListKey*) --

              Place molecules at random locations inside the specified
              box in Cartesian coordinates.

              Coordinates of the box corners are specified as: Xmin,
              Xmax, Ymin, Ymax, Zmin, Zmax. This setting is ignored if
              Coords is used.

              In AMSinput, if this field is not empty it will be used
              instead of the default Coords.

            * **CoordsSigma** (*Iterable**[**float**] **|
              **FloatListKey*) -- Sigma values (one per Cartesian
              axis) for a Gauss distribution of the initial
              coordinates. Can only be used together with Coords.

            * **DeviationAngle** (*float** | **FloatKey*) -- Randomly
              tilt the shooting direction up to this angle away from
              the VelocityDirection vector.

            * **Energy** (*float** | **FloatKey*) -- Initial kinetic
              energy of the molecule in the shooting direction.

            * **EnergySigma** (*float** | **FloatKey*) -- Sigma value
              for the Gauss distribution of the initial kinetic energy
              around the specified value. Should only be used together
              with Energy.

            * **FractionalCoords** (*Iterable**[**float**] **|
              **FloatListKey*) -- Place molecules at or around the
              specified fractional coordinates in the main system's
              lattice. For non-periodic dimensions a Cartesian value
              in Angstrom is expected. This setting is ignored if
              [Coords] or [CoordsBox] is used.

            * **FractionalCoordsBox** (*Iterable**[**float**] **|
              **FloatListKey*) --

              Place molecules at random locations inside the box
              specified as fractional coordinates in the main system's
              lattice.

              Coordinates of the box corners are specified as: Xmin,
              Xmax, Ymin, Ymax, Zmin, Zmax.

              For non-periodic dimensions the Cartesian value in
              Angstrom is expected.

              This setting is ignored if [Coords], [CoordsBox], or
              [FractionalCoords] is used.

            * **FractionalCoordsSigma** (*Iterable**[**float**] **|
              **FloatListKey*) -- Sigma values (one per axis) for a
              Gauss distribution of the initial coordinates. For non-
              periodic dimensions the Cartesian value in Angstrom is
              expected. Can only be used together with
              FractionalCoords.

            * **Frequency** (*int** | **IntKey*) --

              A molecule is added every [Frequency] steps after the
              StartStep.

              There is never a molecule added at step 0.

            * **MinDistance** (*float** | **FloatKey*) -- Keep the
              minimal distance to other atoms of the system when
              adding the molecule.

            * **MoleFraction** (*float** | **FloatKey*) --

              Defines a mixture to be deposited using one AddMolecules
              block per component.

              AMS will randomly alternate between any guns that have
              MoleFraction set. These need to all have the same
              settings for StartStep, StopStep and Frequency. Any
              additional AddMolecules blocks without MoleFraction will
              remain completely independent.

            * **NumAttempts** (*int** | **IntKey*) -- Try adding the
              molecule up to the specified number of times or until
              the MinDistance constraint is satisfied. If all attempts
              fail a message will be printed and the simulation will
              continue normally.

            * **Rotate** (*BoolType** | **BoolKey*) -- Rotate the
              molecule randomly before adding it to the system.

            * **StartStep** (*int** | **IntKey*) --

              Step number when the first molecule should be added.
              After that, molecules are added every Frequency steps.

              For example, ff StartStep=99 and Frequency=100 then a
              molecule will be added at steps 99, 199, 299, etc...

              No molecule will be added at step 0, so if StartStep=0
              the first molecule is added at the step number equal to
              [Frequency].

            * **StopStep** (*int** | **IntKey*) -- Do not add this
              molecule after the specified step.

            * **System** (*str** | **StringKey*) --

              String ID of the [System] that will be added with this
              'gun'.

              The lattice specified with this System is ignored and
              the main system's lattice is used instead.

              AMSinput adds the system at the coordinates of the
              System (thus setting Coords to the center of the
              System).

            * **Temperature** (*float** | **FloatKey*) -- Initial
              energy of the molecule in the shooting direction will
              correspond to the given temperature.

            * **TemperatureSigma** (*float** | **FloatKey*) -- Sigma
              value for the Gauss distribution of the initial
              temperature the specified value. Should only be used
              together with Temperature.

            * **Velocity** (*float** | **FloatKey*) -- Initial
              velocity of the molecule in the shooting direction.

            * **VelocityDirection** (*Iterable**[**float**] **|
              **FloatListKey*) --

              Velocity direction vector for aimed shooting. It will be
              random if not specified.

              In AMSinput add one or two atoms (which may be dummies).

              One atom: use vector from center of the system to add to
              that atom.

              Two atoms: use vector from the first to the second atom.

            * **VelocitySigma** (*float** | **FloatKey*) -- Sigma
              value for the Gauss distribution of the initial velocity
              around the specified value. Should only be used together
              with Velocity.

      class _ApplyForce

         The ApplyForce keyword can be used to apply an arbitrary
         constant force to a certain (subgroups of) atoms in the
         system

         Variables:
            * **CalculateViscosity** (*BoolType** | **BoolKey*) --
              Calculates Viscosity property yes/no. If yes is chosen,
              the global viscosity of the system is calculated and
              written into the RKF-file. The formula used for the
              viscosity calculation is eta = - Pxz / (dVx/dz)

            * **CalculateViscosityBins** (*int** | **IntKey*) --
              Amount of bins used to determine (dVx/dz)

            * **CalculateViscosityEnd** (*int** | **IntKey*) -- end
              index to select region in space to calculate (dVx/dz)

            * **CalculateViscosityStart** (*int** | **IntKey*) --
              Start index to select region in space to calculate
              (dVx/dz)

            * **Force** (*Iterable**[**float**] **| **FloatListKey*)
              -- Defines the constant force vector

            * **PerAtom** (*BoolType** | **BoolKey*) -- If enabled,
              the Force vector is applied separately to every atom in
              the selected Region, so that the total net force on the
              Region equals the value of Force times the number of
              atoms in Region. This was the behavior of ApplyForce in
              AMS2022. By default, with PerAtom disabled, the Force
              vector defines the total net force on the Region, so the
              force applied to each atom equals the value of Force
              divided by the number of atoms in Region.

            * **Region** (*str** | **StringKey*) -- Apply the constant
              force to all atoms in this region.

      class _ApplyVelocity

         The ApplyVelocity keyword can be used to move an arbitrary
         group of atoms in the system with a constant net velocity

         Variables:
            * **CalculateViscosity** (*BoolType** | **BoolKey*) --
              Calculates Viscosity property yes/no. If yes is chosen,
              the global viscosity of the system is calculated and
              written into the RKF-file. The formula used for the
              viscosity calculation is eta = - Pxz / (dVx/dz)

            * **CalculateViscosityBins** (*int** | **IntKey*) --
              Amount of bins used to determine (dVx/dz)

            * **CalculateViscosityEnd** (*int** | **IntKey*) -- end
              index to select region in space to calculate (dVx/dz)

            * **CalculateViscosityStart** (*int** | **IntKey*) --
              Start index to select region in space to calculate
              (dVx/dz)

            * **Components** (*Literal**[**"X"**, **"Y"**, **"Z"**,
              **"XY"**, **"YZ"**, **"XZ"**, **"XYZ"**]*) -- Select
              which components of the Velocity vector are used to set
              the corresponding components of the net velocity of the
              specified set of atoms. Any other components of Velocity
              are ignored and the motion of the selected atoms in
              those directions is unaffected by ApplyVelocity.

            * **Region** (*str** | **StringKey*) -- Applies the
              defined velocity to all atoms in this region.

            * **Velocity** (*Iterable**[**float**] **|
              **FloatListKey*) -- The constant velocity that will be
              applied to the specified atoms.

      class _Barostat

         This block allows to specify the use of a barostat during the
         simulation.

         Variables:
            * **BulkModulus** (*float** | **FloatKey*) --

              An estimate of the bulk modulus (inverse
              compressibility) of the system for the Berendsen
              barostat.

              This is only used to make Tau correspond to the true
              observed relaxation time constant. Values are commonly
              on the order of 10-100 GPa (1e10 to 1e11) for solids and
              1 GPa (1e9) for liquids (2.2e9 for water). Use 1e9 to
              match the behavior of standalone ReaxFF.

            * **ConstantVolume** (*BoolType** | **BoolKey*) --

              Keep the volume constant while allowing the box shape to
              change.

              This is currently supported only by the MTK barostat.

            * **Duration** (*Iterable**[**int**] **| **IntListKey*) --
              Specifies how many steps should a transition from a
              particular pressure to the next one in sequence take.

            * **Equal** (*Literal**[**"None"**, **"XYZ"**, **"XY"**,
              **"YZ"**, **"XZ"**]*) -- Enforce equal scaling of the
              selected set of dimensions. They will be barostatted as
              one dimension according to the average pressure over the
              components.

            * **Pressure** (*Iterable**[**float**] **|
              **FloatListKey*) --

              Specifies the target pressure.

              You can specify multiple pressures (separated by
              spaces). In that case the Duration field specifies how
              many steps to use for the transition from one p to the
              next p (using a linear ramp).

            * **Scale** (*Literal**[**"XYZ"**, **"Shape"**, **"X"**,
              **"Y"**, **"Z"**, **"XY"**, **"YZ"**, **"XZ"**]*) --
              Dimensions that should be scaled by the barostat to
              maintain pressure. Selecting Shape means that all three
              dimensions and also all the cell angles are allowed to
              change.

            * **Tau** (*float** | **FloatKey*) -- Specifies the time
              constant of the barostat.

            * **Type** (*Literal**[**"None"**, **"Berendsen"**,
              **"MTK"**]*) -- Selects the type of the barostat.

      class _BinLog

         This block controls writing the BinLog section in ams.rkf,
         which contains the selected MD state scalars and tensors from
         every MD step. No per-atom data is written. If you need the
         per-atom data then you can set the sampling frequency to 1
         and get the required data from the MDHistory section. The
         tensors are written per component, that is, the pressure
         tensor is written as six variables: PressureTensor_xx,
         PressureTensor_yy, etc.. To reduce the file size, all data is
         written in blocks.

         Variables:
            * **BiasEnergy** (*BoolType** | **BoolKey*) -- Write the
              CVHD bias energy at every time step.

            * **BoostFactor** (*BoolType** | **BoolKey*) -- Write the
              CVHD boost factor at every time step.

            * **ConservedEnergy** (*BoolType** | **BoolKey*) -- Write
              the conserved energy value at every time step.

            * **Density** (*BoolType** | **BoolKey*) -- Write the
              density at every time step.

            * **DipoleMoment** (*BoolType** | **BoolKey*) -- Write the
              dipole moment at every time step. Each component of the
              tensor is written in its own variable.

            * **Hypertime** (*BoolType** | **BoolKey*) -- Write the
              CVHD hypertime at every time step.

            * **KineticEnergy** (*BoolType** | **BoolKey*) -- Write
              the kinetic energy value at every time step.

            * **MaxBiasEnergy** (*BoolType** | **BoolKey*) -- Write
              the max CVHD bias energy at every time step.

            * **MaxBoostFactor** (*BoolType** | **BoolKey*) -- Write
              the max CVHD boost factor at every time step.

            * **PotentialEnergy** (*BoolType** | **BoolKey*) -- Write
              the potential energy value at every time step.

            * **Pressure** (*BoolType** | **BoolKey*) -- Write the
              pressure at every time step.

            * **PressureTensor** (*BoolType** | **BoolKey*) -- Write
              the pressure tensor in Voigt notation at every time
              step. Each component of the tensor is written in its own
              variable.

            * **Step** (*BoolType** | **BoolKey*) -- Write the step
              index during the simulation at every time step.

            * **Temperature** (*BoolType** | **BoolKey*) -- Write the
              temperature at every time step.

            * **Time** (*BoolType** | **BoolKey*) -- Write the
              simulation time (fs) at every time step.

            * **TotalEnergy** (*BoolType** | **BoolKey*) -- Write the
              total energy value at every time step.

            * **Volume** (*BoolType** | **BoolKey*) -- Write the
              simulation cell volume, area or length, depending on the
              system periodicity, at every time step.

      class _BondBoost

         Forced reaction (bond boost) definitions. Multiple BondBoost
         blocks may be specified, which will be treated independently.

         Variables:
            * **AddBond** (*str** | **StringKey*) -- [Reserved] Add a
              bond to the system or change its order. Specify two atom
              indices followed by the bond's order. The indices
              indicate positions of the atoms in the AtomNames key.
              Currently no engine will honor bond changes caused by
              this key.

            * **DistanceRestraint** (*str** | **StringKey*) --

              Specify two atom indices followed by the target distance
              in Angstrom, the first parameter and, optionally, the
              profile type and the second parameter.

              For periodic systems, restraints follow the minimum
              image convention.

              Each atom index indicates a position of the
              corresponding atom in the AtomNames key. Currently
              recognized restraint profile types: Harmonic (default),
              Hyperbolic, Erf, GaussianWell. The profile name can
              optionally be prefixed by "OneSided-", thus making this
              particular restraint one-sided. A one-sided restraint
              will only push or pull the distance towards its target
              value depending on the sign of the difference between
              the initial and the target distance. For example, if the
              initial distance is larger than the target one then the
              restraint will only push the value down. This is
              especially useful with moving restraints because then
              the restraint will effectively disappear as soon as the
              system crosses a barrier along the reaction path. By
              default, the restraints are two-sided, which means they
              will try to keep the distance between the two specified
              atoms near the (possibly moving) target value. For
              moving restraints, this means that after crossing a
              reaction barrier the system will slide slowly towards
              products held back by the restraints.

              The first parameter is the force constant for the
              Harmonic, Hyperbolic, and Erf profiles, or well depth
              for GaussianWell. The second parameter is the asymptotic
              force value F(Inf) for Hyperbolic and Erf profiles, or
              the factor before x^2 in the exponent for GaussianWell.

              Note: the GaussianWell restraint should be used with the
              Moving flag.

            * **Moving** (*BoolType** | **BoolKey*) --

              Move the restraints created with this BondBoost. The
              restraint value will start at the current coordinate's
              value and will move towards the optimum during the
              restraint's lifetime. The increment is calculated from
              the initial deviation and the [NSteps] parameter.

              This feature should be used with the GaussianWell
              restraint types.

            * **NSteps** (*int** | **IntKey*) -- Number of steps the
              restraints will remain active until removed. Atoms
              participating in one reaction are not available for the
              given number of steps.

            * **NumInstances** (*int** | **IntKey*) -- Number of
              reactions of this type taking place simultaneously.

            * **RemoveBond** (*str** | **StringKey*) -- [Reserved]
              Remove a bond from the system. Specify two atom indices.
              The indices indicate positions of the atoms in the
              AtomNames key. Currently no engine will honor bond
              changes caused by this key.

            * **SetAtomName** (*str** | **StringKey*) -- Change the
              specified atom's name. Specify atom index followed by
              the new name. The index indicates position of the atom
              in the AtomNames key. Note: this action will change the
              atom name only and not other properties (element name,
              mass, etc.). This may be useful to change atom names to
              affect future chain detections. The atom name length is
              limited to 32 characters.

            * **Units** (*Literal**[**"Default"**, **"MD"**]*) --
              Change energy, force and force constant units in the
              DistanceRestraint key from the default (atomic units) to
              those often used in the MD community (based on kcal/mol
              and Angstrom). Units for the optimum distances are not
              affected.

            * **Chain**
              (*AMSBatch._MolecularDynamics._BondBoost._Chain*) --
              Specifications of a chain of atoms. When a chain is
              detected the distance restraints will be activated. No
              other chain of this type will be detected while any
              restraints for this chain is active.

         class _Chain

            Specifications of a chain of atoms. When a chain is
            detected the distance restraints will be activated. No
            other chain of this type will be detected while any
            restraints for this chain is active.

            Variables:
               * **AtomNames** (*str** | **StringKey*) -- Atom names
                 specifying the chain. An atom name can optionally be
                 followed by '@' and a region name, in this case only
                 atoms of this type from the given region will be
                 matched. A leading '@' followed by a number indicates
                 that this position in the chain must be occupied by
                 the atom found earlier at the specified position in
                 the chain. For example "O H N C @1" indicates that
                 the last atom in the chain of the five atoms must be
                 the first oxygen, thus defining a 4-membered ring.
                 This is the only way to define a ring because
                 implicit rings will not be detected. For example, "O
                 H N C O" does not include rings.

               * **MaxDistances** (*Iterable**[**float**] **|
                 **FloatListKey*) -- Maximum distances for each pair
                 of atoms in the chain. The number of distances must
                 be one less than the number of AtomNames.

               * **MinDistances** (*Iterable**[**float**] **|
                 **FloatListKey*) -- Minimum distances for each pair
                 of atoms in the chain. The number of distances must
                 be one less than the number of AtomNames.

      class _CRESTMTD

         Input for CREST metadynamics simulation.

         Variables:
            * **AddEnergy** (*BoolType** | **BoolKey*) -- Add the bias
              energy to the potential energy (to match the gradients)

            * **Height** (*float** | **FloatKey*) -- The height of the
              Gaussians added

            * **NGaussiansMax** (*int** | **IntKey*) -- Maximum number
              of Gaussians stored

            * **NSteps** (*int** | **IntKey*) -- Interval of Gaussian
              placement

            * **Region** (*str** | **StringKey*) -- Restrict the range
              of atoms for RMSD calculation to the specified region.

            * **RestartFile** (*str** | **Path** | **StringKey*) --
              Filename for file from which to read data on Gaussians
              placed previously.

            * **Width** (*float** | **FloatKey*) -- The width of the
              Gaussians added in terms of the RMSD

            * **GaussianScaling** (*AMSBatch._MolecularDynamics._CRES
              TMTD._GaussianScaling*) -- Options for gradual
              introduction of the Gaussians

         class _GaussianScaling

            Options for gradual introduction of the Gaussians

            Variables:
               * **ScaleGaussians** (*BoolType** | **BoolKey*) --
                 Introduce the Gaussians gradually, using a scaling
                 function

               * **ScalingSlope** (*float** | **FloatKey*) -- Slope of
                 the scaling function for the Gaussians with respect
                 to time

      class _CVHD

         Input for the Collective Variable-driven HyperDynamics
         (CVHD).

         Variables:
            * **Frequency** (*int** | **IntKey*) -- Frequency of
              adding a new bias peak, in steps.  New bias is deposited
              every [Frequency] steps after [StartStep] if the
              following conditions are satisfied:  the current CV
              value is less than 0.9 (to avoid creating barriers at
              the transition state),  the step number is greater than
              or equal to [StartStep], and  the step number is less
              than or equal to [StopStep].

            * **MaxEvents** (*int** | **IntKey*) -- Max number of
              events to allow during dynamics. When this number is
              reached no new bias will be added for this input block.

            * **StartStep** (*int** | **IntKey*) -- If this key is
              specified, the first bias will be deposited at this
              step. Otherwise, the first bias peak is added at the
              step number equal to the Frequency parameter. The bias
              is never deposited at step 0.

            * **StopStep** (*int** | **IntKey*) -- No bias will be
              deposited after the specified step. The already
              deposited bias will continue to be applied until the
              reaction event occurs. After that no new CVHD will be
              started. By default, the CVHD runs for the whole
              duration of the MD calculation.

            * **WaitSteps** (*int** | **IntKey*) -- If the CV value
              becomes equal to 1 and remains at this value for this
              many steps then the reaction event is considered having
              taken place. After this, the collective variable will be
              reset and the bias will be removed.

            * **Bias** (*AMSBatch._MolecularDynamics._CVHD._Bias*) --
              The bias is built from a series of Gaussian peaks
              deposited on the collective variable axis every
              [Frequency] steps during MD. Each peak is characterized
              by its (possibly damped) height and the RMS width
              (standard deviation).

            * **ColVarBB**
              (*AMSBatch._MolecularDynamics._CVHD._ColVarBB*) --
              Description of a bond-breaking collective variable (CV)
              as described in [Bal & Neyts, JCTC, 11 (2015)]. A
              collective variable may consist of multiple ColVar
              blocks.

            * **ColVarBM**
              (*AMSBatch._MolecularDynamics._CVHD._ColVarBM*) --
              Description of a bond-making collective variable (CV). A
              collective variable may consist of multiple ColVar
              blocks.

         class _Bias

            The bias is built from a series of Gaussian peaks
            deposited on the collective variable axis every
            [Frequency] steps during MD. Each peak is characterized by
            its (possibly damped) height and the RMS width (standard
            deviation).

            Variables:
               * **DampingTemp** (*float** | **FloatKey*) -- During
                 well-tempered hyperdynamics the height of the added
                 bias is scaled down with an exp(-E/kT) factor
                 [PhysRevLett 100, 020603 (2008)], where E is the
                 current value of the bias at the given CV value and T
                 is the damping temperature DampingTemp. If
                 DampingTemp is zero then no damping is applied.

               * **Delta** (*float** | **FloatKey*) -- Standard
                 deviation parameter of the Gaussian bias peak.

               * **Height** (*float** | **FloatKey*) -- Height of the
                 Gaussian bias peak.

         class _ColVarBB

            Description of a bond-breaking collective variable (CV) as
            described in [Bal & Neyts, JCTC, 11 (2015)]. A collective
            variable may consist of multiple ColVar blocks.

            Variables:
               * **cutoff** (*float** | **FloatKey*) -- Bond order
                 cutoff. Bonds with BO below this value are ignored
                 when creating the initial bond list for the CV. The
                 bond list does not change during lifetime of the
                 variable even if some bond orders drop below the
                 cutoff.

               * **p** (*int** | **IntKey*) -- Exponent value p used
                 to calculate the p-norm for this CV.

               * **rmax** (*float** | **FloatKey*) -- Max bond
                 distance parameter Rmax used for calculating the CV.
                 It should be close to the transition-state distance
                 for the corresponding bond.

               * **rmin** (*float** | **FloatKey*) -- Min bond
                 distance parameter Rmin used for calculating the CV.
                 It should be close to equilibrium distance for the
                 corresponding bond.

               * **at1**
                 (*AMSBatch._MolecularDynamics._CVHD._ColVarBB._at1*)
                 -- Specifies the first bonded atom in the collective
                 variable.

               * **at2**
                 (*AMSBatch._MolecularDynamics._CVHD._ColVarBB._at2*)
                 -- Specifies the second bonded atom in the collective
                 variable.

            class _at1

               Specifies the first bonded atom in the collective
               variable.

               Variables:
                  * **region** (*str** | **StringKey*) -- Restrict the
                    selection of bonded atoms to a specific region. If
                    this is not set, atoms anywhere in the system will
                    be selected.

                  * **symbol** (*str** | **StringKey*) -- Atom type
                    name of the first atom of the bond. The name must
                    be as it appears in the System block. That is, if
                    the atom name contains an extension (e.g C.1) then
                    the full name including the extension must be used
                    here.

            class _at2

               Specifies the second bonded atom in the collective
               variable.

               Variables:
                  * **region** (*str** | **StringKey*) -- Restrict the
                    selection of bonded atoms to a specific region. If
                    this is not set, atoms anywhere in the system will
                    be selected.

                  * **symbol** (*str** | **StringKey*) -- Atom type
                    name of the second atom of the bond. The value is
                    allowed to be the same as [at1], in which case
                    bonds between atoms of the same type will be
                    included.

         class _ColVarBM

            Description of a bond-making collective variable (CV). A
            collective variable may consist of multiple ColVar blocks.

            Variables:
               * **cutoff** (*float** | **FloatKey*) -- Bond order
                 cutoff. Bonds with BO above this value are ignored
                 when creating the initial atom-pair list for the CV.
                 The list does not change during lifetime of the
                 variable even if some bond orders rise above the
                 cutoff.

               * **p** (*int** | **IntKey*) -- Exponent value p used
                 to calculate the p-norm for this CV.

               * **rmax** (*float** | **FloatKey*) -- Max bond
                 distance parameter Rmax used for calculating the CV.
                 It should be much larger than the corresponding Rmin.

               * **rmin** (*float** | **FloatKey*) -- Min bond
                 distance parameter Rmin used for calculating the CV.
                 It should be close to the transition-state distance
                 for the corresponding bond.

               * **at1**
                 (*AMSBatch._MolecularDynamics._CVHD._ColVarBM._at1*)
                 -- Specifies selection criteria for the first atom of
                 a pair in the collective variable.

               * **at2**
                 (*AMSBatch._MolecularDynamics._CVHD._ColVarBM._at2*)
                 -- Specifies selection criteria for the second atom
                 of a pair in the collective variable.

            class _at1

               Specifies selection criteria for the first atom of a
               pair in the collective variable.

               Variables:
                  * **region** (*str** | **StringKey*) -- Restrict the
                    selection to a specific region. If this is not
                    set, atoms anywhere in the system will be
                    selected.

                  * **symbol** (*str** | **StringKey*) -- Atom type
                    name of the first atom of the pair. The name must
                    be as it appears in the System block. That is, if
                    the atom name contains an extension (e.g C.1) then
                    the full name including the extension must be used
                    here.

            class _at2

               Specifies selection criteria for the second atom of a
               pair in the collective variable.

               Variables:
                  * **region** (*str** | **StringKey*) -- Restrict the
                    selection to a specific region. If this is not
                    set, atoms anywhere in the system will be
                    selected.

                  * **symbol** (*str** | **StringKey*) -- Atom type
                    name of the second atom of the pair. The value is
                    allowed to be the same as [at1], in which case
                    pairs of atoms of the same type will be included.

      class _CheckTemperature

         Check at every time step if the temperature has exceeded a
         threshold. If it has, it is assumed the system exploded, and
         the simulation will stop.

         Variables:
            * **Enabled** (*BoolType** | **BoolKey*) -- If enabled,
              the simulation will stop if the temperature becomes too
              large.

            * **MaxTemperature** (*float** | **FloatKey*) -- Maximum
              temperature the system can have. If larger, the
              simulation will stop.

      class _Checkpoint

         Sets the frequency for storing the entire MD state necessary
         for restarting the calculation.

         Variables:
            * **Frequency** (*int** | **IntKey*) --

              Write the MD state to the Molecule and MDResults
              sections on ams.rkf once every N steps. Setting this to
              zero disables checkpointing during the simulation, but
              one checkpoint at the very end of the simulation will
              always be written.

              NOTE: This no longer controls the frequency of writing
              MDStep*.rkf files, set Trajectory%EngineResultsFreq
              instead.

            * **WriteProperties** (*BoolType** | **BoolKey*) --

              Honor top-level Properties input block when writing
              engine results files.

              DEPRECATED: This input option will be removed in AMS2026
              and will be considered always enabled. If you rely on it
              being disabled, please contact SCM support.

      class _CosineShear

         Apply an external acceleration to all atoms of a fluid using
         a periodic (cosine) function along a selected coordinate
         axis. This induces a periodic shear flow profile which can be
         used to determine the viscosity.

         Variables:
            * **Acceleration** (*float** | **FloatKey*) -- Amplitude
              of the applied cosine shear acceleration profile. The
              default value should be a rough first guess for water
              and it needs to be adjusted by experimentation for other
              systems.

            * **Enabled** (*BoolType** | **BoolKey*) -- Apply a cosine
              shear acceleration profile for a NEMD calculation of
              viscosity.

            * **FlowDirection** (*Iterable**[**float**] **|
              **FloatListKey*) -- The direction in which to apply the
              shear acceleration, in Cartesian coordinates. The
              magnitude of this vector is ignored (AMS will normalize
              it internally). FlowDirection has to be perpendicular to
              ProfileAxis.

            * **ProfileAxis** (*Literal**[**"X"**, **"Y"**, **"Z"**]*)
              -- The Cartesian coordinate axis along which the cosine
              wave runs

      class _Deformation

         Deform the periodic lattice of the system during the
         simulation.

         Variables:
            * **LengthRate** (*Iterable**[**float**] **|
              **FloatListKey*) -- Relative rate of change of each
              lattice vector per step.

            * **LengthVelocity** (*Iterable**[**float**] **|
              **FloatListKey*) -- Change the length of each lattice
              vector with this velocity. With Type=Exponential,
              LengthVelocity is divided by the current lattice vector
              lengths on StartStep to determine a LengthRate, which is
              then applied on all subsequent steps. For Type Sine and
              Cosine, this defines the maximum velocity (at the
              inflection point).

            * **Period** (*float** | **FloatKey*) -- Period of
              oscillation for Type Sine and Cosine.

            * **ScaleAtoms** (*BoolType** | **BoolKey*) -- Scale the
              atomic positions together with the lattice vectors.
              Disable this to deform only the lattice, keeping the
              coordinates of atoms unchanged.

            * **StartStep** (*int** | **IntKey*) -- First step at
              which the deformation will be applied.

            * **StopStep** (*int** | **IntKey*) -- Last step at which
              the deformation will be applied. If unset or zero,
              nSteps will be used instead.

            * **TargetDensity** (*float** | **FloatKey*) --

              Target density of the system to be achieved by StopStep
              by isotropically rescaling the lattice.

              This can only be used for 3D-periodic systems. Note that
              the selected Type determines how the lengths of the
              lattice vectors will evolve (linearly or as a
              sine/cosine), the evolution of the volume or density is
              thus necessarily non-linear.

            * **TargetLength** (*Iterable**[**float**] **|
              **FloatListKey*) -- Target lengths of each lattice
              vector to be achieved by StopStep. The number of values
              should equal the periodicity of the system. If a value
              is zero, the corresponding lattice vector will not be
              modified.

            * **Type** (*Literal**[**"Linear"**, **"Exponential"**,
              **"Sine"**, **"Cosine"**]*) --

              Function defining the time dependence of the deformed
              lattice parameters.

              Linear increments the lattice parameters by the same
              absolute amount every timestep. Exponential multiplies
              the lattice parameters by the same factor every
              timestep. Only StrainRate, LengthRate, and
              LengthVelocity are supported for Type=Exponential. Sine
              deforms the system from the starting lattice to
              TargetLattice/TargetLength and then by the same amount
              to the opposite direction, while Cosine deforms the
              system from the starting lattice to the target and back.

            * **LatticeVelocity** (*str** | **Sequence**[**str**] **|
              **FreeBlock*) -- Velocity of individual lattice vector
              components in Angstrom/fs. The format is identical to
              the System%Lattice block. For Type Sine and Cosine, this
              defines the maximum velocity (at the inflection point).

            * **StrainRate** (*str** | **Sequence**[**str**] **|
              **FreeBlock*) -- Strain rate matrix to be applied on
              every step. The format is identical to the
              System%Lattice block.

            * **TargetLattice** (*str** | **Sequence**[**str**] **|
              **FreeBlock*) -- Target lattice vectors to be achieved
              by StopStep. The format is identical to the
              System%Lattice block.

         class _LatticeVelocity

            Velocity of individual lattice vector components in
            Angstrom/fs. The format is identical to the System%Lattice
            block. For Type Sine and Cosine, this defines the maximum
            velocity (at the inflection point).

         class _StrainRate

            Strain rate matrix to be applied on every step. The format
            is identical to the System%Lattice block.

         class _TargetLattice

            Target lattice vectors to be achieved by StopStep. The
            format is identical to the System%Lattice block.

      class _Gravity

         Apply a constant acceleration in -z.

         Variables:
            **Acceleration** (*float** | **FloatKey*) -- Magnitude of
            the applied acceleration.

      class _HeatExchange

         Input for the heat-exchange non-equilibrium MD (T-NEMD).

         Variables:
            * **HeatingRate** (*float** | **FloatKey*) -- Rate at
              which the energy is added to the Source and removed from
              the Sink. A heating rate of 1 Hartree/fs equals to about
              0.00436 Watt of power being transferred through the
              system.

            * **Method** (*Literal**[**"Simple"**, **"HEX"**,
              **"eHEX"**]*) --

              Heat exchange method used.

              Simple: kinetic energy of the atoms of the source and
              sink regions is modified irrespective of that of the
              center of mass (CoM) of the region (recommended for
              solids).

              HEX: kinetic energy of the atoms of these regions is
              modified keeping that of the corresponding CoM constant.

              eHEX: an enhanced version of HEX that conserves the
              total energy better (recommended for gases and liquids).

            * **StartStep** (*int** | **IntKey*) -- Index of the MD
              step at which the heat exchange will start.

            * **StopStep** (*int** | **IntKey*) -- Index of the MD
              step at which the heat exchange will stop.

            * **Sink**
              (*AMSBatch._MolecularDynamics._HeatExchange._Sink*) --
              Defines the heat sink region (where the heat will be
              removed).

            * **Source**
              (*AMSBatch._MolecularDynamics._HeatExchange._Source*) --
              Defines the heat source region (where the heat will be
              added).

         class _Sink

            Defines the heat sink region (where the heat will be
            removed).

            Variables:
               * **AtomList** (*Iterable**[**int**] **| **IntListKey*)
                 --

                 The atoms that are part of the sink.

                 This key is ignored if the [Box] block or [Region]
                 key is present.

               * **FirstAtom** (*int** | **IntKey*) -- Index of the
                 first atom of the region. This key is ignored if the
                 [Box] block or the [AtomList] key is present.

               * **LastAtom** (*int** | **IntKey*) -- Index of the
                 last atom of the region. This key is ignored if the
                 [Box] block or the [AtomList] key is present.

               * **Region** (*str** | **StringKey*) --

                 The region that is the sink.

                 This key is ignored if the [Box] block is present.

               * **Show** (*BoolType** | **BoolKey*) -- Show the sink
                 in the AMSinput

               * **Box** (*AMSBatch._MolecularDynamics._HeatExchange.
                 _Sink._Box*) -- Part of the simulation box (in
                 fractional cell coordinates) defining the heat sink.
                 If this block is specified, then by default, the
                 whole box in each of the three dimensions is used,
                 which usually does not make much sense. Normally, you
                 will want to set the bounds along one of the axes.

            class _Box

               Part of the simulation box (in fractional cell
               coordinates) defining the heat sink. If this block is
               specified, then by default, the whole box in each of
               the three dimensions is used, which usually does not
               make much sense. Normally, you will want to set the
               bounds along one of the axes.

               Variables:
                  * **Amax** (*float** | **FloatKey*) -- Coordinate of
                    the upper bound along the first axis.

                  * **Amin** (*float** | **FloatKey*) -- Coordinate of
                    the lower bound along the first axis.

                  * **Bmax** (*float** | **FloatKey*) -- Coordinate of
                    the upper bound along the second axis.

                  * **Bmin** (*float** | **FloatKey*) -- Coordinate of
                    the lower bound along the second axis.

                  * **Cmax** (*float** | **FloatKey*) -- Coordinate of
                    the upper bound along the third axis.

                  * **Cmin** (*float** | **FloatKey*) -- Coordinate of
                    the lower bound along the third axis.

         class _Source

            Defines the heat source region (where the heat will be
            added).

            Variables:
               * **AtomList** (*Iterable**[**int**] **| **IntListKey*)
                 --

                 The atoms that are part of the source.

                 This key is ignored if the [Box] block or [Region]
                 key is present.

               * **FirstAtom** (*int** | **IntKey*) -- Index of the
                 first atom of the region. This key is ignored if the
                 [Box] block or the [AtomList] key is present.

               * **LastAtom** (*int** | **IntKey*) -- Index of the
                 last atom of the region. This key is ignored if the
                 [Box] block or the [AtomList] key is present.

               * **Region** (*str** | **StringKey*) --

                 The region that is the source.

                 This key is ignored if the [Box] block is present.

               * **Show** (*BoolType** | **BoolKey*) -- Show the
                 source in the AMSinput

               * **Box** (*AMSBatch._MolecularDynamics._HeatExchange.
                 _Source._Box*) -- Part of the simulation box (in
                 fractional cell coordinates) defining the heat
                 source. If this block is specified, then by default,
                 the whole box in each of the three dimensions is
                 used, which usually does not make much sense.
                 Normally, you will want to set the bounds along one
                 of the axes. This block is mutually exclusive with
                 the FirstAtom/LastAtom setting.

            class _Box

               Part of the simulation box (in fractional cell
               coordinates) defining the heat source. If this block is
               specified, then by default, the whole box in each of
               the three dimensions is used, which usually does not
               make much sense. Normally, you will want to set the
               bounds along one of the axes. This block is mutually
               exclusive with the FirstAtom/LastAtom setting.

               Variables:
                  * **Amax** (*float** | **FloatKey*) -- Coordinate of
                    the upper bound along the first axis.

                  * **Amin** (*float** | **FloatKey*) -- Coordinate of
                    the lower bound along the first axis.

                  * **Bmax** (*float** | **FloatKey*) -- Coordinate of
                    the upper bound along the second axis.

                  * **Bmin** (*float** | **FloatKey*) -- Coordinate of
                    the lower bound along the second axis.

                  * **Cmax** (*float** | **FloatKey*) -- Coordinate of
                    the upper bound along the third axis.

                  * **Cmin** (*float** | **FloatKey*) -- Coordinate of
                    the lower bound along the third axis.

      class _InitialVelocities

         Sets the frequency for printing to stdout and storing the
         molecular configuration on the .rkf file.

         Variables:
            * **File** (*str** | **Path** | **StringKey*) -- AMS RKF
              file containing the initial velocities.

            * **RandomVelocitiesMethod** (*Literal**[**"Exact"**,
              **"Boltzmann"**, **"Gromacs"**]*) --

              Specifies how are random velocities generated. Three
              methods are available.

              Exact: Velocities are scaled to exactly match set random
              velocities temperature.

              Boltzmann: Velocities are not scaled and sample Maxwell-
              Boltzmann distribution. However, the distribution is not
              corrected for constraints.

              Gromacs: Velocities are scaled to match set random
              velocities temperature, but removal of net momentum is
              performed only after the scaling. Resulting kinetic
              energy is lower based on how much net momentum the
              system had.

            * **Temperature** (*float** | **FloatKey*) --

              Sets the temperature for the Maxwell-Boltzmann
              distribution when the type of the initial velocities is
              set to random, in which case specifying this key is
              mandatory.

              AMSinput will use the first temperature of the first
              thermostat as default.

            * **Type** (*Literal**[**"Zero"**, **"Random"**,
              **"FromFile"**, **"Input"**]*) --

              Specifies the initial velocities to assign to the atoms.
              Three methods to assign velocities are available.

              Zero: All atom are at rest at the beginning of the
              calculation.

              Random: Initial atom velocities follow a Maxwell-
              Boltzmann distribution for the temperature given by the
              [MolecularDynamics%InitialVelocities%Temperature]
              keyword.

              FromFile: Load the velocities from a previous ams result
              file.

              Input: Atom's velocities are set to the values specified
              in the [MolecularDynamics%InitialVelocities%Values]
              block, which can be accessed via the Expert AMS panel in
              AMSinput.

            * **Values** (*str** | **Sequence**[**str**] **|
              **FreeBlock*) -- This block specifies the velocity of
              each atom, in Angstrom/fs, when
              [MolecularDynamics%InitialVelocities%Type] is set to
              Input. Each row must contain three floating point values
              (corresponding to the x,y,z component of the velocity
              vector) and a number of rows equal to the number of
              atoms must be present, given in the same order as the
              [System%Atoms] block.

         class _Values

            This block specifies the velocity of each atom, in
            Angstrom/fs, when
            [MolecularDynamics%InitialVelocities%Type] is set to
            Input. Each row must contain three floating point values
            (corresponding to the x,y,z component of the velocity
            vector) and a number of rows equal to the number of atoms
            must be present, given in the same order as the
            [System%Atoms] block.

      class _MovingRestraints

         Define a set of moving restraints.

         Variables:
            * **Change** (*Literal**[**"Linear"**, **"Sine"**,
              **"Cosine"**]*) --

              Type of function defining how the target restraint value
              will change over time:

              Linear - linearly between the StartValue and EndValue.
              Sine - oscillating around StartValue with an amplitude
              equal to the difference between EndValue and StartValue.
              Cosine - oscillating between StartValue and EndValue.

            * **Name** (*str** | **StringKey*) -- Optional name to be
              used for plotting.

            * **Period** (*float** | **FloatKey*) -- Period of
              oscillation for Sine and Cosine change types.

            * **RestraintType** (*Literal**[**"None"**,
              **"Harmonic"**, **"Hyperbolic"**, **"Erf"**,
              **"GaussianWell"**]*) -- Select type of the moving
              restraint profile. The force for Hyperbolic and Erf is
              bounded by a user-defined value, the latter converging
              to it faster than the former. The GaussianWell has a
              finite depth so it is suitable for cases when crossing a
              high reaction barrier is not desirable.

            * **StartStep** (*int** | **IntKey*) -- First step number
              at which the restraints will be applied.

            * **StopStep** (*int** | **IntKey*) -- Last step number at
              which the restraints will be applied.

            * **Distance** (*AMSBatch._MolecularDynamics._MovingRestr
              aints._Distance*) -- Define a distance restraint between
              pair of atoms. For linear-type

            * **Erf**
              (*AMSBatch._MolecularDynamics._MovingRestraints._Erf*)
              -- Define parameters for the Int(erf) restraint
              potential V = alpha*(beta*x*erf(beta*x) +
              (exp(-(beta*x)**2) - 1)/sqrt(PI)). The alpha and beta
              parameters are computed from the user-defined
              ForceConstant and MaxForce.

            * **GaussianWell** (*AMSBatch._MolecularDynamics._MovingR
              estraints._GaussianWell*) -- Define parameters in the
              Gaussian well restraint potential
              V=-WellDepth*exp(-Sigma*(r-r0)^2).

            * **Harmonic** (*AMSBatch._MolecularDynamics._MovingRestr
              aints._Harmonic*) -- Define parameters for the harmonic
              potential V=0.5*FC*(r-r0)^2.

            * **Hyperbolic** (*AMSBatch._MolecularDynamics._MovingRes
              traints._Hyperbolic*) -- Define parameters for the
              hyperbolic restraint potential V=alpha*(sqrt(1 +
              beta*x^2) - 1). The alpha and beta parameters are
              computed from the user-defined ForceConstant and
              MaxForce: beta=ForceConstant/MaxForce,
              alpha=MaxForce/beta

         class _Distance

            Define a distance restraint between pair of atoms. For
            linear-type

            Variables:
               * **Atom1** (*int** | **IntKey*) -- First atom of the
                 distance restraint.

               * **Atom2** (*int** | **IntKey*) -- Second atom of the
                 distance restraint.

               * **EndValue** (*float** | **FloatKey*) -- Linear:
                 final target distance. Sine: target distance at 1/4
                 of the period. Cosine: target distance at 1/2 of the
                 period.

               * **StartValue** (*float** | **FloatKey*) -- Initial
                 target distance.

         class _Erf

            Define parameters for the Int(erf) restraint potential V =
            alpha*(beta*x*erf(beta*x) + (exp(-(beta*x)**2) -
            1)/sqrt(PI)). The alpha and beta parameters are computed
            from the user-defined ForceConstant and MaxForce.

            Variables:
               * **ForceConstant** (*float** | **FloatKey*) -- The
                 force constant (second derivative of the potential)
                 at the optimum point.

               * **MaxForce** (*float** | **FloatKey*) -- Asymptotic
                 value of the force at the infinity.

         class _GaussianWell

            Define parameters in the Gaussian well restraint potential
            V=-WellDepth*exp(-Sigma*(r-r0)^2).

            Variables:
               * **Sigma** (*float** | **FloatKey*) -- Sigma parameter
                 in the potential expression.

               * **WellDepth** (*float** | **FloatKey*) -- WellDepth
                 parameter in the potential expression.

         class _Harmonic

            Define parameters for the harmonic potential
            V=0.5*FC*(r-r0)^2.

            Variables:
               **ForceConstant** (*float** | **FloatKey*) -- The FC
               parameter of the harmonic potential.

         class _Hyperbolic

            Define parameters for the hyperbolic restraint potential
            V=alpha*(sqrt(1 + beta*x^2) - 1). The alpha and beta
            parameters are computed from the user-defined
            ForceConstant and MaxForce: beta=ForceConstant/MaxForce,
            alpha=MaxForce/beta

            Variables:
               * **ForceConstant** (*float** | **FloatKey*) -- The
                 force constant (second derivative of the potential)
                 at the optimum point.

               * **MaxForce** (*float** | **FloatKey*) -- Asymptotic
                 value of the force at the infinity.

      class _PRD

         This block is used for Parallel Replica Dynamics simulations.

         Variables:
            * **CorrelatedSteps** (*int** | **IntKey*) -- How many
              steps to wait for correlated events after detecting an
              initial event.

            * **DephasingSteps** (*int** | **IntKey*) -- Spend this
              many steps dephasing the individual replicas after an
              event.

            * **nReplicas** (*int** | **IntKey*) -- Number of replicas
              to run in parallel.

            * **BondChange**
              (*AMSBatch._MolecularDynamics._PRD._BondChange*) --
              Detect changes to the bonding topology and bond orders
              returned by the engine.

            * **MolCount**
              (*AMSBatch._MolecularDynamics._PRD._MolCount*) -- Detect
              changes to the molecular composition of the system.

         class _BondChange

            Detect changes to the bonding topology and bond orders
            returned by the engine.

            Variables:
               * **ChangeThreshold** (*float** | **FloatKey*) --
                 Trigger an event when the bond order of a bond
                 changes from the reference state by more than this
                 value.

               * **DissociationThreshold** (*float** | **FloatKey*) --
                 Trigger an event when a bond dissociates (its bond
                 order drops below this value while it was above
                 FormationThreshold in the reference state).

               * **FormationThreshold** (*float** | **FloatKey*) --
                 Trigger an event when a new bond forms (its bond
                 order exceeds this value while it was below
                 DissociationThreshold in the reference state).

         class _MolCount

            Detect changes to the molecular composition of the system.

      class _Plumed

         Input for PLUMED (version 2.5.0). The parallel option is
         still experimental.

         Variables:
            * **Input** (*str** | **Sequence**[**str**] **|
              **FreeBlock*) -- Input for PLUMED. Contents of this
              block is passed to PLUMED as is.

            * **Parallel**
              (*AMSBatch._MolecularDynamics._Plumed._Parallel*) --
              Options for double parallelization, which allows to
              split the available processor cores into groups working
              through all the available tasks in parallel, resulting
              in a better parallel performance. The keys in this block
              determine how to split the available processor cores
              into groups working in parallel.

         class _Input

            Input for PLUMED. Contents of this block is passed to
            PLUMED as is.

         class _Parallel

            Options for double parallelization, which allows to split
            the available processor cores into groups working through
            all the available tasks in parallel, resulting in a better
            parallel performance. The keys in this block determine how
            to split the available processor cores into groups working
            in parallel.

            Variables:
               * **nCoresPerGroup** (*int** | **IntKey*) -- Number of
                 cores in each working group.

               * **nGroups** (*int** | **IntKey*) -- Total number of
                 processor groups. This is the number of tasks that
                 will be executed in parallel.

               * **nNodesPerGroup** (*int** | **IntKey*) -- Number of
                 nodes in each group. This option should only be used
                 on homogeneous compute clusters, where all used
                 compute nodes have the same number of processor
                 cores.

      class _Preserve

         Periodically remove numerical drift accumulated during the
         simulation to preserve different whole-system parameters.

         Variables:
            * **AngularMomentum** (*BoolType** | **BoolKey*) -- Remove
              overall angular momentum of the system. This option is
              ignored for 2D and 3D-periodic systems, and disabled by
              default for systems which are not translationally
              invariant (for example when frozen atoms are present).

            * **CenterOfMass** (*BoolType** | **BoolKey*) -- Translate
              the system to keep its center of mass at the coordinate
              origin. This option is not very useful for 3D-periodic
              systems.

            * **Momentum** (*BoolType** | **BoolKey*) -- Remove
              overall (linear) momentum of the system. This is
              disabled by default for systems which are not
              translationally invariant (for example when frozen atoms
              are present).

      class _Print

         This block controls the printing of additional information to
         stdout.

         Variables:
            * **System** (*BoolType** | **BoolKey*) -- Print the
              chemical system before and after the simulation.

            * **Velocities** (*BoolType** | **BoolKey*) -- Print the
              atomic velocities before and after the simulation.

      class _ReactionBoost

         Define a series of transitions between different states of
         the system.

         Each transition is defined by a TargetSystem and by a set of
         restraints that force the transition.

         Variables:
            * **Change** (*Literal**[**"TargetCoordinate"**,
              **"Force"**, **"LogForce"**]*) --

              Select what to change during dynamics.

              By default, once the restraints are switched on, AMS
              will change the restraint's target coordinate towards
              its final value.

              If the [Force] or [LogForce] option is selected then the
              target coordinate is set to its final value immediately
              and instead the restraint force is gradually scaled from
              0 to 1. The scaling is either linear (Force) or
              logarithmic (LogForce).

            * **InitialFraction** (*float** | **FloatKey*) --

              Initial fraction of the boost variable.

              At the first boosting step, the restraint's target value
              (or force or log(force)) is equal to InitialFraction +
              1/NSteps.

            * **InterEquilibrationSteps** (*int** | **IntKey*) --
              Number of equilibration steps after reaching a target
              before setting up restraints for the next one.

            * **MinBondChange** (*float** | **FloatKey*) -- Minimal
              change in the distance for an individual restraint to be
              considered bond-breaking/making vs bonded.

            * **MinBondStrength** (*float** | **FloatKey*) -- Minimum
              strength (usually ranges from 0 to 1) for a bond to be
              considered.

            * **NSteps** (*int** | **IntKey*) -- Number of steps per
              target the restraints should be active for.

            * **PreEquilibrationSteps** (*int** | **IntKey*) -- Number
              of steps before enabling the first set of restraints.

            * **Region** (*str** | **StringKey*) -- Region to which
              the restraints should be limited.

            * **TargetSystem** (*str** | **StringKey*) --

              The target system's name for this transition. Multiple
              targets can be specified to request multiple transitions
              in one simulation.

              Note that only the lattice and the atomic coordinates of
              the target system are used and other properties (bonds,
              charge, etc.) are ignored. The target system's lattice
              is used only to determine connections and it cannot be
              restrained.

            * **Type** (*Literal**[**"None"**, **"Pair"**,
              **"RMSD"**]*) --

              Reaction Boost uses a series of transitions between
              different states of the system. Each transition is
              defined by a TargetSystem and by a set of restraints
              that force the transition.

              Select the type of the restraint set: -None: no Reaction
              Boost - Pair: use pair restraints - RMSD: use RMSD
              restraints.

              Pair restraints are defined per atom pair while the RMSD
              defines one collective restraint for all atoms and is
              thus suitable for very large systems.

              The pair restraints are further divided into four sub-
              types: bonding, non-bonding, bond-breaking and bond-
              making. The sub-type of restraints for each pair is
              determined automatically depending on whether the two
              atoms are bonded in the initial/final state.

              Parameters of the pair restraints are defined by
              [NonBondedRestraints], [BondedRestraints],
              [BondBreakingRestraints] and [BondMakingRestraints]
              blocks, while those of the RMSD restraint by the
              [RMSDRestraint] block.

            * **BondBreakingRestraints** (*AMSBatch._MolecularDynamic
              s._ReactionBoost._BondBreakingRestraints*) --

              Define parameters for moving restraints that are added
              for pairs of atoms that become disconnected during the
              transition.

              It is intended to make sure the corresponding bonds get
              broken, although this may not always be required because
              forming other bonds will likely get these bonds broken.

            * **BondMakingRestraints** (*AMSBatch._MolecularDynamics.
              _ReactionBoost._BondMakingRestraints*) --

              Define parameters for moving restraints that are added
              for pairs of atoms that become connected during the
              transition.

              It is intended to make sure the bonds are created as
              required.

            * **BondedRestraints** (*AMSBatch._MolecularDynamics._Rea
              ctionBoost._BondedRestraints*) --

              Define parameters for bonded restraints. A bonded
              restraint is added for each pair of atoms that are
              bonded both in the current and in the final state.

              It is intended to make sure they remain bonded during
              simulation.

            * **NonBondedRestraints** (*AMSBatch._MolecularDynamics._
              ReactionBoost._NonBondedRestraints*) --

              Define parameters for non-bonded restraints. A non-
              bonded restraint is added for each pair of atoms that
              are bonded neither in the current nor in the final
              state.

              It is intended to keep them from forming a bond
              unintentionally. They are represented by a repulsive
              potential

            * **RMSDRestraint** (*AMSBatch._MolecularDynamics._Reacti
              onBoost._RMSDRestraint*) -- Define a static restraint
              that pulls each atom to its position in the target
              system, but in contrast to the individual restraints,
              the force for this one depends on the total mass-
              weighted root-mean-squared distance (RMSD) between the
              two structures.

         class _BondBreakingRestraints

            Define parameters for moving restraints that are added for
            pairs of atoms that become disconnected during the
            transition.

            It is intended to make sure the corresponding bonds get
            broken, although this may not always be required because
            forming other bonds will likely get these bonds broken.

            Variables:
               * **Type** (*Literal**[**"None"**, **"Harmonic"**,
                 **"Hyperbolic"**, **"Erf"**, **"GaussianWell"**]*) --

                 Select type of the moving restraint profile.

                 Harmonic: V=0.5*FC*(r-r0)^2

                 Hyperbolic: V=alpha*(sqrt(1 + beta*x^2) - 1)

                 Erf: V = alpha*(beta*x*erf(beta*x) +
                 (exp(-(beta*x)**2) - 1)/sqrt(PI))

                 GaussianWell: V=WellDepth*(1-exp(-Sigma*(r-r0)^2))

                 Here beta=ForceConstant/MaxForce,
                 alpha=MaxForce/beta.

                 The force for Hyperbolic and Erf is bounded by a
                 user-defined value, the latter converging to it
                 faster than the former. The GaussianWell has a finite
                 depth so it is suitable for cases when crossing a
                 high reaction barrier is not desirable.

                 Moving restraints are added for pairs of atoms that
                 become disconnected during the transition.

                 It is intended to make sure the corresponding bonds
                 get broken, although this may not always be required
                 because forming other bonds will likely get these
                 bonds broken.

               * **Erf** (*AMSBatch._MolecularDynamics._ReactionBoost
                 ._BondBreakingRestraints._Erf*) -- Define parameters
                 for the Int(erf) potential V =
                 alpha*(beta*x*erf(beta*x) + (exp(-(beta*x)**2) -
                 1)/sqrt(PI)). The alpha and beta parameters are
                 computed from the user-defined ForceConstant and
                 MaxForce.

               * **GaussianWell** (*AMSBatch._MolecularDynamics._Reac
                 tionBoost._BondBreakingRestraints._GaussianWell*) --
                 Define parameters in the Gaussian well potential
                 V=-WellDepth*exp(-Sigma*(r-r0)^2).

               * **Harmonic** (*AMSBatch._MolecularDynamics._Reaction
                 Boost._BondBreakingRestraints._Harmonic*) -- Define
                 parameters for the harmonic potential
                 V=0.5*FC*(r-r0)^2.

               * **Hyperbolic** (*AMSBatch._MolecularDynamics._Reacti
                 onBoost._BondBreakingRestraints._Hyperbolic*) --
                 Define parameters for the hyperbolic potential
                 V=alpha*(sqrt(1 + beta*x^2) - 1). The alpha and beta
                 parameters are computed from the user-defined
                 ForceConstant and MaxForce:
                 beta=ForceConstant/MaxForce, alpha=MaxForce/beta

               * **Taper** (*AMSBatch._MolecularDynamics._ReactionBoo
                 st._BondBreakingRestraints._Taper*) --

            class _Erf

               Define parameters for the Int(erf) potential V =
               alpha*(beta*x*erf(beta*x) + (exp(-(beta*x)**2) -
               1)/sqrt(PI)). The alpha and beta parameters are
               computed from the user-defined ForceConstant and
               MaxForce.

               Variables:
                  * **ForceConstant** (*float** | **FloatKey*) -- The
                    force constant (second derivative of the
                    potential) at the optimum point.

                  * **MaxForce** (*float** | **FloatKey*) --
                    Asymptotic value of the force at the infinity.

            class _GaussianWell

               Define parameters in the Gaussian well potential
               V=-WellDepth*exp(-Sigma*(r-r0)^2).

               Variables:
                  * **Sigma** (*float** | **FloatKey*) -- Sigma
                    parameter in the potential expression.

                  * **WellDepth** (*float** | **FloatKey*) --
                    WellDepth parameter in the potential expression.

            class _Harmonic

               Define parameters for the harmonic potential
               V=0.5*FC*(r-r0)^2.

               Variables:
                  **ForceConstant** (*float** | **FloatKey*) -- The FC
                  parameter of the harmonic potential.

            class _Hyperbolic

               Define parameters for the hyperbolic potential
               V=alpha*(sqrt(1 + beta*x^2) - 1). The alpha and beta
               parameters are computed from the user-defined
               ForceConstant and MaxForce:
               beta=ForceConstant/MaxForce, alpha=MaxForce/beta

               Variables:
                  * **ForceConstant** (*float** | **FloatKey*) -- The
                    force constant (second derivative of the
                    potential) at the optimum point.

                  * **MaxForce** (*float** | **FloatKey*) --
                    Asymptotic value of the force at the infinity.

            class _Taper

               Variables:
                  * **Enabled** (*BoolType** | **BoolKey*) -- Enable
                    tapering of the restraint potential and force
                    between the given range of bond distances. A 7-th
                    order tapering function on the actual (not
                    target!) distance will be used. The MaxDistance
                    must be greater than MinDistance.

                  * **MaxDistance** (*float** | **FloatKey*) -- Bond
                    length at which the restraint potential and force
                    decays to zero.

                  * **MinDistance** (*float** | **FloatKey*) -- Bond
                    length at which the restraint potential and force
                    will start decaying to zero.

         class _BondMakingRestraints

            Define parameters for moving restraints that are added for
            pairs of atoms that become connected during the
            transition.

            It is intended to make sure the bonds are created as
            required.

            Variables:
               * **Type** (*Literal**[**"None"**, **"Harmonic"**,
                 **"Hyperbolic"**, **"Erf"**, **"GaussianWell"**]*) --

                 Select type of the moving restraint profile.

                 Harmonic: V=0.5*FC*(r-r0)^2

                 Hyperbolic: V=alpha*(sqrt(1 + beta*x^2) - 1)

                 Erf: V = alpha*(beta*x*erf(beta*x) +
                 (exp(-(beta*x)**2) - 1)/sqrt(PI))

                 GaussianWell: V=-WellDepth*exp(-Sigma*(r-r0)^2)

                 Here beta=ForceConstant/MaxForce,
                 alpha=MaxForce/beta.

                 The force for Hyperbolic and Erf is bounded by a
                 user-defined value. The GaussianWell has a finite
                 depth so it is suitable for cases when crossing a
                 high reaction barrier is not desirable.

                 Moving restraints are added for pairs of atoms that
                 become connected during the transition.

                 It is intended to make sure the bonds are created as
                 required.

               * **Erf** (*AMSBatch._MolecularDynamics._ReactionBoost
                 ._BondMakingRestraints._Erf*) -- Define parameters
                 for the Int(erf) potential V =
                 alpha*(beta*x*erf(beta*x) + (exp(-(beta*x)**2) -
                 1)/sqrt(PI)). The alpha and beta parameters are
                 computed from the user-defined ForceConstant and
                 MaxForce.

               * **GaussianWell** (*AMSBatch._MolecularDynamics._Reac
                 tionBoost._BondMakingRestraints._GaussianWell*) --
                 Define parameters in the Gaussian well potential
                 V=-WellDepth*exp(-Sigma*(r-r0)^2).

               * **Harmonic** (*AMSBatch._MolecularDynamics._Reaction
                 Boost._BondMakingRestraints._Harmonic*) -- Define
                 parameters for the harmonic potential
                 V=0.5*FC*(r-r0)^2.

               * **Hyperbolic** (*AMSBatch._MolecularDynamics._Reacti
                 onBoost._BondMakingRestraints._Hyperbolic*) -- Define
                 parameters for the hyperbolic potential
                 V=alpha*(sqrt(1 + beta*x^2) - 1). The alpha and beta
                 parameters are computed from the user-defined
                 ForceConstant and MaxForce:
                 beta=ForceConstant/MaxForce, alpha=MaxForce/beta

            class _Erf

               Define parameters for the Int(erf) potential V =
               alpha*(beta*x*erf(beta*x) + (exp(-(beta*x)**2) -
               1)/sqrt(PI)). The alpha and beta parameters are
               computed from the user-defined ForceConstant and
               MaxForce.

               Variables:
                  * **ForceConstant** (*float** | **FloatKey*) -- The
                    force constant (second derivative of the
                    potential) at the optimum point.

                  * **MaxForce** (*float** | **FloatKey*) --
                    Asymptotic value of the force at the infinity.

            class _GaussianWell

               Define parameters in the Gaussian well potential
               V=-WellDepth*exp(-Sigma*(r-r0)^2).

               Variables:
                  * **Sigma** (*float** | **FloatKey*) -- Sigma
                    parameter in the potential expression.

                  * **WellDepth** (*float** | **FloatKey*) --
                    WellDepth parameter in the potential expression.

            class _Harmonic

               Define parameters for the harmonic potential
               V=0.5*FC*(r-r0)^2.

               Variables:
                  **ForceConstant** (*float** | **FloatKey*) -- The FC
                  parameter of the harmonic potential.

            class _Hyperbolic

               Define parameters for the hyperbolic potential
               V=alpha*(sqrt(1 + beta*x^2) - 1). The alpha and beta
               parameters are computed from the user-defined
               ForceConstant and MaxForce:
               beta=ForceConstant/MaxForce, alpha=MaxForce/beta

               Variables:
                  * **ForceConstant** (*float** | **FloatKey*) -- The
                    force constant (second derivative of the
                    potential) at the optimum point.

                  * **MaxForce** (*float** | **FloatKey*) --
                    Asymptotic value of the force at the infinity.

         class _BondedRestraints

            Define parameters for bonded restraints. A bonded
            restraint is added for each pair of atoms that are bonded
            both in the current and in the final state.

            It is intended to make sure they remain bonded during
            simulation.

            Variables:
               * **Type** (*Literal**[**"None"**, **"Harmonic"**]*) --

                 Select type of the bonded restraints:

                 Harmonic: V=0.5*FC*(r-r0)^2

                 A bonded restraint is added for each pair of atoms
                 that are bonded both in the current and in the final
                 state.

                 It is intended to make sure they remain bonded during
                 simulation.

               * **Harmonic** (*AMSBatch._MolecularDynamics._Reaction
                 Boost._BondedRestraints._Harmonic*) -- Define
                 parameters for the harmonic potential
                 V=0.5*FC*(r-r0)^2.

            class _Harmonic

               Define parameters for the harmonic potential
               V=0.5*FC*(r-r0)^2.

               Variables:
                  **ForceConstant** (*float** | **FloatKey*) -- The FC
                  parameter of the harmonic potential.

         class _NonBondedRestraints

            Define parameters for non-bonded restraints. A non-bonded
            restraint is added for each pair of atoms that are bonded
            neither in the current nor in the final state.

            It is intended to keep them from forming a bond
            unintentionally. They are represented by a repulsive
            potential

            Variables:
               * **Type** (*Literal**[**"None"**, **"Exponential"**]*)
                 --

                 Select type of the non-bonded restraints:

                 Exponential: V=Epsilon*exp(-Sigma*r)

                 A non-bonded restraint is added for each pair of
                 atoms that are bonded neither in the current nor in
                 the final state.

                 It is intended to keep them from forming a bond
                 unintentionally. They are represented by a repulsive
                 potential.

               * **Exponential** (*AMSBatch._MolecularDynamics._React
                 ionBoost._NonBondedRestraints._Exponential*) --
                 Define parameters for the repulsive potential
                 V=Epsilon*exp(-Sigma*r).

            class _Exponential

               Define parameters for the repulsive potential
               V=Epsilon*exp(-Sigma*r).

               Variables:
                  * **Epsilon** (*float** | **FloatKey*) -- Epsilon
                    parameter in the repulsive potential expression.

                  * **Sigma** (*float** | **FloatKey*) -- Sigma
                    parameter in the repulsive potential expression.

         class _RMSDRestraint

            Define a static restraint that pulls each atom to its
            position in the target system, but in contrast to the
            individual restraints, the force for this one depends on
            the total mass-weighted root-mean-squared distance (RMSD)
            between the two structures.

            Variables:
               * **Type** (*Literal**[**"None"**, **"Harmonic"**,
                 **"Hyperbolic"**, **"Erf"**, **"GaussianWell"**]*) --

                 Select type of the RMSD restraint profile:

                 Harmonic: V=0.5*FC*(r-r0)^2

                 Hyperbolic: V=alpha*(sqrt(1 + beta*x^2) - 1)

                 Erf: V = alpha*(beta*x*erf(beta*x) +
                 (exp(-(beta*x)**2) - 1)/sqrt(PI),

                 GaussianWell: V=-WellDepth*exp(-Sigma*(r-r0)^2)

                 Here beta=ForceConstant/MaxForce,
                 alpha=MaxForce/beta.

                 The Harmonic profile can be problematic at large
                 deviations as it may result in large forces. The
                 force for Hyperbolic and Erf is bounded by a user-
                 defined value. The GaussianWell has a finite depth so
                 it is suitable for cases when crossing a high
                 reaction barrier is not desirable.

               * **Erf** (*AMSBatch._MolecularDynamics._ReactionBoost
                 ._RMSDRestraint._Erf*) -- Define parameters for the
                 Int(erf) potential V = alpha*(beta*x*erf(beta*x) +
                 (exp(-(beta*x)**2) - 1)/sqrt(PI)). The alpha and beta
                 parameters are computed from the user-defined
                 ForceConstant and MaxForce.

               * **GaussianWell** (*AMSBatch._MolecularDynamics._Reac
                 tionBoost._RMSDRestraint._GaussianWell*) -- Define
                 parameters in the Gaussian well potential
                 V=-WellDepth*exp(-Sigma*(r-r0)^2).

               * **Harmonic** (*AMSBatch._MolecularDynamics._Reaction
                 Boost._RMSDRestraint._Harmonic*) -- Define parameters
                 for the harmonic potential V=0.5*FC*(r-r0)^2.

               * **Hyperbolic** (*AMSBatch._MolecularDynamics._Reacti
                 onBoost._RMSDRestraint._Hyperbolic*) -- Define
                 parameters for the hyperbolic potential
                 V=alpha*(sqrt(1 + beta*x^2) - 1). The alpha and beta
                 parameters are computed from the user-defined
                 ForceConstant and MaxForce:
                 beta=ForceConstant/MaxForce, alpha=MaxForce/beta

            class _Erf

               Define parameters for the Int(erf) potential V =
               alpha*(beta*x*erf(beta*x) + (exp(-(beta*x)**2) -
               1)/sqrt(PI)). The alpha and beta parameters are
               computed from the user-defined ForceConstant and
               MaxForce.

               Variables:
                  * **ForceConstant** (*float** | **FloatKey*) -- The
                    force constant (second derivative of the
                    potential) at the optimum point.

                  * **MaxForce** (*float** | **FloatKey*) --
                    Asymptotic value of the force at the infinity.

            class _GaussianWell

               Define parameters in the Gaussian well potential
               V=-WellDepth*exp(-Sigma*(r-r0)^2).

               Variables:
                  * **Sigma** (*float** | **FloatKey*) -- Sigma
                    parameter in the potential expression.

                  * **WellDepth** (*float** | **FloatKey*) --
                    WellDepth parameter in the potential expression.

            class _Harmonic

               Define parameters for the harmonic potential
               V=0.5*FC*(r-r0)^2.

               Variables:
                  **ForceConstant** (*float** | **FloatKey*) -- The FC
                  parameter of the harmonic potential.

            class _Hyperbolic

               Define parameters for the hyperbolic potential
               V=alpha*(sqrt(1 + beta*x^2) - 1). The alpha and beta
               parameters are computed from the user-defined
               ForceConstant and MaxForce:
               beta=ForceConstant/MaxForce, alpha=MaxForce/beta

               Variables:
                  * **ForceConstant** (*float** | **FloatKey*) -- The
                    force constant (second derivative of the
                    potential) at the optimum point.

                  * **MaxForce** (*float** | **FloatKey*) --
                    Asymptotic value of the force at the infinity.

      class _Reactor

         Define one phase of the nanoreactor. A reactor is a region of
         space surrounded by an elastic wall. Atoms inside the region
         are not affected. Atoms outside it will be pushed back with
         force depending on the [ForceConstant] and the [MassScaled]
         flag.

         Variables:
            * **ForceConstant** (*float** | **FloatKey*) -- Force
              constant of the reactor wall in Hartree/Bohr^2 (or
              Hartree/Bohr^2/Dalton if [MassScaled] is true).

            * **MassScaled** (*BoolType** | **BoolKey*) -- If this
              flag is disabled the force on an atom outside of the
              reactor depends only on the atomic coordinates and the
              force constant. Otherwise, the force is also multiplied
              by the mass of the atom. This means that atoms at the
              same distance from the wall will receive the same
              accelerate due to the wall potential.

            * **NSteps** (*int** | **IntKey*) -- Number of steps for
              which the reactor will remain active until disabled. The
              next reactor will be activated immediately after this.
              After the last reactor is disabled the cycle will
              repeat.

            * **Radius** (*float** | **FloatKey*) -- Radius of the
              reactor sphere.

      class _ReflectiveWall

         Apply a reflective wall in space

         Variables:
            * **Axis** (*Iterable**[**float**] **| **FloatListKey*) --
              Defines the normal vector perpendicular to the plane of
              the reflective wall. Any particle moving in this
              direction will be reflected back.

            * **Direction** (*Literal**[**"under"**, **"above"**]*) --
              Defines the direction of the reflective wall. under will
              keep the particles under the defined wall, and above
              will keep the particles above the defined wall

            * **Region** (*str** | **StringKey*) -- Apply the
              reflective wall to all atoms in this region.

            * **Thickness** (*float** | **FloatKey*) -- Any particle
              not deeper than Thickness beyond the reflective face of
              the wall will be reflected. Particles deeper than this
              will be ignored by the wall. This setting allows the
              placement of two walls back-to-back to create a two-
              sided wall that reflects in both directions (offset the
              position of each individual wall by Thickness so that
              their areas of influence do not overlap). Systems with
              very high speed particles (light atoms at high
              temperatures) need a higher Thickness to stop atoms from
              tunneling through the wall in a single timestep.

            * **Threshold** (*float** | **FloatKey*) -- Defines the
              threshold value determining the position of the
              reflective wall. If the dot product of a position of a
              particle with Axis exceeds Threshold, the particle will
              be reflected. This means that the plane of the wall
              passes through a point given by Axis times Threshold.

      class _Remap

         Control periodic remapping (backtranslation) of atoms into
         the PBC box.

         Variables:
            * **Range** (*Literal**[**"Auto"**, **"ZeroToOne"**,
              **"PlusMinusHalf"**, **"AroundCenter"**]*) --

              Select the range of fractional coordinates to which
              atoms are remapped.

              Auto: Use PlusMinusHalf if the geometrical center of the
              starting positions of all atoms lies between -0.25 and
              0.25 in fractional coordinates in all periodic
              directions, ZeroToOne otherwise.

              PlusMinusHalf: Remap atoms to lie between -0.5 and 0.5
              in fractional coordinates.

              ZeroToOne: Remap atoms to lie between 0 and 1 in
              fractional coordinates.

              AroundCenter: Remap atoms to lie within 0.5 in
              fractional coordinates around the geometrical center of
              the starting positions of all atoms.

            * **Type** (*Literal**[**"None"**, **"Atoms"**]*) --

              Select the method used to remap atoms into the unit
              cell.

              None: Disable remapping completely.

              Atoms: Remap any atoms that leave the unit cell.

      class _RemoveMolecules

         This block controls removal of molecules from the system.
         Multiple occurrences of this block are possible.

         Variables:
            * **Formula** (*str** | **StringKey*) --

              Molecular formula of the molecules that should be
              removed from the system.

              The order of elements in the formula is very important
              and the correct order is: C, H, all other elements in
              the strictly alphabetic order.  Element names are case-
              sensitive, spaces in the formula are not allowed. Digit
              '1' must be omitted.

              Valid formula examples: C2H6O, H2O, O2S. Invalid formula
              examples: C2H5OH, H2O1, OH, SO2. Invalid formulas are
              silently ignored.

              Use * to remove any molecule, which must be combined
              with SinkBox or SafeBox.

            * **Frequency** (*int** | **IntKey*) -- The specified
              molecules are removed every so many steps after the
              StartStep. There is never a molecule removed at step 0.

            * **StartStep** (*int** | **IntKey*) --

              Step number when molecules are removed for the first
              time. After that, molecules are removed every
              [Frequency] steps.

              For example, if StartStep=99 and Frequency=100 then
              molecules will be removed at steps 99, 199, 299, etc...

              No molecule will be removed at step 0, so if StartStep=0
              the first molecules are removed at the step number equal
              to [Frequency].

            * **StopStep** (*int** | **IntKey*) -- Do not remove the
              specified molecules after this step.

            * **SafeBox** (*AMSBatch._MolecularDynamics._RemoveMolecu
              les._SafeBox*) -- Part of the simulation box where
              molecules may not be removed. Only one of the SinkBox or
              SafeBox blocks may be present. If this block is present
              the molecule will not be removed if any of its atoms is
              within the box. For a periodic dimension it is given as
              a fraction of the simulation box (the full 0 to 1 range
              by default). For a non-periodic dimension it represents
              absolute Cartesian coordinates in Angstrom.

            * **SinkBox** (*AMSBatch._MolecularDynamics._RemoveMolecu
              les._SinkBox*) -- Part of the simulation box where
              matching molecules will be removed. By default,
              molecules matching the formula will be removed
              regardless of their location. If this block is present
              then such a molecule will only be removed if any of its
              atoms is within the box. For a periodic dimension it is
              given as a fraction of the simulation box (the full 0 to
              1 range by default). For a non-periodic dimension it
              represents absolute Cartesian coordinates in Angstrom.

         class _SafeBox

            Part of the simulation box where molecules may not be
            removed. Only one of the SinkBox or SafeBox blocks may be
            present. If this block is present the molecule will not be
            removed if any of its atoms is within the box. For a
            periodic dimension it is given as a fraction of the
            simulation box (the full 0 to 1 range by default). For a
            non-periodic dimension it represents absolute Cartesian
            coordinates in Angstrom.

            Variables:
               * **Amax** (*float** | **FloatKey*) -- Coordinate of
                 the upper bound along the first axis.

               * **Amin** (*float** | **FloatKey*) -- Coordinate of
                 the lower bound along the first axis.

               * **Bmax** (*float** | **FloatKey*) -- Coordinate of
                 the upper bound along the second axis.

               * **Bmin** (*float** | **FloatKey*) -- Coordinate of
                 the lower bound along the second axis.

               * **Cmax** (*float** | **FloatKey*) -- Coordinate of
                 the upper bound along the third axis.

               * **Cmin** (*float** | **FloatKey*) -- Coordinate of
                 the lower bound along the third axis.

               * **FractionalCoordsBox** (*Iterable**[**float**] **|
                 **FloatListKey*) --

                 Do not remove molecules that are (partly) inside the
                 safe box.

                 Borders of the safe box specified as: Amin, Amax,
                 Bmin, Bmax, Cmin, Cmax.

                 For periodic dimensions fractional coordinates
                 between 0 and 1 and for non-periodic dimensions
                 Cartesian values in Angstrom are expected.

         class _SinkBox

            Part of the simulation box where matching molecules will
            be removed. By default, molecules matching the formula
            will be removed regardless of their location. If this
            block is present then such a molecule will only be removed
            if any of its atoms is within the box. For a periodic
            dimension it is given as a fraction of the simulation box
            (the full 0 to 1 range by default). For a non-periodic
            dimension it represents absolute Cartesian coordinates in
            Angstrom.

            Variables:
               * **Amax** (*float** | **FloatKey*) -- Coordinate of
                 the upper bound along the first axis.

               * **Amin** (*float** | **FloatKey*) -- Coordinate of
                 the lower bound along the first axis.

               * **Bmax** (*float** | **FloatKey*) -- Coordinate of
                 the upper bound along the second axis.

               * **Bmin** (*float** | **FloatKey*) -- Coordinate of
                 the lower bound along the second axis.

               * **Cmax** (*float** | **FloatKey*) -- Coordinate of
                 the upper bound along the third axis.

               * **Cmin** (*float** | **FloatKey*) -- Coordinate of
                 the lower bound along the third axis.

               * **FractionalCoordsBox** (*Iterable**[**float**] **|
                 **FloatListKey*) --

                 Remove molecules that are (partly) inside the sink
                 box.

                 Borders of the sink box specified as: Amin, Amax,
                 Bmin, Bmax, Cmin, Cmax.

                 For periodic dimensions fractional coordinates
                 between 0 and 1 and for non-periodic dimensions
                 Cartesian values in Angstrom are expected.

      class _ReplicaExchange

         This block is used for (temperature) Replica Exchange MD
         (Parallel Tempering) simulations.

         Variables:
            * **AllowWrongResults** (*BoolType** | **BoolKey*) --
              Allow combining Replica Exchange with other features
              when the combination is known to produce physically
              incorrect results.

            * **EWMALength** (*int** | **IntKey*) --

              Length of the exponentially weighted moving average used
              to smooth swap probabilities for monitoring.

              This value is equal to the inverse of the EWMA mixing
              factor.

            * **SwapFrequency** (*int** | **IntKey*) -- Attempt an
              exchange every N steps.

            * **TemperatureFactors** (*Iterable**[**float**] **|
              **FloatListKey*) --

              This is the ratio of the temperatures of two successive
              replicas.

              The first value sets the temperature of the second
              replica with respect to the first replica, the second
              value sets the temperature of the third replica with
              respect to the second one, and so on. If there are fewer
              values than nReplicas, the last value of
              TemperatureFactor is used for all the remaining
              replicas.

            * **Temperatures** (*Iterable**[**float**] **|
              **FloatListKey*) --

              List of temperatures for all replicas except for the
              first one.

              This is mutually exclusive with TemperatureFactors.
              Exactly nReplicas-1 temperature values need to be
              specified, in increasing order. The temperature of the
              first replica is given by [Thermostat%Temperature].

            * **nReplicas** (*int** | **IntKey*) -- Number of replicas
              to run in parallel.

      class _Shake

         Parameters of the Shake/Rattle algorithm.

         Variables:
            * **All** (*str** | **StringKey*) --

              Constraint description in one the following formats:
              All [bondOrder] bonds at1 at2 [to distance] All
              triangles at1 at2 at3

              The first option constrains all bonds between atoms at1
              at2 to a certain length, while the second - bonds
              at1-at2 and at2-at3 and the angle between them.

              The [bondOrder] can be a number or a string such as
              single, double, triple or aromatic. If it's omitted then
              all bonds between specified atoms will be constrained.
              Atom names are case-sensitive and they must be as they
              are in the Atoms block, or an asterisk '*' denoting any
              atom. The distance, if present, must be in Angstrom. If
              it is omitted then the bond length from the initial
              geometry is used.

              Important: only the bonds present in the system at
              certain points of the simulation (at the start or right
              after adding/removing atoms) can be constrained, which
              means that the bonds may need to be specified in the
              System block.

              Warning: the triangles constraint should be used with
              care because each constrained bond or angle means
              removing one degree of freedom from the dynamics. When
              there are too many constraints (for example, "All
              triangles H C H" in methane) some of them may be
              linearly dependent, which will lead to an error in the
              temperature computation.

              Valid examples: All single bonds C C to 1.4 All bonds O
              H to 0.98 All bonds O H All bonds H * All triangles H *
              H

            * **ConvergeR2** (*float** | **FloatKey*) -- Convergence
              criterion on the max squared difference, in atomic
              units.

            * **ConvergeRV** (*float** | **FloatKey*) -- Convergence
              criterion on the orthogonality of the constraint and the
              relative atomic velocity, in atomic units.

            * **ExcludeRegion** (*str** | **StringKey*) -- Exclude all
              atoms covered by this region expression from all
              constraints. If both atoms of a bond belong to
              ExcludeRegion, the bond will be kept unconstrained,
              regardless of Shake%All or engine-specific constraints.

            * **Iterations** (*int** | **IntKey*) -- Number of
              iterations.

            * **ShakeInitialCoordinates** (*BoolType** | **BoolKey*)
              -- Apply constraints before computing the first energy
              and gradients.

      class _Thermostat

         This block allows to specify the use of a thermostat during
         the simulation. Depending on the selected thermostat type,
         different additional options may be needed to characterize
         the specific thermostat's behavior.

         Variables:
            * **BerendsenApply** (*Literal**[**"Local"**,
              **"Global"**]*) --

              Select how to apply the scaling correction for the
              Berendsen thermostat:

              * per-atom-velocity (Local)

              * on the molecular system as a whole (Global).

            * **ChainLength** (*int** | **IntKey*) -- Number of
              individual thermostats forming the NHC thermostat

            * **Duration** (*Iterable**[**int**] **| **IntListKey*) --
              Specifies how many steps should a transition from a
              particular temperature to the next one in sequence take.

            * **ExcludedDirection** (*Literal**[**"None"**, **"X"**,
              **"Y"**, **"Z"**]*) -- Exclude a component of the
              velocities from rescaling by the thermostat. For example
              in NEMD simulations, when a shear force/velocity is
              applied in the x direction, the x-direction is often
              excluded from thermostatting. This currently only works
              for the Nose-Hoover thermostat.

            * **Friction** (*float** | **FloatKey*) -- Friction
              coefficient used in langevin dynamics

            * **Region** (*str** | **StringKey*) -- The identifier of
              the region to thermostat. The default *** applies the
              thermostat to the entire system. The value can by a
              plain region name, or a region expression, e.g.
              **-myregion* to thermostat all atoms that are not in
              myregion, or *regionA+regionB* to thermostat the union
              of the 'regionA' and 'regionB'. Note that if multiple
              thermostats are used, their regions may not overlap.

            * **ScaleFrequency** (*int** | **IntKey*) --

              Optional parameter used only by the Scale thermostat.

              If specified, the thermostat will be applied every N
              steps, using that step's ensemble temperature and the
              specified thermostat temperature to compute the scaling
              factor.

              If not specified, the thermostat will be applied at
              every step, using the mean temperature of the ensemble
              and the specified thermostat temperature to compute the
              scaling factor.

            * **Tau** (*float** | **FloatKey*) -- The time constant of
              the thermostat.

            * **Temperature** (*Iterable**[**float**] **|
              **FloatListKey*) --

              The target temperature of the thermostat.

              You can specify multiple temperatures (separated by
              spaces). In that case the Duration field specifies how
              many steps to use for the transition from one T to the
              next T (using a linear ramp). For NHC thermostat, the
              temperature may not be zero.

            * **Type** (*Literal**[**"None"**, **"Scale"**,
              **"Berendsen"**, **"NHC"**, **"Langevin"**]*) -- Selects
              the type of the thermostat.

      class _Trajectory

         Sets the frequency for printing to stdout and storing the
         molecular configuration on the .rkf file.

         Variables:
            * **EngineResultsFreq** (*int** | **IntKey*) -- Write
              MDStep*.rkf files with engine-specific results once
              every N steps. Setting this to zero disables writing
              engine results files except for one file at the end of
              the simulation. If this is set to a negative value, the
              value of Checkpoint%Frequency will be used instead.

            * **ExitConditionFreq** (*int** | **IntKey*) -- Check the
              exit conditions every N steps. By default this is done
              every SamplingFreq steps.

            * **PrintFreq** (*int** | **IntKey*) -- Print current
              thermodynamic properties to the output every N steps. By
              default this is done every SamplingFreq steps.

            * **SamplingFreq** (*int** | **IntKey*) -- Write the
              molecular geometry (and possibly other properties) to
              the ams.rkf file once every N steps.

            * **TProfileGridPoints** (*int** | **IntKey*) -- Number of
              points in the temperature profile. If TProfileGridPoints
              > 0, a temperature profile along each of the three
              lattice axes will be written to the .rkf file. The
              temperature at a given profile point is calculated as
              the total temperature of all atoms inside the
              corresponding slice of the simulation box, time-averaged
              over all MD steps since the previous snapshot.​ By
              default, no profile is generated.

            * **WriteBonds** (*BoolType** | **BoolKey*) -- Write
              detected bonds to the .rkf file.

            * **WriteCharges** (*BoolType** | **BoolKey*) -- Write
              current atomic point charges (if available) to the .rkf
              file. Disable this to reduce trajectory size if you do
              not need to analyze charges.

            * **WriteCoordinates** (*BoolType** | **BoolKey*) -- Write
              atomic coordinates to the .rkf file.

            * **WriteEngineGradients** (*BoolType** | **BoolKey*) --
              Write atomic gradients (negative of the atomic forces,
              as calculated by the engine) to the History section of
              ams.rkf.

            * **WriteMolecules** (*BoolType** | **BoolKey*) -- Write
              the results of molecule analysis to the .rkf file.

            * **WriteVelocities** (*BoolType** | **BoolKey*) -- Write
              velocities to the .rkf file. Disable this to reduce
              trajectory size if you do not need to analyze the
              velocities.

      class _fbMC

         This block sets up force bias Monte Carlo interleaved with
         the molecular dynamics simulation.

         Variables:
            * **Frequency** (*int** | **IntKey*) -- Run the fbMC
              procedure every Frequency MD steps.

            * **MassRoot** (*float** | **FloatKey*) -- Inverse of the
              exponent used to mass-weight fbMC steps.

            * **NSteps** (*int** | **IntKey*) -- Number of fbMC steps
              to perform on every invocation of the procedure.

            * **PrintFreq** (*int** | **IntKey*) -- Print current
              thermodynamic properties to the output every N fbMC
              steps. This defaults to the PrintFreq set in the
              Trajectory block. Setting this to zero disables printing
              fbMC steps.

            * **StartStep** (*int** | **IntKey*) -- First step at
              which the fbMC procedure may run.

            * **StepLength** (*float** | **FloatKey*) -- Maximum
              allowed displacement of the lightest atom in the system
              in each Cartesian coordinate in one fbMC step.

            * **StopStep** (*int** | **IntKey*) -- Last step at which
              the fbMC procedure may run. If unset or zero, there is
              no limit.

            * **Temperature** (*float** | **FloatKey*) -- Temperature
              used for fbMC.

            * **MolecularMoves**
              (*AMSBatch._MolecularDynamics._fbMC._MolecularMoves*) --
              Move molecules as rigid bodies in addition to normal
              atomic moves.

         class _MolecularMoves

            Move molecules as rigid bodies in addition to normal
            atomic moves.

            Variables:
               * **Enabled** (*BoolType** | **BoolKey*) -- Enable
                 moving molecules as rigid bodies based on net forces
                 and torques. Ordinary per-atom displacements will
                 then be based on residual atomic forces.

               * **RotationMethod** (*Literal**[**"Mees"**,
                 **"Rao"**]*) -- Select the fbMC method used to
                 generate molecular rotation moves.

               * **RotationStepAngle** (*float** | **FloatKey*) --
                 Maximum allowed angle of rotation of each molecule in
                 one fbMC step.

               * **TranslationStepLength** (*float** | **FloatKey*) --
                 Maximum allowed displacement of each molecule in each
                 Cartesian coordinate in one fbMC step.

   class _Molecules

      Configures details of the molecular composition analysis enabled
      by the Properties%Molecules block.

      Variables:
         * **AdsorptionSupportRegion** (*str** | **StringKey*) --
           Select region that will represent a support for adsorption
           analysis. Adsorbed molecules will receive an '(ads)' suffix
           after name of the element bonded to the support. Such
           elements will be listed separate from atoms of the same
           element not bonded to the support, for example, HOH(ads)
           for a water molecule bonded to a surface via one of its H
           atoms.

         * **BondOrderCutoff** (*float** | **FloatKey*) -- Bond order
           cutoff for analysis of the molecular composition. Bonds
           with bond order smaller than this value are neglected when
           determining the molecular composition.

   class _NEB

      Configures details of the Nudged Elastic Band optimization.

      Variables:
         * **Climbing** (*BoolType** | **BoolKey*) -- Use the climbing
           image algorithm to drive the highest image to the
           transition state.

         * **ClimbingThreshold** (*float** | **FloatKey*) -- Climbing
           image force threshold. If ClimbingThreshold > 0 and the max
           perpendicular force component is above the threshold then
           no climbing is performed at this step. This entry can be
           used to get a better approximation for the reaction path
           before starting the search for the transition state. A
           typical value is 0.01 Hartree/Bohr.

         * **DoubleNudge** (*Literal**[**"None"**, **"Henkelman"**,
           **"Trygubenko"**]*) -- Type of the double nudging method.

         * **Images** (*int** | **IntKey*) -- Number of NEB images
           (not counting the chain ends). Using more images will
           result in a smoother reaction path and can help with
           convergence problems, but it will also increase the
           computation time.

         * **Intermediates** (*str** | **StringKey*) --

           Define one or more intermediate systems.

           The molecule names are adjusted when saving so that the
           order of the intermediates is the order as they appear in
           the list here.

           If no intermediate systems are needed, select None

         * **InterpolateInternal** (*BoolType** | **BoolKey*) -- The
           initial NEB image geometries are calculated by
           interpolating between the initial and the final state. By
           default, for non-periodic systems the interpolation is
           performed in internal coordinates but the user can choose
           to do it in the Cartesian ones. For periodic systems the
           interpolation is always done in Cartesian coordinates. If
           PreOptimizeWithIDPP is set then the path may be further
           refined using the image-dependent pair potential (IDPP).

         * **InterpolateShortest** (*BoolType** | **BoolKey*) -- Allow
           interpolation across periodic cell boundaries. Set to false
           if an atom is intended to move more than half across the
           simulation box during reaction.

         * **InterpolationOption** (*int** | **IntKey*) --

           Select which internal coordinates will be interpolated:

           0 - automatic,
              1 - only distances,  2 - distances and near-linear
              valence angles,  3 - distances and all valence angles,
              4 - distances and dihedral angles,  99 - all coordinates

         * **Iterations** (*int** | **IntKey*) -- Maximum number of
           NEB iterations. The default value depends on the number of
           degrees of freedom (number of images, atoms, periodic
           dimensions).

         * **Jacobian** (*float** | **FloatKey*) -- Scaling factor
           used to convert the lattice strain to a NEB coordinate
           value. Default value: sqrt(N)*(V/N)^(1/d), where V -
           lattice volume (area for 2D, length for 1D), N - number of
           atoms, and d - number of periodic dimensions.

         * **MapAtomsToCell** (*BoolType** | **BoolKey*) -- Translate
           atoms to the [-0.5,0.5] cell before every step. This option
           cannot be disabled for SS-NEB.

         * **OldTangent** (*BoolType** | **BoolKey*) -- Turn on the
           old central difference tangent.

         * **OptimizeEnds** (*BoolType** | **BoolKey*) -- Start the
           NEB with optimization of the reactant and product
           geometries.

         * **OptimizeLattice** (*BoolType** | **BoolKey*) -- Turn on
           the solid-state NEB (SS-NEB).

         * **PreOptimizeWithIDPP** (*BoolType** | **BoolKey*) --
           (Experimental) When there is only initial and final system
           available, the image-dependent pair potential (IDPP, doi:
           10.1063/1.4878664) can be used to determine the initial NEB
           path by interpolating all interatomic distances between the
           two points and optimizing intermediate images towards them.
           The optimization starts from the geometries obtained using
           the selected interpolation options.

         * **ReOptimizeEnds** (*BoolType** | **BoolKey*) -- Re-
           optimize reactant and product geometries upon restart.

         * **Restart** (*str** | **Path** | **StringKey*) -- Provide
           an ams.rkf file from a previous NEB calculation to restart
           from. It can be an unfinished NEB calculation or one
           performed with different engine parameters.

         * **Skewness** (*float** | **FloatKey*) -- Degree of how much
           images are shifted towards or away from the TS, which may
           help tackle problems with a long reaction path (for example
           involving a loose adsorption complex) without needing too
           many images. A value greater than 1 will make sure that
           images are concentrated near the transition state. The
           optimal value depends on the path length, the number of
           images (larger [Skewness] may be needed for a longer path
           and fewer images). Technically [Skewness] is equal to the
           ratio between the optimized distances to the lower and the
           higher neighbor image on the path.

         * **Spring** (*float** | **FloatKey*) -- Spring force
           constant in atomic units.

         * **LoadPath** (*AMSBatch._NEB._LoadPath*) -- Provide details
           about the trajectory to get the initial NEB path from.
           PESScan and NEB trajectories are supported. Only the last
           geometry for each point on the trajectory is considered.

         * **Parallel** (*AMSBatch._NEB._Parallel*) -- Options for
           double parallelization, which allows to split the available
           processor cores into groups working through all the
           available tasks in parallel, resulting in a better parallel
           performance. The keys in this block determine how to split
           the available processor cores into groups working in
           parallel.

      class _LoadPath

         Provide details about the trajectory to get the initial NEB
         path from. PESScan and NEB trajectories are supported. Only
         the last geometry for each point on the trajectory is
         considered.

         Variables:
            * **File** (*str** | **Path** | **StringKey*) --

              Provide an ams.rkf file to load the initial path from.
              All geometries of this calculation, including initial
              and final, will be taken from the History section of the
              file.

              Note that for a PESScan it should be a 1D path.

            * **Geometries** (*Iterable**[**int**] **| **IntListKey*)
              -- Raw indices of the geometries from the History
              section. By default the last geometry of each path point
              is used.

            * **Points** (*Iterable**[**int**] **| **IntListKey*) --
              By default the whole path is used, which may sometimes
              be not desirable. For example when a PESScan revealed
              multiple barriers. In this case one can specify indices
              of the path points to be used. The last geometry of the
              specified path point will be loaded.

      class _Parallel

         Options for double parallelization, which allows to split the
         available processor cores into groups working through all the
         available tasks in parallel, resulting in a better parallel
         performance. The keys in this block determine how to split
         the available processor cores into groups working in
         parallel.

         Variables:
            * **nCoresPerGroup** (*int** | **IntKey*) -- Number of
              cores in each working group.

            * **nGroups** (*int** | **IntKey*) -- Total number of
              processor groups. This is the number of tasks that will
              be executed in parallel.

            * **nNodesPerGroup** (*int** | **IntKey*) -- Number of
              nodes in each group. This option should only be used on
              homogeneous compute clusters, where all used compute
              nodes have the same number of processor cores.

   class _NormalModes

      Configures details of a normal modes calculation.

      Variables:
         * **Displacements** (*Literal**[**"Cartesian"**,
           **"Symmetric"**, **"Block"**]*) --

           Type of displacements.

           In case of symmetric displacements it is possible to choose
           only the modes that have non-zero IR or Raman intensity.

           Block displacements take rigid blocks into account.

         * **Hessian** (*Literal**[**"Auto"**, **"Analytical"**,
           **"Numerical"**]*) -- Default Auto means that if possible
           by the engine the Hessian will be calculated analytically,
           else the Hessian will be calculated numerically by AMS.

         * **ReScanFreqRange** (*Iterable**[**float**] **|
           **FloatListKey*) -- Specifies a frequency range within
           which all modes will be scanned. 2 numbers: an upper and a
           lower bound.

         * **ReScanModes** (*BoolType** | **BoolKey*) -- Whether or
           not to scan imaginary modes after normal modes calculation
           has concluded.

         * **UseSymmetry** (*BoolType** | **BoolKey*) -- Whether or
           not to exploit the symmetry of the system in the normal
           modes calculation.

         * **BlockDisplacements**
           (*AMSBatch._NormalModes._BlockDisplacements*) -- Configures
           details of a Block Normal Modes (a.k.a. Mobile Block
           Hessian, or MBH) calculation.

         * **SymmetricDisplacements**
           (*AMSBatch._NormalModes._SymmetricDisplacements*) --
           Configures details of the calculation of the frequencies
           and normal modes of vibration in symmetric displacements.

      class _BlockDisplacements

         Configures details of a Block Normal Modes (a.k.a. Mobile
         Block Hessian, or MBH) calculation.

         Variables:
            * **AngularDisplacement** (*float** | **FloatKey*) --
              Relative step size for rotational degrees of freedom
              during Block Normal Modes finite difference
              calculations. It will be scaled with the characteristic
              block size.

            * **BlockAtoms** (*Iterable**[**int**] **| **IntListKey*)
              -- List of atoms belonging to a block. You can have
              multiple BlockAtoms.

            * **BlockRegion** (*str** | **StringKey*) -- The region to
              to be considered a block. You can have multiple
              BlockRegions, also in combination with BlockAtoms.

            * **RadialDisplacement** (*float** | **FloatKey*) -- Step
              size for translational degrees of freedom during Block
              Normal Modes finite difference calculations.

            * **Parallel**
              (*AMSBatch._NormalModes._BlockDisplacements._Parallel*)
              -- Configuration for how the individual displacements
              are calculated in parallel.

         class _Parallel

            Configuration for how the individual displacements are
            calculated in parallel.

            Variables:
               * **nCoresPerGroup** (*int** | **IntKey*) -- Number of
                 cores in each working group.

               * **nGroups** (*int** | **IntKey*) -- Total number of
                 processor groups. This is the number of tasks that
                 will be executed in parallel.

               * **nNodesPerGroup** (*int** | **IntKey*) -- Number of
                 nodes in each group. This option should only be used
                 on homogeneous compute clusters, where all used
                 compute nodes have the same number of processor
                 cores.

      class _SymmetricDisplacements

         Configures details of the calculation of the frequencies and
         normal modes of vibration in symmetric displacements.

         Variables:
            **Type** (*Literal**[**"All"**, **"Infrared"**,
            **"Raman"**, **"InfraredAndRaman"**]*) --

            For symmetric molecules it is possible to choose only the
            modes that have non-zero IR or Raman intensity (or either
            of them) by symmetry.

            In order to calculate the Raman intensities the Raman
            property must be requested.

   class _NumericalDifferentiation

      Define options for numerical differentiations, that is the
      numerical calculation of gradients, Hessian and the stress
      tensor for periodic systems.

      Variables:
         * **NuclearStepSize** (*float** | **FloatKey*) -- Step size
           for numerical nuclear gradient calculation.

         * **StrainStepSize** (*float** | **FloatKey*) -- Step size
           (relative) for numerical stress tensor calculation.

         * **UseSymmetry** (*BoolType** | **BoolKey*) -- Whether or
           not to exploit the symmetry of the system for numerical
           differentiations.

         * **Parallel**
           (*AMSBatch._NumericalDifferentiation._Parallel*) -- Options
           for double parallelization, which allows to split the
           available processor cores into groups working through all
           the available tasks in parallel, resulting in a better
           parallel performance. The keys in this block determine how
           to split the available processor cores into groups working
           in parallel.

      class _Parallel

         Options for double parallelization, which allows to split the
         available processor cores into groups working through all the
         available tasks in parallel, resulting in a better parallel
         performance. The keys in this block determine how to split
         the available processor cores into groups working in
         parallel.

         Variables:
            * **nCoresPerGroup** (*int** | **IntKey*) -- Number of
              cores in each working group.

            * **nGroups** (*int** | **IntKey*) -- Total number of
              processor groups. This is the number of tasks that will
              be executed in parallel.

            * **nNodesPerGroup** (*int** | **IntKey*) -- Number of
              nodes in each group. This option should only be used on
              homogeneous compute clusters, where all used compute
              nodes have the same number of processor cores.

   class _NumericalPhonons

      Configures details of a numerical phonons calculation.

      Variables:
         * **AutomaticBZPath** (*BoolType** | **BoolKey*) -- If True,
           compute the phonon dispersion curve for the standard path
           through the Brillouin zone. If False, you must specify your
           custom path in the [BZPath] block.

         * **BornEffCharge** (*float** | **FloatKey*) -- Input option
           to give the Born effective charges of the species.

         * **DielectricConst** (*float** | **FloatKey*) -- Input
           option to give the static dielectric constant of the
           species.

         * **DoubleSided** (*BoolType** | **BoolKey*) -- By default a
           two-sided (or quadratic) numerical differentiation of the
           nuclear gradients is used. Using a single-sided (or linear)
           numerical differentiation is computationally faster but
           much less accurate. Note: In older versions of the program
           only the single-sided option was available.

         * **Interpolation** (*int** | **IntKey*) -- Use interpolation
           to generate smooth phonon plots.

         * **KPathFinderConvention** (*Literal**[**"Setyawan-
           Curtarolo"**, **"Hinuma"**]*) --

           This option determines how the path through the Brillouin
           zone is generated when using the automatic k-point mode.

           Available options:

           * "Setyawan-Curtarolo" (default for 1D and 2D lattices):
             Uses our built-in KPath program to find a path through
             high-symmetry points based on the method by Setyawan and
             Curtarolo
             (https://doi.org/10.1016/j.commatsci.2010.05.010). For 2D
             lattices, the path is derived from the intersection of
             the 3D Brillouin zone with a plane. For 1D lattices, the
             path is simply Gamma-Z.

           * "Hinuma": Uses the external SeeKPath utility to generate
             the k-path (https://github.com/giovannipizzi/seekpath and
             https://doi.org/10.1016/j.commatsci.2016.10.015).

         * **MaxTemperature** (*float** | **FloatKey*) -- Maximum
           temperature for the thermodynamic properties calculation
           (Internal Energy, Free Energy, Specific Heat, and Entropy).
           This value sets the upper limit of the temperature range
           considered. It is used in conjunction with "NTemperatures"
           to define the temperature grid. The calculation of
           thermodynamic properties is performed only if the phonon
           density of states (DOS) is requested (i.e., "Phonons%DOS"
           is set to "Yes").

         * **NDosEnergies** (*int** | **IntKey*) -- Nr. of energies
           used to calculate the phonon DOS used to integrate
           thermodynamic properties. For fast compute engines this may
           become time limiting and smaller values can be tried.

         * **NTemperatures** (*int** | **IntKey*) -- Number of
           temperature points to use in the thermodynamic properties
           calculation (Internal Energy, Free Energy, Specific Heat,
           and Entropy). This value, along with "MaxTemperature",
           determines the density of the temperature grid.  The
           temperatures will be distributed evenly between 0 Kelvin
           and 'MaxTemperature'. The calculation of thermodynamic
           properties is performed only if the phonon density of
           states (DOS) is requested (i.e., "Phonons%DOS" is set to
           "Yes").

         * **RequestContinuousPES** (*BoolType** | **BoolKey*) --
           Whether or not the engine should be instructed to disable
           symmetry. AMS versions older than AMS2024 would use the the
           hard coded value false.

         * **StepSize** (*float** | **FloatKey*) -- Step size to be
           taken to obtain the force constants (second derivative)
           from the analytical gradients numerically.

         * **UseSymmetry** (*BoolType** | **BoolKey*) -- Whether or
           not to exploit the symmetry of the system in the phonon
           calculation.

         * **BZPath** (*AMSBatch._NumericalPhonons._BZPath*) -- If
           [NumericalPhonons%AutomaticBZPath] is false, the phonon
           dispersion curve will be computed for the user-defined path
           in the [BZPath] block. You should define the vertices of
           your path in fractional coordinates (with respect to the
           reciprocal lattice vectors) in the [Path] sub-block. If you
           want to make a jump in your path (i.e. have a discontinuous
           path), you need to specify a new [Path] sub-block.

         * **Parallel** (*AMSBatch._NumericalPhonons._Parallel*) --
           Options for double parallelization, which allows to split
           the available processor cores into groups working through
           all the available tasks in parallel, resulting in a better
           parallel performance. The keys in this block determine how
           to split the available processor cores into groups working
           in parallel.

         * **SuperCell** (*str** | **Sequence**[**str**] **|
           **FreeBlock*) -- Used for the phonon run. The super lattice
           is expressed in the lattice vectors. Most people will find
           a diagonal matrix easiest to understand.

      class _BZPath

         If [NumericalPhonons%AutomaticBZPath] is false, the phonon
         dispersion curve will be computed for the user-defined path
         in the [BZPath] block. You should define the vertices of your
         path in fractional coordinates (with respect to the
         reciprocal lattice vectors) in the [Path] sub-block. If you
         want to make a jump in your path (i.e. have a discontinuous
         path), you need to specify a new [Path] sub-block.

         Variables:
            **Path** (*str** | **Sequence**[**str**] **| **FreeBlock*)
            -- A section of a k space path. This block should contain
            multiple lines, and in each line you should specify one
            vertex of the path in fractional coordinates. Optionally,
            you can add text labels for your vertices at the end of
            each line.

         class _Path

            A section of a k space path. This block should contain
            multiple lines, and in each line you should specify one
            vertex of the path in fractional coordinates. Optionally,
            you can add text labels for your vertices at the end of
            each line.

      class _Parallel

         Options for double parallelization, which allows to split the
         available processor cores into groups working through all the
         available tasks in parallel, resulting in a better parallel
         performance. The keys in this block determine how to split
         the available processor cores into groups working in
         parallel.

         Variables:
            * **nCoresPerGroup** (*int** | **IntKey*) -- Number of
              cores in each working group.

            * **nGroups** (*int** | **IntKey*) -- Total number of
              processor groups. This is the number of tasks that will
              be executed in parallel.

            * **nNodesPerGroup** (*int** | **IntKey*) -- Number of
              nodes in each group. This option should only be used on
              homogeneous compute clusters, where all used compute
              nodes have the same number of processor cores.

      class _SuperCell

         Used for the phonon run. The super lattice is expressed in
         the lattice vectors. Most people will find a diagonal matrix
         easiest to understand.

   class _PESExploration

      Configures details of the automated PES exploration methods.

      Variables:
         * **CalculateEnergyReferences** (*BoolType** | **BoolKey*) --
           Calculates the energy references.

         * **CalculateFragments** (*BoolType** | **BoolKey*) -- The
           reference region must be defined using the
           StatesAlignment%ReferenceRegion keyword. This enables the
           distinction between two parts of the chemical system: the
           adsorbent, identified by the reference region, and the
           adsorbate, which comprises the remaining portion. This
           keyword initiates a geometry optimization calculation for
           both the adsorbate and adsorbent individually for each
           state in the database at the end of the execution.
           Fragmented states are included in the energy landscape.
           This keyword does not apply to LandscapeRefinement
           calculations.

         * **DynamicSeedStates** (*BoolType** | **BoolKey*) -- Whether
           subsequent expeditions may start from states discovered by
           previous expeditions. This should lead to a more
           comprehensive exploration of the potential energy surface.
           Disabling this will focus the PES exploration around the
           initial seed states.

         * **ExcludeReflectionAxes** (*Literal**[**"x"**, **"y"**,
           **"z"**, **"None"**]*) -- Determines which axial
           reflections ('x', 'y', or 'z') to exclude when generating
           symmetry images. This parameter is active only if
           [GenerateSymmetryImages] is *True*. The default 'z' axis
           exclusion is commonly used for 2D systems (e.g., slabs) to
           prevent unintended projection of binding sites across the
           slab plane.

         * **FiniteDifference** (*float** | **FloatKey*) -- The finite
           difference distance to use for Dimer, Hessian, Lanczos, and
           optimization methods.

         * **GenerateSymmetryImages** (*BoolType** | **BoolKey*) -- By
           activating this option, after concluding the energy
           landscape exploration process, it will create the complete
           set of symmetry-related copies by using the symmetry
           operators of the reference structure. SinglePoint
           calculations (including gradients and normal modes) are
           carried out for each new image structure obtained.

         * **Job** (*Literal**[**"ProcessSearch"**,
           **"BasinHopping"**, **"SaddleSearch"**,
           **"LandscapeRefinement"**, **"BindingSites"**,
           **"NudgedElasticBand"**, **"SystemMatching"**]*) -- Specify
           the PES exploration job to perform.

         * **NegativeEigenvalueTolerance** (*float** | **FloatKey*) --
           The threshold in Hessian eigenvalue below which a mode is
           considered imaginary, i.e. indicating a transition state.
           This is a small negative number, as very small negative
           eigenvalues may be due to numerical noise on an essentially
           flat PES and do not indicate true transition states. We
           need a more flexible value for this parameter in
           PESExploration because the high computational cost of the
           task typically forces us to reduce the engine precision,
           which increases the noise in the vibrational frequencies
           evaluation. [PESPointCharacter%NegativeEigenvalueTolerance]
           is overridden by this parameter.

         * **NumExpeditions** (*int** | **IntKey*) -- Sets the number
           of subsequent expeditions our job will consist of. Larger
           values result in a more comprehensive exploration of the
           potential energy surface, but will take more computational
           time.

         * **NumExplorers** (*int** | **IntKey*) -- Sets the number of
           independent PES explorers dispatched as part of each
           expedition. Larger values will result in a more
           comprehensive exploration of the potential energy surface,
           but will take more computational time. By default an
           appropriate number of explorers are executed in parallel.

         * **OptTSMethod** (*Literal**[**"SaddleSearch"**,
           **"NudgedElasticBand"**]*) -- When the full set of states
           in the energy landscape are optimized (see
           PESExploration%Job = GeometryOptimization), transition
           states can be optimized using either SaddleSearch or
           NudgedElasticBand methods. SaddleSearch uses information
           only from the current geometry of the TS; contrary,
           NudgedElasticBand ignores the current geometry and runs a
           Nudged-Elastic-Band calculation trying to connect the
           associated reactants and products if they are available.

         * **Potential** (*str** | **StringKey*) -- The PES to be
           explored. The default is to use a callback into AMS to
           evaluate the energy and gradients using an AMS engine. This
           can be changed here to give access to one of the EON
           client's builtin potentials. This has not been well tested
           by SCM.

         * **RandomSeed** (*int** | **IntKey*) -- Number used to
           initialize both the EON clients random number generators as
           well as the AMS global RNG. The latter is normally
           initialized with the RNGSeed keyword at the root level.
           Should be used by developers only. May or may not help to
           make more reproducible regression tests ...

         * **SelectedListedAtomsForPESPointCharacter** (*str** |
           **StringKey*) -- Uses the Hessian matrix elements only for
           the listed atoms to determine the PES point character of a
           located state during the exploration. If not specified, the
           full Hessian is used.

         * **SelectedRegionForPESPointCharacter** (*str** |
           **StringKey*) -- Uses the Hessian matrix elements only for
           the atoms in a particular region to determine the PES point
           character of a located state during the exploration. If not
           specified, the full Hessian is used.

         * **Temperature** (*float** | **FloatKey*) -- The temperature
           that the job will run at. This may be used in different
           ways depending on the job, e.g. acceptance probabilities
           for Monte-Carlo based jobs, thermostatting for dynamics
           based jobs, kinetic prefactors for jobs that find
           transition states. Some jobs may not use this temperature
           at all.

         * **WriteEngineGradients** (*BoolType** | **BoolKey*) --
           Write atomic gradients (negative of the atomic forces, as
           calculated by the engine) to the History section of
           ams.rkf.

         * **WriteHistory** (*Literal**[**"None"**, **"Converged"**,
           **"All"**]*) -- When to write the molecular geometry (and
           possibly other properties) to the history on the ams.rkf
           file. The default is to only write the converged geometries
           to the history. Can be changed to write no frames at all to
           the history, or write all frames (should only be used when
           testing because of the performance impact). Note that for
           parallel calculations, only the first group of processes
           writes to ams.rkf.

         * **BasinHopping** (*AMSBatch._PESExploration._BasinHopping*)
           -- Configures the details of the Basin Hopping subtask.

         * **BindingSites** (*AMSBatch._PESExploration._BindingSites*)
           -- Options related to the calculation of binding sites.

         * **Debug** (*AMSBatch._PESExploration._Debug*) -- Options
           for debugging purposes. Should only be used by developers.

         * **Dynamics** (*AMSBatch._PESExploration._Dynamics*) --
           Settings for molecular dynamics, used by dynamics-based
           search methods.

         * **Hessian** (*AMSBatch._PESExploration._Hessian*) --
           Settings for Hessian calculations and vibrational analysis.

         * **LandscapeRefinement**
           (*AMSBatch._PESExploration._LandscapeRefinement*) --
           Configures details of the energy landscape refinement job.

         * **LoadEnergyLandscape**
           (*AMSBatch._PESExploration._LoadEnergyLandscape*) --
           Options related to the loading of an Energy Landscape from
           a previous calculation.

         * **LoadInitialSystems**
           (*AMSBatch._PESExploration._LoadInitialSystems*) -- Load
           initial systems from different sources.

         * **NudgedElasticBand**
           (*AMSBatch._PESExploration._NudgedElasticBand*) -- Options
           for the Nudged Elastic Band (NEB) method.

         * **Optimizer** (*AMSBatch._PESExploration._Optimizer*) --
           Configures the details of the geometry optimizers used by
           the PES explorers.

         * **Parallel** (*AMSBatch._PESExploration._Parallel*) --
           Options for double parallelization, which allows to split
           the available processor cores into groups working through
           all the available tasks in parallel, resulting in a better
           parallel performance. The keys in this block determine how
           to split the available processor cores into groups working
           in parallel.

         * **ParallelReplica**
           (*AMSBatch._PESExploration._ParallelReplica*) -- Settings
           for the Parallel Replica Dynamics method.

         * **Prefactor** (*AMSBatch._PESExploration._Prefactor*) --
           Settings for calculating reaction rate pre-exponential
           factors.

         * **ProcessSearch**
           (*AMSBatch._PESExploration._ProcessSearch*) -- Input
           options specific to the process search procedure.

         * **SaddleSearch** (*AMSBatch._PESExploration._SaddleSearch*)
           -- Configuration for the Saddle Search procedure (used in
           SaddleSearch and ProcessSearch Jobs).

         * **StatesAlignment**
           (*AMSBatch._PESExploration._StatesAlignment*) -- Configures
           details of how the energy landscape configurations are
           aligned respect to the main chemical system [System].

         * **StructureComparison**
           (*AMSBatch._PESExploration._StructureComparison*) --
           Settings for structure comparison.

      class _BasinHopping

         Configures the details of the Basin Hopping subtask.

         Variables:
            * **AdjustDisplacement** (*BoolType** | **BoolKey*) --
              Automatically adjust the displacement size to meet the
              target acceptance ratio.

            * **AdjustFraction** (*float** | **FloatKey*) -- The
              fraction by which to change the step size in order to
              meet the target acceptance ratio.

            * **AdjustPeriod** (*int** | **IntKey*) -- The number of
              Monte Carlo steps between adjustments of the step size.

            * **DisplaceAtomsInRegion** (*str** | **StringKey*) -- If
              you specify a region name here, only the atoms belonging
              to this region will be displaced during the basin
              hopping procedure. For more details on regions, see the
              documentation on the System definition.

            * **DisplaceListedAtoms** (*str** | **StringKey*) --
              Specifies a list of atom indices (e.g., '1 5 10') to be
              exclusively considered for displacement during the basin
              hopping steps. If empty, all atoms (or those in a
              specified region) are eligible.

            * **DisplaceListedTypes** (*str** | **StringKey*) --
              Specifies a list of atom types (e.g., 'H C') to be
              exclusively considered for displacement. Atoms of these
              types will be randomly moved.

            * **Displacement** (*float** | **FloatKey*) --
              Displacement in each degree of freedom.

            * **DisplacementAlgorithm** (*Literal**[**"Standard"**,
              **"Linear"**, **"Quadratic"**]*) -- Undocumented in EON.

            * **DisplacementDistribution** (*Literal**[**"Uniform"**,
              **"Gaussian"**]*) --

              The distribution used for the displacement of each atom.

              * Gaussian: The value of the "Displacement" keyword
                serves as the standard deviation of a Gaussian
                distribution used to draw the nuclear displacements
                from.

              * A random number is selected uniformly between
                "-Displacement" and "Displacement".

            * **InitialRandomStructureProbability** (*float** |
              **FloatKey*) -- Probability to generate an entirely
              random structure to start the Basin Hopping from.

            * **JumpMax** (*int** | **IntKey*) -- The number of
              consecutive rejected steps after which jump steps should
              be taken. This serves to provide a more global search
              when the structure is stuck in a certain basin. The
              number of jump steps is assigned in jump_steps. See
              paper on the Basin Hopping with Occasional Jumping
              algorithm by Iwamatsu and Okabe: Chem. Phys. Lett. 399
              396 (2004)

            * **JumpSteps** (*int** | **IntKey*) -- The number of jump
              steps to take after the "JumpMax" number of consecutive
              rejections have taken place.

            * **MainSystemAsSeed** (*BoolType** | **BoolKey*) -- If
              true, only the main system will be used as a seed state.
              The main system is not added to the database.

            * **PESPointCharacterization** (*BoolType** | **BoolKey*)
              -- If true, a PES point characterization based on a
              vibrational analysis is carried out to confirm each
              detected state is an actual local minimum (no imaginary
              frequencies). Conversely, if this option is false, the
              PES point characterization is avoided, which will assume
              that all located states are local minima (zero
              gradients). Enabling this option is very useful for
              large systems. It circumvents the need for computing and
              diagonalizing the Hessian matrix, a typically expensive
              computational process.

            * **PushApartDistance** (*float** | **FloatKey*) -- Push
              atoms apart until no atoms are closer than this
              distance. This criterion is enforced for the initial
              structure and all those generated by random
              displacements.

            * **QuenchingSteps** (*int** | **IntKey*) -- Undocumented
              in EON.

            * **RotateNonListedAtoms** (*BoolType** | **BoolKey*) --
              If true, each iteration randomly rotates all atoms as a
              rigid body, excluding those listed in
              [BasinHopping%DisplaceListedAtoms],
              [BasinHopping%DisplaceListedTypes], or
              [BasinHopping%DisplaceAtomsInRegion].

            * **SignificantStructure** (*BoolType** | **BoolKey*) --
              If true, the Significant Structure Basin Hopping (SSBH)
              variant instead of the Raw Structure Basin Hopping
              method (RSBH). In SSBH previously found structures are
              used as initial structures for further displacements,
              see Chem. Phys. Lett. 289, 463 (1998) for a comparison
              of the two approaches.

            * **SingleAtomDisplace** (*BoolType** | **BoolKey*) -- If
              true, only one atom is displaced per step. Otherwise all
              atoms of the structure are randomly displaced.

            * **Steps** (*int** | **IntKey*) -- Number of displace &
              optimize Monte-Carlo steps to take.

            * **StopEnergy** (*float** | **FloatKey*) -- Undocumented
              in EON.

            * **SwapProbability** (*float** | **FloatKey*) -- The
              probability in range [0,1] that a swapping step takes
              place instead of a displacement step. The swap step
              selects two atoms of different elements and swaps their
              position.

            * **TargetRatio** (*float** | **FloatKey*) -- The target
              acceptance ratio that will be used to determine whether
              to increase or decrease the step size.

            * **WriteUnique** (*BoolType** | **BoolKey*) -- If true,
              all unique states found will be included in the energy
              landscape, even the rejected ones. If false, only the
              lowest energy structure will be included in the energy
              landscape.

      class _BindingSites

         Options related to the calculation of binding sites.

         Variables:
            * **Calculate** (*BoolType** | **BoolKey*) -- Calculate
              binding sites at the end of a job. Not needed for
              Binding Sites job.

            * **DistanceDifference** (*float** | **FloatKey*) -- If
              the distance between two mapped binding-sites is larger
              than this threshold, the binding-sites are considered
              different. If not specified, its value will set equal to
              [PESExploration%StructureComparison%DistanceDifference]

            * **MaxCoordinationShellsForLabels** (*int** | **IntKey*)
              -- The binding site labels are given based on the
              coordination numbers of shells in the reference region,
              using the following format: N<int><int>..., e.g., the
              label 'N334' means 3 atoms in the first coordination
              shell, 3 in the second one, and 4 in the third one. This
              parameter controls the maximum number of shells to
              include.

            * **NeighborCutoff** (*float** | **FloatKey*) -- Atoms
              within this distance of each other are considered
              neighbors for the calculation of the binding sites. If
              not specified, its value will set equal to
              [PESExploration%StructureComparison%NeighborCutoff]

            * **PositioningMethod**
              (*Literal**[**"AdsorbedAtomCoords"**,
              **"ConstantDistance"**]*) -- Determines how the binding
              site's coordinates are defined. • AdsorbedAtomCoords:
              Use the exact coordinates of the adsorbed atom as the
              binding site. • ConstantDistance: Place the binding site
              at a fixed distance from the surface. This position is
              calculated along the vector that connects the surface to
              the atom. See the
              "[PESExploration%StructureComparison%SurfaceOffset]"
              option.

            * **ReferenceRegion** (*str** | **StringKey*) -- Defines
              the region that is considered as the reference for
              binding sites detection. Binding sites are projected on
              this region using the geometry from the reference
              system. If not specified, its value will set equal to
              [PESExploration%StatesAlignment%ReferenceRegion]

            * **SurfaceOffset** (*float** | **FloatKey*) -- Sets the
              binding site's distance from the surface. This value is
              only used when
              "[PESExploration%StructureComparison%PositioningMethod]"
              is set to "ConstantDistance". The distance is measured
              from a reference point on the surface, which is the
              centroid of the adsorbate's nearest neighbor atoms.

      class _Debug

         Options for debugging purposes. Should only be used by
         developers.

         Variables:
            **KeepBadSaddles** (*BoolType** | **BoolKey*) -- If true,
            saddles that do not meet the required criteria (e.g.,
            connecting to the correct minima) are still kept in the
            database for analysis.

      class _Dynamics

         Settings for molecular dynamics, used by dynamics-based
         search methods.

         Variables:
            * **Thermostat** (*Literal**[**"andersen"**,
              **"nose_hoover"**, **"langevin"**, **"none"**]*) --
              Selects the thermostat algorithm to control the
              simulation temperature.

            * **Time** (*float** | **FloatKey*) -- The total
              simulation time for the molecular dynamics trajectory in
              femtoseconds.

            * **TimeStep** (*float** | **FloatKey*) -- The integration
              time step for the molecular dynamics simulation in
              femtoseconds.

            * **Andersen**
              (*AMSBatch._PESExploration._Dynamics._Andersen*) --
              Settings for the Andersen thermostat.

            * **Langevin**
              (*AMSBatch._PESExploration._Dynamics._Langevin*) --
              Settings for the Langevin thermostat.

            * **Nose** (*AMSBatch._PESExploration._Dynamics._Nose*) --
              Settings for the Nosé-Hoover thermostat.

         class _Andersen

            Settings for the Andersen thermostat.

            Variables:
               * **Alpha** (*float** | **FloatKey*) -- A coupling
                 parameter that influences the strength of the
                 Andersen thermostat.

               * **CollisionPeriod** (*float** | **FloatKey*) -- The
                 average time between stochastic collisions with the
                 heat bath in femtoseconds.

         class _Langevin

            Settings for the Langevin thermostat.

            Variables:
               **Friction** (*float** | **FloatKey*) -- The friction
               coefficient that determines the strength of the
               coupling to the heat bath.

         class _Nose

            Settings for the Nosé-Hoover thermostat.

            Variables:
               **Mass** (*float** | **FloatKey*) -- The fictitious
               mass of the extended degree of freedom that couples to
               the system.

      class _Hessian

         Settings for Hessian calculations and vibrational analysis.

         Variables:
            * **AtomList** (*str** | **StringKey*) -- Specifies which
              atoms to include in a partial Hessian calculation. Can
              be a list of indices (e.g., '1 2 3') or 'all'.

            * **ZeroFreqValue** (*float** | **FloatKey*) --
              Frequencies with a magnitude smaller than this value are
              considered to be zero. This helps filter out numerical
              noise associated with translational and rotational
              modes.

      class _LandscapeRefinement

         Configures details of the energy landscape refinement job.

         Variables:
            * **CalculateOnlyEnergies** (*BoolType** | **BoolKey*) --
              If true, the states' geometry is not optimized, and the
              final PES point characterization is ignored [PESExplora
              tion%LandscapeRefinement%IgnoreFinalPESPointCharacter].
              Only energy values are updated using the specified
              engine. Furthermore, normal modes and associated
              properties are copied from the previous calculation to
              avoid the typically high computational effort of the
              Hessian matrix calculation. Enabling this option implies
              that RunInitialSinglePoints='F',
              IgnoreFinalPESPointCharacter='T'.

            * **GenerateFragments** (*BoolType** | **BoolKey*) -- The
              reference region must be defined using the
              StatesAlignment%ReferenceRegion keyword. This enables
              the distinction between two parts of the chemical
              system: the adsorbent, identified by the reference
              region, and the adsorbate, which comprises the remaining
              portion. This keyword (if true) initiates a single-point
              calculation for both the adsorbate and adsorbent
              individually for each state in the database. Fragmented
              states are included in the energy landscape.

            * **IgnoreFinalPESPointCharacter** (*BoolType** |
              **BoolKey*) -- At the end of the energy landscape
              refinement job, each state is assigned a PES point
              character (MIN or TS) based on its vibrational
              frequencies before being included in the final database.
              States are only added if the PES point character after
              refinement remains unchanged. However, states are added
              without verifying if this option is "true". Nonetheless,
              vibrational frequencies are calculated and stored for
              future analysis. This option is especially useful when
              using computationally demanding engines. Because in
              those cases, precision and computational effort must be
              balanced, resulting in significant vibrational
              frequencies inaccuracies.

            * **IgnoreFinalPESPointCharacterForFragments**
              (*BoolType** | **BoolKey*) -- Same as
              "LandscapeRefinement%IgnoreFinalPESPointCharacter" but
              regarding the Fragments calculations, see option
              "LandscapeRefinement%CalculateFragments".

            * **Quiet** (*BoolType** | **BoolKey*) -- Suppress the
              output details of the geometry optimizations.

            * **RelaxFromSaddlePoint** (*BoolType** | **BoolKey*) --
              Relaxes the saddle point geometries following the
              imaginary mode to get both reactants and products.

            * **RunInitialSinglePoints** (*BoolType** | **BoolKey*) --
              If it is "true", just after loading the energy landscape
              to refine, the single energy point computations are
              disabled. Be aware that if you enable this, the output
              file's 'Initial Energy Landscape' section will display
              incorrect states' energy values. If the engine requires
              too much processing power, this option can help you save
              a small amount of time.

            * **TransitionStateSearchMethod** (*Literal**[**"Auto"**,
              **"Dimer"**]*) -- Sets the method to refine transition
              states.

            * **UseReactantsAndProductsForTSs** (*BoolType** |
              **BoolKey*) -- For the refinement of transition states,
              the reaction coordinate can be estimated using either
              the reactants or products (final system). By enabling
              this option, the difference between the initial and
              final geometries is utilized as the reaction coordinate.
              The final system with the lowest RMSD is chosen to
              determine this coordinate. For more details see the
              section [TransitionStateSearch].

      class _LoadEnergyLandscape

         Options related to the loading of an Energy Landscape from a
         previous calculation.

         Variables:
            * **ExcludeReflectionAxes** (*Literal**[**"x"**, **"y"**,
              **"z"**, **"None"**]*) -- Determines which axial
              reflections ('x', 'y', or 'z') to exclude when
              generating symmetry images. This parameter is active
              only if [BindingSites%GenerateSymmetryImages] is *True*.
              The default 'z' axis exclusion is commonly used for 2D
              systems (e.g., slabs) to prevent unintended projection
              of binding sites across the slab plane.

            * **GenerateSymmetryImages** (*BoolType** | **BoolKey*) --
              By activating this option, after loading the energy
              landscape, it will create the complete set of symmetry-
              related copies by using the symmetry operators of the
              reference structure. Be aware that rkf result files of
              the generated symmetry images are copies from the parent
              structures but only atomic coordinates are updated.

            * **KeepOnly** (*Iterable**[**int**] **| **IntListKey*) --
              Upon loading the Energy Landscape, only keep the states
              specified here. The states should be specified via a
              list of integers referring to the indices of the states
              you want to keep.

            * **Path** (*str** | **Path** | **StringKey*) -- AMS
              results folder to load an energy landscape from. In the
              text input file, you may alternatively specify a ".con"
              file in the native EON format.

            * **Remove** (*Iterable**[**int**] **| **IntListKey*) --
              Upon loading the Energy Landscape, remove (i.e. do not
              load) the states specified here. The states should be
              specified via a list of integers referring to the
              indices of the states you want to remove (i.e. the
              states you don't want to load).

            * **RemoveWithNoBindingSites** (*BoolType** | **BoolKey*)
              -- Upon loading the Energy Landscape, it removes states
              with no associated binding sites. Associated transition
              states are also removed. This is an advantageous option
              to remove physisorbed states automatically. Notice that
              it requires that the previous calculation was executed,
              enabling the option [BindingSites%Calculate].

            * **SeedStates** (*Iterable**[**int**] **| **IntListKey*)
              -- By default when you start a new PES Exploration from
              a loaded Energy Landscape, expeditions can start from
              any of the loaded minima. By using this input option,
              you can instruct the program to only use some of the
              states as 'expedition starting point'. The states that
              serve as 'expedition starting points' should be
              specified via a list of integers referring to the
              indices of the states.

      class _LoadInitialSystems

         Load initial systems from different sources.

         Variables:
            **FromKFHistory** (*AMSBatch._PESExploration._LoadInitial
            Systems._FromKFHistory*) -- Load initial systems from the
            History section of kf files.

         class _FromKFHistory

            Load initial systems from the History section of kf files.

            Variables:
               * **Path** (*str** | **Path** | **StringKey*) -- AMS
                 results folder to load the initial systems from. In
                 the text input file, you may alternatively specify a
                 ".kf" file. By default, the "ams.kf" file will be
                 used.

               * **TargetPESPointCharacter** (*Literal**[**"MIN"**,
                 **"TS"**]*) -- Selects the PES point character for
                 all loaded systems.

      class _NudgedElasticBand

         Options for the Nudged Elastic Band (NEB) method.

         Variables:
            * **ClimbingImageConvergedOnly** (*BoolType** |
              **BoolKey*) -- If true, the climbing image is only
              activated after the rest of the NEB path has reached a
              pre-defined convergence threshold.

            * **ClimbingImageMethod** (*BoolType** | **BoolKey*) --
              Use the climbing image algorithm to drive the highest
              image to the transition state.

            * **ConvergedForce** (*float** | **FloatKey*) --
              Convergence threshold for nuclear gradients. Note:
              Special value of -1.0 means using the same convergence
              criterion as the PES explorer's geometry optimizer.

            * **DoublyNudged** (*BoolType** | **BoolKey*) -- Enables
              the Doubly Nudged Elastic Band (DNEB) method, which adds
              a perpendicular spring force to better maintain equal
              spacing between images.

            * **DoublyNudgedSwitching** (*BoolType** | **BoolKey*) --
              Enables a DNEB variant where the doubly-nudged force is
              switched on and off during the optimization.

            * **ElasticBand** (*BoolType** | **BoolKey*) -- If true, a
              plain Elastic Band (EB) calculation is performed, where
              the perpendicular component of the true force is not
              removed.

            * **Images** (*int** | **IntKey*) -- Number of NEB images
              between the two endpoints.

            * **MaxIterations** (*int** | **IntKey*) -- Maximum number
              of NEB iterations.

            * **OldTangent** (*BoolType** | **BoolKey*) -- Use the old
              central difference tangent.

            * **OptMethod** (*str** | **StringKey*) -- Specifies the
              optimization method to use for relaxing the NEB images.
              If empty, the global optimizer settings are used.

            * **Spring** (*float** | **FloatKey*) -- Spring force
              constant.

      class _Optimizer

         Configures the details of the geometry optimizers used by the
         PES explorers.

         Variables:
            * **ConvergedForce** (*float** | **FloatKey*) --
              Convergence threshold for nuclear gradients.

            * **ConvergenceMetric** (*Literal**[**"norm"**,
              **"max_atom"**, **"max_component"**]*) -- Determines how
              the EON client checks the convergence of the forces.
              "norm" uses the Frobenius norm of the (3,nFreeAtoms)
              forces array. "max_atom" takes the maximum norm2 of the
              nFreeAtoms individual force vectors on the free atoms.
              "max_component" just takes the maximum of all elements
              in the array. Don't change this at the moment, as it
              will break snapshot writing to the history section of
              ams.rkf.

            * **MaxIterations** (*int** | **IntKey*) -- Maximum number
              of iterations allowed for optimizations.

            * **MaxMove** (*float** | **FloatKey*) -- The maximum
              distance any atom is allowed to move in a single
              optimization step.

            * **MaxTimeStep** (*float** | **FloatKey*) -- The maximum
              allowed time step for the optimizer to prevent
              instability.

            * **Method** (*Literal**[**"CG"**, **"QM"**, **"LBFGS"**,
              **"FIRE"**, **"SD"**]*) -- Select the method for
              geometry optimizations.

            * **TimeStep** (*float** | **FloatKey*) -- The time step
              used in dynamics-based optimizers like FIRE. It
              influences the integration of motion.

            * **CG** (*AMSBatch._PESExploration._Optimizer._CG*) --
              Settings for the Conjugate Gradient (CG) optimizer.

            * **LBFGS** (*AMSBatch._PESExploration._Optimizer._LBFGS*)
              -- Settings for the Limited-memory Broyden-Fletcher-
              Goldfarb-Shanno (LBFGS) optimizer.

            * **QM** (*AMSBatch._PESExploration._Optimizer._QM*) --
              Settings for the Quick-Min (QM) optimizer.

            * **SD** (*AMSBatch._PESExploration._Optimizer._SD*) --
              Settings for the Steepest Descent (SD) optimizer.

         class _CG

            Settings for the Conjugate Gradient (CG) optimizer.

            Variables:
               * **KnockOutMaxMove** (*BoolType** | **BoolKey*) -- If
                 true, the MaxMove constraint is ignored, potentially
                 allowing for larger steps.

               * **LineConverged** (*float** | **FloatKey*) -- The
                 convergence criterion for the line search portion of
                 the CG algorithm.

               * **LineSearch** (*BoolType** | **BoolKey*) -- If true,
                 performs a line search to find the optimal step size
                 along the conjugate direction.

               * **LineSearchMaxIter** (*int** | **IntKey*) -- The
                 maximum number of iterations allowed for the line
                 search.

               * **MaxIterBeforeReset** (*int** | **IntKey*) -- The
                 number of iterations after which the conjugate
                 gradient direction is reset to the steepest descent
                 direction. A value of 0 means it resets based on the
                 number of degrees of freedom.

               * **NoOvershooting** (*BoolType** | **BoolKey*) -- If
                 true, prevents the optimizer from overshooting the
                 minimum along the search direction.

         class _LBFGS

            Settings for the Limited-memory Broyden-Fletcher-Goldfarb-
            Shanno (LBFGS) optimizer.

            Variables:
               * **AngleReset** (*BoolType** | **BoolKey*) -- If true,
                 the LBFGS history is reset if the angle between
                 consecutive gradients is too large, indicating a
                 change in the potential energy surface curvature.

               * **AutoScale** (*BoolType** | **BoolKey*) -- If true,
                 automatically scales the step size based on previous
                 iterations.

               * **DistanceReset** (*BoolType** | **BoolKey*) -- If
                 true, the LBFGS history is reset if the step size
                 becomes excessively large.

               * **InverseCurvature** (*float** | **FloatKey*) -- An
                 initial guess for the inverse curvature (diagonal
                 elements of the inverse Hessian).

               * **Memory** (*int** | **IntKey*) -- The number of
                 previous steps (gradients and positions) to store for
                 approximating the inverse Hessian matrix.

         class _QM

            Settings for the Quick-Min (QM) optimizer.

            Variables:
               **SteepestDecent** (*BoolType** | **BoolKey*) -- If
               true, forces the optimizer to only take steepest
               descent steps, ignoring velocity information.

         class _SD

            Settings for the Steepest Descent (SD) optimizer.

            Variables:
               * **Alpha** (*float** | **FloatKey*) -- The scaling
                 factor for the step size in the direction of the
                 negative gradient.

               * **TwoPoint** (*BoolType** | **BoolKey*) -- If true,
                 uses information from two points to estimate a better
                 step size.

      class _Parallel

         Options for double parallelization, which allows to split the
         available processor cores into groups working through all the
         available tasks in parallel, resulting in a better parallel
         performance. The keys in this block determine how to split
         the available processor cores into groups working in
         parallel.

         Variables:
            * **nCoresPerGroup** (*int** | **IntKey*) -- Number of
              cores in each working group.

            * **nGroups** (*int** | **IntKey*) -- Total number of
              processor groups. This is the number of tasks that will
              be executed in parallel.

            * **nNodesPerGroup** (*int** | **IntKey*) -- Number of
              nodes in each group. This option should only be used on
              homogeneous compute clusters, where all used compute
              nodes have the same number of processor cores.

      class _ParallelReplica

         Settings for the Parallel Replica Dynamics method.

         Variables:
            * **DephaseLoopMax** (*int** | **IntKey*) -- The maximum
              number of times the dephasing procedure will be
              attempted.

            * **DephaseLoopStop** (*BoolType** | **BoolKey*) -- If
              true, the dephasing loop will stop early if a transition
              is detected during dephasing.

            * **DephaseTime** (*float** | **FloatKey*) -- The duration
              of the dephasing period, during which replicas evolve
              independently to lose correlation.

            * **PostTransitionTime** (*float** | **FloatKey*) -- The
              amount of time (in fs) the simulation continues to run
              after a transition is detected, to ensure the new state
              is stable.

            * **RefineTransition** (*BoolType** | **BoolKey*) -- If
              true, after a transition is detected, a saddle search is
              performed to precisely locate the transition state.

            * **StateCheckInterval** (*float** | **FloatKey*) -- The
              time interval (in fs) at which each replica is checked
              to see if a transition has occurred.

            * **StateSaveInterval** (*float** | **FloatKey*) -- The
              time interval (in fs) at which the state of the replicas
              is saved. A negative value disables this.

            * **StopAfterTransition** (*BoolType** | **BoolKey*) -- If
              true, the simulation will terminate after the first
              reactive event is successfully identified.

      class _Prefactor

         Settings for calculating reaction rate pre-exponential
         factors.

         Variables:
            **Rate** (*Literal**[**"HTST"**, **"QQHTST"**,
            **"None"**]*) -- Calculates reaction rate pre-exponential
            factors via: HTST (Harmonic Transition State Theory),
            QQHTST (quasi-quantum HTST), or None (disable
            calculation).

      class _ProcessSearch

         Input options specific to the process search procedure.

         Variables:
            * **MinimizationOffset** (*float** | **FloatKey*) -- After
              a saddle is found, images are placed on either side of
              the saddle along the mode and minimized to ensure that
              the saddle is connected to the original minimum and to
              locate the product state. MinimizationOffset is the
              distance those images are displaced from the saddle.

            * **MinimizeFirst** (*BoolType** | **BoolKey*) -- If true,
              every time a process search is run by a client the
              reactant will be minimized first before doing any saddle
              searches.

      class _SaddleSearch

         Configuration for the Saddle Search procedure (used in
         SaddleSearch and ProcessSearch Jobs).

         Variables:
            * **ConvergedForce** (*float** | **FloatKey*) --
              Convergence threshold for nuclear gradients. Note:
              Special value of -1.0 means using the same convergence
              criterion as the PES explorer's geometry optimizer.

            * **DisplaceAllAtoms** (*BoolType** | **BoolKey*) -- If
              true, the initial displacement is applied to all atoms
              in the system, rather than just those within a radius of
              a chosen epicenter.

            * **DisplaceAllListed** (*BoolType** | **BoolKey*) -- If
              true, all atoms specified in DisplaceListedAtoms or
              DisplaceListedTypes are displaced simultaneously.

            * **DisplaceAlongNoisyNormalModes** (*BoolType** |
              **BoolKey*) -- If true, atoms are displaced following
              the normal modes.

            * **DisplaceAlongNormalModesActiveModes** (*str** |
              **StringKey*) -- Sets the active modes to be used when
              the option [SaddleSearch%DisplaceAlongNormalModesWeight]
              is enabled. e.g. 1,2,3,5. By default, all normal modes
              are considered active.

            * **DisplaceAlongNormalModesWeight** (*float** |
              **FloatKey*) -- The probability of generating a
              displacement resulting in a random linear combination of
              the normal modes specified in
              [SaddleSearch%DisplaceAlongNormalModesActiveModes]. This
              parameter is a numeric value that should fall within the
              interval [0.0, 1.0].

            * **DisplaceAtomsInRegion** (*str** | **StringKey*) -- A
              string corresponding to the name of a region. When
              performing the initial random displacement, only
              displace atoms in the specified region.

            * **DisplaceAtomsInRegionWeight** (*float** | **FloatKey*)
              -- The probability of generating a displacement
              involving only atoms from the region specified in
              [SaddleSearch%DisplaceAtomsInRegion]. This parameter is
              a numeric value that should fall within the interval
              [0.0, 1.0].

            * **DisplaceLeastCoordinatedWeight** (*float** |
              **FloatKey*) -- Relative probability to displace with an
              epicenter that has a coordination number equal to the
              least-coordinated atom in the configuration.

            * **DisplaceListedAtomWeight** (*float** | **FloatKey*) --
              Relative probability to displace with an epicenter
              listed in displace_atomlist.

            * **DisplaceListedAtoms** (*str** | **StringKey*) -- Sets
              the active atoms to be used when the option
              [SaddleSearch%DisplaceAlongNormalModesWeight] is
              enabled. e.g. 1,2,3,5. By default, all normal modes are
              considered active.

            * **DisplaceListedTypeWeight** (*float** | **FloatKey*) --
              Relative probability to displace with an epicenter
              listed in displace_typelist.

            * **DisplaceListedTypes** (*str** | **StringKey*) -- A
              list of atom types (e.g., 'H O') to be considered as
              epicenters for displacement. Used with
              DisplaceListedTypeWeight.

            * **DisplaceMagnitude** (*float** | **FloatKey*) -- The
              standard deviation of the Gaussian displacement in each
              degree of freedom for the selected atoms.

            * **DisplaceMaxCoordination** (*int** | **IntKey*) -- The
              maximum coordination number for an atom to be eligible
              as an epicenter for an under-coordinated displacement.

            * **DisplaceMinNorm** (*float** | **FloatKey*) -- The
              minimum required norm (magnitude) of the initial
              displacement vector. If a randomly generated
              displacement is smaller than this, it is rescaled.

            * **DisplaceNotFCCHCPWeight** (*float** | **FloatKey*) --
              Relative probability to displace with an epicenter that
              is not FCC or HCP coordinated.

            * **DisplaceNotTCPBCCWeight** (*float** | **FloatKey*) --
              Relative probability to select an epicenter atom that
              does not have a Tetrahedrally Close-Packed (TCP) or
              Body-Centered Cubic (BCC) coordination environment.

            * **DisplaceNotTCPWeight** (*float** | **FloatKey*) --
              Relative probability to select an epicenter atom that
              does not have a Tetrahedrally Close-Packed (TCP)
              coordination environment.

            * **DisplaceRadius** (*float** | **FloatKey*) -- Atoms
              within this distance of the epicenter will be displaced.

            * **DisplaceRandomWeight** (*float** | **FloatKey*) --
              Relative probability to displace with a random
              epicenter.

            * **DisplaceUnderCoordinatedWeight** (*float** |
              **FloatKey*) -- Relative probability to displace with an
              epicenter with a coordination equal to or less than
              displace_max_coordination.

            * **DisplaceWaterWeight** (*float** | **FloatKey*) --
              Relative probability to select an oxygen atom from a
              water molecule as the epicenter for displacement.

            * **MaxEnergy** (*float** | **FloatKey*) -- The energy
              (relative to the starting point of the saddle search) at
              which a saddle search explorer considers the search bad
              and terminates it.

            * **MaxIterations** (*int** | **IntKey*) -- Maximum number
              of iterations for each saddle search run.

            * **Method** (*Literal**[**"min_mode"**, **"dynamics"**,
              **"basin_hopping"**, **"bgsd"**]*) -- Which saddle
              search method to use.

            * **MinEnergyBarrier** (*float** | **FloatKey*) -- Minimum
              energy barrier to accept a new transition state.

            * **MinModeMethod** (*Literal**[**"dimer"**,
              **"lanczos"**]*) -- The minimum-mode following method to
              use.

            * **RandomMode** (*BoolType** | **BoolKey*) -- If true,
              the initial displacement is a completely random vector.
              If false, it's based on other criteria.

            * **RelaxFromSaddlePoint** (*BoolType** | **BoolKey*) --
              Relaxes the saddle point geometries following the
              imaginary mode to get both reactants and products.

            * **RemoveRotation** (*BoolType** | **BoolKey*) -- If
              true, removes the rotational component from the initial
              displacement vector to prevent rigid body rotations.

            * **ZeroModeAbortCurvature** (*float** | **FloatKey*) --
              The threshold in the frequency below which the minimum
              mode is considered zero. The calculation is aborted if
              the negative mode becomes zero.

      class _StatesAlignment

         Configures details of how the energy landscape configurations
         are aligned respect to the main chemical system [System].

         Variables:
            * **DistanceDifference** (*float** | **FloatKey*) -- If
              the distance between two mapped atoms is larger than
              this threshold, the configuration is considered not
              aligned. If not specified, its value will set equal to
              [PESExploration%StructureComparison%DistanceDifference]

            * **ReferenceRegion** (*str** | **StringKey*) -- Defines
              the region that is considered as the reference for
              alignments. Atoms outside this region are ignored in the
              alignments.

            * **RemoveUnaligned** (*BoolType** | **BoolKey*) -- If
              enabled, states that cannot be aligned with the
              reference structure according to the specified criteria
              will be removed from the energy landscape.

      class _StructureComparison

         Settings for structure comparison.

         Variables:
            * **CheckRotation** (*BoolType** | **BoolKey*) -- Rotates
              the system optimally before comparing structures. The
              default is to do this only for molecular systems when
              there are no fixed atom constraints.

            * **CheckSymmetry** (*BoolType** | **BoolKey*) --
              Considers that two systems are equal if they are
              equivalent by symmetry.

            * **CovalentScale** (*float** | **FloatKey*) -- Scale
              factor for the covalent distances used in the
              neighboring detection. Only used if
              [StructureComparison%UseCovalent] is enabled. This is an
              experimental feature!

            * **DistanceDifference** (*float** | **FloatKey*) -- If
              the distance between two mapped atoms is larger than
              this threshold, the two configurations are considered
              different structures.

            * **EnergyDifference** (*float** | **FloatKey*) -- If the
              energy difference between two configurations is below
              this threshold, we perform a geometric check to confirm
              they are distinct structures.

            * **IndistinguishableAtoms** (*BoolType** | **BoolKey*) --
              If yes, the order of the atoms does not affect the
              structural comparison. Atoms of the same element are
              then indistinguishable.

            * **NeighborCutoff** (*float** | **FloatKey*) -- Defines
              the maximum distance at which atoms are considered
              neighbors. The default value is calculated as the mode
              of all interatomic distances within the main system,
              with a minimum effective value of 3.3 Å. This parameter
              is only active when [StructureComparison%CheckSymmetry]
              is false or [StructureComparison%UseCovalent] is false.

            * **RemoveTranslation** (*BoolType** | **BoolKey*) --
              Translates the system optimally before comparing
              structures. The default is to do this only when there
              are no fixed atom constraints.

            * **UseCovalent** (*BoolType** | **BoolKey*) -- Atoms are
              considered neighbors if the distance between them is
              lower than [StructureComparison%CovalentScale] times the
              covalent distance calculated following M. O'Keeffe and
              N.E. Brese, J. Am. Chem.Soc. 113 (1991) 3226. This
              option disables [StructureComparison%NeighborCutoff].
              This is an experimental feature!

   class _PESPointCharacter

      Options for the characterization of PES points.

      Variables:
         * **Displacement** (*float** | **FloatKey*) -- Controls the
           size of the displacements used for numerical
           differentiation: The displaced geometries are calculated by
           taking the original coordinates and adding the mass-
           weighted mode times the reduced mass of the mode times the
           value of this keyword.

         * **NegativeEigenvalueTolerance** (*float** | **FloatKey*) --
           The threshold in Hessian eigenvalue below which a mode is
           considered imaginary, i.e. indicating a transition state.
           This is a small negative number, as very small negative
           eigenvalues may be due to numerical noise on an essentially
           flat PES and do not indicate true transition states.

         * **NegativeFrequenciesTolerance** (*float** | **FloatKey*)
           -- The threshold in frequencies below which a mode is
           considered imaginary, i.e. indicating a transition state.
           Deprecated. Use NegativeEigenvalueTolerance instead.

         * **NumberOfModes** (*int** | **IntKey*) -- The number of
           (lowest) eigenvalues that should be checked.

         * **Tolerance** (*float** | **FloatKey*) -- Convergence
           tolerance for residual in iterative Davidson
           diagonalization.

   class _PESScan

      Configures the details of the potential energy surface scanning
      task.

      Variables:
         * **CalcPropertiesAtPESPoints** (*BoolType** | **BoolKey*) --
           Whether to perform an additional calculation with
           properties on all the sampled points of the PES. If this
           option is enabled AMS will produce a separate engine output
           file for every sampled PES point.

         * **FillUnconvergedGaps** (*BoolType** | **BoolKey*) -- After
           the initial pass over the PES, restart the unconverged
           points from converged neighboring points. This has no
           effect if the "Optimize" key is set to "False".

         * **Optimize** (*BoolType** | **BoolKey*) -- Whether to
           optimize the geometry at each point along the scan,
           relaxing all degrees of freedom except those being scanned
           or explicitly constrained.

         * **ScanCoordinate** (*AMSBatch._PESScan._ScanCoordinate*) --
           Specifies a coordinate along which the potential energy
           surface is scanned. If this block contains multiple
           entries, these coordinates will be varied and scanned
           together as if they were one. Note that there can be only
           one ScanCoordinate containing a lattice scan in any PES
           scan job.

      class _ScanCoordinate

         Specifies a coordinate along which the potential energy
         surface is scanned. If this block contains multiple entries,
         these coordinates will be varied and scanned together as if
         they were one. Note that there can be only one ScanCoordinate
         containing a lattice scan in any PES scan job.

         Variables:
            * **Angle** (*str** | **StringKey*) -- Scan the angle
              between three atoms. Three atom indices followed by two
              real numbers delimiting the transit range in degrees.

            * **CellVolumeRange** (*Iterable**[**float**] **|
              **FloatListKey*) -- Two numbers for the initial and
              final cell volume. The cell is scaled isotropically
              between these values. Can not be used together with any
              other coordinate within the same ScanCoordinate block.

            * **CellVolumeScalingRange** (*Iterable**[**float**] **|
              **FloatListKey*) -- Two scaling factors for the initial
              and final cell volume. A value of '0.9 1.1' would result
              in an isotropic scaling between 90% and 110% of the cell
              volume of the input system. Can not be used together
              with any other coordinate within the same ScanCoordinate
              block.

            * **Coordinate** (*str** | **StringKey*) -- Scan a
              particular coordinate of an atom. Atom index followed by
              (x|y|z) followed by two real numbers delimiting the
              transit range.

            * **DifDist** (*str** | **StringKey*) -- Scan the
              difference distance between two pairs of atoms,
              R(12)-R(34). Four atom indices followed by two real
              numbers delimiting the transit range in Angstrom.

            * **Dihedral** (*str** | **StringKey*) -- Scan the
              dihedral angle between four atoms. Four atom indices
              followed by two real numbers delimiting the transit
              angle in degrees.

            * **Distance** (*str** | **StringKey*) -- Scan the
              distance between two atoms. Two atom indices followed by
              two real numbers delimiting the transit distance in
              Angstrom.

            * **FromStrainVoigt** (*Iterable**[**float**] **|
              **FloatListKey*) -- The elements of the initial lattice
              strain in Voigt notation. One should specify 6 numbers
              for 3D periodic system (order: xx,yy,zz,yz,xz,xy), 3
              numbers for 2D periodic systems (order: xx,yy,xy) or 1
              number for 1D periodic systems. Has to be used in
              combination with the ToStrainVoigt keyword and no other
              coordinate within the same ScanCoordinate block.

            * **LatticeARange** (*Iterable**[**float**] **|
              **FloatListKey*) -- Scans the length of the first
              lattice vector. Can be combined with the LatticeBRange
              and LatticeCRange keywords, but no other coordinates
              within the same ScanCoordinate.

            * **LatticeBRange** (*Iterable**[**float**] **|
              **FloatListKey*) -- Scans the length of the second
              lattice vector. Can be combined with the LatticeARange
              and LatticeCRange keyword, but no other coordinates
              within the same ScanCoordinate..

            * **LatticeCRange** (*Iterable**[**float**] **|
              **FloatListKey*) -- Scans the length of the third
              lattice vector. Can be combined with the LatticeARange
              and LatticeBRange keyword, but no other coordinates
              within the same ScanCoordinate..

            * **SumDist** (*str** | **StringKey*) -- Scan the sum of
              distances between two pairs of atoms, R(12)+R(34). Four
              atom indices followed by two real numbers delimiting the
              transit range in Angstrom.

            * **ToStrainVoigt** (*Iterable**[**float**] **|
              **FloatListKey*) -- The elements of the final lattice
              strain in Voigt notation. One should specify 6 numbers
              for 3D periodic system (order: xx,yy,zz,yz,xz,xy), 3
              numbers for 2D periodic systems (order: xx,yy,xy) or 1
              number for 1D periodic systems.

            * **nPoints** (*int** | **IntKey*) -- The number of points
              along the scanned coordinate. Must be greater or equal
              2.

            * **FromLattice** (*str** | **Sequence**[**str**] **|
              **FreeBlock*) -- Up to three lattice vectors to start
              the scan at. Has to be used in combination with the
              ToLattice keyword and no other coordinate within the
              same ScanCoordinate block. Unit can be specified in the
              header. Default unit is Angstrom.

            * **ToLattice** (*str** | **Sequence**[**str**] **|
              **FreeBlock*) -- Up to three lattice vectors to end the
              scan at. Unit can be specified in the header. Default
              unit is Angstrom.

         class _FromLattice

            Up to three lattice vectors to start the scan at. Has to
            be used in combination with the ToLattice keyword and no
            other coordinate within the same ScanCoordinate block.
            Unit can be specified in the header. Default unit is
            Angstrom.

         class _ToLattice

            Up to three lattice vectors to end the scan at. Unit can
            be specified in the header. Default unit is Angstrom.

   class _Phonons

      Configures the phonons calculation.

      Variables:
         * **BandStructure** (*BoolType** | **BoolKey*) -- Calculates
           and saves the phonon band structure for visualization.
           Further configuration options for analytical calculations
           may be available in the engine-specific settings
           ("Phonons%BandStructure").

         * **DOS** (*BoolType** | **BoolKey*) -- Calculates and saves
           the phonon density of states (DOS) for visualization.
           Further configuration options for analytical calculations
           may be available in the engine-specific settings
           ("Phonons%DOS").

         * **Method** (*Literal**[**"Auto"**, **"Analytical"**,
           **"Numerical"**]*) -- Determines how phonons are
           calculated. "Auto" selects the analytical method if
           supported by the engine, otherwise it defaults to numerical
           calculation. Configure numerical parameters in the
           "NumericalPhonons" section. Engine-specific options for
           analytical phonon calculations may be available in
           "Engine%Phonons".

   class _Print

      This block controls the printing of additional information to
      stdout.

      Variables:
         **Timers** (*Literal**[**"None"**, **"Normal"**,
         **"Detail"**, **"TooMuchDetail"**]*) -- Printing timing
         details to see how much time is spend in which part of the
         code.

   class _Properties

      Configures which AMS level properties to calculate for
      SinglePoint calculations or other important geometries (e.g. at
      the end of an optimization).

      Variables:
         * **BondOrders** (*BoolType** | **BoolKey*) --

           Requests the engine to calculate bond orders.

           For MM engines these might just be the defined bond orders
           that go into the force-field, while for QM engines, this
           might trigger a bond order analysis based on the electronic
           structure. For engines that do not have a bond order
           analysis method, a bond guessing algorithm will be used.
           See also the input options in the BondOrders block.

         * **Charges** (*BoolType** | **BoolKey*) -- Requests the
           engine to calculate the atomic charges.

         * **DipoleGradients** (*BoolType** | **BoolKey*) -- Requests
           the engine to calculate the nuclear gradients of the
           electric dipole moment of the molecule. This can only be
           requested for non-periodic systems.

         * **DipoleMoment** (*BoolType** | **BoolKey*) -- Requests the
           engine to calculate the electric dipole moment of the
           molecule. This can only be requested for non-periodic
           systems.

         * **ElasticTensor** (*BoolType** | **BoolKey*) -- Calculate
           the elastic tensor.

         * **GSES** (*BoolType** | **BoolKey*) -- Requests the engine
           to calculate the gradients of ground to excited state
           properties.

         * **Gradients** (*BoolType** | **BoolKey*) -- Calculate the
           nuclear gradients.

         * **Hessian** (*BoolType** | **BoolKey*) -- Whether or not to
           calculate the Hessian.

         * **Molecules** (*BoolType** | **BoolKey*) -- Requests an
           analysis of the molecular components of a system, based on
           the bond orders calculated by the engine.

         * **NormalModes** (*BoolType** | **BoolKey*) -- Calculate the
           frequencies and normal modes of vibration, as well as the
           corresponding IR intensities, if the engine supports these
           calculations natively or can calculate dipole moments.

         * **OrbitalsInfo** (*BoolType** | **BoolKey*) -- Basic
           molecular orbitals information: orbital energies,
           occupations, HOMO, LUMO and HOMO-LUMO gap.

         * **Other** (*BoolType** | **BoolKey*) -- Other (engine
           specific) properties. Details are configured in the engine
           block.

         * **PESPointCharacter** (*BoolType** | **BoolKey*) --
           Determine whether the sampled PES point is a minimum or
           saddle point. Note that for large systems this does not
           entail the calculation of the full Hessian and can
           therefore be used to quickly confirm the success of a
           geometry optimization or transition state search.

         * **Phonons** (*BoolType** | **BoolKey*) -- Calculate the
           phonons (for periodic systems).

         * **Polarizability** (*BoolType** | **BoolKey*) -- Requests
           the engine to calculate the polarizability tensor of the
           system.

         * **Raman** (*BoolType** | **BoolKey*) -- Requests
           calculation of Raman intensities for vibrational normal
           modes.

         * **SelectedRegionForHessian** (*str** | **StringKey*) --
           Compute the Hessian matrix elements only for the atoms in a
           particular region. If not specified, the Hessian will be
           computed for all atoms.

         * **StressTensor** (*BoolType** | **BoolKey*) -- Calculate
           the stress tensor.

         * **UncertaintyScore** (*BoolType** | **BoolKey*) -- Request
           the engine to state how (un)certain it is about its
           results. Higher number means less certain but specific
           implementation depends on engine.

         * **VCD** (*BoolType** | **BoolKey*) -- Requests calculation
           of VCD for vibrational normal modes.

         * **VROA** (*BoolType** | **BoolKey*) -- Requests calculation
           of VROA for vibrational normal modes.

   class _Raman

      Configures details of the Raman or VROA calculation.

      Variables:
         * **FreqRange** (*Iterable**[**float**] **| **FloatListKey*)
           -- Specifies a frequency range within which all modes will
           be scanned. 2 numbers: an upper and a lower bound.

         * **IncidentFrequency** (*float** | **FloatKey*) -- Frequency
           of incident light.

         * **LifeTime** (*float** | **FloatKey*) -- 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 typical
           value is 0.004 Hartree.

   class _Replay

      Configures the details of the Replay task.

      Variables:
         * **Atoms** (*Iterable**[**int**] **| **IntListKey*) -- List
           of atom indices to include in the replay. All other atoms
           will be removed before the calculation of energy (and
           possible other properties). If this keyword is not
           specified, all atoms will be used for the replay. This
           keyword can currently not be used for trajectory with a
           changing number of atoms between frames, e.g. MD
           trajectories with molecule guns and sinks.

         * **File** (*str** | **Path** | **StringKey*) -- Provide an
           ams.rkf file (or a .results folder) from a previously run
           job to replay. The file needs to contain a History section.

         * **Frames** (*Iterable**[**int**] **| **IntListKey*) --

           List of frames from the History section to recompute.

           If you use AMSmovie, you can use it to find the frame
           number, but add one since frame numbers in AMSmovie start
           at 0.

           If not specified the recomputed frames are determined
           automatically based on the task of the job that is being
           replayed: PES scans and NEB calculations will only have the
           converged points replayed, while all other tasks will have
           all frames recomputed.

           Specifying the frames to recompute in the input is probably
           only useful when replaying trajectories from
           MolecularDynamics calculations.

         * **StoreAllResultFiles** (*BoolType** | **BoolKey*) --

           If this option is enabled AMS will produce a separate
           engine output file for every replayed frame.

           While basic properties like energy, gradients, stress
           tensor, etc. are stored anyway on the History section in
           the AMS driver output file (if they were requested in the
           Properties block), engine specific properties (e.g.
           excitations energies from ADF) will only be available if
           the full result files are stored.

   class _Restraints

      The Restraints block allows to add soft constraints to the
      system. A restraint is a potential energy function (a spring)
      attached to a certain coordinate, for example, an interatomic
      distance, with its minimum at the specified optimal value. A
      restraint is defined using one or two parameters: the
      ForceConstant and, for some types, the F(Inf) value. The
      ForceConstant parameter corresponds to second derivative of the
      restraint potential energy d2V(x)/dx^2 for any x (harmonic
      restraints) or only at at x=0 (other restraints). Here, x is a
      deviation from the restraint's optimal value.

      Variables:
         * **Angle** (*str** | **StringKey*) -- Specify three atom
           indices i j k followed by an angle in degrees and,
           optionally, by the ForceConstant (default is 0.3 in a.u.),
           profile type and F(Inf) (in a.u.). This restraint will try
           to keep the i-j-k angle at the given value. For periodic
           systems this restraint follows the minimum image
           convention.

         * **DifDist** (*str** | **StringKey*) -- Specify four atom
           indices i j k l followed by the distance in Angstrom and,
           optionally, by the ForceConstant (default is 1.0 in a.u.),
           profile type and F(Inf) (in a.u.). This restraint will try
           to keep the difference R(ij)-R(kl) at the given value. For
           periodic systems this restraint follows the minimum image
           convention.

         * **Dihedral** (*str** | **StringKey*) -- Specify four atom
           indices i j k l followed by an angle in degrees and,
           optionally, by the ForceConstant (default is 0.1 in a.u.),
           profile type and F(Inf) (in a.u.). This restraint will try
           to keep the i-j-k-l dihedral angle at the given value. For
           periodic systems this restraint follows the minimum image
           convention.

         * **Distance** (*str** | **StringKey*) -- Specify two atom
           indices followed by the distance in Angstrom and,
           optionally, by the ForceConstant (default is 1.0 in a.u.),
           profile type and F(Inf) (in a.u.). This restraint will try
           to keep the distance between the two specified atoms at the
           given value. For periodic systems this restraint follows
           the minimum image convention.

         * **FInfinity** (*float** | **FloatKey*) --

           Specify the default asymptotic value for the restraint
           force for the Hyperbolic and Erf profiles, in Hartree/Bohr
           or Hartree/radian.

           A per-restraint value can be specified after the profile
           type on the corresponding restraint line.

         * **Profile** (*Literal**[**"Harmonic"**, **"Hyperbolic"**,
           **"Erf"**, **"GaussianWell"**]*) --

           Select the default type of restraint profile.

           The harmonic profile is most suitable for geometry
           optimizations but may result is very large forces that can
           be problematic in molecular dynamic.

           For MD simulations the Hyperbolic or Erf may be more
           suitable because the restraint force is bounded by a user-
           defined value.

           A per-restraint profile type can be specified after the
           ForceConstant value on the corresponding restraint line.

         * **SumDist** (*str** | **StringKey*) -- Specify four atom
           indices i j k l followed by the distance in Angstrom and,
           optionally, by the ForceConstant (default is 1.0 in a.u.),
           profile type and F(Inf) (in a.u.). This restraint will try
           to keep the sum R(ij)+R(kl) at the given value. For
           periodic systems this restraint follows the minimum image
           convention.

         * **Units** (*Literal**[**"Default"**, **"MD"**]*) -- Change
           units for energy, force and force constant values from the
           default (atomic units) to those often used in the MD
           community (based on kcal/mol and Angstrom). Units for the
           optimal distances are not affected and are always Angstrom.

   class _RigidMotions

      Specify which rigid motions of the total system are allowed. An
      external field is not considered part of the system. Normally
      the automatic option is doing what you want. However this
      feature can be used as a means of geometry constraint.

      Variables:
         * **AllowRotations** (*Literal**[**"Auto"**, **"None"**,
           **"All"**, **"X"**, **"Y"**, **"Z"**, **"XY"**, **"XZ"**,
           **"YZ"**]*) -- Which overall rotations of the system are
           allowed

         * **AllowTranslations** (*Literal**[**"Auto"**, **"None"**,
           **"All"**, **"X"**, **"Y"**, **"Z"**, **"XY"**, **"XZ"**,
           **"YZ"**]*) -- Which overall transitions of the system are
           allowed

         * **Tolerance** (*float** | **FloatKey*) -- Tolerance for
           detecting linear molecules. A large value means larger
           deviation from linearity is permitted.

   class _SCMLibrary

      Technical settings affecting src/lib

      Variables:
         **ShellBasedNAFS** (*BoolType** | **BoolKey*) -- Assume that
         the NAFS are ordered by shell, this allows for a faster
         evaluation.

   class _SCMMatrix

      Technical settings for programs using the AMT matrix system.
      Currently this is only used by DFTB

      Variables:
         * **Type** (*Literal**[**"Auto"**, **"Reference"**,
           **"ScaLapack"**, **"Elpa"**]*) -- Determines which
           implementation is used to support the AbstractMatrixType.

         * **DistributedMatrix**
           (*AMSBatch._SCMMatrix._DistributedMatrix*) -- Technical
           settings for Distributed matrices

      class _DistributedMatrix

         Technical settings for Distributed matrices

         Variables:
            * **ColBlockSize** (*int** | **IntKey*) -- See comment of
              RowBlockSize.

            * **RowBlockSize** (*int** | **IntKey*) -- The matrix is
              divided into blocks of size RowBlockSize x ColBlockSize.
              The smaller the blocks the better the distribution, but
              at the expense of increased communication overhead

   class _SerializedTensors

      Technical settings affecting the SerializedTensors module,
      currently only used for HartreeFock

      Variables:
         * **AllowZeroSize** (*BoolType** | **BoolKey*) -- When the
           data is blocked, can the size be zero?

         * **IntegerDataBlockSize** (*int** | **IntKey*) -- Integer
           (meta) data per tensor may be aligned by using a blockSize,
           only relevant when sparseness is used.

         * **RealDataBlockSize** (*int** | **IntKey*) -- Real data per
           tensor may be aligned by using a blockSize

         * **SparseDataImplementation** (*int** | **IntKey*) --

           1. use three ftlDynArrays per tensor. 2) use one big shared
              array.

   class _SteepestDescent

      Configures details of the steepest descent task.

      Variables:
         * **GradientConvergence** (*float** | **FloatKey*) --

         * **StepSize** (*float** | **FloatKey*) -- Controls the size
           of the step to take. This number is multiplied with the
           force and added to the gradient.

   class _Symmetry

      Specifying details about the details of symmetry detection and
      usage.

      Variables:
         * **SymmetrizeTolerance** (*float** | **FloatKey*) --
           Tolerance used to detect symmetry in case symmetrize is
           requested.

         * **Tolerance** (*float** | **FloatKey*) -- Tolerance used to
           detect symmetry in the system.

   class _System

      Specification of the chemical system. For some applications more
      than one system may be present in the input. In this case, all
      systems except one must have a non-empty string ID specified
      after the System keyword. The system without an ID is considered
      the main one.

      Variables:
         * **AllowCloseAtoms** (*BoolType** | **BoolKey*) -- No longer
           functional. Just here for backwards compatibility.

         * **Charge** (*float** | **FloatKey*) -- The system's total
           charge in atomic units.

         * **FractionalCoords** (*BoolType** | **BoolKey*) -- Whether
           the atomic coordinates in the Atoms block are given in
           fractional coordinates of the lattice vectors. Requires the
           presence of the Lattice block.

         * **GeometryFile** (*str** | **Path** | **StringKey*) -- Read
           the geometry from a file (instead of from Atoms and Lattice
           blocks). Supported formats: .xyz

         * **GuessBonds** (*BoolType** | **BoolKey*) -- Equivalent to
           'Modify%GuessBonds'. Please update input file to use
           'Modify' block instead.

         * **LatticeStrain** (*Iterable**[**float**] **|
           **FloatListKey*) -- Equivalent to 'Modify%LatticeStrain'.
           Please update input file to use 'Modify' block instead.

         * **MapAtomsToUnitCell** (*BoolType** | **BoolKey*) --
           Equivalent to 'Modify%MapAtomsToUnitCell'. Please update
           input file to use 'Modify' block instead.

         * **PerturbCoordinates** (*float** | **FloatKey*) --
           Equivalent to 'Modify%PerturbCoordinates'. Please update
           input file to use 'Modify' block instead.

         * **PerturbLattice** (*float** | **FloatKey*) -- Equivalent
           to 'Modify%PerturbLattice'. Please update input file to use
           'Modify' block instead.

         * **ShiftCoordinates** (*Iterable**[**float**] **|
           **FloatListKey*) -- Equivalent to 'Modify%Translate', but
           in the unit of bohr by default. Please update input file to
           use 'Modify' block instead.

         * **SuperCell** (*Iterable**[**int**] **| **IntListKey*) --
           Equivalent to 'Modify%SuperCell'. Please update input file
           to use 'Modify' block instead.

         * **SuperCellTrafo** (*Iterable**[**int**] **| **IntListKey*)
           -- Equivalent to 'Modify%SuperCellTrafo'. Please update
           input file to use 'Modify' block instead.

         * **Symmetrize** (*BoolType** | **BoolKey*) -- Equivalent to
           'Modify%Symmetrize'. Please update input file to use
           'Modify' block instead.

         * **Atoms** (*str** | **Sequence**[**str**] **| **FreeBlock*)
           -- The atom types and coordinates. Unit can be specified in
           the header. Default unit is Angstrom.

         * **BondOrders** (*str** | **Sequence**[**str**] **|
           **FreeBlock*) -- Defined bond orders. Each line should
           contain two atom indices, followed by the bond order (1,
           1.5, 2, 3 for single, aromatic, double and triple bonds)
           and (optionally) the cell shifts for periodic systems. May
           be used by MM engines and for defining constraints. If the
           system is periodic and none of the bonds have the cell
           shift defined then AMS will attempt to determine them
           following the minimum image convention.

         * **ElectrostaticEmbedding**
           (*AMSBatch._System._ElectrostaticEmbedding*) -- Container
           for electrostatic embedding options, which can be combined.

         * **Lattice** (*str** | **Sequence**[**str**] **|
           **FreeBlock*) -- Up to three lattice vectors. Unit can be
           specified in the header. Default unit is Angstrom.

         * **Modify** (*AMSBatch._System._Modify*) -- Modifications to
           make to the chemical system after construction. This block
           is read like a script and the modifications applied top to
           bottom.

      class _Atoms

         The atom types and coordinates. Unit can be specified in the
         header. Default unit is Angstrom.

      class _BondOrders

         Defined bond orders. Each line should contain two atom
         indices, followed by the bond order (1, 1.5, 2, 3 for single,
         aromatic, double and triple bonds) and (optionally) the cell
         shifts for periodic systems. May be used by MM engines and
         for defining constraints. If the system is periodic and none
         of the bonds have the cell shift defined then AMS will
         attempt to determine them following the minimum image
         convention.

      class _ElectrostaticEmbedding

         Container for electrostatic embedding options, which can be
         combined.

         Variables:
            * **ElectricField** (*Iterable**[**float**] **|
              **FloatListKey*) --

              External homogeneous electric field with three Cartesian
              components: ex, ey, ez, the default unit being V/Å.

              In atomic units: Hartree/(e bohr) = 51.422 V/Angstrom;
              the relation to SI units is: 1 Hartree/(e bohr) = 5.14
              ... e11 V/m.

              Supported by the engines adf, band, dftb and mopac.

              For periodic systems the field may only have nonzero
              components orthogonal to the direction(s) of periodicity
              (i.e. for 1D periodic system the x-component of the
              electric field should be zero, while for 2D periodic
              systems both the x and y components should be zero. This
              options cannot be used for 3D periodic systems.

            * **MultipolePotential** (*AMSBatch._System._Electrostati
              cEmbedding._MultipolePotential*) -- External point
              charges (and dipoles).

         class _MultipolePotential

            External point charges (and dipoles).

            Variables:
               * **ChargeModel** (*Literal**[**"Point"**,
                 **"Gaussian"**]*) -- A multipole may be represented
                 by a point (with a singular potential at its
                 location) or by a spherical Gaussian distribution.

               * **ChargeWidth** (*float** | **FloatKey*) -- The width
                 parameter in a.u. in case a Gaussian charge model is
                 chosen. A negative value means that the width will be
                 chosen automatically.

               * **Coordinates** (*str** | **Sequence**[**str**] **|
                 **FreeBlock*) --

                 Positions and values of the multipoles, one per line.
                 Each line has the following format:

                 x y z q, or x y z q µx µy µz.

                 Here x, y, z are the coordinates in Å, q is the
                 charge (in atomic units of charge) and µx, µy, µz are
                 the (optional) dipole moment components (in atomic
                 units, i.e. e*Bohr).

                 Periodic systems are not supported.

            class _Coordinates

               Positions and values of the multipoles, one per line.
               Each line has the following format:

               x y z q, or x y z q µx µy µz.

               Here x, y, z are the coordinates in Å, q is the charge
               (in atomic units of charge) and µx, µy, µz are the
               (optional) dipole moment components (in atomic units,
               i.e. e*Bohr).

               Periodic systems are not supported.

      class _Lattice

         Up to three lattice vectors. Unit can be specified in the
         header. Default unit is Angstrom.

      class _Modify

         Modifications to make to the chemical system after
         construction. This block is read like a script and the
         modifications applied top to bottom.

         Variables:
            * **EnableAtomAttributes** (*Literal**[**"gui"**,
              **"adf"**, **"band"**, **"forcefield"**, **"dftb"**,
              **"reaxff"**, **"qe"**]*) -- Enables an atomic attribute
              group. This is only necessary if you want a group
              enabled, but no atom in the input is using any attribute
              from that group.

            * **GuessBonds** (*BoolType** | **BoolKey*) -- Guesses
              bonds based on the atomic elements and the geometry.
              Keeps existing bonds.

            * **LatticeStrain** (*Iterable**[**float**] **|
              **FloatListKey*) -- Deform the input system by the
              specified strain. The strain elements are in Voigt
              notation, so one should specify 6 numbers for 3D
              periodic system (order: xx,yy,zz,yz,xz,xy), 3 numbers
              for 2D periodic systems (order: xx,yy,xy) or 1 number
              for 1D periodic systems.

            * **MapAtomsToUnitCell** (*Iterable**[**float**] **|
              **FloatListKey*) -- For periodic systems the atoms will
              be moved to the central unit cell where all their
              fractional coordinates are in the range
              [start_range,start_range+1). No mapping will take place
              along non-periodic directions. If just a single number
              is given, it corresponds to start_range. If multiple
              numbers are given, they should match the number of
              lattice vectors and will be used as start ranges along
              the individual lattice vectors. If no number is given at
              all, the mapping will be done to the [-0.5:0.5) cell.

            * **PerturbCoordinates** (*float** | **FloatKey*) --
              Perturb the atomic coordinates by adding random numbers
              between [-PerturbCoordinates,PerturbCoordinates] to each
              Cartesian component. This can be useful if you want to
              break the symmetry of your system (e.g. for a geometry
              optimization).

            * **PerturbLattice** (*float** | **FloatKey*) -- Perturb
              the lattice vectors by applying random strain with
              matrix elements between
              [-PerturbLattice,PerturbLattice]. This can be useful if
              you want to deviate from an ideal symmetric geometry,
              for example if you look for a phase change due to high
              pressure.

            * **SuperCell** (*Iterable**[**int**] **| **IntListKey*)
              -- Create a supercell of the input system (only possible
              for periodic systems). The integer numbers represent the
              diagonal elements of the supercell transformation; you
              should specify as many numbers as lattice vectors (i.e.
              1 number for 1D, 2 numbers for 2D and 3 numbers for 3D
              periodic systems).

            * **SuperCellTrafo** (*Iterable**[**int**] **|
              **IntListKey*) -- Create a supercell of the input system
              (only possible for periodic systems) \vec{a}_i' = \sum_j
              T_{ij} \vec{a}_j. The integer numbers represent the
              supercell transformation T_{ij}: 1 number for 1D PBC, 4
              numbers for 2D PBC corresponding to a 2x2 matrix (order:
              (1,1),(1,2),(2,1),(2,2)) and 9 numbers for 3D PBC
              corresponding to a 3x3 matrix (order:
              (1,1),(1,2),(1,3),(2,1),(2,2),(2,3),(3,1),(3,2),(3,3)).

            * **Symmetrize** (*BoolType** | **BoolKey*) -- Symmetrizes
              a system, using either the "symmetrize_molecule" or
              "symmetrize_cell" method, depending on periodicity.

            * **SymmetrizeMoleculeTo** (*str** | **StringKey*) --
              Symmetrizes a molecule to a particular symmetry given by
              a Schoenflies symbol. Symmetrizes the atomic coordinates
              to machine precision, but does NOT rototranslate the
              molecule in any way. If the symmetrization fails, an
              error will be raised.

            * **Translate** (*Iterable**[**float**] **|
              **FloatListKey*) -- Translate all atoms by a vector.

   class _SystemsFromConformers

      Constructs a series of systems (with identifiers 'conformer1',
      'conformer2', etc.) from a RKF or XYZ file from a Conformers
      run.

      Variables:
         * **File** (*str** | **Path** | **StringKey*) -- A path to an
           RKF or concatenated XYZ file.

         * **MaxEnergy** (*float** | **FloatKey*) -- Energy cut-off
           relative to lowest energy conformer.

   class _SystemsFromPES

      Constructs a series of systems (with identifiers 'system1',
      'system2', etc.) from a RKF file from Conformers,
      PESExploration, or PESScan run.

      Variables:
         * **File** (*str** | **Path** | **StringKey*) -- A path to an
           RKF file.

         * **MaxEnergy** (*float** | **FloatKey*) -- Maximum energy
           relative to lowest energy for which the system should be
           read.

   class _SystemsFromSMILES

      Generates systems from SMILES strings using the
      plams.from_smiles() functions. Each line should contain first
      the system identifier separated by a comma from its SMILES
      string, e.g.: 'propanol, CCCO'

   class _SystemsFromTrajectory

      Constructs a series of systems (with identifiers 'frame1',
      'frame2', etc.) from a trajectory file.

      Variables:
         * **File** (*str** | **Path** | **StringKey*) -- A path to an
           RKF or concatenated XYZ file.

         * **Frames** (*Iterable**[**int**] **| **IntListKey*) -- List
           of frames to load from the file. If not specified, all
           frames will be loaded.

   class _Thermo

      Options for thermodynamic properties (assuming an ideal gas).
      The properties are computed for all specified temperatures.

      Variables:
         * **Pressure** (*float** | **FloatKey*) -- The pressure at
           which the thermodynamic properties are computed.

         * **Temperatures** (*Iterable**[**float**] **|
           **FloatListKey*) -- List of temperatures at which the
           thermodynamic properties will be calculated.

         * **UseSymmetryForEntropy** (*BoolType** | **BoolKey*) -- Use
           symmetry for the calculation of rotational entropy.

         * **LowFrequencyCorrector**
           (*AMSBatch._Thermo._LowFrequencyCorrector*) -- Options for
           the dampener-powered free rotor interpolator that corrects
           thermodynamic quantities for low frequencies. See
           DOI:10.1021/jp509921r and DOI:10.1002/chem.201200497.

      class _LowFrequencyCorrector

         Options for the dampener-powered free rotor interpolator that
         corrects thermodynamic quantities for low frequencies. See
         DOI:10.1021/jp509921r and DOI:10.1002/chem.201200497.

         Variables:
            * **Alpha** (*float** | **FloatKey*) -- The exponent term
              used in the dampener.

            * **Frequency** (*float** | **FloatKey*) -- The frequency
              around which the dampener interpolates between harmonic
              oscillator and free rotor quantities.

            * **MomentOfInertia** (*float** | **FloatKey*) -- The
              moment of inertia used to restrict entropy results for
              very small frequencies (generally around less than 1
              cm-1).

   class _TransitionStateSearch

      Configures some details of the transition state search.

      Variables:
         * **ModeToFollow** (*int** | **IntKey*) -- In case of
           Transition State Search, here you can specify the index of
           the normal mode to follow (1 is the mode with the lowest
           frequency).

         * **ReactionCoordinate**
           (*AMSBatch._TransitionStateSearch._ReactionCoordinate*) --
           Specify components of the transition state reaction
           coordinate (TSRC) as a linear combination of internal
           coordinates (distances or angles).

      class _ReactionCoordinate

         Specify components of the transition state reaction
         coordinate (TSRC) as a linear combination of internal
         coordinates (distances or angles).

         Variables:
            * **All** (*str** | **StringKey*) -- Dummy.

            * **Angle** (*str** | **StringKey*) -- The TSRC contains
              the valence angle between the given atoms. Three atom
              indices followed by the weight.

            * **Atom** (*str** | **StringKey*) -- Dummy.

            * **AtomList** (*str** | **StringKey*) -- Dummy.

            * **Block** (*str** | **StringKey*) -- Name of the region.
              Only atoms of the region will be included in the TSRC.
              It is useful when computing the reaction coordinate from
              the initial Hessian, in which case only part of the
              Hessian will be analyzed.

            * **BlockAtoms** (*Iterable**[**int**] **| **IntListKey*)
              -- List of atom indices. Only the listed atoms will be
              included in the TSRC. It is useful when computing the
              reaction coordinate from the initial Hessian, in which
              case only part of the Hessian will be analyzed.

            * **Coordinate** (*str** | **StringKey*) -- The TSRC
              contains Cartesian displacement of an atom: atom index
              followed by [x|y|z] and the weight.

            * **DifDist** (*str** | **StringKey*) -- Dummy.

            * **Dihedral** (*str** | **StringKey*) -- The TSRC
              contains the dihedral angle between the given atoms.
              Four atom indices followed by the weight.

            * **Distance** (*str** | **StringKey*) -- The TSRC
              contains the distance between the given atoms. Two atom
              indices followed by the weight.

            * **EqualStrain** (*str** | **StringKey*) -- Dummy.

            * **FixedRegion** (*str** | **StringKey*) -- Dummy.

            * **FreezeStrain** (*str** | **StringKey*) -- Dummy.

            * **SumDist** (*str** | **StringKey*) -- Dummy.

   class _VibrationalAnalysis

      Input data for all vibrational analysis utilities in the AMS
      driver.

      Variables:
         * **Displacement** (*float** | **FloatKey*) -- Step size for
           finite difference calculations.

         * **Quiet** (*BoolType** | **BoolKey*) -- Suppress run-time
           output

         * **Type** (*Literal**[**"ModeScanning"**,
           **"ModeTracking"**, **"ModeRefinement"**,
           **"VibronicStructure"**, **"VibronicStructureTracking"**,
           **"VibronicStructureRefinement"**, **"ResonanceRaman"**]*)
           -- Specifies the type of vibrational analysis that should
           be performed

         * **VSTRestartFile** (*str** | **Path** | **StringKey*) --
           Path to a .rkf file containing restart information for VST.

         * **AbsorptionSpectrum**
           (*AMSBatch._VibrationalAnalysis._AbsorptionSpectrum*) --
           Settings related to the integration of the spectrum for
           vibronic tasks.

         * **ExcitationSettings**
           (*AMSBatch._VibrationalAnalysis._ExcitationSettings*) --
           Block that contains settings related to the excitation for
           vibronic tasks.

         * **ModeTracking**
           (*AMSBatch._VibrationalAnalysis._ModeTracking*) -- Input
           data for Mode Tracking.

         * **NormalModes**
           (*AMSBatch._VibrationalAnalysis._NormalModes*) -- All input
           related to processing of normal modes. Not available for
           vibronic structure tracking (as no modes are required
           there).

         * **ResonanceRaman**
           (*AMSBatch._VibrationalAnalysis._ResonanceRaman*) -- Block
           that contains settings for the calculation of Resonance
           Raman calculations

      class _AbsorptionSpectrum

         Settings related to the integration of the spectrum for
         vibronic tasks.

         Variables:
            * **AbsorptionRange** (*Iterable**[**float**] **|
              **FloatListKey*) -- Specifies frequency range of the
              vibronic absorption spectrum to compute. 2 numbers: an
              upper and a lower bound.

            * **FrequencyGridPoints** (*int** | **IntKey*) -- Number
              of grid points to use for the spectrum

            * **IntegrationThreshold** (*float** | **FloatKey*) --
              Value of exponential damping in absorption cross-section
              used to define upper integration limit.

            * **LineWidth** (*float** | **FloatKey*) -- Lorentzian
              line-width.

            * **SpectrumOffset** (*Literal**[**"absolute"**,
              **"relative"**]*) -- Specifies whether provided
              frequency range are absolute frequencies or frequencies
              relative to computed 0-0 excitation energy.

            * **TimeStep** (*float** | **FloatKey*) -- Value of time
              step for spectrum integration.

      class _ExcitationSettings

         Block that contains settings related to the excitation for
         vibronic tasks.

         Variables:
            * **EnergyInline** (*float** | **FloatKey*) -- Vertical
              excitation energy, used when [ExcitationInfo] =
              [Inline].

            * **ExcitationFile** (*str** | **Path** | **StringKey*) --
              Path to a .rkf/.t21 file containing the excited state
              information (gradients, transition dipoles and
              energies).

            * **ExcitationInputFormat** (*Literal**[**"File"**,
              **"Inline"**]*) -- Select how the application should
              retrieve the excited state information (energy,
              gradient).

            * **GradientInline** (*str** | **Sequence**[**str**] **|
              **FreeBlock*) -- Excited state gradient at ground state
              equilibrium geometry, used when [ExcitationInfo] =
              [Inline].

            * **Singlet** (*str** | **Sequence**[**str**] **|
              **FreeBlock*) -- Symmetry labels + integer indices of
              desired singlet transitions (VG-FC absorption spectra
              support only 1 at a time)

            * **Triplet** (*str** | **Sequence**[**str**] **|
              **FreeBlock*) -- Symmetry labels + integer indices of
              desired triplet transitions (VG-FC absorption spectra
              support only 1 at a time)

         class _GradientInline

            Excited state gradient at ground state equilibrium
            geometry, used when [ExcitationInfo] = [Inline].

         class _Singlet

            Symmetry labels + integer indices of desired singlet
            transitions (VG-FC absorption spectra support only 1 at a
            time)

         class _Triplet

            Symmetry labels + integer indices of desired triplet
            transitions (VG-FC absorption spectra support only 1 at a
            time)

      class _ModeTracking

         Input data for Mode Tracking.

         Variables:
            * **GramSchmidt** (*BoolType** | **BoolKey*) -- Turn
              on/off gram-schmidt orthogonalization of new vectors to
              alter convergence.

            * **GramSchmidtIterations** (*int** | **IntKey*) --
              Maximum number of gram-schmidt orthogonalization steps
              per iteration.

            * **GramSchmidtTolerance** (*float** | **FloatKey*) --
              Tolerance for checking orthogonality when expanding the
              basis.

            * **HessianGuess** (*Literal**[**"Unit"**, **"File"**,
              **"CalculateWithFastEngine"**, **"Inline"**]*) -- Sets
              how to obtain the guess for the Hessian used in the
              preconditioner (if one is to be used).

            * **HessianPath** (*str** | **Path** | **StringKey*) --
              Path to a .rkf file containing the initial guess for the
              Hessian, used when [HessianGuess] = [File]. It may also
              be the name of the results folder containing the engine
              file.

            * **MaxIterations** (*int** | **IntKey*) -- Maximum number
              of allowed iterations.

            * **RemoveRigids** (*BoolType** | **BoolKey*) --
              Orthogonalize tracked vectors against rigid modes

            * **ToleranceForBasis** (*float** | **FloatKey*) --
              Convergence tolerance for the contribution of the newest
              basis vector to the tracked mode.

            * **ToleranceForNorm** (*float** | **FloatKey*) --
              Convergence tolerance for residual RMS value.

            * **ToleranceForResidual** (*float** | **FloatKey*) --
              Convergence tolerance for the maximum component of the
              residual vector.

            * **ToleranceForSpectrum** (*float** | **FloatKey*) --
              Convergence tolerance for the spectrum in Vibronic
              Structure Tracking.

            * **TrackingMethod** (*Literal**[**"OverlapInitial"**,
              **"DifferenceInitial"**, **"FreqInitial"**,
              **"IRInitial"**, **"OverlapPrevious"**,
              **"DifferencePrevious"**, **"FreqPrevious"**,
              **"IRPrevious"**, **"HighestFreq"**, **"HighestIR"**,
              **"LowestFreq"**, **"LowestResidual"**]*) -- Set the
              tracking method that will be used. Vibronic Structure
              Tracking uses Largest Displacement.

            * **UpdateMethod** (*Literal**[**"JD"**, **"D"**,
              **"I"**]*) -- Chooses the method for expanding the
              Krylov subspace: (I) No preconditioner (VST default),
              (D) Davidson or (JD) vdVorst-Sleijpen variant of Jacobi-
              Davidson (Mode tracking default).

            * **HessianInline** (*str** | **Sequence**[**str**] **|
              **FreeBlock*) -- Initial guess for the (non-mass-
              weighted) Hessian in a 3N x 3N block, used when
              [HessianGuess] = [Inline].

         class _HessianInline

            Initial guess for the (non-mass-weighted) Hessian in a 3N
            x 3N block, used when [HessianGuess] = [Inline].

      class _NormalModes

         All input related to processing of normal modes. Not
         available for vibronic structure tracking (as no modes are
         required there).

         Variables:
            * **MassWeightInlineMode** (*BoolType** | **BoolKey*) --
              MODE TRACKING ONLY: The supplied modes must be mass-
              weighted. This tells the program to mass-weight the
              supplied modes in case this has not yet been done. (True
              means the supplied modes will be mass-weighted by the
              program, e.g. the supplied modes are non-mass-weighted.)

            * **ModeFile** (*str** | **Path** | **StringKey*) -- Path
              to a .rkf or .t21 file containing the modes which are to
              be scanned. Which modes will be scanned is selected
              using the criteria from the [ModeSelect] block.) This
              key is optional for Resonance Raman and Vibronic
              Structure. These methods can also calculate the modes
              using the engine.

            * **ModeInputFormat** (*Literal**[**"File"**,
              **"Inline"**, **"Hessian"**]*) -- Set how the initial
              guesses for the modes are supplied. Only mode tracking
              supports the Inline and Hessian options.

            * **ScanModes** (*BoolType** | **BoolKey*) -- Supported
              by: Mode Tracking, Mode Refinement, Vibronic Structure
              Refinement: If enabled an additional displacement will
              be performed along the new modes at the end of the
              calculation to obtain refined frequencies and IR
              intensities. Equivalent to running the output file of
              the mode tracking calculation through the AMS
              ModeScanning task.

            * **ModeInline** (*str** | **Sequence**[**str**] **|
              **FreeBlock*) -- MODE TRACKING ONLY: Coordinates of the
              mode which will be tracked in a N x 3 block (same as for
              atoms), used when [ModeInputFormat] = [Inline]. Rows
              must be ordered in the same way as in the [System%Atoms]
              block. Mode Tracking only.

            * **ModeSelect** (*AMSBatch._VibrationalAnalysis._NormalM
              odes._ModeSelect*) -- Pick which modes to read from
              file.

         class _ModeInline

            MODE TRACKING ONLY: Coordinates of the mode which will be
            tracked in a N x 3 block (same as for atoms), used when
            [ModeInputFormat] = [Inline]. Rows must be ordered in the
            same way as in the [System%Atoms] block. Mode Tracking
            only.

         class _ModeSelect

            Pick which modes to read from file.

            Variables:
               * **DisplacementBound** (*float** | **FloatKey*) --
                 Vibronic Structure (Refinement), Resonance Raman:
                 Select all modes with a dimensionless oscillator
                 displacement greater than the specified value.

               * **FreqAndIRRange** (*Iterable**[**float**] **|
                 **FloatListKey*) -- Specifies a combined frequency
                 and IR intensity range within which all modes will be
                 selected. First 2 numbers are the frequency range in
                 cm-1, last 2 numbers are the IR intensity range in
                 km/mol.

               * **FreqRange** (*Iterable**[**float**] **|
                 **FloatListKey*) -- Specifies a frequency range
                 within which all modes will be selected. 2 numbers:
                 an upper and a lower bound. Calculating all modes
                 higher than some frequency can be achieved by making
                 the upper bound very large.

               * **Full** (*BoolType** | **BoolKey*) -- Select all
                 modes. This only make sense for Mode Scanning
                 calculations.

               * **HighFreq** (*int** | **IntKey*) -- Select the N
                 modes with the highest frequencies.

               * **HighIR** (*int** | **IntKey*) -- Select the N modes
                 with the largest IR intensities.

               * **IRRange** (*Iterable**[**float**] **|
                 **FloatListKey*) -- Specifies an IR intensity range
                 within which all modes will be selected. 2 numbers:
                 an upper and a lower bound.

               * **ImFreq** (*BoolType** | **BoolKey*) -- Select all
                 modes with imaginary frequencies.

               * **LargestDisplacement** (*int** | **IntKey*) --
                 Vibronic Structure (Refinement), Resonance Raman:
                 Select the N modes with the largest VG-FC
                 displacement.

               * **LowFreq** (*int** | **IntKey*) -- Select the N
                 modes with the lowest frequencies. Includes imaginary
                 modes which are recorded with negative frequencies.

               * **LowFreqNoIm** (*int** | **IntKey*) -- Select the N
                 modes with the lowest non-negative frequencies.
                 Imaginary modes have negative frequencies and are
                 thus omitted here.

               * **LowIR** (*int** | **IntKey*) -- Select the N modes
                 with the smallest IR intensities.

               * **ModeNumber** (*Iterable**[**int**] **|
                 **IntListKey*) -- Indices of the modes to select.

      class _ResonanceRaman

         Block that contains settings for the calculation of Resonance
         Raman calculations

         Variables:
            * **IncidentFrequency** (*float** | **FloatKey*) --
              Frequency of incident light. Also used to determine most
              important excitation in case more than one is provided.

            * **LifeTime** (*float** | **FloatKey*) -- Lifetime of
              Raman excited state.

            * **MaximumStates** (*int** | **IntKey*) -- Maximum number
              of final states included in the spectrum.

            * **RamanOrder** (*int** | **IntKey*) -- Order up to which
              to compute Raman transitions

            * **RamanRange** (*Iterable**[**float**] **|
              **FloatListKey*) -- Specifies frequency range of the
              Raman spectrum to compute. 2 numbers: an upper and a
              lower bound.

class AMSInteractive

   Variables:
      * **Stop** (*BoolType** | **BoolKey*) -- Makes the AMS driver
        stop execution in an ordered manner at the next opportunity.
        This will not interrupt the execution in the middle of the
        numerical calculation of a PES point property (e.g. a
        Hessian).

      * **StopProperties** (*BoolType** | **BoolKey*) -- Makes the AMS
        driver stop execution during the evaluation of PES point
        properties. This may for example be used to interrupt the
        numerical calculation of a Hessian. Note that this just works
        at the level of the loops used for the **numerical**
        calculation of the properties, so engines which calculate a
        property analytically may not be interruptible using this
        keyword. It is recommended to use this keyword in combination
        with the generic "Stop" keyword.

class Analysis

   Variables:
      * **Task** (*Literal**[**"RadialDistribution"**,
        **"Histogram"**, **"AutoCorrelation"**,
        **"MeanSquareDisplacement"**, **"AverageBinPlot"**]*) -- The
        analysis task.

      * **Title** (*str** | **StringKey*) -- Title to identify the
        analysis run. Only used by the GUI.

      * **AutoCorrelation** (*Analysis._AutoCorrelation*) -- All input
        related to auto correlation functions.

      * **AverageBinPlot** (*Analysis._AverageBinPlot*) -- All input
        related to velocity profile

      * **Histogram** (*Analysis._Histogram*) -- All input related to
        histograms.

      * **LoadSystem** (*Analysis._LoadSystem*) -- Block that controls
        reading the chemical system from a KF file instead of the
        [System] block.

      * **MeanSquareDisplacement**
        (*Analysis._MeanSquareDisplacement*) -- All input related to
        mean square displacement functions.

      * **Print** (*Analysis._Print*) -- This block controls the
        printing of additional information to stdout.

      * **RadialDistribution** (*Analysis._RadialDistribution*) -- All
        input related to radial distribution functions.

      * **System** (*Analysis._System*) -- Specification of the
        chemical system. For some applications more than one system
        may be present in the input. In this case, all systems except
        one must have a non-empty string ID specified after the System
        keyword. The system without an ID is considered the main one.

      * **TrajectoryInfo** (*Analysis._TrajectoryInfo*) -- All the
        info regarding the reading of the trajectory files.

   class _AutoCorrelation

      All input related to auto correlation functions.

      Variables:
         * **ComputeStandardDeviation** (*BoolType** | **BoolKey*) --
           Compute the standard deviation of the autocorrelation
           function. This will slow down the calculation by
           approximately a factor 2. The standard deviation takes into
           account the variance introduced by both the simulation time
           and by the contributing atoms.

         * **DataReading** (*Literal**[**"Auto"**, **"AtOnce"**,
           **"BlockWise"**]*) -- The KF data can be read in and
           handled once, or blockwise. The former is memory intensive,
           but mostly faster. If Auto is selected, the data is read at
           once if it is less than 1 GB, and blockwise if it is more.

         * **LimitMaxFrame** (*BoolType** | **BoolKey*) -- If set to
           true (default), the program will exit if MaxFrame is
           selected larger than half the provided number of frames.
           This limit is only active is UseAllValues is set to false.

         * **MaxCorrelationTime** (*float** | **FloatKey*) -- The
           maximum correlation time in fs. The default is half the
           simulation time, except when the PressureTensor is read
           from the ams.rkf, in which case it is 10 percent of the
           simulation time. The PressureTensor is read when the
           Properties PressureTensor, Viscosity, or
           ViscosityFromBinLog are selected.

         * **MaxFrame** (*int** | **IntKey*) -- The maximum number of
           frames for which the autocorrelation function will be
           computed. The default is half of the number of provided
           frames. Determines the same settings as MaxCorrelationTime.
           If both are set, MaxCorrelationTime will take precedence.

         * **NPointsHighestFreq** (*int** | **IntKey*) -- The number
           of points (timesteps) used for the highest frequency
           displayed in spectrum. This determines up to which
           frequency the spectrum is displayed. If the spacing between
           time-steps used for the ACF is 1 fs, then by default the
           maximum frequency displayed is 0.25 fs-1 (or 8339 cm-1).
           This corresponds to a (default) value of NPointsHighestFreq
           of 4. A higher number selected here, will result in a lower
           maximum frequency returned by the program. The lowest
           possible value (spectrum up to highest possible frequency)
           is 2.

         * **PerElement** (*BoolType** | **BoolKey*) -- Compute ACF
           for all elements in the system. Any other settings in the
           block will be used.

         * **Property** (*Literal**[**"Velocities"**,
           **"DipoleMomentFromCharges"**, **"DiffusionCoefficient"**,
           **"DipoleDerivativeFromCharges"**, **"PressureTensor"**,
           **"Viscosity"**, **"DipoleMomentFromBinLog"**,
           **"ViscosityFromBinLog"**]*) -- Compute the ACF either from
           velocities (from rkf), the dipole moment (from coordinates
           and atomic charges in rkf), the dipole moment derivative
           (from velocities and atomic charges in rkf), from the
           pressure tensor (from rkf), or from values specified in
           input. Selecting DiffusionCoefficient is equivalent to
           selecting Velocities. The default,
           DipoleDerivativeFromCharges, results in the computation of
           an IR spectrum.DipoleMomentFromBinLog and
           ViscosityFromBinLog allow the relevant properties (dipole
           moment and pressure tensor respectively) to be read from
           the BinLog section of the trajectory file. In the BinLog
           section requested properties are stored every step (even if
           SamplingFreq was set to a higher number than 1) but only if
           this was specifically requested at the start of the MD
           simulation.

         * **UnwrapCoordinates** (*Literal**[**"Auto"**, **"Yes"**,
           **"No"**]*) -- If the coordinates are involved in the
           requested property, those coordinates are wrapped into the
           box at each time step. If set to true, this keyword unwraps
           those coordinates so that the trajectory is continuous. If
           not provided the code uses automatic defaults.

         * **UseAllValues** (*BoolType** | **BoolKey*) -- By default
           the same number of values are used for each t-step in the
           ACF. This has the advantage that all values in the ACF are
           equally reliable, but it does mean that for the smaller
           timesteps much of the data is not used. To switch this off
           and use all data, UseAllValues can be set to true

         * **WritePropertyToKF** (*BoolType** | **BoolKey*) -- Write
           the selected property to the KF files for every requested
           frame

         * **Atoms** (*Analysis._AutoCorrelation._Atoms*) -- Relevant
           if Property is set to Velocities, DipoleMomentFromCharges,
           DipoleDerivativeFromCharges, or DiffusionCoefficient. Atom
           numbers or elements for the set of atoms for which the
           property is read/computed. By default all atoms are used.

         * **UseTimeDerivative**
           (*Analysis._AutoCorrelation._UseTimeDerivative*) --
           Possibly use the time derivative of the selected property
           (e.g. velocity or dipole moments).

         * **VecElements** (*Analysis._AutoCorrelation._VecElements*)
           -- A set of indices referring to a subset of the property
           vector. Works in combination with the atoms block. For
           example, in combination with the property Velocities, the
           Atoms block allows the selection of a subset of atoms,
           while the VecElelements block allows the selection of a
           subset of vector elements (e.g. 1 and 2 for the elements x
           and y).

      class _Atoms

         Relevant if Property is set to Velocities,
         DipoleMomentFromCharges, DipoleDerivativeFromCharges, or
         DiffusionCoefficient. Atom numbers or elements for the set of
         atoms for which the property is read/computed. By default all
         atoms are used.

         Variables:
            * **Atom** (*int** | **IntKey*) -- Atom number.

            * **Element** (*str** | **StringKey*) -- Element Symbol
              Atom.

            * **Region** (*str** | **StringKey*) -- Region name.

      class _UseTimeDerivative

         Possibly use the time derivative of the selected property
         (e.g. velocity or dipole moments).

         Variables:
            * **Enabled** (*BoolType** | **BoolKey*) -- Enable the use
              of the time derivative of the property.

            * **ProjectOutRotations** (*BoolType** | **BoolKey*) --
              Take the rotations out of the time derivative.

      class _VecElements

         A set of indices referring to a subset of the property
         vector. Works in combination with the atoms block. For
         example, in combination with the property Velocities, the
         Atoms block allows the selection of a subset of atoms, while
         the VecElelements block allows the selection of a subset of
         vector elements (e.g. 1 and 2 for the elements x and y).

         Variables:
            **Index** (*int** | **IntKey*) -- Element of the property
            vector.

   class _AverageBinPlot

      All input related to velocity profile

      Variables:
         * **Nbins** (*int** | **IntKey*) -- Number of bins that are
           plotted

         * **Atoms** (*Analysis._AverageBinPlot._Atoms*) -- Relevant
           if Properties are atom dependent. Atom numbers or elements
           for the set of atoms for which the property is
           read/computed. By default all atoms are used.

         * **Property** (*Analysis._AverageBinPlot._Property*) --
           Property to be plotted along the Y-axis

         * **XProperty** (*Analysis._AverageBinPlot._XProperty*) --
           Property to be plotted along the Y-axis

      class _Atoms

         Relevant if Properties are atom dependent. Atom numbers or
         elements for the set of atoms for which the property is
         read/computed. By default all atoms are used.

         Variables:
            * **Atom** (*int** | **IntKey*) -- Atom number.

            * **Element** (*str** | **StringKey*) -- Element Symbol
              Atom.

            * **Region** (*str** | **StringKey*) -- Region name.

      class _Property

         Property to be plotted along the Y-axis

         Variables:
            * **Axis** (*Iterable**[**float**] **| **FloatListKey*) --
              If defined the dot_product along this axis will be
              taken. Otherwise, the length of the property vector will
              be used.

            * **Name** (*Literal**[**"FrictionCoefficient"**,
              **"Viscosity"**, **"Velocities"**,
              **"EngineGradients"**]*) -- Name of the property

      class _XProperty

         Property to be plotted along the Y-axis

         Variables:
            * **Name** (*Literal**[**"Time"**, **"Coords"**]*) --
              Timestep used for the plotting

            * **VecElements**
              (*Analysis._AverageBinPlot._XProperty._VecElements*) --
              A set of indices referring to a subset of the property
              vector. Works in combination with the atoms block. For
              example, in combination with the property Velocities,
              the Atoms block allows the selection of a subset of
              atoms, while the VecElelements block allows the
              selection of a subset of vector elements (e.g. 1 and 2
              for the elements x and y).

         class _VecElements

            A set of indices referring to a subset of the property
            vector. Works in combination with the atoms block. For
            example, in combination with the property Velocities, the
            Atoms block allows the selection of a subset of atoms,
            while the VecElelements block allows the selection of a
            subset of vector elements (e.g. 1 and 2 for the elements x
            and y).

            Variables:
               **Index** (*int** | **IntKey*) -- Element of the
               x_property, in case it is a vector (For Coords: 1 for
               X, 2 for Y, 3 for Z).

   class _Histogram

      All input related to histograms.

      Variables:
         * **KeepRemainder** (*BoolType** | **BoolKey*) -- Place the
           values that fall outside the range in an extra bin (on the
           right).

         * **Normalized** (*BoolType** | **BoolKey*) -- Give the
           normalized histogram.

         * **Axes** (*Analysis._Histogram._Axes*) -- Specifications
           for the histogram axes.

      class _Axes

         Specifications for the histogram axes.

         Variables:
            **Axis** (*Analysis._Histogram._Axes._Axis*) --
            Specifications for a single histogram axis.

         class _Axis

            Specifications for a single histogram axis.

            Variables:
               * **NBins** (*int** | **IntKey*) -- The number of bins
                 along the histogram axis.

               * **Range** (*Iterable**[**float**] **|
                 **FloatListKey*) -- Either one, two, or three real
                 values. If one it is the stepsize. If two, it is the
                 minimum value and the maximum value. If three, it is
                 the minimum value, the maximum value, and the
                 stepsize. The stepsize overrides NBins.

               * **Variable** (*str** | **StringKey*) -- The quantity
                 along the histogram axis.

               * **Atoms** (*Analysis._Histogram._Axes._Axis._Atoms*)
                 -- Relevant if variable has a value per atom (e.g.
                 Coords, Velocities). This block specifies indices or
                 elements for the set of atoms for which the variable
                 is to be read. By default all atoms are used.

               * **VecElements**
                 (*Analysis._Histogram._Axes._Axis._VecElements*) -- A
                 set of indices referring to a subset of a vector. If
                 the variable to be plotted has non-scalar values per
                 step, then this block allows the selection of a
                 subset of vector elements (e.g. 1 and 2 for the x and
                 y values). Can be used in combination with the Atoms
                 block.

            class _Atoms

               Relevant if variable has a value per atom (e.g. Coords,
               Velocities). This block specifies indices or elements
               for the set of atoms for which the variable is to be
               read. By default all atoms are used.

               Variables:
                  * **Atom** (*int** | **IntKey*) -- Atom index.

                  * **Element** (*str** | **StringKey*) -- Element
                    Symbol Atom.

                  * **Region** (*str** | **StringKey*) -- Region name

            class _VecElements

               A set of indices referring to a subset of a vector. If
               the variable to be plotted has non-scalar values per
               step, then this block allows the selection of a subset
               of vector elements (e.g. 1 and 2 for the x and y
               values). Can be used in combination with the Atoms
               block.

               Variables:
                  **Index** (*int** | **IntKey*) -- Element of the
                  property vector.

   class _LoadSystem

      Block that controls reading the chemical system from a KF file
      instead of the [System] block.

      Variables:
         * **File** (*str** | **Path** | **StringKey*) -- The path of
           the KF file from which to load the system. It may also be
           the results directory containing it.

         * **Section** (*str** | **StringKey*) -- The section on the
           KF file from which to load the system.

   class _MeanSquareDisplacement

      All input related to mean square displacement functions.

      Variables:
         * **ComputeStandardDeviation** (*BoolType** | **BoolKey*) --
           Compute the standard deviation of the mean square
           displacement. This will slow down the calculation by
           approximately a factor 2. The standard deviation takes into
           account the variance introduced by both the simulation time
           and by the contributing atoms.

         * **DataReading** (*Literal**[**"Auto"**, **"AtOnce"**,
           **"BlockWise"**]*) -- The KF data can be read in and
           handled once, or blockwise. The former is memory intensive,
           but mostly faster. If Auto is selected, the data is read at
           once if it is less than 1 GB, and blockwise if it is more.

         * **LimitMaxFrame** (*BoolType** | **BoolKey*) -- If set to
           true (default), the program will exit if MaxFrame is
           selected larger than half the provided number of frames.
           This limit is only active is UseAllValues is set to false.

         * **MaxCorrelationTime** (*float** | **FloatKey*) -- The
           maximum correlation time in fs. The default is half the
           simulation time.

         * **MaxFrame** (*int** | **IntKey*) -- The maximum number of
           frames for which the mean square displacement function will
           be computed. The default is half of the number of provided
           frames. Determines the same settings as MaxCorrelationTime.
           If both are set, MaxCorrelationTime will take precedence.

         * **PerElement** (*BoolType** | **BoolKey*) -- Compute MSD
           for all elements in the system. Any other settings in thie
           block will be used.

         * **Property** (*Literal**[**"Coords"**,
           **"DiffusionCoefficient"**, **"Conductivity"**]*) --
           Compute the MSD from the property selected here (from rkf).
           Selecting DiffusionCoefficient is equivalent to selecting
           the property Coords.

         * **StartTimeSlope** (*float** | **FloatKey*) -- The MSD has
           a nonlinear regime at short timescales, and a linear regime
           at long timescales. To determine the slope, the starting
           point for the linear regime has to be determined. This
           keyword sets the starting time in fs. If set to zero, the
           starttime will be automatically determined.

         * **UnwrapCoordinates** (*Literal**[**"Auto"**, **"Yes"**,
           **"No"**]*) -- If the coordinates are involved in the
           requested property, those coordinates are wrapped into the
           box at each time step. If set to true, this keyword unwraps
           those coordinates so that the trajectory is continuous. If
           not provided the code uses automatic defaults.

         * **UseAllValues** (*BoolType** | **BoolKey*) -- By default
           the same number of values are used for each t-step in the
           MSD. This has the advantage that all values in the MSD are
           equally reliable, but it does mean that for the smaller
           timesteps much of the data is not used. To switch this off
           and use all data, UseAllValues can be set to true

         * **WritePropertyToKF** (*BoolType** | **BoolKey*) -- Write
           the selected property to the KF files for every requested
           frame

         * **Atoms** (*Analysis._MeanSquareDisplacement._Atoms*) --
           Relevant if Property is set to any quantity that is
           available per atom (Coords, DiffusionCoefficient). Atom
           numbers or elements for the set of atoms for which the
           property is read/computed are provided here. By default all
           atoms are used.

         * **UseMolecularCentersOfMass** (*Analysis._MeanSquareDispla
           cement._UseMolecularCentersOfMass*) -- Specifications on
           using the center of mass coordinates per molecule instead
           of coordinates per atom. Only relevant for properties that
           rely on coordinates: Coords, DiffusionCoefficient, and
           Conductivity.

         * **VecElements**
           (*Analysis._MeanSquareDisplacement._VecElements*) -- A set
           of indices referring to a subset of the property vector.
           Works in combination with the atoms block. For example, in
           combination with the property Coords, the Atoms block
           allows the selection of a subset of atoms, while the
           VecElelements block allows the selection of a subset of
           vector elements (e.g. 1 and 2 for the elements x and y).

      class _Atoms

         Relevant if Property is set to any quantity that is available
         per atom (Coords, DiffusionCoefficient). Atom numbers or
         elements for the set of atoms for which the property is
         read/computed are provided here. By default all atoms are
         used.

         Variables:
            * **Atom** (*int** | **IntKey*) -- Atom number.

            * **Element** (*str** | **StringKey*) -- Element Symbol
              Atom.

            * **Region** (*str** | **StringKey*) -- Region name.

      class _UseMolecularCentersOfMass

         Specifications on using the center of mass coordinates per
         molecule instead of coordinates per atom. Only relevant for
         properties that rely on coordinates: Coords,
         DiffusionCoefficient, and Conductivity.

         Variables:
            * **CheckForBondChanges** (*BoolType** | **BoolKey*) --
              Check for each frame if the bonds still correspond to
              the input bonds. If they changed, an error is thrown. If
              this is set to false, it is assumed that the molecules
              stay in tact.

            * **Enabled** (*BoolType** | **BoolKey*) -- Use the center
              of mass coordinates per molecule. Only relevant for
              properties that rely on coordinates: Coords,
              DiffusionCoefficient, and Conductivity. The bonds from
              the MD input system are used.

      class _VecElements

         A set of indices referring to a subset of the property
         vector. Works in combination with the atoms block. For
         example, in combination with the property Coords, the Atoms
         block allows the selection of a subset of atoms, while the
         VecElelements block allows the selection of a subset of
         vector elements (e.g. 1 and 2 for the elements x and y).

         Variables:
            **Index** (*int** | **IntKey*) -- Element of the property
            vector.

   class _Print

      This block controls the printing of additional information to
      stdout.

      Variables:
         **Timers** (*Literal**[**"None"**, **"Normal"**,
         **"Detail"**, **"TooMuchDetail"**]*) -- Printing timing
         details to see how much time is spend in which part of the
         code.

   class _RadialDistribution

      All input related to radial distribution functions.

      Variables:
         * **AssumeNoSystemChanges** (*BoolType** | **BoolKey*) -- The
           system (bonds and atoms) do not change during the
           simulation, so no checks are needed.

         * **DistanceTypeSelection** (*Literal**[**"All"**,
           **"InterMolecular"**, **"IntraMolecular"**]*) -- Select
           only a certain type of interatomic distances.

         * **KeepRemainder** (*BoolType** | **BoolKey*) -- Place the
           values that fall outside the range in an extra bin (on the
           right).

         * **NBins** (*int** | **IntKey*) -- The number of bins in the
           histogram.

         * **PairwisePerElement** (*BoolType** | **BoolKey*) --
           Compute RDF for all element pairs (for all atoms in the
           system). Any other settings in the block will be used.

         * **Range** (*Iterable**[**float**] **| **FloatListKey*) --
           Either one, two, or three real values. If one it is the
           stepsize. If two, it is the minimum value and the maximum
           value. If three, it is the minimum value, the maximum
           value, and the stepsize. The stepsize overrides NBins.

         * **AtomsFrom** (*Analysis._RadialDistribution._AtomsFrom*)
           -- Atom numbers or elements for the first set of atoms in
           the radial distribution.

         * **AtomsTo** (*Analysis._RadialDistribution._AtomsTo*) --
           Atom numbers or elements for the second set of atoms in the
           radial distribution.

      class _AtomsFrom

         Atom numbers or elements for the first set of atoms in the
         radial distribution.

         Variables:
            * **Atom** (*int** | **IntKey*) -- Atom number.

            * **Element** (*str** | **StringKey*) -- Element Symbol
              Atom.

            * **Region** (*str** | **StringKey*) -- Region name.

      class _AtomsTo

         Atom numbers or elements for the second set of atoms in the
         radial distribution.

         Variables:
            * **Atom** (*int** | **IntKey*) -- Atom number.

            * **Element** (*str** | **StringKey*) -- Element Symbol
              Atom.

            * **Region** (*str** | **StringKey*) -- Region name.

   class _System

      Specification of the chemical system. For some applications more
      than one system may be present in the input. In this case, all
      systems except one must have a non-empty string ID specified
      after the System keyword. The system without an ID is considered
      the main one.

      Variables:
         * **AllowCloseAtoms** (*BoolType** | **BoolKey*) -- No longer
           functional. Just here for backwards compatibility.

         * **Charge** (*float** | **FloatKey*) -- The system's total
           charge in atomic units.

         * **FractionalCoords** (*BoolType** | **BoolKey*) -- Whether
           the atomic coordinates in the Atoms block are given in
           fractional coordinates of the lattice vectors. Requires the
           presence of the Lattice block.

         * **GeometryFile** (*str** | **Path** | **StringKey*) -- Read
           the geometry from a file (instead of from Atoms and Lattice
           blocks). Supported formats: .xyz

         * **GuessBonds** (*BoolType** | **BoolKey*) -- Equivalent to
           'Modify%GuessBonds'. Please update input file to use
           'Modify' block instead.

         * **LatticeStrain** (*Iterable**[**float**] **|
           **FloatListKey*) -- Equivalent to 'Modify%LatticeStrain'.
           Please update input file to use 'Modify' block instead.

         * **MapAtomsToUnitCell** (*BoolType** | **BoolKey*) --
           Equivalent to 'Modify%MapAtomsToUnitCell'. Please update
           input file to use 'Modify' block instead.

         * **PerturbCoordinates** (*float** | **FloatKey*) --
           Equivalent to 'Modify%PerturbCoordinates'. Please update
           input file to use 'Modify' block instead.

         * **PerturbLattice** (*float** | **FloatKey*) -- Equivalent
           to 'Modify%PerturbLattice'. Please update input file to use
           'Modify' block instead.

         * **ShiftCoordinates** (*Iterable**[**float**] **|
           **FloatListKey*) -- Equivalent to 'Modify%Translate', but
           in the unit of bohr by default. Please update input file to
           use 'Modify' block instead.

         * **SuperCell** (*Iterable**[**int**] **| **IntListKey*) --
           Equivalent to 'Modify%SuperCell'. Please update input file
           to use 'Modify' block instead.

         * **SuperCellTrafo** (*Iterable**[**int**] **| **IntListKey*)
           -- Equivalent to 'Modify%SuperCellTrafo'. Please update
           input file to use 'Modify' block instead.

         * **Symmetrize** (*BoolType** | **BoolKey*) -- Equivalent to
           'Modify%Symmetrize'. Please update input file to use
           'Modify' block instead.

         * **Atoms** (*str** | **Sequence**[**str**] **| **FreeBlock*)
           -- The atom types and coordinates. Unit can be specified in
           the header. Default unit is Angstrom.

         * **BondOrders** (*str** | **Sequence**[**str**] **|
           **FreeBlock*) -- Defined bond orders. Each line should
           contain two atom indices, followed by the bond order (1,
           1.5, 2, 3 for single, aromatic, double and triple bonds)
           and (optionally) the cell shifts for periodic systems. May
           be used by MM engines and for defining constraints. If the
           system is periodic and none of the bonds have the cell
           shift defined then AMS will attempt to determine them
           following the minimum image convention.

         * **ElectrostaticEmbedding**
           (*Analysis._System._ElectrostaticEmbedding*) -- Container
           for electrostatic embedding options, which can be combined.

         * **Lattice** (*str** | **Sequence**[**str**] **|
           **FreeBlock*) -- Up to three lattice vectors. Unit can be
           specified in the header. Default unit is Angstrom.

         * **Modify** (*Analysis._System._Modify*) -- Modifications to
           make to the chemical system after construction. This block
           is read like a script and the modifications applied top to
           bottom.

      class _Atoms

         The atom types and coordinates. Unit can be specified in the
         header. Default unit is Angstrom.

      class _BondOrders

         Defined bond orders. Each line should contain two atom
         indices, followed by the bond order (1, 1.5, 2, 3 for single,
         aromatic, double and triple bonds) and (optionally) the cell
         shifts for periodic systems. May be used by MM engines and
         for defining constraints. If the system is periodic and none
         of the bonds have the cell shift defined then AMS will
         attempt to determine them following the minimum image
         convention.

      class _ElectrostaticEmbedding

         Container for electrostatic embedding options, which can be
         combined.

         Variables:
            * **ElectricField** (*Iterable**[**float**] **|
              **FloatListKey*) --

              External homogeneous electric field with three Cartesian
              components: ex, ey, ez, the default unit being V/Å.

              In atomic units: Hartree/(e bohr) = 51.422 V/Angstrom;
              the relation to SI units is: 1 Hartree/(e bohr) = 5.14
              ... e11 V/m.

              Supported by the engines adf, band, dftb and mopac.

              For periodic systems the field may only have nonzero
              components orthogonal to the direction(s) of periodicity
              (i.e. for 1D periodic system the x-component of the
              electric field should be zero, while for 2D periodic
              systems both the x and y components should be zero. This
              options cannot be used for 3D periodic systems.

            * **MultipolePotential** (*Analysis._System._Electrostati
              cEmbedding._MultipolePotential*) -- External point
              charges (and dipoles).

         class _MultipolePotential

            External point charges (and dipoles).

            Variables:
               * **ChargeModel** (*Literal**[**"Point"**,
                 **"Gaussian"**]*) -- A multipole may be represented
                 by a point (with a singular potential at its
                 location) or by a spherical Gaussian distribution.

               * **ChargeWidth** (*float** | **FloatKey*) -- The width
                 parameter in a.u. in case a Gaussian charge model is
                 chosen. A negative value means that the width will be
                 chosen automatically.

               * **Coordinates** (*str** | **Sequence**[**str**] **|
                 **FreeBlock*) --

                 Positions and values of the multipoles, one per line.
                 Each line has the following format:

                 x y z q, or x y z q µx µy µz.

                 Here x, y, z are the coordinates in Å, q is the
                 charge (in atomic units of charge) and µx, µy, µz are
                 the (optional) dipole moment components (in atomic
                 units, i.e. e*Bohr).

                 Periodic systems are not supported.

            class _Coordinates

               Positions and values of the multipoles, one per line.
               Each line has the following format:

               x y z q, or x y z q µx µy µz.

               Here x, y, z are the coordinates in Å, q is the charge
               (in atomic units of charge) and µx, µy, µz are the
               (optional) dipole moment components (in atomic units,
               i.e. e*Bohr).

               Periodic systems are not supported.

      class _Lattice

         Up to three lattice vectors. Unit can be specified in the
         header. Default unit is Angstrom.

      class _Modify

         Modifications to make to the chemical system after
         construction. This block is read like a script and the
         modifications applied top to bottom.

         Variables:
            * **EnableAtomAttributes** (*Literal**[**"gui"**,
              **"adf"**, **"band"**, **"forcefield"**, **"dftb"**,
              **"reaxff"**, **"qe"**]*) -- Enables an atomic attribute
              group. This is only necessary if you want a group
              enabled, but no atom in the input is using any attribute
              from that group.

            * **GuessBonds** (*BoolType** | **BoolKey*) -- Guesses
              bonds based on the atomic elements and the geometry.
              Keeps existing bonds.

            * **LatticeStrain** (*Iterable**[**float**] **|
              **FloatListKey*) -- Deform the input system by the
              specified strain. The strain elements are in Voigt
              notation, so one should specify 6 numbers for 3D
              periodic system (order: xx,yy,zz,yz,xz,xy), 3 numbers
              for 2D periodic systems (order: xx,yy,xy) or 1 number
              for 1D periodic systems.

            * **MapAtomsToUnitCell** (*Iterable**[**float**] **|
              **FloatListKey*) -- For periodic systems the atoms will
              be moved to the central unit cell where all their
              fractional coordinates are in the range
              [start_range,start_range+1). No mapping will take place
              along non-periodic directions. If just a single number
              is given, it corresponds to start_range. If multiple
              numbers are given, they should match the number of
              lattice vectors and will be used as start ranges along
              the individual lattice vectors. If no number is given at
              all, the mapping will be done to the [-0.5:0.5) cell.

            * **PerturbCoordinates** (*float** | **FloatKey*) --
              Perturb the atomic coordinates by adding random numbers
              between [-PerturbCoordinates,PerturbCoordinates] to each
              Cartesian component. This can be useful if you want to
              break the symmetry of your system (e.g. for a geometry
              optimization).

            * **PerturbLattice** (*float** | **FloatKey*) -- Perturb
              the lattice vectors by applying random strain with
              matrix elements between
              [-PerturbLattice,PerturbLattice]. This can be useful if
              you want to deviate from an ideal symmetric geometry,
              for example if you look for a phase change due to high
              pressure.

            * **SuperCell** (*Iterable**[**int**] **| **IntListKey*)
              -- Create a supercell of the input system (only possible
              for periodic systems). The integer numbers represent the
              diagonal elements of the supercell transformation; you
              should specify as many numbers as lattice vectors (i.e.
              1 number for 1D, 2 numbers for 2D and 3 numbers for 3D
              periodic systems).

            * **SuperCellTrafo** (*Iterable**[**int**] **|
              **IntListKey*) -- Create a supercell of the input system
              (only possible for periodic systems) \vec{a}_i' = \sum_j
              T_{ij} \vec{a}_j. The integer numbers represent the
              supercell transformation T_{ij}: 1 number for 1D PBC, 4
              numbers for 2D PBC corresponding to a 2x2 matrix (order:
              (1,1),(1,2),(2,1),(2,2)) and 9 numbers for 3D PBC
              corresponding to a 3x3 matrix (order:
              (1,1),(1,2),(1,3),(2,1),(2,2),(2,3),(3,1),(3,2),(3,3)).

            * **Symmetrize** (*BoolType** | **BoolKey*) -- Symmetrizes
              a system, using either the "symmetrize_molecule" or
              "symmetrize_cell" method, depending on periodicity.

            * **SymmetrizeMoleculeTo** (*str** | **StringKey*) --
              Symmetrizes a molecule to a particular symmetry given by
              a Schoenflies symbol. Symmetrizes the atomic coordinates
              to machine precision, but does NOT rototranslate the
              molecule in any way. If the symmetrization fails, an
              error will be raised.

            * **Translate** (*Iterable**[**float**] **|
              **FloatListKey*) -- Translate all atoms by a vector.

   class _TrajectoryInfo

      All the info regarding the reading of the trajectory files.

      Variables:
         * **NBlocksToCompare** (*int** | **IntKey*) -- Get an error
           estimate by comparing histograms for NBLocks time blocks of
           the trajectory.

         * **Trajectory** (*Analysis._TrajectoryInfo._Trajectory*) --
           All info regarding the reading of a single trajectory file.

      class _Trajectory

         All info regarding the reading of a single trajectory file.

         Variables:
            * **KFFilename** (*str** | **Path** | **StringKey*) -- The
              name of the AMS trajectory file.

            * **Range** (*Iterable**[**int**] **| **IntListKey*) --
              One or two values: start frame, and optionally end
              frame. By default the first and last frame are read.

            * **StepSize** (*int** | **IntKey*) -- The step size at
              which frames are read from the RKF (default 1, every
              frame is read).

class AtomTyping

   Variables:
      * **Type** (*Literal**[**"GAFF"**, **"UFF"**, **"APPLE&P"**,
        **"UFFAutograf"**]*) -- The forcefield type for which
        atomtyping should be performed

      * **APPLE&P** (*AtomTyping._APPLE&P*) -- Options for APPLE&P
        atom typing

      * **GAFF** (*AtomTyping._GAFF*) -- Options for ForceField atom
        typing

      * **LoadSystem** (*AtomTyping._LoadSystem*) -- Block that
        controls reading the chemical system from a KF file instead of
        the [System] block.

      * **System** (*AtomTyping._System*) -- Specification of the
        chemical system. For some applications more than one system
        may be present in the input. In this case, all systems except
        one must have a non-empty string ID specified after the System
        keyword. The system without an ID is considered the main one.

   class _APPLE_AND_P

      Options for APPLE&P atom typing

      Variables:
         **MolecularCharge** (*AtomTyping._APPLE&P._MolecularCharge*)
         -- Charge of a molecule

      class _MolecularCharge

         Charge of a molecule

         Variables:
            * **Charge** (*float** | **FloatKey*) -- Molecular charge

            * **Region** (*str** | **StringKey*) -- Region name of the
              molecule for which a charge will be provided

   class _GAFF

      Options for ForceField atom typing

      Variables:
         * **AntechamberTask** (*Literal**[**"GeometryOptimization"**,
           **"SinglePoint"**]*) -- If antechamber is invoked to guess
           atomtypes and charges (GAFF force field), select the task
           for charge guessing with MOPAC

         * **KeepAntechamberFolder** (*BoolType** | **BoolKey*) -- If
           atom-typing is performed with antechamber, keep the folder
           after the call to antechamber

         * **MolecularCharge** (*AtomTyping._GAFF._MolecularCharge*)
           -- Defines a (set of) submolecule(s) with their charge, to
           be Used in GAFF atomtyping.

      class _MolecularCharge

         Defines a (set of) submolecule(s) with their charge, to be
         Used in GAFF atomtyping.

         Variables:
            * **Charge** (*float** | **FloatKey*) -- Molecular charge
              of submolecule(s) defined in Region.

            * **Region** (*str** | **StringKey*) -- Region name that
              defines a (set of) submolecule(s).

   class _LoadSystem

      Block that controls reading the chemical system from a KF file
      instead of the [System] block.

      Variables:
         * **File** (*str** | **Path** | **StringKey*) -- The path of
           the KF file from which to load the system. It may also be
           the results directory containing it.

         * **Section** (*str** | **StringKey*) -- The section on the
           KF file from which to load the system.

   class _System

      Specification of the chemical system. For some applications more
      than one system may be present in the input. In this case, all
      systems except one must have a non-empty string ID specified
      after the System keyword. The system without an ID is considered
      the main one.

      Variables:
         * **AllowCloseAtoms** (*BoolType** | **BoolKey*) -- No longer
           functional. Just here for backwards compatibility.

         * **Charge** (*float** | **FloatKey*) -- The system's total
           charge in atomic units.

         * **FractionalCoords** (*BoolType** | **BoolKey*) -- Whether
           the atomic coordinates in the Atoms block are given in
           fractional coordinates of the lattice vectors. Requires the
           presence of the Lattice block.

         * **GeometryFile** (*str** | **Path** | **StringKey*) -- Read
           the geometry from a file (instead of from Atoms and Lattice
           blocks). Supported formats: .xyz

         * **GuessBonds** (*BoolType** | **BoolKey*) -- Equivalent to
           'Modify%GuessBonds'. Please update input file to use
           'Modify' block instead.

         * **LatticeStrain** (*Iterable**[**float**] **|
           **FloatListKey*) -- Equivalent to 'Modify%LatticeStrain'.
           Please update input file to use 'Modify' block instead.

         * **MapAtomsToUnitCell** (*BoolType** | **BoolKey*) --
           Equivalent to 'Modify%MapAtomsToUnitCell'. Please update
           input file to use 'Modify' block instead.

         * **PerturbCoordinates** (*float** | **FloatKey*) --
           Equivalent to 'Modify%PerturbCoordinates'. Please update
           input file to use 'Modify' block instead.

         * **PerturbLattice** (*float** | **FloatKey*) -- Equivalent
           to 'Modify%PerturbLattice'. Please update input file to use
           'Modify' block instead.

         * **ShiftCoordinates** (*Iterable**[**float**] **|
           **FloatListKey*) -- Equivalent to 'Modify%Translate', but
           in the unit of bohr by default. Please update input file to
           use 'Modify' block instead.

         * **SuperCell** (*Iterable**[**int**] **| **IntListKey*) --
           Equivalent to 'Modify%SuperCell'. Please update input file
           to use 'Modify' block instead.

         * **SuperCellTrafo** (*Iterable**[**int**] **| **IntListKey*)
           -- Equivalent to 'Modify%SuperCellTrafo'. Please update
           input file to use 'Modify' block instead.

         * **Symmetrize** (*BoolType** | **BoolKey*) -- Equivalent to
           'Modify%Symmetrize'. Please update input file to use
           'Modify' block instead.

         * **Atoms** (*str** | **Sequence**[**str**] **| **FreeBlock*)
           -- The atom types and coordinates. Unit can be specified in
           the header. Default unit is Angstrom.

         * **BondOrders** (*str** | **Sequence**[**str**] **|
           **FreeBlock*) -- Defined bond orders. Each line should
           contain two atom indices, followed by the bond order (1,
           1.5, 2, 3 for single, aromatic, double and triple bonds)
           and (optionally) the cell shifts for periodic systems. May
           be used by MM engines and for defining constraints. If the
           system is periodic and none of the bonds have the cell
           shift defined then AMS will attempt to determine them
           following the minimum image convention.

         * **ElectrostaticEmbedding**
           (*AtomTyping._System._ElectrostaticEmbedding*) -- Container
           for electrostatic embedding options, which can be combined.

         * **Lattice** (*str** | **Sequence**[**str**] **|
           **FreeBlock*) -- Up to three lattice vectors. Unit can be
           specified in the header. Default unit is Angstrom.

         * **Modify** (*AtomTyping._System._Modify*) -- Modifications
           to make to the chemical system after construction. This
           block is read like a script and the modifications applied
           top to bottom.

      class _Atoms

         The atom types and coordinates. Unit can be specified in the
         header. Default unit is Angstrom.

      class _BondOrders

         Defined bond orders. Each line should contain two atom
         indices, followed by the bond order (1, 1.5, 2, 3 for single,
         aromatic, double and triple bonds) and (optionally) the cell
         shifts for periodic systems. May be used by MM engines and
         for defining constraints. If the system is periodic and none
         of the bonds have the cell shift defined then AMS will
         attempt to determine them following the minimum image
         convention.

      class _ElectrostaticEmbedding

         Container for electrostatic embedding options, which can be
         combined.

         Variables:
            * **ElectricField** (*Iterable**[**float**] **|
              **FloatListKey*) --

              External homogeneous electric field with three Cartesian
              components: ex, ey, ez, the default unit being V/Å.

              In atomic units: Hartree/(e bohr) = 51.422 V/Angstrom;
              the relation to SI units is: 1 Hartree/(e bohr) = 5.14
              ... e11 V/m.

              Supported by the engines adf, band, dftb and mopac.

              For periodic systems the field may only have nonzero
              components orthogonal to the direction(s) of periodicity
              (i.e. for 1D periodic system the x-component of the
              electric field should be zero, while for 2D periodic
              systems both the x and y components should be zero. This
              options cannot be used for 3D periodic systems.

            * **MultipolePotential** (*AtomTyping._System._Electrosta
              ticEmbedding._MultipolePotential*) -- External point
              charges (and dipoles).

         class _MultipolePotential

            External point charges (and dipoles).

            Variables:
               * **ChargeModel** (*Literal**[**"Point"**,
                 **"Gaussian"**]*) -- A multipole may be represented
                 by a point (with a singular potential at its
                 location) or by a spherical Gaussian distribution.

               * **ChargeWidth** (*float** | **FloatKey*) -- The width
                 parameter in a.u. in case a Gaussian charge model is
                 chosen. A negative value means that the width will be
                 chosen automatically.

               * **Coordinates** (*str** | **Sequence**[**str**] **|
                 **FreeBlock*) --

                 Positions and values of the multipoles, one per line.
                 Each line has the following format:

                 x y z q, or x y z q µx µy µz.

                 Here x, y, z are the coordinates in Å, q is the
                 charge (in atomic units of charge) and µx, µy, µz are
                 the (optional) dipole moment components (in atomic
                 units, i.e. e*Bohr).

                 Periodic systems are not supported.

            class _Coordinates

               Positions and values of the multipoles, one per line.
               Each line has the following format:

               x y z q, or x y z q µx µy µz.

               Here x, y, z are the coordinates in Å, q is the charge
               (in atomic units of charge) and µx, µy, µz are the
               (optional) dipole moment components (in atomic units,
               i.e. e*Bohr).

               Periodic systems are not supported.

      class _Lattice

         Up to three lattice vectors. Unit can be specified in the
         header. Default unit is Angstrom.

      class _Modify

         Modifications to make to the chemical system after
         construction. This block is read like a script and the
         modifications applied top to bottom.

         Variables:
            * **EnableAtomAttributes** (*Literal**[**"gui"**,
              **"adf"**, **"band"**, **"forcefield"**, **"dftb"**,
              **"reaxff"**, **"qe"**]*) -- Enables an atomic attribute
              group. This is only necessary if you want a group
              enabled, but no atom in the input is using any attribute
              from that group.

            * **GuessBonds** (*BoolType** | **BoolKey*) -- Guesses
              bonds based on the atomic elements and the geometry.
              Keeps existing bonds.

            * **LatticeStrain** (*Iterable**[**float**] **|
              **FloatListKey*) -- Deform the input system by the
              specified strain. The strain elements are in Voigt
              notation, so one should specify 6 numbers for 3D
              periodic system (order: xx,yy,zz,yz,xz,xy), 3 numbers
              for 2D periodic systems (order: xx,yy,xy) or 1 number
              for 1D periodic systems.

            * **MapAtomsToUnitCell** (*Iterable**[**float**] **|
              **FloatListKey*) -- For periodic systems the atoms will
              be moved to the central unit cell where all their
              fractional coordinates are in the range
              [start_range,start_range+1). No mapping will take place
              along non-periodic directions. If just a single number
              is given, it corresponds to start_range. If multiple
              numbers are given, they should match the number of
              lattice vectors and will be used as start ranges along
              the individual lattice vectors. If no number is given at
              all, the mapping will be done to the [-0.5:0.5) cell.

            * **PerturbCoordinates** (*float** | **FloatKey*) --
              Perturb the atomic coordinates by adding random numbers
              between [-PerturbCoordinates,PerturbCoordinates] to each
              Cartesian component. This can be useful if you want to
              break the symmetry of your system (e.g. for a geometry
              optimization).

            * **PerturbLattice** (*float** | **FloatKey*) -- Perturb
              the lattice vectors by applying random strain with
              matrix elements between
              [-PerturbLattice,PerturbLattice]. This can be useful if
              you want to deviate from an ideal symmetric geometry,
              for example if you look for a phase change due to high
              pressure.

            * **SuperCell** (*Iterable**[**int**] **| **IntListKey*)
              -- Create a supercell of the input system (only possible
              for periodic systems). The integer numbers represent the
              diagonal elements of the supercell transformation; you
              should specify as many numbers as lattice vectors (i.e.
              1 number for 1D, 2 numbers for 2D and 3 numbers for 3D
              periodic systems).

            * **SuperCellTrafo** (*Iterable**[**int**] **|
              **IntListKey*) -- Create a supercell of the input system
              (only possible for periodic systems) \vec{a}_i' = \sum_j
              T_{ij} \vec{a}_j. The integer numbers represent the
              supercell transformation T_{ij}: 1 number for 1D PBC, 4
              numbers for 2D PBC corresponding to a 2x2 matrix (order:
              (1,1),(1,2),(2,1),(2,2)) and 9 numbers for 3D PBC
              corresponding to a 3x3 matrix (order:
              (1,1),(1,2),(1,3),(2,1),(2,2),(2,3),(3,1),(3,2),(3,3)).

            * **Symmetrize** (*BoolType** | **BoolKey*) -- Symmetrizes
              a system, using either the "symmetrize_molecule" or
              "symmetrize_cell" method, depending on periodicity.

            * **SymmetrizeMoleculeTo** (*str** | **StringKey*) --
              Symmetrizes a molecule to a particular symmetry given by
              a Schoenflies symbol. Symmetrizes the atomic coordinates
              to machine precision, but does NOT rototranslate the
              molecule in any way. If the symmetrization fails, an
              error will be raised.

            * **Translate** (*Iterable**[**float**] **|
              **FloatListKey*) -- Translate all atoms by a vector.

class CPL

   Variables:
      * **ADFFile** (*str** | **StringKey*) -- Path to TAPE21 file
        from which cpl reads data and to which cpl writes data

      * **ALTRHOF** (*BoolType** | **BoolKey*) --

      * **Allow** (*str** | **StringKey*) --

      * **CALCV2007** (*BoolType** | **BoolKey*) -- compatibility with
        older versions of CPL that did not use the SAPA approximation
        but always calculated the potential during the CPL run, which
        is inconsistent with SAPA settings in ADF

      * **CPLDebug** (*int** | **IntKey*) --

      * **Debug** (*str** | **StringKey*) --

      * **Diagonal** (*BoolType** | **BoolKey*) --

      * **Diffuse** (*BoolType** | **BoolKey*) --

      * **FORCECONVERGE** (*BoolType** | **BoolKey*) --

      * **FULLNBO** (*BoolType** | **BoolKey*) --

      * **Fractional** (*BoolType** | **BoolKey*) -- Allow Fractional
        occupations

      * **GGA** (*BoolType** | **BoolKey*) -- Use first-order GGA
        potential instead of the first-order VWN potential

      * **LinearScaling** (*BoolType** | **BoolKey*) --

      * **MODEBUG** (*BoolType** | **BoolKey*) --

      * **NBODEBUG** (*BoolType** | **BoolKey*) --

      * **NEWCPKS** (*BoolType** | **BoolKey*) --

      * **NoFDKERN** (*BoolType** | **BoolKey*) --

      * **NoGGAPot** (*BoolType** | **BoolKey*) --

      * **NoKMat** (*BoolType** | **BoolKey*) --

      * **NoPrint** (*str** | **StringKey*) --

      * **NoTKINFDKERN** (*BoolType** | **BoolKey*) --

      * **NoXCFDKERN** (*BoolType** | **BoolKey*) --

      * **OLDCPKS** (*BoolType** | **BoolKey*) --

      * **OldCode** (*BoolType** | **BoolKey*) -- Use old code

      * **PSOFirst** (*BoolType** | **BoolKey*) --

      * **Print** (*str** | **StringKey*) --

      * **Restart** (*str** | **StringKey*) --

      * **SPINCURRENTS** (*BoolType** | **BoolKey*) --

      * **Save** (*str** | **StringKey*) --

      * **Skip** (*str** | **StringKey*) --

      * **TAPE10File** (*str** | **StringKey*) -- Path to the TAPE10
        file from which cpl reads data

      * **Hyperfine** (*CPL._Hyperfine*) -- control the computation of
        the NSSCCs

      * **NMRCoupling** (*CPL._NMRCoupling*) -- control the
        computation of the NSSCCs

      * **ZFS** (*CPL._ZFS*) -- ZFS branch of the code

   class _Hyperfine

      control the computation of the NSSCCs

      Variables:
         * **ADFGUI** (*BoolType** | **BoolKey*) --

         * **Atoms** (*Iterable**[**int**] **| **IntListKey*) --

         * **Enabled** (*BoolType** | **BoolKey*) --

         * **FC** (*BoolType** | **BoolKey*) --

         * **NOFC** (*BoolType** | **BoolKey*) --

         * **NOPSOSO** (*BoolType** | **BoolKey*) --

         * **NOSD** (*BoolType** | **BoolKey*) --

         * **Nuclei** (*Iterable**[**int**] **| **IntListKey*) --

         * **PSOSO** (*BoolType** | **BoolKey*) --

         * **SD** (*BoolType** | **BoolKey*) --

         * **SCF** (*CPL._Hyperfine._SCF*) --

      class _SCF

         Variables:
            * **Converge** (*float** | **FloatKey*) -- maximum number
              of iterations

            * **Iterations** (*int** | **IntKey*) -- maximum number of
              iterations

            * **Mix** (*float** | **FloatKey*) --

            * **NOACCEL** (*BoolType** | **BoolKey*) --

            * **NOCYC** (*BoolType** | **BoolKey*) --

   class _NMRCoupling

      control the computation of the NSSCCs

      Variables:
         * **ADFGUI** (*BoolType** | **BoolKey*) --

         * **ALDA** (*BoolType** | **BoolKey*) --

         * **AtomPert** (*Iterable**[**int**] **| **IntListKey*) --

         * **AtomResp** (*Iterable**[**int**] **| **IntListKey*) --

         * **Contributions** (*str** | **StringKey*) -- Analyze
           orbital contributions

         * **DSO** (*BoolType** | **BoolKey*) --

         * **FC** (*BoolType** | **BoolKey*) --

         * **Gamma** (*str** | **StringKey*) --

         * **Internal** (*BoolType** | **BoolKey*) --

         * **NOFC** (*BoolType** | **BoolKey*) --

         * **NOSD** (*BoolType** | **BoolKey*) --

         * **Nuclei** (*Iterable**[**int**] **| **IntListKey*) --

         * **PSO** (*BoolType** | **BoolKey*) --

         * **PertAllAtomsOfType** (*str** | **StringKey*) -- Space
           separated list of type of perturbing nuclei (like H, C, P)
           for which the NMR spin-spin coupling should be calculated.

         * **RespAllAtomsOfType** (*str** | **StringKey*) -- Space
           separated list of type of responding nuclei (like H, C, P)
           for which the NMR spin-spin coupling should be calculated.

         * **SD** (*BoolType** | **BoolKey*) --

         * **XAlpha** (*BoolType** | **BoolKey*) --

         * **SCF** (*CPL._NMRCoupling._SCF*) --

      class _SCF

         Variables:
            * **Converge** (*float** | **FloatKey*) -- maximum number
              of iterations

            * **DELTAE** (*BoolType** | **BoolKey*) -- apply energy
              denominator correction

            * **DiskMO** (*BoolType** | **BoolKey*) -- store MO's on
              disk

            * **ERange** (*str** | **StringKey*) --

            * **Iterations** (*int** | **IntKey*) -- maximum number of
              iterations

            * **Mix** (*float** | **FloatKey*) --

            * **NOACCEL** (*BoolType** | **BoolKey*) --

            * **NOCYC** (*BoolType** | **BoolKey*) --

   class _ZFS

      ZFS branch of the code

      Variables:
         * **ADFGUI** (*BoolType** | **BoolKey*) --

         * **GAUGE** (*BoolType** | **BoolKey*) --

         * **NOGAUGE** (*BoolType** | **BoolKey*) --

         * **NOSOSO** (*BoolType** | **BoolKey*) --

         * **SOSO** (*BoolType** | **BoolKey*) --

         * **SCF** (*CPL._ZFS._SCF*) --

      class _SCF

         Variables:
            * **Converge** (*float** | **FloatKey*) -- maximum number
              of iterations

            * **Iterations** (*int** | **IntKey*) -- maximum number of
              iterations

            * **Mix** (*float** | **FloatKey*) --

            * **NOACCEL** (*BoolType** | **BoolKey*) --

            * **NOCYC** (*BoolType** | **BoolKey*) --

class Chemtrayzer2

   Variables:
      * **PrintDebug** (*BoolType** | **BoolKey*) -- Print extra debug
        information to the terminal.

      * **Analysis** (*Chemtrayzer2._Analysis*) -- Statistical post-
        detection analysis, includes reaction coefficients
        calculation.

      * **MoleculeIdentifier** (*Chemtrayzer2._MoleculeIdentifier*) --
        Settings for the subgraph identification of molecules and
        reactions.

      * **Output** (*Chemtrayzer2._Output*) -- Settings for program
        output and output file generation.

      * **ReactionDetection** (*Chemtrayzer2._ReactionDetection*) --
        Parameters for the the reaction detection algorithm.

      * **Trajectory** (*Chemtrayzer2._Trajectory*) -- Info regarding
        the trajectory to analyze.

   class _Analysis

      Statistical post-detection analysis, includes reaction
      coefficients calculation.

      Variables:
         * **PerformAnalysis** (*BoolType** | **BoolKey*) -- Determine
           the reaction rate coefficients and statistical errors for
           the detected reactions.

         * **RateConfidence** (*float** | **FloatKey*) -- Upper and
           lower bounds to the rate coefficients will be calculated
           for this confidence (0 < confidence < 1), assuming a
           Poisson distribution of the number of reactive events. A
           value of 0.9 means that the kinetics of 90% of events of
           one reaction can be described by a coefficient between the
           bounds.

   class _MoleculeIdentifier

      Settings for the subgraph identification of molecules and
      reactions.

      Variables:
         * **MaxDepth** (*int** | **IntKey*) -- The maximum number of
           layers the algorithm goes along bonds, starting from one
           atom when generating hashes for one atom. The entire
           molecule hash is built from the atom hashes, so this
           setting influences the identification of atom
           neighborhoods.

         * **UseBondOrders** (*BoolType** | **BoolKey*) -- Consider
           bond orders in the identifier.

         * **UseHs** (*BoolType** | **BoolKey*) -- Consider number of
           hydrogens of atoms in the identifier.

         * **UseRings** (*BoolType** | **BoolKey*) -- Consider ring
           membership of atoms in the identifier.

         * **WindowDepth** (*int** | **IntKey*) -- The maximum number
           of layers the algorithm goes along bonds starting from the
           reactive atoms when generating hashes for the entire
           molecule. With this setting, the identifier can be limited
           to only a part of the molecule.

   class _Output

      Settings for program output and output file generation.

      Variables:
         * **CreateLegacyOutput** (*BoolType** | **BoolKey*) --
           Whether to save the reactions, species, and rates as
           'reac.reac.tab', 'reac.spec.tab', and 'reac.rate.tab' in
           the same format as ChemTraYzer 1.

         * **ShowReactionGraph** (*BoolType** | **BoolKey*) -- Whether
           or not to show the reaction graph at the end of the
           calculation. Requires the python library matplotlib to be
           installed.

         * **WriteEventsPerTime** (*BoolType** | **BoolKey*) -- Write
           two .csv files that contain the number of reactions in
           every frame (reaction_events_per_time.csv) and the number
           of bond changes in every
           frame(bond_change_events_per_time.csv)

         * **WriteKF** (*BoolType** | **BoolKey*) -- Whether to write
           output to KF

         * **WriteMolPopulation** (*BoolType** | **BoolKey*) -- Write
           two .csv files: (1) mol_statistics.csv, which contains
           basic population statistics (counts, averages) for each
           unique species over the entire trajectory; and (2)
           mol_population.csv, which provides the count of each unique
           species in every frame.

         * **WriteReactions** (*BoolType** | **BoolKey*) -- Write two
           .csv files that contain information about (1) all unique
           reactions (reactions.csv); and (2) all individual reaction
           events (reaction_events.csv).

         * **WriteXYZFiles** (*BoolType** | **BoolKey*) -- Write XYZ
           files (geometries) for detected species and XYZ movies for
           detected reactions into a subfolder named 'xyz'.

   class _ReactionDetection

      Parameters for the the reaction detection algorithm.

      Variables:
         * **BondBreakingThreshold** (*float** | **FloatKey*) -- The
           bond-order threshold for bond breaking. If the bond order
           of a bond goes below this value, the bond is considered
           broken.

         * **BondFormationThreshold** (*float** | **FloatKey*) -- The
           bond-order threshold for bond formation. If the bond order
           between two atoms goes above this value, then this will be
           considered to be a new bond.

         * **InitialBondThreshold** (*float** | **FloatKey*) -- The
           bond-order threshold for determining the connectivity for
           the first frame of the simulation. If not specified, the
           value in BondFormationThreshold will be used instead.

         * **TStable** (*float** | **FloatKey*) -- The minimum time
           for a molecule to be considered stable.

   class _Trajectory

      Info regarding the trajectory to analyze.

      Variables:
         * **FinalFrame** (*int** | **IntKey*) -- Last frame of the
           trajectory to analyze.

         * **FirstFrame** (*int** | **IntKey*) -- First frame of the
           trajectory to analyze.

         * **Path** (*str** | **Path** | **StringKey*) -- The path to
           ams results dir of an AMS calculation. This folder must
           contain a ams.rkf file.

class Conductance

   Variables:
      * **EnergyGrid** (*Conductance._EnergyGrid*) -- Energy grid for
        Transmission Function

      * **Files** (*Conductance._Files*) -- path of files

      * **Output** (*Conductance._Output*) -- options describing what
        should be printed

      * **Physics** (*Conductance._Physics*) -- Block describing the
        physics of the system

      * **Technical** (*Conductance._Technical*) -- options describing
        technical parts of the calculation

   class _EnergyGrid

      Energy grid for Transmission Function

      Variables:
         * **Max** (*float** | **FloatKey*) -- Max Energy (relative to
           Fermi energy)

         * **Min** (*float** | **FloatKey*) -- Min energy (relative to
           Fermi energy)

         * **Num** (*int** | **IntKey*) -- Number of energy values in
           which the interval Min-Max is subdivided

   class _Files

      path of files

      Variables:
         * **HamiltonianElectrode** (*str** | **StringKey*) --

         * **HamiltonianMolecule** (*str** | **StringKey*) --

         * **Leads** (*str** | **StringKey*) -- Path (either absolute
           or relative) of the lead results file

         * **OverlapElectrode** (*str** | **StringKey*) --

         * **OverlapMolecule** (*str** | **StringKey*) --

         * **Scattering** (*str** | **StringKey*) -- Path (either
           absolute or relative) of the scattering region results

   class _Output

      options describing what should be printed

      Variables:
         **OldOutput** (*BoolType** | **BoolKey*) --

   class _Physics

      Block describing the physics of the system

      Variables:
         **FermiEnergy** (*Conductance._Physics._FermiEnergy*) --
         Block describing the physics of the system

      class _FermiEnergy

         Block describing the physics of the system

         Variables:
            **Electrode** (*float** | **FloatKey*) -- Fermi energy of
            the electrode

   class _Technical

      options describing technical parts of the calculation

      Variables:
         * **Eta** (*float** | **FloatKey*) -- To avoid poles of the
           Green's function, a small imaginary number is added to the
           energy

         * **overwriteLeads** (*BoolType** | **BoolKey*) -- If true,
           Hamiltonians H_L and H_R are taken from the DFTB-leads
           calculation. If False, they are taken from the DFTB
           scattering-region calculation

         * **setOffDiagonalToZero** (*BoolType** | **BoolKey*) -- If
           true, H_LR and S_LR are explicitly set to zero. If False,
           they are taken from the DFTB scattering-region calculation.

class Conformers

   Variables:
      * **InputConformersSet** (*str** | **Path** | **StringKey*) --

        The path to a file containing a set of conformers.

        The file should be either an 'conformers.rkf' file (i.e. the
        results file of conformers), a concatenated .xyz file, a .sdf
        file, or even .dcd file. In the case of a .dcd file, an
        additional System block is required. If the specified file
        does not contain energies in the AMS conformers format (as
        produced by the conformers tool), all conformer energies will
        be set to zero.

        You can specify multiple input conformers sets by including
        the InputConformersSet keyword multiple times.

      * **InputMaxConfs** (*int** | **IntKey*) -- The maximum number
        of conformers to carry forward when loading conformer sets.
        If this input is not specified, this limit will not be
        imposed.

      * **InputMaxEnergy** (*float** | **FloatKey*) -- Threshold for
        filtering out high-energy conformers when loading conformers
        sets using the InputConformerSet keyword. Conformers with an
        larger relative energy will not be loaded.

      * **RNGSeed** (*int** | **IntKey*) -- Initial seed for the
        (pseudo)random number generator. If this is unset, the
        generator will be seeded randomly from external sources of
        entropy and the generated conformers will be non-
        deterministic.

      * **Task** (*Literal**[**"Generate"**, **"Optimize"**,
        **"Filter"**, **"Score"**, **"Expand"**]*) --

        The task to be performed by the Conformers tool.

        'Generate': given a molecule, generate a set of conformers.
        Note: this task will automatically optimize, filter and score
        the conformers.

        'Optimize': given a previously generated set of conformers,
        optimize, filter and score the structures using the specified
        engine.

        'Filter': given one or more previously generated set of
        conformers, merge them into a single conformer set and filter
        out duplicate conformers. Note: this will not optimize or re-
        score the conformers.

        'Score' given one or more previously generated set of
        conformers, re-score them by computing the energy using the
        specified engine. Note: this will only do a single point
        calculation, and will not optimize the structures.

        In case of 'Optimize', 'Filter' and 'Score' you can specify
        the input conformer set(s) using the 'InputConformersSet'
        keyword.

      * **Constraints** (*Conformers._Constraints*) -- The Constraints
        block allows geometry optimizations and potential energy
        surface scans with constraints. The constraints do not have to
        be satisfied at the start of the calculation.

      * **Engine** (*EngineBlock*) -- The input for the computational
        engine used to compute energy and forces.

      * **EngineAddons** (*Conformers._EngineAddons*) -- This block
        configures all the engine add-ons.

      * **Equivalence** (*Conformers._Equivalence*) -- Options for the
        procedure determining whether two structures are equivalent or
        distinct conformers.

      * **Expander** (*Conformers._Expander*) --

        Options for the conformer expander. The Expander expands an
        existing conformer set, by adding new conformers to it. The
        new conformers are generated from the original conformers in
        the set. Unlike the generators, the outcome of an expander is
        therefore very dependent on the input conformations.

        The GC generator uses a genetic algorithm to create a
        combinatorial expansion by combining local substructures. The
        MD expander start MD simulations from the conformers in the
        set, and extracts snapshots to create new conformers. Both
        these expanders are part of the CREST generator.

      * **Filter** (*Conformers._Filter*) -- Options for the conformer
        filtering.

      * **Generator** (*Conformers._Generator*) -- Options for the
        conformer generator.

      * **GeometryOptimization** (*Conformers._GeometryOptimization*)
        -- Some options / details regarding the optimization
        procedure.

      * **LoadSystem** (*Conformers._LoadSystem*) -- Block that
        controls reading the chemical system from a KF file instead of
        the [System] block.

      * **Output** (*Conformers._Output*) -- Options regarding the
        output and result files.

      * **Restraints** (*Conformers._Restraints*) -- The Restraints
        block allows to add soft constraints to the system. A
        restraint is a potential energy function (a spring) attached
        to a certain coordinate, for example, an interatomic distance,
        with its minimum at the specified optimal value. A restraint
        is defined using one or two parameters: the ForceConstant and,
        for some types, the F(Inf) value. The ForceConstant parameter
        corresponds to second derivative of the restraint potential
        energy d2V(x)/dx^2 for any x (harmonic restraints) or only at
        at x=0 (other restraints). Here, x is a deviation from the
        restraint's optimal value.

      * **Rotamers** (*Conformers._Rotamers*) -- Options for the
        treatment of Grimme-rotamers.

      * **System** (*Conformers._System*) -- Specification of the
        chemical system. For some applications more than one system
        may be present in the input. In this case, all systems except
        one must have a non-empty string ID specified after the System
        keyword. The system without an ID is considered the main one.

   class _Constraints

      The Constraints block allows geometry optimizations and
      potential energy surface scans with constraints. The constraints
      do not have to be satisfied at the start of the calculation.

      Variables:
         * **All** (*str** | **StringKey*) --

           Fix multiple distances using one the following formats:
           All [bondOrder] bonds at1 at2 [to distance] All triangles
           at1 at2 at3

           The first option constrains all bonds between atoms at1 at2
           to a certain length, while the second - bonds at1-at2 and
           at2-at3 as well as the angle between them.

           The [bondOrder] can be a number or a string such as single,
           double, triple or aromatic. If it's omitted then any bond
           between specified atoms will be constrained. Atom names are
           case-sensitive and they must be as they are in the Atoms
           block, or an asterisk '*' denoting any atom. If the
           distance is omitted then the bond length from the initial
           geometry is used.

           Important: only the bonds present in the system at the
           start of the simulation can be constrained, which means
           that the bonds may need to be specified in the System
           block.

           Valid examples: All single bonds C C to 1.4 All bonds O H
           to 0.98 All bonds O H All bonds H * All triangles H * H

         * **Angle** (*str** | **StringKey*) -- Fix the angle between
           three atoms. Three atom indices followed by an angle in
           degrees.

         * **Atom** (*int** | **IntKey*) -- Fix the position of an
           atom. Just one integer referring to the index of the atom
           in the [System%Atoms] block.

         * **AtomList** (*Iterable**[**int**] **| **IntListKey*) --
           Fix positions of the specified atoms. A list of integers
           referring to indices of atoms in the [System%Atoms] block.

         * **Block** (*str** | **StringKey*) -- Name of the region to
           constrain as a rigid block. Regions are specified in the
           System%Atoms block.

         * **BlockAtoms** (*Iterable**[**int**] **| **IntListKey*) --
           List of atom indices for a block constraint, where the
           internal degrees of freedom are frozen.

         * **Coordinate** (*str** | **StringKey*) -- Fix a particular
           coordinate of an atom. Atom index followed by (x|y|z).

         * **DifDist** (*str** | **StringKey*) -- Four atom indices i
           j k l followed by the distance in Angstrom. This will
           constrain the difference R(ij)-R(kl) at the given value.

         * **Dihedral** (*str** | **StringKey*) -- Fix the dihedral
           angle between four atoms. Four atom indices followed by an
           angle in degrees.

         * **Distance** (*str** | **StringKey*) -- Fix the distance
           between two atoms. Two atom indices followed by the
           distance in Angstrom.

         * **EqualStrain** (*str** | **StringKey*) --

           Exclusively for lattice optimizations:

           Accepts a set of strain components [xx, xy, xz, yy, yz, zz]
           which are to be kept equal.

           The applied strain will be determined by the average of the
           corresponding stress tensors components.

           In AMSinput just check the corresponding check buttons.

         * **FixedRegion** (*str** | **StringKey*) -- Fix positions of
           all atoms in a region.

         * **FreezeStrain** (*str** | **StringKey*) --

           Exclusively for lattice optimizations:

           Freezes any lattice deformation corresponding to a
           particular component of the strain tensor.

           Accepts a set of strain components [xx, xy, xz, yy, yz, zz]
           to be frozen.

           In AMSinput just check the corresponding check buttons.

         * **SumDist** (*str** | **StringKey*) -- Four atom indices i
           j k l followed by the distance in Angstrom. This will
           constrain the sum R(ij)+R(kl) at the given value.

   class _Engine

      The input for the computational engine used to compute energy
      and forces.

   class _EngineAddons

      This block configures all the engine add-ons.

      Variables:
         * **Pressure** (*float** | **FloatKey*) -- Add a hydrostatic
           pressure term to the engine's energy and stress tensor. Can
           only be used for 3D periodic boundary conditions.

         * **AtomEnergies** (*str** | **Sequence**[**str**] **|
           **FreeBlock*) -- Add an element-dependent energy per atom.
           On each line, give the chemical element followed by the
           energy (in atomic units).

         * **D3Dispersion** (*Conformers._EngineAddons._D3Dispersion*)
           -- This block configures the add-on that adds the Grimme D3
           dispersion correction to the engine's energy, gradients,
           and stress tensor.

         * **D4Dispersion** (*Conformers._EngineAddons._D4Dispersion*)
           -- This block configures the addon that adds the Grimme
           D4(EEQ) dispersion correction to the engine's energy,
           gradients, stress tensor and Hessian.

         * **ExternalEngine**
           (*Conformers._EngineAddons._ExternalEngine*) -- External
           engine as an addon

         * **ExternalStress**
           (*Conformers._EngineAddons._ExternalStress*) -- This block
           configures the addon that adds external stress term to the
           engine's energy and stress tensor.

         * **PipeEngine** (*Conformers._EngineAddons._PipeEngine*) --
           Pipe engine as an addon

         * **Repulsion** (*Conformers._EngineAddons._Repulsion*) --
           This block configures an addon that adds a repulsive Weeks-
           Chandler-Andersen potential to all atom pairs.

         * **WallPotential**
           (*Conformers._EngineAddons._WallPotential*) -- This block
           configures the addon that adds a spherical wall potential
           to the engine's energy and gradients.

      class _AtomEnergies

         Add an element-dependent energy per atom. On each line, give
         the chemical element followed by the energy (in atomic
         units).

      class _D3Dispersion

         This block configures the add-on that adds the Grimme D3
         dispersion correction to the engine's energy, gradients, and
         stress tensor.

         Variables:
            * **Damping** (*Literal**[**"BJ"**, **"Zero"**]*) -- Type
              of damping: BJ (Becke-Johnson) or Zero. BJ is
              recommended for most applications.

            * **Enabled** (*BoolType** | **BoolKey*) -- Enables the D3
              dispersion correction addon.

            * **Functional** (*str** | **StringKey*) -- Use the D3
              parameterization by Grimme for a given xc-functional.
              Accepts the same values as the --func command line
              option of the official dftd3 program. Note: the naming
              convention is different from elsewhere in the AMS suite.
              For example, BLYP should be called b-lyp.

            * **a1** (*float** | **FloatKey*) -- The a1 parameter.
              Only used if Damping is set to BJ. If set, it overwrites
              the a1 value for the chosen functional.

            * **a2** (*float** | **FloatKey*) -- The a2 parameter.
              Only used if Damping is set to BJ. If set, it overwrites
              the a2 value for the chosen functional.

            * **alp** (*float** | **FloatKey*) -- The a2 parameter.
              Only used if Damping is set to BJ. If set, it overwrites
              the a2 value for the chosen functional.

            * **s6** (*float** | **FloatKey*) -- The s6 parameter,
              global scaling parameter. If set, it overwrites the s6
              value for the chosen functional.

            * **s8** (*float** | **FloatKey*) -- The s8 parameter. If
              set, it overwrites the s8 value for the chosen
              functional.

            * **sr6** (*float** | **FloatKey*) -- The sr6 parameter.
              Only used if Damping is set to Zero. If set, it
              overwrites the sr6 value for the chosen functional.

      class _D4Dispersion

         This block configures the addon that adds the Grimme D4(EEQ)
         dispersion correction to the engine's energy, gradients,
         stress tensor and Hessian.

         Variables:
            * **Enabled** (*BoolType** | **BoolKey*) -- Enables the D4
              dispersion correction addon.

            * **Functional** (*Literal**[**"HF"**, **"BLYP"**,
              **"BPBE"**, **"BP86"**, **"BPW"**, **"LB94"**,
              **"MPWLYP"**, **"MPWPW91"**, **"OLYP"**, **"OPBE"**,
              **"PBE"**, **"RPBE"**, **"REVPBE"**, **"PW86PBE"**,
              **"RPW86PBE"**, **"PW91"**, **"PW91P86"**, **"XLYP"**,
              **"B97"**, **"TPSS"**, **"REVTPSS"**, **"SCAN"**,
              **"B1LYP"**, **"B3LYP"**, **"BHLYP"**, **"B1P86"**,
              **"B3P86"**, **"B1PW91"**, **"B3PW91"**, **"O3LYP"**,
              **"REVPBE0"**, **"REVPBE38"**, **"PBE0"**, **"PWP1"**,
              **"PW1PW"**, **"MPW1PW91"**, **"MPW1LYP"**,
              **"PW6B95"**, **"TPSSH"**, **"TPSS0"**, **"X3LYP"**,
              **"M06L"**, **"M06"**, **"OMEGAB97"**, **"OMEGAB97X"**,
              **"CAM-B3LYP"**, **"LC-BLYP"**, **"LH07TSVWN"**,
              **"LH07SSVWN"**, **"LH12CTSSIRPW92"**,
              **"LH12CTSSIFPW92"**, **"LH14TCALPBE"**, **"B2PLYP"**,
              **"B2GPPLYP"**, **"MPW2PLYP"**, **"PWPB95"**,
              **"DSDBLYP"**, **"DSDPBE"**, **"DSDPBEB95"**,
              **"DSDPBEP86"**, **"DSDSVWN"**, **"DODBLYP"**,
              **"DODPBE"**, **"DODPBEB95"**, **"DODPBEP86"**,
              **"DODSVWN"**, **"PBE02"**, **"PBE0DH"**,
              **"DFTB**(**3ob**)**"**, **"DFTB**(**mio**)**"**,
              **"DFTB**(**pbc**)**"**, **"DFTB**(**matsci**)**"**,
              **"DFTB**(**ob2**)**"**, **"B1B95"**, **"MPWB1K"**,
              **"REVTPSSH"**, **"GLYP"**, **"REVPBE0DH"**,
              **"REVTPSS0"**, **"REVDSDPBEP86"**, **"REVDSDPBEPBE"**,
              **"REVDSDBLYP"**, **"REVDODPBEP86"**, **"B97M"**,
              **"OMEGAB97M"**, **"R2SCAN"**]*) -- Use the D4
              parameterization by Grimme for a given xc-functional.

            * **Verbosity** (*Literal**[**"Silent"**, **"Normal"**,
              **"Verbose"**, **"VeryVerbose"**]*) -- Controls the
              verbosity of the dftd4 code. Equivalent to the --silent
              and --verbose command line switches of the official
              dftd4 program.

            * **a1** (*float** | **FloatKey*) -- The a1 parameter, see
              D4 article. The physically reasonable range for a1 is
              [0.0,1.0]. If set, it overwrites the a1 value for the
              chosen functional.

            * **a2** (*float** | **FloatKey*) -- The a2 parameter, see
              D4 article. The physically reasonable range for a2 is
              [0.0,7.0]. If set, it overwrites the a2 value for the
              chosen functional.

            * **ga** (*float** | **FloatKey*) -- The ga parameter. GCP

            * **gc** (*float** | **FloatKey*) -- The gc parameter. GCP

            * **s6** (*float** | **FloatKey*) -- The s6 parameter, see
              D4 article. The physically reasonable range for s6 is
              [0.0,1.0]. If set, it overwrites the s6 value for the
              chosen functional.

            * **s8** (*float** | **FloatKey*) -- The s8 parameter, see
              D4 article. The physically reasonable range for s8 is
              [0.0,3.0]. If set, it overwrites the s8 value for the
              chosen functional.

            * **s9** (*float** | **FloatKey*) -- The s9 parameter, see
              D4 article. If set, it overwrites the s9 value for the
              chosen functional.

      class _ExternalEngine

         External engine as an addon

         Variables:
            **Execute** (*str** | **StringKey*) -- execute command

      class _ExternalStress

         This block configures the addon that adds external stress
         term to the engine's energy and stress tensor.

         Variables:
            * **StressTensorVoigt** (*Iterable**[**float**] **|
              **FloatListKey*) -- The elements of the external stress
              tensor in Voigt notation. One should specify 6 numbers
              for 3D periodic system (order: xx,yy,zz,yz,xz,xy), 3
              numbers for 2D periodic systems (order: xx,yy,xy) or 1
              number for 1D periodic systems.

            * **UpdateReferenceCell** (*BoolType** | **BoolKey*) --
              Whether ot not the reference cell should be updated
              every time the system changes (see documentation).

      class _PipeEngine

         Pipe engine as an addon

         Variables:
            **WorkerCommand** (*str** | **StringKey*) -- pipe worker
            command

      class _Repulsion

         This block configures an addon that adds a repulsive Weeks-
         Chandler-Andersen potential to all atom pairs.

         Variables:
            * **Enabled** (*BoolType** | **BoolKey*) --

              Enables the repulsive Weeks-Chandler-Andersen potential
              addon.

              When enabled, all atom pairs will experience repulsion E
              = 4*epsilon*( (sigma/r)^12 - (sigma/r)^6 + 1/4 ) at the
              distances shorter than about 1.12*sigma.

            * **Epsilon** (*float** | **FloatKey*) -- The epsilon
              parameter in the potential equation. It is equal to the
              amount of energy added at r=sigma.

            * **HydrogenSigmaScale** (*float** | **FloatKey*) -- The
              sigma parameter for a pair of atoms where one of them is
              hydrogen is scaled with the given factor. For H-H
              interactions the sigma is scaled with this value
              squared.

            * **Sigma** (*float** | **FloatKey*) -- The sigma
              parameter in the potential equation. The potential is
              exactly zero at the distances larger than about
              1.12*sigma

            * **SkinLength** (*float** | **FloatKey*) -- Technical
              parameter specifying skin length for the neighbor list
              generation. A larger value increases the neighbor list
              cutoff (and cost) but reduces the frequency it needs to
              be re-created.

      class _WallPotential

         This block configures the addon that adds a spherical wall
         potential to the engine's energy and gradients.

         Variables:
            * **Enabled** (*BoolType** | **BoolKey*) -- Enables the
              wall potential addon. When enabled, a spherical wall of
              radius [Radius] around the origin will be added. The
              force due to the potential will decay exponentially
              inside the wall, will be close to [Prefactor*Gradient]
              outside and exactly half of that at the wall.

            * **Gradient** (*float** | **FloatKey*) -- The radial
              gradient outside the sphere.

            * **Prefactor** (*float** | **FloatKey*) -- The multiplier
              for the overall strength of the potential.

            * **Radius** (*float** | **FloatKey*) -- The radius of the
              sphere, wherein the potential is close to zero.

   class _Equivalence

      Options for the procedure determining whether two structures are
      equivalent or distinct conformers.

      Variables:
         * **AcceptAll** (*BoolType** | **BoolKey*) -- If set to True,
           add any candidate to the set without checks of connectivity
           changes, stereo- or cis/trans isomerization, or
           duplication.

         * **AcceptBondchanges** (*BoolType** | **BoolKey*) -- If set
           to True, perform all checks of a new conformer candidate,
           except for the connectivity check.

         * **AcceptIsomers** (*BoolType** | **BoolKey*) -- If set to
           True, perform all checks of a new conformer candidate,
           except for the stereo- or cis/trans isomerization check.

         * **CheckForDuplicates** (*BoolType** | **BoolKey*) -- If set
           to True, check any new conformer candidate for duplication,
           and only accept unique conformers. If set to False, accept
           duplicates into the set.

         * **EnableSwapping** (*BoolType** | **BoolKey*) -- If set to
           True, a conformer candidate will replace another conformer
           if it is deemed a duplicate but with slightly lower energy.

         * **LogDuplicates** (*BoolType** | **BoolKey*) -- If set to
           True, print information on equivalence to logfile and
           standard output.

         * **Method** (*Literal**[**"AMS"**, **"TFD"**, **"RMSD"**,
           **"CREST"**]*) --

           Method used to determine (and filter out) equivalent
           conformers.

           The CREST equivalence method relies on rotational constants
           comparisons. For this reason, conformers with the same
           rotational constants (such as mirror images) will be
           considered equivalent conformers.

           The AMS equivalence method uses a distance matrix and
           dihedrals to compare conformers. This equivalence method
           can be computationally expensive for large molecules.

           The TFD equivalence method uses the Torsion Fingerprint
           Difference as implemented in RDKit.

           The RMSD equivalence method uses the RDKit GetBestRMS
           implementation.

         * **Reorder** (*BoolType** | **BoolKey*) -- Reorder
           conformers based on energy, whenever a new conformer is
           added.

         * **Verbose** (*BoolType** | **BoolKey*) -- If set to True,
           print errors in adding conformer candidates to the logfile.

         * **AMS** (*Conformers._Equivalence._AMS*) -- Options for the
           AMS method of checking equivalence. This method uses the
           atomic distance matrices and the torsion angles between
           heavy atoms to determine if conformer candidates are
           duplicates.

         * **CREST** (*Conformers._Equivalence._CREST*) -- Options for
           the CREST method of checking equivalence. This method uses
           the rotational constants of conformer candidates to
           determine if they are duplicates.

         * **RMSD** (*Conformers._Equivalence._RMSD*) -- Options for
           the RMSD method of checking equivalence. This method uses
           the RDKit implementation of GetBestRMS, which enumerates
           over atomic permutations for pairs of geometries to detect
           duplicates based on the RMSD value.

         * **TFD** (*Conformers._Equivalence._TFD*) -- Options for the
           TFD method of checking equivalence. This method uses the
           Torsion Finger Print method to determine if two conformer
           candidates are duplicates.

      class _AMS

         Options for the AMS method of checking equivalence. This
         method uses the atomic distance matrices and the torsion
         angles between heavy atoms to determine if conformer
         candidates are duplicates.

         Variables:
            * **CompareAcrossMolecules** (*BoolType** | **BoolKey*) --
              If a system contains multiple molecules, equivalence
              testing by default takes into account conformational
              changes of the molecules relative to one another. This
              can be turned off with this keyword.

            * **DihedralThreshold** (*float** | **FloatKey*) --
              Maximum difference a dihedral can have for a conformer
              to be considered a duplicate.

            * **DistanceThreshold** (*float** | **FloatKey*) --
              Maximum difference a distance between two atoms can have
              for a conformer to be considered a duplicate.

            * **EnergyThreshold** (*float** | **FloatKey*) -- The
              energy difference beyond which two conformers are always
              considered distinct.

            * **IrrelevantAtoms** (*Iterable**[**int**] **|
              **IntListKey*) -- To detect equivalence, only a subset
              of atoms is used. The atoms that are excluded from
              equivalence comparison should be specified here. By
              default only non-hydrogen atoms will be used for the
              comparison. Numbering starts at 0.

            * **MaxDist** (*float** | **FloatKey*) -- In comparing the
              distance matrices of different entries, any distances
              larger than MaxDist will not contribute to the
              equivalence test. By default there is no distance
              cutoff.

            * **StoreRotamers** (*BoolType** | **BoolKey*) -- Whether
              or not rotamers (permutations of the conformers) should
              be stored in the conformers object. If set to yes,
              writing the rotamers to file still needs to be
              explicitly enabled. Storing the rotamers considerably
              slows down the conformer filtering process.

            * **UseTorsions** (*BoolType** | **BoolKey*) -- To detect
              equivalence, a two-step procedure is followed. First the
              permutation of atoms with the best match is determined,
              and then this permutation is used to see if distances
              and torsion angles are within the threshold values. For
              the first step by default both the distance matrices and
              the torsion angles aere used as well, but this is time
              consuming. By settings this key to False, only the
              distance matrix will be used for this first step. As a
              result it may happen that geometries that are actually
              equivalent will be accepted as unique conformers, but
              this will only happen for very symmetric molecules.

      class _CREST

         Options for the CREST method of checking equivalence. This
         method uses the rotational constants of conformer candidates
         to determine if they are duplicates.

         Variables:
            * **BconstScalingFactor** (*float** | **FloatKey*) -- This
              is the scaling factor of the rotational constant
              difference used only for cluster analysis. This is not
              used to determine conformer equivalence (see
              ScaledBconstSettings). However, if FollowPaper is set to
              True, then this value IS used to determine conformer
              equivalence.

            * **EnergyThreshold** (*float** | **FloatKey*) -- The
              energy difference beyond which two conformers are always
              considered distinct.

            * **FollowPaper** (*BoolType** | **BoolKey*) -- By default
              this code uses a procedure to determine equivalence that
              is as close as possible to the procedure followed by
              Grimmes crest code. However, when this flag is turned
              on, then the procedure as described by the CREST paper
              (DOI: 10.1039/c9cp06869d) is followed. If set to True,
              then the rotational constant difference threshold used
              to determine equivalence is BconstScalingFactor, and not
              BconstThreshold.

            * **RMSDThreshold** (*float** | **FloatKey*) -- Threshold
              for the RMSD between two conformers that determines if
              they are duplicates or rotamers (according to the CREST
              rotamer definition.)

            * **SizeThreshold** (*float** | **FloatKey*) -- An
              additional threshold based on the difference between
              distance matrices. This is used to determine if two
              geometries are duplicates or rotamers.

            * **StoreRotamers** (*BoolType** | **BoolKey*) -- Whether
              or not rotamers (permutations of the conformers) should
              be stored in the conformers object. If set to yes,
              writing the rotamers to file still needs to be
              explicitly enabled. Storing the rotamers considerably
              slows down the conformer filtering process.

            * **ScaledRotationalConstantSettings** (*Conformers._Equi
              valence._CREST._ScaledRotationalConstantSettings*) -- By
              default, the equivalence of two geometries is determined
              mainly by comparing the rotational constants, and
              weighing the difference based on the average anisotropy
              of the two systems. This procedure has several settings
              that can be user defined.

         class _ScaledRotationalConstantSettings

            By default, the equivalence of two geometries is
            determined mainly by comparing the rotational constants,
            and weighing the difference based on the average
            anisotropy of the two systems. This procedure has several
            settings that can be user defined.

            Variables:
               * **BthrMax** (*float** | **FloatKey*) -- Maximum
                 rotational constant threshold due to anisotropy.

               * **BthrShift** (*float** | **FloatKey*) -- Shift in
                 the error function used to compute modified
                 rotational constant threshold, based on anisotropy.

               * **RotationalConstantThreshold** (*float** |
                 **FloatKey*) -- Threshold for the difference in
                 rotational constants that determines if two
                 geometries are duplicates. The threshold is weighed
                 by the anisotropy of the systems. Note: in the grimme
                 code they use 0.01 as bconst_threshold, but this
                 leads to a lot of misclassifications (i.e. different
                 conformers are classified as equivalent rotamers)
                 So, here we use a smaller default value.

      class _RMSD

         Options for the RMSD method of checking equivalence. This
         method uses the RDKit implementation of GetBestRMS, which
         enumerates over atomic permutations for pairs of geometries
         to detect duplicates based on the RMSD value.

         Variables:
            * **EnergyThreshold** (*float** | **FloatKey*) -- The
              energy difference beyond which two conformers are always
              considered distinct.

            * **RMSDThreshold** (*float** | **FloatKey*) -- Threshold
              on the RMSD difference to determine if two geometries
              represent the same conformer. This value is in Angstrom.

      class _TFD

         Options for the TFD method of checking equivalence. This
         method uses the Torsion Finger Print method to determine if
         two conformer candidates are duplicates.

         Variables:
            * **EnergyThreshold** (*float** | **FloatKey*) -- The
              energy difference beyond which two conformers are always
              considered distinct.

            * **TFDThreshold** (*float** | **FloatKey*) -- Threshold
              on the torsion fingerprint difference to determine if
              two geometries represent the same conformer. This value
              is unit-less.

            * **UseEnergyThreshold** (*BoolType** | **BoolKey*) --
              Accept all conformers with an energy difference greater
              than the energy threshold as unique, without TFD
              testing.

            * **UseWeights** (*BoolType** | **BoolKey*) -- Use the
              weights of the torsion angles to compute the torsion
              fingerprint difference (all determined by RDKit).

   class _Expander

      Options for the conformer expander. The Expander expands an
      existing conformer set, by adding new conformers to it. The new
      conformers are generated from the original conformers in the
      set. Unlike the generators, the outcome of an expander is
      therefore very dependent on the input conformations.

      The GC generator uses a genetic algorithm to create a
      combinatorial expansion by combining local substructures. The MD
      expander start MD simulations from the conformers in the set,
      and extracts snapshots to create new conformers. Both these
      expanders are part of the CREST generator.

      Variables:
         * **AdjustInputBonds** (*BoolType** | **BoolKey*) -- If
           geometry optimization of the initial conformer results in
           bond changes, adjust the reference connectivity. If the
           changes are too severe, the calculation will stop.

         * **MaxEnergy** (*float** | **FloatKey*) -- Threshold for
           filtering out high-energy conformers. If the relative
           energy of a conformer with respect to the lowest conformer
           is larger than this value, the conformer will be discarded.

         * **Method** (*Literal**[**"MD"**, **"GC"**]*) -- Method used
           to generate the conformers.

         * **RNGSeed** (*int** | **IntKey*) -- Initial guesses for
           conformers can be randomly generated by RDKit, using the
           ETKDG algorithm. For reproducibility, a random number seed
           can be provided here.

         * **Verbose** (*BoolType** | **BoolKey*) -- If set to True,
           print additional info about conformer equivalence to
           standard output.

         * **GC** (*Conformers._Expander._GC*) -- Options for the
           genetic algorithm for combinatorial expansion of conformer
           geometries. This generator only  works if a non-zero set of
           conformers is already provided.

         * **MD** (*Conformers._Expander._MD*) -- Produces conformers
           by running a set of MD simulations at different elevated
           temperatures, extracting snapshots, and optimizing those.

         * **Preoptimization**
           (*Conformers._Expander._Preoptimization*) -- If this block
           is enabled geometries will be preoptimized. After
           preoptimization the high energy conformers will be
           discarded, and then from the remaining set the unoptimized
           geometries will be optimized at higher level. This is to
           prevent the preoptimizer from collapsing different
           conformers into a single false minimum. As a result,
           preoptimization is only useful if MaxEnergy is chosen low.

         * **RDKitETKDG** (*Conformers._Expander._RDKitETKDG*) --
           Settings for the call to RDKits ETKDG conformer generator
           tool.

      class _GC

         Options for the genetic algorithm for combinatorial expansion
         of conformer geometries. This generator only  works if a non-
         zero set of conformers is already provided.

         Variables:
            * **ClashThreshold** (*float** | **FloatKey*) -- Newly
              generated geometries are only accepted if the increase
              in coordination number per atom is below this
              threshold..

            * **CoordnumThreshold** (*float** | **FloatKey*) --
              Distance squared threshold, above which the coordination
              number can be neglected in Angstrom**2.

            * **GCNgeomsFactor** (*float** | **FloatKey*) -- Parameter
              used to determine the maximum number of geometries that
              this generator is allowed to produce.

            * **MaxGCenergy** (*float** | **FloatKey*) -- The maximum
              energy (relative to the lowest in the set) of the
              conformers we are going to use for expansion. The
              default is 6.0 kcal/mol, but if MaxEnergy was set, then
              that value is used.

            * **Parallel** (*BoolType** | **BoolKey*) -- Determines if
              the combinatorial expansion of conformers should be
              performed in parallel or not (default: True).

            * **RMSDThreshold** (*float** | **FloatKey*) -- Newly
              generated geometries are only considered unique if their
              RMSD from all other newly generated geometries is larger
              than this threshold.

      class _MD

         Produces conformers by running a set of MD simulations at
         different elevated temperatures, extracting snapshots, and
         optimizing those.

         Variables:
            * **Blocksize** (*int** | **IntKey*) -- The interval
              between the trajectory snapshots written to file that
              are extracted and optimized. By default all written
              snapshots are extracted.

            * **Multiples** (*int** | **IntKey*) -- The number of MD
              simulations per selected temperature and starting
              geometry. The default is 1.

            * **NMolDynStepsFactor** (*int** | **IntKey*) -- If the
              number of MD steps for the metadynamics and regular MD
              are not explicitly set in the respecive blocks, then the
              number of steps determined from the flexibility of the
              system will be multiplied by this value.

            * **Ngeoms** (*int** | **IntKey*) -- At each temperature,
              MD simulations are started from Ngeoms different
              starting geometries. The starting geometries are
              extracted from the provided conformer set. If the
              conformer set is empty, then no more than a single
              geometry per temperature can be provided, limiting the
              total number of MD simulations.

            * **Temperatures** (*Iterable**[**float**] **|
              **FloatListKey*) -- The list of different temperatures
              at which MD simulations are run.

            * **UseShake** (*BoolType** | **BoolKey*) -- Constrain all
              -H bonds with shake. If turned on, the MD timestep is
              automatically increased.

            * **UseXtb** (*BoolType** | **BoolKey*) -- Use Grimmes XTB
              code to perform the MD simulations instead of AMS

            * **MolecularDynamics**
              (*Conformers._Expander._MD._MolecularDynamics*) --
              Configures molecular dynamics (with the velocity-Verlet
              algorithm) with and without thermostats. This block
              allows to specify the details of the molecular dynamics
              calculation. Default values will be ignored.

         class _MolecularDynamics

            Configures molecular dynamics (with the velocity-Verlet
            algorithm) with and without thermostats. This block allows
            to specify the details of the molecular dynamics
            calculation. Default values will be ignored.

            Variables:
               * **NSteps** (*int** | **IntKey*) -- The number of
                 steps to be taken in the MD simulation.

               * **Restart** (*str** | **Path** | **StringKey*) -- The
                 path to the ams.rkf file from which to restart the
                 simulation.

               * **TimeStep** (*float** | **FloatKey*) -- The time
                 difference per step.

               * **Checkpoint** (*Conformers._Expander._MD._Molecular
                 Dynamics._Checkpoint*) -- Sets the frequency for
                 storing the entire MD state necessary for restarting
                 the calculation.

               * **InitialVelocities** (*Conformers._Expander._MD._Mo
                 lecularDynamics._InitialVelocities*) -- Sets the
                 frequency for printing to stdout and storing the
                 molecular configuration on the .rkf file.

               * **Preserve** (*Conformers._Expander._MD._MolecularDy
                 namics._Preserve*) -- Periodically remove numerical
                 drift accumulated during the simulation to preserve
                 different whole-system parameters.

               * **Print** (*Conformers._Expander._MD._MolecularDynam
                 ics._Print*) -- This block controls the printing of
                 additional information to stdout.

               * **Shake** (*Conformers._Expander._MD._MolecularDynam
                 ics._Shake*) -- Parameters of the Shake/Rattle
                 algorithm.

               * **Thermostat** (*Conformers._Expander._MD._Molecular
                 Dynamics._Thermostat*) -- This block allows to
                 specify the use of a thermostat during the
                 simulation. Depending on the selected thermostat
                 type, different additional options may be needed to
                 characterize the specific thermostat's behavior.

               * **Trajectory** (*Conformers._Expander._MD._Molecular
                 Dynamics._Trajectory*) -- Sets the frequency for
                 printing to stdout and storing the molecular
                 configuration on the .rkf file.

            class _Checkpoint

               Sets the frequency for storing the entire MD state
               necessary for restarting the calculation.

               Variables:
                  * **Frequency** (*int** | **IntKey*) --

                    Write the MD state to the Molecule and MDResults
                    sections on ams.rkf once every N steps. Setting
                    this to zero disables checkpointing during the
                    simulation, but one checkpoint at the very end of
                    the simulation will always be written.

                    NOTE: This no longer controls the frequency of
                    writing MDStep*.rkf files, set
                    Trajectory%EngineResultsFreq instead.

                  * **WriteProperties** (*BoolType** | **BoolKey*) --

                    Honor top-level Properties input block when
                    writing engine results files.

                    DEPRECATED: This input option will be removed in
                    AMS2026 and will be considered always enabled. If
                    you rely on it being disabled, please contact SCM
                    support.

            class _InitialVelocities

               Sets the frequency for printing to stdout and storing
               the molecular configuration on the .rkf file.

               Variables:
                  * **File** (*str** | **Path** | **StringKey*) -- AMS
                    RKF file containing the initial velocities.

                  * **RandomVelocitiesMethod**
                    (*Literal**[**"Exact"**, **"Boltzmann"**,
                    **"Gromacs"**]*) --

                    Specifies how are random velocities generated.
                    Three methods are available.

                    Exact: Velocities are scaled to exactly match set
                    random velocities temperature.

                    Boltzmann: Velocities are not scaled and sample
                    Maxwell-Boltzmann distribution. However, the
                    distribution is not corrected for constraints.

                    Gromacs: Velocities are scaled to match set random
                    velocities temperature, but removal of net
                    momentum is performed only after the scaling.
                    Resulting kinetic energy is lower based on how
                    much net momentum the system had.

                  * **Temperature** (*float** | **FloatKey*) --

                    Sets the temperature for the Maxwell-Boltzmann
                    distribution when the type of the initial
                    velocities is set to random, in which case
                    specifying this key is mandatory.

                    AMSinput will use the first temperature of the
                    first thermostat as default.

                  * **Type** (*Literal**[**"Zero"**, **"Random"**,
                    **"FromFile"**, **"Input"**]*) --

                    Specifies the initial velocities to assign to the
                    atoms. Three methods to assign velocities are
                    available.

                    Zero: All atom are at rest at the beginning of the
                    calculation.

                    Random: Initial atom velocities follow a Maxwell-
                    Boltzmann distribution for the temperature given
                    by the
                    [MolecularDynamics%InitialVelocities%Temperature]
                    keyword.

                    FromFile: Load the velocities from a previous ams
                    result file.

                    Input: Atom's velocities are set to the values
                    specified in the
                    [MolecularDynamics%InitialVelocities%Values]
                    block, which can be accessed via the Expert AMS
                    panel in AMSinput.

                  * **Values** (*str** | **Sequence**[**str**] **|
                    **FreeBlock*) -- This block specifies the velocity
                    of each atom, in Angstrom/fs, when
                    [MolecularDynamics%InitialVelocities%Type] is set
                    to Input. Each row must contain three floating
                    point values (corresponding to the x,y,z component
                    of the velocity vector) and a number of rows equal
                    to the number of atoms must be present, given in
                    the same order as the [System%Atoms] block.

               class _Values

                  This block specifies the velocity of each atom, in
                  Angstrom/fs, when
                  [MolecularDynamics%InitialVelocities%Type] is set to
                  Input. Each row must contain three floating point
                  values (corresponding to the x,y,z component of the
                  velocity vector) and a number of rows equal to the
                  number of atoms must be present, given in the same
                  order as the [System%Atoms] block.

            class _Preserve

               Periodically remove numerical drift accumulated during
               the simulation to preserve different whole-system
               parameters.

               Variables:
                  * **AngularMomentum** (*BoolType** | **BoolKey*) --
                    Remove overall angular momentum of the system.
                    This option is ignored for 2D and 3D-periodic
                    systems, and disabled by default for systems which
                    are not translationally invariant (for example
                    when frozen atoms are present).

                  * **CenterOfMass** (*BoolType** | **BoolKey*) --
                    Translate the system to keep its center of mass at
                    the coordinate origin. This option is not very
                    useful for 3D-periodic systems.

                  * **Momentum** (*BoolType** | **BoolKey*) -- Remove
                    overall (linear) momentum of the system. This is
                    disabled by default for systems which are not
                    translationally invariant (for example when frozen
                    atoms are present).

            class _Print

               This block controls the printing of additional
               information to stdout.

               Variables:
                  * **System** (*BoolType** | **BoolKey*) -- Print the
                    chemical system before and after the simulation.

                  * **Velocities** (*BoolType** | **BoolKey*) -- Print
                    the atomic velocities before and after the
                    simulation.

            class _Shake

               Parameters of the Shake/Rattle algorithm.

               Variables:
                  * **All** (*str** | **StringKey*) --

                    Constraint description in one the following
                    formats:  All [bondOrder] bonds at1 at2 [to
                    distance] All triangles at1 at2 at3

                    The first option constrains all bonds between
                    atoms at1 at2 to a certain length, while the
                    second - bonds at1-at2 and at2-at3 and the angle
                    between them.

                    The [bondOrder] can be a number or a string such
                    as single, double, triple or aromatic. If it's
                    omitted then all bonds between specified atoms
                    will be constrained. Atom names are case-sensitive
                    and they must be as they are in the Atoms block,
                    or an asterisk '*' denoting any atom. The
                    distance, if present, must be in Angstrom. If it
                    is omitted then the bond length from the initial
                    geometry is used.

                    Important: only the bonds present in the system at
                    certain points of the simulation (at the start or
                    right after adding/removing atoms) can be
                    constrained, which means that the bonds may need
                    to be specified in the System block.

                    Warning: the triangles constraint should be used
                    with care because each constrained bond or angle
                    means removing one degree of freedom from the
                    dynamics. When there are too many constraints (for
                    example, "All triangles H C H" in methane) some of
                    them may be linearly dependent, which will lead to
                    an error in the temperature computation.

                    Valid examples: All single bonds C C to 1.4 All
                    bonds O H to 0.98 All bonds O H All bonds H * All
                    triangles H * H

                  * **ConvergeR2** (*float** | **FloatKey*) --
                    Convergence criterion on the max squared
                    difference, in atomic units.

                  * **ConvergeRV** (*float** | **FloatKey*) --
                    Convergence criterion on the orthogonality of the
                    constraint and the relative atomic velocity, in
                    atomic units.

                  * **ExcludeRegion** (*str** | **StringKey*) --
                    Exclude all atoms covered by this region
                    expression from all constraints. If both atoms of
                    a bond belong to ExcludeRegion, the bond will be
                    kept unconstrained, regardless of Shake%All or
                    engine-specific constraints.

                  * **Iterations** (*int** | **IntKey*) -- Number of
                    iterations.

                  * **ShakeInitialCoordinates** (*BoolType** |
                    **BoolKey*) -- Apply constraints before computing
                    the first energy and gradients.

            class _Thermostat

               This block allows to specify the use of a thermostat
               during the simulation. Depending on the selected
               thermostat type, different additional options may be
               needed to characterize the specific thermostat's
               behavior.

               Variables:
                  * **BerendsenApply** (*Literal**[**"Local"**,
                    **"Global"**]*) --

                    Select how to apply the scaling correction for the
                    Berendsen thermostat:

                    * per-atom-velocity (Local)

                    * on the molecular system as a whole (Global).

                  * **ChainLength** (*int** | **IntKey*) -- Number of
                    individual thermostats forming the NHC thermostat

                  * **Duration** (*Iterable**[**int**] **|
                    **IntListKey*) -- Specifies how many steps should
                    a transition from a particular temperature to the
                    next one in sequence take.

                  * **ExcludedDirection** (*Literal**[**"None"**,
                    **"X"**, **"Y"**, **"Z"**]*) -- Exclude a
                    component of the velocities from rescaling by the
                    thermostat. For example in NEMD simulations, when
                    a shear force/velocity is applied in the x
                    direction, the x-direction is often excluded from
                    thermostatting. This currently only works for the
                    Nose-Hoover thermostat.

                  * **Friction** (*float** | **FloatKey*) -- Friction
                    coefficient used in langevin dynamics

                  * **Region** (*str** | **StringKey*) -- The
                    identifier of the region to thermostat. The
                    default *** applies the thermostat to the entire
                    system. The value can by a plain region name, or a
                    region expression, e.g. **-myregion* to thermostat
                    all atoms that are not in myregion, or
                    *regionA+regionB* to thermostat the union of the
                    'regionA' and 'regionB'. Note that if multiple
                    thermostats are used, their regions may not
                    overlap.

                  * **ScaleFrequency** (*int** | **IntKey*) --

                    Optional parameter used only by the Scale
                    thermostat.

                    If specified, the thermostat will be applied every
                    N steps, using that step's ensemble temperature
                    and the specified thermostat temperature to
                    compute the scaling factor.

                    If not specified, the thermostat will be applied
                    at every step, using the mean temperature of the
                    ensemble and the specified thermostat temperature
                    to compute the scaling factor.

                  * **Tau** (*float** | **FloatKey*) -- The time
                    constant of the thermostat.

                  * **Temperature** (*Iterable**[**float**] **|
                    **FloatListKey*) --

                    The target temperature of the thermostat.

                    You can specify multiple temperatures (separated
                    by spaces). In that case the Duration field
                    specifies how many steps to use for the transition
                    from one T to the next T (using a linear ramp).
                    For NHC thermostat, the temperature may not be
                    zero.

                  * **Type** (*Literal**[**"None"**, **"Scale"**,
                    **"Berendsen"**, **"NHC"**, **"Langevin"**]*) --
                    Selects the type of the thermostat.

            class _Trajectory

               Sets the frequency for printing to stdout and storing
               the molecular configuration on the .rkf file.

               Variables:
                  * **EngineResultsFreq** (*int** | **IntKey*) --
                    Write MDStep*.rkf files with engine-specific
                    results once every N steps. Setting this to zero
                    disables writing engine results files except for
                    one file at the end of the simulation. If this is
                    set to a negative value, the value of
                    Checkpoint%Frequency will be used instead.

                  * **ExitConditionFreq** (*int** | **IntKey*) --
                    Check the exit conditions every N steps. By
                    default this is done every SamplingFreq steps.

                  * **PrintFreq** (*int** | **IntKey*) -- Print
                    current thermodynamic properties to the output
                    every N steps. By default this is done every
                    SamplingFreq steps.

                  * **SamplingFreq** (*int** | **IntKey*) -- Write the
                    molecular geometry (and possibly other properties)
                    to the ams.rkf file once every N steps.

                  * **TProfileGridPoints** (*int** | **IntKey*) --
                    Number of points in the temperature profile. If
                    TProfileGridPoints > 0, a temperature profile
                    along each of the three lattice axes will be
                    written to the .rkf file. The temperature at a
                    given profile point is calculated as the total
                    temperature of all atoms inside the corresponding
                    slice of the simulation box, time-averaged over
                    all MD steps since the previous snapshot.​ By
                    default, no profile is generated.

                  * **WriteBonds** (*BoolType** | **BoolKey*) -- Write
                    detected bonds to the .rkf file.

                  * **WriteCharges** (*BoolType** | **BoolKey*) --
                    Write current atomic point charges (if available)
                    to the .rkf file. Disable this to reduce
                    trajectory size if you do not need to analyze
                    charges.

                  * **WriteCoordinates** (*BoolType** | **BoolKey*) --
                    Write atomic coordinates to the .rkf file.

                  * **WriteEngineGradients** (*BoolType** |
                    **BoolKey*) -- Write atomic gradients (negative of
                    the atomic forces, as calculated by the engine) to
                    the History section of ams.rkf.

                  * **WriteMolecules** (*BoolType** | **BoolKey*) --
                    Write the results of molecule analysis to the .rkf
                    file.

                  * **WriteVelocities** (*BoolType** | **BoolKey*) --
                    Write velocities to the .rkf file. Disable this to
                    reduce trajectory size if you do not need to
                    analyze the velocities.

      class _Preoptimization

         If this block is enabled geometries will be preoptimized.
         After preoptimization the high energy conformers will be
         discarded, and then from the remaining set the unoptimized
         geometries will be optimized at higher level. This is to
         prevent the preoptimizer from collapsing different conformers
         into a single false minimum. As a result, preoptimization is
         only useful if MaxEnergy is chosen low.

         Variables:
            * **Enable** (*BoolType** | **BoolKey*) -- Perform
              preoptimization at a low level of accuracy.

            * **PreoptFactor** (*int** | **IntKey*) -- This factor is
              multiplied with MaxEnergy, to determine which high
              energy conformers can be discarded after
              preoptimization.

            * **Engine** (*EngineBlock*) -- The engine specifics to be
              used for preoptimization.

         class _Engine

            The engine specifics to be used for preoptimization.

      class _RDKitETKDG

         Settings for the call to RDKits ETKDG conformer generator
         tool.

         Variables:
            * **BestRMSDThreshold** (*float** | **FloatKey*) -- After
              ETKDG conformer generation by RDKit, RDKit can be used
              to remove duplicates via the BestRMS algorithm. This
              filter does exactly the same as the RMSD equivalence
              detector in the Equivalence block.

            * **ConstrainedAtoms** (*Iterable**[**int**] **|
              **IntListKey*) -- The indices of the atoms to constrain
              during ETKDG conformer generation. The atom numbering
              starts at zero.

            * **Forcefield** (*Literal**[**"None"**, **"UFF"**,
              **"MMFF"**]*) -- The name of the RDKit forcefield to use
              for geometry optimization at the end of ETKDG conformer
              generation (by default no geometry optimization is
              performed). Using the RDKit internal optimization may
              make the subsequent geometry optimizations with AMS
              faster.

            * **Parallel** (*BoolType** | **BoolKey*) -- Experimental:
              Parallelize the RDKit generation step by calling the
              RDKit conformer generation method in parallel from
              multiple processes.

            * **RMSDThreshold** (*float** | **FloatKey*) -- Root Mean
              Square deviation threshold for removing
              similar/equivalent conformations during the RDKit ETKDG
              procedure. By default there is no pruning (value: -1).

            * **UseExpTorsionAnglePrefs** (*str** | **StringKey*) --
              Impose experimental torsion angle preferences in RDKit
              ETKDG conformer generation. By default the RDKit version
              determines whether or not to switch this on.

   class _Filter

      Options for the conformer filtering.

      Variables:
         * **MaxEnergy** (*float** | **FloatKey*) -- Threshold for
           filtering out high-energy conformers. If the relative
           energy of a conformer with respect to the lowest conformer
           is larger than this value, the conformer will be discarded.

         * **RemoveNonMinima** (*BoolType** | **BoolKey*) -- For the
           final set of conformers, explicitly check that the geometry
           corresponds to a local minimum, and remove it if it does
           not. Note: this will run a PES point characterization,
           which can be computationally expensive!

   class _Generator

      Options for the conformer generator.

      Variables:
         * **AdjustInputBonds** (*BoolType** | **BoolKey*) -- If
           geometry optimization of the initial conformer results in
           bond changes, adjust the reference connectivity. If the
           changes are too severe, the calculation will stop.

         * **MaxEnergy** (*float** | **FloatKey*) -- Threshold for
           filtering out high-energy conformers. If the relative
           energy of a conformer with respect to the lowest conformer
           is larger than this value, the conformer will be discarded.

         * **Method** (*Literal**[**"RDKit"**, **"CREST"**,
           **"METADYNAMICS"**, **"ANNEALING"**, **"TORSION"**]*) --

           Method used to generate the conformers.

           The RDKit generator is based on random distance matrix
           method. This is the recommended (and default) method.

           The CREST Generator uses a multi-step workflow with meta-
           dynamics simulations to explore the conformers space of a
           molecule. This can be a powerful conformer search method,
           but it is generally computationally expensive compared to
           the RDKit generator.

           The ANNEALING generator performs a simulated annealing
           simulation to explore conformer space.

         * **RNGSeed** (*int** | **IntKey*) -- Initial guesses for
           conformers can be randomly generated by RDKit, using the
           ETKDG algorithm. For reproducibility, a random number seed
           can be provided here.

         * **Verbose** (*BoolType** | **BoolKey*) -- If set to True,
           print additional info about conformer equivalence to
           standard output.

         * **ANNEALING** (*Conformers._Generator._ANNEALING*) --
           Options for the annealing generator. This generator creates
           conformers by performing a simulated annealing simulation.

         * **CREST** (*Conformers._Generator._CREST*) -- Options for
           the CREST generator. The CREST generator performs a set of
           metadynamics simulations (using the METADYNAMICS
           generator), then a set of MD simulations (using the MD
           expander), and finally it does a combinatorial expansion of
           the generated conformers using the GC expander. This
           sequence is repeated in an iterative fashion until the
           lowest energy conformer no longer changes.

         * **METADYNAMICS** (*Conformers._Generator._METADYNAMICS*) --
           Produces conformers by running a set of CREST-RMSD
           metadynamics simulations with different biases, extracting
           snapshots, and optimizing those.

         * **Preoptimization**
           (*Conformers._Generator._Preoptimization*) -- If this block
           is enabled geometries will be preoptimized. After
           preoptimization the high energy conformers will be
           discarded, and then from the remaining set the unoptimized
           geometries will be optimized at higher level. This is to
           prevent the preoptimizer from collapsing different
           conformers into a single false minimum. As a result,
           preoptimization is only useful if MaxEnergy is chosen low.

         * **RDKit** (*Conformers._Generator._RDKit*) -- Options for
           the RDKit generator. This generator produces initial
           guesses for conformers using the RDKit ETKDG method,
           followed by AMS geometry optimizations.

         * **RDKitETKDG** (*Conformers._Generator._RDKitETKDG*) --
           Settings for the call to RDKits ETKDG conformer generator
           tool.

         * **TORSION** (*Conformers._Generator._TORSION*) -- Options
           for the TorsionGenerator, which generates geometries by
           enumerative rotation around rotatable bonds. This is the
           slowest of all generator, and quickly becomes infeasible
           for large systems. Currently does not work for systems with
           interconnected rings.

      class _ANNEALING

         Options for the annealing generator. This generator creates
         conformers by performing a simulated annealing simulation.

         Variables:
            * **Blocksize** (*int** | **IntKey*) -- The spacing
              between the number of frames stored on the MD trajectory
              file, that will be used to generate conformers.

            * **NMolDynStepsFactor** (*int** | **IntKey*) -- If the
              number of MD steps for the metadynamics and regular MD
              are not explicitly set in the respecive blocks, then the
              number of steps determined from the flexibility of the
              system will be multiplied by this value.

            * **Temperatures** (*Iterable**[**float**] **|
              **FloatListKey*) -- The minimum and maximum temperature
              of the annealing simulation. The simulation will start
              at the highest temperature, and cool down to the lowest.

            * **UseShake** (*BoolType** | **BoolKey*) -- Constrain all
              -H bonds with shake. If turned on, the MD timestep is
              automatically increased.

            * **MolecularDynamics**
              (*Conformers._Generator._ANNEALING._MolecularDynamics*)
              -- Configures molecular dynamics (with the velocity-
              Verlet algorithm) with and without thermostats. This
              block allows to specify the details of the molecular
              dynamics calculation. Default values will be ignored.

         class _MolecularDynamics

            Configures molecular dynamics (with the velocity-Verlet
            algorithm) with and without thermostats. This block allows
            to specify the details of the molecular dynamics
            calculation. Default values will be ignored.

            Variables:
               * **NSteps** (*int** | **IntKey*) -- The number of
                 steps to be taken in the MD simulation.

               * **Restart** (*str** | **Path** | **StringKey*) -- The
                 path to the ams.rkf file from which to restart the
                 simulation.

               * **TimeStep** (*float** | **FloatKey*) -- The time
                 difference per step.

               * **Checkpoint** (*Conformers._Generator._ANNEALING._M
                 olecularDynamics._Checkpoint*) -- Sets the frequency
                 for storing the entire MD state necessary for
                 restarting the calculation.

               * **InitialVelocities** (*Conformers._Generator._ANNEA
                 LING._MolecularDynamics._InitialVelocities*) -- Sets
                 the frequency for printing to stdout and storing the
                 molecular configuration on the .rkf file.

               * **Preserve** (*Conformers._Generator._ANNEALING._Mol
                 ecularDynamics._Preserve*) -- Periodically remove
                 numerical drift accumulated during the simulation to
                 preserve different whole-system parameters.

               * **Print** (*Conformers._Generator._ANNEALING._Molecu
                 larDynamics._Print*) -- This block controls the
                 printing of additional information to stdout.

               * **Shake** (*Conformers._Generator._ANNEALING._Molecu
                 larDynamics._Shake*) -- Parameters of the
                 Shake/Rattle algorithm.

               * **Thermostat** (*Conformers._Generator._ANNEALING._M
                 olecularDynamics._Thermostat*) -- This block allows
                 to specify the use of a thermostat during the
                 simulation. Depending on the selected thermostat
                 type, different additional options may be needed to
                 characterize the specific thermostat's behavior.

               * **Trajectory** (*Conformers._Generator._ANNEALING._M
                 olecularDynamics._Trajectory*) -- Sets the frequency
                 for printing to stdout and storing the molecular
                 configuration on the .rkf file.

            class _Checkpoint

               Sets the frequency for storing the entire MD state
               necessary for restarting the calculation.

               Variables:
                  * **Frequency** (*int** | **IntKey*) --

                    Write the MD state to the Molecule and MDResults
                    sections on ams.rkf once every N steps. Setting
                    this to zero disables checkpointing during the
                    simulation, but one checkpoint at the very end of
                    the simulation will always be written.

                    NOTE: This no longer controls the frequency of
                    writing MDStep*.rkf files, set
                    Trajectory%EngineResultsFreq instead.

                  * **WriteProperties** (*BoolType** | **BoolKey*) --

                    Honor top-level Properties input block when
                    writing engine results files.

                    DEPRECATED: This input option will be removed in
                    AMS2026 and will be considered always enabled. If
                    you rely on it being disabled, please contact SCM
                    support.

            class _InitialVelocities

               Sets the frequency for printing to stdout and storing
               the molecular configuration on the .rkf file.

               Variables:
                  * **File** (*str** | **Path** | **StringKey*) -- AMS
                    RKF file containing the initial velocities.

                  * **RandomVelocitiesMethod**
                    (*Literal**[**"Exact"**, **"Boltzmann"**,
                    **"Gromacs"**]*) --

                    Specifies how are random velocities generated.
                    Three methods are available.

                    Exact: Velocities are scaled to exactly match set
                    random velocities temperature.

                    Boltzmann: Velocities are not scaled and sample
                    Maxwell-Boltzmann distribution. However, the
                    distribution is not corrected for constraints.

                    Gromacs: Velocities are scaled to match set random
                    velocities temperature, but removal of net
                    momentum is performed only after the scaling.
                    Resulting kinetic energy is lower based on how
                    much net momentum the system had.

                  * **Temperature** (*float** | **FloatKey*) --

                    Sets the temperature for the Maxwell-Boltzmann
                    distribution when the type of the initial
                    velocities is set to random, in which case
                    specifying this key is mandatory.

                    AMSinput will use the first temperature of the
                    first thermostat as default.

                  * **Type** (*Literal**[**"Zero"**, **"Random"**,
                    **"FromFile"**, **"Input"**]*) --

                    Specifies the initial velocities to assign to the
                    atoms. Three methods to assign velocities are
                    available.

                    Zero: All atom are at rest at the beginning of the
                    calculation.

                    Random: Initial atom velocities follow a Maxwell-
                    Boltzmann distribution for the temperature given
                    by the
                    [MolecularDynamics%InitialVelocities%Temperature]
                    keyword.

                    FromFile: Load the velocities from a previous ams
                    result file.

                    Input: Atom's velocities are set to the values
                    specified in the
                    [MolecularDynamics%InitialVelocities%Values]
                    block, which can be accessed via the Expert AMS
                    panel in AMSinput.

                  * **Values** (*str** | **Sequence**[**str**] **|
                    **FreeBlock*) -- This block specifies the velocity
                    of each atom, in Angstrom/fs, when
                    [MolecularDynamics%InitialVelocities%Type] is set
                    to Input. Each row must contain three floating
                    point values (corresponding to the x,y,z component
                    of the velocity vector) and a number of rows equal
                    to the number of atoms must be present, given in
                    the same order as the [System%Atoms] block.

               class _Values

                  This block specifies the velocity of each atom, in
                  Angstrom/fs, when
                  [MolecularDynamics%InitialVelocities%Type] is set to
                  Input. Each row must contain three floating point
                  values (corresponding to the x,y,z component of the
                  velocity vector) and a number of rows equal to the
                  number of atoms must be present, given in the same
                  order as the [System%Atoms] block.

            class _Preserve

               Periodically remove numerical drift accumulated during
               the simulation to preserve different whole-system
               parameters.

               Variables:
                  * **AngularMomentum** (*BoolType** | **BoolKey*) --
                    Remove overall angular momentum of the system.
                    This option is ignored for 2D and 3D-periodic
                    systems, and disabled by default for systems which
                    are not translationally invariant (for example
                    when frozen atoms are present).

                  * **CenterOfMass** (*BoolType** | **BoolKey*) --
                    Translate the system to keep its center of mass at
                    the coordinate origin. This option is not very
                    useful for 3D-periodic systems.

                  * **Momentum** (*BoolType** | **BoolKey*) -- Remove
                    overall (linear) momentum of the system. This is
                    disabled by default for systems which are not
                    translationally invariant (for example when frozen
                    atoms are present).

            class _Print

               This block controls the printing of additional
               information to stdout.

               Variables:
                  * **System** (*BoolType** | **BoolKey*) -- Print the
                    chemical system before and after the simulation.

                  * **Velocities** (*BoolType** | **BoolKey*) -- Print
                    the atomic velocities before and after the
                    simulation.

            class _Shake

               Parameters of the Shake/Rattle algorithm.

               Variables:
                  * **All** (*str** | **StringKey*) --

                    Constraint description in one the following
                    formats:  All [bondOrder] bonds at1 at2 [to
                    distance] All triangles at1 at2 at3

                    The first option constrains all bonds between
                    atoms at1 at2 to a certain length, while the
                    second - bonds at1-at2 and at2-at3 and the angle
                    between them.

                    The [bondOrder] can be a number or a string such
                    as single, double, triple or aromatic. If it's
                    omitted then all bonds between specified atoms
                    will be constrained. Atom names are case-sensitive
                    and they must be as they are in the Atoms block,
                    or an asterisk '*' denoting any atom. The
                    distance, if present, must be in Angstrom. If it
                    is omitted then the bond length from the initial
                    geometry is used.

                    Important: only the bonds present in the system at
                    certain points of the simulation (at the start or
                    right after adding/removing atoms) can be
                    constrained, which means that the bonds may need
                    to be specified in the System block.

                    Warning: the triangles constraint should be used
                    with care because each constrained bond or angle
                    means removing one degree of freedom from the
                    dynamics. When there are too many constraints (for
                    example, "All triangles H C H" in methane) some of
                    them may be linearly dependent, which will lead to
                    an error in the temperature computation.

                    Valid examples: All single bonds C C to 1.4 All
                    bonds O H to 0.98 All bonds O H All bonds H * All
                    triangles H * H

                  * **ConvergeR2** (*float** | **FloatKey*) --
                    Convergence criterion on the max squared
                    difference, in atomic units.

                  * **ConvergeRV** (*float** | **FloatKey*) --
                    Convergence criterion on the orthogonality of the
                    constraint and the relative atomic velocity, in
                    atomic units.

                  * **ExcludeRegion** (*str** | **StringKey*) --
                    Exclude all atoms covered by this region
                    expression from all constraints. If both atoms of
                    a bond belong to ExcludeRegion, the bond will be
                    kept unconstrained, regardless of Shake%All or
                    engine-specific constraints.

                  * **Iterations** (*int** | **IntKey*) -- Number of
                    iterations.

                  * **ShakeInitialCoordinates** (*BoolType** |
                    **BoolKey*) -- Apply constraints before computing
                    the first energy and gradients.

            class _Thermostat

               This block allows to specify the use of a thermostat
               during the simulation. Depending on the selected
               thermostat type, different additional options may be
               needed to characterize the specific thermostat's
               behavior.

               Variables:
                  * **BerendsenApply** (*Literal**[**"Local"**,
                    **"Global"**]*) --

                    Select how to apply the scaling correction for the
                    Berendsen thermostat:

                    * per-atom-velocity (Local)

                    * on the molecular system as a whole (Global).

                  * **ChainLength** (*int** | **IntKey*) -- Number of
                    individual thermostats forming the NHC thermostat

                  * **Duration** (*Iterable**[**int**] **|
                    **IntListKey*) -- Specifies how many steps should
                    a transition from a particular temperature to the
                    next one in sequence take.

                  * **ExcludedDirection** (*Literal**[**"None"**,
                    **"X"**, **"Y"**, **"Z"**]*) -- Exclude a
                    component of the velocities from rescaling by the
                    thermostat. For example in NEMD simulations, when
                    a shear force/velocity is applied in the x
                    direction, the x-direction is often excluded from
                    thermostatting. This currently only works for the
                    Nose-Hoover thermostat.

                  * **Friction** (*float** | **FloatKey*) -- Friction
                    coefficient used in langevin dynamics

                  * **Region** (*str** | **StringKey*) -- The
                    identifier of the region to thermostat. The
                    default *** applies the thermostat to the entire
                    system. The value can by a plain region name, or a
                    region expression, e.g. **-myregion* to thermostat
                    all atoms that are not in myregion, or
                    *regionA+regionB* to thermostat the union of the
                    'regionA' and 'regionB'. Note that if multiple
                    thermostats are used, their regions may not
                    overlap.

                  * **ScaleFrequency** (*int** | **IntKey*) --

                    Optional parameter used only by the Scale
                    thermostat.

                    If specified, the thermostat will be applied every
                    N steps, using that step's ensemble temperature
                    and the specified thermostat temperature to
                    compute the scaling factor.

                    If not specified, the thermostat will be applied
                    at every step, using the mean temperature of the
                    ensemble and the specified thermostat temperature
                    to compute the scaling factor.

                  * **Tau** (*float** | **FloatKey*) -- The time
                    constant of the thermostat.

                  * **Temperature** (*Iterable**[**float**] **|
                    **FloatListKey*) --

                    The target temperature of the thermostat.

                    You can specify multiple temperatures (separated
                    by spaces). In that case the Duration field
                    specifies how many steps to use for the transition
                    from one T to the next T (using a linear ramp).
                    For NHC thermostat, the temperature may not be
                    zero.

                  * **Type** (*Literal**[**"None"**, **"Scale"**,
                    **"Berendsen"**, **"NHC"**, **"Langevin"**]*) --
                    Selects the type of the thermostat.

            class _Trajectory

               Sets the frequency for printing to stdout and storing
               the molecular configuration on the .rkf file.

               Variables:
                  * **EngineResultsFreq** (*int** | **IntKey*) --
                    Write MDStep*.rkf files with engine-specific
                    results once every N steps. Setting this to zero
                    disables writing engine results files except for
                    one file at the end of the simulation. If this is
                    set to a negative value, the value of
                    Checkpoint%Frequency will be used instead.

                  * **ExitConditionFreq** (*int** | **IntKey*) --
                    Check the exit conditions every N steps. By
                    default this is done every SamplingFreq steps.

                  * **PrintFreq** (*int** | **IntKey*) -- Print
                    current thermodynamic properties to the output
                    every N steps. By default this is done every
                    SamplingFreq steps.

                  * **SamplingFreq** (*int** | **IntKey*) -- Write the
                    molecular geometry (and possibly other properties)
                    to the ams.rkf file once every N steps.

                  * **TProfileGridPoints** (*int** | **IntKey*) --
                    Number of points in the temperature profile. If
                    TProfileGridPoints > 0, a temperature profile
                    along each of the three lattice axes will be
                    written to the .rkf file. The temperature at a
                    given profile point is calculated as the total
                    temperature of all atoms inside the corresponding
                    slice of the simulation box, time-averaged over
                    all MD steps since the previous snapshot.​ By
                    default, no profile is generated.

                  * **WriteBonds** (*BoolType** | **BoolKey*) -- Write
                    detected bonds to the .rkf file.

                  * **WriteCharges** (*BoolType** | **BoolKey*) --
                    Write current atomic point charges (if available)
                    to the .rkf file. Disable this to reduce
                    trajectory size if you do not need to analyze
                    charges.

                  * **WriteCoordinates** (*BoolType** | **BoolKey*) --
                    Write atomic coordinates to the .rkf file.

                  * **WriteEngineGradients** (*BoolType** |
                    **BoolKey*) -- Write atomic gradients (negative of
                    the atomic forces, as calculated by the engine) to
                    the History section of ams.rkf.

                  * **WriteMolecules** (*BoolType** | **BoolKey*) --
                    Write the results of molecule analysis to the .rkf
                    file.

                  * **WriteVelocities** (*BoolType** | **BoolKey*) --
                    Write velocities to the .rkf file. Disable this to
                    reduce trajectory size if you do not need to
                    analyze the velocities.

      class _CREST

         Options for the CREST generator. The CREST generator performs
         a set of metadynamics simulations (using the METADYNAMICS
         generator), then a set of MD simulations (using the MD
         expander), and finally it does a combinatorial expansion of
         the generated conformers using the GC expander. This sequence
         is repeated in an iterative fashion until the lowest energy
         conformer no longer changes.

         Variables:
            * **ConvergenceQualityCrude** (*Literal**[**"Normal"**,
              **"Good"**, **"VeryGood"**, **"Excellent"**,
              **"None"**]*) -- The tightness of the convergence of the
              crude geometry pre-optimizations. If set to none it will
              be selected two levels below ConvergenceQuality.

            * **ConvergenceQualityTight** (*Literal**[**"Normal"**,
              **"Good"**, **"VeryGood"**, **"Excellent"**,
              **"None"**]*) -- The tightness of the convergence of the
              final geometry optimizations. If set to none it will be
              selected the same as ConvergenceQuality.

            * **GCStep** (*BoolType** | **BoolKey*) -- Wether or not
              to include the combinatorial expansion of the conformers
              using the GC Generator. For big systems this step can be
              very time consuming. By default it is set to True.

            * **NCycles** (*int** | **IntKey*) -- The maximum number
              of CREST cycles (by default the number is 10). If the
              lowest conformer energy converges before then, Crest
              exits.

            * **NMolDynStepsFactor** (*int** | **IntKey*) -- If the
              number of MD steps for the metadynamics and regular MD
              are not explicitly set in the respecive blocks, then the
              number of steps determined from the flexibility of the
              system will be multiplied by this value.

            * **UseShake** (*BoolType** | **BoolKey*) -- Wether or not
              SHAKE should be turned on in the MD and Metadynamics
              simulations. If this is turned on, the MD timestep is
              automatically increased (from 2 to 5 fs).

      class _METADYNAMICS

         Produces conformers by running a set of CREST-RMSD
         metadynamics simulations with different biases, extracting
         snapshots, and optimizing those.

         Variables:
            * **Blocksize** (*int** | **IntKey*) -- The interval
              between the trajectory snapshots written to file that
              are extracted and optimized. By default all written
              snapshots are extracted.

            * **ConvergenceQualityCrude** (*Literal**[**"normal"**,
              **"good"**, **"verygood"**, **"excellent"**,
              **"none"**]*) -- The tightness of the convergence of the
              crude geometry pre-optimizations. If set to none it will
              be selected two levels below ConvergenceQuality.

            * **MaxHeight** (*float** | **FloatKey*) -- The maximum
              Gaussian height used in a metadynamics simulation.

            * **MaxWidth** (*float** | **FloatKey*) -- The maximum
              Gaussian width used in a metadynamics simulation.

            * **MinHeight** (*float** | **FloatKey*) -- The minimum
              Gaussian height used in a metadynamics simulation.

            * **NCycles** (*int** | **IntKey*) -- The maximum number
              of cycles of metadynamics simulations. The generator
              stops when either this number is reached, or the
              conformer set is stable.

            * **NMolDynStepsFactor** (*int** | **IntKey*) -- If the
              number of MD steps for the metadynamics and regular MD
              are not explicitly set in the respecive blocks, then the
              number of steps determined from the flexibility of the
              system will be multiplied by this value.

            * **NWidthsHeights** (*Iterable**[**int**] **|
              **IntListKey*) -- The number of different Gaussian
              widths and heights respectively used in the metadynamics
              simulations. By default 4 different widths are used and
              3 different heights, resulting in 12 different
              metadynamics simulations.

            * **Restartdir** (*str** | **StringKey*) -- A PLAMS folder
              containing the results from a previous conformers
              generation using the METADYNAMICS generator.

            * **SimulationSuccessFraction** (*float** | **FloatKey*)
              -- The fraction of planned metadynamics steps that has
              to have succeeded in order for the metadynamics
              iteration to be considered a success.

            * **UseShake** (*BoolType** | **BoolKey*) -- Constrain all
              -H bonds with shake. If turned on, the MD timestep is
              automatically increased.

            * **UseXtb** (*BoolType** | **BoolKey*) -- Use Grimmes xTB
              code to perform the MD simulations instead of AMS

            * **WidthIncrement** (*float** | **FloatKey*) -- The
              increment between Gaussian widths used in subsequent
              metadynamics simulations.

            * **AdditionalGaussians** (*Conformers._Generator._METADY
              NAMICS._AdditionalGaussians*) -- An additional set of
              Gaussian widths and heights, each representing the
              Gaussians of a single additional metadynamics
              simulation. By default, if nothing is provided, then two
              Gaussians are used: ([(width:0.1 Angstrom, height:0.001
              Hartree), (width:0.8 Angstrom, height:0.005 Hartree)])

            * **MolecularDynamics** (*Conformers._Generator._METADYNA
              MICS._MolecularDynamics*) -- Configures molecular
              dynamics (with the velocity-Verlet algorithm) with and
              without thermostats. This block allows to specify the
              details of the molecular dynamics calculation. Default
              values will be ignored.

         class _AdditionalGaussians

            An additional set of Gaussian widths and heights, each
            representing the Gaussians of a single additional
            metadynamics simulation. By default, if nothing is
            provided, then two Gaussians are used: ([(width:0.1
            Angstrom, height:0.001 Hartree), (width:0.8 Angstrom,
            height:0.005 Hartree)])

            Variables:
               * **Height** (*float** | **FloatKey*) -- The height of
                 the Gaussians in an additional metadynamics
                 simulation, in Hartree.

               * **Width** (*float** | **FloatKey*) -- The width of
                 the Gaussians in an additional metadynanics
                 simulation, in Angstrom.

         class _MolecularDynamics

            Configures molecular dynamics (with the velocity-Verlet
            algorithm) with and without thermostats. This block allows
            to specify the details of the molecular dynamics
            calculation. Default values will be ignored.

            Variables:
               * **NSteps** (*int** | **IntKey*) -- The number of
                 steps to be taken in the MD simulation.

               * **Restart** (*str** | **Path** | **StringKey*) -- The
                 path to the ams.rkf file from which to restart the
                 simulation.

               * **TimeStep** (*float** | **FloatKey*) -- The time
                 difference per step.

               * **Checkpoint** (*Conformers._Generator._METADYNAMICS
                 ._MolecularDynamics._Checkpoint*) -- Sets the
                 frequency for storing the entire MD state necessary
                 for restarting the calculation.

               * **InitialVelocities** (*Conformers._Generator._METAD
                 YNAMICS._MolecularDynamics._InitialVelocities*) --
                 Sets the frequency for printing to stdout and storing
                 the molecular configuration on the .rkf file.

               * **Preserve** (*Conformers._Generator._METADYNAMICS._
                 MolecularDynamics._Preserve*) -- Periodically remove
                 numerical drift accumulated during the simulation to
                 preserve different whole-system parameters.

               * **Print** (*Conformers._Generator._METADYNAMICS._Mol
                 ecularDynamics._Print*) -- This block controls the
                 printing of additional information to stdout.

               * **Shake** (*Conformers._Generator._METADYNAMICS._Mol
                 ecularDynamics._Shake*) -- Parameters of the
                 Shake/Rattle algorithm.

               * **Thermostat** (*Conformers._Generator._METADYNAMICS
                 ._MolecularDynamics._Thermostat*) -- This block
                 allows to specify the use of a thermostat during the
                 simulation. Depending on the selected thermostat
                 type, different additional options may be needed to
                 characterize the specific thermostat's behavior.

               * **Trajectory** (*Conformers._Generator._METADYNAMICS
                 ._MolecularDynamics._Trajectory*) -- Sets the
                 frequency for printing to stdout and storing the
                 molecular configuration on the .rkf file.

            class _Checkpoint

               Sets the frequency for storing the entire MD state
               necessary for restarting the calculation.

               Variables:
                  * **Frequency** (*int** | **IntKey*) --

                    Write the MD state to the Molecule and MDResults
                    sections on ams.rkf once every N steps. Setting
                    this to zero disables checkpointing during the
                    simulation, but one checkpoint at the very end of
                    the simulation will always be written.

                    NOTE: This no longer controls the frequency of
                    writing MDStep*.rkf files, set
                    Trajectory%EngineResultsFreq instead.

                  * **WriteProperties** (*BoolType** | **BoolKey*) --

                    Honor top-level Properties input block when
                    writing engine results files.

                    DEPRECATED: This input option will be removed in
                    AMS2026 and will be considered always enabled. If
                    you rely on it being disabled, please contact SCM
                    support.

            class _InitialVelocities

               Sets the frequency for printing to stdout and storing
               the molecular configuration on the .rkf file.

               Variables:
                  * **File** (*str** | **Path** | **StringKey*) -- AMS
                    RKF file containing the initial velocities.

                  * **RandomVelocitiesMethod**
                    (*Literal**[**"Exact"**, **"Boltzmann"**,
                    **"Gromacs"**]*) --

                    Specifies how are random velocities generated.
                    Three methods are available.

                    Exact: Velocities are scaled to exactly match set
                    random velocities temperature.

                    Boltzmann: Velocities are not scaled and sample
                    Maxwell-Boltzmann distribution. However, the
                    distribution is not corrected for constraints.

                    Gromacs: Velocities are scaled to match set random
                    velocities temperature, but removal of net
                    momentum is performed only after the scaling.
                    Resulting kinetic energy is lower based on how
                    much net momentum the system had.

                  * **Temperature** (*float** | **FloatKey*) --

                    Sets the temperature for the Maxwell-Boltzmann
                    distribution when the type of the initial
                    velocities is set to random, in which case
                    specifying this key is mandatory.

                    AMSinput will use the first temperature of the
                    first thermostat as default.

                  * **Type** (*Literal**[**"Zero"**, **"Random"**,
                    **"FromFile"**, **"Input"**]*) --

                    Specifies the initial velocities to assign to the
                    atoms. Three methods to assign velocities are
                    available.

                    Zero: All atom are at rest at the beginning of the
                    calculation.

                    Random: Initial atom velocities follow a Maxwell-
                    Boltzmann distribution for the temperature given
                    by the
                    [MolecularDynamics%InitialVelocities%Temperature]
                    keyword.

                    FromFile: Load the velocities from a previous ams
                    result file.

                    Input: Atom's velocities are set to the values
                    specified in the
                    [MolecularDynamics%InitialVelocities%Values]
                    block, which can be accessed via the Expert AMS
                    panel in AMSinput.

                  * **Values** (*str** | **Sequence**[**str**] **|
                    **FreeBlock*) -- This block specifies the velocity
                    of each atom, in Angstrom/fs, when
                    [MolecularDynamics%InitialVelocities%Type] is set
                    to Input. Each row must contain three floating
                    point values (corresponding to the x,y,z component
                    of the velocity vector) and a number of rows equal
                    to the number of atoms must be present, given in
                    the same order as the [System%Atoms] block.

               class _Values

                  This block specifies the velocity of each atom, in
                  Angstrom/fs, when
                  [MolecularDynamics%InitialVelocities%Type] is set to
                  Input. Each row must contain three floating point
                  values (corresponding to the x,y,z component of the
                  velocity vector) and a number of rows equal to the
                  number of atoms must be present, given in the same
                  order as the [System%Atoms] block.

            class _Preserve

               Periodically remove numerical drift accumulated during
               the simulation to preserve different whole-system
               parameters.

               Variables:
                  * **AngularMomentum** (*BoolType** | **BoolKey*) --
                    Remove overall angular momentum of the system.
                    This option is ignored for 2D and 3D-periodic
                    systems, and disabled by default for systems which
                    are not translationally invariant (for example
                    when frozen atoms are present).

                  * **CenterOfMass** (*BoolType** | **BoolKey*) --
                    Translate the system to keep its center of mass at
                    the coordinate origin. This option is not very
                    useful for 3D-periodic systems.

                  * **Momentum** (*BoolType** | **BoolKey*) -- Remove
                    overall (linear) momentum of the system. This is
                    disabled by default for systems which are not
                    translationally invariant (for example when frozen
                    atoms are present).

            class _Print

               This block controls the printing of additional
               information to stdout.

               Variables:
                  * **System** (*BoolType** | **BoolKey*) -- Print the
                    chemical system before and after the simulation.

                  * **Velocities** (*BoolType** | **BoolKey*) -- Print
                    the atomic velocities before and after the
                    simulation.

            class _Shake

               Parameters of the Shake/Rattle algorithm.

               Variables:
                  * **All** (*str** | **StringKey*) --

                    Constraint description in one the following
                    formats:  All [bondOrder] bonds at1 at2 [to
                    distance] All triangles at1 at2 at3

                    The first option constrains all bonds between
                    atoms at1 at2 to a certain length, while the
                    second - bonds at1-at2 and at2-at3 and the angle
                    between them.

                    The [bondOrder] can be a number or a string such
                    as single, double, triple or aromatic. If it's
                    omitted then all bonds between specified atoms
                    will be constrained. Atom names are case-sensitive
                    and they must be as they are in the Atoms block,
                    or an asterisk '*' denoting any atom. The
                    distance, if present, must be in Angstrom. If it
                    is omitted then the bond length from the initial
                    geometry is used.

                    Important: only the bonds present in the system at
                    certain points of the simulation (at the start or
                    right after adding/removing atoms) can be
                    constrained, which means that the bonds may need
                    to be specified in the System block.

                    Warning: the triangles constraint should be used
                    with care because each constrained bond or angle
                    means removing one degree of freedom from the
                    dynamics. When there are too many constraints (for
                    example, "All triangles H C H" in methane) some of
                    them may be linearly dependent, which will lead to
                    an error in the temperature computation.

                    Valid examples: All single bonds C C to 1.4 All
                    bonds O H to 0.98 All bonds O H All bonds H * All
                    triangles H * H

                  * **ConvergeR2** (*float** | **FloatKey*) --
                    Convergence criterion on the max squared
                    difference, in atomic units.

                  * **ConvergeRV** (*float** | **FloatKey*) --
                    Convergence criterion on the orthogonality of the
                    constraint and the relative atomic velocity, in
                    atomic units.

                  * **ExcludeRegion** (*str** | **StringKey*) --
                    Exclude all atoms covered by this region
                    expression from all constraints. If both atoms of
                    a bond belong to ExcludeRegion, the bond will be
                    kept unconstrained, regardless of Shake%All or
                    engine-specific constraints.

                  * **Iterations** (*int** | **IntKey*) -- Number of
                    iterations.

                  * **ShakeInitialCoordinates** (*BoolType** |
                    **BoolKey*) -- Apply constraints before computing
                    the first energy and gradients.

            class _Thermostat

               This block allows to specify the use of a thermostat
               during the simulation. Depending on the selected
               thermostat type, different additional options may be
               needed to characterize the specific thermostat's
               behavior.

               Variables:
                  * **BerendsenApply** (*Literal**[**"Local"**,
                    **"Global"**]*) --

                    Select how to apply the scaling correction for the
                    Berendsen thermostat:

                    * per-atom-velocity (Local)

                    * on the molecular system as a whole (Global).

                  * **ChainLength** (*int** | **IntKey*) -- Number of
                    individual thermostats forming the NHC thermostat

                  * **Duration** (*Iterable**[**int**] **|
                    **IntListKey*) -- Specifies how many steps should
                    a transition from a particular temperature to the
                    next one in sequence take.

                  * **ExcludedDirection** (*Literal**[**"None"**,
                    **"X"**, **"Y"**, **"Z"**]*) -- Exclude a
                    component of the velocities from rescaling by the
                    thermostat. For example in NEMD simulations, when
                    a shear force/velocity is applied in the x
                    direction, the x-direction is often excluded from
                    thermostatting. This currently only works for the
                    Nose-Hoover thermostat.

                  * **Friction** (*float** | **FloatKey*) -- Friction
                    coefficient used in langevin dynamics

                  * **Region** (*str** | **StringKey*) -- The
                    identifier of the region to thermostat. The
                    default *** applies the thermostat to the entire
                    system. The value can by a plain region name, or a
                    region expression, e.g. **-myregion* to thermostat
                    all atoms that are not in myregion, or
                    *regionA+regionB* to thermostat the union of the
                    'regionA' and 'regionB'. Note that if multiple
                    thermostats are used, their regions may not
                    overlap.

                  * **ScaleFrequency** (*int** | **IntKey*) --

                    Optional parameter used only by the Scale
                    thermostat.

                    If specified, the thermostat will be applied every
                    N steps, using that step's ensemble temperature
                    and the specified thermostat temperature to
                    compute the scaling factor.

                    If not specified, the thermostat will be applied
                    at every step, using the mean temperature of the
                    ensemble and the specified thermostat temperature
                    to compute the scaling factor.

                  * **Tau** (*float** | **FloatKey*) -- The time
                    constant of the thermostat.

                  * **Temperature** (*Iterable**[**float**] **|
                    **FloatListKey*) --

                    The target temperature of the thermostat.

                    You can specify multiple temperatures (separated
                    by spaces). In that case the Duration field
                    specifies how many steps to use for the transition
                    from one T to the next T (using a linear ramp).
                    For NHC thermostat, the temperature may not be
                    zero.

                  * **Type** (*Literal**[**"None"**, **"Scale"**,
                    **"Berendsen"**, **"NHC"**, **"Langevin"**]*) --
                    Selects the type of the thermostat.

            class _Trajectory

               Sets the frequency for printing to stdout and storing
               the molecular configuration on the .rkf file.

               Variables:
                  * **EngineResultsFreq** (*int** | **IntKey*) --
                    Write MDStep*.rkf files with engine-specific
                    results once every N steps. Setting this to zero
                    disables writing engine results files except for
                    one file at the end of the simulation. If this is
                    set to a negative value, the value of
                    Checkpoint%Frequency will be used instead.

                  * **ExitConditionFreq** (*int** | **IntKey*) --
                    Check the exit conditions every N steps. By
                    default this is done every SamplingFreq steps.

                  * **PrintFreq** (*int** | **IntKey*) -- Print
                    current thermodynamic properties to the output
                    every N steps. By default this is done every
                    SamplingFreq steps.

                  * **SamplingFreq** (*int** | **IntKey*) -- Write the
                    molecular geometry (and possibly other properties)
                    to the ams.rkf file once every N steps.

                  * **TProfileGridPoints** (*int** | **IntKey*) --
                    Number of points in the temperature profile. If
                    TProfileGridPoints > 0, a temperature profile
                    along each of the three lattice axes will be
                    written to the .rkf file. The temperature at a
                    given profile point is calculated as the total
                    temperature of all atoms inside the corresponding
                    slice of the simulation box, time-averaged over
                    all MD steps since the previous snapshot.​ By
                    default, no profile is generated.

                  * **WriteBonds** (*BoolType** | **BoolKey*) -- Write
                    detected bonds to the .rkf file.

                  * **WriteCharges** (*BoolType** | **BoolKey*) --
                    Write current atomic point charges (if available)
                    to the .rkf file. Disable this to reduce
                    trajectory size if you do not need to analyze
                    charges.

                  * **WriteCoordinates** (*BoolType** | **BoolKey*) --
                    Write atomic coordinates to the .rkf file.

                  * **WriteEngineGradients** (*BoolType** |
                    **BoolKey*) -- Write atomic gradients (negative of
                    the atomic forces, as calculated by the engine) to
                    the History section of ams.rkf.

                  * **WriteMolecules** (*BoolType** | **BoolKey*) --
                    Write the results of molecule analysis to the .rkf
                    file.

                  * **WriteVelocities** (*BoolType** | **BoolKey*) --
                    Write velocities to the .rkf file. Disable this to
                    reduce trajectory size if you do not need to
                    analyze the velocities.

      class _Preoptimization

         If this block is enabled geometries will be preoptimized.
         After preoptimization the high energy conformers will be
         discarded, and then from the remaining set the unoptimized
         geometries will be optimized at higher level. This is to
         prevent the preoptimizer from collapsing different conformers
         into a single false minimum. As a result, preoptimization is
         only useful if MaxEnergy is chosen low.

         Variables:
            * **Enable** (*BoolType** | **BoolKey*) -- Perform
              preoptimization at a low level of accuracy.

            * **PreoptFactor** (*int** | **IntKey*) -- This factor is
              multiplied with MaxEnergy, to determine which high
              energy conformers can be discarded after
              preoptimization.

            * **Engine** (*EngineBlock*) -- The engine specifics to be
              used for preoptimization.

         class _Engine

            The engine specifics to be used for preoptimization.

      class _RDKit

         Options for the RDKit generator. This generator produces
         initial guesses for conformers using the RDKit ETKDG method,
         followed by AMS geometry optimizations.

         Variables:
            * **InitialNConformers** (*int** | **IntKey*) -- Number of
              geometries initially created by RDKit, before AMS
              geometry optimization and filtering. If not set, the
              number will be automatically set, based on the number of
              rotational bonds.

            * **MaxConfs** (*int** | **IntKey*) -- If
              InitialNConformers is not set, then the number of
              conformers will be automatically set, with a maximum of
              MaxConfs.

            * **MinConfs** (*int** | **IntKey*) -- If
              InitialNConformers is not set, then the number of
              conformers will be automatically set, with a minimum of
              MinConfs.

            * **NconfsEstimationFactor** (*int** | **IntKey*) -- If
              InitialNConformers is not set, then the number of
              conformers will be automatically set based on the number
              of rotational bonds. The resulting number is then
              multiplied by this factor (default: 100), to ensure that
              enough conformers will be created.

            * **Restartdir** (*str** | **StringKey*) -- A PLAMS folder
              containing the results from a previous conformers
              generation using this same generator. Currently only
              used to reread the initial conformers created by RDKit.

            * **Restartfilename** (*str** | **StringKey*) -- The name
              of the file containing geometries generated by RDKits
              ETKDG algorithm, in the Restartdir folder.

      class _RDKitETKDG

         Settings for the call to RDKits ETKDG conformer generator
         tool.

         Variables:
            * **BestRMSDThreshold** (*float** | **FloatKey*) -- After
              ETKDG conformer generation by RDKit, RDKit can be used
              to remove duplicates via the BestRMS algorithm. This
              filter does exactly the same as the RMSD equivalence
              detector in the Equivalence block.

            * **ConstrainedAtoms** (*Iterable**[**int**] **|
              **IntListKey*) -- The indices of the atoms to constrain
              during ETKDG conformer generation.

            * **Forcefield** (*Literal**[**"None"**, **"UFF"**,
              **"MMFF"**]*) -- The name of the RDKit forcefield to use
              for geometry optimization at the end of ETKDG conformer
              generation (by default no geometry optimization is
              performed). Using the RDKit internal optimization may
              make the subsequent geometry optimizations with AMS
              faster.

            * **Parallel** (*BoolType** | **BoolKey*) -- Experimental:
              Parallelize the RDKit generation step by calling the
              RDKit conformer generation method in parallel from
              multiple processes.

            * **RMSDThreshold** (*float** | **FloatKey*) -- Root Mean
              Square deviation threshold for removing
              similar/equivalent conformations during the RDKit ETKDG
              procedure. By default there is no pruning (value: -1).

            * **UseExpTorsionAnglePrefs** (*str** | **StringKey*) --
              Impose experimental torsion angle preferences in RDKit
              ETKDG conformer generation. By default the RDKit version
              determines whether or not to switch this on.

      class _TORSION

         Options for the TorsionGenerator, which generates geometries
         by enumerative rotation around rotatable bonds. This is the
         slowest of all generator, and quickly becomes infeasible for
         large systems. Currently does not work for systems with
         interconnected rings.

         Variables:
            * **BondDistortionThreshold** (*float** | **FloatKey*) --
              A factor multiplied by the original bondlength, used to
              check if a geometry is not too distorted. A new geometry
              is discarded if any of the bonds have become longer than
              this value times the original bond length.

            * **Dtheta** (*float** | **FloatKey*) -- The angle over
              which the bonds are rotated, in order to create a new
              conformer.

            * **TruncateRingtorsions** (*BoolType** | **BoolKey*) --
              In producing conformers for rings, one can rotate over
              all the bonds in the ring, or one can save time by
              excluding the last three bonds in the ring, which share
              atoms with the first bonds in the ring. This should
              yield identical results, and by default this is done.

   class _GeometryOptimization

      Some options / details regarding the optimization procedure.

      Variables:
         * **ConvergenceQuality** (*Literal**[**"Normal"**,
           **"Good"**, **"VeryGood"**, **"Excellent"**]*) -- The
           tightness of the convergence of the geometry optimizations.
           Lower quality levels may lead to badly converged geometries
           being classified as distinct conformers.

         * **IgnoreAllConstraints** (*BoolType** | **BoolKey*) -- In
           the geometry optimizations, ignore all constraints,
           restraints and walls (relevant blocks: Constraints,
           Restraints, EngineAddons)

         * **Keep** (*Literal**[**"None"**, **"all"**]*) -- Keep all
           the output files of the geometry optimizations. If set to
           'all', must be used in combination with Output%KeepWorkDir.
           This will automatically set UseAMSWorker to False.

         * **KeepAMSWorkerFolder** (*BoolType** | **BoolKey*) -- If
           UseAMSWorker is set, then keep the temporary folders
           containing the output of the workders. If you want to use
           this, do not set the Keep keyword to True.

         * **MaxConvergenceTime** (*Literal**[**"Default"**,
           **"High"**]*) -- The number of iterations for the geometry
           optimization, based on the number of atoms in the system.
           The default value is the general AMS value for geometry
           optimization. Often, for conformer generation, it needs to
           be set higher.

         * **MaxOptimizations** (*int** | **IntKey*) -- Set a maximum
           to the number of geometries accepted for optimization at
           once, per AMSWorker (so should be multiplied by the number
           of cores used). If not set, the disc size requirements can
           become too large.

         * **OptimizationMethod** (*Literal**[**"Auto"**, **"Quasi-
           Newton"**, **"FIRE"**, **"L-BFGS"**,
           **"ConjugateGradients"**, **"Dimer"**]*) --

           Select the optimization algorithm employed for the geometry
           relaxation. Currently supported are:

           the Hessian-based Quasi-Newton-type BFGS algorithm,

           the fast inertial relaxation method (FIRE),

           the limited-memory BFGS method,

           and the conjugate gradients method. The default is Quasi-
           Newton, which gives the most reliable results for
           conformers. The Auto method leaves it to the AMS
           GeometryOptimization task to select a method.

         * **UseAMSWorker** (*BoolType** | **BoolKey*) -- Whether the
           set of optimizations should be run via the AMSWorkerPool or
           via regular AMSJobs.

         * **GeometryOptimization**
           (*Conformers._GeometryOptimization._GeometryOptimization*)
           -- Configures details of the geometry optimization and
           transition state searches.

         * **WriteGeometries**
           (*Conformers._GeometryOptimization._WriteGeometries*) --
           Determines if and where optimized geometries will be
           written to file during optimization. When the AMSWorker is
           used, then the write interval depends on MaxOptimizations.
           If enabled, must be used in combination with
           Output%KeepWorkDir.

      class _GeometryOptimization

         Configures details of the geometry optimization and
         transition state searches.

         Variables:
            * **CalcPropertiesOnlyIfConverged** (*BoolType** |
              **BoolKey*) -- Compute the properties requested in the
              'Properties' block, e.g. Frequencies or Phonons, only if
              the optimization (or transition state search) converged.
              If False, the properties will be computed even if the
              optimization did not converge.

            * **CoordinateType** (*Literal**[**"Auto"**,
              **"Delocalized"**, **"Cartesian"**]*) --

              Select the type of coordinates in which to perform the
              optimization. 'Auto' automatically selects the most
              appropriate CoordinateType for a given Method.

              If 'Auto' is selected, Delocalized coordinates will be
              used for the Quasi-Newton method, while Cartesian
              coordinates will be used for all other methods.

            * **KeepIntermediateResults** (*BoolType** | **BoolKey*)
              -- Whether the full engine result files of all
              intermediate steps are stored on disk. By default only
              the last step is kept, and only if the geometry
              optimization converged. This can easily lead to huge
              amounts of data being stored on disk, but it can
              sometimes be convenient to closely monitor a tricky
              optimization, e.g. excited state optimizations going
              through conical intersections, etc. ...

            * **MaxIterations** (*int** | **IntKey*) -- The maximum
              number of geometry iterations allowed to converge to the
              desired structure.

            * **MaxRestarts** (*int** | **IntKey*) -- If a geometry
              optimization of a system with no symmetry operators (or
              with explicitly disabled symmetry: "UseSymmetry False")
              and enabled PES point characterization converges to a
              transition state (or higher order saddle point), it can
              be restarted automatically after a small displacement
              along the imaginary vibrational mode. In case the
              restarted optimization again does not find a minimum,
              this can happen multiple times in succession. This
              keyword sets the maximum number of restarts. The default
              value is 0, so the automatic restarting is disabled by
              default.

            * **Method** (*Literal**[**"Auto"**, **"Quasi-Newton"**,
              **"FIRE"**, **"L-BFGS"**, **"ConjugateGradients"**,
              **"Dimer"**]*) --

              Select the optimization algorithm employed for the
              geometry relaxation. Currently supported are:

              the Hessian-based Quasi-Newton-type BFGS algorithm,

              the fast inertial relaxation method (FIRE),

              the limited-memory BFGS method,

              and the conjugate gradients method. The default is to
              choose an appropriate method automatically based on the
              engine's speed, the system size and the supported
              optimization options.

            * **OptimizeLattice** (*BoolType** | **BoolKey*) --
              Whether to also optimize the lattice for periodic
              structures. This is currently supported with the Quasi-
              Newton, FIRE, and L-BFGS optimizers.

            * **PretendConverged** (*BoolType** | **BoolKey*) --
              Normally a non-converged geometry optimization is
              considered an error. If this keyword is set to True, the
              optimizer will only produce a warning and still claim
              that the optimization is converged. (This is mostly
              useful for scripting applications, where one might want
              to consider non-converged optimizations still successful
              jobs.)

            * **RestartDisplacement** (*float** | **FloatKey*) -- If a
              geometry optimization of a system with no symmetry
              operators (or with explicitly disabled symmetry:
              "UseSymmetry False") and enabled PES point
              characterization converges to a transition state (or
              higher order saddle point), it can be restarted
              automatically after a small displacement along the
              imaginary vibrational mode. This keywords sets the size
              of the displacement for the furthest moving atom.

            * **Convergence** (*Conformers._GeometryOptimization._Geo
              metryOptimization._Convergence*) -- Convergence is
              monitored for up to 4 quantities: the energy change, the
              Cartesian gradients, the Cartesian step size, and for
              lattice optimizations the stress energy per atom.
              Convergence criteria can be specified separately for
              each of these items.

            * **Dimer** (*Conformers._GeometryOptimization._GeometryO
              ptimization._Dimer*) -- Options for the Dimer method for
              transition state search.

            * **EngineAutomations** (*Conformers._GeometryOptimizatio
              n._GeometryOptimization._EngineAutomations*) -- The
              optimizer can change some settings of the engine, based
              for instance on the error. The idea is to allow the
              engine to be a bit quicker at the start, and more
              accurate towards the end. Automations are always engine
              specific.

            * **FIRE** (*Conformers._GeometryOptimization._GeometryOp
              timization._FIRE*) -- This block configures the details
              of the FIRE optimizer. The keywords name correspond the
              the symbols used in the article describing the method,
              see PRL 97, 170201 (2006).

            * **HessianFree** (*Conformers._GeometryOptimization._Geo
              metryOptimization._HessianFree*) -- Configures details
              of the Hessian-free (conjugate gradients or L-BFGS)
              geometry optimizer.

            * **InitialHessian** (*Conformers._GeometryOptimization._
              GeometryOptimization._InitialHessian*) -- Options for
              initial model Hessian when optimizing systems with the
              Quasi-Newton method.

            * **Quasi-Newton**
              (*Conformers._GeometryOptimization._GeometryOptimization
              ._Quasi-Newton*) -- Configures details of the Quasi-
              Newton geometry optimizer.

         class _Convergence

            Convergence is monitored for up to 4 quantities: the
            energy change, the Cartesian gradients, the Cartesian step
            size, and for lattice optimizations the stress energy per
            atom. Convergence criteria can be specified separately for
            each of these items.

            Variables:
               * **Energy** (*float** | **FloatKey*) -- The criterion
                 for changes in the energy. The energy is considered
                 converged when the change in energy is smaller than
                 this threshold times the number of atoms.

               * **Gradients** (*float** | **FloatKey*) -- Threshold
                 for nuclear gradients.

               * **Quality** (*Literal**[**"VeryBasic"**, **"Basic"**,
                 **"Normal"**, **"Good"**, **"VeryGood"**,
                 **"Excellent"**, **"Custom"**]*) -- A quick way to
                 change convergence thresholds: 'Good' will reduce all
                 thresholds by an order of magnitude from their
                 default value. 'VeryGood' will tighten them by two
                 orders of magnitude. 'Basic' and 'VeryBasic' will
                 increase the thresholds by one or two orders of
                 magnitude respectively.

               * **Step** (*float** | **FloatKey*) -- The maximum
                 Cartesian step allowed for a converged geometry.

               * **StressEnergyPerAtom** (*float** | **FloatKey*) --
                 Threshold used when optimizing the lattice vectors.
                 The stress is considered 'converged' when the maximum
                 value of stress_tensor * cell_volume /
                 number_of_atoms is smaller than this threshold (for
                 2D and 1D systems, the cell_volume is replaced by the
                 cell_area and cell_length respectively).

         class _Dimer

            Options for the Dimer method for transition state search.

            Variables:
               * **AngleThreshold** (*float** | **FloatKey*) -- The
                 rotation is considered converged when the the
                 rotation angle falls below the specified threshold.

               * **DimerDelta** (*float** | **FloatKey*) -- Euclidian
                 distance between the midpoint and the endpoint.

               * **ExtrapolateForces** (*BoolType** | **BoolKey*) --
                 Set to false to call engine to calculate forces at
                 the extrapolated rotation angle instead of
                 extrapolating them.

               * **LBFGSMaxVectors** (*int** | **IntKey*) -- Max
                 number of vectors for the L-BFGS algorithm to save.

               * **MaxRotationIterations** (*int** | **IntKey*) --
                 Maximum number of rotation iterations for a single
                 translation step.

               * **Region** (*str** | **StringKey*) -- Include only
                 atoms of the specified region(s) in the rotations,
                 which allows searching for a transition state
                 involving selected atoms only.

               * **RotationTrustRadius** (*float** | **FloatKey*) --
                 L-BFGS trust radius during rotation iterations.

               * **TranslationTrustRadius** (*float** | **FloatKey*)
                 -- L-BFGS trust radius during translation iterations.

         class _EngineAutomations

            The optimizer can change some settings of the engine,
            based for instance on the error. The idea is to allow the
            engine to be a bit quicker at the start, and more accurate
            towards the end. Automations are always engine specific.

            Variables:
               * **Enabled** (*BoolType** | **BoolKey*) -- Whether or
                 not automations are enabled at all.

               * **Gradient** (*Conformers._GeometryOptimization._Geo
                 metryOptimization._EngineAutomations._Gradient*) -- A
                 gradient-based automation.

               * **Iteration** (*Conformers._GeometryOptimization._Ge
                 ometryOptimization._EngineAutomations._Iteration*) --
                 Geometry step based automation.

            class _Gradient

               A gradient-based automation.

               Variables:
                  * **FinalValue** (*float** | **FloatKey*) -- This
                    value will be used whenever the gradient is less
                    than GradientLow

                  * **HighGradient** (*float** | **FloatKey*) --
                    Defines a large gradient. When the actual gradient
                    is between GradientHigh and GradientLow a linear
                    interpolation scheme is used for kT (on a log
                    scale).

                  * **InitialValue** (*float** | **FloatKey*) -- This
                    value will be used at the first geometry, and
                    whenever the gradient is higher than GradientHigh

                  * **LowGradient** (*float** | **FloatKey*) --
                    Defines a small gradient, see GradientHigh

                  * **UseLogInterpolation** (*BoolType** | **BoolKey*)
                    -- Whether to use interpolation on a log (y) scale
                    or not

                  * **Variable** (*str** | **StringKey*) -- variable
                    to be tweaked for the engine.

            class _Iteration

               Geometry step based automation.

               Variables:
                  * **FinalValue** (*float** | **FloatKey*) --

                  * **FirstIteration** (*int** | **IntKey*) -- When
                    the actual gradient is between the first and last
                    iteration, a linear interpolation is used.

                  * **InitialValue** (*float** | **FloatKey*) -- This
                    value will be used when the iteration number is
                    smaller or equal to FirstIteration

                  * **LastIteration** (*int** | **IntKey*) -- Where
                    the automation should reach the FinalValue

                  * **UseLogInterpolation** (*BoolType** | **BoolKey*)
                    -- Whether to use interpolation on a log (y) scale
                    or not

                  * **Variable** (*str** | **StringKey*) -- variable
                    to be tweaked for the engine.

         class _FIRE

            This block configures the details of the FIRE optimizer.
            The keywords name correspond the the symbols used in the
            article describing the method, see PRL 97, 170201 (2006).

            Variables:
               * **AllowOverallRotation** (*BoolType** | **BoolKey*)
                 -- Whether or not the system is allowed to freely
                 rotate during the optimization. This is relevant when
                 optimizing structures in the presence of external
                 fields.

               * **AllowOverallTranslation** (*BoolType** |
                 **BoolKey*) -- Whether or not the system is allowed
                 to translate during the optimization. This is
                 relevant when optimizing structures in the presence
                 of external fields.

               * **MapAtomsToUnitCell** (*BoolType** | **BoolKey*) --
                 Map the atoms to the central cell at each geometry
                 step.

               * **NMin** (*int** | **IntKey*) -- Number of steps
                 after stopping before increasing the time step again.

               * **alphaStart** (*float** | **FloatKey*) -- Steering
                 coefficient.

               * **atomMass** (*float** | **FloatKey*) -- Fictitious
                 atomic mass used for all atoms. There is no reason to
                 change this, as it just corresponds to using a
                 different integration timestep.

               * **dtMax** (*float** | **FloatKey*) -- Maximum time
                 step used for the integration. For ReaxFF and
                 APPLE&P, this value is reduced by 50%.

               * **dtStart** (*float** | **FloatKey*) -- Initial time
                 step for the integration.

               * **fAlpha** (*float** | **FloatKey*) -- Reduction
                 factor for the steering coefficient.

               * **fDec** (*float** | **FloatKey*) -- Reduction factor
                 for reducing the time step in case of uphill
                 movement.

               * **fInc** (*float** | **FloatKey*) -- Growth factor
                 for the integration time step.

               * **strainMass** (*float** | **FloatKey*) -- Fictitious
                 relative mass of the lattice degrees of freedom. This
                 controls the stiffness of the lattice degrees of
                 freedom relative to the atomic degrees of freedom,
                 with smaller values resulting in a more aggressive
                 optimization of the lattice.

         class _HessianFree

            Configures details of the Hessian-free (conjugate
            gradients or L-BFGS) geometry optimizer.

            Variables:
               **Step** (*Conformers._GeometryOptimization._GeometryO
               ptimization._HessianFree._Step*) --

            class _Step

               Variables:
                  * **MaxCartesianStep** (*float** | **FloatKey*) --
                    Limit on a single Cartesian component of the step.

                  * **MinRadius** (*float** | **FloatKey*) -- Minimum
                    value for the trust radius.

                  * **TrialStep** (*float** | **FloatKey*) -- Length
                    of the finite-difference step when determining
                    curvature. Should be smaller than the step
                    convergence criterion.

                  * **TrustRadius** (*float** | **FloatKey*) --
                    Initial value of the trust radius.

         class _InitialHessian

            Options for initial model Hessian when optimizing systems
            with the Quasi-Newton method.

            Variables:
               * **File** (*str** | **Path** | **StringKey*) -- KF
                 file containing the initial Hessian (or the results
                 dir. containing it). This can be used to load a
                 Hessian calculated in a previously with the
                 [Properties%Hessian] keyword.

               * **Type** (*Literal**[**"Auto"**, **"UnitMatrix"**,
                 **"Swart"**, **"FromFile"**, **"Calculate"**,
                 **"CalculateWithFastEngine"**]*) -- Select the type
                 of initial Hessian. Auto: let the program pick an
                 initial model Hessian. UnitMatrix: simplest initial
                 model Hessian, just a unit matrix in the optimization
                 coordinates. Swart: model Hessian from M. Swart.
                 FromFile: load the Hessian from the results of a
                 previous calculation (see InitialHessian%File).
                 Calculate: compute the initial Hessian (this may be
                 computationally expensive and it is mostly
                 recommended for TransitionStateSearch calculations).
                 CalculateWithFastEngine: compute the initial Hessian
                 with a faster engine.

         class _Quasi_Newton

            Configures details of the Quasi-Newton geometry optimizer.

            Variables:
               * **EnforceConstraints** (*BoolType** | **BoolKey*) --
                 Whether to enforce constraints at each steps exactly
                 or add them to the optimization space as Lagrange
                 multipliers.

               * **MaxGDIISVectors** (*int** | **IntKey*) -- Sets the
                 maximum number of GDIIS vectors. Setting this to a
                 number >0 enables the GDIIS method.

               * **UpdateTSVectorEveryStep** (*BoolType** |
                 **BoolKey*) -- Whether to update the TS reaction
                 coordinate at each step with the current eigenvector.

               * **Step** (*Conformers._GeometryOptimization._Geometr
                 yOptimization._Quasi-Newton._Step*) --

            class _Step

               Variables:
                  * **TrustRadius** (*float** | **FloatKey*) --
                    Initial value of the trust radius.

                  * **VaryTrustRadius** (*BoolType** | **BoolKey*) --
                    Whether to allow the trust radius to change during
                    optimization. By default True during energy
                    minimization and False during transition state
                    search.

      class _WriteGeometries

         Determines if and where optimized geometries will be written
         to file during optimization. When the AMSWorker is used, then
         the write interval depends on MaxOptimizations. If enabled,
         must be used in combination with Output%KeepWorkDir.

         Variables:
            * **Dirname** (*str** | **StringKey*) -- The name of the
              folder that should contain the optimized geometries.

            * **Enabled** (*BoolType** | **BoolKey*) -- Enables or
              disables the periodic writing of optimized geometries to
              file

   class _LoadSystem

      Block that controls reading the chemical system from a KF file
      instead of the [System] block.

      Variables:
         * **File** (*str** | **Path** | **StringKey*) -- The path of
           the KF file from which to load the system. It may also be
           the results directory containing it.

         * **Section** (*str** | **StringKey*) -- The section on the
           KF file from which to load the system.

   class _Output

      Options regarding the output and result files.

      Variables:
         * **KeepWorkDir** (*BoolType** | **BoolKey*) -- Do not remove
           the working directories after the conformer generation is
           finished.

         * **rkf** (*BoolType** | **BoolKey*) -- Save the final
           conformers in .rkf format. The file 'conformers.rkf' will
           be located in the results directory. You can visualize this
           file using the AMSMovie GUI module.

         * **sdf** (*BoolType** | **BoolKey*) -- Save the final
           conformers in .sdf format. The file 'conformers.sdf' will
           be located in the results directory.

         * **xyz** (*BoolType** | **BoolKey*) -- Save the final
           conformers in .xyz format. The file 'conformers.xyz' will
           be located in the results directory.

   class _Restraints

      The Restraints block allows to add soft constraints to the
      system. A restraint is a potential energy function (a spring)
      attached to a certain coordinate, for example, an interatomic
      distance, with its minimum at the specified optimal value. A
      restraint is defined using one or two parameters: the
      ForceConstant and, for some types, the F(Inf) value. The
      ForceConstant parameter corresponds to second derivative of the
      restraint potential energy d2V(x)/dx^2 for any x (harmonic
      restraints) or only at at x=0 (other restraints). Here, x is a
      deviation from the restraint's optimal value.

      Variables:
         * **Angle** (*str** | **StringKey*) -- Specify three atom
           indices i j k followed by an angle in degrees and,
           optionally, by the ForceConstant (default is 0.3 in a.u.),
           profile type and F(Inf) (in a.u.). This restraint will try
           to keep the i-j-k angle at the given value. For periodic
           systems this restraint follows the minimum image
           convention.

         * **DifDist** (*str** | **StringKey*) -- Specify four atom
           indices i j k l followed by the distance in Angstrom and,
           optionally, by the ForceConstant (default is 1.0 in a.u.),
           profile type and F(Inf) (in a.u.). This restraint will try
           to keep the difference R(ij)-R(kl) at the given value. For
           periodic systems this restraint follows the minimum image
           convention.

         * **Dihedral** (*str** | **StringKey*) -- Specify four atom
           indices i j k l followed by an angle in degrees and,
           optionally, by the ForceConstant (default is 0.1 in a.u.),
           profile type and F(Inf) (in a.u.). This restraint will try
           to keep the i-j-k-l dihedral angle at the given value. For
           periodic systems this restraint follows the minimum image
           convention.

         * **Distance** (*str** | **StringKey*) -- Specify two atom
           indices followed by the distance in Angstrom and,
           optionally, by the ForceConstant (default is 1.0 in a.u.),
           profile type and F(Inf) (in a.u.). This restraint will try
           to keep the distance between the two specified atoms at the
           given value. For periodic systems this restraint follows
           the minimum image convention.

         * **FInfinity** (*float** | **FloatKey*) --

           Specify the default asymptotic value for the restraint
           force for the Hyperbolic and Erf profiles, in Hartree/Bohr
           or Hartree/radian.

           A per-restraint value can be specified after the profile
           type on the corresponding restraint line.

         * **Profile** (*Literal**[**"Harmonic"**, **"Hyperbolic"**,
           **"Erf"**, **"GaussianWell"**]*) --

           Select the default type of restraint profile.

           The harmonic profile is most suitable for geometry
           optimizations but may result is very large forces that can
           be problematic in molecular dynamic.

           For MD simulations the Hyperbolic or Erf may be more
           suitable because the restraint force is bounded by a user-
           defined value.

           A per-restraint profile type can be specified after the
           ForceConstant value on the corresponding restraint line.

         * **SumDist** (*str** | **StringKey*) -- Specify four atom
           indices i j k l followed by the distance in Angstrom and,
           optionally, by the ForceConstant (default is 1.0 in a.u.),
           profile type and F(Inf) (in a.u.). This restraint will try
           to keep the sum R(ij)+R(kl) at the given value. For
           periodic systems this restraint follows the minimum image
           convention.

         * **Units** (*Literal**[**"Default"**, **"MD"**]*) -- Change
           units for energy, force and force constant values from the
           default (atomic units) to those often used in the MD
           community (based on kcal/mol and Angstrom). Units for the
           optimal distances are not affected and are always Angstrom.

   class _Rotamers

      Options for the treatment of Grimme-rotamers.

      Variables:
         * **Read** (*BoolType** | **BoolKey*) -- Whether to read all
           associated rotamers from disk when loading a set of
           conformers with the "InputConformersSet" keyword.

         * **Write** (*BoolType** | **BoolKey*) -- Whether to write
           the geometries of all found conformers to the output files.

   class _System

      Specification of the chemical system. For some applications more
      than one system may be present in the input. In this case, all
      systems except one must have a non-empty string ID specified
      after the System keyword. The system without an ID is considered
      the main one.

      Variables:
         * **AllowCloseAtoms** (*BoolType** | **BoolKey*) -- No longer
           functional. Just here for backwards compatibility.

         * **Charge** (*float** | **FloatKey*) -- The system's total
           charge in atomic units.

         * **FractionalCoords** (*BoolType** | **BoolKey*) -- Whether
           the atomic coordinates in the Atoms block are given in
           fractional coordinates of the lattice vectors. Requires the
           presence of the Lattice block.

         * **GeometryFile** (*str** | **Path** | **StringKey*) -- Read
           the geometry from a file (instead of from Atoms and Lattice
           blocks). Supported formats: .xyz

         * **GuessBonds** (*BoolType** | **BoolKey*) -- Equivalent to
           'Modify%GuessBonds'. Please update input file to use
           'Modify' block instead.

         * **LatticeStrain** (*Iterable**[**float**] **|
           **FloatListKey*) -- Equivalent to 'Modify%LatticeStrain'.
           Please update input file to use 'Modify' block instead.

         * **MapAtomsToUnitCell** (*BoolType** | **BoolKey*) --
           Equivalent to 'Modify%MapAtomsToUnitCell'. Please update
           input file to use 'Modify' block instead.

         * **PerturbCoordinates** (*float** | **FloatKey*) --
           Equivalent to 'Modify%PerturbCoordinates'. Please update
           input file to use 'Modify' block instead.

         * **PerturbLattice** (*float** | **FloatKey*) -- Equivalent
           to 'Modify%PerturbLattice'. Please update input file to use
           'Modify' block instead.

         * **ShiftCoordinates** (*Iterable**[**float**] **|
           **FloatListKey*) -- Equivalent to 'Modify%Translate', but
           in the unit of bohr by default. Please update input file to
           use 'Modify' block instead.

         * **SuperCell** (*Iterable**[**int**] **| **IntListKey*) --
           Equivalent to 'Modify%SuperCell'. Please update input file
           to use 'Modify' block instead.

         * **SuperCellTrafo** (*Iterable**[**int**] **| **IntListKey*)
           -- Equivalent to 'Modify%SuperCellTrafo'. Please update
           input file to use 'Modify' block instead.

         * **Symmetrize** (*BoolType** | **BoolKey*) -- Equivalent to
           'Modify%Symmetrize'. Please update input file to use
           'Modify' block instead.

         * **Atoms** (*str** | **Sequence**[**str**] **| **FreeBlock*)
           -- The atom types and coordinates. Unit can be specified in
           the header. Default unit is Angstrom.

         * **BondOrders** (*str** | **Sequence**[**str**] **|
           **FreeBlock*) -- Defined bond orders. Each line should
           contain two atom indices, followed by the bond order (1,
           1.5, 2, 3 for single, aromatic, double and triple bonds)
           and (optionally) the cell shifts for periodic systems. May
           be used by MM engines and for defining constraints. If the
           system is periodic and none of the bonds have the cell
           shift defined then AMS will attempt to determine them
           following the minimum image convention.

         * **ElectrostaticEmbedding**
           (*Conformers._System._ElectrostaticEmbedding*) -- Container
           for electrostatic embedding options, which can be combined.

         * **Lattice** (*str** | **Sequence**[**str**] **|
           **FreeBlock*) -- Up to three lattice vectors. Unit can be
           specified in the header. Default unit is Angstrom.

         * **Modify** (*Conformers._System._Modify*) -- Modifications
           to make to the chemical system after construction. This
           block is read like a script and the modifications applied
           top to bottom.

      class _Atoms

         The atom types and coordinates. Unit can be specified in the
         header. Default unit is Angstrom.

      class _BondOrders

         Defined bond orders. Each line should contain two atom
         indices, followed by the bond order (1, 1.5, 2, 3 for single,
         aromatic, double and triple bonds) and (optionally) the cell
         shifts for periodic systems. May be used by MM engines and
         for defining constraints. If the system is periodic and none
         of the bonds have the cell shift defined then AMS will
         attempt to determine them following the minimum image
         convention.

      class _ElectrostaticEmbedding

         Container for electrostatic embedding options, which can be
         combined.

         Variables:
            * **ElectricField** (*Iterable**[**float**] **|
              **FloatListKey*) --

              External homogeneous electric field with three Cartesian
              components: ex, ey, ez, the default unit being V/Å.

              In atomic units: Hartree/(e bohr) = 51.422 V/Angstrom;
              the relation to SI units is: 1 Hartree/(e bohr) = 5.14
              ... e11 V/m.

              Supported by the engines adf, band, dftb and mopac.

              For periodic systems the field may only have nonzero
              components orthogonal to the direction(s) of periodicity
              (i.e. for 1D periodic system the x-component of the
              electric field should be zero, while for 2D periodic
              systems both the x and y components should be zero. This
              options cannot be used for 3D periodic systems.

            * **MultipolePotential** (*Conformers._System._Electrosta
              ticEmbedding._MultipolePotential*) -- External point
              charges (and dipoles).

         class _MultipolePotential

            External point charges (and dipoles).

            Variables:
               * **ChargeModel** (*Literal**[**"Point"**,
                 **"Gaussian"**]*) -- A multipole may be represented
                 by a point (with a singular potential at its
                 location) or by a spherical Gaussian distribution.

               * **ChargeWidth** (*float** | **FloatKey*) -- The width
                 parameter in a.u. in case a Gaussian charge model is
                 chosen. A negative value means that the width will be
                 chosen automatically.

               * **Coordinates** (*str** | **Sequence**[**str**] **|
                 **FreeBlock*) --

                 Positions and values of the multipoles, one per line.
                 Each line has the following format:

                 x y z q, or x y z q µx µy µz.

                 Here x, y, z are the coordinates in Å, q is the
                 charge (in atomic units of charge) and µx, µy, µz are
                 the (optional) dipole moment components (in atomic
                 units, i.e. e*Bohr).

                 Periodic systems are not supported.

            class _Coordinates

               Positions and values of the multipoles, one per line.
               Each line has the following format:

               x y z q, or x y z q µx µy µz.

               Here x, y, z are the coordinates in Å, q is the charge
               (in atomic units of charge) and µx, µy, µz are the
               (optional) dipole moment components (in atomic units,
               i.e. e*Bohr).

               Periodic systems are not supported.

      class _Lattice

         Up to three lattice vectors. Unit can be specified in the
         header. Default unit is Angstrom.

      class _Modify

         Modifications to make to the chemical system after
         construction. This block is read like a script and the
         modifications applied top to bottom.

         Variables:
            * **EnableAtomAttributes** (*Literal**[**"gui"**,
              **"adf"**, **"band"**, **"forcefield"**, **"dftb"**,
              **"reaxff"**, **"qe"**]*) -- Enables an atomic attribute
              group. This is only necessary if you want a group
              enabled, but no atom in the input is using any attribute
              from that group.

            * **GuessBonds** (*BoolType** | **BoolKey*) -- Guesses
              bonds based on the atomic elements and the geometry.
              Keeps existing bonds.

            * **LatticeStrain** (*Iterable**[**float**] **|
              **FloatListKey*) -- Deform the input system by the
              specified strain. The strain elements are in Voigt
              notation, so one should specify 6 numbers for 3D
              periodic system (order: xx,yy,zz,yz,xz,xy), 3 numbers
              for 2D periodic systems (order: xx,yy,xy) or 1 number
              for 1D periodic systems.

            * **MapAtomsToUnitCell** (*Iterable**[**float**] **|
              **FloatListKey*) -- For periodic systems the atoms will
              be moved to the central unit cell where all their
              fractional coordinates are in the range
              [start_range,start_range+1). No mapping will take place
              along non-periodic directions. If just a single number
              is given, it corresponds to start_range. If multiple
              numbers are given, they should match the number of
              lattice vectors and will be used as start ranges along
              the individual lattice vectors. If no number is given at
              all, the mapping will be done to the [-0.5:0.5) cell.

            * **PerturbCoordinates** (*float** | **FloatKey*) --
              Perturb the atomic coordinates by adding random numbers
              between [-PerturbCoordinates,PerturbCoordinates] to each
              Cartesian component. This can be useful if you want to
              break the symmetry of your system (e.g. for a geometry
              optimization).

            * **PerturbLattice** (*float** | **FloatKey*) -- Perturb
              the lattice vectors by applying random strain with
              matrix elements between
              [-PerturbLattice,PerturbLattice]. This can be useful if
              you want to deviate from an ideal symmetric geometry,
              for example if you look for a phase change due to high
              pressure.

            * **SuperCell** (*Iterable**[**int**] **| **IntListKey*)
              -- Create a supercell of the input system (only possible
              for periodic systems). The integer numbers represent the
              diagonal elements of the supercell transformation; you
              should specify as many numbers as lattice vectors (i.e.
              1 number for 1D, 2 numbers for 2D and 3 numbers for 3D
              periodic systems).

            * **SuperCellTrafo** (*Iterable**[**int**] **|
              **IntListKey*) -- Create a supercell of the input system
              (only possible for periodic systems) \vec{a}_i' = \sum_j
              T_{ij} \vec{a}_j. The integer numbers represent the
              supercell transformation T_{ij}: 1 number for 1D PBC, 4
              numbers for 2D PBC corresponding to a 2x2 matrix (order:
              (1,1),(1,2),(2,1),(2,2)) and 9 numbers for 3D PBC
              corresponding to a 3x3 matrix (order:
              (1,1),(1,2),(1,3),(2,1),(2,2),(2,3),(3,1),(3,2),(3,3)).

            * **Symmetrize** (*BoolType** | **BoolKey*) -- Symmetrizes
              a system, using either the "symmetrize_molecule" or
              "symmetrize_cell" method, depending on periodicity.

            * **SymmetrizeMoleculeTo** (*str** | **StringKey*) --
              Symmetrizes a molecule to a particular symmetry given by
              a Schoenflies symbol. Symmetrizes the atomic coordinates
              to machine precision, but does NOT rototranslate the
              molecule in any way. If the symmetrization fails, an
              error will be raised.

            * **Translate** (*Iterable**[**float**] **|
              **FloatListKey*) -- Translate all atoms by a vector.

class DENSF

   Variables:
      * **ADFFile** (*str** | **StringKey*) -- Path to the TAPE21 file
        from which densf reads the input data

      * **AOResponse** (*str** | **StringKey*) --

      * **COSMO** (*BoolType** | **BoolKey*) --

      * **Convert** (*BoolType** | **BoolKey*) --

      * **CubInput** (*str** | **StringKey*) -- If the CubInput
        keyword is present then the grid as specified in the file is
        used to calculate all requested quantities. Any volume data
        found in the cube file is also saved in the output file. NOTE:
        CUBINPUT option cannot be used with a pre-existing TAPE41 file
        because they both specify the grid, which may lead to a
        conflict.

      * **CubOutput** (*str** | **StringKey*) -- Presence of the
        CubOutput keyword tells densf to save all computed quantities
        as cube files using file as filename prefix. The prefix can
        also contain a complete path including directories. For
        example, specifying the following in the densf input

      * **DEBUGRISM** (*BoolType** | **BoolKey*) --

      * **DenGrad** (*str** | **StringKey*) --

      * **DenHess** (*str** | **StringKey*) --

      * **Density** (*str** | **StringKey*) --

      * **DualDescriptor** (*BoolType** | **BoolKey*) --

      * **Extend** (*float** | **FloatKey*) -- Extend grid?

      * **FOD** (*BoolType** | **BoolKey*) --

      * **InputFile** (*str** | **StringKey*) -- Path to the TAPE21
        file from which densf reads the input data

      * **KinDens** (*str** | **StringKey*) --

      * **Laplacian** (*str** | **StringKey*) --

      * **NCI** (*str** | **StringKey*) --

      * **NEBImage** (*int** | **IntKey*) --

      * **OutputFile** (*str** | **StringKey*) -- Path to the
        (possibly existing) TAPE41 file. If the file exists, densf
        will read grid specifications from it ignoring GRID keyword in
        the input. Computed quantities are saved in the file
        overwriting existing data with the same name, if any

      * **POLTDDFT** (*int** | **IntKey*) -- Frequency point for
        transition density

      * **Potential** (*str** | **StringKey*) --

      * **QP** (*BoolType** | **BoolKey*) --

      * **RISM** (*BoolType** | **BoolKey*) --

      * **Ridge** (*BoolType** | **BoolKey*) --

      * **SEDD** (*BoolType** | **BoolKey*) --

      * **TAPE16File** (*str** | **StringKey*) -- Path to the TAPE16
        file from which densf reads the input data

      * **VTKFile** (*str** | **StringKey*) -- Specifies path to a
        file in the format readable by VTK directly. This option
        exists primarily for better integration with AMS-GUI and the
        user should not specify it.

      * **GenFit** (*str** | **Sequence**[**str**] **| **FreeBlock*)
        --

      * **Grid** (*str** | **Sequence**[**str**] **| **FreeBlock*) --

      * **IrrepDensity** (*str** | **Sequence**[**str**] **|
        **FreeBlock*) -- Select particular symmetry to compute the
        electron density for.

      * **Line** (*str** | **Sequence**[**str**] **| **FreeBlock*) --

      * **NOCV** (*str** | **Sequence**[**str**] **| **FreeBlock*) --

      * **Orbitals** (*str** | **Sequence**[**str**] **| **FreeBlock*)
        --

      * **Spinor** (*str** | **Sequence**[**str**] **| **FreeBlock*)
        --

      * **StericInteraction** (*str** | **Sequence**[**str**] **|
        **FreeBlock*) --

      * **TransitionDensity** (*str** | **Sequence**[**str**] **|
        **FreeBlock*) -- Select particular excitations to calculate
        the transition density for. Format: SS|ST SymLabel Index

      * **Units** (*DENSF._Units*) -- Definitions of the units.

   class _GenFit

   class _Grid

   class _IrrepDensity

      Select particular symmetry to compute the electron density for.

   class _Line

   class _NOCV

   class _Orbitals

   class _Spinor

   class _StericInteraction

   class _TransitionDensity

      Select particular excitations to calculate the transition
      density for. Format: SS|ST SymLabel Index

   class _Units

      Definitions of the units.

      Variables:
         **length** (*Literal**[**"bohr"**, **"angstrom"**]*) -- Units
         of length

class DFTBPlus

   Variables:
      **HSDInputTemplate** (*str** | **Path** | **StringKey*) -- Path
      to the DFTB+ input file template in .hsd format. This is in
      principle like the normal dftb_in.hsd but contains some
      placeholders for things filled in by the AMS driver. See the
      examples for details.

class EPR

   Variables:
      * **GSOODetailed** (*BoolType** | **BoolKey*) --

      * **GSOOSPINWEIGHTS** (*Iterable**[**float**] **|
        **FloatListKey*) --

      * **NOGSOOSCREENING** (*BoolType** | **BoolKey*) --

      * **PROXBUF** (*int** | **IntKey*) --

      * **PROXCELLS** (*int** | **IntKey*) --

      * **CLGEPR** (*str** | **Sequence**[**str**] **| **FreeBlock*)
        --

   class _CLGEPR

class FCF

   Variables:
      * **Convergence** (*float** | **FloatKey*) -- Minimum fraction
        of the FC factors sum to be calculated

      * **DeltaClass** (*float** | **FloatKey*) -- Minimum gain in FCF
        between classes to continue calculation

      * **Lambda** (*float** | **FloatKey*) -- Optional. The minimum
        value of the electron-phonon coupling for a mode to be taken
        into account in the calculation. Together with the MODES
        option, this provides a way to significantly reduce the total
        number of Franck-Condon factors. As with the MODES option,
        always check if the results do not change too much.

      * **Modes** (*Iterable**[**int**] **| **IntListKey*) --
        Optional. The first and last mode to be taken into account in
        the calculation. By default, all modes are taken into account.
        This option can be used to effectively specify and energy
        range for the Franck-Condon factors. When using this options,
        always check if the results (electron-phonon couplings, ground
        state to ground overlap integral, average sum of Franck-Condon
        factors, etc.) do not change too much.

      * **NumericalQuality** (*Literal**[**"0-0"**, **"Basic"**,
        **"Normal"**, **"Good"**, **"Excellent"**]*) -- Set the
        quality of several technical aspects of an FC calculation,
        including details for the prescreening, the amount of computed
        integrals, the maximum integral class evaluated, as well as
        the convergence criteria.

      * **Rotate** (*BoolType** | **BoolKey*) -- Recommended to be
        used. Rotate the geometries to maximize the overlap of the
        nuclear coordinates.

      * **State1** (*str** | **StringKey*) -- Filename of the result
        files of a numerical or analytical frequency calculation for
        the first (initial) state.

      * **State2** (*str** | **StringKey*) -- Filename of the result
        files of a numerical or analytical frequency calculation for
        the second (final) state.

      * **States** (*str** | **StringKey*) -- The filenames of two
        results files of a numerical or analytical frequency
        calculation. The calculations must have been performed on the
        same molecule, i.e. the type, mass and order of occurrence of
        all the atoms (or fragments) has to be the same in both files.

      * **Translate** (*BoolType** | **BoolKey*) -- Recommended to be
        used. Move the center of mass of both geometries to the
        origin.

      * **Prescreening** (*FCF._Prescreening*) -- Optional. Controls
        the details of the FC factors prescreening algorithm

      * **Printing** (*FCF._Printing*) -- Optional. Printing Options.

      * **Spectrum** (*FCF._Spectrum*) -- Optional. Controls the
        details of the spectrum calculation

   class _Prescreening

      Optional. Controls the details of the FC factors prescreening
      algorithm

      Variables:
         * **Class1** (*int** | **IntKey*) -- Maximum quantum number
           for Class 1 FC integrals

         * **Class2** (*int** | **IntKey*) -- Maximum quantum number
           for Class 2 FC integrals

         * **MaxClass** (*int** | **IntKey*) -- Maximum class of
           integrals to be computed

         * **MaxFCI** (*int** | **IntKey*) -- Maximum number of FC
           integrals to be computed for each Class (in millions)

   class _Printing

      Optional. Printing Options.

      Variables:
         * **FCFThresh** (*float** | **FloatKey*) -- The minimum value
           for the printing of a FC factor.

         * **Verbose** (*BoolType** | **BoolKey*) -- Increase output
           verbosity.

   class _Spectrum

      Optional. Controls the details of the spectrum calculation

      Variables:
         * **HWHM** (*float** | **FloatKey*) -- Half-Width at Half-
           Maximum for the spectral lineshape function

         * **LineShape** (*Literal**[**"Stick"**, **"Gaussian"**,
           **"Lorentzian"**]*) -- Type of lineshape function

         * **SpcLen** (*int** | **IntKey*) -- Number of points in the
           spectrum

         * **SpcMax** (*float** | **FloatKey*) -- Maximum absolute
           energy difference between the states relative to the 0-0
           transition

         * **SpcMin** (*float** | **FloatKey*) -- Minimum absolute
           energy difference between the states relative to the 0-0
           transition

         * **Type** (*Literal**[**"Absorption"**, **"Emission"**]*) --
           Type of spectrum

class Green

   Variables:
      * **DOS** (*str** | **StringKey*) -- Enables the calculation of
        the density of states. The string specifies the TAPE21 file
        containing the result of an ADF calculation of the extended
        molecule (performed with SYMMETRY NOSYM)

      * **ETA** (*float** | **FloatKey*) -- The imaginary energy, or
        the distance from the real axis, in the calculation of the
        Green's function. The value needs to be a small positive
        number to prevent singularities in the calculation.

      * **Eps** (*str** | **StringKey*) -- mineps maxeps numeps: The
        energy range for which either the self-energy matrices or the
        DOS and transmission have to be calculated. The range consists
        of numeps (<=1) points running from mineps to maxeps
        inclusive.

      * **FermiLevel** (*str** | **StringKey*) --

      * **NoSave** (*str** | **StringKey*) --

      * **SO** (*Iterable**[**float**] **| **FloatListKey*) --

      * **Trans** (*str** | **StringKey*) --

      * **Left** (*Green._Left*) -- Specify the left self-energies
        used in a calculation of the DOS and transmission. If a
        filename is specified in the header, the self-energy matrices
        are read from that file.

      * **Right** (*Green._Right*) -- Specify the right self-energies
        used in a calculation of the DOS and transmission. If a
        filename is specified in the header, the self-energy matrices
        are read from that file.

      * **Surface** (*Green._Surface*) -- Enables the calculation of
        the self-energy matrices. The filename in the header specifies
        the TAPE21 file resulting from an ADF calculation of the
        contacts

   class _Left

      Specify the left self-energies used in a calculation of the DOS
      and transmission. If a filename is specified in the header, the
      self-energy matrices are read from that file.

      Variables:
         * **ETA** (*float** | **FloatKey*) -- Magnitude of the
           coupling

         * **Fragment** (*str** | **StringKey*) --

   class _Right

      Specify the right self-energies used in a calculation of the DOS
      and transmission. If a filename is specified in the header, the
      self-energy matrices are read from that file.

      Variables:
         * **ETA** (*float** | **FloatKey*) -- Magnitude of the
           coupling

         * **Fragment** (*str** | **StringKey*) --

   class _Surface

      Enables the calculation of the self-energy matrices. The
      filename in the header specifies the TAPE21 file resulting from
      an ADF calculation of the contacts

      Variables:
         **Fragments** (*str** | **StringKey*) -- The two principal
         layers between which the surface is defined

class LFDFT

   Variables:
      * **ADFFile** (*str** | **StringKey*) -- Path to TAPE21 file
        from which lfdft reads data and to which lfdft writes data

      * **BField** (*Iterable**[**float**] **| **FloatListKey*) --
        Include a finite magnetic Field. For MCD calculations include
        a magnetic field in the z-direction. The DegeneracyThreshold
        should be small to see the splitting of levels due to the
        magnetic field.

      * **DEBUG** (*BoolType** | **BoolKey*) -- debug

      * **DegeneracyThreshold** (*float** | **FloatKey*) -- Energy
        difference threshold to determine degenerate levels

      * **MOIND** (*Iterable**[**int**] **| **IntListKey*) -- The
        indices of the MOs that participate for shell 1.

      * **MOIND1** (*Iterable**[**int**] **| **IntListKey*) -- The
        indices of the MOs that participate for shell 1.

      * **MOIND2** (*Iterable**[**int**] **| **IntListKey*) -- The
        indices of the MOs that participate for shell 2.

      * **MOIND3** (*Iterable**[**int**] **| **IntListKey*) -- The
        indices of the MOs that participate for shell 3.

      * **MOIND4** (*Iterable**[**int**] **| **IntListKey*) -- The
        indices of the MOs that participate for shell 4.

      * **NLVAL** (*Iterable**[**int**] **| **IntListKey*) -- n and l
        value of shell 1.

      * **NLVAL1** (*Iterable**[**int**] **| **IntListKey*) -- n and l
        value of shell 1.

      * **NLVAL2** (*Iterable**[**int**] **| **IntListKey*) -- n and l
        value of shell 2.

      * **NLVAL3** (*Iterable**[**int**] **| **IntListKey*) -- n and l
        value of shell 3.

      * **NLVAL4** (*Iterable**[**int**] **| **IntListKey*) -- n and l
        value of shell 4.

      * **NSHEL** (*int** | **IntKey*) -- number of shells

      * **NSHELL** (*int** | **IntKey*) -- number of shells

      * **ORF** (*float** | **FloatKey*) -- Orbital reduction factor

      * **SOC** (*Iterable**[**float**] **| **FloatListKey*) --
        Include Spin-Orbit coupling for the shells, scaling it with
        the specified factor(s).

      * **SOCType** (*LFDFT._SOCType*) -- Choose the type of Spin-
        Orbit coupling calculation used for the shells.

   class _SOCType

      Choose the type of Spin-Orbit coupling calculation used for the
      shells.

      Variables:
         * **Shell1** (*Literal**[**"ZORA"**, **"Core"**]*) -- Type of
           Spin-Orbit coupling for the first shell

         * **Shell2** (*Literal**[**"ZORA"**, **"Core"**]*) -- Type of
           Spin-Orbit coupling for the second shell

         * **Shell3** (*Literal**[**"ZORA"**, **"Core"**]*) -- Type of
           Spin-Orbit coupling for the third shell

         * **Shell4** (*Literal**[**"ZORA"**, **"Core"**]*) -- Type of
           Spin-Orbit coupling for the fourth shell

class LFDFT_TDM

   Variables:
      * **DEBUG** (*BoolType** | **BoolKey*) -- debug

      * **STATE1** (*str** | **StringKey*) -- NAME of the state1 file.

      * **STATE2** (*str** | **StringKey*) -- NAME of the state2 file.

class NAO

   Variables:
      * **RunType** (*Literal**[**"foo"**, **"bar"**,
        **"slakotable"**, **"testblas"**,
        **"testfunctionsetdotproduct"**,
        **"testfunctionsetdotproduct2"**, **"testlinalg"**,
        **"testsyscalls"**, **"testabstractmatrix"**]*) --

      * **Title** (*str** | **StringKey*) --

      * **filename** (*str** | **StringKey*) --

      * **resultfilename** (*str** | **StringKey*) --

      * **setlogginglevel** (*str** | **StringKey*) --

      * **usesymmetry** (*BoolType** | **BoolKey*) --

      * **System** (*NAO._System*) -- Specification of the chemical
        system. For some applications more than one system may be
        present in the input. In this case, all systems except one
        must have a non-empty string ID specified after the System
        keyword. The system without an ID is considered the main one.

      * **TestParameters** (*NAO._TestParameters*) --

      * **aimcriticalpoints** (*NAO._aimcriticalpoints*) --

      * **beckegridconfig** (*NAO._beckegridconfig*) --

      * **fields** (*str** | **Sequence**[**str**] **| **FreeBlock*)
        --

      * **grid** (*NAO._grid*) --

      * **programmer** (*NAO._programmer*) --

      * **slakotableconfig** (*NAO._slakotableconfig*) --

      * **thresholds** (*NAO._thresholds*) --

      * **zlmfit** (*NAO._zlmfit*) -- Options for the density fitting
        scheme 'ZlmFit'.

   class _System

      Specification of the chemical system. For some applications more
      than one system may be present in the input. In this case, all
      systems except one must have a non-empty string ID specified
      after the System keyword. The system without an ID is considered
      the main one.

      Variables:
         * **AllowCloseAtoms** (*BoolType** | **BoolKey*) -- No longer
           functional. Just here for backwards compatibility.

         * **Charge** (*float** | **FloatKey*) -- The system's total
           charge in atomic units.

         * **FractionalCoords** (*BoolType** | **BoolKey*) -- Whether
           the atomic coordinates in the Atoms block are given in
           fractional coordinates of the lattice vectors. Requires the
           presence of the Lattice block.

         * **GeometryFile** (*str** | **Path** | **StringKey*) -- Read
           the geometry from a file (instead of from Atoms and Lattice
           blocks). Supported formats: .xyz

         * **GuessBonds** (*BoolType** | **BoolKey*) -- Equivalent to
           'Modify%GuessBonds'. Please update input file to use
           'Modify' block instead.

         * **LatticeStrain** (*Iterable**[**float**] **|
           **FloatListKey*) -- Equivalent to 'Modify%LatticeStrain'.
           Please update input file to use 'Modify' block instead.

         * **MapAtomsToUnitCell** (*BoolType** | **BoolKey*) --
           Equivalent to 'Modify%MapAtomsToUnitCell'. Please update
           input file to use 'Modify' block instead.

         * **PerturbCoordinates** (*float** | **FloatKey*) --
           Equivalent to 'Modify%PerturbCoordinates'. Please update
           input file to use 'Modify' block instead.

         * **PerturbLattice** (*float** | **FloatKey*) -- Equivalent
           to 'Modify%PerturbLattice'. Please update input file to use
           'Modify' block instead.

         * **ShiftCoordinates** (*Iterable**[**float**] **|
           **FloatListKey*) -- Equivalent to 'Modify%Translate', but
           in the unit of bohr by default. Please update input file to
           use 'Modify' block instead.

         * **SuperCell** (*Iterable**[**int**] **| **IntListKey*) --
           Equivalent to 'Modify%SuperCell'. Please update input file
           to use 'Modify' block instead.

         * **SuperCellTrafo** (*Iterable**[**int**] **| **IntListKey*)
           -- Equivalent to 'Modify%SuperCellTrafo'. Please update
           input file to use 'Modify' block instead.

         * **Symmetrize** (*BoolType** | **BoolKey*) -- Equivalent to
           'Modify%Symmetrize'. Please update input file to use
           'Modify' block instead.

         * **Atoms** (*str** | **Sequence**[**str**] **| **FreeBlock*)
           -- The atom types and coordinates. Unit can be specified in
           the header. Default unit is Angstrom.

         * **BondOrders** (*str** | **Sequence**[**str**] **|
           **FreeBlock*) -- Defined bond orders. Each line should
           contain two atom indices, followed by the bond order (1,
           1.5, 2, 3 for single, aromatic, double and triple bonds)
           and (optionally) the cell shifts for periodic systems. May
           be used by MM engines and for defining constraints. If the
           system is periodic and none of the bonds have the cell
           shift defined then AMS will attempt to determine them
           following the minimum image convention.

         * **ElectrostaticEmbedding**
           (*NAO._System._ElectrostaticEmbedding*) -- Container for
           electrostatic embedding options, which can be combined.

         * **Lattice** (*str** | **Sequence**[**str**] **|
           **FreeBlock*) -- Up to three lattice vectors. Unit can be
           specified in the header. Default unit is Angstrom.

         * **Modify** (*NAO._System._Modify*) -- Modifications to make
           to the chemical system after construction. This block is
           read like a script and the modifications applied top to
           bottom.

      class _Atoms

         The atom types and coordinates. Unit can be specified in the
         header. Default unit is Angstrom.

      class _BondOrders

         Defined bond orders. Each line should contain two atom
         indices, followed by the bond order (1, 1.5, 2, 3 for single,
         aromatic, double and triple bonds) and (optionally) the cell
         shifts for periodic systems. May be used by MM engines and
         for defining constraints. If the system is periodic and none
         of the bonds have the cell shift defined then AMS will
         attempt to determine them following the minimum image
         convention.

      class _ElectrostaticEmbedding

         Container for electrostatic embedding options, which can be
         combined.

         Variables:
            * **ElectricField** (*Iterable**[**float**] **|
              **FloatListKey*) --

              External homogeneous electric field with three Cartesian
              components: ex, ey, ez, the default unit being V/Å.

              In atomic units: Hartree/(e bohr) = 51.422 V/Angstrom;
              the relation to SI units is: 1 Hartree/(e bohr) = 5.14
              ... e11 V/m.

              Supported by the engines adf, band, dftb and mopac.

              For periodic systems the field may only have nonzero
              components orthogonal to the direction(s) of periodicity
              (i.e. for 1D periodic system the x-component of the
              electric field should be zero, while for 2D periodic
              systems both the x and y components should be zero. This
              options cannot be used for 3D periodic systems.

            * **MultipolePotential** (*NAO._System._ElectrostaticEmbe
              dding._MultipolePotential*) -- External point charges
              (and dipoles).

         class _MultipolePotential

            External point charges (and dipoles).

            Variables:
               * **ChargeModel** (*Literal**[**"Point"**,
                 **"Gaussian"**]*) -- A multipole may be represented
                 by a point (with a singular potential at its
                 location) or by a spherical Gaussian distribution.

               * **ChargeWidth** (*float** | **FloatKey*) -- The width
                 parameter in a.u. in case a Gaussian charge model is
                 chosen. A negative value means that the width will be
                 chosen automatically.

               * **Coordinates** (*str** | **Sequence**[**str**] **|
                 **FreeBlock*) --

                 Positions and values of the multipoles, one per line.
                 Each line has the following format:

                 x y z q, or x y z q µx µy µz.

                 Here x, y, z are the coordinates in Å, q is the
                 charge (in atomic units of charge) and µx, µy, µz are
                 the (optional) dipole moment components (in atomic
                 units, i.e. e*Bohr).

                 Periodic systems are not supported.

            class _Coordinates

               Positions and values of the multipoles, one per line.
               Each line has the following format:

               x y z q, or x y z q µx µy µz.

               Here x, y, z are the coordinates in Å, q is the charge
               (in atomic units of charge) and µx, µy, µz are the
               (optional) dipole moment components (in atomic units,
               i.e. e*Bohr).

               Periodic systems are not supported.

      class _Lattice

         Up to three lattice vectors. Unit can be specified in the
         header. Default unit is Angstrom.

      class _Modify

         Modifications to make to the chemical system after
         construction. This block is read like a script and the
         modifications applied top to bottom.

         Variables:
            * **EnableAtomAttributes** (*Literal**[**"gui"**,
              **"adf"**, **"band"**, **"forcefield"**, **"dftb"**,
              **"reaxff"**, **"qe"**]*) -- Enables an atomic attribute
              group. This is only necessary if you want a group
              enabled, but no atom in the input is using any attribute
              from that group.

            * **GuessBonds** (*BoolType** | **BoolKey*) -- Guesses
              bonds based on the atomic elements and the geometry.
              Keeps existing bonds.

            * **LatticeStrain** (*Iterable**[**float**] **|
              **FloatListKey*) -- Deform the input system by the
              specified strain. The strain elements are in Voigt
              notation, so one should specify 6 numbers for 3D
              periodic system (order: xx,yy,zz,yz,xz,xy), 3 numbers
              for 2D periodic systems (order: xx,yy,xy) or 1 number
              for 1D periodic systems.

            * **MapAtomsToUnitCell** (*Iterable**[**float**] **|
              **FloatListKey*) -- For periodic systems the atoms will
              be moved to the central unit cell where all their
              fractional coordinates are in the range
              [start_range,start_range+1). No mapping will take place
              along non-periodic directions. If just a single number
              is given, it corresponds to start_range. If multiple
              numbers are given, they should match the number of
              lattice vectors and will be used as start ranges along
              the individual lattice vectors. If no number is given at
              all, the mapping will be done to the [-0.5:0.5) cell.

            * **PerturbCoordinates** (*float** | **FloatKey*) --
              Perturb the atomic coordinates by adding random numbers
              between [-PerturbCoordinates,PerturbCoordinates] to each
              Cartesian component. This can be useful if you want to
              break the symmetry of your system (e.g. for a geometry
              optimization).

            * **PerturbLattice** (*float** | **FloatKey*) -- Perturb
              the lattice vectors by applying random strain with
              matrix elements between
              [-PerturbLattice,PerturbLattice]. This can be useful if
              you want to deviate from an ideal symmetric geometry,
              for example if you look for a phase change due to high
              pressure.

            * **SuperCell** (*Iterable**[**int**] **| **IntListKey*)
              -- Create a supercell of the input system (only possible
              for periodic systems). The integer numbers represent the
              diagonal elements of the supercell transformation; you
              should specify as many numbers as lattice vectors (i.e.
              1 number for 1D, 2 numbers for 2D and 3 numbers for 3D
              periodic systems).

            * **SuperCellTrafo** (*Iterable**[**int**] **|
              **IntListKey*) -- Create a supercell of the input system
              (only possible for periodic systems) \vec{a}_i' = \sum_j
              T_{ij} \vec{a}_j. The integer numbers represent the
              supercell transformation T_{ij}: 1 number for 1D PBC, 4
              numbers for 2D PBC corresponding to a 2x2 matrix (order:
              (1,1),(1,2),(2,1),(2,2)) and 9 numbers for 3D PBC
              corresponding to a 3x3 matrix (order:
              (1,1),(1,2),(1,3),(2,1),(2,2),(2,3),(3,1),(3,2),(3,3)).

            * **Symmetrize** (*BoolType** | **BoolKey*) -- Symmetrizes
              a system, using either the "symmetrize_molecule" or
              "symmetrize_cell" method, depending on periodicity.

            * **SymmetrizeMoleculeTo** (*str** | **StringKey*) --
              Symmetrizes a molecule to a particular symmetry given by
              a Schoenflies symbol. Symmetrizes the atomic coordinates
              to machine precision, but does NOT rototranslate the
              molecule in any way. If the symmetrization fails, an
              error will be raised.

            * **Translate** (*Iterable**[**float**] **|
              **FloatListKey*) -- Translate all atoms by a vector.

   class _TestParameters

      Variables:
         * **Debug** (*BoolType** | **BoolKey*) --

         * **Integer** (*int** | **IntKey*) --

         * **IntegerList** (*str** | **StringKey*) --

         * **Logical** (*BoolType** | **BoolKey*) --

         * **String** (*str** | **StringKey*) --

   class _aimcriticalpoints

      Variables:
         * **eqvpointstol** (*float** | **FloatKey*) --

         * **gridpadding** (*float** | **FloatKey*) --

         * **gridspacing** (*float** | **FloatKey*) --

   class _beckegridconfig

      Variables:
         * **angularlorder** (*int** | **IntKey*) --

         * **radialgridquality** (*float** | **FloatKey*) --

   class _fields

   class _grid

      Variables:
         * **extendx** (*float** | **FloatKey*) --

         * **extendy** (*float** | **FloatKey*) --

         * **extendz** (*float** | **FloatKey*) --

         * **filename** (*str** | **StringKey*) --

         * **type** (*str** | **StringKey*) --

         * **userdefined** (*str** | **Sequence**[**str**] **|
           **FreeBlock*) -- One can define the regular grid
           specification in this block. See example. Default unit is
           Bohr

      class _userdefined

         One can define the regular grid specification in this block.
         See example. Default unit is Bohr

   class _programmer

      Variables:
         * **UseSharedMemoryForSandwiching** (*BoolType** |
           **BoolKey*) --

         * **blocksize** (*int** | **IntKey*) --

         * **calcdipole** (*BoolType** | **BoolKey*) --

         * **dynamicblockiterator** (*BoolType** | **BoolKey*) --

         * **exactsharedarraylocking** (*BoolType** | **BoolKey*) --

         * **functionsetdotproductemploysym** (*BoolType** |
           **BoolKey*) --

         * **functionsetdotproducteps** (*float** | **FloatKey*) --

         * **functionsetdotproductoption** (*int** | **IntKey*) --

         * **functionsetoverlapemploysym** (*BoolType** | **BoolKey*)
           --

         * **functionsetoverlaplockcolumn** (*BoolType** | **BoolKey*)
           --

         * **functionsetoverlapoption** (*int** | **IntKey*) --

         * **functionsetoverlapslicesize** (*int** | **IntKey*) --

         * **functionsettransformeps** (*float** | **FloatKey*) --

         * **functionsettransformoption** (*int** | **IntKey*) --

         * **randomlypermuteblocks** (*BoolType** | **BoolKey*) --

         * **usenewtailroutines** (*BoolType** | **BoolKey*) --

         * **usesharedmemory** (*BoolType** | **BoolKey*) --

   class _slakotableconfig

      Variables:
         * **basisfile1** (*str** | **StringKey*) --

         * **basisfile2** (*str** | **StringKey*) --

         * **debug** (*BoolType** | **BoolKey*) --

         * **outputstyle** (*int** | **IntKey*) --

         * **grid** (*NAO._slakotableconfig._grid*) --

         * **repweights** (*NAO._slakotableconfig._repweights*) --

      class _grid

         Variables:
            * **numsteps** (*int** | **IntKey*) --

            * **stepsize** (*float** | **FloatKey*) --

      class _repweights

         Variables:
            * **electronic** (*float** | **FloatKey*) --

            * **exc** (*float** | **FloatKey*) --

            * **nuclear** (*float** | **FloatKey*) --

            * **vxc** (*float** | **FloatKey*) --

   class _thresholds

      Variables:
         * **densitycutoff** (*float** | **FloatKey*) --

         * **functioncutoff** (*float** | **FloatKey*) --

   class _zlmfit

      Options for the density fitting scheme 'ZlmFit'.

      Variables:
         **quality** (*str** | **StringKey*) --

class NMR

   Variables:
      * **ADFFile** (*str** | **StringKey*) -- Path to TAPE21 file
        from which nmr reads data and to which nmr writes data

      * **AllInOne** (*BoolType** | **BoolKey*) -- Tensor in one step

      * **Allow** (*str** | **StringKey*) --

      * **DBGNMR** (*int** | **IntKey*) --

      * **Debug** (*str** | **StringKey*) --

      * **FakeSO** (*BoolType** | **BoolKey*) --

      * **Fractional** (*BoolType** | **BoolKey*) --

      * **HFAtomsPerPass** (*int** | **IntKey*) -- Memory usage option
        for old HF scheme

      * **HFMaxMemory** (*int** | **IntKey*) -- Memory usage option
        for old HF scheme

      * **Logfile** (*str** | **StringKey*) --

      * **NBO** (*BoolType** | **BoolKey*) --

      * **NoScale** (*BoolType** | **BoolKey*) --

      * **PNMRFile** (*str** | **StringKey*) -- Path to file that
        contains pNMR data

      * **Print** (*str** | **StringKey*) --

      * **Programmer** (*str** | **StringKey*) --

      * **RecalculateTAPE10** (*BoolType** | **BoolKey*) --

      * **Save** (*str** | **StringKey*) --

      * **Scaled** (*BoolType** | **BoolKey*) --

      * **Skip** (*str** | **StringKey*) --

      * **TAPE10File** (*str** | **StringKey*) -- Path to the TAPE10
        file from which nmr reads data

      * **Temperature** (*float** | **FloatKey*) -- Temperature
        (Kelvin) for temperature dependent part shielding tensor.

      * **Analysis** (*NMR._Analysis*) -- Block for analysis options.

      * **NMR** (*NMR._NMR*) -- Main NMR options.

   class _Analysis

      Block for analysis options.

      Variables:
         * **Components** (*BoolType** | **BoolKey*) -- The components
           keyword is optional and enables an analysis not only of the
           isotropic shielding but also of the diagonal Cartesian
           components of the tensor XX, YY, and ZZ). In order to
           analyze the principal shielding tensor components with
           canonical MOs you can calculate the shielding tensor first
           with the NMR code, rotate the molecule such that the
           principal axes system aligns with the Cartesian coordinate
           system, and then repeat the NMR calculation with the
           analysis features switched on.

         * **FakeSO** (*BoolType** | **BoolKey*) --

         * **NoPrincipal** (*BoolType** | **BoolKey*) -- Do not
           transform to principal axes for analysis

         * **Print** (*float** | **FloatKey*) -- The print keyword
           selects printout of contributions relative to the total
           diamagnetic, paramagnetic. For example in case of print
           0.01 only contributions greater than 1% are printed. Set to
           zero to print ALL contributions.

         * **ZSOAO2007** (*BoolType** | **BoolKey*) --

         * **canonical** (*BoolType** | **BoolKey*) -- It enables an
           analysis of the shielding in terms of the canonical MOs.

         * **nbo** (*BoolType** | **BoolKey*) --

   class _NMR

      Main NMR options.

      Variables:
         * **ADFGUI** (*BoolType** | **BoolKey*) --

         * **AllAtomsOfType** (*str** | **StringKey*) -- Space
           separated list of type of nuclei (like H, C, P) for which
           the NMR shielding should be calculated. In addition to Nuc
           or Atoms.

         * **Analysis** (*int** | **IntKey*) --

           This key controls the MO analysis. Its value should be an
           integer, which then specifies that the first so many MOs
           are to be analyzed.

           Default no Analysis.

           The value of this analysis subkey in the block key NMR is
           somewhat limited. The separate ANALYSIS block key can give
           more analysis of the NMR chemical shielding.

         * **Atoms** (*Iterable**[**int**] **| **IntListKey*) -- This
           subkey ATOMS specifies for which nuclei the NMR shielding
           is calculated. Default all nuclei are calculated, i.e. as
           for omitting the subkeys ATOMS and NUC. The numbers refer
           to the input ordering in the ADF calculation. Use the
           subkey NUC to specify the nuclei according to the internal
           NMR numbers of the atoms.

         * **Calc** (*str** | **StringKey*) -- The sub key Calc
           controls what is actually calculated. All: Implies all of
           the other options to this key. Para: The paramagnetic part,
           Dia: The diamagnetic part, FC: The Fermi-contact part in
           case of the Pauli Hamiltonian, SO: The Fermi-contact part
           in case of the ZORA Hamiltonian.

         * **GFactors** (*BoolType** | **BoolKey*) -- Calculate
           g-factors

         * **Nuc** (*Iterable**[**int**] **| **IntListKey*) -- This
           subkey NUC specifies for which nuclei the NMR shielding is
           calculated. Default all nuclei are calculated, i.e. as for
           omitting the subkeys ATOMS and NUC. Else you may use this
           options by simply typing Nuc in the NMR block (without any
           further data); this means: for no nuclei at all.
           Alternatively you may type the index of the atom(s) you
           want to see analyzed. Default all nuclei are calculated,
           i.e. as for omitting this subkey. The numbers refer to the
           internal numbering of the nuclei as it appears somewhere
           early in the general ADF output. This internal numbering is
           also the internal NMR numbering, but it is not necessarily
           the same as the input ordering. Use the subkey ATOMS to
           specify the nuclei according to this input ordering in the
           ADF calculation. Note that the number of nuclei has a
           significant consequence for the total CPU time.

         * **Out** (*str** | **StringKey*) -- Controls printed output.
           Options: All: All the other options, ISO: Isotropic
           shielding constants, Tens: Shielding tensors, Eig:
           Eigenvectors, U1: The U1 Matrix, F1: The first order change
           in the Fock matrix, S1: The first order change in the
           Overlap matrix, AOP: The paramagnetic AO matrix (= the
           matrix in the representation of elementary atomic basis
           functions), AOD: The diamagnetic AO matrix, AOF: The Fermi-
           contact AO matrix, Refs: Literature references, INFO:
           General information.

         * **SCF** (*float** | **FloatKey*) -- Convergence threshold
           for CPKS cycle

         * **U1K** (*str** | **StringKey*) -- Determines which terms
           are included in the calculation of the U1 matrix (first
           order changes in MO coefficients). Best: The best
           (recommended) options for each relativistic option are
           included for this subkey. Implies None for non-relativistic
           and scalar relativistic ZORA, SO + SOFULL for spin-orbit
           coupled ZORA, and MV + Dar for the Pauli Hamiltonian. None:
           Implies none of the other options to this key. All: Implies
           all the other options to this key. MV: The mass-velocity
           term. Dar: The Darwin term. ZMAN: The Spin-Zeeman term (can
           be included only in case of spin-orbit coupled Pauli
           Hamiltonian). SO: ZORA spin-orbit part. SOFULL: ZORA spin-
           orbit part.

         * **Use** (*str** | **StringKey*) -- The subkey Use controls
           some optional options. FXC: Improves the exchange-
           correlation kernel used, as was implemented by J.
           Autschbach
           [http://dx.doi.org/10.1080/00268976.2013.796415]. Important
           only in case of spin-orbit coupled calculations. This may
           give some (small) gauge dependent results when using this.
           Important option that should be seriously considered and
           has been advocated in Ref
           [http://dx.doi.org/10.1080/00268976.2013.796415]. SCALED:
           Implies the scaled ZORA method, which gives (slightly)
           gauge dependent results. Note that in case of the ZORA
           Hamiltonian default the unscaled ZORA method is used. For
           chemical shifts, only compare results with the same
           options. SO1C: Before ADF2008.01 in the the spin-orbit term
           a 1-center approximation was used, which does not suffer
           from gauge dependence. This 1-center approximation can be
           used with USE SO1C.

         * **Ghosts** (*str** | **Sequence**[**str**] **|
           **FreeBlock*) -- The subkey GHOSTS is a block type subkey.
           The format is Ghosts | xx1 yy1 zz1 | xx2 yy2 zz2 | ... |
           SubEnd

      class _Ghosts

         The subkey GHOSTS is a block type subkey. The format is
         Ghosts | xx1 yy1 zz1 | xx2 yy2 zz2 | ... | SubEnd

class OLEDDepostion

   Variables:
      * **RestartWorkdir** (*str** | **Path** | **StringKey*) -- Uses
        the data from the working directory of a previously run
        deposition workflow for restarting. Under the hood this uses
        the normal rerun-prevention available in PLAMS: it may reuse
        results from old jobs instead of running them again.

      * **Box** (*OLEDDepostion._Box*) -- Specifications of the box
        into which the material is deposited.

      * **Deposition** (*OLEDDepostion._Deposition*) -- Specifies the
        details of how molecules are deposited.

      * **LAMMPSOffload** (*OLEDDepostion._LAMMPSOffload*) -- Offload
        the calculation to LAMMPS via AMSPipe.

      * **LoadSystem** (*OLEDDepostion._LoadSystem*) -- Block that
        controls reading the chemical system from a KF file instead of
        the [System] block.

      * **Molecule** (*OLEDDepostion._Molecule*) -- Specification of
        the molecule to be deposited.

      * **System** (*OLEDDepostion._System*) -- Specification of the
        chemical system. For some applications more than one system
        may be present in the input. In this case, all systems except
        one must have a non-empty string ID specified after the System
        keyword. The system without an ID is considered the main one.

   class _Box

      Specifications of the box into which the material is deposited.

      Variables:
         * **Size** (*Iterable**[**float**] **| **FloatListKey*) --
           Specify the desired size of the box. The final deposited
           box may have a different size. The x- and y-axis are
           perpendicular to the direction of deposition, so these may
           be regarded as the width of the growing layer. The z-axis
           is the direction along which the deposition happens, so
           this determines the thickness of the deposited layer. Note
           that the x- and y-axis will be ignored if a custom
           substrate is used: the are of the box is then determined by
           the lattice of the substrate. The z-axis can still be
           freely chosen, but should be large enough that there is
           enough space for the substrate itself and to deposit more
           molecules on top of it.

         * **Substrate** (*Literal**[**"Graphene"**, **"Custom"**]*)
           -- The substrate on which to grow the layer.

         * **SubstrateSystem** (*str** | **StringKey*) -- String ID of
           a named [System] to be used as a substrate. (This is only
           used when the Substrate key is set to Custom.)

   class _Deposition

      Specifies the details of how molecules are deposited.

      Variables:
         * **ConstrainHXBonds** (*BoolType** | **BoolKey*) --
           Constrain the bond length for all H-* bonds (i.e. any bond
           to a hydrogen atom). Doing this allows choosing a larger
           time step. If this option is disabled, the TimeStep needs
           to be reduced manually.

         * **Frequency** (*int** | **IntKey*) -- The frequency in MD
           steps at which new molecules will be added to the system.

         * **NumMolecules** (*int** | **IntKey*) -- The number of
           molecules that we will try to deposit. If not specified the
           number will be determined automatically such that the box
           becomes approximately full.

         * **Temperature** (*float** | **FloatKey*) -- The temperature
           at which the deposition happens.

         * **TimeStep** (*float** | **FloatKey*) -- The time
           difference per step.

   class _LAMMPSOffload

      Offload the calculation to LAMMPS via AMSPipe.

      Variables:
         * **Enabled** (*BoolType** | **BoolKey*) -- Enable offloading
           the force field evaluation to LAMMPS instead of handling it
           internally in AMS.

         * **UseGPU** (*BoolType** | **BoolKey*) -- Accelerate LAMMPS
           calculations using a GPU. Requires a LAMMPS library built
           with the GPU package.

         * **UseGPUForKSpace** (*BoolType** | **BoolKey*) -- When
           UseGPU is enabled, also use the GPU to accelerate
           reciprocal space electrostatic interactions. Disabling this
           can improve performance on less powerful GPUs.

         * **UseGPUForNeighbor** (*BoolType** | **BoolKey*) -- When
           UseGPU is enabled, also use the GPU to accelerate neighbor
           searches. Disabling this can improve performance on less
           powerful GPUs.

         * **UseOpenMP** (*BoolType** | **BoolKey*) -- Parallelize
           LAMMPS calculations using OpenMP threading. Requires a
           LAMMPS library built with the OMP package.

   class _LoadSystem

      Block that controls reading the chemical system from a KF file
      instead of the [System] block.

      Variables:
         * **File** (*str** | **Path** | **StringKey*) -- The path of
           the KF file from which to load the system. It may also be
           the results directory containing it.

         * **Section** (*str** | **StringKey*) -- The section on the
           KF file from which to load the system.

   class _Molecule

      Specification of the molecule to be deposited.

      Variables:
         * **MoleFraction** (*float** | **FloatKey*) -- The relative
           occurrence of the molecule with regard to other deposited
           species. Only relevant for mixed molecule depositions.

         * **SystemName** (*str** | **StringKey*) -- String ID of a
           named [System] to be inserted. The lattice specified with
           this System, if any, is ignored and the main system's
           lattice is used instead.

   class _System

      Specification of the chemical system. For some applications more
      than one system may be present in the input. In this case, all
      systems except one must have a non-empty string ID specified
      after the System keyword. The system without an ID is considered
      the main one.

      Variables:
         * **AllowCloseAtoms** (*BoolType** | **BoolKey*) -- No longer
           functional. Just here for backwards compatibility.

         * **Charge** (*float** | **FloatKey*) -- The system's total
           charge in atomic units.

         * **FractionalCoords** (*BoolType** | **BoolKey*) -- Whether
           the atomic coordinates in the Atoms block are given in
           fractional coordinates of the lattice vectors. Requires the
           presence of the Lattice block.

         * **GeometryFile** (*str** | **Path** | **StringKey*) -- Read
           the geometry from a file (instead of from Atoms and Lattice
           blocks). Supported formats: .xyz

         * **GuessBonds** (*BoolType** | **BoolKey*) -- Equivalent to
           'Modify%GuessBonds'. Please update input file to use
           'Modify' block instead.

         * **LatticeStrain** (*Iterable**[**float**] **|
           **FloatListKey*) -- Equivalent to 'Modify%LatticeStrain'.
           Please update input file to use 'Modify' block instead.

         * **MapAtomsToUnitCell** (*BoolType** | **BoolKey*) --
           Equivalent to 'Modify%MapAtomsToUnitCell'. Please update
           input file to use 'Modify' block instead.

         * **PerturbCoordinates** (*float** | **FloatKey*) --
           Equivalent to 'Modify%PerturbCoordinates'. Please update
           input file to use 'Modify' block instead.

         * **PerturbLattice** (*float** | **FloatKey*) -- Equivalent
           to 'Modify%PerturbLattice'. Please update input file to use
           'Modify' block instead.

         * **ShiftCoordinates** (*Iterable**[**float**] **|
           **FloatListKey*) -- Equivalent to 'Modify%Translate', but
           in the unit of bohr by default. Please update input file to
           use 'Modify' block instead.

         * **SuperCell** (*Iterable**[**int**] **| **IntListKey*) --
           Equivalent to 'Modify%SuperCell'. Please update input file
           to use 'Modify' block instead.

         * **SuperCellTrafo** (*Iterable**[**int**] **| **IntListKey*)
           -- Equivalent to 'Modify%SuperCellTrafo'. Please update
           input file to use 'Modify' block instead.

         * **Symmetrize** (*BoolType** | **BoolKey*) -- Equivalent to
           'Modify%Symmetrize'. Please update input file to use
           'Modify' block instead.

         * **Atoms** (*str** | **Sequence**[**str**] **| **FreeBlock*)
           -- The atom types and coordinates. Unit can be specified in
           the header. Default unit is Angstrom.

         * **BondOrders** (*str** | **Sequence**[**str**] **|
           **FreeBlock*) -- Defined bond orders. Each line should
           contain two atom indices, followed by the bond order (1,
           1.5, 2, 3 for single, aromatic, double and triple bonds)
           and (optionally) the cell shifts for periodic systems. May
           be used by MM engines and for defining constraints. If the
           system is periodic and none of the bonds have the cell
           shift defined then AMS will attempt to determine them
           following the minimum image convention.

         * **ElectrostaticEmbedding**
           (*OLEDDepostion._System._ElectrostaticEmbedding*) --
           Container for electrostatic embedding options, which can be
           combined.

         * **Lattice** (*str** | **Sequence**[**str**] **|
           **FreeBlock*) -- Up to three lattice vectors. Unit can be
           specified in the header. Default unit is Angstrom.

         * **Modify** (*OLEDDepostion._System._Modify*) --
           Modifications to make to the chemical system after
           construction. This block is read like a script and the
           modifications applied top to bottom.

      class _Atoms

         The atom types and coordinates. Unit can be specified in the
         header. Default unit is Angstrom.

      class _BondOrders

         Defined bond orders. Each line should contain two atom
         indices, followed by the bond order (1, 1.5, 2, 3 for single,
         aromatic, double and triple bonds) and (optionally) the cell
         shifts for periodic systems. May be used by MM engines and
         for defining constraints. If the system is periodic and none
         of the bonds have the cell shift defined then AMS will
         attempt to determine them following the minimum image
         convention.

      class _ElectrostaticEmbedding

         Container for electrostatic embedding options, which can be
         combined.

         Variables:
            * **ElectricField** (*Iterable**[**float**] **|
              **FloatListKey*) --

              External homogeneous electric field with three Cartesian
              components: ex, ey, ez, the default unit being V/Å.

              In atomic units: Hartree/(e bohr) = 51.422 V/Angstrom;
              the relation to SI units is: 1 Hartree/(e bohr) = 5.14
              ... e11 V/m.

              Supported by the engines adf, band, dftb and mopac.

              For periodic systems the field may only have nonzero
              components orthogonal to the direction(s) of periodicity
              (i.e. for 1D periodic system the x-component of the
              electric field should be zero, while for 2D periodic
              systems both the x and y components should be zero. This
              options cannot be used for 3D periodic systems.

            * **MultipolePotential** (*OLEDDepostion._System._Electro
              staticEmbedding._MultipolePotential*) -- External point
              charges (and dipoles).

         class _MultipolePotential

            External point charges (and dipoles).

            Variables:
               * **ChargeModel** (*Literal**[**"Point"**,
                 **"Gaussian"**]*) -- A multipole may be represented
                 by a point (with a singular potential at its
                 location) or by a spherical Gaussian distribution.

               * **ChargeWidth** (*float** | **FloatKey*) -- The width
                 parameter in a.u. in case a Gaussian charge model is
                 chosen. A negative value means that the width will be
                 chosen automatically.

               * **Coordinates** (*str** | **Sequence**[**str**] **|
                 **FreeBlock*) --

                 Positions and values of the multipoles, one per line.
                 Each line has the following format:

                 x y z q, or x y z q µx µy µz.

                 Here x, y, z are the coordinates in Å, q is the
                 charge (in atomic units of charge) and µx, µy, µz are
                 the (optional) dipole moment components (in atomic
                 units, i.e. e*Bohr).

                 Periodic systems are not supported.

            class _Coordinates

               Positions and values of the multipoles, one per line.
               Each line has the following format:

               x y z q, or x y z q µx µy µz.

               Here x, y, z are the coordinates in Å, q is the charge
               (in atomic units of charge) and µx, µy, µz are the
               (optional) dipole moment components (in atomic units,
               i.e. e*Bohr).

               Periodic systems are not supported.

      class _Lattice

         Up to three lattice vectors. Unit can be specified in the
         header. Default unit is Angstrom.

      class _Modify

         Modifications to make to the chemical system after
         construction. This block is read like a script and the
         modifications applied top to bottom.

         Variables:
            * **EnableAtomAttributes** (*Literal**[**"gui"**,
              **"adf"**, **"band"**, **"forcefield"**, **"dftb"**,
              **"reaxff"**, **"qe"**]*) -- Enables an atomic attribute
              group. This is only necessary if you want a group
              enabled, but no atom in the input is using any attribute
              from that group.

            * **GuessBonds** (*BoolType** | **BoolKey*) -- Guesses
              bonds based on the atomic elements and the geometry.
              Keeps existing bonds.

            * **LatticeStrain** (*Iterable**[**float**] **|
              **FloatListKey*) -- Deform the input system by the
              specified strain. The strain elements are in Voigt
              notation, so one should specify 6 numbers for 3D
              periodic system (order: xx,yy,zz,yz,xz,xy), 3 numbers
              for 2D periodic systems (order: xx,yy,xy) or 1 number
              for 1D periodic systems.

            * **MapAtomsToUnitCell** (*Iterable**[**float**] **|
              **FloatListKey*) -- For periodic systems the atoms will
              be moved to the central unit cell where all their
              fractional coordinates are in the range
              [start_range,start_range+1). No mapping will take place
              along non-periodic directions. If just a single number
              is given, it corresponds to start_range. If multiple
              numbers are given, they should match the number of
              lattice vectors and will be used as start ranges along
              the individual lattice vectors. If no number is given at
              all, the mapping will be done to the [-0.5:0.5) cell.

            * **PerturbCoordinates** (*float** | **FloatKey*) --
              Perturb the atomic coordinates by adding random numbers
              between [-PerturbCoordinates,PerturbCoordinates] to each
              Cartesian component. This can be useful if you want to
              break the symmetry of your system (e.g. for a geometry
              optimization).

            * **PerturbLattice** (*float** | **FloatKey*) -- Perturb
              the lattice vectors by applying random strain with
              matrix elements between
              [-PerturbLattice,PerturbLattice]. This can be useful if
              you want to deviate from an ideal symmetric geometry,
              for example if you look for a phase change due to high
              pressure.

            * **SuperCell** (*Iterable**[**int**] **| **IntListKey*)
              -- Create a supercell of the input system (only possible
              for periodic systems). The integer numbers represent the
              diagonal elements of the supercell transformation; you
              should specify as many numbers as lattice vectors (i.e.
              1 number for 1D, 2 numbers for 2D and 3 numbers for 3D
              periodic systems).

            * **SuperCellTrafo** (*Iterable**[**int**] **|
              **IntListKey*) -- Create a supercell of the input system
              (only possible for periodic systems) \vec{a}_i' = \sum_j
              T_{ij} \vec{a}_j. The integer numbers represent the
              supercell transformation T_{ij}: 1 number for 1D PBC, 4
              numbers for 2D PBC corresponding to a 2x2 matrix (order:
              (1,1),(1,2),(2,1),(2,2)) and 9 numbers for 3D PBC
              corresponding to a 3x3 matrix (order:
              (1,1),(1,2),(1,3),(2,1),(2,2),(2,3),(3,1),(3,2),(3,3)).

            * **Symmetrize** (*BoolType** | **BoolKey*) -- Symmetrizes
              a system, using either the "symmetrize_molecule" or
              "symmetrize_cell" method, depending on periodicity.

            * **SymmetrizeMoleculeTo** (*str** | **StringKey*) --
              Symmetrizes a molecule to a particular symmetry given by
              a Schoenflies symbol. Symmetrizes the atomic coordinates
              to machine precision, but does NOT rototranslate the
              molecule in any way. If the symmetrization fails, an
              error will be raised.

            * **Translate** (*Iterable**[**float**] **|
              **FloatListKey*) -- Translate all atoms by a vector.

class OLEDProperties

   Variables:
      * **CoresPerJob** (*int** | **IntKey*) -- The number of CPU
        cores used for each job in the workflow. Combined with the
        total number of cores used (set by the "NSCM" environment
        variable or the "-n" command line argument), this indirectly
        determines the number of simultaneously running jobs. The
        default value should usually be a good choice. When changing
        this value, make sure you are using all allocated cores by
        setting a value that divides the total number of cores, as
        well as the number of cores on each node.

      * **LogProgressEvery** (*float** | **FloatKey*) -- How often to
        print progress information to the logfile.

      * **NumAdditionalOrbitalEnergies** (*int** | **IntKey*) -- The
        number of additional orbital energies to write to the HDF5
        file. A value of N means to write everything up to HOMO-N and
        LUMO+N.

      * **NumExcitations** (*int** | **IntKey*) -- The number of
        exited states to calculate. By default the S_1 and T_1 states
        will be calculated. The calculation of excited states is
        currently only supported for systems with a closed-shell
        ground state.

      * **NumSelectedMoleculesPerSpecies** (*int** | **IntKey*) --
        Number of molecules per species to calculate properties for.
        Around 50 molecules per species should be enough to estimate
        distribution means and standard deviations as input for the
        Bumblebee KMC code. Mutually exclusive with the
        "SelectedMolecules" keyword. If neither this key nor
        "SelectedMolecules" is present, all molecules will be
        selected.

      * **OccupationSmearing** (*Literal**[**"None"**, **"Ions"**,
        **"All"**]*) -- Determines for which systems the electron
        smearing feature in ADF will be used. If enabled, the
        molecular orbital occupations will be smeared out with a 300K
        Fermi-Dirac distribution. This makes SCF convergence easier,
        as the occupation of energetically close orbitals does not
        jump when their energetic order flips. See the ADF manual for
        details. It is recommended to keep this option enabled for the
        ionic systems, which are more likely to suffer from difficult
        SCF convergence.

      * **Relax** (*Literal**[**"None"**, **"Neutral"**, **"All"**]*)
        --

        Which geometries to relax prior to taking the energy
        differences for the calculation of ionization potential and
        electron affinity. The relaxation is done at the DFTB level
        using the GFN1-xTB model Hamiltonian with electrostatic
        embedding in a UFF environment.

        * None: Use the geometries directly from the input.

        * Neutral: Relax the uncharged molecule and use its optimized
          geometry for the neutral as well as the ionic systems. This
          gives (approximately) the vertical ionization potential and
          electron affinity.

        * All: Individually relax the neutral systems and the ions
          before calculating the total energies. This gives
          (approximately) the adiabatic ionization potential and
          electron affinity.

      * **Restart** (*str** | **Path** | **StringKey*) -- The HDF5
        file from a previous calculation on the same morphology. Data
        already calculated on the restart file will just be copied
        over and not be recalculated.

      * **SelectedMolecules** (*Iterable**[**int**] **| **IntListKey*)
        -- Indices of the molecules to calculate properties for. Note
        that indexing starts at 0. Mutually exclusive with the
        "NumSelectedMoleculesPerSpecies" keyword. If neither this key
        nor "NumSelectedMoleculesPerSpecies" is present, all molecules
        will be selected.

      * **StoreResultFiles** (*Literal**[**"None"**, **"Failed"**,
        **"All"**]*) -- Whether to keep the full result files from all
        the individual jobs. By default the result files from all jobs
        for a particular molecule will be deleted after all relevant
        results have been extracted and stored on the HDF5 file. Note
        that keeping the full results for all molecules can easily
        require hundreds of gigabytes of storage space.

      * **Embedding** (*OLEDProperties._Embedding*) -- Configures
        details of how the environment is taken into account.

      * **GW** (*OLEDProperties._GW*) -- Perform a GW calculation.
        G0W0 is the default for GW%SelfConsistency.

      * **LoadSystem** (*OLEDProperties._LoadSystem*) -- Block that
        controls reading the chemical system from a KF file instead of
        the [System] block.

      * **MBPT** (*OLEDProperties._MBPT*) -- Technical aspects of the
        MP2 algorithm.

      * **System** (*OLEDProperties._System*) -- Specification of the
        chemical system. For some applications more than one system
        may be present in the input. In this case, all systems except
        one must have a non-empty string ID specified after the System
        keyword. The system without an ID is considered the main one.

      * **TransferIntegrals** (*OLEDProperties._TransferIntegrals*) --
        Configures the details of the calculation of electron and hole
        transfer integrals.

   class _Embedding

      Configures details of how the environment is taken into account.

      Variables:
         * **Charges** (*Literal**[**"DFTB"**, **"DFT"**]*) --

           Which atomic charges to use for the DRF embedding.

           * DFTB: Use the self-consistent Mulliken charges from a
             quick DFTB calculation with the GFN1-xTB model.

           * DFT: Use the MDC-D charges from a relatively quick DFT
             calculation using LDA and a DZP basis set.

         * **Cutoff** (*float** | **FloatKey*) -- The cutoff distance
           determining which molecules will be considered the
           environment of the central molecule. The maximum possible
           cutoff distance is half the length of the smallest lattice
           vector. The distance can be measured using different
           metrics, see the "Metric" keyword.

         * **Metric** (*Literal**[**"CoM"**, **"Atoms"**,
           **"Atoms_noH"**]*) --

           The metric used to calculate the distance between two
           molecules.

           * CoM: use the distance between the centers of mass of the
             two molecules.

           * Atoms: Use the distance between the two closest atoms of
             two molecules.

           * Atoms_noH: Use the distance between the closest non-
             hydrogen atoms of the two molecules.

         * **Type** (*Literal**[**"None"**, **"DRF"**]*) -- The type
           of embedding used to simulate the molecular environment.

   class _GW

      Perform a GW calculation. G0W0 is the default for
      GW%SelfConsistency.

      Variables:
         * **AdaptiveMixing** (*Iterable**[**float**] **|
           **FloatListKey*) --

           Requests to use adaptive mixing instead of DIIS and sets
           the staring mixing parameter for mixing of Green's function
           in case of self-consistency.

           Adapative mixing is recommended in case a qsGW calculation
           does not converge with DIIS.

           It is ignored in non-selfconsistent calculation and
           overwritten by DIIS when DIIS is also present.

         * **DIIS** (*int** | **IntKey*) -- Requests to use DIIS. This
           is the Default. Number of expansion coefficients can be
           requested as well. Ignored in non-selfconsistent
           calculation

         * **Enabled** (*BoolType** | **BoolKey*) -- Enable the
           calculation of the GW quasi-particle energies.

         * **ExpansionOrder** (*int** | **IntKey*) -- Order of the
           expansion of the screened interaction on the SOS-GF(n)
           method. order 2 (=SOS-GF2) is the default

         * **FixedGridSizes** (*BoolType** | **BoolKey*) -- In a self-
           consistent GW calculation, recalculate Grids but keep them
           the same size during the SCF procedure.

         * **FixedGrids** (*BoolType** | **BoolKey*) -- In a self-
           consistent GW calculation, do not recalculate Grids. Can be
           useful in case of convergence problems. Only relevant for
           qsGW and qsGW0. In case of evGW and evGW0, the grids are
           always kept fixed.

         * **G3W2** (*Literal**[**"Full"**, **"Diagonal"**,
           **"Perturbative"**]*) -- Only relevant when self-energy is
           one of GF2 or G3W2: Full requests that the second-order
           term is evaluated for the full self-energy matrix. This is
           very expensive and should only be done for small systems.
           Diagonal requests, that only the Diagonal of the self-
           energy matrix is updated. Perturbative means, that only a
           second-order screened exchange correction is evaluated
           after the GW calculation is completed. For a G0W0
           calculation, all of these options are equivalent.

         * **LinearMixing** (*Iterable**[**float**] **|
           **FloatListKey*) --

           Requests to use linear mixing instead of DIIS and sets the
           mixing parameter for linear mixing of Green's function in
           case of self-consistency.

           It is ignored in non-selfconsistent calculation and
           overwritten by DIIS when DIIS is also present.

         * **LinearizeQPequations** (*BoolType** | **BoolKey*) --

           Instead of solving the non-linear QP equations in a G0W0
           (or evGW calculation) by bisection exacly, linearize them
           by first-order Taylor expansion.

           This is not recommended since it does not save
           computational time when used together with analytical
           continuation (as implemented in AMS). It might however be
           useful for benchmarking or for validating results.

           If the results os the linearization differ by a lot (for
           instance, more than 0.1 eV in frontier QP energies) from
           the non-linearized results, this might indicate that the GW
           calculation is not reliable.

         * **OffDiagonalEFermi** (*BoolType** | **BoolKey*) --
           Analytically continue the off-diagonal elements of the KSF2
           qsGW Hamiltonian at the Fermi-energy instead of omega=0.
           Typically leads to slightly lower QP energies, i.e. higher
           ionization potentials. The HOMO-LUMO gaps are typically not
           affected.

         * **Polarizability** (*Literal**[**"RPA"**, **"BSE"**,
           **"G4W1"**, **"G4V1"**, **"TDHF"**]*) --

           Sets the expression for the Polarizability used in the GW
           calculation.

           RPA is the Default and amounts to a standard GW
           calculation.

           BSE denotes screening in the Bethe-Salpeter-equation
           formalism.

         * **PrintAllSolutions** (*BoolType** | **BoolKey*) -- Print
           out all solutions for all requested states. Detects
           multiple solutions of the QP equations.

         * **PrintImaginaryAxisData** (*BoolType** | **BoolKey*) -- If
           true, print out the self-energy on the imaginary axis.

         * **PrintSpectralFunction** (*BoolType** | **BoolKey*) --
           Plot the self-energy as a function of frequency.
           Automatically done in case of analytical continuation.
           However, this is expensive in the analytical integration
           formalism.

         * **PrintZfactor** (*BoolType** | **BoolKey*) --

         * **QPHamiltonian** (*Literal**[**"KSF1"**, **"KSF2"**,
           **"SRG"**, **"LQSGW"**]*) --

           The quasi-particle Hamiltonian can be constructed in
           different ways.

           KSF1 refers to the original construction by Kotani, Van
           Schilfgaarde anf Faleev (KSF) which is also implemented in
           TURBOMOLE.

           KSF2 refers to an alternative construction by KSF.

           KSF1 is not recommended since it is numerically less stable
           than KSF2 in case analytical continuation is used (the
           default).

           In case the analytical integration algorithm is used, only
           KSF1 is implemented. Therefore, make sure that KSF1 is
           specified. The results are typically very similar.

           The QP energies at which the matrix elements are evaluated
           can be tweaked further, see the two subsequent keys:
           However, KSF2 is recommended since it typically leads to QP
           energies with the best agreement with experiment.

           Ignored when not a quasi-particle self-consistent GW
           calculation is performed

         * **Scaling** (*float** | **FloatKey*) -- Scale factor for
           the polarizability in the screened interaction SOS-GF2.
           Default = 1.0 (corresponds to no scaling)

         * **ScissorShift** (*BoolType** | **BoolKey*) --

           Only calculate the HOMO and LUMO QP energies and shift the
           remaining QP energies by the same amount.

           This is a rather crude approximation and not recommended.

           It might again be useful for benchmarking purposes.

         * **SelfConsistency** (*Literal**[**"None"**, **"G0W0"**,
           **"EVGW0"**, **"EVGW"**, **"QSGW0"**, **"QSGW"**]*) --

           Sets the level of self-consistency in a GW calculation.

           G0W0 calculates a one-shot, perturbative correction to the
           KS eigenvalues.

           In evGW and evGW0, the quasi-particle energies are updated
           until self-consistency is reached.

           evGW0 requests that the Green's function is evaluated self-
           consistently but not the screened interaction.

           In qsGW, the density is updated as well, however, the self-
           energy is mapped to a static effective potential and the
           Dyson equation is solved by diagonalization instead of
           inversion. The results of a qsGW are independent of the
           choice of the underlying exchange-correlation functional
           and are usually the most accurate ones.

           The same is done in qsGW0, but the screened interaction is
           not updated.

         * **SelfConsistentSigmaVertex** (*BoolType** | **BoolKey*) --
           If active, evaluate the vertex correction in Sigma in qsGW
           self-consistent. Only supported for GWGammaInf so far

         * **SelfEnergy** (*Literal**[**"HF"**, **"GW"**, **"G3W2"**,
           **"SOSEX"**, **"GWGamma"**, **"G3W2dynamic"**,
           **"GWGammaInf"**, **"GWGammaInfDyn"**]*) --

           Controls the form of the self-energy.

           GW is the default and corresponds to the standard GW
           calculation.

           G3W2 is a GW calculation plus a perturbative second-order
           statically screened exchange correction (second order
           expansion in the self-energy). Note, that there the self-
           energy is always static.

         * **TabulateGridPoints** (*BoolType** | **BoolKey*) --
           pretabulate grid points for numerical integration.

         * **nIterations** (*Iterable**[**int**] **| **IntListKey*) --

           The maximum number of iterations within the (partially or
           fully) self-consistent GW calculation has to converge.

           Ignored when Formalism is set to G0W0

         * **nLowest** (*int** | **IntKey*) -- Number of lowest
           occupied QP levels to be evaluated, overwrites nStates'

         * **nStates** (*int** | **IntKey*) --

           Number of Quasiparticle States to be printed to output.

           The default is 5 states which in this case means that
           min(5, Number of particle states) occupied and min(5,
           Number of hole states) hole states are printed. The whole
           list of states can be printed by setting this parameter to
           -1'

         * **preconditionQSGW** (*BoolType** | **BoolKey*) --

           If true, the QSGW equations are solved but prior to each
           diagonalization, i.e. a G0W0 calculation is performed to
           find the optimal QP energies at which to analytically
           continue the self-energy.

           This is in principle a more consistent construction than
           KSF1 or KSF2 since the diagonal elements are consistent
           with G0W0.

           In KSF1 and KSF2, the diagonal elements are evaluated at
           the QP energies from the previous iteration which is
           equivalent to a zeroth-order Taylor expansion of the
           diagonal elements around the previous QP energies.Enabling
           this option typically leads to slightly lower QP energies.

         * **AnalyticalIntegration**
           (*OLEDProperties._GW._AnalyticalIntegration*) -- Use
           analytical integration to calculate the self-energy. Very
           slow, unless the system is very small but useful to check
           the accuracy of the frequency integration

         * **Converge** (*OLEDProperties._GW._Converge*) -- Sets
           convergence criteria for the GW calculation in self-
           consistent case

      class _AnalyticalIntegration

         Use analytical integration to calculate the self-energy. Very
         slow, unless the system is very small but useful to check the
         accuracy of the frequency integration

         Variables:
            * **Enabled** (*BoolType** | **BoolKey*) -- Enable the
              calculation of the GW quasi-particle energies via
              analytical integration.

            * **SpectralFunctionResolution** (*int** | **IntKey*) --
              Number of points at which spectral function is
              evaluated.

            * **TDA** (*BoolType** | **BoolKey*) -- Solve the linear
              response equations in the Tamm-Dancoff approximation.

            * **eta** (*float** | **FloatKey*) --

              Artificial (positive) broadening parameter for
              evaluation of self-energy in analytical integration.

              Ideally should be as small as possible but this might
              lead to convergence issues in partially self-consistent
              approaches.

              In this case, a value of up to 0.1 is possible.

            * **printBSEexcitationsInLastIteration** (*BoolType** |
              **BoolKey*) --

              Print out BSE excitations in the last iteration in a
              qsGW calculation. Can be used in the BAND engine.

              In ADF, one should instead just calculate excitation
              energies using the excitation block.

      class _Converge

         Sets convergence criteria for the GW calculation in self-
         consistent case

         Variables:
            * **Density** (*Iterable**[**float**] **| **FloatListKey*)
              --

              First Criterion for self-consistency procedure to
              terminate.

              Criterion is the trace of the density matrix. Ignored in
              non-selfconsistent Calculation and in eigenvalue self-
              consistent GW

              It is possible to run a qsGW calculation with an inner
              SCF loop which updates the static part of the elf-energy
              only. This can be useful to accelerate the convergence
              in case linear mixing is used. It is not recommended to
              use linear mixing, so it is also not recommended to use
              that inner loop as well. The second number in this list
              specifies the convergence criterion for the inner SCF
              loop.

            * **HOMO** (*float** | **FloatKey*) --

              Criterion for self-consistency procedure to terminate.

              The self-consistent GW calculation terminates, when the
              difference between the HOMO QP energies between 2
              consecutive iterations is below this number.

              The LUMO energy converged faster than the HOMO energy so
              when the HOMO energy is converged according to this
              criterion, the LUMO energy will be converged as well.

              In non-selfconsistent Calculation, this criterion is
              ignored.

   class _LoadSystem

      Block that controls reading the chemical system from a KF file
      instead of the [System] block.

      Variables:
         * **File** (*str** | **Path** | **StringKey*) -- The path of
           the KF file from which to load the system. It may also be
           the results directory containing it.

         * **Section** (*str** | **StringKey*) -- The section on the
           KF file from which to load the system.

   class _MBPT

      Technical aspects of the MP2 algorithm.

      Variables:
         * **Dependency** (*BoolType** | **BoolKey*) -- If true, to
           improve numerical stability, almost linearly-dependent
           combination of basis functions are removed from the Green's
           function that are used in the MBPT equations. Disabling
           this key is strongly discouraged. Its value can however be
           changed. The key to adjust this value is
           RiHartreeFock%DependencyThreshold

         * **Enabled** (*BoolType** | **BoolKey*) -- Enable the
           calculation of the MP2 energy.

         * **ExcludeCore** (*BoolType** | **BoolKey*) --

           If active, excludes core states from the calculation of the
           optimal imaginary time and frequency grids.

           The core states are still included in all parts of the
           calculations.

           In case a frozen care calculation is performed, this key is
           ignored.

           For MP2 and double hybrid calculation, it defaults to
           false. For RPA and GW calculations, it defaults to true.

         * **FitSetQuality** (*Literal**[**"Auto"**, **"VeryBasic"**,
           **"Basic"**, **"Normal"**, **"Good"**, **"VeryGood"**]*) --

           Specifies the fit set to be used in the MBPT calculation.

           'Normal' quality is generally sufficient for basis sets up
           to and including TZ2P.

           For larger basis sets (or for benchmarking purposes) a
           'VeryGood' fit set is recommended. Note that the
           FitSetQuality heavily influences the computational cost of
           the calculation.

           If not specified or 'Auto', the RIHartreeFock%FitSetQuality
           is used.

         * **Formalism** (*Literal**[**"Auto"**, **"RI"**, **"LT"**,
           **"All"**]*) --

           Specifies the formalism for the calculation of the MP2
           correlation energy.

           'LT' means Laplace Transformed MP2 (also referred to as AO-
           PARI-MP2),

           'RI' means that a conventional RI-MP2 is carried out.

           If 'Auto', LT will be used in case of DOD double hybrids
           and SOS MP2, and RI will be used in all other cases.

           'All' means that both RI and LT formalisms are used in the
           calculation.

           For a RPA or GW calculation, the formalism is always LT,
           irrespective of the formalism specified with this key.

         * **FrequencyGridType** (*Literal**[**"LeastSquare"**,
           **"GaussLegendre"**]*) -- Use Gauss-legendre grid for
           imaginary frequency integration in RPA and GW calculations
           instead of the usually used Least-Square optimized ones.
           Has the advantage that it can be systematically converged
           and an arbitrary number of grid points can be used.
           Typically more grid points will be needed to get the same
           level of accuracy. However, the convergence of the results
           with the size of the grid can be more systematic. These
           grids can only be used when Formalism is set to RI.

         * **IntegrationQuality** (*Literal**[**"VeryBasic"**,
           **"Basic"**, **"Normal"**, **"Good"**, **"VeryGood"**]*) --
           Specifies the integration quality to be used in the MBPT
           calculation. If not specified, the
           RIHartreeFock%IntegrationQuality is used.

         * **PrintOutSigma** (*BoolType** | **BoolKey*) -- Print out
           additional output for sigma-functional for parametrization.

         * **SigmaFunctionalParametrization** (*Literal**[**"W1"**,
           **"W2"**, **"S1"**, **"S2"**, **"S1re"**]*) -- Only
           relevant if a sigma-functional calculation is performed.
           Possible choices for the parametrization of the sigma-
           functional. Not all options are supported for all
           functionals.

         * **ThresholdQuality** (*Literal**[**"VeryBasic"**,
           **"Basic"**, **"Normal"**, **"Good"**, **"VeryGood"**,
           **"Excellent"**]*) -- Controls the distances between atomic
           centers for which the product of two basis functions is not
           fitted any more. Especially for spatially extended, large
           systems, 'VERYBASIC' and 'BASIC' can lead to large
           computational savings, but the fit is also more
           approximate. If not specified, the
           RIHartreeFock%ThresholdQuality is used.

         * **UseScaledZORA** (*BoolType** | **BoolKey*) -- If true,
           use the scaled ZORA orbital energies instead of the ZORA
           orbital energies in the MBPT equations.

         * **cutOfftransition** (*float** | **FloatKey*) -- Energy
           above which states are ignored in a MBPT calculation (must
           be a positive number). The default energy is chosen so
           high, that all states are included except for the ones
           which have been removed.

         * **frozencore** (*BoolType** | **BoolKey*) -- Freeze core
           states in correlation part of MBPT calculation

         * **nCore** (*int** | **IntKey*) --

           Number of core states which will be excluded from the
           correlated calculation.

           Will be ignored if frozencore is false.

           In case nothing is specified, the number of core levels
           will be determined automatically.

           Needs to be smaller than the number of occupied states.

         * **nFreqIntegration** (*int** | **IntKey*) -- Number of
           imaginary frequency points for G3W2 integration

         * **nFrequency** (*int** | **IntKey*) -- Number of imaginary
           frequency points. This key is only relevant for RPA and GW
           and will be ignored if used in an AO-PARI-MP2 calculation.
           12 Points is the default for a RPA calculation. It is
           technically possible to use a different number of imaginary
           frequency points than for imaginary time. The maximum
           number of points which can be requested for imaginary
           frequency integration is 42. Important note: The
           computation time and memory requirements roughly scale
           linearly with the number of imaginary frequency points.
           However, memory can be an issue for RPA and GW when the
           number of imaginary frequency points is high. In case a job
           crashes, it is advised to increase the number of nodes
           since the necessary memory distributes over all nodes.

         * **nLambda** (*int** | **IntKey*) -- Size of coupling
           constant integration grid for SOSEX variants in RPA.
           Default is 4 points

         * **nTime** (*int** | **IntKey*) --

           Number of imaginary time points (only relevant in case the
           Laplace Transformed (LT) formalism is used).

           In the many-body-perturbation theory module in ADF, the
           polarizability (or Kohn-Sham density response function) is
           evaluated in imaginary time to exploit sparsity in the AO
           basis. For MP2, this is often referred to as a Laplace
           transform. For MP2, 9 points are the default. This is a
           safe choice, guaranteeing accuracies higher than 1 Kj/mol
           for most systems (For many simple organic systems, 6 points
           are sufficient for good accuracy).

           Only for systems with a very small HOMO-LUMO gap or low-
           lying core states (heavy elements starting from the 4th row
           of the periodic table) more points might be necessary.

           In principle, the same considerations apply for RPA and GW
           as well, however, the accuracy requirements are somewhat
           higher and 12 point are the default for RPA. In a GW
           calculation, the number of points is adjusted according to
           the numerical quality. Using less than 9 points is strongly
           discouraged except for the simplest molecules.

           In ADF2019, it can happen that the algorithm determining
           the imaginary time grid does not converge. In this case,
           the usual reason is that the number of points is too small
           and more points need to be specified. Starting from
           AMS2020, this does not happen any more. In case the
           imaginary time grid does not converge, the number of points
           is automatically adjusted until it does.

           The computation time of AO-PARI-MP2, RPA, and GW scales
           linearly with the number of imaginary time points.

         * **useGreenXgrids** (*BoolType** | **BoolKey*) -- Use GreenX
           library to generate grid points. This is recommended for
           larger number of grid points (> 20). Up to 34 points can be
           requested.

   class _System

      Specification of the chemical system. For some applications more
      than one system may be present in the input. In this case, all
      systems except one must have a non-empty string ID specified
      after the System keyword. The system without an ID is considered
      the main one.

      Variables:
         * **AllowCloseAtoms** (*BoolType** | **BoolKey*) -- No longer
           functional. Just here for backwards compatibility.

         * **Charge** (*float** | **FloatKey*) -- The system's total
           charge in atomic units.

         * **FractionalCoords** (*BoolType** | **BoolKey*) -- Whether
           the atomic coordinates in the Atoms block are given in
           fractional coordinates of the lattice vectors. Requires the
           presence of the Lattice block.

         * **GeometryFile** (*str** | **Path** | **StringKey*) -- Read
           the geometry from a file (instead of from Atoms and Lattice
           blocks). Supported formats: .xyz

         * **GuessBonds** (*BoolType** | **BoolKey*) -- Equivalent to
           'Modify%GuessBonds'. Please update input file to use
           'Modify' block instead.

         * **LatticeStrain** (*Iterable**[**float**] **|
           **FloatListKey*) -- Equivalent to 'Modify%LatticeStrain'.
           Please update input file to use 'Modify' block instead.

         * **MapAtomsToUnitCell** (*BoolType** | **BoolKey*) --
           Equivalent to 'Modify%MapAtomsToUnitCell'. Please update
           input file to use 'Modify' block instead.

         * **PerturbCoordinates** (*float** | **FloatKey*) --
           Equivalent to 'Modify%PerturbCoordinates'. Please update
           input file to use 'Modify' block instead.

         * **PerturbLattice** (*float** | **FloatKey*) -- Equivalent
           to 'Modify%PerturbLattice'. Please update input file to use
           'Modify' block instead.

         * **ShiftCoordinates** (*Iterable**[**float**] **|
           **FloatListKey*) -- Equivalent to 'Modify%Translate', but
           in the unit of bohr by default. Please update input file to
           use 'Modify' block instead.

         * **SuperCell** (*Iterable**[**int**] **| **IntListKey*) --
           Equivalent to 'Modify%SuperCell'. Please update input file
           to use 'Modify' block instead.

         * **SuperCellTrafo** (*Iterable**[**int**] **| **IntListKey*)
           -- Equivalent to 'Modify%SuperCellTrafo'. Please update
           input file to use 'Modify' block instead.

         * **Symmetrize** (*BoolType** | **BoolKey*) -- Equivalent to
           'Modify%Symmetrize'. Please update input file to use
           'Modify' block instead.

         * **Atoms** (*str** | **Sequence**[**str**] **| **FreeBlock*)
           -- The atom types and coordinates. Unit can be specified in
           the header. Default unit is Angstrom.

         * **BondOrders** (*str** | **Sequence**[**str**] **|
           **FreeBlock*) -- Defined bond orders. Each line should
           contain two atom indices, followed by the bond order (1,
           1.5, 2, 3 for single, aromatic, double and triple bonds)
           and (optionally) the cell shifts for periodic systems. May
           be used by MM engines and for defining constraints. If the
           system is periodic and none of the bonds have the cell
           shift defined then AMS will attempt to determine them
           following the minimum image convention.

         * **ElectrostaticEmbedding**
           (*OLEDProperties._System._ElectrostaticEmbedding*) --
           Container for electrostatic embedding options, which can be
           combined.

         * **Lattice** (*str** | **Sequence**[**str**] **|
           **FreeBlock*) -- Up to three lattice vectors. Unit can be
           specified in the header. Default unit is Angstrom.

         * **Modify** (*OLEDProperties._System._Modify*) --
           Modifications to make to the chemical system after
           construction. This block is read like a script and the
           modifications applied top to bottom.

      class _Atoms

         The atom types and coordinates. Unit can be specified in the
         header. Default unit is Angstrom.

      class _BondOrders

         Defined bond orders. Each line should contain two atom
         indices, followed by the bond order (1, 1.5, 2, 3 for single,
         aromatic, double and triple bonds) and (optionally) the cell
         shifts for periodic systems. May be used by MM engines and
         for defining constraints. If the system is periodic and none
         of the bonds have the cell shift defined then AMS will
         attempt to determine them following the minimum image
         convention.

      class _ElectrostaticEmbedding

         Container for electrostatic embedding options, which can be
         combined.

         Variables:
            * **ElectricField** (*Iterable**[**float**] **|
              **FloatListKey*) --

              External homogeneous electric field with three Cartesian
              components: ex, ey, ez, the default unit being V/Å.

              In atomic units: Hartree/(e bohr) = 51.422 V/Angstrom;
              the relation to SI units is: 1 Hartree/(e bohr) = 5.14
              ... e11 V/m.

              Supported by the engines adf, band, dftb and mopac.

              For periodic systems the field may only have nonzero
              components orthogonal to the direction(s) of periodicity
              (i.e. for 1D periodic system the x-component of the
              electric field should be zero, while for 2D periodic
              systems both the x and y components should be zero. This
              options cannot be used for 3D periodic systems.

            * **MultipolePotential** (*OLEDProperties._System._Electr
              ostaticEmbedding._MultipolePotential*) -- External point
              charges (and dipoles).

         class _MultipolePotential

            External point charges (and dipoles).

            Variables:
               * **ChargeModel** (*Literal**[**"Point"**,
                 **"Gaussian"**]*) -- A multipole may be represented
                 by a point (with a singular potential at its
                 location) or by a spherical Gaussian distribution.

               * **ChargeWidth** (*float** | **FloatKey*) -- The width
                 parameter in a.u. in case a Gaussian charge model is
                 chosen. A negative value means that the width will be
                 chosen automatically.

               * **Coordinates** (*str** | **Sequence**[**str**] **|
                 **FreeBlock*) --

                 Positions and values of the multipoles, one per line.
                 Each line has the following format:

                 x y z q, or x y z q µx µy µz.

                 Here x, y, z are the coordinates in Å, q is the
                 charge (in atomic units of charge) and µx, µy, µz are
                 the (optional) dipole moment components (in atomic
                 units, i.e. e*Bohr).

                 Periodic systems are not supported.

            class _Coordinates

               Positions and values of the multipoles, one per line.
               Each line has the following format:

               x y z q, or x y z q µx µy µz.

               Here x, y, z are the coordinates in Å, q is the charge
               (in atomic units of charge) and µx, µy, µz are the
               (optional) dipole moment components (in atomic units,
               i.e. e*Bohr).

               Periodic systems are not supported.

      class _Lattice

         Up to three lattice vectors. Unit can be specified in the
         header. Default unit is Angstrom.

      class _Modify

         Modifications to make to the chemical system after
         construction. This block is read like a script and the
         modifications applied top to bottom.

         Variables:
            * **EnableAtomAttributes** (*Literal**[**"gui"**,
              **"adf"**, **"band"**, **"forcefield"**, **"dftb"**,
              **"reaxff"**, **"qe"**]*) -- Enables an atomic attribute
              group. This is only necessary if you want a group
              enabled, but no atom in the input is using any attribute
              from that group.

            * **GuessBonds** (*BoolType** | **BoolKey*) -- Guesses
              bonds based on the atomic elements and the geometry.
              Keeps existing bonds.

            * **LatticeStrain** (*Iterable**[**float**] **|
              **FloatListKey*) -- Deform the input system by the
              specified strain. The strain elements are in Voigt
              notation, so one should specify 6 numbers for 3D
              periodic system (order: xx,yy,zz,yz,xz,xy), 3 numbers
              for 2D periodic systems (order: xx,yy,xy) or 1 number
              for 1D periodic systems.

            * **MapAtomsToUnitCell** (*Iterable**[**float**] **|
              **FloatListKey*) -- For periodic systems the atoms will
              be moved to the central unit cell where all their
              fractional coordinates are in the range
              [start_range,start_range+1). No mapping will take place
              along non-periodic directions. If just a single number
              is given, it corresponds to start_range. If multiple
              numbers are given, they should match the number of
              lattice vectors and will be used as start ranges along
              the individual lattice vectors. If no number is given at
              all, the mapping will be done to the [-0.5:0.5) cell.

            * **PerturbCoordinates** (*float** | **FloatKey*) --
              Perturb the atomic coordinates by adding random numbers
              between [-PerturbCoordinates,PerturbCoordinates] to each
              Cartesian component. This can be useful if you want to
              break the symmetry of your system (e.g. for a geometry
              optimization).

            * **PerturbLattice** (*float** | **FloatKey*) -- Perturb
              the lattice vectors by applying random strain with
              matrix elements between
              [-PerturbLattice,PerturbLattice]. This can be useful if
              you want to deviate from an ideal symmetric geometry,
              for example if you look for a phase change due to high
              pressure.

            * **SuperCell** (*Iterable**[**int**] **| **IntListKey*)
              -- Create a supercell of the input system (only possible
              for periodic systems). The integer numbers represent the
              diagonal elements of the supercell transformation; you
              should specify as many numbers as lattice vectors (i.e.
              1 number for 1D, 2 numbers for 2D and 3 numbers for 3D
              periodic systems).

            * **SuperCellTrafo** (*Iterable**[**int**] **|
              **IntListKey*) -- Create a supercell of the input system
              (only possible for periodic systems) \vec{a}_i' = \sum_j
              T_{ij} \vec{a}_j. The integer numbers represent the
              supercell transformation T_{ij}: 1 number for 1D PBC, 4
              numbers for 2D PBC corresponding to a 2x2 matrix (order:
              (1,1),(1,2),(2,1),(2,2)) and 9 numbers for 3D PBC
              corresponding to a 3x3 matrix (order:
              (1,1),(1,2),(1,3),(2,1),(2,2),(2,3),(3,1),(3,2),(3,3)).

            * **Symmetrize** (*BoolType** | **BoolKey*) -- Symmetrizes
              a system, using either the "symmetrize_molecule" or
              "symmetrize_cell" method, depending on periodicity.

            * **SymmetrizeMoleculeTo** (*str** | **StringKey*) --
              Symmetrizes a molecule to a particular symmetry given by
              a Schoenflies symbol. Symmetrizes the atomic coordinates
              to machine precision, but does NOT rototranslate the
              molecule in any way. If the symmetrization fails, an
              error will be raised.

            * **Translate** (*Iterable**[**float**] **|
              **FloatListKey*) -- Translate all atoms by a vector.

   class _TransferIntegrals

      Configures the details of the calculation of electron and hole
      transfer integrals.

      Variables:
         * **Type** (*Literal**[**"None"**, **"DFTB"**, **"Fast"**,
           **"Full"**]*) -- The method used for the calculation of the
           transfer integrals.

         * **Exclude** (*OLEDProperties._TransferIntegrals._Exclude*)
           -- Configures which dimers NOT to calculate transfer
           integrals for.

         * **Include** (*OLEDProperties._TransferIntegrals._Include*)
           -- Configures which dimers transfer integrals are
           calculated for.

      class _Exclude

         Configures which dimers NOT to calculate transfer integrals
         for.

         Variables:
            * **Cutoff** (*float** | **FloatKey*) -- Exclude dimers
              for which the distance is larger than this threshold.
              Acts as a quick pre-screening to reduce the number of
              dimers to calculate transfer integrals for.

            * **Metric** (*Literal**[**"CoM"**, **"Atoms"**,
              **"Atoms_noH"**]*) --

              The metric used to calculate the distance between two
              molecules.

              * CoM: use the distance between the centers of mass of
                the two molecules.

              * Atoms: Use the distance between the two closest atoms
                of two molecules.

              * Atoms_noH: Use the distance between the closest non-
                hydrogen atoms of the two molecules.

      class _Include

         Configures which dimers transfer integrals are calculated
         for.

         Variables:
            * **Cutoff** (*float** | **FloatKey*) -- Transfer
              integrals will be calculated for all molecule pairs
              within a cutoff distance from each other. This distance
              can be measured using different metrics, see the
              corresponding "Metric" keyword.

            * **Metric** (*Literal**[**"CoM"**, **"Atoms"**,
              **"Atoms_noH"**]*) --

              The metric used to calculate the distance between two
              molecules.

              * CoM: use the distance between the centers of mass of
                the two molecules.

              * Atoms: Use the distance between the two closest atoms
                of two molecules.

              * Atoms_noH: Use the distance between the closest non-
                hydrogen atoms of the two molecules.

class ParAMS

   Variables:
      * **ApplyStoppersToBestOptimizer** (*BoolType** | **BoolKey*) --
        By default the stoppers are not applied to the best optimizer
        (the one who has seen the best value thus far). This is
        because many stoppers are based on comparisons to the best
        optimizer, and in most scenarios one would like to keep a
        well-performing optimizer alive. For some stopper
        configurations this paradigm does not make sense and we would
        prefer to apply the stoppers equally to all optimizers.

      * **CheckStopperInterval** (*int** | **IntKey*) -- Number of
        loss function evaluations between evaluations of the stopper
        conditions.

      * **EndTimeout** (*float** | **FloatKey*) --

        The amount of time the manager will wait trying to smoothly
        join each optimizer at the end of the run. If exceeded the
        manager will abandon the optimizer and shutdown. This can
        raise errors from the abandoned threads, but may be needed to
        ensure the manager closes and does not hang.

        This option is often needed if the Scipy optimizers are being
        used and should be set to a low value.

      * **EngineCollection** (*str** | **StringKey*) -- Path to
        (optional) JobCollection Engines YAML file.

      * **EvaluateLoss** (*BoolType** | **BoolKey*) --

        Evaluate the loss function based on the job results. This will
        produce the same output files as Task Optimization.  If No,
        this will be skipped and only the jobs will be run (and
        saved).

        Warning: If both Store Jobs and Evaluate Loss are No then this
        task will not produce any output.

      * **ExitConditionBooleanCombination** (*str** | **StringKey*) --

        If multiple ExitConditions are used, this key indicates how
        their evaluations relate to one another.

        Use an integer to refer to a exit condition (defined by order
        in input file).

        Recognizes the symbols: ( ) & |

        E.g. (1 & 2) | 3.

        Defaults to an OR combination of all selected exit conditions.

      * **FilterInfiniteValues** (*BoolType** | **BoolKey*) --

        If Yes, removes points from the calculation with non-finite
        loss values.

        Non-finite points can cause numerical issues in the
        sensitivity calculation.

      * **GlompoLogging** (*BoolType** | **BoolKey*) -- Include status
        and progress information from the optimization manager in the
        printstreams.

      * **GlompoSummaryFiles** (*Literal**[**"None"**, **"1"**,
        **"2"**, **"3"**, **"4"**]*) --

        Indicates what GloMPO-style outputs you would like saved to
        disk. Higher values also save all lower level information.

        Available options: • None: Nothing is saved. • 1: YAML file
        with summary info about the optimization settings, performance
        and the result. • 2: PNG file showing the trajectories of the
        optimizers. • 3: HDF5 file containing iteration history for
        each optimizer. • 4: More detailed HDF5 log including the
        residual results for each optimizer, data set and iteration.

      * **JobCollection** (*str** | **StringKey*) -- Path to
        JobCollection YAML file.

      * **MoreExtractorsPath** (*str** | **Path** | **StringKey*) --
        Path to directory with extractors.

      * **NumberBootstraps** (*int** | **IntKey*) --

        Number of repeats of the calculation with different sub-
        samples.

        A small spread from a large number of bootstraps provides
        confidence on the estimation of the sensitivity.

      * **NumberCalculationSamples** (*int** | **IntKey*) --

        Number of samples from the full set available to use in the
        calculation.

        If not specified or -1, uses all available points. For the
        sensitivity calculation, this will be redrawn for every
        bootstrap.

      * **NumberSamples** (*int** | **IntKey*) -- Number of samples to
        generate during the sampling procedure.

      * **PLAMSWorkingDirectory** (*str** | **Path** | **StringKey*)
        -- Path to PLAMS working directory to temporarily hold Job
        results files.

      * **ParameterInterface** (*str** | **StringKey*) -- Path to
        parameter interface YAML file.

      * **PrintStatusInterval** (*float** | **FloatKey*) -- Number of
        seconds between printing of a status summary.

      * **RandomSeed** (*int** | **IntKey*) -- Random seed to use
        during the sampling procedure (for reproducibility).

      * **RestartDirectory** (*str** | **Path** | **StringKey*) --

        Specify a directory to continue interrupted GenerateReference
        or SinglePoint calculations. The directory depends on the
        task:

        GenerateReference: results/reference_jobs SinglePoint:
        results/single_point/jobs

        Note: If you use the GUI this directory will be COPIED into
        the results folder and the name will be prepended with 'dep-'.
        This can take up a lot of disk space, so you may want to
        remove the 'dep-' folder after the job has finished.

      * **ResultsDirectory** (*str** | **Path** | **StringKey*) --
        Directory in which output files will be created.

      * **ResumeCheckpoint** (*str** | **Path** | **StringKey*) --
        Path to checkpoint file from which a previous optimization can
        be resumed.

      * **RunReweightCalculation** (*BoolType** | **BoolKey*) --

        Run a more expensive sensitivity calculation that will also
        return suggested weights for the training set which will
        produce more balanced sensitivities between all the
        parameters.

        Note: The Gaussian kernel is recommended for the loss values
        kernel in this case.

      * **RunSampling** (*BoolType** | **BoolKey*) --

        Produce a set of samples of the loss function and active
        parameters. Samples from the parameter space are drawn from a
        uniform random distribution.

        Such a set of samples serves as the input to the sensitivity
        calculation.

      * **SampleWithReplacement** (*BoolType** | **BoolKey*) --

        Sample from the available data with or without replacement.

        This only has an effect if the number of samples for the
        calculation is less than the total number available otherwise
        replace is Yes by necessity.

      * **SamplesDirectory** (*str** | **Path** | **StringKey*) --

        Path to an 'optimization' directory containing the results of
        a previously run sampling.

        First looks for a 'glompo_log.h5' file. If not found, will
        look for 'running_loss.txt' and
        'running_active_parameters.txt' in a sub-directory. The sub-
        directory used will depend on the DataSet Name.

        For the Reweight calculation only a 'glompo_log.h5' file (with
        residuals) may be used.

      * **SaveResiduals** (*BoolType** | **BoolKey*) --

        During the sampling, save the individual difference between
        reference and predicted values for every sample and training
        set item. Required for the Reweight calculation, and will be
        automatically activated if the reweight calculation is
        requested.

        Saving and analyzing the residuals can provide valuable
        insight into your training set, but can quickly occupy a large
        amount of disk space. Only save the residuals if you would
        like to run the reweight calculation or have a particular
        reason to do so.

      * **Scaler** (*Literal**[**"Linear"**, **"Std"**, **"None"**,
        **"Optimizers"**]*) --

        Type of scaling applied to the parameters. A scaled input
        space is needed by many optimization algorithms.

        Available options: • Linear: Scale all parameters between 0
        and 1. • Std: Scale all parameters between -1 and 1. • None:
        Applies no scaling. • Optimizers (Default): Does not specify a
        scaling at the manager level, but allows the selection to be
        governed by the optimizer/s. If they do not require any
        particular scaler, then 'linear' is selected as the ultimate
        fallback.

      * **SetToAnalyze** (*Literal**[**"TrainingSet"**,
        **"ValidationSet"**]*) -- Name of the data set to use for the
        sensitivity analysis.

      * **ShareBestEvaluationBetweenOptimizers** (*BoolType** |
        **BoolKey*) --

        Share new best evaluations from one optimizer to another.

        Some algorithms can use this information to accelerate their
        own convergence. However, optimizers typically have to be
        configured to receive and handle the information.

        This option can work very well with CMA-ES injections.

      * **SkipX0** (*BoolType** | **BoolKey*) --

        Do not evaluate the initial parameters before starting the
        optimization.

        If the initial parameters evaluated and do not return a finite
        loss function value, the optimization will abort. A non-
        infinite value typically indicates crashed jobs.

      * **SplitPrintstreams** (*BoolType** | **BoolKey*) -- Split
        print statements from each optimizer to separate files.

      * **StopperBooleanCombination** (*str** | **StringKey*) --

        If multiple Stoppers are used this is required to indicate how
        their evaluations relate to one another.

        Use an integer to refer to a stopper (defined by order in
        input file).

        Recognizes the symbols: ( ) & |

        E.g. (1 & 2) | 3.

        Defaults to an OR combination of all selected stoppers.

      * **StoreJobs** (*Literal**[**"Auto"**, **"Yes"**, **"No"**]*)
        --

        Keeps the results files for each of the jobs. If No, all
        pipeable jobs will be run through the AMS Pipe and no files
        will be saved (not even the ones not run through the pipe). If
        Auto, the pipeable jobs are run through the pipe and the
        results of nonpipeable jobs are saved to disk. If Yes, no jobs
        are run through the pipe and all job results are stored on
        disk.

        Warning: If both Store Jobs and Evaluate Loss are No then task
        SinglePoint will not produce any output.

      * **Task** (*Literal**[**"Optimization"**,
        **"GenerateReference"**, **"SinglePoint"**, **"Sensitivity"**,
        **"MachineLearning"**]*) --

        Task to run.

        Available options: •MachineLearning: Optimization for machine
        learning models. •Optimization: Global optimization powered by
        GloMPO •Generate Reference: Run jobs with reference engine to
        get reference values •Single Point: Evaluate the current
        configuration of jobs, training data, and parameters
        •Sensitivity: Measure the sensitivity of the loss function to
        each of the active parameters

      * **Validation** (*float** | **FloatKey*) -- Fraction of the
        training set to be used as a validation set. Will be ignored
        if a validation set has been explicitly defined.

      * **CheckpointControl** (*ParAMS._CheckpointControl*) --
        Settings to control the production of checkpoints from which
        the optimization can be resumed.

      * **Constraints** (*str** | **Sequence**[**str**] **|
        **FreeBlock*) --

        Parameter constraint rules to apply to the loss function. One
        per line. Use 'p' to reference the parameter set. You may use
        indices or names in square brackets to refer to a specific
        variable.

        Note, that indices are absolute i.e., they do not reference
        the active subset of parameters.

        Eg: p[0]>=p[2] p['O:p_boc2']==p['H:p_boc2']

      * **ControlOptimizerSpawning**
        (*ParAMS._ControlOptimizerSpawning*) -- Control the spawning
        of optimizers. Note, this is different from ExitConditions.
        These simply stop new optimizers from spawning, but leave
        existing ones untouched. ExitConditions shutdown active
        optimizers and stop the optimization.

      * **DataSet** (*ParAMS._DataSet*) -- Configuration settings for
        each data set in the optimization.

      * **Engine** (*EngineBlock*) -- If set, use this engine for the
        ParAMS SinglePoint. Mutually exclusive with EngineCollection.

      * **ExitCondition** (*ParAMS._ExitCondition*) -- A condition
        used to stop the optimization when it returns true.

      * **Generator** (*ParAMS._Generator*) -- A Generator used to
        produce x0 starting points for the optimizers.

      * **LoggingInterval** (*ParAMS._LoggingInterval*) -- Number of
        function evaluations between every log to file.

      * **LossValuesKernel** (*ParAMS._LossValuesKernel*) -- Kernel
        applied to the parameters for which sensitivity is being
        measured.

      * **MachineLearning** (*ParAMS._MachineLearning*) -- Options for
        Task MachineLearning.

      * **Optimizer** (*ParAMS._Optimizer*) -- An optimizer which may
        be used during the optimization.

      * **OptimizerSelector** (*ParAMS._OptimizerSelector*) -- If
        multiple Optimizers are included, then this block must be
        included and configures the Selector which will choose between
        them.

      * **ParallelLevels** (*ParAMS._ParallelLevels*) -- Distribution
        of threads/processes between the parallelization levels.

      * **ParametersKernel** (*ParAMS._ParametersKernel*) -- Kernel
        applied to the parameters for which sensitivity is being
        measured.

      * **Stopper** (*ParAMS._Stopper*) -- A Stopper used to terminate
        optimizers early.

   class _CheckpointControl

      Settings to control the production of checkpoints from which the
      optimization can be resumed.

      Variables:
         * **AtEnd** (*BoolType** | **BoolKey*) -- Create a checkpoint
           when the exit condition/s are triggered.

         * **AtInitialisation** (*BoolType** | **BoolKey*) -- Create a
           checkpoint immediately at the start of an optimization.

         * **CheckpointingDirectory** (*str** | **Path** |
           **StringKey*) -- Directory in which the checkpoints will be
           saved. Defaults to 'checkpoints' in the results directory

         * **EveryFunctionCalls** (*int** | **IntKey*) --

           Create a checkpoint every n function evaluations.

           If not specified or -1, checkpoints are not created based
           on function calls.

         * **EverySeconds** (*float** | **FloatKey*) --

           Create a checkpoint every n seconds.

           If not specified or -1, a checkpoint is not created based
           time.

         * **KeepPast** (*int** | **IntKey*) --

           Number of earlier checkpoints to keep. Older ones are
           deleted when a new one is created. -1 does not delete any
           previous checkpoints, and 0 retains only the most recent
           checkpoint.

           This number excludes the most recent checkpoint which is
           obviously always retained! So the actual number of files
           will be larger than this number by one.

         * **NamingFormat** (*str** | **StringKey*) --

           Convention used to name the checkpoints.

           The following special keys are supported: • %(date):
           Current calendar date in YYYYMMDD format • %(year): Year
           formatted to YYYY • %(yr): Year formatted to YY • %(month):
           Numerical month formatted to MM • %(day): Calendar day of
           the month formatted to DD • %(time): Current calendar time
           formatted to HHMMSS (24-hour style) • %(hour): Hour
           formatted to HH  (24-hour style) • %(min): Minutes
           formatted to MM • %(sec): Seconds formatted to SS •
           %(count): Index count of the number of checkpoints
           constructed. Starts at zero, formatted to 3 digits.

         * **RaiseFail** (*BoolType** | **BoolKey*) -- Raise an error
           and stop the optimization if a checkpoint fails to be
           constructed, otherwise issue a warning and continue the
           optimization.

   class _Constraints

      Parameter constraint rules to apply to the loss function. One
      per line. Use 'p' to reference the parameter set. You may use
      indices or names in square brackets to refer to a specific
      variable.

      Note, that indices are absolute i.e., they do not reference the
      active subset of parameters.

      Eg: p[0]>=p[2] p['O:p_boc2']==p['H:p_boc2']

   class _ControlOptimizerSpawning

      Control the spawning of optimizers. Note, this is different from
      ExitConditions. These simply stop new optimizers from spawning,
      but leave existing ones untouched. ExitConditions shutdown
      active optimizers and stop the optimization.

      Variables:
         * **MaxEvaluations** (*int** | **IntKey*) --

           No new optimizers will be started after this number of
           function evaluations has been used.

           Note, this is different from the equivalent exit condition
           which would terminate existing optimizers rather than
           simply not allowing new ones to spawn.

         * **MaxOptimizers** (*int** | **IntKey*) --

           No new optimizers will be started after this number has
           been spawned.

           Note, this is different from the equivalent exit condition
           which would terminate existing optimizers rather than
           simply not allowing new ones to spawn.

   class _DataSet

      Configuration settings for each data set in the optimization.

      Variables:
         * **BatchSize** (*int** | **IntKey*) -- Number of data set
           entries to be evaluated per epoch. Default 0 means all
           entries.

         * **EvaluateEvery** (*int** | **IntKey*) --

           This data set is evaluated every n evaluations of the
           training set.

           This will always be set to 1 for the training set. For
           other data sets it will be adjusted to the closest multiple
           of LoggingInterval%General, i.e., you cannot evaluate an
           extra data set more frequently than you log it.

         * **LossFunction** (*Literal**[**"mae"**, **"rmse"**,
           **"sse"**, **"sae"**]*) --

           Loss function used to quantify the error between model and
           reference values. This becomes the minimization task.

           Available options: • mae: Mean absolute error • rmse: Root
           mean squared error • sse: Sum of squared errors • sae: Sum
           of absolute errors

         * **MaxJobs** (*int** | **IntKey*) -- Limit each evaluation
           to a subset of n jobs. Default 0 meaning all jobs are used.

         * **MaxJobsShuffle** (*BoolType** | **BoolKey*) -- Use a
           different job subset every for every evaluation.

         * **Name** (*str** | **StringKey*) --

           Unique data set identifier.

           The first occurrence of DataSet will always be called
           training_set. The second will always be called
           validation_set. These cannot be overwritten.

           Later occurrences will default to data_set_xx where xx
           starts at 03 and increments from there. This field can be
           used to customize the latter names.

         * **Path** (*str** | **StringKey*) -- Path to DataSet YAML
           file.

         * **UsePipe** (*BoolType** | **BoolKey*) -- Use AMS Pipe for
           suitable jobs to speed-up evaluation.

   class _Engine

      If set, use this engine for the ParAMS SinglePoint. Mutually
      exclusive with EngineCollection.

   class _ExitCondition

      A condition used to stop the optimization when it returns true.

      Variables:
         * **MaxOptimizersConverged** (*int** | **IntKey*) --

           Return True after n optimizers have converged normally.

           An optimizer that has 'converged' is distinct from an
           optimizer that was shutdown via the Stopper settings (i.e.
           'stopped').

         * **MaxOptimizersStarted** (*int** | **IntKey*) --

           Return True after n optimizers have been started.

           Note, this is best used in combination with other
           conditions because it will stop the optimization as soon as
           the correct number have been started and not allow newly
           spawned optimizer to iterate at all.

         * **MaxOptimizersStopped** (*int** | **IntKey*) --

           Return True after n optimizers have been stopped.

           An optimizer that has been 'stopped' is distinct from an
           optimizer that stopped due to its internal convergence
           conditions (i.e., 'converged').

         * **MaxTotalFunctionCalls** (*int** | **IntKey*) -- Return
           True after n function calls have been executed.

         * **TargetFunctionValue** (*float** | **FloatKey*) -- Return
           True after an optimizer finds a function value less than or
           equal to n.

         * **TimeLimit** (*float** | **FloatKey*) --

           Return True after the entire optimization has been running
           for n seconds.

           Note, this is NOT the time for any particular optimizer.

           See also: Time Limit Through Restarts

         * **TimeLimitThroughRestarts** (*float** | **FloatKey*) --

           Return True after the sum-total of all optimization runs
           (i.e., through all restarts) has been running for n
           seconds.

           Note, this is NOT the time for any particular optimizer.

           See also: Time Limit

         * **Type** (*Literal**[**"TimeLimit"**,
           **"MaxTotalFunctionCalls"**, **"MaxOptimizersStarted"**,
           **"MaxOptimizersConverged"**, **"MaxOptimizersStopped"**,
           **"StopsAfterConvergence"**,
           **"TimeLimitThroughRestarts"**,
           **"TargetFunctionValue"**]*) --

           A condition used to stop the optimization when it returns
           true.

           Available options: • Time Limit: Limit the optimization
           walltime. • Max Function Calls: Stop the optimization after
           a certain number of loss function evaluations. • Max
           Optimizers Started: Shutdown after a certain number of
           optimizers have been spawned. • Max Optimizers Converged:
           Shutdown when optimizers have converged via their own
           internal conditions. • Max Optimizers Stopped: Shutdown
           when the Stopping configuration has resulted in a number of
           optimizers being stopped. • Stops After Convergence: Stop
           when some optimizers have converged and others have been
           stopped. • Time Limit Through Restarts: Limit the total
           cumulative walltime across multiple restarts of the
           optimization. • Target Function Value: Shutdown when a
           small enough loss function value is found.

         * **StopsAfterConvergence**
           (*ParAMS._ExitCondition._StopsAfterConvergence*) -- Returns
           True when at least n_a optimizers have been stopped *after*
           n_b optimizers have converged.

      class _StopsAfterConvergence

         Returns True when at least n_a optimizers have been stopped
         *after* n_b optimizers have converged.

         Variables:
            * **OptimizersConverged** (*int** | **IntKey*) -- Minimum
              number of converged optimizers.

            * **OptimizersStopped** (*int** | **IntKey*) -- Maximum
              number of stopped optimizers.

   class _Generator

      A Generator used to produce x0 starting points for the
      optimizers.

      Variables:
         * **Type** (*Literal**[**"Incumbent"**, **"ExploreExploit"**,
           **"Perturbation"**, **"Random"**, **"SinglePoint"**]*) --

           Algorithm used to pick starting points for the optimizers.

           Available options: • Incumbent: Optimizers will be started
           at the best point seen thus far by any optimizer. First
           point is random. • ExploreExploit: Early starting points
           are random, but later points are closer to good minima. •
           Perturbation: Each starting point is a drawn from a
           multivariate Gaussian distribution centred at the initial
           parameter set. • Random: Optimizers are started at random
           locations in parameter space. • SinglePoint: All optimizers
           are started at the initial parameter values.

         * **ExploreExploit** (*ParAMS._Generator._ExploreExploit*) --
           Blends a randomly generated point with the location of an
           existing optimizer, based on the time progress through the
           optimization. The optimizer is chosen based on a weighted
           roulette selection based on their function value. Early in
           the optimization optimizers are started randomly, and later
           they are started near previously found good minima.

         * **Perturbation** (*ParAMS._Generator._Perturbation*) --
           Randomly generates parameter vectors from a multivariate
           normal distribution around the starting parameters.

      class _ExploreExploit

         Blends a randomly generated point with the location of an
         existing optimizer, based on the time progress through the
         optimization. The optimizer is chosen based on a weighted
         roulette selection based on their function value. Early in
         the optimization optimizers are started randomly, and later
         they are started near previously found good minima.

         Variables:
            * **Focus** (*float** | **FloatKey*) -- The blend
              parameter between random point and incumbent points.
              Used as follows: p=(f_calls / max_f_calls) ** focus

            * **MaxFunctionCalls** (*int** | **IntKey*) -- Maximum
              function calls allowed for the optimization, at and
              beyond this point there is a 100% chance that a
              previously evaluated point will be returned by the
              generator. If the optimization is not limited by the
              number of function calls, provide an estimate.

      class _Perturbation

         Randomly generates parameter vectors from a multivariate
         normal distribution around the starting parameters.

         Variables:
            **StandardDeviation** (*float** | **FloatKey*) -- Standard
            deviation of the multivariate normal distribution. Used
            here to control how wide the generator should explore
            around the starting parameters.

   class _LoggingInterval

      Number of function evaluations between every log to file.

      Variables:
         * **Flush** (*int** | **IntKey*) --

           The number of function evaluations between flushes of the
           output streams to disk.

           If Flush = General, then files will be flushed after every
           logged call.

         * **General** (*int** | **IntKey*) --

           The number of function evaluations between writes to
           stdout, running_loss.txt, running_stats.txt and all
           *latest/* and *best/* files.

           This is also the interval with which the validation set
           will be evaluated and logged.

         * **History** (*int** | **IntKey*) -- The number of function
           evaluations between saves to the history directory with
           copies of latest/.

         * **Parameters** (*int** | **IntKey*) -- The number of
           function evaluations between writes to
           running_active_parameters.txt.

   class _LossValuesKernel

      Kernel applied to the parameters for which sensitivity is being
      measured.

      Variables:
         * **Alpha** (*float** | **FloatKey*) --

           Cut-off parameter for the Threshold kernel between zero and
           one.

           All loss values are scaled by taking the logarithm and then
           adjusted to a range between zero and one. This parameter is
           a value within this scaled space.

         * **Gamma** (*float** | **FloatKey*) -- Bandwidth parameter
           for the conjunctive-Gaussian kernel.

         * **Sigma** (*float** | **FloatKey*) --

           Bandwidth parameter for the Gaussian kernel.

           If not specified or -1, calculates a reasonable default
           based on the number of parameters being tested.

         * **Type** (*Literal**[**"Gaussian"**,
           **"ConjunctiveGaussian"**, **"Threshold"**,
           **"Polynomial"**, **"Linear"**]*) -- Name of the kernel to
           applied to the parameters for which sensitivity is being
           measured.

         * **Polynomial** (*ParAMS._LossValuesKernel._Polynomial*) --
           Settings for the Polynomial kernel.

      class _Polynomial

         Settings for the Polynomial kernel.

         Variables:
            * **Order** (*int** | **IntKey*) -- Maximum order of the
              polynomial.

            * **Shift** (*float** | **FloatKey*) -- Free parameter (≥
              0) trading off higher-order versus lower-order effects.

   class _MachineLearning

      Options for Task MachineLearning.

      Variables:
         * **Backend** (*Literal**[**"Custom"**, **"M3GNet"**,
           **"MACE"**, **"NequIP"**, **"Test"**]*) -- The backend to
           use. You must separately install the backend before running
           a training job.

         * **CommitteeSize** (*int** | **IntKey*) -- The number of
           independently trained ML potentials.

         * **LoadModel** (*str** | **Path** | **StringKey*) -- Load a
           previously fitted model from a ParAMS results directory. A
           ParAMS results directory should contain two subdirectories
           "optimization" and "settings_and_initial_data". This option
           ignores all settings inside model blocks.

         * **MaxEpochs** (*int** | **IntKey*) -- Set the maximum
           number of epochs a backend should perform.

         * **RunAMSAtEnd** (*BoolType** | **BoolKey*) -- Whether to
           run the (committee) ML potential through AMS at the end.
           This will create the energy/forces scatter plots for the
           final trained model.

         * **Custom** (*ParAMS._MachineLearning._Custom*) -- Set up a
           custom fitting program within ParAMS

         * **LossCoeffs** (*ParAMS._MachineLearning._LossCoeffs*) --
           Modify the coefficients for the machine learning loss
           function. For backends that support weights, this is on top
           of the supplied dataset weights and sigmas.

         * **M3GNet** (*ParAMS._MachineLearning._M3GNet*) -- Options
           for M3GNet fitting.

         * **MACE** (*ParAMS._MachineLearning._MACE*) -- Options for
           MACE fitting.

         * **NequIP** (*ParAMS._MachineLearning._NequIP*) -- Options
           for NequIP fitting.

         * **Target** (*ParAMS._MachineLearning._Target*) -- Target
           values for stopping training. If both the training and
           validation metrics are smaller than the specified values,
           the training will stop early. Only supported by the M3GNet
           backend.

      class _Custom

         Set up a custom fitting program within ParAMS

         Variables:
            * **File** (*str** | **Path** | **StringKey*) -- Python
              file containing a function called 'get_fit_job' that
              returns a subclass of 'FitJob'

            * **Arguments** (*str** | **Sequence**[**str**] **|
              **FreeBlock*) -- Pass on keyword arguments to the
              'get_fit_job' function.

         class _Arguments

            Pass on keyword arguments to the 'get_fit_job' function.

      class _LossCoeffs

         Modify the coefficients for the machine learning loss
         function. For backends that support weights, this is on top
         of the supplied dataset weights and sigmas.

         Variables:
            * **AverageForcePerAtom** (*BoolType** | **BoolKey*) --
              For each force data entry, divide the loss contribution
              by the number of concomitant atoms. This is the same as
              the behavior for ParAMS Optimization, but it is turned
              off by default in Task MachineLearning. For machine
              learning, setting this to 'No' can be better since
              larger molecules will contribute more to the loss. For
              backends that support weights, this is on top of the
              supplied dataset weights and sigmas.

            * **Energy** (*float** | **FloatKey*) -- Coefficient for
              the contribution of loss due to the energy. For backends
              that support weights, this is on top of the supplied
              dataset weights and sigmas.

            * **Forces** (*float** | **FloatKey*) -- Coefficient for
              the contribution of loss due to the forces. For backends
              that support weights, this is on top of the supplied
              dataset weights and sigmas.

      class _M3GNet

         Options for M3GNet fitting.

         Variables:
            * **LearningRate** (*float** | **FloatKey*) -- Learning
              rate for the M3GNet weight optimization.

            * **Model** (*Literal**[**"UniversalPotential"**,
              **"Custom"**, **"ModelDir"**]*) -- How to specify the
              model for the M3GNet backend. Either a Custom model can
              be made from scratch or an existing model directory can
              be loaded to obtain the model settings.

            * **ModelDir** (*str** | **Path** | **StringKey*) -- Path
              to the directory defining the model. This folder should
              contain the files: 'checkpoint',
              'm3gnet.data-00000-of-00001', ' m3gnet.index' and
              'm3gnet.json'

            * **Custom** (*ParAMS._MachineLearning._M3GNet._Custom*)
              -- Specify a custom M3GNet model.

            * **UniversalPotential**
              (*ParAMS._MachineLearning._M3GNet._UniversalPotential*)
              -- Settings for (transfer) learning with the M3GNet
              Universal Potential.

         class _Custom

            Specify a custom M3GNet model.

            Variables:
               * **Cutoff** (*float** | **FloatKey*) -- Cutoff radius
                 of the graph

               * **MaxL** (*int** | **IntKey*) -- Include spherical
                 components up to order MaxL. Higher gives a better
                 angular resolution, but increases computational cost
                 substantially.

               * **MaxN** (*int** | **IntKey*) -- Include radial
                 components up to the MaxN'th root of the spherical
                 Bessel function. Higher gives a better radial
                 resolution, but increases computational cost
                 substantially.

               * **NumBlocks** (*int** | **IntKey*) -- Number of
                 convolution blocks.

               * **NumNeurons** (*int** | **IntKey*) -- Number of
                 neurons in each layer.

               * **ThreebodyCutoff** (*float** | **FloatKey*) --
                 Cutoff radius of the three-body interaction.

         class _UniversalPotential

            Settings for (transfer) learning with the M3GNet Universal
            Potential.

            Variables:
               * **Featurizer** (*BoolType** | **BoolKey*) -- Train
                 the Featurizer layer of the M3GNet universal
                 potential.

               * **Final** (*BoolType** | **BoolKey*) -- Train the
                 Final layer of the M3GNet universal potential.

               * **GraphLayer1** (*BoolType** | **BoolKey*) -- Train
                 the first Graph layer of the M3GNet universal
                 potential.

               * **GraphLayer2** (*BoolType** | **BoolKey*) -- Train
                 the second Graph layer of the M3GNet universal
                 potential.

               * **GraphLayer3** (*BoolType** | **BoolKey*) -- Train
                 the third Graph layer of the M3GNet universal
                 potential.

               * **ThreeDInteractions1** (*BoolType** | **BoolKey*) --
                 Train the first ThreeDInteractions (three-body terms)
                 layer of the M3GNet universal potential.

               * **ThreeDInteractions2** (*BoolType** | **BoolKey*) --
                 Train the second ThreeDInteractions (three-body
                 terms) layer of the M3GNet universal potential.

               * **ThreeDInteractions3** (*BoolType** | **BoolKey*) --
                 Train the third ThreeDInteractions (three-body terms)
                 layer of the M3GNet universal potential.

               * **Version** (*Literal**[**"2022"**]*) -- Which
                 version of the M3GNet Universal Potential to use.

      class _MACE

         Options for MACE fitting.

         Variables:
            * **LearningRate** (*float** | **FloatKey*) -- Learning
              rate for the MACE weight optimization

            * **Model** (*Literal**[**"Foundation"**, **"Custom"**,
              **"ModelFile"**]*) -- How to specify the model for the
              MACE backend. A foundation model can be used, a custom
              model can be made from scratch or an existing model file
              can be loaded to obtain the model settings.

            * **ModelFile** (*str** | **Path** | **StringKey*) -- Path
              to the .model file defining the model.

            * **Custom** (*ParAMS._MachineLearning._MACE._Custom*) --
              Specify a custom MACE model.

            * **Foundation**
              (*ParAMS._MachineLearning._MACE._Foundation*) --
              Settings for (transfer) learning with the MACE
              foundation model.

            * **LossCoeffs**
              (*ParAMS._MachineLearning._MACE._LossCoeffs*) -- Modify
              the coefficients for the machine learning loss function,
              by applying scale factors to the
              MachineLearning%LossCoeffs values.

            * **StageTwo** (*ParAMS._MachineLearning._MACE._StageTwo*)
              -- Settings for stage two of training.

         class _Custom

            Specify a custom MACE model.

            Variables:
               * **DataType** (*Literal**[**"float32"**,
                 **"float64"**]*) -- Using "float32" is faster but
                 less accurate, and generally recommended for MD.
                 Conversely using "float64" is slower but more
                 accurate, and recommended for geometry optimization.

               * **LMax** (*int** | **IntKey*) -- Maximum spherical
                 harmonic order of the messages in the message passing
                 step; 0 is invariant, 1 and 2 are higher order
                 (equivariant). Defaults to "1". A higher value
                 increases accuracy, but increases model size and
                 computational cost.

               * **NumChannels** (*int** | **IntKey*) -- Number of
                 channels per angular momentum order. Defaults to
                 "128". Set to "64" for a smaller model or "256" for a
                 larger model. A higher value increases accuracy, but
                 increases model size and computational cost.

               * **RMax** (*float** | **FloatKey*) -- Distance cutoff
                 for interactions.

         class _Foundation

            Settings for (transfer) learning with the MACE foundation
            model.

            Variables:
               **Type** (*Literal**[**"MACE-MPA-0"**, **"MACE-
               MP-0-Large"**, **"MACE-MP-0-Medium"**, **"MACE-
               MP-0-Small"**]*) -- Which MACE foundation model to use.

         class _LossCoeffs

            Modify the coefficients for the machine learning loss
            function, by applying scale factors to the
            MachineLearning%LossCoeffs values.

            Variables:
               * **EnergyScaleFactor** (*float** | **FloatKey*) --
                 Scale factor to apply to the energy loss coefficient,
                 i.e. EnergyScaleFactor *
                 MachineLearning%LossCoeffs%Energy.

               * **ForcesScaleFactor** (*float** | **FloatKey*) --
                 Scale factor to apply to the forces loss coefficient
                 i.e. ForcesScaleFactor *
                 MachineLearning%LossCoeffs%Forces.

         class _StageTwo

            Settings for stage two of training.

            Variables:
               * **Enabled** (*BoolType** | **BoolKey*) -- Whether to
                 enable stage two training, defaults to "True".

               * **LearningRate** (*float** | **FloatKey*) -- Learning
                 rate for the MACE weight optimization for stage two
                 training

               * **Start** (*float** | **FloatKey*) -- When to start
                 stage two training, as a proportion of the
                 MachineLearning%MaxEpochs

               * **LossCoeffs** (*ParAMS._MachineLearning._MACE._Stag
                 eTwo._LossCoeffs*) -- Modify the coefficients for the
                 machine learning loss function for stage two
                 training, by applying scale factors to the
                 MachineLearning%LossCoeffs values.

            class _LossCoeffs

               Modify the coefficients for the machine learning loss
               function for stage two training, by applying scale
               factors to the MachineLearning%LossCoeffs values.

               Variables:
                  * **EnergyScaleFactor** (*float** | **FloatKey*) --
                    Scale factor to apply to the energy loss
                    coefficient for stage two training, i.e.
                    EnergyScaleFactor *
                    MachineLearning%LossCoeffs%Energy.

                  * **ForcesScaleFactor** (*float** | **FloatKey*) --
                    Scale factor to apply to the forces loss
                    coefficient for stage two training i.e.
                    ForcesScaleFactor *
                    MachineLearning%LossCoeffs%Forces.

      class _NequIP

         Options for NequIP fitting.

         Variables:
            * **LearningRate** (*float** | **FloatKey*) -- Learning
              rate for the NequIP weight optimization

            * **Model** (*Literal**[**"Custom"**, **"ModelFile"**]*)
              -- How to specify the model for the NequIP backend.
              Either a Custom model can be made from scratch or an
              existing 'model.pth' file can be loaded to obtain the
              model settings.

            * **ModelFile** (*str** | **Path** | **StringKey*) -- Path
              to the model.pth file defining the model.

            * **UseRescalingFromLoadedModel** (*BoolType** |
              **BoolKey*) -- When loading a model with LoadModel or
              NequiP%ModelFile do not recalculate the dataset
              rescaling but use the value from the loaded model.

            * **Custom** (*ParAMS._MachineLearning._NequIP._Custom*)
              -- Specify a custom NequIP model.

         class _Custom

            Specify a custom NequIP model.

            Variables:
               * **LMax** (*int** | **IntKey*) -- Maximum L value. 1
                 is probably high enough.

               * **MetricsKey** (*Literal**[**"training_loss"**,
                 **"validation_loss"**]*) -- Which metric to use to
                 generate the 'best' model.

               * **NumLayers** (*int** | **IntKey*) -- Number of
                 interaction layers in the NequIP neural network.

               * **RMax** (*float** | **FloatKey*) -- Distance cutoff
                 for interactions.

      class _Target

         Target values for stopping training. If both the training and
         validation metrics are smaller than the specified values, the
         training will stop early. Only supported by the M3GNet
         backend.

         Variables:
            **Forces** (*ParAMS._MachineLearning._Target._Forces*) --
            Forces (as reported by the backend)

         class _Forces

            Forces (as reported by the backend)

            Variables:
               * **Enabled** (*BoolType** | **BoolKey*) -- Whether to
                 use target values for forces.

               * **MAE** (*float** | **FloatKey*) -- MAE for forces
                 (as reported by the backend).

   class _Optimizer

      An optimizer which may be used during the optimization.

      Variables:
         * **Type** (*Literal**[**"AdaptiveRateMonteCarlo"**,
           **"CMAES"**, **"Nevergrad"**, **"Scipy"**,
           **"RandomSampling"**, **"GridSampling"**]*) --

           Name of the optimization algorithm or interface.

           Available options: • Adaptive Rate Monte Carlo • CMAES
           (Covariance Matrix Adaptation Evolutionary Strategy) •
           Nevergrad (Interface to many other algorithms) • Scipy
           (Interface to classic optimization algorithms) • Random
           Sampling (Uniform random sampling of the space for later
           analysis. NOT an actual optimizer) • Grid Sampling
           (Gridwise sampling of the parameter space for later
           analysis. NOT and actual optimizer)

         * **AdaptiveRateMonteCarlo**
           (*ParAMS._Optimizer._AdaptiveRateMonteCarlo*) -- Settings
           for the Adaptive Rate Monte-Carlo optimizer

         * **CMAES** (*ParAMS._Optimizer._CMAES*) -- Settings for the
           Covariance Matrix Adaptation Evolutionary Strategy

         * **GridSampling** (*ParAMS._Optimizer._GridSampling*) --
           Settings for grid-wise sampling of the parameter space.

         * **Nevergrad** (*ParAMS._Optimizer._Nevergrad*) -- Settings
           for the Nevergrad wrapper which gives access to many
           optimization algorithms.

         * **RandomSampling** (*ParAMS._Optimizer._RandomSampling*) --
           Settings for a totally random sampler of the parameter
           space.

         * **Scipy** (*ParAMS._Optimizer._Scipy*) -- Settings for the
           Scipy wrapper which gives access to many optimization
           algorithms. For parallel optimizations, Nevergrad is
           preferred as it provides better control options.

      class _AdaptiveRateMonteCarlo

         Settings for the Adaptive Rate Monte-Carlo optimizer

         Variables:
            * **AcceptanceTarget** (*float** | **FloatKey*) -- The
              target acceptance rate αₜ

            * **Gamma** (*float** | **FloatKey*) -- γ parameter.

            * **MoveRange** (*Iterable**[**float**] **|
              **FloatListKey*) -- List of allowed move sizes.

            * **Phi** (*float** | **FloatKey*) -- ϕ parameter.

            * **SubIterations** (*int** | **IntKey*) -- Number of sub-
              iterations (ω)

            * **SuperIterations** (*int** | **IntKey*) -- Number of
              super-iterations (κ)

      class _CMAES

         Settings for the Covariance Matrix Adaptation Evolutionary
         Strategy

         Variables:
            * **ForceInjections** (*BoolType** | **BoolKey*) --

              If Yes, injections of parameter vectors into the solver
              will be exact, guaranteeing that that solution will be
              in the next iteration's population.

              If No, the injection will result in a direction relative
              nudge towards the vector. Forcing the injecting can
              limit global exploration but non-forced injections may
              have little effect.

              See also glompo.optimizer.cmaes.injectioninterval

            * **InjectionInterval** (*int** | **IntKey*) --

              Number of iterations between injections of the incumbent
              solution into the sampled population. Defaults to 0,
              i.e., no injections are performed.

              Injections can be helpful in increasing the convergence
              speed and nudging optimizers toward a solution. This is
              a form of elitism and will limit exploration.

              Of particular interest is pairing this key with
              glompo.ShareBestEvaluationBetweenOptimizers. In this
              case the incumbent that is injected comes from other
              optimizers run in parallel. This can help nudge
              optimizers towards better solutions while dramatically
              improving convergence speed.

              See also glompo.optimizer.cmaes.forceinjections

            * **KeepFiles** (*BoolType** | **BoolKey*) -- Keep CMA
              specific history files about the state of the covariance
              matrix and other algorithm variables.

            * **MinSigma** (*float** | **FloatKey*) -- Convergence
              condition to terminate the optimization when the
              standard deviation of the sampling distribution falls
              below this value.

            * **Popsize** (*int** | **IntKey*) --

              Number of function evaluations per CMA-ES iteration.

              If not specified or -1, then the population size will
              equal the number of workers available to the optimizer.
              This is computationally efficient but not
              algorithmically efficient.

              A value of zero or one will set the population size to
              the value suggested by CMA based on the dimensionality
              of the problem. This produces the best algorithm
              performance but may be computationally inefficient if
              resources are left idling while waiting for other
              evaluations to complete.

              Note: a population of one is not allowed by CMA,
              therefore, it is changed to the algorithm default. This
              also means that giving CMA only one worker will also
              change the popsize to the algorithm default.

            * **Sampler** (*Literal**[**"full"**, **"vd"**,
              **"vkd"**]*) --

              Choice of full or restricted Gaussian sampling
              procedures.

              Options: • full: Full sampling procedure • vd:
              Restricted sampler for VD-CMA (Linear time/space
              comparison-based natural gradient optimization) • vkd:
              Restricted sampler for VkD-CMA (Time/space variant of
              CMA-ES)

            * **Sigma0** (*float** | **FloatKey*) --

              Initial standard deviation of the multivariate normal
              distribution from which trials are drawn.

              The recommended range of values for is between 0.01 and
              0.5. Lower values sample very locally and converge
              quickly, higher values sample broadly but will take a
              long time to converge.

            * **Verbose** (*BoolType** | **BoolKey*) -- Produce a
              printstream of results from within the optimizer itself.

            * **Settings** (*str** | **Sequence**[**str**] **|
              **FreeBlock*) --

              'argument value' pairs for extra CMA specific
              configuration arguments.

              See CMAOptimizer API documentation for more details on
              which options are possible.

         class _Settings

            'argument value' pairs for extra CMA specific
            configuration arguments.

            See CMAOptimizer API documentation for more details on
            which options are possible.

      class _GridSampling

         Settings for grid-wise sampling of the parameter space.

         Variables:
            **NumberOfDivisions** (*int** | **IntKey*) -- Number of
            equal sub-divisions to take for each parameter. Total
            calls is n_steps^n_parameters.

      class _Nevergrad

         Settings for the Nevergrad wrapper which gives access to many
         optimization algorithms.

         Variables:
            * **Algorithm** (*Literal**[**"ASCMA2PDEthird"**,
              **"ASCMADEQRthird"**, **"ASCMADEthird"**,
              **"AlmostRotationInvariantDE"**,
              **"AvgMetaLogRecentering"**, **"AvgMetaRecentering"**,
              **"BO"**, **"CM"**, **"CMA"**, **"CMandAS"**,
              **"CMandAS2"**, **"CMandAS3"**, **"CauchyLHSSearch"**,
              **"CauchyOnePlusOne"**, **"CauchyScrHammersleySearch"**,
              **"Cobyla"**, **"DE"**, **"DiagonalCMA"**,
              **"DiscreteOnePlusOne"**,
              **"DoubleFastGADiscreteOnePlusOne"**, **"EDA"**,
              **"ES"**, **"FCMA"**, **"HaltonSearch"**,
              **"HaltonSearchPlusMiddlePoint"**,
              **"HammersleySearch"**,
              **"HammersleySearchPlusMiddlePoint"**, **"LHSSearch"**,
              **"LargeHaltonSearch"**, **"LhsDE"**, **"MEDA"**,
              **"MPCEDA"**, **"MetaLogRecentering"**,
              **"MetaRecentering"**, **"MixES"**, **"MultiCMA"**,
              **"MultiScaleCMA"**, **"MutDE"**, **"NGO"**,
              **"NaiveIsoEMNA"**, **"NaiveTBPSA"**, **"NelderMead"**,
              **"NoisyBandit"**, **"NoisyDE"**,
              **"NoisyDiscreteOnePlusOne"**, **"NoisyOnePlusOne"**,
              **"OAvgMetaLogRecentering"**, **"ORandomSearch"**,
              **"OScrHammersleySearch"**, **"OnePlusOne"**,
              **"OptimisticDiscreteOnePlusOne"**,
              **"OptimisticNoisyOnePlusOne"**, **"PBIL"**,
              **"PCEDA"**, **"PSO"**, **"ParaPortfolio"**,
              **"Portfolio"**, **"Powell"**, **"QORandomSearch"**,
              **"QOScrHammersleySearch"**, **"QrDE"**, **"RCobyla"**,
              **"RPowell"**, **"RSQP"**, **"RandomSearch"**,
              **"RandomSearchPlusMiddlePoint"**, **"RealSpacePSO"**,
              **"RecES"**, **"RecMixES"**, **"RecMutDE"**, **"Recombi
              ningPortfolioOptimisticNoisyDiscreteOnePlusOne"**,
              **"RotationInvariantDE"**, **"SPSA"**, **"SQP"**,
              **"SQPCMA"**, **"ScrHaltonSearch"**,
              **"ScrHaltonSearchPlusMiddlePoint"**,
              **"ScrHammersleySearch"**,
              **"ScrHammersleySearchPlusMiddlePoint"**, **"Shiva"**,
              **"SplitOptimizer"**, **"TBPSA"**, **"TripleCMA"**,
              **"TwoPointsDE"**, **"cGA"**, **"chainCMAPowel"**]*) --

              Optimization strategy to use.

              See Nevergrad documentation for details of the available
              methods.

            * **Zero** (*float** | **FloatKey*) -- Function value
              below which the algorithm will terminate.

            * **Settings** (*str** | **Sequence**[**str**] **|
              **FreeBlock*) --

              'argument value' pairs for extra algorithm-specific
              configuration arguments.

              See Nevergrad API documentation for more details on
              which options are possible.

         class _Settings

            'argument value' pairs for extra algorithm-specific
            configuration arguments.

            See Nevergrad API documentation for more details on which
            options are possible.

      class _RandomSampling

         Settings for a totally random sampler of the parameter space.

         Variables:
            * **NumberOfSamples** (*int** | **IntKey*) -- Number of
              samples to generate.

            * **RandomSeed** (*int** | **IntKey*) -- Random seed to
              use for the generator. Useful for reproducibility.

      class _Scipy

         Settings for the Scipy wrapper which gives access to many
         optimization algorithms. For parallel optimizations,
         Nevergrad is preferred as it provides better control options.

         Variables:
            * **Algorithm** (*Literal**[**"Nelder-Mead"**,
              **"Powell"**, **"CG"**, **"BFGS"**, **"Newton-CG"**,
              **"L-BFGS-B"**, **"TNC"**, **"COBYLA"**, **"SLSQP"**,
              **"trust-constr"**, **"dogleg"**, **"trust-ncg"**,
              **"trust-exact"**, **"trust-krylov"**]*) --

              Optimization strategy to use.

              See Scipy documentation for details of the available
              methods.

            * **Hessian** (*Literal**[**"2-point"**, **"3-point"**,
              **"cs"**]*) -- Choice of the Hessian estimation method.
              Only for Newton-CG, dogleg, trust-ncg, trust-krylov,
              trust-exact and trust-constr.

            * **Jacobian** (*Literal**[**"2-point"**, **"3-point"**,
              **"cs"**]*) -- Choice of gradient estimation method.
              Only for CG, BFGS, Newton-CG, L-BFGS-B, TNC, SLSQP,
              dogleg, trust-ncg, trust-krylov, trust-exact and trust-
              constr.

            * **Tolerance** (*float** | **FloatKey*) -- Tolerance for
              termination. Interpretation linked to chosen method. See
              Scipy docs.

            * **Settings** (*str** | **Sequence**[**str**] **|
              **FreeBlock*) --

              'argument value' pairs for extra algorithm-specific
              configuration arguments.

              See Scipy API documentation for more details on which
              options are possible.

         class _Settings

            'argument value' pairs for extra algorithm-specific
            configuration arguments.

            See Scipy API documentation for more details on which
            options are possible.

   class _OptimizerSelector

      If multiple Optimizers are included, then this block must be
      included and configures the Selector which will choose between
      them.

      Variables:
         * **Type** (*Literal**[**"Cycle"**, **"Random"**,
           **"Chain"**]*) --

           Name of the algorithm selecting between optimizers.

           Available options: • Cycle (Default): Sequential loop
           through available optimizers. • Random: Optimizers are
           selected randomly from the available options. • Chain:
           Time-based progression through the list of available
           optimizers. The next option will be started once a certain
           number of loss function evaluations have been used.

         * **Chain** (*ParAMS._OptimizerSelector._Chain*) -- Start
           different optimizers at different points in time based on
           the number of function evaluations used.

      class _Chain

         Start different optimizers at different points in time based
         on the number of function evaluations used.

         Variables:
            **Thresholds** (*Iterable**[**int**] **| **IntListKey*) --
            List of loss function evaluation thresholds which switch
            to the next optimizer in the list. If there are n
            optimizers available, then this list should have n-1
            thresholds.

   class _ParallelLevels

      Distribution of threads/processes between the parallelization
      levels.

      Variables:
         * **CommitteeMembers** (*int** | **IntKey*) -- Maximum number
           of committee member optimizations to run in parallel. If
           set to zero will take the minimum of
           MachineLearning%CommitteeSize and the number of available
           cores (NSCM)

         * **Cores** (*int** | **IntKey*) -- Number of cores to use
           per committee member optimization. By default (0) the
           available cores (NSCM) divided equally among committee
           members. When using GPU offloading, consider setting this
           to 1.

         * **Jobs** (*int** | **IntKey*) -- Number of JobCollection
           jobs to run in parallel for each loss function evaluation.

         * **Optimizations** (*int** | **IntKey*) -- Number of
           independent optimizers to run in parallel.

         * **ParameterVectors** (*int** | **IntKey*) --

           Number of parameter vectors to try in parallel for each
           optimizer iteration. This level of parallelism can only be
           used with optimizers that support parallel optimization!

           Default (0) will set this value to the number of cores on
           the system divided by the number of optimizers run in
           parallel, i.e., each optimizer will be given an equal share
           of the resources.

         * **Processes** (*int** | **IntKey*) --

           Number of processes (MPI ranks) to spawn for each
           JobCollection job. This effectively sets the NSCM
           environment variable for each job.

           A value of *-1* will disable explicit setting of related
           variables. We recommend a value of *1* in almost all cases.
           A value greater than 1 would only be useful if you
           parametrize DFTB with a serial optimizer and have very few
           jobs in the job collection.

         * **Threads** (*int** | **IntKey*) --

           Number of threads to use for each of the processes. This
           effectively set the OMP_NUM_THREADS environment variable.
           Note that the DFTB engine does not use threads, so the
           value of this variable would not have any effect. We
           recommend always leaving it at the default value of 1.
           Please consult the manual of the engine you are
           parameterizing.

           A value of *-1* will disable explicit setting of related
           variables.

   class _ParametersKernel

      Kernel applied to the parameters for which sensitivity is being
      measured.

      Variables:
         * **Alpha** (*float** | **FloatKey*) --

           Cut-off parameter for the Threshold kernel between zero and
           one.

           All loss values are scaled by taking the logarithm and then
           adjusted to a range between zero and one. This parameter is
           a value within this scaled space.

         * **Gamma** (*float** | **FloatKey*) -- Bandwidth parameter
           for the conjunctive-Gaussian kernel.

         * **Sigma** (*float** | **FloatKey*) -- Bandwidth parameter
           for the Gaussian kernel.

         * **Type** (*Literal**[**"Gaussian"**,
           **"ConjunctiveGaussian"**, **"Threshold"**,
           **"Polynomial"**, **"Linear"**]*) -- Name of the kernel to
           applied to the parameters for which sensitivity is being
           measured.

         * **Polynomial** (*ParAMS._ParametersKernel._Polynomial*) --
           Settings for the Polynomial kernel.

      class _Polynomial

         Settings for the Polynomial kernel.

         Variables:
            * **Order** (*int** | **IntKey*) -- Maximum order of the
              polynomial.

            * **Shift** (*float** | **FloatKey*) -- Free parameter (≥
              0) trading off higher-order versus lower-order effects.

   class _Stopper

      A Stopper used to terminate optimizers early.

      Variables:
         * **MaxFunctionCalls** (*int** | **IntKey*) --

           Returns True after an optimizer has evaluated at least n
           points.

           Use in an AND combination with other stoppers to keep
           optimizers alive for at least some period of time, or alone
           or in an OR combination to shut them down after some period
           of time.

         * **MaxSequentialInvalidPoints** (*int** | **IntKey*) --
           Return True if the optimizer has failed to find a finite
           function value in the last n iterations. Usually indicates
           a lost optimizer with poor starting point.

         * **OptimizerType** (*Literal**[**"AdaptiveRateMonteCarlo"**,
           **"CMAES"**, **"Nevergrad"**, **"Scipy"**,
           **"RandomSampling"**, **"GridSampling"**]*) -- Intended for
           use with other stoppers to allow for specific hunting
           conditions based on the type of optimizer.

         * **Type** (*Literal**[**"BestFunctionValueUnmoving"**,
           **"CurrentFunctionValueUnmoving"**,
           **"MaxSequentialInvalidPoints"**, **"MaxFunctionCalls"**,
           **"MaxInteroptimizerDistance"**, **"MinStepSize"**,
           **"TimeAnnealing"**, **"OptimizerType"**,
           **"ValueAnnealing"**, **"ValidationWorsening"**]*) --

           Conditions used to stop individual optimizers. Only
           optimizers which have not seen the current best value will
           be hunted. The 'best' optimizer will always be left alive.

           Available options: • Best Function Value Unmoving: Shutdown
           optimizers who haven't improved their best point in a long
           time. • Current Function Value Unmoving: Shutdown
           optimizers which have not changed their currently explored
           loss function value a lot in a long time. • Max Sequential
           Invalid Points: Stop optimizers that are stuck in areas of
           parameter space which return non-finite loss function
           values. • Max Function Calls: Stop optimizers when they
           have evaluated the loss function a certain number of times.
           • Max Interoptimizer Distance: Stop optimizers too close
           together in parameter space. • Min Step Size: Stop
           optimizers who are taking very small steps between
           iterations. • Time Annealing: For use with other
           conditions. Keep an optimizer alive for longer if it's
           relatively new. • Optimizer Type: For use with other
           conditions. Shutdown optimizers of a specific type. • Value
           Annealing: For use with other conditions. Keep an optimizer
           alive if it looks likely to overtake the best optimizer. •
           Validation Worsening: Stops optimizers which are evaluating
           points where the validation set loss value is worse than
           the average of several previously seen ones.

         * **BestFunctionValueUnmoving**
           (*ParAMS._Stopper._BestFunctionValueUnmoving*) -- Return
           True if an optimizer's best value has not improved
           significantly in a given amount of time.

         * **CurrentFunctionValueUnmoving**
           (*ParAMS._Stopper._CurrentFunctionValueUnmoving*) -- Return
           True if an optimizer's current function value has not
           improved significantly in a given amount of time.

         * **MaxInteroptimizerDistance**
           (*ParAMS._Stopper._MaxInteroptimizerDistance*) -- Return
           True if two optimizers are evaluating points too close to
           one another in parameter space.

         * **MinStepSize** (*ParAMS._Stopper._MinStepSize*) -- Return
           True if an optimizer's step size between evaluations is too
           small.

         * **TimeAnnealing** (*ParAMS._Stopper._TimeAnnealing*) --
           Keeps optimizers alive based on how long they have been
           alive. Randomly keeps optimizers alive based on how long
           (in function evaluations) they have been active. The newer
           an optimizer is, the more likely it will pass the test and
           be kept alive. Used to temper very strict termination
           conditions.

         * **ValidationWorsening**
           (*ParAMS._Stopper._ValidationWorsening*) -- Return True if
           the loss value of the validation set is increasing.

         * **ValueAnnealing** (*ParAMS._Stopper._ValueAnnealing*) --
           Intended for use with other stoppers. This condition is
           unlikely to stop a victim which has a loss function value
           very near the best seen thus far, but the probability of
           stopping increases with the difference between them.

      class _BestFunctionValueUnmoving

         Return True if an optimizer's best value has not improved
         significantly in a given amount of time.

         Variables:
            * **NumberOfFunctionCalls** (*int** | **IntKey*) -- Number
              of function evaluations between comparison points.

            * **Tolerance** (*float** | **FloatKey*) -- Function
              tolerance fraction between 0 and 1.

      class _CurrentFunctionValueUnmoving

         Return True if an optimizer's current function value has not
         improved significantly in a given amount of time.

         Variables:
            * **NumberOfFunctionCalls** (*int** | **IntKey*) -- Number
              of function evaluations between comparison points.

            * **Tolerance** (*float** | **FloatKey*) -- Function
              tolerance fraction between 0 and 1.

      class _MaxInteroptimizerDistance

         Return True if two optimizers are evaluating points too close
         to one another in parameter space.

         Variables:
            * **CompareAllOptimizers** (*BoolType** | **BoolKey*) --
              If Yes the distance between all optimizer combinations
              are compared, otherwise worse optimizers are only
              compared to the best one.

            * **MaxRelativeDistance** (*float** | **FloatKey*) --
              Fraction (between 0 and 1) of the maximum distance in
              the space (from the point at all lower bounds to the
              point at all upper bounds) below which the optimizers
              are deemed too close and the victim will be stopped.

      class _MinStepSize

         Return True if an optimizer's step size between evaluations
         is too small.

         Variables:
            * **NumberOfFunctionCalls** (*int** | **IntKey*) -- Number
              of function evaluations between comparison points.

            * **Tolerance** (*float** | **FloatKey*) -- Fraction
              (between 0 and 1) of the maximum distance in the space
              (from the point at all lower bounds to the point at all
              upper bounds)

      class _TimeAnnealing

         Keeps optimizers alive based on how long they have been
         alive. Randomly keeps optimizers alive based on how long (in
         function evaluations) they have been active. The newer an
         optimizer is, the more likely it will pass the test and be
         kept alive. Used to temper very strict termination
         conditions.

         Variables:
            **CriticalRatio** (*float** | **FloatKey*) -- Critical
            ratio of function calls between stopper and victim above
            which the victim is guaranteed to survive. Values lower
            than one are looser and allow the victim to survive even
            if it has been in operation longer than the stopper.
            Values higher than one are stricter and may stop the
            victim even if it has iterated fewer times than the
            stopper.

      class _ValidationWorsening

         Return True if the loss value of the validation set is
         increasing.

         Variables:
            * **NumberOfFunctionCalls** (*int** | **IntKey*) -- Number
              of function evaluations between comparison points.

            * **Tolerance** (*float** | **FloatKey*) -- The loss value
              (f) is modified by: f * (1 + *tol*). This can also be
              used to ignore the effects of mild fluctuations.

      class _ValueAnnealing

         Intended for use with other stoppers. This condition is
         unlikely to stop a victim which has a loss function value
         very near the best seen thus far, but the probability of
         stopping increases with the difference between them.

         Variables:
            **CriticalStopChance** (*float** | **FloatKey*) -- Value
            is the probability of stopping a victim which is twice as
            large as the stopper in absolute value. The default is
            50%.

class ParAMSGenerateReference

   Variables:
      * **EngineCollection** (*str** | **StringKey*) -- Path to
        (optional) JobCollection Engines YAML file.

      * **JobCollection** (*str** | **StringKey*) -- Path to
        JobCollection YAML file.

      * **ParameterInterface** (*str** | **StringKey*) -- Path to
        parameter interface YAML file.

      * **RestartDirectory** (*str** | **Path** | **StringKey*) --

        Specify a directory to continue interrupted GenerateReference
        or SinglePoint calculations. The directory depends on the
        task:

        GenerateReference: results/reference_jobs SinglePoint:
        results/single_point/jobs

        Note: If you use the GUI this directory will be COPIED into
        the results folder and the name will be prepended with 'dep-'.
        This can take up a lot of disk space, so you may want to
        remove the 'dep-' folder after the job has finished.

      * **ResultsDirectory** (*str** | **Path** | **StringKey*) --
        Directory in which output files will be created.

      * **Task** (*Literal**[**"Optimization"**,
        **"GenerateReference"**, **"SinglePoint"**, **"Sensitivity"**,
        **"MachineLearning"**]*) --

        Task to run.

        Available options: •MachineLearning: Optimization for machine
        learning models. •Optimization: Global optimization powered by
        GloMPO •Generate Reference: Run jobs with reference engine to
        get reference values •Single Point: Evaluate the current
        configuration of jobs, training data, and parameters
        •Sensitivity: Measure the sensitivity of the loss function to
        each of the active parameters

      * **DataSet** (*ParAMSGenerateReference._DataSet*) --
        Configuration settings for each data set in the optimization.

      * **ParallelLevels** (*ParAMSGenerateReference._ParallelLevels*)
        -- Distribution of threads/processes between the
        parallelization levels.

   class _DataSet

      Configuration settings for each data set in the optimization.

      Variables:
         * **BatchSize** (*int** | **IntKey*) -- Number of data set
           entries to be evaluated per epoch. Default 0 means all
           entries.

         * **EvaluateEvery** (*int** | **IntKey*) --

           This data set is evaluated every n evaluations of the
           training set.

           This will always be set to 1 for the training set. For
           other data sets it will be adjusted to the closest multiple
           of LoggingInterval%General, i.e., you cannot evaluate an
           extra data set more frequently than you log it.

         * **LossFunction** (*Literal**[**"mae"**, **"rmse"**,
           **"sse"**, **"sae"**]*) --

           Loss function used to quantify the error between model and
           reference values. This becomes the minimization task.

           Available options: • mae: Mean absolute error • rmse: Root
           mean squared error • sse: Sum of squared errors • sae: Sum
           of absolute errors

         * **MaxJobs** (*int** | **IntKey*) -- Limit each evaluation
           to a subset of n jobs. Default 0 meaning all jobs are used.

         * **MaxJobsShuffle** (*BoolType** | **BoolKey*) -- Use a
           different job subset every for every evaluation.

         * **Name** (*str** | **StringKey*) --

           Unique data set identifier.

           The first occurrence of DataSet will always be called
           training_set. The second will always be called
           validation_set. These cannot be overwritten.

           Later occurrences will default to data_set_xx where xx
           starts at 03 and increments from there. This field can be
           used to customize the latter names.

         * **Path** (*str** | **StringKey*) -- Path to DataSet YAML
           file.

         * **UsePipe** (*BoolType** | **BoolKey*) -- Use AMS Pipe for
           suitable jobs to speed-up evaluation.

   class _ParallelLevels

      Distribution of threads/processes between the parallelization
      levels.

      Variables:
         * **CommitteeMembers** (*int** | **IntKey*) -- Maximum number
           of committee member optimizations to run in parallel. If
           set to zero will take the minimum of
           MachineLearning%CommitteeSize and the number of available
           cores (NSCM)

         * **Cores** (*int** | **IntKey*) -- Number of cores to use
           per committee member optimization. By default (0) the
           available cores (NSCM) divided equally among committee
           members. When using GPU offloading, consider setting this
           to 1.

         * **Jobs** (*int** | **IntKey*) -- Number of JobCollection
           jobs to run in parallel for each loss function evaluation.

         * **Optimizations** (*int** | **IntKey*) -- Number of
           independent optimizers to run in parallel.

         * **ParameterVectors** (*int** | **IntKey*) --

           Number of parameter vectors to try in parallel for each
           optimizer iteration. This level of parallelism can only be
           used with optimizers that support parallel optimization!

           Default (0) will set this value to the number of cores on
           the system divided by the number of optimizers run in
           parallel, i.e., each optimizer will be given an equal share
           of the resources.

         * **Processes** (*int** | **IntKey*) --

           Number of processes (MPI ranks) to spawn for each
           JobCollection job. This effectively sets the NSCM
           environment variable for each job.

           A value of *-1* will disable explicit setting of related
           variables. We recommend a value of *1* in almost all cases.
           A value greater than 1 would only be useful if you
           parametrize DFTB with a serial optimizer and have very few
           jobs in the job collection.

         * **Threads** (*int** | **IntKey*) --

           Number of threads to use for each of the processes. This
           effectively set the OMP_NUM_THREADS environment variable.
           Note that the DFTB engine does not use threads, so the
           value of this variable would not have any effect. We
           recommend always leaving it at the default value of 1.
           Please consult the manual of the engine you are
           parameterizing.

           A value of *-1* will disable explicit setting of related
           variables.

class ParAMSMachineLearning

   Variables:
      * **EngineCollection** (*str** | **StringKey*) -- Path to
        (optional) JobCollection Engines YAML file.

      * **JobCollection** (*str** | **StringKey*) -- Path to
        JobCollection YAML file.

      * **ResultsDirectory** (*str** | **Path** | **StringKey*) --
        Directory in which output files will be created.

      * **Task** (*Literal**[**"Optimization"**,
        **"GenerateReference"**, **"SinglePoint"**, **"Sensitivity"**,
        **"MachineLearning"**]*) --

        Task to run.

        Available options: •MachineLearning: Optimization for machine
        learning models. •Optimization: Global optimization powered by
        GloMPO •Generate Reference: Run jobs with reference engine to
        get reference values •Single Point: Evaluate the current
        configuration of jobs, training data, and parameters
        •Sensitivity: Measure the sensitivity of the loss function to
        each of the active parameters

      * **DataSet** (*ParAMSMachineLearning._DataSet*) --
        Configuration settings for each data set in the optimization.

      * **MachineLearning** (*ParAMSMachineLearning._MachineLearning*)
        -- Options for Task MachineLearning.

      * **ParallelLevels** (*ParAMSMachineLearning._ParallelLevels*)
        -- Distribution of threads/processes between the
        parallelization levels.

   class _DataSet

      Configuration settings for each data set in the optimization.

      Variables:
         * **BatchSize** (*int** | **IntKey*) -- Number of data set
           entries to be evaluated per epoch. Default 0 means all
           entries.

         * **EvaluateEvery** (*int** | **IntKey*) --

           This data set is evaluated every n evaluations of the
           training set.

           This will always be set to 1 for the training set. For
           other data sets it will be adjusted to the closest multiple
           of LoggingInterval%General, i.e., you cannot evaluate an
           extra data set more frequently than you log it.

         * **LossFunction** (*Literal**[**"mae"**, **"rmse"**,
           **"sse"**, **"sae"**]*) --

           Loss function used to quantify the error between model and
           reference values. This becomes the minimization task.

           Available options: • mae: Mean absolute error • rmse: Root
           mean squared error • sse: Sum of squared errors • sae: Sum
           of absolute errors

         * **MaxJobs** (*int** | **IntKey*) -- Limit each evaluation
           to a subset of n jobs. Default 0 meaning all jobs are used.

         * **MaxJobsShuffle** (*BoolType** | **BoolKey*) -- Use a
           different job subset every for every evaluation.

         * **Name** (*str** | **StringKey*) --

           Unique data set identifier.

           The first occurrence of DataSet will always be called
           training_set. The second will always be called
           validation_set. These cannot be overwritten.

           Later occurrences will default to data_set_xx where xx
           starts at 03 and increments from there. This field can be
           used to customize the latter names.

         * **Path** (*str** | **StringKey*) -- Path to DataSet YAML
           file.

         * **UsePipe** (*BoolType** | **BoolKey*) -- Use AMS Pipe for
           suitable jobs to speed-up evaluation.

   class _MachineLearning

      Options for Task MachineLearning.

      Variables:
         * **Backend** (*Literal**[**"Custom"**, **"M3GNet"**,
           **"MACE"**, **"NequIP"**, **"Test"**]*) -- The backend to
           use. You must separately install the backend before running
           a training job.

         * **CommitteeSize** (*int** | **IntKey*) -- The number of
           independently trained ML potentials.

         * **LoadModel** (*str** | **Path** | **StringKey*) -- Load a
           previously fitted model from a ParAMS results directory. A
           ParAMS results directory should contain two subdirectories
           "optimization" and "settings_and_initial_data". This option
           ignores all settings inside model blocks.

         * **MaxEpochs** (*int** | **IntKey*) -- Set the maximum
           number of epochs a backend should perform.

         * **RunAMSAtEnd** (*BoolType** | **BoolKey*) -- Whether to
           run the (committee) ML potential through AMS at the end.
           This will create the energy/forces scatter plots for the
           final trained model.

         * **Custom**
           (*ParAMSMachineLearning._MachineLearning._Custom*) -- Set
           up a custom fitting program within ParAMS

         * **LossCoeffs**
           (*ParAMSMachineLearning._MachineLearning._LossCoeffs*) --
           Modify the coefficients for the machine learning loss
           function. For backends that support weights, this is on top
           of the supplied dataset weights and sigmas.

         * **M3GNet**
           (*ParAMSMachineLearning._MachineLearning._M3GNet*) --
           Options for M3GNet fitting.

         * **MACE** (*ParAMSMachineLearning._MachineLearning._MACE*)
           -- Options for MACE fitting.

         * **NequIP**
           (*ParAMSMachineLearning._MachineLearning._NequIP*) --
           Options for NequIP fitting.

         * **Target**
           (*ParAMSMachineLearning._MachineLearning._Target*) --
           Target values for stopping training. If both the training
           and validation metrics are smaller than the specified
           values, the training will stop early. Only supported by the
           M3GNet backend.

      class _Custom

         Set up a custom fitting program within ParAMS

         Variables:
            * **File** (*str** | **Path** | **StringKey*) -- Python
              file containing a function called 'get_fit_job' that
              returns a subclass of 'FitJob'

            * **Arguments** (*str** | **Sequence**[**str**] **|
              **FreeBlock*) -- Pass on keyword arguments to the
              'get_fit_job' function.

         class _Arguments

            Pass on keyword arguments to the 'get_fit_job' function.

      class _LossCoeffs

         Modify the coefficients for the machine learning loss
         function. For backends that support weights, this is on top
         of the supplied dataset weights and sigmas.

         Variables:
            * **AverageForcePerAtom** (*BoolType** | **BoolKey*) --
              For each force data entry, divide the loss contribution
              by the number of concomitant atoms. This is the same as
              the behavior for ParAMS Optimization, but it is turned
              off by default in Task MachineLearning. For machine
              learning, setting this to 'No' can be better since
              larger molecules will contribute more to the loss. For
              backends that support weights, this is on top of the
              supplied dataset weights and sigmas.

            * **Energy** (*float** | **FloatKey*) -- Coefficient for
              the contribution of loss due to the energy. For backends
              that support weights, this is on top of the supplied
              dataset weights and sigmas.

            * **Forces** (*float** | **FloatKey*) -- Coefficient for
              the contribution of loss due to the forces. For backends
              that support weights, this is on top of the supplied
              dataset weights and sigmas.

      class _M3GNet

         Options for M3GNet fitting.

         Variables:
            * **LearningRate** (*float** | **FloatKey*) -- Learning
              rate for the M3GNet weight optimization.

            * **Model** (*Literal**[**"UniversalPotential"**,
              **"Custom"**, **"ModelDir"**]*) -- How to specify the
              model for the M3GNet backend. Either a Custom model can
              be made from scratch or an existing model directory can
              be loaded to obtain the model settings.

            * **ModelDir** (*str** | **Path** | **StringKey*) -- Path
              to the directory defining the model. This folder should
              contain the files: 'checkpoint',
              'm3gnet.data-00000-of-00001', ' m3gnet.index' and
              'm3gnet.json'

            * **Custom** (*ParAMSMachineLearning._MachineLearning._M3
              GNet._Custom*) -- Specify a custom M3GNet model.

            * **UniversalPotential** (*ParAMSMachineLearning._Machine
              Learning._M3GNet._UniversalPotential*) -- Settings for
              (transfer) learning with the M3GNet Universal Potential.

         class _Custom

            Specify a custom M3GNet model.

            Variables:
               * **Cutoff** (*float** | **FloatKey*) -- Cutoff radius
                 of the graph

               * **MaxL** (*int** | **IntKey*) -- Include spherical
                 components up to order MaxL. Higher gives a better
                 angular resolution, but increases computational cost
                 substantially.

               * **MaxN** (*int** | **IntKey*) -- Include radial
                 components up to the MaxN'th root of the spherical
                 Bessel function. Higher gives a better radial
                 resolution, but increases computational cost
                 substantially.

               * **NumBlocks** (*int** | **IntKey*) -- Number of
                 convolution blocks.

               * **NumNeurons** (*int** | **IntKey*) -- Number of
                 neurons in each layer.

               * **ThreebodyCutoff** (*float** | **FloatKey*) --
                 Cutoff radius of the three-body interaction.

         class _UniversalPotential

            Settings for (transfer) learning with the M3GNet Universal
            Potential.

            Variables:
               * **Featurizer** (*BoolType** | **BoolKey*) -- Train
                 the Featurizer layer of the M3GNet universal
                 potential.

               * **Final** (*BoolType** | **BoolKey*) -- Train the
                 Final layer of the M3GNet universal potential.

               * **GraphLayer1** (*BoolType** | **BoolKey*) -- Train
                 the first Graph layer of the M3GNet universal
                 potential.

               * **GraphLayer2** (*BoolType** | **BoolKey*) -- Train
                 the second Graph layer of the M3GNet universal
                 potential.

               * **GraphLayer3** (*BoolType** | **BoolKey*) -- Train
                 the third Graph layer of the M3GNet universal
                 potential.

               * **ThreeDInteractions1** (*BoolType** | **BoolKey*) --
                 Train the first ThreeDInteractions (three-body terms)
                 layer of the M3GNet universal potential.

               * **ThreeDInteractions2** (*BoolType** | **BoolKey*) --
                 Train the second ThreeDInteractions (three-body
                 terms) layer of the M3GNet universal potential.

               * **ThreeDInteractions3** (*BoolType** | **BoolKey*) --
                 Train the third ThreeDInteractions (three-body terms)
                 layer of the M3GNet universal potential.

               * **Version** (*Literal**[**"2022"**]*) -- Which
                 version of the M3GNet Universal Potential to use.

      class _MACE

         Options for MACE fitting.

         Variables:
            * **LearningRate** (*float** | **FloatKey*) -- Learning
              rate for the MACE weight optimization

            * **Model** (*Literal**[**"Foundation"**, **"Custom"**,
              **"ModelFile"**]*) -- How to specify the model for the
              MACE backend. A foundation model can be used, a custom
              model can be made from scratch or an existing model file
              can be loaded to obtain the model settings.

            * **ModelFile** (*str** | **Path** | **StringKey*) -- Path
              to the .model file defining the model.

            * **Custom**
              (*ParAMSMachineLearning._MachineLearning._MACE._Custom*)
              -- Specify a custom MACE model.

            * **Foundation** (*ParAMSMachineLearning._MachineLearning
              ._MACE._Foundation*) -- Settings for (transfer) learning
              with the MACE foundation model.

            * **LossCoeffs** (*ParAMSMachineLearning._MachineLearning
              ._MACE._LossCoeffs*) -- Modify the coefficients for the
              machine learning loss function, by applying scale
              factors to the MachineLearning%LossCoeffs values.

            * **StageTwo** (*ParAMSMachineLearning._MachineLearning._
              MACE._StageTwo*) -- Settings for stage two of training.

         class _Custom

            Specify a custom MACE model.

            Variables:
               * **DataType** (*Literal**[**"float32"**,
                 **"float64"**]*) -- Using "float32" is faster but
                 less accurate, and generally recommended for MD.
                 Conversely using "float64" is slower but more
                 accurate, and recommended for geometry optimization.

               * **LMax** (*int** | **IntKey*) -- Maximum spherical
                 harmonic order of the messages in the message passing
                 step; 0 is invariant, 1 and 2 are higher order
                 (equivariant). Defaults to "1". A higher value
                 increases accuracy, but increases model size and
                 computational cost.

               * **NumChannels** (*int** | **IntKey*) -- Number of
                 channels per angular momentum order. Defaults to
                 "128". Set to "64" for a smaller model or "256" for a
                 larger model. A higher value increases accuracy, but
                 increases model size and computational cost.

               * **RMax** (*float** | **FloatKey*) -- Distance cutoff
                 for interactions.

         class _Foundation

            Settings for (transfer) learning with the MACE foundation
            model.

            Variables:
               **Type** (*Literal**[**"MACE-MPA-0"**, **"MACE-
               MP-0-Large"**, **"MACE-MP-0-Medium"**, **"MACE-
               MP-0-Small"**]*) -- Which MACE foundation model to use.

         class _LossCoeffs

            Modify the coefficients for the machine learning loss
            function, by applying scale factors to the
            MachineLearning%LossCoeffs values.

            Variables:
               * **EnergyScaleFactor** (*float** | **FloatKey*) --
                 Scale factor to apply to the energy loss coefficient,
                 i.e. EnergyScaleFactor *
                 MachineLearning%LossCoeffs%Energy.

               * **ForcesScaleFactor** (*float** | **FloatKey*) --
                 Scale factor to apply to the forces loss coefficient
                 i.e. ForcesScaleFactor *
                 MachineLearning%LossCoeffs%Forces.

         class _StageTwo

            Settings for stage two of training.

            Variables:
               * **Enabled** (*BoolType** | **BoolKey*) -- Whether to
                 enable stage two training, defaults to "True".

               * **LearningRate** (*float** | **FloatKey*) -- Learning
                 rate for the MACE weight optimization for stage two
                 training

               * **Start** (*float** | **FloatKey*) -- When to start
                 stage two training, as a proportion of the
                 MachineLearning%MaxEpochs

               * **LossCoeffs** (*ParAMSMachineLearning._MachineLearn
                 ing._MACE._StageTwo._LossCoeffs*) -- Modify the
                 coefficients for the machine learning loss function
                 for stage two training, by applying scale factors to
                 the MachineLearning%LossCoeffs values.

            class _LossCoeffs

               Modify the coefficients for the machine learning loss
               function for stage two training, by applying scale
               factors to the MachineLearning%LossCoeffs values.

               Variables:
                  * **EnergyScaleFactor** (*float** | **FloatKey*) --
                    Scale factor to apply to the energy loss
                    coefficient for stage two training, i.e.
                    EnergyScaleFactor *
                    MachineLearning%LossCoeffs%Energy.

                  * **ForcesScaleFactor** (*float** | **FloatKey*) --
                    Scale factor to apply to the forces loss
                    coefficient for stage two training i.e.
                    ForcesScaleFactor *
                    MachineLearning%LossCoeffs%Forces.

      class _NequIP

         Options for NequIP fitting.

         Variables:
            * **LearningRate** (*float** | **FloatKey*) -- Learning
              rate for the NequIP weight optimization

            * **Model** (*Literal**[**"Custom"**, **"ModelFile"**]*)
              -- How to specify the model for the NequIP backend.
              Either a Custom model can be made from scratch or an
              existing 'model.pth' file can be loaded to obtain the
              model settings.

            * **ModelFile** (*str** | **Path** | **StringKey*) -- Path
              to the model.pth file defining the model.

            * **UseRescalingFromLoadedModel** (*BoolType** |
              **BoolKey*) -- When loading a model with LoadModel or
              NequiP%ModelFile do not recalculate the dataset
              rescaling but use the value from the loaded model.

            * **Custom** (*ParAMSMachineLearning._MachineLearning._Ne
              quIP._Custom*) -- Specify a custom NequIP model.

         class _Custom

            Specify a custom NequIP model.

            Variables:
               * **LMax** (*int** | **IntKey*) -- Maximum L value. 1
                 is probably high enough.

               * **MetricsKey** (*Literal**[**"training_loss"**,
                 **"validation_loss"**]*) -- Which metric to use to
                 generate the 'best' model.

               * **NumLayers** (*int** | **IntKey*) -- Number of
                 interaction layers in the NequIP neural network.

               * **RMax** (*float** | **FloatKey*) -- Distance cutoff
                 for interactions.

      class _Target

         Target values for stopping training. If both the training and
         validation metrics are smaller than the specified values, the
         training will stop early. Only supported by the M3GNet
         backend.

         Variables:
            **Forces**
            (*ParAMSMachineLearning._MachineLearning._Target._Forces*)
            -- Forces (as reported by the backend)

         class _Forces

            Forces (as reported by the backend)

            Variables:
               * **Enabled** (*BoolType** | **BoolKey*) -- Whether to
                 use target values for forces.

               * **MAE** (*float** | **FloatKey*) -- MAE for forces
                 (as reported by the backend).

   class _ParallelLevels

      Distribution of threads/processes between the parallelization
      levels.

      Variables:
         * **CommitteeMembers** (*int** | **IntKey*) -- Maximum number
           of committee member optimizations to run in parallel. If
           set to zero will take the minimum of
           MachineLearning%CommitteeSize and the number of available
           cores (NSCM)

         * **Cores** (*int** | **IntKey*) -- Number of cores to use
           per committee member optimization. By default (0) the
           available cores (NSCM) divided equally among committee
           members. When using GPU offloading, consider setting this
           to 1.

         * **Jobs** (*int** | **IntKey*) -- Number of JobCollection
           jobs to run in parallel for each loss function evaluation.

         * **Optimizations** (*int** | **IntKey*) -- Number of
           independent optimizers to run in parallel.

         * **ParameterVectors** (*int** | **IntKey*) --

           Number of parameter vectors to try in parallel for each
           optimizer iteration. This level of parallelism can only be
           used with optimizers that support parallel optimization!

           Default (0) will set this value to the number of cores on
           the system divided by the number of optimizers run in
           parallel, i.e., each optimizer will be given an equal share
           of the resources.

         * **Processes** (*int** | **IntKey*) --

           Number of processes (MPI ranks) to spawn for each
           JobCollection job. This effectively sets the NSCM
           environment variable for each job.

           A value of *-1* will disable explicit setting of related
           variables. We recommend a value of *1* in almost all cases.
           A value greater than 1 would only be useful if you
           parametrize DFTB with a serial optimizer and have very few
           jobs in the job collection.

         * **Threads** (*int** | **IntKey*) --

           Number of threads to use for each of the processes. This
           effectively set the OMP_NUM_THREADS environment variable.
           Note that the DFTB engine does not use threads, so the
           value of this variable would not have any effect. We
           recommend always leaving it at the default value of 1.
           Please consult the manual of the engine you are
           parameterizing.

           A value of *-1* will disable explicit setting of related
           variables.

class ParAMSOptimize

   Variables:
      * **ApplyStoppersToBestOptimizer** (*BoolType** | **BoolKey*) --
        By default the stoppers are not applied to the best optimizer
        (the one who has seen the best value thus far). This is
        because many stoppers are based on comparisons to the best
        optimizer, and in most scenarios one would like to keep a
        well-performing optimizer alive. For some stopper
        configurations this paradigm does not make sense and we would
        prefer to apply the stoppers equally to all optimizers.

      * **CheckStopperInterval** (*int** | **IntKey*) -- Number of
        loss function evaluations between evaluations of the stopper
        conditions.

      * **EndTimeout** (*float** | **FloatKey*) --

        The amount of time the manager will wait trying to smoothly
        join each optimizer at the end of the run. If exceeded the
        manager will abandon the optimizer and shutdown. This can
        raise errors from the abandoned threads, but may be needed to
        ensure the manager closes and does not hang.

        This option is often needed if the Scipy optimizers are being
        used and should be set to a low value.

      * **EngineCollection** (*str** | **StringKey*) -- Path to
        (optional) JobCollection Engines YAML file.

      * **ExitConditionBooleanCombination** (*str** | **StringKey*) --

        If multiple ExitConditions are used, this key indicates how
        their evaluations relate to one another.

        Use an integer to refer to a exit condition (defined by order
        in input file).

        Recognizes the symbols: ( ) & |

        E.g. (1 & 2) | 3.

        Defaults to an OR combination of all selected exit conditions.

      * **GlompoLogging** (*BoolType** | **BoolKey*) -- Include status
        and progress information from the optimization manager in the
        printstreams.

      * **GlompoSummaryFiles** (*Literal**[**"None"**, **"1"**,
        **"2"**, **"3"**, **"4"**]*) --

        Indicates what GloMPO-style outputs you would like saved to
        disk. Higher values also save all lower level information.

        Available options: • None: Nothing is saved. • 1: YAML file
        with summary info about the optimization settings, performance
        and the result. • 2: PNG file showing the trajectories of the
        optimizers. • 3: HDF5 file containing iteration history for
        each optimizer. • 4: More detailed HDF5 log including the
        residual results for each optimizer, data set and iteration.

      * **JobCollection** (*str** | **StringKey*) -- Path to
        JobCollection YAML file.

      * **MoreExtractorsPath** (*str** | **Path** | **StringKey*) --
        Path to directory with extractors.

      * **PLAMSWorkingDirectory** (*str** | **Path** | **StringKey*)
        -- Path to PLAMS working directory to temporarily hold Job
        results files.

      * **ParameterInterface** (*str** | **StringKey*) -- Path to
        parameter interface YAML file.

      * **PrintStatusInterval** (*float** | **FloatKey*) -- Number of
        seconds between printing of a status summary.

      * **ResultsDirectory** (*str** | **Path** | **StringKey*) --
        Directory in which output files will be created.

      * **ResumeCheckpoint** (*str** | **Path** | **StringKey*) --
        Path to checkpoint file from which a previous optimization can
        be resumed.

      * **Scaler** (*Literal**[**"Linear"**, **"Std"**, **"None"**,
        **"Optimizers"**]*) --

        Type of scaling applied to the parameters. A scaled input
        space is needed by many optimization algorithms.

        Available options: • Linear: Scale all parameters between 0
        and 1. • Std: Scale all parameters between -1 and 1. • None:
        Applies no scaling. • Optimizers (Default): Does not specify a
        scaling at the manager level, but allows the selection to be
        governed by the optimizer/s. If they do not require any
        particular scaler, then 'linear' is selected as the ultimate
        fallback.

      * **ShareBestEvaluationBetweenOptimizers** (*BoolType** |
        **BoolKey*) --

        Share new best evaluations from one optimizer to another.

        Some algorithms can use this information to accelerate their
        own convergence. However, optimizers typically have to be
        configured to receive and handle the information.

        This option can work very well with CMA-ES injections.

      * **SkipX0** (*BoolType** | **BoolKey*) --

        Do not evaluate the initial parameters before starting the
        optimization.

        If the initial parameters evaluated and do not return a finite
        loss function value, the optimization will abort. A non-
        infinite value typically indicates crashed jobs.

      * **SplitPrintstreams** (*BoolType** | **BoolKey*) -- Split
        print statements from each optimizer to separate files.

      * **StopperBooleanCombination** (*str** | **StringKey*) --

        If multiple Stoppers are used this is required to indicate how
        their evaluations relate to one another.

        Use an integer to refer to a stopper (defined by order in
        input file).

        Recognizes the symbols: ( ) & |

        E.g. (1 & 2) | 3.

        Defaults to an OR combination of all selected stoppers.

      * **Task** (*Literal**[**"Optimization"**,
        **"GenerateReference"**, **"SinglePoint"**, **"Sensitivity"**,
        **"MachineLearning"**]*) --

        Task to run.

        Available options: •MachineLearning: Optimization for machine
        learning models. •Optimization: Global optimization powered by
        GloMPO •Generate Reference: Run jobs with reference engine to
        get reference values •Single Point: Evaluate the current
        configuration of jobs, training data, and parameters
        •Sensitivity: Measure the sensitivity of the loss function to
        each of the active parameters

      * **Validation** (*float** | **FloatKey*) -- Fraction of the
        training set to be used as a validation set. Will be ignored
        if a validation set has been explicitly defined.

      * **CheckpointControl** (*ParAMSOptimize._CheckpointControl*) --
        Settings to control the production of checkpoints from which
        the optimization can be resumed.

      * **Constraints** (*str** | **Sequence**[**str**] **|
        **FreeBlock*) --

        Parameter constraint rules to apply to the loss function. One
        per line. Use 'p' to reference the parameter set. You may use
        indices or names in square brackets to refer to a specific
        variable.

        Note, that indices are absolute i.e., they do not reference
        the active subset of parameters.

        Eg: p[0]>=p[2] p['O:p_boc2']==p['H:p_boc2']

      * **ControlOptimizerSpawning**
        (*ParAMSOptimize._ControlOptimizerSpawning*) -- Control the
        spawning of optimizers. Note, this is different from
        ExitConditions. These simply stop new optimizers from
        spawning, but leave existing ones untouched. ExitConditions
        shutdown active optimizers and stop the optimization.

      * **DataSet** (*ParAMSOptimize._DataSet*) -- Configuration
        settings for each data set in the optimization.

      * **ExitCondition** (*ParAMSOptimize._ExitCondition*) -- A
        condition used to stop the optimization when it returns true.

      * **Generator** (*ParAMSOptimize._Generator*) -- A Generator
        used to produce x0 starting points for the optimizers.

      * **LoggingInterval** (*ParAMSOptimize._LoggingInterval*) --
        Number of function evaluations between every log to file.

      * **Optimizer** (*ParAMSOptimize._Optimizer*) -- An optimizer
        which may be used during the optimization.

      * **OptimizerSelector** (*ParAMSOptimize._OptimizerSelector*) --
        If multiple Optimizers are included, then this block must be
        included and configures the Selector which will choose between
        them.

      * **ParallelLevels** (*ParAMSOptimize._ParallelLevels*) --
        Distribution of threads/processes between the parallelization
        levels.

      * **Stopper** (*ParAMSOptimize._Stopper*) -- A Stopper used to
        terminate optimizers early.

   class _CheckpointControl

      Settings to control the production of checkpoints from which the
      optimization can be resumed.

      Variables:
         * **AtEnd** (*BoolType** | **BoolKey*) -- Create a checkpoint
           when the exit condition/s are triggered.

         * **AtInitialisation** (*BoolType** | **BoolKey*) -- Create a
           checkpoint immediately at the start of an optimization.

         * **CheckpointingDirectory** (*str** | **Path** |
           **StringKey*) -- Directory in which the checkpoints will be
           saved. Defaults to 'checkpoints' in the results directory

         * **EveryFunctionCalls** (*int** | **IntKey*) --

           Create a checkpoint every n function evaluations.

           If not specified or -1, checkpoints are not created based
           on function calls.

         * **EverySeconds** (*float** | **FloatKey*) --

           Create a checkpoint every n seconds.

           If not specified or -1, a checkpoint is not created based
           time.

         * **KeepPast** (*int** | **IntKey*) --

           Number of earlier checkpoints to keep. Older ones are
           deleted when a new one is created. -1 does not delete any
           previous checkpoints, and 0 retains only the most recent
           checkpoint.

           This number excludes the most recent checkpoint which is
           obviously always retained! So the actual number of files
           will be larger than this number by one.

         * **NamingFormat** (*str** | **StringKey*) --

           Convention used to name the checkpoints.

           The following special keys are supported: • %(date):
           Current calendar date in YYYYMMDD format • %(year): Year
           formatted to YYYY • %(yr): Year formatted to YY • %(month):
           Numerical month formatted to MM • %(day): Calendar day of
           the month formatted to DD • %(time): Current calendar time
           formatted to HHMMSS (24-hour style) • %(hour): Hour
           formatted to HH  (24-hour style) • %(min): Minutes
           formatted to MM • %(sec): Seconds formatted to SS •
           %(count): Index count of the number of checkpoints
           constructed. Starts at zero, formatted to 3 digits.

         * **RaiseFail** (*BoolType** | **BoolKey*) -- Raise an error
           and stop the optimization if a checkpoint fails to be
           constructed, otherwise issue a warning and continue the
           optimization.

   class _Constraints

      Parameter constraint rules to apply to the loss function. One
      per line. Use 'p' to reference the parameter set. You may use
      indices or names in square brackets to refer to a specific
      variable.

      Note, that indices are absolute i.e., they do not reference the
      active subset of parameters.

      Eg: p[0]>=p[2] p['O:p_boc2']==p['H:p_boc2']

   class _ControlOptimizerSpawning

      Control the spawning of optimizers. Note, this is different from
      ExitConditions. These simply stop new optimizers from spawning,
      but leave existing ones untouched. ExitConditions shutdown
      active optimizers and stop the optimization.

      Variables:
         * **MaxEvaluations** (*int** | **IntKey*) --

           No new optimizers will be started after this number of
           function evaluations has been used.

           Note, this is different from the equivalent exit condition
           which would terminate existing optimizers rather than
           simply not allowing new ones to spawn.

         * **MaxOptimizers** (*int** | **IntKey*) --

           No new optimizers will be started after this number has
           been spawned.

           Note, this is different from the equivalent exit condition
           which would terminate existing optimizers rather than
           simply not allowing new ones to spawn.

   class _DataSet

      Configuration settings for each data set in the optimization.

      Variables:
         * **BatchSize** (*int** | **IntKey*) -- Number of data set
           entries to be evaluated per epoch. Default 0 means all
           entries.

         * **EvaluateEvery** (*int** | **IntKey*) --

           This data set is evaluated every n evaluations of the
           training set.

           This will always be set to 1 for the training set. For
           other data sets it will be adjusted to the closest multiple
           of LoggingInterval%General, i.e., you cannot evaluate an
           extra data set more frequently than you log it.

         * **LossFunction** (*Literal**[**"mae"**, **"rmse"**,
           **"sse"**, **"sae"**]*) --

           Loss function used to quantify the error between model and
           reference values. This becomes the minimization task.

           Available options: • mae: Mean absolute error • rmse: Root
           mean squared error • sse: Sum of squared errors • sae: Sum
           of absolute errors

         * **MaxJobs** (*int** | **IntKey*) -- Limit each evaluation
           to a subset of n jobs. Default 0 meaning all jobs are used.

         * **MaxJobsShuffle** (*BoolType** | **BoolKey*) -- Use a
           different job subset every for every evaluation.

         * **Name** (*str** | **StringKey*) --

           Unique data set identifier.

           The first occurrence of DataSet will always be called
           training_set. The second will always be called
           validation_set. These cannot be overwritten.

           Later occurrences will default to data_set_xx where xx
           starts at 03 and increments from there. This field can be
           used to customize the latter names.

         * **Path** (*str** | **StringKey*) -- Path to DataSet YAML
           file.

         * **UsePipe** (*BoolType** | **BoolKey*) -- Use AMS Pipe for
           suitable jobs to speed-up evaluation.

   class _ExitCondition

      A condition used to stop the optimization when it returns true.

      Variables:
         * **MaxOptimizersConverged** (*int** | **IntKey*) --

           Return True after n optimizers have converged normally.

           An optimizer that has 'converged' is distinct from an
           optimizer that was shutdown via the Stopper settings (i.e.
           'stopped').

         * **MaxOptimizersStarted** (*int** | **IntKey*) --

           Return True after n optimizers have been started.

           Note, this is best used in combination with other
           conditions because it will stop the optimization as soon as
           the correct number have been started and not allow newly
           spawned optimizer to iterate at all.

         * **MaxOptimizersStopped** (*int** | **IntKey*) --

           Return True after n optimizers have been stopped.

           An optimizer that has been 'stopped' is distinct from an
           optimizer that stopped due to its internal convergence
           conditions (i.e., 'converged').

         * **MaxTotalFunctionCalls** (*int** | **IntKey*) -- Return
           True after n function calls have been executed.

         * **TargetFunctionValue** (*float** | **FloatKey*) -- Return
           True after an optimizer finds a function value less than or
           equal to n.

         * **TimeLimit** (*float** | **FloatKey*) --

           Return True after the entire optimization has been running
           for n seconds.

           Note, this is NOT the time for any particular optimizer.

           See also: Time Limit Through Restarts

         * **TimeLimitThroughRestarts** (*float** | **FloatKey*) --

           Return True after the sum-total of all optimization runs
           (i.e., through all restarts) has been running for n
           seconds.

           Note, this is NOT the time for any particular optimizer.

           See also: Time Limit

         * **Type** (*Literal**[**"TimeLimit"**,
           **"MaxTotalFunctionCalls"**, **"MaxOptimizersStarted"**,
           **"MaxOptimizersConverged"**, **"MaxOptimizersStopped"**,
           **"StopsAfterConvergence"**,
           **"TimeLimitThroughRestarts"**,
           **"TargetFunctionValue"**]*) --

           A condition used to stop the optimization when it returns
           true.

           Available options: • Time Limit: Limit the optimization
           walltime. • Max Function Calls: Stop the optimization after
           a certain number of loss function evaluations. • Max
           Optimizers Started: Shutdown after a certain number of
           optimizers have been spawned. • Max Optimizers Converged:
           Shutdown when optimizers have converged via their own
           internal conditions. • Max Optimizers Stopped: Shutdown
           when the Stopping configuration has resulted in a number of
           optimizers being stopped. • Stops After Convergence: Stop
           when some optimizers have converged and others have been
           stopped. • Time Limit Through Restarts: Limit the total
           cumulative walltime across multiple restarts of the
           optimization. • Target Function Value: Shutdown when a
           small enough loss function value is found.

         * **StopsAfterConvergence**
           (*ParAMSOptimize._ExitCondition._StopsAfterConvergence*) --
           Returns True when at least n_a optimizers have been stopped
           *after* n_b optimizers have converged.

      class _StopsAfterConvergence

         Returns True when at least n_a optimizers have been stopped
         *after* n_b optimizers have converged.

         Variables:
            * **OptimizersConverged** (*int** | **IntKey*) -- Minimum
              number of converged optimizers.

            * **OptimizersStopped** (*int** | **IntKey*) -- Maximum
              number of stopped optimizers.

   class _Generator

      A Generator used to produce x0 starting points for the
      optimizers.

      Variables:
         * **Type** (*Literal**[**"Incumbent"**, **"ExploreExploit"**,
           **"Perturbation"**, **"Random"**, **"SinglePoint"**]*) --

           Algorithm used to pick starting points for the optimizers.

           Available options: • Incumbent: Optimizers will be started
           at the best point seen thus far by any optimizer. First
           point is random. • ExploreExploit: Early starting points
           are random, but later points are closer to good minima. •
           Perturbation: Each starting point is a drawn from a
           multivariate Gaussian distribution centred at the initial
           parameter set. • Random: Optimizers are started at random
           locations in parameter space. • SinglePoint: All optimizers
           are started at the initial parameter values.

         * **ExploreExploit**
           (*ParAMSOptimize._Generator._ExploreExploit*) -- Blends a
           randomly generated point with the location of an existing
           optimizer, based on the time progress through the
           optimization. The optimizer is chosen based on a weighted
           roulette selection based on their function value. Early in
           the optimization optimizers are started randomly, and later
           they are started near previously found good minima.

         * **Perturbation**
           (*ParAMSOptimize._Generator._Perturbation*) -- Randomly
           generates parameter vectors from a multivariate normal
           distribution around the starting parameters.

      class _ExploreExploit

         Blends a randomly generated point with the location of an
         existing optimizer, based on the time progress through the
         optimization. The optimizer is chosen based on a weighted
         roulette selection based on their function value. Early in
         the optimization optimizers are started randomly, and later
         they are started near previously found good minima.

         Variables:
            * **Focus** (*float** | **FloatKey*) -- The blend
              parameter between random point and incumbent points.
              Used as follows: p=(f_calls / max_f_calls) ** focus

            * **MaxFunctionCalls** (*int** | **IntKey*) -- Maximum
              function calls allowed for the optimization, at and
              beyond this point there is a 100% chance that a
              previously evaluated point will be returned by the
              generator. If the optimization is not limited by the
              number of function calls, provide an estimate.

      class _Perturbation

         Randomly generates parameter vectors from a multivariate
         normal distribution around the starting parameters.

         Variables:
            **StandardDeviation** (*float** | **FloatKey*) -- Standard
            deviation of the multivariate normal distribution. Used
            here to control how wide the generator should explore
            around the starting parameters.

   class _LoggingInterval

      Number of function evaluations between every log to file.

      Variables:
         * **Flush** (*int** | **IntKey*) --

           The number of function evaluations between flushes of the
           output streams to disk.

           If Flush = General, then files will be flushed after every
           logged call.

         * **General** (*int** | **IntKey*) --

           The number of function evaluations between writes to
           stdout, running_loss.txt, running_stats.txt and all
           *latest/* and *best/* files.

           This is also the interval with which the validation set
           will be evaluated and logged.

         * **History** (*int** | **IntKey*) -- The number of function
           evaluations between saves to the history directory with
           copies of latest/.

         * **Parameters** (*int** | **IntKey*) -- The number of
           function evaluations between writes to
           running_active_parameters.txt.

   class _Optimizer

      An optimizer which may be used during the optimization.

      Variables:
         * **Type** (*Literal**[**"AdaptiveRateMonteCarlo"**,
           **"CMAES"**, **"Nevergrad"**, **"Scipy"**,
           **"RandomSampling"**, **"GridSampling"**]*) --

           Name of the optimization algorithm or interface.

           Available options: • Adaptive Rate Monte Carlo • CMAES
           (Covariance Matrix Adaptation Evolutionary Strategy) •
           Nevergrad (Interface to many other algorithms) • Scipy
           (Interface to classic optimization algorithms) • Random
           Sampling (Uniform random sampling of the space for later
           analysis. NOT an actual optimizer) • Grid Sampling
           (Gridwise sampling of the parameter space for later
           analysis. NOT and actual optimizer)

         * **AdaptiveRateMonteCarlo**
           (*ParAMSOptimize._Optimizer._AdaptiveRateMonteCarlo*) --
           Settings for the Adaptive Rate Monte-Carlo optimizer

         * **CMAES** (*ParAMSOptimize._Optimizer._CMAES*) -- Settings
           for the Covariance Matrix Adaptation Evolutionary Strategy

         * **GridSampling**
           (*ParAMSOptimize._Optimizer._GridSampling*) -- Settings for
           grid-wise sampling of the parameter space.

         * **Nevergrad** (*ParAMSOptimize._Optimizer._Nevergrad*) --
           Settings for the Nevergrad wrapper which gives access to
           many optimization algorithms.

         * **RandomSampling**
           (*ParAMSOptimize._Optimizer._RandomSampling*) -- Settings
           for a totally random sampler of the parameter space.

         * **Scipy** (*ParAMSOptimize._Optimizer._Scipy*) -- Settings
           for the Scipy wrapper which gives access to many
           optimization algorithms. For parallel optimizations,
           Nevergrad is preferred as it provides better control
           options.

      class _AdaptiveRateMonteCarlo

         Settings for the Adaptive Rate Monte-Carlo optimizer

         Variables:
            * **AcceptanceTarget** (*float** | **FloatKey*) -- The
              target acceptance rate αₜ

            * **Gamma** (*float** | **FloatKey*) -- γ parameter.

            * **MoveRange** (*Iterable**[**float**] **|
              **FloatListKey*) -- List of allowed move sizes.

            * **Phi** (*float** | **FloatKey*) -- ϕ parameter.

            * **SubIterations** (*int** | **IntKey*) -- Number of sub-
              iterations (ω)

            * **SuperIterations** (*int** | **IntKey*) -- Number of
              super-iterations (κ)

      class _CMAES

         Settings for the Covariance Matrix Adaptation Evolutionary
         Strategy

         Variables:
            * **ForceInjections** (*BoolType** | **BoolKey*) --

              If Yes, injections of parameter vectors into the solver
              will be exact, guaranteeing that that solution will be
              in the next iteration's population.

              If No, the injection will result in a direction relative
              nudge towards the vector. Forcing the injecting can
              limit global exploration but non-forced injections may
              have little effect.

              See also glompo.optimizer.cmaes.injectioninterval

            * **InjectionInterval** (*int** | **IntKey*) --

              Number of iterations between injections of the incumbent
              solution into the sampled population. Defaults to 0,
              i.e., no injections are performed.

              Injections can be helpful in increasing the convergence
              speed and nudging optimizers toward a solution. This is
              a form of elitism and will limit exploration.

              Of particular interest is pairing this key with
              glompo.ShareBestEvaluationBetweenOptimizers. In this
              case the incumbent that is injected comes from other
              optimizers run in parallel. This can help nudge
              optimizers towards better solutions while dramatically
              improving convergence speed.

              See also glompo.optimizer.cmaes.forceinjections

            * **KeepFiles** (*BoolType** | **BoolKey*) -- Keep CMA
              specific history files about the state of the covariance
              matrix and other algorithm variables.

            * **MinSigma** (*float** | **FloatKey*) -- Convergence
              condition to terminate the optimization when the
              standard deviation of the sampling distribution falls
              below this value.

            * **Popsize** (*int** | **IntKey*) --

              Number of function evaluations per CMA-ES iteration.

              If not specified or -1, then the population size will
              equal the number of workers available to the optimizer.
              This is computationally efficient but not
              algorithmically efficient.

              A value of zero or one will set the population size to
              the value suggested by CMA based on the dimensionality
              of the problem. This produces the best algorithm
              performance but may be computationally inefficient if
              resources are left idling while waiting for other
              evaluations to complete.

              Note: a population of one is not allowed by CMA,
              therefore, it is changed to the algorithm default. This
              also means that giving CMA only one worker will also
              change the popsize to the algorithm default.

            * **Sampler** (*Literal**[**"full"**, **"vd"**,
              **"vkd"**]*) --

              Choice of full or restricted Gaussian sampling
              procedures.

              Options: • full: Full sampling procedure • vd:
              Restricted sampler for VD-CMA (Linear time/space
              comparison-based natural gradient optimization) • vkd:
              Restricted sampler for VkD-CMA (Time/space variant of
              CMA-ES)

            * **Sigma0** (*float** | **FloatKey*) --

              Initial standard deviation of the multivariate normal
              distribution from which trials are drawn.

              The recommended range of values for is between 0.01 and
              0.5. Lower values sample very locally and converge
              quickly, higher values sample broadly but will take a
              long time to converge.

            * **Verbose** (*BoolType** | **BoolKey*) -- Produce a
              printstream of results from within the optimizer itself.

            * **Settings** (*str** | **Sequence**[**str**] **|
              **FreeBlock*) --

              'argument value' pairs for extra CMA specific
              configuration arguments.

              See CMAOptimizer API documentation for more details on
              which options are possible.

         class _Settings

            'argument value' pairs for extra CMA specific
            configuration arguments.

            See CMAOptimizer API documentation for more details on
            which options are possible.

      class _GridSampling

         Settings for grid-wise sampling of the parameter space.

         Variables:
            **NumberOfDivisions** (*int** | **IntKey*) -- Number of
            equal sub-divisions to take for each parameter. Total
            calls is n_steps^n_parameters.

      class _Nevergrad

         Settings for the Nevergrad wrapper which gives access to many
         optimization algorithms.

         Variables:
            * **Algorithm** (*Literal**[**"ASCMA2PDEthird"**,
              **"ASCMADEQRthird"**, **"ASCMADEthird"**,
              **"AlmostRotationInvariantDE"**,
              **"AvgMetaLogRecentering"**, **"AvgMetaRecentering"**,
              **"BO"**, **"CM"**, **"CMA"**, **"CMandAS"**,
              **"CMandAS2"**, **"CMandAS3"**, **"CauchyLHSSearch"**,
              **"CauchyOnePlusOne"**, **"CauchyScrHammersleySearch"**,
              **"Cobyla"**, **"DE"**, **"DiagonalCMA"**,
              **"DiscreteOnePlusOne"**,
              **"DoubleFastGADiscreteOnePlusOne"**, **"EDA"**,
              **"ES"**, **"FCMA"**, **"HaltonSearch"**,
              **"HaltonSearchPlusMiddlePoint"**,
              **"HammersleySearch"**,
              **"HammersleySearchPlusMiddlePoint"**, **"LHSSearch"**,
              **"LargeHaltonSearch"**, **"LhsDE"**, **"MEDA"**,
              **"MPCEDA"**, **"MetaLogRecentering"**,
              **"MetaRecentering"**, **"MixES"**, **"MultiCMA"**,
              **"MultiScaleCMA"**, **"MutDE"**, **"NGO"**,
              **"NaiveIsoEMNA"**, **"NaiveTBPSA"**, **"NelderMead"**,
              **"NoisyBandit"**, **"NoisyDE"**,
              **"NoisyDiscreteOnePlusOne"**, **"NoisyOnePlusOne"**,
              **"OAvgMetaLogRecentering"**, **"ORandomSearch"**,
              **"OScrHammersleySearch"**, **"OnePlusOne"**,
              **"OptimisticDiscreteOnePlusOne"**,
              **"OptimisticNoisyOnePlusOne"**, **"PBIL"**,
              **"PCEDA"**, **"PSO"**, **"ParaPortfolio"**,
              **"Portfolio"**, **"Powell"**, **"QORandomSearch"**,
              **"QOScrHammersleySearch"**, **"QrDE"**, **"RCobyla"**,
              **"RPowell"**, **"RSQP"**, **"RandomSearch"**,
              **"RandomSearchPlusMiddlePoint"**, **"RealSpacePSO"**,
              **"RecES"**, **"RecMixES"**, **"RecMutDE"**, **"Recombi
              ningPortfolioOptimisticNoisyDiscreteOnePlusOne"**,
              **"RotationInvariantDE"**, **"SPSA"**, **"SQP"**,
              **"SQPCMA"**, **"ScrHaltonSearch"**,
              **"ScrHaltonSearchPlusMiddlePoint"**,
              **"ScrHammersleySearch"**,
              **"ScrHammersleySearchPlusMiddlePoint"**, **"Shiva"**,
              **"SplitOptimizer"**, **"TBPSA"**, **"TripleCMA"**,
              **"TwoPointsDE"**, **"cGA"**, **"chainCMAPowel"**]*) --

              Optimization strategy to use.

              See Nevergrad documentation for details of the available
              methods.

            * **Zero** (*float** | **FloatKey*) -- Function value
              below which the algorithm will terminate.

            * **Settings** (*str** | **Sequence**[**str**] **|
              **FreeBlock*) --

              'argument value' pairs for extra algorithm-specific
              configuration arguments.

              See Nevergrad API documentation for more details on
              which options are possible.

         class _Settings

            'argument value' pairs for extra algorithm-specific
            configuration arguments.

            See Nevergrad API documentation for more details on which
            options are possible.

      class _RandomSampling

         Settings for a totally random sampler of the parameter space.

         Variables:
            * **NumberOfSamples** (*int** | **IntKey*) -- Number of
              samples to generate.

            * **RandomSeed** (*int** | **IntKey*) -- Random seed to
              use for the generator. Useful for reproducibility.

      class _Scipy

         Settings for the Scipy wrapper which gives access to many
         optimization algorithms. For parallel optimizations,
         Nevergrad is preferred as it provides better control options.

         Variables:
            * **Algorithm** (*Literal**[**"Nelder-Mead"**,
              **"Powell"**, **"CG"**, **"BFGS"**, **"Newton-CG"**,
              **"L-BFGS-B"**, **"TNC"**, **"COBYLA"**, **"SLSQP"**,
              **"trust-constr"**, **"dogleg"**, **"trust-ncg"**,
              **"trust-exact"**, **"trust-krylov"**]*) --

              Optimization strategy to use.

              See Scipy documentation for details of the available
              methods.

            * **Hessian** (*Literal**[**"2-point"**, **"3-point"**,
              **"cs"**]*) -- Choice of the Hessian estimation method.
              Only for Newton-CG, dogleg, trust-ncg, trust-krylov,
              trust-exact and trust-constr.

            * **Jacobian** (*Literal**[**"2-point"**, **"3-point"**,
              **"cs"**]*) -- Choice of gradient estimation method.
              Only for CG, BFGS, Newton-CG, L-BFGS-B, TNC, SLSQP,
              dogleg, trust-ncg, trust-krylov, trust-exact and trust-
              constr.

            * **Tolerance** (*float** | **FloatKey*) -- Tolerance for
              termination. Interpretation linked to chosen method. See
              Scipy docs.

            * **Settings** (*str** | **Sequence**[**str**] **|
              **FreeBlock*) --

              'argument value' pairs for extra algorithm-specific
              configuration arguments.

              See Scipy API documentation for more details on which
              options are possible.

         class _Settings

            'argument value' pairs for extra algorithm-specific
            configuration arguments.

            See Scipy API documentation for more details on which
            options are possible.

   class _OptimizerSelector

      If multiple Optimizers are included, then this block must be
      included and configures the Selector which will choose between
      them.

      Variables:
         * **Type** (*Literal**[**"Cycle"**, **"Random"**,
           **"Chain"**]*) --

           Name of the algorithm selecting between optimizers.

           Available options: • Cycle (Default): Sequential loop
           through available optimizers. • Random: Optimizers are
           selected randomly from the available options. • Chain:
           Time-based progression through the list of available
           optimizers. The next option will be started once a certain
           number of loss function evaluations have been used.

         * **Chain** (*ParAMSOptimize._OptimizerSelector._Chain*) --
           Start different optimizers at different points in time
           based on the number of function evaluations used.

      class _Chain

         Start different optimizers at different points in time based
         on the number of function evaluations used.

         Variables:
            **Thresholds** (*Iterable**[**int**] **| **IntListKey*) --
            List of loss function evaluation thresholds which switch
            to the next optimizer in the list. If there are n
            optimizers available, then this list should have n-1
            thresholds.

   class _ParallelLevels

      Distribution of threads/processes between the parallelization
      levels.

      Variables:
         * **CommitteeMembers** (*int** | **IntKey*) -- Maximum number
           of committee member optimizations to run in parallel. If
           set to zero will take the minimum of
           MachineLearning%CommitteeSize and the number of available
           cores (NSCM)

         * **Cores** (*int** | **IntKey*) -- Number of cores to use
           per committee member optimization. By default (0) the
           available cores (NSCM) divided equally among committee
           members. When using GPU offloading, consider setting this
           to 1.

         * **Jobs** (*int** | **IntKey*) -- Number of JobCollection
           jobs to run in parallel for each loss function evaluation.

         * **Optimizations** (*int** | **IntKey*) -- Number of
           independent optimizers to run in parallel.

         * **ParameterVectors** (*int** | **IntKey*) --

           Number of parameter vectors to try in parallel for each
           optimizer iteration. This level of parallelism can only be
           used with optimizers that support parallel optimization!

           Default (0) will set this value to the number of cores on
           the system divided by the number of optimizers run in
           parallel, i.e., each optimizer will be given an equal share
           of the resources.

         * **Processes** (*int** | **IntKey*) --

           Number of processes (MPI ranks) to spawn for each
           JobCollection job. This effectively sets the NSCM
           environment variable for each job.

           A value of *-1* will disable explicit setting of related
           variables. We recommend a value of *1* in almost all cases.
           A value greater than 1 would only be useful if you
           parametrize DFTB with a serial optimizer and have very few
           jobs in the job collection.

         * **Threads** (*int** | **IntKey*) --

           Number of threads to use for each of the processes. This
           effectively set the OMP_NUM_THREADS environment variable.
           Note that the DFTB engine does not use threads, so the
           value of this variable would not have any effect. We
           recommend always leaving it at the default value of 1.
           Please consult the manual of the engine you are
           parameterizing.

           A value of *-1* will disable explicit setting of related
           variables.

   class _Stopper

      A Stopper used to terminate optimizers early.

      Variables:
         * **MaxFunctionCalls** (*int** | **IntKey*) --

           Returns True after an optimizer has evaluated at least n
           points.

           Use in an AND combination with other stoppers to keep
           optimizers alive for at least some period of time, or alone
           or in an OR combination to shut them down after some period
           of time.

         * **MaxSequentialInvalidPoints** (*int** | **IntKey*) --
           Return True if the optimizer has failed to find a finite
           function value in the last n iterations. Usually indicates
           a lost optimizer with poor starting point.

         * **OptimizerType** (*Literal**[**"AdaptiveRateMonteCarlo"**,
           **"CMAES"**, **"Nevergrad"**, **"Scipy"**,
           **"RandomSampling"**, **"GridSampling"**]*) -- Intended for
           use with other stoppers to allow for specific hunting
           conditions based on the type of optimizer.

         * **Type** (*Literal**[**"BestFunctionValueUnmoving"**,
           **"CurrentFunctionValueUnmoving"**,
           **"MaxSequentialInvalidPoints"**, **"MaxFunctionCalls"**,
           **"MaxInteroptimizerDistance"**, **"MinStepSize"**,
           **"TimeAnnealing"**, **"OptimizerType"**,
           **"ValueAnnealing"**, **"ValidationWorsening"**]*) --

           Conditions used to stop individual optimizers. Only
           optimizers which have not seen the current best value will
           be hunted. The 'best' optimizer will always be left alive.

           Available options: • Best Function Value Unmoving: Shutdown
           optimizers who haven't improved their best point in a long
           time. • Current Function Value Unmoving: Shutdown
           optimizers which have not changed their currently explored
           loss function value a lot in a long time. • Max Sequential
           Invalid Points: Stop optimizers that are stuck in areas of
           parameter space which return non-finite loss function
           values. • Max Function Calls: Stop optimizers when they
           have evaluated the loss function a certain number of times.
           • Max Interoptimizer Distance: Stop optimizers too close
           together in parameter space. • Min Step Size: Stop
           optimizers who are taking very small steps between
           iterations. • Time Annealing: For use with other
           conditions. Keep an optimizer alive for longer if it's
           relatively new. • Optimizer Type: For use with other
           conditions. Shutdown optimizers of a specific type. • Value
           Annealing: For use with other conditions. Keep an optimizer
           alive if it looks likely to overtake the best optimizer. •
           Validation Worsening: Stops optimizers which are evaluating
           points where the validation set loss value is worse than
           the average of several previously seen ones.

         * **BestFunctionValueUnmoving**
           (*ParAMSOptimize._Stopper._BestFunctionValueUnmoving*) --
           Return True if an optimizer's best value has not improved
           significantly in a given amount of time.

         * **CurrentFunctionValueUnmoving**
           (*ParAMSOptimize._Stopper._CurrentFunctionValueUnmoving*)
           -- Return True if an optimizer's current function value has
           not improved significantly in a given amount of time.

         * **MaxInteroptimizerDistance**
           (*ParAMSOptimize._Stopper._MaxInteroptimizerDistance*) --
           Return True if two optimizers are evaluating points too
           close to one another in parameter space.

         * **MinStepSize** (*ParAMSOptimize._Stopper._MinStepSize*) --
           Return True if an optimizer's step size between evaluations
           is too small.

         * **TimeAnnealing**
           (*ParAMSOptimize._Stopper._TimeAnnealing*) -- Keeps
           optimizers alive based on how long they have been alive.
           Randomly keeps optimizers alive based on how long (in
           function evaluations) they have been active. The newer an
           optimizer is, the more likely it will pass the test and be
           kept alive. Used to temper very strict termination
           conditions.

         * **ValidationWorsening**
           (*ParAMSOptimize._Stopper._ValidationWorsening*) -- Return
           True if the loss value of the validation set is increasing.

         * **ValueAnnealing**
           (*ParAMSOptimize._Stopper._ValueAnnealing*) -- Intended for
           use with other stoppers. This condition is unlikely to stop
           a victim which has a loss function value very near the best
           seen thus far, but the probability of stopping increases
           with the difference between them.

      class _BestFunctionValueUnmoving

         Return True if an optimizer's best value has not improved
         significantly in a given amount of time.

         Variables:
            * **NumberOfFunctionCalls** (*int** | **IntKey*) -- Number
              of function evaluations between comparison points.

            * **Tolerance** (*float** | **FloatKey*) -- Function
              tolerance fraction between 0 and 1.

      class _CurrentFunctionValueUnmoving

         Return True if an optimizer's current function value has not
         improved significantly in a given amount of time.

         Variables:
            * **NumberOfFunctionCalls** (*int** | **IntKey*) -- Number
              of function evaluations between comparison points.

            * **Tolerance** (*float** | **FloatKey*) -- Function
              tolerance fraction between 0 and 1.

      class _MaxInteroptimizerDistance

         Return True if two optimizers are evaluating points too close
         to one another in parameter space.

         Variables:
            * **CompareAllOptimizers** (*BoolType** | **BoolKey*) --
              If Yes the distance between all optimizer combinations
              are compared, otherwise worse optimizers are only
              compared to the best one.

            * **MaxRelativeDistance** (*float** | **FloatKey*) --
              Fraction (between 0 and 1) of the maximum distance in
              the space (from the point at all lower bounds to the
              point at all upper bounds) below which the optimizers
              are deemed too close and the victim will be stopped.

      class _MinStepSize

         Return True if an optimizer's step size between evaluations
         is too small.

         Variables:
            * **NumberOfFunctionCalls** (*int** | **IntKey*) -- Number
              of function evaluations between comparison points.

            * **Tolerance** (*float** | **FloatKey*) -- Fraction
              (between 0 and 1) of the maximum distance in the space
              (from the point at all lower bounds to the point at all
              upper bounds)

      class _TimeAnnealing

         Keeps optimizers alive based on how long they have been
         alive. Randomly keeps optimizers alive based on how long (in
         function evaluations) they have been active. The newer an
         optimizer is, the more likely it will pass the test and be
         kept alive. Used to temper very strict termination
         conditions.

         Variables:
            **CriticalRatio** (*float** | **FloatKey*) -- Critical
            ratio of function calls between stopper and victim above
            which the victim is guaranteed to survive. Values lower
            than one are looser and allow the victim to survive even
            if it has been in operation longer than the stopper.
            Values higher than one are stricter and may stop the
            victim even if it has iterated fewer times than the
            stopper.

      class _ValidationWorsening

         Return True if the loss value of the validation set is
         increasing.

         Variables:
            * **NumberOfFunctionCalls** (*int** | **IntKey*) -- Number
              of function evaluations between comparison points.

            * **Tolerance** (*float** | **FloatKey*) -- The loss value
              (f) is modified by: f * (1 + *tol*). This can also be
              used to ignore the effects of mild fluctuations.

      class _ValueAnnealing

         Intended for use with other stoppers. This condition is
         unlikely to stop a victim which has a loss function value
         very near the best seen thus far, but the probability of
         stopping increases with the difference between them.

         Variables:
            **CriticalStopChance** (*float** | **FloatKey*) -- Value
            is the probability of stopping a victim which is twice as
            large as the stopper in absolute value. The default is
            50%.

class ParAMSSensitivity

   Variables:
      * **EngineCollection** (*str** | **StringKey*) -- Path to
        (optional) JobCollection Engines YAML file.

      * **FilterInfiniteValues** (*BoolType** | **BoolKey*) --

        If Yes, removes points from the calculation with non-finite
        loss values.

        Non-finite points can cause numerical issues in the
        sensitivity calculation.

      * **JobCollection** (*str** | **StringKey*) -- Path to
        JobCollection YAML file.

      * **NumberBootstraps** (*int** | **IntKey*) --

        Number of repeats of the calculation with different sub-
        samples.

        A small spread from a large number of bootstraps provides
        confidence on the estimation of the sensitivity.

      * **NumberCalculationSamples** (*int** | **IntKey*) --

        Number of samples from the full set available to use in the
        calculation.

        If not specified or -1, uses all available points. For the
        sensitivity calculation, this will be redrawn for every
        bootstrap.

      * **NumberSamples** (*int** | **IntKey*) -- Number of samples to
        generate during the sampling procedure.

      * **ParameterInterface** (*str** | **StringKey*) -- Path to
        parameter interface YAML file.

      * **RandomSeed** (*int** | **IntKey*) -- Random seed to use
        during the sampling procedure (for reproducibility).

      * **ResultsDirectory** (*str** | **Path** | **StringKey*) --
        Directory in which output files will be created.

      * **RunReweightCalculation** (*BoolType** | **BoolKey*) --

        Run a more expensive sensitivity calculation that will also
        return suggested weights for the training set which will
        produce more balanced sensitivities between all the
        parameters.

        Note: The Gaussian kernel is recommended for the loss values
        kernel in this case.

      * **RunSampling** (*BoolType** | **BoolKey*) --

        Produce a set of samples of the loss function and active
        parameters. Samples from the parameter space are drawn from a
        uniform random distribution.

        Such a set of samples serves as the input to the sensitivity
        calculation.

      * **SampleWithReplacement** (*BoolType** | **BoolKey*) --

        Sample from the available data with or without replacement.

        This only has an effect if the number of samples for the
        calculation is less than the total number available otherwise
        replace is Yes by necessity.

      * **SamplesDirectory** (*str** | **Path** | **StringKey*) --

        Path to an 'optimization' directory containing the results of
        a previously run sampling.

        First looks for a 'glompo_log.h5' file. If not found, will
        look for 'running_loss.txt' and
        'running_active_parameters.txt' in a sub-directory. The sub-
        directory used will depend on the DataSet Name.

        For the Reweight calculation only a 'glompo_log.h5' file (with
        residuals) may be used.

      * **SaveResiduals** (*BoolType** | **BoolKey*) --

        During the sampling, save the individual difference between
        reference and predicted values for every sample and training
        set item. Required for the Reweight calculation, and will be
        automatically activated if the reweight calculation is
        requested.

        Saving and analyzing the residuals can provide valuable
        insight into your training set, but can quickly occupy a large
        amount of disk space. Only save the residuals if you would
        like to run the reweight calculation or have a particular
        reason to do so.

      * **SetToAnalyze** (*Literal**[**"TrainingSet"**,
        **"ValidationSet"**]*) -- Name of the data set to use for the
        sensitivity analysis.

      * **Task** (*Literal**[**"Optimization"**,
        **"GenerateReference"**, **"SinglePoint"**, **"Sensitivity"**,
        **"MachineLearning"**]*) --

        Task to run.

        Available options: •MachineLearning: Optimization for machine
        learning models. •Optimization: Global optimization powered by
        GloMPO •Generate Reference: Run jobs with reference engine to
        get reference values •Single Point: Evaluate the current
        configuration of jobs, training data, and parameters
        •Sensitivity: Measure the sensitivity of the loss function to
        each of the active parameters

      * **DataSet** (*ParAMSSensitivity._DataSet*) -- Configuration
        settings for each data set in the optimization.

      * **LossValuesKernel** (*ParAMSSensitivity._LossValuesKernel*)
        -- Kernel applied to the parameters for which sensitivity is
        being measured.

      * **ParametersKernel** (*ParAMSSensitivity._ParametersKernel*)
        -- Kernel applied to the parameters for which sensitivity is
        being measured.

   class _DataSet

      Configuration settings for each data set in the optimization.

      Variables:
         * **BatchSize** (*int** | **IntKey*) -- Number of data set
           entries to be evaluated per epoch. Default 0 means all
           entries.

         * **EvaluateEvery** (*int** | **IntKey*) --

           This data set is evaluated every n evaluations of the
           training set.

           This will always be set to 1 for the training set. For
           other data sets it will be adjusted to the closest multiple
           of LoggingInterval%General, i.e., you cannot evaluate an
           extra data set more frequently than you log it.

         * **LossFunction** (*Literal**[**"mae"**, **"rmse"**,
           **"sse"**, **"sae"**]*) --

           Loss function used to quantify the error between model and
           reference values. This becomes the minimization task.

           Available options: • mae: Mean absolute error • rmse: Root
           mean squared error • sse: Sum of squared errors • sae: Sum
           of absolute errors

         * **MaxJobs** (*int** | **IntKey*) -- Limit each evaluation
           to a subset of n jobs. Default 0 meaning all jobs are used.

         * **MaxJobsShuffle** (*BoolType** | **BoolKey*) -- Use a
           different job subset every for every evaluation.

         * **Name** (*str** | **StringKey*) --

           Unique data set identifier.

           The first occurrence of DataSet will always be called
           training_set. The second will always be called
           validation_set. These cannot be overwritten.

           Later occurrences will default to data_set_xx where xx
           starts at 03 and increments from there. This field can be
           used to customize the latter names.

         * **Path** (*str** | **StringKey*) -- Path to DataSet YAML
           file.

         * **UsePipe** (*BoolType** | **BoolKey*) -- Use AMS Pipe for
           suitable jobs to speed-up evaluation.

   class _LossValuesKernel

      Kernel applied to the parameters for which sensitivity is being
      measured.

      Variables:
         * **Alpha** (*float** | **FloatKey*) --

           Cut-off parameter for the Threshold kernel between zero and
           one.

           All loss values are scaled by taking the logarithm and then
           adjusted to a range between zero and one. This parameter is
           a value within this scaled space.

         * **Gamma** (*float** | **FloatKey*) -- Bandwidth parameter
           for the conjunctive-Gaussian kernel.

         * **Sigma** (*float** | **FloatKey*) --

           Bandwidth parameter for the Gaussian kernel.

           If not specified or -1, calculates a reasonable default
           based on the number of parameters being tested.

         * **Type** (*Literal**[**"Gaussian"**,
           **"ConjunctiveGaussian"**, **"Threshold"**,
           **"Polynomial"**, **"Linear"**]*) -- Name of the kernel to
           applied to the parameters for which sensitivity is being
           measured.

         * **Polynomial**
           (*ParAMSSensitivity._LossValuesKernel._Polynomial*) --
           Settings for the Polynomial kernel.

      class _Polynomial

         Settings for the Polynomial kernel.

         Variables:
            * **Order** (*int** | **IntKey*) -- Maximum order of the
              polynomial.

            * **Shift** (*float** | **FloatKey*) -- Free parameter (≥
              0) trading off higher-order versus lower-order effects.

   class _ParametersKernel

      Kernel applied to the parameters for which sensitivity is being
      measured.

      Variables:
         * **Alpha** (*float** | **FloatKey*) --

           Cut-off parameter for the Threshold kernel between zero and
           one.

           All loss values are scaled by taking the logarithm and then
           adjusted to a range between zero and one. This parameter is
           a value within this scaled space.

         * **Gamma** (*float** | **FloatKey*) -- Bandwidth parameter
           for the conjunctive-Gaussian kernel.

         * **Sigma** (*float** | **FloatKey*) -- Bandwidth parameter
           for the Gaussian kernel.

         * **Type** (*Literal**[**"Gaussian"**,
           **"ConjunctiveGaussian"**, **"Threshold"**,
           **"Polynomial"**, **"Linear"**]*) -- Name of the kernel to
           applied to the parameters for which sensitivity is being
           measured.

         * **Polynomial**
           (*ParAMSSensitivity._ParametersKernel._Polynomial*) --
           Settings for the Polynomial kernel.

      class _Polynomial

         Settings for the Polynomial kernel.

         Variables:
            * **Order** (*int** | **IntKey*) -- Maximum order of the
              polynomial.

            * **Shift** (*float** | **FloatKey*) -- Free parameter (≥
              0) trading off higher-order versus lower-order effects.

class ParAMSSinglePoint

   Variables:
      * **EngineCollection** (*str** | **StringKey*) -- Path to
        (optional) JobCollection Engines YAML file.

      * **EvaluateLoss** (*BoolType** | **BoolKey*) --

        Evaluate the loss function based on the job results. This will
        produce the same output files as Task Optimization.  If No,
        this will be skipped and only the jobs will be run (and
        saved).

        Warning: If both Store Jobs and Evaluate Loss are No then this
        task will not produce any output.

      * **JobCollection** (*str** | **StringKey*) -- Path to
        JobCollection YAML file.

      * **ParameterInterface** (*str** | **StringKey*) -- Path to
        parameter interface YAML file.

      * **RestartDirectory** (*str** | **Path** | **StringKey*) --

        Specify a directory to continue interrupted GenerateReference
        or SinglePoint calculations. The directory depends on the
        task:

        GenerateReference: results/reference_jobs SinglePoint:
        results/single_point/jobs

        Note: If you use the GUI this directory will be COPIED into
        the results folder and the name will be prepended with 'dep-'.
        This can take up a lot of disk space, so you may want to
        remove the 'dep-' folder after the job has finished.

      * **ResultsDirectory** (*str** | **Path** | **StringKey*) --
        Directory in which output files will be created.

      * **StoreJobs** (*Literal**[**"Auto"**, **"Yes"**, **"No"**]*)
        --

        Keeps the results files for each of the jobs. If No, all
        pipeable jobs will be run through the AMS Pipe and no files
        will be saved (not even the ones not run through the pipe). If
        Auto, the pipeable jobs are run through the pipe and the
        results of nonpipeable jobs are saved to disk. If Yes, no jobs
        are run through the pipe and all job results are stored on
        disk.

        Warning: If both Store Jobs and Evaluate Loss are No then task
        SinglePoint will not produce any output.

      * **Task** (*Literal**[**"Optimization"**,
        **"GenerateReference"**, **"SinglePoint"**, **"Sensitivity"**,
        **"MachineLearning"**]*) --

        Task to run.

        Available options: •MachineLearning: Optimization for machine
        learning models. •Optimization: Global optimization powered by
        GloMPO •Generate Reference: Run jobs with reference engine to
        get reference values •Single Point: Evaluate the current
        configuration of jobs, training data, and parameters
        •Sensitivity: Measure the sensitivity of the loss function to
        each of the active parameters

      * **DataSet** (*ParAMSSinglePoint._DataSet*) -- Configuration
        settings for each data set in the optimization.

      * **Engine** (*EngineBlock*) -- If set, use this engine for the
        ParAMS SinglePoint. Mutually exclusive with EngineCollection.

      * **ParallelLevels** (*ParAMSSinglePoint._ParallelLevels*) --
        Distribution of threads/processes between the parallelization
        levels.

   class _DataSet

      Configuration settings for each data set in the optimization.

      Variables:
         * **BatchSize** (*int** | **IntKey*) -- Number of data set
           entries to be evaluated per epoch. Default 0 means all
           entries.

         * **EvaluateEvery** (*int** | **IntKey*) --

           This data set is evaluated every n evaluations of the
           training set.

           This will always be set to 1 for the training set. For
           other data sets it will be adjusted to the closest multiple
           of LoggingInterval%General, i.e., you cannot evaluate an
           extra data set more frequently than you log it.

         * **LossFunction** (*Literal**[**"mae"**, **"rmse"**,
           **"sse"**, **"sae"**]*) --

           Loss function used to quantify the error between model and
           reference values. This becomes the minimization task.

           Available options: • mae: Mean absolute error • rmse: Root
           mean squared error • sse: Sum of squared errors • sae: Sum
           of absolute errors

         * **MaxJobs** (*int** | **IntKey*) -- Limit each evaluation
           to a subset of n jobs. Default 0 meaning all jobs are used.

         * **MaxJobsShuffle** (*BoolType** | **BoolKey*) -- Use a
           different job subset every for every evaluation.

         * **Name** (*str** | **StringKey*) --

           Unique data set identifier.

           The first occurrence of DataSet will always be called
           training_set. The second will always be called
           validation_set. These cannot be overwritten.

           Later occurrences will default to data_set_xx where xx
           starts at 03 and increments from there. This field can be
           used to customize the latter names.

         * **Path** (*str** | **StringKey*) -- Path to DataSet YAML
           file.

         * **UsePipe** (*BoolType** | **BoolKey*) -- Use AMS Pipe for
           suitable jobs to speed-up evaluation.

   class _Engine

      If set, use this engine for the ParAMS SinglePoint. Mutually
      exclusive with EngineCollection.

   class _ParallelLevels

      Distribution of threads/processes between the parallelization
      levels.

      Variables:
         * **CommitteeMembers** (*int** | **IntKey*) -- Maximum number
           of committee member optimizations to run in parallel. If
           set to zero will take the minimum of
           MachineLearning%CommitteeSize and the number of available
           cores (NSCM)

         * **Cores** (*int** | **IntKey*) -- Number of cores to use
           per committee member optimization. By default (0) the
           available cores (NSCM) divided equally among committee
           members. When using GPU offloading, consider setting this
           to 1.

         * **Jobs** (*int** | **IntKey*) -- Number of JobCollection
           jobs to run in parallel for each loss function evaluation.

         * **Optimizations** (*int** | **IntKey*) -- Number of
           independent optimizers to run in parallel.

         * **ParameterVectors** (*int** | **IntKey*) --

           Number of parameter vectors to try in parallel for each
           optimizer iteration. This level of parallelism can only be
           used with optimizers that support parallel optimization!

           Default (0) will set this value to the number of cores on
           the system divided by the number of optimizers run in
           parallel, i.e., each optimizer will be given an equal share
           of the resources.

         * **Processes** (*int** | **IntKey*) --

           Number of processes (MPI ranks) to spawn for each
           JobCollection job. This effectively sets the NSCM
           environment variable for each job.

           A value of *-1* will disable explicit setting of related
           variables. We recommend a value of *1* in almost all cases.
           A value greater than 1 would only be useful if you
           parametrize DFTB with a serial optimizer and have very few
           jobs in the job collection.

         * **Threads** (*int** | **IntKey*) --

           Number of threads to use for each of the processes. This
           effectively set the OMP_NUM_THREADS environment variable.
           Note that the DFTB engine does not use threads, so the
           value of this variable would not have any effect. We
           recommend always leaving it at the default value of 1.
           Please consult the manual of the engine you are
           parameterizing.

           A value of *-1* will disable explicit setting of related
           variables.

class PreAmsifiedADF

   Variables:
      * **A1Fit** (*float** | **FloatKey*) -- STO-Fit keyword:
        distance between atoms, in Angstrom. The symmetric fit
        approximation is applied only for atoms farther apart.

      * **AOMat2File** (*BoolType** | **BoolKey*) -- Write PMatrix,
        Fock matrix, and overlap matrix on AO basis to file for future
        analysis purposes

      * **AORCOnly** (*BoolType** | **BoolKey*) --

      * **AORXCOnly** (*BoolType** | **BoolKey*) --

      * **AORun** (*BoolType** | **BoolKey*) --

      * **AccurateGradients** (*BoolType** | **BoolKey*) -- Print the
        nuclear gradients with more digits than usual.

      * **AddDiffuseFit** (*BoolType** | **BoolKey*) -- STO-Fit
        keyword: One can get more diffuse fit functions by setting
        this to True.

      * **AllDipMat** (*BoolType** | **BoolKey*) -- Print all dipole
        matrix elements between occupied and virtual Kohn-Sham
        orbitals.

      * **AllPoints** (*BoolType** | **BoolKey*) -- 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.

      * **AllWaals** (*BoolType** | **BoolKey*) --

      * **Allow** (*str** | **StringKey*) --

      * **AltLinVXC** (*BoolType** | **BoolKey*) --

      * **AltOrthon** (*BoolType** | **BoolKey*) --

      * **AltRhof** (*BoolType** | **BoolKey*) --

      * **AnaPol** (*BoolType** | **BoolKey*) --

      * **Balance** (*BoolType** | **BoolKey*) -- Measure the actual
        speed of the nodes in the parallel machine

      * **BasValZero** (*BoolType** | **BoolKey*) -- Debug option

      * **Blapt** (*BoolType** | **BoolKey*) --

      * **BondOrder** (*str** | **StringKey*) --

      * **BoySold** (*BoolType** | **BoolKey*) --

      * **C2Coef** (*BoolType** | **BoolKey*) -- Print C2Coef to
        output

      * **CDataFile** (*str** | **StringKey*) -- Untested and
        undocumented

      * **CM5** (*BoolType** | **BoolKey*) -- Calculate the charge
        model 5 (CM5) analysis.

      * **CRDFilemol** (*str** | **StringKey*) -- Untested and
        undocumented

      * **CRDFilemopac** (*str** | **StringKey*) -- Untested and
        undocumented

      * **CRDFilexyz** (*str** | **StringKey*) -- Untested and
        undocumented

      * **CalcOverlapOnly** (*BoolType** | **BoolKey*) -- Calculate
        overlaps of primitive basis and stops after computing them.

      * **CalcTotalEnergy** (*BoolType** | **BoolKey*) -- Whether or
        not to calculate the total energy.

      * **Charge** (*Iterable**[**float**] **| **FloatListKey*) --
        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.

      * **ChkDisFal** (*BoolType** | **BoolKey*) --

      * **ColTDDFT** (*BoolType** | **BoolKey*) --

      * **Collinear** (*BoolType** | **BoolKey*) -- Use collinear
        approximation (only relevant in the case of Spin-Orbit
        coupling).

      * **CommTiming** (*BoolType** | **BoolKey*) --

      * **ComplexAcl** (*BoolType** | **BoolKey*) --

      * **CoreTables** (*BoolType** | **BoolKey*) --

      * **CoulombFit** (*BoolType** | **BoolKey*) --

      * **Create** (*str** | **StringKey*) -- Keywords for create run.
        {Atomtype Datafile}

      * **DFTBParams** (*BoolType** | **BoolKey*) --

      * **DRho241** (*BoolType** | **BoolKey*) --

      * **Database** (*str** | **StringKey*) -- Untested and
        undocumented

      * **Debug** (*str** | **StringKey*) --

      * **DeltaEpStrip** (*BoolType** | **BoolKey*) --

      * **DensPrep** (*BoolType** | **BoolKey*) --

      * **Diffuse** (*BoolType** | **BoolKey*) --

      * **DipoleLength** (*BoolType** | **BoolKey*) -- Use dipole-
        length elements for perturbing (external) integrals in CURRENT
        response

      * **DipoleResponse** (*BoolType** | **BoolKey*) --

      * **EField** (*str** | **StringKey*) -- Electric field.

      * **EGOXAlpha** (*BoolType** | **BoolKey*) --

      * **EnergyTest** (*BoolType** | **BoolKey*) --

      * **ExactDensity** (*BoolType** | **BoolKey*) -- Use the exact
        density (as opposed to the fitted density) for the computation
        of the exchange-correlation potential

      * **ExtendPopAn** (*BoolType** | **BoolKey*) --

      * **ExtendedPopan** (*BoolType** | **BoolKey*) -- Calculate the
        Mayer bond orders and Mulliken atom-atom populations per
        l-value

      * **FitAlfa** (*BoolType** | **BoolKey*) --

      * **FitExcit** (*BoolType** | **BoolKey*) --

      * **FitFile** (*str** | **StringKey*) --

      * **Fitelstat** (*BoolType** | **BoolKey*) --

      * **Fithyppol** (*BoolType** | **BoolKey*) --

      * **Fitmeta** (*BoolType** | **BoolKey*) --

      * **Fitsecder** (*BoolType** | **BoolKey*) --

      * **ForceALDA** (*BoolType** | **BoolKey*) -- 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

      * **FragMetaGGAToten** (*BoolType** | **BoolKey*) -- 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.

      * **FullFock** (*BoolType** | **BoolKey*) -- Calculate the full
        Fock matrix each SCF iteration (instead of the difference with
        the previous cycle).

      * **FullSCF** (*BoolType** | **BoolKey*) --

      * **FullTotEn** (*BoolType** | **BoolKey*) --

      * **Fuzzy_BO** (*BoolType** | **BoolKey*) --

      * **GSCorr** (*BoolType** | **BoolKey*) -- 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.

      * **GZip** (*str** | **StringKey*) -- GZip the corresponding
        tape (possibly working only for TAPE21)

      * **GaugeOrigin** (*Iterable**[**float**] **| **FloatListKey*)
        -- Untested and undocumented

      * **Gradient** (*BoolType** | **BoolKey*) --

        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.

      * **HFAtomsPerPass** (*int** | **IntKey*) -- Memory usage option
        for old HF scheme

      * **HFDependency** (*BoolType** | **BoolKey*) -- Untested and
        undocumented

      * **HFMaxMemory** (*int** | **IntKey*) -- Memory usage option
        for old HF scheme

      * **HartreeFock** (*BoolType** | **BoolKey*) -- Compute hybrid
        meta-GGA energy functionals (if METAGGA key is True)

      * **HessTest** (*BoolType** | **BoolKey*) -- Print the force
        field derived initial Hessian.

      * **Hilbert** (*BoolType** | **BoolKey*) --

      * **IgnoreOverlap** (*BoolType** | **BoolKey*) --

      * **ImportEmbPot** (*str** | **StringKey*) -- File containing an
        external embedding potential (FDE calculations only)

      * **ImportGrid** (*str** | **StringKey*) --

      * **IsotopicShift** (*str** | **StringKey*) -- Untested

      * **KSSpectrum** (*BoolType** | **BoolKey*) --

      * **LB4** (*BoolType** | **BoolKey*) --

      * **Lap1** (*BoolType** | **BoolKey*) --

      * **LinTermVXC** (*BoolType** | **BoolKey*) --

      * **MBlockBig** (*BoolType** | **BoolKey*) --

      * **MBlockSmall** (*BoolType** | **BoolKey*) --

      * **MOExactDensity** (*BoolType** | **BoolKey*) --

      * **MetaGGA** (*BoolType** | **BoolKey*) --

      * **NewDIIS** (*BoolType** | **BoolKey*) --

      * **NoBeckeGrid** (*BoolType** | **BoolKey*) --

      * **NoESRfcsd** (*BoolType** | **BoolKey*) --

      * **NoESRpso** (*BoolType** | **BoolKey*) --

      * **NoFDEPot** (*BoolType** | **BoolKey*) --

      * **NoFragDp** (*BoolType** | **BoolKey*) --

      * **NoGTerm** (*BoolType** | **BoolKey*) --

      * **NoPrint** (*str** | **StringKey*) --

      * **NoSharedArrays** (*BoolType** | **BoolKey*) --

      * **NoSymFit** (*BoolType** | **BoolKey*) --

      * **NoTotEn** (*BoolType** | **BoolKey*) --

      * **NoUpdFac** (*BoolType** | **BoolKey*) --

      * **NonCollinear** (*BoolType** | **BoolKey*) -- Use non-
        collinear approximation (only relevant in the case of Spin-
        Orbit coupling).

      * **NuclearModel** (*Literal**[**"PointCharge"**,
        **"Gaussian"**]*) --

        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.

      * **NumericalQuality** (*Literal**[**"Basic"**, **"Normal"**,
        **"Good"**, **"VeryGood"**, **"Excellent"**]*) -- 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')

      * **OPop_Analysis** (*str** | **StringKey*) --

      * **Occupations** (*str** | **StringKey*) -- Occupations options

      * **OrbitalsCoulombInteraction** (*Iterable**[**int**] **|
        **IntListKey*) -- 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).

      * **OrthFragPrep** (*BoolType** | **BoolKey*) --

      * **PartialZORA** (*str** | **StringKey*) -- Untested and
        undocumented

      * **Print** (*str** | **StringKey*) --

      * **ProgConv** (*BoolType** | **BoolKey*) --

      * **QTens** (*BoolType** | **BoolKey*) -- Calculate the the
        Nuclear Electric Quadrupole Hyperfine interaction (Q-tensor,
        NQCC, NQI), related to the Electric Field Gradient (EFG).

      * **RConfine** (*Iterable**[**float**] **| **FloatListKey*) --
        Untested and undocumented

      * **RESTOCC** (*BoolType** | **BoolKey*) --

      * **RamanRange** (*str** | **StringKey*) --

      * **ReducedMass** (*BoolType** | **BoolKey*) -- Print reduced
        mass for each normal mode

      * **Relativistic** (*str** | **StringKey*) -- instructs ADF to
        take relativistic effects into account.

      * **RemoveAllFragVirtuals** (*BoolType** | **BoolKey*) --

      * **SFTDDFT** (*BoolType** | **BoolKey*) -- Calculate spin-flip
        excitation energies (requires TDA and FORCEALDA keys).

      * **SOMCD** (*BoolType** | **BoolKey*) --

      * **SOUExact** (*BoolType** | **BoolKey*) --

      * **STContrib** (*BoolType** | **BoolKey*) --

      * **STOFit** (*BoolType** | **BoolKey*) --

      * **Save** (*str** | **StringKey*) --

      * **ScanFreq** (*str** | **StringKey*) --

      * **SharcOverlap** (*BoolType** | **BoolKey*) --

      * **Skip** (*str** | **StringKey*) --

      * **StopAfter** (*str** | **StringKey*) --

      * **Symmetry** (*str** | **StringKey*) -- The Schonfliess
        symmetry symbol. A tolerance can be supplied.

      * **TDA** (*BoolType** | **BoolKey*) -- Use the Tamm-Dancoff
        approximation (TDA) (requires the EXCITATION block key)

      * **TDDFTSO** (*BoolType** | **BoolKey*) --

      * **Title** (*str** | **StringKey*) -- Title of the calculation.

      * **TotalEnergy** (*BoolType** | **BoolKey*) --

        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.

      * **TransferIntegrals** (*BoolType** | **BoolKey*) --

        Calculate the charge transfer integrals, spatial overlap
        integrals and site energies.

        Charge transfer integrals can be used in models that calculate
        transport properties.

      * **Unrestricted** (*BoolType** | **BoolKey*) -- By default, a
        spin-restricted calculation is performed where the spin alpha
        and spin beta orbitals are spatially the same.

      * **UnrestrictedFragments** (*BoolType** | **BoolKey*) --

        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.

      * **UsePseudoDiag** (*BoolType** | **BoolKey*) --

      * **UseSPCode** (*BoolType** | **BoolKey*) -- Use Patchkovskii
        routines for PBE

      * **VCD** (*BoolType** | **BoolKey*) -- Calculate rotational
        strength during an analytical frequencies calculation.

      * **VectorLength** (*int** | **IntKey*) -- Specify a different
        batch size for the integration points here (default: 128 on
        most machines and 2047 on vector machines).

      * **ZExact** (*BoolType** | **BoolKey*) --

      * **ZFS** (*str** | **StringKey*) --

      * **gpuenabled** (*BoolType** | **BoolKey*) --

      * **grad_no_fragment_potentials** (*BoolType** | **BoolKey*) --

      * **grad_trf_btrf** (*BoolType** | **BoolKey*) --

      * **hydrogenbonds** (*BoolType** | **BoolKey*) --

      * **nocalcs2** (*BoolType** | **BoolKey*) --

      * **nodrop** (*BoolType** | **BoolKey*) --

      * **noerror** (*BoolType** | **BoolKey*) --

      * **nogiao** (*BoolType** | **BoolKey*) --

      * **nomorton** (*BoolType** | **BoolKey*) --

      * **nopm5rho** (*BoolType** | **BoolKey*) --

      * **notstcoe** (*BoolType** | **BoolKey*) --

      * **nouseactivefrag** (*BoolType** | **BoolKey*) --

      * **novkpot** (*BoolType** | **BoolKey*) --

      * **noxcprint** (*BoolType** | **BoolKey*) --

      * **oldblockedsmat** (*BoolType** | **BoolKey*) --

      * **oldorthon** (*BoolType** | **BoolKey*) --

      * **peano** (*BoolType** | **BoolKey*) --

      * **plap3** (*BoolType** | **BoolKey*) --

      * **prepvibron** (*BoolType** | **BoolKey*) --

      * **prtallten** (*BoolType** | **BoolKey*) --

      * **prtiao** (*BoolType** | **BoolKey*) --

      * **quild_nocoords_in_log** (*BoolType** | **BoolKey*) --

      * **readepsilons** (*BoolType** | **BoolKey*) --

      * **readfcfile** (*BoolType** | **BoolKey*) --

      * **rhobelpotimport** (*BoolType** | **BoolKey*) --

      * **riskyfast** (*BoolType** | **BoolKey*) --

      * **scaledkinfunctionals** (*BoolType** | **BoolKey*) --

      * **sfguess** (*BoolType** | **BoolKey*) --

      * **sfotrans** (*BoolType** | **BoolKey*) --

      * **skipcoulombpot** (*BoolType** | **BoolKey*) --

      * **skorthon** (*BoolType** | **BoolKey*) --

      * **solv** (*BoolType** | **BoolKey*) --

      * **soux** (*BoolType** | **BoolKey*) --

      * **souy** (*BoolType** | **BoolKey*) --

      * **sozero** (*BoolType** | **BoolKey*) --

      * **switchcoe** (*BoolType** | **BoolKey*) --

      * **symexcit** (*BoolType** | **BoolKey*) --

      * **symresp** (*BoolType** | **BoolKey*) --

      * **testaor** (*BoolType** | **BoolKey*) --

      * **testfit** (*BoolType** | **BoolKey*) --

      * **testjob** (*BoolType** | **BoolKey*) --

      * **testpscharge** (*BoolType** | **BoolKey*) --

      * **testsub1** (*BoolType** | **BoolKey*) --

      * **totenskip** (*BoolType** | **BoolKey*) --

      * **trustsfguess** (*BoolType** | **BoolKey*) --

      * **userlegmn** (*BoolType** | **BoolKey*) --

      * **usesumfragp** (*BoolType** | **BoolKey*) --

      * **xonly** (*BoolType** | **BoolKey*) --

      * **xyonly** (*BoolType** | **BoolKey*) --

      * **xzonly** (*BoolType** | **BoolKey*) --

      * **yonly** (*BoolType** | **BoolKey*) --

      * **yzonly** (*BoolType** | **BoolKey*) --

      * **zonly** (*BoolType** | **BoolKey*) --

      * **AOResponse** (*PreAmsifiedADF._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

      * **AnalyticalFreq** (*PreAmsifiedADF._AnalyticalFreq*) --
        Calculate the harmonic frequencies analytically

      * **Aromaticity** (*str** | **Sequence**[**str**] **|
        **FreeBlock*) -- Calculate aromaticity indicators, i.e. the
        matrix of localization/delocalization indices (LI-DI), Iring
        (ring index) and MCI (multi center index) aromaticity indices.

      * **AtomProps** (*str** | **Sequence**[**str**] **|
        **FreeBlock*) --

      * **Atoms** (*str** | **Sequence**[**str**] **| **FreeBlock*) --
        Atomic positions

      * **Basis** (*str** | **Sequence**[**str**] **| **FreeBlock*) --
        Not to be used. Use $ADFBIN/adf (NOT adf.exe!) to run this job

      * **BeckeGrid** (*PreAmsifiedADF._BeckeGrid*) -- Options for the
        numerical integration grid.

      * **CDFT** (*PreAmsifiedADF._CDFT*) -- CDFT is a tool for
        carrying out DFT calculations in the presence of a constraint.

      * **CVNDFT** (*PreAmsifiedADF._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.

      * **ConceptualDFT** (*PreAmsifiedADF._ConceptualDFT*) --
        Conceptual DFT Properties

      * **Constraints** (*str** | **Sequence**[**str**] **|
        **FreeBlock*) --

      * **ConstructPot** (*PreAmsifiedADF._ConstructPot*) -- Reads a
        density from a TAPE41 file and constructs numerically the
        corresponding potential to it

      * **CorePotentials** (*str** | **Sequence**[**str**] **|
        **FreeBlock*) -- With the key COREPOTENTIALS you specify the
        core file and (optionally) which sections pertain to the
        distinct atom types in the molecule.

      * **CurrentResponse** (*PreAmsifiedADF._CurrentResponse*) --

      * **DIMPAR** (*str** | **Sequence**[**str**] **| **FreeBlock*)
        --

      * **DIMQM** (*str** | **Sequence**[**str**] **| **FreeBlock*) --

      * **Dependency** (*PreAmsifiedADF._Dependency*) --

      * **EPrint** (*PreAmsifiedADF._EPrint*) -- Print switches that
        require more specification than just off or on

      * **ESR** (*PreAmsifiedADF._ESR*) --

      * **ETSNOCV** (*PreAmsifiedADF._ETSNOCV*) -- Perform ETS-NOCV
        analysis.

      * **ElectronTransfer** (*PreAmsifiedADF._ElectronTransfer*) --

      * **EnergyFrag** (*str** | **Sequence**[**str**] **|
        **FreeBlock*) --

      * **Excitations** (*PreAmsifiedADF._Excitations*) -- Excitation
        energies: UV/Vis

      * **ExcitedGO** (*PreAmsifiedADF._ExcitedGO*) -- Excited state
        geometry optimization

      * **Externals** (*str** | **Sequence**[**str**] **|
        **FreeBlock*) -- Legacy support of the older DRF code

      * **FDE** (*PreAmsifiedADF._FDE*) -- Frozen Density Embedding
        options

      * **Fitnadkin** (*str** | **Sequence**[**str**] **|
        **FreeBlock*) --

      * **FragOccupations** (*str** | **Sequence**[**str**] **|
        **FreeBlock*) --

      * **Fragments** (*str** | **Sequence**[**str**] **|
        **FreeBlock*) -- Definitions of the fragment type/files:
        {FragmentName FragmentFile}. In the block header one can
        specify the directory where the fragment files are located

      * **GUIBonds** (*str** | **Sequence**[**str**] **| **FreeBlock*)
        -- The bonds used by the GUI (this does not affect the ADF
        calculation in any way)

      * **GeoVar** (*str** | **Sequence**[**str**] **| **FreeBlock*)
        --

      * **Geometry** (*PreAmsifiedADF._Geometry*) -- Geometry
        Optimizations procedure

      * **HessDiag** (*PreAmsifiedADF._HessDiag*) -- Diagonal Hessian
        elements... Placeholder

      * **IQA** (*PreAmsifiedADF._IQA*) -- Bond energy decomposition
        based on the interacting quantum atoms (IQA) approach and
        using QTAIM real-space partition.

      * **IRCStart** (*str** | **Sequence**[**str**] **| **FreeBlock*)
        --

      * **Integration** (*str** | **Sequence**[**str**] **|
        **FreeBlock*) -- Options for the obsolete Voronoi numerical
        integration scheme

      * **IrrepOccupations** (*str** | **Sequence**[**str**] **|
        **FreeBlock*) -- Explicit occupation numbers per irrep

      * **LinearConstraints** (*str** | **Sequence**[**str**] **|
        **FreeBlock*) --

      * **LinearScaling** (*PreAmsifiedADF._LinearScaling*) --

      * **LocOrb** (*str** | **Sequence**[**str**] **| **FreeBlock*)
        --

      * **MDC** (*PreAmsifiedADF._MDC*) -- Options for Multipole
        Derived Charges (MDC)

      * **MP2** (*PreAmsifiedADF._MP2*) -- Technical aspects of the
        MP2 algorithm.

      * **ModifyExcitation** (*PreAmsifiedADF._ModifyExcitation*) --

      * **ModifyStartPotential** (*str** | **Sequence**[**str**] **|
        **FreeBlock*) --

      * **PertLoc** (*PreAmsifiedADF._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.

      * **PointCharges** (*str** | **Sequence**[**str**] **|
        **FreeBlock*) -- Point charges: {x y z q}

      * **PolTDDFT** (*PreAmsifiedADF._PolTDDFT*) -- TODO!

      * **QMMM** (*str** | **Sequence**[**str**] **| **FreeBlock*) --

      * **QTAIM** (*PreAmsifiedADF._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.

      * **RIHartreeFock** (*PreAmsifiedADF._RIHartreeFock*) --

      * **RISM** (*str** | **Sequence**[**str**] **| **FreeBlock*) --
        3D-RISM-related input keys.

      * **RadialCoreGrid** (*PreAmsifiedADF._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.

      * **RemoveFragOrbitals** (*str** | **Sequence**[**str**] **|
        **FreeBlock*) --

      * **Response** (*PreAmsifiedADF._Response*) -- The calculation
        of frequency-dependent (hyper)polarizabilities and related
        properties (Raman, ORD)

      * **Restart** (*PreAmsifiedADF._Restart*) -- Options for
        restarts

      * **Restraint** (*str** | **Sequence**[**str**] **|
        **FreeBlock*) --

      * **SCF** (*PreAmsifiedADF._SCF*) -- Control aspects of the Self
        Consistent Field procedure

      * **SCRF** (*str** | **Sequence**[**str**] **| **FreeBlock*) --

      * **SICOEP** (*str** | **Sequence**[**str**] **| **FreeBlock*)
        --

      * **SOPert** (*PreAmsifiedADF._SOPert*) --

      * **SelectExcitation** (*PreAmsifiedADF._SelectExcitation*) --

      * **SlaterDeterminants** (*str** | **Sequence**[**str**] **|
        **FreeBlock*) --

      * **Solvation** (*PreAmsifiedADF._Solvation*) --

      * **SubExci** (*PreAmsifiedADF._SubExci*) -- Subsystem TDDFT
        (FDE)

      * **SubResponse** (*str** | **Sequence**[**str**] **|
        **FreeBlock*) -- Untested and undocumented

      * **TSRC** (*str** | **Sequence**[**str**] **| **FreeBlock*) --
        Transition State Reaction Coordinate (TSRC)

      * **Tails** (*PreAmsifiedADF._Tails*) -- Obsolete option for
        linear scaling and distance effects. We recommend using the
        LinearScaling key instead.

      * **Thermo** (*PreAmsifiedADF._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

      * **Units** (*PreAmsifiedADF._Units*) -- Definitions of the
        units.

      * **VSCRF** (*str** | **Sequence**[**str**] **| **FreeBlock*) --

      * **Vibron** (*PreAmsifiedADF._Vibron*) -- Resonance Raman Input
        options

      * **XC** (*PreAmsifiedADF._XC*) -- Definition of the XC.

      * **XES** (*PreAmsifiedADF._XES*) -- X-ray emission spectroscopy

      * **ZlmFit** (*PreAmsifiedADF._ZlmFit*) -- Options for the
        density fitting scheme 'ZlmFit'.

   class _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

      Variables:
         * **2ANTISYM** (*BoolType** | **BoolKey*) --

         * **ALDA** (*BoolType** | **BoolKey*) -- Use ALDA only

         * **Alpha** (*BoolType** | **BoolKey*) -- Calculate linear
           response

         * **Beta** (*BoolType** | **BoolKey*) -- Will use 2n+1 rule
           to calculate beta.

         * **CALCTRANSFORMPROP** (*str** | **StringKey*) --
           Transformation Properties of Polarizabilities

         * **CHANGESIGN** (*BoolType** | **BoolKey*) --

         * **Components** (*str** | **StringKey*) -- 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

         * **Cubic** (*BoolType** | **BoolKey*) -- Calculate cubic
           response

         * **Damp** (*float** | **FloatKey*) -- Specify damping for
           non-acceleration iteration

         * **Debug** (*int** | **IntKey*) -- Debug level for
           AOResponse.

         * **DoNothing** (*BoolType** | **BoolKey*) -- Do nothing.

         * **EFG** (*str** | **StringKey*) --

         * **EFIOR** (*BoolType** | **BoolKey*) --

         * **EFISHG** (*BoolType** | **BoolKey*) --

         * **EFPLOT** (*BoolType** | **BoolKey*) --

         * **EL_DIPOLE_EL_DIPOLE** (*str** | **StringKey*) --

         * **EL_DIPOLE_EL_OCTUPOLE** (*str** | **StringKey*) --

         * **EL_DIPOLE_EL_QUADRUPOLE** (*str** | **StringKey*) --

         * **EL_DIPOLE_MAG_DIPOLE** (*str** | **StringKey*) --

         * **EL_DIPOLE_MAG_QUADRUPOLE** (*str** | **StringKey*) --

         * **EL_QUADRUPOLE_EL_QUADRUPOLE** (*str** | **StringKey*) --

         * **EL_QUADRUPOLE_MAG_DIPOLE** (*str** | **StringKey*) --

         * **EOPE** (*BoolType** | **BoolKey*) --

         * **FULLMAT** (*BoolType** | **BoolKey*) --

         * **FitAODeriv** (*BoolType** | **BoolKey*) -- Use FITAODERIV
           for Coulomb potential

         * **FreqRange** (*str** | **StringKey*) -- 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

         * **Frequency** (*str** | **StringKey*) -- 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

         * **GIAO** (*BoolType** | **BoolKey*) -- Use gauge-included
           atomic orbitals

         * **Gamma** (*BoolType** | **BoolKey*) -- Will use 2n+1 rule
           to calculate gamma.

         * **HirshPol** (*BoolType** | **BoolKey*) -- Hirshfeld
           Polarizability of fragments

         * **IDRI** (*BoolType** | **BoolKey*) --

         * **LifeTime** (*float** | **FloatKey*) -- 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].

         * **MAG_DIPOLE_MAG_DIPOLE** (*str** | **StringKey*) --

         * **MagOptRot** (*BoolType** | **BoolKey*) -- Calculate
           magneto-optical rotation

         * **MagneticPert** (*BoolType** | **BoolKey*) -- Use magnetic
           field as a perturbation

         * **NBO** (*BoolType** | **BoolKey*) -- Perform NBO analysis

         * **NoCore** (*BoolType** | **BoolKey*) -- if NOCORE is set
           we skip the core potential in diamagnetic term and/or in
           the unperturbed density of the CPKS solvers

         * **OCCOCC** (*BoolType** | **BoolKey*) -- occ-occ block
           response (not GIAO) - Experimental

         * **OKE** (*BoolType** | **BoolKey*) --

         * **ONLYANTISYM** (*BoolType** | **BoolKey*) --

         * **ONLYSYM** (*BoolType** | **BoolKey*) --

         * **OPTICALR** (*BoolType** | **BoolKey*) --

         * **OnlyPot** (*BoolType** | **BoolKey*) -- Calculation only
           potential for debugging purposes

         * **OpticalRotation** (*BoolType** | **BoolKey*) -- Calculate
           optical rotation

         * **PBE0LDA** (*BoolType** | **BoolKey*) --

         * **QuadBeta** (*BoolType** | **BoolKey*) -- Quadrupole
           operators with beta tensor

         * **QuadPert** (*BoolType** | **BoolKey*) -- Calculate
           quadrupole-quadrupole polarizability

         * **Quadratic** (*BoolType** | **BoolKey*) -- Calculate
           quadratic response

         * **Quadrupole** (*BoolType** | **BoolKey*) -- Calculate
           dipole-quadrupole polarizability

         * **REVPBE** (*BoolType** | **BoolKey*) --

         * **Raman** (*BoolType** | **BoolKey*) --

         * **SCF** (*str** | **StringKey*) -- 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.

         * **SHG** (*BoolType** | **BoolKey*) --

         * **STATIC** (*BoolType** | **BoolKey*) --

         * **THG** (*BoolType** | **BoolKey*) --

         * **TPA** (*BoolType** | **BoolKey*) --

         * **Traceless** (*BoolType** | **BoolKey*) -- Traceless
           quadrupole tensors

         * **USEHP** (*BoolType** | **BoolKey*) --

         * **VROA** (*BoolType** | **BoolKey*) -- Calculate
           Vibrational Raman Optical Activity.

         * **VelocityOrd** (*BoolType** | **BoolKey*) -- Use
           VelocityOrd without GIAOs

         * **XAlpha** (*BoolType** | **BoolKey*) -- Xalpha potential

   class _AnalyticalFreq

      Calculate the harmonic frequencies analytically

      Variables:
         * **B1Size** (*float** | **FloatKey*) -- Sparse grid max
           memory size

         * **B1Thresh** (*float** | **FloatKey*) -- MMGF_DENB1 and
           MMGF_GRADB1 cutoff values

         * **Check_CPKS_From_Iteration** (*int** | **IntKey*) --
           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.

         * **Debug** (*str** | **StringKey*) -- For debugging
           purposes. Options: fit, hessian, b1, densities, numbers,
           symmetry, all.

         * **Hessian** (*Literal**[**"reflect"**, **"average"**]*) --
           Whether the final Hessian is obtained by reflecting or
           averaging?

         * **Max_CPKS_Iterations** (*int** | **IntKey*) -- 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.

         * **Nuc** (*Iterable**[**int**] **| **IntListKey*) -- 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

         * **Print** (*str** | **StringKey*) -- 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.

         * **Test** (*str** | **StringKey*) -- Test COSMO

         * **U1_Accuracy** (*float** | **FloatKey*) -- 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.

   class _Aromaticity

      Calculate aromaticity indicators, i.e. the matrix of
      localization/delocalization indices (LI-DI), Iring (ring index)
      and MCI (multi center index) aromaticity indices.

   class _AtomProps

   class _Atoms

      Atomic positions

   class _Basis

      Not to be used. Use $ADFBIN/adf (NOT adf.exe!) to run this job

   class _BeckeGrid

      Options for the numerical integration grid.

      Variables:
         * **AllowAngularBoost** (*BoolType** | **BoolKey*) -- Allow
           automatic augmentation of the Lebedev spherical grid for
           highly coordinated atoms.

         * **InnerShellsPruning** (*BoolType** | **BoolKey*) -- Allow
           automatic pruning of the Lebedev spherical grid for shells
           close to the nuclei.

         * **PartitionFunPruning** (*BoolType** | **BoolKey*) -- Allow
           pruning of integration points based on the value of the
           partition function.

         * **QPNear** (*float** | **FloatKey*) -- 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

         * **Quality** (*Literal**[**"Auto"**, **"Basic"**,
           **"Normal"**, **"Good"**, **"VeryGood"**,
           **"Excellent"**]*) -- 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.

         * **RadialGridBoost** (*float** | **FloatKey*) -- 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.

         * **AtomDepQuality** (*str** | **Sequence**[**str**] **|
           **FreeBlock*) -- One can define a different grid quality
           for each atom.

      class _AtomDepQuality

         One can define a different grid quality for each atom.

   class _CDFT

      CDFT is a tool for carrying out DFT calculations in the presence
      of a constraint.

      Variables:
         * **AllAtoms** (*BoolType** | **BoolKey*) -- If AllAtoms is
           true, then TheAtoms is overridden and all the atoms in the
           active fragment are included in the set.

         * **AnalyticalHessian** (*int** | **IntKey*) -- 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.

         * **ChargeAndSpin** (*BoolType** | **BoolKey*) -- will
           constrain both the charge and the spin

         * **Constraints** (*Iterable**[**float**] **|
           **FloatListKey*) -- 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.

         * **DoNotOptimize** (*BoolType** | **BoolKey*) -- If true,
           the multipliers chosen in INITIALMULTIPLIERS will not be
           optimized and will be constant throughout the entire SCF
           procedure.

         * **ExcitedCDFT** (*BoolType** | **BoolKey*) -- 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.

         * **InitialMultipliers** (*Iterable**[**float**] **|
           **FloatListKey*) -- If available, a guess for the Lagrange
           multipliers can be entered.

         * **MaxIter** (*int** | **IntKey*) -- Maximum number of CDFT
           iterations. CDFT carries out a loop nested inside the SCF
           cycle.

         * **Metric** (*BoolType** | **BoolKey*) -- metric parameter
           p, d and m that characterizes the quality of the XCDFT
           excitation.

         * **NAtomsPerSet** (*Iterable**[**int**] **| **IntListKey*)
           -- The number of atoms in each moiety (set).

         * **NConstraints** (*int** | **IntKey*) -- 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.

         * **OnlyCharge** (*BoolType** | **BoolKey*) -- Will constrain
           only the charge, letting spin relax (and potentially
           delocalize)

         * **OnlySpin** (*BoolType** | **BoolKey*) -- Will constrain
           only the spin

         * **PopType** (*Literal**[**"yukawalike"**,
           **"fuzzyvoronoibecke"**, **"fuzzyvoronoifermi"**]*) -- The
           population analysis chosen for determining the constraint.

         * **Print** (*Literal**[**"low"**, **"medium"**,
           **"high"**]*) -- Print level and debugging.

         * **SelfConsistent** (*BoolType** | **BoolKey*) -- Self-
           Consistent CDFT

         * **StepSize** (*float** | **FloatKey*) -- The amount of the
           Lagrange multipliers step taken in each CDFT iteration

         * **TheAtoms** (*Iterable**[**int**] **| **IntListKey*) --
           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.

         * **Threshold** (*float** | **FloatKey*) -- The threshold for
           convergence of the CDFT constraints. The tighter the SCF
           convergence criteria, the tighter the THRESHOLD should be.

   class _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.

      Variables:
         * **Iteration** (*int** | **IntKey*) -- The maximum number of
           iterations

         * **Tolerance** (*float** | **FloatKey*) -- The convergence
           criterion, i.e. the SCF-CV(infinity)-DFT procedure stops
           when the given accuracy is achieved.

         * **CV_DFT** (*PreAmsifiedADF._CVNDFT._CV_DFT*) -- The
           simplest case: the TDDFT transition density U-vector is
           substituted into the infinite order CV(infinity)-DFT
           excitation energy

         * **DSCF_CV_DFT** (*PreAmsifiedADF._CVNDFT._DSCF_CV_DFT*) --
           The simplest case: the TDDFT transition density U-vector is
           substituted into the infinite order CV(infinity)-DFT
           excitation energy

         * **RSCF_CV_DFT** (*PreAmsifiedADF._CVNDFT._RSCF_CV_DFT*) --
           The simplest case: the TDDFT transition density U-vector is
           substituted into the infinite order CV(infinity)-DFT
           excitation energy

         * **R_CV_DFT** (*PreAmsifiedADF._CVNDFT._R_CV_DFT*) -- The
           simplest case: the TDDFT transition density U-vector is
           substituted into the infinite order CV(infinity)-DFT
           excitation energy

         * **SCF_CV_DFT** (*PreAmsifiedADF._CVNDFT._SCF_CV_DFT*) --
           The simplest case: the TDDFT transition density U-vector is
           substituted into the infinite order CV(infinity)-DFT
           excitation energy

      class _CV_DFT

         The simplest case: the TDDFT transition density U-vector is
         substituted into the infinite order CV(infinity)-DFT
         excitation energy

         Variables:
            **InitGuess** (*Literal**[**"TDDFT"**, **"SOR"**]*) --
            Initial guess

      class _DSCF_CV_DFT

         The simplest case: the TDDFT transition density U-vector is
         substituted into the infinite order CV(infinity)-DFT
         excitation energy

         Variables:
            * **DampOrbRelax** (*float** | **FloatKey*) -- The
              mix_relax parameter defines the relative weight of the
              new relaxation vector that is added to the one from the
              previous iteration.

            * **DampVariable** (*BoolType** | **BoolKey*) -- Damping
              condition

            * **Damping** (*float** | **FloatKey*) -- Damping

            * **InitGuess** (*Literal**[**"TDDFT"**, **"SOR"**]*) --
              Initial guess

            * **Optimize** (*Literal**[**"SVD"**, **"SOR"**,
              **"COL"**]*) -- Gradient optimization method

            * **RelaxAlpha** (*int** | **IntKey*) -- The SCF cycle
              number at which the relaxation of alpha orbitals starts.

            * **RelaxBeta** (*int** | **IntKey*) -- The SCF cycle
              number at which the relaxation of beta orbitals starts.

      class _RSCF_CV_DFT

         The simplest case: the TDDFT transition density U-vector is
         substituted into the infinite order CV(infinity)-DFT
         excitation energy

         Variables:
            * **DampOrbRelax** (*float** | **FloatKey*) -- The
              mix_relax parameter defines the relative weight of the
              new relaxation vector that is added to the one from the
              previous iteration.

            * **DampVariable** (*BoolType** | **BoolKey*) -- Damping
              condition

            * **Damping** (*float** | **FloatKey*) -- Damping

            * **InitGuess** (*Literal**[**"TDDFT"**, **"SOR"**]*) --
              Initial guess

            * **RelaxAlpha** (*int** | **IntKey*) -- The SCF cycle
              number at which the relaxation of alpha orbitals starts.

            * **RelaxBeta** (*int** | **IntKey*) -- The SCF cycle
              number at which the relaxation of beta orbitals starts.

      class _R_CV_DFT

         The simplest case: the TDDFT transition density U-vector is
         substituted into the infinite order CV(infinity)-DFT
         excitation energy

         Variables:
            * **DampOrbRelax** (*float** | **FloatKey*) -- The
              mix_relax parameter defines the relative weight of the
              new relaxation vector that is added to the one from the
              previous iteration.

            * **DampVariable** (*BoolType** | **BoolKey*) -- Damping
              condition

            * **InitGuess** (*Literal**[**"TDDFT"**, **"SOR"**]*) --
              Initial guess

            * **RelaxAlpha** (*int** | **IntKey*) -- The SCF cycle
              number at which the relaxation of alpha orbitals starts.

            * **RelaxBeta** (*int** | **IntKey*) -- The SCF cycle
              number at which the relaxation of beta orbitals starts.

      class _SCF_CV_DFT

         The simplest case: the TDDFT transition density U-vector is
         substituted into the infinite order CV(infinity)-DFT
         excitation energy

         Variables:
            * **DampVariable** (*BoolType** | **BoolKey*) -- Damping
              condition

            * **Damping** (*float** | **FloatKey*) -- Damping

            * **InitGuess** (*Literal**[**"TDDFT"**, **"SOR"**]*) --
              Initial guess

   class _ConceptualDFT

      Conceptual DFT Properties

      Variables:
         * **AnalysisLevel** (*Literal**[**"Normal"**, **"Extended"**,
           **"Full"**]*) --

           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.

         * **AtomsToDo** (*Iterable**[**int**] **| **IntListKey*) --
           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.

         * **Electronegativity** (*BoolType** | **BoolKey*) --
           Calculate atomic electronegativities. Requires an all-
           electron calculation (no frozen core), triggers the
           TotalEnergy and increases the [AnalysisLevel] to at least
           Extended.

         * **Enabled** (*BoolType** | **BoolKey*) -- Calculate
           Conceptual DFT properties.

         * **Domains** (*PreAmsifiedADF._ConceptualDFT._Domains*) --
           Calculate integrated properties for the domains (same sign)
           of the dual descriptor.

      class _Domains

         Calculate integrated properties for the domains (same sign)
         of the dual descriptor.

         Variables:
            * **Border** (*float** | **FloatKey*) -- 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.

            * **Display** (*float** | **FloatKey*) -- Domains for
              which the integrated DD value is smaller (in magnitude)
              than the specified value are omitted from the printed
              output.

            * **Enabled** (*BoolType** | **BoolKey*) -- Calculate
              properties of reactivity domains.

            * **Ensemble** (*Literal**[**"Canonical"**,
              **"GrandCanonical"**]*) -- 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.

            * **Radius** (*float** | **FloatKey*) -- 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.

            * **Spacing** (*float** | **FloatKey*) -- 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.

            * **Threshold** (*float** | **FloatKey*) -- Arbitrary
              value of dual descriptor used to separate DD domains
              (values below this threshold are ignored).

   class _Constraints

   class _ConstructPot

      Reads a density from a TAPE41 file and constructs numerically
      the corresponding potential to it

      Variables:
         * **CPBasis** (*BoolType** | **BoolKey*) --

         * **CPGrid** (*BoolType** | **BoolKey*) --

         * **Converge** (*float** | **FloatKey*) --

         * **CutNegativeDens** (*float** | **FloatKey*) --

         * **Damp** (*float** | **FloatKey*) --

         * **DensConv** (*float** | **FloatKey*) --

         * **EigenShift** (*float** | **FloatKey*) --

         * **FitBas** (*BoolType** | **BoolKey*) --

         * **FixedLambda** (*BoolType** | **BoolKey*) --

         * **ImportDens** (*str** | **StringKey*) -- Filename of
           density...

         * **Lambda** (*float** | **FloatKey*) --

         * **PotBas** (*str** | **StringKey*) -- Filename...

         * **PotProj** (*str** | **StringKey*) --

         * **ProjChange** (*float** | **FloatKey*) --

         * **ProjSmallDens** (*float** | **FloatKey*) --

         * **QPiterations** (*int** | **IntKey*) --

         * **SVD** (*BoolType** | **BoolKey*) --

         * **SmallEigThresh** (*float** | **FloatKey*) --

         * **StartPot** (*str** | **StringKey*) -- Filename of
           potential...

         * **StepSize** (*float** | **FloatKey*) --

         * **TIKH** (*float** | **FloatKey*) --

   class _CorePotentials

      With the key COREPOTENTIALS you specify the core file and
      (optionally) which sections pertain to the distinct atom types
      in the molecule.

   class _CurrentResponse

      Variables:
         * **CDSpec** (*BoolType** | **BoolKey*) --

         * **Damping** (*float** | **FloatKey*) --

         * **GTensor** (*BoolType** | **BoolKey*) --

         * **Magnet** (*BoolType** | **BoolKey*) --

         * **NCT** (*float** | **FloatKey*) --

         * **NMRShielding** (*BoolType** | **BoolKey*) --

         * **NoVK** (*BoolType** | **BoolKey*) --

         * **PARTVK** (*float** | **FloatKey*) --

         * **Parabolic** (*float** | **FloatKey*) --

         * **QIANVignale** (*BoolType** | **BoolKey*) --

         * **Static** (*BoolType** | **BoolKey*) --

   class _DIMPAR

   class _DIMQM

   class _Dependency

      Variables:
         * **bas** (*float** | **FloatKey*) -- 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.

         * **eig** (*float** | **FloatKey*) -- 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).

         * **fit** (*float** | **FloatKey*) -- 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.

   class _EPrint

      Print switches that require more specification than just off or
      on

      Variables:
         * **AtomPop** (*str** | **StringKey*) -- Mulliken population
           analysis on a per-atom basis

         * **BASPop** (*str** | **StringKey*) -- Mulliken population
           analysis on a per-bas-function basis

         * **Eigval** (*str** | **StringKey*) -- One-electron orbital
           energies

         * **Fit** (*str** | **StringKey*) -- Fit functions and fit
           coefficients

         * **Frag** (*str** | **StringKey*) -- Building of the
           molecule from fragments

         * **FragPop** (*str** | **StringKey*) -- Mulliken population
           analysis on a per fragment basis

         * **Freq** (*str** | **StringKey*) -- Intermediate results in
           the computation of frequencies (see debug: freq).

         * **GeoStep** (*str** | **StringKey*) -- Geometry updates
           (Optimization, Transition State, ...)

         * **NumInt** (*str** | **StringKey*) -- Numerical Integration

         * **OrbPopEr** (*str** | **StringKey*) -- Energy Range (ER)
           in hartree units for the OrbPop subkey

         * **Repeat** (*str** | **StringKey*) -- Repetition of output
           in Geometry iterations (SCF, optimization, ...)

         * **SCF** (*str** | **StringKey*) -- Self Consistent Field
           procedure

         * **SFO** (*str** | **StringKey*) -- Information related to
           the Symmetrized Fragment Orbitals and the analysis

         * **TF** (*str** | **StringKey*) -- Transition Field method

         * **OrbPop** (*str** | **Sequence**[**str**] **|
           **FreeBlock*) -- (Mulliken type) population analysis for
           individual MOs

      class _OrbPop

         (Mulliken type) population analysis for individual MOs

   class _ESR

      Variables:
         **Enabled** (*BoolType** | **BoolKey*) -- Calculate ESR (g-
         and/or A tensors)

   class _ETSNOCV

      Perform ETS-NOCV analysis.

      Variables:
         * **EKMin** (*float** | **FloatKey*) -- The threshold for
           orbital interaction energy contributions corresponding to
           deformation density components originating from each NOCV-
           pairs

         * **ENOCV** (*float** | **FloatKey*) -- The threshold for
           NOCV-eigenvalues

         * **Enabled** (*BoolType** | **BoolKey*) -- Perform ETS-NOCV
           analysis.

         * **RhoKMin** (*float** | **FloatKey*) -- The threshold for
           population analysis of each deformation density
           contribution in terms of individual SFOs.

   class _ElectronTransfer

      Variables:
         * **CDFT** (*BoolType** | **BoolKey*) --

         * **Debug** (*BoolType** | **BoolKey*) --

         * **Disjoint** (*BoolType** | **BoolKey*) --

         * **FDE** (*BoolType** | **BoolKey*) --

         * **InvThr** (*float** | **FloatKey*) --

         * **Joint** (*BoolType** | **BoolKey*) --

         * **KNADD** (*BoolType** | **BoolKey*) --

         * **NonCT** (*BoolType** | **BoolKey*) --

         * **NumFrag** (*int** | **IntKey*) --

         * **Print** (*str** | **StringKey*) --

   class _EnergyFrag

   class _Excitations

      Excitation energies: UV/Vis

      Variables:
         * **ALLXASMOMENTS** (*BoolType** | **BoolKey*) -- 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

         * **ALLXASQUADRUPOLE** (*BoolType** | **BoolKey*) -- To be
           used in combination with XAS.This will print out the
           individual oscillator strength components to the total
           oscillator strength.

         * **Allowed** (*BoolType** | **BoolKey*) -- Treat only those
           irreducible representations for which the oscillator
           strengths will be nonzero (as opposed to all)

         * **AlsoRestricted** (*BoolType** | **BoolKey*) -- Include
           also excitation energies in which a spin-restricted
           exchange-correlation kernel is used

         * **Analytical** (*BoolType** | **BoolKey*) -- The required
           integrals for the CD spectrum are calculated analytically,
           instead of numerically. Only used in case of CD spectrum

         * **AsympCor** (*float** | **FloatKey*) --

         * **CDSpectrum** (*BoolType** | **BoolKey*) -- Compute the
           rotatory strengths for the calculated excitations, in order
           to simulate Circular Dichroism (CD) spectra

         * **DTensor** (*str** | **StringKey*) -- MCD gtensor

         * **Descriptors** (*BoolType** | **BoolKey*) -- Compute
           charge-transfer descriptors and SFO analysis

         * **Descriptors_CT_AT_Rab** (*float** | **FloatKey*) --
           Atomic distance criterion used for the calculation of CT_AT
           descriptors

         * **FullKernel** (*BoolType** | **BoolKey*) -- Use the non-
           ALDA kernel (with XCFUN)

         * **GTensor** (*str** | **StringKey*) -- MCD gtensor

         * **Iterations** (*int** | **IntKey*) -- The maximum number
           of attempts within which the Davidson algorithm has to
           converge

         * **KFWrite** (*int** | **IntKey*) -- 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.

         * **Lowest** (*Iterable**[**int**] **| **IntListKey*) --
           Number of lowest excitations to compute

         * **MCD** (*str** | **StringKey*) -- TODO: Magnetic Circular
           Dichroism

         * **NTO** (*BoolType** | **BoolKey*) -- Compute the Natural
           Transition Orbitals

         * **N_SFO** (*int** | **IntKey*) -- Number of SFO analyzed
           and printed

         * **OnlySing** (*BoolType** | **BoolKey*) -- Compute only
           singlet-singlet excitations

         * **OnlyTrip** (*BoolType** | **BoolKey*) -- Compute only
           singlet-triplet excitations

         * **Orthonormality** (*float** | **FloatKey*) -- 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.

         * **Residu** (*float** | **FloatKey*) --

         * **SFOAnalysis** (*BoolType** | **BoolKey*) -- Do SFO
           analysis

         * **SOSFreq** (*float** | **FloatKey*) --

         * **STDA** (*BoolType** | **BoolKey*) -- Simplified Tamm-
           Dancoff approach

         * **STDDFT** (*BoolType** | **BoolKey*) -- Simplified time-
           dependent DFT

         * **ScaleCoul** (*float** | **FloatKey*) -- Scaling of
           Coulomb kernel with scale parameter

         * **ScaleHF** (*float** | **FloatKey*) -- Scaling of the HF
           part of the kernel with scale parameter

         * **ScaleXC** (*float** | **FloatKey*) -- Scaling of the XC-
           kernel (excluding a possible HF-part) with scale parameter

         * **Select** (*str** | **StringKey*) -- Rather than selecting
           the first nmcdterm transitions for consideration individual
           transitions can be selected through the SELECT keyword

         * **SingleOrbTrans** (*BoolType** | **BoolKey*) -- keyword to
           use only orbital energy differences

         * **TD-DFTB** (*BoolType** | **BoolKey*) -- Use the molecular
           orbitals from a DFT ground state calculation as input to an
           excited state calculation with TD-DFTB coupling matrices

         * **Tolerance** (*float** | **FloatKey*) --

         * **Vectors** (*int** | **IntKey*) -- 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.

         * **Velocity** (*BoolType** | **BoolKey*) -- 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

         * **XAS** (*BoolType** | **BoolKey*) -- 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.

         * **Davidson** (*str** | **Sequence**[**str**] **|
           **FreeBlock*) -- Use the Davidson procedure

         * **Exact** (*str** | **Sequence**[**str**] **| **FreeBlock*)
           -- 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

      class _Davidson

         Use the Davidson procedure

      class _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

   class _ExcitedGO

      Excited state geometry optimization

      Variables:
         * **ALLGRADIENTS** (*BoolType** | **BoolKey*) --

         * **EigenFollow** (*BoolType** | **BoolKey*) -- This key
           tries to follow the eigenvector in excited state geometry
           optimizations

         * **Output** (*int** | **IntKey*) -- The amount of output
           printed. A higher value requests more detailed output

         * **Singlet** (*BoolType** | **BoolKey*) -- Singlet-singlet
           excitation is considered

         * **State** (*str** | **StringKey*) -- 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.

         * **Triplet** (*BoolType** | **BoolKey*) -- Singlet-triplet
           excitation is considered

         * **CPKS** (*PreAmsifiedADF._ExcitedGO._CPKS*) -- Some
           control parameters for the CPKS(Z-vector) part of the TDDFT
           gradients calculation

         * **SING_GRADS** (*str** | **Sequence**[**str**] **|
           **FreeBlock*) --

         * **TRIP_GRADS** (*str** | **Sequence**[**str**] **|
           **FreeBlock*) --

      class _CPKS

         Some control parameters for the CPKS(Z-vector) part of the
         TDDFT gradients calculation

         Variables:
            * **Eps** (*float** | **FloatKey*) -- Convergence
              requirement of the CPKS

            * **IterOut** (*int** | **IntKey*) -- Details of the CPKS
              calculation are printed every iter iterations

            * **NoPreConiter** (*int** | **IntKey*) -- maximum number
              of iterations allowed for the unpreconditioned solver.

            * **PreConiter** (*int** | **IntKey*) -- maximum number of
              iterations allowed for the preconditioned solver

      class _SING_GRADS

      class _TRIP_GRADS

   class _Externals

      Legacy support of the older DRF code

   class _FDE

      Frozen Density Embedding options

      Variables:
         * **AMOLFDE** (*BoolType** | **BoolKey*) -- placeholder

         * **CAPDENSCONV** (*float** | **FloatKey*) -- placeholder

         * **CAPPOTBASIS** (*BoolType** | **BoolKey*) -- placeholder

         * **CAPPOTDIIS** (*BoolType** | **BoolKey*) -- placeholder

         * **CAPPOTLINESEARCH** (*BoolType** | **BoolKey*) --
           placeholder

         * **CAPRADIUS** (*float** | **FloatKey*) -- placeholder

         * **CJCORR** (*float** | **FloatKey*) -- Option to switch on
           a long-distance correction

         * **Coulomb** (*BoolType** | **BoolKey*) -- 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.

         * **Dipole** (*BoolType** | **BoolKey*) -- placeholder

         * **E00** (*BoolType** | **BoolKey*) -- placeholder

         * **EIGENSHIFT** (*float** | **FloatKey*) -- placeholder

         * **ENERGY** (*BoolType** | **BoolKey*) -- placeholder

         * **EXTERNALORTHO** (*float** | **FloatKey*) -- Used to
           specify the use of external orthogonality (EO) in the FDE
           block

         * **EXTPRINTENERGY** (*BoolType** | **BoolKey*) --
           placeholder

         * **FULLGRID** (*BoolType** | **BoolKey*) -- placeholder

         * **FreezeAndThawCycles** (*int** | **IntKey*) -- This
           keyword duplicates RelaxCycles

         * **FreezeAndThawDensType** (*str** | **StringKey*) --
           placeholder

         * **FreezeAndThawPostSCF** (*BoolType** | **BoolKey*) -- This
           keyword duplicates RelaxPostSCF

         * **GGA97** (*BoolType** | **BoolKey*) -- placeholder

         * **GGAPotCFD** (*str** | **StringKey*) -- The correlation
           approximant is used in the construction of the embedding
           potential. The same correlation approximants as in the XC
           key are available.

         * **GGAPotXFD** (*str** | **StringKey*) -- The exchange
           approximant is used in the construction of the embedding
           potential. The same exchange approximants as in the XC key
           are available.

         * **LAMBDATIKH** (*float** | **FloatKey*) -- placeholder

         * **LBDAMP** (*float** | **FloatKey*) -- placeholder

         * **LBMAXSTEP** (*float** | **FloatKey*) -- placeholder

         * **LLP91** (*BoolType** | **BoolKey*) -- placeholder

         * **LLP91S** (*BoolType** | **BoolKey*) -- placeholder

         * **NDSD** (*str** | **StringKey*) -- placeholder

         * **NOCAPSEPCONV** (*BoolType** | **BoolKey*) -- placeholder

         * **NOFDKERN** (*BoolType** | **BoolKey*) -- placeholder

         * **OL91A** (*BoolType** | **BoolKey*) -- placeholder

         * **OL91B** (*BoolType** | **BoolKey*) -- placeholder

         * **ONEGRID** (*BoolType** | **BoolKey*) -- placeholder

         * **P92** (*BoolType** | **BoolKey*) -- placeholder

         * **PBE2** (*BoolType** | **BoolKey*) -- placeholder

         * **PBE3** (*BoolType** | **BoolKey*) -- placeholder

         * **PBE4** (*BoolType** | **BoolKey*) -- placeholder

         * **PDFT** (*BoolType** | **BoolKey*) -- placeholder

         * **PRINTEACHCYCLE** (*BoolType** | **BoolKey*) --
           placeholder

         * **PRINTRHO2** (*BoolType** | **BoolKey*) -- placeholder

         * **PW86K** (*BoolType** | **BoolKey*) -- placeholder

         * **PW91K** (*BoolType** | **BoolKey*) -- placeholder

         * **PW91Kscaled** (*BoolType** | **BoolKey*) -- placeholder

         * **RHO1FITTED** (*BoolType** | **BoolKey*) -- placeholder

         * **RelaxCycles** (*int** | **IntKey*) -- 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.

         * **RelaxDensType** (*str** | **StringKey*) -- placeholder

         * **RelaxPostSCF** (*BoolType** | **BoolKey*) -- 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.

         * **SCFCONVTHRESH** (*float** | **FloatKey*) -- placeholder

         * **SDFTEnergy** (*BoolType** | **BoolKey*) -- placeholder

         * **SHORTPRINTENERGY** (*BoolType** | **BoolKey*) --
           placeholder

         * **SMALLEIGTHRESH** (*float** | **FloatKey*) -- placeholder

         * **TF9W** (*BoolType** | **BoolKey*) -- placeholder

         * **THAKKAR92** (*BoolType** | **BoolKey*) -- placeholder

         * **THOMASFERMI** (*BoolType** | **BoolKey*) -- Local-
           density-approximation form of vt[rhoA,rhoB] derived from
           Thomas-Fermi expression for Ts[rho]

         * **TW02** (*BoolType** | **BoolKey*) -- placeholder

         * **WEIZ** (*BoolType** | **BoolKey*) -- placeholder

         * **XCFun** (*BoolType** | **BoolKey*) -- Use XCFUN for
           nonadditive functionals

         * **XCNAdd** (*str** | **StringKey*) --

   class _Fitnadkin

   class _FragOccupations

   class _Fragments

      Definitions of the fragment type/files: {FragmentName
      FragmentFile}. In the block header one can specify the directory
      where the fragment files are located

   class _GUIBonds

      The bonds used by the GUI (this does not affect the ADF
      calculation in any way)

   class _GeoVar

   class _Geometry

      Geometry Optimizations procedure

      Variables:
         * **Branch** (*Literal**[**"New"**, **"Old"**]*) -- Code
           branch to be used.

         * **CINEB** (*int** | **IntKey*) -- Climbing-Image Nudged
           Elastic Band

         * **Constraints** (*Literal**[**"FullConverge"**,
           **"PartialConverge"**]*) -- Choice between enforcing
           constraints at each steps exactly or adding them to the
           optimization space as Lagrange multipliers.

         * **Externprogram** (*str** | **StringKey*) --

         * **GEigenvalueThreshold** (*float** | **FloatKey*) --
           Threshold for delocalized coordinates singular value
           decomposition eigenvalues

         * **GO** (*BoolType** | **BoolKey*) -- Just for
           compatibility. It is not actually parsed

         * **GeoOpt** (*BoolType** | **BoolKey*) -- Just for
           compatibility. It is not actually parsed

         * **HessUpd** (*Literal**[**"Automatic"**, **"BFGS"**,
           **"MS"**, **"DFP"**, **"FS"**, **"FARKAS"**, **"FARKAS-
           BOFILL"**, **"BOFILL"**, **"HOSHINO"**, **"POWELL"**,
           **"BAKKEN-HELGAKER"**, **"NONE"**]*) -- Specifies how the
           Hessian matrix is updated, using the gradient values of the
           current and the previous geometry

         * **ImplicitHessianUpdate** (*BoolType** | **BoolKey*) --
           Placeholder

         * **InitHess** (*str** | **StringKey*) -- 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.

         * **Iterations** (*Iterable**[**int**] **| **IntListKey*) --
           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).

         * **Lanczos** (*str** | **StringKey*) -- Transition state
           search

         * **LinearTransit** (*int** | **IntKey*) -- Linear transit

         * **MBH** (*str** | **StringKey*) -- Mobile Block Hessian
           block names

         * **NEBOpt** (*str** | **StringKey*) -- Optimization type to
           use in NEB

         * **NEBOptEnds** (*BoolType** | **BoolKey*) -- Optimize end
           points

         * **NEBSpring** (*str** | **StringKey*) --

         * **Optim** (*str** | **StringKey*) --

         * **QuasiNewton** (*Literal**[**"HighOrder"**,
           **"Standard"**]*) --

         * **SP** (*BoolType** | **BoolKey*) -- Single point

         * **Vibron** (*BoolType** | **BoolKey*) -- Placeholder

         * **Converge** (*PreAmsifiedADF._Geometry._Converge*) --
           Convergence criteria

         * **DIIS** (*PreAmsifiedADF._Geometry._DIIS*) -- DIIS options

         * **Frequencies** (*PreAmsifiedADF._Geometry._Frequencies*)
           -- Calculation of frequencies via numerical differentiation

         * **IRC** (*PreAmsifiedADF._Geometry._IRC*) -- Intrinsic
           Reaction Coordinates

         * **Step** (*PreAmsifiedADF._Geometry._Step*) -- Controls
           that changes in geometry from one cycle to another are not
           too large

         * **TransitionState**
           (*PreAmsifiedADF._Geometry._TransitionState*) -- Transition
           state search

      class _Converge

         Convergence criteria

         Variables:
            * **Angle** (*float** | **FloatKey*) -- Refers to changes
              in bond- and dihedral angles, in degrees. This is only
              meaningful if optimization takes place in Z-matrix
              coordinates

            * **E** (*float** | **FloatKey*) -- The criterion for
              changes in the energy

            * **Grad** (*float** | **FloatKey*) -- The criterion for
              the nuclear gradients

            * **Rad** (*float** | **FloatKey*) -- Refers to changes in
              the Cartesian coordinates or bond lengths, depending on
              in what coordinates you optimize

      class _DIIS

         DIIS options

         Variables:
            * **CYC** (*int** | **IntKey*) -- number of geometry
              cycles run before the DIIS starts to modify the geometry
              steps

            * **N** (*int** | **IntKey*) -- number of vectors used by
              the DIIS interpolation method

      class _Frequencies

         Calculation of frequencies via numerical differentiation

         Variables:
            * **Allowed** (*BoolType** | **BoolKey*) -- 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.

            * **DisAng** (*float** | **FloatKey*) -- The displacements
              of the coordinates (angle)

            * **DisRad** (*float** | **FloatKey*) -- The displacements
              of the coordinates (Cartesian and bond length)

            * **NoScan** (*BoolType** | **BoolKey*) -- Placeholder

            * **NumDif** (*int** | **IntKey*) -- 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

            * **ScanAll** (*BoolType** | **BoolKey*) -- Placeholder

            * **ScanRange** (*Iterable**[**float**] **|
              **FloatListKey*) -- Placeholder

            * **Symm** (*BoolType** | **BoolKey*) -- Frequencies are
              calculated in symmetric displacements

      class _IRC

         Intrinsic Reaction Coordinates

         Variables:
            * **Backward** (*BoolType** | **BoolKey*) -- Do backward
              path from the Transition State

            * **Barrier** (*float** | **FloatKey*) -- lowerbound on
              barrier height

            * **Forward** (*BoolType** | **BoolKey*) -- Do forward
              path from the Transition State

            * **HessianEigenvector** (*int** | **IntKey*) -- 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!).

            * **Points** (*int** | **IntKey*) -- 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).

            * **Start** (*Literal**[**"Hess"**, **"Read"**,
              **"Grad"**]*) -- Defines how the initial direction of
              the path is chosen to move away from the Transition
              State

            * **Step** (*float** | **FloatKey*) -- The (initial) step
              length when proceeding from one IRC point to another
              along the path.

            * **StepMax** (*float** | **FloatKey*) -- 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)

            * **StepMin** (*float** | **FloatKey*) -- (the program
              will wither use the default or 0.3 times the initial
              step length, whichever is smaller)

      class _Step

         Controls that changes in geometry from one cycle to another
         are not too large

         Variables:
            * **Angle** (*float** | **FloatKey*) -- Can only be used
              in combination with the old branch

            * **Rad** (*float** | **FloatKey*) -- Can only be used in
              combination with the old branch

            * **TrustRadius** (*float** | **FloatKey*) -- By default,
              the trust radius is set to 0.01 Bohr times the number of
              atoms with a minimum of 0.2 Bohr

      class _TransitionState

         Transition state search

         Variables:
            * **LineSearchStep** (*float** | **FloatKey*) --

            * **MinMode** (*BoolType** | **BoolKey*) --

            * **Mode** (*int** | **IntKey*) -- Which mode to follow

   class _HessDiag

      Diagonal Hessian elements... Placeholder

      Variables:
         * **Ang** (*float** | **FloatKey*) -- Placeholder

         * **Dih** (*float** | **FloatKey*) -- Placeholder

         * **Rad** (*float** | **FloatKey*) -- Placeholder

   class _IQA

      Bond energy decomposition based on the interacting quantum atoms
      (IQA) approach and using QTAIM real-space partition.

      Variables:
         * **Accuracy** (*float** | **FloatKey*) -- Placeholder

         * **AtomsToDo** (*Iterable**[**int**] **| **IntListKey*) --

           Define a subset of atoms for which the IQA atom-atom
           interactions are calculated.

           If left empty, all atoms will be included.

         * **Enabled** (*BoolType** | **BoolKey*) -- Calculate the
           bond energy decomposition using the interacting quantum
           atoms (IQA) approach and the QTAIM real-space partitioning.

         * **Interactions** (*Literal**[**"intra"**, **"inter"**,
           **"all"**]*) -- Placeholder

         * **Print** (*Literal**[**"Normal"**, **"Verbose"**,
           **"Debug"**]*) --

           For each atom pair, print energy terms:

           Normal: total, covalent and ionic terms,

           Verbose: all terms.

   class _IRCStart

   class _Integration

      Options for the obsolete Voronoi numerical integration scheme

   class _IrrepOccupations

      Explicit occupation numbers per irrep

   class _LinearConstraints

   class _LinearScaling

      Variables:
         * **Cutoff_Coulomb** (*float** | **FloatKey*) -- determines
           the radii for the fit functions in the evaluation of the
           (short-range part of) the Coulomb potential.

         * **Cutoff_Fit** (*float** | **FloatKey*) -- 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.

         * **Cutoff_Multipoles** (*float** | **FloatKey*) --
           determines the cut-offs in the multipole (long-range) part
           of the Coulomb potential

         * **HF_Fit** (*float** | **FloatKey*) -- Parameter for HF
           exchange

         * **Overlap_Int** (*float** | **FloatKey*) -- 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

         * **ProgConv** (*float** | **FloatKey*) -- determines how the
           overall accuracy changes during the SCF procedure

   class _LocOrb

   class _MDC

      Options for Multipole Derived Charges (MDC)

      Variables:
         * **Debug** (*BoolType** | **BoolKey*) -- Print debug
           information on MDC

         * **ExpMCD** (*float** | **FloatKey*) -- Exponent for MDC

         * **IncDum** (*int** | **IntKey*) -- Parameter for including
           dummy atoms as positions for distributed charges

         * **MDCExp** (*int** | **IntKey*) -- kind of weight function
           to be used (Gaussian or Slater[=default])

         * **TolMDC** (*float** | **FloatKey*) -- Numerical accuracy
           parameter

   class _MP2

      Technical aspects of the MP2 algorithm.

      Variables:
         * **Debug** (*BoolType** | **BoolKey*) -- Enable MP2 debug
           output.

         * **Enabled** (*BoolType** | **BoolKey*) -- Enable the
           calculation of the MP2 energy.

         * **FitSetQuality** (*Literal**[**"Auto"**, **"VeryBasic"**,
           **"Basic"**, **"Normal"**, **"Good"**, **"VeryGood"**]*) --
           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.

         * **Formalism** (*Literal**[**"Auto"**, **"RI"**, **"LT"**,
           **"All"**]*) -- 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.

         * **IntegrationQuality** (*Literal**[**"VeryBasic"**,
           **"Basic"**, **"Normal"**, **"Good"**, **"VeryGood"**]*) --
           Specifies the integration quality to be used in the MP2
           calculation. If not specified, the
           RIHartreeFock%IntegrationQuality is used.

         * **Memory** (*BoolType** | **BoolKey*) -- If true, the more
           memory efficient variant of the algorithm is invoked (only
           implemented for SOS)

         * **MultipoleApproximation** (*BoolType** | **BoolKey*) -- If
           true, the multipole approximation for distant centers will
           be used.

         * **ThresholdQuality** (*Literal**[**"VeryBasic"**,
           **"Basic"**, **"Normal"**, **"Good"**, **"VeryGood"**]*) --
           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.

         * **ThresholdQualityHalf** (*float** | **FloatKey*) --
           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.

         * **ThresholdQualityHalfTimesC** (*float** | **FloatKey*) --
           Specifies the treshold for neglecting products of halt-
           transformed fit-coefficients with fitfunctions.

         * **nLaplace** (*int** | **IntKey*) -- 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.

   class _ModifyExcitation

      Variables:
         * **DipStrength** (*float** | **FloatKey*) --

         * **GRIMMEAEX** (*float** | **FloatKey*) --

         * **GRIMMEALPHA** (*float** | **FloatKey*) --

         * **GRIMMEBETA** (*float** | **FloatKey*) --

         * **GRIMMEDEMAX** (*float** | **FloatKey*) --

         * **GRIMMEPERTC** (*BoolType** | **BoolKey*) --

         * **GRIMMETPMIN** (*float** | **FloatKey*) --

         * **HighExcit** (*float** | **FloatKey*) --

         * **NOGRIMMEPERTC** (*BoolType** | **BoolKey*) --

         * **NOverlap** (*int** | **IntKey*) --

         * **OscStrength** (*float** | **FloatKey*) -- 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

         * **SetLargeEnergy** (*float** | **FloatKey*) -- 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

         * **SetOccEnergy** (*float** | **FloatKey*) -- 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.

         * **UseOccRange** (*Iterable**[**float**] **|
           **FloatListKey*) -- Use only occupied orbitals which have
           orbital energies between the two numbers.

         * **UseOccVirtNumbers** (*Iterable**[**int**] **|
           **IntListKey*) -- 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.

         * **UseOccVirtRange** (*Iterable**[**float**] **|
           **FloatListKey*) -- Use only pairs of an occupied and
           virtual orbital, for which the orbital energy difference is
           between the two numbers

         * **UseScaledZORA** (*BoolType** | **BoolKey*) -- 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.

         * **UseVirtRange** (*Iterable**[**float**] **|
           **FloatListKey*) -- Use only virtual orbitals which have
           orbital energies between the two numbers

         * **UseOccupied** (*str** | **Sequence**[**str**] **|
           **FreeBlock*) -- Use only the occupied orbitals which are
           specified

         * **UseVirtual** (*str** | **Sequence**[**str**] **|
           **FreeBlock*) -- Use only the virtual orbitals which are
           specified

      class _UseOccupied

         Use only the occupied orbitals which are specified

      class _UseVirtual

         Use only the virtual orbitals which are specified

   class _ModifyStartPotential

   class _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.

      Variables:
         * **Alfa** (*BoolType** | **BoolKey*) -- Analyze the static
           or dynamic polarizability

         * **BField** (*BoolType** | **BoolKey*) -- The perturbation
           is a magnetic field. Should be consistent with AORESPONSE

         * **Beta** (*BoolType** | **BoolKey*) -- 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

         * **Diag** (*BoolType** | **BoolKey*) -- Only analyze the
           diagonal of the response tensor

         * **Dynamic** (*BoolType** | **BoolKey*) -- Should be used
           for a frequency dependent perturbation field.

         * **EField** (*BoolType** | **BoolKey*) -- The perturbation
           is an electric field

         * **Fulltens** (*BoolType** | **BoolKey*) -- The full tensor
           is analyzed

         * **GPrime** (*BoolType** | **BoolKey*) -- Analyze the G'
           (gyration) tensor, for optical rotation dispersion.
           Requires a frequency dependent perturbation field, with a
           frequency (omega) unequal to zero.

         * **Static** (*BoolType** | **BoolKey*) -- should be used for
           a static field

   class _PointCharges

      Point charges: {x y z q}

   class _PolTDDFT

      TODO!

      Variables:
         * **CutOff** (*float** | **FloatKey*) -- 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.

         * **Enabled** (*BoolType** | **BoolKey*) -- 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.

         * **FreqRange** (*str** | **StringKey*) -- 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).

         * **KGrid** (*str** | **StringKey*) -- 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).

         * **Lambda** (*float** | **FloatKey*) -- Jacob's scaling
           factor for the study of plasmonic resonances. This factor,
           0<lambda<1, turns on the coupling matrix K.

         * **Lifetime** (*float** | **FloatKey*) -- 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.

         * **Velocity** (*BoolType** | **BoolKey*) -- If True, ADF
           calculates the dipole moment in velocity gauge. If false:
           dipole-length representation is used

         * **Irrep** (*str** | **Sequence**[**str**] **| **FreeBlock*)
           -- 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

      class _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

   class _QMMM

   class _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.

      Variables:
         * **AnalysisLevel** (*Literal**[**"Normal"**, **"Extended"**,
           **"Full"**]*) --

           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.

         * **AtomsToDo** (*Iterable**[**int**] **| **IntListKey*) --
           List of atoms for which condensed descriptors are to be
           calculated. By default all atoms are included.

         * **Enabled** (*BoolType** | **BoolKey*) -- Calculate QTAIM
           (also known as Bader) properties.

         * **Energy** (*BoolType** | **BoolKey*) -- Calculate atomic
           energies. Requires an all-electron calculation (no frozen
           core), triggers the TotalEnergy and increases the
           [AnalysisLevel] to at least Extended.

         * **Spacing** (*float** | **FloatKey*) -- 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.

   class _RIHartreeFock

      Variables:
         * **DependencyThreshold** (*float** | **FloatKey*) --

           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)

         * **FitSetQuality** (*Literal**[**"Auto"**, **"VeryBasic"**,
           **"Basic"**, **"Normal"**, **"Good"**, **"VeryGood"**,
           **"Excellent"**]*) --

           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.

         * **IntegrationQuality** (*Literal**[**"VeryBasic"**,
           **"Basic"**, **"Normal"**, **"Good"**, **"VeryGood"**,
           **"Excellent"**]*) -- 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.

         * **Quality** (*Literal**[**"Auto"**, **"VeryBasic"**,
           **"Basic"**, **"Normal"**, **"Good"**, **"VeryGood"**,
           **"Excellent"**]*) -- Numerical accuracy of the RI
           procedure. If 'Auto', the quality specified in the
           'NumericalQuality' will be used.

         * **ResponseQuality** (*Literal**[**"VeryBasic"**,
           **"Basic"**, **"Normal"**, **"Good"**, **"VeryGood"**,
           **"Excellent"**]*) -- Numerical accuracy of the RI
           procedure for the Response module.

         * **ThresholdQuality** (*Literal**[**"VeryBasic"**,
           **"Basic"**, **"Normal"**, **"Good"**, **"VeryGood"**,
           **"Excellent"**]*) -- 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.

         * **UseMe** (*BoolType** | **BoolKey*) -- Set to False if you
           want to use the old RI scheme

         * **AtomDepQuality** (*str** | **Sequence**[**str**] **|
           **FreeBlock*) -- 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.

      class _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.

   class _RISM

      3D-RISM-related input keys.

   class _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.

      Variables:
         * **NRad** (*int** | **IntKey*) -- The number of radial grid
           points

         * **RMax** (*float** | **FloatKey*) -- The largest distance
           in the radial grid

         * **RMin** (*float** | **FloatKey*) -- The shortest distance
           used in the radial grid

   class _RemoveFragOrbitals

   class _Response

      The calculation of frequency-dependent (hyper)polarizabilities
      and related properties (Raman, ORD)

      Variables:
         * **ALLCOMPONENTS** (*BoolType** | **BoolKey*) --

         * **ALLHYPER** (*BoolType** | **BoolKey*) --

         * **ALPHAINANG** (*BoolType** | **BoolKey*) --

         * **ANALYTIC** (*BoolType** | **BoolKey*) --

         * **AllCycles** (*BoolType** | **BoolKey*) -- Convergence
           printout

         * **AllTensor** (*BoolType** | **BoolKey*) -- Higher
           dispersion coefficients are also calculated

         * **C8** (*BoolType** | **BoolKey*) --

         * **CONSTPOLYYN** (*float** | **FloatKey*) --

         * **CUTTAILS** (*BoolType** | **BoolKey*) --

         * **DYNAHYP** (*BoolType** | **BoolKey*) --

         * **Dipole** (*BoolType** | **BoolKey*) --

         * **DmpDII** (*float** | **FloatKey*) --

         * **DmpRsp** (*float** | **FloatKey*) --

         * **ERABSX** (*float** | **FloatKey*) --

         * **ERRALF** (*float** | **FloatKey*) --

         * **ERRTMX** (*float** | **FloatKey*) --

         * **EpsRho** (*float** | **FloatKey*) -- Rho threshold

         * **FRQBEG** (*float** | **FloatKey*) --

         * **FRQEND** (*float** | **FloatKey*) --

         * **FXCALPHA** (*float** | **FloatKey*) --

         * **FXCDRCONV** (*BoolType** | **BoolKey*) --

         * **FXCLB** (*BoolType** | **BoolKey*) --

         * **GXCALPHA** (*float** | **FloatKey*) --

         * **Hartree** (*BoolType** | **BoolKey*) --

         * **HyperPol** (*float** | **FloatKey*) --

         * **IFILES** (*int** | **IntKey*) -- Integration run
           including external files. Used for Van der Waals dispersion
           coefficients calculations.

         * **IPRESP** (*int** | **IntKey*) --

         * **IReal** (*int** | **IntKey*) --

         * **KSORBRUN** (*BoolType** | **BoolKey*) --

         * **LINVXCCONST** (*float** | **FloatKey*) --

         * **MAGNETICPERT** (*BoolType** | **BoolKey*) --

         * **MAXWAALS** (*int** | **IntKey*) --

         * **NCycMx** (*int** | **IntKey*) --

         * **NFreq** (*int** | **IntKey*) --

         * **NOFXCDR** (*BoolType** | **BoolKey*) --

         * **NUMERIC** (*BoolType** | **BoolKey*) --

         * **OPTICALROTATION** (*BoolType** | **BoolKey*) --

         * **Octupole** (*BoolType** | **BoolKey*) --

         * **Quadrupole** (*BoolType** | **BoolKey*) --

         * **Raman** (*BoolType** | **BoolKey*) --

         * **STARTREALGR** (*BoolType** | **BoolKey*) --

         * **SYMRUN** (*BoolType** | **BoolKey*) --

         * **Temperature** (*float** | **FloatKey*) -- 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)

         * **VANDERWAALS** (*int** | **IntKey*) --

         * **VERDET** (*float** | **FloatKey*) -- For numerical
           differentiation d alfa(omega) /d omega, needed for Verdet
           constant, the default frequencies are omega + dverdt and
           omega - dverdt

   class _Restart

      Options for restarts

      Variables:
         * **File** (*str** | **StringKey*) -- 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.

         * **NoExc** (*BoolType** | **BoolKey*) -- Do not use any
           Excitation data from the restart file.

         * **NoGeo** (*BoolType** | **BoolKey*) -- Do not use the
           geometry - Cartesian, Z-matrix, etc. coordinates - from the
           restart file

         * **NoHes** (*BoolType** | **BoolKey*) -- Do not use any
           Hessian from the restart file.

         * **NoOrb** (*BoolType** | **BoolKey*) -- Do not use orbitals
           from the restart file

         * **NoSCF** (*BoolType** | **BoolKey*) -- 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.

         * **NoSmear** (*BoolType** | **BoolKey*) -- Do not use any
           electron smearing data from the restart file.

         * **SpinFlip** (*Iterable**[**int**] **| **IntListKey*) --
           Indices of atoms in for which the flipping will be
           performed

   class _Restraint

   class _SCF

      Control aspects of the Self Consistent Field procedure

      Variables:
         * **AccelerationMethod** (*Literal**[**"ADIIS"**,
           **"fDIIS"**, **"LISTb"**, **"LISTf"**, **"LISTi"**,
           **"MESA"**, **"SDIIS"**]*) --

           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.

         * **Converge** (*Iterable**[**float**] **| **FloatListKey*)
           --

           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.

         * **EDIIS** (*BoolType** | **BoolKey*) -- 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.

         * **Iterations** (*int** | **IntKey*) -- The maximum number
           of SCF cycles allowed.

         * **LShift** (*float** | **FloatKey*) --

           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.

         * **LShift_cyc** (*int** | **IntKey*) -- Specifies that level
           shifting is not turned on before the given SCF cycle number
           (for the start-up geometry).

         * **LShift_err** (*float** | **FloatKey*) -- Specifies that
           level shifting will be turned off by the program as soon as
           the SCF error drops below a threshold.

         * **MESA** (*str** | **StringKey*) --

         * **Mixing** (*float** | **FloatKey*) -- When none of the SCF
           acceleration methods is active, the next Fock matrix is
           determined F = mixing * F_n + (1-mixing)F_(n-1).

         * **Mixing1** (*float** | **FloatKey*) -- The mixing
           parameter at the 1st SCF cycle.

         * **NoADIIS** (*BoolType** | **BoolKey*) -- Disables A-DIIS
           and switches SCF to a damping+DIIS scheme.

         * **OldSCF** (*BoolType** | **BoolKey*) --

           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.

         * **ScalableSCF** (*BoolType** | **BoolKey*) -- Use new
           scalable scf.

         * **ScalableSO** (*BoolType** | **BoolKey*) -- Use new
           scalable scf.

         * **ADIIS** (*PreAmsifiedADF._SCF._ADIIS*) -- Settings for
           the ADIIS method.

         * **ARH** (*PreAmsifiedADF._SCF._ARH*) -- The Augmented
           Roothaan-Hall method has been developed by T. Helgaker and
           coworkers.

         * **DIIS** (*PreAmsifiedADF._SCF._DIIS*) -- The maximum
           number of SCF cycles allowed.

      class _ADIIS

         Settings for the ADIIS method.

         Variables:
            * **Thresh1** (*float** | **FloatKey*) --

              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.

            * **Thresh2** (*float** | **FloatKey*) --

              If ErrMax < Thresh2 then only SDIIS coefficients are
              used.

              Below this threshold a weighted mix of A-DIIS and DIIS
              coefficients will be used.

      class _ARH

         The Augmented Roothaan-Hall method has been developed by T.
         Helgaker and coworkers.

         Variables:
            * **CGiter** (*int** | **IntKey*) -- Sets the maximum
              number of micro-iterations.

            * **Conv** (*float** | **FloatKey*) -- ARH convergence
              criterion. When the RMS gradient and its maximum
              components are both lower than the criterion, the ARH
              procedure will be considered converged.

            * **ETestLim** (*float** | **FloatKey*) --

            * **Enabled** (*BoolType** | **BoolKey*) -- Use ARH.

            * **Final** (*BoolType** | **BoolKey*) --

              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.

            * **Iter** (*int** | **IntKey*) -- 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

            * **LvlShIter** (*int** | **IntKey*) --

            * **MaxTrustR** (*float** | **FloatKey*) --

            * **MinTrustR** (*float** | **FloatKey*) --

            * **NOTRANSPCG** (*BoolType** | **BoolKey*) --

            * **NSAVED** (*int** | **IntKey*) --

              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.

            * **NoPrecond** (*BoolType** | **BoolKey*) --

            * **PRECOND** (*BoolType** | **BoolKey*) --

            * **SHIFTED** (*BoolType** | **BoolKey*) --

            * **START** (*int** | **IntKey*) --

            * **SWITCHING** (*BoolType** | **BoolKey*) --

              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).

            * **TRANSPCG** (*BoolType** | **BoolKey*) --

            * **TRUSTR** (*float** | **FloatKey*) --

      class _DIIS

         The maximum number of SCF cycles allowed.

         Variables:
            * **BFac** (*float** | **FloatKey*) -- By default, the
              latest vector is not favored in the DIIS algorithm
              (value 0.0). A sensible value would be 0.2.

            * **CX** (*float** | **FloatKey*) -- The DIIS space is
              reduced when very large DIIS coefficients appear. The
              value is the threshold.

            * **CXX** (*float** | **FloatKey*) -- When very large DIIS
              coefficients appear, switch to traditional damping. The
              value is the threshold.

            * **Cyc** (*int** | **IntKey*) -- When A-DIIS is disabled,
              the Pulay DIIS will start at this iteration irrespective
              of the DIIS OK value.

            * **N** (*int** | **IntKey*) -- 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)

            * **Ok** (*float** | **FloatKey*) -- The Pulay DIIS
              starting criterion, when A-DIIS is disabled,

   class _SCRF

   class _SICOEP

   class _SOPert

      Variables:
         * **EShift** (*float** | **FloatKey*) --

         * **NCalc** (*int** | **IntKey*) --

   class _SelectExcitation

      Variables:
         * **DipStrength** (*float** | **FloatKey*) --

         * **GRIMMEAEX** (*float** | **FloatKey*) --

         * **GRIMMEALPHA** (*float** | **FloatKey*) --

         * **GRIMMEBETA** (*float** | **FloatKey*) --

         * **GRIMMEDEMAX** (*float** | **FloatKey*) --

         * **GRIMMEPERTC** (*BoolType** | **BoolKey*) --

         * **GRIMMETPMIN** (*float** | **FloatKey*) --

         * **HighExcit** (*float** | **FloatKey*) --

         * **NOGRIMMEPERTC** (*BoolType** | **BoolKey*) --

         * **NOverlap** (*int** | **IntKey*) --

         * **OscStrength** (*float** | **FloatKey*) -- 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

         * **SetLargeEnergy** (*float** | **FloatKey*) -- 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

         * **SetOccEnergy** (*float** | **FloatKey*) -- 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.

         * **UseOccRange** (*Iterable**[**float**] **|
           **FloatListKey*) -- Use only occupied orbitals which have
           orbital energies between the two numbers.

         * **UseOccVirtNumbers** (*Iterable**[**int**] **|
           **IntListKey*) -- 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.

         * **UseOccVirtRange** (*Iterable**[**float**] **|
           **FloatListKey*) -- Use only pairs of an occupied and
           virtual orbital, for which the orbital energy difference is
           between the two numbers

         * **UseScaledZORA** (*BoolType** | **BoolKey*) -- 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.

         * **UseVirtRange** (*Iterable**[**float**] **|
           **FloatListKey*) -- Use only virtual orbitals which have
           orbital energies between the two numbers

         * **UseOccupied** (*str** | **Sequence**[**str**] **|
           **FreeBlock*) -- Use only the occupied orbitals which are
           specified

         * **UseVirtual** (*str** | **Sequence**[**str**] **|
           **FreeBlock*) -- Use only the virtual orbitals which are
           specified

      class _UseOccupied

         Use only the occupied orbitals which are specified

      class _UseVirtual

         Use only the virtual orbitals which are specified

   class _SlaterDeterminants

   class _Solvation

      Variables:
         * **ARO** (*float** | **FloatKey*) --

         * **Acid** (*float** | **FloatKey*) --

         * **Ass** (*BoolType** | **BoolKey*) --

         * **Base** (*float** | **FloatKey*) --

         * **BornC** (*float** | **FloatKey*) -- Coulomb constant for
           Born

         * **C-Mat** (*str** | **StringKey*) --

         * **COSKFAtoms** (*Iterable**[**int**] **| **IntListKey*) --
           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.

         * **Charged** (*str** | **StringKey*) --

         * **Chgal** (*float** | **FloatKey*) --

         * **CsmRsp** (*BoolType** | **BoolKey*) --

         * **Cust** (*str** | **StringKey*) --

         * **Debug** (*str** | **StringKey*) --

         * **Disc** (*str** | **StringKey*) --

         * **Div** (*str** | **StringKey*) --

         * **EPS** (*float** | **FloatKey*) --

         * **ForceCosmo** (*str** | **StringKey*) --

         * **HALO** (*float** | **FloatKey*) --

         * **Lpr** (*BoolType** | **BoolKey*) --

         * **NoAss** (*BoolType** | **BoolKey*) --

         * **NoCsmRsp** (*BoolType** | **BoolKey*) --

         * **NoLpr** (*BoolType** | **BoolKey*) --

         * **NoPVec** (*BoolType** | **BoolKey*) --

         * **PVec** (*BoolType** | **BoolKey*) --

         * **PrintSM12** (*BoolType** | **BoolKey*) --

         * **RadSolv** (*float** | **FloatKey*) --

         * **Ref** (*float** | **FloatKey*) --

         * **SCF** (*str** | **StringKey*) --

         * **Solv** (*str** | **StringKey*) -- Solvent details

         * **Surf** (*Literal**[**"wsurf"**, **"asurf"**, **"esurf"**,
           **"klamt"**, **"delley"**, **"wsurf nokeep"**, **"asurf
           nokeep"**, **"esurf nokeep"**, **"klamt nokeep"**,
           **"delley nokeep"**]*) -- Defines the type of cavity to be
           used.

         * **Tens** (*float** | **FloatKey*) --

         * **RADII** (*str** | **Sequence**[**str**] **| **FreeBlock*)
           --

      class _RADII

   class _SubExci

      Subsystem TDDFT (FDE)

      Variables:
         * **CICoupl** (*BoolType** | **BoolKey*) -- 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.

         * **COULKERNEL** (*BoolType** | **BoolKey*) --

         * **COUPLBLOCK** (*BoolType** | **BoolKey*) --

         * **COUPLSYS** (*Iterable**[**int**] **| **IntListKey*) --

         * **CPLTAPE** (*str** | **StringKey*) --

         * **CThres** (*float** | **FloatKey*) -- 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.

         * **DIPVEL** (*BoolType** | **BoolKey*) --

         * **DiagType** (*Literal**[**"EXACT"**]*) --

         * **EIGPRINT** (*int** | **IntKey*) --

         * **ETHRES** (*float** | **FloatKey*) -- Threshold for
           effective coupling

         * **FULLGRID** (*BoolType** | **BoolKey*) --

         * **InvGuess** (*Literal**[**"EigVal-OrbDiff"**, **"OrbDiff-
           OrbDiff"**, **"Exact"**]*) -- Type of states to be coupled

         * **LOCALFXCK** (*BoolType** | **BoolKey*) --

         * **Lowest** (*int** | **IntKey*) -- The selection of the
           excited states to be coupled consists of two steps

         * **NITER** (*int** | **IntKey*) --

         * **NOINTERSOLV** (*BoolType** | **BoolKey*) --

         * **NOSOLVCCHECK** (*BoolType** | **BoolKey*) --

         * **ONEGRID** (*BoolType** | **BoolKey*) --

         * **OptStates** (*Iterable**[**int**] **| **IntListKey*) --
           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.

         * **PFRAGOUT** (*BoolType** | **BoolKey*) --

         * **PTHRES** (*float** | **FloatKey*) --

         * **SETDIAG** (*float** | **FloatKey*) --

         * **SFThres** (*float** | **FloatKey*) -- 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.

         * **SMARTGRID** (*BoolType** | **BoolKey*) --

         * **Stat2CPL** (*Literal**[**"OnlyKnown"**]*) -- Type of
           states to be coupled

         * **TCOMEGA** (*BoolType** | **BoolKey*) -- Transpose
           construction of Omega matrix

         * **TDA** (*BoolType** | **BoolKey*) -- 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.

         * **TKINKERNEL** (*BoolType** | **BoolKey*) --

         * **XCKERNEL** (*BoolType** | **BoolKey*) --

   class _SubResponse

      Untested and undocumented

   class _TSRC

      Transition State Reaction Coordinate (TSRC)

   class _Tails

      Obsolete option for linear scaling and distance effects. We
      recommend using the LinearScaling key instead.

      Variables:
         * **Bas** (*float** | **FloatKey*) -- 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.

         * **Fit** (*float** | **FloatKey*) -- 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.

   class _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

      Variables:
         * **P** (*float** | **FloatKey*) -- The Pressure. A zero or
           negative pressure is adjusted by the program to a (very)
           small number 1e-4

         * **TMax** (*float** | **FloatKey*) -- Maximum temperature
           for the temperature range.

         * **TMin** (*float** | **FloatKey*) -- Minimum temperature
           for the temperature range.

         * **nT** (*int** | **IntKey*) --

           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.

   class _Units

      Definitions of the units.

      Variables:
         * **angle** (*Literal**[**"degree"**, **"radian"**]*) --
           Units of angles

         * **length** (*Literal**[**"bohr"**, **"angstrom"**]*) --
           Units of length

   class _VSCRF

   class _Vibron

      Resonance Raman Input options

      Variables:
         * **CALCCC** (*BoolType** | **BoolKey*) -- use ADF routines
           to calculate coupling constants (they only work for the
           linear coupling constants)

         * **CBTAPE** (*str** | **StringKey*) --

         * **CDVIBRON** (*BoolType** | **BoolKey*) -- CD spectra
           calculations

         * **CGRAD** (*BoolType** | **BoolKey*) -- calculate ground-
           state gradients in VIBRON runs

         * **DISPTYPE** (*str** | **StringKey*) -- default type of
           displacement

         * **DOMODES** (*Iterable**[**int**] **| **IntListKey*) --

         * **DONTMODES** (*Iterable**[**int**] **| **IntListKey*) --

         * **DONTSTEPS** (*Iterable**[**int**] **| **IntListKey*) --

         * **DOSTEPS** (*Iterable**[**int**] **| **IntListKey*) --

         * **DSCHEME** (*str** | **StringKey*) -- default diabatizing
           scheme

         * **ELTHRES** (*float** | **FloatKey*) -- lower boundary for
           excitation energy

         * **EUTHRES** (*float** | **FloatKey*) -- upper boundary for
           excitation energy

         * **EXTAPE** (*str** | **StringKey*) -- excited state
           symmetry information input file

         * **HARMGR** (*BoolType** | **BoolKey*) -- use harmonic
           approximation for ground state energy

         * **IGNORECHECK** (*BoolType** | **BoolKey*) -- ignore safety
           checks

         * **NDTYPE** (*int** | **IntKey*) -- by default, always use
           3-point central differences (i.e. two sided), but only
           compute linear couplings

         * **NMTape** (*str** | **StringKey*) -- 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.

         * **NOINV** (*BoolType** | **BoolKey*) -- inversion of
           initial sadiab

         * **NOTONLYSYM** (*BoolType** | **BoolKey*) --

         * **NSTEPSC** (*int** | **IntKey*) -- Number of steps for PES
           scans

         * **ONLYSYM** (*BoolType** | **BoolKey*) -- calculate
           displacements along symmetric modes

         * **PDEBUG** (*BoolType** | **BoolKey*) --

         * **PESCAN** (*Iterable**[**int**] **| **IntListKey*) --

         * **PURIFY** (*BoolType** | **BoolKey*) -- purify excitation
           energies for excited states (leads to errors for non-
           totally symmetric modes in degenerate systems)

         * **RESRAMAN** (*BoolType** | **BoolKey*) -- perform
           resonance Raman calculations

         * **SAVERAWDAT** (*int** | **IntKey*) --

         * **SAVEREFAO** (*BoolType** | **BoolKey*) -- save reference
           AO vectors

         * **STOPAT** (*int** | **IntKey*) -- debug option: stop at a
           particular geometry step

         * **STPSIZE** (*float** | **FloatKey*) -- Step size for
           numerical differentiation

         * **SelState** (*Iterable**[**int**] **| **IntListKey*) --
           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.

         * **TRANSDEF** (*BoolType** | **BoolKey*) -- use transpose
           definition of overlap matrix

         * **USERAWDAT** (*BoolType** | **BoolKey*) --

         * **WINTREAT** (*str** | **StringKey*) -- do not increase
           energy window upon change of state no.

         * **WRTMAG** (*BoolType** | **BoolKey*) --

         * **EShift** (*str** | **Sequence**[**str**] **|
           **FreeBlock*) -- Empirical vertical shifts for the
           excitation energies

         * **UsSym** (*str** | **Sequence**[**str**] **| **FreeBlock*)
           -- user-specified symmetry of excited states (at reference
           geometry)

      class _EShift

         Empirical vertical shifts for the excitation energies

      class _UsSym

         user-specified symmetry of excited states (at reference
         geometry)

   class _XC

      Definition of the XC.

      Variables:
         * **Dispersion** (*str** | **StringKey*) -- Dispersion
           corrections.

         * **DoubleHybrid** (*str** | **StringKey*) -- Specifies the
           double hybrid functional that should be used during the
           SCF.

         * **EmpiricalScaling** (*Literal**[**"None"**, **"SOS"**,
           **"SCS"**, **"SCSMI"**]*) -- Calculate the
           (SOS/SCS/SCSMI)-MP2 correlation energy.

         * **GGA** (*str** | **StringKey*) -- Specifies the GGA part
           of the XC Functional

         * **HartreeFock** (*BoolType** | **BoolKey*) -- Use the
           Hartree-Fock exchange should be used during the SCF.

         * **Hybrid** (*str** | **StringKey*) -- Specifies the hybrid
           functional that should be used during the SCF.

         * **LDA** (*str** | **StringKey*) -- Defines the LDA part of
           the XC functional

         * **LibXC** (*str** | **StringKey*) -- Use the LibXC library
           with the specified functional.

         * **MP2** (*BoolType** | **BoolKey*) -- Calculate the MP2
           correlation energy after the HF SCF is completed.

         * **MetaGGA** (*str** | **StringKey*) -- Specifies that a
           meta-GGA should be used during the SCF

         * **MetaHybrid** (*str** | **StringKey*) -- Specifies the
           meta-hybrid functional that should be used during the SCF.

         * **Model** (*str** | **StringKey*) -- Model potential to be
           used

         * **NoLibXC** (*BoolType** | **BoolKey*) -- Prevent the usage
           of the LibXC library

         * **OEP** (*str** | **StringKey*) -- Defines the optimized
           effective potential expanded into a set of the fit
           functions

         * **RangeSep** (*str** | **StringKey*) -- Range separated
           hybrids parameters

         * **XCFun** (*BoolType** | **BoolKey*) -- Use the XCFun
           library

   class _XES

      X-ray emission spectroscopy

      Variables:
         * **AllXESMoments** (*BoolType** | **BoolKey*) -- Print out
           all the individual transition moments used within the
           calculation of the total oscillator strength

         * **AllXESQuadrupole** (*BoolType** | **BoolKey*) -- Print
           out the individual oscillator strength components to the
           total oscillator strength

         * **CoreHole** (*str** | **StringKey*) --

           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)

         * **Enabled** (*BoolType** | **BoolKey*) --

           Calculate the X-ray emission energies to a core orbital.

           By default it calculates the emission to the first orbital
           in the first symmetry.

   class _ZlmFit

      Options for the density fitting scheme 'ZlmFit'.

      Variables:
         * **AllowBoost** (*BoolType** | **BoolKey*) -- 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.

         * **DensityThreshold** (*float** | **FloatKey*) -- Threshold
           below which the electron density is considered to be
           negligible.

         * **GridAngOrder** (*int** | **IntKey*) --

         * **GridRadialFactor** (*float** | **FloatKey*) --

         * **PartitionFunThreshold** (*float** | **FloatKey*) --

         * **PotentialThreshold** (*float** | **FloatKey*) --

         * **Pruning** (*BoolType** | **BoolKey*) --

         * **Quality** (*Literal**[**"Auto"**, **"Basic"**,
           **"Normal"**, **"Good"**, **"VeryGood"**,
           **"Excellent"**]*) -- 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.

         * **lExpansion** (*int** | **IntKey*) --

         * **lMargin** (*int** | **IntKey*) --

         * **AtomDepQuality** (*str** | **Sequence**[**str**] **|
           **FreeBlock*) -- 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.

      class _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.

class ReactionsDiscovery

   Variables:
      * **Engine** (*EngineBlock*) -- The input for the computational
        engine for the MolecularDynamics and NetworkExtraction tasks.
        The header of the block determines the type of the engine.

      * **LoadSystem** (*ReactionsDiscovery._LoadSystem*) -- Block
        that controls reading the chemical system from a KF file
        instead of the [System] block.

      * **MolecularDynamics**
        (*ReactionsDiscovery._MolecularDynamics*) -- Settings for
        reactive molecular dynamics.

      * **NetworkExtraction**
        (*ReactionsDiscovery._NetworkExtraction*) -- Options for
        extracting the reactive network from MD trajectories

      * **ProductRanking** (*ReactionsDiscovery._ProductRanking*) --
        Options for ranking of the intermediates by stability

      * **System** (*ReactionsDiscovery._System*) -- Specification of
        the chemical system. For some applications more than one
        system may be present in the input. In this case, all systems
        except one must have a non-empty string ID specified after the
        System keyword. The system without an ID is considered the
        main one.

   class _Engine

      The input for the computational engine for the MolecularDynamics
      and NetworkExtraction tasks. The header of the block determines
      the type of the engine.

   class _LoadSystem

      Block that controls reading the chemical system from a KF file
      instead of the [System] block.

      Variables:
         * **File** (*str** | **Path** | **StringKey*) -- The path of
           the KF file from which to load the system. It may also be
           the results directory containing it.

         * **Section** (*str** | **StringKey*) -- The section on the
           KF file from which to load the system.

   class _MolecularDynamics

      Settings for reactive molecular dynamics.

      Variables:
         * **Enabled** (*BoolType** | **BoolKey*) -- Whether to run
           molecular dynamics.

         * **NumSimulations** (*int** | **IntKey*) -- Total number of
           MD simulations to run.

         * **TimeStep** (*float** | **FloatKey*) -- Molecular dynamics
           time step.

         * **Type** (*Literal**[**"NanoReactorOld"**,
           **"LatticeDeformationOld"**, **"NanoReactor"**,
           **"LatticeDeformation"**, **"Restart"**]*) -- The type of
           molecular dynamics.

         * **UseDeuterium** (*BoolType** | **BoolKey*) -- If true, all
           hydrogen atoms will be replaced by deuterium during the MD.
           This helps to slow down the motion of the hydrogen atoms.
           This options does *not* affect the density you should
           insert in BuildSystem%Density. However, it *does* affect
           the density on the resulting MD trajectory file.

         * **BondOrders**
           (*ReactionsDiscovery._MolecularDynamics._BondOrders*) --
           Details regarding the calculation/guessing of bond orders
           during Molecular Dynamics. The bond changes during the MD
           are later analyzed in the Network Extraction step.

         * **BuildSystem**
           (*ReactionsDiscovery._MolecularDynamics._BuildSystem*) --
           Build the initial system for molecular dynamics with
           packmol. If "MolecularDynamics%Type" is set to "Restart",
           then BuildSystem is ignored.

         * **LatticeDeformation** (*ReactionsDiscovery._MolecularDyna
           mics._LatticeDeformation*) -- Option for the reactive
           molecular dynamics.

         * **NanoReactor**
           (*ReactionsDiscovery._MolecularDynamics._NanoReactor*) --
           Option for the reactive molecular dynamics.

         * **Restart**
           (*ReactionsDiscovery._MolecularDynamics._Restart*) --
           Settings for restarting MD simulations.

      class _BondOrders

         Details regarding the calculation/guessing of bond orders
         during Molecular Dynamics. The bond changes during the MD are
         later analyzed in the Network Extraction step.

         Variables:
            **Method** (*Literal**[**"Guess"**,
            **"EngineWithGuessFallback"**]*) --

            How to compute the bond orders.

            'Guess': Use a bond guessing algorithm based on the
            system's geometry. This is the same algorithm that is used
            by the Graphical User Interface to guess bonds.

            'EngineWithGuessFallback': let the engine compute the bond
            orders but if the engine did not produce any bond orders,
            use the bond guessing algorithm as a fallback option.

      class _BuildSystem

         Build the initial system for molecular dynamics with packmol.
         If "MolecularDynamics%Type" is set to "Restart", then
         BuildSystem is ignored.

         Variables:
            * **Density** (*float** | **FloatKey*) -- The initial
              density of the system. This should be the lowest density
              (corresponding to the largest volume) that you want the
              system to have. The standard atomic masses are used when
              building the system.

            * **Enabled** (*BoolType** | **BoolKey*) -- If True, build
              the initial system using packmol. If False, a System
              block must be provided with the initial system.

            * **Equilibration** (*BoolType** | **BoolKey*) -- Whether
              to run a short 250 fs equilibration simulation on the
              packmol-built structure.

            * **NumAtoms** (*int** | **IntKey*) -- Approximate total
              number of atoms in each MD simulation.

            * **Molecule** (*ReactionsDiscovery._MolecularDynamics._B
              uildSystem._Molecule*) -- A molecule to put in the MD
              simulation.

         class _Molecule

            A molecule to put in the MD simulation.

            Variables:
               * **MoleFraction** (*float** | **FloatKey*) -- Mole
                 fraction of the molecule (the mole fractions of the
                 various molecules will be normalized, so only the
                 relative MoleFraction values matter)

               * **SMILES** (*str** | **StringKey*) -- The SMILES
                 string of the molecules.

               * **SystemID** (*str** | **StringKey*) -- The ID of the
                 corresponding System (i.e. the header of the
                 corresponding System block).

      class _LatticeDeformation

         Option for the reactive molecular dynamics.

         Variables:
            * **MinVolumeFraction** (*float** | **FloatKey*) -- The
              minimum (compressed) volume of the system, as a fraction
              of the initial (maximum) system volume.

            * **NumCycles** (*int** | **IntKey*) -- How many
              compression-expansion cycles to perform.

            * **Period** (*float** | **FloatKey*) -- The period with
              which the lattice will oscillate in femtoseconds.

            * **Temperature** (*float** | **FloatKey*) -- Thermostat
              temperature during the MD simulation.

      class _NanoReactor

         Option for the reactive molecular dynamics.

         Variables:
            * **DiffusionTime** (*float** | **FloatKey*) -- The length
              of the diffusion phase in femtoseconds.

            * **InitialRadius** (*float** | **FloatKey*) -- The radius
              of the initial (spherical) system. If "BuildSystem" is
              used, the value is ignored (then the value is
              automatically determined). If "BuildSystem" is not used,
              then a guess for the "InitialRadius" will be made if it
              is not specified.

            * **MinVolumeFraction** (*float** | **FloatKey*) -- The
              minimum (compressed) volume of the system, as a fraction
              of the initial (maximum) system volume.

            * **NumCycles** (*int** | **IntKey*) -- How many
              compression-expansion cycles to perform.

            * **Temperature** (*float** | **FloatKey*) -- Temperature
              during the diffusion phase. The temperature during the
              compression phase will be much higher as a result of the
              inward acceleration.

      class _Restart

         Settings for restarting MD simulations.

         Variables:
            * **Directory** (*str** | **Path** | **StringKey*) --
              Directory containing a previous Reactions Discovery
              calculation with MD simulations that were not finished.
              Note: This directory will be scanned recursively for
              ams.rkf files!

            * **NSteps** (*int** | **IntKey*) -- Number of MD steps.
              If left empty, the number of MD steps from the original
              MD trajectory will be used. Note that you need to
              manually increase this number if you want to continue
              finished simulations.

   class _NetworkExtraction

      Options for extracting the reactive network from MD trajectories

      Variables:
         * **Enabled** (*BoolType** | **BoolKey*) -- Whether to
           perform network extraction.

         * **ExtractFromFailedMDJobs** (*BoolType** | **BoolKey*) --
           Whether to extract from failed/crashed MD jobs (by default,
           only successful jobs are used)

         * **MDTrajectories** (*str** | **Path** | **StringKey*) -- If
           MolecularDynamics%Enabled is False, this directory will be
           recursively scanned for ams.rkf files containing MD
           trajectories. All found trajectories will be used for the
           analysis. It should typically be a Reactions Discovery
           results directory containing finished MD simulations.

         * **StoreGeometryOptimizationResults** (*BoolType** |
           **BoolKey*) -- Many AMS calculations are performed to
           analyse whether detected molecules are stable. Enabling
           this option will store all those calculations on disk,
           which can be helpful to understand why a molecule was not
           considered stable or why a calculation failed, but it will
           make the NetworkExtraction much slower and can take up
           large amounts of disk space.

         * **UseCharges** (*BoolType** | **BoolKey*) -- Use engine-
           calculated charges if they exist on the MD trajectory files
           for the NetworkExtraction

         * **Print** (*ReactionsDiscovery._NetworkExtraction._Print*)
           -- Printing details

      class _Print

         Printing details

         Variables:
            * **FilterFluctuations** (*BoolType** | **BoolKey*) -- If
              true, do not print molecules that are only part of
              recrossing reactions.

            * **MaxReactionOrder** (*int** | **IntKey*) -- If the
              reaction order is larger than this value, the reaction
              will not be printed.

            * **MinReactionsThreshold** (*int** | **IntKey*) -- If a
              molecule is involved in fewer reaction than this value,
              skip printing the results corresponding to it. To print
              all molecules, set this value to 0.

            * **SkipRareReactions** (*BoolType** | **BoolKey*) -- If
              true,reduce the output by filtering out rare reactions.
              If false, always print all reactions.

   class _ProductRanking

      Options for ranking of the intermediates by stability

      Variables:
         * **BalanceFromNetwork** (*BoolType** | **BoolKey*) -- Use
           the network to determine the balanced reaction from the
           initial reactants to each stable product. This is not the
           default. By default, a balanced equation is determined
           directly by using the other stable products as possible
           side products.

         * **DiscardIons** (*BoolType** | **BoolKey*) -- Remove all
           ions from the final product list

         * **Enabled** (*BoolType** | **BoolKey*) -- Whether to
           perform ranking of the reaction network.

         * **MaxBalancedReactions** (*int** | **IntKey*) -- The
           maximum number of stable products used to find a balanced
           reaction equation for each one.

         * **ReactionNetwork** (*str** | **Path** | **StringKey*) --
           Directory containing a previous Reactions Discovery
           calculation with 'NetworkExtraction%Enabled Yes'

         * **Temperature** (*float** | **FloatKey*) -- Temperature
           used to compute reaction rates from reaction energies of
           reactions in the reaction network.

         * **WritePaths** (*BoolType** | **BoolKey*) -- Write full
           paths to the reaction network for each molecule.

   class _System

      Specification of the chemical system. For some applications more
      than one system may be present in the input. In this case, all
      systems except one must have a non-empty string ID specified
      after the System keyword. The system without an ID is considered
      the main one.

      Variables:
         * **AllowCloseAtoms** (*BoolType** | **BoolKey*) -- No longer
           functional. Just here for backwards compatibility.

         * **Charge** (*float** | **FloatKey*) -- The system's total
           charge in atomic units.

         * **FractionalCoords** (*BoolType** | **BoolKey*) -- Whether
           the atomic coordinates in the Atoms block are given in
           fractional coordinates of the lattice vectors. Requires the
           presence of the Lattice block.

         * **GeometryFile** (*str** | **Path** | **StringKey*) -- Read
           the geometry from a file (instead of from Atoms and Lattice
           blocks). Supported formats: .xyz

         * **GuessBonds** (*BoolType** | **BoolKey*) -- Equivalent to
           'Modify%GuessBonds'. Please update input file to use
           'Modify' block instead.

         * **LatticeStrain** (*Iterable**[**float**] **|
           **FloatListKey*) -- Equivalent to 'Modify%LatticeStrain'.
           Please update input file to use 'Modify' block instead.

         * **MapAtomsToUnitCell** (*BoolType** | **BoolKey*) --
           Equivalent to 'Modify%MapAtomsToUnitCell'. Please update
           input file to use 'Modify' block instead.

         * **PerturbCoordinates** (*float** | **FloatKey*) --
           Equivalent to 'Modify%PerturbCoordinates'. Please update
           input file to use 'Modify' block instead.

         * **PerturbLattice** (*float** | **FloatKey*) -- Equivalent
           to 'Modify%PerturbLattice'. Please update input file to use
           'Modify' block instead.

         * **ShiftCoordinates** (*Iterable**[**float**] **|
           **FloatListKey*) -- Equivalent to 'Modify%Translate', but
           in the unit of bohr by default. Please update input file to
           use 'Modify' block instead.

         * **SuperCell** (*Iterable**[**int**] **| **IntListKey*) --
           Equivalent to 'Modify%SuperCell'. Please update input file
           to use 'Modify' block instead.

         * **SuperCellTrafo** (*Iterable**[**int**] **| **IntListKey*)
           -- Equivalent to 'Modify%SuperCellTrafo'. Please update
           input file to use 'Modify' block instead.

         * **Symmetrize** (*BoolType** | **BoolKey*) -- Equivalent to
           'Modify%Symmetrize'. Please update input file to use
           'Modify' block instead.

         * **Atoms** (*str** | **Sequence**[**str**] **| **FreeBlock*)
           -- The atom types and coordinates. Unit can be specified in
           the header. Default unit is Angstrom.

         * **BondOrders** (*str** | **Sequence**[**str**] **|
           **FreeBlock*) -- Defined bond orders. Each line should
           contain two atom indices, followed by the bond order (1,
           1.5, 2, 3 for single, aromatic, double and triple bonds)
           and (optionally) the cell shifts for periodic systems. May
           be used by MM engines and for defining constraints. If the
           system is periodic and none of the bonds have the cell
           shift defined then AMS will attempt to determine them
           following the minimum image convention.

         * **ElectrostaticEmbedding**
           (*ReactionsDiscovery._System._ElectrostaticEmbedding*) --
           Container for electrostatic embedding options, which can be
           combined.

         * **Lattice** (*str** | **Sequence**[**str**] **|
           **FreeBlock*) -- Up to three lattice vectors. Unit can be
           specified in the header. Default unit is Angstrom.

         * **Modify** (*ReactionsDiscovery._System._Modify*) --
           Modifications to make to the chemical system after
           construction. This block is read like a script and the
           modifications applied top to bottom.

      class _Atoms

         The atom types and coordinates. Unit can be specified in the
         header. Default unit is Angstrom.

      class _BondOrders

         Defined bond orders. Each line should contain two atom
         indices, followed by the bond order (1, 1.5, 2, 3 for single,
         aromatic, double and triple bonds) and (optionally) the cell
         shifts for periodic systems. May be used by MM engines and
         for defining constraints. If the system is periodic and none
         of the bonds have the cell shift defined then AMS will
         attempt to determine them following the minimum image
         convention.

      class _ElectrostaticEmbedding

         Container for electrostatic embedding options, which can be
         combined.

         Variables:
            * **ElectricField** (*Iterable**[**float**] **|
              **FloatListKey*) --

              External homogeneous electric field with three Cartesian
              components: ex, ey, ez, the default unit being V/Å.

              In atomic units: Hartree/(e bohr) = 51.422 V/Angstrom;
              the relation to SI units is: 1 Hartree/(e bohr) = 5.14
              ... e11 V/m.

              Supported by the engines adf, band, dftb and mopac.

              For periodic systems the field may only have nonzero
              components orthogonal to the direction(s) of periodicity
              (i.e. for 1D periodic system the x-component of the
              electric field should be zero, while for 2D periodic
              systems both the x and y components should be zero. This
              options cannot be used for 3D periodic systems.

            * **MultipolePotential** (*ReactionsDiscovery._System._El
              ectrostaticEmbedding._MultipolePotential*) -- External
              point charges (and dipoles).

         class _MultipolePotential

            External point charges (and dipoles).

            Variables:
               * **ChargeModel** (*Literal**[**"Point"**,
                 **"Gaussian"**]*) -- A multipole may be represented
                 by a point (with a singular potential at its
                 location) or by a spherical Gaussian distribution.

               * **ChargeWidth** (*float** | **FloatKey*) -- The width
                 parameter in a.u. in case a Gaussian charge model is
                 chosen. A negative value means that the width will be
                 chosen automatically.

               * **Coordinates** (*str** | **Sequence**[**str**] **|
                 **FreeBlock*) --

                 Positions and values of the multipoles, one per line.
                 Each line has the following format:

                 x y z q, or x y z q µx µy µz.

                 Here x, y, z are the coordinates in Å, q is the
                 charge (in atomic units of charge) and µx, µy, µz are
                 the (optional) dipole moment components (in atomic
                 units, i.e. e*Bohr).

                 Periodic systems are not supported.

            class _Coordinates

               Positions and values of the multipoles, one per line.
               Each line has the following format:

               x y z q, or x y z q µx µy µz.

               Here x, y, z are the coordinates in Å, q is the charge
               (in atomic units of charge) and µx, µy, µz are the
               (optional) dipole moment components (in atomic units,
               i.e. e*Bohr).

               Periodic systems are not supported.

      class _Lattice

         Up to three lattice vectors. Unit can be specified in the
         header. Default unit is Angstrom.

      class _Modify

         Modifications to make to the chemical system after
         construction. This block is read like a script and the
         modifications applied top to bottom.

         Variables:
            * **EnableAtomAttributes** (*Literal**[**"gui"**,
              **"adf"**, **"band"**, **"forcefield"**, **"dftb"**,
              **"reaxff"**, **"qe"**]*) -- Enables an atomic attribute
              group. This is only necessary if you want a group
              enabled, but no atom in the input is using any attribute
              from that group.

            * **GuessBonds** (*BoolType** | **BoolKey*) -- Guesses
              bonds based on the atomic elements and the geometry.
              Keeps existing bonds.

            * **LatticeStrain** (*Iterable**[**float**] **|
              **FloatListKey*) -- Deform the input system by the
              specified strain. The strain elements are in Voigt
              notation, so one should specify 6 numbers for 3D
              periodic system (order: xx,yy,zz,yz,xz,xy), 3 numbers
              for 2D periodic systems (order: xx,yy,xy) or 1 number
              for 1D periodic systems.

            * **MapAtomsToUnitCell** (*Iterable**[**float**] **|
              **FloatListKey*) -- For periodic systems the atoms will
              be moved to the central unit cell where all their
              fractional coordinates are in the range
              [start_range,start_range+1). No mapping will take place
              along non-periodic directions. If just a single number
              is given, it corresponds to start_range. If multiple
              numbers are given, they should match the number of
              lattice vectors and will be used as start ranges along
              the individual lattice vectors. If no number is given at
              all, the mapping will be done to the [-0.5:0.5) cell.

            * **PerturbCoordinates** (*float** | **FloatKey*) --
              Perturb the atomic coordinates by adding random numbers
              between [-PerturbCoordinates,PerturbCoordinates] to each
              Cartesian component. This can be useful if you want to
              break the symmetry of your system (e.g. for a geometry
              optimization).

            * **PerturbLattice** (*float** | **FloatKey*) -- Perturb
              the lattice vectors by applying random strain with
              matrix elements between
              [-PerturbLattice,PerturbLattice]. This can be useful if
              you want to deviate from an ideal symmetric geometry,
              for example if you look for a phase change due to high
              pressure.

            * **SuperCell** (*Iterable**[**int**] **| **IntListKey*)
              -- Create a supercell of the input system (only possible
              for periodic systems). The integer numbers represent the
              diagonal elements of the supercell transformation; you
              should specify as many numbers as lattice vectors (i.e.
              1 number for 1D, 2 numbers for 2D and 3 numbers for 3D
              periodic systems).

            * **SuperCellTrafo** (*Iterable**[**int**] **|
              **IntListKey*) -- Create a supercell of the input system
              (only possible for periodic systems) \vec{a}_i' = \sum_j
              T_{ij} \vec{a}_j. The integer numbers represent the
              supercell transformation T_{ij}: 1 number for 1D PBC, 4
              numbers for 2D PBC corresponding to a 2x2 matrix (order:
              (1,1),(1,2),(2,1),(2,2)) and 9 numbers for 3D PBC
              corresponding to a 3x3 matrix (order:
              (1,1),(1,2),(1,3),(2,1),(2,2),(2,3),(3,1),(3,2),(3,3)).

            * **Symmetrize** (*BoolType** | **BoolKey*) -- Symmetrizes
              a system, using either the "symmetrize_molecule" or
              "symmetrize_cell" method, depending on periodicity.

            * **SymmetrizeMoleculeTo** (*str** | **StringKey*) --
              Symmetrizes a molecule to a particular symmetry given by
              a Schoenflies symbol. Symmetrizes the atomic coordinates
              to machine precision, but does NOT rototranslate the
              molecule in any way. If the symmetrization fails, an
              error will be raised.

            * **Translate** (*Iterable**[**float**] **|
              **FloatListKey*) -- Translate all atoms by a vector.

class RedoxPotential

   Variables:
      * **Method** (*Literal**[**"DC"**, **"TC"**, **"TC-COSMORS"**,
        **"Screening"**]*) --

        Specify the method to use to calculate the redox potential.

        DC: Direct calculation TC: Thermodynamic cycle TC-COSMORS:
        Thermodynamic cycle using COSMO-RS Screening: Quick method
        using lower level of theory (GFN1-xTB)

      * **Mode** (*Literal**[**"Oxidation"**, **"Reduction"**]*) --
        Specify whether to do reduction or oxidation

      * **System** (*RedoxPotential._System*) -- Specification of the
        chemical system. For some applications more than one system
        may be present in the input. In this case, all systems except
        one must have a non-empty string ID specified after the System
        keyword. The system without an ID is considered the main one.

   class _System

      Specification of the chemical system. For some applications more
      than one system may be present in the input. In this case, all
      systems except one must have a non-empty string ID specified
      after the System keyword. The system without an ID is considered
      the main one.

      Variables:
         * **AllowCloseAtoms** (*BoolType** | **BoolKey*) -- No longer
           functional. Just here for backwards compatibility.

         * **Charge** (*float** | **FloatKey*) -- The system's total
           charge in atomic units.

         * **FractionalCoords** (*BoolType** | **BoolKey*) -- Whether
           the atomic coordinates in the Atoms block are given in
           fractional coordinates of the lattice vectors. Requires the
           presence of the Lattice block.

         * **GeometryFile** (*str** | **Path** | **StringKey*) -- Read
           the geometry from a file (instead of from Atoms and Lattice
           blocks). Supported formats: .xyz

         * **GuessBonds** (*BoolType** | **BoolKey*) -- Equivalent to
           'Modify%GuessBonds'. Please update input file to use
           'Modify' block instead.

         * **LatticeStrain** (*Iterable**[**float**] **|
           **FloatListKey*) -- Equivalent to 'Modify%LatticeStrain'.
           Please update input file to use 'Modify' block instead.

         * **MapAtomsToUnitCell** (*BoolType** | **BoolKey*) --
           Equivalent to 'Modify%MapAtomsToUnitCell'. Please update
           input file to use 'Modify' block instead.

         * **PerturbCoordinates** (*float** | **FloatKey*) --
           Equivalent to 'Modify%PerturbCoordinates'. Please update
           input file to use 'Modify' block instead.

         * **PerturbLattice** (*float** | **FloatKey*) -- Equivalent
           to 'Modify%PerturbLattice'. Please update input file to use
           'Modify' block instead.

         * **ShiftCoordinates** (*Iterable**[**float**] **|
           **FloatListKey*) -- Equivalent to 'Modify%Translate', but
           in the unit of bohr by default. Please update input file to
           use 'Modify' block instead.

         * **SuperCell** (*Iterable**[**int**] **| **IntListKey*) --
           Equivalent to 'Modify%SuperCell'. Please update input file
           to use 'Modify' block instead.

         * **SuperCellTrafo** (*Iterable**[**int**] **| **IntListKey*)
           -- Equivalent to 'Modify%SuperCellTrafo'. Please update
           input file to use 'Modify' block instead.

         * **Symmetrize** (*BoolType** | **BoolKey*) -- Equivalent to
           'Modify%Symmetrize'. Please update input file to use
           'Modify' block instead.

         * **Atoms** (*str** | **Sequence**[**str**] **| **FreeBlock*)
           -- The atom types and coordinates. Unit can be specified in
           the header. Default unit is Angstrom.

         * **BondOrders** (*str** | **Sequence**[**str**] **|
           **FreeBlock*) -- Defined bond orders. Each line should
           contain two atom indices, followed by the bond order (1,
           1.5, 2, 3 for single, aromatic, double and triple bonds)
           and (optionally) the cell shifts for periodic systems. May
           be used by MM engines and for defining constraints. If the
           system is periodic and none of the bonds have the cell
           shift defined then AMS will attempt to determine them
           following the minimum image convention.

         * **ElectrostaticEmbedding**
           (*RedoxPotential._System._ElectrostaticEmbedding*) --
           Container for electrostatic embedding options, which can be
           combined.

         * **Lattice** (*str** | **Sequence**[**str**] **|
           **FreeBlock*) -- Up to three lattice vectors. Unit can be
           specified in the header. Default unit is Angstrom.

         * **Modify** (*RedoxPotential._System._Modify*) --
           Modifications to make to the chemical system after
           construction. This block is read like a script and the
           modifications applied top to bottom.

      class _Atoms

         The atom types and coordinates. Unit can be specified in the
         header. Default unit is Angstrom.

      class _BondOrders

         Defined bond orders. Each line should contain two atom
         indices, followed by the bond order (1, 1.5, 2, 3 for single,
         aromatic, double and triple bonds) and (optionally) the cell
         shifts for periodic systems. May be used by MM engines and
         for defining constraints. If the system is periodic and none
         of the bonds have the cell shift defined then AMS will
         attempt to determine them following the minimum image
         convention.

      class _ElectrostaticEmbedding

         Container for electrostatic embedding options, which can be
         combined.

         Variables:
            * **ElectricField** (*Iterable**[**float**] **|
              **FloatListKey*) --

              External homogeneous electric field with three Cartesian
              components: ex, ey, ez, the default unit being V/Å.

              In atomic units: Hartree/(e bohr) = 51.422 V/Angstrom;
              the relation to SI units is: 1 Hartree/(e bohr) = 5.14
              ... e11 V/m.

              Supported by the engines adf, band, dftb and mopac.

              For periodic systems the field may only have nonzero
              components orthogonal to the direction(s) of periodicity
              (i.e. for 1D periodic system the x-component of the
              electric field should be zero, while for 2D periodic
              systems both the x and y components should be zero. This
              options cannot be used for 3D periodic systems.

            * **MultipolePotential** (*RedoxPotential._System._Electr
              ostaticEmbedding._MultipolePotential*) -- External point
              charges (and dipoles).

         class _MultipolePotential

            External point charges (and dipoles).

            Variables:
               * **ChargeModel** (*Literal**[**"Point"**,
                 **"Gaussian"**]*) -- A multipole may be represented
                 by a point (with a singular potential at its
                 location) or by a spherical Gaussian distribution.

               * **ChargeWidth** (*float** | **FloatKey*) -- The width
                 parameter in a.u. in case a Gaussian charge model is
                 chosen. A negative value means that the width will be
                 chosen automatically.

               * **Coordinates** (*str** | **Sequence**[**str**] **|
                 **FreeBlock*) --

                 Positions and values of the multipoles, one per line.
                 Each line has the following format:

                 x y z q, or x y z q µx µy µz.

                 Here x, y, z are the coordinates in Å, q is the
                 charge (in atomic units of charge) and µx, µy, µz are
                 the (optional) dipole moment components (in atomic
                 units, i.e. e*Bohr).

                 Periodic systems are not supported.

            class _Coordinates

               Positions and values of the multipoles, one per line.
               Each line has the following format:

               x y z q, or x y z q µx µy µz.

               Here x, y, z are the coordinates in Å, q is the charge
               (in atomic units of charge) and µx, µy, µz are the
               (optional) dipole moment components (in atomic units,
               i.e. e*Bohr).

               Periodic systems are not supported.

      class _Lattice

         Up to three lattice vectors. Unit can be specified in the
         header. Default unit is Angstrom.

      class _Modify

         Modifications to make to the chemical system after
         construction. This block is read like a script and the
         modifications applied top to bottom.

         Variables:
            * **EnableAtomAttributes** (*Literal**[**"gui"**,
              **"adf"**, **"band"**, **"forcefield"**, **"dftb"**,
              **"reaxff"**, **"qe"**]*) -- Enables an atomic attribute
              group. This is only necessary if you want a group
              enabled, but no atom in the input is using any attribute
              from that group.

            * **GuessBonds** (*BoolType** | **BoolKey*) -- Guesses
              bonds based on the atomic elements and the geometry.
              Keeps existing bonds.

            * **LatticeStrain** (*Iterable**[**float**] **|
              **FloatListKey*) -- Deform the input system by the
              specified strain. The strain elements are in Voigt
              notation, so one should specify 6 numbers for 3D
              periodic system (order: xx,yy,zz,yz,xz,xy), 3 numbers
              for 2D periodic systems (order: xx,yy,xy) or 1 number
              for 1D periodic systems.

            * **MapAtomsToUnitCell** (*Iterable**[**float**] **|
              **FloatListKey*) -- For periodic systems the atoms will
              be moved to the central unit cell where all their
              fractional coordinates are in the range
              [start_range,start_range+1). No mapping will take place
              along non-periodic directions. If just a single number
              is given, it corresponds to start_range. If multiple
              numbers are given, they should match the number of
              lattice vectors and will be used as start ranges along
              the individual lattice vectors. If no number is given at
              all, the mapping will be done to the [-0.5:0.5) cell.

            * **PerturbCoordinates** (*float** | **FloatKey*) --
              Perturb the atomic coordinates by adding random numbers
              between [-PerturbCoordinates,PerturbCoordinates] to each
              Cartesian component. This can be useful if you want to
              break the symmetry of your system (e.g. for a geometry
              optimization).

            * **PerturbLattice** (*float** | **FloatKey*) -- Perturb
              the lattice vectors by applying random strain with
              matrix elements between
              [-PerturbLattice,PerturbLattice]. This can be useful if
              you want to deviate from an ideal symmetric geometry,
              for example if you look for a phase change due to high
              pressure.

            * **SuperCell** (*Iterable**[**int**] **| **IntListKey*)
              -- Create a supercell of the input system (only possible
              for periodic systems). The integer numbers represent the
              diagonal elements of the supercell transformation; you
              should specify as many numbers as lattice vectors (i.e.
              1 number for 1D, 2 numbers for 2D and 3 numbers for 3D
              periodic systems).

            * **SuperCellTrafo** (*Iterable**[**int**] **|
              **IntListKey*) -- Create a supercell of the input system
              (only possible for periodic systems) \vec{a}_i' = \sum_j
              T_{ij} \vec{a}_j. The integer numbers represent the
              supercell transformation T_{ij}: 1 number for 1D PBC, 4
              numbers for 2D PBC corresponding to a 2x2 matrix (order:
              (1,1),(1,2),(2,1),(2,2)) and 9 numbers for 3D PBC
              corresponding to a 3x3 matrix (order:
              (1,1),(1,2),(1,3),(2,1),(2,2),(2,3),(3,1),(3,2),(3,3)).

            * **Symmetrize** (*BoolType** | **BoolKey*) -- Symmetrizes
              a system, using either the "symmetrize_molecule" or
              "symmetrize_cell" method, depending on periodicity.

            * **SymmetrizeMoleculeTo** (*str** | **StringKey*) --
              Symmetrizes a molecule to a particular symmetry given by
              a Schoenflies symbol. Symmetrizes the atomic coordinates
              to machine precision, but does NOT rototranslate the
              molecule in any way. If the symmetrization fails, an
              error will be raised.

            * **Translate** (*Iterable**[**float**] **|
              **FloatListKey*) -- Translate all atoms by a vector.

class SGF

   Variables:
      * **Debug** (*str** | **StringKey*) --

      * **Save** (*str** | **StringKey*) --

      * **Title** (*str** | **StringKey*) --

      * **SurfaceGF** (*SGF._SurfaceGF*) --

      * **TightBinding** (*SGF._TightBinding*) --

   class _SurfaceGF

      Variables:
         * **BANDMU** (*float** | **FloatKey*) --

         * **CONTACT** (*int** | **IntKey*) --

         * **CPMARGIN** (*float** | **FloatKey*) --

         * **ContourQuality** (*Literal**[**"basic"**, **"normal"**,
           **"good"**, **"verygood"**, **"excellent"**]*) --

         * **DELTA** (*float** | **FloatKey*) --

         * **ETA** (*float** | **FloatKey*) --

         * **KGRID** (*int** | **IntKey*) --

         * **KT** (*float** | **FloatKey*) --

         * **MAXDOS** (*float** | **FloatKey*) --

         * **MINDOS** (*float** | **FloatKey*) --

         * **MINVALENCE** (*float** | **FloatKey*) --

         * **MULOWER** (*float** | **FloatKey*) --

         * **MUUPPER** (*float** | **FloatKey*) --

         * **NARCPTS** (*int** | **IntKey*) --

         * **NDOSPTS** (*int** | **IntKey*) --

         * **NE** (*int** | **IntKey*) --

         * **NEQLINEPTS** (*int** | **IntKey*) --

         * **NFPOLES** (*int** | **IntKey*) --

         * **NLAYERS** (*int** | **IntKey*) --

         * **NNONEQLPTS** (*int** | **IntKey*) --

         * **PHI1** (*float** | **FloatKey*) --

         * **PHI2** (*float** | **FloatKey*) --

         * **RKFFileName** (*str** | **StringKey*) --

         * **SCMCODE** (*BoolType** | **BoolKey*) --

         * **SECANT** (*BoolType** | **BoolKey*) --

         * **SGFMaxIter** (*int** | **IntKey*) --

         * **SGFTOL** (*float** | **FloatKey*) --

         * **TOL** (*float** | **FloatKey*) --

         * **TRANSDIR** (*int** | **IntKey*) --

         * **TRUEMU** (*float** | **FloatKey*) --

         * **deContourInt** (*float** | **FloatKey*) --

   class _TightBinding

      Variables:
         * **DTol** (*float** | **FloatKey*) --

         * **Eps** (*float** | **FloatKey*) --

         * **IODim** (*int** | **IntKey*) --

         * **MaxMerit** (*float** | **FloatKey*) --

         * **MaxRange** (*float** | **FloatKey*) --

         * **XTol** (*float** | **FloatKey*) --

class SimpleActiveLearning

   Variables:
      * **RNGSeed** (*Iterable**[**int**] **| **IntListKey*) --
        Initial seed for the (pseudo)random number generator. This
        should be omitted in most calculations to avoid introducing
        bias into the results. If this is unset, the generator will be
        seeded randomly from external sources of entropy. If you want
        to exactly reproduce an older calculation, set this to the
        numbers printed in its output.

      * **Task** (*Literal**[**"MolecularDynamics"**]*) -- The task to
        perform.

      * **ActiveLearning** (*SimpleActiveLearning._ActiveLearning*) --
        Settings for Active Learning

      * **Constraints** (*SimpleActiveLearning._Constraints*) -- The
        Constraints block allows geometry optimizations and potential
        energy surface scans with constraints. The constraints do not
        have to be satisfied at the start of the calculation.

      * **Engine** (*EngineBlock*) -- The reference engine settings.

      * **LoadSystem** (*SimpleActiveLearning._LoadSystem*) -- Block
        that controls reading the chemical system from a KF file
        instead of the [System] block.

      * **MachineLearning** (*SimpleActiveLearning._MachineLearning*)
        -- Options for Task MachineLearning.

      * **MolecularDynamics**
        (*SimpleActiveLearning._MolecularDynamics*) -- Settings for
        Molecular Dynamics

      * **ParallelLevels** (*SimpleActiveLearning._ParallelLevels*) --
        Distribution of threads/processes between the parallelization
        levels.

      * **System** (*SimpleActiveLearning._System*) -- Specification
        of the chemical system. For some applications more than one
        system may be present in the input. In this case, all systems
        except one must have a non-empty string ID specified after the
        System keyword. The system without an ID is considered the
        main one.

   class _ActiveLearning

      Settings for Active Learning

      Variables:
         * **JobPrefix** (*str** | **StringKey*) -- Jobs added to the
           job collection will receive this prefix. Example: set to
           "water_" to get jobs like "water_step1_attempt1_frame001".
           If the prefix does not end with an underscore "_", one will
           be automatically added.

         * **MaxAttemptsPerStep** (*int** | **IntKey*) -- Maximum
           number of attempts per active learning step. If this number
           is exceeded, the active learning will continue to the next
           step even if the potential is not accurate enough according
           to the criteria. If the default value is exceeded, it
           probably means that the criteria are too strict.

         * **MaxReferenceCalculationsPerAttempt** (*int** | **IntKey*)
           -- Maximum number of reference calculations per attempt.
           For successful attempts, only a single reference
           calculation is performed. For very short active learning
           steps, fewer calculations are done than the number
           specified.

         * **RestartDirectory** (*str** | **Path** | **StringKey*) --

           Directory to restart from. It should be a "jobname.results"
           folder containing the file "simple_active_learning.rkf".

           This will continue an interrupted Active Learning workflow
           and ignore all other input settings.

           To reuse reference data from a previous workflow, instead
           use the "ActiveLearning%InitialReferenceData" block. To
           reuse a previously trained model, instead use the
           "MachineLearning%LoadModel" key.

         * **AtEnd** (*SimpleActiveLearning._ActiveLearning._AtEnd*)
           -- What to do at the end of the active learning loop.

         * **FromScratchTraining** (*SimpleActiveLearning._ActiveLear
           ning._FromScratchTraining*) -- Custom options when training
           'from scratch' (not restarting).

         * **InitialReferenceData** (*SimpleActiveLearning._ActiveLea
           rning._InitialReferenceData*) -- Options for loading
           reference data.

         * **ReasonableSimulationCriteria** (*SimpleActiveLearning._A
           ctiveLearning._ReasonableSimulationCriteria*) -- Criteria
           for determining whether a simulation is reasonable. If any
           of the criteria are exceeded, this will be reported as
           'ENERGY_UNCERTAINTY', 'TEMPERATURE', etc., with capital
           letters in the output. If a simulation is unreasonable, it
           will never lead to an increase of the Step, even if the
           number of attempts exceeds "MaxAttemptsPerStep".

         * **Save** (*SimpleActiveLearning._ActiveLearning._Save*) --
           The files/directories on disk to keep. If you set these
           options to "All", a lot of output will be created. This
           output is usually not necessary but can be used for
           debugging purposes, or to better understand what the
           workflow is doing.

         * **Steps** (*SimpleActiveLearning._ActiveLearning._Steps*)
           -- Settings to determine the number of MD steps per active
           learning step.

         * **SuccessCriteria**
           (*SimpleActiveLearning._ActiveLearning._SuccessCriteria*)
           -- Criteria for determining whether an active learning step
           was successful. These criteria compare one or more
           reference calculations to the predictions. If any of the
           criteria are exceeded, the active learning loop will
           reparametrize the model and repeat the step.

      class _AtEnd

         What to do at the end of the active learning loop.

         Variables:
            * **RerunSimulation** (*BoolType** | **BoolKey*) -- Rerun
              the MD simulation (folder:
              "final_production_simulation") using the last set of
              parameters. This guarantees that the entire trajectory
              is calculated using the same model / potential energy
              surface, and that the trajectory has a consistent
              sampling frequency. This means that it can be used with
              all MD postanalysis tools.

            * **RetrainModel** (*BoolType** | **BoolKey*) -- Train a
              final model (folder: "final_training") using all
              reference (training and validation) data, including any
              reference calculations that have not yet been trained
              to.

      class _FromScratchTraining

         Custom options when training 'from scratch' (not restarting).

         Variables:
            * **Enabled** (*BoolType** | **BoolKey*) -- With the given
              probability, start parameter training from the original
              starting point (from 'scratch') instead of restarting
              from the previous step/attempt.

            * **EpochMultiplier** (*float** | **FloatKey*) -- The
              maximum number of epochs is multiplier by this number
              when training from scratch. When not restarting from the
              previous parameters, it is usually a good idea to train
              for more epochs.

            * **Probability** (*float** | **FloatKey*) -- With the
              given probability, start parameter training from the
              original starting point (from 'scratch') instead of
              restarting from the previous step/attempt.

      class _InitialReferenceData

         Options for loading reference data.

         Variables:
            * **Generate** (*SimpleActiveLearning._ActiveLearning._In
              itialReferenceData._Generate*) --

              How to generate initial reference data from the initial
              structure. Can also be combined with the "Load" block.

              The purpose of these options is to get some initial
              reference structures/data around the current structure
              that can be used for Step 1 of the active learning loop.

              The "ReferenceMD" option will be automatically enabled
              if no data is otherwise loaded or generated.

            * **Load** (*SimpleActiveLearning._ActiveLearning._Initia
              lReferenceData._Load*) -- How to load initial reference
              data from other sources. Can also be combined with the
              "Generate" block

         class _Generate

            How to generate initial reference data from the initial
            structure. Can also be combined with the "Load" block.

            The purpose of these options is to get some initial
            reference structures/data around the current structure
            that can be used for Step 1 of the active learning loop.

            The "ReferenceMD" option will be automatically enabled if
            no data is otherwise loaded or generated.

            Variables:
               * **M3GNetShortMD** (*SimpleActiveLearning._ActiveLear
                 ning._InitialReferenceData._Generate._M3GNetShortMD*)
                 -- Structure sampler using M3GNet-UP-2022

               * **ReferenceMD** (*SimpleActiveLearning._ActiveLearni
                 ng._InitialReferenceData._Generate._ReferenceMD*) --
                 Run a very short MD simulation using the reference
                 engine.

            class _M3GNetShortMD

               Structure sampler using M3GNet-UP-2022

               Variables:
                  **Enabled** (*BoolType** | **BoolKey*) -- Run 300
                  steps with M3GNet-UP-2022 at T=600 K. If the system
                  is 3D-periodic the density will be scanned around
                  the initial value. Extract 5 frames and run
                  reference calculations on those.

            class _ReferenceMD

               Run a very short MD simulation using the reference
               engine.

               Variables:
                  * **Enabled** (*BoolType** | **BoolKey*) -- Run 3
                    steps with the reference engine and add those 3
                    frames to the training and validation sets. If no
                    other reference data is loaded or generated, this
                    option will automatically be enabled.

                  * **NSteps** (*int** | **IntKey*) -- Number of steps
                    to run using the reference engine.

         class _Load

            How to load initial reference data from other sources. Can
            also be combined with the "Generate" block

            Variables:
               * **Directory** (*str** | **Path** | **StringKey*) --

                 Directory containing initial reference data. It can
                 be  * a ParAMS input directory or a
                 "stepX_attemptY_reference_data" directory containing
                 the files job_collection.yaml, training_set.yaml, and
                 validation_set.yaml. * a ParAMS results directory.

                 If a directory is specified here it will be used
                 instead of the data from a previously loaded model.

               * **FromPreviousModel** (*BoolType** | **BoolKey*) --

                 If "MachineLearning%LoadModel" is set, reuse
                 reference data from that ParAMS run.

                 If "MachineLearning%LoadModel" is not set, or if
                 "Directory" is specified, then this input option is
                 ignored.

      class _ReasonableSimulationCriteria

         Criteria for determining whether a simulation is reasonable.
         If any of the criteria are exceeded, this will be reported as
         'ENERGY_UNCERTAINTY', 'TEMPERATURE', etc., with capital
         letters in the output. If a simulation is unreasonable, it
         will never lead to an increase of the Step, even if the
         number of attempts exceeds "MaxAttemptsPerStep".

         Variables:
            * **Distance** (*SimpleActiveLearning._ActiveLearning._Re
              asonableSimulationCriteria._Distance*) -- Stop the
              simulation if any interatomic distance is smaller than
              the specified value.

            * **EnergyUncertainty** (*SimpleActiveLearning._ActiveLea
              rning._ReasonableSimulationCriteria._EnergyUncertainty*)
              -- Stop the simulation if the uncertainty in the energy
              is too high. Currently only applicable when training
              committees.

            * **GradientsUncertainty** (*SimpleActiveLearning._Active
              Learning._ReasonableSimulationCriteria._GradientsUncert
              ainty*) -- Stop the simulation if the uncertainty in the
              gradients (forces) is too high. Currently only
              applicable when training committees.

            * **Temperature** (*SimpleActiveLearning._ActiveLearning.
              _ReasonableSimulationCriteria._Temperature*) -- Discard
              all frames after the temperature has reached the
              specified value.

         class _Distance

            Stop the simulation if any interatomic distance is smaller
            than the specified value.

            Variables:
               * **Enabled** (*BoolType** | **BoolKey*) -- Stop the
                 simulation if any interatomic distance is smaller
                 than the specified value.

               * **MinValue** (*float** | **FloatKey*) -- Minimum
                 allowed interatomic distance.

         class _EnergyUncertainty

            Stop the simulation if the uncertainty in the energy is
            too high. Currently only applicable when training
            committees.

            Variables:
               * **Enabled** (*BoolType** | **BoolKey*) -- Stop the
                 simulation if the uncertainty in the energy is too
                 high. Currently only applicable when training
                 committees. If CommitteeSize = 1 then this keyword
                 has no effect.

               * **MaxValue** (*float** | **FloatKey*) -- Threshold
                 for allowed [energy uncertainty divided by
                 "Normalization"].

               * **Normalization** (*float** | **FloatKey*) --
                 Normalize (divide) the energy uncertainty by this
                 number before comparing to the specified threshold.
                 If not specified, it will become the number of atoms.

         class _GradientsUncertainty

            Stop the simulation if the uncertainty in the gradients
            (forces) is too high. Currently only applicable when
            training committees.

            Variables:
               * **Enabled** (*BoolType** | **BoolKey*) -- Stop the
                 simulation if the uncertainty in the gradients
                 (forces) is too high. Currently only applicable when
                 training committees. If CommitteeSize = 1 then this
                 keyword has no effect.

               * **MaxValue** (*float** | **FloatKey*) -- Maximum
                 allowed gradients (forces) uncertainty.

         class _Temperature

            Discard all frames after the temperature has reached the
            specified value.

            Variables:
               * **Enabled** (*BoolType** | **BoolKey*) -- Discard all
                 frames after the temperature has reached the
                 specified value.

               * **MaxValue** (*float** | **FloatKey*) -- Maximum
                 allowed temperature

      class _Save

         The files/directories on disk to keep. If you set these
         options to "All", a lot of output will be created. This
         output is usually not necessary but can be used for debugging
         purposes, or to better understand what the workflow is doing.

         Variables:
            * **ReferenceCalculations** (*Literal**[**"None"**,
              **"All"**]*) -- The reference calculation directories
              ("initial_reference_calculations" or
              "stepX_attemptY_ref_calcZ") including the original input
              and output.  These directories may take up a lot of disk
              space and are not kept by default. Enable this option if
              you need to investigate why reference calculations fail
              (incorrect input, SCF convergence problems, ...), or if
              you want to keep them for some other reason. Note: The
              output used for parametrization (energy, forces) is
              always stored in the ReferenceData (training and
              validation sets).

            * **ReferenceData** (*Literal**[**"Latest"**, **"All"**]*)
              -- The reference data directories
              ("stepX_attemptY_reference_data") containing the
              training and validation sets in ParAMS .yaml format (and
              ASE .xyz format). These can be opened in the ParAMS GUI
              or used as input for ParAMS.

            * **TrainingDirectories** (*Literal**[**"Latest"**,
              **"All"**]*) -- The ParAMS training directories
              ("stepX_attemptY_training").

            * **Trajectories** (*Literal**[**"Latest"**, **"All"**]*)
              -- The MD trajectory calculation directories
              ("stepX_attemptY_simulation") using the trained ML
              potential. Note: the trajectories in these directories
              are the entire trajectories from the beginning of the
              simulation.

      class _Steps

         Settings to determine the number of MD steps per active
         learning step.

         Variables:
            * **List** (*Iterable**[**int**] **| **IntListKey*) --
              List of MD frame indices, for example "10 50 200 1000
              10000 100000". Only indices smaller than
              "MolecularDynamics%NSteps" are considered. Note: the
              final frame of the MD simulation is always considered to
              be the end of a step and does not need to be specified
              here.

            * **Type** (*Literal**[**"Geometric"**, **"List"**,
              **"Linear"**]*) -- How to determine the number of MD
              steps per active learning step.

            * **Geometric** (*SimpleActiveLearning._ActiveLearning._S
              teps._Geometric*) -- Options for geometric.

            * **Linear**
              (*SimpleActiveLearning._ActiveLearning._Steps._Linear*)
              -- Options for linear.

         class _Geometric

            Options for geometric.

            Variables:
               * **NumSteps** (*int** | **IntKey*) -- The number of
                 active learning steps to perform. The MD simulation
                 will be split into this number of active learning
                 steps. The active learning steps will progressively
                 contain more and more MD steps.

               * **Start** (*int** | **IntKey*) -- The length of the
                 first step (in MD time steps).

         class _Linear

            Options for linear.

            Variables:
               * **Start** (*int** | **IntKey*) -- The length of the
                 first step (in MD time steps).

               * **StepSize** (*int** | **IntKey*) -- The length of
                 every subsequent active learning step (in MD time
                 steps).

      class _SuccessCriteria

         Criteria for determining whether an active learning step was
         successful. These criteria compare one or more reference
         calculations to the predictions. If any of the criteria are
         exceeded, the active learning loop will reparametrize the
         model and repeat the step.

         Variables:
            * **Energy** (*SimpleActiveLearning._ActiveLearning._Succ
              essCriteria._Energy*) -- Conditions to decide whether
              the calculated energy is are accurate enough with
              respect to reference energies.

            * **Forces** (*SimpleActiveLearning._ActiveLearning._Succ
              essCriteria._Forces*) -- Conditions to decide whether
              calculated forces are accurate enough with respect to
              reference forces.

         class _Energy

            Conditions to decide whether the calculated energy is are
            accurate enough with respect to reference energies.

            Variables:
               * **Enabled** (*BoolType** | **BoolKey*) -- Enable
                 energy checking during the active learning.

               * **Normalization** (*float** | **FloatKey*) --
                 Normalize (divide) energies by this number before
                 comparing to the specified thresholds. If not
                 specified, it will become the number of atoms.

               * **Relative** (*float** | **FloatKey*) --
                 "|ΔΔE|/Normalization": Maximum allowed difference
                 between the calculated relative reference energies
                 and relative predicted energies. The relative
                 energies are calculated for the current structure
                 with respect to the structure in the previous
                 reference calculation. ΔE_ref = E_ref(current) -
                 E_ref(previous). ΔE_pred = E_pred(current) -
                 E_pred(previous). "|ΔΔE| = |ΔE_pred - ΔE_ref|"

               * **Total** (*float** | **FloatKey*) --
                 "|ΔE|/Normalization": Maximum allowed total energy
                 difference between the reference and predicted
                 energy. This criterion is mostly useful when
                 restarting a workflow from a previously trained model
                 but on a new stoichiometry / system, for which the
                 total energy prediction may be very far from the
                 target. The default value is quite large so it is
                 normally not exceeded. "|∆E| = |E_pred - E_ref|"

         class _Forces

            Conditions to decide whether calculated forces are
            accurate enough with respect to reference forces.

            Variables:
               * **Enabled** (*BoolType** | **BoolKey*) -- Enable
                 checking the forces during the active learning.

               * **MaxDeviationForZeroForce** (*float** | **FloatKey*)
                 -- The maximum allowed deviation between a calculated
                 force component and the corresponding reference force
                 component. For larger reference forces, the allowed
                 deviation will also be larger (see the
                 documentation). If any deviation is larger than the
                 (magnitude-dependent) threshold, the active learning
                 step will be repeated after a reparametrization.

               * **MaxMAE** (*float** | **FloatKey*) -- Maximum
                 allowed mean absolute error when comparing reference
                 and predicted forces for a single frame at the end of
                 an active learning step. If the obtained MAE is
                 larger than this threshold, the active learning step
                 will be repeated after a reparametrization.

               * **MinR2** (*float** | **FloatKey*) -- Minimum allowed
                 value for R^2 when comparing reference and predicted
                 forces for a single frame at the end of an active
                 learning step. If the obtained R^2 is smaller than
                 this threshold, the active learning step will be
                 repeated after a reparametrization. Note that if you
                 have very small forces (for example by running the
                 active learning at a very low temperature or starting
                 from a geometry-optimized structure), then you should
                 decrease the MinR2 since it is difficult for the ML
                 model predict very small forces accurately.

   class _Constraints

      The Constraints block allows geometry optimizations and
      potential energy surface scans with constraints. The constraints
      do not have to be satisfied at the start of the calculation.

      Variables:
         * **All** (*str** | **StringKey*) --

           Fix multiple distances using one the following formats:
           All [bondOrder] bonds at1 at2 [to distance] All triangles
           at1 at2 at3

           The first option constrains all bonds between atoms at1 at2
           to a certain length, while the second - bonds at1-at2 and
           at2-at3 as well as the angle between them.

           The [bondOrder] can be a number or a string such as single,
           double, triple or aromatic. If it's omitted then any bond
           between specified atoms will be constrained. Atom names are
           case-sensitive and they must be as they are in the Atoms
           block, or an asterisk '*' denoting any atom. If the
           distance is omitted then the bond length from the initial
           geometry is used.

           Important: only the bonds present in the system at the
           start of the simulation can be constrained, which means
           that the bonds may need to be specified in the System
           block.

           Valid examples: All single bonds C C to 1.4 All bonds O H
           to 0.98 All bonds O H All bonds H * All triangles H * H

         * **Angle** (*str** | **StringKey*) -- Fix the angle between
           three atoms. Three atom indices followed by an angle in
           degrees.

         * **Atom** (*int** | **IntKey*) -- Fix the position of an
           atom. Just one integer referring to the index of the atom
           in the [System%Atoms] block.

         * **AtomList** (*Iterable**[**int**] **| **IntListKey*) --
           Fix positions of the specified atoms. A list of integers
           referring to indices of atoms in the [System%Atoms] block.

         * **Block** (*str** | **StringKey*) -- Name of the region to
           constrain as a rigid block. Regions are specified in the
           System%Atoms block.

         * **BlockAtoms** (*Iterable**[**int**] **| **IntListKey*) --
           List of atom indices for a block constraint, where the
           internal degrees of freedom are frozen.

         * **Coordinate** (*str** | **StringKey*) -- Fix a particular
           coordinate of an atom. Atom index followed by (x|y|z).

         * **DifDist** (*str** | **StringKey*) -- Four atom indices i
           j k l followed by the distance in Angstrom. This will
           constrain the difference R(ij)-R(kl) at the given value.

         * **Dihedral** (*str** | **StringKey*) -- Fix the dihedral
           angle between four atoms. Four atom indices followed by an
           angle in degrees.

         * **Distance** (*str** | **StringKey*) -- Fix the distance
           between two atoms. Two atom indices followed by the
           distance in Angstrom.

         * **EqualStrain** (*str** | **StringKey*) --

           Exclusively for lattice optimizations:

           Accepts a set of strain components [xx, xy, xz, yy, yz, zz]
           which are to be kept equal.

           The applied strain will be determined by the average of the
           corresponding stress tensors components.

           In AMSinput just check the corresponding check buttons.

         * **FixedRegion** (*str** | **StringKey*) -- Fix positions of
           all atoms in a region.

         * **FreezeStrain** (*str** | **StringKey*) --

           Exclusively for lattice optimizations:

           Freezes any lattice deformation corresponding to a
           particular component of the strain tensor.

           Accepts a set of strain components [xx, xy, xz, yy, yz, zz]
           to be frozen.

           In AMSinput just check the corresponding check buttons.

         * **SumDist** (*str** | **StringKey*) -- Four atom indices i
           j k l followed by the distance in Angstrom. This will
           constrain the sum R(ij)+R(kl) at the given value.

   class _Engine

      The reference engine settings.

   class _LoadSystem

      Block that controls reading the chemical system from a KF file
      instead of the [System] block.

      Variables:
         * **File** (*str** | **Path** | **StringKey*) -- The path of
           the KF file from which to load the system. It may also be
           the results directory containing it.

         * **Section** (*str** | **StringKey*) -- The section on the
           KF file from which to load the system.

   class _MachineLearning

      Options for Task MachineLearning.

      Variables:
         * **Backend** (*Literal**[**"Custom"**, **"M3GNet"**,
           **"MACE"**, **"NequIP"**, **"Test"**]*) -- The backend to
           use. You must separately install the backend before running
           a training job.

         * **CommitteeSize** (*int** | **IntKey*) -- The number of
           independently trained ML potentials.

         * **LoadModel** (*str** | **Path** | **StringKey*) -- Load a
           previously fitted model from a ParAMS results directory. A
           ParAMS results directory should contain two subdirectories
           "optimization" and "settings_and_initial_data". This option
           ignores all settings inside model blocks.

         * **MaxEpochs** (*int** | **IntKey*) -- Set the maximum
           number of epochs a backend should perform.

         * **RunAMSAtEnd** (*BoolType** | **BoolKey*) -- Whether to
           run the (committee) ML potential through AMS at the end.
           This will create the energy/forces scatter plots for the
           final trained model.

         * **Custom**
           (*SimpleActiveLearning._MachineLearning._Custom*) -- Set up
           a custom fitting program within ParAMS

         * **LossCoeffs**
           (*SimpleActiveLearning._MachineLearning._LossCoeffs*) --
           Modify the coefficients for the machine learning loss
           function. For backends that support weights, this is on top
           of the supplied dataset weights and sigmas.

         * **M3GNet**
           (*SimpleActiveLearning._MachineLearning._M3GNet*) --
           Options for M3GNet fitting.

         * **MACE** (*SimpleActiveLearning._MachineLearning._MACE*) --
           Options for MACE fitting.

         * **NequIP**
           (*SimpleActiveLearning._MachineLearning._NequIP*) --
           Options for NequIP fitting.

         * **Target**
           (*SimpleActiveLearning._MachineLearning._Target*) -- Target
           values for stopping training. If both the training and
           validation metrics are smaller than the specified values,
           the training will stop early. Only supported by the M3GNet
           backend.

      class _Custom

         Set up a custom fitting program within ParAMS

         Variables:
            * **File** (*str** | **Path** | **StringKey*) -- Python
              file containing a function called 'get_fit_job' that
              returns a subclass of 'FitJob'

            * **Arguments** (*str** | **Sequence**[**str**] **|
              **FreeBlock*) -- Pass on keyword arguments to the
              'get_fit_job' function.

         class _Arguments

            Pass on keyword arguments to the 'get_fit_job' function.

      class _LossCoeffs

         Modify the coefficients for the machine learning loss
         function. For backends that support weights, this is on top
         of the supplied dataset weights and sigmas.

         Variables:
            * **AverageForcePerAtom** (*BoolType** | **BoolKey*) --
              For each force data entry, divide the loss contribution
              by the number of concomitant atoms. This is the same as
              the behavior for ParAMS Optimization, but it is turned
              off by default in Task MachineLearning. For machine
              learning, setting this to 'No' can be better since
              larger molecules will contribute more to the loss. For
              backends that support weights, this is on top of the
              supplied dataset weights and sigmas.

            * **Energy** (*float** | **FloatKey*) -- Coefficient for
              the contribution of loss due to the energy. For backends
              that support weights, this is on top of the supplied
              dataset weights and sigmas.

            * **Forces** (*float** | **FloatKey*) -- Coefficient for
              the contribution of loss due to the forces. For backends
              that support weights, this is on top of the supplied
              dataset weights and sigmas.

      class _M3GNet

         Options for M3GNet fitting.

         Variables:
            * **LearningRate** (*float** | **FloatKey*) -- Learning
              rate for the M3GNet weight optimization.

            * **Model** (*Literal**[**"UniversalPotential"**,
              **"Custom"**, **"ModelDir"**]*) -- How to specify the
              model for the M3GNet backend. Either a Custom model can
              be made from scratch or an existing model directory can
              be loaded to obtain the model settings.

            * **ModelDir** (*str** | **Path** | **StringKey*) -- Path
              to the directory defining the model. This folder should
              contain the files: 'checkpoint',
              'm3gnet.data-00000-of-00001', ' m3gnet.index' and
              'm3gnet.json'

            * **Custom** (*SimpleActiveLearning._MachineLearning._M3G
              Net._Custom*) -- Specify a custom M3GNet model.

            * **UniversalPotential** (*SimpleActiveLearning._MachineL
              earning._M3GNet._UniversalPotential*) -- Settings for
              (transfer) learning with the M3GNet Universal Potential.

         class _Custom

            Specify a custom M3GNet model.

            Variables:
               * **Cutoff** (*float** | **FloatKey*) -- Cutoff radius
                 of the graph

               * **MaxL** (*int** | **IntKey*) -- Include spherical
                 components up to order MaxL. Higher gives a better
                 angular resolution, but increases computational cost
                 substantially.

               * **MaxN** (*int** | **IntKey*) -- Include radial
                 components up to the MaxN'th root of the spherical
                 Bessel function. Higher gives a better radial
                 resolution, but increases computational cost
                 substantially.

               * **NumBlocks** (*int** | **IntKey*) -- Number of
                 convolution blocks.

               * **NumNeurons** (*int** | **IntKey*) -- Number of
                 neurons in each layer.

               * **ThreebodyCutoff** (*float** | **FloatKey*) --
                 Cutoff radius of the three-body interaction.

         class _UniversalPotential

            Settings for (transfer) learning with the M3GNet Universal
            Potential.

            Variables:
               * **Featurizer** (*BoolType** | **BoolKey*) -- Train
                 the Featurizer layer of the M3GNet universal
                 potential.

               * **Final** (*BoolType** | **BoolKey*) -- Train the
                 Final layer of the M3GNet universal potential.

               * **GraphLayer1** (*BoolType** | **BoolKey*) -- Train
                 the first Graph layer of the M3GNet universal
                 potential.

               * **GraphLayer2** (*BoolType** | **BoolKey*) -- Train
                 the second Graph layer of the M3GNet universal
                 potential.

               * **GraphLayer3** (*BoolType** | **BoolKey*) -- Train
                 the third Graph layer of the M3GNet universal
                 potential.

               * **ThreeDInteractions1** (*BoolType** | **BoolKey*) --
                 Train the first ThreeDInteractions (three-body terms)
                 layer of the M3GNet universal potential.

               * **ThreeDInteractions2** (*BoolType** | **BoolKey*) --
                 Train the second ThreeDInteractions (three-body
                 terms) layer of the M3GNet universal potential.

               * **ThreeDInteractions3** (*BoolType** | **BoolKey*) --
                 Train the third ThreeDInteractions (three-body terms)
                 layer of the M3GNet universal potential.

               * **Version** (*Literal**[**"2022"**]*) -- Which
                 version of the M3GNet Universal Potential to use.

      class _MACE

         Options for MACE fitting.

         Variables:
            * **LearningRate** (*float** | **FloatKey*) -- Learning
              rate for the MACE weight optimization

            * **Model** (*Literal**[**"Foundation"**, **"Custom"**,
              **"ModelFile"**]*) -- How to specify the model for the
              MACE backend. A foundation model can be used, a custom
              model can be made from scratch or an existing model file
              can be loaded to obtain the model settings.

            * **ModelFile** (*str** | **Path** | **StringKey*) -- Path
              to the .model file defining the model.

            * **Custom**
              (*SimpleActiveLearning._MachineLearning._MACE._Custom*)
              -- Specify a custom MACE model.

            * **Foundation** (*SimpleActiveLearning._MachineLearning.
              _MACE._Foundation*) -- Settings for (transfer) learning
              with the MACE foundation model.

            * **LossCoeffs** (*SimpleActiveLearning._MachineLearning.
              _MACE._LossCoeffs*) -- Modify the coefficients for the
              machine learning loss function, by applying scale
              factors to the MachineLearning%LossCoeffs values.

            * **StageTwo** (*SimpleActiveLearning._MachineLearning._M
              ACE._StageTwo*) -- Settings for stage two of training.

         class _Custom

            Specify a custom MACE model.

            Variables:
               * **DataType** (*Literal**[**"float32"**,
                 **"float64"**]*) -- Using "float32" is faster but
                 less accurate, and generally recommended for MD.
                 Conversely using "float64" is slower but more
                 accurate, and recommended for geometry optimization.

               * **LMax** (*int** | **IntKey*) -- Maximum spherical
                 harmonic order of the messages in the message passing
                 step; 0 is invariant, 1 and 2 are higher order
                 (equivariant). Defaults to "1". A higher value
                 increases accuracy, but increases model size and
                 computational cost.

               * **NumChannels** (*int** | **IntKey*) -- Number of
                 channels per angular momentum order. Defaults to
                 "128". Set to "64" for a smaller model or "256" for a
                 larger model. A higher value increases accuracy, but
                 increases model size and computational cost.

               * **RMax** (*float** | **FloatKey*) -- Distance cutoff
                 for interactions.

         class _Foundation

            Settings for (transfer) learning with the MACE foundation
            model.

            Variables:
               **Type** (*Literal**[**"MACE-MPA-0"**, **"MACE-
               MP-0-Large"**, **"MACE-MP-0-Medium"**, **"MACE-
               MP-0-Small"**]*) -- Which MACE foundation model to use.

         class _LossCoeffs

            Modify the coefficients for the machine learning loss
            function, by applying scale factors to the
            MachineLearning%LossCoeffs values.

            Variables:
               * **EnergyScaleFactor** (*float** | **FloatKey*) --
                 Scale factor to apply to the energy loss coefficient,
                 i.e. EnergyScaleFactor *
                 MachineLearning%LossCoeffs%Energy.

               * **ForcesScaleFactor** (*float** | **FloatKey*) --
                 Scale factor to apply to the forces loss coefficient
                 i.e. ForcesScaleFactor *
                 MachineLearning%LossCoeffs%Forces.

         class _StageTwo

            Settings for stage two of training.

            Variables:
               * **Enabled** (*BoolType** | **BoolKey*) -- Whether to
                 enable stage two training, defaults to "True".

               * **LearningRate** (*float** | **FloatKey*) -- Learning
                 rate for the MACE weight optimization for stage two
                 training

               * **Start** (*float** | **FloatKey*) -- When to start
                 stage two training, as a proportion of the
                 MachineLearning%MaxEpochs

               * **LossCoeffs** (*SimpleActiveLearning._MachineLearni
                 ng._MACE._StageTwo._LossCoeffs*) -- Modify the
                 coefficients for the machine learning loss function
                 for stage two training, by applying scale factors to
                 the MachineLearning%LossCoeffs values.

            class _LossCoeffs

               Modify the coefficients for the machine learning loss
               function for stage two training, by applying scale
               factors to the MachineLearning%LossCoeffs values.

               Variables:
                  * **EnergyScaleFactor** (*float** | **FloatKey*) --
                    Scale factor to apply to the energy loss
                    coefficient for stage two training, i.e.
                    EnergyScaleFactor *
                    MachineLearning%LossCoeffs%Energy.

                  * **ForcesScaleFactor** (*float** | **FloatKey*) --
                    Scale factor to apply to the forces loss
                    coefficient for stage two training i.e.
                    ForcesScaleFactor *
                    MachineLearning%LossCoeffs%Forces.

      class _NequIP

         Options for NequIP fitting.

         Variables:
            * **LearningRate** (*float** | **FloatKey*) -- Learning
              rate for the NequIP weight optimization

            * **Model** (*Literal**[**"Custom"**, **"ModelFile"**]*)
              -- How to specify the model for the NequIP backend.
              Either a Custom model can be made from scratch or an
              existing 'model.pth' file can be loaded to obtain the
              model settings.

            * **ModelFile** (*str** | **Path** | **StringKey*) -- Path
              to the model.pth file defining the model.

            * **UseRescalingFromLoadedModel** (*BoolType** |
              **BoolKey*) -- When loading a model with LoadModel or
              NequiP%ModelFile do not recalculate the dataset
              rescaling but use the value from the loaded model.

            * **Custom** (*SimpleActiveLearning._MachineLearning._Neq
              uIP._Custom*) -- Specify a custom NequIP model.

         class _Custom

            Specify a custom NequIP model.

            Variables:
               * **LMax** (*int** | **IntKey*) -- Maximum L value. 1
                 is probably high enough.

               * **MetricsKey** (*Literal**[**"training_loss"**,
                 **"validation_loss"**]*) -- Which metric to use to
                 generate the 'best' model.

               * **NumLayers** (*int** | **IntKey*) -- Number of
                 interaction layers in the NequIP neural network.

               * **RMax** (*float** | **FloatKey*) -- Distance cutoff
                 for interactions.

      class _Target

         Target values for stopping training. If both the training and
         validation metrics are smaller than the specified values, the
         training will stop early. Only supported by the M3GNet
         backend.

         Variables:
            **Forces**
            (*SimpleActiveLearning._MachineLearning._Target._Forces*)
            -- Forces (as reported by the backend)

         class _Forces

            Forces (as reported by the backend)

            Variables:
               * **Enabled** (*BoolType** | **BoolKey*) -- Whether to
                 use target values for forces.

               * **MAE** (*float** | **FloatKey*) -- MAE for forces
                 (as reported by the backend).

   class _MolecularDynamics

      Settings for Molecular Dynamics

      Variables:
         * **CalcPressure** (*BoolType** | **BoolKey*) --

           Calculate the pressure in periodic systems.

           This may be computationally expensive for some engines that
           require numerical differentiation.

           Some other engines can calculate the pressure for
           negligible additional cost and will always do so, even if
           this option is disabled.

         * **CopyRestartTrajectory** (*BoolType** | **BoolKey*) -- If
           the keyword Restart is present, the content of the
           restartfile is copied to the ams.rkf file.

         * **NSteps** (*int** | **IntKey*) -- The number of steps to
           be taken in the MD simulation.

         * **Restart** (*str** | **Path** | **StringKey*) -- The path
           to the ams.rkf file from which to restart the simulation.

         * **TimeStep** (*float** | **FloatKey*) -- The time
           difference per step.

         * **AddMolecules**
           (*SimpleActiveLearning._MolecularDynamics._AddMolecules*)
           --

           This block controls adding molecules to the system (a.k.a.
           the Molecule Gun). Multiple occurrences of this block are
           possible.

           By default, molecules are added at random positions in the
           simulation box with velocity matching the current system
           temperature. The initial position can be modified using one
           of the following keywords: Coords, CoordsBox,
           FractionalCoords, FractionalCoordsBox. The Coords and
           FractionalCoords keys can optionally be accompanied by
           CoordsSigma or FractionalCoordsSigma, respectively.

         * **ApplyForce**
           (*SimpleActiveLearning._MolecularDynamics._ApplyForce*) --
           The ApplyForce keyword can be used to apply an arbitrary
           constant force to a certain (subgroups of) atoms in the
           system

         * **ApplyVelocity**
           (*SimpleActiveLearning._MolecularDynamics._ApplyVelocity*)
           -- The ApplyVelocity keyword can be used to move an
           arbitrary group of atoms in the system with a constant net
           velocity

         * **Barostat**
           (*SimpleActiveLearning._MolecularDynamics._Barostat*) --
           This block allows to specify the use of a barostat during
           the simulation.

         * **BinLog**
           (*SimpleActiveLearning._MolecularDynamics._BinLog*) -- This
           block controls writing the BinLog section in ams.rkf, which
           contains the selected MD state scalars and tensors from
           every MD step. No per-atom data is written. If you need the
           per-atom data then you can set the sampling frequency to 1
           and get the required data from the MDHistory section. The
           tensors are written per component, that is, the pressure
           tensor is written as six variables: PressureTensor_xx,
           PressureTensor_yy, etc.. To reduce the file size, all data
           is written in blocks.

         * **BondBoost**
           (*SimpleActiveLearning._MolecularDynamics._BondBoost*) --
           Forced reaction (bond boost) definitions. Multiple
           BondBoost blocks may be specified, which will be treated
           independently.

         * **CRESTMTD**
           (*SimpleActiveLearning._MolecularDynamics._CRESTMTD*) --
           Input for CREST metadynamics simulation.

         * **CVHD** (*SimpleActiveLearning._MolecularDynamics._CVHD*)
           -- Input for the Collective Variable-driven HyperDynamics
           (CVHD).

         * **CheckTemperature** (*SimpleActiveLearning._MolecularDyna
           mics._CheckTemperature*) -- Check at every time step if the
           temperature has exceeded a threshold. If it has, it is
           assumed the system exploded, and the simulation will stop.

         * **Checkpoint**
           (*SimpleActiveLearning._MolecularDynamics._Checkpoint*) --
           Sets the frequency for storing the entire MD state
           necessary for restarting the calculation.

         * **CosineShear**
           (*SimpleActiveLearning._MolecularDynamics._CosineShear*) --
           Apply an external acceleration to all atoms of a fluid
           using a periodic (cosine) function along a selected
           coordinate axis. This induces a periodic shear flow profile
           which can be used to determine the viscosity.

         * **Deformation**
           (*SimpleActiveLearning._MolecularDynamics._Deformation*) --
           Deform the periodic lattice of the system during the
           simulation.

         * **Gravity**
           (*SimpleActiveLearning._MolecularDynamics._Gravity*) --
           Apply a constant acceleration in -z.

         * **HeatExchange**
           (*SimpleActiveLearning._MolecularDynamics._HeatExchange*)
           -- Input for the heat-exchange non-equilibrium MD (T-NEMD).

         * **InitialVelocities** (*SimpleActiveLearning._MolecularDyn
           amics._InitialVelocities*) -- Sets the frequency for
           printing to stdout and storing the molecular configuration
           on the .rkf file.

         * **MovingRestraints** (*SimpleActiveLearning._MolecularDyna
           mics._MovingRestraints*) -- Define a set of moving
           restraints.

         * **PRD** (*SimpleActiveLearning._MolecularDynamics._PRD*) --
           This block is used for Parallel Replica Dynamics
           simulations.

         * **Plumed**
           (*SimpleActiveLearning._MolecularDynamics._Plumed*) --
           Input for PLUMED (version 2.5.0). The parallel option is
           still experimental.

         * **Preserve**
           (*SimpleActiveLearning._MolecularDynamics._Preserve*) --
           Periodically remove numerical drift accumulated during the
           simulation to preserve different whole-system parameters.

         * **Print**
           (*SimpleActiveLearning._MolecularDynamics._Print*) -- This
           block controls the printing of additional information to
           stdout.

         * **ReactionBoost**
           (*SimpleActiveLearning._MolecularDynamics._ReactionBoost*)
           --

           Define a series of transitions between different states of
           the system.

           Each transition is defined by a TargetSystem and by a set
           of restraints that force the transition.

         * **Reactor**
           (*SimpleActiveLearning._MolecularDynamics._Reactor*) --
           Define one phase of the nanoreactor. A reactor is a region
           of space surrounded by an elastic wall. Atoms inside the
           region are not affected. Atoms outside it will be pushed
           back with force depending on the [ForceConstant] and the
           [MassScaled] flag.

         * **ReflectiveWall**
           (*SimpleActiveLearning._MolecularDynamics._ReflectiveWall*)
           -- Apply a reflective wall in space

         * **Remap**
           (*SimpleActiveLearning._MolecularDynamics._Remap*) --
           Control periodic remapping (backtranslation) of atoms into
           the PBC box.

         * **RemoveMolecules** (*SimpleActiveLearning._MolecularDynam
           ics._RemoveMolecules*) -- This block controls removal of
           molecules from the system. Multiple occurrences of this
           block are possible.

         * **ReplicaExchange** (*SimpleActiveLearning._MolecularDynam
           ics._ReplicaExchange*) -- This block is used for
           (temperature) Replica Exchange MD (Parallel Tempering)
           simulations.

         * **Shake**
           (*SimpleActiveLearning._MolecularDynamics._Shake*) --
           Parameters of the Shake/Rattle algorithm.

         * **Thermostat**
           (*SimpleActiveLearning._MolecularDynamics._Thermostat*) --
           This block allows to specify the use of a thermostat during
           the simulation. Depending on the selected thermostat type,
           different additional options may be needed to characterize
           the specific thermostat's behavior.

         * **Trajectory**
           (*SimpleActiveLearning._MolecularDynamics._Trajectory*) --
           Sets the frequency for printing to stdout and storing the
           molecular configuration on the .rkf file.

         * **fbMC** (*SimpleActiveLearning._MolecularDynamics._fbMC*)
           -- This block sets up force bias Monte Carlo interleaved
           with the molecular dynamics simulation.

      class _AddMolecules

         This block controls adding molecules to the system (a.k.a.
         the Molecule Gun). Multiple occurrences of this block are
         possible.

         By default, molecules are added at random positions in the
         simulation box with velocity matching the current system
         temperature. The initial position can be modified using one
         of the following keywords: Coords, CoordsBox,
         FractionalCoords, FractionalCoordsBox. The Coords and
         FractionalCoords keys can optionally be accompanied by
         CoordsSigma or FractionalCoordsSigma, respectively.

         Variables:
            * **AtomTemperature** (*float** | **FloatKey*) -- Add
              random velocity corresponding to the specified
              temperature to individual atoms of the molecule. This
              only affects rotational and internal degrees of freedom,
              not the net translational velocity of the inserted
              molecule as set by the other options.

            * **ContactDistance** (*float** | **FloatKey*) --
              Translate the bullet along the velocity vector until it
              comes within ContactDistance of any other atom.

            * **Coords** (*Iterable**[**float**] **| **FloatListKey*)
              --

              Place molecules at or around the specified Cartesian
              coordinates.

              This setting takes precedence over other ways to specify
              initial coordinates of the molecule: [CoordsBox],
              [FractionalCoords], and [FractionalCoordsBox].

            * **CoordsBox** (*Iterable**[**float**] **|
              **FloatListKey*) --

              Place molecules at random locations inside the specified
              box in Cartesian coordinates.

              Coordinates of the box corners are specified as: Xmin,
              Xmax, Ymin, Ymax, Zmin, Zmax. This setting is ignored if
              Coords is used.

              In AMSinput, if this field is not empty it will be used
              instead of the default Coords.

            * **CoordsSigma** (*Iterable**[**float**] **|
              **FloatListKey*) -- Sigma values (one per Cartesian
              axis) for a Gauss distribution of the initial
              coordinates. Can only be used together with Coords.

            * **DeviationAngle** (*float** | **FloatKey*) -- Randomly
              tilt the shooting direction up to this angle away from
              the VelocityDirection vector.

            * **Energy** (*float** | **FloatKey*) -- Initial kinetic
              energy of the molecule in the shooting direction.

            * **EnergySigma** (*float** | **FloatKey*) -- Sigma value
              for the Gauss distribution of the initial kinetic energy
              around the specified value. Should only be used together
              with Energy.

            * **FractionalCoords** (*Iterable**[**float**] **|
              **FloatListKey*) -- Place molecules at or around the
              specified fractional coordinates in the main system's
              lattice. For non-periodic dimensions a Cartesian value
              in Angstrom is expected. This setting is ignored if
              [Coords] or [CoordsBox] is used.

            * **FractionalCoordsBox** (*Iterable**[**float**] **|
              **FloatListKey*) --

              Place molecules at random locations inside the box
              specified as fractional coordinates in the main system's
              lattice.

              Coordinates of the box corners are specified as: Xmin,
              Xmax, Ymin, Ymax, Zmin, Zmax.

              For non-periodic dimensions the Cartesian value in
              Angstrom is expected.

              This setting is ignored if [Coords], [CoordsBox], or
              [FractionalCoords] is used.

            * **FractionalCoordsSigma** (*Iterable**[**float**] **|
              **FloatListKey*) -- Sigma values (one per axis) for a
              Gauss distribution of the initial coordinates. For non-
              periodic dimensions the Cartesian value in Angstrom is
              expected. Can only be used together with
              FractionalCoords.

            * **Frequency** (*int** | **IntKey*) --

              A molecule is added every [Frequency] steps after the
              StartStep.

              There is never a molecule added at step 0.

            * **MinDistance** (*float** | **FloatKey*) -- Keep the
              minimal distance to other atoms of the system when
              adding the molecule.

            * **MoleFraction** (*float** | **FloatKey*) --

              Defines a mixture to be deposited using one AddMolecules
              block per component.

              AMS will randomly alternate between any guns that have
              MoleFraction set. These need to all have the same
              settings for StartStep, StopStep and Frequency. Any
              additional AddMolecules blocks without MoleFraction will
              remain completely independent.

            * **NumAttempts** (*int** | **IntKey*) -- Try adding the
              molecule up to the specified number of times or until
              the MinDistance constraint is satisfied. If all attempts
              fail a message will be printed and the simulation will
              continue normally.

            * **Rotate** (*BoolType** | **BoolKey*) -- Rotate the
              molecule randomly before adding it to the system.

            * **StartStep** (*int** | **IntKey*) --

              Step number when the first molecule should be added.
              After that, molecules are added every Frequency steps.

              For example, ff StartStep=99 and Frequency=100 then a
              molecule will be added at steps 99, 199, 299, etc...

              No molecule will be added at step 0, so if StartStep=0
              the first molecule is added at the step number equal to
              [Frequency].

            * **StopStep** (*int** | **IntKey*) -- Do not add this
              molecule after the specified step.

            * **System** (*str** | **StringKey*) --

              String ID of the [System] that will be added with this
              'gun'.

              The lattice specified with this System is ignored and
              the main system's lattice is used instead.

              AMSinput adds the system at the coordinates of the
              System (thus setting Coords to the center of the
              System).

            * **Temperature** (*float** | **FloatKey*) -- Initial
              energy of the molecule in the shooting direction will
              correspond to the given temperature.

            * **TemperatureSigma** (*float** | **FloatKey*) -- Sigma
              value for the Gauss distribution of the initial
              temperature the specified value. Should only be used
              together with Temperature.

            * **Velocity** (*float** | **FloatKey*) -- Initial
              velocity of the molecule in the shooting direction.

            * **VelocityDirection** (*Iterable**[**float**] **|
              **FloatListKey*) --

              Velocity direction vector for aimed shooting. It will be
              random if not specified.

              In AMSinput add one or two atoms (which may be dummies).

              One atom: use vector from center of the system to add to
              that atom.

              Two atoms: use vector from the first to the second atom.

            * **VelocitySigma** (*float** | **FloatKey*) -- Sigma
              value for the Gauss distribution of the initial velocity
              around the specified value. Should only be used together
              with Velocity.

      class _ApplyForce

         The ApplyForce keyword can be used to apply an arbitrary
         constant force to a certain (subgroups of) atoms in the
         system

         Variables:
            * **CalculateViscosity** (*BoolType** | **BoolKey*) --
              Calculates Viscosity property yes/no. If yes is chosen,
              the global viscosity of the system is calculated and
              written into the RKF-file. The formula used for the
              viscosity calculation is eta = - Pxz / (dVx/dz)

            * **CalculateViscosityBins** (*int** | **IntKey*) --
              Amount of bins used to determine (dVx/dz)

            * **CalculateViscosityEnd** (*int** | **IntKey*) -- end
              index to select region in space to calculate (dVx/dz)

            * **CalculateViscosityStart** (*int** | **IntKey*) --
              Start index to select region in space to calculate
              (dVx/dz)

            * **Force** (*Iterable**[**float**] **| **FloatListKey*)
              -- Defines the constant force vector

            * **PerAtom** (*BoolType** | **BoolKey*) -- If enabled,
              the Force vector is applied separately to every atom in
              the selected Region, so that the total net force on the
              Region equals the value of Force times the number of
              atoms in Region. This was the behavior of ApplyForce in
              AMS2022. By default, with PerAtom disabled, the Force
              vector defines the total net force on the Region, so the
              force applied to each atom equals the value of Force
              divided by the number of atoms in Region.

            * **Region** (*str** | **StringKey*) -- Apply the constant
              force to all atoms in this region.

      class _ApplyVelocity

         The ApplyVelocity keyword can be used to move an arbitrary
         group of atoms in the system with a constant net velocity

         Variables:
            * **CalculateViscosity** (*BoolType** | **BoolKey*) --
              Calculates Viscosity property yes/no. If yes is chosen,
              the global viscosity of the system is calculated and
              written into the RKF-file. The formula used for the
              viscosity calculation is eta = - Pxz / (dVx/dz)

            * **CalculateViscosityBins** (*int** | **IntKey*) --
              Amount of bins used to determine (dVx/dz)

            * **CalculateViscosityEnd** (*int** | **IntKey*) -- end
              index to select region in space to calculate (dVx/dz)

            * **CalculateViscosityStart** (*int** | **IntKey*) --
              Start index to select region in space to calculate
              (dVx/dz)

            * **Components** (*Literal**[**"X"**, **"Y"**, **"Z"**,
              **"XY"**, **"YZ"**, **"XZ"**, **"XYZ"**]*) -- Select
              which components of the Velocity vector are used to set
              the corresponding components of the net velocity of the
              specified set of atoms. Any other components of Velocity
              are ignored and the motion of the selected atoms in
              those directions is unaffected by ApplyVelocity.

            * **Region** (*str** | **StringKey*) -- Applies the
              defined velocity to all atoms in this region.

            * **Velocity** (*Iterable**[**float**] **|
              **FloatListKey*) -- The constant velocity that will be
              applied to the specified atoms.

      class _Barostat

         This block allows to specify the use of a barostat during the
         simulation.

         Variables:
            * **BulkModulus** (*float** | **FloatKey*) --

              An estimate of the bulk modulus (inverse
              compressibility) of the system for the Berendsen
              barostat.

              This is only used to make Tau correspond to the true
              observed relaxation time constant. Values are commonly
              on the order of 10-100 GPa (1e10 to 1e11) for solids and
              1 GPa (1e9) for liquids (2.2e9 for water). Use 1e9 to
              match the behavior of standalone ReaxFF.

            * **ConstantVolume** (*BoolType** | **BoolKey*) --

              Keep the volume constant while allowing the box shape to
              change.

              This is currently supported only by the MTK barostat.

            * **Duration** (*Iterable**[**int**] **| **IntListKey*) --
              Specifies how many steps should a transition from a
              particular pressure to the next one in sequence take.

            * **Equal** (*Literal**[**"None"**, **"XYZ"**, **"XY"**,
              **"YZ"**, **"XZ"**]*) -- Enforce equal scaling of the
              selected set of dimensions. They will be barostatted as
              one dimension according to the average pressure over the
              components.

            * **Pressure** (*Iterable**[**float**] **|
              **FloatListKey*) --

              Specifies the target pressure.

              You can specify multiple pressures (separated by
              spaces). In that case the Duration field specifies how
              many steps to use for the transition from one p to the
              next p (using a linear ramp).

            * **Scale** (*Literal**[**"XYZ"**, **"Shape"**, **"X"**,
              **"Y"**, **"Z"**, **"XY"**, **"YZ"**, **"XZ"**]*) --
              Dimensions that should be scaled by the barostat to
              maintain pressure. Selecting Shape means that all three
              dimensions and also all the cell angles are allowed to
              change.

            * **Tau** (*float** | **FloatKey*) -- Specifies the time
              constant of the barostat.

            * **Type** (*Literal**[**"None"**, **"Berendsen"**,
              **"MTK"**]*) -- Selects the type of the barostat.

      class _BinLog

         This block controls writing the BinLog section in ams.rkf,
         which contains the selected MD state scalars and tensors from
         every MD step. No per-atom data is written. If you need the
         per-atom data then you can set the sampling frequency to 1
         and get the required data from the MDHistory section. The
         tensors are written per component, that is, the pressure
         tensor is written as six variables: PressureTensor_xx,
         PressureTensor_yy, etc.. To reduce the file size, all data is
         written in blocks.

         Variables:
            * **BiasEnergy** (*BoolType** | **BoolKey*) -- Write the
              CVHD bias energy at every time step.

            * **BoostFactor** (*BoolType** | **BoolKey*) -- Write the
              CVHD boost factor at every time step.

            * **ConservedEnergy** (*BoolType** | **BoolKey*) -- Write
              the conserved energy value at every time step.

            * **Density** (*BoolType** | **BoolKey*) -- Write the
              density at every time step.

            * **DipoleMoment** (*BoolType** | **BoolKey*) -- Write the
              dipole moment at every time step. Each component of the
              tensor is written in its own variable.

            * **Hypertime** (*BoolType** | **BoolKey*) -- Write the
              CVHD hypertime at every time step.

            * **KineticEnergy** (*BoolType** | **BoolKey*) -- Write
              the kinetic energy value at every time step.

            * **MaxBiasEnergy** (*BoolType** | **BoolKey*) -- Write
              the max CVHD bias energy at every time step.

            * **MaxBoostFactor** (*BoolType** | **BoolKey*) -- Write
              the max CVHD boost factor at every time step.

            * **PotentialEnergy** (*BoolType** | **BoolKey*) -- Write
              the potential energy value at every time step.

            * **Pressure** (*BoolType** | **BoolKey*) -- Write the
              pressure at every time step.

            * **PressureTensor** (*BoolType** | **BoolKey*) -- Write
              the pressure tensor in Voigt notation at every time
              step. Each component of the tensor is written in its own
              variable.

            * **Step** (*BoolType** | **BoolKey*) -- Write the step
              index during the simulation at every time step.

            * **Temperature** (*BoolType** | **BoolKey*) -- Write the
              temperature at every time step.

            * **Time** (*BoolType** | **BoolKey*) -- Write the
              simulation time (fs) at every time step.

            * **TotalEnergy** (*BoolType** | **BoolKey*) -- Write the
              total energy value at every time step.

            * **Volume** (*BoolType** | **BoolKey*) -- Write the
              simulation cell volume, area or length, depending on the
              system periodicity, at every time step.

      class _BondBoost

         Forced reaction (bond boost) definitions. Multiple BondBoost
         blocks may be specified, which will be treated independently.

         Variables:
            * **AddBond** (*str** | **StringKey*) -- [Reserved] Add a
              bond to the system or change its order. Specify two atom
              indices followed by the bond's order. The indices
              indicate positions of the atoms in the AtomNames key.
              Currently no engine will honor bond changes caused by
              this key.

            * **DistanceRestraint** (*str** | **StringKey*) --

              Specify two atom indices followed by the target distance
              in Angstrom, the first parameter and, optionally, the
              profile type and the second parameter.

              For periodic systems, restraints follow the minimum
              image convention.

              Each atom index indicates a position of the
              corresponding atom in the AtomNames key. Currently
              recognized restraint profile types: Harmonic (default),
              Hyperbolic, Erf, GaussianWell. The profile name can
              optionally be prefixed by "OneSided-", thus making this
              particular restraint one-sided. A one-sided restraint
              will only push or pull the distance towards its target
              value depending on the sign of the difference between
              the initial and the target distance. For example, if the
              initial distance is larger than the target one then the
              restraint will only push the value down. This is
              especially useful with moving restraints because then
              the restraint will effectively disappear as soon as the
              system crosses a barrier along the reaction path. By
              default, the restraints are two-sided, which means they
              will try to keep the distance between the two specified
              atoms near the (possibly moving) target value. For
              moving restraints, this means that after crossing a
              reaction barrier the system will slide slowly towards
              products held back by the restraints.

              The first parameter is the force constant for the
              Harmonic, Hyperbolic, and Erf profiles, or well depth
              for GaussianWell. The second parameter is the asymptotic
              force value F(Inf) for Hyperbolic and Erf profiles, or
              the factor before x^2 in the exponent for GaussianWell.

              Note: the GaussianWell restraint should be used with the
              Moving flag.

            * **Moving** (*BoolType** | **BoolKey*) --

              Move the restraints created with this BondBoost. The
              restraint value will start at the current coordinate's
              value and will move towards the optimum during the
              restraint's lifetime. The increment is calculated from
              the initial deviation and the [NSteps] parameter.

              This feature should be used with the GaussianWell
              restraint types.

            * **NSteps** (*int** | **IntKey*) -- Number of steps the
              restraints will remain active until removed. Atoms
              participating in one reaction are not available for the
              given number of steps.

            * **NumInstances** (*int** | **IntKey*) -- Number of
              reactions of this type taking place simultaneously.

            * **RemoveBond** (*str** | **StringKey*) -- [Reserved]
              Remove a bond from the system. Specify two atom indices.
              The indices indicate positions of the atoms in the
              AtomNames key. Currently no engine will honor bond
              changes caused by this key.

            * **SetAtomName** (*str** | **StringKey*) -- Change the
              specified atom's name. Specify atom index followed by
              the new name. The index indicates position of the atom
              in the AtomNames key. Note: this action will change the
              atom name only and not other properties (element name,
              mass, etc.). This may be useful to change atom names to
              affect future chain detections. The atom name length is
              limited to 32 characters.

            * **Units** (*Literal**[**"Default"**, **"MD"**]*) --
              Change energy, force and force constant units in the
              DistanceRestraint key from the default (atomic units) to
              those often used in the MD community (based on kcal/mol
              and Angstrom). Units for the optimum distances are not
              affected.

            * **Chain** (*SimpleActiveLearning._MolecularDynamics._Bo
              ndBoost._Chain*) -- Specifications of a chain of atoms.
              When a chain is detected the distance restraints will be
              activated. No other chain of this type will be detected
              while any restraints for this chain is active.

         class _Chain

            Specifications of a chain of atoms. When a chain is
            detected the distance restraints will be activated. No
            other chain of this type will be detected while any
            restraints for this chain is active.

            Variables:
               * **AtomNames** (*str** | **StringKey*) -- Atom names
                 specifying the chain. An atom name can optionally be
                 followed by '@' and a region name, in this case only
                 atoms of this type from the given region will be
                 matched. A leading '@' followed by a number indicates
                 that this position in the chain must be occupied by
                 the atom found earlier at the specified position in
                 the chain. For example "O H N C @1" indicates that
                 the last atom in the chain of the five atoms must be
                 the first oxygen, thus defining a 4-membered ring.
                 This is the only way to define a ring because
                 implicit rings will not be detected. For example, "O
                 H N C O" does not include rings.

               * **MaxDistances** (*Iterable**[**float**] **|
                 **FloatListKey*) -- Maximum distances for each pair
                 of atoms in the chain. The number of distances must
                 be one less than the number of AtomNames.

               * **MinDistances** (*Iterable**[**float**] **|
                 **FloatListKey*) -- Minimum distances for each pair
                 of atoms in the chain. The number of distances must
                 be one less than the number of AtomNames.

      class _CRESTMTD

         Input for CREST metadynamics simulation.

         Variables:
            * **AddEnergy** (*BoolType** | **BoolKey*) -- Add the bias
              energy to the potential energy (to match the gradients)

            * **Height** (*float** | **FloatKey*) -- The height of the
              Gaussians added

            * **NGaussiansMax** (*int** | **IntKey*) -- Maximum number
              of Gaussians stored

            * **NSteps** (*int** | **IntKey*) -- Interval of Gaussian
              placement

            * **Region** (*str** | **StringKey*) -- Restrict the range
              of atoms for RMSD calculation to the specified region.

            * **RestartFile** (*str** | **Path** | **StringKey*) --
              Filename for file from which to read data on Gaussians
              placed previously.

            * **Width** (*float** | **FloatKey*) -- The width of the
              Gaussians added in terms of the RMSD

            * **GaussianScaling** (*SimpleActiveLearning._MolecularDy
              namics._CRESTMTD._GaussianScaling*) -- Options for
              gradual introduction of the Gaussians

         class _GaussianScaling

            Options for gradual introduction of the Gaussians

            Variables:
               * **ScaleGaussians** (*BoolType** | **BoolKey*) --
                 Introduce the Gaussians gradually, using a scaling
                 function

               * **ScalingSlope** (*float** | **FloatKey*) -- Slope of
                 the scaling function for the Gaussians with respect
                 to time

      class _CVHD

         Input for the Collective Variable-driven HyperDynamics
         (CVHD).

         Variables:
            * **Frequency** (*int** | **IntKey*) -- Frequency of
              adding a new bias peak, in steps.  New bias is deposited
              every [Frequency] steps after [StartStep] if the
              following conditions are satisfied:  the current CV
              value is less than 0.9 (to avoid creating barriers at
              the transition state),  the step number is greater than
              or equal to [StartStep], and  the step number is less
              than or equal to [StopStep].

            * **MaxEvents** (*int** | **IntKey*) -- Max number of
              events to allow during dynamics. When this number is
              reached no new bias will be added for this input block.

            * **StartStep** (*int** | **IntKey*) -- If this key is
              specified, the first bias will be deposited at this
              step. Otherwise, the first bias peak is added at the
              step number equal to the Frequency parameter. The bias
              is never deposited at step 0.

            * **StopStep** (*int** | **IntKey*) -- No bias will be
              deposited after the specified step. The already
              deposited bias will continue to be applied until the
              reaction event occurs. After that no new CVHD will be
              started. By default, the CVHD runs for the whole
              duration of the MD calculation.

            * **WaitSteps** (*int** | **IntKey*) -- If the CV value
              becomes equal to 1 and remains at this value for this
              many steps then the reaction event is considered having
              taken place. After this, the collective variable will be
              reset and the bias will be removed.

            * **Bias**
              (*SimpleActiveLearning._MolecularDynamics._CVHD._Bias*)
              -- The bias is built from a series of Gaussian peaks
              deposited on the collective variable axis every
              [Frequency] steps during MD. Each peak is characterized
              by its (possibly damped) height and the RMS width
              (standard deviation).

            * **ColVarBB** (*SimpleActiveLearning._MolecularDynamics.
              _CVHD._ColVarBB*) -- Description of a bond-breaking
              collective variable (CV) as described in [Bal & Neyts,
              JCTC, 11 (2015)]. A collective variable may consist of
              multiple ColVar blocks.

            * **ColVarBM** (*SimpleActiveLearning._MolecularDynamics.
              _CVHD._ColVarBM*) -- Description of a bond-making
              collective variable (CV). A collective variable may
              consist of multiple ColVar blocks.

         class _Bias

            The bias is built from a series of Gaussian peaks
            deposited on the collective variable axis every
            [Frequency] steps during MD. Each peak is characterized by
            its (possibly damped) height and the RMS width (standard
            deviation).

            Variables:
               * **DampingTemp** (*float** | **FloatKey*) -- During
                 well-tempered hyperdynamics the height of the added
                 bias is scaled down with an exp(-E/kT) factor
                 [PhysRevLett 100, 020603 (2008)], where E is the
                 current value of the bias at the given CV value and T
                 is the damping temperature DampingTemp. If
                 DampingTemp is zero then no damping is applied.

               * **Delta** (*float** | **FloatKey*) -- Standard
                 deviation parameter of the Gaussian bias peak.

               * **Height** (*float** | **FloatKey*) -- Height of the
                 Gaussian bias peak.

         class _ColVarBB

            Description of a bond-breaking collective variable (CV) as
            described in [Bal & Neyts, JCTC, 11 (2015)]. A collective
            variable may consist of multiple ColVar blocks.

            Variables:
               * **cutoff** (*float** | **FloatKey*) -- Bond order
                 cutoff. Bonds with BO below this value are ignored
                 when creating the initial bond list for the CV. The
                 bond list does not change during lifetime of the
                 variable even if some bond orders drop below the
                 cutoff.

               * **p** (*int** | **IntKey*) -- Exponent value p used
                 to calculate the p-norm for this CV.

               * **rmax** (*float** | **FloatKey*) -- Max bond
                 distance parameter Rmax used for calculating the CV.
                 It should be close to the transition-state distance
                 for the corresponding bond.

               * **rmin** (*float** | **FloatKey*) -- Min bond
                 distance parameter Rmin used for calculating the CV.
                 It should be close to equilibrium distance for the
                 corresponding bond.

               * **at1** (*SimpleActiveLearning._MolecularDynamics._C
                 VHD._ColVarBB._at1*) -- Specifies the first bonded
                 atom in the collective variable.

               * **at2** (*SimpleActiveLearning._MolecularDynamics._C
                 VHD._ColVarBB._at2*) -- Specifies the second bonded
                 atom in the collective variable.

            class _at1

               Specifies the first bonded atom in the collective
               variable.

               Variables:
                  * **region** (*str** | **StringKey*) -- Restrict the
                    selection of bonded atoms to a specific region. If
                    this is not set, atoms anywhere in the system will
                    be selected.

                  * **symbol** (*str** | **StringKey*) -- Atom type
                    name of the first atom of the bond. The name must
                    be as it appears in the System block. That is, if
                    the atom name contains an extension (e.g C.1) then
                    the full name including the extension must be used
                    here.

            class _at2

               Specifies the second bonded atom in the collective
               variable.

               Variables:
                  * **region** (*str** | **StringKey*) -- Restrict the
                    selection of bonded atoms to a specific region. If
                    this is not set, atoms anywhere in the system will
                    be selected.

                  * **symbol** (*str** | **StringKey*) -- Atom type
                    name of the second atom of the bond. The value is
                    allowed to be the same as [at1], in which case
                    bonds between atoms of the same type will be
                    included.

         class _ColVarBM

            Description of a bond-making collective variable (CV). A
            collective variable may consist of multiple ColVar blocks.

            Variables:
               * **cutoff** (*float** | **FloatKey*) -- Bond order
                 cutoff. Bonds with BO above this value are ignored
                 when creating the initial atom-pair list for the CV.
                 The list does not change during lifetime of the
                 variable even if some bond orders rise above the
                 cutoff.

               * **p** (*int** | **IntKey*) -- Exponent value p used
                 to calculate the p-norm for this CV.

               * **rmax** (*float** | **FloatKey*) -- Max bond
                 distance parameter Rmax used for calculating the CV.
                 It should be much larger than the corresponding Rmin.

               * **rmin** (*float** | **FloatKey*) -- Min bond
                 distance parameter Rmin used for calculating the CV.
                 It should be close to the transition-state distance
                 for the corresponding bond.

               * **at1** (*SimpleActiveLearning._MolecularDynamics._C
                 VHD._ColVarBM._at1*) -- Specifies selection criteria
                 for the first atom of a pair in the collective
                 variable.

               * **at2** (*SimpleActiveLearning._MolecularDynamics._C
                 VHD._ColVarBM._at2*) -- Specifies selection criteria
                 for the second atom of a pair in the collective
                 variable.

            class _at1

               Specifies selection criteria for the first atom of a
               pair in the collective variable.

               Variables:
                  * **region** (*str** | **StringKey*) -- Restrict the
                    selection to a specific region. If this is not
                    set, atoms anywhere in the system will be
                    selected.

                  * **symbol** (*str** | **StringKey*) -- Atom type
                    name of the first atom of the pair. The name must
                    be as it appears in the System block. That is, if
                    the atom name contains an extension (e.g C.1) then
                    the full name including the extension must be used
                    here.

            class _at2

               Specifies selection criteria for the second atom of a
               pair in the collective variable.

               Variables:
                  * **region** (*str** | **StringKey*) -- Restrict the
                    selection to a specific region. If this is not
                    set, atoms anywhere in the system will be
                    selected.

                  * **symbol** (*str** | **StringKey*) -- Atom type
                    name of the second atom of the pair. The value is
                    allowed to be the same as [at1], in which case
                    pairs of atoms of the same type will be included.

      class _CheckTemperature

         Check at every time step if the temperature has exceeded a
         threshold. If it has, it is assumed the system exploded, and
         the simulation will stop.

         Variables:
            * **Enabled** (*BoolType** | **BoolKey*) -- If enabled,
              the simulation will stop if the temperature becomes too
              large.

            * **MaxTemperature** (*float** | **FloatKey*) -- Maximum
              temperature the system can have. If larger, the
              simulation will stop.

      class _Checkpoint

         Sets the frequency for storing the entire MD state necessary
         for restarting the calculation.

         Variables:
            * **Frequency** (*int** | **IntKey*) --

              Write the MD state to the Molecule and MDResults
              sections on ams.rkf once every N steps. Setting this to
              zero disables checkpointing during the simulation, but
              one checkpoint at the very end of the simulation will
              always be written.

              NOTE: This no longer controls the frequency of writing
              MDStep*.rkf files, set Trajectory%EngineResultsFreq
              instead.

            * **WriteProperties** (*BoolType** | **BoolKey*) --

              Honor top-level Properties input block when writing
              engine results files.

              DEPRECATED: This input option will be removed in AMS2026
              and will be considered always enabled. If you rely on it
              being disabled, please contact SCM support.

      class _CosineShear

         Apply an external acceleration to all atoms of a fluid using
         a periodic (cosine) function along a selected coordinate
         axis. This induces a periodic shear flow profile which can be
         used to determine the viscosity.

         Variables:
            * **Acceleration** (*float** | **FloatKey*) -- Amplitude
              of the applied cosine shear acceleration profile. The
              default value should be a rough first guess for water
              and it needs to be adjusted by experimentation for other
              systems.

            * **Enabled** (*BoolType** | **BoolKey*) -- Apply a cosine
              shear acceleration profile for a NEMD calculation of
              viscosity.

            * **FlowDirection** (*Iterable**[**float**] **|
              **FloatListKey*) -- The direction in which to apply the
              shear acceleration, in Cartesian coordinates. The
              magnitude of this vector is ignored (AMS will normalize
              it internally). FlowDirection has to be perpendicular to
              ProfileAxis.

            * **ProfileAxis** (*Literal**[**"X"**, **"Y"**, **"Z"**]*)
              -- The Cartesian coordinate axis along which the cosine
              wave runs

      class _Deformation

         Deform the periodic lattice of the system during the
         simulation.

         Variables:
            * **LengthRate** (*Iterable**[**float**] **|
              **FloatListKey*) -- Relative rate of change of each
              lattice vector per step.

            * **LengthVelocity** (*Iterable**[**float**] **|
              **FloatListKey*) -- Change the length of each lattice
              vector with this velocity. With Type=Exponential,
              LengthVelocity is divided by the current lattice vector
              lengths on StartStep to determine a LengthRate, which is
              then applied on all subsequent steps. For Type Sine and
              Cosine, this defines the maximum velocity (at the
              inflection point).

            * **Period** (*float** | **FloatKey*) -- Period of
              oscillation for Type Sine and Cosine.

            * **ScaleAtoms** (*BoolType** | **BoolKey*) -- Scale the
              atomic positions together with the lattice vectors.
              Disable this to deform only the lattice, keeping the
              coordinates of atoms unchanged.

            * **StartStep** (*int** | **IntKey*) -- First step at
              which the deformation will be applied.

            * **StopStep** (*int** | **IntKey*) -- Last step at which
              the deformation will be applied. If unset or zero,
              nSteps will be used instead.

            * **TargetDensity** (*float** | **FloatKey*) --

              Target density of the system to be achieved by StopStep
              by isotropically rescaling the lattice.

              This can only be used for 3D-periodic systems. Note that
              the selected Type determines how the lengths of the
              lattice vectors will evolve (linearly or as a
              sine/cosine), the evolution of the volume or density is
              thus necessarily non-linear.

            * **TargetLength** (*Iterable**[**float**] **|
              **FloatListKey*) -- Target lengths of each lattice
              vector to be achieved by StopStep. The number of values
              should equal the periodicity of the system. If a value
              is zero, the corresponding lattice vector will not be
              modified.

            * **Type** (*Literal**[**"Linear"**, **"Exponential"**,
              **"Sine"**, **"Cosine"**]*) --

              Function defining the time dependence of the deformed
              lattice parameters.

              Linear increments the lattice parameters by the same
              absolute amount every timestep. Exponential multiplies
              the lattice parameters by the same factor every
              timestep. Only StrainRate, LengthRate, and
              LengthVelocity are supported for Type=Exponential. Sine
              deforms the system from the starting lattice to
              TargetLattice/TargetLength and then by the same amount
              to the opposite direction, while Cosine deforms the
              system from the starting lattice to the target and back.

            * **LatticeVelocity** (*str** | **Sequence**[**str**] **|
              **FreeBlock*) -- Velocity of individual lattice vector
              components in Angstrom/fs. The format is identical to
              the System%Lattice block. For Type Sine and Cosine, this
              defines the maximum velocity (at the inflection point).

            * **StrainRate** (*str** | **Sequence**[**str**] **|
              **FreeBlock*) -- Strain rate matrix to be applied on
              every step. The format is identical to the
              System%Lattice block.

            * **TargetLattice** (*str** | **Sequence**[**str**] **|
              **FreeBlock*) -- Target lattice vectors to be achieved
              by StopStep. The format is identical to the
              System%Lattice block.

         class _LatticeVelocity

            Velocity of individual lattice vector components in
            Angstrom/fs. The format is identical to the System%Lattice
            block. For Type Sine and Cosine, this defines the maximum
            velocity (at the inflection point).

         class _StrainRate

            Strain rate matrix to be applied on every step. The format
            is identical to the System%Lattice block.

         class _TargetLattice

            Target lattice vectors to be achieved by StopStep. The
            format is identical to the System%Lattice block.

      class _Gravity

         Apply a constant acceleration in -z.

         Variables:
            **Acceleration** (*float** | **FloatKey*) -- Magnitude of
            the applied acceleration.

      class _HeatExchange

         Input for the heat-exchange non-equilibrium MD (T-NEMD).

         Variables:
            * **HeatingRate** (*float** | **FloatKey*) -- Rate at
              which the energy is added to the Source and removed from
              the Sink. A heating rate of 1 Hartree/fs equals to about
              0.00436 Watt of power being transferred through the
              system.

            * **Method** (*Literal**[**"Simple"**, **"HEX"**,
              **"eHEX"**]*) --

              Heat exchange method used.

              Simple: kinetic energy of the atoms of the source and
              sink regions is modified irrespective of that of the
              center of mass (CoM) of the region (recommended for
              solids).

              HEX: kinetic energy of the atoms of these regions is
              modified keeping that of the corresponding CoM constant.

              eHEX: an enhanced version of HEX that conserves the
              total energy better (recommended for gases and liquids).

            * **StartStep** (*int** | **IntKey*) -- Index of the MD
              step at which the heat exchange will start.

            * **StopStep** (*int** | **IntKey*) -- Index of the MD
              step at which the heat exchange will stop.

            * **Sink** (*SimpleActiveLearning._MolecularDynamics._Hea
              tExchange._Sink*) -- Defines the heat sink region (where
              the heat will be removed).

            * **Source** (*SimpleActiveLearning._MolecularDynamics._H
              eatExchange._Source*) -- Defines the heat source region
              (where the heat will be added).

         class _Sink

            Defines the heat sink region (where the heat will be
            removed).

            Variables:
               * **AtomList** (*Iterable**[**int**] **| **IntListKey*)
                 --

                 The atoms that are part of the sink.

                 This key is ignored if the [Box] block or [Region]
                 key is present.

               * **FirstAtom** (*int** | **IntKey*) -- Index of the
                 first atom of the region. This key is ignored if the
                 [Box] block or the [AtomList] key is present.

               * **LastAtom** (*int** | **IntKey*) -- Index of the
                 last atom of the region. This key is ignored if the
                 [Box] block or the [AtomList] key is present.

               * **Region** (*str** | **StringKey*) --

                 The region that is the sink.

                 This key is ignored if the [Box] block is present.

               * **Show** (*BoolType** | **BoolKey*) -- Show the sink
                 in the AMSinput

               * **Box** (*SimpleActiveLearning._MolecularDynamics._H
                 eatExchange._Sink._Box*) -- Part of the simulation
                 box (in fractional cell coordinates) defining the
                 heat sink. If this block is specified, then by
                 default, the whole box in each of the three
                 dimensions is used, which usually does not make much
                 sense. Normally, you will want to set the bounds
                 along one of the axes.

            class _Box

               Part of the simulation box (in fractional cell
               coordinates) defining the heat sink. If this block is
               specified, then by default, the whole box in each of
               the three dimensions is used, which usually does not
               make much sense. Normally, you will want to set the
               bounds along one of the axes.

               Variables:
                  * **Amax** (*float** | **FloatKey*) -- Coordinate of
                    the upper bound along the first axis.

                  * **Amin** (*float** | **FloatKey*) -- Coordinate of
                    the lower bound along the first axis.

                  * **Bmax** (*float** | **FloatKey*) -- Coordinate of
                    the upper bound along the second axis.

                  * **Bmin** (*float** | **FloatKey*) -- Coordinate of
                    the lower bound along the second axis.

                  * **Cmax** (*float** | **FloatKey*) -- Coordinate of
                    the upper bound along the third axis.

                  * **Cmin** (*float** | **FloatKey*) -- Coordinate of
                    the lower bound along the third axis.

         class _Source

            Defines the heat source region (where the heat will be
            added).

            Variables:
               * **AtomList** (*Iterable**[**int**] **| **IntListKey*)
                 --

                 The atoms that are part of the source.

                 This key is ignored if the [Box] block or [Region]
                 key is present.

               * **FirstAtom** (*int** | **IntKey*) -- Index of the
                 first atom of the region. This key is ignored if the
                 [Box] block or the [AtomList] key is present.

               * **LastAtom** (*int** | **IntKey*) -- Index of the
                 last atom of the region. This key is ignored if the
                 [Box] block or the [AtomList] key is present.

               * **Region** (*str** | **StringKey*) --

                 The region that is the source.

                 This key is ignored if the [Box] block is present.

               * **Show** (*BoolType** | **BoolKey*) -- Show the
                 source in the AMSinput

               * **Box** (*SimpleActiveLearning._MolecularDynamics._H
                 eatExchange._Source._Box*) -- Part of the simulation
                 box (in fractional cell coordinates) defining the
                 heat source. If this block is specified, then by
                 default, the whole box in each of the three
                 dimensions is used, which usually does not make much
                 sense. Normally, you will want to set the bounds
                 along one of the axes. This block is mutually
                 exclusive with the FirstAtom/LastAtom setting.

            class _Box

               Part of the simulation box (in fractional cell
               coordinates) defining the heat source. If this block is
               specified, then by default, the whole box in each of
               the three dimensions is used, which usually does not
               make much sense. Normally, you will want to set the
               bounds along one of the axes. This block is mutually
               exclusive with the FirstAtom/LastAtom setting.

               Variables:
                  * **Amax** (*float** | **FloatKey*) -- Coordinate of
                    the upper bound along the first axis.

                  * **Amin** (*float** | **FloatKey*) -- Coordinate of
                    the lower bound along the first axis.

                  * **Bmax** (*float** | **FloatKey*) -- Coordinate of
                    the upper bound along the second axis.

                  * **Bmin** (*float** | **FloatKey*) -- Coordinate of
                    the lower bound along the second axis.

                  * **Cmax** (*float** | **FloatKey*) -- Coordinate of
                    the upper bound along the third axis.

                  * **Cmin** (*float** | **FloatKey*) -- Coordinate of
                    the lower bound along the third axis.

      class _InitialVelocities

         Sets the frequency for printing to stdout and storing the
         molecular configuration on the .rkf file.

         Variables:
            * **File** (*str** | **Path** | **StringKey*) -- AMS RKF
              file containing the initial velocities.

            * **RandomVelocitiesMethod** (*Literal**[**"Exact"**,
              **"Boltzmann"**, **"Gromacs"**]*) --

              Specifies how are random velocities generated. Three
              methods are available.

              Exact: Velocities are scaled to exactly match set random
              velocities temperature.

              Boltzmann: Velocities are not scaled and sample Maxwell-
              Boltzmann distribution. However, the distribution is not
              corrected for constraints.

              Gromacs: Velocities are scaled to match set random
              velocities temperature, but removal of net momentum is
              performed only after the scaling. Resulting kinetic
              energy is lower based on how much net momentum the
              system had.

            * **Temperature** (*float** | **FloatKey*) --

              Sets the temperature for the Maxwell-Boltzmann
              distribution when the type of the initial velocities is
              set to random, in which case specifying this key is
              mandatory.

              AMSinput will use the first temperature of the first
              thermostat as default.

            * **Type** (*Literal**[**"Zero"**, **"Random"**,
              **"FromFile"**, **"Input"**]*) --

              Specifies the initial velocities to assign to the atoms.
              Three methods to assign velocities are available.

              Zero: All atom are at rest at the beginning of the
              calculation.

              Random: Initial atom velocities follow a Maxwell-
              Boltzmann distribution for the temperature given by the
              [MolecularDynamics%InitialVelocities%Temperature]
              keyword.

              FromFile: Load the velocities from a previous ams result
              file.

              Input: Atom's velocities are set to the values specified
              in the [MolecularDynamics%InitialVelocities%Values]
              block, which can be accessed via the Expert AMS panel in
              AMSinput.

            * **Values** (*str** | **Sequence**[**str**] **|
              **FreeBlock*) -- This block specifies the velocity of
              each atom, in Angstrom/fs, when
              [MolecularDynamics%InitialVelocities%Type] is set to
              Input. Each row must contain three floating point values
              (corresponding to the x,y,z component of the velocity
              vector) and a number of rows equal to the number of
              atoms must be present, given in the same order as the
              [System%Atoms] block.

         class _Values

            This block specifies the velocity of each atom, in
            Angstrom/fs, when
            [MolecularDynamics%InitialVelocities%Type] is set to
            Input. Each row must contain three floating point values
            (corresponding to the x,y,z component of the velocity
            vector) and a number of rows equal to the number of atoms
            must be present, given in the same order as the
            [System%Atoms] block.

      class _MovingRestraints

         Define a set of moving restraints.

         Variables:
            * **Change** (*Literal**[**"Linear"**, **"Sine"**,
              **"Cosine"**]*) --

              Type of function defining how the target restraint value
              will change over time:

              Linear - linearly between the StartValue and EndValue.
              Sine - oscillating around StartValue with an amplitude
              equal to the difference between EndValue and StartValue.
              Cosine - oscillating between StartValue and EndValue.

            * **Name** (*str** | **StringKey*) -- Optional name to be
              used for plotting.

            * **Period** (*float** | **FloatKey*) -- Period of
              oscillation for Sine and Cosine change types.

            * **RestraintType** (*Literal**[**"None"**,
              **"Harmonic"**, **"Hyperbolic"**, **"Erf"**,
              **"GaussianWell"**]*) -- Select type of the moving
              restraint profile. The force for Hyperbolic and Erf is
              bounded by a user-defined value, the latter converging
              to it faster than the former. The GaussianWell has a
              finite depth so it is suitable for cases when crossing a
              high reaction barrier is not desirable.

            * **StartStep** (*int** | **IntKey*) -- First step number
              at which the restraints will be applied.

            * **StopStep** (*int** | **IntKey*) -- Last step number at
              which the restraints will be applied.

            * **Distance** (*SimpleActiveLearning._MolecularDynamics.
              _MovingRestraints._Distance*) -- Define a distance
              restraint between pair of atoms. For linear-type

            * **Erf** (*SimpleActiveLearning._MolecularDynamics._Movi
              ngRestraints._Erf*) -- Define parameters for the
              Int(erf) restraint potential V =
              alpha*(beta*x*erf(beta*x) + (exp(-(beta*x)**2) -
              1)/sqrt(PI)). The alpha and beta parameters are computed
              from the user-defined ForceConstant and MaxForce.

            * **GaussianWell** (*SimpleActiveLearning._MolecularDynam
              ics._MovingRestraints._GaussianWell*) -- Define
              parameters in the Gaussian well restraint potential
              V=-WellDepth*exp(-Sigma*(r-r0)^2).

            * **Harmonic** (*SimpleActiveLearning._MolecularDynamics.
              _MovingRestraints._Harmonic*) -- Define parameters for
              the harmonic potential V=0.5*FC*(r-r0)^2.

            * **Hyperbolic** (*SimpleActiveLearning._MolecularDynamic
              s._MovingRestraints._Hyperbolic*) -- Define parameters
              for the hyperbolic restraint potential V=alpha*(sqrt(1 +
              beta*x^2) - 1). The alpha and beta parameters are
              computed from the user-defined ForceConstant and
              MaxForce: beta=ForceConstant/MaxForce,
              alpha=MaxForce/beta

         class _Distance

            Define a distance restraint between pair of atoms. For
            linear-type

            Variables:
               * **Atom1** (*int** | **IntKey*) -- First atom of the
                 distance restraint.

               * **Atom2** (*int** | **IntKey*) -- Second atom of the
                 distance restraint.

               * **EndValue** (*float** | **FloatKey*) -- Linear:
                 final target distance. Sine: target distance at 1/4
                 of the period. Cosine: target distance at 1/2 of the
                 period.

               * **StartValue** (*float** | **FloatKey*) -- Initial
                 target distance.

         class _Erf

            Define parameters for the Int(erf) restraint potential V =
            alpha*(beta*x*erf(beta*x) + (exp(-(beta*x)**2) -
            1)/sqrt(PI)). The alpha and beta parameters are computed
            from the user-defined ForceConstant and MaxForce.

            Variables:
               * **ForceConstant** (*float** | **FloatKey*) -- The
                 force constant (second derivative of the potential)
                 at the optimum point.

               * **MaxForce** (*float** | **FloatKey*) -- Asymptotic
                 value of the force at the infinity.

         class _GaussianWell

            Define parameters in the Gaussian well restraint potential
            V=-WellDepth*exp(-Sigma*(r-r0)^2).

            Variables:
               * **Sigma** (*float** | **FloatKey*) -- Sigma parameter
                 in the potential expression.

               * **WellDepth** (*float** | **FloatKey*) -- WellDepth
                 parameter in the potential expression.

         class _Harmonic

            Define parameters for the harmonic potential
            V=0.5*FC*(r-r0)^2.

            Variables:
               **ForceConstant** (*float** | **FloatKey*) -- The FC
               parameter of the harmonic potential.

         class _Hyperbolic

            Define parameters for the hyperbolic restraint potential
            V=alpha*(sqrt(1 + beta*x^2) - 1). The alpha and beta
            parameters are computed from the user-defined
            ForceConstant and MaxForce: beta=ForceConstant/MaxForce,
            alpha=MaxForce/beta

            Variables:
               * **ForceConstant** (*float** | **FloatKey*) -- The
                 force constant (second derivative of the potential)
                 at the optimum point.

               * **MaxForce** (*float** | **FloatKey*) -- Asymptotic
                 value of the force at the infinity.

      class _PRD

         This block is used for Parallel Replica Dynamics simulations.

         Variables:
            * **CorrelatedSteps** (*int** | **IntKey*) -- How many
              steps to wait for correlated events after detecting an
              initial event.

            * **DephasingSteps** (*int** | **IntKey*) -- Spend this
              many steps dephasing the individual replicas after an
              event.

            * **nReplicas** (*int** | **IntKey*) -- Number of replicas
              to run in parallel.

            * **BondChange** (*SimpleActiveLearning._MolecularDynamic
              s._PRD._BondChange*) -- Detect changes to the bonding
              topology and bond orders returned by the engine.

            * **MolCount** (*SimpleActiveLearning._MolecularDynamics.
              _PRD._MolCount*) -- Detect changes to the molecular
              composition of the system.

         class _BondChange

            Detect changes to the bonding topology and bond orders
            returned by the engine.

            Variables:
               * **ChangeThreshold** (*float** | **FloatKey*) --
                 Trigger an event when the bond order of a bond
                 changes from the reference state by more than this
                 value.

               * **DissociationThreshold** (*float** | **FloatKey*) --
                 Trigger an event when a bond dissociates (its bond
                 order drops below this value while it was above
                 FormationThreshold in the reference state).

               * **FormationThreshold** (*float** | **FloatKey*) --
                 Trigger an event when a new bond forms (its bond
                 order exceeds this value while it was below
                 DissociationThreshold in the reference state).

         class _MolCount

            Detect changes to the molecular composition of the system.

      class _Plumed

         Input for PLUMED (version 2.5.0). The parallel option is
         still experimental.

         Variables:
            * **Input** (*str** | **Sequence**[**str**] **|
              **FreeBlock*) -- Input for PLUMED. Contents of this
              block is passed to PLUMED as is.

            * **Parallel** (*SimpleActiveLearning._MolecularDynamics.
              _Plumed._Parallel*) -- Options for double
              parallelization, which allows to split the available
              processor cores into groups working through all the
              available tasks in parallel, resulting in a better
              parallel performance. The keys in this block determine
              how to split the available processor cores into groups
              working in parallel.

         class _Input

            Input for PLUMED. Contents of this block is passed to
            PLUMED as is.

         class _Parallel

            Options for double parallelization, which allows to split
            the available processor cores into groups working through
            all the available tasks in parallel, resulting in a better
            parallel performance. The keys in this block determine how
            to split the available processor cores into groups working
            in parallel.

            Variables:
               * **nCoresPerGroup** (*int** | **IntKey*) -- Number of
                 cores in each working group.

               * **nGroups** (*int** | **IntKey*) -- Total number of
                 processor groups. This is the number of tasks that
                 will be executed in parallel.

               * **nNodesPerGroup** (*int** | **IntKey*) -- Number of
                 nodes in each group. This option should only be used
                 on homogeneous compute clusters, where all used
                 compute nodes have the same number of processor
                 cores.

      class _Preserve

         Periodically remove numerical drift accumulated during the
         simulation to preserve different whole-system parameters.

         Variables:
            * **AngularMomentum** (*BoolType** | **BoolKey*) -- Remove
              overall angular momentum of the system. This option is
              ignored for 2D and 3D-periodic systems, and disabled by
              default for systems which are not translationally
              invariant (for example when frozen atoms are present).

            * **CenterOfMass** (*BoolType** | **BoolKey*) -- Translate
              the system to keep its center of mass at the coordinate
              origin. This option is not very useful for 3D-periodic
              systems.

            * **Momentum** (*BoolType** | **BoolKey*) -- Remove
              overall (linear) momentum of the system. This is
              disabled by default for systems which are not
              translationally invariant (for example when frozen atoms
              are present).

      class _Print

         This block controls the printing of additional information to
         stdout.

         Variables:
            * **System** (*BoolType** | **BoolKey*) -- Print the
              chemical system before and after the simulation.

            * **Velocities** (*BoolType** | **BoolKey*) -- Print the
              atomic velocities before and after the simulation.

      class _ReactionBoost

         Define a series of transitions between different states of
         the system.

         Each transition is defined by a TargetSystem and by a set of
         restraints that force the transition.

         Variables:
            * **Change** (*Literal**[**"TargetCoordinate"**,
              **"Force"**, **"LogForce"**]*) --

              Select what to change during dynamics.

              By default, once the restraints are switched on, AMS
              will change the restraint's target coordinate towards
              its final value.

              If the [Force] or [LogForce] option is selected then the
              target coordinate is set to its final value immediately
              and instead the restraint force is gradually scaled from
              0 to 1. The scaling is either linear (Force) or
              logarithmic (LogForce).

            * **InitialFraction** (*float** | **FloatKey*) --

              Initial fraction of the boost variable.

              At the first boosting step, the restraint's target value
              (or force or log(force)) is equal to InitialFraction +
              1/NSteps.

            * **InterEquilibrationSteps** (*int** | **IntKey*) --
              Number of equilibration steps after reaching a target
              before setting up restraints for the next one.

            * **MinBondChange** (*float** | **FloatKey*) -- Minimal
              change in the distance for an individual restraint to be
              considered bond-breaking/making vs bonded.

            * **MinBondStrength** (*float** | **FloatKey*) -- Minimum
              strength (usually ranges from 0 to 1) for a bond to be
              considered.

            * **NSteps** (*int** | **IntKey*) -- Number of steps per
              target the restraints should be active for.

            * **PreEquilibrationSteps** (*int** | **IntKey*) -- Number
              of steps before enabling the first set of restraints.

            * **Region** (*str** | **StringKey*) -- Region to which
              the restraints should be limited.

            * **TargetSystem** (*str** | **StringKey*) --

              The target system's name for this transition. Multiple
              targets can be specified to request multiple transitions
              in one simulation.

              Note that only the lattice and the atomic coordinates of
              the target system are used and other properties (bonds,
              charge, etc.) are ignored. The target system's lattice
              is used only to determine connections and it cannot be
              restrained.

            * **Type** (*Literal**[**"None"**, **"Pair"**,
              **"RMSD"**]*) --

              Reaction Boost uses a series of transitions between
              different states of the system. Each transition is
              defined by a TargetSystem and by a set of restraints
              that force the transition.

              Select the type of the restraint set: -None: no Reaction
              Boost - Pair: use pair restraints - RMSD: use RMSD
              restraints.

              Pair restraints are defined per atom pair while the RMSD
              defines one collective restraint for all atoms and is
              thus suitable for very large systems.

              The pair restraints are further divided into four sub-
              types: bonding, non-bonding, bond-breaking and bond-
              making. The sub-type of restraints for each pair is
              determined automatically depending on whether the two
              atoms are bonded in the initial/final state.

              Parameters of the pair restraints are defined by
              [NonBondedRestraints], [BondedRestraints],
              [BondBreakingRestraints] and [BondMakingRestraints]
              blocks, while those of the RMSD restraint by the
              [RMSDRestraint] block.

            * **BondBreakingRestraints** (*SimpleActiveLearning._Mole
              cularDynamics._ReactionBoost._BondBreakingRestraints*)
              --

              Define parameters for moving restraints that are added
              for pairs of atoms that become disconnected during the
              transition.

              It is intended to make sure the corresponding bonds get
              broken, although this may not always be required because
              forming other bonds will likely get these bonds broken.

            * **BondMakingRestraints** (*SimpleActiveLearning._Molecu
              larDynamics._ReactionBoost._BondMakingRestraints*) --

              Define parameters for moving restraints that are added
              for pairs of atoms that become connected during the
              transition.

              It is intended to make sure the bonds are created as
              required.

            * **BondedRestraints** (*SimpleActiveLearning._MolecularD
              ynamics._ReactionBoost._BondedRestraints*) --

              Define parameters for bonded restraints. A bonded
              restraint is added for each pair of atoms that are
              bonded both in the current and in the final state.

              It is intended to make sure they remain bonded during
              simulation.

            * **NonBondedRestraints** (*SimpleActiveLearning._Molecul
              arDynamics._ReactionBoost._NonBondedRestraints*) --

              Define parameters for non-bonded restraints. A non-
              bonded restraint is added for each pair of atoms that
              are bonded neither in the current nor in the final
              state.

              It is intended to keep them from forming a bond
              unintentionally. They are represented by a repulsive
              potential

            * **RMSDRestraint** (*SimpleActiveLearning._MolecularDyna
              mics._ReactionBoost._RMSDRestraint*) -- Define a static
              restraint that pulls each atom to its position in the
              target system, but in contrast to the individual
              restraints, the force for this one depends on the total
              mass-weighted root-mean-squared distance (RMSD) between
              the two structures.

         class _BondBreakingRestraints

            Define parameters for moving restraints that are added for
            pairs of atoms that become disconnected during the
            transition.

            It is intended to make sure the corresponding bonds get
            broken, although this may not always be required because
            forming other bonds will likely get these bonds broken.

            Variables:
               * **Type** (*Literal**[**"None"**, **"Harmonic"**,
                 **"Hyperbolic"**, **"Erf"**, **"GaussianWell"**]*) --

                 Select type of the moving restraint profile.

                 Harmonic: V=0.5*FC*(r-r0)^2

                 Hyperbolic: V=alpha*(sqrt(1 + beta*x^2) - 1)

                 Erf: V = alpha*(beta*x*erf(beta*x) +
                 (exp(-(beta*x)**2) - 1)/sqrt(PI))

                 GaussianWell: V=WellDepth*(1-exp(-Sigma*(r-r0)^2))

                 Here beta=ForceConstant/MaxForce,
                 alpha=MaxForce/beta.

                 The force for Hyperbolic and Erf is bounded by a
                 user-defined value, the latter converging to it
                 faster than the former. The GaussianWell has a finite
                 depth so it is suitable for cases when crossing a
                 high reaction barrier is not desirable.

                 Moving restraints are added for pairs of atoms that
                 become disconnected during the transition.

                 It is intended to make sure the corresponding bonds
                 get broken, although this may not always be required
                 because forming other bonds will likely get these
                 bonds broken.

               * **Erf** (*SimpleActiveLearning._MolecularDynamics._R
                 eactionBoost._BondBreakingRestraints._Erf*) -- Define
                 parameters for the Int(erf) potential V =
                 alpha*(beta*x*erf(beta*x) + (exp(-(beta*x)**2) -
                 1)/sqrt(PI)). The alpha and beta parameters are
                 computed from the user-defined ForceConstant and
                 MaxForce.

               * **GaussianWell** (*SimpleActiveLearning._MolecularDy
                 namics._ReactionBoost._BondBreakingRestraints._Gauss
                 ianWell*) -- Define parameters in the Gaussian well
                 potential V=-WellDepth*exp(-Sigma*(r-r0)^2).

               * **Harmonic** (*SimpleActiveLearning._MolecularDynami
                 cs._ReactionBoost._BondBreakingRestraints._Harmonic*)
                 -- Define parameters for the harmonic potential
                 V=0.5*FC*(r-r0)^2.

               * **Hyperbolic** (*SimpleActiveLearning._MolecularDyna
                 mics._ReactionBoost._BondBreakingRestraints._Hyperbo
                 lic*) -- Define parameters for the hyperbolic
                 potential V=alpha*(sqrt(1 + beta*x^2) - 1). The alpha
                 and beta parameters are computed from the user-
                 defined ForceConstant and MaxForce:
                 beta=ForceConstant/MaxForce, alpha=MaxForce/beta

               * **Taper** (*SimpleActiveLearning._MolecularDynamics.
                 _ReactionBoost._BondBreakingRestraints._Taper*) --

            class _Erf

               Define parameters for the Int(erf) potential V =
               alpha*(beta*x*erf(beta*x) + (exp(-(beta*x)**2) -
               1)/sqrt(PI)). The alpha and beta parameters are
               computed from the user-defined ForceConstant and
               MaxForce.

               Variables:
                  * **ForceConstant** (*float** | **FloatKey*) -- The
                    force constant (second derivative of the
                    potential) at the optimum point.

                  * **MaxForce** (*float** | **FloatKey*) --
                    Asymptotic value of the force at the infinity.

            class _GaussianWell

               Define parameters in the Gaussian well potential
               V=-WellDepth*exp(-Sigma*(r-r0)^2).

               Variables:
                  * **Sigma** (*float** | **FloatKey*) -- Sigma
                    parameter in the potential expression.

                  * **WellDepth** (*float** | **FloatKey*) --
                    WellDepth parameter in the potential expression.

            class _Harmonic

               Define parameters for the harmonic potential
               V=0.5*FC*(r-r0)^2.

               Variables:
                  **ForceConstant** (*float** | **FloatKey*) -- The FC
                  parameter of the harmonic potential.

            class _Hyperbolic

               Define parameters for the hyperbolic potential
               V=alpha*(sqrt(1 + beta*x^2) - 1). The alpha and beta
               parameters are computed from the user-defined
               ForceConstant and MaxForce:
               beta=ForceConstant/MaxForce, alpha=MaxForce/beta

               Variables:
                  * **ForceConstant** (*float** | **FloatKey*) -- The
                    force constant (second derivative of the
                    potential) at the optimum point.

                  * **MaxForce** (*float** | **FloatKey*) --
                    Asymptotic value of the force at the infinity.

            class _Taper

               Variables:
                  * **Enabled** (*BoolType** | **BoolKey*) -- Enable
                    tapering of the restraint potential and force
                    between the given range of bond distances. A 7-th
                    order tapering function on the actual (not
                    target!) distance will be used. The MaxDistance
                    must be greater than MinDistance.

                  * **MaxDistance** (*float** | **FloatKey*) -- Bond
                    length at which the restraint potential and force
                    decays to zero.

                  * **MinDistance** (*float** | **FloatKey*) -- Bond
                    length at which the restraint potential and force
                    will start decaying to zero.

         class _BondMakingRestraints

            Define parameters for moving restraints that are added for
            pairs of atoms that become connected during the
            transition.

            It is intended to make sure the bonds are created as
            required.

            Variables:
               * **Type** (*Literal**[**"None"**, **"Harmonic"**,
                 **"Hyperbolic"**, **"Erf"**, **"GaussianWell"**]*) --

                 Select type of the moving restraint profile.

                 Harmonic: V=0.5*FC*(r-r0)^2

                 Hyperbolic: V=alpha*(sqrt(1 + beta*x^2) - 1)

                 Erf: V = alpha*(beta*x*erf(beta*x) +
                 (exp(-(beta*x)**2) - 1)/sqrt(PI))

                 GaussianWell: V=-WellDepth*exp(-Sigma*(r-r0)^2)

                 Here beta=ForceConstant/MaxForce,
                 alpha=MaxForce/beta.

                 The force for Hyperbolic and Erf is bounded by a
                 user-defined value. The GaussianWell has a finite
                 depth so it is suitable for cases when crossing a
                 high reaction barrier is not desirable.

                 Moving restraints are added for pairs of atoms that
                 become connected during the transition.

                 It is intended to make sure the bonds are created as
                 required.

               * **Erf** (*SimpleActiveLearning._MolecularDynamics._R
                 eactionBoost._BondMakingRestraints._Erf*) -- Define
                 parameters for the Int(erf) potential V =
                 alpha*(beta*x*erf(beta*x) + (exp(-(beta*x)**2) -
                 1)/sqrt(PI)). The alpha and beta parameters are
                 computed from the user-defined ForceConstant and
                 MaxForce.

               * **GaussianWell** (*SimpleActiveLearning._MolecularDy
                 namics._ReactionBoost._BondMakingRestraints._Gaussia
                 nWell*) -- Define parameters in the Gaussian well
                 potential V=-WellDepth*exp(-Sigma*(r-r0)^2).

               * **Harmonic** (*SimpleActiveLearning._MolecularDynami
                 cs._ReactionBoost._BondMakingRestraints._Harmonic*)
                 -- Define parameters for the harmonic potential
                 V=0.5*FC*(r-r0)^2.

               * **Hyperbolic** (*SimpleActiveLearning._MolecularDyna
                 mics._ReactionBoost._BondMakingRestraints._Hyperboli
                 c*) -- Define parameters for the hyperbolic potential
                 V=alpha*(sqrt(1 + beta*x^2) - 1). The alpha and beta
                 parameters are computed from the user-defined
                 ForceConstant and MaxForce:
                 beta=ForceConstant/MaxForce, alpha=MaxForce/beta

            class _Erf

               Define parameters for the Int(erf) potential V =
               alpha*(beta*x*erf(beta*x) + (exp(-(beta*x)**2) -
               1)/sqrt(PI)). The alpha and beta parameters are
               computed from the user-defined ForceConstant and
               MaxForce.

               Variables:
                  * **ForceConstant** (*float** | **FloatKey*) -- The
                    force constant (second derivative of the
                    potential) at the optimum point.

                  * **MaxForce** (*float** | **FloatKey*) --
                    Asymptotic value of the force at the infinity.

            class _GaussianWell

               Define parameters in the Gaussian well potential
               V=-WellDepth*exp(-Sigma*(r-r0)^2).

               Variables:
                  * **Sigma** (*float** | **FloatKey*) -- Sigma
                    parameter in the potential expression.

                  * **WellDepth** (*float** | **FloatKey*) --
                    WellDepth parameter in the potential expression.

            class _Harmonic

               Define parameters for the harmonic potential
               V=0.5*FC*(r-r0)^2.

               Variables:
                  **ForceConstant** (*float** | **FloatKey*) -- The FC
                  parameter of the harmonic potential.

            class _Hyperbolic

               Define parameters for the hyperbolic potential
               V=alpha*(sqrt(1 + beta*x^2) - 1). The alpha and beta
               parameters are computed from the user-defined
               ForceConstant and MaxForce:
               beta=ForceConstant/MaxForce, alpha=MaxForce/beta

               Variables:
                  * **ForceConstant** (*float** | **FloatKey*) -- The
                    force constant (second derivative of the
                    potential) at the optimum point.

                  * **MaxForce** (*float** | **FloatKey*) --
                    Asymptotic value of the force at the infinity.

         class _BondedRestraints

            Define parameters for bonded restraints. A bonded
            restraint is added for each pair of atoms that are bonded
            both in the current and in the final state.

            It is intended to make sure they remain bonded during
            simulation.

            Variables:
               * **Type** (*Literal**[**"None"**, **"Harmonic"**]*) --

                 Select type of the bonded restraints:

                 Harmonic: V=0.5*FC*(r-r0)^2

                 A bonded restraint is added for each pair of atoms
                 that are bonded both in the current and in the final
                 state.

                 It is intended to make sure they remain bonded during
                 simulation.

               * **Harmonic** (*SimpleActiveLearning._MolecularDynami
                 cs._ReactionBoost._BondedRestraints._Harmonic*) --
                 Define parameters for the harmonic potential
                 V=0.5*FC*(r-r0)^2.

            class _Harmonic

               Define parameters for the harmonic potential
               V=0.5*FC*(r-r0)^2.

               Variables:
                  **ForceConstant** (*float** | **FloatKey*) -- The FC
                  parameter of the harmonic potential.

         class _NonBondedRestraints

            Define parameters for non-bonded restraints. A non-bonded
            restraint is added for each pair of atoms that are bonded
            neither in the current nor in the final state.

            It is intended to keep them from forming a bond
            unintentionally. They are represented by a repulsive
            potential

            Variables:
               * **Type** (*Literal**[**"None"**, **"Exponential"**]*)
                 --

                 Select type of the non-bonded restraints:

                 Exponential: V=Epsilon*exp(-Sigma*r)

                 A non-bonded restraint is added for each pair of
                 atoms that are bonded neither in the current nor in
                 the final state.

                 It is intended to keep them from forming a bond
                 unintentionally. They are represented by a repulsive
                 potential.

               * **Exponential** (*SimpleActiveLearning._MolecularDyn
                 amics._ReactionBoost._NonBondedRestraints._Exponenti
                 al*) -- Define parameters for the repulsive potential
                 V=Epsilon*exp(-Sigma*r).

            class _Exponential

               Define parameters for the repulsive potential
               V=Epsilon*exp(-Sigma*r).

               Variables:
                  * **Epsilon** (*float** | **FloatKey*) -- Epsilon
                    parameter in the repulsive potential expression.

                  * **Sigma** (*float** | **FloatKey*) -- Sigma
                    parameter in the repulsive potential expression.

         class _RMSDRestraint

            Define a static restraint that pulls each atom to its
            position in the target system, but in contrast to the
            individual restraints, the force for this one depends on
            the total mass-weighted root-mean-squared distance (RMSD)
            between the two structures.

            Variables:
               * **Type** (*Literal**[**"None"**, **"Harmonic"**,
                 **"Hyperbolic"**, **"Erf"**, **"GaussianWell"**]*) --

                 Select type of the RMSD restraint profile:

                 Harmonic: V=0.5*FC*(r-r0)^2

                 Hyperbolic: V=alpha*(sqrt(1 + beta*x^2) - 1)

                 Erf: V = alpha*(beta*x*erf(beta*x) +
                 (exp(-(beta*x)**2) - 1)/sqrt(PI),

                 GaussianWell: V=-WellDepth*exp(-Sigma*(r-r0)^2)

                 Here beta=ForceConstant/MaxForce,
                 alpha=MaxForce/beta.

                 The Harmonic profile can be problematic at large
                 deviations as it may result in large forces. The
                 force for Hyperbolic and Erf is bounded by a user-
                 defined value. The GaussianWell has a finite depth so
                 it is suitable for cases when crossing a high
                 reaction barrier is not desirable.

               * **Erf** (*SimpleActiveLearning._MolecularDynamics._R
                 eactionBoost._RMSDRestraint._Erf*) -- Define
                 parameters for the Int(erf) potential V =
                 alpha*(beta*x*erf(beta*x) + (exp(-(beta*x)**2) -
                 1)/sqrt(PI)). The alpha and beta parameters are
                 computed from the user-defined ForceConstant and
                 MaxForce.

               * **GaussianWell** (*SimpleActiveLearning._MolecularDy
                 namics._ReactionBoost._RMSDRestraint._GaussianWell*)
                 -- Define parameters in the Gaussian well potential
                 V=-WellDepth*exp(-Sigma*(r-r0)^2).

               * **Harmonic** (*SimpleActiveLearning._MolecularDynami
                 cs._ReactionBoost._RMSDRestraint._Harmonic*) --
                 Define parameters for the harmonic potential
                 V=0.5*FC*(r-r0)^2.

               * **Hyperbolic** (*SimpleActiveLearning._MolecularDyna
                 mics._ReactionBoost._RMSDRestraint._Hyperbolic*) --
                 Define parameters for the hyperbolic potential
                 V=alpha*(sqrt(1 + beta*x^2) - 1). The alpha and beta
                 parameters are computed from the user-defined
                 ForceConstant and MaxForce:
                 beta=ForceConstant/MaxForce, alpha=MaxForce/beta

            class _Erf

               Define parameters for the Int(erf) potential V =
               alpha*(beta*x*erf(beta*x) + (exp(-(beta*x)**2) -
               1)/sqrt(PI)). The alpha and beta parameters are
               computed from the user-defined ForceConstant and
               MaxForce.

               Variables:
                  * **ForceConstant** (*float** | **FloatKey*) -- The
                    force constant (second derivative of the
                    potential) at the optimum point.

                  * **MaxForce** (*float** | **FloatKey*) --
                    Asymptotic value of the force at the infinity.

            class _GaussianWell

               Define parameters in the Gaussian well potential
               V=-WellDepth*exp(-Sigma*(r-r0)^2).

               Variables:
                  * **Sigma** (*float** | **FloatKey*) -- Sigma
                    parameter in the potential expression.

                  * **WellDepth** (*float** | **FloatKey*) --
                    WellDepth parameter in the potential expression.

            class _Harmonic

               Define parameters for the harmonic potential
               V=0.5*FC*(r-r0)^2.

               Variables:
                  **ForceConstant** (*float** | **FloatKey*) -- The FC
                  parameter of the harmonic potential.

            class _Hyperbolic

               Define parameters for the hyperbolic potential
               V=alpha*(sqrt(1 + beta*x^2) - 1). The alpha and beta
               parameters are computed from the user-defined
               ForceConstant and MaxForce:
               beta=ForceConstant/MaxForce, alpha=MaxForce/beta

               Variables:
                  * **ForceConstant** (*float** | **FloatKey*) -- The
                    force constant (second derivative of the
                    potential) at the optimum point.

                  * **MaxForce** (*float** | **FloatKey*) --
                    Asymptotic value of the force at the infinity.

      class _Reactor

         Define one phase of the nanoreactor. A reactor is a region of
         space surrounded by an elastic wall. Atoms inside the region
         are not affected. Atoms outside it will be pushed back with
         force depending on the [ForceConstant] and the [MassScaled]
         flag.

         Variables:
            * **ForceConstant** (*float** | **FloatKey*) -- Force
              constant of the reactor wall in Hartree/Bohr^2 (or
              Hartree/Bohr^2/Dalton if [MassScaled] is true).

            * **MassScaled** (*BoolType** | **BoolKey*) -- If this
              flag is disabled the force on an atom outside of the
              reactor depends only on the atomic coordinates and the
              force constant. Otherwise, the force is also multiplied
              by the mass of the atom. This means that atoms at the
              same distance from the wall will receive the same
              accelerate due to the wall potential.

            * **NSteps** (*int** | **IntKey*) -- Number of steps for
              which the reactor will remain active until disabled. The
              next reactor will be activated immediately after this.
              After the last reactor is disabled the cycle will
              repeat.

            * **Radius** (*float** | **FloatKey*) -- Radius of the
              reactor sphere.

      class _ReflectiveWall

         Apply a reflective wall in space

         Variables:
            * **Axis** (*Iterable**[**float**] **| **FloatListKey*) --
              Defines the normal vector perpendicular to the plane of
              the reflective wall. Any particle moving in this
              direction will be reflected back.

            * **Direction** (*Literal**[**"under"**, **"above"**]*) --
              Defines the direction of the reflective wall. under will
              keep the particles under the defined wall, and above
              will keep the particles above the defined wall

            * **Region** (*str** | **StringKey*) -- Apply the
              reflective wall to all atoms in this region.

            * **Thickness** (*float** | **FloatKey*) -- Any particle
              not deeper than Thickness beyond the reflective face of
              the wall will be reflected. Particles deeper than this
              will be ignored by the wall. This setting allows the
              placement of two walls back-to-back to create a two-
              sided wall that reflects in both directions (offset the
              position of each individual wall by Thickness so that
              their areas of influence do not overlap). Systems with
              very high speed particles (light atoms at high
              temperatures) need a higher Thickness to stop atoms from
              tunneling through the wall in a single timestep.

            * **Threshold** (*float** | **FloatKey*) -- Defines the
              threshold value determining the position of the
              reflective wall. If the dot product of a position of a
              particle with Axis exceeds Threshold, the particle will
              be reflected. This means that the plane of the wall
              passes through a point given by Axis times Threshold.

      class _Remap

         Control periodic remapping (backtranslation) of atoms into
         the PBC box.

         Variables:
            * **Range** (*Literal**[**"Auto"**, **"ZeroToOne"**,
              **"PlusMinusHalf"**, **"AroundCenter"**]*) --

              Select the range of fractional coordinates to which
              atoms are remapped.

              Auto: Use PlusMinusHalf if the geometrical center of the
              starting positions of all atoms lies between -0.25 and
              0.25 in fractional coordinates in all periodic
              directions, ZeroToOne otherwise.

              PlusMinusHalf: Remap atoms to lie between -0.5 and 0.5
              in fractional coordinates.

              ZeroToOne: Remap atoms to lie between 0 and 1 in
              fractional coordinates.

              AroundCenter: Remap atoms to lie within 0.5 in
              fractional coordinates around the geometrical center of
              the starting positions of all atoms.

            * **Type** (*Literal**[**"None"**, **"Atoms"**]*) --

              Select the method used to remap atoms into the unit
              cell.

              None: Disable remapping completely.

              Atoms: Remap any atoms that leave the unit cell.

      class _RemoveMolecules

         This block controls removal of molecules from the system.
         Multiple occurrences of this block are possible.

         Variables:
            * **Formula** (*str** | **StringKey*) --

              Molecular formula of the molecules that should be
              removed from the system.

              The order of elements in the formula is very important
              and the correct order is: C, H, all other elements in
              the strictly alphabetic order.  Element names are case-
              sensitive, spaces in the formula are not allowed. Digit
              '1' must be omitted.

              Valid formula examples: C2H6O, H2O, O2S. Invalid formula
              examples: C2H5OH, H2O1, OH, SO2. Invalid formulas are
              silently ignored.

              Use * to remove any molecule, which must be combined
              with SinkBox or SafeBox.

            * **Frequency** (*int** | **IntKey*) -- The specified
              molecules are removed every so many steps after the
              StartStep. There is never a molecule removed at step 0.

            * **StartStep** (*int** | **IntKey*) --

              Step number when molecules are removed for the first
              time. After that, molecules are removed every
              [Frequency] steps.

              For example, if StartStep=99 and Frequency=100 then
              molecules will be removed at steps 99, 199, 299, etc...

              No molecule will be removed at step 0, so if StartStep=0
              the first molecules are removed at the step number equal
              to [Frequency].

            * **StopStep** (*int** | **IntKey*) -- Do not remove the
              specified molecules after this step.

            * **SafeBox** (*SimpleActiveLearning._MolecularDynamics._
              RemoveMolecules._SafeBox*) -- Part of the simulation box
              where molecules may not be removed. Only one of the
              SinkBox or SafeBox blocks may be present. If this block
              is present the molecule will not be removed if any of
              its atoms is within the box. For a periodic dimension it
              is given as a fraction of the simulation box (the full 0
              to 1 range by default). For a non-periodic dimension it
              represents absolute Cartesian coordinates in Angstrom.

            * **SinkBox** (*SimpleActiveLearning._MolecularDynamics._
              RemoveMolecules._SinkBox*) -- Part of the simulation box
              where matching molecules will be removed. By default,
              molecules matching the formula will be removed
              regardless of their location. If this block is present
              then such a molecule will only be removed if any of its
              atoms is within the box. For a periodic dimension it is
              given as a fraction of the simulation box (the full 0 to
              1 range by default). For a non-periodic dimension it
              represents absolute Cartesian coordinates in Angstrom.

         class _SafeBox

            Part of the simulation box where molecules may not be
            removed. Only one of the SinkBox or SafeBox blocks may be
            present. If this block is present the molecule will not be
            removed if any of its atoms is within the box. For a
            periodic dimension it is given as a fraction of the
            simulation box (the full 0 to 1 range by default). For a
            non-periodic dimension it represents absolute Cartesian
            coordinates in Angstrom.

            Variables:
               * **Amax** (*float** | **FloatKey*) -- Coordinate of
                 the upper bound along the first axis.

               * **Amin** (*float** | **FloatKey*) -- Coordinate of
                 the lower bound along the first axis.

               * **Bmax** (*float** | **FloatKey*) -- Coordinate of
                 the upper bound along the second axis.

               * **Bmin** (*float** | **FloatKey*) -- Coordinate of
                 the lower bound along the second axis.

               * **Cmax** (*float** | **FloatKey*) -- Coordinate of
                 the upper bound along the third axis.

               * **Cmin** (*float** | **FloatKey*) -- Coordinate of
                 the lower bound along the third axis.

               * **FractionalCoordsBox** (*Iterable**[**float**] **|
                 **FloatListKey*) --

                 Do not remove molecules that are (partly) inside the
                 safe box.

                 Borders of the safe box specified as: Amin, Amax,
                 Bmin, Bmax, Cmin, Cmax.

                 For periodic dimensions fractional coordinates
                 between 0 and 1 and for non-periodic dimensions
                 Cartesian values in Angstrom are expected.

         class _SinkBox

            Part of the simulation box where matching molecules will
            be removed. By default, molecules matching the formula
            will be removed regardless of their location. If this
            block is present then such a molecule will only be removed
            if any of its atoms is within the box. For a periodic
            dimension it is given as a fraction of the simulation box
            (the full 0 to 1 range by default). For a non-periodic
            dimension it represents absolute Cartesian coordinates in
            Angstrom.

            Variables:
               * **Amax** (*float** | **FloatKey*) -- Coordinate of
                 the upper bound along the first axis.

               * **Amin** (*float** | **FloatKey*) -- Coordinate of
                 the lower bound along the first axis.

               * **Bmax** (*float** | **FloatKey*) -- Coordinate of
                 the upper bound along the second axis.

               * **Bmin** (*float** | **FloatKey*) -- Coordinate of
                 the lower bound along the second axis.

               * **Cmax** (*float** | **FloatKey*) -- Coordinate of
                 the upper bound along the third axis.

               * **Cmin** (*float** | **FloatKey*) -- Coordinate of
                 the lower bound along the third axis.

               * **FractionalCoordsBox** (*Iterable**[**float**] **|
                 **FloatListKey*) --

                 Remove molecules that are (partly) inside the sink
                 box.

                 Borders of the sink box specified as: Amin, Amax,
                 Bmin, Bmax, Cmin, Cmax.

                 For periodic dimensions fractional coordinates
                 between 0 and 1 and for non-periodic dimensions
                 Cartesian values in Angstrom are expected.

      class _ReplicaExchange

         This block is used for (temperature) Replica Exchange MD
         (Parallel Tempering) simulations.

         Variables:
            * **AllowWrongResults** (*BoolType** | **BoolKey*) --
              Allow combining Replica Exchange with other features
              when the combination is known to produce physically
              incorrect results.

            * **EWMALength** (*int** | **IntKey*) --

              Length of the exponentially weighted moving average used
              to smooth swap probabilities for monitoring.

              This value is equal to the inverse of the EWMA mixing
              factor.

            * **SwapFrequency** (*int** | **IntKey*) -- Attempt an
              exchange every N steps.

            * **TemperatureFactors** (*Iterable**[**float**] **|
              **FloatListKey*) --

              This is the ratio of the temperatures of two successive
              replicas.

              The first value sets the temperature of the second
              replica with respect to the first replica, the second
              value sets the temperature of the third replica with
              respect to the second one, and so on. If there are fewer
              values than nReplicas, the last value of
              TemperatureFactor is used for all the remaining
              replicas.

            * **Temperatures** (*Iterable**[**float**] **|
              **FloatListKey*) --

              List of temperatures for all replicas except for the
              first one.

              This is mutually exclusive with TemperatureFactors.
              Exactly nReplicas-1 temperature values need to be
              specified, in increasing order. The temperature of the
              first replica is given by [Thermostat%Temperature].

            * **nReplicas** (*int** | **IntKey*) -- Number of replicas
              to run in parallel.

      class _Shake

         Parameters of the Shake/Rattle algorithm.

         Variables:
            * **All** (*str** | **StringKey*) --

              Constraint description in one the following formats:
              All [bondOrder] bonds at1 at2 [to distance] All
              triangles at1 at2 at3

              The first option constrains all bonds between atoms at1
              at2 to a certain length, while the second - bonds
              at1-at2 and at2-at3 and the angle between them.

              The [bondOrder] can be a number or a string such as
              single, double, triple or aromatic. If it's omitted then
              all bonds between specified atoms will be constrained.
              Atom names are case-sensitive and they must be as they
              are in the Atoms block, or an asterisk '*' denoting any
              atom. The distance, if present, must be in Angstrom. If
              it is omitted then the bond length from the initial
              geometry is used.

              Important: only the bonds present in the system at
              certain points of the simulation (at the start or right
              after adding/removing atoms) can be constrained, which
              means that the bonds may need to be specified in the
              System block.

              Warning: the triangles constraint should be used with
              care because each constrained bond or angle means
              removing one degree of freedom from the dynamics. When
              there are too many constraints (for example, "All
              triangles H C H" in methane) some of them may be
              linearly dependent, which will lead to an error in the
              temperature computation.

              Valid examples: All single bonds C C to 1.4 All bonds O
              H to 0.98 All bonds O H All bonds H * All triangles H *
              H

            * **ConvergeR2** (*float** | **FloatKey*) -- Convergence
              criterion on the max squared difference, in atomic
              units.

            * **ConvergeRV** (*float** | **FloatKey*) -- Convergence
              criterion on the orthogonality of the constraint and the
              relative atomic velocity, in atomic units.

            * **ExcludeRegion** (*str** | **StringKey*) -- Exclude all
              atoms covered by this region expression from all
              constraints. If both atoms of a bond belong to
              ExcludeRegion, the bond will be kept unconstrained,
              regardless of Shake%All or engine-specific constraints.

            * **Iterations** (*int** | **IntKey*) -- Number of
              iterations.

            * **ShakeInitialCoordinates** (*BoolType** | **BoolKey*)
              -- Apply constraints before computing the first energy
              and gradients.

      class _Thermostat

         This block allows to specify the use of a thermostat during
         the simulation. Depending on the selected thermostat type,
         different additional options may be needed to characterize
         the specific thermostat's behavior.

         Variables:
            * **BerendsenApply** (*Literal**[**"Local"**,
              **"Global"**]*) --

              Select how to apply the scaling correction for the
              Berendsen thermostat:

              * per-atom-velocity (Local)

              * on the molecular system as a whole (Global).

            * **ChainLength** (*int** | **IntKey*) -- Number of
              individual thermostats forming the NHC thermostat

            * **Duration** (*Iterable**[**int**] **| **IntListKey*) --
              Specifies how many steps should a transition from a
              particular temperature to the next one in sequence take.

            * **ExcludedDirection** (*Literal**[**"None"**, **"X"**,
              **"Y"**, **"Z"**]*) -- Exclude a component of the
              velocities from rescaling by the thermostat. For example
              in NEMD simulations, when a shear force/velocity is
              applied in the x direction, the x-direction is often
              excluded from thermostatting. This currently only works
              for the Nose-Hoover thermostat.

            * **Friction** (*float** | **FloatKey*) -- Friction
              coefficient used in langevin dynamics

            * **Region** (*str** | **StringKey*) -- The identifier of
              the region to thermostat. The default *** applies the
              thermostat to the entire system. The value can by a
              plain region name, or a region expression, e.g.
              **-myregion* to thermostat all atoms that are not in
              myregion, or *regionA+regionB* to thermostat the union
              of the 'regionA' and 'regionB'. Note that if multiple
              thermostats are used, their regions may not overlap.

            * **ScaleFrequency** (*int** | **IntKey*) --

              Optional parameter used only by the Scale thermostat.

              If specified, the thermostat will be applied every N
              steps, using that step's ensemble temperature and the
              specified thermostat temperature to compute the scaling
              factor.

              If not specified, the thermostat will be applied at
              every step, using the mean temperature of the ensemble
              and the specified thermostat temperature to compute the
              scaling factor.

            * **Tau** (*float** | **FloatKey*) -- The time constant of
              the thermostat.

            * **Temperature** (*Iterable**[**float**] **|
              **FloatListKey*) --

              The target temperature of the thermostat.

              You can specify multiple temperatures (separated by
              spaces). In that case the Duration field specifies how
              many steps to use for the transition from one T to the
              next T (using a linear ramp). For NHC thermostat, the
              temperature may not be zero.

            * **Type** (*Literal**[**"None"**, **"Scale"**,
              **"Berendsen"**, **"NHC"**, **"Langevin"**]*) -- Selects
              the type of the thermostat.

      class _Trajectory

         Sets the frequency for printing to stdout and storing the
         molecular configuration on the .rkf file.

         Variables:
            * **EngineResultsFreq** (*int** | **IntKey*) -- Write
              MDStep*.rkf files with engine-specific results once
              every N steps. Setting this to zero disables writing
              engine results files except for one file at the end of
              the simulation. If this is set to a negative value, the
              value of Checkpoint%Frequency will be used instead.

            * **ExitConditionFreq** (*int** | **IntKey*) -- Check the
              exit conditions every N steps. By default this is done
              every SamplingFreq steps.

            * **PrintFreq** (*int** | **IntKey*) -- Print current
              thermodynamic properties to the output every N steps. By
              default this is done every SamplingFreq steps.

            * **SamplingFreq** (*int** | **IntKey*) -- Write the
              molecular geometry (and possibly other properties) to
              the ams.rkf file once every N steps.

            * **TProfileGridPoints** (*int** | **IntKey*) -- Number of
              points in the temperature profile. If TProfileGridPoints
              > 0, a temperature profile along each of the three
              lattice axes will be written to the .rkf file. The
              temperature at a given profile point is calculated as
              the total temperature of all atoms inside the
              corresponding slice of the simulation box, time-averaged
              over all MD steps since the previous snapshot.​ By
              default, no profile is generated.

            * **WriteBonds** (*BoolType** | **BoolKey*) -- Write
              detected bonds to the .rkf file.

            * **WriteCharges** (*BoolType** | **BoolKey*) -- Write
              current atomic point charges (if available) to the .rkf
              file. Disable this to reduce trajectory size if you do
              not need to analyze charges.

            * **WriteCoordinates** (*BoolType** | **BoolKey*) -- Write
              atomic coordinates to the .rkf file.

            * **WriteEngineGradients** (*BoolType** | **BoolKey*) --
              Write atomic gradients (negative of the atomic forces,
              as calculated by the engine) to the History section of
              ams.rkf.

            * **WriteMolecules** (*BoolType** | **BoolKey*) -- Write
              the results of molecule analysis to the .rkf file.

            * **WriteVelocities** (*BoolType** | **BoolKey*) -- Write
              velocities to the .rkf file. Disable this to reduce
              trajectory size if you do not need to analyze the
              velocities.

      class _fbMC

         This block sets up force bias Monte Carlo interleaved with
         the molecular dynamics simulation.

         Variables:
            * **Frequency** (*int** | **IntKey*) -- Run the fbMC
              procedure every Frequency MD steps.

            * **MassRoot** (*float** | **FloatKey*) -- Inverse of the
              exponent used to mass-weight fbMC steps.

            * **NSteps** (*int** | **IntKey*) -- Number of fbMC steps
              to perform on every invocation of the procedure.

            * **PrintFreq** (*int** | **IntKey*) -- Print current
              thermodynamic properties to the output every N fbMC
              steps. This defaults to the PrintFreq set in the
              Trajectory block. Setting this to zero disables printing
              fbMC steps.

            * **StartStep** (*int** | **IntKey*) -- First step at
              which the fbMC procedure may run.

            * **StepLength** (*float** | **FloatKey*) -- Maximum
              allowed displacement of the lightest atom in the system
              in each Cartesian coordinate in one fbMC step.

            * **StopStep** (*int** | **IntKey*) -- Last step at which
              the fbMC procedure may run. If unset or zero, there is
              no limit.

            * **Temperature** (*float** | **FloatKey*) -- Temperature
              used for fbMC.

            * **MolecularMoves** (*SimpleActiveLearning._MolecularDyn
              amics._fbMC._MolecularMoves*) -- Move molecules as rigid
              bodies in addition to normal atomic moves.

         class _MolecularMoves

            Move molecules as rigid bodies in addition to normal
            atomic moves.

            Variables:
               * **Enabled** (*BoolType** | **BoolKey*) -- Enable
                 moving molecules as rigid bodies based on net forces
                 and torques. Ordinary per-atom displacements will
                 then be based on residual atomic forces.

               * **RotationMethod** (*Literal**[**"Mees"**,
                 **"Rao"**]*) -- Select the fbMC method used to
                 generate molecular rotation moves.

               * **RotationStepAngle** (*float** | **FloatKey*) --
                 Maximum allowed angle of rotation of each molecule in
                 one fbMC step.

               * **TranslationStepLength** (*float** | **FloatKey*) --
                 Maximum allowed displacement of each molecule in each
                 Cartesian coordinate in one fbMC step.

   class _ParallelLevels

      Distribution of threads/processes between the parallelization
      levels.

      Variables:
         * **CommitteeMembers** (*int** | **IntKey*) -- Maximum number
           of committee member optimizations to run in parallel. If
           set to zero will take the minimum of
           MachineLearning%CommitteeSize and the number of available
           cores (NSCM)

         * **Cores** (*int** | **IntKey*) -- Number of cores to use
           per committee member optimization. By default (0) the
           available cores (NSCM) divided equally among committee
           members. When using GPU offloading, consider setting this
           to 1.

         * **Jobs** (*int** | **IntKey*) -- Number of JobCollection
           jobs to run in parallel for each loss function evaluation.

         * **Optimizations** (*int** | **IntKey*) -- Number of
           independent optimizers to run in parallel.

         * **ParameterVectors** (*int** | **IntKey*) --

           Number of parameter vectors to try in parallel for each
           optimizer iteration. This level of parallelism can only be
           used with optimizers that support parallel optimization!

           Default (0) will set this value to the number of cores on
           the system divided by the number of optimizers run in
           parallel, i.e., each optimizer will be given an equal share
           of the resources.

         * **Processes** (*int** | **IntKey*) --

           Number of processes (MPI ranks) to spawn for each
           JobCollection job. This effectively sets the NSCM
           environment variable for each job.

           A value of *-1* will disable explicit setting of related
           variables. We recommend a value of *1* in almost all cases.
           A value greater than 1 would only be useful if you
           parametrize DFTB with a serial optimizer and have very few
           jobs in the job collection.

         * **Threads** (*int** | **IntKey*) --

           Number of threads to use for each of the processes. This
           effectively set the OMP_NUM_THREADS environment variable.
           Note that the DFTB engine does not use threads, so the
           value of this variable would not have any effect. We
           recommend always leaving it at the default value of 1.
           Please consult the manual of the engine you are
           parameterizing.

           A value of *-1* will disable explicit setting of related
           variables.

   class _System

      Specification of the chemical system. For some applications more
      than one system may be present in the input. In this case, all
      systems except one must have a non-empty string ID specified
      after the System keyword. The system without an ID is considered
      the main one.

      Variables:
         * **AllowCloseAtoms** (*BoolType** | **BoolKey*) -- No longer
           functional. Just here for backwards compatibility.

         * **Charge** (*float** | **FloatKey*) -- The system's total
           charge in atomic units.

         * **FractionalCoords** (*BoolType** | **BoolKey*) -- Whether
           the atomic coordinates in the Atoms block are given in
           fractional coordinates of the lattice vectors. Requires the
           presence of the Lattice block.

         * **GeometryFile** (*str** | **Path** | **StringKey*) -- Read
           the geometry from a file (instead of from Atoms and Lattice
           blocks). Supported formats: .xyz

         * **GuessBonds** (*BoolType** | **BoolKey*) -- Equivalent to
           'Modify%GuessBonds'. Please update input file to use
           'Modify' block instead.

         * **LatticeStrain** (*Iterable**[**float**] **|
           **FloatListKey*) -- Equivalent to 'Modify%LatticeStrain'.
           Please update input file to use 'Modify' block instead.

         * **MapAtomsToUnitCell** (*BoolType** | **BoolKey*) --
           Equivalent to 'Modify%MapAtomsToUnitCell'. Please update
           input file to use 'Modify' block instead.

         * **PerturbCoordinates** (*float** | **FloatKey*) --
           Equivalent to 'Modify%PerturbCoordinates'. Please update
           input file to use 'Modify' block instead.

         * **PerturbLattice** (*float** | **FloatKey*) -- Equivalent
           to 'Modify%PerturbLattice'. Please update input file to use
           'Modify' block instead.

         * **ShiftCoordinates** (*Iterable**[**float**] **|
           **FloatListKey*) -- Equivalent to 'Modify%Translate', but
           in the unit of bohr by default. Please update input file to
           use 'Modify' block instead.

         * **SuperCell** (*Iterable**[**int**] **| **IntListKey*) --
           Equivalent to 'Modify%SuperCell'. Please update input file
           to use 'Modify' block instead.

         * **SuperCellTrafo** (*Iterable**[**int**] **| **IntListKey*)
           -- Equivalent to 'Modify%SuperCellTrafo'. Please update
           input file to use 'Modify' block instead.

         * **Symmetrize** (*BoolType** | **BoolKey*) -- Equivalent to
           'Modify%Symmetrize'. Please update input file to use
           'Modify' block instead.

         * **Atoms** (*str** | **Sequence**[**str**] **| **FreeBlock*)
           -- The atom types and coordinates. Unit can be specified in
           the header. Default unit is Angstrom.

         * **BondOrders** (*str** | **Sequence**[**str**] **|
           **FreeBlock*) -- Defined bond orders. Each line should
           contain two atom indices, followed by the bond order (1,
           1.5, 2, 3 for single, aromatic, double and triple bonds)
           and (optionally) the cell shifts for periodic systems. May
           be used by MM engines and for defining constraints. If the
           system is periodic and none of the bonds have the cell
           shift defined then AMS will attempt to determine them
           following the minimum image convention.

         * **ElectrostaticEmbedding**
           (*SimpleActiveLearning._System._ElectrostaticEmbedding*) --
           Container for electrostatic embedding options, which can be
           combined.

         * **Lattice** (*str** | **Sequence**[**str**] **|
           **FreeBlock*) -- Up to three lattice vectors. Unit can be
           specified in the header. Default unit is Angstrom.

         * **Modify** (*SimpleActiveLearning._System._Modify*) --
           Modifications to make to the chemical system after
           construction. This block is read like a script and the
           modifications applied top to bottom.

      class _Atoms

         The atom types and coordinates. Unit can be specified in the
         header. Default unit is Angstrom.

      class _BondOrders

         Defined bond orders. Each line should contain two atom
         indices, followed by the bond order (1, 1.5, 2, 3 for single,
         aromatic, double and triple bonds) and (optionally) the cell
         shifts for periodic systems. May be used by MM engines and
         for defining constraints. If the system is periodic and none
         of the bonds have the cell shift defined then AMS will
         attempt to determine them following the minimum image
         convention.

      class _ElectrostaticEmbedding

         Container for electrostatic embedding options, which can be
         combined.

         Variables:
            * **ElectricField** (*Iterable**[**float**] **|
              **FloatListKey*) --

              External homogeneous electric field with three Cartesian
              components: ex, ey, ez, the default unit being V/Å.

              In atomic units: Hartree/(e bohr) = 51.422 V/Angstrom;
              the relation to SI units is: 1 Hartree/(e bohr) = 5.14
              ... e11 V/m.

              Supported by the engines adf, band, dftb and mopac.

              For periodic systems the field may only have nonzero
              components orthogonal to the direction(s) of periodicity
              (i.e. for 1D periodic system the x-component of the
              electric field should be zero, while for 2D periodic
              systems both the x and y components should be zero. This
              options cannot be used for 3D periodic systems.

            * **MultipolePotential** (*SimpleActiveLearning._System._
              ElectrostaticEmbedding._MultipolePotential*) -- External
              point charges (and dipoles).

         class _MultipolePotential

            External point charges (and dipoles).

            Variables:
               * **ChargeModel** (*Literal**[**"Point"**,
                 **"Gaussian"**]*) -- A multipole may be represented
                 by a point (with a singular potential at its
                 location) or by a spherical Gaussian distribution.

               * **ChargeWidth** (*float** | **FloatKey*) -- The width
                 parameter in a.u. in case a Gaussian charge model is
                 chosen. A negative value means that the width will be
                 chosen automatically.

               * **Coordinates** (*str** | **Sequence**[**str**] **|
                 **FreeBlock*) --

                 Positions and values of the multipoles, one per line.
                 Each line has the following format:

                 x y z q, or x y z q µx µy µz.

                 Here x, y, z are the coordinates in Å, q is the
                 charge (in atomic units of charge) and µx, µy, µz are
                 the (optional) dipole moment components (in atomic
                 units, i.e. e*Bohr).

                 Periodic systems are not supported.

            class _Coordinates

               Positions and values of the multipoles, one per line.
               Each line has the following format:

               x y z q, or x y z q µx µy µz.

               Here x, y, z are the coordinates in Å, q is the charge
               (in atomic units of charge) and µx, µy, µz are the
               (optional) dipole moment components (in atomic units,
               i.e. e*Bohr).

               Periodic systems are not supported.

      class _Lattice

         Up to three lattice vectors. Unit can be specified in the
         header. Default unit is Angstrom.

      class _Modify

         Modifications to make to the chemical system after
         construction. This block is read like a script and the
         modifications applied top to bottom.

         Variables:
            * **EnableAtomAttributes** (*Literal**[**"gui"**,
              **"adf"**, **"band"**, **"forcefield"**, **"dftb"**,
              **"reaxff"**, **"qe"**]*) -- Enables an atomic attribute
              group. This is only necessary if you want a group
              enabled, but no atom in the input is using any attribute
              from that group.

            * **GuessBonds** (*BoolType** | **BoolKey*) -- Guesses
              bonds based on the atomic elements and the geometry.
              Keeps existing bonds.

            * **LatticeStrain** (*Iterable**[**float**] **|
              **FloatListKey*) -- Deform the input system by the
              specified strain. The strain elements are in Voigt
              notation, so one should specify 6 numbers for 3D
              periodic system (order: xx,yy,zz,yz,xz,xy), 3 numbers
              for 2D periodic systems (order: xx,yy,xy) or 1 number
              for 1D periodic systems.

            * **MapAtomsToUnitCell** (*Iterable**[**float**] **|
              **FloatListKey*) -- For periodic systems the atoms will
              be moved to the central unit cell where all their
              fractional coordinates are in the range
              [start_range,start_range+1). No mapping will take place
              along non-periodic directions. If just a single number
              is given, it corresponds to start_range. If multiple
              numbers are given, they should match the number of
              lattice vectors and will be used as start ranges along
              the individual lattice vectors. If no number is given at
              all, the mapping will be done to the [-0.5:0.5) cell.

            * **PerturbCoordinates** (*float** | **FloatKey*) --
              Perturb the atomic coordinates by adding random numbers
              between [-PerturbCoordinates,PerturbCoordinates] to each
              Cartesian component. This can be useful if you want to
              break the symmetry of your system (e.g. for a geometry
              optimization).

            * **PerturbLattice** (*float** | **FloatKey*) -- Perturb
              the lattice vectors by applying random strain with
              matrix elements between
              [-PerturbLattice,PerturbLattice]. This can be useful if
              you want to deviate from an ideal symmetric geometry,
              for example if you look for a phase change due to high
              pressure.

            * **SuperCell** (*Iterable**[**int**] **| **IntListKey*)
              -- Create a supercell of the input system (only possible
              for periodic systems). The integer numbers represent the
              diagonal elements of the supercell transformation; you
              should specify as many numbers as lattice vectors (i.e.
              1 number for 1D, 2 numbers for 2D and 3 numbers for 3D
              periodic systems).

            * **SuperCellTrafo** (*Iterable**[**int**] **|
              **IntListKey*) -- Create a supercell of the input system
              (only possible for periodic systems) \vec{a}_i' = \sum_j
              T_{ij} \vec{a}_j. The integer numbers represent the
              supercell transformation T_{ij}: 1 number for 1D PBC, 4
              numbers for 2D PBC corresponding to a 2x2 matrix (order:
              (1,1),(1,2),(2,1),(2,2)) and 9 numbers for 3D PBC
              corresponding to a 3x3 matrix (order:
              (1,1),(1,2),(1,3),(2,1),(2,2),(2,3),(3,1),(3,2),(3,3)).

            * **Symmetrize** (*BoolType** | **BoolKey*) -- Symmetrizes
              a system, using either the "symmetrize_molecule" or
              "symmetrize_cell" method, depending on periodicity.

            * **SymmetrizeMoleculeTo** (*str** | **StringKey*) --
              Symmetrizes a molecule to a particular symmetry given by
              a Schoenflies symbol. Symmetrizes the atomic coordinates
              to machine precision, but does NOT rototranslate the
              molecule in any way. If the symmetrization fails, an
              error will be raised.

            * **Translate** (*Iterable**[**float**] **|
              **FloatListKey*) -- Translate all atoms by a vector.

class Symmetrize

   Variables:
      * **LoadSystem** (*Symmetrize._LoadSystem*) -- Block that
        controls reading the chemical system from a KF file instead of
        the [System] block.

      * **Symmetry** (*Symmetrize._Symmetry*) -- Specifying details
        about the details of symmetry detection and usage.

      * **System** (*Symmetrize._System*) -- Specification of the
        chemical system. For some applications more than one system
        may be present in the input. In this case, all systems except
        one must have a non-empty string ID specified after the System
        keyword. The system without an ID is considered the main one.

   class _LoadSystem

      Block that controls reading the chemical system from a KF file
      instead of the [System] block.

      Variables:
         * **File** (*str** | **Path** | **StringKey*) -- The path of
           the KF file from which to load the system. It may also be
           the results directory containing it.

         * **Section** (*str** | **StringKey*) -- The section on the
           KF file from which to load the system.

   class _Symmetry

      Specifying details about the details of symmetry detection and
      usage.

      Variables:
         * **SymmetrizeTolerance** (*float** | **FloatKey*) --
           Tolerance used to detect symmetry in case symmetrize is
           requested.

         * **Tolerance** (*float** | **FloatKey*) -- Tolerance used to
           detect symmetry in the system.

   class _System

      Specification of the chemical system. For some applications more
      than one system may be present in the input. In this case, all
      systems except one must have a non-empty string ID specified
      after the System keyword. The system without an ID is considered
      the main one.

      Variables:
         * **AllowCloseAtoms** (*BoolType** | **BoolKey*) -- No longer
           functional. Just here for backwards compatibility.

         * **Charge** (*float** | **FloatKey*) -- The system's total
           charge in atomic units.

         * **FractionalCoords** (*BoolType** | **BoolKey*) -- Whether
           the atomic coordinates in the Atoms block are given in
           fractional coordinates of the lattice vectors. Requires the
           presence of the Lattice block.

         * **GeometryFile** (*str** | **Path** | **StringKey*) -- Read
           the geometry from a file (instead of from Atoms and Lattice
           blocks). Supported formats: .xyz

         * **GuessBonds** (*BoolType** | **BoolKey*) -- Equivalent to
           'Modify%GuessBonds'. Please update input file to use
           'Modify' block instead.

         * **LatticeStrain** (*Iterable**[**float**] **|
           **FloatListKey*) -- Equivalent to 'Modify%LatticeStrain'.
           Please update input file to use 'Modify' block instead.

         * **MapAtomsToUnitCell** (*BoolType** | **BoolKey*) --
           Equivalent to 'Modify%MapAtomsToUnitCell'. Please update
           input file to use 'Modify' block instead.

         * **PerturbCoordinates** (*float** | **FloatKey*) --
           Equivalent to 'Modify%PerturbCoordinates'. Please update
           input file to use 'Modify' block instead.

         * **PerturbLattice** (*float** | **FloatKey*) -- Equivalent
           to 'Modify%PerturbLattice'. Please update input file to use
           'Modify' block instead.

         * **ShiftCoordinates** (*Iterable**[**float**] **|
           **FloatListKey*) -- Equivalent to 'Modify%Translate', but
           in the unit of bohr by default. Please update input file to
           use 'Modify' block instead.

         * **SuperCell** (*Iterable**[**int**] **| **IntListKey*) --
           Equivalent to 'Modify%SuperCell'. Please update input file
           to use 'Modify' block instead.

         * **SuperCellTrafo** (*Iterable**[**int**] **| **IntListKey*)
           -- Equivalent to 'Modify%SuperCellTrafo'. Please update
           input file to use 'Modify' block instead.

         * **Symmetrize** (*BoolType** | **BoolKey*) -- Equivalent to
           'Modify%Symmetrize'. Please update input file to use
           'Modify' block instead.

         * **Atoms** (*str** | **Sequence**[**str**] **| **FreeBlock*)
           -- The atom types and coordinates. Unit can be specified in
           the header. Default unit is Angstrom.

         * **BondOrders** (*str** | **Sequence**[**str**] **|
           **FreeBlock*) -- Defined bond orders. Each line should
           contain two atom indices, followed by the bond order (1,
           1.5, 2, 3 for single, aromatic, double and triple bonds)
           and (optionally) the cell shifts for periodic systems. May
           be used by MM engines and for defining constraints. If the
           system is periodic and none of the bonds have the cell
           shift defined then AMS will attempt to determine them
           following the minimum image convention.

         * **ElectrostaticEmbedding**
           (*Symmetrize._System._ElectrostaticEmbedding*) -- Container
           for electrostatic embedding options, which can be combined.

         * **Lattice** (*str** | **Sequence**[**str**] **|
           **FreeBlock*) -- Up to three lattice vectors. Unit can be
           specified in the header. Default unit is Angstrom.

         * **Modify** (*Symmetrize._System._Modify*) -- Modifications
           to make to the chemical system after construction. This
           block is read like a script and the modifications applied
           top to bottom.

      class _Atoms

         The atom types and coordinates. Unit can be specified in the
         header. Default unit is Angstrom.

      class _BondOrders

         Defined bond orders. Each line should contain two atom
         indices, followed by the bond order (1, 1.5, 2, 3 for single,
         aromatic, double and triple bonds) and (optionally) the cell
         shifts for periodic systems. May be used by MM engines and
         for defining constraints. If the system is periodic and none
         of the bonds have the cell shift defined then AMS will
         attempt to determine them following the minimum image
         convention.

      class _ElectrostaticEmbedding

         Container for electrostatic embedding options, which can be
         combined.

         Variables:
            * **ElectricField** (*Iterable**[**float**] **|
              **FloatListKey*) --

              External homogeneous electric field with three Cartesian
              components: ex, ey, ez, the default unit being V/Å.

              In atomic units: Hartree/(e bohr) = 51.422 V/Angstrom;
              the relation to SI units is: 1 Hartree/(e bohr) = 5.14
              ... e11 V/m.

              Supported by the engines adf, band, dftb and mopac.

              For periodic systems the field may only have nonzero
              components orthogonal to the direction(s) of periodicity
              (i.e. for 1D periodic system the x-component of the
              electric field should be zero, while for 2D periodic
              systems both the x and y components should be zero. This
              options cannot be used for 3D periodic systems.

            * **MultipolePotential** (*Symmetrize._System._Electrosta
              ticEmbedding._MultipolePotential*) -- External point
              charges (and dipoles).

         class _MultipolePotential

            External point charges (and dipoles).

            Variables:
               * **ChargeModel** (*Literal**[**"Point"**,
                 **"Gaussian"**]*) -- A multipole may be represented
                 by a point (with a singular potential at its
                 location) or by a spherical Gaussian distribution.

               * **ChargeWidth** (*float** | **FloatKey*) -- The width
                 parameter in a.u. in case a Gaussian charge model is
                 chosen. A negative value means that the width will be
                 chosen automatically.

               * **Coordinates** (*str** | **Sequence**[**str**] **|
                 **FreeBlock*) --

                 Positions and values of the multipoles, one per line.
                 Each line has the following format:

                 x y z q, or x y z q µx µy µz.

                 Here x, y, z are the coordinates in Å, q is the
                 charge (in atomic units of charge) and µx, µy, µz are
                 the (optional) dipole moment components (in atomic
                 units, i.e. e*Bohr).

                 Periodic systems are not supported.

            class _Coordinates

               Positions and values of the multipoles, one per line.
               Each line has the following format:

               x y z q, or x y z q µx µy µz.

               Here x, y, z are the coordinates in Å, q is the charge
               (in atomic units of charge) and µx, µy, µz are the
               (optional) dipole moment components (in atomic units,
               i.e. e*Bohr).

               Periodic systems are not supported.

      class _Lattice

         Up to three lattice vectors. Unit can be specified in the
         header. Default unit is Angstrom.

      class _Modify

         Modifications to make to the chemical system after
         construction. This block is read like a script and the
         modifications applied top to bottom.

         Variables:
            * **EnableAtomAttributes** (*Literal**[**"gui"**,
              **"adf"**, **"band"**, **"forcefield"**, **"dftb"**,
              **"reaxff"**, **"qe"**]*) -- Enables an atomic attribute
              group. This is only necessary if you want a group
              enabled, but no atom in the input is using any attribute
              from that group.

            * **GuessBonds** (*BoolType** | **BoolKey*) -- Guesses
              bonds based on the atomic elements and the geometry.
              Keeps existing bonds.

            * **LatticeStrain** (*Iterable**[**float**] **|
              **FloatListKey*) -- Deform the input system by the
              specified strain. The strain elements are in Voigt
              notation, so one should specify 6 numbers for 3D
              periodic system (order: xx,yy,zz,yz,xz,xy), 3 numbers
              for 2D periodic systems (order: xx,yy,xy) or 1 number
              for 1D periodic systems.

            * **MapAtomsToUnitCell** (*Iterable**[**float**] **|
              **FloatListKey*) -- For periodic systems the atoms will
              be moved to the central unit cell where all their
              fractional coordinates are in the range
              [start_range,start_range+1). No mapping will take place
              along non-periodic directions. If just a single number
              is given, it corresponds to start_range. If multiple
              numbers are given, they should match the number of
              lattice vectors and will be used as start ranges along
              the individual lattice vectors. If no number is given at
              all, the mapping will be done to the [-0.5:0.5) cell.

            * **PerturbCoordinates** (*float** | **FloatKey*) --
              Perturb the atomic coordinates by adding random numbers
              between [-PerturbCoordinates,PerturbCoordinates] to each
              Cartesian component. This can be useful if you want to
              break the symmetry of your system (e.g. for a geometry
              optimization).

            * **PerturbLattice** (*float** | **FloatKey*) -- Perturb
              the lattice vectors by applying random strain with
              matrix elements between
              [-PerturbLattice,PerturbLattice]. This can be useful if
              you want to deviate from an ideal symmetric geometry,
              for example if you look for a phase change due to high
              pressure.

            * **SuperCell** (*Iterable**[**int**] **| **IntListKey*)
              -- Create a supercell of the input system (only possible
              for periodic systems). The integer numbers represent the
              diagonal elements of the supercell transformation; you
              should specify as many numbers as lattice vectors (i.e.
              1 number for 1D, 2 numbers for 2D and 3 numbers for 3D
              periodic systems).

            * **SuperCellTrafo** (*Iterable**[**int**] **|
              **IntListKey*) -- Create a supercell of the input system
              (only possible for periodic systems) \vec{a}_i' = \sum_j
              T_{ij} \vec{a}_j. The integer numbers represent the
              supercell transformation T_{ij}: 1 number for 1D PBC, 4
              numbers for 2D PBC corresponding to a 2x2 matrix (order:
              (1,1),(1,2),(2,1),(2,2)) and 9 numbers for 3D PBC
              corresponding to a 3x3 matrix (order:
              (1,1),(1,2),(1,3),(2,1),(2,2),(2,3),(3,1),(3,2),(3,3)).

            * **Symmetrize** (*BoolType** | **BoolKey*) -- Symmetrizes
              a system, using either the "symmetrize_molecule" or
              "symmetrize_cell" method, depending on periodicity.

            * **SymmetrizeMoleculeTo** (*str** | **StringKey*) --
              Symmetrizes a molecule to a particular symmetry given by
              a Schoenflies symbol. Symmetrizes the atomic coordinates
              to machine precision, but does NOT rototranslate the
              molecule in any way. If the symmetrization fails, an
              error will be raised.

            * **Translate** (*Iterable**[**float**] **|
              **FloatListKey*) -- Translate all atoms by a vector.


3.1.2. Engines
--------------

class ADF

   Variables:
      * **A1Fit** (*float** | **FloatKey*) -- STO-Fit keyword:
        distance between atoms, in Angstrom. The symmetric fit
        approximation is applied only for atoms farther apart.

      * **AOMat2File** (*BoolType** | **BoolKey*) -- Write PMatrix,
        Fock matrix, and overlap matrix on AO basis to file for future
        analysis purposes

      * **AORCOnly** (*BoolType** | **BoolKey*) -- Debug option
        AOResponse.

      * **AORXCOnly** (*BoolType** | **BoolKey*) -- Debug option
        AOResponse.

      * **AORun** (*BoolType** | **BoolKey*) -- Expert option not to
        write orbitals to file for TDDFT.

      * **AccurateGradients** (*BoolType** | **BoolKey*) -- Print the
        nuclear gradients with more digits than usual.

      * **AddDiffuseFit** (*BoolType** | **BoolKey*) -- STO-Fit
        keyword: One can get more diffuse fit functions by setting
        this to True.

      * **AllDipMat** (*BoolType** | **BoolKey*) -- Print all dipole
        matrix elements between occupied and virtual Kohn-Sham
        orbitals.

      * **AllPoints** (*BoolType** | **BoolKey*) -- 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.

      * **AllWaals** (*BoolType** | **BoolKey*) -- Expert to write all
        van der Waals tensors in Response..

      * **Allow** (*str** | **StringKey*) -- Controlled aborts can in
        some cases be overruled. Of course, the checks have been
        inserted for good reasons and one should realize that ignoring
        them probably produces incorrect results or may lead to a
        program-crash.

      * **AltLinVXC** (*BoolType** | **BoolKey*) --

      * **AltOrthon** (*BoolType** | **BoolKey*) -- Expert option for
        alternative orthogonalization.

      * **AltRhof** (*BoolType** | **BoolKey*) -- Expert option for
        Response.

      * **AtomicChargesTypeForAMS** (*Literal**[**"Mulliken"**,
        **"Hirshfeld"**, **"CM5"**, **"Voronoi"**, **"MDC-M"**,
        **"MDC-D"**, **"MDC-Q"**, **"QTAIM"**, **"ESP-CHELPG"**,
        **"ESP-RESP"**]*) --

        Type of atomic charges to be used by AMS.

        Note that some of these atomic charges are computed and
        printed by default in ADF.

        Hirshfeld charges are available only for default atomic
        fragments.

      * **Balance** (*BoolType** | **BoolKey*) -- Measure the actual
        speed of the nodes in the parallel machine

      * **BasValZero** (*BoolType** | **BoolKey*) -- Debug option

      * **Blapt** (*BoolType** | **BoolKey*) -- Debug option for
        calculating post-SCF functional.

      * **BoysOld** (*BoolType** | **BoolKey*) -- Option for
        localizing orbitals using old scheme.

      * **C2Coef** (*BoolType** | **BoolKey*) -- Print C2Coef to
        output

      * **CM5** (*BoolType** | **BoolKey*) -- Calculate the charge
        model 5 (CM5) analysis.

      * **CalcOverlapOnly** (*BoolType** | **BoolKey*) -- Calculate
        overlaps of primitive basis and stops after computing them.

      * **CalcTotalEnergy** (*BoolType** | **BoolKey*) -- Whether or
        not to calculate the total energy.

      * **ChkDisFal** (*BoolType** | **BoolKey*) -- Debug option not
        to ise distance effects, probably not working correct anymore.

      * **ColTDDFT** (*BoolType** | **BoolKey*) -- Debug option to see
        the effect of a collinear kernel TDDFT in case of spin-orbit
        coupling

      * **CommTiming** (*BoolType** | **BoolKey*) -- Only perform
        parallel timing test on the gather, broadcast and combine
        routines.

      * **ComplexAcl** (*BoolType** | **BoolKey*) -- Expert key for
        AOresponse spin-orbit coupled.

      * **CoreTables** (*BoolType** | **BoolKey*) -- Undocumented and
        unused option for using CoreTables.

      * **CoulombFit** (*BoolType** | **BoolKey*) -- Undocumented and
        unused option for using old HF exchange integrals also for
        Coulomb.

      * **Create** (*str** | **StringKey*) -- Keywords for create run.
        {Atomtype Datafile}

      * **DRho241** (*BoolType** | **BoolKey*) -- Debug key for
        Response.

      * **Debug** (*str** | **StringKey*) -- The amount of printed
        output is regulated with the keys Print, NoPrint, EPrint and
        Debug.

      * **DeltaEpStrip** (*BoolType** | **BoolKey*) -- TDDFT
        Excitations expert key.

      * **DensPrep** (*BoolType** | **BoolKey*) -- Undocumented option
        for FDE for sum-of-fragments density in SCF.

      * **Diffuse** (*BoolType** | **BoolKey*) -- Adding diffuse
        integration points in case of the old Voronoi numerical
        integration grid.

      * **DipoleLength** (*BoolType** | **BoolKey*) -- Use dipole-
        length elements for perturbing (external) integrals in CURRENT
        response

      * **DipoleResponse** (*BoolType** | **BoolKey*) --

      * **DumpBasisOnly** (*BoolType** | **BoolKey*) -- Dump basis and
        fit set files use for each atom.

      * **EGOXAlpha** (*BoolType** | **BoolKey*) -- Debug key for
        excited GO in excitations.

      * **ESP-CHELPG** (*BoolType** | **BoolKey*) -- Calculate the
        ESP-CHELPG atomic charges.

      * **ESP-RESP** (*BoolType** | **BoolKey*) -- Calculate the ESP-
        RESP atomic charges.

      * **EnergyTest** (*BoolType** | **BoolKey*) -- Expert key for
        total energy.

      * **ExactDensity** (*BoolType** | **BoolKey*) -- Use the exact
        density (as opposed to the fitted density) for the computation
        of the exchange-correlation potential

      * **ExtendedPopan** (*BoolType** | **BoolKey*) -- Calculate the
        Mayer bond orders and Mulliken atom-atom populations per
        l-value

      * **FitAlfa** (*BoolType** | **BoolKey*) -- Debug key for
        Response.

      * **FitExcit** (*BoolType** | **BoolKey*) --

      * **FitFile** (*str** | **StringKey*) -- Only to be used in
        Create runs for STOFIT. Specify a file on which the fit
        functions are specified.

      * **Fitelstat** (*BoolType** | **BoolKey*) -- In energy
        decomposition analysis use fitted density for electrostatic
        energy.

      * **Fithyppol** (*BoolType** | **BoolKey*) -- Use fitted density
        in TDDFT for hyperpolarizability calculation.

      * **Fitmeta** (*BoolType** | **BoolKey*) -- SCF: use fitted
        density for post-SCF meta-GGA functionals.

      * **Fitsecder** (*BoolType** | **BoolKey*) -- SCF: use fitted
        density for second derivative density.

      * **ForceALDA** (*BoolType** | **BoolKey*) -- 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

      * **FragMetaGGAToten** (*BoolType** | **BoolKey*) -- 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.

      * **FullFock** (*BoolType** | **BoolKey*) -- Calculate the full
        Fock matrix each SCF iteration (instead of the difference with
        the previous cycle).

      * **FullTotEn** (*BoolType** | **BoolKey*) --

      * **Fuzzy_BO** (*BoolType** | **BoolKey*) --

      * **GZip** (*str** | **StringKey*) -- GZip the corresponding
        tape (possibly working only for TAPE21)

      * **Gradient** (*BoolType** | **BoolKey*) --

        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.

      * **HFAtomsPerPass** (*int** | **IntKey*) -- Memory usage option
        for old HF scheme

      * **HFDependency** (*BoolType** | **BoolKey*) -- Extra
        Dependency trick for old Hartree-Fock exchange integrals.

      * **HFMaxMemory** (*int** | **IntKey*) -- Memory usage option
        for old HF scheme

      * **HartreeFock** (*BoolType** | **BoolKey*) -- Compute hybrid
        meta-GGA energy functionals (if METAGGA key is True)

      * **Hilbert** (*BoolType** | **BoolKey*) -- Option for
        localization of numerical integration points.

      * **IgnoreOverlap** (*BoolType** | **BoolKey*) -- Expert option.
        Ignore that atoms are close.

      * **ImportEmbPot** (*str** | **StringKey*) -- File containing an
        external embedding potential (FDE calculations only)

      * **ImportGrid** (*str** | **StringKey*) -- FDE option for
        importing numerical integration grid.

      * **IntegralsToFile** (*Literal**[**"None"**, **"FCIdump"**,
        **"Dirac"**, **"SERENITY"**]*) -- Write all 4-center integrals
        to direct access file (DIRAC). or in FCIdump/Serenity format.
        Default is None

      * **IsotopicShift** (*str** | **StringKey*) -- Untested

      * **KSSpectrum** (*BoolType** | **BoolKey*) -- Old key. TDDFT
        excitations, calculate single-orbital transitions.

      * **LB4** (*BoolType** | **BoolKey*) -- Debug option for
        unrestricted spin-orbit coupling.

      * **Lap1** (*BoolType** | **BoolKey*) -- Debug option for
        calculating post-SCF functional.

      * **MBlockSmall** (*BoolType** | **BoolKey*) -- For TDDFT
        excitations with Davidson: Option to use only 1 extra trial
        vector at a time.

      * **MOExactDensity** (*BoolType** | **BoolKey*) -- In SCF use
        exact density for MOs.

      * **MetaGGA** (*BoolType** | **BoolKey*) --

      * **NewDIIS** (*BoolType** | **BoolKey*) -- For old SCF routine:
        use newDIIS.

      * **NoBeckeGrid** (*BoolType** | **BoolKey*) -- If true ADF will
        use the Voronoi numerical integration grid.

      * **NoFDEPot** (*BoolType** | **BoolKey*) -- Expert FDE option.

      * **NoFragDp** (*BoolType** | **BoolKey*) -- Debug option for
        orthogonalization and dependency.

      * **NoGTerm** (*BoolType** | **BoolKey*) -- Debug option in
        Response.

      * **NoPrint** (*str** | **StringKey*) -- The amount of printed
        output is regulated with the keys Print, NoPrint, EPrint and
        Debug.

      * **NoSharedArrays** (*BoolType** | **BoolKey*) -- To disable
        the use of shared memory.

      * **NoSymFit** (*BoolType** | **BoolKey*) -- Do not use only an
        A1 symmetric fit.

      * **NoTotEn** (*BoolType** | **BoolKey*) --

      * **NuclearModel** (*Literal**[**"PointCharge"**,
        **"Gaussian"**]*) --

        Model for the nuclear charge distribution.

        To see effects from your choice you will need to use a basis
        set with extra steep functions. For example you can find these
        in the ZORA/TZ2P-J basis directory.

      * **NumericalQuality** (*Literal**[**"Basic"**, **"Normal"**,
        **"Good"**, **"VeryGood"**, **"Excellent"**]*) -- 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')

      * **OPop_Analysis** (*str** | **StringKey*) --

      * **Occupations** (*str** | **StringKey*) -- Occupations options

      * **OrbitalsCoulombInteraction** (*Iterable**[**int**] **|
        **IntListKey*) -- 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).

      * **OrthFragPrep** (*BoolType** | **BoolKey*) -- Expert FDE
        option.

      * **PartialZORA** (*str** | **StringKey*) -- Untested and
        undocumented key to use partial ZORA.

      * **Print** (*str** | **StringKey*) -- The amount of printed
        output is regulated with the keys Print, NoPrint, EPrint and
        Debug.

      * **ProgConv** (*BoolType** | **BoolKey*) -- Use progressive
        convergence in SCF, icw LinearScaling%ProgConv not equal 0.

      * **QTens** (*BoolType** | **BoolKey*) -- Calculate the the
        Nuclear Electric Quadrupole Hyperfine interaction (Q-tensor,
        NQCC, NQI), related to the Electric Field Gradient (EFG).

      * **RConfine** (*Iterable**[**float**] **| **FloatListKey*) --
        Used for making confinement potential in order to make DFTB
        parameters. Obsolete.

      * **RESPPMATSAVE** (*BoolType** | **BoolKey*) -- Needed for
        SubResponse (EO) calculations. Hacked by JN. Restored by
        Pengchong Liu

      * **RESTOCC** (*BoolType** | **BoolKey*) --

      * **RemoveAllFragVirtuals** (*BoolType** | **BoolKey*) -- Remove
        all virtual fragment orbitals.

      * **RemoveOtherFragVirtuals** (*BoolType** | **BoolKey*) --
        Remove all virtual fragment orbitals, except on first
        fragment.

      * **ResponseFormalism** (*Literal**[**"Auto"**, **"Response"**,
        **"AOResponse"**]*) -- Set to RESPONSE or AORESPONSE.

      * **SFTDDFT** (*BoolType** | **BoolKey*) -- Calculate spin-flip
        excitation energies (requires TDA and FORCEALDA keys).

      * **SOMCD** (*BoolType** | **BoolKey*) -- MCD option. Required
        for a calculation of MCD temperature-dependent C terms. The
        calculation must be an unrestricted and scalar relativistic
        ZORA.

      * **STContrib** (*BoolType** | **BoolKey*) -- For an analysis of
        spin-orbit coupled excitations in terms of scalar relativistic
        singlet and triplet excitations. In order to get this analysis
        one needs to perform a scalar relativistic TDDFT calculation
        of excitation energies on the closed shell molecule first, and
        use the resulting adf.rkf as a fragment in the spin-orbit
        coupled TDDFT calculation of excitation energies, including
        this keyword STCONTRIB.

      * **STOFit** (*BoolType** | **BoolKey*) -- Computation of the
        Coulomb potential with the pair fit method.

      * **Save** (*str** | **StringKey*) -- A sequence of file names
        separated by blanks or commas. Possible file names are TAPE10,
        TAPE13, TAPE14.

      * **SharcOverlap** (*BoolType** | **BoolKey*) --

      * **Skip** (*str** | **StringKey*) -- Expert key. To restrict
        which parts of the program are actually executed.

      * **SpinPolarization** (*float** | **FloatKey*) -- The spin
        polarization of the system, which is the number of spin-alpha
        electrons in excess of spin-beta electrons. Specification is
        only meaningful in a spin-unrestricted calculation. However,
        specification is not meaningful in an unrestricted Spin-Orbit
        coupled calculation using the (non-)collinear approximation.

      * **StopAfter** (*str** | **StringKey*) --

      * **Symmetry** (*Literal**[**"AUTO"**, **"NOSYM"**, **"ATOM"**,
        **"C**(**LIN**)**"**, **"D**(**LIN**)**"**,
        **"C**(**I**)**"**, **"C**(**S**)**"**, **"C**(**2**)**"**,
        **"C**(**2V**)**"**, **"C**(**3V**)**"**, **"C**(**4V**)**"**,
        **"C**(**5V**)**"**, **"C**(**6V**)**"**, **"C**(**7V**)**"**,
        **"C**(**8V**)**"**, **"C**(**2H**)**"**, **"D**(**2**)**"**,
        **"D**(**3**)**"**, **"D**(**4**)**"**, **"D**(**5**)**"**,
        **"D**(**6**)**"**, **"D**(**7**)**"**, **"D**(**8**)**"**,
        **"D**(**2D**)**"**, **"D**(**3D**)**"**, **"D**(**4D**)**"**,
        **"D**(**5D**)**"**, **"D**(**6D**)**"**, **"D**(**7D**)**"**,
        **"D**(**8D**)**"**, **"D**(**2H**)**"**, **"D**(**3H**)**"**,
        **"D**(**4H**)**"**, **"D**(**5H**)**"**, **"D**(**6H**)**"**,
        **"D**(**7H**)**"**, **"D**(**8H**)**"**, **"O**(**H**)**"**,
        **"T**(**D**)**"**]*) -- Use (sub)symmetry with this
        Schoenflies symbol. Can only be used for molecules.
        Orientation should be correct for the (sub)symmetry.
        Coordinates must be symmetric within SymmetryTolerance.

      * **SymmetryTolerance** (*float** | **FloatKey*) -- Tolerance
        used to detect symmetry in the system. If symmetry Schoenflies
        symbol is specified, the coordinates must be symmetric within
        this tolerance.

      * **TDA** (*BoolType** | **BoolKey*) -- Use the Tamm-Dancoff
        approximation (TDA) (requires the EXCITATIONS block key)

      * **TDDFTSO** (*BoolType** | **BoolKey*) --

      * **TIDegeneracyThreshold** (*float** | **FloatKey*) -- If the
        orbital energy of the fragment MO is within this threshold
        with fragment HOMO or LUMO energy, then this fragment MO is
        included in the calculation of the transfer integrals.
        Relevant in case there is (near) degeneracy.

      * **Title** (*str** | **StringKey*) -- Title of the calculation.

      * **TotalEnergy** (*BoolType** | **BoolKey*) --

        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.

      * **TransferIntegrals** (*BoolType** | **BoolKey*) --

        Calculate the charge transfer integrals, spatial overlap
        integrals and site energies.

        Charge transfer integrals can be used in models that calculate
        transport properties.

      * **Unrestricted** (*BoolType** | **BoolKey*) -- By default, a
        spin-restricted calculation is performed where the spin alpha
        and spin beta orbitals are spatially the same.

      * **UnrestrictedFragments** (*BoolType** | **BoolKey*) --

        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.

      * **UsePseudoDiag** (*BoolType** | **BoolKey*) -- Expert option
        for diagonalization in SCF.

      * **UseSPCode** (*BoolType** | **BoolKey*) -- Use Patchkovskii
        routines for PBE

      * **VectorLength** (*int** | **IntKey*) -- Specify a different
        batch size for the integration points here (default: 128 on
        most machines and 2047 on vector machines).

      * **ZExact** (*BoolType** | **BoolKey*) -- Expert option in
        TDDFT excitations.

      * **ZFS** (*str** | **StringKey*) -- Calculate the zero-field
        splitting (ZFS) of an open shell ground state. An unrestricted
        calculation is required and a spin larger than 1/2, and no no
        spatial degeneracy. Scalar relativistic ZORA is required.

      * **grad_no_fragment_potentials** (*BoolType** | **BoolKey*) --
        FDE option.

      * **hydrogenbonds** (*BoolType** | **BoolKey*) -- Option for SFO
        population analysis to print small numbers.

      * **nocalcs2** (*BoolType** | **BoolKey*) -- Do not calculate
        expectation value S**2 (spin).

      * **nomorton** (*BoolType** | **BoolKey*) -- Debug option for
        localization of numerical integration points.

      * **nopm5rho** (*BoolType** | **BoolKey*) -- Debug option for
        response.

      * **notstcoe** (*BoolType** | **BoolKey*) -- Option not to test
        orthonormal basis set.

      * **nouseactivefrag** (*BoolType** | **BoolKey*) -- Do not use
        orbital data from active fragment in first cycle SCF.

      * **novkpot** (*BoolType** | **BoolKey*) -- Debug option for
        AOResponse.

      * **noxcprint** (*BoolType** | **BoolKey*) -- Do not print XC
        energy terms.

      * **oldblockedsmat** (*BoolType** | **BoolKey*) -- Use old way
        to calculate overlap matrix.

      * **oldorthon** (*BoolType** | **BoolKey*) -- Use old
        orthogonalization routine.

      * **plap3** (*BoolType** | **BoolKey*) -- Debug option for
        calculating post-SCF functional.

      * **prtallten** (*BoolType** | **BoolKey*) -- Debug option for
        response.

      * **readepsilons** (*BoolType** | **BoolKey*) -- Debug option
        for TDDFT. Read extra orbitals.

      * **rhobelpotimport** (*BoolType** | **BoolKey*) -- Key for FDE-
        MD.

      * **riskyfast** (*BoolType** | **BoolKey*) -- Debug option to
        skip some post-SCF properties, like bond energy.

      * **scaledkinfunctionals** (*BoolType** | **BoolKey*) -- FDE
        option.

      * **sfotrans** (*BoolType** | **BoolKey*) -- Old key for SFO
        analysis TDDFT excitations.

      * **skorthon** (*BoolType** | **BoolKey*) -- Debug option to
        skip ETALOW.

      * **sozero** (*BoolType** | **BoolKey*) -- Debug option to set
        spin-orbit matrix to zero.

      * **switchcoe** (*BoolType** | **BoolKey*) -- Debug option for
        orthogonalization.

      * **symexcit** (*BoolType** | **BoolKey*) -- Debug option for
        TDDFT excitations.

      * **symresp** (*BoolType** | **BoolKey*) -- Debug option for
        TDDFT response.

      * **testsub1** (*BoolType** | **BoolKey*) -- Debug option
        excitations and subexci.

      * **totenskip** (*BoolType** | **BoolKey*) -- Debug option to
        skip toten.

      * **useortp** (*BoolType** | **BoolKey*) -- Use orth density
        matrices instead of previous density matrix.

      * **usesumfragp** (*BoolType** | **BoolKey*) -- Use sum fragment
        density matrices instead of previous density matrix.

      * **xonly** (*BoolType** | **BoolKey*) -- Option for spin-orbit
        coupled AOresponse.

      * **xyonly** (*BoolType** | **BoolKey*) -- Option for spin-orbit
        coupled AOresponse.

      * **xzonly** (*BoolType** | **BoolKey*) -- Option for spin-orbit
        coupled AOresponse.

      * **yonly** (*BoolType** | **BoolKey*) -- Option for spin-orbit
        coupled AOresponse.

      * **yzonly** (*BoolType** | **BoolKey*) -- Option for spin-orbit
        coupled AOresponse.

      * **zonly** (*BoolType** | **BoolKey*) -- Option for spin-orbit
        coupled AOresponse.

      * **AOResponse** (*ADF._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

      * **AnalyticalFreq** (*ADF._AnalyticalFreq*) -- Define options
        for analytical frequencies.

      * **Aromaticity** (*ADF._Aromaticity*) -- Calculate aromaticity
        indicators, i.e. the matrix of localization/delocalization
        indices (LI-DI), Iring (ring index) and MCI (multi center
        index) aromaticity indices.

      * **Basis** (*ADF._Basis*) -- Definition of the basis set

      * **BeckeGrid** (*ADF._BeckeGrid*) -- Options for the numerical
        integration grid.

      * **BondOrders** (*ADF._BondOrders*) -- Options for the
        calculation of bond orders. Note: the calculation of bond
        orders should be requested via the Properties%BondOrders input
        option in the AMS driver input.

      * **CC** (*ADF._CC*) -- Technical aspects of CC methods

      * **CDFT** (*ADF._CDFT*) -- CDFT is a tool for carrying out DFT
        calculations in the presence of a constraint.

      * **CVNDFT** (*ADF._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.

      * **ConceptualDFT** (*ADF._ConceptualDFT*) -- Conceptual DFT
        Properties

      * **ConstructPot** (*ADF._ConstructPot*) -- Reads a density from
        a TAPE41 file and constructs numerically the corresponding
        potential to it

      * **CorePotentials** (*str** | **Sequence**[**str**] **|
        **FreeBlock*) -- With the key COREPOTENTIALS you specify the
        core file and (optionally) which sections pertain to the
        distinct atom types in the molecule.

      * **CurrentResponse** (*ADF._CurrentResponse*) --

      * **DIMPAR** (*str** | **Sequence**[**str**] **| **FreeBlock*)
        -- In this block, the parameters for the DIM atoms are defined
        in DIM/QM calculations.

      * **DIMQM** (*str** | **Sequence**[**str**] **| **FreeBlock*) --
        Input for DIM/QM

      * **Dependency** (*ADF._Dependency*) --

      * **EPrint** (*ADF._EPrint*) -- Print switches that require more
        specification than just off or on

      * **ESR** (*ADF._ESR*) --

      * **ETSNOCV** (*ADF._ETSNOCV*) -- Perform ETS-NOCV analysis.

      * **ElectronTransfer** (*ADF._ElectronTransfer*) -- Block key
        for charge transfer integrals with FDE.

      * **EnergyFrag** (*str** | **Sequence**[**str**] **|
        **FreeBlock*) --

      * **Excitations** (*ADF._Excitations*) -- Excitation energies:
        UV/Vis

      * **ExcitedEDA** (*ADF._ExcitedEDA*) -- Options for excited
        energy decomposition (EDA).

      * **ExcitedGO** (*ADF._ExcitedGO*) -- Excited state geometry
        optimization

      * **ExcitonTransfer** (*ADF._ExcitonTransfer*) -- Block key for
        exciton transfer integrals with ROSE or FOCDFT.

      * **Externals** (*str** | **Sequence**[**str**] **|
        **FreeBlock*) -- Legacy support of the older DRF code.

      * **FDE** (*ADF._FDE*) -- Frozen Density Embedding options

      * **FDEFragments** (*str** | **Sequence**[**str**] **|
        **FreeBlock*) -- Definitions of the FDE fragment types.

      * **FOCDFT** (*ADF._FOCDFT*) -- Localize orbitals on fragments
        and constrain charge and spin polarization on fragments.

      * **Fitnadkin** (*str** | **Sequence**[**str**] **|
        **FreeBlock*) -- FDE option.

      * **FragOccupations** (*str** | **Sequence**[**str**] **|
        **FreeBlock*) -- Simulation of unrestricted fragments with the
        key FRAGOCCUPATIONS. Fragments need to be calculated spin-
        restricted. One can specify occupation numbers as if these
        fragments are calculated spin-unrestricted. The sum of spin-
        alpha and spin-beta occupations must, for each fragment
        orbital in each irrep separately, be equal to the total spin-
        restricted occupation of that orbital in the fragment.

      * **Fragments** (*str** | **Sequence**[**str**] **|
        **FreeBlock*) -- Definitions of the fragment type/files:
        {FragmentName FragmentFile}. In the block header one can
        specify the directory where the fragment files are located

      * **GPU** (*ADF._GPU*) -- Set GPU options

      * **GW** (*ADF._GW*) -- Perform a GW calculation. G0W0 is the
        default for GW%SelfConsistency.

      * **IQA** (*ADF._IQA*) -- Total energy decomposition based on
        the interacting quantum atoms (IQA) approach and using QTAIM
        real-space partition.

      * **Integration** (*ADF._Integration*) -- Options for the
        Voronoi numerical integration scheme

      * **IrrepOccupations** (*str** | **Sequence**[**str**] **|
        **FreeBlock*) -- Explicit occupation numbers per irrep

      * **LinearScaling** (*ADF._LinearScaling*) --

      * **LocOrb** (*str** | **Sequence**[**str**] **| **FreeBlock*)
        -- The computation of localized orbitals is controlled with
        this block-type key

      * **MBPT** (*ADF._MBPT*) -- Technical aspects of the MP2
        algorithm.

      * **MDC** (*ADF._MDC*) -- Options for Multipole Derived Charges
        (MDC)

      * **ModifyExcitation** (*ADF._ModifyExcitation*) --

      * **ModifyStartPotential** (*str** | **Sequence**[**str**] **|
        **FreeBlock*) -- Modify the starting spin-dependent potential
        for unrestricted calculations.

      * **Nanoparticle** (*ADF._Nanoparticle*) -- To include the
        presence of a nanoparticle near the system

      * **PertLoc** (*ADF._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.

      * **PolTDDFT** (*ADF._PolTDDFT*) -- POLTDDFT is a fast algorithm
        to solve the TDDFT equations in the space of the density
        fitting auxiliary basis set. The (real and imaginary part of
        the) diagonal of the polarizability tensor and rotatory
        strengths will be calculated, which can be used to calculate
        the photoabsorption and circular dichroism (CD) spectra.

      * **QMFQ** (*ADF._QMFQ*) -- Block input key for QM/(w)FQ(FMu).

      * **QTAIM** (*ADF._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.

      * **RIHartreeFock** (*ADF._RIHartreeFock*) --

      * **RISM** (*str** | **Sequence**[**str**] **| **FreeBlock*) --
        3D-RISM-related input keys.

      * **ROSE** (*ADF._ROSE*) -- Options for orbital localization

      * **RadialCoreGrid** (*ADF._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.

      * **Relativity** (*ADF._Relativity*) -- Options for relativistic
        effects.

      * **RemoveFragOrbitals** (*str** | **Sequence**[**str**] **|
        **FreeBlock*) -- Block key to remove selected virtual fragment
        orbitals.

      * **Response** (*ADF._Response*) -- The calculation of
        frequency-dependent (hyper)polarizabilities and related
        properties (Raman, ORD)

      * **Restart** (*ADF._Restart*) -- Options for restarts

      * **SCF** (*ADF._SCF*) -- Control aspects of the Self Consistent
        Field procedure

      * **SCRF** (*str** | **Sequence**[**str**] **| **FreeBlock*) --
        SCRF is no longer supported. Use AMS2023 or earlier.

      * **SOPert** (*ADF._SOPert*) -- Key for perturbative inclusion
        of spin-orbit coupling.

      * **SelectExcitation** (*ADF._SelectExcitation*) --

      * **SlaterDeterminants** (*str** | **Sequence**[**str**] **|
        **FreeBlock*) -- The calculation of the one-determinant states
        based on the AOC reference state is controlled with this key.

      * **Solvation** (*ADF._Solvation*) --

      * **SpinOrbitMagnetization** (*ADF._SpinOrbitMagnetization*) --
        Starting artificial spin-orbit magnetization at first SCF
        cycle

      * **SubExci** (*ADF._SubExci*) -- Subsystem TDDFT (FDE)

      * **SubResponse** (*str** | **Sequence**[**str**] **|
        **FreeBlock*) -- Untested and undocumented

      * **Tails** (*ADF._Tails*) -- Obsolete option for linear scaling
        and distance effects. We recommend using the LinearScaling key
        instead.

      * **VSCRF** (*str** | **Sequence**[**str**] **| **FreeBlock*) --
        VSCRF is no longer supported. Use AMS2023 or earlier.

      * **XC** (*ADF._XC*) -- Definition of the XC.

      * **XES** (*ADF._XES*) -- X-ray emission spectroscopy

      * **ZlmFit** (*ADF._ZlmFit*) -- Options for the density fitting
        scheme 'ZlmFit'.

   class _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

      Variables:
         * **2ANTISYM** (*BoolType** | **BoolKey*) --

         * **ALDA** (*BoolType** | **BoolKey*) -- Use ALDA only

         * **Alpha** (*BoolType** | **BoolKey*) -- Calculate linear
           response

         * **Beta** (*BoolType** | **BoolKey*) -- Will use 2n+1 rule
           to calculate beta.

         * **CALCTRANSFORMPROP** (*str** | **StringKey*) --
           Transformation Properties of Polarizabilities

         * **CHANGESIGN** (*BoolType** | **BoolKey*) --

         * **Components** (*str** | **StringKey*) -- 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

         * **Cubic** (*BoolType** | **BoolKey*) -- Calculate cubic
           response

         * **Damp** (*float** | **FloatKey*) -- Specify damping for
           non-acceleration iteration

         * **Debug** (*int** | **IntKey*) -- Debug level for
           AOResponse.

         * **DoNothing** (*BoolType** | **BoolKey*) -- Do nothing.

         * **EFIOR** (*BoolType** | **BoolKey*) --

         * **EFISHG** (*BoolType** | **BoolKey*) --

         * **EFPLOT** (*BoolType** | **BoolKey*) --

         * **EL_DIPOLE_EL_DIPOLE** (*str** | **StringKey*) --

         * **EL_DIPOLE_EL_OCTUPOLE** (*str** | **StringKey*) --

         * **EL_DIPOLE_EL_QUADRUPOLE** (*str** | **StringKey*) --

         * **EL_DIPOLE_MAG_DIPOLE** (*str** | **StringKey*) --

         * **EL_DIPOLE_MAG_QUADRUPOLE** (*str** | **StringKey*) --

         * **EL_QUADRUPOLE_EL_QUADRUPOLE** (*str** | **StringKey*) --

         * **EL_QUADRUPOLE_MAG_DIPOLE** (*str** | **StringKey*) --

         * **EOPE** (*BoolType** | **BoolKey*) --

         * **FitAODeriv** (*BoolType** | **BoolKey*) -- Use FITAODERIV
           for Coulomb potential

         * **Frequencies** (*Iterable**[**float**] **|
           **FloatListKey*) -- List of frequencies of incident light,
           the perturbing field, at which the time-dependent
           properties will be calculated.

         * **GIAO** (*BoolType** | **BoolKey*) -- Use gauge-included
           atomic orbitals

         * **Gamma** (*BoolType** | **BoolKey*) -- Will use 2n+1 rule
           to calculate gamma.

         * **HirshPol** (*BoolType** | **BoolKey*) -- Hirshfeld
           Polarizability of fragments

         * **IDRI** (*BoolType** | **BoolKey*) --

         * **LifeTime** (*float** | **FloatKey*) -- 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].

         * **MAG_DIPOLE_MAG_DIPOLE** (*str** | **StringKey*) --

         * **MagOptRot** (*BoolType** | **BoolKey*) -- Calculate
           magneto-optical rotation

         * **MagneticPert** (*BoolType** | **BoolKey*) -- Use magnetic
           field as a perturbation

         * **NBO** (*BoolType** | **BoolKey*) -- Perform NBO analysis

         * **NoCore** (*BoolType** | **BoolKey*) -- if NOCORE is set
           we skip the core potential in diamagnetic term and/or in
           the unperturbed density of the CPKS solvers

         * **OCCOCC** (*BoolType** | **BoolKey*) -- occ-occ block
           response (not GIAO) - Experimental

         * **OKE** (*BoolType** | **BoolKey*) --

         * **ONLYANTISYM** (*BoolType** | **BoolKey*) --

         * **ONLYSYM** (*BoolType** | **BoolKey*) --

         * **OPTICALR** (*BoolType** | **BoolKey*) --

         * **OnlyPot** (*BoolType** | **BoolKey*) -- Calculation only
           potential for debugging purposes

         * **OpticalRotation** (*BoolType** | **BoolKey*) -- Calculate
           optical rotation

         * **PBE0LDA** (*BoolType** | **BoolKey*) --

         * **QuadBeta** (*BoolType** | **BoolKey*) -- Quadrupole
           operators with beta tensor

         * **QuadPert** (*BoolType** | **BoolKey*) -- Calculate
           quadrupole-quadrupole polarizability

         * **Quadratic** (*BoolType** | **BoolKey*) -- Calculate
           quadratic response

         * **Quadrupole** (*BoolType** | **BoolKey*) -- Calculate
           dipole-quadrupole polarizability

         * **REVPBE** (*BoolType** | **BoolKey*) --

         * **Raman** (*BoolType** | **BoolKey*) --

         * **SCF** (*str** | **StringKey*) -- 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.

         * **SHG** (*BoolType** | **BoolKey*) --

         * **STATIC** (*BoolType** | **BoolKey*) --

         * **THG** (*BoolType** | **BoolKey*) --

         * **TPA** (*BoolType** | **BoolKey*) --

         * **Traceless** (*BoolType** | **BoolKey*) -- Traceless
           quadrupole tensors

         * **VROA** (*BoolType** | **BoolKey*) -- Calculate
           Vibrational Raman Optical Activity.

         * **VelocityOrd** (*BoolType** | **BoolKey*) -- Use
           VelocityOrd without GIAOs

         * **XAlpha** (*BoolType** | **BoolKey*) -- Xalpha potential

         * **EFG** (*ADF._AOResponse._EFG*) -- Perform a Mulliken type
           analysis of the EFG principal components, and an analysis
           in terms of canonical MOs.

      class _EFG

         Perform a Mulliken type analysis of the EFG principal
         components, and an analysis in terms of canonical MOs.

         Variables:
            * **Atom** (*int** | **IntKey*) -- The number of the
              nucleus at which the EFG is to be analyzed (ADF input
              ordering).

            * **Dump** (*BoolType** | **BoolKey*) -- Dump EFG data to
              file.

            * **NBO** (*BoolType** | **BoolKey*) -- Perform an
              NBO/NLMO analysis of the EFG. Requires a series of
              calculations. See documentation.

            * **Nuc** (*int** | **IntKey*) -- The number of the
              nucleus at which the EFG is to be analyzed (ADF internal
              atom ordering).

            * **Thresh** (*float** | **FloatKey*) -- The threshold for
              printing the EFG-NBO contributions. The default is 0.05,
              which means that only orbitals with absolute value
              contribution larger than 5% of the total EFG are
              printed. To increase the number of contributions
              printed, specify a smaller threshold.

   class _AnalyticalFreq

      Define options for analytical frequencies.

      Variables:
         * **B1Size** (*float** | **FloatKey*) -- Sparse grid max
           memory size

         * **B1Thresh** (*float** | **FloatKey*) -- MMGF_DENB1 and
           MMGF_GRADB1 cutoff values

         * **Check_CPKS_From_Iteration** (*int** | **IntKey*) --
           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.

         * **Debug** (*str** | **StringKey*) -- For debugging
           purposes. Options: fit, hessian, b1, densities, numbers,
           symmetry, all.

         * **Hessian** (*Literal**[**"reflect"**, **"average"**]*) --
           Whether the final Hessian is obtained by reflecting or
           averaging?

         * **Max_CPKS_Iterations** (*int** | **IntKey*) -- 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.

         * **Nuc** (*Iterable**[**int**] **| **IntListKey*) -- 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

         * **Print** (*str** | **StringKey*) -- Primarily for
           debugging purposes. Options: eigs, u1, parts. Choosing EIGS
           results in the print out of the MO eigenvectors, while U1
           results in the print out of the U1 matrices. Except for
           small molecules this will result in a lot of data being
           output, and so they are not recommended. Choosing PARTS
           results in the print out of various sub-hessians that add
           up to give the final analytical hessian.

         * **PrintNormalModeAnalysis** (*BoolType** | **BoolKey*) --
           Request ADF to print analysis of the normal modes
           independently of AMS.

         * **Test** (*str** | **StringKey*) -- Test COSMO

         * **U1_Accuracy** (*float** | **FloatKey*) -- 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.

   class _Aromaticity

      Calculate aromaticity indicators, i.e. the matrix of
      localization/delocalization indices (LI-DI), Iring (ring index)
      and MCI (multi center index) aromaticity indices.

      Variables:
         **RingAtoms** (*Iterable**[**int**] **| **IntListKey*) --
         List of the atom numbers that form a ring. For each ring a
         separate line.

   class _Basis

      Definition of the basis set

      Variables:
         * **Core** (*Literal**[**"None"**, **"Small"**, **"Medium"**,
           **"Large"**]*) --

           Select the size of the frozen core you want to use.

           Small and Large will be interpreted within the basis sets
           available (of the selected quality), and might refer to the
           same core in some cases.

           If you specify 'None' you are guaranteed to have an all-
           electron basis set.

         * **CreateOutput** (*BoolType** | **BoolKey*) -- If true, the
           output of the atomic create runs will be printed to
           standard output. If false, it will be saved to the file
           CreateAtoms.out in the AMS results folder.

         * **FitType** (*Literal**[**"Auto"**, **"SZ"**, **"DZ"**,
           **"DZP"**, **"TZP"**, **"TZ2P"**, **"QZ4P"**, **"TZ2P+"**,
           **"TZ2P-J"**, **"QZ4P-J"**, **"ZORA/SZ"**, **"ZORA/DZ"**,
           **"ZORA/DZP"**, **"ZORA/TZP"**, **"ZORA/TZ2P"**,
           **"ZORA/QZ4P"**, **"ZORA/TZ2P+"**, **"ZORA/TZ2P-J"**,
           **"ZORA/QZ4P-J"**, **"ZORA/jcpl"**, **"AUG/ASZ"**,
           **"AUG/ADZ"**, **"AUG/ADZP"**, **"AUG/ATZP"**,
           **"AUG/ATZ2P"**, **"ET/ET-pVQZ"**, **"ET/ET-QZ+5P"**, **"ET
           /ET-QZ3P"**, **"ET/ET-QZ3P-1DIFFUSE"**, **"ET/ET-QZ3P-
           2DIFFUSE"**, **"ET/ET-QZ3P-3DIFFUSE"**]*) --

           Expert option.

           Select the auxiliary fit to be used for STOfit or old
           Hartree-Fock RI scheme.

           The fit set for a given atom is taken from the all-electron
           basis set file for the specified choice, for the same
           element as the atom.

           By default (Auto) the fit set is taken from the original
           basis set file.

         * **Path** (*str** | **StringKey*) -- The name of an
           alternative directory with basis sets to use. ADF looks for
           appropriate basis sets only within this directory. Default
           $AMSRESOURCES/ADF.

         * **Type** (*Literal**[**"SZ"**, **"DZ"**, **"DZP"**,
           **"TZP"**, **"TZ2P"**, **"QZ4P"**, **"TZ2P+"**,
           **"TZ2P-J"**, **"QZ4P-J"**, **"mTZ2P"**, **"ZORA/SZ"**,
           **"ZORA/DZ"**, **"ZORA/DZP"**, **"ZORA/TZP"**,
           **"ZORA/TZ2P"**, **"ZORA/QZ4P"**, **"ZORA/TZ2P+"**,
           **"ZORA/TZ2P-J"**, **"ZORA/QZ4P-J"**, **"ZORA/mTZ2P"**,
           **"ZORA/jcpl"**, **"AUG/ASZ"**, **"AUG/ADZ"**,
           **"AUG/ADZP"**, **"AUG/ATZP"**, **"AUG/ATZ2P"**, **"ET/ET-
           pVQZ"**, **"ET/ET-QZ+5P"**, **"ET/ET-QZ3P"**, **"ET/ET-
           QZ3P-1DIFFUSE"**, **"ET/ET-QZ3P-2DIFFUSE"**, **"ET/ET-QZ3P-
           3DIFFUSE"**, **"Corr/TZ3P"**, **"Corr/QZ6P"**,
           **"Corr/ATZ3P"**, **"Corr/AQZ6P"**, **"Corr/dATZ3P"**,
           **"Corr/dAQZ6P"**, **"POLTDDFT/DZ"**, **"POLTDDFT/DZP"**,
           **"POLTDDFT/TZP"**]*) --

           Select the basis set to use.

           SZ: Single Z DZ: Double Z DZP: Double Z, 1 polarization
           function TZP: Triple Z, 1 polarization function TZ2P:
           Triple Z, 2 polarization functions QZ4P: Quad Z, 4 pol
           functions, all-electron AUG: Augmented (extra diffuse
           functions) ET: Even tempered all electron basis sets J:
           Extra tight functions

           These descriptions are meant to give an indication of the
           quality, but remember that ADF uses Slater type functions.

           For standard calculations (energies, geometries, etc.) the
           relative quality is:

           SZ < DZ < DZP < TZP < TZ2P < ET-pVQZ < QZ4P

           The basis set chosen will apply to all atom types in your
           molecule. If no matching basis set is found, ADF will try
           to use a basis set of better quality.

           For TDDFT applications and small negatively charged atoms
           or molecules, use basis sets with extra diffuse functions.

           J: TZ2P-J, QZ4P-J: for use in ESR hyperfine or NMR spin-
           spin couplings.

           Use the Basis panel to select a basis set per atom type,
           and to see what basis set actually will be used.

         * **PerAtomType** (*ADF._Basis._PerAtomType*) -- Defines the
           basis set for all atoms of a particular type.

         * **PerRegion** (*ADF._Basis._PerRegion*) -- Defines the
           basis set for all atoms in a region. If specified, this
           overwrites the values set with the Basis%Type and
           Basis%PerAtomType keywords for atoms in that region. Note
           that if this keyword is used multiple times, the chosen
           regions may not overlap.

      class _PerAtomType

         Defines the basis set for all atoms of a particular type.

         Variables:
            * **Core** (*Literal**[**"None"**, **"Small"**,
              **"Medium"**, **"Large"**]*) -- Size of the frozen core.

            * **File** (*str** | **Path** | **StringKey*) -- The path
              of the basis set file (the path can either absolute or
              relative to $AMSRESOURCES/ADF). Note that one should
              include ZORA in the path for relativistic calculations,
              for example 'ZORA/QZ4P/Au'. Specifying the path to the
              basis file explicitly overrides the automatic basis file
              selection via the Type and Core subkeys.

            * **Symbol** (*str** | **StringKey*) -- The symbol for
              which to define the basis set.

            * **Type** (*Literal**[**"SZ"**, **"DZ"**, **"DZP"**,
              **"TZP"**, **"TZ2P"**, **"QZ4P"**, **"TZ2P+"**,
              **"TZ2P-J"**, **"QZ4P-J"**, **"mTZ2P"**, **"ZORA/SZ"**,
              **"ZORA/DZ"**, **"ZORA/DZP"**, **"ZORA/TZP"**,
              **"ZORA/TZ2P"**, **"ZORA/QZ4P"**, **"ZORA/TZ2P+"**,
              **"ZORA/TZ2P-J"**, **"ZORA/QZ4P-J"**, **"ZORA/mTZ2P"**,
              **"ZORA/jcpl"**, **"AUG/ASZ"**, **"AUG/ADZ"**,
              **"AUG/ADZP"**, **"AUG/ATZP"**, **"AUG/ATZ2P"**, **"ET
              /ET-pVQZ"**, **"ET/ET-QZ+5P"**, **"ET/ET-QZ3P"**, **"ET
              /ET-QZ3P-1DIFFUSE"**, **"ET/ET-QZ3P-2DIFFUSE"**, **"ET
              /ET-QZ3P-3DIFFUSE"**, **"Corr/TZ3P"**, **"Corr/QZ6P"**,
              **"Corr/ATZ3P"**, **"Corr/AQZ6P"**, **"Corr/dATZ3P"**,
              **"Corr/dAQZ6P"**, **"POLTDDFT/DZ"**,
              **"POLTDDFT/DZP"**, **"POLTDDFT/TZP"**]*) -- The basis
              sets to be used.

      class _PerRegion

         Defines the basis set for all atoms in a region. If
         specified, this overwrites the values set with the Basis%Type
         and Basis%PerAtomType keywords for atoms in that region. Note
         that if this keyword is used multiple times, the chosen
         regions may not overlap.

         Variables:
            * **Core** (*Literal**[**"None"**, **"Small"**,
              **"Medium"**, **"Large"**]*) -- Size of the frozen core.

            * **File** (*str** | **Path** | **StringKey*) -- The path
              of the basis set file (the path can either absolute or
              relative to $AMSRESOURCES/ADF). Note that one should
              include ZORA in the path for relativistic calculations,
              for example 'ZORA/QZ4P/Au'. Specifying the path to the
              basis file explicitly overrides the automatic basis file
              selection via the Type and Core subkeys.

            * **Region** (*str** | **StringKey*) -- The identifier of
              the region for which to define the basis set. Note that
              this may also be a region expression, e.g.
              'myregion+myotherregion' (the union of two regions).

            * **Type** (*Literal**[**"SZ"**, **"DZ"**, **"DZP"**,
              **"TZP"**, **"TZ2P"**, **"QZ4P"**, **"TZ2P+"**,
              **"TZ2P-J"**, **"QZ4P-J"**, **"mTZ2P"**, **"ZORA/SZ"**,
              **"ZORA/DZ"**, **"ZORA/DZP"**, **"ZORA/TZP"**,
              **"ZORA/TZ2P"**, **"ZORA/QZ4P"**, **"ZORA/TZ2P+"**,
              **"ZORA/TZ2P-J"**, **"ZORA/QZ4P-J"**, **"ZORA/mTZ2P"**,
              **"ZORA/jcpl"**, **"AUG/ASZ"**, **"AUG/ADZ"**,
              **"AUG/ADZP"**, **"AUG/ATZP"**, **"AUG/ATZ2P"**, **"ET
              /ET-pVQZ"**, **"ET/ET-QZ+5P"**, **"ET/ET-QZ3P"**, **"ET
              /ET-QZ3P-1DIFFUSE"**, **"ET/ET-QZ3P-2DIFFUSE"**, **"ET
              /ET-QZ3P-3DIFFUSE"**, **"Corr/TZ3P"**, **"Corr/QZ6P"**,
              **"Corr/ATZ3P"**, **"Corr/AQZ6P"**, **"Corr/dATZ3P"**,
              **"Corr/dAQZ6P"**, **"POLTDDFT/DZ"**,
              **"POLTDDFT/DZP"**, **"POLTDDFT/TZP"**]*) -- The basis
              sets to be used.

   class _BeckeGrid

      Options for the numerical integration grid.

      Variables:
         * **AllowAngularBoost** (*BoolType** | **BoolKey*) -- Allow
           automatic augmentation of the Lebedev spherical grid for
           highly coordinated atoms.

         * **InnerShellsPruning** (*BoolType** | **BoolKey*) -- Allow
           automatic pruning of the Lebedev spherical grid for shells
           close to the nuclei.

         * **PartitionFunPruning** (*BoolType** | **BoolKey*) -- Allow
           pruning of integration points based on the value of the
           partition function.

         * **QPNear** (*float** | **FloatKey*) -- 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.

         * **Quality** (*Literal**[**"Auto"**, **"Basic"**,
           **"Normal"**, **"Good"**, **"VeryGood"**,
           **"Excellent"**]*) -- 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.

         * **RadialGridBoost** (*float** | **FloatKey*) -- The number
           of radial grid points will be boosted by this factor. Some
           XC functionals require very accurate radial integration
           grids, so ADF will automatically boost the radial grid by a
           factor 3 for the following numerically sensitive
           functionals: LibXC M05, LibXC M05-2X, LibXC M06-2X, LibXC
           M06-HF, LibXC M06-L, LibXC M08-HX, LibXC M08-SO, LibXC
           M11-L, LibXC MS0, LibXC MS1, LibXC MS2, LibXC MS2H, LibXC
           MVS, LibXC MVSH, LibXC N12, LibXC N12-SX, LibXC SOGGA11,
           LibXC SOGGA11-X, LibXC TH1, LibXC TH2, LibXC WB97, LibXC
           WB97X, MetaGGA M06L, MetaHybrid M06-2X, MetaHybrid M06-HF,
           MetaGGA MVS.

         * **QualityPerRegion** (*ADF._BeckeGrid._QualityPerRegion*)
           -- Sets the grid quality for all atoms in a region. If
           specified, this overwrites the globally set quality.

      class _QualityPerRegion

         Sets the grid quality for all atoms in a region. If
         specified, this overwrites the globally set quality.

         Variables:
            * **Quality** (*Literal**[**"Basic"**, **"Normal"**,
              **"Good"**, **"VeryGood"**, **"Excellent"**]*) -- The
              region's integration grid quality.

            * **Region** (*str** | **StringKey*) -- The identifier of
              the region for which to set the quality.

   class _BondOrders

      Options for the calculation of bond orders. Note: the
      calculation of bond orders should be requested via the
      Properties%BondOrders input option in the AMS driver input.

      Variables:
         * **Calculate** (*BoolType** | **BoolKey*) -- Whether or not
           the bond orders should be calculated. This is for internal
           use/debug purposes, except for multi-atomic fragments. In
           case of atomic fragments one should request the bond orders
           at the AMS driver level via the Properties%BondOrders input
           option. For multi-atomic fragments, however, one should not
           request the bond orders at the AMS driver level, but
           instead use this key.

         * **PrintAll** (*BoolType** | **BoolKey*) -- If 'Yes', all
           five types of bond orders (i.e. Nalewajski-Mrozek-1,2 & 3,
           Mayer and Gopinathan-Jug) will be printed to the output.
           Otherwise only the Nalewajski-Mrozek-3 and the type
           requested in BondOrders%TypeForAMS will be printed.

         * **PrintTolerance** (*float** | **FloatKey*) -- Only bond
           orders larger than this threshold will be printed in the
           output (this treshold applies only to the printing in the
           'BOND-ORDER ANALYSIS' section of the ADF output.

         * **TypeForAMS** (*Literal**[**"Nalewajski-Mrozek-1"**,
           **"Nalewajski-Mrozek-2"**, **"Nalewajski-Mrozek-3"**,
           **"Mayer"**, **"Gopinathan-Jug"**]*) --

           The type of bond order that will be saved, printed and used
           by AMS.

           Nalewajski-Mrozek-1,2: bond orders calculated from two-
           electron valence indices based on partitioning of
           tr(Delta_P^2) using 3-index set or 4-index set
           respectively. Nalewajski-Mrozek-3: bond-orders calculated
           from valence indices based on partitioning of
           tr(P*Delta_P). Inter-atomic bond orders are not defined
           with non-atomic fragments.

   class _CC

      Technical aspects of CC methods

      Variables:
         * **ConvThreshold** (*float** | **FloatKey*) -- Minimum
           threshold of convergence for the CC energy

         * **Enabled** (*BoolType** | **BoolKey*) -- Enable the
           calculation of the CC energy.

         * **Extrapolation** (*Literal**[**"LinMix"**, **"DIIS"**,
           **"CROP"**]*) -- Specifies the t-amplitude extrapolation
           algorithm to be used in a CC calculation

         * **LinMixC** (*float** | **FloatKey*) -- CC Linear Mixing
           coefficient: Fraction of previous iteration that is
           retained.

         * **MaxIts** (*int** | **IntKey*) -- The maximum number of
           iterations to be used in a Coupled Cluster calculation.

         * **TensBuffer** (*int** | **IntKey*) -- The amount of
           memory, in GB, available for the tensor contraction
           library.

         * **Type** (*Literal**[**"None"**, **"SD"**, **"D"**,
           **"SDT"**, **"SDTQ"**, **"SD**(**T**)**"**]*) -- The
           excitation level of the CC calculation. Spin-restricted
           calculations go up to CCSD.

   class _CDFT

      CDFT is a tool for carrying out DFT calculations in the presence
      of a constraint.

      Variables:
         * **AllAtoms** (*BoolType** | **BoolKey*) -- If AllAtoms is
           true, then TheAtoms is overridden and all the atoms in the
           active fragment are included in the set.

         * **AnalyticalHessian** (*int** | **IntKey*) -- 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.

         * **ChargeAndSpin** (*BoolType** | **BoolKey*) -- will
           constrain both the charge and the spin

         * **Constraints** (*Iterable**[**float**] **|
           **FloatListKey*) -- 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.

         * **DoNotOptimize** (*BoolType** | **BoolKey*) -- If true,
           the multipliers chosen in INITIALMULTIPLIERS will not be
           optimized and will be constant throughout the entire SCF
           procedure.

         * **ExcitedCDFT** (*BoolType** | **BoolKey*) -- will generate
           an excited state with CONSTRAINTS number of ALPHA electrons
           constrained to occupy the virtual space of a ground state
           reference calculation. This is the essence of the eXcited
           Constrained DFT (XCDFT) method(P. Ramos, M. Pavanello, Low-
           lying excited states by constrained DFT, Journal of
           Chemical Physics 148, 144103 (2018)
           https://doi.org/10.1063/1.5018615) for the calculation of
           low-lying single excitations. XCDFT is found to correctly
           reproduce the energy surface topology at conical
           intersections between the ground state and the first singly
           excited state and can also accounts for the condensed phase
           effects in solvated chromophores where typical Delta SCF
           methods variationally collapse.

         * **InitialMultipliers** (*Iterable**[**float**] **|
           **FloatListKey*) -- If available, a guess for the Lagrange
           multipliers can be entered.

         * **MaxIter** (*int** | **IntKey*) -- Maximum number of CDFT
           iterations. CDFT carries out a loop nested inside the SCF
           cycle.

         * **Metric** (*BoolType** | **BoolKey*) -- Relevant for
           XCDFT. In the XCDFT method orthogonality is not imposed
           between the KS-orbitals of ground and excited states. If
           METRIC is specified, the degree of mixing of the single
           excited state with the ground state or high-order
           excitations is calculated. Three parameters are calculated:
           p, m and d. The parameters p and m will give information
           about the amount of mixing with the ground state, while
           parameter d will determine the mixing with high order
           excitations. Additional information about the origin of
           these parameters can be found in the literature (P. Ramos,
           M. Pavanello, Low-lying excited states by constrained DFT,
           Journal of Chemical Physics 148, 144103 (2018)
           https://doi.org/10.1063/1.5018615)

         * **NAtomsPerSet** (*Iterable**[**int**] **| **IntListKey*)
           -- The number of atoms in each moiety (set).

         * **NConstraints** (*int** | **IntKey*) -- 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.

         * **OnlyCharge** (*BoolType** | **BoolKey*) -- Will constrain
           only the charge, letting spin relax (and potentially
           delocalize)

         * **OnlySpin** (*BoolType** | **BoolKey*) -- Will constrain
           only the spin

         * **PopType** (*Literal**[**"yukawalike"**,
           **"fuzzyvoronoibecke"**, **"fuzzyvoronoifermi"**]*) -- The
           population analysis chosen for determining the constraint.

         * **Print** (*Literal**[**"low"**, **"medium"**,
           **"high"**]*) -- Print level and debugging.

         * **SelfConsistent** (*BoolType** | **BoolKey*) -- Self-
           Consistent CDFT

         * **StepSize** (*float** | **FloatKey*) -- The amount of the
           Lagrange multipliers step taken in each CDFT iteration

         * **TheAtoms** (*Iterable**[**int**] **| **IntListKey*) --
           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.

         * **Threshold** (*float** | **FloatKey*) -- The threshold for
           convergence of the CDFT constraints. The tighter the SCF
           convergence criteria, the tighter the THRESHOLD should be.

   class _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.

      Variables:
         * **Iteration** (*int** | **IntKey*) -- The maximum number of
           iterations

         * **Tolerance** (*float** | **FloatKey*) -- The convergence
           criterion, i.e. the SCF-CV(infinity)-DFT procedure stops
           when the given accuracy is achieved.

         * **CV_DFT** (*ADF._CVNDFT._CV_DFT*) -- The simplest case:
           the TDDFT transition density U-vector is substituted into
           the infinite order CV(infinity)-DFT excitation energy

         * **DSCF_CV_DFT** (*ADF._CVNDFT._DSCF_CV_DFT*) -- The
           simplest case: the TDDFT transition density U-vector is
           substituted into the infinite order CV(infinity)-DFT
           excitation energy

         * **RSCF_CV_DFT** (*ADF._CVNDFT._RSCF_CV_DFT*) -- The
           simplest case: the TDDFT transition density U-vector is
           substituted into the infinite order CV(infinity)-DFT
           excitation energy

         * **R_CV_DFT** (*ADF._CVNDFT._R_CV_DFT*) -- The simplest
           case: the TDDFT transition density U-vector is substituted
           into the infinite order CV(infinity)-DFT excitation energy

         * **SCF_CV_DFT** (*ADF._CVNDFT._SCF_CV_DFT*) -- The simplest
           case: the TDDFT transition density U-vector is substituted
           into the infinite order CV(infinity)-DFT excitation energy

      class _CV_DFT

         The simplest case: the TDDFT transition density U-vector is
         substituted into the infinite order CV(infinity)-DFT
         excitation energy

         Variables:
            **InitGuess** (*Literal**[**"TDDFT"**, **"SOR"**]*) --
            Initial guess

      class _DSCF_CV_DFT

         The simplest case: the TDDFT transition density U-vector is
         substituted into the infinite order CV(infinity)-DFT
         excitation energy

         Variables:
            * **DampOrbRelax** (*float** | **FloatKey*) -- The
              mix_relax parameter defines the relative weight of the
              new relaxation vector that is added to the one from the
              previous iteration.

            * **DampVariable** (*BoolType** | **BoolKey*) -- Damping
              condition

            * **Damping** (*float** | **FloatKey*) -- Damping

            * **InitGuess** (*Literal**[**"TDDFT"**, **"SOR"**]*) --
              Initial guess

            * **Optimize** (*Literal**[**"SVD"**, **"SOR"**,
              **"COL"**]*) -- Gradient optimization method

            * **RelaxAlpha** (*int** | **IntKey*) -- The SCF cycle
              number at which the relaxation of alpha orbitals starts.

            * **RelaxBeta** (*int** | **IntKey*) -- The SCF cycle
              number at which the relaxation of beta orbitals starts.

      class _RSCF_CV_DFT

         The simplest case: the TDDFT transition density U-vector is
         substituted into the infinite order CV(infinity)-DFT
         excitation energy

         Variables:
            * **DampOrbRelax** (*float** | **FloatKey*) -- The
              mix_relax parameter defines the relative weight of the
              new relaxation vector that is added to the one from the
              previous iteration.

            * **DampVariable** (*BoolType** | **BoolKey*) -- Damping
              condition

            * **Damping** (*float** | **FloatKey*) -- Damping

            * **InitGuess** (*Literal**[**"TDDFT"**, **"SOR"**]*) --
              Initial guess

            * **RelaxAlpha** (*int** | **IntKey*) -- The SCF cycle
              number at which the relaxation of alpha orbitals starts.

            * **RelaxBeta** (*int** | **IntKey*) -- The SCF cycle
              number at which the relaxation of beta orbitals starts.

      class _R_CV_DFT

         The simplest case: the TDDFT transition density U-vector is
         substituted into the infinite order CV(infinity)-DFT
         excitation energy

         Variables:
            * **DampOrbRelax** (*float** | **FloatKey*) -- The
              mix_relax parameter defines the relative weight of the
              new relaxation vector that is added to the one from the
              previous iteration.

            * **DampVariable** (*BoolType** | **BoolKey*) -- Damping
              condition

            * **InitGuess** (*Literal**[**"TDDFT"**, **"SOR"**]*) --
              Initial guess

            * **RelaxAlpha** (*int** | **IntKey*) -- The SCF cycle
              number at which the relaxation of alpha orbitals starts.

            * **RelaxBeta** (*int** | **IntKey*) -- The SCF cycle
              number at which the relaxation of beta orbitals starts.

      class _SCF_CV_DFT

         The simplest case: the TDDFT transition density U-vector is
         substituted into the infinite order CV(infinity)-DFT
         excitation energy

         Variables:
            * **DampVariable** (*BoolType** | **BoolKey*) -- Damping
              condition

            * **Damping** (*float** | **FloatKey*) -- Damping

            * **InitGuess** (*Literal**[**"TDDFT"**, **"SOR"**]*) --
              Initial guess

   class _ConceptualDFT

      Conceptual DFT Properties

      Variables:
         * **AnalysisLevel** (*Literal**[**"Normal"**, **"Extended"**,
           **"Full"**]*) --

           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.

         * **AtomsToDo** (*Iterable**[**int**] **| **IntListKey*) --
           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.

         * **Electronegativity** (*BoolType** | **BoolKey*) --
           Calculate atomic electronegativities. Requires an all-
           electron calculation (no frozen core), triggers the
           TotalEnergy and increases the [AnalysisLevel] to at least
           Extended.

         * **Enabled** (*BoolType** | **BoolKey*) -- Calculate
           Conceptual DFT properties.

         * **Domains** (*ADF._ConceptualDFT._Domains*) -- Calculate
           integrated properties for the domains (same sign) of the
           dual descriptor.

      class _Domains

         Calculate integrated properties for the domains (same sign)
         of the dual descriptor.

         Variables:
            * **Border** (*float** | **FloatKey*) -- 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.

            * **Display** (*float** | **FloatKey*) -- Domains for
              which the integrated DD value is smaller (in magnitude)
              than the specified value are omitted from the printed
              output.

            * **Enabled** (*BoolType** | **BoolKey*) -- Calculate
              properties of reactivity domains.

            * **Ensemble** (*Literal**[**"Canonical"**,
              **"GrandCanonical"**]*) -- 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.

            * **Radius** (*float** | **FloatKey*) -- 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.

            * **Spacing** (*float** | **FloatKey*) -- 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.

            * **Threshold** (*float** | **FloatKey*) -- Arbitrary
              value of dual descriptor used to separate DD domains
              (values below this threshold are ignored).

   class _ConstructPot

      Reads a density from a TAPE41 file and constructs numerically
      the corresponding potential to it

      Variables:
         * **CPBasis** (*BoolType** | **BoolKey*) --

         * **CPGrid** (*BoolType** | **BoolKey*) --

         * **Converge** (*float** | **FloatKey*) --

         * **CutNegativeDens** (*float** | **FloatKey*) --

         * **Damp** (*float** | **FloatKey*) --

         * **DensConv** (*float** | **FloatKey*) --

         * **EigenShift** (*float** | **FloatKey*) --

         * **FitBas** (*BoolType** | **BoolKey*) --

         * **FixedLambda** (*BoolType** | **BoolKey*) --

         * **ImportDens** (*str** | **StringKey*) -- Filename of
           density...

         * **Lambda** (*float** | **FloatKey*) --

         * **PotBas** (*str** | **StringKey*) -- Filename...

         * **PotProj** (*str** | **StringKey*) --

         * **ProjChange** (*float** | **FloatKey*) --

         * **ProjSmallDens** (*float** | **FloatKey*) --

         * **QPiterations** (*int** | **IntKey*) --

         * **SVD** (*BoolType** | **BoolKey*) --

         * **SmallEigThresh** (*float** | **FloatKey*) --

         * **StartPot** (*str** | **StringKey*) -- Filename of
           potential...

         * **StepSize** (*float** | **FloatKey*) --

         * **TIKH** (*float** | **FloatKey*) --

   class _CorePotentials

      With the key COREPOTENTIALS you specify the core file and
      (optionally) which sections pertain to the distinct atom types
      in the molecule.

   class _CurrentResponse

      Variables:
         * **CDSpec** (*BoolType** | **BoolKey*) --

         * **Damping** (*float** | **FloatKey*) --

         * **GTensor** (*BoolType** | **BoolKey*) --

         * **Magnet** (*BoolType** | **BoolKey*) --

         * **NCT** (*float** | **FloatKey*) --

         * **NMRShielding** (*BoolType** | **BoolKey*) --

         * **NoVK** (*BoolType** | **BoolKey*) --

         * **PARTVK** (*float** | **FloatKey*) --

         * **Parabolic** (*float** | **FloatKey*) --

         * **QIANVignale** (*BoolType** | **BoolKey*) --

         * **Static** (*BoolType** | **BoolKey*) --

   class _DIMPAR

      In this block, the parameters for the DIM atoms are defined in
      DIM/QM calculations.

   class _DIMQM

      Input for DIM/QM

   class _Dependency

      Variables:
         * **Enabled** (*BoolType** | **BoolKey*) -- Used to make the
           basis or fit set linearly independent, up to the threshold
           specified below. This is typically important when you have
           many diffuse functions in your basis or fit set.

         * **bas** (*float** | **FloatKey*) --

           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.

         * **eig** (*float** | **FloatKey*) --

           Merely a technical parameter. When the DEPENDENCY key is
           activated, any rejected basis functions (i.e.: linear
           combinations that correspond with small eigenvalues in the
           virtual SFOs overlap matrix) are normally processed until
           diagonalization of the Fock matrix takes place. At that
           point, all matrix elements corresponding to rejected
           functions are set to zero (off-diagonal) and BigEig
           (diagonal).

           In AMSinput you must check the Fix Linear dependency check
           box for this option to be used.

         * **fit** (*float** | **FloatKey*) --

           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.

   class _EPrint

      Print switches that require more specification than just off or
      on

      Variables:
         * **AtomPop** (*str** | **StringKey*) -- Mulliken population
           analysis on a per-atom basis

         * **BASPop** (*str** | **StringKey*) -- Mulliken population
           analysis on a per-bas-function basis

         * **Eigval** (*str** | **StringKey*) -- One-electron orbital
           energies

         * **Fit** (*str** | **StringKey*) -- Fit functions and fit
           coefficients

         * **Frag** (*str** | **StringKey*) -- Building of the
           molecule from fragments

         * **FragPop** (*str** | **StringKey*) -- Mulliken population
           analysis on a per fragment basis

         * **Freq** (*str** | **StringKey*) -- Intermediate results in
           the computation of frequencies (see debug: freq).

         * **GeoStep** (*str** | **StringKey*) -- Geometry updates
           (Optimization, Transition State, ...)

         * **NumInt** (*str** | **StringKey*) -- Numerical Integration

         * **OrbPopEr** (*str** | **StringKey*) -- Energy Range (ER)
           in hartree units for the OrbPop subkey

         * **Repeat** (*str** | **StringKey*) -- Repetition of output
           in Geometry iterations (SCF, optimization, ...)

         * **SCF** (*str** | **StringKey*) -- Self Consistent Field
           procedure

         * **SFO** (*str** | **StringKey*) -- Information related to
           the Symmetrized Fragment Orbitals and the analysis

         * **TF** (*str** | **StringKey*) -- Transition Field method

         * **OrbPop** (*str** | **Sequence**[**str**] **|
           **FreeBlock*) -- (Mulliken type) population analysis for
           individual MOs

      class _OrbPop

         (Mulliken type) population analysis for individual MOs

   class _ESR

      Variables:
         * **AnaPol** (*BoolType** | **BoolKey*) -- Expert option for
           ESR.

         * **Enabled** (*BoolType** | **BoolKey*) -- Calculate ESR (g-
           and/or A tensors)

         * **GaugeOrigin** (*Iterable**[**float**] **|
           **FloatListKey*) -- Can be used in ESR to set gauge origin.

         * **NoESRfcsd** (*BoolType** | **BoolKey*) -- Debug option in
           ESR.

         * **NoESRpso** (*BoolType** | **BoolKey*) -- Debug option in
           ESR.

         * **PARANMR** (*BoolType** | **BoolKey*) -- Paramagnetic part
           NMR shielding.

         * **nogiao** (*BoolType** | **BoolKey*) -- Debug option for
           ESR g-tensor

   class _ETSNOCV

      Perform ETS-NOCV analysis.

      Variables:
         * **DEBUGTV** (*BoolType** | **BoolKey*) -- For T/V debugging

         * **EKMin** (*float** | **FloatKey*) -- The threshold for
           orbital interaction energy contributions corresponding to
           deformation density components originating from each NOCV-
           pairs

         * **ENOCV** (*float** | **FloatKey*) -- The threshold for
           NOCV-eigenvalues

         * **Enabled** (*BoolType** | **BoolKey*) -- Perform ETS-NOCV
           analysis.

         * **RhoKMin** (*float** | **FloatKey*) -- The threshold for
           population analysis of each deformation density
           contribution in terms of individual SFOs.

         * **TVanalysis** (*BoolType** | **BoolKey*) -- Perform T/V
           decomposition

   class _ElectronTransfer

      Block key for charge transfer integrals with FDE.

      Variables:
         * **CDFT** (*BoolType** | **BoolKey*) --

         * **Debug** (*BoolType** | **BoolKey*) --

         * **Disjoint** (*BoolType** | **BoolKey*) --

         * **FDE** (*BoolType** | **BoolKey*) --

         * **InvThr** (*float** | **FloatKey*) --

         * **Joint** (*BoolType** | **BoolKey*) --

         * **KNADD** (*BoolType** | **BoolKey*) --

         * **NonCT** (*BoolType** | **BoolKey*) --

         * **NumFrag** (*int** | **IntKey*) --

         * **Print** (*str** | **StringKey*) --

   class _EnergyFrag

   class _Excitations

      Excitation energies: UV/Vis

      Variables:
         * **AAS** (*BoolType** | **BoolKey*) -- Use the molecular
           orbitals from a DFT ground state calculation as input to an
           excited state calculation with TDDFT-aas coupling matrices

         * **AASALPHA** (*float** | **FloatKey*) -- optimal alpha
           value for TDDFT-aas method

         * **ALLXASMOMENTS** (*BoolType** | **BoolKey*) -- 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

         * **ALLXASQUADRUPOLE** (*BoolType** | **BoolKey*) -- To be
           used in combination with XAS.This will print out the
           individual oscillator strength components to the total
           oscillator strength.

         * **Allowed** (*BoolType** | **BoolKey*) -- Treat only those
           irreducible representations for which the oscillator
           strengths will be nonzero (as opposed to all)

         * **AlsoRestricted** (*BoolType** | **BoolKey*) -- Include
           also excitation energies in which a spin-restricted
           exchange-correlation kernel is used

         * **Analytical** (*BoolType** | **BoolKey*) -- The required
           integrals for the CD spectrum are calculated analytically,
           instead of numerically. Only used in case of CD spectrum

         * **AsympCor** (*float** | **FloatKey*) --

         * **BSE** (*BoolType** | **BoolKey*) -- Solve the static
           Bethe-Salpeter equation based on a GW calculation

         * **BSEscreening** (*BoolType** | **BoolKey*) -- Solve the
           static Bethe-Salpeter equation based on a GW-BSE
           calculation, i.e. the screening entering the excitation
           calculation is calculated at the BSE level of theory
           instead of the RPA.

         * **CDSpectrum** (*BoolType** | **BoolKey*) -- Compute the
           rotatory strengths for the calculated excitations, in order
           to simulate Circular Dichroism (CD) spectra

         * **DBSE** (*BoolType** | **BoolKey*) -- Solve the dynamic
           Bethe-Salpeter equation based on a GW calculation in the
           diagonal approximation for the GW kernel

         * **DTensor** (*str** | **StringKey*) -- MCD gtensor

         * **Descriptors** (*BoolType** | **BoolKey*) -- Compute
           charge-transfer descriptors and SFO analysis

         * **Descriptors_CT_AT_Rab** (*float** | **FloatKey*) --
           Atomic distance criterion used for the calculation of CT_AT
           descriptors

         * **ESESTDM** (*BoolType** | **BoolKey*) -- Compute
           transition dipole moments between excited states

         * **FullKernel** (*BoolType** | **BoolKey*) -- Use the non-
           ALDA kernel (with XCFUN)

         * **GTensor** (*str** | **StringKey*) -- MCD gtensor

         * **HDA** (*BoolType** | **BoolKey*) --

           Activate the diagonal HF exchange approximation.

           This is only relevant if a (meta-)hybrid is used in the
           SCF.

         * **HDA_CutOff** (*float** | **FloatKey*) -- This is cutoff
           based on differences in energy between eps_virt-eps_occ, to
           reduce number of diagonal HF exchange integrals.

         * **Iterations** (*int** | **IntKey*) -- The maximum number
           of attempts within which the Davidson algorithm has to
           converge

         * **KFWrite** (*int** | **IntKey*) -- 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.

         * **Lowest** (*Iterable**[**int**] **| **IntListKey*) --
           Number of lowest excitations to compute

         * **MAXPRINTED** (*int** | **IntKey*) -- The maximum number
           of printed contributions

         * **MCD** (*str** | **StringKey*) -- TODO: Magnetic Circular
           Dichroism

         * **NTO** (*BoolType** | **BoolKey*) -- Compute the Natural
           Transition Orbitals

         * **N_HDA_integral** (*int** | **IntKey*) -- Maximum number
           of HDA integrals

         * **N_SFO** (*int** | **IntKey*) -- Number of SFO analyzed
           and printed

         * **Nospinsocd** (*BoolType** | **BoolKey*) -- Turn off
           calculation of spin operator matrices in spin-orbit
           relativistic CD spectrum calculations

         * **OnlySing** (*BoolType** | **BoolKey*) -- Compute only
           singlet-singlet excitations

         * **OnlyTrip** (*BoolType** | **BoolKey*) -- Compute only
           singlet-triplet excitations

         * **Orthonormality** (*float** | **FloatKey*) -- 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.

         * **Residu** (*float** | **FloatKey*) --

         * **SDKernelType** (*Literal**[**"Collinear"**,
           **"NonCollinear"**, **"QuasiNonCollinear"**]*) -- Choose
           specific kernel approximation in case of ROKS-SD-TDA or
           ROKS-SD-CIS.

         * **SFOAnalysis** (*BoolType** | **BoolKey*) -- Do SFO
           analysis

         * **SOSFreq** (*float** | **FloatKey*) --

         * **STDA** (*BoolType** | **BoolKey*) -- Simplified Tamm-
           Dancoff approach

         * **STDDFT** (*BoolType** | **BoolKey*) -- Simplified time-
           dependent DFT

         * **ScaleCoul** (*float** | **FloatKey*) -- Scaling of
           Coulomb kernel with scale parameter

         * **ScaleHF** (*float** | **FloatKey*) -- Scaling of the HF
           part of the kernel with scale parameter

         * **ScaleXC** (*float** | **FloatKey*) -- Scaling of the XC-
           kernel (excluding a possible HF-part) with scale parameter

         * **Select** (*str** | **StringKey*) -- Rather than selecting
           the first nmcdterm transitions for consideration individual
           transitions can be selected through the SELECT keyword

         * **SingleOrbTrans** (*BoolType** | **BoolKey*) -- keyword to
           use only orbital energy differences

         * **TD-DFTB** (*BoolType** | **BoolKey*) -- Use the molecular
           orbitals from a DFT ground state calculation as input to an
           excited state calculation with TD-DFTB coupling matrices

         * **TDA-DFTB** (*BoolType** | **BoolKey*) -- Use the
           molecular orbitals from a DFT ground state calculation as
           input to an excited state calculation with TDA-DFTB
           coupling matrices

         * **THRESHPRINTED** (*float** | **FloatKey*) -- Loop until
           100 x THRESHPRINTED percent of the transition is found or
           MAXPRINTED contributions are printed

         * **Tolerance** (*float** | **FloatKey*) --

         * **Vectors** (*int** | **IntKey*) -- 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.

         * **Velocity** (*BoolType** | **BoolKey*) -- 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

         * **XAS** (*BoolType** | **BoolKey*) -- 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.

         * **Davidson** (*str** | **Sequence**[**str**] **|
           **FreeBlock*) -- Use the Davidson procedure

         * **Exact** (*str** | **Sequence**[**str**] **| **FreeBlock*)
           -- 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

         * **RoksTddftType** (*ADF._Excitations._RoksTddftType*) --
           Excitation energies from RoksTddft: UV/Vis

      class _Davidson

         Use the Davidson procedure

      class _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

      class _RoksTddftType

         Excitation energies from RoksTddft: UV/Vis

         Variables:
            * **Calculate** (*Literal**[**"None"**, **"SD"**,
              **"SS"**, **"SU"**, **"SD-SS"**, **"SS-SU"**, **"SD-SS-
              SU"**]*) -- Specifies the types of RoksTddft methods to
              target several target spins: spin-down (SD), same-spin
              (SS), and/or spin-up (SU).

            * **SDType** (*Literal**[**"None"**, **"SD-TDA"**, **"SD-
              CIS"**, **"QSD-TDA"**]*) -- Specifies the flavor to be
              used in the case of spin-down (SD) RoksTddft

            * **SSType** (*Literal**[**"None"**, **"R-TDA"**,
              **"S-TDA"**, **"X-TDA"**]*) -- Specifies the flavor to
              be used in the case of same-spin (SS) RoksTddft

            * **SUType** (*Literal**[**"None"**, **"SF-TDA"**]*) --
              Specifies the flavor to be used in the case of spin-up
              (SU) RoksTddft

   class _ExcitedEDA

      Options for excited energy decomposition (EDA).

      Variables:
         * **Calc** (*Literal**[**"None"**, **"Electrostatic"**,
           **"Pauli"**, **"All"**]*) --

           None: No calculation of parts of excited EDA.

           Electrostatic: calculate electrostatic part EDA excited
           state.

           Pauli: calculate Pauli repulsion part of excited state.

         * **ElectrostaticFile** (*str** | **StringKey*) -- Path to
           adf.rkf file from which ADF reads electrostatic part
           excited EDA.

         * **PauliFile** (*str** | **StringKey*) -- Path to adf.rkf
           file from which ADF reads Pauli repulsion part excited EDA.

   class _ExcitedGO

      Excited state geometry optimization

      Variables:
         * **ALLGRADIENTS** (*BoolType** | **BoolKey*) --

         * **EigenFollow** (*BoolType** | **BoolKey*) -- This key
           tries to follow the eigenvector in excited state geometry
           optimizations

         * **Output** (*int** | **IntKey*) -- The amount of output
           printed. A higher value requests more detailed output

         * **Singlet** (*BoolType** | **BoolKey*) -- Singlet-singlet
           excitation is considered

         * **State** (*str** | **StringKey*) -- 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.

         * **Triplet** (*BoolType** | **BoolKey*) -- Singlet-triplet
           excitation is considered

         * **CPKS** (*ADF._ExcitedGO._CPKS*) -- Some control
           parameters for the CPKS(Z-vector) part of the TDDFT
           gradients calculation

         * **SING_GRADS** (*str** | **Sequence**[**str**] **|
           **FreeBlock*) --

         * **TRIP_GRADS** (*str** | **Sequence**[**str**] **|
           **FreeBlock*) --

      class _CPKS

         Some control parameters for the CPKS(Z-vector) part of the
         TDDFT gradients calculation

         Variables:
            * **Eps** (*float** | **FloatKey*) -- Convergence
              requirement of the CPKS

            * **IterOut** (*int** | **IntKey*) -- Details of the CPKS
              calculation are printed every iter iterations

            * **NoPreConiter** (*int** | **IntKey*) -- maximum number
              of iterations allowed for the unpreconditioned solver.

            * **PreConiter** (*int** | **IntKey*) -- maximum number of
              iterations allowed for the preconditioned solver

      class _SING_GRADS

      class _TRIP_GRADS

   class _ExcitonTransfer

      Block key for exciton transfer integrals with ROSE or FOCDFT.

      Variables:
         * **CoupleFinalStates** (*BoolType** | **BoolKey*) --
           Calculate delocalized excited states in the basis of the
           localized excited states that are calculated, thus couple
           the localized excited states.

         * **Debug** (*BoolType** | **BoolKey*) -- Print extra output
           for debug purposes

         * **FullRun** (*BoolType** | **BoolKey*) -- Include run
           without restriction of localization of occupied and/or
           virtual orbitals.

         * **LocalCouplingsOnly** (*BoolType** | **BoolKey*) -- Only
           account for couplings between local diabatic states

         * **Localize** (*Literal**[**"OccupiedOnly"**,
           **"OccupiedAndVirtual"**]*) -- Localize OccupiedAndVirtual
           means that separately purely localized excitations and
           purely charge-transfer excitations are calculated. Localize
           OccupiedOnly means that an excitation may have local and
           charge-transfer character, but the excitation only has
           contributions from occupied orbitals on one fragment. Only
           relevant in case block key FOCDFT is used or ROSE orbitals
           are used.

         * **Lowest** (*Iterable**[**int**] **| **IntListKey*) --
           Number of lowest excitations to compute for each fragment.
           These are purely local excitations if the Localize
           OccupiedAndVirtual key is specified.

         * **LowestCT** (*Iterable**[**int**] **| **IntListKey*) --
           Number of lowest charge-transfer excitations to compute for
           each fragment. Only relevant if the Localize
           OccupiedAndVirtual key is also specified.

         * **Output** (*Literal**[**"AllCouplings"**,
           **"FilteredCouplings"**, **"AllAndFilteredCouplings"**]*)
           -- Amount of output

         * **SecondOrder** (*BoolType** | **BoolKey*) -- Include 2nd-
           order correction to electronic couplings

         * **UseFragments** (*Iterable**[**int**] **| **IntListKey*)
           -- In case of Rose or FOCDFT only, one can specify the
           fragment numbers of 2 fragments. Then calculate only
           excitations from occupied orbitals on fragment one to
           virtual orbitals on fragment two. If not specified
           calculate all possible excitations.

         * **FilteredCouplings**
           (*ADF._ExcitonTransfer._FilteredCouplings*) -- Details on
           filter used for electronic couplings in the output

      class _FilteredCouplings

         Details on filter used for electronic couplings in the output

         Variables:
            * **MaxEnergy** (*float** | **FloatKey*) -- Max. energy
              (in eV) of diabatic states

            * **MaxEnergyDiff** (*float** | **FloatKey*) -- Max.
              energy difference (in eV) between diabatic states

            * **MinCoupling** (*float** | **FloatKey*) -- Min.
              coupling value (in meV) that is printed

            * **MinEnergy** (*float** | **FloatKey*) -- Min. energy
              (in eV) of diabatic states

   class _Externals

      Legacy support of the older DRF code.

   class _FDE

      Frozen Density Embedding options

      Variables:
         * **AMOLFDE** (*BoolType** | **BoolKey*) -- placeholder

         * **CAPDENSCONV** (*float** | **FloatKey*) -- placeholder

         * **CAPPOTBASIS** (*BoolType** | **BoolKey*) -- placeholder

         * **CAPPOTLINESEARCH** (*BoolType** | **BoolKey*) --
           placeholder

         * **CAPRADIUS** (*float** | **FloatKey*) -- placeholder

         * **CJCORR** (*float** | **FloatKey*) -- Option to switch on
           a long-distance correction

         * **Coulomb** (*BoolType** | **BoolKey*) -- 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.

         * **Dipole** (*BoolType** | **BoolKey*) -- placeholder

         * **E00** (*BoolType** | **BoolKey*) -- placeholder

         * **EIGENSHIFT** (*float** | **FloatKey*) -- placeholder

         * **ENERGY** (*BoolType** | **BoolKey*) -- placeholder

         * **EXTERNALORTHO** (*float** | **FloatKey*) -- Used to
           specify the use of external orthogonality (EO) in the FDE
           block

         * **EXTPRINTENERGY** (*BoolType** | **BoolKey*) --
           placeholder

         * **FULLGRID** (*BoolType** | **BoolKey*) -- placeholder

         * **FreezeAndThawCycles** (*int** | **IntKey*) -- This
           keyword duplicates RelaxCycles

         * **FreezeAndThawDensType** (*str** | **StringKey*) --
           placeholder

         * **FreezeAndThawPostSCF** (*BoolType** | **BoolKey*) -- This
           keyword duplicates RelaxPostSCF

         * **GGA97** (*BoolType** | **BoolKey*) -- placeholder

         * **GGAPotCFD** (*str** | **StringKey*) -- The correlation
           approximant is used in the construction of the embedding
           potential. The same correlation approximants as in the XC
           key are available.

         * **GGAPotXFD** (*str** | **StringKey*) -- The exchange
           approximant is used in the construction of the embedding
           potential. The same exchange approximants as in the XC key
           are available.

         * **LAMBDATIKH** (*float** | **FloatKey*) -- placeholder

         * **LBDAMP** (*float** | **FloatKey*) -- placeholder

         * **LBMAXSTEP** (*float** | **FloatKey*) -- placeholder

         * **LLP91** (*BoolType** | **BoolKey*) -- placeholder

         * **LLP91S** (*BoolType** | **BoolKey*) -- placeholder

         * **NDSD** (*str** | **StringKey*) -- placeholder

         * **NOCAPSEPCONV** (*BoolType** | **BoolKey*) -- placeholder

         * **NOFDKERN** (*BoolType** | **BoolKey*) -- placeholder

         * **OL91A** (*BoolType** | **BoolKey*) -- placeholder

         * **OL91B** (*BoolType** | **BoolKey*) -- placeholder

         * **ONEGRID** (*BoolType** | **BoolKey*) -- placeholder

         * **P92** (*BoolType** | **BoolKey*) -- placeholder

         * **PBE2** (*BoolType** | **BoolKey*) -- placeholder

         * **PBE3** (*BoolType** | **BoolKey*) -- placeholder

         * **PBE4** (*BoolType** | **BoolKey*) -- placeholder

         * **PDFT** (*BoolType** | **BoolKey*) -- placeholder

         * **PRINTEACHCYCLE** (*BoolType** | **BoolKey*) --
           placeholder

         * **PRINTRHO2** (*BoolType** | **BoolKey*) -- placeholder

         * **PW86K** (*BoolType** | **BoolKey*) -- placeholder

         * **PW91K** (*BoolType** | **BoolKey*) -- placeholder

         * **PW91Kscaled** (*BoolType** | **BoolKey*) -- placeholder

         * **RHO1FITTED** (*BoolType** | **BoolKey*) -- placeholder

         * **RelaxCycles** (*int** | **IntKey*) -- 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.

         * **RelaxDensType** (*str** | **StringKey*) -- placeholder

         * **RelaxPostSCF** (*BoolType** | **BoolKey*) -- 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.

         * **SCFCONVTHRESH** (*float** | **FloatKey*) -- placeholder

         * **SDFTEnergy** (*BoolType** | **BoolKey*) -- placeholder

         * **SHORTPRINTENERGY** (*BoolType** | **BoolKey*) --
           placeholder

         * **SMALLEIGTHRESH** (*float** | **FloatKey*) -- placeholder

         * **TF9W** (*BoolType** | **BoolKey*) -- placeholder

         * **THAKKAR92** (*BoolType** | **BoolKey*) -- placeholder

         * **THOMASFERMI** (*BoolType** | **BoolKey*) -- Local-
           density-approximation form of vt[rhoA,rhoB] derived from
           Thomas-Fermi expression for Ts[rho]

         * **TW02** (*BoolType** | **BoolKey*) -- placeholder

         * **WEIZ** (*BoolType** | **BoolKey*) -- placeholder

         * **XCFun** (*BoolType** | **BoolKey*) -- Use XCFUN for
           nonadditive functionals

         * **XCNAdd** (*str** | **StringKey*) --

   class _FDEFragments

      Definitions of the FDE fragment types.

   class _FOCDFT

      Localize orbitals on fragments and constrain charge and spin
      polarization on fragments.

      Variables:
         * **Charge** (*Iterable**[**float**] **| **FloatListKey*) --
           Constrain charge on fragments. Number of charges should be
           the same as number of fragments, and sum should add up to
           total charge.

         * **Debug** (*BoolType** | **BoolKey*) -- Debug.

         * **SpinPolarization** (*Iterable**[**float**] **|
           **FloatListKey*) -- Constrain spin polarization on
           fragments. Number of spin polarization values should be the
           same as number of fragments, and sum should add up to total
           spin polarization. Calculation should be spin unrestricted.

         * **ElectronTransfer** (*ADF._FOCDFT._ElectronTransfer*) --

      class _ElectronTransfer

         Variables:
            * **Charge** (*Iterable**[**float**] **| **FloatListKey*)
              -- Constrain charge on fragments for the second
              calculation. Number of charges should be the same as
              number of fragments, and sum should add up to total
              charge.

            * **OffDiagonalHF** (*BoolType** | **BoolKey*) -- Off
              diagonal HF matrix elements.

            * **OffDiagonalHFValue** (*float** | **FloatKey*) --
              Amount of HF in case off diagonal HF matrix elements.

            * **SpinPolarization** (*Iterable**[**float**] **|
              **FloatListKey*) -- Constrain spin polarization on
              fragments for the second calculation. Number of spin
              polarization values should be the same as number of
              fragments, and sum should add up to total spin
              polarization. Calculation should be spin unrestricted.

   class _Fitnadkin

      FDE option.

   class _FragOccupations

      Simulation of unrestricted fragments with the key
      FRAGOCCUPATIONS. Fragments need to be calculated spin-
      restricted. One can specify occupation numbers as if these
      fragments are calculated spin-unrestricted. The sum of spin-
      alpha and spin-beta occupations must, for each fragment orbital
      in each irrep separately, be equal to the total spin-restricted
      occupation of that orbital in the fragment.

   class _Fragments

      Definitions of the fragment type/files: {FragmentName
      FragmentFile}. In the block header one can specify the directory
      where the fragment files are located

   class _GPU

      Set GPU options

      Variables:
         * **Enabled** (*BoolType** | **BoolKey*) -- Use a CUDA-
           compatible GPU.

         * **UseDevices** (*Iterable**[**int**] **| **IntListKey*) --
           Use only specified devices for this calculation. Multiple
           devices will be distributed evenly among MPI ranks.

   class _GW

      Perform a GW calculation. G0W0 is the default for
      GW%SelfConsistency.

      Variables:
         * **AdaptiveMixing** (*Iterable**[**float**] **|
           **FloatListKey*) --

           Requests to use adaptive mixing instead of DIIS and sets
           the staring mixing parameter for mixing of Green's function
           in case of self-consistency.

           Adapative mixing is recommended in case a qsGW calculation
           does not converge with DIIS.

           It is ignored in non-selfconsistent calculation and
           overwritten by DIIS when DIIS is also present.

         * **DIIS** (*int** | **IntKey*) -- Requests to use DIIS. This
           is the Default. Number of expansion coefficients can be
           requested as well. Ignored in non-selfconsistent
           calculation

         * **Enabled** (*BoolType** | **BoolKey*) -- Enable the
           calculation of the GW quasi-particle energies.

         * **ExpansionOrder** (*int** | **IntKey*) -- Order of the
           expansion of the screened interaction on the SOS-GF(n)
           method. order 2 (=SOS-GF2) is the default

         * **FixedGridSizes** (*BoolType** | **BoolKey*) -- In a self-
           consistent GW calculation, recalculate Grids but keep them
           the same size during the SCF procedure.

         * **FixedGrids** (*BoolType** | **BoolKey*) -- In a self-
           consistent GW calculation, do not recalculate Grids. Can be
           useful in case of convergence problems. Only relevant for
           qsGW and qsGW0. In case of evGW and evGW0, the grids are
           always kept fixed.

         * **G3W2** (*Literal**[**"Full"**, **"Diagonal"**,
           **"Perturbative"**]*) -- Only relevant when self-energy is
           one of GF2 or G3W2: Full requests that the second-order
           term is evaluated for the full self-energy matrix. This is
           very expensive and should only be done for small systems.
           Diagonal requests, that only the Diagonal of the self-
           energy matrix is updated. Perturbative means, that only a
           second-order screened exchange correction is evaluated
           after the GW calculation is completed. For a G0W0
           calculation, all of these options are equivalent.

         * **LinearMixing** (*Iterable**[**float**] **|
           **FloatListKey*) --

           Requests to use linear mixing instead of DIIS and sets the
           mixing parameter for linear mixing of Green's function in
           case of self-consistency.

           It is ignored in non-selfconsistent calculation and
           overwritten by DIIS when DIIS is also present.

         * **LinearizeQPequations** (*BoolType** | **BoolKey*) --

           Instead of solving the non-linear QP equations in a G0W0
           (or evGW calculation) by bisection exacly, linearize them
           by first-order Taylor expansion.

           This is not recommended since it does not save
           computational time when used together with analytical
           continuation (as implemented in AMS). It might however be
           useful for benchmarking or for validating results.

           If the results os the linearization differ by a lot (for
           instance, more than 0.1 eV in frontier QP energies) from
           the non-linearized results, this might indicate that the GW
           calculation is not reliable.

         * **OffDiagonalEFermi** (*BoolType** | **BoolKey*) --
           Analytically continue the off-diagonal elements of the KSF2
           qsGW Hamiltonian at the Fermi-energy instead of omega=0.
           Typically leads to slightly lower QP energies, i.e. higher
           ionization potentials. The HOMO-LUMO gaps are typically not
           affected.

         * **Polarizability** (*Literal**[**"RPA"**, **"BSE"**,
           **"G4W1"**, **"G4V1"**, **"TDHF"**]*) --

           Sets the expression for the Polarizability used in the GW
           calculation.

           RPA is the Default and amounts to a standard GW
           calculation.

           BSE denotes screening in the Bethe-Salpeter-equation
           formalism.

         * **PrintAllSolutions** (*BoolType** | **BoolKey*) -- Print
           out all solutions for all requested states. Detects
           multiple solutions of the QP equations.

         * **PrintImaginaryAxisData** (*BoolType** | **BoolKey*) -- If
           true, print out the self-energy on the imaginary axis.

         * **PrintSpectralFunction** (*BoolType** | **BoolKey*) --
           Plot the self-energy as a function of frequency.
           Automatically done in case of analytical continuation.
           However, this is expensive in the analytical integration
           formalism.

         * **PrintZfactor** (*BoolType** | **BoolKey*) --

         * **QPHamiltonian** (*Literal**[**"KSF1"**, **"KSF2"**,
           **"SRG"**, **"LQSGW"**]*) --

           The quasi-particle Hamiltonian can be constructed in
           different ways.

           KSF1 refers to the original construction by Kotani, Van
           Schilfgaarde anf Faleev (KSF) which is also implemented in
           TURBOMOLE.

           KSF2 refers to an alternative construction by KSF.

           KSF1 is not recommended since it is numerically less stable
           than KSF2 in case analytical continuation is used (the
           default).

           In case the analytical integration algorithm is used, only
           KSF1 is implemented. Therefore, make sure that KSF1 is
           specified. The results are typically very similar.

           The QP energies at which the matrix elements are evaluated
           can be tweaked further, see the two subsequent keys:
           However, KSF2 is recommended since it typically leads to QP
           energies with the best agreement with experiment.

           Ignored when not a quasi-particle self-consistent GW
           calculation is performed

         * **Scaling** (*float** | **FloatKey*) -- Scale factor for
           the polarizability in the screened interaction SOS-GF2.
           Default = 1.0 (corresponds to no scaling)

         * **ScissorShift** (*BoolType** | **BoolKey*) --

           Only calculate the HOMO and LUMO QP energies and shift the
           remaining QP energies by the same amount.

           This is a rather crude approximation and not recommended.

           It might again be useful for benchmarking purposes.

         * **SelfConsistency** (*Literal**[**"None"**, **"G0W0"**,
           **"EVGW0"**, **"EVGW"**, **"QSGW0"**, **"QSGW"**]*) --

           Sets the level of self-consistency in a GW calculation.

           G0W0 calculates a one-shot, perturbative correction to the
           KS eigenvalues.

           In evGW and evGW0, the quasi-particle energies are updated
           until self-consistency is reached.

           evGW0 requests that the Green's function is evaluated self-
           consistently but not the screened interaction.

           In qsGW, the density is updated as well, however, the self-
           energy is mapped to a static effective potential and the
           Dyson equation is solved by diagonalization instead of
           inversion. The results of a qsGW are independent of the
           choice of the underlying exchange-correlation functional
           and are usually the most accurate ones.

           The same is done in qsGW0, but the screened interaction is
           not updated.

         * **SelfConsistentSigmaVertex** (*BoolType** | **BoolKey*) --
           If active, evaluate the vertex correction in Sigma in qsGW
           self-consistent. Only supported for GWGammaInf so far

         * **SelfEnergy** (*Literal**[**"HF"**, **"GW"**, **"G3W2"**,
           **"SOSEX"**, **"GWGamma"**, **"G3W2dynamic"**,
           **"GWGammaInf"**, **"GWGammaInfDyn"**]*) --

           Controls the form of the self-energy.

           GW is the default and corresponds to the standard GW
           calculation.

           G3W2 is a GW calculation plus a perturbative second-order
           statically screened exchange correction (second order
           expansion in the self-energy). Note, that there the self-
           energy is always static.

         * **TabulateGridPoints** (*BoolType** | **BoolKey*) --
           pretabulate grid points for numerical integration.

         * **nIterations** (*Iterable**[**int**] **| **IntListKey*) --

           The maximum number of iterations within the (partially or
           fully) self-consistent GW calculation has to converge.

           Ignored when Formalism is set to G0W0

         * **nLowest** (*int** | **IntKey*) -- Number of lowest
           occupied QP levels to be evaluated, overwrites nStates'

         * **nStates** (*int** | **IntKey*) --

           Number of Quasiparticle States to be printed to output.

           The default is 5 states which in this case means that
           min(5, Number of particle states) occupied and min(5,
           Number of hole states) hole states are printed. The whole
           list of states can be printed by setting this parameter to
           -1'

         * **preconditionQSGW** (*BoolType** | **BoolKey*) --

           If true, the QSGW equations are solved but prior to each
           diagonalization, i.e. a G0W0 calculation is performed to
           find the optimal QP energies at which to analytically
           continue the self-energy.

           This is in principle a more consistent construction than
           KSF1 or KSF2 since the diagonal elements are consistent
           with G0W0.

           In KSF1 and KSF2, the diagonal elements are evaluated at
           the QP energies from the previous iteration which is
           equivalent to a zeroth-order Taylor expansion of the
           diagonal elements around the previous QP energies.Enabling
           this option typically leads to slightly lower QP energies.

         * **AnalyticalIntegration**
           (*ADF._GW._AnalyticalIntegration*) -- Use analytical
           integration to calculate the self-energy. Very slow, unless
           the system is very small but useful to check the accuracy
           of the frequency integration

         * **Converge** (*ADF._GW._Converge*) -- Sets convergence
           criteria for the GW calculation in self-consistent case

      class _AnalyticalIntegration

         Use analytical integration to calculate the self-energy. Very
         slow, unless the system is very small but useful to check the
         accuracy of the frequency integration

         Variables:
            * **Enabled** (*BoolType** | **BoolKey*) -- Enable the
              calculation of the GW quasi-particle energies via
              analytical integration.

            * **SpectralFunctionResolution** (*int** | **IntKey*) --
              Number of points at which spectral function is
              evaluated.

            * **TDA** (*BoolType** | **BoolKey*) -- Solve the linear
              response equations in the Tamm-Dancoff approximation.

            * **eta** (*float** | **FloatKey*) --

              Artificial (positive) broadening parameter for
              evaluation of self-energy in analytical integration.

              Ideally should be as small as possible but this might
              lead to convergence issues in partially self-consistent
              approaches.

              In this case, a value of up to 0.1 is possible.

            * **printBSEexcitationsInLastIteration** (*BoolType** |
              **BoolKey*) --

              Print out BSE excitations in the last iteration in a
              qsGW calculation. Can be used in the BAND engine.

              In ADF, one should instead just calculate excitation
              energies using the excitation block.

      class _Converge

         Sets convergence criteria for the GW calculation in self-
         consistent case

         Variables:
            * **Density** (*Iterable**[**float**] **| **FloatListKey*)
              --

              First Criterion for self-consistency procedure to
              terminate.

              Criterion is the trace of the density matrix. Ignored in
              non-selfconsistent Calculation and in eigenvalue self-
              consistent GW

              It is possible to run a qsGW calculation with an inner
              SCF loop which updates the static part of the elf-energy
              only. This can be useful to accelerate the convergence
              in case linear mixing is used. It is not recommended to
              use linear mixing, so it is also not recommended to use
              that inner loop as well. The second number in this list
              specifies the convergence criterion for the inner SCF
              loop.

            * **HOMO** (*float** | **FloatKey*) --

              Criterion for self-consistency procedure to terminate.

              The self-consistent GW calculation terminates, when the
              difference between the HOMO QP energies between 2
              consecutive iterations is below this number.

              The LUMO energy converged faster than the HOMO energy so
              when the HOMO energy is converged according to this
              criterion, the LUMO energy will be converged as well.

              In non-selfconsistent Calculation, this criterion is
              ignored.

   class _IQA

      Total energy decomposition based on the interacting quantum
      atoms (IQA) approach and using QTAIM real-space partition.

      Variables:
         * **Accuracy** (*float** | **FloatKey*) -- Placeholder

         * **AtomsToDo** (*Iterable**[**int**] **| **IntListKey*) --

           Define a subset of atoms for which the IQA atom-atom
           interactions are calculated (no intra-atomic terms).

           If left empty, all atoms will be included (full IQA).

         * **Enabled** (*BoolType** | **BoolKey*) -- Calculate the
           total energy decomposition using the interacting quantum
           atoms (IQA) approach and the QTAIM real-space partitioning.

         * **Interactions** (*Literal**[**"inter"**, **"all"**,
           **"debug"**]*) -- Placeholder

         * **Print** (*Literal**[**"normal"**, **"verbose"**]*) --
           Minimal output (default) or verbose mode (detailed energy
           decomposition)

   class _Integration

      Options for the Voronoi numerical integration scheme

      Variables:
         * **ACCINT** (*Iterable**[**float**] **| **FloatListKey*) --
           The main precision parameter Its value defines the number
           of significant digits by which an internal set of standard
           integrals must be evaluated. The number and distribution of
           integration points is tuned accordingly. For normal
           applications this should yield a nearly optimal (given the
           underlying method) generation of points and weights. The
           default depends on the run type.

         * **ACCOUT** (*float** | **FloatKey*) -- The region of space
           further away from the atoms, outside the polyhedrons, has
           its own precision parameter. By default accout=accint.

         * **ACCPYR** (*float** | **FloatKey*) -- Similarly this
           subkey sets the test level for the parts of the pyramids
           outside the atomic sphere. Default: accpyr=accint.

         * **ACCPYU** (*float** | **FloatKey*) -- The truncated
           pyramids are mathematically transformed into unit cubes. A
           product Gauss integration formula is applied to the cubes,
           with three (test precision) parameters for the three
           dimensions. Accpyw controls the direction that is
           essentially the radial integration from the surface of the
           atomic sphere to the base of the pyramid. The other two
           control the orthogonal directions (angular). By default all
           three equal accpyr.

         * **ACCPYV** (*float** | **FloatKey*) -- The truncated
           pyramids are mathematically transformed into unit cubes. A
           product Gauss integration formula is applied to the cubes,
           with three (test precision) parameters for the three
           dimensions. Accpyw controls the direction that is
           essentially the radial integration from the surface of the
           atomic sphere to the base of the pyramid. The other two
           control the orthogonal directions (angular). By default all
           three equal accpyr.

         * **ACCPYW** (*float** | **FloatKey*) -- The truncated
           pyramids are mathematically transformed into unit cubes. A
           product Gauss integration formula is applied to the cubes,
           with three (test precision) parameters for the three
           dimensions. Accpyw controls the direction that is
           essentially the radial integration from the surface of the
           atomic sphere to the base of the pyramid. The other two
           control the orthogonal directions (angular). By default all
           three equal accpyr.

         * **ACCSPH** (*float** | **FloatKey*) -- The polyhedron
           method of generating integration points partitions space in
           atomic polyhedrons, partitioned in pyramids with their tops
           at the atom in the center of the polyhedron. A core like
           atomic sphere is constructed around the atom; this
           truncates the tops of the pyramids. accsph specifies the
           test precision for the generation of points within the
           spheres. By default accsph=accint.

         * **DISHUL** (*float** | **FloatKey*) -- Sets the distance
           between the outermost nuclei of the molecule and the
           boundary planes that define the boundary between the
           polyhedrons and the outer region. By default dishul=2.3*R,
           where R is the radius of the largest atomic sphere in the
           molecule.

         * **FRANGE** (*float** | **FloatKey*) -- The outward range of
           the outer region: integration is not performed to infinity
           but to a distance frange from the outermost atoms, where
           all functions can be assumed to be essentially zero. By
           default frange is derived both from accint, the general
           precision parameter, and from the present chemical
           elements: heavier atoms have longer-range functions than
           hydrogen say. The precise relations can be found in the
           implementation.

         * **LINROT** (*int** | **IntKey*) -- This parameter is
           significant only for symmetries with an axis of infinite
           rotational symmetry: C and D It is the highest rotational
           quantum number around this axis that occurs among the
           integrands. This depends on the employed basis functions
           and fit functions. By default the program finds this out
           for itself.

         * **LINTEG** (*Iterable**[**int**] **| **IntListKey*) -- The
           maximum angular momentum quantum number of integrands
           centered on an atom of that type (one value for each atom
           type). This depends on the basis functions and on the fit
           functions. By default the program checks the function sets
           and sets the linteg values accordingly. This subkey is
           applied for the generation of grid points in the atomic
           spheres.

         * **NOUTER** (*int** | **IntKey*) -- This outer region is
           treated by a product formula: outwards times parallel. The
           latter involves two dimensions: the surface of the molecule
           say. The outward integration is performed with Gauss-
           Legendre quadrature, in a few separate steps. The lengths
           of the steps are not equal, they increase by constant
           factors. The total length is fixed. The number of steps is
           controlled with this subkey; default: 2.

         * **OUTPAR** (*float** | **FloatKey*) -- Similarly the
           integration in the directions parallel to the surface of
           the atomic system is controlled by a parameter. See the
           implementation for details.

         * **OUTRAD** (*float** | **FloatKey*) -- The parameter that
           defines the number of Gauss-Legendre integration points for
           each outward step. The precise relation between the actual
           number of points and this subkey, and the default relation
           between outrad and accout can be found in the
           implementation.

         * **QPNEAR** (*float** | **FloatKey*) -- If you specify point
           charges in the input file, there are two considerations
           implied for the numerical integration grid. First, since
           the point charges create a Coulomb singularity. The
           integrands (of for instance the basis function products
           against the Coulomb potential) can only be evaluated with
           high precision if the grid around the point charges has
           spherical symmetry and uses local spherical coordinates,
           exactly as is done for the atomic nuclei. Second, the point
           charges do not carry fit or basis functions, hence they
           play only a role in the more diffuse tails of the actual
           functions involved in integrals. Therefore, a relative low
           precision of the integral part close to the point charge
           may have little effect on the total integration accuracy.
           Since additional ‘spherical centers’ with their own
           surrounding grids increase the total number of points
           significantly, typically a few thousands per Coulomb
           center, this may result in high computational effort.
           Therefore, the program generates spherical grids only about
           those point charges that are close to the other atoms. The
           criterion, input with the qpnear subkey, is the closest
           distance between the point charge at hand and any real
           atom. Default 4.0 Angstrom.

         * **RSPHER** (*Iterable**[**float**] **| **FloatListKey*) --
           Gives the radii of the atomic spheres, one value for each
           atom type. By default, the radii are derived from the
           chemical element (heavier atoms get larger spheres) and
           from the environment: the sphere must not be too large for
           the atomic cell (polyhedron).

   class _IrrepOccupations

      Explicit occupation numbers per irrep

   class _LinearScaling

      Variables:
         * **Cutoff_Coulomb** (*float** | **FloatKey*) -- determines
           the radii for the fit functions in the evaluation of the
           (short-range part of) the Coulomb potential.

         * **Cutoff_Fit** (*float** | **FloatKey*) -- 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.

         * **Cutoff_Multipoles** (*float** | **FloatKey*) --
           determines the cut-offs in the multipole (long-range) part
           of the Coulomb potential

         * **HF_Fit** (*float** | **FloatKey*) -- Parameter for HF
           exchange

         * **Overlap_Int** (*float** | **FloatKey*) -- 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

         * **ProgConv** (*float** | **FloatKey*) -- determines how the
           overall accuracy changes during the SCF procedure

   class _LocOrb

      The computation of localized orbitals is controlled with this
      block-type key

   class _MBPT

      Technical aspects of the MP2 algorithm.

      Variables:
         * **Dependency** (*BoolType** | **BoolKey*) -- If true, to
           improve numerical stability, almost linearly-dependent
           combination of basis functions are removed from the Green's
           function that are used in the MBPT equations. Disabling
           this key is strongly discouraged. Its value can however be
           changed. The key to adjust this value is
           RiHartreeFock%DependencyThreshold

         * **Enabled** (*BoolType** | **BoolKey*) -- Enable the
           calculation of the MP2 energy.

         * **ExcludeCore** (*BoolType** | **BoolKey*) --

           If active, excludes core states from the calculation of the
           optimal imaginary time and frequency grids.

           The core states are still included in all parts of the
           calculations.

           In case a frozen care calculation is performed, this key is
           ignored.

           For MP2 and double hybrid calculation, it defaults to
           false. For RPA and GW calculations, it defaults to true.

         * **FitSetQuality** (*Literal**[**"Auto"**, **"VeryBasic"**,
           **"Basic"**, **"Normal"**, **"Good"**, **"VeryGood"**]*) --

           Specifies the fit set to be used in the MBPT calculation.

           'Normal' quality is generally sufficient for basis sets up
           to and including TZ2P.

           For larger basis sets (or for benchmarking purposes) a
           'VeryGood' fit set is recommended. Note that the
           FitSetQuality heavily influences the computational cost of
           the calculation.

           If not specified or 'Auto', the RIHartreeFock%FitSetQuality
           is used.

         * **Formalism** (*Literal**[**"Auto"**, **"RI"**, **"LT"**,
           **"All"**]*) --

           Specifies the formalism for the calculation of the MP2
           correlation energy.

           'LT' means Laplace Transformed MP2 (also referred to as AO-
           PARI-MP2),

           'RI' means that a conventional RI-MP2 is carried out.

           If 'Auto', LT will be used in case of DOD double hybrids
           and SOS MP2, and RI will be used in all other cases.

           'All' means that both RI and LT formalisms are used in the
           calculation.

           For a RPA or GW calculation, the formalism is always LT,
           irrespective of the formalism specified with this key.

         * **FrequencyGridType** (*Literal**[**"LeastSquare"**,
           **"GaussLegendre"**]*) -- Use Gauss-legendre grid for
           imaginary frequency integration in RPA and GW calculations
           instead of the usually used Least-Square optimized ones.
           Has the advantage that it can be systematically converged
           and an arbitrary number of grid points can be used.
           Typically more grid points will be needed to get the same
           level of accuracy. However, the convergence of the results
           with the size of the grid can be more systematic. These
           grids can only be used when Formalism is set to RI.

         * **IntegrationQuality** (*Literal**[**"VeryBasic"**,
           **"Basic"**, **"Normal"**, **"Good"**, **"VeryGood"**]*) --
           Specifies the integration quality to be used in the MBPT
           calculation. If not specified, the
           RIHartreeFock%IntegrationQuality is used.

         * **PrintOutSigma** (*BoolType** | **BoolKey*) -- Print out
           additional output for sigma-functional for parametrization.

         * **SigmaFunctionalParametrization** (*Literal**[**"W1"**,
           **"W2"**, **"S1"**, **"S2"**, **"S1re"**]*) -- Only
           relevant if a sigma-functional calculation is performed.
           Possible choices for the parametrization of the sigma-
           functional. Not all options are supported for all
           functionals.

         * **ThresholdQuality** (*Literal**[**"VeryBasic"**,
           **"Basic"**, **"Normal"**, **"Good"**, **"VeryGood"**,
           **"Excellent"**]*) -- Controls the distances between atomic
           centers for which the product of two basis functions is not
           fitted any more. Especially for spatially extended, large
           systems, 'VERYBASIC' and 'BASIC' can lead to large
           computational savings, but the fit is also more
           approximate. If not specified, the
           RIHartreeFock%ThresholdQuality is used.

         * **UseScaledZORA** (*BoolType** | **BoolKey*) -- If true,
           use the scaled ZORA orbital energies instead of the ZORA
           orbital energies in the MBPT equations.

         * **cutOfftransition** (*float** | **FloatKey*) -- Energy
           above which states are ignored in a MBPT calculation (must
           be a positive number). The default energy is chosen so
           high, that all states are included except for the ones
           which have been removed.

         * **frozencore** (*BoolType** | **BoolKey*) -- Freeze core
           states in correlation part of MBPT calculation

         * **nCore** (*int** | **IntKey*) --

           Number of core states which will be excluded from the
           correlated calculation.

           Will be ignored if frozencore is false.

           In case nothing is specified, the number of core levels
           will be determined automatically.

           Needs to be smaller than the number of occupied states.

         * **nFreqIntegration** (*int** | **IntKey*) -- Number of
           imaginary frequency points for G3W2 integration

         * **nFrequency** (*int** | **IntKey*) -- Number of imaginary
           frequency points. This key is only relevant for RPA and GW
           and will be ignored if used in an AO-PARI-MP2 calculation.
           12 Points is the default for a RPA calculation. It is
           technically possible to use a different number of imaginary
           frequency points than for imaginary time. The maximum
           number of points which can be requested for imaginary
           frequency integration is 42. Important note: The
           computation time and memory requirements roughly scale
           linearly with the number of imaginary frequency points.
           However, memory can be an issue for RPA and GW when the
           number of imaginary frequency points is high. In case a job
           crashes, it is advised to increase the number of nodes
           since the necessary memory distributes over all nodes.

         * **nLambda** (*int** | **IntKey*) -- Size of coupling
           constant integration grid for SOSEX variants in RPA.
           Default is 4 points

         * **nTime** (*int** | **IntKey*) --

           Number of imaginary time points (only relevant in case the
           Laplace Transformed (LT) formalism is used).

           In the many-body-perturbation theory module in ADF, the
           polarizability (or Kohn-Sham density response function) is
           evaluated in imaginary time to exploit sparsity in the AO
           basis. For MP2, this is often referred to as a Laplace
           transform. For MP2, 9 points are the default. This is a
           safe choice, guaranteeing accuracies higher than 1 Kj/mol
           for most systems (For many simple organic systems, 6 points
           are sufficient for good accuracy).

           Only for systems with a very small HOMO-LUMO gap or low-
           lying core states (heavy elements starting from the 4th row
           of the periodic table) more points might be necessary.

           In principle, the same considerations apply for RPA and GW
           as well, however, the accuracy requirements are somewhat
           higher and 12 point are the default for RPA. In a GW
           calculation, the number of points is adjusted according to
           the numerical quality. Using less than 9 points is strongly
           discouraged except for the simplest molecules.

           In ADF2019, it can happen that the algorithm determining
           the imaginary time grid does not converge. In this case,
           the usual reason is that the number of points is too small
           and more points need to be specified. Starting from
           AMS2020, this does not happen any more. In case the
           imaginary time grid does not converge, the number of points
           is automatically adjusted until it does.

           The computation time of AO-PARI-MP2, RPA, and GW scales
           linearly with the number of imaginary time points.

         * **useGreenXgrids** (*BoolType** | **BoolKey*) -- Use GreenX
           library to generate grid points. This is recommended for
           larger number of grid points (> 20). Up to 34 points can be
           requested.

   class _MDC

      Options for Multipole Derived Charges (MDC)

      Variables:
         * **Debug** (*BoolType** | **BoolKey*) -- Print debug
           information on MDC

         * **ExpMCD** (*float** | **FloatKey*) -- Exponent for MDC

         * **IncDum** (*int** | **IntKey*) -- Parameter for including
           dummy atoms as positions for distributed charges

         * **MDCExp** (*int** | **IntKey*) -- kind of weight function
           to be used (Gaussian or Slater[=default])

         * **TolMDC** (*float** | **FloatKey*) -- Numerical accuracy
           parameter

   class _ModifyExcitation

      Variables:
         * **DipStrength** (*float** | **FloatKey*) --

         * **GRIMMEAEX** (*float** | **FloatKey*) --

         * **GRIMMEALPHA** (*float** | **FloatKey*) --

         * **GRIMMEBETA** (*float** | **FloatKey*) --

         * **GRIMMEDEMAX** (*float** | **FloatKey*) --

         * **GRIMMEPERTC** (*BoolType** | **BoolKey*) --

         * **GRIMMETPMIN** (*float** | **FloatKey*) --

         * **HighExcit** (*float** | **FloatKey*) --

         * **NOGRIMMEPERTC** (*BoolType** | **BoolKey*) --

         * **NOverlap** (*int** | **IntKey*) --

         * **OscStrength** (*float** | **FloatKey*) -- 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

         * **SetLargeEnergy** (*float** | **FloatKey*) -- 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

         * **SetOccEnergy** (*float** | **FloatKey*) -- 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.

         * **UseOccRange** (*Iterable**[**float**] **|
           **FloatListKey*) -- Use only occupied orbitals which have
           orbital energies between the two numbers.

         * **UseOccVirtNumbers** (*Iterable**[**int**] **|
           **IntListKey*) -- 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.

         * **UseOccVirtRange** (*Iterable**[**float**] **|
           **FloatListKey*) -- Use only pairs of an occupied and
           virtual orbital, for which the orbital energy difference is
           between the two numbers

         * **UseScaledZORA** (*BoolType** | **BoolKey*) -- 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.

         * **UseVirtRange** (*Iterable**[**float**] **|
           **FloatListKey*) -- Use only virtual orbitals which have
           orbital energies between the two numbers

         * **UseOccupied** (*str** | **Sequence**[**str**] **|
           **FreeBlock*) -- Use only the occupied orbitals which are
           specified

         * **UseVirtual** (*str** | **Sequence**[**str**] **|
           **FreeBlock*) -- Use only the virtual orbitals which are
           specified

      class _UseOccupied

         Use only the occupied orbitals which are specified

      class _UseVirtual

         Use only the virtual orbitals which are specified

   class _ModifyStartPotential

      Modify the starting spin-dependent potential for unrestricted
      calculations.

   class _Nanoparticle

      To include the presence of a nanoparticle near the system

      Variables:
         **TransitionPotential** (*BoolType** | **BoolKey*) --
         Evaluate the transition potential due to a nanoparticle

   class _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.

      Variables:
         * **Alfa** (*BoolType** | **BoolKey*) -- Analyze the static
           or dynamic polarizability

         * **BField** (*BoolType** | **BoolKey*) -- The perturbation
           is a magnetic field. Should be consistent with AORESPONSE

         * **Beta** (*BoolType** | **BoolKey*) -- 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

         * **Diag** (*BoolType** | **BoolKey*) -- Only analyze the
           diagonal of the response tensor

         * **Dynamic** (*BoolType** | **BoolKey*) -- Should be used
           for a frequency dependent perturbation field.

         * **EField** (*BoolType** | **BoolKey*) -- The perturbation
           is an electric field

         * **Fulltens** (*BoolType** | **BoolKey*) -- The full tensor
           is analyzed

         * **GPrime** (*BoolType** | **BoolKey*) -- Analyze the G'
           (gyration) tensor, for optical rotation dispersion.
           Requires a frequency dependent perturbation field, with a
           frequency (omega) unequal to zero.

         * **Static** (*BoolType** | **BoolKey*) -- should be used for
           a static field

   class _PolTDDFT

      POLTDDFT is a fast algorithm to solve the TDDFT equations in the
      space of the density fitting auxiliary basis set. The (real and
      imaginary part of the) diagonal of the polarizability tensor and
      rotatory strengths will be calculated, which can be used to
      calculate the photoabsorption and circular dichroism (CD)
      spectra.

      Variables:
         * **Analysis** (*BoolType** | **BoolKey*) -- An analysis of
           the absorption and CD spectrum in terms of single orbital
           transitions.

         * **CutOff** (*float** | **FloatKey*) -- 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.

         * **Enabled** (*BoolType** | **BoolKey*) -- 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.

         * **FreqRange** (*Iterable**[**float**] **| **FloatListKey*)
           -- Specifies a frequency range of frequencies of incident
           light, the perturbing field, at which the complex dynamical
           polarizability will be calculated. 2 numbers: an upper and
           a lower bound. Use subkey NFreq to specify the number of
           frequencies.

         * **HDA_fitted** (*BoolType** | **BoolKey*) -- Use fit
           functions to calculate HDA (Hybrid diagonal approximation),
           only relevant for hybrids.

         * **KGrid** (*float** | **FloatKey*) -- Keyword KGRID is used
           to discretize the energy scale for calculating the complex
           dynamical polarizability. Only pairs of an occupied and
           virtual orbital are included, for which the orbital energy
           difference is lower than this value. Use key NGRID to set
           the number of points within the energy grid.

         * **Lambda** (*float** | **FloatKey*) --

           Jacob's scaling factor for the study of plasmonic
           resonances.

           This factor, 0<lambda<1, turns on the coupling matrix K.

         * **Lifetime** (*float** | **FloatKey*) --

           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.

         * **NFreq** (*int** | **IntKey*) -- NFreq is the number of
           frequencies of incident light, the perturbing field, at
           which the complex dynamical polarizability will be
           calculated. Use FreqRange to specify the frequency range.

         * **NGrid** (*int** | **IntKey*) -- Ngrid is the number of
           points within the energy grid.

         * **N_FitOrb** (*int** | **IntKey*) -- The number of vectors
           containing the coefficients we use to expand the projection
           of each fitting function over the electron density (of a
           particular molecular orbital) as a linear combination of
           overlap matrices between fitting functions pair

         * **N_HDA_integral** (*int** | **IntKey*) --

         * **N_SubMatricesAk** (*int** | **IntKey*) --

         * **Print_Int_Time** (*int** | **IntKey*) -- Print detailed
           timing during calculation of integrals of Tape63 and Tape64

         * **RegionsForAnalysis** (*str** | **StringKey*) -- Names of
           regions for analysis per region using the fragment
           projection analysis approach. Will split the absorption and
           CD spectrum in region_i -> region_j terms.

         * **Velocity** (*BoolType** | **BoolKey*) --

           If True, ADF calculates the dipole moment in velocity
           gauge.

           If false: dipole-length representation is used

         * **Irrep** (*str** | **Sequence**[**str**] **| **FreeBlock*)
           -- 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

      class _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

   class _QMFQ

      Block input key for QM/(w)FQ(FMu).

      Variables:
         * **DEBUG** (*BoolType** | **BoolKey*) -- The DEBUG subkey
           will print additional information from the FQ subroutines.

         * **EFFECTIVEPOLAR** (*BoolType** | **BoolKey*) -- Calculate
           wFQ(Fmu)QM effective polarizability

         * **FDERESP** (*BoolType** | **BoolKey*) -- In response
           calculations (TD), the polarization contribution of the FDE
           part is introduced at the FQ level [See F. Egidi et al. J.
           Chem. Phys. 2021, 154, 164107].

         * **Forcefield** (*Literal**[**"FQ"**, **"FQ_RQ"**,
           **"FQFMU"**, **"FQFMU_RQRMU"**, **"NOPOL"**, **"wFQ"**,
           **"wFQ_RQ"**, **"wFQFmu"**, **"wFQFmu_RQRMU"**]*) --
           Version of the FQ family of polarizable forcefields

         * **Frozen** (*BoolType** | **BoolKey*) -- Expert option. Do
           not introduce polarization effect in response calculations.

         * **GROUNDSTATE** (*BoolType** | **BoolKey*) -- Introduce FQ
           effects on ground state calculations

         * **Kernel** (*Literal**[**"OHNO"**, **"COUL"**,
           **"GAUS"**]*) -- Expert option. KERNEL can be used to
           choose the functional form of the charge-charge interaction
           kernel between MM atoms. Recommended is to use the default
           OHNO. The COUL screening is the standard Coulomb
           interaction 1/r. The OHNO choice introduce the Ohno
           functional (see [K. Ohno, Theoret. Chim. Acta 2, 219
           (1964)]), which depends on a parameter n that is set equal
           to 2. Finally, the GAUS screening models each FQ charge by
           means of a spherical Gaussian-type distribution, and the
           interaction kernel is obtained accordingly. For QM/FQFMU
           only GAUS SCREEN is implemented.

         * **LifeFrequency** (*float** | **FloatKey*) -- Input
           frequency for calculating TDDFT/wFQ(Fmu) lifetimes

         * **LifeState** (*int** | **IntKey*) -- Target excited state
           for state-specific TDDFT/wFQ(Fmu) lifetimes

         * **MolCharge** (*float** | **FloatKey*) -- Total charge of
           each fragment (FQ only)

         * **NOGROUNDSTATE** (*BoolType** | **BoolKey*) -- Avoid
           introducing FQ effects on ground state calculations

         * **NOLOCALFIELD** (*BoolType** | **BoolKey*) -- Switch off
           wFQ(Fmu) local field effects in polarizability
           calculations.

         * **NonEle** (*Literal**[**"LJ"**, **"None"**]*) -- Whether
           to include non-electrostatic contributions to the energy.
           Default is the Lennard-Jones (LJ) model.

         * **QMSCREEN** (*Literal**[**"ERF"**, **"EXP"**, **"GAUS"**,
           **"NONE"**]*) -- Expert option. QMSCREEN can be used to
           choose the functional form of the charge-charge interaction
           kernel between MM atoms and the QM density. The screening
           types available are ERF (error function), EXP
           (exponential), GAUS (Gaussian), or NONE. The default is
           GAUS.

         * **QMSCREENFACTOR** (*float** | **FloatKey*) -- Expert
           option. Sets the QM/MM interaction kernel screening length.
           Recommended is to use the default value 0.2 with the GAUS
           QM/MM screening function.

         * **ReadDynamicMatrix** (*str** | **Path** | **StringKey*) --
           The absolute path to the decomposed wFQ(FMu) matrix file

         * **WriteDynamicMatrix** (*BoolType** | **BoolKey*) -- Write
           decomposed wFQ(Fmu) matrix as wFQMat_freq in a separate
           file.

         * **AtomType** (*ADF._QMFQ._AtomType*) -- Definition of
           atomic types in MM environment

         * **Coords** (*str** | **Sequence**[**str**] **|
           **FreeBlock*) -- Coordinates and fragment information (FQ
           only)

         * **Repulsion** (*ADF._QMFQ._Repulsion*) -- Definition of
           parameters for Pauli repulsion (see JCTC ....)

         * **Solver** (*ADF._QMFQ._Solver*) --

      class _AtomType

         Definition of atomic types in MM environment

         Variables:
            * **Alpha** (*float** | **FloatKey*) -- Polarizability of
              FQFMU atom

            * **Area** (*float** | **FloatKey*) -- Effective charge-
              transfer area time between same-type wFQ atoms

            * **Charge** (*float** | **FloatKey*) -- MM fixed charge
              (non-polarizable only)

            * **Chi** (*float** | **FloatKey*) -- Electronegativity of
              FQ atom

            * **Dfermi** (*float** | **FloatKey*) -- wFQ d parameter
              for Fermi damping

            * **Efermi** (*float** | **FloatKey*) -- Fermi Energy of
              wFQ carbon-based structure

            * **Eta** (*float** | **FloatKey*) -- Chemical Hardness of
              FQ atom

            * **R0** (*float** | **FloatKey*) -- wFQ R0 parameter for
              Fermi damping

            * **RMU** (*float** | **FloatKey*) -- Variance for
              FQFMU_RQRMU Gaussians

            * **RQ** (*float** | **FloatKey*) -- Variance for FQ_RQ
              Gaussians

            * **Sfermi** (*float** | **FloatKey*) -- wFQ s parameter
              for Fermi damping

            * **Sigma0** (*float** | **FloatKey*) -- Static
              conductivity time of wFQ atom

            * **Symbol** (*str** | **StringKey*) -- Symbol associated
              with atom type

            * **Tau** (*float** | **FloatKey*) -- Scattering time of
              wFQ atom

            * **wFQFMuFile** (*str** | **Path** | **StringKey*) -- The
              absolute path to the wFQFMu interband polarizability
              file

      class _Coords

         Coordinates and fragment information (FQ only)

      class _Repulsion

         Definition of parameters for Pauli repulsion (see JCTC ....)

         Variables:
            * **AtomDistance** (*float** | **FloatKey*) -- Each
              fictitious Slater function is added only if the
              associated MM atom is closer than the AtomDistance
              threshold (in Angstrom) to a QM atom

            * **Basis** (*ADF._QMFQ._Repulsion._Basis*) -- Slater type
              basis function to add on a specific atom type in the
              environment.

         class _Basis

            Slater type basis function to add on a specific atom type
            in the environment.

            Variables:
               * **AngMom** (*int** | **IntKey*) -- Angular momentum

               * **AtomType** (*str** | **StringKey*) -- Atom Type on
                 which the basis function has to be added

               * **Coeff** (*float** | **FloatKey*) -- Coefficient of
                 the basis function

               * **Exp** (*float** | **FloatKey*) -- Exponent of the
                 basis function

      class _Solver

         Variables:
            * **Algorithm** (*Literal**[**"DIRECT"**, **"ITER"**]*) --

            * **Debug** (*BoolType** | **BoolKey*) --

            * **NumIt** (*int** | **IntKey*) --

            * **THRESH** (*float** | **FloatKey*) --

   class _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.

      Variables:
         * **AnalysisLevel** (*Literal**[**"Normal"**, **"Extended"**,
           **"Full"**]*) --

           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, plus basin information on TAPE10

           Full - same as Extended plus non-local descriptors.

         * **AtomsToDo** (*Iterable**[**int**] **| **IntListKey*) --
           List of atoms for which condensed descriptors are to be
           calculated. By default all atoms are included.

         * **Enabled** (*BoolType** | **BoolKey*) -- Calculate QTAIM
           (also known as Bader) properties.

         * **Energy** (*BoolType** | **BoolKey*) -- Calculate atomic
           energies. Requires an all-electron calculation (no frozen
           core), triggers the TotalEnergy and increases the
           [AnalysisLevel] to at least Extended.

         * **Source** (*BoolType** | **BoolKey*) -- Calculate the
           Source Function at BCPs and RCPs.

         * **Spacing** (*float** | **FloatKey*) -- 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.

   class _RIHartreeFock

      Variables:
         * **DependencyCoreRange** (*float** | **FloatKey*) -- Basis
           functions may be given a core character based on the range.
           For now only active in Band and only if present in the
           input

         * **DependencyThreshold** (*float** | **FloatKey*) --

           To improve numerical stability, almost linearly-dependent
           combination of basis functions are removed from the
           Hartree-Fock exchange matrix.

           If you obtain unphysically large bond energy in an Hybrid
           calculation, or an unphysically low correlation energy in
           an RPA, MP2, or double hybrid calculation, you might try
           setting the DependencyThreshold to a larger value (e.g.
           3.0E-3)

           Note, that in GW calculations and GW-BSE calculations the
           default for this key is 5.0e-3.

         * **DoAlternativeDependencyTrick** (*BoolType** | **BoolKey*)
           -- Only applies to band. Do trick on the density matrix
           being input to HFEval, rather than on the K-matrix.

         * **DoDependencyTrick** (*BoolType** | **BoolKey*) --
           Available only in BAND, turns on and off the RIHartreeFock
           dependency trick.

         * **FitSetQuality** (*Literal**[**"Auto"**, **"VeryBasic"**,
           **"Basic"**, **"Normal"**, **"Good"**, **"VeryGood"**,
           **"Excellent"**, **"FromBasisProducts"**]*) --

           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.

         * **IntegrationQuality** (*Literal**[**"VeryBasic"**,
           **"Basic"**, **"Normal"**, **"Good"**, **"VeryGood"**,
           **"Excellent"**]*) -- 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.

         * **Quality** (*Literal**[**"Auto"**, **"VeryBasic"**,
           **"Basic"**, **"Normal"**, **"Good"**, **"VeryGood"**,
           **"Excellent"**]*) -- Numerical accuracy of the RI
           procedure. If 'Auto', the quality specified in the
           'NumericalQuality' will be used.

         * **ResponseQuality** (*Literal**[**"VeryBasic"**,
           **"Basic"**, **"Normal"**, **"Good"**, **"VeryGood"**,
           **"Excellent"**]*) -- Numerical accuracy of the RI
           procedure for the Response module.

         * **ThresholdQuality** (*Literal**[**"VeryBasic"**,
           **"Basic"**, **"Normal"**, **"Good"**, **"VeryGood"**,
           **"Excellent"**]*) -- 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.

         * **UseCoulombMetricForDependency** (*BoolType** |
           **BoolKey*) -- Use Coulomb metric for the Dependency Trick
           (band only)

         * **UseMe** (*BoolType** | **BoolKey*) -- Set to False if you
           want to use the old RI scheme (ADF only)

         * **ExplicitThresholds**
           (*ADF._RIHartreeFock._ExplicitThresholds*) -- Override the
           thresholds as implied by the ThresholdQuality.

         * **FitGenerationDetails**
           (*ADF._RIHartreeFock._FitGenerationDetails*) -- Technical
           details about how the RI Hartree-Fock fit functions are
           generated.

         * **QualityPerRegion**
           (*ADF._RIHartreeFock._QualityPerRegion*) -- Sets the fit-
           set quality for all atoms in a region. If specified, this
           overwrites the globally set quality.

      class _ExplicitThresholds

         Override the thresholds as implied by the ThresholdQuality.

         Variables:
            * **Basis** (*float** | **FloatKey*) -- Threshold for the
              basis functions.

            * **Fit** (*float** | **FloatKey*) -- Threshold for the
              fit functions.

            * **Potential** (*float** | **FloatKey*) -- Threshold for
              the potential of the functions.

      class _FitGenerationDetails

         Technical details about how the RI Hartree-Fock fit functions
         are generated.

         Variables:
            * **BoostL** (*BoolType** | **BoolKey*) --

              Add extra max(l)+1 diffuse function

              When l denotes the highest angular momentum present in
              the primary basis,

              FromBasisProducts will generate auxiliary fit functions
              with up to 2l angular momentum.

              When this key is set to true, the maximum angular
              momentum in the auxiliary fit set becomes 2l+2.

              Typically, this option is not needed and when precision
              issues arise, it is rather advised to adjust the
              OneCenterDependencyThreshold key to a smaller value.

            * **LapackWorkAround** (*BoolType** | **BoolKey*) --
              GetFitFunctionsForAtomType diagonalization done with
              Lapack instead of Scalapack

            * **Method** (*Literal**[**"Auto"**,
              **"FromBasisProducts"**]*) --

              The way in which fit functions are generated. The main
              distinction is whether it depends on the basis functions
              used.

              When FromBasisProducts is used, the auxiliary basis is
              generated directly from the products of primary basis
              functions.

              This has the advantage that the auxiliary fit adapts
              automatically to the basis set size.

              Especially for basis sets of QZ quality or larger, this
              is often necessary to obtain highly precise correlation
              energies using RPA or double hybrids

              FromBasisProducts option is also useful for GW or BSE
              calculations with basis sets of QZ quality or larger.

            * **OneCenterDependencyThreshold** (*float** |
              **FloatKey*) --

              This key is only active when FromBasisProducts is chosen
              as method to generate the auxiliary basis.

              This threshold controls the size, and at the samw time,
              the precision of the auxiliary basis set. A smaller
              number leads to a larger auxiliary fit set.

              The default value of 1e-8 is typically sufficient to
              converge correlation energies and QP energies to a very
              high precision.

              It corresponds to an auxiliary basis which is typically
              8-9 times larger than the primary basis.

            * **UseBandRadialGrid** (*BoolType** | **BoolKey*) --

              Only applies to band. The band logarithmic grid ranges
              (by default) from 1e-6 to 100 with 3000 points.
              Otherwise 300 points will be used.

              For 0-periodicity (molecules) it is advisable to set
              this key to false since lots of memory is needed to
              evaluate all necessary integrals.

      class _QualityPerRegion

         Sets the fit-set quality for all atoms in a region. If
         specified, this overwrites the globally set quality.

         Variables:
            * **Quality** (*Literal**[**"VeryBasic"**, **"Basic"**,
              **"Normal"**, **"Good"**, **"VeryGood"**,
              **"Excellent"**]*) -- This region's quality of the
              auxiliary fit set employed in the RI scheme.

            * **Region** (*str** | **StringKey*) -- The identifier of
              the region for which to set the quality.

   class _RISM

      3D-RISM-related input keys.

   class _ROSE

      Options for orbital localization

      Variables:
         * **Additional_virtuals_cutoff** (*float** | **FloatKey*) --
           Specifies the energy threshold to determine the number of
           additional hard virtuals to localize for the supermolecule.
           If not specified the default value is used.

         * **Exponent** (*int** | **IntKey*) -- The value of the
           exponent (for the default Pipek-Mezey type of localization,
           the exponent is equal to 2. A higher value of 3 or 4 is
           sometimes useful.).

         * **Frag_bias** (*Iterable**[**float**] **| **FloatListKey*)
           -- Expert key. Specifies the bias applied to each fragment
           when assigning the localized orbitals to a particular
           fragment. Use a negative value for default behavior for a
           given fragment. If not specified, or if the number of items
           is unequal the number of fragments, a default bias is used.

         * **Frag_threshold** (*float** | **FloatKey*) -- Specifies
           energy threshold to determine number of reference hard
           virtuals to use for the fragments (needed to localize the
           additional hard virtuals). The total number of reference
           virtuals should be larger than the number of virtual MOs to
           localize (similar to having more reference valence orbitals
           than occupied valence orbitals to localize), so it is
           advisable to use a relatively high value for this
           parameter. If not specified the default value is used.

         * **Frag_valence** (*Iterable**[**int**] **| **IntListKey*)
           -- Expert key. Specifies the number of valence orbitals for
           each fragment. Use a negative value for default behavior
           for a given fragment. If not specified, or if the number of
           items is unequal the number of fragments, by default the
           code generates the valence space for each fragment as the
           sum of valence orbitals of individual atoms within each
           fragment.

         * **FragmentFile** (*str** | **Path** | **StringKey*) -- Path
           (either absolute or relative) of each fragment file. The
           number of fragments used to project on will be number of
           occurrences of this key.

         * **GWenergies** (*BoolType** | **BoolKey*) -- Use GW
           energies instead of DFT energies.

         * **GWorbitals** (*BoolType** | **BoolKey*) -- Use GW
           orbitals instead of DFT orbitals.

         * **Version** (*Literal**[**"Stndrd_2013"**,
           **"Simple_2013"**, **"Simple_2014"**]*) -- Expert key,
           specifies version of the IAO generation. If not specified a
           default value is used.

         * **nfragments** (*int** | **IntKey*) -- Expert key,
           preferably use the FragmentFile key for each fragment
           instead, and do not use this key. If the FragmentFile key
           is not used, then with this key one can specify the number
           of fragments used to project on. If this key is used the
           fragment file names should be called frag1.rkf, frag2.rkf,
           etcetera, and should be present at the directory where ams
           is started.

   class _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.

      Variables:
         * **NRad** (*int** | **IntKey*) -- The number of radial grid
           points

         * **RMax** (*float** | **FloatKey*) -- The largest distance
           in the radial grid

         * **RMin** (*float** | **FloatKey*) -- The shortest distance
           used in the radial grid

   class _Relativity

      Options for relativistic effects.

      Variables:
         * **Formalism** (*Literal**[**"Pauli"**, **"ZORA"**,
           **"X2C"**, **"RA-X2C"**]*) --

           Note that if Level is None, no relativistic effects are
           taken into account, irrespective of the chosen formalism.

           Pauli stands for the Pauli Hamiltonian.

           ZORA means the Zero Order Regular Approximated Hamiltonian,
           recommended.

           X2C and RA-X2C both stand for an exact transformation of
           the 4-component Dirac equation to 2-components.

           X2C is the modified Dirac equation by Dyall.

           RA-X2C is the regular approach to the modified Dirac
           equation.

         * **Level** (*Literal**[**"None"**, **"Scalar"**, **"Spin-
           Orbit"**]*) --

           None: No relativistic effects.

           Scalar: Scalar relativistic. This option comes at very
           little cost.

           Spin-Orbit: Spin-orbit coupled. This is the best level of
           theory, but it is (4-8 times) more expensive than a normal
           calculation. Spin-orbit effects are generally quite small,
           unless there are very heavy atoms in your system,
           especially with p valence electrons (like Pb).

           See also the SpinOrbitMagnetization subkey.

         * **Potential** (*Literal**[**"MAPA"**, **"SAPA"**]*) --
           Starting from ADF2017 instead of SAPA (the Sum of neutral
           Atomic potential Approximation) MAPA is used by default for
           ZORA. The MAPA (the Minimum of neutral Atomic potential
           Approximation) at a point is the minimum of the neutral
           Atomic potentials at that point. Advantage of MAPA over
           SAPA is that the gauge dependence of ZORA is reduced. The
           ZORA gauge dependency is small for almost all properties,
           except for the electron density very close to a heavy
           nucleus. The electron density very close to a heavy nucleus
           can be used for the interpretation of isomer shifts in
           Mossbauer spectroscopy.

         * **SOUExact** (*BoolType** | **BoolKey*) -- Expert option
           for unrestricted spin-orbit coupled calculations.

         * **SpinOrbitMagnetization** (*Literal**[**"NonCollinear"**,
           **"Collinear"**, **"CollinearX"**, **"CollinearY"**,
           **"CollinearZ"**]*) --

           Relevant only for spin-orbit coupling and if unrestricted
           key has been activated.

           Most XC functionals have as one ingredient the spin
           polarization in case of unrestricted calculations. Normally
           the direction of the spin quantization axis is arbitrary
           and conveniently chosen to be the z-axis.

           However, in a spin-orbit calculation the direction matters,
           and it is arbitrary to put the z-component of the
           magnetization vector into the XC functional. There is also
           the exotic option to choose the quantization axis along the
           x or y axis.

           It is also possible to plug the size of the magnetization
           vector into the XC functional. This is called the non-
           collinear approach.

           * NonCollinear: the non-collinear method.

           * CollinearXYZ: use the x, y, or z component as spin
             polarization for the XC functional.

           * Collinear: the same as CollinearZ.

   class _RemoveFragOrbitals

      Block key to remove selected virtual fragment orbitals.

   class _Response

      The calculation of frequency-dependent (hyper)polarizabilities
      and related properties (Raman, ORD)

      Variables:
         * **ALLCOMPONENTS** (*BoolType** | **BoolKey*) --

         * **ALLHYPER** (*BoolType** | **BoolKey*) --

         * **ALPHAINANG** (*BoolType** | **BoolKey*) --

         * **ANALYTIC** (*BoolType** | **BoolKey*) --

         * **AllCycles** (*BoolType** | **BoolKey*) -- Convergence
           printout

         * **AllTensor** (*BoolType** | **BoolKey*) -- Higher
           dispersion coefficients are also calculated

         * **C8** (*BoolType** | **BoolKey*) --

         * **CUTTAILS** (*BoolType** | **BoolKey*) --

         * **DYNAHYP** (*BoolType** | **BoolKey*) --

         * **Dipole** (*BoolType** | **BoolKey*) --

         * **DmpDII** (*float** | **FloatKey*) --

         * **DmpRsp** (*float** | **FloatKey*) --

         * **ERABSX** (*float** | **FloatKey*) --

         * **ERRALF** (*float** | **FloatKey*) --

         * **ERRTMX** (*float** | **FloatKey*) --

         * **EpsRho** (*float** | **FloatKey*) -- Rho threshold

         * **FXCALPHA** (*float** | **FloatKey*) --

         * **Frequencies** (*Iterable**[**float**] **|
           **FloatListKey*) -- List of frequencies of incident light,
           the perturbing field, at which the time-dependent
           properties will be calculated.

         * **GXCALPHA** (*float** | **FloatKey*) --

         * **HyperPol** (*float** | **FloatKey*) --

         * **IFILES** (*int** | **IntKey*) -- Integration run
           including external files. Used for Van der Waals dispersion
           coefficients calculations.

         * **IPRESP** (*int** | **IntKey*) --

         * **IReal** (*int** | **IntKey*) --

         * **KSORBRUN** (*BoolType** | **BoolKey*) --

         * **MAGNETICPERT** (*BoolType** | **BoolKey*) --

         * **MAXWAALS** (*int** | **IntKey*) --

         * **NCycMx** (*int** | **IntKey*) --

         * **NUMERIC** (*BoolType** | **BoolKey*) --

         * **OPTICALROTATION** (*BoolType** | **BoolKey*) --

         * **Octupole** (*BoolType** | **BoolKey*) --

         * **Quadrupole** (*BoolType** | **BoolKey*) --

         * **Raman** (*BoolType** | **BoolKey*) --

         * **STARTREALGR** (*BoolType** | **BoolKey*) --

         * **SYMRUN** (*BoolType** | **BoolKey*) --

         * **Temperature** (*float** | **FloatKey*) -- 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)

         * **VANDERWAALS** (*int** | **IntKey*) --

         * **VERDET** (*float** | **FloatKey*) -- For numerical
           differentiation d alfa(omega) /d omega, needed for Verdet
           constant, the default frequencies are omega + dverdt and
           omega - dverdt

   class _Restart

      Options for restarts

      Variables:
         * **NoOrb** (*BoolType** | **BoolKey*) -- Do not use orbitals
           from the restart file

         * **NoSCF** (*BoolType** | **BoolKey*) -- 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.

         * **NoSmear** (*BoolType** | **BoolKey*) -- Do not use any
           electron smearing data from the restart file.

         * **SpinFlip** (*Iterable**[**int**] **| **IntListKey*) --
           Select the atoms for which the spin is to be flipped upon
           restart.

   class _SCF

      Control aspects of the Self Consistent Field procedure

      Variables:
         * **AccelerationMethod** (*Literal**[**"ADIIS"**,
           **"fDIIS"**, **"LISTb"**, **"LISTf"**, **"LISTi"**,
           **"MESA"**, **"SDIIS"**]*) --

           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.

         * **Converge** (*Iterable**[**float**] **| **FloatListKey*)
           --

           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.

         * **EDIIS** (*BoolType** | **BoolKey*) -- 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.

         * **Iterations** (*int** | **IntKey*) -- The maximum number
           of SCF cycles allowed.

         * **LShift** (*float** | **FloatKey*) --

           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.

         * **LShift_cyc** (*int** | **IntKey*) -- Specifies that level
           shifting is not turned on before the given SCF cycle number
           (for the start-up geometry).

         * **LShift_err** (*float** | **FloatKey*) -- Specifies that
           level shifting will be turned off by the program as soon as
           the SCF error drops below a threshold.

         * **MESA** (*str** | **StringKey*) --

         * **Mixing** (*float** | **FloatKey*) -- When none of the SCF
           acceleration methods is active, the next Fock matrix is
           determined F = mixing * F_n + (1-mixing)F_(n-1).

         * **Mixing1** (*float** | **FloatKey*) -- The mixing
           parameter at the 1st SCF cycle.

         * **NoADIIS** (*BoolType** | **BoolKey*) -- Disables A-DIIS
           and switches SCF to a damping+DIIS scheme.

         * **OldSCF** (*BoolType** | **BoolKey*) --

           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.

         * **ScalableSCF** (*BoolType** | **BoolKey*) -- Use new
           scalable scf.

         * **ScalableSO** (*BoolType** | **BoolKey*) -- Use new
           scalable scf for spin-orbit coupling.

         * **ADIIS** (*ADF._SCF._ADIIS*) -- Settings for the ADIIS
           method.

         * **ARH** (*ADF._SCF._ARH*) -- The Augmented Roothaan-Hall
           method has been developed by T. Helgaker and coworkers.

         * **DIIS** (*ADF._SCF._DIIS*) -- The maximum number of SCF
           cycles allowed.

         * **ROSCF** (*ADF._SCF._ROSCF*) -- Settings for the ROSCF
           method.

      class _ADIIS

         Settings for the ADIIS method.

         Variables:
            * **Thresh1** (*float** | **FloatKey*) --

              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.

            * **Thresh2** (*float** | **FloatKey*) --

              If ErrMax < Thresh2 then only SDIIS coefficients are
              used.

              Below this threshold a weighted mix of A-DIIS and DIIS
              coefficients will be used.

      class _ARH

         The Augmented Roothaan-Hall method has been developed by T.
         Helgaker and coworkers.

         Variables:
            * **CGiter** (*int** | **IntKey*) -- Sets the maximum
              number of micro-iterations.

            * **Conv** (*float** | **FloatKey*) -- ARH convergence
              criterion. When the RMS gradient and its maximum
              components are both lower than the criterion, the ARH
              procedure will be considered converged.

            * **ETestLim** (*float** | **FloatKey*) --

            * **Enabled** (*BoolType** | **BoolKey*) -- Use ARH.

            * **Final** (*BoolType** | **BoolKey*) --

              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.

            * **Iter** (*int** | **IntKey*) -- 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

            * **LvlShIter** (*int** | **IntKey*) --

            * **MaxTrustR** (*float** | **FloatKey*) --

            * **MinTrustR** (*float** | **FloatKey*) --

            * **NOTRANSPCG** (*BoolType** | **BoolKey*) --

            * **NSAVED** (*int** | **IntKey*) --

              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.

            * **NoPrecond** (*BoolType** | **BoolKey*) --

            * **PRECOND** (*BoolType** | **BoolKey*) --

            * **SHIFTED** (*BoolType** | **BoolKey*) --

            * **START** (*int** | **IntKey*) --

            * **SWITCHING** (*BoolType** | **BoolKey*) --

              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).

            * **TRANSPCG** (*BoolType** | **BoolKey*) --

            * **TRUSTR** (*float** | **FloatKey*) --

      class _DIIS

         The maximum number of SCF cycles allowed.

         Variables:
            * **BFac** (*float** | **FloatKey*) -- By default, the
              latest vector is not favored in the DIIS algorithm
              (value 0.0). A sensible value would be 0.2.

            * **CX** (*float** | **FloatKey*) -- The DIIS space is
              reduced when very large DIIS coefficients appear. The
              value is the threshold.

            * **CXX** (*float** | **FloatKey*) -- When very large DIIS
              coefficients appear, switch to traditional damping. The
              value is the threshold.

            * **Cyc** (*int** | **IntKey*) -- When A-DIIS is disabled,
              the Pulay DIIS will start at this iteration irrespective
              of the DIIS OK value.

            * **N** (*int** | **IntKey*) -- 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)

            * **Ok** (*float** | **FloatKey*) -- The Pulay DIIS
              starting criterion, when A-DIIS is disabled,

      class _ROSCF

         Settings for the ROSCF method.

         Variables:
            **Alpha** (*Iterable**[**float**] **| **FloatListKey*) --
            Coefficients to build the alpha-spin orbital contribution
            to the diagonal closed-, open-, and virtual-shell blocks
            of the Fock matrix. The beta-spin orbital contributions
            are 1.0 minus the alpha ones.

   class _SCRF

      SCRF is no longer supported. Use AMS2023 or earlier.

   class _SOPert

      Key for perturbative inclusion of spin-orbit coupling.

      Variables:
         * **EShift** (*float** | **FloatKey*) -- The actually
           calculated eigenvalues are calculated up to the maximum
           singlet-singlet or singlet-triplet scalar relativistic
           excitation energy plus eshift (in Hartree).

         * **GSCorr** (*BoolType** | **BoolKey*) -- 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.

         * **NCalc** (*int** | **IntKey*) -- Number of spin-orbit
           coupled excitation energies to be calculated. Default (and
           maximum) value: 4 times the number of scalar relativistic
           singlet-singlet excitations.

         * **error** (*BoolType** | **BoolKey*) -- Debug option for
           perturbative spin-orbit coupling.

   class _SelectExcitation

      Variables:
         * **DipStrength** (*float** | **FloatKey*) --

         * **GRIMMEAEX** (*float** | **FloatKey*) --

         * **GRIMMEALPHA** (*float** | **FloatKey*) --

         * **GRIMMEBETA** (*float** | **FloatKey*) --

         * **GRIMMEDEMAX** (*float** | **FloatKey*) --

         * **GRIMMEPERTC** (*BoolType** | **BoolKey*) --

         * **GRIMMETPMIN** (*float** | **FloatKey*) --

         * **HighExcit** (*float** | **FloatKey*) --

         * **NOGRIMMEPERTC** (*BoolType** | **BoolKey*) --

         * **NOverlap** (*int** | **IntKey*) --

         * **OscStrength** (*float** | **FloatKey*) -- 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

         * **SetLargeEnergy** (*float** | **FloatKey*) -- 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

         * **SetOccEnergy** (*float** | **FloatKey*) -- 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.

         * **UseOccRange** (*Iterable**[**float**] **|
           **FloatListKey*) -- Use only occupied orbitals which have
           orbital energies between the two numbers.

         * **UseOccVirtNumbers** (*Iterable**[**int**] **|
           **IntListKey*) -- 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.

         * **UseOccVirtRange** (*Iterable**[**float**] **|
           **FloatListKey*) -- Use only pairs of an occupied and
           virtual orbital, for which the orbital energy difference is
           between the two numbers

         * **UseScaledZORA** (*BoolType** | **BoolKey*) -- 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.

         * **UseVirtRange** (*Iterable**[**float**] **|
           **FloatListKey*) -- Use only virtual orbitals which have
           orbital energies between the two numbers

         * **UseOccupied** (*str** | **Sequence**[**str**] **|
           **FreeBlock*) -- Use only the occupied orbitals which are
           specified

         * **UseVirtual** (*str** | **Sequence**[**str**] **|
           **FreeBlock*) -- Use only the virtual orbitals which are
           specified

      class _UseOccupied

         Use only the occupied orbitals which are specified

      class _UseVirtual

         Use only the virtual orbitals which are specified

   class _SlaterDeterminants

      The calculation of the one-determinant states based on the AOC
      reference state is controlled with this key.

   class _Solvation

      Variables:
         * **ARO** (*float** | **FloatKey*) --

         * **Acid** (*float** | **FloatKey*) --

         * **Ass** (*BoolType** | **BoolKey*) --

         * **Base** (*float** | **FloatKey*) --

         * **BornC** (*float** | **FloatKey*) -- Coulomb constant for
           Born

         * **C-Mat** (*str** | **StringKey*) --

         * **COSKFAtoms** (*Iterable**[**int**] **| **IntListKey*) --
           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.

         * **Charged** (*str** | **StringKey*) --

         * **Chgal** (*float** | **FloatKey*) --

         * **CsmRsp** (*BoolType** | **BoolKey*) --

         * **Cust** (*str** | **StringKey*) --

         * **Debug** (*str** | **StringKey*) --

         * **Disc** (*str** | **StringKey*) --

         * **Div** (*str** | **StringKey*) --

         * **EPS** (*float** | **FloatKey*) --

         * **ForceCosmo** (*str** | **StringKey*) --

         * **HALO** (*float** | **FloatKey*) --

         * **Lpr** (*BoolType** | **BoolKey*) --

         * **NoAss** (*BoolType** | **BoolKey*) --

         * **NoCsmRsp** (*BoolType** | **BoolKey*) --

         * **NoLpr** (*BoolType** | **BoolKey*) --

         * **NoPVec** (*BoolType** | **BoolKey*) --

         * **PVec** (*BoolType** | **BoolKey*) --

         * **PrintSM12** (*BoolType** | **BoolKey*) --

         * **RadSolv** (*float** | **FloatKey*) --

         * **Ref** (*float** | **FloatKey*) --

         * **SCF** (*str** | **StringKey*) --

         * **SM12SolvationPotential** (*Literal**[**"CM5"**,
           **"CHELPG"**, **"RESP"**]*) -- Partial Charges to use in
           SCRF for SM12

         * **SM12espgridorder** (*int** | **IntKey*) -- ESP Lebedeev
           Grid order for SM12 CHELPG and RESP. Accepted values are
           19, 23, 29,31, and 41

         * **SM12espgridspacing** (*float** | **FloatKey*) -- ESP
           Lebedeev Grid spacing for SM12 CHELPG and RESP in Angstrom.
           Sensible choices are 0.1, 0.2, 0.3 or 0.5 Angstrom.

         * **SM12printSCRF** (*BoolType** | **BoolKey*) -- Print
           Control for SM12 SCRF data

         * **Solv** (*str** | **StringKey*) -- Solvent details

         * **Surf** (*Literal**[**"wsurf"**, **"asurf"**, **"esurf"**,
           **"klamt"**, **"delley"**, **"wsurf nokeep"**, **"asurf
           nokeep"**, **"esurf nokeep"**, **"klamt nokeep"**,
           **"delley nokeep"**]*) -- Defines the type of cavity to be
           used.

         * **Tens** (*float** | **FloatKey*) --

         * **RADII** (*str** | **Sequence**[**str**] **| **FreeBlock*)
           --

      class _RADII

   class _SpinOrbitMagnetization

      Starting artificial spin-orbit magnetization at first SCF cycle

      Variables:
         * **Strength** (*float** | **FloatKey*) -- Strength of
           artificial spin-polarization at first SCF cycle

         * **PerRegion** (*ADF._SpinOrbitMagnetization._PerRegion*) --
           Defines the starting spin-polarization direction for all
           atoms in a region. Note that if this keyword is used
           multiple times, the chosen regions may not overlap.

      class _PerRegion

         Defines the starting spin-polarization direction for all
         atoms in a region. Note that if this keyword is used multiple
         times, the chosen regions may not overlap.

         Variables:
            * **Direction** (*Iterable**[**float**] **|
              **FloatListKey*) -- The starting spin-polarization
              direction for a region.

            * **Region** (*str** | **StringKey*) -- The identifier of
              the region for which to define the starting spin-
              polarization direction.

            * **Strength** (*float** | **FloatKey*) -- Strength of
              artificial spin-polarization in this region

   class _SubExci

      Subsystem TDDFT (FDE)

      Variables:
         * **CICoupl** (*BoolType** | **BoolKey*) -- 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.

         * **COULKERNEL** (*BoolType** | **BoolKey*) --

         * **COUPLBLOCK** (*BoolType** | **BoolKey*) --

         * **COUPLSYS** (*Iterable**[**int**] **| **IntListKey*) --

         * **CPLTAPE** (*str** | **StringKey*) --

         * **CThres** (*float** | **FloatKey*) -- 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.

         * **DIPVEL** (*BoolType** | **BoolKey*) --

         * **DiagType** (*Literal**[**"EXACT"**]*) --

         * **EIGPRINT** (*int** | **IntKey*) --

         * **ETHRES** (*float** | **FloatKey*) -- Threshold for
           effective coupling

         * **EXTERNALORTHO** (*float** | **FloatKey*) -- EO factor

         * **FULLGRID** (*BoolType** | **BoolKey*) --

         * **InvGuess** (*Literal**[**"EigVal-OrbDiff"**, **"OrbDiff-
           OrbDiff"**, **"Exact"**]*) -- Type of states to be coupled

         * **LOCALFXCK** (*BoolType** | **BoolKey*) --

         * **Lowest** (*int** | **IntKey*) -- The selection of the
           excited states to be coupled consists of two steps

         * **NITER** (*int** | **IntKey*) --

         * **NOINTERSOLV** (*BoolType** | **BoolKey*) --

         * **NOSOLVCCHECK** (*BoolType** | **BoolKey*) --

         * **ONEGRID** (*BoolType** | **BoolKey*) --

         * **OptStates** (*Iterable**[**int**] **| **IntListKey*) --
           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.

         * **PFRAGOUT** (*BoolType** | **BoolKey*) --

         * **PTHRES** (*float** | **FloatKey*) --

         * **SETDIAG** (*float** | **FloatKey*) --

         * **SFThres** (*float** | **FloatKey*) -- 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.

         * **SMARTGRID** (*BoolType** | **BoolKey*) --

         * **Stat2CPL** (*Literal**[**"OnlyKnown"**]*) -- Type of
           states to be coupled

         * **TCOMEGA** (*BoolType** | **BoolKey*) -- Transpose
           construction of Omega matrix

         * **TDA** (*BoolType** | **BoolKey*) -- 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.

         * **TKINKERNEL** (*BoolType** | **BoolKey*) --

         * **XCKERNEL** (*BoolType** | **BoolKey*) --

   class _SubResponse

      Untested and undocumented

   class _Tails

      Obsolete option for linear scaling and distance effects. We
      recommend using the LinearScaling key instead.

      Variables:
         * **Bas** (*float** | **FloatKey*) -- 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.

         * **Fit** (*float** | **FloatKey*) -- 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.

   class _VSCRF

      VSCRF is no longer supported. Use AMS2023 or earlier.

   class _XC

      Definition of the XC.

      Variables:
         * **Dispersion** (*str** | **StringKey*) -- Dispersion
           corrections.

         * **DoubleHybrid** (*str** | **StringKey*) -- Specifies the
           double hybrid functional that should be used during the
           SCF.

         * **EmpiricalScaling** (*Literal**[**"None"**, **"SOS"**,
           **"SCS"**, **"SCSMI"**]*) -- Calculate the
           (SOS/SCS/SCSMI)-MP2 correlation energy.

         * **GALITSKIIMIGDAL** (*BoolType** | **BoolKey*) -- Calculate
           the Galitskii-Migdal correlation energy after the SCF is
           completed.

         * **GCPparameters** (*str** | **StringKey*) -- Applying
           parameters for the geometrical counter poise correction.

         * **GGA** (*str** | **StringKey*) -- Specifies the GGA part
           of the XC Functional

         * **HartreeFock** (*BoolType** | **BoolKey*) -- Use the
           Hartree-Fock exchange should be used during the SCF.

         * **Hybrid** (*str** | **StringKey*) -- Specifies the hybrid
           functional that should be used during the SCF.

         * **LDA** (*str** | **StringKey*) -- Defines the LDA part of
           the XC functional

         * **LibXC** (*str** | **StringKey*) -- Use the LibXC library
           with the specified functional.

         * **MP2** (*BoolType** | **BoolKey*) -- Calculate the MP2
           correlation energy after the HF SCF is completed.

         * **MetaGGA** (*str** | **StringKey*) -- Specifies that a
           meta-GGA should be used during the SCF

         * **MetaHybrid** (*str** | **StringKey*) -- Specifies the
           meta-hybrid functional that should be used during the SCF.

         * **Model** (*str** | **StringKey*) -- Model potential to be
           used

         * **NoLibXC** (*BoolType** | **BoolKey*) -- Prevent the usage
           of the LibXC library

         * **OEP** (*str** | **StringKey*) -- Defines the optimized
           effective potential expanded into a set of the fit
           functions

         * **RPA** (*Literal**[**"None"**, **"Direct"**, **"Sigma"**,
           **"SOSEX"**, **"SOSSX"**]*) -- Specifies the use of an RPA
           or post-RPA method. By default, RPA is not enabled.

         * **RangeSep** (*str** | **StringKey*) -- Range separated
           hybrids parameters

         * **XCFun** (*BoolType** | **BoolKey*) -- Use the XCFun
           library

         * **gCP** (*str** | **StringKey*) -- Use the geometrical
           counter poise correction.

   class _XES

      X-ray emission spectroscopy

      Variables:
         * **AllXESMoments** (*BoolType** | **BoolKey*) -- Print out
           all the individual transition moments used within the
           calculation of the total oscillator strength

         * **AllXESQuadrupole** (*BoolType** | **BoolKey*) -- Print
           out the individual oscillator strength components to the
           total oscillator strength

         * **CoreHole** (*str** | **StringKey*) --

           selection of the acceptor orbital for the calculation of
           the emission oscillator strengths. For example 'CoreHole A1
           2' calculates oscillator strengths to the orbital 2 in
           irrep A1.

           In AMSinput you may also use the notation 2A1 (so first the
           orbital number, next the symmetry)

         * **Enabled** (*BoolType** | **BoolKey*) --

           Calculate the X-ray emission energies to a core orbital.

           By default it calculates the emission to the first orbital
           in the first symmetry.

   class _ZlmFit

      Options for the density fitting scheme 'ZlmFit'.

      Variables:
         * **AllowBoost** (*BoolType** | **BoolKey*) -- 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.

         * **DensityThreshold** (*float** | **FloatKey*) -- Threshold
           below which the electron density is considered to be
           negligible.

         * **GridAngOrder** (*int** | **IntKey*) --

         * **GridRadialFactor** (*float** | **FloatKey*) --

         * **PartitionFunThreshold** (*float** | **FloatKey*) --

         * **PotentialThreshold** (*float** | **FloatKey*) --

         * **Pruning** (*BoolType** | **BoolKey*) --

         * **Quality** (*Literal**[**"Auto"**, **"Basic"**,
           **"Normal"**, **"Good"**, **"VeryGood"**,
           **"Excellent"**]*) -- 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.

         * **lExpansion** (*int** | **IntKey*) --

         * **lMargin** (*int** | **IntKey*) --

         * **QualityPerRegion** (*ADF._ZlmFit._QualityPerRegion*) --
           Sets the ZlmFit quality for all atoms in a region. If
           specified, this overwrites the globally set quality.

      class _QualityPerRegion

         Sets the ZlmFit quality for all atoms in a region. If
         specified, this overwrites the globally set quality.

         Variables:
            * **Quality** (*Literal**[**"Basic"**, **"Normal"**,
              **"Good"**, **"VeryGood"**, **"Excellent"**]*) -- The
              region's quality of the ZlmFit.

            * **Region** (*str** | **StringKey*) -- The identifier of
              the region for which to set the quality.

class ASE

   Variables:
      * **AllASEResults** (*BoolType** | **BoolKey*) -- Return all ASE
        results that are not also part of AMSResults. These values can
        be found in ase.rkf without any unit conversions.

      * **ArgumentsFromFile** (*str** | **Path** | **StringKey*) --
        Specify the path to a yaml or python file defining the
        arguments to the function or class defined in *Calculator* or
        *Callable*.

      * **File** (*str** | **Path** | **StringKey*) --

        Specify the path to a Python file. This file should contain a
        callable (e.g. function or class) named *get_calculator* that
        returns an ASE Calculator and uses the arguments defined in
        *Arguments* or *ArgumentsFromFile*.

        You can find examples of suitable calculator.py files
        (possibly requiring additional installations of packages) in
        "$AMSHOME/scripting/scm/external_engines/backends".

      * **Import** (*str** | **StringKey*) --

        Specify the module and name of a Calculator installed in the
        used Python stack. This is case sensitive.

        Builtin ASE examples: ase.calculators.emt.EMT

        Other examples requiring special installations:
        scm.external_engines.backends._psi4.calculator.get_calculator 
        scm.external_engines.backends._tblite.calculator.get_calculat
        or
        scm.external_engines.backends._mace.calculator.get_calculator

      * **Performance** (*Literal**[**"Fast"**, **"ForceField"**,
        **"DFTB"**, **"DFT"**, **"Slow"**]*) -- Choose which option
        most accurately corresponds to how long a calculation with the
        calculator takes.

      * **Results** (*str** | **StringKey*) -- The data of this key in
        the results dictionary of the Calculator is stored in the
        engine rkf. Multiple results keys can be specified. This is
        case sensitive.

      * **Type** (*Literal**[**"File"**, **"Import"**]*) -- Select how
        to specify which calculator to use.

      * **Arguments** (*str** | **Sequence**[**str**] **|
        **FreeBlock*) --

        Arguments to the function or constructor initializing the
        Calculator. Give each argument on a separate line. This is
        case sensitive.

        Note: Do not perform any Python imports here. Only use Python
        builtin types. Arguments containing paths must be absolute.

        Example: cutoff = 3.14 title = 'my_string' my_list_arg = [1,
        4, 5] options_dictionary = {'key1': 11, 'key2': 22}
        my_boolean_flag = True my_path =
        '/this/must/be/an/absolute/path'

      * **Python** (*ASE._Python*) -- Specify which Python to run.

   class _Arguments

      Arguments to the function or constructor initializing the
      Calculator. Give each argument on a separate line. This is case
      sensitive.

      Note: Do not perform any Python imports here. Only use Python
      builtin types. Arguments containing paths must be absolute.

      Example: cutoff = 3.14 title = 'my_string' my_list_arg = [1, 4,
      5] options_dictionary = {'key1': 11, 'key2': 22} my_boolean_flag
      = True my_path = '/this/must/be/an/absolute/path'

   class _Python

      Specify which Python to run.

      Variables:
         * **Conda** (*str** | **StringKey*) --

           Name of conda environment. Only used when "Python%Type =
           Conda". You may also define the conda environment setting
           the environment variable SCM_ASE_PYTHON_TYPE=conda:name-of-
           environment.

           If the value is an absolute path it will be executed with
           "conda run -p", otherwise it is assumed to be a name of a
           conda environment that can be executed with "conda run -n".

           The "conda" executable shell script must exist on your
           "$PATH". To see available environments, run "conda env
           list".

         * **Type** (*Literal**[**"amspython"**, **"Conda"**,
           **"Current"**, **"Uv"**]*) -- Type of Python environment.
           If "Conda", set the name or path of the environment under
           "Python%Conda". If "Current", the default "python" (or
           "python.exe" on Windows) command will be used. If "Uv", set
           the path of the project under "Python%Uv".

         * **Uv** (*str** | **Path** | **StringKey*) -- Path to the uv
           project. Only used when "Python%Type = Uv". You may also
           define the uv project setting the environment variable
           SCM_ASE_PYTHON_TYPE=uv:path/to/project.

class BAND

   Variables:
      * **Allow** (*str** | **StringKey*) -- Debugging feature to let
        the program continue even when intermediate results seem to be
        wrong or very inaccurate

      * **BerryPhase** (*BoolType** | **BoolKey*) -- Boolean that
        determines whether the dipole as determined through the Berry
        phase approach should be calculated.

      * **CPVector** (*int** | **IntKey*) -- The code is vectorized
        and this key can be used to set the vector length

      * **Debug** (*str** | **StringKey*) -- Enables debug printing
        for the subroutine name(s) specified here.

      * **DefaultsConvention** (*str** | **StringKey*) -- There has
        been a big change in many default settings with the 2014
        release. This lets you switch to the old defaults.

      * **DumpBasisOnly** (*BoolType** | **BoolKey*) -- Dump basis and
        fit set files use for each atom.

      * **EigThreshold** (*float** | **FloatKey*) -- Threshold for
        printing the eigenvectors coefficients (Print Eigens)

      * **EnforcedSpinPolarization** (*float** | **FloatKey*) --

        Enforce a specific spin-polarization instead of occupying
        according to the aufbau principle. The spin-polarization is
        the difference between the number of alpha and beta electron.

        Thus, a value of 1 means that there is one more alpha electron
        than beta electrons.

        The number may be anything, including zero, which may be of
        interest when searching for a spin-flipped pair, that may
        otherwise end up in the (more stable) parallel solution.

      * **FormFactors** (*int** | **IntKey*) -- Number of stars of
        K-vectors for which the form factors are computed

      * **IntegrationMethod** (*Literal**[**"Becke"**,
        **"Voronoi"**]*) -- Choose the real-space numerical
        integration method. Note: the Voronoi integration scheme is
        deprecated.

      * **KGrp0** (*int** | **IntKey*) -- Undocumented.

      * **KGrpX** (*int** | **IntKey*) -- Absolute upper bound on the
        number of k-points processed together. This only affects the
        computational performance.

      * **ModifyAlternativeElements** (*BoolType** | **BoolKey*) --
        When using alternative elements (using the nuclear_charge
        attribute) set the element to the nearest integer Z. If you
        specify an H atom with a nuclear_charge of 2.9 it is replaced
        by a Li atom with the same nuclear charge.

      * **NUElstat** (*int** | **IntKey*) -- Number of outward
        (parabolic) integration points (for elliptical integration of
        the electrostatic interaction)

      * **NVElstat** (*int** | **IntKey*) -- Number of angular
        (elliptic) integration points (for elliptical integration of
        the electrostatic interaction)

      * **NeutralizingDensity** (*Literal**[**"None"**,
        **"rho**(**atoms**)**"**, **"rho**(**valence/atoms**)**"**,
        **"rho**(**neutralizing/atoms**)**"**,
        **"rho**(**homogeneous**)**"**]*) -- For charged systems an
        artificial compensating density can be used to make it neutral
        again. This fictitious density only affects the Coulomb
        potential. For charged periodic systems neutralization is
        required, as otherwise the Coulomb potential diverges.

      * **NuclearModel** (*Literal**[**"PointCharge"**,
        **"Gaussian"**, **"Uniform"**]*) --

        Specify what model to use for the nucleus.

        For the Gaussian model the nuclear radius is calculated
        according to the work of Visscher and Dyall (L. Visscher, and
        K.G. Dyall, Dirac-Fock atomic electronic structure
        calculations using different nuclear charge distributions,
        Atomic Data and Nuclear Data Tables 67, 207 (1997))

      * **NumericalQuality** (*Literal**[**"Basic"**, **"Normal"**,
        **"Good"**, **"VeryGood"**, **"Excellent"**]*) -- Set the
        quality of several important technical aspects of a BAND
        calculation (with the notable exception of the basis set). It
        sets the quality of: BeckeGrid (numerical integration), ZlmFit
        (density fitting), KSpace (reciprocal space integration), and
        SoftConfinement (basis set confinement). Note: the quality
        defined in the block of a specific technical aspects
        supersedes the value defined in NumericalQuality (e.g. if I
        specify 'NumericalQuality Basic' and 'BeckeGrid%Quality Good',
        the quality of the BeckeGrid will be 'Good')

      * **PEDA** (*BoolType** | **BoolKey*) -- If present in
        combination with the fragment block, the decomposition of the
        interaction energy between fragments is invoked.

      * **PopThreshold** (*float** | **FloatKey*) -- Threshold for
        printing Mulliken population terms. Works with 'Print orbpop'

      * **PotentialNoise** (*float** | **FloatKey*) -- The initial
        potential for the SCF procedure is constructed from a sum-of-
        atoms density. Added to this is some small noise in the
        numerical values of the potential in the points of the
        integration grid. The purpose of the noise is to help the
        program break the initial symmetry, if that would lower the
        energy, by effectively inducing small differences between
        (initially) degenerate orbitals.

      * **Print** (*str** | **StringKey*) -- One or more strings
        (separated by blanks) from a pre-defined set may be typed
        after the key. This induces printing of various kinds of
        information, usually only used for debugging and checking. The
        set of recognized strings frequently changes (mainly expands)
        in the course of software-developments. Useful arguments may
        be symmetry, and fit.

      * **Save** (*str** | **StringKey*) -- Save scratch files or
        extra data that would be otherwise deleted at the end of the
        calculation. e.g. 'TAPE10' (containing the integration grid)
        or 'DensityMatrix'

      * **SelectedAtoms** (*Iterable**[**int**] **| **IntListKey*) --
        With this key you can select atoms. This has an effect on a
        few of options, like NMR and EFG.

      * **SetLoggingLevel** (*str** | **StringKey*) -- Undocumented.

      * **Skip** (*str** | **StringKey*) -- Skip the specified part of
        the Band calculation (expert/debug option).

      * **StopAfter** (*str** | **StringKey*) -- Specifies that the
        program is stopped after execution of a specified program-part
        (subroutine).

      * **StoreHamAsMol** (*BoolType** | **BoolKey*) -- Undocumented,
        used for (at least) NEGF.

      * **StoreHamiltonian** (*BoolType** | **BoolKey*) --
        Undocumented.

      * **StoreHamiltonian2** (*BoolType** | **BoolKey*) -- determine
        the tight-binding representation of the overlap an fock
        matrix. Used for (at least) NEGF.

      * **SubSymmetry** (*Iterable**[**int**] **| **IntListKey*) --
        The indices of the symmetry operators to maintain.

      * **Title** (*str** | **StringKey*) -- Title of the calculation,
        which will be printed in the output file.

      * **Unrestricted** (*BoolType** | **BoolKey*) -- Controls
        whether Band should perform a spin-unrestricted calculation.
        Spin-unrestricted calculations are computationally roughly
        twice as expensive as spin-restricted.

      * **UnrestrictedOnlyReference** (*BoolType** | **BoolKey*) --
        Undocumented.

      * **UnrestrictedReference** (*BoolType** | **BoolKey*) --
        Undocumented.

      * **UnrestrictedStartup** (*BoolType** | **BoolKey*) --
        Undocumented.

      * **UseInversionSymmetryInReciprocalSpace** (*BoolType** |
        **BoolKey*) -- Whether to use inversion symmetry in reciprocal
        space. This is almost always a valid assumption.

      * **UseSymmetry** (*BoolType** | **BoolKey*) -- Whether or not
        to exploit symmetry during the calculation.

      * **AIMCriticalPoints** (*BAND._AIMCriticalPoints*) -- Compute
        the critical points of the density (Atoms In Molecules). The
        algorithm starts from a regular mesh of points, and from each
        of these it walks towards its corresponding critical point.

      * **ATensor** (*BAND._ATensor*) -- Hyperfine A-tensor.

      * **Align** (*BAND._Align*) -- Alignment of the potential of the
        system. Old NEGF.

      * **AtomType** (*BAND._AtomType*) -- Explicit basis set
        definition for given atom type.

      * **BField** (*BAND._BField*) -- The effect of a magnetic filed
        can be approximated by the following potential: mu * sigma_i *
        B, where mu is the Bohr magneton, sigma_i are the Pauli
        matrices and B is the magnetic field

      * **BZPath** (*BAND._BZPath*) -- Definition of the user-defined
        path in the Brillouin zone for band structure plotting.

      * **BandStructure** (*BAND._BandStructure*) -- Options for the
        calculation of the band structure.

      * **Basis** (*BAND._Basis*) -- Definition of the basis set

      * **BasisMisc** (*BAND._BasisMisc*) -- Miscellaneous options
        related to basis

      * **BeckeGrid** (*BAND._BeckeGrid*) -- Options for the numerical
        integration grid, which is a refined version of the fuzzy
        cells integration scheme developed by Becke.

      * **Bias** (*BAND._Bias*) -- Old NEGF. No longer supported

      * **CC** (*BAND._CC*) -- Technical aspects of CC methods

      * **CDFT** (*BAND._CDFT*) -- Constrained DFT Implementation in
        Transport. Old NEGF.

      * **Comment** (*str** | **Sequence**[**str**] **| **FreeBlock*)
        -- The content of this block will be copied to the output
        header as a comment to the calculation.

      * **Convergence** (*BAND._Convergence*) -- Options and
        parameters related to the convergence behavior of the SCF
        procedure.

      * **DFTBConfinementPotential**
        (*BAND._DFTBConfinementPotential*) -- Specify the confinement
        potentials (used for DFTB parametrization)

      * **DIIS** (*BAND._DIIS*) -- Parameters for the DIIS procedure
        to obtain the SCF solution

      * **DIRIS** (*BAND._DIRIS*) -- Same options as DIIS key, except
        that this one applies to the DIIS procedure used in the Dirac
        subprogram, for numerical single atom calculations, which
        constructs the radial tables for the NAOs.

      * **DOS** (*BAND._DOS*) -- Density-Of-States (DOS) options

      * **DensityPlot** (*str** | **Sequence**[**str**] **|
        **FreeBlock*) -- Plots of the density. Goes together with the
        Restart%DensityPlot and Grid keys.

      * **Dependency** (*BAND._Dependency*) -- Criteria for linear
        dependency of the basis and fit set

      * **DiracOptions** (*BAND._DiracOptions*) -- Options for the
        atomic Dirac calculations.

      * **Dispersion** (*BAND._Dispersion*) -- Technical options for
        dispersion-corrected functionals.

      * **DosBas** (*str** | **Sequence**[**str**] **| **FreeBlock*)
        -- Used to specify the fragment basis for the DOS.

      * **EFG** (*BAND._EFG*) -- The electronic charge density causes
        an electric field, and the gradient of this field couples with
        the nuclear quadrupole moment, that some (non-spherical)
        nuclei have and can be measured by several spectroscopic
        techniques. The EFG tensor is the second derivative of the
        Coulomb potential at the nuclei. For each atom it is a 3x3
        symmetric and traceless matrix. Diagonalization of this matrix
        gives three eigenvalues, which are usually ordered by their
        decreasing absolute size and denoted as V_{xx}, V_{yy},
        V_{zz}. The result is summarized by the largest eigenvalue and
        the asymmetry parameter.

      * **ESR** (*BAND._ESR*) -- Zeeman g-tensor. The Zeeman g-tensor
        is implemented using two-component approach of Van Lenthe and
        co-workers in which the g-tensor is computed from a pair of
        spinors related to each other by time-reversal symmetry. Note:
        the following options are necessary for ESR: 'Relativistic
        zora spin' and 'Kspace 1'

      * **EffectiveMass** (*BAND._EffectiveMass*) --

        In a semi-conductor, the mobility of electrons and holes is
        related to the curvature of the bands at the top of the
        valence band and the bottom of the conduction band.

        With the effective mass option, this curvature is obtained by
        numerical differentiation.

        The estimation is done with the specified step size, and twice
        the specified step size, and both results are printed to give
        a hint on the accuracy. The easiest way to use this key is to
        enabled it without specifying any extra options.

      * **ElectronHole** (*BAND._ElectronHole*) -- Allows one to
        specify an occupied band which shall be depopulated, where the
        electrons are then moved to the Fermi level. For a spin-
        restricted calculation 2 electrons are shifted and for a spin-
        unrestricted calculation only one electron is shifted.

      * **EmbeddingPotential** (*BAND._EmbeddingPotential*) -- An
        external potential can be read in and will be added to the
        effective Kohn-Sham potential. It has to be on the becke grid

      * **Excitations** (*BAND._Excitations*) -- Excitation energies:
        UV/Vis

      * **Fermi** (*BAND._Fermi*) -- Technical parameter used in
        determining the Fermi energy, which is carried out at each
        cycle of the SCF procedure.

      * **FermiSurface** (*BAND._FermiSurface*) -- Calculation of the
        Fermi surface for metals

      * **FitMethod** (*BAND._FitMethod*) -- Undocumented

      * **FracOp** (*BAND._FracOp*) -- Parameters from input for
        fractional occupations

      * **FragOccupations** (*str** | **Sequence**[**str**] **|
        **FreeBlock*) -- Undocumented

      * **Fragment** (*BAND._Fragment*) -- Defines a fragment. You can
        define several fragments for a calculation.

      * **FragmentEnergyTerms** (*str** | **Sequence**[**str**] **|
        **FreeBlock*) -- Undocumented

      * **FuzzyPotential** (*str** | **Sequence**[**str**] **|
        **FreeBlock*) -- Atomic (fuzzy cell) based, external, electric
        potential. See example.

      * **FuzzyUnitCellGrid** (*BAND._FuzzyUnitCellGrid*) --
        Undocumented.

      * **GMix** (*BAND._GMix*) -- Undocumented. Old NEGF.

      * **GW** (*BAND._GW*) -- Perform a GW calculation. G0W0 is the
        default for GW%SelfConsistency.

      * **Gate** (*BAND._Gate*) -- Undocumented. Old NEGF.

      * **Gradients** (*BAND._Gradients*) -- Options for nuclear
        gradients and strain derivatives calculations.

      * **Grid** (*BAND._Grid*) -- Options for the regular grid used
        for plotting (e.g. density plot). Used ICW the restart option.

      * **GridBasedAIM** (*BAND._GridBasedAIM*) -- Invoke the ultra
        fast grid based Bader analysis.

      * **GrossPopulations** (*str** | **Sequence**[**str**] **|
        **FreeBlock*) -- Partial DOS (pDOS) are generated for the
        gross populations listed under this key. See example.

      * **HardConfinement** (*BAND._HardConfinement*) -- Obsolete
        basis functions confinement method. Use SoftConfinement
        instead.

      * **HubbardU** (*BAND._HubbardU*) -- Options for Hubbard-
        corrected DFT calculations.

      * **Integration** (*BAND._Integration*) -- Options for the
        Voronoi numerical integration scheme. Deprecated. Use
        BeckeGrid instead.

      * **KSpace** (*BAND._KSpace*) -- Options for the k-space
        integration (i.e. the grid used to sample the Brillouin zone)

      * **LDOS** (*BAND._LDOS*) -- Local Density-Of-States
        information. This can be used to generate STM images in the
        Tersoff-Hamann approximation (see
        https://doi.org/10.1103/PhysRevB.31.805)

      * **MBPT** (*BAND._MBPT*) -- Technical aspects of the MP2
        algorithm.

      * **MolecularNMR** (*BAND._MolecularNMR*) -- Options for the
        calculations of the NMR shielding tensor for molecules,
        excluding periodic systems. Implements the Schreckenbach
        method like ADF.

      * **MultiSecantConfig** (*BAND._MultiSecantConfig*) --
        Parameters for the Multi-secant SCF convergence method.

      * **NEGF** (*BAND._NEGF*) -- Options for the NEGF (non-
        equilibrium green function) transport calculation.

      * **NMR** (*BAND._NMR*) -- Options for the calculations of the
        NMR shielding tensor.

      * **NOCVOrbitalPlot** (*str** | **Sequence**[**str**] **|
        **FreeBlock*) -- Goes together with the
        Restart%NOCVOrbitalPlot and Grid keys. See example.

      * **NOCVdRhoPlot** (*str** | **Sequence**[**str**] **|
        **FreeBlock*) -- Goes together with the Restart%NOCVdRhoPlot
        and Grid keys. See example.

      * **NOPROrbitalPlot** (*str** | **Sequence**[**str**] **|
        **FreeBlock*) -- Undocumented.

      * **NOPRdRhoPlot** (*str** | **Sequence**[**str**] **|
        **FreeBlock*) -- Undocumented.

      * **NeutralizingDensityDetails**
        (*BAND._NeutralizingDensityDetails*) --

      * **NewResponse** (*BAND._NewResponse*) -- The TD-CDFT
        calculation to obtain the dielectric function is computed when
        this block is present in the input. Several important settings
        can be defined here.

      * **NewResponseKSpace** (*BAND._NewResponseKSpace*) -- Modify
        the details for the integration weights evaluation in
        reciprocal space for each single-particle transition. Only
        influencing the NewResponse code.

      * **NewResponseSCF** (*BAND._NewResponseSCF*) -- Details for the
        linear-response self-consistent optimization cycle. Only
        influencing the NewResponse code.

      * **NonCollinearMagnetizationModule**
        (*BAND._NonCollinearMagnetizationModule*) -- Undocumented.

      * **Occupations** (*str** | **Sequence**[**str**] **|
        **FreeBlock*) -- Allows one to input specific occupations
        numbers. Applies only for calculations that use only one
        k-point (i.e. pseudo-molecule calculations). See example.

      * **OldResponse** (*BAND._OldResponse*) -- Options for the old
        TD-CDFT implementation.

      * **OrbitalLabels** (*str** | **Sequence**[**str**] **|
        **FreeBlock*) -- Undocumented.

      * **OrbitalPlot** (*str** | **Sequence**[**str**] **|
        **FreeBlock*) -- Goes together with the Restart%OrbitalPlot
        and Grid keys. See Example.

      * **Output** (*BAND._Output*) -- Control the output.

      * **OverlapPopulations** (*str** | **Sequence**[**str**] **|
        **FreeBlock*) -- Overlap population weighted DOS (OPWDOS),
        also known as the crystal orbital overlap population (COOP).

      * **PEDANOCV** (*BAND._PEDANOCV*) -- Options for the
        decomposition of the orbital relaxation (pEDA).

      * **PEDANOPR** (*BAND._PEDANOPR*) -- Undocumented.

      * **PeriodicRIHartreeFock** (*BAND._PeriodicRIHartreeFock*) --
        Technical options for periodic Hartree Fock.

      * **PeriodicSolvation** (*BAND._PeriodicSolvation*) --
        Additional options for simulations of periodic structures with
        solvation.

      * **Programmer** (*BAND._Programmer*) -- Miscellaneous technical
        options.

      * **PropertiesAtNuclei** (*str** | **Sequence**[**str**] **|
        **FreeBlock*) -- A number of properties can be obtained near
        the nucleus. An average is taken over a tiny sphere around the
        nucleus. The following properties are available:
        vxc[rho(fit)], rho(fit), rho(scf), v(coulomb/scf),
        rho(deformation/fit), rho(deformation/scf).

      * **RIHartreeFock** (*BAND._RIHartreeFock*) --

      * **RadialDefaults** (*BAND._RadialDefaults*) -- Options for the
        logarithmic radial grid of the basis functions used in the
        subprogram Dirac

      * **Relativity** (*BAND._Relativity*) -- Options for
        relativistic effects.

      * **ResponseInducedDensityPlot** (*str** | **Sequence**[**str**]
        **| **FreeBlock*) -- Goes together with
        Restart%ResponseInducedDensityPlot and Grid.

      * **Restart** (*BAND._Restart*) -- Tells the program that it
        should restart with the restart file, and what to restart.

      * **SCF** (*BAND._SCF*) -- Controls technical SCF parameters.

      * **Screening** (*BAND._Screening*) -- For the periodic
        solvation potential and for the old (not default anymore)
        fitting method, BAND performs lattice summations which are in
        practice truncated. The precision of the lattice summations is
        controlled by the options in this block.

      * **SlakoConfig** (*BAND._SlakoConfig*) -- Undocumented.

      * **SoftConfinement** (*BAND._SoftConfinement*) -- In order to
        make the basis functions more compact, the radial part of the
        basis functions is multiplied by a Fermi-Dirac (FD) function
        (this 'confinement' is done for efficiency and numerical
        stability reasons). A FD function goes from one to zero,
        controlled by two parameters. It has a value 0.5 at Radius,
        and the decay width is Delta.

      * **Solvation** (*BAND._Solvation*) -- Options for the COSMO
        (Conductor like Screening Model) solvation model.

      * **SolvationSM12** (*BAND._SolvationSM12*) -- Options for
        Solvation Model 12 (SM12).

      * **StrainDerivatives** (*BAND._StrainDerivatives*) --
        Undocumented.

      * **Tails** (*BAND._Tails*) -- Ignore function tails.

      * **TechnicalCOSMO** (*BAND._TechnicalCOSMO*) -- Some options to
        develop cosmo for charged periodic systems

      * **TestParameters** (*BAND._TestParameters*) -- Undocumented.

      * **Transport** (*BAND._Transport*) -- Old NEGF. No longer
        supported

      * **XC** (*BAND._XC*) -- Exchange Correlation functionals

      * **ZlmFit** (*BAND._ZlmFit*) -- Options for the density fitting
        scheme 'ZlmFit'.

   class _AIMCriticalPoints

      Compute the critical points of the density (Atoms In Molecules).
      The algorithm starts from a regular mesh of points, and from
      each of these it walks towards its corresponding critical point.

      Variables:
         * **Enabled** (*BoolType** | **BoolKey*) -- Compute the
           critical points of the density (Atoms In Molecules). The
           algorithm starts from a regular mesh of points, and from
           each of these it walks towards its corresponding critical
           point.

         * **EqvPointsTol** (*float** | **FloatKey*) -- If the
           distance between two critical points is smaller than this
           value, the two critical points are considered to be the
           same point.

         * **GridPadding** (*float** | **FloatKey*) -- How much extra
           space is added to the starting guess domain in the search
           for the critical points

         * **GridSpacing** (*float** | **FloatKey*) -- The distance
           between the initial trial points.

   class _ATensor

      Hyperfine A-tensor.

      Variables:
         **Enabled** (*BoolType** | **BoolKey*) --

         Compute the hyperfine A-tensor.

         Note: Unrestricted calculation is required.

   class _Align

      Alignment of the potential of the system. Old NEGF.

      Variables:
         * **StartAlign** (*int** | **IntKey*) -- Undocumented.

         * **cdiis** (*BoolType** | **BoolKey*) -- Undocumented.

         * **cdiisDamp** (*float** | **FloatKey*) -- Undocumented.

         * **cdiisPrint** (*BoolType** | **BoolKey*) -- Undocumented.

         * **emCharge** (*float** | **FloatKey*) -- Undocumented.

         * **mix** (*float** | **FloatKey*) -- Undocumented.

         * **pmatShift** (*BoolType** | **BoolKey*) -- Undocumented.

   class _AtomType

      Explicit basis set definition for given atom type.

      Variables:
         * **AutomaticGaussians** (*str** | **Sequence**[**str**] **|
           **FreeBlock*) -- Definition of the automatic gaussians

         * **BasisFunctions** (*str** | **Sequence**[**str**] **|
           **FreeBlock*) -- Definition of the extra Slater-type
           orbitals

         * **ContractedGaussians** (*str** | **Sequence**[**str**] **|
           **FreeBlock*) -- Definition of the contracted gaussians

         * **Dirac** (*str** | **Sequence**[**str**] **| **FreeBlock*)
           -- Specification of the numerical ('Herman-Skillman') free
           atom, which defines the initial guess for the SCF density,
           and which also (optionally) supplies Numerical Atomic
           Orbitals (NOs) as basis functions

         * **FitFunctions** (*str** | **Sequence**[**str**] **|
           **FreeBlock*) -- Slater-type fit functions. Obsolete
           feature.

      class _AutomaticGaussians

         Definition of the automatic gaussians

      class _BasisFunctions

         Definition of the extra Slater-type orbitals

      class _ContractedGaussians

         Definition of the contracted gaussians

      class _Dirac

         Specification of the numerical ('Herman-Skillman') free atom,
         which defines the initial guess for the SCF density, and
         which also (optionally) supplies Numerical Atomic Orbitals
         (NOs) as basis functions

      class _FitFunctions

         Slater-type fit functions. Obsolete feature.

   class _BField

      The effect of a magnetic filed can be approximated by the
      following potential: mu * sigma_i * B, where mu is the Bohr
      magneton, sigma_i are the Pauli matrices and B is the magnetic
      field

      Variables:
         * **Bx** (*float** | **FloatKey*) -- Value of the x component
           of the BField

         * **By** (*float** | **FloatKey*) -- Value of the y component
           of the BField

         * **Bz** (*float** | **FloatKey*) -- Value of the z component
           of the BField

         * **Dipole** (*BoolType** | **BoolKey*) -- Use an atomic
           dipole as magnetic field instead of a uniform magnetic
           field.

         * **DipoleAtom** (*int** | **IntKey*) -- Atom on which the
           magnetic dipole should be centered (if using the dipole
           option)

         * **Method** (*Literal**[**"NR_SDOTB"**, **"NR_LDOTB"**,
           **"NR_SDOTB_LDOTB"**]*) --

           There are two terms coupling to an external magnetic field.

           One is the intrinsic spin of the electron, called S-dot-B,
           the other one is the orbital momentum call L-dot-B.

           The L.B is implemented non-relativistically, using GIAOs in
           the case of a homogeneous magnetic field (not for the
           dipole case).

         * **Unit** (*Literal**[**"tesla"**, **"a.u."**]*) -- Unit of
           magnetic filed. The a.u. is the SI version of a.u.

   class _BZPath

      Definition of the user-defined path in the Brillouin zone for
      band structure plotting.

      Variables:
         * **kmesh** (*int** | **IntKey*) -- Undocumented

         * **path** (*str** | **Sequence**[**str**] **| **FreeBlock*)
           -- Definition of the k-points in a path. The vertices of
           your path should be defined in fractional coordinates (wrt
           the reciprocal lattice vectors)

      class _path

         Definition of the k-points in a path. The vertices of your
         path should be defined in fractional coordinates (wrt the
         reciprocal lattice vectors)

   class _BandStructure

      Options for the calculation of the band structure.

      Variables:
         * **Automatic** (*BoolType** | **BoolKey*) --

           If True, BAND will automatically generate the standard path
           through the Brillouin zone.

           If False BAND will use the user-defined path in BZPath.

         * **DeltaK** (*float** | **FloatKey*) --

           Step (in reciprocal space) for band structure
           interpolation.

           Using a smaller number (e.g. 0.03) will result in smoother
           band curves at the cost of an increased computation time.

         * **Enabled** (*BoolType** | **BoolKey*) -- If True, Band
           will calculate the band structure and save it to file for
           visualization.

         * **EnergyAboveFermi** (*float** | **FloatKey*) -- Bands with
           minimum energy larger then FermiEnergy + EnergyAboveFermi
           are not saved to file. Increasing the value of
           EnergyAboveFermi will result in more unoccupied bands to be
           saved to file for visualization.

         * **EnergyBelowFermi** (*float** | **FloatKey*) -- Bands with
           maximum energy smaller then FermiEnergy - EnergyBelowFermi
           are not saved to file. Increasing the value of
           EnergyBelowFermi will result in more occupied core bands to
           be saved to file for visualization. Note: EnergyBelowFermi
           should be a positive number!

         * **FatBands** (*BoolType** | **BoolKey*) --

           If True, BAND will compute the fat bands (only if
           BandStructure%Enabled is True).

           The Fat Bands are the periodic equivalent of the Mulliken
           population analysis.

         * **KPathFinderConvention** (*Literal**[**"Setyawan-
           Curtarolo"**, **"Hinuma"**]*) --

           This option determines how the path through the Brillouin
           zone is generated when using the automatic k-point mode.

           Available options:

           * "Setyawan-Curtarolo" (default for 1D and 2D lattices):
             Uses our built-in KPath program to find a path through
             high-symmetry points based on the method by Setyawan and
             Curtarolo
             (https://doi.org/10.1016/j.commatsci.2010.05.010). For 2D
             lattices, the path is derived from the intersection of
             the 3D Brillouin zone with a plane. For 1D lattices, the
             path is simply Gamma-Z.

           * "Hinuma": Uses the external SeeKPath utility to generate
             the k-path (https://github.com/giovannipizzi/seekpath and
             https://doi.org/10.1016/j.commatsci.2016.10.015).

         * **UseSymmetry** (*BoolType** | **BoolKey*) --

           If True, only the irreducible wedge of the Wigner-Seitz
           cell is sampled.

           If False, the whole (inversion-unique) Wigner-Seitz cell is
           sampled.

           Note: The Symmetry key does not influence the symmetry of
           the band structure sampling. Only available for Setyawan
           and Curtarolo convention (see "KPathFinderConvention").

   class _Basis

      Definition of the basis set

      Variables:
         * **Core** (*Literal**[**"None"**, **"Small"**, **"Medium"**,
           **"Large"**]*) --

           Select the size of the frozen core you want to use.

           Small, Medium, and Large will be interpreted within the
           basis sets available (of the selected quality), and might
           refer to the same core in some cases.

         * **Folder** (*str** | **Path** | **StringKey*) -- Path to a
           folder containing the basis set files. This can be used for
           special use-defined basis sets. Cannot be used in
           combination with 'Type'

         * **Type** (*Literal**[**"SZ"**, **"DZ"**, **"DZP"**,
           **"TZP"**, **"TZ2P"**, **"QZ4P"**, **"QZ5P"**, **"V"**,
           **"STO/TZ2P"**, **"STO/SZ"**, **"STO/DZ"**, **"STO/DZP"**,
           **"STO/QZ4P"**, **"AUTOGAUSS"**, **"CORR/QZ6P"**,
           **"CORR/TZ3P"**, **"CORR/QZ6P_GH"**, **"CORR/TZ3P_G"**,
           **"GTO/CC-PWCVQZ"**, **"GTO/CC-PV5Z"**,
           **"GTO/DEF2-QZVPPD"**, **"GTO/CC-PV6Z"**, **"GTO/CC-
           PVQZ"**, **"GTO/CC-PVTZ"**, **"GTO/CC-PVDZ"**,
           **"GTO/DEF2-SVP"**, **"GTO/DEF2-TZVP"**,
           **"GTO/DEF2-TZVPP"**, **"GTO/DEF2-QZVP"**, **"GTO/AUG-CC-
           PVDZ"**, **"GTO/AUG-CC-PVTZ"**, **"GTO/AUG-CC-PVQZ"**,
           **"GTO/POB-TZVP"**]*) --

           Select the basis set to use.

           SZ   : Single Z DZ   : Double Z DZP  : Double Z, 1
           polarization function TZP : Triple Z, 1 polarization
           function TZ2P : Triple Z, 2 polarization functions QZ4P :
           Quadruple Z, 4 polarization function

           The basis set chosen will apply to all atoms in your
           structure. If a matching basis is not found a better type
           might be used.

         * **PerAtomType** (*BAND._Basis._PerAtomType*) -- Defines the
           basis set for all atoms of a particular type.

         * **PerRegion** (*BAND._Basis._PerRegion*) -- Defines the
           basis set for all atoms in a region. If specified, this
           overwrites the values set with the Basis%Type and
           Basis%PerAtomType keywords for atoms in that region. Note
           that if this keyword is used multiple times, the chosen
           regions may not overlap.

      class _PerAtomType

         Defines the basis set for all atoms of a particular type.

         Variables:
            * **Core** (*Literal**[**"None"**, **"Small"**,
              **"Medium"**, **"Large"**]*) -- Size of the frozen core.

            * **File** (*str** | **Path** | **StringKey*) -- The path
              to the basis set file. The path can be absolute or
              relative to $AMSRESOURCES/Band. Specifying the path to
              the basis file explicitly overrides the automatic basis
              file selection via the Type and Core subkeys.

            * **Symbol** (*str** | **StringKey*) -- The symbol for
              which to define the basis set.

            * **Type** (*Literal**[**"SZ"**, **"DZ"**, **"DZP"**,
              **"TZP"**, **"TZ2P"**, **"QZ4P"**, **"V"**]*) -- The
              basis sets to be used.

      class _PerRegion

         Defines the basis set for all atoms in a region. If
         specified, this overwrites the values set with the Basis%Type
         and Basis%PerAtomType keywords for atoms in that region. Note
         that if this keyword is used multiple times, the chosen
         regions may not overlap.

         Variables:
            * **Core** (*Literal**[**"None"**, **"Small"**,
              **"Medium"**, **"Large"**]*) -- Size of the frozen core.

            * **File** (*str** | **Path** | **StringKey*) -- The path
              to the basis set file. The path can be absolute or
              relative to $AMSRESOURCES/Band. Specifying the path to
              the basis file explicitly overrides the automatic basis
              file selection via the Type and Core subkeys.

            * **Region** (*str** | **StringKey*) -- The identifier of
              the region for which to define the basis set. Note that
              this may also be a region expression, e.g.
              'myregion+myotherregion' (the union of two regions).

            * **Type** (*Literal**[**"SZ"**, **"DZ"**, **"DZP"**,
              **"TZP"**, **"TZ2P"**, **"QZ4P"**, **"V"**]*) -- The
              basis sets to be used.

   class _BasisMisc

      Miscellaneous options related to basis

      Variables:
         * **FreezeCore** (*BoolType** | **BoolKey*) -- Undocumented.

         * **NewFrag** (*BoolType** | **BoolKey*) -- Undocumented.

         * **PrepareFragment** (*BoolType** | **BoolKey*) --
           Undocumented.

         * **SimpleFrag** (*BoolType** | **BoolKey*) -- Undocumented.

         * **SlaterNR** (*BoolType** | **BoolKey*) -- Undocumented.

   class _BeckeGrid

      Options for the numerical integration grid, which is a refined
      version of the fuzzy cells integration scheme developed by
      Becke.

      Variables:
         * **AllowAngularBoost** (*BoolType** | **BoolKey*) -- Allow
           automatic augmentation of the Lebedev spherical grid for
           highly coordinated atoms.

         * **CutOffDistancePointCharges** (*float** | **FloatKey*) --
           In case of external point charges the grid puts also
           centers there. For charges far away from the QM density
           this is not needed.

         * **InnerShellsPruning** (*BoolType** | **BoolKey*) -- Allow
           automatic pruning of the Lebedev spherical grid for shells
           close to the nuclei.

         * **PartitionFunPruning** (*BoolType** | **BoolKey*) -- Allow
           pruning of integration points based on the value of the
           partition function.

         * **Quality** (*Literal**[**"Auto"**, **"Basic"**,
           **"Normal"**, **"Good"**, **"VeryGood"**,
           **"Excellent"**]*) -- 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.

         * **RadialGridBoost** (*float** | **FloatKey*) -- 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.

         * **UserCoreL** (*int** | **IntKey*) -- Technical grid
           parameter: Lebedev angular grid order for core shells.

         * **UserExterL** (*int** | **IntKey*) -- Technical grid
           parameter: Lebedev angular grid order for exterl shells.

         * **UserExterLBoost** (*int** | **IntKey*) -- Technical grid
           parameter.

         * **UserInter1l** (*int** | **IntKey*) -- Technical grid
           parameter: Lebedev angular grid order for first inner core
           shells.

         * **UserInter2l** (*int** | **IntKey*) -- Technical grid
           parameter: Lebedev angular grid order for second inner core
           shells.

         * **UserRadMulFactor** (*float** | **FloatKey*) -- Technical
           grid parameter: Multiplication factor for number of radial
           grid points.

         * **QualityPerRegion** (*BAND._BeckeGrid._QualityPerRegion*)
           -- Sets the grid quality for all atoms in a region. If
           specified, this overwrites the globally set quality.

      class _QualityPerRegion

         Sets the grid quality for all atoms in a region. If
         specified, this overwrites the globally set quality.

         Variables:
            * **Quality** (*Literal**[**"Basic"**, **"Normal"**,
              **"Good"**, **"VeryGood"**, **"Excellent"**]*) -- The
              region's integration grid quality.

            * **Region** (*str** | **StringKey*) -- The identifier of
              the region for which to set the quality.

   class _Bias

      Old NEGF. No longer supported

      Variables:
         * **block** (*BoolType** | **BoolKey*) -- Undocumented.

         * **deltax** (*float** | **FloatKey*) -- Undocumented.

         * **deltay** (*float** | **FloatKey*) -- Undocumented.

         * **deltaz** (*float** | **FloatKey*) -- Undocumented.

         * **iterative** (*BoolType** | **BoolKey*) -- Undocumented.

         * **phi1** (*float** | **FloatKey*) -- Undocumented.

         * **phi2** (*float** | **FloatKey*) -- Undocumented.

         * **plot** (*int** | **IntKey*) -- Undocumented.

         * **tc1** (*float** | **FloatKey*) -- Undocumented.

         * **tc2** (*float** | **FloatKey*) -- Undocumented.

         * **x1** (*float** | **FloatKey*) -- Undocumented.

         * **x2** (*float** | **FloatKey*) -- Undocumented.

         * **y1** (*float** | **FloatKey*) -- Undocumented.

         * **y2** (*float** | **FloatKey*) -- Undocumented.

         * **z1** (*float** | **FloatKey*) -- Undocumented.

         * **z2** (*float** | **FloatKey*) -- Undocumented.

   class _CC

      Technical aspects of CC methods

      Variables:
         * **ConvThreshold** (*float** | **FloatKey*) -- Minimum
           threshold of convergence for the CC energy

         * **Enabled** (*BoolType** | **BoolKey*) -- Enable the
           calculation of the CC energy.

         * **Extrapolation** (*Literal**[**"LinMix"**, **"DIIS"**,
           **"CROP"**]*) -- Specifies the t-amplitude extrapolation
           algorithm to be used in a CC calculation

         * **LinMixC** (*float** | **FloatKey*) -- CC Linear Mixing
           coefficient: Fraction of previous iteration that is
           retained.

         * **MaxIts** (*int** | **IntKey*) -- The maximum number of
           iterations to be used in a Coupled Cluster calculation.

         * **TensBuffer** (*int** | **IntKey*) -- The amount of
           memory, in GB, available for the tensor contraction
           library.

         * **Type** (*Literal**[**"None"**, **"SD"**, **"D"**,
           **"SDT"**, **"SDTQ"**, **"SD**(**T**)**"**]*) -- The
           excitation level of the CC calculation. Spin-restricted
           calculations go up to CCSD.

   class _CDFT

      Constrained DFT Implementation in Transport. Old NEGF.

      Variables:
         * **basfnc** (*int** | **IntKey*) -- lsat basis function of
           contacts+EM-ex-Mol, next basfnc = 1st on Mol

         * **basislim** (*int** | **IntKey*) -- Sets basisfunction to
           start constraining from, overrides previous

         * **cdftmix** (*float** | **FloatKey*) -- Mixing strength

         * **field** (*float** | **FloatKey*) -- Field strength

         * **qexcess** (*float** | **FloatKey*) -- Excess charge

         * **startcdft** (*int** | **IntKey*) -- Sets starting
           iteration

   class _Comment

      The content of this block will be copied to the output header as
      a comment to the calculation.

   class _Convergence

      Options and parameters related to the convergence behavior of
      the SCF procedure.

      Variables:
         * **Boltzmann** (*int** | **IntKey*) -- Undocumented

         * **Criterion** (*float** | **FloatKey*) -- Criterion for
           termination of the SCF procedure. The default depends on
           the NumericalQuality and on the number of atoms in the
           system. Can be used for EngineAutomations

         * **CriterionFactor** (*float** | **FloatKey*) -- Multiply
           Criterion (which depends on system and quality) with this
           factor. Can be used for EngineAutomations

         * **Degenerate** (*str** | **StringKey*) -- Smooths
           (slightly) occupation numbers around the Fermi level, so as
           to insure that nearly-degenerate states get (nearly-)
           identical occupations. Be aware: In case of problematic SCF
           convergence the program will turn this key on
           automatically, unless the key 'Nodegenerate' is set in
           input. The smoothing depends on the argument to this key,
           which can be considered a 'degeneration width'. When the
           argument reads default, the program will use the value 1e-4
           a.u. for the energy width.

         * **EDegen** (*float** | **FloatKey*) -- Undocumented

         * **ElectronicTemperature** (*float** | **FloatKey*) -- (KT)
           Specify this key for a gradient independent electronic
           temperature

         * **InitialDensity** (*Literal**[**"rho"**, **"psi"**,
           **"frompot"**]*) -- The SCF is started with a guess of the
           density. There are the following choices RHO: the sum of
           atomic density. PSI: construct an initial eigensystem by
           occupying the atomic orbitals. The guessed eigensystem is
           orthonormalized, and from this the density is calculated/

         * **LessDegenerate** (*BoolType** | **BoolKey*) -- If
           smoothing of occupations over nearly degenerate orbitals is
           applied (see Degenerate key), then, if this key is set in
           the input file, the program will limit the smoothing energy
           range to 1e-4 a.u. as soon as the SCF has converged
           'halfway', i.e. when the SCF error has decreased to the
           square root of its convergence criterion.

         * **ModestCriterion** (*float** | **FloatKey*) -- If this is
           specified band will consider the SCF converged if the error
           is below this criterion (after using the maximum number of
           iterations).

         * **NoDegenerate** (*BoolType** | **BoolKey*) -- This key
           prevents any internal automatic setting of the key
           DEGENERATE.

         * **NumBoltz** (*int** | **IntKey*) -- The electronic
           temperature is done with a Riemann Stieltjes numerical
           integration, between zero and one occupation. This defines
           the number of points to be used.

         * **SpinFlip** (*Iterable**[**int**] **| **IntListKey*) --
           List here the atoms for which you want the initial spin
           polarization to be flipped. This way you can distinguish
           between ferromagnetic and anti ferromagnetic states.
           Currently, it is not allowed to give symmetry equivalent
           atoms a different spin orientation. To achieve that you
           have to break the symmetry.

         * **SpinFlipEnabled** (*BoolType** | **BoolKey*) -- If set to
           False, the keys SpinFlip and SpinFlipRegion are ignored.
           Only useful/convenient when trying to compare in a script
           the effect of spin flip.

         * **SpinFlipRegion** (*str** | **StringKey*) -- Specify here
           the region for which you want the initial spin polarization
           to be flipped. This way you can distinguish between
           ferromagnetic and anti ferromagnetic states. Currently, it
           is not allowed to give symmetry equivalent atoms a
           different spin orientation. To achieve that you have to
           break the symmetry.

         * **StartWithMaxSpin** (*BoolType** | **BoolKey*) -- To break
           the initial perfect symmetry of up and down densities there
           are two strategies. One is to occupy the numerical orbitals
           in a maximum spin configuration. The alternative is to add
           a constant to the potential. See also Vsplit key.

         * **StartWithMaxSpinForSO** (*BoolType** | **BoolKey*) --
           Same as the StartWithMaxSpin option. In case of spin-orbit
           band always used to split the potential. Now will use
           maxspin in case of SpinFlip. With this option it will
           always do that.

         * **Temperature** (*float** | **FloatKey*) -- Undocumented

   class _DFTBConfinementPotential

      Specify the confinement potentials (used for DFTB
      parametrization)

      Variables:
         * **alpha** (*float** | **FloatKey*) -- Undocumented.

         * **exponent** (*float** | **FloatKey*) -- Undocumented.

         * **r0** (*float** | **FloatKey*) -- Undocumented.

   class _DIIS

      Parameters for the DIIS procedure to obtain the SCF solution

      Variables:
         * **Adaptable** (*BoolType** | **BoolKey*) -- Change
           automatically the value of dimix during the SCF.

         * **Alpha** (*float** | **FloatKey*) -- Undocumented

         * **CHuge** (*float** | **FloatKey*) -- When the largest
           coefficient in the DIIS expansion exceeds this value,
           damping is applied

         * **CLarge** (*float** | **FloatKey*) -- When the largest
           DIIS coefficient exceeds this value, the oldest DIIS vector
           is removed and the procedure re-applied

         * **ComStr** (*str** | **StringKey*) -- Undocumented

         * **Condition** (*float** | **FloatKey*) -- The condition
           number of the DIIS matrix, the largest eigenvalue divided
           by the smallest, must not exceed this value. If this value
           is exceeded, this vector will be removed.

         * **DiMix** (*float** | **FloatKey*) -- Mixing parameter for
           the DIIS procedure

         * **DiMixMax** (*float** | **FloatKey*) -- For adaptive diis:
           A negative value means automatic, see DiMixatnvctrx. If
           positive it is an absolute upper bound for (adaptive) dimix

         * **DiMixMin** (*float** | **FloatKey*) -- An absolute lower
           bound for adaptive dimix.

         * **DiMixatnvctrx** (*float** | **FloatKey*) -- Adaptive
           dimix. When only one vector is used the maximum is one,
           when the full history is used it is this value (Exponential
           decay).

         * **DiMixdecayfac** (*float** | **FloatKey*) -- Undocumented

         * **EDIIS** (*BoolType** | **BoolKey*) -- Use EDIIS

         * **EDIISModCycle** (*int** | **IntKey*) -- Undocumented

         * **GrowthFactor** (*float** | **FloatKey*) -- Undocumented

         * **Method** (*int** | **IntKey*) -- Undocumented

         * **NCycleDamp** (*int** | **IntKey*) -- Number of initial
           iterations where damping is applied, before any DIIS is
           considered

         * **NVctrx** (*int** | **IntKey*) -- Maximum number of DIIS
           expansion vectors

         * **NumAverage** (*int** | **IntKey*) -- Undocumented

         * **Print** (*int** | **IntKey*) -- Output printing level for
           DIIS

         * **ShrinkFactor** (*float** | **FloatKey*) -- Undocumented

         * **Variant** (*Literal**[**"DIIS"**, **"LISTi"**,
           **"LISTb"**, **"LISTd"**]*) -- Which variant to use. In
           case of problematic SCF convergence, first try MultiSecant,
           and if that does not work the LISTi is the advised method.
           Note: LIST is computationally more expensive per SCF
           iteration than DIIS.

   class _DIRIS

      Same options as DIIS key, except that this one applies to the
      DIIS procedure used in the Dirac subprogram, for numerical
      single atom calculations, which constructs the radial tables for
      the NAOs.

      Variables:
         * **adaptable** (*BoolType** | **BoolKey*) -- See DIIS.

         * **alpha** (*float** | **FloatKey*) -- See DIIS.

         * **chuge** (*float** | **FloatKey*) -- See DIIS.

         * **clarge** (*float** | **FloatKey*) -- See DIIS.

         * **comstr** (*str** | **StringKey*) -- See DIIS.

         * **condition** (*float** | **FloatKey*) -- See DIIS.

         * **dimix** (*float** | **FloatKey*) -- See DIIS.

         * **dimixdecayfac** (*float** | **FloatKey*) -- See DIIS.

         * **ediis** (*BoolType** | **BoolKey*) -- See DIIS.

         * **ediismodcycle** (*int** | **IntKey*) -- See DIIS.

         * **method** (*int** | **IntKey*) -- See DIIS.

         * **ncycledamp** (*int** | **IntKey*) -- See DIIS.

         * **numaverage** (*int** | **IntKey*) -- See DIIS.

         * **nvctrx** (*int** | **IntKey*) -- See DIIS.

         * **potential** (*BoolType** | **BoolKey*) -- See DIIS.

         * **print** (*int** | **IntKey*) -- See DIIS.

         * **variant** (*str** | **StringKey*) -- See DIIS.

   class _DOS

      Density-Of-States (DOS) options

      Variables:
         * **AbsoluteMaxMin** (*BoolType** | **BoolKey*) -- When
           DOS%Min and DOS%Max are used: should they be absolute or
           relative to the fermi level.

         * **CalcDOS** (*BoolType** | **BoolKey*) -- Whether or not to
           calculate the density of states.

         * **CalcPDOS** (*BoolType** | **BoolKey*) -- Whether or not
           to calculate the partial DOS (projections on basis
           functions). This can be significantly more expensive than
           calculating the total DOS

         * **CalcPopulationAnalysis** (*BoolType** | **BoolKey*) --
           Whether or not to calculate the population analysis.
           Population analysis can become very expensive when there
           are many symmetry operators, such as in a super cell.

         * **CompensateDeltaE** (*BoolType** | **BoolKey*) -- Only
           relevant when IntegrateDeltaE=yes. If set to true then
           after integrating each interval over DeltaE the result is
           divided by DeltaE, so that the unit is DOS.

         * **DeltaE** (*float** | **FloatKey*) -- Energy step for the
           DOS grid. Using a smaller value (e.g. half the default
           value) will result in a finer sampling of the DOS.

         * **Enabled** (*BoolType** | **BoolKey*) -- Obsolete key
           whether or not to calculate the density of states.

         * **Energies** (*int** | **IntKey*) -- Number of equidistant
           energy-values for the DOS grid. This keyword is superseded
           by the 'DeltaE' keyword.

         * **File** (*str** | **Path** | **StringKey*) -- Write the
           DOS (plain text format) to the specified file instead of
           writing it to the standard output.

         * **IntegrateDeltaE** (*BoolType** | **BoolKey*) -- This
           subkey handles which algorithm is used to calculate the
           data-points in the plotted DOS. If true, the data-points
           represent an integral over the states in an energy
           interval. Here, the energy interval depends on the number
           of Energies and the user-defined upper and lower energy for
           the calculation of the DOS. The result has as unit [number
           of states / (energy interval * unit cell)]. If false, the
           data-points do represent the number of states for a
           specific energy and the resulting plot is equal to the DOS
           per unit cell (unit: [1/energy]). Since the resulting plot
           can be a wild function and one might miss features of the
           DOS due to the step length between the energies, the
           default is set to the integration algorithm.

         * **Max** (*float** | **FloatKey*) -- User defined upper
           bound energy (with respect to the Fermi energy)

         * **MaxBandSliceSize** (*int** | **IntKey*) -- Undocumented.

         * **MaxFuncSliceSize** (*int** | **IntKey*) -- Undocumented.

         * **Min** (*float** | **FloatKey*) -- User defined lower
           bound energy (with respect to the Fermi energy)

         * **ReduceSymmetryOperatorsForIBZExpansion** (*BoolType** |
           **BoolKey*) -- To expand the eigensystem to the whole BZ
           either all or a minimal set can be used. If it can be
           reduced this is the faster option.

         * **StoreCoopPerBasPair** (*BoolType** | **BoolKey*) --
           Calculate the COOP (crystal orbital overlap population).

         * **UseSharedArrays** (*BoolType** | **BoolKey*) --
           Undocumented.

   class _DensityPlot

      Plots of the density. Goes together with the Restart%DensityPlot
      and Grid keys.

   class _Dependency

      Criteria for linear dependency of the basis and fit set

      Variables:
         * **AllowBasisDependency** (*BoolType** | **BoolKey*) --
           Project out the dependent part of the basis set (associated
           with small eigenvalues of the overlap matrix).

         * **Basis** (*float** | **FloatKey*) -- Criteria for linear
           dependency of the basis: smallest eigenvalue of the overlap
           matrix of normalized Bloch functions.

         * **Core** (*float** | **FloatKey*) -- The program verifies
           that the frozen core approximation is reasonable, by
           checking the smallest eigen value of the overlap matrix of
           the core (Bloch) orbitals (which should ideally be one) is
           bigger than this criterion.

         * **CoreValence** (*float** | **FloatKey*) -- Criterion for
           dependency of the core functions on the valence basis. The
           maximum overlap between any two normalized functions in the
           two respective function spaces should not exceed
           1.0-corevalence

         * **Fit** (*float** | **FloatKey*) -- Criterion for
           dependency of the total set of fit functions. The value
           monitored is the smallest eigenvalue of the overlap matrix
           of normalized Bloch sums of symmetrized fit functions.

         * **KeepShapeForDependencyFix** (*BoolType** | **BoolKey*) --
           If AllowBasisDependency=true, this triggers the most simple
           fix, where all matrices retain their shape.

   class _DiracOptions

      Options for the atomic Dirac calculations.

      Variables:
         * **DumpAllTables** (*BoolType** | **BoolKey*) -- Dump many
           functions during the SCF on a file call dirac.rkf. Works
           only for one atom. xxx

         * **UseDidervInDigradRel** (*BoolType** | **BoolKey*) -- For
           scalar zora dv/dr is used to get the analytical second
           derivative of the large component. It can also be obtained
           by numerical differentiation of dpsi/dr

         * **convergence** (*float** | **FloatKey*) -- Convergence
           criterion, based on input/output density difference.

         * **damping** (*float** | **FloatKey*) -- Undocumented.

         * **maxcycles** (*int** | **IntKey*) -- Maximum number of
           self-consistent attempts to be made.

         * **rnuc** (*float** | **FloatKey*) -- Undocumented.

         * **rwell** (*float** | **FloatKey*) -- Undocumented.

         * **spinor** (*BoolType** | **BoolKey*) -- Undocumented.

         * **vwell** (*float** | **FloatKey*) -- Undocumented.

   class _Dispersion

      Technical options for dispersion-corrected functionals.

      Variables:
         **CutOffDistance** (*float** | **FloatKey*) -- Undocumented

   class _DosBas

      Used to specify the fragment basis for the DOS.

   class _EFG

      The electronic charge density causes an electric field, and the
      gradient of this field couples with the nuclear quadrupole
      moment, that some (non-spherical) nuclei have and can be
      measured by several spectroscopic techniques. The EFG tensor is
      the second derivative of the Coulomb potential at the nuclei.
      For each atom it is a 3x3 symmetric and traceless matrix.
      Diagonalization of this matrix gives three eigenvalues, which
      are usually ordered by their decreasing absolute size and
      denoted as V_{xx}, V_{yy}, V_{zz}. The result is summarized by
      the largest eigenvalue and the asymmetry parameter.

      Variables:
         **Enabled** (*BoolType** | **BoolKey*) -- Compute the EFG
         tensor (for nuclear quadrupole interaction).

   class _ESR

      Zeeman g-tensor. The Zeeman g-tensor is implemented using two-
      component approach of Van Lenthe and co-workers in which the
      g-tensor is computed from a pair of spinors related to each
      other by time-reversal symmetry. Note: the following options are
      necessary for ESR: 'Relativistic zora spin' and 'Kspace 1'

      Variables:
         **Enabled** (*BoolType** | **BoolKey*) --

         Compute Zeeman g-tensor.

         The Zeeman g-tensor is implemented using two-component
         approach of Van Lenthe and co-workers in which the g-tensor
         is computed from a pair of spinors related to each other by
         time-reversal symmetry.

         Note: the following options are necessary for ESR:
         'Relativistic zora spin' and 'Kspace 1'

   class _EffectiveMass

      In a semi-conductor, the mobility of electrons and holes is
      related to the curvature of the bands at the top of the valence
      band and the bottom of the conduction band.

      With the effective mass option, this curvature is obtained by
      numerical differentiation.

      The estimation is done with the specified step size, and twice
      the specified step size, and both results are printed to give a
      hint on the accuracy. The easiest way to use this key is to
      enabled it without specifying any extra options.

      Variables:
         * **Enabled** (*BoolType** | **BoolKey*) -- Compute the
           EffectiveMass.

         * **KPointCoord** (*Iterable**[**float**] **|
           **FloatListKey*) -- Coordinate of the k-points for which
           you would like to compute the effective mass.

         * **NumAbove** (*int** | **IntKey*) -- Number of bands to
           take into account above the Fermi level.

         * **NumBelow** (*int** | **IntKey*) -- Number of bands to
           take into account below the Fermi level.

         * **StepSize** (*float** | **FloatKey*) -- Size of the step
           taken in reciprocal space to perform the numerical
           differentiation

         * **UseBandStructureInfoFromPath** (*BoolType** | **BoolKey*)
           -- The (automatic) location of the HOMO and LUMO can be
           determined via band interpolation, or from the path as used
           by the BandStructure feature. The latter works better when
           they are located on the path. See also comments in the
           BandStructure block. To reproduce results from before
           ams2025 set to no.

   class _ElectronHole

      Allows one to specify an occupied band which shall be
      depopulated, where the electrons are then moved to the Fermi
      level. For a spin-restricted calculation 2 electrons are shifted
      and for a spin-unrestricted calculation only one electron is
      shifted.

      Variables:
         * **BandIndex** (*int** | **IntKey*) -- Which occupied band
           shall be depopulated.

         * **SpinIndex** (*int** | **IntKey*) -- Defines the spin of
           the shifted electron (1 or 2).

   class _EmbeddingPotential

      An external potential can be read in and will be added to the
      effective Kohn-Sham potential. It has to be on the becke grid

      Variables:
         * **Filename** (*str** | **StringKey*) -- Name of the file
           containing the embedding potential.

         * **PotentialName** (*str** | **StringKey*) -- Name of
           variable containing the potential.

   class _Excitations

      Excitation energies: UV/Vis

      Variables:
         **BSE** (*BoolType** | **BoolKey*) -- Solve the static Bethe-
         Salpeter equation based on a GW calculation

   class _Fermi

      Technical parameter used in determining the Fermi energy, which
      is carried out at each cycle of the SCF procedure.

      Variables:
         * **Delta** (*float** | **FloatKey*) -- Convergence
           criterion: upper and lower bounds for the Fermi energy and
           the corresponding integrated charge volumes must be equal
           within delta.

         * **Eps** (*float** | **FloatKey*) -- After convergence of
           the Fermi energy search procedure, a final estimate is
           defined by interpolation and the corresponding integrated
           charge volume is tested. It should be exact, to machine
           precision. Tested is that it deviates not more than eps.

         * **MaxTry** (*int** | **IntKey*) -- Maximum number of
           attempts to locate the Fermi energy. The procedure is
           iterative in nature, narrowing the energy band in which the
           Fermi energy must lie, between an upper and a lower bound.
           If the procedure has not converged sufficiently within
           MaxTry iterations, the program takes a reasonable value and
           constructs the charge density by interpolation between the
           functions corresponding to the last used upper and lower
           bounds for the Fermi energy.

         * **RefinePostSCFFactor** (*int** | **IntKey*) -- Use a finer
           k-grid after the scf to calculate a refined fermi level.
           Makes only sense for metals. Works like DoubleCount. Use
           1,2,3

   class _FermiSurface

      Calculation of the Fermi surface for metals

      Variables:
         * **AvoidDuplicates** (*BoolType** | **BoolKey*) --
           Undocumented.

         * **CaseA** (*BoolType** | **BoolKey*) -- Undocumented.

         * **CaseB** (*BoolType** | **BoolKey*) -- Undocumented.

         * **CaseC** (*BoolType** | **BoolKey*) -- Undocumented.

         * **ConjugateGradient** (*BoolType** | **BoolKey*) --
           Undocumented.

         * **Enabled** (*BoolType** | **BoolKey*) -- Calculate the
           Fermi surface if the system has no band gap (i.e. is a
           metal). The result can be visualized with amsbands.

         * **KIntegForSymmetricKGrid** (*int** | **IntKey*) -- If the
           (default) regular k-grid is used, a symmetric one is
           created to determine the Fermi surface. If this key is not
           specified an automatic value of kInteg is used. Odd values
           trigger quadratic interpolation.

         * **NMesh** (*int** | **IntKey*) -- Improves the matching of
           the interpolated quadratic surface. For better results it
           makes more sense to increases KIntegForSymmetricKGrid.

         * **Symmetry** (*str** | **StringKey*) -- Undocumented.

         * **UniqueWedgeOnly** (*BoolType** | **BoolKey*) --
           Undocumented.

   class _FitMethod

      Undocumented

      Variables:
         * **ConstrainCharge** (*BoolType** | **BoolKey*) --
           Undocumented

         * **ConstrainWiths** (*BoolType** | **BoolKey*) --
           Undocumented

         * **Divide** (*str** | **StringKey*) -- Undocumented

         * **Method** (*str** | **StringKey*) -- Undocumented

         * **PruneDivisions** (*BoolType** | **BoolKey*) --
           Undocumented

         * **RScale** (*float** | **FloatKey*) -- Undocumented

         * **RepeatDivisions** (*BoolType** | **BoolKey*) --
           Undocumented

         * **StoreFinalFitTra** (*BoolType** | **BoolKey*) --
           Undocumented

         * **UseSharedarrays** (*BoolType** | **BoolKey*) --
           Undocumented

   class _FracOp

      Parameters from input for fractional occupations

      Variables:
         * **Criterion** (*float** | **FloatKey*) -- Undocumented

         * **Dirac** (*BoolType** | **BoolKey*) -- Undocumented

         * **Gammix** (*float** | **FloatKey*) -- Undocumented

         * **Maxgam** (*int** | **IntKey*) -- Undocumented

         * **Maxscf** (*int** | **IntKey*) -- Undocumented

         * **Print** (*int** | **IntKey*) -- Undocumented

         * **SCF** (*BoolType** | **BoolKey*) -- Undocumented

   class _FragOccupations

      Undocumented

   class _Fragment

      Defines a fragment. You can define several fragments for a
      calculation.

      Variables:
         * **Filename** (*str** | **StringKey*) -- Filename of the
           fragment. Absolute path or path relative to the executing
           directory.

         * **Region** (*str** | **StringKey*) -- Region name.

         * **AtomMapping** (*str** | **Sequence**[**str**] **|
           **FreeBlock*) -- Format 'indexFragAt indexCurrentAt'. One
           has to associate the atoms of the fragment to the atoms of
           the current calculation. So, for each atom of the fragment
           the indexFragAt has to be associated uniquely to the
           indexCurrentAt for the current calculation.

         * **Labels** (*str** | **Sequence**[**str**] **|
           **FreeBlock*) -- This gives the possibility to introduce
           labels for the fragment orbitals. See examples.

      class _AtomMapping

         Format 'indexFragAt indexCurrentAt'. One has to associate the
         atoms of the fragment to the atoms of the current
         calculation. So, for each atom of the fragment the
         indexFragAt has to be associated uniquely to the
         indexCurrentAt for the current calculation.

      class _Labels

         This gives the possibility to introduce labels for the
         fragment orbitals. See examples.

   class _FragmentEnergyTerms

      Undocumented

   class _FuzzyPotential

      Atomic (fuzzy cell) based, external, electric potential. See
      example.

   class _FuzzyUnitCellGrid

      Undocumented.

      Variables:
         * **AtomRadiusLSG** (*float** | **FloatKey*) -- Undocumented.

         * **CellPartitionDelta** (*float** | **FloatKey*) --
           Undocumented.

         * **CellPartitionInterpolationCubic** (*BoolType** |
           **BoolKey*) -- Undocumented.

         * **CellPartitionInterpolationMesh** (*int** | **IntKey*) --
           Undocumented.

         * **CellPartitionVersion** (*int** | **IntKey*) --
           Undocumented.

         * **CentralizeNaturalLSG** (*BoolType** | **BoolKey*) --
           Undocumented.

         * **InterpolateCellPartition** (*BoolType** | **BoolKey*) --
           Undocumented.

         * **NumIntExtraL** (*int** | **IntKey*) -- Undocumented.

         * **NumIntExtraRad** (*int** | **IntKey*) -- Undocumented.

         * **PartitionFunctionTol** (*float** | **FloatKey*) --
           Undocumented.

         * **PruneLatticeSummedGrid** (*BoolType** | **BoolKey*) --
           Undocumented.

         * **ReduceAccuracyLSG** (*BoolType** | **BoolKey*) --
           Undocumented.

         * **SimpleLatticeSummedGrid** (*BoolType** | **BoolKey*) --
           Undocumented.

   class _GMix

      Undocumented. Old NEGF.

      Variables:
         * **ExtraMix** (*float** | **FloatKey*) -- Undocumented.

         * **MinMix** (*float** | **FloatKey*) -- Undocumented.

         * **StopMix** (*int** | **IntKey*) -- Undocumented.

   class _GW

      Perform a GW calculation. G0W0 is the default for
      GW%SelfConsistency.

      Variables:
         * **AdaptiveMixing** (*Iterable**[**float**] **|
           **FloatListKey*) --

           Requests to use adaptive mixing instead of DIIS and sets
           the staring mixing parameter for mixing of Green's function
           in case of self-consistency.

           Adapative mixing is recommended in case a qsGW calculation
           does not converge with DIIS.

           It is ignored in non-selfconsistent calculation and
           overwritten by DIIS when DIIS is also present.

         * **DIIS** (*int** | **IntKey*) -- Requests to use DIIS. This
           is the Default. Number of expansion coefficients can be
           requested as well. Ignored in non-selfconsistent
           calculation

         * **Enabled** (*BoolType** | **BoolKey*) -- Enable the
           calculation of the GW quasi-particle energies.

         * **ExpansionOrder** (*int** | **IntKey*) -- Order of the
           expansion of the screened interaction on the SOS-GF(n)
           method. order 2 (=SOS-GF2) is the default

         * **FixedGridSizes** (*BoolType** | **BoolKey*) -- In a self-
           consistent GW calculation, recalculate Grids but keep them
           the same size during the SCF procedure.

         * **FixedGrids** (*BoolType** | **BoolKey*) -- In a self-
           consistent GW calculation, do not recalculate Grids. Can be
           useful in case of convergence problems. Only relevant for
           qsGW and qsGW0. In case of evGW and evGW0, the grids are
           always kept fixed.

         * **G3W2** (*Literal**[**"Full"**, **"Diagonal"**,
           **"Perturbative"**]*) -- Only relevant when self-energy is
           one of GF2 or G3W2: Full requests that the second-order
           term is evaluated for the full self-energy matrix. This is
           very expensive and should only be done for small systems.
           Diagonal requests, that only the Diagonal of the self-
           energy matrix is updated. Perturbative means, that only a
           second-order screened exchange correction is evaluated
           after the GW calculation is completed. For a G0W0
           calculation, all of these options are equivalent.

         * **LinearMixing** (*Iterable**[**float**] **|
           **FloatListKey*) --

           Requests to use linear mixing instead of DIIS and sets the
           mixing parameter for linear mixing of Green's function in
           case of self-consistency.

           It is ignored in non-selfconsistent calculation and
           overwritten by DIIS when DIIS is also present.

         * **LinearizeQPequations** (*BoolType** | **BoolKey*) --

           Instead of solving the non-linear QP equations in a G0W0
           (or evGW calculation) by bisection exacly, linearize them
           by first-order Taylor expansion.

           This is not recommended since it does not save
           computational time when used together with analytical
           continuation (as implemented in AMS). It might however be
           useful for benchmarking or for validating results.

           If the results os the linearization differ by a lot (for
           instance, more than 0.1 eV in frontier QP energies) from
           the non-linearized results, this might indicate that the GW
           calculation is not reliable.

         * **OffDiagonalEFermi** (*BoolType** | **BoolKey*) --
           Analytically continue the off-diagonal elements of the KSF2
           qsGW Hamiltonian at the Fermi-energy instead of omega=0.
           Typically leads to slightly lower QP energies, i.e. higher
           ionization potentials. The HOMO-LUMO gaps are typically not
           affected.

         * **Polarizability** (*Literal**[**"RPA"**, **"BSE"**,
           **"G4W1"**, **"G4V1"**, **"TDHF"**]*) --

           Sets the expression for the Polarizability used in the GW
           calculation.

           RPA is the Default and amounts to a standard GW
           calculation.

           BSE denotes screening in the Bethe-Salpeter-equation
           formalism.

         * **PrintAllSolutions** (*BoolType** | **BoolKey*) -- Print
           out all solutions for all requested states. Detects
           multiple solutions of the QP equations.

         * **PrintImaginaryAxisData** (*BoolType** | **BoolKey*) -- If
           true, print out the self-energy on the imaginary axis.

         * **PrintSpectralFunction** (*BoolType** | **BoolKey*) --
           Plot the self-energy as a function of frequency.
           Automatically done in case of analytical continuation.
           However, this is expensive in the analytical integration
           formalism.

         * **PrintZfactor** (*BoolType** | **BoolKey*) --

         * **QPHamiltonian** (*Literal**[**"KSF1"**, **"KSF2"**,
           **"SRG"**, **"LQSGW"**]*) --

           The quasi-particle Hamiltonian can be constructed in
           different ways.

           KSF1 refers to the original construction by Kotani, Van
           Schilfgaarde anf Faleev (KSF) which is also implemented in
           TURBOMOLE.

           KSF2 refers to an alternative construction by KSF.

           KSF1 is not recommended since it is numerically less stable
           than KSF2 in case analytical continuation is used (the
           default).

           In case the analytical integration algorithm is used, only
           KSF1 is implemented. Therefore, make sure that KSF1 is
           specified. The results are typically very similar.

           The QP energies at which the matrix elements are evaluated
           can be tweaked further, see the two subsequent keys:
           However, KSF2 is recommended since it typically leads to QP
           energies with the best agreement with experiment.

           Ignored when not a quasi-particle self-consistent GW
           calculation is performed

         * **Scaling** (*float** | **FloatKey*) -- Scale factor for
           the polarizability in the screened interaction SOS-GF2.
           Default = 1.0 (corresponds to no scaling)

         * **ScissorShift** (*BoolType** | **BoolKey*) --

           Only calculate the HOMO and LUMO QP energies and shift the
           remaining QP energies by the same amount.

           This is a rather crude approximation and not recommended.

           It might again be useful for benchmarking purposes.

         * **SelfConsistency** (*Literal**[**"None"**, **"G0W0"**,
           **"EVGW0"**, **"EVGW"**, **"QSGW0"**, **"QSGW"**]*) --

           Sets the level of self-consistency in a GW calculation.

           G0W0 calculates a one-shot, perturbative correction to the
           KS eigenvalues.

           In evGW and evGW0, the quasi-particle energies are updated
           until self-consistency is reached.

           evGW0 requests that the Green's function is evaluated self-
           consistently but not the screened interaction.

           In qsGW, the density is updated as well, however, the self-
           energy is mapped to a static effective potential and the
           Dyson equation is solved by diagonalization instead of
           inversion. The results of a qsGW are independent of the
           choice of the underlying exchange-correlation functional
           and are usually the most accurate ones.

           The same is done in qsGW0, but the screened interaction is
           not updated.

         * **SelfConsistentSigmaVertex** (*BoolType** | **BoolKey*) --
           If active, evaluate the vertex correction in Sigma in qsGW
           self-consistent. Only supported for GWGammaInf so far

         * **SelfEnergy** (*Literal**[**"HF"**, **"GW"**, **"G3W2"**,
           **"SOSEX"**, **"GWGamma"**, **"G3W2dynamic"**,
           **"GWGammaInf"**, **"GWGammaInfDyn"**]*) --

           Controls the form of the self-energy.

           GW is the default and corresponds to the standard GW
           calculation.

           G3W2 is a GW calculation plus a perturbative second-order
           statically screened exchange correction (second order
           expansion in the self-energy). Note, that there the self-
           energy is always static.

         * **TabulateGridPoints** (*BoolType** | **BoolKey*) --
           pretabulate grid points for numerical integration.

         * **nIterations** (*Iterable**[**int**] **| **IntListKey*) --

           The maximum number of iterations within the (partially or
           fully) self-consistent GW calculation has to converge.

           Ignored when Formalism is set to G0W0

         * **nLowest** (*int** | **IntKey*) -- Number of lowest
           occupied QP levels to be evaluated, overwrites nStates'

         * **nStates** (*int** | **IntKey*) --

           Number of Quasiparticle States to be printed to output.

           The default is 5 states which in this case means that
           min(5, Number of particle states) occupied and min(5,
           Number of hole states) hole states are printed. The whole
           list of states can be printed by setting this parameter to
           -1'

         * **preconditionQSGW** (*BoolType** | **BoolKey*) --

           If true, the QSGW equations are solved but prior to each
           diagonalization, i.e. a G0W0 calculation is performed to
           find the optimal QP energies at which to analytically
           continue the self-energy.

           This is in principle a more consistent construction than
           KSF1 or KSF2 since the diagonal elements are consistent
           with G0W0.

           In KSF1 and KSF2, the diagonal elements are evaluated at
           the QP energies from the previous iteration which is
           equivalent to a zeroth-order Taylor expansion of the
           diagonal elements around the previous QP energies.Enabling
           this option typically leads to slightly lower QP energies.

         * **AnalyticalIntegration**
           (*BAND._GW._AnalyticalIntegration*) -- Use analytical
           integration to calculate the self-energy. Very slow, unless
           the system is very small but useful to check the accuracy
           of the frequency integration

         * **Converge** (*BAND._GW._Converge*) -- Sets convergence
           criteria for the GW calculation in self-consistent case

      class _AnalyticalIntegration

         Use analytical integration to calculate the self-energy. Very
         slow, unless the system is very small but useful to check the
         accuracy of the frequency integration

         Variables:
            * **Enabled** (*BoolType** | **BoolKey*) -- Enable the
              calculation of the GW quasi-particle energies via
              analytical integration.

            * **SpectralFunctionResolution** (*int** | **IntKey*) --
              Number of points at which spectral function is
              evaluated.

            * **TDA** (*BoolType** | **BoolKey*) -- Solve the linear
              response equations in the Tamm-Dancoff approximation.

            * **eta** (*float** | **FloatKey*) --

              Artificial (positive) broadening parameter for
              evaluation of self-energy in analytical integration.

              Ideally should be as small as possible but this might
              lead to convergence issues in partially self-consistent
              approaches.

              In this case, a value of up to 0.1 is possible.

            * **printBSEexcitationsInLastIteration** (*BoolType** |
              **BoolKey*) --

              Print out BSE excitations in the last iteration in a
              qsGW calculation. Can be used in the BAND engine.

              In ADF, one should instead just calculate excitation
              energies using the excitation block.

      class _Converge

         Sets convergence criteria for the GW calculation in self-
         consistent case

         Variables:
            * **Density** (*Iterable**[**float**] **| **FloatListKey*)
              --

              First Criterion for self-consistency procedure to
              terminate.

              Criterion is the trace of the density matrix. Ignored in
              non-selfconsistent Calculation and in eigenvalue self-
              consistent GW

              It is possible to run a qsGW calculation with an inner
              SCF loop which updates the static part of the elf-energy
              only. This can be useful to accelerate the convergence
              in case linear mixing is used. It is not recommended to
              use linear mixing, so it is also not recommended to use
              that inner loop as well. The second number in this list
              specifies the convergence criterion for the inner SCF
              loop.

            * **HOMO** (*float** | **FloatKey*) --

              Criterion for self-consistency procedure to terminate.

              The self-consistent GW calculation terminates, when the
              difference between the HOMO QP energies between 2
              consecutive iterations is below this number.

              The LUMO energy converged faster than the HOMO energy so
              when the HOMO energy is converged according to this
              criterion, the LUMO energy will be converged as well.

              In non-selfconsistent Calculation, this criterion is
              ignored.

   class _Gate

      Undocumented. Old NEGF.

      Variables:
         * **Basfnc** (*int** | **IntKey*) -- Undocumented.

         * **Phi** (*float** | **FloatKey*) -- Undocumented.

         * **Phia** (*float** | **FloatKey*) -- Undocumented.

         * **Phib** (*float** | **FloatKey*) -- Undocumented.

         * **Plot** (*int** | **IntKey*) -- Undocumented.

   class _Gradients

      Options for nuclear gradients and strain derivatives
      calculations.

      Variables:
         * **AccurateNucGradKin** (*BoolType** | **BoolKey*) --
           Undocumented.

         * **AddCoulombAndXC** (*BoolType** | **BoolKey*) --
           Undocumented.

         * **CoreOrthApprox** (*int** | **IntKey*) -- Undocumented.

         * **CoreOrthPartialInt** (*BoolType** | **BoolKey*) --
           Undocumented.

         * **FastNucGradRho** (*BoolType** | **BoolKey*) --
           Undocumented.

         * **KgrpxNucGradRho** (*int** | **IntKey*) -- Undocumented.

         * **LatticeStepSize** (*float** | **FloatKey*) --
           Undocumented.

         * **MetaGGAUpdateOption** (*int** | **IntKey*) -- How to
           update metaGGA nuclear gradient terms. Option 1 is the
           original implementation. Option 2 is faster and requires
           less memory

         * **NeglectCoreCoreTerm** (*BoolType** | **BoolKey*) --
           Undocumented.

         * **NucGradAtomGroupSize** (*int** | **IntKey*) -- Avoid
           handling the nuclear gradient of the basis set of all atoms
           at once. A negative value means: handle all at once.
           Currently only affects MetaGGA calculations.

         * **NucGradElstatOption** (*int** | **IntKey*) --
           Undocumented.

         * **NucGradexcoption** (*int** | **IntKey*) -- Undocumented.

         * **NucGradkinoption** (*int** | **IntKey*) -- Undocumented.

         * **OldIO** (*int** | **IntKey*) -- Undocumented.

         * **StrainDerivatives** (*BoolType** | **BoolKey*) --
           Undocumented.

         * **StrainDerunitcellintegraloption** (*int** | **IntKey*) --
           Undocumented.

         * **StrainDerwholespaceintegraloption** (*int** | **IntKey*)
           -- Undocumented.

         * **ViaVOC** (*BoolType** | **BoolKey*) -- Undocumented.

         * **WipeOneCenterTerms** (*BoolType** | **BoolKey*) --
           Undocumented.

   class _Grid

      Options for the regular grid used for plotting (e.g. density
      plot). Used ICW the restart option.

      Variables:
         * **ExtendX** (*float** | **FloatKey*) -- Extend the default
           regular grid along the x-direction by the specified amount:
           [x_min, x_max] => [x_min - ExtendX/2, x_max + ExtendX/2].

         * **ExtendY** (*float** | **FloatKey*) -- Extend the default
           regular grid along the y-direction by the specified amount:
           [y_min, y_max] => [y_min - ExtendY/2, y_max + ExtendY/2].

         * **ExtendZ** (*float** | **FloatKey*) -- Extend the default
           regular grid along the z-direction by the specified amount:
           [z_min, z_max] => [z_min - ExtendZ/2, z_max + ExtendZ/2].

         * **FileName** (*str** | **StringKey*) -- Read in the grid
           from a file. The file format of the grid is: three numbers
           per line (defining the x, y and z coordinates of the
           points).

         * **Type** (*Literal**[**"coarse"**, **"medium"**,
           **"fine"**]*) -- The default regular grids.

         * **UserDefined** (*str** | **Sequence**[**str**] **|
           **FreeBlock*) -- One can define the regular grid
           specification in this block. See example. Default unit is
           Bohr

      class _UserDefined

         One can define the regular grid specification in this block.
         See example. Default unit is Bohr

   class _GridBasedAIM

      Invoke the ultra fast grid based Bader analysis.

      Variables:
         * **Enabled** (*BoolType** | **BoolKey*) -- Invoke the ultra
           fast grid based Bader analysis.

         * **Iterations** (*int** | **IntKey*) -- The maximum number
           of steps that may be taken to find the nuclear attractor
           for a grid point.

         * **SmallDensity** (*float** | **FloatKey*) -- Value below
           which the density is ignored. This should not be chosen too
           small because it may lead to unassignable grid points.

         * **UseStartDensity** (*BoolType** | **BoolKey*) -- Whether
           the analysis is performed on the startup density (True) or
           on the final density (False).

   class _GrossPopulations

      Partial DOS (pDOS) are generated for the gross populations
      listed under this key. See example.

   class _HardConfinement

      Obsolete basis functions confinement method. Use SoftConfinement
      instead.

      Variables:
         * **delta** (*float** | **FloatKey*) -- Undocumented.

         * **radius** (*float** | **FloatKey*) -- Undocumented.

   class _HubbardU

      Options for Hubbard-corrected DFT calculations.

      Variables:
         * **Enabled** (*BoolType** | **BoolKey*) -- Whether or not to
           apply the Hubbard Hamiltonian. Can be useful to turn of
           Hubbard in a script with a single variable.

         * **IgnoreForPEDA** (*BoolType** | **BoolKey*) -- Ignore the
           hubbard energy term when calculating the energy of psi_0
           for the energy decomposition analysis (EDA).

         * **LValue** (*str** | **StringKey*) -- For each atom type
           specify the l value (0 - s orbitals, 1 - p orbitals, 2 - d
           orbitals). A negative value is interpreted as no l-value.

         * **PrintOccupations** (*BoolType** | **BoolKey*) -- Whether
           or not to print the occupations during the SCF.

         * **UValue** (*str** | **StringKey*) -- For each atom type
           specify the U value (in atomic units). A value of 0.0 is
           interpreted as no U.

         * **UseDiagonalOccupations** (*BoolType** | **BoolKey*) --
           Undocumented.

         * **UseNAO** (*BoolType** | **BoolKey*) -- Undocumented.

         * **Atom** (*BAND._HubbardU._Atom*) -- Specify Hubbard
           parameters (U,l) for a certain element

         * **Region** (*BAND._HubbardU._Region*) -- Specify Hubbard
           parameters (U,l) for all atoms in a certain region

      class _Atom

         Specify Hubbard parameters (U,l) for a certain element

         Variables:
            * **Element** (*str** | **StringKey*) -- Name of the
              element, such as Cu or Zn

            * **LValue** (*Literal**[**"s"**, **"p"**, **"d"**,
              **"f"**]*) -- L value of the shell to apply the Hubbard
              model to

            * **UValue** (*float** | **FloatKey*) -- Hubbard U value.

      class _Region

         Specify Hubbard parameters (U,l) for all atoms in a certain
         region

         Variables:
            * **LValue** (*Literal**[**"s"**, **"p"**, **"d"**,
              **"f"**]*) -- L value of the shell to apply the Hubbard
              model to

            * **Name** (*str** | **StringKey*) -- Name of the region

            * **UValue** (*float** | **FloatKey*) -- Hubbard U value.

   class _Integration

      Options for the Voronoi numerical integration scheme.
      Deprecated. Use BeckeGrid instead.

      Variables:
         * **AccInt** (*float** | **FloatKey*) -- General parameter
           controlling the accuracy of the Voronoi integration grid. A
           value of 3 would be basic quality and a value of 7 would be
           good quality.

         * **AccOut** (*float** | **FloatKey*) -- Integration accuracy
           for the outer region.

         * **AccPyr** (*float** | **FloatKey*) -- Undocumented.

         * **AccPyu** (*float** | **FloatKey*) -- Undocumented.

         * **AccPyv** (*float** | **FloatKey*) -- Undocumented.

         * **AccPyw** (*float** | **FloatKey*) -- Undocumented.

         * **AccSph** (*float** | **FloatKey*) -- Integration accuracy
           for the atomic sphere regions.

         * **AccZae** (*float** | **FloatKey*) -- Undocumented.

         * **Add** (*int** | **IntKey*) -- Undocumented.

         * **AllElectron** (*BoolType** | **BoolKey*) -- Undocumented.

         * **DisHul** (*float** | **FloatKey*) -- Undocumented.

         * **FRange** (*float** | **FloatKey*) -- Undocumented.

         * **LInteg** (*str** | **StringKey*) -- Undocumented.

         * **LinRot** (*int** | **IntKey*) -- Undocumented.

         * **NOuter** (*int** | **IntKey*) -- Undocumented.

         * **NumMulangsph** (*float** | **FloatKey*) -- Undocumented.

         * **NumMulout** (*float** | **FloatKey*) -- Undocumented.

         * **NumMulpyr** (*int** | **IntKey*) -- Undocumented.

         * **NumMulpyruv** (*float** | **FloatKey*) -- Undocumented.

         * **NumMulpyrw** (*float** | **FloatKey*) -- Undocumented.

         * **NumMulradsph** (*float** | **FloatKey*) -- Undocumented.

         * **NumMulsph** (*int** | **IntKey*) -- Undocumented.

         * **Ord** (*int** | **IntKey*) -- Undocumented.

         * **OutPar** (*float** | **FloatKey*) -- Undocumented.

         * **OutRad** (*float** | **FloatKey*) -- Undocumented.

         * **Slow** (*BoolType** | **BoolKey*) -- Undocumented.

         * **TSTF** (*BoolType** | **BoolKey*) -- Undocumented.

   class _KSpace

      Options for the k-space integration (i.e. the grid used to
      sample the Brillouin zone)

      Variables:
         * **Analytical** (*BoolType** | **BoolKey*) --

           For analytical integration the BZ is split into simplices,
           whereover the bands are interpolated, ater which the
           integrals can be performed analytically.

           Alternatively, the set of eigenvalues in the discrete set
           of k-points are just handled as distinct molecular
           orbitals.

           Using analytical=no can improve SCF convergence in
           combination with smearing/temperature.

         * **Quality** (*Literal**[**"Auto"**, **"GammaOnly"**,
           **"Basic"**, **"Normal"**, **"Good"**, **"VeryGood"**,
           **"Excellent"**]*) --

           Select the quality of the K-space grid used to sample the
           Brillouin Zone. If 'Auto', the quality defined in the
           'NumericalQuality' will be used. If 'GammaOnly', only one
           point (the gamma point) will be used.

           The actual number of K points generated depends on this
           option and on the size of the unit cell. The larger the
           real space cell, the fewer K points will be generated.

           The CPU-time and accuracy strongly depend on this option.

         * **Type** (*Literal**[**"Regular"**, **"Symmetric"**]*) --

           The type of k-space integration grid used to sample the
           Brillouin zone (BZ) used.

           'Regular': simple regular grid.

           'Symmetric': symmetric grid for the irreducible wedge of
           the first BZ (useful when high-symmetry points in the BZ
           are needed to capture the correct physics of the system,
           graphene being a notable example).

         * **Regular** (*BAND._KSpace._Regular*) -- Options for the
           regular k-space integration grid.

         * **Symmetric** (*BAND._KSpace._Symmetric*) -- Options for
           the symmetric k-space integration grid.

      class _Regular

         Options for the regular k-space integration grid.

         Variables:
            * **DoubleCount** (*int** | **IntKey*) -- Increase for
              each dimension the grid. A sequence of doubling, with a
              special meaning for grid with odd numbers. Useful when
              checking k-space convergence.

            * **KMesh** (*int** | **IntKey*) -- Undocumented.

            * **NumberOfPoints** (*Iterable**[**int**] **|
              **IntListKey*) --

              Use a regular grid with the specified number of k-points
              along each reciprocal lattice vector.

              For 1D periodic systems you should specify only one
              number, for 2D systems two numbers, and for 3D systems
              three numbers.

            * **PreferEvenNumberOfPoints** (*BoolType** | **BoolKey*)
              -- In case of an automatic grid normally odd numbers
              will be generated (1,3,5,9), suitable for a quadratic
              grid. With this option the suggested odd numbers will be
              increased by one, unless it is one.

            * **SplitCubeInSix** (*BoolType** | **BoolKey*) --
              Undocumented.

            * **SplitLongest** (*BoolType** | **BoolKey*) --
              Undocumented.

            * **SplitPermutation** (*int** | **IntKey*) --
              Undocumented.

      class _Symmetric

         Options for the symmetric k-space integration grid.

         Variables:
            * **KInteg** (*int** | **IntKey*) --

              Specify the accuracy for the Symmetric method.

              1: absolutely minimal (only the G-point is used) 2:
              linear tetrahedron method, coarsest spacing 3: quadratic
              tetrahedron method, coarsest spacing 4,6,... (even):
              linear tetrahedron method 5,7.... (odd): quadratic
              method

              The tetrahedron method is usually by far inferior.

            * **KMesh** (*int** | **IntKey*) -- Undocumented.

   class _LDOS

      Local Density-Of-States information. This can be used to
      generate STM images in the Tersoff-Hamann approximation (see
      https://doi.org/10.1103/PhysRevB.31.805)

      Variables:
         * **DeltaNeg** (*float** | **FloatKey*) -- Lower bound energy
           (Shift-DeltaNeg)

         * **DeltaPos** (*float** | **FloatKey*) -- Upper bound energy
           (Shift+DeltaPos)

         * **Shift** (*float** | **FloatKey*) -- The energy bias with
           respect to the Fermi level.

   class _MBPT

      Technical aspects of the MP2 algorithm.

      Variables:
         * **Dependency** (*BoolType** | **BoolKey*) -- If true, to
           improve numerical stability, almost linearly-dependent
           combination of basis functions are removed from the Green's
           function that are used in the MBPT equations. Disabling
           this key is strongly discouraged. Its value can however be
           changed. The key to adjust this value is
           RiHartreeFock%DependencyThreshold

         * **Enabled** (*BoolType** | **BoolKey*) -- Enable the
           calculation of the MP2 energy.

         * **ExcludeCore** (*BoolType** | **BoolKey*) --

           If active, excludes core states from the calculation of the
           optimal imaginary time and frequency grids.

           The core states are still included in all parts of the
           calculations.

           In case a frozen care calculation is performed, this key is
           ignored.

           For MP2 and double hybrid calculation, it defaults to
           false. For RPA and GW calculations, it defaults to true.

         * **FitSetQuality** (*Literal**[**"Auto"**, **"VeryBasic"**,
           **"Basic"**, **"Normal"**, **"Good"**, **"VeryGood"**]*) --

           Specifies the fit set to be used in the MBPT calculation.

           'Normal' quality is generally sufficient for basis sets up
           to and including TZ2P.

           For larger basis sets (or for benchmarking purposes) a
           'VeryGood' fit set is recommended. Note that the
           FitSetQuality heavily influences the computational cost of
           the calculation.

           If not specified or 'Auto', the RIHartreeFock%FitSetQuality
           is used.

         * **Formalism** (*Literal**[**"Auto"**, **"RI"**, **"LT"**,
           **"All"**]*) --

           Specifies the formalism for the calculation of the MP2
           correlation energy.

           'LT' means Laplace Transformed MP2 (also referred to as AO-
           PARI-MP2),

           'RI' means that a conventional RI-MP2 is carried out.

           If 'Auto', LT will be used in case of DOD double hybrids
           and SOS MP2, and RI will be used in all other cases.

           'All' means that both RI and LT formalisms are used in the
           calculation.

           For a RPA or GW calculation, the formalism is always LT,
           irrespective of the formalism specified with this key.

         * **FrequencyGridType** (*Literal**[**"LeastSquare"**,
           **"GaussLegendre"**]*) -- Use Gauss-legendre grid for
           imaginary frequency integration in RPA and GW calculations
           instead of the usually used Least-Square optimized ones.
           Has the advantage that it can be systematically converged
           and an arbitrary number of grid points can be used.
           Typically more grid points will be needed to get the same
           level of accuracy. However, the convergence of the results
           with the size of the grid can be more systematic. These
           grids can only be used when Formalism is set to RI.

         * **IntegrationQuality** (*Literal**[**"VeryBasic"**,
           **"Basic"**, **"Normal"**, **"Good"**, **"VeryGood"**]*) --
           Specifies the integration quality to be used in the MBPT
           calculation. If not specified, the
           RIHartreeFock%IntegrationQuality is used.

         * **PrintOutSigma** (*BoolType** | **BoolKey*) -- Print out
           additional output for sigma-functional for parametrization.

         * **SigmaFunctionalParametrization** (*Literal**[**"W1"**,
           **"W2"**, **"S1"**, **"S2"**, **"S1re"**]*) -- Only
           relevant if a sigma-functional calculation is performed.
           Possible choices for the parametrization of the sigma-
           functional. Not all options are supported for all
           functionals.

         * **ThresholdQuality** (*Literal**[**"VeryBasic"**,
           **"Basic"**, **"Normal"**, **"Good"**, **"VeryGood"**,
           **"Excellent"**]*) -- Controls the distances between atomic
           centers for which the product of two basis functions is not
           fitted any more. Especially for spatially extended, large
           systems, 'VERYBASIC' and 'BASIC' can lead to large
           computational savings, but the fit is also more
           approximate. If not specified, the
           RIHartreeFock%ThresholdQuality is used.

         * **UseScaledZORA** (*BoolType** | **BoolKey*) -- If true,
           use the scaled ZORA orbital energies instead of the ZORA
           orbital energies in the MBPT equations.

         * **cutOfftransition** (*float** | **FloatKey*) -- Energy
           above which states are ignored in a MBPT calculation (must
           be a positive number). The default energy is chosen so
           high, that all states are included except for the ones
           which have been removed.

         * **frozencore** (*BoolType** | **BoolKey*) -- Freeze core
           states in correlation part of MBPT calculation

         * **nCore** (*int** | **IntKey*) --

           Number of core states which will be excluded from the
           correlated calculation.

           Will be ignored if frozencore is false.

           In case nothing is specified, the number of core levels
           will be determined automatically.

           Needs to be smaller than the number of occupied states.

         * **nFreqIntegration** (*int** | **IntKey*) -- Number of
           imaginary frequency points for G3W2 integration

         * **nFrequency** (*int** | **IntKey*) -- Number of imaginary
           frequency points. This key is only relevant for RPA and GW
           and will be ignored if used in an AO-PARI-MP2 calculation.
           12 Points is the default for a RPA calculation. It is
           technically possible to use a different number of imaginary
           frequency points than for imaginary time. The maximum
           number of points which can be requested for imaginary
           frequency integration is 42. Important note: The
           computation time and memory requirements roughly scale
           linearly with the number of imaginary frequency points.
           However, memory can be an issue for RPA and GW when the
           number of imaginary frequency points is high. In case a job
           crashes, it is advised to increase the number of nodes
           since the necessary memory distributes over all nodes.

         * **nLambda** (*int** | **IntKey*) -- Size of coupling
           constant integration grid for SOSEX variants in RPA.
           Default is 4 points

         * **nTime** (*int** | **IntKey*) --

           Number of imaginary time points (only relevant in case the
           Laplace Transformed (LT) formalism is used).

           In the many-body-perturbation theory module in ADF, the
           polarizability (or Kohn-Sham density response function) is
           evaluated in imaginary time to exploit sparsity in the AO
           basis. For MP2, this is often referred to as a Laplace
           transform. For MP2, 9 points are the default. This is a
           safe choice, guaranteeing accuracies higher than 1 Kj/mol
           for most systems (For many simple organic systems, 6 points
           are sufficient for good accuracy).

           Only for systems with a very small HOMO-LUMO gap or low-
           lying core states (heavy elements starting from the 4th row
           of the periodic table) more points might be necessary.

           In principle, the same considerations apply for RPA and GW
           as well, however, the accuracy requirements are somewhat
           higher and 12 point are the default for RPA. In a GW
           calculation, the number of points is adjusted according to
           the numerical quality. Using less than 9 points is strongly
           discouraged except for the simplest molecules.

           In ADF2019, it can happen that the algorithm determining
           the imaginary time grid does not converge. In this case,
           the usual reason is that the number of points is too small
           and more points need to be specified. Starting from
           AMS2020, this does not happen any more. In case the
           imaginary time grid does not converge, the number of points
           is automatically adjusted until it does.

           The computation time of AO-PARI-MP2, RPA, and GW scales
           linearly with the number of imaginary time points.

         * **useGreenXgrids** (*BoolType** | **BoolKey*) -- Use GreenX
           library to generate grid points. This is recommended for
           larger number of grid points (> 20). Up to 34 points can be
           requested.

   class _MolecularNMR

      Options for the calculations of the NMR shielding tensor for
      molecules, excluding periodic systems. Implements the
      Schreckenbach method like ADF.

      Variables:
         **Enabled** (*BoolType** | **BoolKey*) -- Compute NMR
         shielding.

   class _MultiSecantConfig

      Parameters for the Multi-secant SCF convergence method.

      Variables:
         * **CMax** (*float** | **FloatKey*) -- Maximum coefficient
           allowed in expansion

         * **InitialSigmaN** (*float** | **FloatKey*) -- This is a lot
           like a mix factor: bigger means bolder

         * **MaxSigmaN** (*float** | **FloatKey*) -- Upper bound for
           the SigmaN parameter

         * **MaxVectors** (*int** | **IntKey*) -- Maximum number of
           previous cycles to be used

         * **MinSigmaN** (*float** | **FloatKey*) -- Lower bound for
           the SigmaN parameter

         * **PredictGreed** (*BoolType** | **BoolKey*) -- Currently
           not used.

         * **Renormalize** (*BoolType** | **BoolKey*) -- Whether to
           renormalize matrix An with Psi. Affects regularization.

         * **SigmaRegularize** (*float** | **FloatKey*) -- Prevent
           division by zero by adding a small number. Makes most sense
           when using renormalization.

         * **Tweak1** (*BoolType** | **BoolKey*) -- Stick closer too
           the article: sigmaN < R abs(p)/abs(g) rather than sigmaN <
           R abs(u)/abs(p), where u is the unpredicted part, p the
           predicted part and g is the current error

         * **Tweak2** (*BoolType** | **BoolKey*) -- assume x = x + H
           error rather than x = x - H error

         * **Variant** (*Literal**[**"MSB2"**]*) -- There are several
           version of the Multi secant method.

   class _NEGF

      Options for the NEGF (non-equilibrium green function) transport
      calculation.

      Variables:
         * **AlignChargeTol** (*float** | **FloatKey*) -- In an
           alignment run you want to get the number of electrons in
           the center right. This number specifies the criterion for
           that.

         * **AlignmentFile** (*str** | **StringKey*) -- Band result
           file (.rkf) corresponding to the alignment calculation.

         * **Alpha** (*float** | **FloatKey*) -- A charge error needs
           to be translated in a potential shift. DeltaV = alpha *
           DeltaQ

         * **ApplyShift1** (*BoolType** | **BoolKey*) -- Apply the
           main shift, obtained from comparing matrix elements in the
           leads with those from the tight-binding run. Strongly
           recommended.

         * **ApplyShift2** (*BoolType** | **BoolKey*) -- Apply the
           smaller alignment shift. This requires an extra alignment
           run. Usually this shift is smaller.

         * **AutoContour** (*BoolType** | **BoolKey*) -- Use automatic
           contour integral.

         * **BiasPotential** (*float** | **FloatKey*) -- Apply a bias
           potential (atomic units). Can be negative. One has to
           specify the ramp potential with the FuzzyPotential key.
           This is mostly conveniently done with the GUI.

         * **BoundOccupationMethod** (*int** | **IntKey*) -- See text.
           Only relevant with NonEqDensityMethod equal 2 or 3.

         * **CDIIS** (*BoolType** | **BoolKey*) -- Make the normal
           DIIS procedure aware of the align charge error

         * **CheckOverlapTol** (*float** | **FloatKey*) -- BAND checks
           how well the TB overlap matrix S(R=0) represents the
           overlap matrix in the lead region. Elements corresponding
           to the outer layer are neglected, because when using a
           frozen core they have bigger errors.

         * **ContourQuality** (*Literal**[**"basic"**, **"normal"**,
           **"good"**, **"verygood"**]*) -- The density matrix is
           calculated numerically via a contour integral. Changing the
           quality influences the number of points. This influences a
           lot the performance.

         * **DEContourInt** (*float** | **FloatKey*) -- The energy
           interval for the contour grid. Defaults depends on the
           contour quality

         * **DERealAxisInt** (*float** | **FloatKey*) -- The energy
           interval for the real axis grid. Defaults depends on the
           contour quality.

         * **DeltaPhi0** (*float** | **FloatKey*) -- Undocumented.

         * **DeltaPhi1** (*float** | **FloatKey*) -- Undocumented.

         * **DoAlignment** (*BoolType** | **BoolKey*) -- Set this to
           True if you want to do an align run. Between the leads
           there should be lead material. The GUI can be of help here.

         * **EMax** (*float** | **FloatKey*) -- The maximum energy for
           the transmission grid (with respect to the Fermi level of
           the lead)

         * **EMin** (*float** | **FloatKey*) -- The minimum energy for
           the transmission grid (with respect to the Fermi level of
           the lead)

         * **Eta** (*float** | **FloatKey*) -- Small value used for
           the contour integral: stay at least this much above the
           real axis. This value is also used for the evaluation of
           the Transmission and dos.

         * **IgnoreOuterLayer** (*BoolType** | **BoolKey*) -- Whether
           or not to ignore the outer layer.

         * **KT** (*float** | **FloatKey*) -- k-Boltzmann times
           temperature.

         * **LeadFile** (*str** | **StringKey*) -- File containing the
           tight binding representation of the lead.

         * **ModuloAlignCycle** (*int** | **IntKey*) -- Undocumented.

         * **NE** (*int** | **IntKey*) -- The number of energies for
           the transmission energy grid.

         * **NMovingAverage** (*int** | **IntKey*) -- Undocumented.

         * **NonEqDensityMethod** (*int** | **IntKey*) -- See text.

         * **OverwriteLeadFock** (*BoolType** | **BoolKey*) --
           Undocumented.

         * **PlotInterval** (*int** | **IntKey*) -- Undocumented.

         * **SGFFile** (*str** | **StringKey*) -- The result from the
           SGF program. Contains the Fermi energy of the lead.

         * **SGFTol** (*float** | **FloatKey*) -- Undocumented.

         * **StartAlignCycle** (*int** | **IntKey*) -- Undocumented.

         * **YContourInt** (*float** | **FloatKey*) -- The density is
           calculated via a contour integral. This value specifies how
           far above the real axis the (horizontal part of the)
           contour runs. The value is rounded in such a way that it
           goes exactly halfway between two Fermi poles. There is a
           trade off: making it bigger makes the integrand more
           smooth, but the number of enclosed poles increases. For low
           temperatures it makes sense to lower this value, and use a
           smaller deContourInt.

         * **YRealaxisInt** (*float** | **FloatKey*) -- The non-
           Equilibrium density is calculated near the real axis.

   class _NMR

      Options for the calculations of the NMR shielding tensor.

      Variables:
         * **Correct_rmu** (*BoolType** | **BoolKey*) -- Undocumented.

         * **Correction_r** (*BoolType** | **BoolKey*) --
           Undocumented.

         * **Debug_r_corr** (*BoolType** | **BoolKey*) --
           Undocumented.

         * **Enabled** (*BoolType** | **BoolKey*) -- Compute NMR
           shielding.

         * **MS0** (*float** | **FloatKey*) -- Undocumented.

         * **NMRAtom** (*int** | **IntKey*) -- The index of the atom
           atom (in input order) for which NMR should be computed.

         * **Numeric** (*BoolType** | **BoolKey*) -- Undocumented.

         * **Obsolete** (*BoolType** | **BoolKey*) -- Undocumented.

         * **OnlyNDimBasPnt** (*BoolType** | **BoolKey*) --
           Undocumented.

         * **Original** (*BoolType** | **BoolKey*) -- Undocumented.

         * **PrintK** (*BoolType** | **BoolKey*) -- Undocumented.

         * **Print_jp** (*BoolType** | **BoolKey*) -- Print
           paramagnetic current.

         * **SharedArrayColumnLock** (*BoolType** | **BoolKey*) --
           Undocumented.

         * **SuperCell** (*BoolType** | **BoolKey*) -- This is the
           switch between the two methods, either the super cell
           (true), or the single-dipole method (false)

         * **Test** (*BoolType** | **BoolKey*) -- Key for printing all
           intrinsic tensors.

         * **Test_E** (*BoolType** | **BoolKey*) -- Test of energy
           levels.

         * **Test_S** (*BoolType** | **BoolKey*) -- Test of overlap
           matrix.

         * **UpdateForBlockOption** (*int** | **IntKey*) --
           Undocumented.

         * **UseSharedMemory** (*BoolType** | **BoolKey*) -- Whether
           or not to use shared memory in the NMR calculation.

   class _NOCVOrbitalPlot

      Goes together with the Restart%NOCVOrbitalPlot and Grid keys.
      See example.

   class _NOCVdRhoPlot

      Goes together with the Restart%NOCVdRhoPlot and Grid keys. See
      example.

   class _NOPROrbitalPlot

      Undocumented.

   class _NOPRdRhoPlot

      Undocumented.

   class _NeutralizingDensityDetails

      Variables:
         * **DiffuseFactor** (*float** | **FloatKey*) -- The bigger
           this number, the more diffuse (extended) the neutralizing
           density becomes. Works only for rho(neutralizing/atoms)

         * **IncludeSelfTerm** (*BoolType** | **BoolKey*) -- The
           energy should contain the self term for consistent energy
           and gradients.

         * **HomogeneousDensity**
           (*BAND._NeutralizingDensityDetails._HomogeneousDensity*) --
           xxx

      class _HomogeneousDensity

         xxx

         Variables:
            * **Origin** (*Iterable**[**float**] **| **FloatListKey*)
              --

            * **Range** (*float** | **FloatKey*) --

            * **Width** (*float** | **FloatKey*) --

   class _NewResponse

      The TD-CDFT calculation to obtain the dielectric function is
      computed when this block is present in the input. Several
      important settings can be defined here.

      Variables:
         * **ActiveESpace** (*float** | **FloatKey*) -- Modifies the
           energy threshold (DeltaE^{max}_{thresh} = omega_{high} +
           ActiveESpace) for which single orbital transitions
           (DeltaEpsilon_{ia} = Epsilon_{a}^{virtual} -
           Epsilon_{i}^{occupied}) are taken into account.

         * **ActiveXYZ** (*str** | **StringKey*) -- Expects a string
           consisting of three letters of either 'T' (for true) or 'F'
           (for false) where the first is for the X-, the second for
           the Y- and the third for the Z-component of the response
           properties. If true, then the response properties for this
           component will be evaluated.

         * **DensityCutOff** (*float** | **FloatKey*) -- For 1D and 2D
           systems the unit cell volume is undefined. Here, the volume
           is calculated as the volume bordered by the isosurface for
           the value DensityCutoff of the total density.

         * **EShift** (*float** | **FloatKey*) -- Energy shift of the
           virtual crystal orbitals.

         * **FreqHigh** (*float** | **FloatKey*) -- Upper limit of the
           frequency range for which response properties are
           calculated (omega_{high}).

         * **FreqLow** (*float** | **FloatKey*) -- Lower limit of the
           frequency range for which response properties are
           calculated. (omega_{low})

         * **NFreq** (*int** | **IntKey*) -- Number of frequencies for
           which a linear response TD-CDFT calculation is performed.

         * **BugFixes** (*BAND._NewResponse._BugFixes*) -- Allows the
           user to control bug fixes to check older results

      class _BugFixes

         Allows the user to control bug fixes to check older results

         Variables:
            * **CopyTiaOldAlda** (*BoolType** | **BoolKey*) -- NFreq
              was reduced by one in case of old alda. Does not
              influence the calculation, but changes band.rkf used by
              the gui

            * **NoScissorsInJia** (*BoolType** | **BoolKey*) -- The
              scissors operator lifts the virtual eigenvalues, but
              this should not be done while calculating the Jia
              matrix. Relates (logically inversely) to
              OldResponse%Bugfixes%NewAldaShift.

            * **PotTimesTwo** (*BoolType** | **BoolKey*) --
              Undocumented.

            * **SignJia2** (*BoolType** | **BoolKey*) -- Undocumented.

            * **SwapPiaPai** (*BoolType** | **BoolKey*) --
              Undocumented.

            * **WeightsTimesTwo** (*BoolType** | **BoolKey*) --
              Multiply k-space weights times two. No effect when
              UseOldResponseWeights=yes

   class _NewResponseKSpace

      Modify the details for the integration weights evaluation in
      reciprocal space for each single-particle transition. Only
      influencing the NewResponse code.

      Variables:
         * **Eta** (*float** | **FloatKey*) -- Defines the small,
           finite imaginary number i*eta which is necessary in the
           context of integration weights for single-particle
           transitions in reciprocal space.

         * **HardIntegral** (*BoolType** | **BoolKey*) --
           Undocumented.

         * **NSlices** (*int** | **IntKey*) -- Undocumented.

         * **SubSimp** (*int** | **IntKey*) -- determines into how
           many sub-integrals each integration around a k point is
           split. This is only true for so-called quadratic
           integration grids. The larger the number the better the
           convergence behavior for the sampling in reciprocal space.
           Note: the computing time for the weights is linear for 1D,
           quadratic for 2D and cubic for 3D!

         * **UseOldResponseWeights** (*BoolType** | **BoolKey*) --
           Call the old code to generate the response weights. If true
           then all other arguments of NewResponseKSpace are ignored

   class _NewResponseSCF

      Details for the linear-response self-consistent optimization
      cycle. Only influencing the NewResponse code.

      Variables:
         * **Bootstrap** (*int** | **IntKey*) -- defines if the
           Berger2015 kernel (Bootstrap 1) is used or not (Bootstrap
           0). If you chose the Berger2015 kernel, you have to set
           NewResponseSCF%XC to '0'. Since it shall be used in
           combination with the bare Coulomb response only. Note: The
           evaluation of response properties using the Berger2015 is
           recommend for 3D systems only!

         * **COApproach** (*BoolType** | **BoolKey*) -- The program
           automatically decides to calculate the integrals and
           induced densities via the Bloch expanded atomic orbitals
           (AO approach) or via the cyrstal orbitals (CO approach).
           The option COApproach overrules this decision.

         * **COApproachBoost** (*BoolType** | **BoolKey*) --

           Keeps the grid data of the Crystal Orbitals in memory.

           Requires significantly more memory for a speedup of the
           calculation. One might have to use multiple computing nodes
           to not run into memory problems.

         * **Criterion** (*float** | **FloatKey*) --

           For the SCF convergence the RMS of the induced density
           change is tested. If this value is below the Criterion the
           SCF is finished.

           Furthermore, one can find the calculated electric
           susceptibility for each SCF step in the output and can
           therefore decide if the default value is too loose or too
           strict.

         * **LowFreqAlgo** (*BoolType** | **BoolKey*) -- Numerically
           more stable results for frequencies lower than 1.0 eV.
           Note: for a graphene monolayer the conical intersection
           results in a very small band gap (zero band gap semi-
           conductor). This leads ta a failing low frequency
           algorithm. One can then chose to use the algorithm as
           originally proposed by Kootstra by setting the input value
           to *false*. But, this can result in unreliable results for
           frequencies lower than 1.0 eV!

         * **NCycle** (*int** | **IntKey*) -- Number of SCF cycles for
           each frequency to be evaluated.

         * **XC** (*int** | **IntKey*) -- Influences if the bare
           induced Coulomb response (XC 0) is used for the effective,
           induced potential or the induced potential derived from the
           ALDA kernel as well (XC 1).

         * **DIIS** (*BAND._NewResponseSCF._DIIS*) -- Parameters
           influencing the DIIS self-consistency method

      class _DIIS

         Parameters influencing the DIIS self-consistency method

         Variables:
            * **Enabled** (*BoolType** | **BoolKey*) -- If not enabled
              simple mixing without DIIS acceleration will be used.

            * **MaxSamples** (*int** | **IntKey*) -- Specifies the
              maximum number of samples considered during the direct
              inversion of iteration of subspace (DIIS) extrapolation
              of the atomic charges during the SCC iterations. A
              smaller number of samples potentially leads to a more
              aggressive convergence acceleration, while a larger
              number often guarantees a more stable iteration. Due to
              often occurring linear dependencies within the set of
              sample vectors, the maximum number of samples is reached
              only in very rare cases.

            * **MaximumCoefficient** (*float** | **FloatKey*) -- When
              the diis expansion coefficients exceed this threshold,
              the solution is rejected. The vector space is too
              crowded. The oldest vector is discarded, and the
              expansion is re-evaluated.

            * **MinSamples** (*int** | **IntKey*) -- When bigger than
              one, this affects the shrinking of the DIIS space on
              linear dependence. It will not reduce to a smaller space
              than MinSamples unless there is extreme dependency.

            * **MixingFactor** (*float** | **FloatKey*) -- The
              parameter used to mix the DIIS linear combination of
              previously sampled atomic charge vectors with an
              analogous linear combination of charge vectors resulting
              from population analysis combination. It can assume real
              values between 0 and 1.

   class _NonCollinearMagnetizationModule

      Undocumented.

      Variables:
         * **DoBackForthTest** (*BoolType** | **BoolKey*) -- Transform
           2x2 matrices to the Pauli vector representation and back.

         * **DotProductBugfix** (*BoolType** | **BoolKey*) -- About a
           forgotten dagger in the dot product code.

         * **SignFix** (*BoolType** | **BoolKey*) -- Try to get a sign
           in the up and down projections. Otherwise the size of m is
           by definition always in the up direction, i.e. only the
           size of m matters.

   class _Occupations

      Allows one to input specific occupations numbers. Applies only
      for calculations that use only one k-point (i.e. pseudo-molecule
      calculations). See example.

   class _OldResponse

      Options for the old TD-CDFT implementation.

      Variables:
         * **Berger2015** (*BoolType** | **BoolKey*) -- Use the
           parameter-free polarization functional by A. Berger (Phys.
           Rev. Lett. 115, 137402). This is possible for 3D insulators
           and metals. Note: The evaluation of response properties
           using the Berger2015 is recommend for 3D systems only!

         * **CNT** (*BoolType** | **BoolKey*) -- Use the CNT
           parametrization for the longitudinal and transverse kernels
           of the XC kernel of the homogeneous electron gas. Use this
           in conjunction with the NewVK option.

         * **CNVI** (*float** | **FloatKey*) -- The first convergence
           criterion for the change in the fit coefficients for the
           fit functions, when fitting the density.

         * **CNVJ** (*float** | **FloatKey*) -- the second convergence
           criterion for the change in the fit coefficients for the
           fit functions, when fitting the density.

         * **DIISMixFactor** (*float** | **FloatKey*) -- Undocumented.

         * **Ebndtl** (*float** | **FloatKey*) -- the energy band
           tolerance, for determination which routines to use for
           calculating the numerical integration weights, when the
           energy band posses no or to less dispersion.

         * **Enabled** (*BoolType** | **BoolKey*) -- If true, the
           response function will be calculated using the old TD-CDFT
           implementation

         * **Endfr** (*float** | **FloatKey*) -- The upper bound
           frequency of the frequency range over which the dielectric
           function is calculated

         * **Ifxc** (*int** | **IntKey*) -- Integer defining the XC
           kernel. 0: ALDA, 1: Freq. dependent, 2: LB94

         * **Isz** (*int** | **IntKey*) -- Integer indicating whether
           or not scalar zeroth order relativistic effects are
           included in the TDCDFT calculation. 0 = relativistic
           effects are not included, 1 = relativistic effects are
           included. The current implementation does NOT work with the
           option XC%SpinOrbitMagnetization equal NonCollinear

         * **Iyxc** (*int** | **IntKey*) -- integer for printing yxc-
           tensor (see
           http://aip.scitation.org/doi/10.1063/1.1385370). 0 = not
           printed, 1 = printed.

         * **Mac** (*BoolType** | **BoolKey*) -- Undocumented.

         * **MinDIISSpace** (*int** | **IntKey*) -- Ensure that the
           size of the DIIS space does not shrink below this value (if
           bigger than one). It seems that DIIS with two vectors never
           converges. Setting this to 3 is reasonable

         * **MixFactor** (*float** | **FloatKey*) -- Undocumented.

         * **NVirt** (*int** | **IntKey*) -- Undocumented.

         * **Nct** (*BoolType** | **BoolKey*) -- Undocumented.

         * **NewVK** (*BoolType** | **BoolKey*) -- Use the slightly
           modified version of the VK kernel (see
           https://aip.scitation.org/doi/10.1063/1.1385370). When
           using this option one uses effectively the static option,
           even for metals, so one should check carefully the
           convergence with the KSPACE parameter.

         * **Newalda** (*BoolType** | **BoolKey*) -- Undocumented.

         * **Nfreq** (*int** | **IntKey*) -- the number of frequencies
           for which a linear response TD-CDFT calculation is
           performed.

         * **NonLoc** (*BoolType** | **BoolKey*) -- Undocumented.

         * **QV** (*BoolType** | **BoolKey*) -- Use the QV
           parametrization for the longitudinal and transverse kernels
           of the XC kernel of the homogeneous electron gas. Use this
           in conjunction with the NewVK option. (see reference).

         * **QV0** (*BoolType** | **BoolKey*) -- Undocumented.

         * **Rice** (*BoolType** | **BoolKey*) -- Undocumented.

         * **Shift** (*float** | **FloatKey*) -- energy shift for the
           virtual crystal orbitals.

         * **Static** (*BoolType** | **BoolKey*) -- An alternative
           method that allows an analytic evaluation of the static
           response (normally the static response is approximated by a
           finite small frequency value). This option should only be
           used for non-relativistic calculations on insulators, and
           it has no effect on metals. Note: experience shows that
           KSPACE convergence can be slower.

         * **Strtfr** (*float** | **FloatKey*) -- is the lower bound
           frequency of the frequency range over which the dielectric
           function is calculated.

         * **VK** (*BoolType** | **BoolKey*) -- Undocumented.

         * **BugFixes** (*BAND._OldResponse._BugFixes*) -- Allows the
           user to control bug fixes to check older results

      class _BugFixes

         Allows the user to control bug fixes to check older results

         Variables:
            **NewAldaShift** (*BoolType** | **BoolKey*) -- When using
            NewAlda combined with an scissors shift, the current was
            incorrect. fact = 1/(e_i-e_a)

   class _OrbitalLabels

      Undocumented.

   class _OrbitalPlot

      Goes together with the Restart%OrbitalPlot and Grid keys. See
      Example.

   class _Output

      Control the output.

      Variables:
         **Print** (*BAND._Output._Print*) --

      class _Print

         Variables:
            * **Level** (*Literal**[**"None"**, **"Error"**,
              **"Warning"**, **"Minimal"**, **"Normal"**,
              **"Detail"**, **"TooMuchDetail"**]*) --

            * **Section** (*Literal**[**"Prepare"**, **"SCF"**,
              **"Properties"**]*) --

   class _OverlapPopulations

      Overlap population weighted DOS (OPWDOS), also known as the
      crystal orbital overlap population (COOP).

   class _PEDANOCV

      Options for the decomposition of the orbital relaxation (pEDA).

      Variables:
         * **EigvalThresh** (*float** | **FloatKey*) -- The threshold
           controls that for all NOCV deformation densities with NOCV
           eigenvalues larger than EigvalThresh the energy
           contribution will be calculated and the respective pEDA-
           NOCV results will be printed in the output

         * **Enabled** (*BoolType** | **BoolKey*) -- If true in
           combination with the fragment blocks and the pEDA key, the
           decomposition of the orbital relaxation term is performed.

   class _PEDANOPR

      Undocumented.

      Variables:
         **EigvalThresh** (*float** | **FloatKey*) -- Eigenvectors for
         Pauli repulsion (NOPR). Analogous to the NOCV concept. Splits
         up the Pauli repulsion step in orbital contributions.

   class _PeriodicRIHartreeFock

      Technical options for periodic Hartree Fock.

      Variables:
         * **AllowLinearScaling** (*BoolType** | **BoolKey*) -- Use
           function ranges and multipoles.

         * **AllowMultipoleExpansion** (*BoolType** | **BoolKey*) --
           Use the multipole expansion if possible.

         * **AllowOddKGrid** (*BoolType** | **BoolKey*) -- Allow the
           user to specify an odd k-grid. This does not work well with
           HartreeFock.

         * **AllowPartialMultipoleExpansion** (*BoolType** |
           **BoolKey*) -- Use the partial multipole expansion if
           possible. This has only effect if
           AllowMultipoleExpansion=yes.

         * **AnalyzeCells** (*BoolType** | **BoolKey*) -- Determine
           the cell loop ranges needed and stop.

         * **AvoidPeriodicKMatR** (*BoolType** | **BoolKey*) --
           Undocumented.

         * **AvoidPeriodicPMatR** (*BoolType** | **BoolKey*) --
           Undocumented.

         * **CellLoopPrecision** (*Literal**[**"Minimal"**,
           **"Medium"**, **"Full"**]*) -- The range of the density
           matrix, R(P), combined with the range of basis products,
           R(C), determines the cell range contributing to the
           exchange matrix. The cell range used is. Minimal: R(P).
           Medium: R(P)+R(C). All: R(P)+2R(C)

         * **CheckRelativeLatticeIndex** (*BoolType** | **BoolKey*) --
           Compare result of fast and slow routine to obtain the
           relative lattice index.

         * **ExactLMaxMultiPerAtom** (*BoolType** | **BoolKey*) --
           Used to be a hardcodes lMaxMulti=3. If specified it is
           determined per atom from the RIHF fit functions.

         * **FitCoeffThreshold** (*float** | **FloatKey*) -- Threshold
           to be applied for the fit coefficients, ignore blocks for
           which all (abs) elements are smaller than this threshold.

         * **Iterator** (*Literal**[**"Auto"**, **"Static"**,
           **"Hybrid"**, **"Dynamic"**]*) -- With the option Dynamic
           one thread may be sacrified to distribute the work, and is
           the default when using more than 16 cores, otherwise Hybrid
           is used. With Hybrid more detailed timings are possible,
           even if using more than one (shared memory) node.

         * **M1Threshold** (*float** | **FloatKey*) -- Threshold to be
           applied for the M1 matrix appearing in the I,II, and III
           terms. A negative value means no threshold.

         * **MaxCellForP** (*int** | **IntKey*) -- Apply a maximum to
           the the number of cells for P(R), mostly useful for 1D
           systems.

         * **MergeIterators** (*BoolType** | **BoolKey*) -- If true,
           calculate terms I,II,III,and IV in parallel, otherwise term
           IV is done separately.

         * **NCellsToUse** (*int** | **IntKey*) -- Hack to explicitly
           control the number of cells to be used.

         * **PrintKDistanceDecay** (*BoolType** | **BoolKey*) -- The
           decay of the norm of K with respect to the distance cell
           order.

         * **PrintKShellDecay** (*BoolType** | **BoolKey*) -- The
           decay of the norm of K with respect to the shell cell
           order.

         * **PrintKTopoDecay** (*BoolType** | **BoolKey*) -- The decay
           of the norm of K with respect to the topological cell
           order.

         * **RemapPMatR** (*BoolType** | **BoolKey*) -- Possibly move
           elements from one cell to another, minimizing the distance
           between the atom pairs.

         * **RemapPMatRNew** (*BoolType** | **BoolKey*) -- Possibly
           move elements from one cell to another, minimizing the
           distance between the atom pairs.

         * **SaveKMatR** (*BoolType** | **BoolKey*) -- Undocumented.

         * **SortFitFunctions** (*BoolType** | **BoolKey*) -- Sort the
           RIHartreeFock fit functions per atom, based on the range.
           This is needed when allowing for partial multipole atom
           pairs.

         * **SupportPostProcessing** (*BoolType** | **BoolKey*) --
           Store some info in a RIHartreeFock section, that can be
           useful for python post processing/analysis.

         * **UpdateVersion** (*int** | **IntKey*) -- Which
           implementation to use for the update123 and update4
           routines.

         * **UseHalfKGrid** (*BoolType** | **BoolKey*) -- Let all RIHF
           settings be based on the assumption that the k-grid was
           twice as coarse. What will be more accurate is P(R), but it
           gets the range as if the coarser k-grid was used.

         * **UseHelper** (*BoolType** | **BoolKey*) -- Provide the
           RIHartreeFock with knowledge about loop bounds.

         * **UseInverseCellSymmetry** (*BoolType** | **BoolKey*) -- If
           true, only half of the K(R) is calculated, and the rest is
           obtained from K(-R)=transpose(K(R)).

         * **UseLatticeShiftForPairs** (*BoolType** | **BoolKey*) --
           Apply a pair based minimum image convention.

         * **UseM1V** (*BoolType** | **BoolKey*) -- Multiply M1 by V,
           being faster for term II.

         * **lMaxMulti** (*int** | **IntKey*) -- Apply a maximum to
           the lMaxMulti. If negative the key is ignored.

         * **BugFixes** (*BAND._PeriodicRIHartreeFock._BugFixes*) --
           Allows the user to control bug fixes to check older results

      class _BugFixes

         Allows the user to control bug fixes to check older results

         Variables:
            **HalfCells** (*BoolType** | **BoolKey*) --
            AvoidPeriodicPMatR wiped too many cells. Better to use
            kt-1 rather than kUnique

   class _PeriodicSolvation

      Additional options for simulations of periodic structures with
      solvation.

      Variables:
         * **MaxDisttounitcell** (*float** | **FloatKey*) --
           Undocumented.

         * **NStar** (*int** | **IntKey*) -- This option, expecting an
           integer number (>2), handles the accuracy for the
           construction of the COMSO surface. The larger the given
           number the more accurate the construction.

         * **RemovePointsWithNegativeZ** (*BoolType** | **BoolKey*) --

           Whether the COSMO surface is constructed on both sides of a
           surface.

           If one is only interested in the solvation effect on the
           upper side of a surface (in the Z direction), then this
           option should be set to 'True'

         * **RestartPoints** (*BoolType** | **BoolKey*) --
           Undocumented.

         * **RestartWithPointApprox** (*BoolType** | **BoolKey*) --
           Undocumented.

         * **ReusePoints** (*BoolType** | **BoolKey*) -- Undocumented.

         * **SmartScreening** (*BoolType** | **BoolKey*) --
           Undocumented.

         * **SymmetrizeSurfacePoints** (*BoolType** | **BoolKey*) --
           Whether or not the COSMO point should be symmetrized

   class _Programmer

      Miscellaneous technical options.

      Variables:
         * **Allowtailsforresponse** (*BoolType** | **BoolKey*) --
           Undocumented.

         * **Atomicenergyinmolgrid** (*BoolType** | **BoolKey*) --
           Undocumented.

         * **BandEigSysOption** (*int** | **IntKey*) --

           1. orig version, 2) uses SCMMatrix.

         * **Bandcosmoevaluatoroption** (*int** | **IntKey*) --
           Undocumented.

         * **Basgrad** (*BoolType** | **BoolKey*) -- Undocumented.

         * **Baskin** (*BoolType** | **BoolKey*) -- Undocumented.

         * **Bassecder** (*BoolType** | **BoolKey*) -- Undocumented.

         * **Blockpropertyioformatoption** (*int** | **IntKey*) --
           Undocumented.

         * **Calctau** (*BoolType** | **BoolKey*) -- Undocumented.

         * **Determinesvocmethod** (*int** | **IntKey*) --
           Undocumented.

         * **Didervcompat** (*BoolType** | **BoolKey*) --
           Undocumented.

         * **DiracPotentialCutoff** (*float** | **FloatKey*) -- When V
           (times R) is smaller than this, set potential to zero.
           (coulomb potential of spherical atoms in dirac routine)

         * **DirectBas** (*BoolType** | **BoolKey*) -- Calculate basis
           functions and their derivatives on the fly, and do not
           store basis functions on disk.

         * **Directfit** (*BoolType** | **BoolKey*) -- Undocumented.

         * **Dkbas** (*BoolType** | **BoolKey*) -- Undocumented.

         * **DynamicBlockIterator** (*BoolType** | **BoolKey*) -- This
           causes the iteration over the blocks to be dynamic.
           Technically all grid based functions will be stored in
           shared arrays. Might be faster when there is load
           imbalance. Can be considered for large/sparse systems. Does
           not work too wel with too many cores per node.

         * **Enablescratcharraymodule** (*BoolType** | **BoolKey*) --
           Undocumented.

         * **Exactgradrho** (*BoolType** | **BoolKey*) --
           Undocumented.

         * **Exactgradrhopostscf** (*BoolType** | **BoolKey*) --
           Undocumented.

         * **Exactrho** (*BoolType** | **BoolKey*) -- Undocumented.

         * **Exactsharedarraylocking** (*BoolType** | **BoolKey*) --
           Undocumented.

         * **Fastatmfnc** (*BoolType** | **BoolKey*) -- Undocumented.

         * **Fastfitort** (*BoolType** | **BoolKey*) -- Undocumented.

         * **Fitgrad** (*BoolType** | **BoolKey*) -- Undocumented.

         * **Frageif** (*BoolType** | **BoolKey*) -- Undocumented.

         * **Functionsetdotproductemploysym** (*BoolType** |
           **BoolKey*) -- Undocumented.

         * **Functionsetdotproducteps** (*float** | **FloatKey*) --
           Undocumented.

         * **Functionsetdotproductoption** (*int** | **IntKey*) --
           Undocumented.

         * **Functionsetincrementeps** (*float** | **FloatKey*) --
           Undocumented.

         * **Functionsetincrementkeepsorted** (*BoolType** |
           **BoolKey*) -- Undocumented.

         * **Functionsetoverlapemploysym** (*BoolType** | **BoolKey*)
           -- Undocumented.

         * **Functionsetoverlaplockcolumn** (*BoolType** | **BoolKey*)
           -- Undocumented.

         * **Functionsetoverlapoption** (*int** | **IntKey*) --
           Undocumented.

         * **Functionsetoverlapslicesize** (*int** | **IntKey*) --
           Undocumented.

         * **Functionsettransformeps** (*float** | **FloatKey*) --
           Undocumented.

         * **Functionsettransformoption** (*int** | **IntKey*) --
           Undocumented.

         * **Genericpmatoption** (*int** | **IntKey*) -- Undocumented.

         * **HuntForSpinorbitBug** (*BoolType** | **BoolKey*) -- On
           some platforms either the Lowdin ortho fails or the
           CheckCore.

         * **Inverthermitianmatrixmethod** (*int** | **IntKey*) --
           Undocumented.

         * **KMIOMaxSectionSize** (*float** | **FloatKey*) -- Normally
           this should be the maximum number of elements that a kf
           varialbe can hold.

         * **Kequivtol** (*float** | **FloatKey*) -- Undocumented.

         * **Kinviagrad** (*BoolType** | **BoolKey*) -- Undocumented.

         * **KmioFinalStorageMode** (*int** | **IntKey*) -- How the
           eigensystem is saved at the end of the calculation on the
           main result file.

         * **Kmioforcecomplex** (*BoolType** | **BoolKey*) --
           Undocumented.

         * **Kmiostoragemode** (*int** | **IntKey*) -- Undocumented.

         * **LogGap** (*BoolType** | **BoolKey*) -- Show the band gap
           in the logfile at each cycle.

         * **Mapatomstounitcell** (*BoolType** | **BoolKey*) --
           Undocumented.

         * **Nucgradvocoption** (*int** | **IntKey*) -- Undocumented.

         * **Oldgetvocbasis** (*BoolType** | **BoolKey*) --
           Undocumented.

         * **OptimizePointDistribution** (*BoolType** | **BoolKey*) --
           Undocumented.

         * **OptimizePointDistributionStrategy** (*int** | **IntKey*)
           -- ?.

         * **Pmathistory** (*BoolType** | **BoolKey*) -- Undocumented.

         * **PrepareBasLinAlgOption** (*int** | **IntKey*) --
           Variations for the matrix processing part of PrepareBas.
           Possible values: 1 or 2.

         * **RemoveRigidMotions** (*BoolType** | **BoolKey*) --
           Whether or not to remove rigid motions from gradient.

         * **ReorderPoints** (*BoolType** | **BoolKey*) -- Whether or
           not to reorder the real space points by localization.

         * **Rhograd** (*BoolType** | **BoolKey*) -- Undocumented.

         * **SharedMemorySandwichingThreshold** (*int** | **IntKey*)
           --

           When the nr. of basis functions exceeds this threshold
           shared memory will be used to calculate matrix elements.

           Unless UseSharedMemoryForSandwiching is explicitly set in
           the input.

         * **Simplexdividemethod** (*int** | **IntKey*) --
           Undocumented.

         * **StopAfterFirstEigsys** (*BoolType** | **BoolKey*) -- Stop
           after the first call to eigsys is completed, useful for
           timings, in particular for HartreeFock.

         * **StoreDOSPerBas** (*BoolType** | **BoolKey*) -- Whether or
           not to store the parial DOS per basis function. This allows
           you to view any partial DOS with amsspectra and amsbands.
           Requires the CalcPDOS option to be on.

         * **StoreOrbitals** (*BoolType** | **BoolKey*) -- Copy
           information on band.rkf needed for orbital plotting and
           restarts. This can be a lot of information. DOS and
           BandStructure require StoreOrbitals=true.

         * **StoreZlmFitEachSCFCycle** (*BoolType** | **BoolKey*) --
           Write ZlmFit info to band.rkf, normally only done at the
           last cycle.

         * **Storebandinternalham** (*BoolType** | **BoolKey*) --
           Undocumented.

         * **Storeoriginalbloch** (*BoolType** | **BoolKey*) --
           Undocumented.

         * **Testparameter** (*int** | **IntKey*) -- Undocumented.

         * **UpdateSTDVec** (*BoolType** | **BoolKey*) -- Shift atoms
           so that center of mass is at zero. As a results the
           detected symmetry may be higher.

         * **UseDiracCoulomb** (*BoolType** | **BoolKey*) -- Affects
           dirac subroutine. In 2023 a spline-based routine was made
           replacing the original code that employed a (necessary)
           10-6 CutOff. To emulate pre ams2023 calculations set this
           key to false.

         * **UseSharedMemoryForSandwiching** (*BoolType** |
           **BoolKey*) --

           When calculating matrix elements the array will be shared.
           This saves memory at the cost of locking overhead.

           If not specified this will depend on the threshold
           SharedMemorySandwichingThreshold

         * **UseTurnoverRuleForXcMatrix** (*BoolType** | **BoolKey*)
           -- Undocumented.

         * **UseTurnoverRuleForXcMatrixDirac** (*BoolType** |
           **BoolKey*) -- Affects which potential to use in Dirac in
           case of libxc and UseTurnoverRuleForXcMatrix=true.

         * **Usenewtailroutines** (*BoolType** | **BoolKey*) --
           Undocumented.

         * **Usesharedmemory** (*BoolType** | **BoolKey*) --

           When running more then one task, share memory between those
           tasks. This saves a lot of memory.

           Only disable it in case of problems.

         * **Usestofit** (*BoolType** | **BoolKey*) -- Undocumented.

         * **Usezlmfit** (*BoolType** | **BoolKey*) -- Undocumented.

         * **VOCBasEvaluator4OptimizeOrdering** (*BoolType** |
           **BoolKey*) -- Make sure that the sparse functions are
           ordered (idtail is ascending).

         * **Wipeonecenterterms** (*BoolType** | **BoolKey*) --
           Undocumented.

   class _PropertiesAtNuclei

      A number of properties can be obtained near the nucleus. An
      average is taken over a tiny sphere around the nucleus. The
      following properties are available: vxc[rho(fit)], rho(fit),
      rho(scf), v(coulomb/scf), rho(deformation/fit),
      rho(deformation/scf).

   class _RIHartreeFock

      Variables:
         * **DependencyCoreRange** (*float** | **FloatKey*) -- Basis
           functions may be given a core character based on the range.
           For now only active in Band and only if present in the
           input

         * **DependencyThreshold** (*float** | **FloatKey*) --

           To improve numerical stability, almost linearly-dependent
           combination of basis functions are removed from the
           Hartree-Fock exchange matrix.

           If you obtain unphysically large bond energy in an Hybrid
           calculation, or an unphysically low correlation energy in
           an RPA, MP2, or double hybrid calculation, you might try
           setting the DependencyThreshold to a larger value (e.g.
           3.0E-3)

           Note, that in GW calculations and GW-BSE calculations the
           default for this key is 5.0e-3.

         * **DoAlternativeDependencyTrick** (*BoolType** | **BoolKey*)
           -- Only applies to band. Do trick on the density matrix
           being input to HFEval, rather than on the K-matrix.

         * **DoDependencyTrick** (*BoolType** | **BoolKey*) --
           Available only in BAND, turns on and off the RIHartreeFock
           dependency trick.

         * **FitSetQuality** (*Literal**[**"Auto"**, **"VeryBasic"**,
           **"Basic"**, **"Normal"**, **"Good"**, **"VeryGood"**,
           **"Excellent"**, **"FromBasisProducts"**]*) --

           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.

         * **IntegrationQuality** (*Literal**[**"VeryBasic"**,
           **"Basic"**, **"Normal"**, **"Good"**, **"VeryGood"**,
           **"Excellent"**]*) -- 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.

         * **Quality** (*Literal**[**"Auto"**, **"VeryBasic"**,
           **"Basic"**, **"Normal"**, **"Good"**, **"VeryGood"**,
           **"Excellent"**]*) -- Numerical accuracy of the RI
           procedure. If 'Auto', the quality specified in the
           'NumericalQuality' will be used.

         * **ResponseQuality** (*Literal**[**"VeryBasic"**,
           **"Basic"**, **"Normal"**, **"Good"**, **"VeryGood"**,
           **"Excellent"**]*) -- Numerical accuracy of the RI
           procedure for the Response module.

         * **ThresholdQuality** (*Literal**[**"VeryBasic"**,
           **"Basic"**, **"Normal"**, **"Good"**, **"VeryGood"**,
           **"Excellent"**]*) -- 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.

         * **UseCoulombMetricForDependency** (*BoolType** |
           **BoolKey*) -- Use Coulomb metric for the Dependency Trick
           (band only)

         * **UseMe** (*BoolType** | **BoolKey*) -- Set to False if you
           want to use the old RI scheme (ADF only)

         * **ExplicitThresholds**
           (*BAND._RIHartreeFock._ExplicitThresholds*) -- Override the
           thresholds as implied by the ThresholdQuality.

         * **FitGenerationDetails**
           (*BAND._RIHartreeFock._FitGenerationDetails*) -- Technical
           details about how the RI Hartree-Fock fit functions are
           generated.

         * **QualityPerRegion**
           (*BAND._RIHartreeFock._QualityPerRegion*) -- Sets the fit-
           set quality for all atoms in a region. If specified, this
           overwrites the globally set quality.

      class _ExplicitThresholds

         Override the thresholds as implied by the ThresholdQuality.

         Variables:
            * **Basis** (*float** | **FloatKey*) -- Threshold for the
              basis functions.

            * **Fit** (*float** | **FloatKey*) -- Threshold for the
              fit functions.

            * **Potential** (*float** | **FloatKey*) -- Threshold for
              the potential of the functions.

      class _FitGenerationDetails

         Technical details about how the RI Hartree-Fock fit functions
         are generated.

         Variables:
            * **BoostL** (*BoolType** | **BoolKey*) --

              Add extra max(l)+1 diffuse function

              When l denotes the highest angular momentum present in
              the primary basis,

              FromBasisProducts will generate auxiliary fit functions
              with up to 2l angular momentum.

              When this key is set to true, the maximum angular
              momentum in the auxiliary fit set becomes 2l+2.

              Typically, this option is not needed and when precision
              issues arise, it is rather advised to adjust the
              OneCenterDependencyThreshold key to a smaller value.

            * **LapackWorkAround** (*BoolType** | **BoolKey*) --
              GetFitFunctionsForAtomType diagonalization done with
              Lapack instead of Scalapack

            * **Method** (*Literal**[**"Auto"**,
              **"FromBasisProducts"**]*) --

              The way in which fit functions are generated. The main
              distinction is whether it depends on the basis functions
              used.

              When FromBasisProducts is used, the auxiliary basis is
              generated directly from the products of primary basis
              functions.

              This has the advantage that the auxiliary fit adapts
              automatically to the basis set size.

              Especially for basis sets of QZ quality or larger, this
              is often necessary to obtain highly precise correlation
              energies using RPA or double hybrids

              FromBasisProducts option is also useful for GW or BSE
              calculations with basis sets of QZ quality or larger.

            * **OneCenterDependencyThreshold** (*float** |
              **FloatKey*) --

              This key is only active when FromBasisProducts is chosen
              as method to generate the auxiliary basis.

              This threshold controls the size, and at the samw time,
              the precision of the auxiliary basis set. A smaller
              number leads to a larger auxiliary fit set.

              The default value of 1e-8 is typically sufficient to
              converge correlation energies and QP energies to a very
              high precision.

              It corresponds to an auxiliary basis which is typically
              8-9 times larger than the primary basis.

            * **UseBandRadialGrid** (*BoolType** | **BoolKey*) --

              Only applies to band. The band logarithmic grid ranges
              (by default) from 1e-6 to 100 with 3000 points.
              Otherwise 300 points will be used.

              For 0-periodicity (molecules) it is advisable to set
              this key to false since lots of memory is needed to
              evaluate all necessary integrals.

      class _QualityPerRegion

         Sets the fit-set quality for all atoms in a region. If
         specified, this overwrites the globally set quality.

         Variables:
            * **Quality** (*Literal**[**"VeryBasic"**, **"Basic"**,
              **"Normal"**, **"Good"**, **"VeryGood"**,
              **"Excellent"**]*) -- This region's quality of the
              auxiliary fit set employed in the RI scheme.

            * **Region** (*str** | **StringKey*) -- The identifier of
              the region for which to set the quality.

   class _RadialDefaults

      Options for the logarithmic radial grid of the basis functions
      used in the subprogram Dirac

      Variables:
         * **AdjustRMinForFunctional** (*BoolType** | **BoolKey*) --
           Some functionals have numerically unstable potentials near
           the nucleus for light elements: Enlarge rmin for lighter
           elements. If not specified then the option will be set for
           the OLYP and HTBS functionals

         * **DiDervViaSpline** (*BoolType** | **BoolKey*) -- replace
           old diderv with DiDervViaSpline

         * **NR** (*int** | **IntKey*) -- Number of radial points.
           With very high values (like 30000) the Dirac subprogram may
           not converge.

         * **NRPerType** (*Iterable**[**int**] **| **IntListKey*) --
           If present overrides NR. The list needs to be as long as
           there are atom types

         * **RMax** (*float** | **FloatKey*) -- Upper bound of the
           logarithmic radial grid

         * **RMin** (*float** | **FloatKey*) -- Lower bound of the
           logarithmic radial grid

         * **RMinPerType** (*Iterable**[**float**] **|
           **FloatListKey*) -- If specified overrides RMin. The list
           needs to be as long as there are atom types (different
           elements)

   class _Relativity

      Options for relativistic effects.

      Variables:
         * **Level** (*Literal**[**"None"**, **"Scalar"**, **"Spin-
           Orbit"**]*) --

           None: No relativistic effects.

           Scalar: Scalar relativistic ZORA. This option comes at very
           little cost.

           SpinOrbit: Spin-orbit coupled ZORA. This is the best level
           of theory, but it is (4-8 times) more expensive than a
           normal calculation. Spin-orbit effects are generally quite
           small, unless there are very heavy atoms in your system,
           especially with p valence electrons (like Pb).

           See also the SpinOrbitMagnetization key.

         * **Potential** (*Literal**[**"APA"**, **"SAPA"**]*) --
           Undocumented

   class _ResponseInducedDensityPlot

      Goes together with Restart%ResponseInducedDensityPlot and Grid.

   class _Restart

      Tells the program that it should restart with the restart file,
      and what to restart.

      Variables:
         * **BandStructure** (*BoolType** | **BoolKey*) -- Calculate
           the band structure from a previous calculation. Does not
           work with model potentials and Hubbard.

         * **COSMO** (*BoolType** | **BoolKey*) -- Restart the COSMO
           charges.

         * **CheckAtomicPositions** (*BoolType** | **BoolKey*) -- If
           set to True: For restarting the SCF the atomic positions
           will be checked, and may not deviate too much.

         * **DOS** (*BoolType** | **BoolKey*) -- Calculate the DOS
           from a previous calculation. Does not work with model
           potentials and Hubbard.

         * **DensityPlot** (*BoolType** | **BoolKey*) -- Goes together
           with the DensityPlot block and Grid blocks

         * **FermiSurface** (*BoolType** | **BoolKey*) --
           Undocumented.

         * **File** (*str** | **Path** | **StringKey*) -- Name of the
           restart file. The file should be a band.rkf file from a
           previous run.

         * **IgnoreBadGeometry** (*BoolType** | **BoolKey*) --
           Undocumented.

         * **LoadEigenSystem** (*BoolType** | **BoolKey*) -- At each
           step of the SCF load the section eigensystem from the
           restart file, forcing constant eigenvalues and vectors.

         * **NOCVOrbitalPlot** (*BoolType** | **BoolKey*) -- Goes
           together with the NOCVOrbitalPlot and Grid blocks.

         * **NOCVdRhoPlot** (*BoolType** | **BoolKey*) -- Goes
           together with the NOCVdRhoPlot and Grid blocks.

         * **NoPrdRhoPlot** (*BoolType** | **BoolKey*) --
           Undocumented.

         * **NoprOrbitalPlot** (*BoolType** | **BoolKey*) --
           Undocumented.

         * **OrbitalPlot** (*BoolType** | **BoolKey*) -- Goes together
           with the OrbitalPlot and Grid

         * **ResponseInducedDensityPlot** (*BoolType** | **BoolKey*)
           -- Goes together with the ResponseInducedDensityPlot and
           Grid blocks.

         * **SCF** (*BoolType** | **BoolKey*) -- Continue the SCF
           procedure using the orbital coefficients and occupations
           from the restart file.

         * **UseDensityMatrix** (*BoolType** | **BoolKey*) -- If set
           to True: For restarting the SCF the density matrix will be
           used. Requires you to set 'Save DensityMatrix' in the
           previous run.

         * **VTKFile** (*str** | **StringKey*) -- If specified a vtk
           file with be created with this name. If the extension is
           '.txt', a text file is created. Setting it to 'CUBE' one or
           more (one for each component) files in the cube format are
           generated with an automatic naming scheme.

         * **VoronoiGrid** (*BoolType** | **BoolKey*) -- Copy the
           section Num In Params to the current file.

   class _SCF

      Controls technical SCF parameters.

      Variables:
         * **ApplyVSplitToDensity** (*BoolType** | **BoolKey*) --
           Undocumented.

         * **Eigenstates** (*BoolType** | **BoolKey*) -- The program
           knows two alternative ways to evaluate the charge density
           iteratively in the SCF procedure: from the P-matrix, and
           directly from the squared occupied eigenstates. By default
           the program actually uses both at least one time and tries
           to take the most efficient. If present, Eigenstates turns
           off this comparison and lets the program stick to one
           method (from the eigenstates).

         * **Iterations** (*int** | **IntKey*) -- The maximum number
           of SCF iterations to be performed.

         * **LoadPreviousSCFMixing** (*BoolType** | **BoolKey*) --
           Load dimix and mixing from the previous SCF procedure, for
           instance during a geometry optimization.

         * **Method** (*Literal**[**"DIIS"**, **"MultiSecant"**,
           **"MultiStepper"**]*) -- Choose the general scheme used to
           converge the density in the SCF. In case of scf problems
           one can try the MultiSecant alternative at no extra cost
           per SCF cycle. For more details see the DIIS and
           MultiSecantConfig block.

         * **Mixing** (*float** | **FloatKey*) -- Initial 'damping'
           parameter in the SCF procedure, for the iterative update of
           the potential: new potential = old potential + mix
           (computed potential-old potential). Note: the program
           automatically adapts Mixing during the SCF iterations, in
           an attempt to find the optimal mixing value.

         * **MultiStepperPresetPath** (*str** | **Path** |
           **StringKey*) -- Name of file containing a SCFMultiStepper
           key block. This will be used if no Explicit SCFMultiStepper
           block is in the input, and Method=MultiStepper. If the path
           is not absolute, it is relative to
           $AMSHOME/data/presets/multi_stepper'

         * **NComponentsForNonColDIIS** (*int** | **IntKey*) -- For a
           non-collinear calculation: use all 8 components for the
           DIIS error metric. Possible choices: 2,4,8. With option=2
           information is discarded. Option=4 or 8 are nearly
           identical except that the off diag weights are a bit
           different. Before the key was introduced two components
           were used.

         * **NewEigenstates** (*BoolType** | **BoolKey*) --
           Undocumented.

         * **NewPMatrix** (*BoolType** | **BoolKey*) -- Undocumented.

         * **PMatrix** (*BoolType** | **BoolKey*) -- If present,
           evaluate the charge density from the P-matrix. See also the
           key Eigenstates.

         * **PrintAllOccupiedBands** (*BoolType** | **BoolKey*) --
           When printing the ranges of the bands, include all occupied
           ones.

         * **PrintAllVirtualBands** (*BoolType** | **BoolKey*) -- When
           printing the ranges of the bands, include all virtual ones.

         * **PrintAlwaysBandRanges** (*BoolType** | **BoolKey*) --
           Normally the ranges of the bands are only printed at the
           last SCF cycle

         * **Rate** (*float** | **FloatKey*) -- Minimum rate of
           convergence for the SCF procedure. If progress is too slow
           the program will take measures (such as smearing out
           occupations around the Fermi level, see key Degenerate of
           block Convergence) or, if everything seems to fail, it will
           stop

         * **SkipDiagonalization** (*BoolType** | **BoolKey*) --
           Undocumented.

         * **TryDensityMethods** (*str** | **StringKey*) --
           Undocumented.

         * **VSplit** (*float** | **FloatKey*) -- To disturb
           degeneracy of alpha and beta spin MOs the value of this key
           is added to the beta spin potential at the startup.

         * **SCFMultiStepper** (*BAND._SCF._SCFMultiStepper*) -- To
           solve the self-consistent problem multiple steppers can be
           tried during stints using the ones that give the best
           progress.

      class _SCFMultiStepper

         To solve the self-consistent problem multiple steppers can be
         tried during stints using the ones that give the best
         progress.

         Variables:
            * **AlwaysChangeStepper** (*BoolType** | **BoolKey*) --
              When the progress is fine there is no reason to change
              the stepper. In practice this is always set to true,
              because also the Stepper%ExpectedSlope can be used to
              achieve similar behavior.

            * **ErrorGrowthAbortFactor** (*float** | **FloatKey*) --
              Abort stint when the error grows too much, compared to
              the error at the start of the stint.

            * **FractionalStepFactor** (*float** | **FloatKey*) --
              Multiply the step by this factor. If smaller than zero
              this is not used.

            * **MinStintCyclesForAbort** (*int** | **IntKey*) -- Look
              at ErrorGrowthAbortFactor only when a number of steps
              has been completed since the start of the stint. A value
              of  0 means always.

            * **StintLength** (*int** | **IntKey*) -- A stepper is
              active during a number of SCF cycles, called a stint.

            * **UsePreviousStintForErrorGrowthAbort** (*BoolType** |
              **BoolKey*) -- The error is normally checked against the
              first error of the stint. With this option that will be
              the one from the previous stint, if performed with the
              same stepper.

            * **Stepper** (*BAND._SCF._SCFMultiStepper._Stepper*) --

              ??

         class _Stepper

            ??

            Variables:
               * **AbortSlope** (*float** | **FloatKey*) -- If the
                 slope (at the end of a stint) is larger than this:
                 abort the stepper

               * **AlwaysAbortAtBeginOfStint** (*BoolType** |
                 **BoolKey*) -- For debugging only: no matter what
                 abort this stepper at the begin of the stint (doing
                 only one step).

               * **AlwaysAbortAtEndOfStint** (*BoolType** |
                 **BoolKey*) -- For debugging only: no matter what
                 abort this stepper at the end of the stint.

               * **ErrorGrowthAbortFactor** (*float** | **FloatKey*)
                 -- Abort stint when the error grows too much,
                 compared to the error at the start of the stint.
                 Overrides global ErrorGrowthAbortFactor when set to a
                 value > 0

               * **ExpectedSlope** (*float** | **FloatKey*) -- If the
                 slope of the total SCF is better than this keep on
                 going.

               * **FractionalStepFactor** (*float** | **FloatKey*) --
                 Multiply the step by this factor. If smaller than
                 zero this is not used.

               * **InitialMixFromPreviousStint** (*BoolType** |
                 **BoolKey*) -- Similar to MixFromPreviousStint, but
                 only done the first time that a stepper is used.

               * **MaxInitialError** (*float** | **FloatKey*) -- Only
                 use the stepper when error is smaller than this.

               * **MaxIterationNumber** (*int** | **IntKey*) --
                 Stepper will only be active for iterations smaller
                 than this number. (Negative value means: Ignore this
                 option)

               * **MaxStintNumber** (*int** | **IntKey*) -- Stepper
                 will only be active for stints smaller than this
                 number. (Negative value means: Ignore this option)

               * **MaxStints** (*int** | **IntKey*) -- Maximum number
                 of stints that a stepper should be used.

               * **MinInitialError** (*float** | **FloatKey*) -- Only
                 use the stepper when error is larger than this.

               * **MinIterationNumber** (*int** | **IntKey*) --
                 Stepper will only be active for iterations larger
                 than this number.

               * **MinStintCyclesForAbort** (*int** | **IntKey*) --
                 Look at ErrorGrowthAbortFactor only when a number of
                 steps has been completed since the start of the
                 stint. A value of  0 means always. Overrides global
                 value.

               * **MinStintNumber** (*int** | **IntKey*) -- Stepper
                 will only be active for stints larger than this
                 number.

               * **MixFromPreviousStint** (*BoolType** | **BoolKey*)
                 -- When starting a new stint use the mix from the
                 previous stepper, even if it is of another type.

               * **StintLength** (*int** | **IntKey*) -- Override
                 global StintLength.

               * **DIISStepper**
                 (*BAND._SCF._SCFMultiStepper._Stepper._DIISStepper*)
                 -- DIIS stepper

               * **MixAdapter**
                 (*BAND._SCF._SCFMultiStepper._Stepper._MixAdapter*)
                 -- Generic mix adapter

               * **MixStepper**
                 (*BAND._SCF._SCFMultiStepper._Stepper._MixStepper*)
                 -- Simple mixing stepper, only using the previous
                 (in/out) density.

               * **MultiSecantStepper** (*BAND._SCF._SCFMultiStepper.
                 _Stepper._MultiSecantStepper*) -- Multi secant
                 stepper.

            class _DIISStepper

               DIIS stepper

               Variables:
                  * **EDIIS** (*BoolType** | **BoolKey*) -- Use energy
                    DIIS. The energy is used as extra info and only
                    interpolation is done (all coefficients in the
                    interval [0,1]).

                  * **EDIISAlpha** (*float** | **FloatKey*) -- The
                    extra energy vector is weighed by this factor. .

                  * **MaxBMatrixRange** (*float** | **FloatKey*) -- If
                    larger than zero: limit the ratio between the
                    oldest and last diagonal B matrix element.

                  * **MaxCoefficient** (*float** | **FloatKey*) -- The
                    largest allowed value of the expansion
                    coefficients. If exceed the number of vectors is
                    reduces until the criterion is met.

                  * **MaxConditionNumber** (*float** | **FloatKey*) --
                    If larger than zero: check condition number of the
                    B matrix. If too large reduce nVectors.

                  * **MaxVectors** (*int** | **IntKey*) -- Maximum
                    number of previous densities to be used (size of
                    the history).

                  * **MinLastCoefficient** (*float** | **FloatKey*) --
                    If larger than zero: If the most recent vector
                    gets a (abs) coefficient smaller than this the mix
                    is boosted.

                  * **MinVectors** (*int** | **IntKey*) -- Try to
                    prevent to make nVectors shrink below this value,
                    by allowing for significantly larger coefficients.

                  * **Mix** (*float** | **FloatKey*) -- Also known as
                    greed. It determines the amount of output density
                    to be used. May be changed by the MixAdapter.

                  * **RescaleBMatrix** (*BoolType** | **BoolKey*) --
                    Rescale the B matrix so that is's values are of
                    the same order as those of the constraints.

                  * **UseHalfMixForFirstCycle** (*BoolType** |
                    **BoolKey*) -- Use half the mix factor at
                    iteration 1 (if applicable).

            class _MixAdapter

               Generic mix adapter

               Variables:
                  * **CorrelateMixWithSlope** (*BoolType** |
                    **BoolKey*) -- For the last two mixing factors the
                    one with the best slope is preferred.

                  * **ErrorGrowthPanicFactor** (*float** |
                    **FloatKey*) -- When the error increases more than
                    this factor, this mix is reduced a lot.

                  * **GrowWhenSpaceGrows** (*BoolType** | **BoolKey*)
                    -- Has only effect when the error goes down.  If
                    nVectors increases grow the mix factor, otherwise
                    do not change the mix

                  * **GrowthFactor** (*float** | **FloatKey*) -- When
                    the mix is considered too low it is multiplied by
                    this factor. Otherwise it is divided by it.

                  * **MaxMix** (*float** | **FloatKey*) -- Do not grow
                    the mix above this value.

                  * **MinMix** (*float** | **FloatKey*) -- Do not
                    shrink the mix below this value.

                  * **NTrialMixFactors** (*int** | **IntKey*) -- Only
                    used with Type=Trial. Must be an odd number.

                  * **TrialMode**
                    (*Literal**[**"CurrentMixCentered"**,
                    **"FullRange"**]*) -- How are the NTrialMixFactors
                    chosen?

                  * **Type** (*Literal**[**"Error"**, **"Energy"**,
                    **"UnpredictedStep"**, **"Trial"**]*) -- Adapt the
                    mix factor based on the observed progress (slope).

            class _MixStepper

               Simple mixing stepper, only using the previous (in/out)
               density.

               Variables:
                  **Mix** (*float** | **FloatKey*) -- ???.

            class _MultiSecantStepper

               Multi secant stepper.

               Variables:
                  * **AlphaMSR1** (*float** | **FloatKey*) -- For the
                    MSR1 variant:  W = Y + alpha S.

                  * **MaxCoefficient** (*float** | **FloatKey*) --
                    ???.

                  * **MaxConditionNumber** (*float** | **FloatKey*) --
                    If set larger than zero this condition number of
                    the matrix to be inverted will be checked. If
                    exceeded the space is reduced.

                  * **MaxVectors** (*int** | **IntKey*) -- ???.

                  * **Mix** (*float** | **FloatKey*) -- ???.

                  * **PredictGreed** (*BoolType** | **BoolKey*) -- Try
                    to predict the optimal greed.

                  * **ScaleYTY** (*BoolType** | **BoolKey*) -- Scale
                    matrix before inversion

                  * **SigmaRegularize** (*float** | **FloatKey*) --
                    Prevent division by zero by adding a small number.
                    Makes most sense when using renormalization.

                  * **Variant** (*Literal**[**"MSB1"**, **"MSB2"**,
                    **"MSR1"**, **"MSR1s"**]*) -- There are several
                    version of the Multi secant method.

   class _Screening

      For the periodic solvation potential and for the old (not
      default anymore) fitting method, BAND performs lattice
      summations which are in practice truncated. The precision of the
      lattice summations is controlled by the options in this block.

      Variables:
         * **AutoStarFactor** (*float** | **FloatKey*) --
           Undocumented.

         * **CutOff** (*float** | **FloatKey*) -- Criterion for
           negligibility of tails in the construction of Bloch sums.
           Default depends on Accuracy.

         * **DMadel** (*float** | **FloatKey*) -- One of the
           parameters that define the screening of Coulomb-potentials
           in lattice sums. Depends by default on Accuracy, rmadel,
           and rcelx. One should consult the literature for more
           information

         * **DMadelFactor** (*float** | **FloatKey*) -- Undocumented.

         * **DMadelPowFactor** (*float** | **FloatKey*) --
           Undocumented.

         * **FermFC** (*float** | **FloatKey*) -- Undocumented.

         * **LatticeBased** (*BoolType** | **BoolKey*) --
           Undocumented.

         * **NoDirectionalScreening** (*BoolType** | **BoolKey*) --
           Real space lattice sums of slowly (or non-) convergent
           terms, such as the Coulomb potential, are computed by a
           screening technique. In previous releases, the screening
           was applied to all (long-range) Coulomb expressions.
           Screening is only applied in the periodicity directions.
           This key restores the original situation: screening in all
           directions

         * **RCelx** (*float** | **FloatKey*) -- Max. distance of
           lattice site from which tails of atomic functions will be
           taken into account for the Bloch sums. Default depends on
           Accuracy.

         * **RMadel** (*float** | **FloatKey*) -- One of the
           parameters that define screening of the Coulomb potentials
           in lattice summations. Depends by default on Accuracy,
           dmadel, rcelx. One should consult the literature for more
           information.

   class _SlakoConfig

      Undocumented.

      Variables:
         * **approximation** (*str** | **StringKey*) -- Undocumented.

         * **atompotentialshift** (*float** | **FloatKey*) --
           Undocumented.

         * **confinement** (*str** | **StringKey*) -- Undocumented.

         * **numcores1** (*int** | **IntKey*) -- Undocumented.

         * **numcores2** (*int** | **IntKey*) -- Undocumented.

         * **runtype** (*str** | **StringKey*) -- Undocumented.

   class _SoftConfinement

      In order to make the basis functions more compact, the radial
      part of the basis functions is multiplied by a Fermi-Dirac (FD)
      function (this 'confinement' is done for efficiency and
      numerical stability reasons). A FD function goes from one to
      zero, controlled by two parameters. It has a value 0.5 at
      Radius, and the decay width is Delta.

      Variables:
         * **Analytical** (*BoolType** | **BoolKey*) -- Undocumented

         * **AssumeLatticeDependent** (*BoolType** | **BoolKey*) --
           Bit of a hack to store the fact that the confinement was
           affected by the lattice. This allows later for disabling
           analytical stress if so.

         * **Delta** (*float** | **FloatKey*) -- Explicitly specify
           the delta parameter of the Fermi-Dirac function (if not
           specified, it will be 0.1*Radius).

         * **Method** (*str** | **StringKey*) -- Undocumented.

         * **Quality** (*Literal**[**"Auto"**, **"Basic"**,
           **"Normal"**, **"Good"**, **"VeryGood"**,
           **"Excellent"**]*) --

           In order to make the basis functions more compact, the
           radial part of the basis functions is multiplied by a
           Fermi-Dirac (FD) function (this 'confinement' is done for
           efficiency and numerical stability reasons). A FD function
           goes from one to zero, controlled by two parameters. It has
           a value 0.5 at Radius, and the decay width is Delta.

           This key sets the two parameters 'Radius' and 'Delta'.

           Basic: Radius=7.0, Delta=0.7; Normal: Radius=10.0,
           Delta=1.0; Good: Radius=20.0, Delta=2.0; VeryGood and
           Excellent: no confinement at all.

           If 'Auto', the quality defined in the 'NumericalQuality'
           will be used.

         * **Radius** (*float** | **FloatKey*) -- Explicitly specify
           the radius parameter of the Fermi-Dirac function.

         * **RadiusPerType** (*str** | **StringKey*) -- Undocumented.

   class _Solvation

      Options for the COSMO (Conductor like Screening Model) solvation
      model.

      Variables:
         * **CVec** (*Literal**[**"EXACT"**, **"FITPOT"**]*) --

           Choose how to calculate the Coulomb interaction matrix
           between the molecule and the point charges on the surface:

           * EXACT: use exact density, and integrate against the
             potential of the point charges. This may have
             inaccuracies when integration points are close to the
             point charges.

           * FITPOT: evaluate the molecular potential at the positions
             of the point charges, and multiply with these charges.

         * **Enabled** (*BoolType** | **BoolKey*) -- Use the Conductor
           like Screening Model (COSMO) to include solvent effects.

         * **SCF** (*Literal**[**"VAR"**, **"PERT"**, **"NONE"**]*) --
           Determine the point charges either Variational (VAR) or
           after the SCF as a Perturbation (PERT).

         * **Surf** (*Literal**[**"Delley"**, **"Wsurf"**,
           **"Asurf"**, **"Esurf"**, **"Klamt"**]*) --

           Within the COSMO model the molecule is contained in a
           molecule shaped cavity.

           Select one of the following surfaces to define the cavity:

           * Wsurf: Van der Waals surface

           * Asurf: solvent accessible surface

           * Esurf: solvent excluding surface

           * Klamt: Klamt surface

           * Delley: Delley surface.

         * **Charge** (*BAND._Solvation._Charge*) -- Select the
           algorithm to determine the charges.

         * **Radii** (*str** | **Sequence**[**str**] **| **FreeBlock*)
           -- The values are the radii of the atomic spheres. If not
           specified the default values are those by Allinger. Format:
           'AtomType value'. e.g.: 'H 0.7'

         * **Solvent** (*BAND._Solvation._Solvent*) -- Solvent details

      class _Charge

         Select the algorithm to determine the charges.

         Variables:
            * **Conv** (*float** | **FloatKey*) -- Charge convergence
              threshold in iterative COSMO solution.

            * **Corr** (*BoolType** | **BoolKey*) -- Correct for
              outlying charge.

            * **Iter** (*int** | **IntKey*) -- Maximum number of
              iterations to solve COSMO equations.

            * **Method** (*Literal**[**"CONJ"**, **"INVER"**]*) --

              INVER: matrix inversion, CONJ: biconjugate gradient
              method.

              The CONJ method is guaranteed to converge with small
              memory requirements and is normally the preferred
              method.

      class _Radii

         The values are the radii of the atomic spheres. If not
         specified the default values are those by Allinger. Format:
         'AtomType value'. e.g.: 'H 0.7'

      class _Solvent

         Solvent details

         Variables:
            * **Del** (*float** | **FloatKey*) -- Del is the value of
              Klamt's delta_sol parameter, only relevant in case of
              Klamt surface.

            * **Emp** (*float** | **FloatKey*) -- Emp is the empirical
              scaling factor x for the energy scaling.

            * **Eps** (*float** | **FloatKey*) -- User-defined
              dielectric constant of the solvent (overrides the Eps
              value of the solvent defined in 'Name')

            * **Name** (*Literal**[**"AceticAcid"**, **"Acetone"**,
              **"Acetonitrile"**, **"Ammonia"**, **"Aniline"**,
              **"Benzene"**, **"BenzylAlcohol"**, **"Bromoform"**,
              **"Butanol"**, **"isoButanol"**, **"tertButanol"**,
              **"CarbonDisulfide"**, **"CarbonTetrachloride"**,
              **"Chloroform"**, **"Cyclohexane"**,
              **"Cyclohexanone"**, **"Dichlorobenzene"**,
              **"DiethylEther"**, **"Dioxane"**, **"DMFA"**,
              **"DMSO"**, **"Ethanol"**, **"EthylAcetate"**,
              **"Dichloroethane"**, **"EthyleneGlycol"**,
              **"Formamide"**, **"FormicAcid"**, **"Glycerol"**,
              **"HexamethylPhosphoramide"**, **"Hexane"**,
              **"Hydrazine"**, **"Methanol"**,
              **"MethylEthylKetone"**, **"Dichloromethane"**,
              **"Methylformamide"**, **"Methypyrrolidinone"**,
              **"Nitrobenzene"**, **"Nitrogen"**, **"Nitromethane"**,
              **"PhosphorylChloride"**, **"IsoPropanol"**,
              **"Pyridine"**, **"Sulfolane"**, **"Tetrahydrofuran"**,
              **"Toluene"**, **"Triethylamine"**,
              **"TrifluoroaceticAcid"**, **"Water"**]*) -- Name of a
              pre-defined solvent. A solvent is characterized by the
              dielectric constant (Eps) and the solvent radius (Rad).

            * **Rad** (*float** | **FloatKey*) -- User-defined radius
              of the solvent molecule (overrides the Rad value of the
              solvent defined in 'Name').

   class _SolvationSM12

      Options for Solvation Model 12 (SM12).

      Variables:
         * **ARO** (*float** | **FloatKey*) -- Square of the fraction
           of non-hydrogen atoms in the solvent that are aromatic
           carbon atoms (carbon aromaticity)

         * **Acid** (*float** | **FloatKey*) -- Abraham hydrogen bond
           acidity parameter

         * **Base** (*float** | **FloatKey*) -- Abraham hydrogen bond
           basicity parameter

         * **BornC** (*float** | **FloatKey*) -- Coulomb constant for
           General Born Approximation

         * **Chgal** (*float** | **FloatKey*) -- Exponential of
           Pauli's bond order

         * **Cust** (*str** | **StringKey*) -- Custom solvent input

         * **Debug** (*str** | **StringKey*) -- Prints a lot of
           information about every pass on CDS and ENP code, keywords:
           ENP, CDS

         * **EPS** (*float** | **FloatKey*) -- The dielectric constant

         * **Enabled** (*BoolType** | **BoolKey*) -- Whether to use
           the Solvation Model 12 (SM12) in the calculation.

         * **HALO** (*float** | **FloatKey*) -- Square of the fraction
           of non-hydrogen atoms in the solvent molecule that are F,
           Cl, or Br (electronegative halogenicity)

         * **Kappa** (*float** | **FloatKey*) -- Factor for Debye
           screening

         * **PostSCF** (*BoolType** | **BoolKey*) -- Whether to apply
           the solvation potential during the SCF or only calculate
           the solvation energy after the SCF.

         * **PotentialFactor** (*float** | **FloatKey*) --

         * **PrintSM12** (*BoolType** | **BoolKey*) -- Prints out an
           in-depth breakdown of solvation energies

         * **RadSolv** (*float** | **FloatKey*) -- The radius distance
           between the solute and solvent

         * **Ref** (*float** | **FloatKey*) -- Refractive index of
           solvent

         * **Solv** (*Literal**[**"ACETICACID"**, **"ACETONITRILE"**,
           **"ACETOPHENONE"**, **"ANILINE"**, **"ANISOLE"**,
           **"BENZENE"**, **"BENZONITRILE"**, **"BENZYLALCOHOL"**,
           **"BROMOBENZENE"**, **"BROMOETHANE"**, **"BROMOFORM"**,
           **"BROMOOCTANE"**, **"N-BUTANOL"**, **"SEC-BUTANOL"**,
           **"BUTANONE"**, **"BUTYLACETATE"**, **"N-BUTYLBENZENE"**,
           **"SEC-BUTYLBENZENE"**, **"T-BUTYLBENZENE"**,
           **"CARBONDISULFIDE"**, **"CARBONTETRACHLORIDE"**,
           **"CHLOROBENZENE"**, **"CHLOROFORM"**, **"CHLOROHEXANE"**,
           **"M-CRESOL"**, **"CYCLOHEXANE"**, **"CYCLOHEXANONE"**,
           **"DECALIN"**, **"DECANE"**, **"DECANOL"**,
           **"1-2-DIBROMOETHANE"**, **"DIBUTYLETHER"**,
           **"O-DICHLOROBENZENE"**, **"1-2-DICHLOROETHANE"**,
           **"DIETHYLETHER"**, **"DIISOPROPYLETHER"**,
           **"N-N-DIMETHYLACETAMIDE"**, **"N-N-DIMETHYLFORMAMIDE"**,
           **"2-6-DIMETHYLPYRIDINE"**, **"DIMETHYLSULFOXIDE"**,
           **"DODECANE"**, **"ETHANOL"**, **"ETHOXYBENZENE"**,
           **"ETHYLACETATE"**, **"ETHYLBENZENE"**,
           **"FLUOROBENZENE"**, **"1-FLUORO-N-OCTANE"**,
           **"HEPTANE"**, **"HEPTANOL"**, **"HEXADECANE"**,
           **"HEXADECYLIODIDE"**, **"HEXANE"**, **"HEXANOL"**,
           **"IODOBENZENE"**, **"ISOBUTANOL"**, **"ISOOCTANE"**,
           **"ISOPROPANOL"**, **"ISOPROPYLBENZENE"**,
           **"P-ISOPROPYLTOLUENE"**, **"MESITYLENE"**, **"METHANOL"**,
           **"METHOXYETHANOL"**, **"METHYLENECHLORIDE"**,
           **"N-METHYLFORMAMIDE"**, **"2-METHYLPYRIDINE"**,
           **"4-METHYL-2-PENTANONE"**, **"NITROBENZENE"**,
           **"NITROETHANE"**, **"NITROMETHANE"**,
           **"O-NITROTOLUENE"**, **"NONANE"**, **"NONANOL"**,
           **"OCTANE"**, **"OCTANOL"**, **"PENTADECANE"**,
           **"PENTANE"**, **"PENTANOL"**, **"PERFLUOROBENZENE"**,
           **"PHENYLETHER"**, **"PROPANOL"**, **"PYRIDINE"**,
           **"TETRACHLOROETHENE"**, **"TETRAHYDROFURAN"**,
           **"TETRAHYDROTHIOPHENEDIOXIDE"**, **"TETRALIN"**,
           **"TOLUENE"**, **"TRIBUTYLPHOSPHATE"**,
           **"TRIETHYLAMINE"**, **"1-2-4-TRIMETHYLBENZENE"**,
           **"UNDECANE"**, **"WATER"**, **"XYLENE"**,
           **"1-2-DIBROMOETHANE_WATER"**,
           **"1-2-DICHLOROETHANE_WATER"**, **"BENZENE_WATER"**,
           **"CARBONTETRACHLORIDE_WATER"**, **"CHLOROBENZENE_WATER"**,
           **"CHLOROFORM_WATER"**, **"CYCLOHEXANE_WATER"**,
           **"DIBUTYLETHER_WATER"**, **"DIETHYLETHER_WATER"**,
           **"ETHYLACETATE_WATER"**, **"HEPTANE_WATER"**,
           **"HEXANE_WATER"**, **"NITROBENZENE_WATER"**,
           **"OCTANOL_WATER"**]*) -- List of predefined solvents

         * **SuperTrafoDiag** (*int** | **IntKey*) -- Used for the
           generation of the super cell.

         * **SuperTrafoDiagCM5** (*int** | **IntKey*) -- Used for the
           generation of the super cell with CM5 charges.

         * **Tens** (*float** | **FloatKey*) -- Macroscopic surface
           tension of the solvent at the air/solvent interface at 298K
           (cal*mol^-1*Ang^-2)

         * **BornRadiusConfig**
           (*BAND._SolvationSM12._BornRadiusConfig*) --

         * **TopologicalExtrapolation**
           (*BAND._SolvationSM12._TopologicalExtrapolation*) -- Method
           to extrapolate the long range Coulomb potential, needed for
           periodic calculations

      class _BornRadiusConfig

         Variables:
            * **MaxCellDistance** (*float** | **FloatKey*) -- Max
              distance from the centra cell used when computing the
              Born radii for periodic systems

            * **PointsPerBohr** (*int** | **IntKey*) --

            * **UseLegendreGrid** (*BoolType** | **BoolKey*) --

      class _TopologicalExtrapolation

         Method to extrapolate the long range Coulomb potential,
         needed for periodic calculations

         Variables:
            * **FirstCell** (*int** | **IntKey*) -- First cell for the
              topological extrapolation of the long range part of the
              Coulomb Potential.

            * **LastCell** (*int** | **IntKey*) -- Last cell for the
              topological extrapolation of the long range part of the
              Coulomb Potential.

            * **Order** (*int** | **IntKey*) -- Order of the
              topological extrapolation of the long range part of the
              Coulomb Potential.

   class _StrainDerivatives

      Undocumented.

      Variables:
         * **Analytical** (*BoolType** | **BoolKey*) -- Whether or not
           to use analytical strain derivatives. By default this is
           determined automatically, and used if possible.

         * **AnalyticalElectrostatic** (*BoolType** | **BoolKey*) --
           Undocumented.

         * **Analyticalkinetic** (*BoolType** | **BoolKey*) --
           Undocumented.

         * **Analyticalpulay** (*BoolType** | **BoolKey*) --
           Undocumented.

         * **Analyticalxc** (*BoolType** | **BoolKey*) --
           Undocumented.

         * **CalcRhoDef0FitError** (*BoolType** | **BoolKey*) -- Does
           not affect the results, but prints the fit error and a
           first order error estimation for the stress. Can be very
           expensive.

         * **Celltopoorder** (*int** | **IntKey*) -- Undocumented.

         * **Coreorthoption** (*int** | **IntKey*) -- Undocumented.

         * **Fitrho0numintextrarad** (*int** | **IntKey*) --
           Undocumented.

         * **Fitrho0prune** (*BoolType** | **BoolKey*) --
           Undocumented.

         * **Kinviadagger** (*BoolType** | **BoolKey*) --
           Undocumented.

         * **Lmaxmultipoleexpansion** (*int** | **IntKey*) --
           Undocumented.

         * **Naiveelstat** (*BoolType** | **BoolKey*) -- Undocumented.

         * **NoPairSetKCoordsToZero** (*BoolType** | **BoolKey*) --
           This used to be the case, do not know why. It seems to have
           no effect.

         * **Numericaldefdef** (*BoolType** | **BoolKey*) --
           Undocumented.

         * **Numericaldefdeflong** (*BoolType** | **BoolKey*) --
           Undocumented.

         * **Pairgridlowerangularorder** (*int** | **IntKey*) --
           Undocumented.

         * **Pairgridradpointsincrease** (*int** | **IntKey*) --
           Undocumented.

         * **Renormalizechargefitrho0** (*BoolType** | **BoolKey*) --
           Undocumented.

         * **Shiftmultipoleorigin** (*BoolType** | **BoolKey*) --
           Undocumented.

         * **Skipinlgwsmodule** (*BoolType** | **BoolKey*) --
           Undocumented.

         * **SubtractAtomicXC** (*BoolType** | **BoolKey*) -- Derive
           stress from xc energy difference of molecule versus atoms.

         * **Usesymmetry** (*BoolType** | **BoolKey*) -- Undocumented.

         * **Usevstrainderrho** (*BoolType** | **BoolKey*) --
           Undocumented.

         * **fitrho0numintextral** (*int** | **IntKey*) --
           Undocumented.

   class _Tails

      Ignore function tails.

      Variables:
         * **Bas** (*float** | **FloatKey*) -- Cut off the basis
           functions when smaller than the specified threshold.

         * **Confine** (*float** | **FloatKey*) -- Define a soft
           confinement radius for all functions. The value can be
           chosen larger than Tails%Bas. It never exceeds the
           SoftConfinement%Radius value.

         * **Core** (*float** | **FloatKey*) -- ToDo

         * **Coulomb** (*BoolType** | **BoolKey*) -- ToDo

         * **Fit** (*float** | **FloatKey*) -- ToDo

         * **Multipole** (*float** | **FloatKey*) -- ToDo

         * **Rosa** (*BoolType** | **BoolKey*) -- Increase the radius
           of contracted functions. A factor is used that decays from
           2 to 1.

         * **Screening** (*float** | **FloatKey*) -- ToDo

         * **Verbose** (*BoolType** | **BoolKey*) -- Feedback, in
           particular on the confinement.

   class _TechnicalCOSMO

      Some options to develop cosmo for charged periodic systems

      Variables:
         * **AddCOSMOPotentialToZlmFit** (*BoolType** | **BoolKey*) --
           Should the cosmo potential be calculated via ZlmFit?.
           Merely for technical tests

         * **CalcEnergyForChargedPeriodicCase** (*BoolType** |
           **BoolKey*) -- Use new energy expression suitable for
           charged periodic systems.

         * **ChargeConstraintViaEnergy** (*BoolType** | **BoolKey*) --
           The charge constraint can be done via a Lagrange
           multiplier, or by eliminating one charge from the energy.

         * **ExcludeNuBugFix** (*BoolType** | **BoolKey*) -- There was
           a bug skipping for all nu==mu, not checking icell = 1

         * **ExtrapolateChargeDerivativePotential** (*BoolType** |
           **BoolKey*) -- Use topological extrapolation for the
           calculation of the charge derivative of the (surface)
           potential.

         * **IncludeCOSMOPotentialInZlmFit** (*BoolType** |
           **BoolKey*) -- Solve COSMO and include cosmo pot in ZlmFit
           potential. This makes sense for the charge periodic COSMO
           case.

         * **NeutralizeSurfaceCharges** (*BoolType** | **BoolKey*) --
           Add Q/N to surface charges.

         * **SolveChargesForChargedPeriodicCase** (*BoolType** |
           **BoolKey*) -- Use new energy expression suitable for
           charged periodic systems to determine the charges.

         * **UseFullEnergyExpression** (*BoolType** | **BoolKey*) --
           Use the energy expression that is valid for any q vector.

   class _TestParameters

      Undocumented.

      Variables:
         * **Integer** (*int** | **IntKey*) -- Undocumented.

         * **IntegerList** (*str** | **StringKey*) -- Undocumented.

         * **Logical** (*BoolType** | **BoolKey*) -- Undocumented.

         * **String** (*str** | **StringKey*) -- Undocumented.

   class _Transport

      Old NEGF. No longer supported

      Variables:
         * **c1atoms** (*int** | **IntKey*) -- count of number of
           atoms considered as contact 1

         * **c2atoms** (*int** | **IntKey*) -- count of number of
           atoms considered as contact 2

         * **contactshift** (*float** | **FloatKey*) -- sets baseline
           deltaphi0

         * **defersigma** (*BoolType** | **BoolKey*) -- decides
           whether to load sigmas on the fly

         * **easynegf** (*BoolType** | **BoolKey*) -- Undocumented.

         * **freezestop** (*int** | **IntKey*) -- controls how long
           you might whether deltaphi0 floats in transport

         * **hmatmixsteps** (*int** | **IntKey*) -- controls over how
           many steps to mix in bulk hmats after freezestop

         * **nematoms** (*int** | **IntKey*) -- count of number of
           atoms considered as extended molecule

         * **noshiftfloat** (*BoolType** | **BoolKey*) -- turns off
           deltaphi0 floating calculation in transport

         * **offsetshift** (*float** | **FloatKey*) -- sets baseline
           deltaphi1

         * **plot** (*int** | **IntKey*) -- Print option for dos and
           transmission

         * **screw** (*BoolType** | **BoolKey*) -- controls negfs
           ability to adapt the scf, diis mixing parameters

         * **testmatch** (*BoolType** | **BoolKey*) -- controls
           whether we should do extensive testing of hmat matches

         * **transdir** (*int** | **IntKey*) -- Transport direction

         * **unresleads** (*BoolType** | **BoolKey*) -- turns on
           unrestricted calculation for the leads in transport

         * **wbl** (*BoolType** | **BoolKey*) -- sets wide band limit
           coupling parameter

         * **wblflat** (*float** | **FloatKey*) -- decides whether to
           do wbl with flat imaginary constant part, and sets it

         * **wblimonly** (*BoolType** | **BoolKey*) -- decides whether
           to do wbl sigma(fermi) with only imaginary part

         * **wblplotonly** (*BoolType** | **BoolKey*) -- decides
           whether to turn wbl of any kind off in scf cycle

         * **wblrescale** (*BoolType** | **BoolKey*) -- decides
           whether to do wbl sigma rescaled from ellipse to flat band

   class _XC

      Exchange Correlation functionals

      Variables:
         * **DoubleHybrid** (*str** | **StringKey*) -- Specifies the
           double hybrid functional that should be used during the
           SCF.

         * **EmpiricalScaling** (*Literal**[**"None"**, **"SOS"**,
           **"SCS"**, **"SCSMI"**]*) -- Calculate the
           (SOS/SCS/SCSMI)-MP2 correlation energy.

         * **GALITSKIIMIGDAL** (*BoolType** | **BoolKey*) -- Calculate
           the Galitskii-Migdal correlation energy after the SCF is
           completed.

         * **GLLBKParameter** (*float** | **FloatKey*) -- K parameter
           for the GLLB functionals. See equation (20) of the paper.

         * **HartreeFock** (*BoolType** | **BoolKey*) -- Stand alone
           HF calculation.

         * **MP2** (*BoolType** | **BoolKey*) -- Calculate the MP2
           correlation energy after the HF SCF is completed.

         * **RPA** (*Literal**[**"None"**, **"Direct"**, **"Sigma"**,
           **"SOSEX"**, **"SOSSX"**]*) -- Specifies the use of an RPA
           or post-RPA method. By default, RPA is not enabled.

         * **RangeSeparation** (*str** | **StringKey*) -- Intended to
           be used with HartreeFock (or hybrid functionals). Example:
           OMEGA=    0.110000 ALPHA=    0.250000 BETA=   -0.250000
           ERF-SHORTRANGE

         * **allowany** (*BoolType** | **BoolKey*) -- Undocumented.

         * **diracgga** (*str** | **StringKey*) -- GGA for the dirac .

         * **dispersion** (*str** | **StringKey*) -- The dispersion
           correction model to be used.

         * **gga** (*str** | **StringKey*) -- GGA XC functional.

         * **lda** (*str** | **StringKey*) -- LDA XC functional.

         * **libxc** (*str** | **StringKey*) -- Functional using the
           LicXC library.

         * **libxcdensitythreshold** (*float** | **FloatKey*) --
           Density threshold for LibXC functionals.

         * **metagga** (*str** | **StringKey*) -- MetaGG XC
           functional.

         * **mggaoepconvergence** (*float** | **FloatKey*) --
           Undocumented.

         * **mggaoepmaxabortiter** (*int** | **IntKey*) --
           Undocumented.

         * **mggaoepmaxerrorincrease** (*float** | **FloatKey*) --
           Undocumented.

         * **mggaoepmaxiter** (*int** | **IntKey*) -- Undocumented.

         * **mggaoepwaititer** (*int** | **IntKey*) -- Undocumented.

         * **model** (*str** | **StringKey*) -- Model potential. The
           possible choices are LB94, GLLB-SC, BGLLB-VWN, and BGLLB-
           LYP

         * **nlxcpot** (*str** | **StringKey*) -- Undocumented.

         * **spinorbitmagnetization** (*str** | **StringKey*) -- Type
           of Spin-Orbit magnetization.

         * **tb_mbjafactor** (*float** | **FloatKey*) -- a parameter
           for the TB-MBJ model potential.

         * **tb_mbjbfactor** (*float** | **FloatKey*) -- b parameter
           for the TB-MBJ model potential..

         * **tb_mbjcfactor** (*float** | **FloatKey*) -- c parameter
           for the TB-MBJ model potential..

         * **tb_mbjefactor** (*float** | **FloatKey*) -- e parameter
           for the TB-MBJ model potential..

         * **usexcfun** (*BoolType** | **BoolKey*) -- Whether ot not
           the XCFun library should be used.

         * **xcfun** (*BoolType** | **BoolKey*) -- Functional for the
           XCFun library.

         * **DFTHalf** (*BAND._XC._DFTHalf*) -- DFT-1/2 method for
           band gaps. See PRB vol 78,125116 2008. This method can be
           used in combination with any functional. For each active
           atom type (see ActiveAtomType) Band will perform SCF
           calculations at different screening cut-off values (see
           ScreeningCutOffs) and pick the cut-off value that maximizes
           the band gap. If multiple atom types are active, the
           screening cut-off optimizations are done one type at the
           time (in the same order as the ActiveAtomType blocks appear
           in the input).

      class _DFTHalf

         DFT-1/2 method for band gaps. See PRB vol 78,125116 2008.
         This method can be used in combination with any functional.
         For each active atom type (see ActiveAtomType) Band will
         perform SCF calculations at different screening cut-off
         values (see ScreeningCutOffs) and pick the cut-off value that
         maximizes the band gap. If multiple atom types are active,
         the screening cut-off optimizations are done one type at the
         time (in the same order as the ActiveAtomType blocks appear
         in the input).

         Variables:
            * **Enabled** (*BoolType** | **BoolKey*) -- Whether the
              DFT-1/2 method will be used.

            * **Prepare** (*BoolType** | **BoolKey*) -- Analyze the
              band structure to determine reasonable settings for an
              DFT-1/2 calculation. If this is possible the list of
              active atom types is written to the output. This can be
              used in a next run as the values for ActiveAtomType. The
              DFTHalf%Enabled key should be set to false

            * **SelfConsistent** (*BoolType** | **BoolKey*) -- Apply
              the extra potential during the SCF, or only afterwards.
              Applying DFT-1/2 only post SCF increases the band gap,
              compared to the self-consistent one.

            * **ActiveAtomType** (*BAND._XC._DFTHalf._ActiveAtomType*)
              -- Use the DFT-1/2 method for the atom-type specified in
              this block.

         class _ActiveAtomType

            Use the DFT-1/2 method for the atom-type specified in this
            block.

            Variables:
               * **AtomType** (*str** | **StringKey*) -- Atom-type to
                 use. You can activate all atom-types by specifying
                 'All'.

               * **IonicCharge** (*float** | **FloatKey*) -- The
                 amount of charge to be removed from the atomic HOMO.

               * **ScreeningCutOffs** (*Iterable**[**float**] **|
                 **FloatListKey*) -- List of screening cut-offs (to
                 screen the asymptotic IonicCharge/r potential). Band
                 will loop over these values and find the cut-off that
                 maximizes the band-gap. If only one number is
                 provided, Band will simply use that value.

   class _ZlmFit

      Options for the density fitting scheme 'ZlmFit'.

      Variables:
         * **AllowBoost** (*BoolType** | **BoolKey*) -- 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.

         * **DensityThreshold** (*float** | **FloatKey*) -- Threshold
           below which the electron density is considered to be
           negligible. Depends on Quality and is normally 1.0e-7

         * **FGaussianW** (*float** | **FloatKey*) -- Only for 3D
           periodic systems. Width of the Gaussian functions replacing
           the S and P Zlms for Fourier transform.

         * **FGridSpacing** (*float** | **FloatKey*) -- Only for 3D
           periodic systems. Spacing for the Fourier grid. By default,
           this depends on the quality.

         * **FKSpaceCutOff** (*float** | **FloatKey*) -- Only for 3D
           periodic systems. Cut-off of the grid in k-space for the
           Fourier transform.

         * **FirstTopoCell** (*int** | **IntKey*) -- First cell for
           the topological extrapolation of the long range part of the
           Coulomb Potential.

         * **GridAngOrder** (*int** | **IntKey*) -- Lebedev angular
           order for the fitting grid.

         * **GridRadialFactor** (*float** | **FloatKey*) -- User
           defined value for determining how many radial points are
           used in the interpolation grid. By default, this depends on
           the quality, and normally is 1.0

         * **LMargin** (*int** | **IntKey*) -- User-defined l-margin,
           i.e., l_max for fitting is max(lMargin +
           l_max_basis_function, 2*l_max_basis_function). Depends on
           Quality and normally is 4

         * **LastTopoCell** (*int** | **IntKey*) -- Last cell for the
           topological extrapolation of the long range part of the
           Coulomb Potential.

         * **NumStarsPartitionFun** (*int** | **IntKey*) -- Number of
           cell stars to consider when computing the partition
           function.

         * **OrderTopoTrick** (*int** | **IntKey*) -- Order of the
           topological extrapolation of the long range part of the
           Coulomb Potential.

         * **PartitionFunThreshold** (*float** | **FloatKey*) --
           Threshold for the partition functions: if an integration
           point has a partition function weight smaller than this
           threshold, it will be discarded.

         * **PotentialThreshold** (*float** | **FloatKey*) -- Depends
           on the Quality. For band it is normally 1.0e-8, ten times
           smaller than for molecules.

         * **Pruning** (*BoolType** | **BoolKey*) -- Undocumented.
           Depends on the Quality, normally true

         * **Quality** (*Literal**[**"Auto"**, **"Basic"**,
           **"Normal"**, **"Good"**, **"VeryGood"**,
           **"Excellent"**]*) -- 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.

         * **RenormalizeChargeMethod** (*int** | **IntKey*) --
           Undocumented.

         * **UseBlockProperty** (*BoolType** | **BoolKey*) --
           Undocumented.

         * **QualityPerRegion** (*BAND._ZlmFit._QualityPerRegion*) --
           Sets the ZlmFit quality for all atoms in a region. If
           specified, this overwrites the globally set quality.

      class _QualityPerRegion

         Sets the ZlmFit quality for all atoms in a region. If
         specified, this overwrites the globally set quality.

         Variables:
            * **Quality** (*Literal**[**"Basic"**, **"Normal"**,
              **"Good"**, **"VeryGood"**, **"Excellent"**]*) -- The
              region's quality of the ZlmFit.

            * **Region** (*str** | **StringKey*) -- The identifier of
              the region for which to set the quality.

class DFTB

   Variables:
      * **DispersionCorrection** (*Literal**[**"None"**, **"Auto"**,
        **"UFF"**, **"ULG"**, **"D2"**, **"D3-BJ"**, **"D4"**]*) --

        This key is used to specify an empirical dispersion model.
        Please refer to the DFTB documentation for details on the
        different methods.

        By default no dispersion correction will be applied. Setting
        this to auto applies the dispersion correction recommended in
        the DFTB parameter set's metainfo file. Note that the D3-BJ
        dispersion correction is enabled by default when using the
        GFN1-xTB model Hamiltonian, but can be disabled manually by
        setting this keyword to None.

      * **Model** (*Literal**[**"DFTB"**, **"DFTB0"**, **"DFTB1"**,
        **"SCC-DFTB"**, **"DFTB2"**, **"DFTB3"**, **"GFN1-xTB"**,
        **"NonSCC-GFN1-xTB"**]*) --

        Selects the Hamiltonian used in the DFTB calculation: -
        DFTB/DFTB0/DFTB1 for classic DFTB without a self-consistent
        charge cycle - SCC-DFTB/DFTB2 with a self-consistency loop for
        the Mulliken charges - DFTB3 for additional third-order
        contributions. - GFN1-xTB for Grimme's extended tight-binding
        model in the GFN1 version. - NonSCC-GFN1-xTB for a less
        accurate but faster version of GFN1-xTB without a self-
        consistency cycle

        The choice has to be supported by the selected parameter set.

      * **NumericalQuality** (*Literal**[**"Basic"**, **"Normal"**,
        **"Good"**, **"VeryGood"**, **"Excellent"**]*) -- Set the
        quality of some technical aspects of a DFTB calculation. It
        sets the quality of: KSpace (reciprocal space integration).
        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 'KSpace%Quality
        Good', the quality of the KSpace will be 'Good')

      * **RadialExtrapolation** (*Literal**[**"Auto"**,
        **"ScreenTail"**, **"None"**, **"Linear"**, **"Original"**,
        **"Improved"**, **"Bezier"**]*) -- Advanced control option.
        Overrides the extrapolation method for Slater-Koster grid
        values between the end of the tabulated grid and the cutoff
        distance (value for which atoms are considered too far to
        interact). Depending on the structure of your Slater-Koster
        tables, a different radial extrapolation method may be needed
        in order to guarantee correct behavior, in particular for
        large and periodic systems. See the DFTB documentation for a
        description of the various available methods.

      * **ResourcesDir** (*str** | **Path** | **StringKey*) -- The
        directory containing the parameter files. The path can be
        absolute or relative. Relative paths starting with ./ are
        considered relative to the directory in which the calculation
        is started, otherwise they are considered relative to
        $AMSRESOURCES/DFTB. This key is required for the Slater-Koster
        based DFTB models, but optional for xTB.

      * **StoreMatrices** (*BoolType** | **BoolKey*) -- Determines
        whether the Hamiltonian and overlap matrices are stored in the
        binary result file.

      * **StoreOrbitals** (*BoolType** | **BoolKey*) -- Determines
        whether the orbital coefficients are stored in the binary
        result file. They are needed for displaying orbitals and
        densities in amsview.

      * **UnpairedElectrons** (*int** | **IntKey*) --

        This specifies the number of unpaired electrons (not the
        multiplicity!).

        This number will then be used in the orbital-filling strategy.
        Has to be compatible with the total number of electrons,
        meaning it must be an even number if the total number of
        electrons is even and odd if the total number is odd. Must be
        an integer value.

        Note that this does not activate spin polarization, it only
        affects the filling of the orbitals.

      * **UseSymmetry** (*BoolType** | **BoolKey*) --

      * **KSpace** (*DFTB._KSpace*) -- Options for the k-space
        integration (i.e. the grid used to sample the Brillouin zone)

      * **Occupation** (*DFTB._Occupation*) -- Configures the details
        of how the molecular orbitals are occupied with electrons.

      * **Periodic** (*DFTB._Periodic*) -- Block that sets various
        details of the calculation only relevant for periodic systems.

      * **Properties** (*DFTB._Properties*) -- DFTB can calculate
        various properties of the simulated system. This block
        configures which properties will be calculated.

      * **QMFQ** (*DFTB._QMFQ*) -- Block input key for QM/(w)FQ(FMu).

      * **Repulsion** (*DFTB._Repulsion*) -- Configures various
        details of the repulsive potential.

      * **SCC** (*DFTB._SCC*) -- This optional section configures
        various details of the self-consistent charge cycle. If the
        model Hamiltonian does not need a self-consistent solution
        (e.g. plain DFTB0), none of this information is used and the
        entire section will be ignored.

      * **Solvation** (*DFTB._Solvation*) -- Generalized Born
        solvation model with Solvent Accessible Surface Area (GBSA).

      * **Technical** (*DFTB._Technical*) -- This optional section is
        about technical aspects of the program that should not concern
        the normal user.

      * **XTBConfig** (*DFTB._XTBConfig*) -- This block allows for
        minor tweaking.

   class _KSpace

      Options for the k-space integration (i.e. the grid used to
      sample the Brillouin zone)

      Variables:
         * **Analytical** (*BoolType** | **BoolKey*) --

           For analytical integration the BZ is split into simplices,
           whereover the bands are interpolated, ater which the
           integrals can be performed analytically.

           Alternatively, the set of eigenvalues in the discrete set
           of k-points are just handled as distinct molecular
           orbitals.

           Using analytical=no can improve SCF convergence in
           combination with smearing/temperature.

         * **Quality** (*Literal**[**"Auto"**, **"GammaOnly"**,
           **"Basic"**, **"Normal"**, **"Good"**, **"VeryGood"**,
           **"Excellent"**]*) --

           Select the quality of the K-space grid used to sample the
           Brillouin Zone. If 'Auto', the quality defined in the
           'NumericalQuality' will be used. If 'GammaOnly', only one
           point (the gamma point) will be used.

           The actual number of K points generated depends on this
           option and on the size of the unit cell. The larger the
           real space cell, the fewer K points will be generated.

           The CPU-time and accuracy strongly depend on this option.

         * **Type** (*Literal**[**"Regular"**, **"Symmetric"**]*) --

           The type of k-space integration grid used to sample the
           Brillouin zone (BZ) used.

           'Regular': simple regular grid.

           'Symmetric': symmetric grid for the irreducible wedge of
           the first BZ (useful when high-symmetry points in the BZ
           are needed to capture the correct physics of the system,
           graphene being a notable example).

         * **Regular** (*DFTB._KSpace._Regular*) -- Options for the
           regular k-space integration grid.

         * **Symmetric** (*DFTB._KSpace._Symmetric*) -- Options for
           the symmetric k-space integration grid.

      class _Regular

         Options for the regular k-space integration grid.

         Variables:
            * **DoubleCount** (*int** | **IntKey*) -- Increase for
              each dimension the grid. A sequence of doubling, with a
              special meaning for grid with odd numbers. Useful when
              checking k-space convergence.

            * **KMesh** (*int** | **IntKey*) -- Undocumented.

            * **NumberOfPoints** (*Iterable**[**int**] **|
              **IntListKey*) --

              Use a regular grid with the specified number of k-points
              along each reciprocal lattice vector.

              For 1D periodic systems you should specify only one
              number, for 2D systems two numbers, and for 3D systems
              three numbers.

            * **PreferEvenNumberOfPoints** (*BoolType** | **BoolKey*)
              -- In case of an automatic grid normally odd numbers
              will be generated (1,3,5,9), suitable for a quadratic
              grid. With this option the suggested odd numbers will be
              increased by one, unless it is one.

            * **SplitCubeInSix** (*BoolType** | **BoolKey*) --
              Undocumented.

            * **SplitLongest** (*BoolType** | **BoolKey*) --
              Undocumented.

            * **SplitPermutation** (*int** | **IntKey*) --
              Undocumented.

      class _Symmetric

         Options for the symmetric k-space integration grid.

         Variables:
            * **KInteg** (*int** | **IntKey*) --

              Specify the accuracy for the Symmetric method.

              1: absolutely minimal (only the G-point is used) 2:
              linear tetrahedron method, coarsest spacing 3: quadratic
              tetrahedron method, coarsest spacing 4,6,... (even):
              linear tetrahedron method 5,7.... (odd): quadratic
              method

              The tetrahedron method is usually by far inferior.

            * **KMesh** (*int** | **IntKey*) -- Undocumented.

   class _Occupation

      Configures the details of how the molecular orbitals are
      occupied with electrons.

      Variables:
         * **KT** (*float** | **FloatKey*) -- (KT) Boltzmann constant
           times temperature, used for electronic temperature with
           strategy is auto. The default value is the default value
           for Temperature*3.166815423e-6. This key and Temperature
           are mutually exclusive.

         * **NumBoltz** (*int** | **IntKey*) -- The electronic
           temperature is done with a Riemann Stieltjes numerical
           integration, between zero and one occupation. This defines
           the number of points to be used.

         * **Strategy** (*Literal**[**"Auto"**, **"Aufbau"**,
           **"Fermi"**]*) --

           This optional key allows to specify the fill strategy to
           use for the molecular orbitals.

           Can either be 'Aufbau' for simply filling the energetically
           lowest orbitals, or 'Fermi' for a smeared out Fermi-Dirac
           occupation. By default the occupation strategy is
           determined automatically, based on the other settings (such
           as the number of unpaired electrons).

         * **Temperature** (*float** | **FloatKey*) -- The Fermi
           temperature used for the Fermi-Dirac distribution. Ignored
           in case of aufbau occupations.

   class _Periodic

      Block that sets various details of the calculation only relevant
      for periodic systems.

      Variables:
         * **BZPath** (*DFTB._Periodic._BZPath*) -- If
           [BandStructure%Automatic] is disabled, DFTB will compute
           the band structure for the user-defined path in the
           [BZPath] block. You should define the vertices of your path
           in fractional coordinates (with respect to the reciprocal
           lattice vectors) in the [Path] sub-block. If you want to
           make a jump in your path, you need to specify a new [Path]
           sub-block.

         * **BandStructure** (*DFTB._Periodic._BandStructure*) --
           Options for band structure plotting. This has no effect on
           the calculated energy. [Warning: The band structure is only
           computed in case of k-space sampling, i.e. it is not
           computed for Gamma-only calculations (see:
           Periodic%KSpace).]

         * **DOS** (*DFTB._Periodic._DOS*) -- The subkeys of [DOS]
           allow to customize the calculation of the density of
           states.

         * **EffectiveMass** (*DFTB._Periodic._EffectiveMass*) --

           In a semi-conductor, the mobility of electrons and holes is
           related to the curvature of the bands at the top of the
           valence band and the bottom of the conduction band.

           With the effective mass option, this curvature is obtained
           by numerical differentiation.

           The estimation is done with the specified step size, and
           twice the specified step size, and both results are printed
           to give a hint on the accuracy. By far the most convenient
           way to use this key is without specifying any options.

      class _BZPath

         If [BandStructure%Automatic] is disabled, DFTB will compute
         the band structure for the user-defined path in the [BZPath]
         block. You should define the vertices of your path in
         fractional coordinates (with respect to the reciprocal
         lattice vectors) in the [Path] sub-block. If you want to make
         a jump in your path, you need to specify a new [Path] sub-
         block.

         Variables:
            **Path** (*str** | **Sequence**[**str**] **| **FreeBlock*)
            -- A section of a k space path.

         class _Path

            A section of a k space path.

      class _BandStructure

         Options for band structure plotting. This has no effect on
         the calculated energy. [Warning: The band structure is only
         computed in case of k-space sampling, i.e. it is not computed
         for Gamma-only calculations (see: Periodic%KSpace).]

         Variables:
            * **Automatic** (*BoolType** | **BoolKey*) --

              Generate and use the standard path through the Brillouin
              zone.

              If not, use the user defined path (set via Custom path
              in the GUI, or with the Periodic%BZPath keyword in the
              run script).

            * **DeltaK** (*float** | **FloatKey*) -- Step size in
              reciprocal space for band structure interpolation. Using
              a smaller number will produce smoother band curves at an
              increased computational time.

            * **Enabled** (*BoolType** | **BoolKey*) -- Whether or not
              to calculate the band structure.

            * **FatBands** (*BoolType** | **BoolKey*) --

              Control the computation of the fat bands (only when the
              bandstructure is calculated).

              The fat bands are the periodic equivalent of the
              Mulliken population analysis. The definition of the fat
              bands can be found in the Band Documentation.

            * **KPathFinderConvention** (*Literal**[**"Setyawan-
              Curtarolo"**, **"Hinuma"**]*) --

              This option determines how the path through the
              Brillouin zone is generated when using the automatic
              k-point mode.

              Available options:

              * "Setyawan-Curtarolo" (default for 1D and 2D lattices):
                Uses our built-in KPath program to find a path through
                high-symmetry points based on the method by Setyawan
                and Curtarolo
                (https://doi.org/10.1016/j.commatsci.2010.05.010). For
                2D lattices, the path is derived from the intersection
                of the 3D Brillouin zone with a plane. For 1D
                lattices, the path is simply Gamma-Z.

              * "Hinuma": Uses the external SeeKPath utility to
                generate the k-path
                (https://github.com/giovannipizzi/seekpath and
                https://doi.org/10.1016/j.commatsci.2016.10.015).

            * **UseSymmetry** (*BoolType** | **BoolKey*) -- If set,
              only the irreducible wedge of the Wigner-Seitz cell is
              sampled. If not, the whole (inversion-unique) Wigner-
              Seitz cell is sampled. Only available for Setyawan and
              Curtarolo convention (see "KPathFinderConvention").

      class _DOS

         The subkeys of [DOS] allow to customize the calculation of
         the density of states.

         Variables:
            * **EMax** (*float** | **FloatKey*) -- Upper end of the
              energy interval in which the density of states is
              calculated.

            * **EMin** (*float** | **FloatKey*) -- Lower end of the
              energy interval in which the density of states is
              calculated.

            * **Enabled** (*BoolType** | **BoolKey*) -- Whether or not
              to calculate the DOS. Note that the DOS will always be
              calculated when also the band structure is calculated.

            * **NSteps** (*int** | **IntKey*) -- The number of energy
              intervals between [EMin] and [EMax] for which the
              density of states is calculated.

      class _EffectiveMass

         In a semi-conductor, the mobility of electrons and holes is
         related to the curvature of the bands at the top of the
         valence band and the bottom of the conduction band.

         With the effective mass option, this curvature is obtained by
         numerical differentiation.

         The estimation is done with the specified step size, and
         twice the specified step size, and both results are printed
         to give a hint on the accuracy. By far the most convenient
         way to use this key is without specifying any options.

         Variables:
            * **Enabled** (*BoolType** | **BoolKey*) --

              In a semi-conductor, the mobility of electrons and holes
              is related to the curvature of the bands at the top of
              the valence band and the bottom of the conduction band.

              With the effective mass option, this curvature is
              obtained by numerical differentiation.

              The estimation is done with the specified step size, and
              twice the specified step size, and both results are
              printed to give a hint on the accuracy. By far the most
              convenient way to use this key is without specifying any
              options.

            * **KPointCoord** (*Iterable**[**float**] **|
              **FloatListKey*) -- Coordinate of the k-points for which
              you would like to compute the effective mass.

            * **NumAbove** (*int** | **IntKey*) -- Number of bands to
              take into account above the Fermi level.

            * **NumBelow** (*int** | **IntKey*) -- Number of bands to
              take into account below the Fermi level.

            * **StepSize** (*float** | **FloatKey*) -- Size of the
              step taken in reciprocal space to perform the numerical
              differentiation

            * **UseBandStructureInfoFromPath** (*BoolType** |
              **BoolKey*) -- The (automatic) location of the HOMO and
              LUMO can be determined via band interpolation, or from
              the path as used by the BandStructure feature. The
              latter works better when they are located on the path.
              See also comments in the BandStructure block. To
              reproduce results from before ams2025 set to no.

   class _Properties

      DFTB can calculate various properties of the simulated system.
      This block configures which properties will be calculated.

      Variables:
         * **NBOInput** (*BoolType** | **BoolKey*) -- Whether or not
           an input file for the NBO program is written to disk as
           nboInput.FILE47. The input file follows the FILE47 format
           as described in the NBO6 manual available on
           nbo6.chem.wisc.edu. By default, only the calculation of the
           natural bond orbitals and the natural localized molecular
           orbitals is enabled, but the nboInput.FILE47 file can be
           edited by hand to enable other analysis models. Please
           refer to the NBO6 manual for details.

         * **Excitations** (*DFTB._Properties._Excitations*) --
           Contains all options related to the calculation of excited
           states, either as simple single orbitals transitions or
           from a TD-DFTB calculation.

         * **Fragments** (*DFTB._Properties._Fragments*) -- Fragment
           files

         * **RESPONSE** (*DFTB._Properties._RESPONSE*) -- Linear
           response module to compute electric (complex)
           polarizabilities

      class _Excitations

         Contains all options related to the calculation of excited
         states, either as simple single orbitals transitions or from
         a TD-DFTB calculation.

         Variables:
            * **SingleOrbTrans**
              (*DFTB._Properties._Excitations._SingleOrbTrans*) -- The
              simplest approximation to the true excitations are the
              single orbital transitions (sometimes called Kohn-Sham
              transitions), that is transitions where a single
              electron is excited from an occupied Kohn-Sham orbital
              into a virtual orbital. The calculation of these
              transitions is configured in this section. Note that the
              SingleOrbTrans section is optional even though the
              single orbital transitions are also needed for TD-DFTB
              calculations. If the section is not present all single
              orbital transitions will still be calculated and used in
              a subsequent TD-DFTB calculation, but no output will be
              produced.

            * **TDDFTB** (*DFTB._Properties._Excitations._TDDFTB*) --
              Calculations with time-dependent DFTB can be configured
              in the TDDFTB section and should in general give better
              results than the raw single orbital transitions. TD-DFTB
              calculates the excitations in the basis of the single
              orbital transitions, whose calculation is configured in
              the SingleOrbTrans section. Using a filter in
              SingleOrbTrans can therefore be used to reduce the size
              of the basis for TD-DFTB. One possible application of
              this is to accelerate the calculation of electronic
              absorption spectra by removing single orbital
              transitions with small oscillator strengths from the
              basis. Note that the entire TDDFTB section is optional.
              If no TDDFTB section is found, the behavior depends on
              the existence of the SingleOrbTrans section: If no
              SingleOrbTrans section is found (the Excitations section
              is completely empty then) a TD-DFTB calculation with
              default parameters will be performed. If only the
              SingleOrbTrans section is present no TD-DFTB calculation
              will be done.

            * **TDDFTBGradients**
              (*DFTB._Properties._Excitations._TDDFTBGradients*) --
              This block configures the calculation of analytical
              gradients for the TD-DFTB excitation energies, which
              allows the optimization of excited state geometries and
              the calculation of vibrational frequencies in excited
              states (see J. Comput. Chem., 28: 2589-2601). If the
              gradients are calculated, they will automatically be
              used for geometry optimizations or vibrational frequency
              calculations, if the corresponding Task is selected and
              only 1 excitation is selected. Vibrationally resolved
              UV/Vis spectroscopy (Franck-Condon Factors) can be
              calculated in combination with the FCF program or using
              the Vibrational Analysis Tools in AMS. See the ADF
              documentation on Vibrationally resolved electronic
              spectra or the AMS documentation for the Vibrational
              Analysis Tools.

         class _SingleOrbTrans

            The simplest approximation to the true excitations are the
            single orbital transitions (sometimes called Kohn-Sham
            transitions), that is transitions where a single electron
            is excited from an occupied Kohn-Sham orbital into a
            virtual orbital. The calculation of these transitions is
            configured in this section. Note that the SingleOrbTrans
            section is optional even though the single orbital
            transitions are also needed for TD-DFTB calculations. If
            the section is not present all single orbital transitions
            will still be calculated and used in a subsequent TD-DFTB
            calculation, but no output will be produced.

            Variables:
               * **Enabled** (*BoolType** | **BoolKey*) -- Calculate
                 the single orbital transitions.

               * **PrintLowest** (*int** | **IntKey*) --

                 The number of single orbital transitions that are
                 printed to the screen and written to disk.

                 If not a TD-DFTB calculation, the default is to print
                 the 10 lowest single orbital transitions.

                 In case of a TD-DFTB calculation it is assumed that
                 the single orbital transitions are only used as an
                 input for TD-DFTB and nothing will be printed unless
                 PrintLowest is specified explicitly.

               * **Filter** (*DFTB._Properties._Excitations._SingleOr
                 bTrans._Filter*) -- This section allows to remove
                 single orbital transitions based on certain criteria.
                 All filters are disabled by default.

            class _Filter

               This section allows to remove single orbital
               transitions based on certain criteria. All filters are
               disabled by default.

               Variables:
                  * **MinPertCont** (*float** | **FloatKey*) -- The
                    energy range up to which SOTs are considered
                    primary in Grimme's sTDA based filter.

                  * **OSMin** (*float** | **FloatKey*) --

                    Removes single orbital transitions with an
                    oscillator strength smaller than this threshold.

                    A typical value to start (if used at all) would be
                    1.0e-3.

                  * **PrimRange** (*float** | **FloatKey*) -- The
                    energy range up to which SOTs are considered
                    primary in Grimme's sTDA based filter.

                  * **UsePertCorr** (*BoolType** | **BoolKey*) -- The
                    energy range up to which SOTs are considered
                    primary in Grimme's sTDA based filter.

                  * **dEMax** (*float** | **FloatKey*) -- Removes
                    single orbital transitions with an orbital energy
                    difference larger than this threshold.

                  * **dEMin** (*float** | **FloatKey*) -- Removes
                    single orbital transitions with an orbital energy
                    difference smaller than this threshold.

         class _TDDFTB

            Calculations with time-dependent DFTB can be configured in
            the TDDFTB section and should in general give better
            results than the raw single orbital transitions. TD-DFTB
            calculates the excitations in the basis of the single
            orbital transitions, whose calculation is configured in
            the SingleOrbTrans section. Using a filter in
            SingleOrbTrans can therefore be used to reduce the size of
            the basis for TD-DFTB. One possible application of this is
            to accelerate the calculation of electronic absorption
            spectra by removing single orbital transitions with small
            oscillator strengths from the basis. Note that the entire
            TDDFTB section is optional. If no TDDFTB section is found,
            the behavior depends on the existence of the
            SingleOrbTrans section: If no SingleOrbTrans section is
            found (the Excitations section is completely empty then) a
            TD-DFTB calculation with default parameters will be
            performed. If only the SingleOrbTrans section is present
            no TD-DFTB calculation will be done.

            Variables:
               * **ATChargeAnalysis** (*Literal**[**"Mulliken"**,
                 **"Loewdin"**]*) -- Which analysis method to use for
                 the calculation of the atomic transition charges.

               * **Calc** (*Literal**[**"None"**, **"Singlet"**,
                 **"Triplet"**]*) -- Specifies the multiplicity of the
                 excitations to be calculated.

               * **Diagonalization** (*Literal**[**"Auto"**,
                 **"Davidson"**, **"Exact"**]*) --

                 Select the method used to solve the TD-DFTB
                 eigenvalue equation.

                 The most straightforward procedure is a direct
                 diagonalization of the matrix from which the
                 excitation energies and oscillator strengths are
                 obtained. Since the matrix grows quickly with system
                 size (number of used single orbital transitions
                 squared), this option is possible only for small
                 molecules.

                 The alternative is the iterative Davidson method,
                 which finds a few of the lowest excitations within an
                 error tolerance without ever storing the full matrix.

                 The default is to make this decision automatically
                 based on the system size and the requested number of
                 excitations.

               * **Lowest** (*int** | **IntKey*) --

                 Specifies the number of excitations that are
                 calculated.

                 Note that in case of the exact diagonalization all
                 excitations are calculated, but only the lowest ones
                 are printed to screen and written to the output file.

                 Also note that if limited both by number and by
                 energy, (lowest and upto), DFTB will always use
                 whatever results in the smaller number of calculated
                 excitations.

               * **Print** (*str** | **StringKey*) -- Specifies
                 whether to print details on the contribution of the
                 individual single orbital transitions to the
                 calculated excitations.

               * **ScaleKernel** (*float** | **FloatKey*) --

                 Set the scaling parameter of the response kernel.

                 A scaling approach can be used to identify plasmons
                 in molecules. While single-particle excitations are
                 only slightly affected by scaling of the response
                 kernel, plasmonic excitations are sensitive to
                 variations in the scaling parameter. Default no
                 scaling is used (scaling parameter = 1.0)

               * **UpTo** (*float** | **FloatKey*) --

                 Set the maximum excitation energy.

                 Attempts to calculate all excitations up to a given
                 energy by calculating a number of excitations equal
                 to the number of single orbital transitions in this
                 window. This is only approximately correct, so one
                 should always add some safety margin.

                 Note that if limited both by number and by energy,
                 (lowest and upto), DFTB will always use whatever
                 results in the smaller number of calculated
                 excitations.

               * **DavidsonConfig** (*DFTB._Properties._Excitations._
                 TDDFTB._DavidsonConfig*) -- This section contains a
                 number of keywords that can be used to override
                 various internals of the Davidson eigensolver. The
                 default values should generally be fine.

            class _DavidsonConfig

               This section contains a number of keywords that can be
               used to override various internals of the Davidson
               eigensolver. The default values should generally be
               fine.

               Variables:
                  * **ATCharges** (*Literal**[**"Precalc"**,
                    **"OnTheFly"**]*) --

                    Select whether the atomic transition charges are
                    precalculated in advance or reevaluated during the
                    iterations of the Davidson solver.

                    Precalculating the charges will improve the
                    performance, but requires additional storage.

                    The default is to precalculate the atomic
                    transition charges, but the precalculation may be
                    disabled if not not enough memory is available.

                  * **SafetyMargin** (*int** | **IntKey*) -- The
                    number of eigenvectors the Davidson method will
                    calculate in addition to the ones requested by the
                    user. With the Davidson eigensolver it is
                    generally a good idea to calculate a few more
                    eigenvectors than needed, as depending on the
                    initial guess for the eigenvectors it can happen
                    that the found ones are not exactly the lowest
                    ones. This problem is especially prominent if one
                    wants to calculate only a small number of
                    excitations for a symmetric molecule, where the
                    initial guesses for the eigenvectors might have
                    the wrong symmetry. Note that the additionally
                    calculated excitations will neither be written to
                    the result file nor be visible in the output.

                  * **Tolerance** (*float** | **FloatKey*) --
                    Convergence criterion for the norm of the
                    residual.

         class _TDDFTBGradients

            This block configures the calculation of analytical
            gradients for the TD-DFTB excitation energies, which
            allows the optimization of excited state geometries and
            the calculation of vibrational frequencies in excited
            states (see J. Comput. Chem., 28: 2589-2601). If the
            gradients are calculated, they will automatically be used
            for geometry optimizations or vibrational frequency
            calculations, if the corresponding Task is selected and
            only 1 excitation is selected. Vibrationally resolved
            UV/Vis spectroscopy (Franck-Condon Factors) can be
            calculated in combination with the FCF program or using
            the Vibrational Analysis Tools in AMS. See the ADF
            documentation on Vibrationally resolved electronic spectra
            or the AMS documentation for the Vibrational Analysis
            Tools.

            Variables:
               * **Eigenfollow** (*BoolType** | **BoolKey*) -- If this
                 option is set, DFTB uses the transition density in
                 atomic orbital basis to follow the initially selected
                 excited state during a geometry optimization. This is
                 useful if excited state potential energy surfaces
                 cross each other and you want to follow the surface
                 you started on.

               * **Excitation** (*Iterable**[**int**] **|
                 **IntListKey*) --

                 Select which excited states to calculate the
                 gradients for.

                 Gradients can only be calculated for an excited
                 states that has been calculated using TD-DFTB. Make
                 sure that enough excitations are calculated.

      class _Fragments

         Fragment files

         Variables:
            * **Analysis** (*BoolType** | **BoolKey*) -- Mulliken
              population analysis in terms of fragment orbitals.

            * **EMax** (*float** | **FloatKey*) -- Upper end of the
              energy interval for which the orbitals are analyzed.

            * **Emin** (*float** | **FloatKey*) -- Lower end of the
              energy interval for which the orbitals are analyzed.

            * **File** (*str** | **StringKey*) -- Path (either
              absolute or relative) of fragment file

            * **TIDegeneracyThreshold** (*float** | **FloatKey*) -- If
              the orbital energy of the fragment MO is within this
              threshold with fragment HOMO or LUMO energy, then this
              fragment MO is included in the calculation of the
              transfer integrals. Relevant in case there is (near)
              degeneracy.

            * **TransferIntegrals** (*BoolType** | **BoolKey*) --

              Calculate the charge transfer integrals, spatial overlap
              integrals and site energies.

              Charge transfer integrals can be used in models that
              calculate transport properties.

      class _RESPONSE

         Linear response module to compute electric (complex)
         polarizabilities

         Variables:
            * **ATChargeAnalysis** (*Literal**[**"Mulliken"**,
              **"Loewdin"**]*) -- Which analysis method to use for the
              calculation of the atomic transition charges.

            * **Frequencies** (*Iterable**[**float**] **|
              **FloatListKey*) -- List of frequencies of incident
              light

            * **LifeTime** (*float** | **FloatKey*) --
              Phenomenological damping

            * **Solver** (*DFTB._Properties._RESPONSE._Solver*) --
              Solver details for CPKS

         class _Solver

            Solver details for CPKS

            Variables:
               * **Algorithm** (*Literal**[**"EXACT"**, **"ITER"**]*)
                 -- Choice of solver for CPKS

               * **Debug** (*BoolType** | **BoolKey*) -- Print
                 technical information from solver

               * **NumIt** (*int** | **IntKey*) -- Maximum number of
                 iterations (ITER solver only)

               * **RMSE** (*float** | **FloatKey*) -- Threshold for
                 convergence (ITER solver only)

   class _QMFQ

      Block input key for QM/(w)FQ(FMu).

      Variables:
         * **DEBUG** (*BoolType** | **BoolKey*) -- The DEBUG subkey
           will print additional information from the FQ subroutines.

         * **EFFECTIVEPOLAR** (*BoolType** | **BoolKey*) -- Calculate
           wFQ(Fmu)QM effective polarizability

         * **FDERESP** (*BoolType** | **BoolKey*) -- In response
           calculations (TD), the polarization contribution of the FDE
           part is introduced at the FQ level [See F. Egidi et al. J.
           Chem. Phys. 2021, 154, 164107].

         * **Forcefield** (*Literal**[**"FQ"**, **"FQ_RQ"**,
           **"FQFMU"**, **"FQFMU_RQRMU"**, **"NOPOL"**, **"wFQ"**,
           **"wFQ_RQ"**, **"wFQFmu"**, **"wFQFmu_RQRMU"**]*) --
           Version of the FQ family of polarizable forcefields

         * **Frozen** (*BoolType** | **BoolKey*) -- Expert option. Do
           not introduce polarization effect in response calculations.

         * **GROUNDSTATE** (*BoolType** | **BoolKey*) -- Introduce FQ
           effects on ground state calculations

         * **Kernel** (*Literal**[**"OHNO"**, **"COUL"**,
           **"GAUS"**]*) -- Expert option. KERNEL can be used to
           choose the functional form of the charge-charge interaction
           kernel between MM atoms. Recommended is to use the default
           OHNO. The COUL screening is the standard Coulomb
           interaction 1/r. The OHNO choice introduce the Ohno
           functional (see [K. Ohno, Theoret. Chim. Acta 2, 219
           (1964)]), which depends on a parameter n that is set equal
           to 2. Finally, the GAUS screening models each FQ charge by
           means of a spherical Gaussian-type distribution, and the
           interaction kernel is obtained accordingly. For QM/FQFMU
           only GAUS SCREEN is implemented.

         * **LifeFrequency** (*float** | **FloatKey*) -- Input
           frequency for calculating TDDFT/wFQ(Fmu) lifetimes

         * **LifeState** (*int** | **IntKey*) -- Target excited state
           for state-specific TDDFT/wFQ(Fmu) lifetimes

         * **MolCharge** (*float** | **FloatKey*) -- Total charge of
           each fragment (FQ only)

         * **NOGROUNDSTATE** (*BoolType** | **BoolKey*) -- Avoid
           introducing FQ effects on ground state calculations

         * **NOLOCALFIELD** (*BoolType** | **BoolKey*) -- Switch off
           wFQ(Fmu) local field effects in polarizability
           calculations.

         * **NonEle** (*Literal**[**"LJ"**, **"None"**]*) -- Whether
           to include non-electrostatic contributions to the energy.
           Default is the Lennard-Jones (LJ) model.

         * **QMSCREEN** (*Literal**[**"ERF"**, **"EXP"**, **"GAUS"**,
           **"NONE"**]*) -- Expert option. QMSCREEN can be used to
           choose the functional form of the charge-charge interaction
           kernel between MM atoms and the QM density. The screening
           types available are ERF (error function), EXP
           (exponential), GAUS (Gaussian), or NONE. The default is
           GAUS.

         * **QMSCREENFACTOR** (*float** | **FloatKey*) -- Expert
           option. Sets the QM/MM interaction kernel screening length.
           Recommended is to use the default value 0.2 with the GAUS
           QM/MM screening function.

         * **ReadDynamicMatrix** (*str** | **Path** | **StringKey*) --
           The absolute path to the decomposed wFQ(FMu) matrix file

         * **WriteDynamicMatrix** (*BoolType** | **BoolKey*) -- Write
           decomposed wFQ(Fmu) matrix as wFQMat_freq in a separate
           file.

         * **AtomType** (*DFTB._QMFQ._AtomType*) -- Definition of
           atomic types in MM environment

         * **Coords** (*str** | **Sequence**[**str**] **|
           **FreeBlock*) -- Coordinates and fragment information (FQ
           only)

         * **Repulsion** (*DFTB._QMFQ._Repulsion*) -- Definition of
           parameters for Pauli repulsion (see JCTC ....)

         * **Solver** (*DFTB._QMFQ._Solver*) --

      class _AtomType

         Definition of atomic types in MM environment

         Variables:
            * **Alpha** (*float** | **FloatKey*) -- Polarizability of
              FQFMU atom

            * **Area** (*float** | **FloatKey*) -- Effective charge-
              transfer area time between same-type wFQ atoms

            * **Charge** (*float** | **FloatKey*) -- MM fixed charge
              (non-polarizable only)

            * **Chi** (*float** | **FloatKey*) -- Electronegativity of
              FQ atom

            * **Dfermi** (*float** | **FloatKey*) -- wFQ d parameter
              for Fermi damping

            * **Efermi** (*float** | **FloatKey*) -- Fermi Energy of
              wFQ carbon-based structure

            * **Eta** (*float** | **FloatKey*) -- Chemical Hardness of
              FQ atom

            * **R0** (*float** | **FloatKey*) -- wFQ R0 parameter for
              Fermi damping

            * **RMU** (*float** | **FloatKey*) -- Variance for
              FQFMU_RQRMU Gaussians

            * **RQ** (*float** | **FloatKey*) -- Variance for FQ_RQ
              Gaussians

            * **Sfermi** (*float** | **FloatKey*) -- wFQ s parameter
              for Fermi damping

            * **Sigma0** (*float** | **FloatKey*) -- Static
              conductivity time of wFQ atom

            * **Symbol** (*str** | **StringKey*) -- Symbol associated
              with atom type

            * **Tau** (*float** | **FloatKey*) -- Scattering time of
              wFQ atom

            * **wFQFMuFile** (*str** | **Path** | **StringKey*) -- The
              absolute path to the wFQFMu interband polarizability
              file

      class _Coords

         Coordinates and fragment information (FQ only)

      class _Repulsion

         Definition of parameters for Pauli repulsion (see JCTC ....)

         Variables:
            * **AtomDistance** (*float** | **FloatKey*) -- Each
              fictitious Slater function is added only if the
              associated MM atom is closer than the AtomDistance
              threshold (in Angstrom) to a QM atom

            * **Basis** (*DFTB._QMFQ._Repulsion._Basis*) -- Slater
              type basis function to add on a specific atom type in
              the environment.

         class _Basis

            Slater type basis function to add on a specific atom type
            in the environment.

            Variables:
               * **AngMom** (*int** | **IntKey*) -- Angular momentum

               * **AtomType** (*str** | **StringKey*) -- Atom Type on
                 which the basis function has to be added

               * **Coeff** (*float** | **FloatKey*) -- Coefficient of
                 the basis function

               * **Exp** (*float** | **FloatKey*) -- Exponent of the
                 basis function

      class _Solver

         Variables:
            * **Algorithm** (*Literal**[**"DIRECT"**, **"ITER"**]*) --

            * **Debug** (*BoolType** | **BoolKey*) --

            * **NumIt** (*int** | **IntKey*) --

            * **THRESH** (*float** | **FloatKey*) --

   class _Repulsion

      Configures various details of the repulsive potential.

      Variables:
         **ForcePolynomial** (*BoolType** | **BoolKey*) -- Forces the
         use of the polynomial repulsion, even if a spline repulsion
         is present in the Slater-Koster files.

   class _SCC

      This optional section configures various details of the self-
      consistent charge cycle. If the model Hamiltonian does not need
      a self-consistent solution (e.g. plain DFTB0), none of this
      information is used and the entire section will be ignored.

      Variables:
         * **AdaptiveMixing** (*BoolType** | **BoolKey*) -- Change the
           mixing parameter based on the monitored energy. A
           significant increase of energy will strongly reduce the
           mixing. Then it will slowly grow back to the SCC%Mixing
           value.

         * **AdaptiveMixingStrategy** (*int** | **IntKey*) --
           Currently there are three flavors, 1, 2, and 3. The first
           is the most conservative. The difference between 2 and 3 is
           that number 3 decreases the mixing when the energy seems to
           go up.

         * **AlwaysClaimConvergence** (*BoolType** | **BoolKey*) --
           Even if the SCC does not converge, claim convergence.

         * **HXDamping** (*BoolType** | **BoolKey*) -- This option
           activates the DFTB3 style damping for H-X bonds. Note that
           this is always enabled if the DFTB%Model key is set to
           DFTB3. Not used with xTB.

         * **InheritMixFromPreviousResult** (*BoolType** | **BoolKey*)
           -- For some run types, such as GeometryOptimization, a
           previous result is available. By using the charges from the
           previous geometry a better initial guess for the SCC
           procedure may be obtained. Also the last mix factor from
           the previous result can be loaded, possibly speeding up the
           SCC.

         * **Iterations** (*int** | **IntKey*) --

           Allows to specify the maximum number of SCC iterations. The
           default should suffice for most standard calculations.

           Convergence issues may arise due to the use of the Aufbau
           occupations for systems with small HOMO-LUMO gaps. In this
           case the use of a Fermi broadening strategy may improve
           convergence.

           Choosing a smaller mixing parameter (see DFTB%SCC%Mixing)
           may also help with convergence issues: it often provides a
           more stable but slower way to converge the SCC cycle.

         * **Method** (*Literal**[**"DIIS"**, **"MultiStepper"**]*) --
           The DIIS option is the old method. The MultiStepper is much
           more flexible and is controlled by the SCFMultiSolver block

         * **MinimumAdaptiveMixingFactor** (*float** | **FloatKey*) --
           In case of AdaptiveMixing the lower bound for the
           MixingFactor.

         * **MultiStepperPresetPath** (*str** | **Path** |
           **StringKey*) -- Name of file containing a SCFMultiStepper
           key block. This will be used if no Explicit SCFMultiStepper
           block is in the input, and Method=MultiStepper. If the path
           is not absolute, it is relative to
           $AMSHOME/data/presets/multi_stepper'

         * **OrbitalDependent** (*BoolType** | **BoolKey*) --
           Activates or disables orbital resolved calculations. If
           this key is absent the recommended settings from the
           parameter file's metainfo.

         * **PrintIterationDetails** (*BoolType** | **BoolKey*) --
           Print nIterationsGlobal, etc. to standard output.

         * **SpinOrbit** (*BoolType** | **BoolKey*) -- test

         * **Unrestricted** (*BoolType** | **BoolKey*) --

           Enables spin unrestricted calculations.

           Only collinear spin polarization is supported, see Theor
           Chem Acc (2016) 135: 232, for details.

           Must be supported by the chosen parameter set. Not yet
           compatible with DFTB3, k-space sampling periodic
           calculations or the xTB models.

         * **Converge** (*DFTB._SCC._Converge*) -- Controls the
           convergence criteria of the SCC cycle.

         * **DIIS** (*DFTB._SCC._DIIS*) -- Parameters influencing the
           DIIS self-consistency method

         * **SCFMultiStepper** (*DFTB._SCC._SCFMultiStepper*) -- To
           solve the self-consistent problem multiple steppers can be
           tried during stints using the ones that give the best
           progress.

      class _Converge

         Controls the convergence criteria of the SCC cycle.

         Variables:
            * **Charge** (*float** | **FloatKey*) -- The maximum
              change in atomic charges between subsequent SCC
              iterations. If the charges change less, the SCC cycle is
              considered converged.

            * **Norm** (*Literal**[**"L2"**, **"L-Infinity"**]*) --
              The LInfinity norm is the more stringent choice. The L2
              norm is directly what is optimized by the DIIS
              procedure, it is scaled by the extra constant factor
              2/sqrt(nAtoms).

      class _DIIS

         Parameters influencing the DIIS self-consistency method

         Variables:
            * **Enabled** (*BoolType** | **BoolKey*) -- If not enabled
              simple mixing without DIIS acceleration will be used.

            * **MaxSamples** (*int** | **IntKey*) -- Specifies the
              maximum number of samples considered during the direct
              inversion of iteration of subspace (DIIS) extrapolation
              of the atomic charges during the SCC iterations. A
              smaller number of samples potentially leads to a more
              aggressive convergence acceleration, while a larger
              number often guarantees a more stable iteration. Due to
              often occurring linear dependencies within the set of
              sample vectors, the maximum number of samples is reached
              only in very rare cases.

            * **MaximumCoefficient** (*float** | **FloatKey*) -- When
              the diis expansion coefficients exceed this threshold,
              the solution is rejected. The vector space is too
              crowded. The oldest vector is discarded, and the
              expansion is re-evaluated.

            * **MinSamples** (*int** | **IntKey*) -- When bigger than
              one, this affects the shrinking of the DIIS space on
              linear dependence. It will not reduce to a smaller space
              than MinSamples unless there is extreme dependency.

            * **MixingFactor** (*float** | **FloatKey*) -- The
              parameter used to mix the DIIS linear combination of
              previously sampled atomic charge vectors with an
              analogous linear combination of charge vectors resulting
              from population analysis combination. It can assume real
              values between 0 and 1.

      class _SCFMultiStepper

         To solve the self-consistent problem multiple steppers can be
         tried during stints using the ones that give the best
         progress.

         Variables:
            * **AlwaysChangeStepper** (*BoolType** | **BoolKey*) --
              When the progress is fine there is no reason to change
              the stepper. In practice this is always set to true,
              because also the Stepper%ExpectedSlope can be used to
              achieve similar behavior.

            * **ErrorGrowthAbortFactor** (*float** | **FloatKey*) --
              Abort stint when the error grows too much, compared to
              the error at the start of the stint.

            * **FractionalStepFactor** (*float** | **FloatKey*) --
              Multiply the step by this factor. If smaller than zero
              this is not used.

            * **MinStintCyclesForAbort** (*int** | **IntKey*) -- Look
              at ErrorGrowthAbortFactor only when a number of steps
              has been completed since the start of the stint. A value
              of  0 means always.

            * **StintLength** (*int** | **IntKey*) -- A stepper is
              active during a number of SCF cycles, called a stint.

            * **UsePreviousStintForErrorGrowthAbort** (*BoolType** |
              **BoolKey*) -- The error is normally checked against the
              first error of the stint. With this option that will be
              the one from the previous stint, if performed with the
              same stepper.

            * **Stepper** (*DFTB._SCC._SCFMultiStepper._Stepper*) --

              ??

         class _Stepper

            ??

            Variables:
               * **AbortSlope** (*float** | **FloatKey*) -- If the
                 slope (at the end of a stint) is larger than this:
                 abort the stepper

               * **AlwaysAbortAtBeginOfStint** (*BoolType** |
                 **BoolKey*) -- For debugging only: no matter what
                 abort this stepper at the begin of the stint (doing
                 only one step).

               * **AlwaysAbortAtEndOfStint** (*BoolType** |
                 **BoolKey*) -- For debugging only: no matter what
                 abort this stepper at the end of the stint.

               * **ErrorGrowthAbortFactor** (*float** | **FloatKey*)
                 -- Abort stint when the error grows too much,
                 compared to the error at the start of the stint.
                 Overrides global ErrorGrowthAbortFactor when set to a
                 value > 0

               * **ExpectedSlope** (*float** | **FloatKey*) -- If the
                 slope of the total SCF is better than this keep on
                 going.

               * **FractionalStepFactor** (*float** | **FloatKey*) --
                 Multiply the step by this factor. If smaller than
                 zero this is not used.

               * **InitialMixFromPreviousStint** (*BoolType** |
                 **BoolKey*) -- Similar to MixFromPreviousStint, but
                 only done the first time that a stepper is used.

               * **MaxInitialError** (*float** | **FloatKey*) -- Only
                 use the stepper when error is smaller than this.

               * **MaxIterationNumber** (*int** | **IntKey*) --
                 Stepper will only be active for iterations smaller
                 than this number. (Negative value means: Ignore this
                 option)

               * **MaxStintNumber** (*int** | **IntKey*) -- Stepper
                 will only be active for stints smaller than this
                 number. (Negative value means: Ignore this option)

               * **MaxStints** (*int** | **IntKey*) -- Maximum number
                 of stints that a stepper should be used.

               * **MinInitialError** (*float** | **FloatKey*) -- Only
                 use the stepper when error is larger than this.

               * **MinIterationNumber** (*int** | **IntKey*) --
                 Stepper will only be active for iterations larger
                 than this number.

               * **MinStintCyclesForAbort** (*int** | **IntKey*) --
                 Look at ErrorGrowthAbortFactor only when a number of
                 steps has been completed since the start of the
                 stint. A value of  0 means always. Overrides global
                 value.

               * **MinStintNumber** (*int** | **IntKey*) -- Stepper
                 will only be active for stints larger than this
                 number.

               * **MixFromPreviousStint** (*BoolType** | **BoolKey*)
                 -- When starting a new stint use the mix from the
                 previous stepper, even if it is of another type.

               * **StintLength** (*int** | **IntKey*) -- Override
                 global StintLength.

               * **DIISStepper**
                 (*DFTB._SCC._SCFMultiStepper._Stepper._DIISStepper*)
                 -- DIIS stepper

               * **MixAdapter**
                 (*DFTB._SCC._SCFMultiStepper._Stepper._MixAdapter*)
                 -- Generic mix adapter

               * **MixStepper**
                 (*DFTB._SCC._SCFMultiStepper._Stepper._MixStepper*)
                 -- Simple mixing stepper, only using the previous
                 (in/out) density.

               * **MultiSecantStepper** (*DFTB._SCC._SCFMultiStepper.
                 _Stepper._MultiSecantStepper*) -- Multi secant
                 stepper.

            class _DIISStepper

               DIIS stepper

               Variables:
                  * **EDIIS** (*BoolType** | **BoolKey*) -- Use energy
                    DIIS. The energy is used as extra info and only
                    interpolation is done (all coefficients in the
                    interval [0,1]).

                  * **EDIISAlpha** (*float** | **FloatKey*) -- The
                    extra energy vector is weighed by this factor. .

                  * **MaxBMatrixRange** (*float** | **FloatKey*) -- If
                    larger than zero: limit the ratio between the
                    oldest and last diagonal B matrix element.

                  * **MaxCoefficient** (*float** | **FloatKey*) -- The
                    largest allowed value of the expansion
                    coefficients. If exceed the number of vectors is
                    reduces until the criterion is met.

                  * **MaxConditionNumber** (*float** | **FloatKey*) --
                    If larger than zero: check condition number of the
                    B matrix. If too large reduce nVectors.

                  * **MaxVectors** (*int** | **IntKey*) -- Maximum
                    number of previous densities to be used (size of
                    the history).

                  * **MinLastCoefficient** (*float** | **FloatKey*) --
                    If larger than zero: If the most recent vector
                    gets a (abs) coefficient smaller than this the mix
                    is boosted.

                  * **MinVectors** (*int** | **IntKey*) -- Try to
                    prevent to make nVectors shrink below this value,
                    by allowing for significantly larger coefficients.

                  * **Mix** (*float** | **FloatKey*) -- Also known as
                    greed. It determines the amount of output density
                    to be used. May be changed by the MixAdapter.

                  * **RescaleBMatrix** (*BoolType** | **BoolKey*) --
                    Rescale the B matrix so that is's values are of
                    the same order as those of the constraints.

                  * **UseHalfMixForFirstCycle** (*BoolType** |
                    **BoolKey*) -- Use half the mix factor at
                    iteration 1 (if applicable).

            class _MixAdapter

               Generic mix adapter

               Variables:
                  * **CorrelateMixWithSlope** (*BoolType** |
                    **BoolKey*) -- For the last two mixing factors the
                    one with the best slope is preferred.

                  * **ErrorGrowthPanicFactor** (*float** |
                    **FloatKey*) -- When the error increases more than
                    this factor, this mix is reduced a lot.

                  * **GrowWhenSpaceGrows** (*BoolType** | **BoolKey*)
                    -- Has only effect when the error goes down.  If
                    nVectors increases grow the mix factor, otherwise
                    do not change the mix

                  * **GrowthFactor** (*float** | **FloatKey*) -- When
                    the mix is considered too low it is multiplied by
                    this factor. Otherwise it is divided by it.

                  * **MaxMix** (*float** | **FloatKey*) -- Do not grow
                    the mix above this value.

                  * **MinMix** (*float** | **FloatKey*) -- Do not
                    shrink the mix below this value.

                  * **NTrialMixFactors** (*int** | **IntKey*) -- Only
                    used with Type=Trial. Must be an odd number.

                  * **TrialMode**
                    (*Literal**[**"CurrentMixCentered"**,
                    **"FullRange"**]*) -- How are the NTrialMixFactors
                    chosen?

                  * **Type** (*Literal**[**"Error"**, **"Energy"**,
                    **"UnpredictedStep"**, **"Trial"**]*) -- Adapt the
                    mix factor based on the observed progress (slope).

            class _MixStepper

               Simple mixing stepper, only using the previous (in/out)
               density.

               Variables:
                  **Mix** (*float** | **FloatKey*) -- ???.

            class _MultiSecantStepper

               Multi secant stepper.

               Variables:
                  * **AlphaMSR1** (*float** | **FloatKey*) -- For the
                    MSR1 variant:  W = Y + alpha S.

                  * **MaxCoefficient** (*float** | **FloatKey*) --
                    ???.

                  * **MaxConditionNumber** (*float** | **FloatKey*) --
                    If set larger than zero this condition number of
                    the matrix to be inverted will be checked. If
                    exceeded the space is reduced.

                  * **MaxVectors** (*int** | **IntKey*) -- ???.

                  * **Mix** (*float** | **FloatKey*) -- ???.

                  * **PredictGreed** (*BoolType** | **BoolKey*) -- Try
                    to predict the optimal greed.

                  * **ScaleYTY** (*BoolType** | **BoolKey*) -- Scale
                    matrix before inversion

                  * **SigmaRegularize** (*float** | **FloatKey*) --
                    Prevent division by zero by adding a small number.
                    Makes most sense when using renormalization.

                  * **Variant** (*Literal**[**"MSB1"**, **"MSB2"**,
                    **"MSR1"**, **"MSR1s"**]*) -- There are several
                    version of the Multi secant method.

   class _Solvation

      Generalized Born solvation model with Solvent Accessible Surface
      Area (GBSA).

      Variables:
         * **GSolvState** (*Literal**[**"Gas1BarSolvent"**,
           **"Gas1MSolvent1M"**, **"Gas1BarSolvent1M"**]*) --
           Reference state for solvation free energy shift.

         * **Solvent** (*Literal**[**"None"**, **"Acetone"**,
           **"Acetonitrile"**, **"Benzene"**, **"CH2Cl2"**,
           **"CHCl3"**, **"CS2"**, **"DMSO"**, **"Ether"**, **"H2O"**,
           **"Methanol"**, **"THF"**, **"Toluene"**]*) -- Solvent used
           in the GBSA implicit solvation model.

         * **SurfaceGrid** (*Literal**[**"230"**, **"974"**,
           **"2030"**, **"5810"**]*) -- Number of angular grid points
           for the construction of the solvent accessible surface
           area. Usually the default number of grid point suffices,
           but in case of suspicious behaviors you can increase the
           number of points.

         * **Temperature** (*float** | **FloatKey*) -- The temperature
           used when calculating the solvation free energy shift. Only
           used for 'Gas1BarSolvent' and 'Gas1BarSolvent1M' GSolvState
           options.

         * **UseGSASA** (*BoolType** | **BoolKey*) -- Include shift
           term and G(SASA) terms in the energy and gradient.

   class _Technical

      This optional section is about technical aspects of the program
      that should not concern the normal user.

      Variables:
         * **AnalyticalStressTensor** (*BoolType** | **BoolKey*) --
           Whether to compute the stress tensor analytically. Note:
           This can only be used together with Ewald summation as it
           will give (slightly) wrong results with Madelung screening.

         * **AssumeInsulator** (*BoolType** | **BoolKey*) -- (Expert
           option) Assume that the material has only fully occupied
           bands. Only relevant for periodic structures. If you know
           the material is an insulator this can be a bit faster. Use
           with care.

         * **MatricesViaFullMaxSize** (*int** | **IntKey*) -- Matrices
           smaller than this size are constructed via a full matrix.
           This is faster, but uses more memory in the construction.

         * **ReuseKSpaceConfig** (*BoolType** | **BoolKey*) -- Keep
           the number of k-points constant during a lattice
           optimization. Otherwise the PES might display jumps,
           because the number of points depends on the lattice vector
           sizes. If this option is on it will always use the number
           of k-points that was used from a previous result.

         * **UseGeneralizedDiagonalization** (*BoolType** |
           **BoolKey*) -- Whether or not to use generalized
           diagonalization. Does not affect the results, but might be
           faster or slower.

         * **EwaldSummation** (*DFTB._Technical._EwaldSummation*) --
           Configures the details of the Ewald summation of the
           Coulomb interaction.

         * **Parallel** (*DFTB._Technical._Parallel*) -- Calculation
           of the orbitals in several k-points is trivially parallel.

         * **Screening** (*DFTB._Technical._Screening*) -- For SCC-
           DFTB in periodic systems the Coulomb interaction can
           (instead of using Ewald summation) be screened with a
           Fermi-Dirac like function defined as
           S(r)=1/(exp((r-r_madel)/d_madel)+1). This section allows to
           change some details of the screening procedure. Note that
           Coulomb screening is only used if the Ewald summation is
           disabled.

      class _EwaldSummation

         Configures the details of the Ewald summation of the Coulomb
         interaction.

         Variables:
            * **CellRangeFactor** (*float** | **FloatKey*) -- Smaller
              values will make the Ewald summation less accurate but
              faster.

            * **Enabled** (*BoolType** | **BoolKey*) -- Whether to use
              Ewald summation for the long-range part of the Coulomb
              interaction. Otherwise screening is used.

            * **Tolerance** (*float** | **FloatKey*) -- Larger values
              will make the Ewald summation less accurate but faster.

      class _Parallel

         Calculation of the orbitals in several k-points is trivially
         parallel.

         Variables:
            * **nCoresPerGroup** (*int** | **IntKey*) -- Number of
              cores in each working group.

            * **nGroups** (*int** | **IntKey*) -- Total number of
              processor groups. This is the number of tasks that will
              be executed in parallel.

            * **nNodesPerGroup** (*int** | **IntKey*) -- Number of
              nodes in each group. This option should only be used on
              homogeneous compute clusters, where all used compute
              nodes have the same number of processor cores.

      class _Screening

         For SCC-DFTB in periodic systems the Coulomb interaction can
         (instead of using Ewald summation) be screened with a Fermi-
         Dirac like function defined as
         S(r)=1/(exp((r-r_madel)/d_madel)+1). This section allows to
         change some details of the screening procedure. Note that
         Coulomb screening is only used if the Ewald summation is
         disabled.

         Variables:
            * **DirectionalScreening** (*BoolType** | **BoolKey*) --

            * **dMadel** (*float** | **FloatKey*) -- Sets the
              smoothness of the screening function. The default is
              1/10 of [rMadel].

            * **rMadel** (*float** | **FloatKey*) -- Sets the range of
              the screening function. The default is 2x the norm of
              the longest lattice vector.

   class _XTBConfig

      This block allows for minor tweaking.

      Variables:
         * **SlaterRadialThreshold** (*float** | **FloatKey*) --
           Threshold determining the range of the basis functions.
           Using a larger threshold will speed up the calculation, but
           will also make the results less accurate.

         * **useXBTerm** (*BoolType** | **BoolKey*) -- Whether to use
           the Halogen bonding (XB) term. This is not advised as it
           has a non-continuous PES.

class External

   Variables:
      * **Execute** (*str** | **StringKey*) -- The command to execute
        to run the external engine. The command is executed in a
        temporary subdirectory to the results directory.

      * **ExecuteAtEnd** (*str** | **StringKey*) -- The command to
        execute after the last calculation (e.g. after the final step
        of a geometry optimization). This can, for example, be used to
        run a custom analysis tool, or to stop a background process.
        The command is executed in the results directory.

      * **InputDefinition** (*str** | **Path** | **StringKey*) -- The
        JSON file containing the definition of the input for the
        external engine.

      * **Input** (*str** | **Sequence**[**str**] **| **FreeBlock*) --
        The text input of the engine. This has to match with the JSON
        input definition set with the InputDefinition keyword.

      * **Supports** (*External._Supports*) -- Specifies the
        capabilities of the external engine.

   class _Input

      The text input of the engine. This has to match with the JSON
      input definition set with the InputDefinition keyword.

   class _Supports

      Specifies the capabilities of the external engine.

      Variables:
         * **DipoleMoment** (*BoolType** | **BoolKey*) -- Whether the
           external engine can calculate dipole moments.

         * **NonSpecificSystems** (*BoolType** | **BoolKey*) --
           Whether the engine can handle calculating any system in any
           order, or if it is restricted to a single system and only
           supports changes in the geometry. Engines that only handle
           a specific system can not be used for tasks such as GCMC,
           MD calculations with insertions (molecule gun), or
           numerical phonon calculations.

         * **PeriodicityBulk** (*BoolType** | **BoolKey*) -- Whether
           the external engine supports 3D periodic systems.

         * **PeriodicityChain** (*BoolType** | **BoolKey*) -- Whether
           the external engine supports 1D periodic systems, i.e.
           chains.

         * **PeriodicityNone** (*BoolType** | **BoolKey*) -- Whether
           the external engine supports non-periodic systems, i.e.
           molecules.

         * **PeriodicitySlab** (*BoolType** | **BoolKey*) -- Whether
           the external engine supports 2D periodic systems, i.e.
           slabs.

class ForceField

   Variables:
      * **AllowMissingParameters** (*BoolType** | **BoolKey*) -- When
        parameters are not found for bonds, angles, dihedrals, or
        inversions, the first entry in the database will be used.

      * **AntechamberIntegration** (*BoolType** | **BoolKey*) --
        EXPERIMENTAL: Use the Antechamber program to automatically
        determine atom types for the GAFF force field. This may run a
        geometry optimization with MOPAC under the hood in order to
        determine the charges (see keyword AntechamberTask), which
        might not work for very large systems.

      * **AntechamberTask** (*Literal**[**"GeometryOptimization"**,
        **"SinglePoint"**]*) -- If antechamber is invoked to guess
        atomtypes and charges (GAFF force field), select the task for
        charge guessing with MOPAC

      * **BondsUsage** (*Literal**[**"Input"**, **"None"**,
        **"Guess"**, **"Auto"**]*) -- Controls what bonds are used by
        the engine. The choice auto means: guess in case there are no
        bonds. Guessing only happens at the first MD step, or first
        geometry optimization step.

      * **CheckDuplicateRules** (*BoolType** | **BoolKey*) -- The
        database could contain duplicate entries. For torsions this is
        a feature, and the potentials will be added. For all other
        terms this is no allowed, and if detected the program stops.
        One should fix the database or set the checking to false. As
        always the last entry will be used.

      * **DipoleConvergenceThreshold** (*float** | **FloatKey*) --
        Convergence criterion for induced point dipoles, in atomic
        units. When the length of every atomic delta_mu vector between
        two iterations becomes below the tolerance, the procedure is
        considered converged.

      * **DoChargeCheck** (*BoolType** | **BoolKey*) -- Check that the
        sum of atomic (partial) charges equals the total charge of the
        system.

      * **EngineConstraints** (*BoolType** | **BoolKey*) -- Set to
        false to ignore constraints implied by the engine.

      * **ForceFieldFile** (*str** | **Path** | **StringKey*) -- Path
        to the force field parameter file

      * **ForceFieldPatchFile** (*str** | **Path** | **StringKey*) --
        Present for backwards compatibility. Path to the force field
        patch parameter file (additional parameters, missing from main
        file). Cannot be used when atomtypes are guessed.

      * **GuessCharges** (*BoolType** | **BoolKey*) -- Use another
        engine to calculate/guess the charges to be used by the force
        field.

      * **KeepAntechamberFolder** (*BoolType** | **BoolKey*) -- If
        atom-typing is performed with antechamber, keep the folder
        after the call to antechamber

      * **LinearizationEnergyForRepulsion** (*float** | **FloatKey*)
        -- The Lennard-Jones potential becomes extremely repulsive at
        short distances. The distance is determined where the
        potential reaches this threshold, for smaller distances a
        linear expression is used, reducing the repulsion.

      * **NeighborListSkin** (*float** | **FloatKey*) -- Thickness of
        the buffer region added to the NonBondedCutoff when building a
        neighbor list.

      * **NonBondedCutoff** (*float** | **FloatKey*) --

        Distance beyond which the non-bonded pair interactions
        (Coulomb and Van der Waals) will be ignored.

        The interactions are smoothly damped starting from
        0.9*NonBondedCutoff.

        Has no effect on the Coulomb term for 3D-periodic systems, as
        Ewald summation is used.

      * **PairInteractionTapering** (*Literal**[**"None"**,
        **"Potential"**, **"Force"**, **"CHARMM"**, **"CHARMM-
        Force"**]*) --

        Select a method for smoothing non-bonded pair interactions in
        the distance range between 90% and 100% of the
        [NonBondedCutoff] to avoid energy and force jump near the
        cutoff.

        Potential - use a 7th order polynomial switching function that
        has zero 1st, 2nd and 3rd derivatives at both ends of the
        interval (force matches the energy derivative). Force - the
        same switching function is applied both to the potential and
        the force (so the force does not match the energy), which may
        break the total energy conservation during MD. CHARMM - use a
        different polynomial that does not have a decaying 2nd
        derivative at NonBondedCutoff. CHARMM-Force - use the same
        switching function as CHARMM but apply it both to the energy
        and the forces.

      * **PerformanceHacks** (*BoolType** | **BoolKey*) -- This
        enables various hacks in the Forcefield engine to boost its
        performance. These hacks break the AMS driver <-> engine
        contract and will therefore not work with the vast majority of
        tasks in AMS. This keyword is used internally by some
        workflows in the Amsterdam Modeling Suite, where SCM has
        tested and confirmed the correctness of the results.

      * **ReuseTypeInfo** (*str** | **Path** | **StringKey*) -- Path
        to RKF file with atom typing information (atom types, charges,
        and - in case of GAFF or APPLE&P - possibly a forcefield
        (patch) file for the system).

      * **TaperPairInteractions** (*BoolType** | **BoolKey*) -- Smooth
        non-bonded pair interactions in the distance range between 90%
        and 100% of the [NonBondedCutoff] to avoid energy and force
        jump near the cutoff. See PairInteractionTapering for more
        precise tuning.

      * **Type** (*Literal**[**"UFF"**, **"Amber95"**, **"GAFF"**,
        **"Tripos5.2"**, **"APPLE&P"**, **"UserDefined"**]*) -- Type
        of force field to be used

      * **Verbosity** (*Literal**[**"Silent"**, **"Normal"**,
        **"Verbose"**, **"VeryVerbose"**]*) -- Controls the verbosity
        of the engine.

      * **APPLE&P** (*ForceField._APPLE&P*) -- Options for the APPLE&P
        force field.

      * **EnergyTerms** (*ForceField._EnergyTerms*) -- expert key,
        that allows you to disable specific energy terms.

      * **EwaldSummation** (*ForceField._EwaldSummation*) --
        Configures the details of the particle mesh Ewald (PME)
        summation of the Coulomb interaction.

      * **GAFF** (*ForceField._GAFF*) -- Specific keywords for the
        GAFF force field type

      * **GuessChargesConfig** (*ForceField._GuessChargesConfig*) --
        Guess charges to be used by the forcefield

      * **LAMMPSOffload** (*ForceField._LAMMPSOffload*) -- Offload the
        calculation to LAMMPS via AMSPipe.

      * **LoadCharges** (*ForceField._LoadCharges*) -- Load charges
        from a file to be used as forcefield charges

      * **SoftCorePotentials** (*ForceField._SoftCorePotentials*) --
        When performing free energy perturbation the LJ interactions
        must be scaled by lambda. To avoid numerical instabilities at
        small lambda, soft-core potentials need to be used (see
        DOI:10.1021/ct900587b).

      * **UFF** (*ForceField._UFF*) -- Option for the UFF force filed.

   class _APPLE_AND_P

      Options for the APPLE&P force field.

      Variables:
         * **LongRangeCorrection** (*BoolType** | **BoolKey*) --

           Add a long-range dispersion correction to the energy and
           pressure for 3D-periodic systems.

           This correction should be enabled only for a homogeneous
           liquid.

         * **MuMu14Scaling** (*float** | **FloatKey*) -- Scaling
           factor for dipole-dipole interactions between atoms
           connected to 3rd order (via a dihedral).

         * **QMu14Scaling** (*float** | **FloatKey*) -- Scaling factor
           for charge-dipole interactions between atoms connected to
           3rd order (via a dihedral).

         * **QQ14Scaling** (*float** | **FloatKey*) -- Scaling factor
           for charge-charge interactions between atoms connected to
           3rd order (via a dihedral).

         * **RD14Scaling** (*float** | **FloatKey*) -- Scaling factor
           for repulsion/dispersion interactions between atoms
           connected to 3rd order (via a dihedral).

         * **TholeParam** (*float** | **FloatKey*) -- (UNUSED)
           Parameter for the exponential Thole screening for the
           induced dipole-dipole interactions.

         * **ForceFieldParameters** (*str** | **Sequence**[**str**]
           **| **FreeBlock*) -- Forcefield parameter text block,
           provided as alternative to the general ForceFieldFile
           keyword. Will be ignored if ForceFieldFile keyword is also
           present.

      class _ForceFieldParameters

         Forcefield parameter text block, provided as alternative to
         the general ForceFieldFile keyword. Will be ignored if
         ForceFieldFile keyword is also present.

   class _EnergyTerms

      expert key, that allows you to disable specific energy terms.

      Variables:
         * **Angle** (*BoolType** | **BoolKey*) -- Whether to use
           angle (bend) energy.

         * **Coulomb** (*BoolType** | **BoolKey*) -- Whether to use
           coulomb energy.

         * **Dispersion** (*BoolType** | **BoolKey*) -- Whether to use
           dispersion energy.

         * **Inversion** (*BoolType** | **BoolKey*) -- Whether to use
           inversion energy.

         * **Stretch** (*BoolType** | **BoolKey*) -- Whether to use
           stretch energy.

         * **Torsion** (*BoolType** | **BoolKey*) -- Whether to use
           torsion energy.

   class _EwaldSummation

      Configures the details of the particle mesh Ewald (PME)
      summation of the Coulomb interaction.

      Variables:
         * **Alpha** (*float** | **FloatKey*) -- This parameter shifts
           the workload from real space (smaller alpha) to reciprocal
           space (larger alpha). Using a larger [Alpha] without
           decreasing [GridSpacing] may increase the error in the
           reciprocal-space contribution. Set to zero to disable the
           reciprocal-space Ewald part. Negative value means the
           [Alpha] will be determined automatically from the
           [Tolerance] and [RealSpaceCutoff] values.

         * **Enabled** (*BoolType** | **BoolKey*) -- Set to false to
           use real-space pair summation instead of the Ewald, which
           is the default and the only option for molecules, 1D and 2D
           periodic systems.

         * **GridSpacing** (*float** | **FloatKey*) -- Grid spacing in
           the particle mesh Ewald method. Smaller grid spacing will
           make the reciprocal energy calculation more accurate but
           slower. Using a larger [Alpha] value may require a smaller
           GridSpacing to be accurate.

         * **RealSpaceCutoff** (*float** | **FloatKey*) -- Set the
           cutoff value for the real-space summation. Zero means the
           internal defaults will be used depending on the [Alpha] (if
           Alpha=0 then the cutoff will be set to 50 Bohr, otherwise
           to 20 Bohr).

         * **Tolerance** (*float** | **FloatKey*) -- Value of the
           error function that should be used to determine the cutoff
           radius for real-space Ewald summation if [Alpha] is set on
           input. Alternatively, if the [RealSpaceCutoff] is set but
           [Alpha] is not then the [Tolerance] value affects the
           [Alpha]. Larger values will make the real-space summation
           faster but less accurate.

   class _GAFF

      Specific keywords for the GAFF force field type

      Variables:
         * **ForceFieldPatchFile** (*str** | **Path** | **StringKey*)
           -- Path to the force field patch parameter file (additional
           parameters, missing from main file). Cannot be used when
           atomtypes are guessed.

         * **AtomTyping** (*ForceField._GAFF._AtomTyping*) -- Specific
           keywords for automatic atom typing for the GAFF force field
           type

         * **ForceFieldParameters** (*str** | **Sequence**[**str**]
           **| **FreeBlock*) -- Parameter file text in AMBER format
           with (additional parameters, missing from main file).
           Alternative option to ForceFieldPatchFile. The parameter
           patches provided by antechamber can be used here. Cannot be
           used when atomtypes are guessed.

      class _AtomTyping

         Specific keywords for automatic atom typing for the GAFF
         force field type

         Variables:
            * **AntechamberIntegration** (*BoolType** | **BoolKey*) --
              EXPERIMENTAL: Use the Antechamber program to
              automatically determine atom types for the GAFF force
              field. This may run a geometry optimization with MOPAC
              under the hood in order to determine the charges (see
              keyword AntechamberTask), which might not work for very
              large systems.

            * **AntechamberTask**
              (*Literal**[**"GeometryOptimization"**,
              **"SinglePoint"**]*) -- If antechamber is invoked to
              guess atomtypes and charges (GAFF force field), select
              the task for charge guessing with MOPAC

            * **KeepAntechamberFolder** (*BoolType** | **BoolKey*) --
              If atom-typing is performed with antechamber, keep the
              folder after the call to antechamber

            * **MolecularCharge**
              (*ForceField._GAFF._AtomTyping._MolecularCharge*) --
              Defines a (set of) submolecule(s) with their charge, to
              be Used in GAFF atomtyping.

         class _MolecularCharge

            Defines a (set of) submolecule(s) with their charge, to be
            Used in GAFF atomtyping.

            Variables:
               * **Charge** (*float** | **FloatKey*) -- Molecular
                 charge of submolecule(s) defined in Region.

               * **Region** (*str** | **StringKey*) -- Region name
                 that defines a (set of) submolecule(s).

      class _ForceFieldParameters

         Parameter file text in AMBER format with (additional
         parameters, missing from main file). Alternative option to
         ForceFieldPatchFile. The parameter patches provided by
         antechamber can be used here. Cannot be used when atomtypes
         are guessed.

   class _GuessChargesConfig

      Guess charges to be used by the forcefield

      Variables:
         **EngineType** (*str** | **StringKey*) -- Engine that can
         calculate or guess charges

   class _LAMMPSOffload

      Offload the calculation to LAMMPS via AMSPipe.

      Variables:
         * **Enabled** (*BoolType** | **BoolKey*) -- Enable offloading
           the force field evaluation to LAMMPS instead of handling it
           internally in AMS. This is currently only supported for
           Type=UFF.

         * **UseGPU** (*BoolType** | **BoolKey*) -- Accelerate LAMMPS
           calculations using a GPU. Requires a LAMMPS library built
           with the GPU package.

         * **UseGPUForKSpace** (*BoolType** | **BoolKey*) -- When
           UseGPU is enabled, also use the GPU to accelerate
           reciprocal space electrostatic interactions. Disabling this
           can improve performance on less powerful GPUs.

         * **UseGPUForNeighbor** (*BoolType** | **BoolKey*) -- When
           UseGPU is enabled, also use the GPU to accelerate neighbor
           searches. Disabling this can improve performance on less
           powerful GPUs.

         * **UseOpenMP** (*BoolType** | **BoolKey*) -- Parallelize
           LAMMPS calculations using OpenMP threading. Requires a
           LAMMPS library built with the OMP package.

         * **WorkerCommand** (*str** | **StringKey*) -- The command to
           execute to run the external worker. The command is executed
           in a subdirectory of the results directory. The LAMMPS
           input commands will be passed to the worker on standard
           input.

         * **Input** (*str** | **Sequence**[**str**] **| **FreeBlock*)
           -- Commands to be passed to LAMMPS to set up the
           calculation. If this is left empty, AMS will generate a set
           of commands to set LAMMPS up according to the settings of
           the ForceField engine. Any LAMMPS commands entered in this
           input block will be used to set LAMMPS up instead of those
           generated by AMS. To merge the AMS-generated lines with
           your customizations, include lines like 'AMS
           somelammpskeyword' anywhere in this block. Any such line
           will be replaced by the AMS-generated line for
           'somelammpskeyword'. Any text after 'somelammpskeyword'
           will be appended to the generated line verbatim, which can
           be used to modify the generated command by additional
           options. A special line 'AMS everything' will be replaced
           by the entire block of AMS-generated commands, except those
           overridden anywhere in this input block (defined manually
           or inserted using 'AMS somelammpskeyword'. Any customized
           Input block should probably include 'AMS read_data' near or
           at the end to load the AMS-generated data file defining the
           system.

      class _Input

         Commands to be passed to LAMMPS to set up the calculation. If
         this is left empty, AMS will generate a set of commands to
         set LAMMPS up according to the settings of the ForceField
         engine. Any LAMMPS commands entered in this input block will
         be used to set LAMMPS up instead of those generated by AMS.
         To merge the AMS-generated lines with your customizations,
         include lines like 'AMS somelammpskeyword' anywhere in this
         block. Any such line will be replaced by the AMS-generated
         line for 'somelammpskeyword'. Any text after
         'somelammpskeyword' will be appended to the generated line
         verbatim, which can be used to modify the generated command
         by additional options. A special line 'AMS everything' will
         be replaced by the entire block of AMS-generated commands,
         except those overridden anywhere in this input block (defined
         manually or inserted using 'AMS somelammpskeyword'. Any
         customized Input block should probably include 'AMS
         read_data' near or at the end to load the AMS-generated data
         file defining the system.

   class _LoadCharges

      Load charges from a file to be used as forcefield charges

      Variables:
         * **File** (*str** | **StringKey*) -- Name of the (kf) file

         * **Section** (*str** | **StringKey*) -- Section name of the
           kf file

         * **Variable** (*str** | **StringKey*) -- variable name of
           the kf file

   class _SoftCorePotentials

      When performing free energy perturbation the LJ interactions
      must be scaled by lambda. To avoid numerical instabilities at
      small lambda, soft-core potentials need to be used (see
      DOI:10.1021/ct900587b).

      Variables:
         * **Alpha** (*float** | **FloatKey*) -- This parameter
           determines how far the soft-core potential deviates from
           the scaled regular LJ potential (at zero the expression is
           a regular LJ expression).

         * **Enabled** (*BoolType** | **BoolKey*) -- Set to True to
           use the scaled soft-core LJ potentials.

         * **Lambda** (*float** | **FloatKey*) -- The scaling
           parameter for the LJ interaction term for free energy
           perturbation (the window).

   class _UFF

      Option for the UFF force filed.

      Variables:
         * **AtomTypesFile** (*str** | **StringKey*) -- Expert option:
           Select the file that defines how UFF determines the atom
           types

         * **Database** (*str** | **StringKey*) -- Expert option:
           Select the file that defines the UFF parameters per atom
           type

         * **ElementsFile** (*str** | **StringKey*) -- Expert option:
           Select the file that defines the elements known to UFF

         * **IgnoreInputBonds** (*BoolType** | **BoolKey*) --
           Developer option: Ignore the bonds from the input. This
           mean UFF will either reuse bonds from a previous result, or
           will guess the bonds.

         * **Library** (*Literal**[**"UFF"**, **"UFF4MOF"**,
           **"UFF4MOF-II"**]*) -- Selects the used parameter library.

class GFNFF

   Variables:
      * **Accuracy** (*float** | **FloatKey*) -- Expert option: GFNFF
        accuracy parameter. Several thresholds within GFNFF depend on
        this accuracy parameter. Must be a positive number. Smaller
        values of Accuracy will result in larger distance thresholds.

      * **EwaldTolerance** (*float** | **FloatKey*) -- Expert option:
        Value of the error function that should be used to determine
        the cutoff radius for real-space Ewald summation if [Alpha] is
        set on input. Alternatively, if the [RealSpaceCutoff] is set
        but [Alpha] is not then the [Tolerance] value affects the
        [Alpha]. Larger values will make the real-space summation
        faster but less accurate.

      * **ForceFieldFile** (*str** | **StringKey*) -- Path to a GFNFF
        parameter file

      * **Type** (*Literal**[**"AngewChem2020"**,
        **"AngewChem2020_1"**, **"AngewChem2020_2"**,
        **"Harmonic2020"**, **"FromFile"**]*) -- Type of GFNFF to be
        used

      * **EnergyTerms** (*GFNFF._EnergyTerms*) -- expert key, that
        allows you to disable specific energy terms.

   class _EnergyTerms

      expert key, that allows you to disable specific energy terms.

      Variables:
         * **Angle** (*BoolType** | **BoolKey*) -- Whether to use
           angle (bend) energy.

         * **BondedATM** (*BoolType** | **BoolKey*) -- Whether to use
           bonded ATM energy.

         * **Coulomb** (*BoolType** | **BoolKey*) -- Whether to use
           coulomb energy.

         * **Dispersion** (*BoolType** | **BoolKey*) -- Whether to use
           dispersion energy.

         * **ElectricField** (*BoolType** | **BoolKey*) -- Whether to
           use external electric field energy.

         * **HBonding** (*BoolType** | **BoolKey*) -- Whether to use
           hydrogen bonding energy.

         * **Repulsion** (*BoolType** | **BoolKey*) -- Whether to use
           the repulsion energy.

         * **Solvation** (*BoolType** | **BoolKey*) -- Whether to use
           solvation energy.

         * **Stretch** (*BoolType** | **BoolKey*) -- Whether to use
           stretch energy.

         * **Torsion** (*BoolType** | **BoolKey*) -- Whether to use
           torsion energy.

         * **XBonding** (*BoolType** | **BoolKey*) -- Whether to use
           halogen bonding energy.

class Hybrid

   Variables:
      * **AllowSanityCheckWarnings** (*BoolType** | **BoolKey*) --
        Sanity checks will be performed on the setup. If this option
        is on, only warnings are printed. If not the program will stop
        on warnings.

      * **GuessAttributesOnce** (*BoolType** | **BoolKey*) -- If any
        ForceField subengines are defined, and if automatic atom
        typing is possible, then the atom typing is done at the level
        of the Hybrid engine, and not of the ForceField subengines.
        This ensures that the same atom types and charges are used in
        each subsystem, so that pair energy terms that should cancel,
        will cancel. If set to False, then for each energy term the
        atom types and charges of the subsystem will be determined
        separately.

      * **RestartSubEngines** (*BoolType** | **BoolKey*) -- Save all
        the results of the subengines and pass those in a next
        geometry step or MD step.

      * **TweakRequestForSubEngines** (*BoolType** | **BoolKey*) --
        Only request what is really needed, gradients and charges.

      * **Capping** (*Hybrid._Capping*) -- This block is about capping
        details. Capping occurs with hydrogen atoms when a bond is
        broken between an atom inside the region and one outside.

      * **Committee** (*Hybrid._Committee*) -- Settings for using the
        hybrid engine as a committee. The factors and region for each
        engine must be the same. When committee is enabled the
        standard deviation is also reported as the uncertainty.

      * **Energy** (*Hybrid._Energy*) -- This block is there to
        construct the energy.

      * **Engine** (*EngineBlock*) -- The input for the computational
        (sub) engine. The header of the block determines the type of
        the engine. An optional second word in the header serves as
        the EngineID, if not present it defaults to the engine name.
        Currently it is not allowed to have a Hybrid engine as a sub
        engine.

      * **QMMM** (*Hybrid._QMMM*) -- This block is there to identify
        the QMMM engines.

   class _Capping

      This block is about capping details. Capping occurs with
      hydrogen atoms when a bond is broken between an atom inside the
      region and one outside.

      Variables:
         * **AllowHighBondOrders** (*BoolType** | **BoolKey*) --
           Allows capping of interregional aromatic, double and triple
           bonds. This is normally not a good idea, since the capping
           is done with hydrogen atoms.

         * **AtomicInfoForCappingAtom** (*str** | **StringKey*) -- The
           AtomicInfo for the capping atoms. Typically a string like
           ForceField.Type=X much like forcefield info is entered in
           the System block for normal atoms.

         * **CappingElement** (*str** | **StringKey*) -- The element
           to be used for capping. The hydrogen atom has the advantage
           that it is very small.

         * **CheckCapping** (*BoolType** | **BoolKey*) -- The same
           outside atom can be involved in multiple capping coordinate
           definitions. This is not a good idea, and this will not be
           accepted by using this check.

         * **Distance** (*float** | **FloatKey*) -- A negative value
           means automatic. In that case the sum of covalent radii is
           used

         * **Option** (*Literal**[**"Fractional"**, **"Fixed"**]*) --

           The capping atom is always along the broken bond vector.

           The bond distance between the capping atom and the two
           atoms are obtained from covalent radii, let us call them
           D1H and D2H.

           With option=Fractional the capping is on the bond vector
           with the fraction D1H/(D1H+D2H).

           With the Fixed option it at the distance D1H from atom 1. A
           distance of zero always means the coordinate of the inside
           atom.

   class _Committee

      Settings for using the hybrid engine as a committee. The factors
      and region for each engine must be the same. When committee is
      enabled the standard deviation is also reported as the
      uncertainty.

      Variables:
         **Enabled** (*BoolType** | **BoolKey*) -- Enable committee

   class _Energy

      This block is there to construct the energy.

      Variables:
         * **DynamicFactors** (*Literal**[**"Default"**,
           **"UseLowestEnergy"**, **"UseHighestEnergy"**]*) -- Default
           - use factors as set in the corresponding Term blocks;
           UseLowestEnergy - set all factors to 0 except for that of
           the engine with the lowest energy, which is set to 1;
           UseHighestEnergy - set all factors to 0 except for that of
           the engine with the highest energy, which is set to 1.  The
           last two options make sense only for non-QMMM hybrid
           calculation (that is, if the QMMM block is not present) and
           only when using engines whose energies can be compared
           directly.

         * **Term** (*Hybrid._Energy._Term*) -- This block is there to
           construct the energy term. Can have multiple occurrences

      class _Term

         This block is there to construct the energy term. Can have
         multiple occurrences

         Variables:
            * **Charge** (*float** | **FloatKey*) -- Net charge to be
              used for this energy term.

            * **EngineID** (*str** | **StringKey*) -- Identifier for
              the engine

            * **Factor** (*float** | **FloatKey*) --

            * **PBC** (*BoolType** | **BoolKey*) -- If the full system
              has a periodic lattice, apply it to the region

            * **Region** (*str** | **StringKey*) -- Identifier for the
              region

            * **UseCappingAtoms** (*BoolType** | **BoolKey*) --
              Whether to use capping for broken bonds

   class _Engine

      The input for the computational (sub) engine. The header of the
      block determines the type of the engine. An optional second word
      in the header serves as the EngineID, if not present it defaults
      to the engine name. Currently it is not allowed to have a Hybrid
      engine as a sub engine.

   class _QMMM

      This block is there to identify the QMMM engines.

      Variables:
         * **Embedding** (*Literal**[**"Mechanical"**,
           **"Electrostatic"**]*) --

           Determines how the QM region is embedded into the MM
           region.

           Mechanical embedding embedding can also be achieved using
           the Energy%Terms keywords, but the common case of a two
           region mechanical QM/MM embedding is easier to set up using
           this keyword.

         * **MMCharge** (*float** | **FloatKey*) -- Net charge to be
           used for the MM region.

         * **MMEngineID** (*str** | **StringKey*) -- Identifier for
           the MM engine

         * **MMEngineIsPolarizable** (*BoolType** | **BoolKey*) --
           Whether or not the MM engine has dynamic charges (for now
           not supported at all).

         * **QMCharge** (*float** | **FloatKey*) -- Net charge to be
           used for the QM region.

         * **QMEngineID** (*str** | **StringKey*) -- Identifier for
           the QM engine

         * **QMRegion** (*str** | **StringKey*) -- Identifier for the
           QM region. The rest of the system is considered the MM
           region.

         * **UseCappingAtoms** (*BoolType** | **BoolKey*) -- Whether
           to use capping for broken bonds.

class LennardJones

   Variables:
      * **Cutoff** (*float** | **FloatKey*) -- The distance at which
        the interaction is truncated.

      * **Eps** (*float** | **FloatKey*) -- The depth of the potential
        well.

      * **RMin** (*float** | **FloatKey*) -- The distance of the
        potential minimum.

class MLPotential

   Variables:
      * **Backend** (*Literal**[**"FAIRChem"**, **"M3GNet"**,
        **"MACE"**, **"NequIP"**, **"TorchANI"**]*) -- The machine
        learning potential backend.

      * **Device** (*Literal**[**""**, **"cpu"**, **"cuda:0"**,
        **"cuda:1"**, **"mps"**]*) --

        Device on which to run the calculation (e.g. cpu, cuda:0).

        If empty, the device can be controlled using environment
        variables for TensorFlow or PyTorch.

      * **MLDistanceUnit** (*Literal**[**"Auto"**, **"angstrom"**,
        **"bohr"**]*) -- Unit of distances expected by the ML backend
        (not the ASE calculator). The ASE calculator may require this
        information.

      * **MLEnergyUnit** (*Literal**[**"Auto"**, **"Hartree"**,
        **"eV"**, **"kcal/mol"**, **"kJ/mol"**]*) -- Unit of energy
        output by the ML backend (not the unit output by the ASE
        calculator). The ASE calculator may require this information.

      * **Model** (*Literal**[**"Custom"**, **"AIMNet2-B973c"**,
        **"AIMNet2-wB97MD3"**, **"ANI-1ccx"**, **"ANI-1x"**, **"ANI-
        2x"**, **"eSEN-S-Con-OMol"**, **"M3GNet-UP-2022"**, **"MACE-
        MP-0-Large"**, **"MACE-MP-0-Medium"**, **"MACE-MP-0-Small"**,
        **"MACE-MPA-0"**, **"UMA-S-1.2-OC20"**, **"UMA-S-1.2-OC22"**,
        **"UMA-S-1.2-OC25"**, **"UMA-S-1.2-ODAC"**,
        **"UMA-S-1.2-OMat"**, **"UMA-S-1.2-OMC"**,
        **"UMA-S-1.2-OMol"**]*) --

        Select a pre-parameterized or custom model.

        AIMNet2-(wB97MD3/B973c): best for fast calculations of small,
        drug-like molecules; limited to aperiodic systems of 14
        elements (H, B, C, N, O, F, Si, P, S, Cl, As, Se, Br, I).

        ANI-(1x/1ccx/2x): best for very fast calculations of organic
        molecules; limited to elements H, C, N, O (ANI-1x/1ccx), F, S,
        Cl (ANI-2x).

        eSEN-S-Con-OMol: best for highly accurate calculations of
        diverse organic and bio-relevant molecules; not intended for
        calculations on periodic inorganic bulk materials.

        M3GNet-UP-2022: best for fast calculations of inorganic
        crystalline materials; not designed for accurately modeling
        small organic molecules or biomolecules.

        MACE-MP-0-(Small/Medium/Large): best for accurate periodic
        calculations of inorganic materials; size trades
        speed/accuracy; not designed for accurately modeling small
        organic molecules or biomolecules. MACE-MPA-0 has improved
        accuracy vs MP-0.

        UMA-S-1.2 variants: best for high accuracy calculations on a
        broad range of systems; choose from OC20 (adsorption and
        surface chemistry), OC22 (oxide catalysis), OC25
        (electrocatalysis), ODAC (adsorption in porous frameworks),
        OMat (inorganic materials), OMC (organic molecular crystals),
        OMol (molecules, biomolecules, metal complexes, electrolytes);
        can be computationally expensive compared to other, more
        targeted models.

        Set Custom to choose a backend and provide your own
        parameters.

      * **NumThreads** (*str** | **StringKey*) --

        Number of threads.

        If not empty, OMP_NUM_THREADS will be set to this number; for
        PyTorch-engines, torch.set_num_threads() will be called.

      * **ParameterDir** (*str** | **Path** | **StringKey*) -- Path to
        a set of parameters for the backend, if it expects to read
        from a directory.

      * **ParameterFile** (*str** | **Path** | **StringKey*) -- Path
        to a set of parameters for the backend, if it expects to read
        from a file.

      * **UnpairedElectrons** (*int** | **IntKey*) -- The number of
        unpaired electrons in the system for a spin unrestricted
        calculation. The spin multiplicity is taken as this value plus
        one.

      * **Unrestricted** (*BoolType** | **BoolKey*) -- Enables spin
        unrestricted calculations, passing spin information to the
        machine learning model. Only applicable to 'UMA-S-1.2-OMol',
        'eSEN-S-Con-OMol' and custom FAIRChem models.

      * **FAIRChem** (*MLPotential._FAIRChem*) -- Options for the
        FAIRChem machine learning potential backend.

      * **MACE** (*MLPotential._MACE*) -- Options for the MACE machine
        learning potential backend.

      * **Member** (*MLPotential._Member*) -- Specify the details of a
        member of a committee.

   class _FAIRChem

      Options for the FAIRChem machine learning potential backend.

      Variables:
         **ModelTask** (*str** | **StringKey*) -- Model task to use if
         a custom UMA/eSEN model is supplied via a parameter file
         (e.g. 'OC20', 'OC22', 'OC25', 'ODAC', 'OMat', 'OMC', 'OMol').
         Ignored if a specific FAIRChem model is selected.

   class _MACE

      Options for the MACE machine learning potential backend.

      Variables:
         * **DataType** (*Literal**[**"float32"**, **"float64"**]*) --
           Using "float32" is faster but less accurate, and generally
           recommended for MD. Conversely using "float64" is slower
           but more accurate, and recommended for geometry
           optimization.

         * **EnableCuEquivariance** (*BoolType** | **BoolKey*) --
           Enable CUDA-accelerated cuEquivariance library for
           equivariant neural networks, if CUDA available.

         * **ModelHead** (*str** | **StringKey*) -- Model head to use
           if a custom MACE model is supplied via a parameter file
           (e.g. 'omat_pbe', 'omol', 'spice_wB97M', 'ωB97M-D3(BJ)',
           'rgd1_b3lyp', 'oc20_usemppbe', 'matpes_r2scan'). Ignored if
           a specific MACE model is selected.

   class _Member

      Specify the details of a member of a committee.

      Variables:
         * **ParameterDir** (*str** | **Path** | **StringKey*) -- Path
           to a set of parameters for the backend, if it expects to
           read from a directory.

         * **ParameterFile** (*str** | **Path** | **StringKey*) --
           Path to a set of parameters for the backend, if it expects
           to read from a file.

class Mopac

   Variables:
      * **CalcLocalOrbitals** (*BoolType** | **BoolKey*) -- Compute
        and print the localized orbitals, also known as Natural Bond
        Orbitals (NBO). This is equivalent to the LOCAL mopac keyword.

      * **Debug** (*BoolType** | **BoolKey*) -- Extra debug printing.

      * **Keywords** (*str** | **StringKey*) -- A string containing
        all the desired custom MOPAC keywords. Basically for anything
        not directly supported through AMS.

      * **Model** (*Literal**[**"AM1"**, **"MNDO"**, **"MNDOD"**,
        **"PM3"**, **"RM1"**, **"PM6"**, **"PM6-D3"**, **"PM6-DH+"**,
        **"PM6-DH2"**, **"PM6-DH2X"**, **"PM6-D3H4X"**, **"PM7"**]*)
        --

        Selects the model Hamiltonian to use in the calculation.

        AM1: Use the AM1 Hamiltonian.
           MNDO: Use the MNDO Hamiltonian. MNDOD: Use the MNDO-d
           Hamiltonian. RM1: Use the RM1 Hamiltonian. PM3: Use the
           MNDO-PM3 Hamiltonian. PM6: Use the PM6 Hamiltonian. PM6-D3:
           Use the PM6 Hamiltonian with Grimme's D3 corrections for
           dispersion. PM6-DH+: Use the PM6 Hamiltonian with
           corrections for dispersion and hydrogen-bonding. PM6-DH2:
           Use the PM6 Hamiltonian with corrections for dispersion and
           hydrogen-bonding. PM6-DH2X: Use PM6 with corrections for
           dispersion and hydrogen and halogen bonding. PM6-D3H4: Use
           PM6 with Rezac and Hobza's D3H4 correction. PM6-D3H4X: Use
           PM6 with Brahmkshatriya, et al.'s D3H4X correction. PM7:
           Use the PM7 Hamiltonian. PM7-TS: Use the PM7-TS Hamiltonian
           (only for barrier heights)

      * **Mozyme** (*BoolType** | **BoolKey*) -- Replace the standard
        SCF procedure with a localized molecular orbital (LMO) method.
        The time required for an SCF cycle when Mozyme is used scales
        linearly with system size.

      * **Sparkles** (*BoolType** | **BoolKey*) -- Represent
        lanthanides by their fully ionized 3+ sparkles. That is, they
        have no basis set, and therefore cannot have a charge
        different from +3. When using sparkles, the geometries of the
        lanthanides are reproduced with good accuracy, but the heats
        of formation and electronic properties are not accurate.

      * **UnpairedElectrons** (*int** | **IntKey*) -- If this key is
        present, a spin-unrestricted calculation with the specified
        number of unpaired electrons is performed. If this key is not
        present the number of unpaired electrons is determined
        automatically (0 for systems with an even number of electrons,
        1 for radicals), and a restricted or unrestricted calculation
        is performed accordingly.

      * **Properties** (*Mopac._Properties*) -- MOPAC can calculate
        various properties of the simulated system. This block
        configures which properties will be calculated.

      * **SCF** (*Mopac._SCF*) -- Options for the self-consistent
        field procedure.

      * **Solvation** (*Mopac._Solvation*) -- Options for the COSMO
        (Conductor like Screening Model) solvation model.

   class _Properties

      MOPAC can calculate various properties of the simulated system.
      This block configures which properties will be calculated.

      Variables:
         * **StaticPolarizability** (*BoolType** | **BoolKey*) --
           Calculate the static polarizability. An electric field
           gradient is applied to the system, and the response is
           calculated. The dipole and polarizability are calculated
           two different ways, from the change in heat of formation
           and from the change in dipole. A measure of the imprecision
           of the calculation can be obtained by comparing the two
           quantities.

         * **pKa** (*BoolType** | **BoolKey*) -- If requested, the pKa
           of hydrogen atoms attached to oxygen atoms is calculated
           and printed.

   class _SCF

      Options for the self-consistent field procedure.

      Variables:
         * **CampKingConverger** (*BoolType** | **BoolKey*) -- Use the
           Camp-King SCF converger. This is a very powerful, but CPU
           intensive, SCF converger.

         * **ConvergenceThreshold** (*float** | **FloatKey*) -- If the
           difference in energy between two successive SCF iterations
           is smaller than this value, the SCF procedure is considered
           converged.

         * **MaxIterations** (*int** | **IntKey*) -- Maximum number of
           SCF iterations.

   class _Solvation

      Options for the COSMO (Conductor like Screening Model) solvation
      model.

      Variables:
         * **Enabled** (*BoolType** | **BoolKey*) -- Use the Conductor
           like Screening Model (COSMO) to include solvent effects.

         * **NSPA** (*Literal**[**"12"**, **"32"**, **"42"**,
           **"92"**, **"122"**, **"162"**, **"252"**, **"272"**,
           **"362"**, **"482"**, **"492"**, **"642"**, **"752"**]*) --
           Maximum number of COSMO surface points per atom.

         * **Solvent** (*Mopac._Solvation._Solvent*) -- Solvent
           details

      class _Solvent

         Solvent details

         Variables:
            * **Eps** (*float** | **FloatKey*) -- User-defined
              dielectric constant of the solvent (overrides the Eps
              value of the solvent defined in 'Name')

            * **Name** (*Literal**[**"CRS"**, **"AceticAcid"**,
              **"Acetone"**, **"Acetonitrile"**, **"Ammonia"**,
              **"Aniline"**, **"Benzene"**, **"BenzylAlcohol"**,
              **"Bromoform"**, **"Butanol"**, **"isoButanol"**,
              **"tertButanol"**, **"CarbonDisulfide"**,
              **"CarbonTetrachloride"**, **"Chloroform"**,
              **"Cyclohexane"**, **"Cyclohexanone"**,
              **"Dichlorobenzene"**, **"DiethylEther"**,
              **"Dioxane"**, **"DMFA"**, **"DMSO"**, **"Ethanol"**,
              **"EthylAcetate"**, **"Dichloroethane"**,
              **"EthyleneGlycol"**, **"Formamide"**, **"FormicAcid"**,
              **"Glycerol"**, **"HexamethylPhosphoramide"**,
              **"Hexane"**, **"Hydrazine"**, **"Methanol"**,
              **"MethylEthylKetone"**, **"Dichloromethane"**,
              **"Methylformamide"**, **"Methypyrrolidinone"**,
              **"Nitrobenzene"**, **"Nitrogen"**, **"Nitromethane"**,
              **"PhosphorylChloride"**, **"IsoPropanol"**,
              **"Pyridine"**, **"Sulfolane"**, **"Tetrahydrofuran"**,
              **"Toluene"**, **"Triethylamine"**,
              **"TrifluoroaceticAcid"**, **"Water"**]*) -- Name of a
              pre-defined solvent. A solvent is characterized by the
              dielectric constant (Eps) and the solvent radius (Rad).

            * **Rad** (*float** | **FloatKey*) -- User-defined radius
              of the solvent molecule (overrides the Rad value of the
              solvent defined in 'Name').

class Pipe

   Variables:
      **WorkerCommand** (*str** | **StringKey*) -- The command to
      execute to run the external worker. The command is executed in a
      subdirectory of the results directory.

class QuantumESPRESSO

   Variables:
      * **CheckInputIncompatibilities** (*BoolType** | **BoolKey*) --
        Performs a preliminary check for incompatible input parameters
        before starting the calculation. If any inconsistencies are
        detected (e.g., attempting a Raman calculation with spin
        polarization), the program will stop and report the error.
        This helps to avoid wasted time and resources by identifying
        potential issues early on.

      * **K_PointsLabels** (*str** | **StringKey*) -- You can provide
        labels for your k-points, like "L-GAMMA-X-U-GAMMA", separating
        each label with a hyphen (-) or a vertical bar (|). For
        example, "L-GAMMA-X-U-GAMMA" and "L|GAMMA|X|U|GAMMA" are both
        valid. These labels are optional and only used for display
        purposes when the "K_Points" block is specified. This option
        is used only if the header of the "K_Points" block is not
        "ams_kpath". **Important:** These labels do not determine the
        actual k-point coordinates. You must specify the k-point
        coordinates separately within the "K_Points" section.

      * **KeepDataFiles** (*BoolType** | **BoolKey*) -- If 'False' the
        program will perform the following actions at the end of the
        calculation: 1) Remove the 'prefix.qein' file, which serves as
        the QE input file, 2) Delete the output data stored in the
        'prefix.xml' file, and 3) Clear the contents of the
        'prefix.save' directory. If you require further details,
        please refer to the QE user manual in the 'Data Files'
        section. It provides comprehensive information on the specific
        files and their functionalities. In particular, these files
        are needed to calculate the bands structure and DOS.

      * **UseBondingEnergy** (*BoolType** | **BoolKey*) -- When
        enabled, the calculation engine uses the bonding energy
        (energy difference between the molecule and its constituent
        atoms) instead of the total energy. This facilitates
        comparisons of relative stability between molecular
        configurations. Atomic energies are consistently computed
        using Gamma-point sampling, Gaussian smearing (degauss =
        0.01), and spin-restricted (nSpin = 1) settings within a cubic
        lattice of 8 angstrom side length to approximate their
        spherically symmetric ground states. All other parameters for
        the atomic calculations remain the same as those used for the
        molecular system.

      * **AVERAGE_X** (*QuantumESPRESSO._AVERAGE_X*) -- This section
        configures the parameters for running the QE-utility
        "average.x". This utility reads files produce by produced by
        "pp.x" and compute planar and macroscopic averages of a
        quantity (e.g. charge) in real space on a 3D FFT mesh.

      * **BandStructure** (*QuantumESPRESSO._BandStructure*) --

        This section configures the parameters for calculating the
        Band Structure. This involves utilizing the following
        utilities:

        * "kpath": This AMS tool generates an automated high-symmetry
          k-path in the Brillouin zone.

        * "pw.x" (with calculation=bands): This utility from Quantum
          ESPRESSO (QE) performs electronic structure calculations,
          particularly for bands. For more details see https://www
          .quantum-espresso.org/Doc/INPUT_PW.html

        * "bands.x": Another QE utility, which calculates the band
          structure. For more details see https://www.quantum-
          espresso.org/Doc/INPUT_BANDS.html.

      * **Control** (*QuantumESPRESSO._Control*) -- Keywords from the
        &CONTROL namelist in the QuantumEspresso input file.

      * **DOS** (*QuantumESPRESSO._DOS*) --

        This section configures the parameters for calculating the
        Density of States (DOS). These are the utilities involved:

        * "kpath": This AMS tool generates an automated high-symmetry
          k-path in the Brillouin zone.

        * "pw.x" (with "calculation=nscf"): This Quantum ESPRESSO (QE)
          utility conducts electronic structure calculations,
          specifically for the non-self-consistent field (nscf)
          computation.

        * "dos.x": A QE utility utilized for post-processing
          electronic structure calculations. It analyzes the
          electronic wavefunctions obtained from preceding
          calculations to determine the density of available
          electronic states at different energy levels. For more
          details see https://www.quantum-
          espresso.org/Doc/INPUT_DOS.html

        * "projwfc.x": Another QE utility employed for post-processing
          electronic structure calculations. It projects the
          wavefunctions onto atomic orbitals or basis sets, offering
          insights into the composition and character of electronic
          states. For more details see https://www.quantum-
          espresso.org/Doc/INPUT_PROJWFC.html

        By default, the calculation sequence follows the order: "kpath
        -> pw.x(calculation=nscf) -> dos.x". However, enabling
        "DOS%PDOS" switches the calculation to use "projwfc.x" instead
        of "dos.x". While common parameters can be customized directly
        in this section, specialized adjustments should be made in
        either the "DOS_X" or "PROJWFC_X" section, depending on
        specific requirements.

      * **DOS_X** (*QuantumESPRESSO._DOS_X*) -- This section
        configures the parameters for running the QE-utility "dos.x"
        (see https://www.quantum-espresso.org/Doc/INPUT_DOS.html).
        This utility calculates the Density of States (DOS), separated
        into up and down components for DSDA.

      * **DYNMAT_X** (*QuantumESPRESSO._DYNMAT_X*) -- This section
        configures the parameters for running the QE utility
        *dynmat.x* (see https://www.quantum-
        espresso.org/Doc/INPUT_DYNMAT.html). This utility is used to
        ???

      * **Electrons** (*QuantumESPRESSO._Electrons*) -- Keywords from
        the &ELECTRONS namelist in the QuantumEspresso input file.

      * **Hubbard** (*str** | **Sequence**[**str**] **| **FreeBlock*)
        --

        Specify parameters for DFT+U models. The type of Hubbard
        projectors to use (e.g. "atomic" or "ortho-atomic") is
        specified in the header of this block. Example input:

           Hubbard ortho-atomic
               U Fe-3d 3.0
            End

        More examples can be found in the documentation.

      * **HubbardU** (*QuantumESPRESSO._HubbardU*) -- Specify
        parameters for DFT+U Models.

      * **K_Points** (*str** | **Sequence**[**str**] **| **FreeBlock*)
        -- Specify the k-points to use. Available header values are:
        "tpiba", "automatic", "crystal", "gamma", "tpiba_b",
        "crystal_b", "tpiba_c", "crystal_c", and "ams_kpath". See the
        examples and QE documentation for details. If omitted, only
        "gamma" is used. For most cases, "automatic" (which generates
        a Monkhorst-Pack grid) is recommended. Note: Gamma-point
        calculations are significantly faster using "gamma" than
        "automatic", but may not be possible to use for all types of
        calculations or postprocessing programs.

      * **MATDYN_X** (*QuantumESPRESSO._MATDYN_X*) -- This section
        configures the parameters for running the QE utility
        *matdyn.x* (see https://www.quantum-
        espresso.org/Doc/INPUT_MATDYN.html). This utility is used to
        calculate various phonon-related properties from the real-
        space interatomic force constants (IFC) produced by *q2r.x*.
        These properties include phonon dispersion curves, phonon
        density of states (DOS), thermodynamic properties (e.g., free
        energy, entropy), and more.

      * **MagneticAnisotropyEnergy**
        (*QuantumESPRESSO._MagneticAnisotropyEnergy*) --

        This option computes the Magnetic Anisotropy Energy (MAE)
        using the Force Theorem approximation [see Phys. Rev. B 90,
        205409 (2014)]. The calculation follows this procedure:

        * Run SCF (no SOC): First, perform a standard Self-Consistent
          Field (SCF) calculation without Spin-Orbit Coupling (SOC).
          This step determines the converged ground-state charge
          density and potential.

        * Run NSCF (with SOC): Using the potential from the SCF step,
          run a separate Non-Self-Consistent Field (NSCF) calculation
          (including SOC) for each 'State' block defined by the user
          (see "MagneticAnisotropyEnergy%State").

        * Calculate MAE: The MAE is the energy difference between the
          total band energy (eband) of each state and the one
          specified by "MagneticAnisotropyEnergy%ReferenceState":
          MAE_i = eband_i - eband_ref.

      * **NormalModes** (*QuantumESPRESSO._NormalModes*) --

        This section outlines the configuration of parameters for
        calculating Normal Modes. The process involves using the
        following utilities:

        * "ph.x": This utility from Quantum ESPRESSO (QE) calculates
          phonon frequencies and eigenvectors at specified q-points
          (wave vectors) using Density Functional Perturbation Theory
          (DFPT). You can set specific parameters in the section
          "PH_X". For more details, see https://www.quantum-
          espresso.org/Doc/INPUT_PH.html.

        * "dynmat.x": This QE utility calculates the infrared (IR) and
          Raman intensities (oscillator strengths) as well as the
          normal modes associated with each vibrational frequency.
          Specific parameters can be set in the section "DYNMAT_X".
          The information from "ph.x", combined with the phonon
          frequencies, is used to generate the simulated IR/Raman
          absorption spectrum. For more details, see https://www
          .quantum-espresso.org/Doc/INPUT_DYNMAT.html.

        If Normal Modes are requested in the main AMS properties
        section, the program automatically sets "PH_X%asr=Yes",
        "PH_X%epsilon=Yes", and "PH_X%trans=Yes". If Raman is
        requested in the main AMS properties section, it also sets
        "PH_X%lraman=Yes" along with the previous parameters.

      * **PH_X** (*QuantumESPRESSO._PH_X*) -- This section configures
        the parameters for running the QE utility *ph.x* (see
        https://www.quantum-espresso.org/Doc/INPUT_PH.html). This
        utility is used for post-processing phonon calculations in
        Quantum ESPRESSO.

      * **PP_X** (*QuantumESPRESSO._PP_X*) -- This section configures
        the parameters for running the QE-utility "pp.x" (see
        https://www.quantum-espresso.org/Doc/INPUT_PP.html). This
        utility reads the output produced by "pw.x", extracts and
        calculates the desired quantity/quantities (rho, V, ...), and
        then writes the desired quantity to file in a suitable format
        for various types of plotting and various plotting programs.
        Only a few options are supported at the moment.

      * **PROJWFC_X** (*QuantumESPRESSO._PROJWFC_X*) -- This section
        configures the parameters for running the QE-utility
        "projwfc.x" (see https://www.quantum-
        espresso.org/Doc/INPUT_PROJWFC.html). This utility projects
        wavefunctions onto orthogonalized atomic wavefunctions,
        calculates Lowdin charges, spilling parameter, projected DOS
        (separated into up and down components for LSDA).

      * **Phonons** (*QuantumESPRESSO._Phonons*) --

        This section configures the parameters for calculating the
        Phonon Structure. This involves utilizing the following
        utilities:

        * "kpath": This AMS tool generates an automated high-symmetry
          k-path in the Brillouin zone.

        * "ph.x": This utility from Quantum ESPRESSO (QE) calculates
          phonon frequencies and eigenvectors at specified q-points
          (wavevectors) using Density Functional Perturbation Theory
          (DFPT). For more details see https://www.quantum-
          espresso.org/Doc/INPUT_PH.html

        * "q2r.x": This QE utility transforms the dynamical matrix
          from reciprocal space (q-space) to real space (r-space).
          This is necessary for further post-processing steps. For
          more details see https://www.quantum-
          espresso.org/Doc/INPUT_Q2R.html.

        * "matdyn.x": This QE utility calculates various phonon-
          related properties from the real-space dynamical matrix,
          such as phonon dispersion curves, density of states (DOS),
          thermodynamic properties, and more. For more details see
          https://www.quantum-espresso.org/Doc/INPUT_MATDYN.html.

      * **Properties** (*QuantumESPRESSO._Properties*) -- Configures
        which QE level properties to calculate for SinglePoint
        calculations or other important geometries (e.g. at the end of
        an optimization).

      * **Pseudopotentials** (*QuantumESPRESSO._Pseudopotentials*) --
        Selects the pseudopotential to use for the atomic species.

      * **Q2R_X** (*QuantumESPRESSO._Q2R_X*) -- This section
        configures the parameters for running the QE utility *q2r.x*
        (see https://www.quantum-espresso.org/Doc/INPUT_Q2R.html).
        This utility is used to transform the interatomic force
        constants (IFC) calculated in reciprocal space (q-space) by
        *ph.x* into real space (r-space). The real-space IFCs are then
        used as input for the *matdyn.x* utility to calculate various
        phonon-related properties.

      * **Restart** (*QuantumESPRESSO._Restart*) -- This section
        configures restarting a Quantum Espresso calculation from
        previous data. You can restart from a specific Quantum
        Espresso results file (e.g., *quantumespresso.rkf*), or by
        providing the directory and file prefix of the previous
        calculation. This is compatible with any stand-alone Quantum
        Espresso version.

      * **System** (*QuantumESPRESSO._System*) -- Keywords from the
        &SYSTEM namelist in the QuantumEspresso input file.

      * **WorkFunction** (*QuantumESPRESSO._WorkFunction*) --

        This section configures the parameters for calculating the
        Work Function. This involves utilizing the following
        utilities:

        * "pp.x": Calculates the the electrostatic potential using the
          results from the last Quantum ESPRESSO calculation.

        * "average.x": Performs planar and macroscopic averages of the
          electrostatic potential along a specified direction, which
          are crucial for determining the vacuum level and
          subsequently the work function.

   class _AVERAGE_X

      This section configures the parameters for running the QE-
      utility "average.x". This utility reads files produce by
      produced by "pp.x" and compute planar and macroscopic averages
      of a quantity (e.g. charge) in real space on a 3D FFT mesh.

      Variables:
         * **awin** (*float** | **FloatKey*) -- The size of the window
           for macroscopic average (a.u.).

         * **filename** (*str** | **StringKey*) -- List of strings
           containing the name of the n files.

         * **idir** (*int** | **IntKey*) -- 1,2 or 3. Planar average
           is done in the plane orthogonal to direction "idir", as
           defined for the crystal cell.

         * **nfile** (*int** | **IntKey*) -- The number of files
           containing the desired quantities. All files must refer to
           the same physical system!

         * **npt** (*int** | **IntKey*) -- The number of points for
           the final interpolation of the planar and macroscopic
           averages, as written to file. If npt <= N_idir (see below)
           no interpolation is done, the N_idir FFT points in
           direction idir are printed.

         * **weight** (*Iterable**[**float**] **| **FloatListKey*) --
           List of numbers containing the weights w_n of the
           quantities read from the files "filename".

   class _BandStructure

      This section configures the parameters for calculating the Band
      Structure. This involves utilizing the following utilities:

      * "kpath": This AMS tool generates an automated high-symmetry
        k-path in the Brillouin zone.

      * "pw.x" (with calculation=bands): This utility from Quantum
        ESPRESSO (QE) performs electronic structure calculations,
        particularly for bands. For more details see https://www
        .quantum-espresso.org/Doc/INPUT_PW.html

      * "bands.x": Another QE utility, which calculates the band
        structure. For more details see https://www.quantum-
        espresso.org/Doc/INPUT_BANDS.html.

      Variables:
         * **KPathFinderConvention** (*Literal**[**"Setyawan-
           Curtarolo"**, **"Hinuma"**]*) --

           This option determines how the path through the Brillouin
           zone is generated when using the automatic k-point mode.

           Available options:

           * "Setyawan-Curtarolo" (default for 1D and 2D lattices):
             Uses our built-in KPath program to find a path through
             high-symmetry points based on the method by Setyawan and
             Curtarolo
             (https://doi.org/10.1016/j.commatsci.2010.05.010). For 2D
             lattices, the path is derived from the intersection of
             the 3D Brillouin zone with a plane. For 1D lattices, the
             path is simply "GAMMA-Z".

           * "Hinuma": Uses the external SeeKPath utility to generate
             the k-path (https://github.com/giovannipizzi/seekpath and
             https://doi.org/10.1016/j.commatsci.2016.10.015).

         * **K_PointsLabels** (*str** | **StringKey*) -- You can
           provide labels for your k-points, like "L-GAMMA-X-U-GAMMA",
           separating each label with a hyphen (-) or a vertical bar
           (|). For example, "L-GAMMA-X-U-GAMMA" and
           "L|GAMMA|X|U|GAMMA" are both valid. These labels are
           optional and only used for display purposes when the
           "K_Points" block is specified. This option is used only if
           the header of the "BandStructure%K_Points" block is not
           "ams_kpath". **Important:** These labels do not determine
           the actual k-point coordinates. You must specify the
           k-point coordinates separately within the "K_Points"
           section.

         * **K_PointsStep** (*float** | **FloatKey*) -- Step size in
           reciprocal space for band structure calculation. Using a
           smaller number will produce smoother band curves at an
           increased computational time. This option is used only if
           the header of the "BandStructure%K_Points" block is
           "ams_kpath".

         * **UseSymmetry** (*BoolType** | **BoolKey*) -- If set, only
           the irreducible wedge of the Wigner-Seitz cell is sampled.
           If not, the whole (inversion-unique) Wigner-Seitz cell is
           sampled. Only available for Setyawan and Curtarolo
           convention (see "KPathFinderConvention").

         * **nbnd** (*int** | **IntKey*) --

           Number of electronic states (bands) to be calculated. Note
           that in spin-polarized calculations the number of k-point,
           not the number of bands per k-point, is doubled.

           Default: 20% more (minimum of 4 additional bands) than the
           number used in the main 'pw.x' calculation, regardless of
           the material's insulating or metallic nature. Notice that
           this default is calculated differently than in standard QE.

         * **K_Points** (*str** | **Sequence**[**str**] **|
           **FreeBlock*) -- Specify the k-points to use. Choose a
           header appropriate for your system. Supported values:
           "tpiba", "automatic", "crystal", "gamma", "tpiba_b",
           "crystal_b", "tpiba_c", "crystal_c", and "ams_kpath". See
           the QE documentation for details. If omitted, "ams_kpath"
           will be used for 3D systems, and "gamma" otherwise. For
           most cases, "ams_kpath" (which generates a convenient path
           along high-symmetry k-points in the Brillouin zone) is
           recommended.

      class _K_Points

         Specify the k-points to use. Choose a header appropriate for
         your system. Supported values: "tpiba", "automatic",
         "crystal", "gamma", "tpiba_b", "crystal_b", "tpiba_c",
         "crystal_c", and "ams_kpath". See the QE documentation for
         details. If omitted, "ams_kpath" will be used for 3D systems,
         and "gamma" otherwise. For most cases, "ams_kpath" (which
         generates a convenient path along high-symmetry k-points in
         the Brillouin zone) is recommended.

   class _Control

      Keywords from the &CONTROL namelist in the QuantumEspresso input
      file.

      Variables:
         * **dipfield** (*BoolType** | **BoolKey*) --

           If True (and "tefield" is True) a dipole correction is also
           added to the bare ionic potential - implements the recipe
           of L. Bengtsson, PRB 59, 12301 (1999).

           See keywords "edir", "emaxpos", "eopreg" for the form of
           the correction.

           Must be used ONLY in a slab geometry, for surface
           calculations, with the discontinuity FALLING IN THE EMPTY
           SPACE.

         * **disk_io** (*Literal**[**"High"**, **"Medium"**,
           **"Low"**, **"NoWf"**, **"Minimal"**, **"None"**,
           **"Auto"**]*) --

           Specifies the amount of disk I/O activity:

           * High: save charge to disk at each SCF step, keep
             wavefunctions on disk (in 'distributed' format), save
             mixing data as well. Do not use this option unless you
             have a good reason! It is no longer needed to specify
             'high' in order to be able to restart from an interrupted
             calculation (see restart_mode).

           * Medium: save charge to disk at each SCF step, keep
             wavefunctions on disk only if more than one k-point, per
             process is present, otherwise keep them in memory; save
             them to disk only at the end (in 'portable' format).

           * Low: save charge to disk at each SCF step, keep
             wavefunctions in memory (for all k-points), save them to
             disk only at the end (in 'portable' format). Reduces I/O
             but increases memory wrt the previous cases.

           * NoWf: save to disk only the xml data file and the charge
             density at convergence, never save wavefunctions.
             Restarting from an interrupted calculation is not
             possible with this option.

           * Minimal: save to disk only the xml data file at
             convergence.

           * None: do not save anything to disk.

           * The Default ('Auto') is stablished by QE ('Low' for the
             scf case, 'Medium' otherwise.)

         * **lelfield** (*BoolType** | **BoolKey*) --

           If True a homogeneous finite electric field described
           through the modern theory of the polarization is applied.

           This is different from setting "tefield" to True!

         * **max_seconds** (*float** | **FloatKey*) --

           Jobs stops after max_seconds CPU time. Use this option in
           conjunction with option restart_mode if you need to

           split a job too long to complete into shorter jobs that fit
           into your batch queues. Warning! Unfortunately, AMS does
           not yet support restarting an SCF calculation in QE.
           Therefore, utilizing this option is unhelpful, unless you
           intend to continue the calculation directly using QE.

         * **tefield** (*BoolType** | **BoolKey*) --

           If True a saw-like potential simulating an electric field
           is added to the bare ionic potential.

           See keywords "edir", "eamp", "emaxpos", "eopreg" for the
           form and size of the added potential.

         * **verbosity** (*Literal**[**"Minimal"**, **"Low"**,
           **"Default"**, **"Debug"**, **"Medium"**, **"High"**,
           **"Auto"**]*) -- Currently two verbosity levels are
           implemented: 'high', 'low'. 'debug' and 'medium' have the
           same effect as 'high', 'default' and 'minimal' as 'low'.
           The Default ('Auto') is stablished by QE.

   class _DOS

      This section configures the parameters for calculating the
      Density of States (DOS). These are the utilities involved:

      * "kpath": This AMS tool generates an automated high-symmetry
        k-path in the Brillouin zone.

      * "pw.x" (with "calculation=nscf"): This Quantum ESPRESSO (QE)
        utility conducts electronic structure calculations,
        specifically for the non-self-consistent field (nscf)
        computation.

      * "dos.x": A QE utility utilized for post-processing electronic
        structure calculations. It analyzes the electronic
        wavefunctions obtained from preceding calculations to
        determine the density of available electronic states at
        different energy levels. For more details see https://www
        .quantum-espresso.org/Doc/INPUT_DOS.html

      * "projwfc.x": Another QE utility employed for post-processing
        electronic structure calculations. It projects the
        wavefunctions onto atomic orbitals or basis sets, offering
        insights into the composition and character of electronic
        states. For more details see https://www.quantum-
        espresso.org/Doc/INPUT_PROJWFC.html

      By default, the calculation sequence follows the order: "kpath
      -> pw.x(calculation=nscf) -> dos.x". However, enabling
      "DOS%PDOS" switches the calculation to use "projwfc.x" instead
      of "dos.x". While common parameters can be customized directly
      in this section, specialized adjustments should be made in
      either the "DOS_X" or "PROJWFC_X" section, depending on specific
      requirements.

      Variables:
         * **DeltaE** (*float** | **FloatKey*) -- Energy grid step.

         * **Emax** (*float** | **FloatKey*) -- Maximum energy for DOS
           plot. If unspecified, the upper band value, plus 3 times
           the value of the gaussian smearing if present, will be
           used.

         * **Emin** (*float** | **FloatKey*) -- Minimum energy for DOS
           plot. If unspecified, the lower band value, minus 3 times
           the value of the gaussian smearing if present, will be
           used.

         * **K_PointsStep** (*float** | **FloatKey*) -- This option is
           used only if the header of the "DOS%K_Points" block is
           "ams_kpath".

         * **PDOS** (*BoolType** | **BoolKey*) -- If true, the partial
           Density-Of-States (projections on atomic basis functions)
           is calculated and saved for visualization. It uses the QE-
           utility "projwfc.x". To configure the parameters of the
           calculation, please modify the options in the the section
           "PROJWFC_X".

         * **degauss** (*float** | **FloatKey*) -- Gaussian
           broadening. See more details in sections "DOS_X" or
           "PROJWFC_X".

         * **nbnd** (*int** | **IntKey*) --

           Number of electronic states (bands) to be calculated. Note
           that in spin-polarized calculations the number of k-point,
           not the number of bands per k-point, is doubled.

           Default: 20% more (minimum of 4 additional bands) than the
           number used in the main 'pw.x' calculation, regardless of
           the material's insulating or metallic nature. Notice that
           this default is calculated differently than in standard QE.

         * **ngauss** (*Literal**[**"0"**, **"SimpleGaussian"**,
           **"1"**, **"Methfessel-Paxton"**, **"-1"**,
           **"ColdSmearing"**, **"-99"**, **"Fermi-Dirac"**,
           **"Default"**]*) --

           Type of gaussian broadening: Available options are:

           * SimpleGaussian.

           * Methfessel-Paxton: Methfessel-Paxton of order 1.

           * ColdSmearing: Marzari-Vanderbilt-DeVita-Payne.

           * Fermi-Dirac: Fermi-Dirac function.

           * Default: See more details in sections "DOS_X" or
             "PROJWFC_X".

         * **occupations** (*Literal**[**"Smearing"**,
           **"Tetrahedra"**, **"Tetrahedra_lin"**,
           **"Tetrahedra_opt"**, **"Fixed"**, **"Auto"**]*) --

           Available options are:

           * Smearing: gaussian smearing for metals; see keywords
             "smearing" and "degauss"

           * Tetrahedra: Tetrahedron method, Bloechl's version: P.E.
             Bloechl, PRB 49, 16223 (1994). Requires uniform grid of
             k-points, to be automatically generated (see "block
             K_Points"). Well suited for calculation of DOS, less so
             (because not variational) for force/optimization/dynamics
             calculations.

           * Tetrahedra_lin: Original linear tetrahedron method. To be
             used only as a reference; the optimized tetrahedron
             method is more efficient.

           * Tetrahedra_opt: optimized tetrahedron method, see M.
             Kawamura, PRB 89, 094515 (2014). Can be used for phonon
             calculations as well.

           * Fixed: for insulators with a gap.

           * Auto: Uses "Tetrahedra" for 3D and 2D systems, and
             "Fixed" for 0D and 1D systems.

         * **smearing** (*Literal**[**"Gaussian"**, **"gauss"**,
           **"Methfessel-Paxton"**, **"m-p"**, **"mp"**, **"Marzari-
           Vanderbilt"**, **"cold"**, **"m-v"**, **"mv"**, **"Fermi-
           Dirac"**, **"f-d"**, **"fd"**]*) --

           Available options are:

           * Gaussian: ordinary Gaussian spreading

           * Methfessel-Paxton: first-order spreading (see PRB 40,
             3616 (1989))

           * Marzari-Vanderbilt: cold smearing (see PRL 82, 3296
             (1999))

           * Fermi-Dirac: smearing with Fermi-Dirac function

         * **K_Points** (*str** | **Sequence**[**str**] **|
           **FreeBlock*) -- Specify the k-points to use. Choose a
           header appropriate for your system. Supported values:
           "tpiba", "automatic", "crystal", "gamma", "tpiba_b",
           "crystal_b", "tpiba_c", "crystal_c", and "ams_kpath". See
           the QE documentation for details. If omitted, the k-points
           specified in the main QE calculation will be used. For most
           cases, "automatic" (which generates a Monkhorst-Pack grid)
           is recommended.

      class _K_Points

         Specify the k-points to use. Choose a header appropriate for
         your system. Supported values: "tpiba", "automatic",
         "crystal", "gamma", "tpiba_b", "crystal_b", "tpiba_c",
         "crystal_c", and "ams_kpath". See the QE documentation for
         details. If omitted, the k-points specified in the main QE
         calculation will be used. For most cases, "automatic" (which
         generates a Monkhorst-Pack grid) is recommended.

   class _DOS_X

      This section configures the parameters for running the QE-
      utility "dos.x" (see https://www.quantum-
      espresso.org/Doc/INPUT_DOS.html). This utility calculates the
      Density of States (DOS), separated into up and down components
      for DSDA.

      Variables:
         * **DeltaE** (*float** | **FloatKey*) -- Energy grid step.

         * **Emax** (*float** | **FloatKey*) -- Maximum energy for DOS
           plot. If unspecified, the upper band value, plus 3 times
           the value of the gaussian smearing if present, will be
           used.

         * **Emin** (*float** | **FloatKey*) -- Minimum energy for DOS
           plot. If unspecified, the lower band value, minus 3 times
           the value of the gaussian smearing if present, will be
           used.

         * **bz_sum** (*Literal**[**"Smearing"**, **"Tetrahedra"**,
           **"Tetrahedra_lin"**, **"Tetrahedra_opt"**,
           **"Default"**]*) --

           Keyword selecting  the method for BZ summation. Available
           options are:

           * Smearing: Integration using gaussian smearing. In fact
             currently any string not related to tetrahedra defaults
             to smearing.

           * Tetrahedra: Tetrahedron method, Bloechl's version: P.E.
             Bloechl, PRB 49, 16223 (1994). Requires uniform grid of
             k-points, to be automatically generated (see "block
             K_Points").

           * Tetrahedra_lin: Original linear tetrahedron method. To be
             used only as a reference; the optimized tetrahedron
             method is more efficient.

           * Tetrahedra_opt: Optimized tetrahedron method, see M.
             Kawamura, PRB 89, 094515 (2014). Default: The default
             value is "Smearing" if "DOS_X%degauss" is set, otherwise
             it is influenced by related variables used in the
             previous 'pw.x' run. For more information, consult the
             original Quantum Espresso documentation at this link:
             https://www.quantum-espresso.org/Doc/INPUT_DOS.html.

         * **degauss** (*float** | **FloatKey*) -- Gaussian
           broadening. If not set, the default value is determined by
           the choice you make for "DOS_X%bz_sum", and it may also be
           influenced by related variables used in the previous 'pw.x'
           run. For more information, consult the original Quantum
           Espresso documentation at this link: https://www.quantum-
           espresso.org/Doc/INPUT_DOS.html.

         * **ngauss** (*Literal**[**"0"**, **"SimpleGaussian"**,
           **"1"**, **"Methfessel-Paxton"**, **"-1"**,
           **"ColdSmearing"**, **"-99"**, **"Fermi-Dirac"**,
           **"Default"**]*) --

           Type of gaussian broadening: Available options are:

           * SimpleGaussian.

           * Methfessel-Paxton: Methfessel-Paxton of order 1.

           * ColdSmearing: Marzari-Vanderbilt-DeVita-Payne.

           * Fermi-Dirac: Fermi-Dirac function.

           * Default: The default value is determined by the choices
             you make for "DOS_X%bz_sum" and "DOS_X%degauss", and it
             may also be influenced by related variables used in the
             previous 'pw.x' run. For more information, consult the
             original Quantum Espresso documentation at this link:
             https://www.quantum-espresso.org/Doc/INPUT_DOS.html.

   class _DYNMAT_X

      This section configures the parameters for running the QE
      utility *dynmat.x* (see https://www.quantum-
      espresso.org/Doc/INPUT_DYNMAT.html). This utility is used to ???

      Variables:
         **asr** (*str** | **StringKey*) -- Indicates the type of
         Acoustic Sum Rule imposed. Allowed values: 'no', 'simple',
         'crystal', 'one-dim', 'zero-dim'

   class _Electrons

      Keywords from the &ELECTRONS namelist in the QuantumEspresso
      input file.

      Variables:
         * **conv_thr** (*float** | **FloatKey*) -- Convergence
           threshold for selfconsistency: estimated energy error <
           "conv_thr". Note that "conv_thr" is extensive, like the
           total energy.

         * **diagonalization** (*Literal**[**"Davidson"**,
           **"David"**, **"ConjugateGradient"**, **"CG"**, **"PPCG"**,
           **"ParO"**, **"RMM-Davidson"**, **"RMM-ParO"**]*) --

           Available options are:

           * Davidson: iterative diagonalization with overlap matrix.
             Fast, may in some rare cases fail.

           * ConjugateGradient: Conjugate-gradient-like band-by-band
             diagonalization. MUCH slower than "Davidson" but uses
             less memory and is (a little bit) more robust.

           * PPCG: PPCG iterative diagonalization

           * ParO: ParO iterative diagonalization

           * RMM-Davidson & RMM-ParO: RMM-DIIS iterative
             diagonalization. To stabilize the SCF loop RMM-DIIS is
             alternated with calls to Davidson or ParO solvers.

         * **electron_maxstep** (*int** | **IntKey*) -- Maximum number
           of iterations in a SCF step.

         * **mixing_beta** (*float** | **FloatKey*) --

           Mixing factor for self-consistency.

           Note: the default value in the AMS interface (0.3) is
           smaller than the default value in pw.x (0.7)

         * **mixing_mode** (*Literal**[**"Plain"**, **"Thomas-
           Fermi"**, **"TF"**, **"Local-Thomas-Fermi"**, **"local-
           TF"**]*) --

           Available options are:

           * Plain: charge density Broyden mixing

           * Thomas-Fermi: as above, with simple Thomas-Fermi
             screening (for highly homogeneous systems)

           * Local-Thomas-Fermi: as above, with local-density-
             dependent TF screening (for highly inhomogeneous systems)

         * **mixing_ndim** (*int** | **IntKey*) -- Number of
           iterations used in mixing scheme. If you are tight with
           memory, you may reduce it to 4 or so.

         * **scf_must_converge** (*BoolType** | **BoolKey*) -- If
           .false. do not stop molecular dynamics or ionic relaxation
           when electron_maxstep is reached. Use with care. Important:
           When using the AMS interface, setting this to .true. will
           halt the entire AMS execution if the SCF fails; otherwise,
           AMS will try to continue using the unconverged results.

         * **startingpot** (*Literal**[**"atomic"**, **"file"**]*) --

           Available options are:

           * 'atomic': starting potential from atomic charge
             superposition.

           * 'file': start from existing 'charge-density.xml' file in
             the directory specified by variables prefix and outdir.
             **Note:** This option applies only to the main and first
             QE calculation. Once the QE worker is up, the results
             from the previous step are reused.

         * **startingwfc** (*Literal**[**"atomic"**,
           **"atomic+random"**, **"random"**, **"file"**]*) --

           Available options are:

           * 'atomic': Start from superposition of atomic orbitals. If
             not enough atomic orbitals are available, fill with
             random numbers the remaining wfcs. The scf typically
             starts better with this option, but in some high-symmetry
             cases one can 'loose' valence states, ending up in the
             wrong ground state.

           * 'atomic+random': As above, plus a superimposed
             'randomization' of atomic orbitals. Prevents the 'loss'
             of states mentioned above.

           * 'random': Start from random wfcs. Slower start of scf but
             safe. It may also reduce memory usage in conjunction with
             diagonalization='cg'.

           * 'file': Start from an existing wavefunction file in the
             directory specified by variables prefix and outdir.
             **Note:** This option applies only to the main and first
             QE calculation. Once the QE worker is up, the results
             from the previous step are reused.

   class _Hubbard

      Specify parameters for DFT+U models. The type of Hubbard
      projectors to use (e.g. "atomic" or "ortho-atomic") is specified
      in the header of this block. Example input:

         Hubbard ortho-atomic
             U Fe-3d 3.0
          End

      More examples can be found in the documentation.

   class _HubbardU

      Specify parameters for DFT+U Models.

      Variables:
         * **Projector** (*Literal**[**"atomic"**, **"ortho-atomic"**,
           **"norm-atomic"**, **"wf"**, **"pseudo"**]*) -- The Hubbard
           projector to use.

         * **Parameter** (*QuantumESPRESSO._HubbardU._Parameter*) --
           Specify parameters for DFT+U Models.

      class _Parameter

         Specify parameters for DFT+U Models.

         Variables:
            * **AtomType** (*str** | **StringKey*) -- The QE atom type
              for which this parameter applies.

            * **State** (*Literal**[**"1s"**, **"2s"**, **"2p"**,
              **"3s"**, **"3p"**, **"3d"**, **"4s"**, **"4p"**,
              **"4d"**, **"4f"**, **"5s"**, **"5p"**, **"5d"**,
              **"5f"**, **"6s"**, **"6p"**, **"6d"**, **"7s"**,
              **"7p"**]*) -- The state for this parameter applies.

            * **Type** (*Literal**[**"U"**, **"J"**, **"J0"**,
              **"B"**, **"V"**]*) -- The type of Hubbard parameter.

            * **Value** (*float** | **FloatKey*) -- The value of this
              parameter.

   class _K_Points

      Specify the k-points to use. Available header values are:
      "tpiba", "automatic", "crystal", "gamma", "tpiba_b",
      "crystal_b", "tpiba_c", "crystal_c", and "ams_kpath". See the
      examples and QE documentation for details. If omitted, only
      "gamma" is used. For most cases, "automatic" (which generates a
      Monkhorst-Pack grid) is recommended. Note: Gamma-point
      calculations are significantly faster using "gamma" than
      "automatic", but may not be possible to use for all types of
      calculations or postprocessing programs.

   class _MATDYN_X

      This section configures the parameters for running the QE
      utility *matdyn.x* (see https://www.quantum-
      espresso.org/Doc/INPUT_MATDYN.html). This utility is used to
      calculate various phonon-related properties from the real-space
      interatomic force constants (IFC) produced by *q2r.x*. These
      properties include phonon dispersion curves, phonon density of
      states (DOS), thermodynamic properties (e.g., free energy,
      entropy), and more.

      Variables:
         * **asr** (*Literal**[**"no"**, **"simple"**, **"crystal"**,
           **"all"**, **"one-dim"**, **"zero-dim"**]*) --

           Indicates the type of Acoustic Sum Rule imposed. Allowed
           values:

           * 'no':  no Acoustic Sum Rules imposed (default)

           * 'simple': previous implementation of the asr used (3
             translational asr imposed by correction of the diagonal
             elements of the force constants matrix).

           * 'crytal': 3 translational asr imposed by optimized
             correction of the force constants (projection).

           * 'all': 3 translational asr + 3 rotational asr + 15 Huang
             conditions for vanishing stress tensor, imposed by
             optimized correction of the force constants (projection).
             Remember to set write_lr = .true. to write long-range
             force constants into file when running q2r and set
             read_lr = .true. when running matdyn in the case of
             infrared-active solids. (See npj Comput Mater 8, 236
             (2022)).

           * 'one-dim': 3 translational asr + 1 rotational asr imposed
             by optimized correction of the dyn. mat. (the rotation
             axis is the direction of periodicity; it will work only
             if this axis considered is one of the Cartesian axis).

           * 'zero-dim': 3 translational asr + 3 rotational asr
             imposed by optimized correction of the dyn. mat.

         * **degauss** (*float** | **FloatKey*) -- DOS broadening in
           cm-1. Default: 0 - meaning use tetrahedra.

         * **deltaE** (*float** | **FloatKey*) -- Energy step, in
           cm-1, for DOS calculation: from min to max phonon energy
           (default: 1 cm-1 if is not specified).

         * **dos** (*BoolType** | **BoolKey*) -- If .true. calculate
           phonon Density of States (DOS) using tetrahedra and a
           uniform q-point grid (see below) NB: may not work properly
           in noncubic materials. If .false. calculate phonon bands
           from the list of q-points supplied in input (default)

         * **l1** (*int** | **IntKey*) -- Supercell lattice vectors
           are original cell vectors times "l1", "l2", "l3"
           respectively (default: 1)

         * **l2** (*int** | **IntKey*) -- Supercell lattice vectors
           are original cell vectors times "l1", "l2", "l3"
           respectively (default: 1)

         * **l3** (*int** | **IntKey*) -- Supercell lattice vectors
           are original cell vectors times "l1", "l2", "l3"
           respectively (default: 1)

         * **loto_2d** (*BoolType** | **BoolKey*) -- Set to .true. to
           activate two-dimensional treatment of LO-TO splitting

         * **ndos** (*int** | **IntKey*) -- Number of energy steps for
           DOS calculations (default: calculated from deltaE if not
           specified).

         * **nk1** (*int** | **IntKey*) -- Uniform q-point grid for
           DOS calculation (includes q=0). First direction. Must be
           specified if "dos = .true.", ignored otherwise.

         * **nk2** (*int** | **IntKey*) -- Uniform q-point grid for
           DOS calculation (includes q=0). Second direction. Must be
           specified if "dos = .true.", ignored otherwise.

         * **nk3** (*int** | **IntKey*) -- Uniform q-point grid for
           DOS calculation (includes q=0). Third direction. Must be
           specified if "dos = .true.", ignored otherwise.

         * **q_in_cryst_coord** (*BoolType** | **BoolKey*) -- If True,
           the q-points for the phonon dispersion calculation are
           given in crystal coordinates (i.e., as fractions of the
           reciprocal lattice vectors).

         * **Q_Points** (*str** | **Sequence**[**str**] **|
           **FreeBlock*) -- Specify the q-points to use for the bands
           calculation.

      class _Q_Points

         Specify the q-points to use for the bands calculation.

   class _MagneticAnisotropyEnergy

      This option computes the Magnetic Anisotropy Energy (MAE) using
      the Force Theorem approximation [see Phys. Rev. B 90, 205409
      (2014)]. The calculation follows this procedure:

      * Run SCF (no SOC): First, perform a standard Self-Consistent
        Field (SCF) calculation without Spin-Orbit Coupling (SOC).
        This step determines the converged ground-state charge density
        and potential.

      * Run NSCF (with SOC): Using the potential from the SCF step,
        run a separate Non-Self-Consistent Field (NSCF) calculation
        (including SOC) for each 'State' block defined by the user
        (see "MagneticAnisotropyEnergy%State").

      * Calculate MAE: The MAE is the energy difference between the
        total band energy (eband) of each state and the one specified
        by "MagneticAnisotropyEnergy%ReferenceState": MAE_i = eband_i
        - eband_ref.

      Variables:
         * **ReferenceSpecies** (*str** | **StringKey*) -- Sets the
           atomic type used as the primary axis for spin orientation.
           This species is placed first in the input to ensure its
           angles define the global magnetic rotation of the system.
           If not specified, the selection is arbitrary and based on
           the alphabetical order of the atomic types.

         * **ReferenceState** (*str** | **StringKey*) -- Specifies the
           'Label' of the 'State' block to be used as the zero-energy
           reference. MAE values will be calculated as "E_band -
           E_ref". If left empty, the state with the lowest band
           energy is automatically selected as the reference.

         * **conv_thr** (*float** | **FloatKey*) -- For the non-self-
           consistent calculation (second step in MAE), "conv_thr" is
           used to set the default value of the threshold (ethr) for
           iterative diagonalization. If unspecified,
           "Electrons%conv_thr" will be used.

         * **nosym** (*BoolType** | **BoolKey*) -- Same as
           "System%nosym" but applies only for the non-self-consistent
           calculation (second step in MAE). If unspecified,
           "System%nosym" will be used

         * **K_Points** (*str** | **Sequence**[**str**] **|
           **FreeBlock*) -- Specify the k-points to use in the non-
           self-consistent calculation (second step in MAE). Choose a
           header appropriate for your system. Supported values:
           "tpiba", "automatic", "crystal", "gamma", "tpiba_b",
           "crystal_b", "tpiba_c", "crystal_c", and "ams_kpath". See
           the QE documentation for details. If omitted, the k-points
           specified in the main QE calculation will be used. For most
           cases, "automatic" (which generates a Monkhorst-Pack grid)
           is recommended.

         * **Pseudopotentials** (*QuantumESPRESSO._MagneticAnisotropy
           Energy._Pseudopotentials*) -- Specifies the
           pseudopotentials to use specifically for the NSCF+SOC step
           in the MAE calculation. If unspecified, the main
           'Pseudopotentials' block is used by default. In the GUI,
           enabling this override starts from a copy of the current
           main QE pseudopotentials settings. If using 'Files', you
           must manually select a fully-relativistic pseudopotential
           file when required for Spin-Orbit Coupling (SOC).

         * **State**
           (*QuantumESPRESSO._MagneticAnisotropyEnergy._State*) --
           Defines a specific spin configuration (a 'State') for which
           to run one NSCF+SOC calculation. This block can be repeated
           multiple times to define all orientations of interest.

      class _K_Points

         Specify the k-points to use in the non-self-consistent
         calculation (second step in MAE). Choose a header appropriate
         for your system. Supported values: "tpiba", "automatic",
         "crystal", "gamma", "tpiba_b", "crystal_b", "tpiba_c",
         "crystal_c", and "ams_kpath". See the QE documentation for
         details. If omitted, the k-points specified in the main QE
         calculation will be used. For most cases, "automatic" (which
         generates a Monkhorst-Pack grid) is recommended.

      class _Pseudopotentials

         Specifies the pseudopotentials to use specifically for the
         NSCF+SOC step in the MAE calculation. If unspecified, the
         main 'Pseudopotentials' block is used by default. In the GUI,
         enabling this override starts from a copy of the current main
         QE pseudopotentials settings. If using 'Files', you must
         manually select a fully-relativistic pseudopotential file
         when required for Spin-Orbit Coupling (SOC).

         Variables:
            * **Database** (*str** | **StringKey*) -- Specifies the
              file name of the pseudopotential database located in
              $AMSRESOURCES/QE

            * **Directory** (*str** | **Path** | **StringKey*) --

              This key is mutually exclusive with the "Family" and
              "Files" keywords. This key specifies a directory
              containing label.upf files.

              Example:

                 System
                    Atoms
                      H 0 0 0
                      H 0 0 1 QE.Label=H1
                      H 0 0 2 QE.Label=H2
                      C 0 0 3 QE.Label=C1
                    End
                  End

              This will look for the files H.upf, H1.upf, H2.upf,
              C1.upf. If H1.upf does not exist, H.upf will be used. If
              H2.upf does not exist, H.upf will be used. If C1.upf
              does not exist, C.upf will be used.

            * **Family** (*Literal**[**"Dojo"**, **"GBRV"**,
              **"pslibrary-PAW"**, **"pslibrary-US"**, **"SG15"**,
              **"SSSP-Efficiency"**, **"SSSP-Precision"**]*) -- The
              pseudopotential family to use. Mutually exclusive with
              the "Files" and "Directory" keywords.

            * **FullyRelativistic** (*BoolType** | **BoolKey*) --
              Whether to use fully relativistic pseudopotentials
              (required for spin-orbit calculations).

            * **Functional** (*Literal**[**"BLYP"**, **"LDA"**,
              **"PBE"**, **"PBEsol"**, **"PW91"**]*) --

              Exchange-correlation functional that was used to
              generate the pseudopotential. Not all choices are valid
              for all pseudopotential families.

              This functional will also be used for the calculation,
              unless the "input_dft" option is set.

            * **Version** (*str** | **StringKey*) -- Version number
              for pseudopotentials. Currently, must be set to 'auto'.

            * **Files** (*QuantumESPRESSO._MagneticAnisotropyEnergy._
              Pseudopotentials._Files*) -- Selects the
              pseudopotentials to use for each atomic species. This
              key is mutually exclusive with the "Family" and
              "Directory" keywords.

         class _Files

            Selects the pseudopotentials to use for each atomic
            species. This key is mutually exclusive with the "Family"
            and "Directory" keywords.

            Variables:
               * **Label** (*str** | **StringKey*) -- Label for an
                 atom corresponding to the QE.Label, or to the element
                 symbol if QE.Label is not set.

               * **Path** (*str** | **Path** | **StringKey*) -- Path
                 to a .upf file to use as pseudopotential. Relative
                 paths are relative to root of the pseudopotential
                 library shipped with AMS. Prefix a path with './' to
                 make it relative to the starting directory of your
                 job.

      class _State

         Defines a specific spin configuration (a 'State') for which
         to run one NSCF+SOC calculation. This block can be repeated
         multiple times to define all orientations of interest.

         Variables:
            * **Label** (*str** | **StringKey*) -- A unique user-
              defined string to identify this state. This label is
              used by the 'ReferenceState' keyword and in the output
              files.

            * **SpinOrientation** (*QuantumESPRESSO._MagneticAnisotro
              pyEnergy._State._SpinOrientation*) -- Defines the spin
              quantization axis (theta, phi) for atoms matching the
              'Label'. This block can be repeated within a 'State' to
              define non-collinear or per-atom spin structures.

         class _SpinOrientation

            Defines the spin quantization axis (theta, phi) for atoms
            matching the 'Label'. This block can be repeated within a
            'State' to define non-collinear or per-atom spin
            structures.

            Variables:
               * **Label** (*str** | **StringKey*) -- Label for an
                 atom corresponding to the QE.Label, or to the element
                 symbol if QE.Label is not set.

               * **Phi** (*float** | **FloatKey*) -- The angle
                 expressed in degrees between the projection of the
                 initial magnetization on x-y plane and the x-axis for
                 the specified QE.Label.

               * **Theta** (*float** | **FloatKey*) -- The angle
                 expressed in degrees between the initial
                 magnetization and the z-axis for the specified
                 QE.Label.

   class _NormalModes

      This section outlines the configuration of parameters for
      calculating Normal Modes. The process involves using the
      following utilities:

      * "ph.x": This utility from Quantum ESPRESSO (QE) calculates
        phonon frequencies and eigenvectors at specified q-points
        (wave vectors) using Density Functional Perturbation Theory
        (DFPT). You can set specific parameters in the section "PH_X".
        For more details, see https://www.quantum-
        espresso.org/Doc/INPUT_PH.html.

      * "dynmat.x": This QE utility calculates the infrared (IR) and
        Raman intensities (oscillator strengths) as well as the normal
        modes associated with each vibrational frequency. Specific
        parameters can be set in the section "DYNMAT_X". The
        information from "ph.x", combined with the phonon frequencies,
        is used to generate the simulated IR/Raman absorption
        spectrum. For more details, see https://www.quantum-
        espresso.org/Doc/INPUT_DYNMAT.html.

      If Normal Modes are requested in the main AMS properties
      section, the program automatically sets "PH_X%asr=Yes",
      "PH_X%epsilon=Yes", and "PH_X%trans=Yes". If Raman is requested
      in the main AMS properties section, it also sets
      "PH_X%lraman=Yes" along with the previous parameters.

      Variables:
         * **ActiveAtoms** (*Iterable**[**int**] **| **IntListKey*) --
           This is a list of atoms to be used in the linear response
           calculation. It can help estimate modes for a molecule
           adsorbed on a surface without requiring a full calculation.
           Please be aware that this is an approximation and may not
           be reliable. If you perform a linear response calculation
           for a specific atom, you should also do so for all
           symmetry-equivalent atoms. This option serves as an
           interface to the "ph.x" option "nat_todo". This is an
           experimental feature!

         * **ActiveAtomsInRegion** (*str** | **StringKey*) -- Specify
           the region of atoms to be included in the linear response
           calculation. It can help estimate modes for a molecule
           adsorbed on a surface without requiring a full calculation.
           Please be aware that this is an approximation and may not
           be reliable. If you perform a linear response calculation
           for a specific atom, you should also do so for all
           symmetry-equivalent atoms. This option serves as an
           interface to the "ph.x" option "nat_todo". This is an
           experimental feature!

         * **asr** (*Literal**[**"no"**, **"simple"**, **"crystal"**,
           **"one-dim"**, **"zero-dim"**]*) -- Indicates the type of
           Acoustic Sum Rule imposed. Allowed values: 'no', 'simple',
           'crystal', 'one-dim', 'zero-dim'

         * **tr2_ph** (*float** | **FloatKey*) -- Threshold for self-
           consistency. It overwrites "PH_X%tr2_ph".

         * **xq1** (*float** | **FloatKey*) -- First component of the
           phonon wavevector (q-point) at which the IR spectrum is
           calculated, in units of 2pi/a0 (a0 = lattice parameter). It
           overwrites "PH_X%xq1".

         * **xq2** (*float** | **FloatKey*) -- Second component of the
           phonon wavevector (q-point) at which the IR spectrum is
           calculated, in units of 2pi/a0 (a0 = lattice parameter). It
           overwrites "PH_X%xq2".

         * **xq3** (*float** | **FloatKey*) -- Third component of the
           phonon wavevector (q-point) at which the IR spectrum is
           calculated, in units of 2pi/a0 (a0 = lattice parameter). It
           overwrites "PH_X%xq3".

   class _PH_X

      This section configures the parameters for running the QE
      utility *ph.x* (see https://www.quantum-
      espresso.org/Doc/INPUT_PH.html). This utility is used for post-
      processing phonon calculations in Quantum ESPRESSO.

      Variables:
         * **asr** (*BoolType** | **BoolKey*) -- Apply Acoustic Sum
           Rule to dynamical matrix, effective charges Works only in
           conjunction with 'gamma_gamma' tricks (see above)

         * **epsil** (*BoolType** | **BoolKey*) -- If .true. in a q=0
           calculation for a non metal the macroscopic dielectric
           constant of the system is computed. Do not set epsil to
           .true. if you have a metallic system or q/=0: the code will
           complain and stop.

         * **k1** (*int** | **IntKey*) -- If specified, triggers a
           non-self-consistent calculation in *ph.x* with a separate
           Monkhorst-Pack k-point grid for phonons. This sets the
           k-point grid offset along the first reciprocal lattice
           vector for that grid.

         * **k2** (*int** | **IntKey*) -- If specified, triggers a
           non-self-consistent calculation in *ph.x* with a separate
           Monkhorst-Pack k-point grid for phonons. This sets the
           k-point grid offset along the second reciprocal lattice
           vector for that grid.

         * **k3** (*int** | **IntKey*) -- If specified, triggers a
           non-self-consistent calculation in *ph.x* with a separate
           Monkhorst-Pack k-point grid for phonons. This sets the
           k-point grid offset along the third reciprocal lattice
           vector for that grid.

         * **ldisp** (*BoolType** | **BoolKey*) -- If True, phonon
           dispersion curves are calculated along specified high-
           symmetry lines in the Brillouin zone. Requires additional
           input defining the path.

         * **lraman** (*BoolType** | **BoolKey*) -- If .true.
           calculate non-resonant Raman coefficients using second-
           order response as in: M. Lazzeri and F. Mauri, PRL 90,
           036401 (2003).

         * **nk1** (*int** | **IntKey*) -- If specified, triggers a
           non-self-consistent calculation in *ph.x* with a separate
           Monkhorst-Pack k-point grid for phonons. This sets the
           number of k-points along the first reciprocal lattice
           vector for that grid.

         * **nk2** (*int** | **IntKey*) -- If specified, triggers a
           non-self-consistent calculation in *ph.x* with a separate
           Monkhorst-Pack k-point grid for phonons. This sets the
           number of k-points along the second reciprocal lattice
           vector for that grid.

         * **nk3** (*int** | **IntKey*) -- If specified, triggers a
           non-self-consistent calculation in *ph.x* with a separate
           Monkhorst-Pack k-point grid for phonons. This sets the
           number of k-points along the third reciprocal lattice
           vector for that grid.

         * **nq1** (*int** | **IntKey*) -- Sets the number of q-points
           along the first reciprocal lattice vector for the
           Monkhorst-Pack q-point grid for phonons. Default 1. Notice
           that this default is different than in standard QE (default
           0).

         * **nq2** (*int** | **IntKey*) -- Sets the number of q-points
           along the second reciprocal lattice vector for the
           Monkhorst-Pack q-point grid for phonons. Default 1. Notice
           that this default is different than in standard QE (default
           0).

         * **nq3** (*int** | **IntKey*) -- Sets the number of q-points
           along the third reciprocal lattice vector for the
           Monkhorst-Pack q-point grid for phonons. Default 1. Notice
           that this default is different than in standard QE (default
           0).

         * **search_sym** (*BoolType** | **BoolKey*) -- Set it to
           .false. if you want to disable the mode symmetry analysis.

         * **tr2_ph** (*float** | **FloatKey*) -- Threshold for self-
           consistency.

         * **trans** (*BoolType** | **BoolKey*) -- If .false. the
           phonons are not computed. If trans .and. epsil are both
           .true., the effective charges are calculated. If ldisp is
           .true., trans=.false. is overridden (except for the case of
           electron-phonon calculations)

         * **xq1** (*float** | **FloatKey*) -- First component of the
           phonon wavevector, in units of 2pi/a0 (a0 = lattice
           parameter). Not used if ldisp=.true. or qplot=.true.

         * **xq2** (*float** | **FloatKey*) -- Second component of the
           phonon wavevector, in units of 2pi/a0 (a0 = lattice
           parameter). Not used if ldisp=.true. or qplot=.true.

         * **xq3** (*float** | **FloatKey*) -- Third component of the
           phonon wavevector, in units of 2pi/a0 (a0 = lattice
           parameter). Not used if ldisp=.true. or qplot=.true.

   class _PP_X

      This section configures the parameters for running the QE-
      utility "pp.x" (see https://www.quantum-
      espresso.org/Doc/INPUT_PP.html). This utility reads the output
      produced by "pw.x", extracts and calculates the desired
      quantity/quantities (rho, V, ...), and then writes the desired
      quantity to file in a suitable format for various types of
      plotting and various plotting programs. Only a few options are
      supported at the moment.

      Variables:
         **plot_num** (*int** | **IntKey*) -- Selects what to save in
         filplot. See "pp.x" documentation for more details.

   class _PROJWFC_X

      This section configures the parameters for running the QE-
      utility "projwfc.x" (see https://www.quantum-
      espresso.org/Doc/INPUT_PROJWFC.html). This utility projects
      wavefunctions onto orthogonalized atomic wavefunctions,
      calculates Lowdin charges, spilling parameter, projected DOS
      (separated into up and down components for LSDA).

      Variables:
         * **DeltaE** (*float** | **FloatKey*) -- Energy grid step.

         * **Emax** (*float** | **FloatKey*) -- Maximum energy for DOS
           plot. If unspecified, the upper band value, plus 3 times
           the value of the gaussian smearing if present, will be
           used.

         * **Emin** (*float** | **FloatKey*) -- Minimum energy for DOS
           plot. If unspecified, the lower band value, minus 3 times
           the value of the gaussian smearing if present, will be
           used.

         * **degauss** (*float** | **FloatKey*) -- Gaussian
           broadening. If not set, the default value is determined by
           the choice you make for "DOS_X%bz_sum", and it may also be
           influenced by related variables used in the previous 'pw.x'
           run. For more information, consult the original Quantum
           Espresso documentation at this link: https://www.quantum-
           espresso.org/Doc/INPUT_PROJWFC.html.

         * **diag_basis** (*BoolType** | **BoolKey*) -- If False, the
           projections of Kohn-Sham states are done on the
           orthogonalized atomic orbitals in the global XYZ coordinate
           frame. If True, the projections of Kohn-Sham states are
           done on the orthogonalized atomic orbitals that are rotated
           to the basis in which the atomic occupation matrix is
           diagonal (i.e. local XYZ coordinate frame).

         * **lsym** (*BoolType** | **BoolKey*) -- If True, the
           projections are symmetrized, the partial density of states
           are computed. If False the projections are not symmetrized,
           the partial DOS can be computed only in the k-resolved case

         * **ngauss** (*Literal**[**"0"**, **"SimpleGaussian"**,
           **"1"**, **"Methfessel-Paxton"**, **"-1"**,
           **"ColdSmearing"**, **"-99"**, **"Fermi-Dirac"**,
           **"Default"**]*) --

           Type of gaussian broadening: Available options are:

           * SimpleGaussian.

           * Methfessel-Paxton: Methfessel-Paxton of order 1.

           * ColdSmearing: Marzari-Vanderbilt-DeVita-Payne.

           * Fermi-Dirac: Fermi-Dirac function.

           * Default: The default value is determined by the choices
             you make for "DOS_X%bz_sum" and "DOS_X%degauss", and it
             may also be influenced by related variables used in the
             previous 'pw.x' run. For more information, consult the
             original Quantum Espresso documentation at this link:
             https://www.quantum-espresso.org/Doc/INPUT_PROJWFC.html.

   class _Phonons

      This section configures the parameters for calculating the
      Phonon Structure. This involves utilizing the following
      utilities:

      * "kpath": This AMS tool generates an automated high-symmetry
        k-path in the Brillouin zone.

      * "ph.x": This utility from Quantum ESPRESSO (QE) calculates
        phonon frequencies and eigenvectors at specified q-points
        (wavevectors) using Density Functional Perturbation Theory
        (DFPT). For more details see https://www.quantum-
        espresso.org/Doc/INPUT_PH.html

      * "q2r.x": This QE utility transforms the dynamical matrix from
        reciprocal space (q-space) to real space (r-space). This is
        necessary for further post-processing steps. For more details
        see https://www.quantum-espresso.org/Doc/INPUT_Q2R.html.

      * "matdyn.x": This QE utility calculates various phonon-related
        properties from the real-space dynamical matrix, such as
        phonon dispersion curves, density of states (DOS),
        thermodynamic properties, and more. For more details see
        https://www.quantum-espresso.org/Doc/INPUT_MATDYN.html.

      Variables:
         * **MaxTemperature** (*float** | **FloatKey*) -- Maximum
           temperature for the thermodynamic properties calculation
           (Internal Energy, Free Energy, Specific Heat, and Entropy).
           This value sets the upper limit of the temperature range
           considered. It is used in conjunction with "NTemperatures"
           to define the temperature grid. The calculation of
           thermodynamic properties is performed only if the phonon
           density of states (DOS) is requested (i.e., "Phonons%DOS"
           is set to "Yes").

         * **NTemperatures** (*int** | **IntKey*) -- Number of
           temperature points to use in the thermodynamic properties
           calculation (Internal Energy, Free Energy, Specific Heat,
           and Entropy). This value, along with "MaxTemperature",
           determines the density of the temperature grid.  The
           temperatures will be distributed evenly between 0 Kelvin
           and 'MaxTemperature'. The calculation of thermodynamic
           properties is performed only if the phonon density of
           states (DOS) is requested (i.e., "Phonons%DOS" is set to
           "Yes").

         * **asr** (*Literal**[**"simple"**, **"crystal"**,
           **"no"**]*) -- Determines the acoustic sum rule (ASR)
           treatment. It has three options: * 'simple':  Applies a
           simplified ASR where the frequencies of the three acoustic
           modes at q=0 are forced to be zero. * 'crystal': Applies
           the ASR considering the crystal symmetry to impose
           constraints on the frequencies at q=0. * 'no':  Does not
           enforce any ASR. It overwrites "PH_X%asr" (setting it to
           .TRUE. if asr is not 'no'), "Q2R_X%zasr", and
           "MATDYN_X%asr". Notice that the default value is different
           than in standard QE (default 'simple').

         * **k1** (*int** | **IntKey*) -- If specified, triggers a
           non-self-consistent calculation in *ph.x* with a separate
           Monkhorst-Pack k-point grid for phonons. This sets the
           k-point grid offset along the first reciprocal lattice
           vector for that grid.

         * **k2** (*int** | **IntKey*) -- If specified, triggers a
           non-self-consistent calculation in *ph.x* with a separate
           Monkhorst-Pack k-point grid for phonons. This sets the
           k-point grid offset along the second reciprocal lattice
           vector for that grid.

         * **k3** (*int** | **IntKey*) -- If specified, triggers a
           non-self-consistent calculation in *ph.x* with a separate
           Monkhorst-Pack k-point grid for phonons. This sets the
           k-point grid offset along the third reciprocal lattice
           vector for that grid.

         * **nk1** (*int** | **IntKey*) -- If specified, triggers a
           non-self-consistent calculation in *ph.x* with a separate
           Monkhorst-Pack k-point grid for phonons. This sets the
           number of k-points along the first reciprocal lattice
           vector for that grid.

         * **nk2** (*int** | **IntKey*) -- If specified, triggers a
           non-self-consistent calculation in *ph.x* with a separate
           Monkhorst-Pack k-point grid for phonons. This sets the
           number of k-points along the second reciprocal lattice
           vector for that grid.

         * **nk3** (*int** | **IntKey*) -- If specified, triggers a
           non-self-consistent calculation in *ph.x* with a separate
           Monkhorst-Pack k-point grid for phonons. This sets the
           number of k-points along the third reciprocal lattice
           vector for that grid.

         * **nq1** (*int** | **IntKey*) -- Sets the number of q-points
           along the first reciprocal lattice vector for the
           Monkhorst-Pack q-point grid for phonons. Default 1. Notice
           that this default is different than in standard QE (default
           0).

         * **nq2** (*int** | **IntKey*) -- Sets the number of q-points
           along the second reciprocal lattice vector for the
           Monkhorst-Pack q-point grid for phonons. Default 1. Notice
           that this default is different than in standard QE (default
           0).

         * **nq3** (*int** | **IntKey*) -- Sets the number of q-points
           along the third reciprocal lattice vector for the
           Monkhorst-Pack q-point grid for phonons. Default 1. Notice
           that this default is different than in standard QE (default
           0).

         * **BandStructure**
           (*QuantumESPRESSO._Phonons._BandStructure*) -- This section
           configures the parameters for calculating the Phonons Band
           Structure.

         * **DOS** (*QuantumESPRESSO._Phonons._DOS*) -- Configures the
           parameters for calculating the Phonons DOS.

         * **K_Points** (*str** | **Sequence**[**str**] **|
           **FreeBlock*) -- When these block is specified the phonon
           program ("ph.x") runs a pw non-self consistent calculation
           with a different k-point grid thant that used for the
           charge density. The only available header values are
           "automatic" or "gamma". See the examples and QE
           documentation for details. This parameter is equivalent to
           "nk1, nk2, nk3, k1, k2, k3" in the QE tool "ph.x". If
           omitted, "ph.x" will use the same k-point grid used in the
           main QE calculation.

         * **Q_Points** (*str** | **Sequence**[**str**] **|
           **FreeBlock*) -- Defines the Monkhorst-Pack grid (no
           offset) for sampling the Brillouin zone in the phonon
           calculation. The grid determines the density of q-points at
           which phonon frequencies will be calculated. It is used
           when DOS or BandStructure phonon properties are requested.
           The only available header values are "automatic" or
           "gamma". See the examples and QE documentation for details.
           This parameter is equivalent to "nq1, nq2, nq3" in the QE
           tool "ph.x". If omitted, only "gamma" ("1 1 1 0 0 0") is
           used.

      class _BandStructure

         This section configures the parameters for calculating the
         Phonons Band Structure.

         Variables:
            * **KPathFinderConvention** (*Literal**[**"Setyawan-
              Curtarolo"**, **"Hinuma"**]*) --

              This option determines how the path through the
              Brillouin zone is generated when using the automatic
              k-point mode.

              Available options:

              * "Setyawan-Curtarolo" (default for 1D and 2D lattices):
                Uses our built-in KPath program to find a path through
                high-symmetry points based on the method by Setyawan
                and Curtarolo
                (https://doi.org/10.1016/j.commatsci.2010.05.010). For
                2D lattices, the path is derived from the intersection
                of the 3D Brillouin zone with a plane. For 1D
                lattices, the path is simply "GAMMA-Z".

              * "Hinuma": Uses the external SeeKPath utility to
                generate the k-path
                (https://github.com/giovannipizzi/seekpath and
                https://doi.org/10.1016/j.commatsci.2016.10.015).

            * **Q_PointsLabels** (*str** | **StringKey*) -- You can
              provide labels for your q-points, like
              "L-GAMMA-X-U-GAMMA", separating each label with a hyphen
              (-) or a vertical bar (|). For example,
              "L-GAMMA-X-U-GAMMA" and "L|GAMMA|X|U|GAMMA" are both
              valid. These labels are optional and only used for
              display purposes when the "Q_Points" block is specified.
              This option is used only if the header of the "Q_Points"
              block is not "ams_kpath". **Important:** These labels do
              not determine the actual k-point coordinates. You must
              specify the q-point coordinates separately within the
              "Q_Points" section.

            * **Q_PointsStep** (*float** | **FloatKey*) -- This option
              is used only if the header of the
              "Phonons%BandStructure%Q_Points" block is "ams_kpath".

            * **UseSymmetry** (*BoolType** | **BoolKey*) -- If set,
              only the irreducible wedge of the Wigner-Seitz cell is
              sampled. If not, the whole (inversion-unique) Wigner-
              Seitz cell is sampled. Only available for Setyawan and
              Curtarolo convention (see "KPathFinderConvention").

            * **Q_Points** (*str** | **Sequence**[**str**] **|
              **FreeBlock*) -- Specify the q-points to use. Available
              header values are: "crystal_b", and "ams_kpath". See the
              examples and QE documentation for details. If omitted,
              "ams_kpath" is used.

         class _Q_Points

            Specify the q-points to use. Available header values are:
            "crystal_b", and "ams_kpath". See the examples and QE
            documentation for details. If omitted, "ams_kpath" is
            used.

      class _DOS

         Configures the parameters for calculating the Phonons DOS.

         Variables:
            * **degauss** (*float** | **FloatKey*) -- DOS broadening
              in cm-1. Default: 0 - meaning use tetrahedra. It
              overwrites "MATDYN_X%degauss".

            * **deltaE** (*float** | **FloatKey*) -- Energy step, in
              cm-1, for DOS calculation: from min to max phonon energy
              (default: 1 cm-1). It overwrites "MATDYN_X%deltaE".

            * **nq1** (*int** | **IntKey*) -- Uniform q-point grid for
              DOS calculation (includes q=0). First direction. It
              overwrites "MATDYN_X%nk1".

            * **nq2** (*int** | **IntKey*) -- Uniform q-point grid for
              DOS calculation (includes q=0). Second direction. It
              overwrites "MATDYN_X%nk2".

            * **nq3** (*int** | **IntKey*) -- Uniform q-point grid for
              DOS calculation (includes q=0). Third direction. It
              overwrites "MATDYN_X%nk3".

            * **Q_Points** (*str** | **Sequence**[**str**] **|
              **FreeBlock*) -- Specify the q-points to use. Only the
              header "automatic" is allowed. This option is added for
              consistency, it is equivalent to set "nq1", "nq2", and
              "nq3" independently.

         class _Q_Points

            Specify the q-points to use. Only the header "automatic"
            is allowed. This option is added for consistency, it is
            equivalent to set "nq1", "nq2", and "nq3" independently.

      class _K_Points

         When these block is specified the phonon program ("ph.x")
         runs a pw non-self consistent calculation with a different
         k-point grid thant that used for the charge density. The only
         available header values are "automatic" or "gamma". See the
         examples and QE documentation for details. This parameter is
         equivalent to "nk1, nk2, nk3, k1, k2, k3" in the QE tool
         "ph.x". If omitted, "ph.x" will use the same k-point grid
         used in the main QE calculation.

      class _Q_Points

         Defines the Monkhorst-Pack grid (no offset) for sampling the
         Brillouin zone in the phonon calculation. The grid determines
         the density of q-points at which phonon frequencies will be
         calculated. It is used when DOS or BandStructure phonon
         properties are requested. The only available header values
         are "automatic" or "gamma". See the examples and QE
         documentation for details. This parameter is equivalent to
         "nq1, nq2, nq3" in the QE tool "ph.x". If omitted, only
         "gamma" ("1 1 1 0 0 0") is used.

   class _Properties

      Configures which QE level properties to calculate for
      SinglePoint calculations or other important geometries (e.g. at
      the end of an optimization).

      Variables:
         * **BandStructure** (*BoolType** | **BoolKey*) -- If true,
           the band structure is calculated and saved for
           visualization. To configure the parameters of the
           calculation, please modify the options in the the section
           'BandStructure'.

         * **DOS** (*BoolType** | **BoolKey*) -- If true, the Density-
           Of-States (DOS) is calculated and saved for visualization.
           To configure the parameters of the calculation, please
           modify the options in the the section 'DOS'.

         * **ForceStopAfterError** (*BoolType** | **BoolKey*) -- If
           set to true, and a Quantum Espresso property calculation
           fails, the entire job will stop, preventing any subsequent
           property calculations from running. If set to false
           (default), other property calculations will proceed even if
           one fails.

         * **MagneticAnisotropyEnergy** (*BoolType** | **BoolKey*) --
           If true, the Magnetic Anisotropy Energy (MAE) is calculated
           and saved for visualization. To configure the parameters of
           the calculation, please modify the options in the the
           section 'MagneticAnisotropyEnergy'.

         * **WorkFunction** (*BoolType** | **BoolKey*) -- If true, the
           work function is calculated and saved for visualization. To
           configure the parameters of the calculation, please modify
           the options in the the section 'WorkFunction'.

   class _Pseudopotentials

      Selects the pseudopotential to use for the atomic species.

      Variables:
         * **Database** (*str** | **StringKey*) -- Specifies the file
           name of the pseudopotential database located in
           $AMSRESOURCES/QE

         * **Directory** (*str** | **Path** | **StringKey*) --

           This key is mutually exclusive with the "Family" and
           "Files" keywords. This key specifies a directory containing
           label.upf files.

           Example:

              System
                 Atoms
                   H 0 0 0
                   H 0 0 1 QE.Label=H1
                   H 0 0 2 QE.Label=H2
                   C 0 0 3 QE.Label=C1
                 End
               End

           This will look for the files H.upf, H1.upf, H2.upf, C1.upf.
           If H1.upf does not exist, H.upf will be used. If H2.upf
           does not exist, H.upf will be used. If C1.upf does not
           exist, C.upf will be used.

         * **Family** (*Literal**[**"Dojo"**, **"GBRV"**,
           **"pslibrary-PAW"**, **"pslibrary-US"**, **"SG15"**,
           **"SSSP-Efficiency"**, **"SSSP-Precision"**]*) -- The
           pseudopotential family to use. Mutually exclusive with the
           "Files" and "Directory" keywords.

         * **FullyRelativistic** (*BoolType** | **BoolKey*) -- Whether
           to use fully relativistic pseudopotentials (required for
           spin-orbit calculations).

         * **Functional** (*Literal**[**"BLYP"**, **"LDA"**,
           **"PBE"**, **"PBEsol"**, **"PW91"**]*) --

           Exchange-correlation functional that was used to generate
           the pseudopotential. Not all choices are valid for all
           pseudopotential families.

           This functional will also be used for the calculation,
           unless the "input_dft" option is set.

         * **Version** (*str** | **StringKey*) -- Version number for
           pseudopotentials. Currently, must be set to 'auto'.

         * **Files** (*QuantumESPRESSO._Pseudopotentials._Files*) --
           Selects the pseudopotentials to use for each atomic
           species. This key is mutually exclusive with the "Family"
           and "Directory" keywords.

      class _Files

         Selects the pseudopotentials to use for each atomic species.
         This key is mutually exclusive with the "Family" and
         "Directory" keywords.

         Variables:
            * **Label** (*str** | **StringKey*) -- Label for an atom
              corresponding to the QE.Label, or to the element symbol
              if QE.Label is not set.

            * **Path** (*str** | **Path** | **StringKey*) -- Path to a
              .upf file to use as pseudopotential. Relative paths are
              relative to root of the pseudopotential library shipped
              with AMS. Prefix a path with './' to make it relative to
              the starting directory of your job.

   class _Q2R_X

      This section configures the parameters for running the QE
      utility *q2r.x* (see https://www.quantum-
      espresso.org/Doc/INPUT_Q2R.html). This utility is used to
      transform the interatomic force constants (IFC) calculated in
      reciprocal space (q-space) by *ph.x* into real space (r-space).
      The real-space IFCs are then used as input for the *matdyn.x*
      utility to calculate various phonon-related properties.

      Variables:
         * **loto_2d** (*BoolType** | **BoolKey*) -- Set to .true. to
           activate two-dimensional treatment of LO-TO splitting

         * **zasr** (*Literal**[**"simple"**, **"crystal"**,
           **"no"**]*) -- Determines the acoustic sum rule (ASR)
           treatment. It has three options: * 'simple':  Applies a
           simplified ASR where the frequencies of the three acoustic
           modes at q=0 are forced to be zero. * 'crystal': Applies
           the ASR considering the crystal symmetry to impose
           constraints on the frequencies at q=0. * 'no':  Does not
           enforce any ASR.

   class _Restart

      This section configures restarting a Quantum Espresso
      calculation from previous data. You can restart from a specific
      Quantum Espresso results file (e.g., *quantumespresso.rkf*), or
      by providing the directory and file prefix of the previous
      calculation. This is compatible with any stand-alone Quantum
      Espresso version.

      Variables:
         * **Directory** (*str** | **Path** | **StringKey*) -- The
           directory containing the restart files from a previous
           Quantum Espresso calculation. This typically includes the
           *prefix.save* directory with wavefunctions and other data.
           This option is used in conjunction with the *Prefix*
           option.

         * **Path** (*str** | **Path** | **StringKey*) -- Path to the
           Quantum Espresso results file (e.g., *quantumespresso.rkf*)
           to use to restart the calculation.  When this option is
           used, the directory of the results file is used as the
           *Directory*, and the filename (without the *.rkf*
           extension) is used as the *Prefix*. This assumes all
           restart files (e.g., *prefix.save* directory) are in the
           same directory as the results file. This option is
           equivalent to the *EngineRestart* option.

         * **Prefix** (*str** | **StringKey*) -- The prefix used for
           the files in the previous calculation. This is usually the
           same as the 'prefix' specified in the input file of the
           original calculation. For example, if your files are named
           'my_calc.save' and 'my_calc.restart_scf', the prefix would
           be 'my_calc'. This option is used in conjunction with the
           *Directory* option.

   class _System

      Keywords from the &SYSTEM namelist in the QuantumEspresso input
      file.

      Variables:
         * **assume_isolated** (*Literal**[**"Auto"**, **"None"**,
           **"m-p"**, **"mp"**, **"Martyna-Tuckerman"**, **"m-t"**,
           **"mt"**, **"ESM"**, **"2D"**]*) --

           Used to perform calculation assuming the system to be
           isolated (a molecule or a cluster in a 3D supercell).

           Currently available choices:

           * Auto: determines the used method based on the periodicity
             of the system in the AMS driver input. None for systems
             3D periodicity, Martyna-Tuckerman for systems without a
             lattice.

           * None: regular periodic calculation w/o any correction.

           * Martyna-Tuckerman: correction to both total energy and
             scf potential. Adapted from: G.J. Martyna, and M.E.
             Tuckerman, A reciprocal space based method for treating
             long range interactions in ab-initio and force-field-
             based calculation in clusters, J. Chem. Phys. 110, 2810
             (1999), [doi:10.1063/1.477923].

           * ESM: Effective Screening Medium Method. For polarized or
             charged slab calculation, embeds the simulation cell
             within an effective semi-infinite medium in the
             perpendicular direction (along z). Embedding regions can
             be vacuum or semi-infinite metal electrodes (use esm_bc
             to choose boundary conditions). If between two
             electrodes, an optional electric field (esm_efield) may
             be applied. Method described in M. Otani and O. Sugino,
             'First-principles calculations of charged surfaces and
             interfaces: A plane-wave nonrepeated slab approach', PRB
             73, 115407 (2006).

           * 2D: Truncation of the Coulomb interaction in the z
             direction for structures periodic in the x-y plane. Total
             energy, forces and stresses are computed in a two-
             dimensional framework. Linear-response calculations ()
             done on top of a self-consistent calculation with this
             flag will automatically be performed in the 2D framework
             as well. Please refer to: Sohier, T., Calandra, M., &
             Mauri, F. (2017), 'Density functional perturbation theory
             for gated two-dimensional heterostructures: Theoretical
             developments and application to flexural phonons in
             graphene', PRB, 96, 075448 (2017).

         * **degauss** (*float** | **FloatKey*) -- Value of the
           gaussian spreading for Brillouin-zone integration in
           metals.

         * **dftd3_threebody** (*BoolType** | **BoolKey*) --

           Turn three-body terms in Grimme-D3 on.

           If False two-body contributions only are computed, using
           two-body parameters of Grimme-D3.

           If dftd3_version is set to "2", three-body contribution is
           always disabled.

         * **dftd3_version** (*Literal**[**"2"**, **"3"**, **"4"**,
           **"5"**, **"6"**]*) --

           Version of Grimme implementation of Grimme-D3:

           * 2: Original Grimme-D2 parametrization

           * 3: Grimme-D3 (zero damping)

           * 4: Grimme-D3 (BJ damping)

           * 5: Grimme-D3M (zero damping)

           * 6: Grimme-D3M (BJ damping)

           * NOTE: not all functionals are parametrized.

         * **eamp** (*float** | **FloatKey*) --

           Amplitude of the electric field, in Hartree a.u. = =
           51.4220632*10^10 V/m.

           Used only if "tefield" is enabled.

           The saw-like potential increases with slope "eamp" in the
           region from ("emaxpos" + "eopreg"- 1) to ("emaxpos"), then
           decreases to 0 until ("emaxpos" + "eopreg"), in units of
           the crystal vector edir.

           Important: the change of slope of this potential must be
           located in the empty region, or else unphysical forces will
           result.

         * **ecutfock** (*float** | **FloatKey*) --

           Kinetic energy cutoff for the exact exchange operator in
           EXX type calculations.

           By default this is the same as "ecutrho" but in some EXX
           calculations, a significant speed-up can be obtained by
           reducing ecutfock, at the expense of some loss in accuracy.

           Must be >= "ecutwfc".

           Not implemented for stress calculation and for US-PP and
           PAW pseudopotentials.

           Use with care, especially in metals where it may give raise
           to instabilities.

         * **ecutrho** (*float** | **FloatKey*) --

           Kinetic energy cutoff for charge density and potential.

           If this key is not specified and the
           "Pseudopotential%Family" recommends a ratio of "ecutrho" to
           "ecutwfc", this recommended ratio will be used.

           If there is no recommended ratio, the default value is "4 x
           ecutwfc".

           For norm-conserving pseudopotential you should stick to the
           default value, you can reduce it by a little but it will
           introduce noise especially on forces and stress.

           If there are ultrasoft PP, a larger value than the default
           is often desirable ("ecutrho" = 8 to 12 times "ecutwfc",
           typically).

           PAW datasets can often be used at "4 x ecutwfc", but it
           depends on the shape of augmentation charge: testing is
           mandatory.

           The use of gradient-corrected functional, especially in
           cells with vacuum, or for pseudopotential without non-
           linear core correction, usually requires an higher values
           of "ecutrho" to be accurately converged.

         * **ecutvcut** (*float** | **FloatKey*) -- Reciprocal space
           cutoff for correcting Coulomb potential divergencies at
           small q vectors.

         * **ecutwfc** (*float** | **FloatKey*) -- Kinetic energy
           cutoff for wavefunctions.

         * **edir** (*Literal**[**"1"**, **"2"**, **"3"**, **"x"**,
           **"y"**, **"z"**]*) --

           "1" (or "x"), 2 (or "y") or 3 (or "z"). The direction of
           the electric field or dipole correction is parallel to the
           bg(:,edir) reciprocal lattice vector.

           Thus the potential is constant in planes defined by FFT
           grid points.

           Used only if "tefield" is enabled.

         * **emaxpos** (*float** | **FloatKey*) --

           Position of the maximum of the saw-like potential along
           crystal axis "edir", within the unit cell, see also
           "eopreg".

           0 < "emaxpos" < 1

           Used only if "tefield" is enabled.

         * **eopreg** (*float** | **FloatKey*) --

           Zone in the unit cell where the saw-like potential
           decreases, see also "amp".

           Must be in range 0 < "eopreg" < 1.

           Used only if "tefield" is enabled.

         * **esm_bc** (*Literal**[**"pbc"**, **"bc1"**, **"bc2"**,
           **"bc3"**]*) --

           If assume_isolated = 'esm', determines the boundary
           conditions used for either side of the slab. Currently
           available choices:

           * 'pbc': regular periodic calculation (no ESM).

           * 'bc1': Vacuum-slab-vacuum (open boundary conditions).

           * 'bc2': Metal-slab-metal (dual electrode configuration).
             See also *esm_efield*.

           * 'bc3' : Vacuum-slab-metal.

         * **exx_fraction** (*float** | **FloatKey*) --

           Fraction of EXX for hybrid functional calculations.

           In the case of "input_dft" set to 'PBE0', the default value
           is 0.25, while for "input_dft" set to 'B3LYP' the
           "exx_fraction" default value is 0.20.

         * **exxdiv_treatment** (*Literal**[**"gygi-baldereschi"**,
           **"vcut_spherical"**, **"vcut_ws"**, **"none"**]*) --

           Specific for EXX. It selects the kind of approach to be
           used for treating the Coulomb potential divergencies at
           small q vectors.

           gygi-baldereschi:  appropriate for cubic and quasi-cubic
           supercells

           vcut_spherical:  appropriate for cubic and quasi-cubic
           supercells

           vcut_ws: appropriate for strongly anisotropic supercells,
           see also ecutvcut.
              none:  sets Coulomb potential at G,q=0 to 0.0 (required
              for GAU-PBE)

         * **gcscf_conv_thr** (*float** | **FloatKey*) -- Convergence
           threshold of Fermi energy (eV) for GC-SCF.

         * **gcscf_mu** (*float** | **FloatKey*) -- Required if
           *lgcscf* is .TRUE.. The target Fermi energy (eV) of GC-SCF.
           One can start with appropriate total charge of the system
           by giving tot_charge.

         * **input_dft** (*str** | **StringKey*) --

           Exchange-correlation functional. Some valid values are •
           pbe • blyp • pbe0 • hse • revpbe • vdw-df-cx. See the
           documentation for more possible values.

           Overrides the value read from pseudopotential files.

         * **lgcscf** (*BoolType** | **BoolKey*) --

           If .TRUE. perform a constant bias potential (constant-mu)
           calculation with Grand-Canonical SCF. (JCP 146, 114104
           (2017), R.Sundararaman, et al.)

           •NB:

           * * The total energy displayed in output includes the
               potentiostat contribution (-mu*N).

           * * assume_isolated = 'esm' and esm_bc = 'bc2' or 'bc3'
               must be set in SYSTEM namelist.

           * * ESM-RISM is also supported (assume_isolated = 'esm' and
               esm_bc = 'bc1' and trism = .TRUE.).

           * * mixing_mode has to be 'TF' or 'local-TF', also its
               default is 'TF.'

           * * The default of mixing_beta is 0.1 with ESM-RISM, 0.2
               without ESM-RISM.

           * * The default of diago_thr_init is 1.D-5.

           * * diago_full_acc is always .TRUE. .

           * * diago_rmm_conv is always .TRUE. .

         * **lspinorb** (*BoolType** | **BoolKey*) -- if .TRUE. the
           noncollinear code can use a pseudopotential with spin-
           orbit.

         * **nbnd** (*int** | **IntKey*) --

           Number of electronic states (bands) to be calculated.  Note
           that in spin-polarized calculations the number of k-point,
           not the number of bands per k-point, is doubled.

           Default: For an insulator, nbnd = number of valence bands
           (nbnd = # of electrons /2); for a metal, 20% more (minimum
           4 more)

         * **noncolin** (*BoolType** | **BoolKey*) -- If True the
           program will perform a noncollinear calculation.

         * **nosym** (*BoolType** | **BoolKey*) -- If True, symmetry
           is not used, and k points are forced to have the symmetry
           of the Bravais lattice; an automatically generated
           Monkhorst-Pack grid will contain all points of the grid
           over the entire Brillouin Zone, plus the points rotated by
           the symmetries of the Bravais lattice which were not in the
           original grid. The same applies if a k-point list is
           provided in input instead of a Monkhorst-Pack grid. Time
           reversal symmetry is assumed so k and -k are equivalent
           unless noinv=.true. is specified. This option differs from
           nosym because it forces k-points in all cases to have the
           full symmetry of the Bravais lattice (not all uniform grids
           have such property!)

         * **nqx1** (*int** | **IntKey*) -- Three-dimensional mesh for
           q (k1-k2) sampling of the Fock operator (EXX). Can be
           smaller than the number of k-points.  Defaults to the size
           of the k-point mesh used.

         * **nqx2** (*int** | **IntKey*) -- Three-dimensional mesh for
           q (k1-k2) sampling of the Fock operator (EXX). Can be
           smaller than the number of k-points.  Defaults to the size
           of the k-point mesh used.

         * **nqx3** (*int** | **IntKey*) -- Three-dimensional mesh for
           q (k1-k2) sampling of the Fock operator (EXX). Can be
           smaller than the number of k-points.  Defaults to the size
           of the k-point mesh used.

         * **nr1** (*int** | **IntKey*) -- Three-dimensional FFT mesh
           (hard grid) for charge density (and scf potential). If not
           specified the grid is calculated based on the cutoff for
           charge density (see also "ecutrho"). Note: you must specify
           all three dimensions for this setting to be used ("nr1",
           "nr2", "nr3").

         * **nr1s** (*int** | **IntKey*) -- Three-dimensional mesh for
           wavefunction FFT and for the smooth part of charge density
           ( smooth grid ). Coincides with "nr1", "nr2", "nr3" if
           "ecutrho = 4 * ecutwfc" ( default ). Note: you must specify
           all three dimensions for this setting to be used ("nr1s",
           "nr2s", "nr3s").

         * **nr2** (*int** | **IntKey*) -- Three-dimensional FFT mesh
           (hard grid) for charge density (and scf potential). If not
           specified the grid is calculated based on the cutoff for
           charge density (see also "ecutrho"). Note: you must specify
           all three dimensions for this setting to be used ("nr1",
           "nr2", "nr3").

         * **nr2s** (*int** | **IntKey*) -- Three-dimensional mesh for
           wavefunction FFT and for the smooth part of charge density
           ( smooth grid ). Coincides with "nr1", "nr2", "nr3" if
           "ecutrho = 4 * ecutwfc" ( default ). Note: you must specify
           all three dimensions for this setting to be used ("nr1s",
           "nr2s", "nr3s").

         * **nr3** (*int** | **IntKey*) -- Three-dimensional FFT mesh
           (hard grid) for charge density (and scf potential). If not
           specified the grid is calculated based on the cutoff for
           charge density (see also "ecutrho"). Note: you must specify
           all three dimensions for this setting to be used ("nr1",
           "nr2", "nr3").

         * **nr3s** (*int** | **IntKey*) -- Three-dimensional mesh for
           wavefunction FFT and for the smooth part of charge density
           ( smooth grid ). Coincides with "nr1", "nr2", "nr3" if
           "ecutrho = 4 * ecutwfc" ( default ). Note: you must specify
           all three dimensions for this setting to be used ("nr1s",
           "nr2s", "nr3s").

         * **nspin** (*Literal**[**"1"**, **"None"**, **"2"**,
           **"Collinear"**, **"4"**, **"Non-Collinear"**]*) --

           Available options are:

           * None: not spin-polarized

           * Collinear: LSDA with magnetization along z-axis

           * Non-Collinear: any magnetization (equivalent to setting
             the "noncolin" key to True)

         * **occupations** (*Literal**[**"Smearing"**,
           **"Tetrahedra"**, **"Tetrahedra_lin"**,
           **"Tetrahedra_opt"**, **"Fixed"**]*) --

           Available options are:

           * Smearing: gaussian smearing for metals; see keywords
             "smearing" and "degauss"

           * Tetrahedra: Tetrahedron method, Bloechl's version: P.E.
             Bloechl, PRB 49, 16223 (1994). Requires uniform grid of
             k-points, to be automatically generated (see "block
             K_Points"). Well suited for calculation of DOS, less so
             (because not variational) for force/optimization/dynamics
             calculations.

           * Tetrahedra_lin: Original linear tetrahedron method. To be
             used only as a reference; the optimized tetrahedron
             method is more efficient.

           * Tetrahedra_opt: optimized tetrahedron method, see M.
             Kawamura, PRB 89, 094515 (2014). Can be used for phonon
             calculations as well.

           * Fixed: for insulators with a gap.

         * **screening_parameter** (*float** | **FloatKey*) --
           screening_parameter for HSE like hybrid functionals.  For
           more information, see: J. Chem. Phys. 118, 8207 (2003),
           doi:10.1063/1.1564060 J. Chem. Phys. 124, 219906 (2006),
           doi:10.1063/1.2204597

         * **smearing** (*Literal**[**"Gaussian"**, **"gauss"**,
           **"Methfessel-Paxton"**, **"m-p"**, **"mp"**, **"Marzari-
           Vanderbilt"**, **"cold"**, **"m-v"**, **"mv"**, **"Fermi-
           Dirac"**, **"f-d"**, **"fd"**]*) --

           Available options are:

           * Gaussian: ordinary Gaussian spreading

           * Methfessel-Paxton: first-order spreading (see PRB 40,
             3616 (1989))

           * Marzari-Vanderbilt: cold smearing (see PRL 82, 3296
             (1999))

           * Fermi-Dirac: smearing with Fermi-Dirac function

         * **tot_magnetization** (*float** | **FloatKey*) --

           Total majority spin charge minus minority spin charge.

           Used to impose a specific total electronic magnetization.

           If unspecified then tot_magnetization variable is ignored
           and the amount of electronic magnetization is determined
           during the self-consistent cycle.

         * **vdw_corr** (*Literal**[**"None"**, **"Grimme-D2"**,
           **"DFT-D"**, **"Grimme-D3"**, **"DFT-D3"**, **"TS"**,
           **"ts-vdW"**, **"tkatchenko-scheffler"**, **"MBD"**,
           **"many-body-dispersion"**, **"mbd_vdw"**, **"XDM"**]*) --

           Type of Van der Waals correction. Allowed values:

           * Grimme-D2: Semiempirical Grimme's DFT-D2, see S. Grimme,
             J. Comp. Chem. 27, 1787 (2006) [doi:10.1002/jcc.20495],
             and V. Barone et al., J. Comp. Chem. 30, 934 (2009)
             [doi:10.1002/jcc.21112].

           * Grimme-D3: Semiempirical Grimme's DFT-D3, see S. Grimme
             et al, J. Chem. Phys 132, 154104 (2010)
             [doi:10.1063/1.3382344].

           * TS: Tkatchenko-Scheffler dispersion corrections with
             first-principle derived C6 coefficients, see A.
             Tkatchenko and M. Scheffler, PRL 102, 073005 (2009).

           * MBD: Many-body dispersion (MBD) correction to long-range
             interactions, see A. Ambrosetti, A. M. Reilly, R. A.
             DiStasio, A. Tkatchenko, J. Chem. Phys. 140 18A508
             (2014).

           * XDM: Exchange-hole dipole-moment model, see A. D. Becke
             et al., J. Chem. Phys. 127, 154108 (2007)
             [doi:10.1063/1.2795701], and A. Otero de la Roza et al.,
             J. Chem. Phys. 136, 174109 (2012)
             [doi:10.1063/1.4705760].

           Note that non-local functionals (eg vdw-DF) are NOT
           specified here but using the "input_dft" keyword.

         * **x_gamma_extrapolation** (*BoolType** | **BoolKey*) --
           Specific for EXX. If .true., extrapolate the G=0 term of
           the potential (see README in examples/EXX_example for more)
           Set this to .false. for GAU-PBE.

         * **xdm_a1** (*float** | **FloatKey*) --

           Damping function parameter a1 (adimensional).

           It is NOT necessary to give a value if the functional is
           one of B86bPBE, PW86PBE, PBE, BLYP. For functionals in this
           list, the coefficients are given in:
           http://schooner.chem.dal.ca/wiki/XDM; A. Otero de la Roza,
           E. R. Johnson, J. Chem. Phys. 138, 204109 (2013)
           [doi:10.1063/1.4705760]

         * **xdm_a2** (*float** | **FloatKey*) --

           Damping function parameter a2 (Angstrom).

           It is NOT necessary to give a value if the functional is
           one of B86bPBE, PW86PBE, PBE, BLYP. For functionals in this
           list, the coefficients are given in:
           http://schooner.chem.dal.ca/wiki/XDM; A. Otero de la Roza,
           E. R. Johnson, J. Chem. Phys. 138, 204109 (2013)
           [doi:10.1063/1.4705760]

         * **starting_magnetization**
           (*QuantumESPRESSO._System._starting_magnetization*) --

           Starting spin polarization for an atomic type in a spin
           polarized (LSDA or noncollinear/spin-orbit) calculation.
           Allowed values range between -1 (all spins down for the
           valence electrons of atom type 'i') to 1 (all spins up). If
           you expect a nonzero magnetization in your ground state,
           you MUST either specify a nonzero value for at least one
           atomic type, or constrain the magnetization using keyword
           "tot_magnetization" for LSDA, "constrained_magnetization"
           for noncollinear/spin-orbit calculations. If you don't, you
           will get a nonmagnetic (zero magnetization) state. In order
           to perform LSDA calculations for an antiferromagnetic
           state, define two different atomic species corresponding to
           sublattices of the same atomic type.

           Note: If you fix the magnetization with
           "tot_magnetization", do not specify
           "starting_magnetization".

           Note: In the noncollinear/spin-orbit case, starting with
           zero starting_magnetization on all atoms imposes time
           reversal symmetry. The magnetization is never calculated
           and is set to zero.

      class _starting_magnetization

         Starting spin polarization for an atomic type in a spin
         polarized (LSDA or noncollinear/spin-orbit) calculation.
         Allowed values range between -1 (all spins down for the
         valence electrons of atom type 'i') to 1 (all spins up). If
         you expect a nonzero magnetization in your ground state, you
         MUST either specify a nonzero value for at least one atomic
         type, or constrain the magnetization using keyword
         "tot_magnetization" for LSDA, "constrained_magnetization" for
         noncollinear/spin-orbit calculations. If you don't, you will
         get a nonmagnetic (zero magnetization) state. In order to
         perform LSDA calculations for an antiferromagnetic state,
         define two different atomic species corresponding to
         sublattices of the same atomic type.

         Note: If you fix the magnetization with "tot_magnetization",
         do not specify "starting_magnetization".

         Note: In the noncollinear/spin-orbit case, starting with zero
         starting_magnetization on all atoms imposes time reversal
         symmetry. The magnetization is never calculated and is set to
         zero.

         Variables:
            * **Label** (*str** | **StringKey*) -- Label for an atom
              corresponding to the QE.Label, or to the element symbol
              if QE.Label is not set.

            * **Value** (*float** | **FloatKey*) -- Starting
              magnetization value.

   class _WorkFunction

      This section configures the parameters for calculating the Work
      Function. This involves utilizing the following utilities:

      * "pp.x": Calculates the the electrostatic potential using the
        results from the last Quantum ESPRESSO calculation.

      * "average.x": Performs planar and macroscopic averages of the
        electrostatic potential along a specified direction, which are
        crucial for determining the vacuum level and subsequently the
        work function.

      Variables:
         * **awin** (*float** | **FloatKey*) -- The size of the window
           for macroscopic average (a.u.).

         * **centralize** (*BoolType** | **BoolKey*) -- Translates the
           calculated electrostatic potential along the "idir"
           coordinate, respecting periodic boundary conditions, so
           that the geometric center of the system is at the center of
           the coordinate.

         * **idir** (*Literal**[**"1"**, **"2"**, **"3"**, **"x"**,
           **"y"**, **"z"**]*) -- "1" (or "x"), 2 (or "y") or 3 (or
           "z"). Planar average is done in the plane orthogonal to
           direction "idir", as defined for the crystal cell. The
           "idir" parameter defaults to the value of "System%edir" if
           it's set. Otherwise, "idir" is set to 3.

         * **npt** (*int** | **IntKey*) -- Number of points used for
           the final interpolation of the planar and macroscopic
           averages of the electrostatic potential. This controls the
           resolution of the averaged potential data. If npt is less
           than or equal to N_idir (the number of FFT grid points
           along the specified direction), no interpolation is
           performed and the raw FFT data is used. The default value
           is 10 * N_idir, which typically provides sufficient
           resolution for accurate work function calculations.

class ReaxFF

   Variables:
      * **BondDistanceCutoff** (*float** | **FloatKey*) -- Maximum
        distance between two atoms to be considered when searching for
        possible bonds.

      * **BondOrderCutoff** (*float** | **FloatKey*) -- Minimum bond
        order required for a bond to be considered during the
        evaluation of the 3- and 4-body potentials.

      * **ComputeAtomicPressure** (*BoolType** | **BoolKey*) --
        Compute the virial part of the atomic pressure (the kinetic
        part cannot be computed by the engine).

      * **FeDimerCorrection** (*BoolType** | **BoolKey*) -- Add a
        special correction term for Fe-Fe dimers.

      * **ForceField** (*str** | **Path** | **StringKey*) -- Path to
        the force field parameter file. The path can be absolute or
        relative. Relative paths starting with ./ are considered
        relative to the directory in which the calculation is started,
        otherwise they are considered relative to
        $AMSRESOURCES/ForceFields/ReaxFF.

      * **FurmanTorsions** (*BoolType** | **BoolKey*) -- Use
        (sin(Theta_ijk)*sin(Theta_jkl))^3 instead of
        sin(Theta_ijk)*sin(Theta_jkl) in the torsion energy term to
        remove discontinuity in the corresponding force.

      * **NonReactive** (*BoolType** | **BoolKey*) -- Enable the non-
        reactive mode. Bonds are determined only once at the beginning
        and subsequent steps only update their bond orders. Thus, no
        new bonds can form during the simulation, but existing bonds
        can still stretch and dissociate.

      * **RemapSkin** (*float** | **FloatKey*) -- Thickness of region
        around the unit cell into which atoms are allowed to move
        before being internally remapped back into the unit
        cell.Defaults to VerletListSkin if not set. Should never be
        smaller than VerletListSkin.

      * **ReturnCorrectedBonds** (*BoolType** | **BoolKey*) -- When
        enabled, the bonds returned to the driver are based on the
        final bond orders that include valence-dependent correction
        terms. Disable this if you want to see the raw uncorrected
        bond orders instead.

      * **StrongBondCutoff** (*float** | **FloatKey*) -- Minimum bond
        order required for a bond to be returned to the driver for
        bonding analysis and molecule detection. Bonds below this
        threshold are only used to evaluate the potential and not
        written to result files.

      * **TaperBO** (*BoolType** | **BoolKey*) -- Use tapered bond
        orders by Furman & Wales (DOI: 10.1021/acs.jpclett.9b02810).

      * **Torsions** (*Literal**[**"Original"**, **"2013"**]*) --
        Version of the torsion potential expression.

      * **VerletListSkin** (*float** | **FloatKey*) -- Thickness of
        the buffer region added to the force-field-defined non-bonded
        cutoff radius when building the Verlet list.

      * **Charges** (*ReaxFF._Charges*) -- Settings for the
        polarizable charge model.

   class _Charges

      Settings for the polarizable charge model.

      Variables:
         * **AllowSmallCellACKS2** (*BoolType** | **BoolKey*) --
           EXPERIMENTAL: Let ACKS2 run even with a periodic cell
           thinner than the bond softness cutoff.

         * **DisableChecks** (*BoolType** | **BoolKey*) -- Disable
           checks for suspicious or unphysical charges.

         * **Fix** (*BoolType** | **BoolKey*) -- REB: Fix certain atom
           charges, if those atoms are specified with MOLCHARGE (not
           yet possible with AMS-REAXFF

         * **Solver** (*Literal**[**"Direct"**, **"CG"**,
           **"MINRESQLP"**, **"SparseCG"**, **"None"**]*) -- Algorithm
           used to solve the charge equilibration equations.

         * **Constraint** (*ReaxFF._Charges._Constraint*) -- Constrain
           the net charge of a given region.

         * **Converge** (*ReaxFF._Charges._Converge*) -- Controls the
           convergence criteria for charge equilibration.

         * **Predictor** (*ReaxFF._Charges._Predictor*) -- Settings
           for the prediction of new charges before running the
           solver.

      class _Constraint

         Constrain the net charge of a given region.

         Variables:
            * **Charge** (*float** | **FloatKey*) -- Desired net
              charge of the region.

            * **Region** (*str** | **StringKey*) -- Name of the region
              to be constrained.

      class _Converge

         Controls the convergence criteria for charge equilibration.

         Variables:
            **Charge** (*float** | **FloatKey*) -- Requested upper
            bound on the sum of squared charge residuals.

      class _Predictor

         Settings for the prediction of new charges before running the
         solver.

         Variables:
            **Method** (*Literal**[**"None"**, **"Simple"**]*) --
            Method used to predict the charges.

class VASP

   Variables:
      * **CHGCARFile** (*str** | **Path** | **StringKey*) -- Use a
        custom CHGCAR file for initializing the charge density. Note:
        You must also set ICHARG to an appropriate value for this
        CHGCAR file to be read by VASP.

      * **EnergyChoice** (*Literal**[**"FreeEnergy"**,
        **"EnergyWithoutEntropy"**, **"EnergySigmaToZero"**]*) -- The
        energy from the VASP output which is used with the AMS driver.

      * **EnergyCutoff** (*float** | **FloatKey*) --

        The energy cutoff for the plane wave basis set.

        VASP keyword: ENCUT

      * **INCARFile** (*str** | **Path** | **StringKey*) -- Use a
        custom INCAR file. The keywords NSW, IBRION, ISIF, and LWAV
        must not be set in this INCAR file, since they are controlled
        by the AMS driver.

      * **KPOINTSFile** (*str** | **Path** | **StringKey*) -- Use a
        custom KPOINTS file. This will override any other settings
        related to the k-point sampling.

      * **KPOINTSOrigin** (*Literal**[**"Gamma-centered"**,
        **"Monkhorst-Pack"**]*) --

        Type of regular k-point grid. Gamma-centered k-point grids
        always include the Gamma point, whereas Monkhorst-Pack grids
        do not include the Gamma point if any of the k-point grid
        dimensions is even.

        To use a custom set of k-points, or to specify paths in the
        Brillouin zone, prepare such a KPOINTS file manually and set
        the KPOINTSFile setting.

      * **LDAU** (*BoolType** | **BoolKey*) -- Enables a DFT+U
        calculation. The options LMAXMIX, LDAUType, LDAUU, LDAUJ, and
        LDAUL must also be set.

      * **LDAUJ** (*Iterable**[**float**] **| **FloatListKey*) --

      * **LDAUL** (*str** | **StringKey*) --

      * **LDAUType** (*Literal**[**"1"**, **"2"**, **"3"**, **"4"**]*)
        --

        1: The rotationally invariant DFT+U introduced by
        Liechtenstein et al. 2: The simplified (rotationally
        invariant) approach to DFT+U, introduced by Dudarev et al. 4:
        Same as type 1, but without exchange splitting.

        VASP keyword: LDAUTYPE.

      * **LDAUU** (*Iterable**[**float**] **| **FloatListKey*) --

      * **LMAXMIX** (*int** | **IntKey*) -- VASP keyword: LMAXMIX

      * **Occupation** (*Literal**[**"Gaussian"**, **"Fermi"**,
        **"ReadFromWAVECAR"**, **"ReadFromINCAR"**,
        **"1stOrderMethfesselPaxton"**,
        **"2ndOrderMethfesselPaxton"**,
        **"TetrahedronMethodWithoutSmearing"**,
        **"TetrahedronMethodWithBlochlCorrections"**,
        **"TetrahedronMethodWithSmearing"**,
        **"TetrahedronMethodWithBlochlCorrectionsAndSmearing"**]*) --

        Type of electronic smearing (fractional occupation scheme).

        VASP keyword: ISMEAR

      * **POTCARLibrary** (*str** | **Path** | **StringKey*) --

        Path to the POTCAR (pseudopotential) library, as delivered
        with VASP. This library must be accessible on the machine
        currently running AMSinput.

        For example, setting this to /library/PBE/PAW/ will use
        /library/PBE/PAW/Cu/POTCAR as the POTCAR file for Cu atoms by
        default.

        Can also be left empty if VASP_PP_PATH is set as an
        environment variable.

        Special POTCARs (e.g. H.5 instead of H) can be used for
        individual atoms by using the vasp.label atom label.
        Alternatively, custom POTCAR files can be specified using the
        POTCAROverride tag.

      * **Precision** (*Literal**[**"Single"**, **"SingleN"**,
        **"Normal"**, **"Accurate"**]*) --

        Adjusts the default cutoff energy and FFT grid spacing, and
        the accuracy of the projectors in real space. SingleN is only
        available for VASP 6.x.

        VASP keyword: PREC

      * **Smearing** (*float** | **FloatKey*) -- VASP keyword: SIGMA

      * **SpinPolarization** (*BoolType** | **BoolKey*) -- Determines
        if a spin-polarized calculation is performed. If set, the VASP
        keyword ISPIN is set to 2.

      * **VASPExec** (*str** | **StringKey*) --

        Command used to execute VASP.

        For example: mpirun -np 4 vasp

        Can also be left empty if VASP_COMMAND is set as an
        environment variable.

      * **Verbosity** (*BoolType** | **BoolKey*) -- If set, more
        detailed information is printed in the EngineVASP.log file.

      * **WAVECARFile** (*str** | **Path** | **StringKey*) --

        Path to a WAVECAR (wavefunction) file from a previous
        calculation that is used to initialize the present
        calculation.

        If specified, the file will be copied into the new calculation
        directory and the VASP keyword ISTART will be set to 1.

      * **XC** (*Literal**[**"Auto"**, **"LDA"**, **"BLYP"**,
        **"PW91"**, **"PBE"**, **"PS"**, **"RE"**, **"RP"**, **"AM"**,
        **"91"**, **"B3"**, **"B5"**, **"BF"**, **"BO"**, **"CA"**,
        **"MK"**, **"OR"**, **"PE"**, **"PZ"**, **"VW"**, **"WI"**,
        **"TPSS"**, **"RTPSS"**, **"M06L"**, **"MS0"**, **"MS1"**,
        **"MS2"**, **"SCAN"**, **"RSCAN"**, **"R2SCAN"**, **"SCAN-
        REVV10"**, **"MBJ"**, **"VDW-DF"**, **"VDW-DF-CX"**, **"VDW-
        DF-CX0P"**, **"OPTPBE-VDW"**, **"OPTB88-VDW"**, **"OPTB86B-
        VDW"**, **"VDW-DF2"**, **"REV-VDW-DF2"**, **"BEEF-VDW"**,
        **"HF"**, **"B3LYP"**, **"B3PW91"**, **"PBE0"**, **"HSE03"**,
        **"HSE06"**, **"HSESOL"**, **"SOGGA"**, **"SOGGA11"**,
        **"SOGGA11-X"**, **"N12"**, **"N12-SX"**, **"MN12L"**,
        **"GA"**, **"MN15L"**, **"HLE17"**, **"REVM06L"**,
        **"M06SX"**, **"03"**, **"05"**, **"10"**, **"20"**, **"PL"**,
        **"CO"**, **"HL"**, **"RA"**]*) --

        The exchange-correlation functional. This setting *must* be
        consistent with POTCAR. If your desired functional is not
        present in the list, choose Auto and set the GGA tag manually
        under Additional INCAR options.

        Auto: The XC functional is determined by the information in
        POTCAR. For more information on what these options do, see the
        VASP manual.

        Note that some options are only available depending on your
        version of VASP or how it was compiled.

      * **nk1** (*int** | **IntKey*) -- Number of k-points in the
        first dimension

      * **nk2** (*int** | **IntKey*) -- Number of k-points in the
        second dimension

      * **nk3** (*int** | **IntKey*) -- Number of k-points in the
        third dimension

      * **sk1** (*float** | **FloatKey*) -- Fractional shift of the
        k-mesh in the first dimension

      * **sk2** (*float** | **FloatKey*) -- Fractional shift of the
        k-mesh in the second dimension

      * **sk3** (*float** | **FloatKey*) -- Fractional shift of the
        k-mesh in the third dimension

      * **vdW** (*Literal**[**"Disable"**, **"DFT-D2"**, **"DFT-D3"**,
        **"DFT-D3**(**BJ**)**"**, **"DFT-D4"**, **"DFT-ulg"**,
        **"dDsC"**, **"TS"**,
        **"TSWithIterativeHirshfeldPartitioning"**,
        **"ManyBodyDispersionEnergyMethod"**, **"ManyBodyDispersionEn
        ergyWithFractionallyIonicModelForPolarizability"**,
        **"libMD"**]*) --

        The van der Waals correction method.

        VASP keyword: IVDW Default: IVDW = 0 (Disable)

      * **Misc** (*str** | **Sequence**[**str**] **| **FreeBlock*) --

        The contents of this block are copied verbatim into the VASP
        INCAR file. Tags set in this block will override other input
        options.

        Note: do not set POTIM, IBRION, INTERACTIVE or EDIFFG in this
        block, as those keys are set by the AMS driver and cannot be
        changed.

        By default, the AMS driver also sets the following default
        values for the following tags: NSW=999999999 (enforce VASP to
        run indefinetly until killed) IWAVPR=11 (Wave function
        extrapolation when the volume of the cell changes) ISYM=0
        (symmetry is disabled to avoid spurious error due to
        wavefunction mismatch between ionic steps) ISIF=3 (capture
        stress-induced changes (only for VASP version >=6.4))

      * **POTCAROverride** (*VASP._POTCAROverride*) -- Selects the
        pseudopotentials to use for each atomic species. Choosing this
        overrides the default option for each element found in
        POTCARLibrary.

   class _Misc

      The contents of this block are copied verbatim into the VASP
      INCAR file. Tags set in this block will override other input
      options.

      Note: do not set POTIM, IBRION, INTERACTIVE or EDIFFG in this
      block, as those keys are set by the AMS driver and cannot be
      changed.

      By default, the AMS driver also sets the following default
      values for the following tags: NSW=999999999 (enforce VASP to
      run indefinetly until killed) IWAVPR=11 (Wave function
      extrapolation when the volume of the cell changes) ISYM=0
      (symmetry is disabled to avoid spurious error due to
      wavefunction mismatch between ionic steps) ISIF=3 (capture
      stress-induced changes (only for VASP version >=6.4))

   class _POTCAROverride

      Selects the pseudopotentials to use for each atomic species.
      Choosing this overrides the default option for each element
      found in POTCARLibrary.

      Variables:
         **POTCARFiles** (*VASP._POTCAROverride._POTCARFiles*) --
         Selects the pseudopotentials to use for each atomic species.

      class _POTCARFiles

         Selects the pseudopotentials to use for each atomic species.

         Variables:
            * **Label** (*str** | **StringKey*) -- Label for an atom
              corresponding to the vasp.label, or to the element
              symbol if vasp.label is not set.

            * **Path** (*str** | **Path** | **StringKey*) -- Path to a
              POTCAR or POTCAR.Z file to use as a pseudopotential.


3.2. PISA
=========


3.2.1. Entry Module
-------------------

The "Entry" class is the abstract base class for all input entries. It
provides the skeleton for producing input strings and the mechanics
for repeated entries. This class is not meant to be used directly.

_check_unique(meth)

   Decorator that is used to wrap any "Entry" method that is not meant
   for unique entries (like "__getitem__")

   Parameters:
      **meth** (*Callable*) -- "Entry" method to decorate

   Raises:
      **ValueError** -- When wrapped method is called on unique
      instances of the "Entry" object

   Returns:
      The wrapped method

   Return type:
      Callable

class Entry

   Abstract base class serving as the base class for the Block and Key
   classes. Also handles index notation '[]' for repeated blocks and
   keys by automatically creating new instances of itself upon
   indexing.

   __init__(name=None, comment='', hidden=False, unique=True, gui_name=None, default=None, ispath=False, unit='', choices=None, hiddenchoices=None, header=False, ordered=False, isatomlist=False, rootdir=None, engines=None, extra_info=None, gui_type=None, shared_id=None, default_engine=None, range=None, _keyword_dict=None)

      Parameters:
         * **name** (*str** | **None*) --

         * **comment** (*str*) --

         * **hidden** (*bool*) --

         * **unique** (*bool*) --

         * **gui_name** (*str** | **None*) --

         * **default** (*Any*) --

         * **ispath** (*bool*) --

         * **unit** (*str*) --

         * **choices** (*list**[**str**] **| **None*) --

         * **hiddenchoices** (*list**[**str**] **| **None*) --

         * **header** (*bool*) --

         * **ordered** (*bool*) --

         * **isatomlist** (*bool*) --

         * **rootdir** (*str** | **None*) --

         * **engines** (*str** | **None*) --

         * **extra_info** (*str** | **None*) --

         * **gui_type** (*str** | **None*) --

         * **shared_id** (*str** | **None*) --

         * **default_engine** (*str** | **None*) --

         * **range** (*str** | **None*) --

         * **_keyword_dict** (*dict**[**str**, **dict**] **| **None*)
           --

      Return type:
         None

   property value_changed: bool

      Property that determines if an entry will be processed by
      "get_input_string()". Will be set to true if the entry was
      touched in any way. For keys, this means trying to change their
      values (even if changed to the default value). For blocks, this
      means any of their keys were touched in any way.

      Returns:
         Whether the value of the entry was changed

      Return type:
         bool

   get_input_string(indent_lvl=0)

      Generates a valid AMS input string. Note that this method exists
      for every entry, but generally as user you want to call it on
      the highest level "DriverBlock" instance, which will recursively
      include all its entries.

      Parameters:
         **indent_lvl** (*int**, **optional*) -- With how many tabs to
         indent the string. Useful for dealing with snippets, not with
         DriverBlock. Defaults to 0.

      Returns:
         Valid AMS input string.

      Return type:
         str

   abstract _get_single_input_string(indent_lvl=0)

      This method produces the input string for unique Entries. This
      is the method that needs to be overwritten to implement specific
      subclasses, not "get_input_string()".

      Parameters:
         **indent_lvl** (*int**, **optional*) -- Indentation level,
         defaults to 0

      Returns:
         string representing the "Entry" in the input system.

      Return type:
         str

   _get_repeated_input_string(indent_lvl)

      For repeated entries, simply generate a multiline string by
      repeatedly calling "get_input_string()" for every entry in
      "self._entry_list"

      Parameters:
         **indent_lvl** (*int*) -- Indentation level

      Returns:
         Multiline string representing all items in the repeated
         Entry.

      Return type:
         str

   insert(index, value)

      Parameters:
         * **index** (*int*) --

         * **value** (*Entry*) --

      Return type:
         None


3.2.2. Block Module
-------------------

The following classes represent the different types of blocks in the
input system. Note that for normal usage, one never needs to
instantiate these classes directly. Instead use the autogenerated
subclasses present in "scm.input_classes.drivers" and
"scm.input_classes.engines".

class InputParserEngineBlock

   Simple container for data created by the InputParser for
   EngineBlocks. Only used in the "Block.from_text()" functionality

   _h: str

   _1: Sequence[str]

   __init__(_h, _1)

      Parameters:
         * **_h** (*str*) --

         * **_1** (*Sequence**[**str**]*) --

      Return type:
         None

class InputParserFreeBlock

   Simple container for data created by the InputParser for
   FreeBlocks. Only used in the "Block.from_text()" functionality

   _1: Sequence[str]

   __init__(_1)

      Parameters:
         **_1** (*Sequence**[**str**]*) --

      Return type:
         None

class Block

   Base class representing an input block for AMS.

   _header = ''

   property header

   static from_def_dict(name, def_dict)

      Instantiate the relevant "Block"  object from a definition
      dictionary from the json input definitions. Only used in the
      autogeneration of "scm.input_classes"

      Parameters:
         * **name** (*str*) -- Name of the block to create

         * **def_dict** (*dict**[**str**, **Any**]*) -- Definition
           dictionary from the json input definitions.

      Returns:
         The created "Block" instance

      Return type:
         Block

   classmethod from_settings(settings)

      Generate a block object from a settings object. Should only be
      used for backwards compatibility, e.g. old job classes or
      recipes that will break on receiving a PISA object. Not
      guaranteed to always work, since it does a to text input and
      from text input conversion. Examples:

         from scm.input_classes import AMS, DFTB
         from scm.plams.interfaces.adfsuite.ams import AMSJob
         from scm.plams.core.settings import Settings

         settings = Settings()
         settings.input
         settings.input.ams.Task = 'GeometryOptimization'
         settings.input.ams.Properties.NormalModes = 'Yes'
         settings.input.DFTB.Model = 'SCC-DFTB'

         ams = AMS.from_settings(settings)

         # this is supported, but fragile:
         dftb = DFTB.from_settings(settings)
         # this is safer:
         ams = AMS.from_settings(settings)
         dftb = ams.engine

      Parameters:
         * **cls** (*type**[**T_Block**]*) -- Block class you want to
           generate from settings. Usually should be AMS

         * **settings** (*Settings*) -- Settings object to convert
           from. Should contain 'input' attribute.

      Raises:
         **ValueError** -- If settings input does not contain 'input'
         attribute

      Returns:
         Block object with keys and blocks set according to
         information in settings object.

      Return type:
         T_Block

   classmethod from_text(text)

      Class method to instantiate a block object from text input. Need
      to call this on the relevant subclass to work correctly. E.g.
      for an AMS input string one needs to call AMS.from_text, not
      Block.from_text

      Parameters:
         * **cls** (*type**[**T_Block**]*) -- Relevant block class

         * **text** (*str*) -- String representing valid AMS input

      Returns:
         Block object representing the text input

      Return type:
         T_Block

   set_from_input_dict(input_dict)

      Called from "Block.from_text" after instantiation of the Block
      to correctly set the values of the key/block attributes as
      defined in the text input.

      Parameters:
         **input_dict** (*dict**[**str**, **Any**]*) -- dictionary
         returned by "scm.base.InputParser"

      Raises:
         **ValueError** -- When the text input references an Entry not
         present in the JSON input definitions, would be caused by
         faulty text input.

      Return type:
         None

   property blocks: tuple[Block, ...]

      Property returning all the blocks in this block

      Returns:
         All the blocks in this block

      Return type:
         tuple[Block, ...]

   property keys: tuple[Key, ...]

      Property returning all the keys in this block

      Returns:
         All the keys in this block

      Return type:
         tuple[Key, ...]

   property entries: tuple[Entry, ...]

      Property returning all the entries (blocks and keys) in this
      block. Return will be sorted with possible engine blocks at the
      end.

      Returns:
         Tuple of all entries in this block

      Return type:
         tuple[Entry, ...]

   property _lowercase_dict_entry: dict[str, Entry]

      Lowercase dictionary of all Entries and their lowercase names,
      used to check if accessed "Entry" attributes in "__setattr__()"
      are an incorrect case variation of an existing attributes.

      Returns:
         Dictionary with lowercase entry names as keys, and entry
         attributes as values

      Return type:
         dict[str, Entry]

   property _dict_entry: dict[str, Entry]

      Dictionary of all Entries and their names, to find the proper
      case names of misspelled Entries in "__setattr__()" .

      Returns:
         Dictionary with entry names as keys, and entry attributes as
         values

      Return type:
         dict[str, Entry]

   _get_single_input_string(indent_lvl=0)

      A wrapper that concatenates the outputs of
      "self._get_block_start", "self._get_block_body", and
      "self._get_block_end". Those are the methods to override in the
      subclasses.

      Parameters:
         **indent_lvl** (*int**, **optional*) -- Indentation level,
         defaults to 0

      Returns:
         Input string for a unique block.

      Return type:
         str

   _get_block_start(indent_lvl)

      Inserts the block name

      Parameters:
         **indent_lvl** (*int*) -- Indentation level

      Returns:
         Properly indented block name

      Return type:
         str

   _get_block_body(indent_lvl)

      Recursively searches all the key/block attributes build the body
      by concatenating the outputs of "get_input_string" for
      attributes that were changed/touched by the user.

      Parameters:
         **indent_lvl** (*int*) -- Indentation level

      Returns:
         block body

      Return type:
         str

   _get_block_end(indent_lvl)

      Simply returns the string *end* with required indentation.

      Parameters:
         **indent_lvl** (*int*) -- Indentation level

      Returns:
         *End*

      Return type:
         str

   property value_changed: bool

      Recursively searches all "Entry" attributes to see if any of
      them has "value_changed=True". We consider a key changed if it's
      value is changed by the user, even if it is set to the default
      value. A block is changed when any of its keys or block have
      their value changed. Used as a condition to include a block in
      the input string

      Returns:
         Whether the value of this block is different from the default
         or touched by the user.

      Return type:
         bool

class EngineBlock

   Represents engine blocks. Input string will always start with
   'Engine <engine_name>' and end with 'EndEngine'

   _get_block_start(indent_lvl)

      Prefixes the word *Engine* to the block start line containing
      the block name

      Parameters:
         **indent_lvl** (*int*) -- Indentation level

      Returns:
         <INDENT>Engine <block_name>

      Return type:
         str

   _get_block_end(indent_lvl)

      Return *EndEngine* instead of *End*

      Parameters:
         **indent_lvl** (*int*) -- Indentation level

      Returns:
         <INDENT>EndEngine

      Return type:
         str

   static _get_engine_class_and_header(header_str)

      Only used when generating block objects from text input.
      Separates the engine name from the possible header and looks it
      up in "scm.input_classes.engine"

      Parameters:
         **header_str** (*str*) -- Line like "BAND test_header" that
         started the engine block in the text input

      Raises:
         **ValueError** -- When the corresponding engine class can not
         be found

      Returns:
         The Engine class and the possible header

      Return type:
         tuple[type[EngineBlock], str | None]

   static _from_input_parser(d)

      Create an "EngineBlock" object from the output of the
      "scm.base.InputParser"

      Parameters:
         **d** (*InputParserEngineBlock*) -- Dataclass holding the
         engine block info

      Returns:
         EngineBlock object

      Return type:
         EngineBlock

   _init_finished: bool

   comment: Final

   hidden: Final

   unique: Final

   gui_name: Final

   default: Final

   ispath: Final

   unit: Final

   choices: Final[list[str] | None]

   hiddenchoices: Final[list[str] | None]

   allow_header: Final

   ordered: Final

   isatomlist: Final

   rootdir: Final

   engines: Final

   extra_info: Final

   gui_type: Final

   shared_id: Final

   default_engine: Final

   range: Final

   _keyword_dict: Final

   _entry_list: list[Entry]

   _value_changed: bool

class DriverBlock

   Represents the highest level block.

   _get_block_start(indent_lvl)

      Driver blocks don't have start line or an end line, simply
      returns an empty string

      Parameters:
         **indent_lvl** (*int*) -- Indentation level, ignored.

      Returns:
         Empty string

      Return type:
         Literal[""]

   _get_block_end(indent_lvl)

      Driver blocks don't have start line or an end line, simply
      returns an empty string

      Parameters:
         **indent_lvl** (*int*) -- Indentation level, ignored.

      Returns:
         Empty string

      Return type:
         Literal[""]

   get_input_string(indent_lvl=-1)

      Generates a valid AMS input string. Note that this method exists
      for every entry, but generally as user you want to call it on
      the highest level "DriverBlock" instance, which will recursively
      include all its entries.

      Parameters:
         **indent_lvl** (*int**, **optional*) -- With how many tabs to
         indent the string. Useful for dealing with snippets, not with
         DriverBlock. Defaults to 0.

      Returns:
         Valid AMS input string.

      Return type:
         str

   to_settings()

      Convert the Block to a PLAMS Settings object. Can be used for
      Job classes/recipes that don't support PISA objects. Example:

         from scm.input_classes import AMS, DFTB
         from scm.plams.interfaces.adfsuite.ams import AMSJob
         from scm.plams.core.settings import Settings

         ams = AMS()
         ams.Task = 'SinglePoint'
         ams.Engine = DFTB()

         s = Settings()
         s.input = ams.to_settings()
         AMSJob(settings=s)

      This conversion works via serializing to text and using the
      libbase InputParser to create a settings object from text. Since
      this is a bit fragile, only recommended to use this method for
      backwards compatibility.

      Returns:
         Settings object representation of the Block

      Return type:
         Settings

   _init_finished: bool

   comment: Final

   hidden: Final

   unique: Final

   gui_name: Final

   default: Final

   ispath: Final

   unit: Final

   choices: Final[list[str] | None]

   hiddenchoices: Final[list[str] | None]

   allow_header: Final

   ordered: Final

   isatomlist: Final

   rootdir: Final

   engines: Final

   extra_info: Final

   gui_type: Final

   shared_id: Final

   default_engine: Final

   range: Final

   _keyword_dict: Final

   _entry_list: list[Entry]

   _value_changed: bool

class FreeBlock

   A block that can be assigned a multiline string of an iterable of
   strings, instead of directly assigning attributes. Will simply
   result in a series of lines in the input text

   _multiline_string: str = ''

   _get_block_body(indent_lvl=0)

      Simply returns an indented version of the multiline string in
      "FreeBlock._multiline_string"

      Parameters:
         **indent_lvl** (*int**, **optional*) -- Indentation level,
         defaults to 0

      Returns:
         Indented version of multiline string.

      Return type:
         str

   set_from_input_dict(input_dict)

      Called from "Block.from_text" after instantiation of the Block
      to correctly set the values of the key/block attributes as
      defined in the text input.

      Parameters:
         **input_dict** (*dict**[**str**, **Any**]*) -- dictionary
         returned by "scm.base.InputParser"

      Raises:
         **ValueError** -- When the text input references an Entry not
         present in the JSON input definitions, would be caused by
         faulty text input.

      Return type:
         None

class FixedBlock

   Standard block with a predefined set of possible keys and blocks.

   _init_finished: bool

   comment: Final

   hidden: Final

   unique: Final

   gui_name: Final

   default: Final

   ispath: Final

   unit: Final

   choices: Final[list[str] | None]

   hiddenchoices: Final[list[str] | None]

   allow_header: Final

   ordered: Final

   isatomlist: Final

   rootdir: Final

   engines: Final

   extra_info: Final

   gui_type: Final

   shared_id: Final

   default_engine: Final

   range: Final

   _keyword_dict: Final

   _entry_list: list[Entry]

   _value_changed: bool

class InputBlock

   Identical to the "FreeBlock", but end with *EndInput* instead of
   *End*

   _get_block_end(indent_lvl)

      Simply returns the string *end* with required indentation.

      Parameters:
         **indent_lvl** (*int*) -- Indentation level

      Returns:
         *End*

      Return type:
         str

   _init_finished: bool

   comment: Final

   hidden: Final

   unique: Final

   gui_name: Final

   default: Final

   ispath: Final

   unit: Final

   choices: Final[list[str] | None]

   hiddenchoices: Final[list[str] | None]

   allow_header: Final

   ordered: Final

   isatomlist: Final

   rootdir: Final

   engines: Final

   extra_info: Final

   gui_type: Final

   shared_id: Final

   default_engine: Final

   range: Final

   _keyword_dict: Final

   _entry_list: list[Entry]

   _value_changed: bool

class VerbatimBlock

   Identical to the "InputBlock"

   _init_finished: bool

   comment: Final

   hidden: Final

   unique: Final

   gui_name: Final

   default: Final

   ispath: Final

   unit: Final

   choices: Final[list[str] | None]

   hiddenchoices: Final[list[str] | None]

   allow_header: Final

   ordered: Final

   isatomlist: Final

   rootdir: Final

   engines: Final

   extra_info: Final

   gui_type: Final

   shared_id: Final

   default_engine: Final

   range: Final

   _keyword_dict: Final

   _entry_list: list[Entry]

   _value_changed: bool

type_hint(b, namespace='')

   Produces the proper type hint for all "Block" classes. Useful for
   "Block" classes that are allowed to overwritten as an attribute,
   such as an "EngineBlock" or a "FreeBlock" with a sequence of
   strings. Fixed blocks are prefixed by the given namespace.

   Parameters:
      * **b** (*Block*) -- Block instance to produce type hint for

      * **namespace** (*str*) -- Namespace to use for fixed blocks
        e.g. "A._B._C."

   Returns:
      Proper type hint.

   Return type:
      str | None


3.2.3. Key Module
-----------------

The following classes represent the different types of keys in the
input system. Note that for normal usage, one never needs to
instantiate these classes directly. Instead, the autogenerated block
classes will have key attributes that are subclasses of the following
classes:

class Key

   Base class for all key classes in the input system. Keys are single
   lines in the text input, with the name of the key, followed by a
   space, and followed by a string representing the value.

   property val

      Property representing the key value. Any proposed *value* will
      be sent to the abstract method "_convert_val()", which is
      overwritten in each subclass. Values that cannot be converted to
      the correct type will be rejected.

      Parameters:
         **value** (*Any*) -- Value to set the key with

   abstract _convert_val(value)

   set_to_default()

      Reset the key to the default value, if present.

   static from_def_dict(name, def_dict)

      Parameters:
         * **name** (*str*) --

         * **def_dict** (*dict*) --

      Return type:
         *Key*

   _get_single_input_string(indent_lvl=0)

      This method produces the input string for unique Entries. This
      is the method that needs to be overwritten to implement specific
      subclasses, not "get_input_string()".

      Parameters:
         **indent_lvl** (*int**, **optional*) -- Indentation level,
         defaults to 0

      Returns:
         string representing the "Entry" in the input system.

      Return type:
         str

   _format_val()

      Return type:
         str

   _update_existing_attr(attr, _Key__name, _Key__value)

      Parameters:
         * **attr** (*Any*) --

         * **_Key__name** (*str*) --

         * **_Key__value** (*Any*) --

      Return type:
         None

   _check_for_boolean(val)

      Parameters:
         **val** (*T*) --

      Return type:
         *T*

   _check_for_non_integer_float(val)

      Parameters:
         **val** (*T*) --

      Return type:
         *T*

class FloatKey

   _convert_val(val)

      Will accept anything that can be converted to a python float,
      but raises errors on values of type "bool", since the type
      hinter considers them a valid subclass of "float", but passing
      booleans as floats is never intended

      Parameters:
         **val** (*float*) -- value

      Returns:
         Converted value

      Return type:
         float

class BoolKey

   _convert_val(val)

      Will accept a set of strings and *True* or *False* as boolean
      values. Will not try to convert to "bool", since nearly every
      python object can be converted to a boolean and passing anything
      but "BoolType" rarely on purpose.

      Parameters:
         **val** (*BoolType*) -- value

      Raises:
         **ValueError** -- When value is not of type "BoolType" or a
         case variation of one of the strings

      Returns:
         Converted value

      Return type:
         bool

class IntKey

   _convert_val(val)

      Accepts anything that can be converted to an integer, except
      boolean values and floats with a fractional component.

      Parameters:
         **val** (*int*) -- value

      Returns:
         Converted value

      Return type:
         int

class FloatListKey

   _convert_val(val)

      Accepts any iterable of values that are convertible to float,
      except boolean values.

      Parameters:
         **val** (*Iterable**[**float**]*) -- value

      Returns:
         converted value

      Return type:
         tuple[float, ...]

   _format_val()

      Return type:
         str

class IntListKey

   _convert_val(val)

      Accepts any iterable of values that are convertible to integer,
      except boolean values and floats with a fractional component.

      Parameters:
         **val** (*Iterable**[**int**]*) -- value

      Returns:
         converted value

      Return type:
         tuple[int, ...]

   _format_val()

      Return type:
         str

class MultipleChoiceKey

   _convert_val(val)

      Accepts any strings that is equal to (or a case variation of)
      the list of strings defined in "MultipleChoiceKey.choices".

      Parameters:
         **val** (*str*) -- value

      Raises:
         **ValueError** -- When *val* not present in
         "MultipleChoiceKey.choices"

      Returns:
         Converted value.

      Return type:
         str

class StringKey

   _convert_val(val)

      Accepts any string. Validates whether the argument passed is
      actually a string, since calling str(val) would succeed for
      every possible type of val.

      Parameters:
         **val** (*str*) -- value

      Returns:
         Converted value

      Return type:
         str

class PathStringKey

   _convert_val(val)

      Accepts strings that represent paths.

      Parameters:
         **val** (*str** | **Path*) -- value

      Returns:
         Converted value

      Return type:
         str

type_hint(k)

   Provides the proper type hint for key attributes for the
   autogenerated classes. Keys are type hinted as their actual type,
   plus the type hint of their value to allow for syntax like:

      some_block.some_key = 5

   to pass the type hinter, instead of the more cumbersome

      some_block.some_key.val = 5

   Parameters:
      **k** (*Key*) -- Key object

   Raises:
      **NotImplementedError** -- When providing a key object for which
      a type hint is not implemented yet.

   Returns:
      String describing a type hint

   Return type:
      str

scm.pisa.key.BoolType: Literal = ["Yes", "yes", "No", "no", "True", "true", "False", "false", "t", "f", "T", "F", True, False]
