Source code for scm.input_classes.drivers.acerxn

from __future__ import annotations
from pathlib import Path
from typing import Iterable, Literal, Sequence
from scm.pisa.block import DriverBlock,EngineBlock,FixedBlock,FreeBlock,InputBlock
from scm.pisa.key import BoolKey,FloatKey,FloatListKey,IntKey,IntListKey,MultipleChoiceKey,PathStringKey,StringKey,BoolType

[docs]class ACERXN(DriverBlock):
    r"""
    
    
    :ivar Product: Make one or more product molecule.
    :vartype Product: str | StringKey
    :ivar Reactant: Make one or more reactant molecule.
    :vartype Reactant: str | StringKey
    :ivar BasicOptions: General options
    :vartype BasicOptions: ACERXN._BasicOptions
    :ivar DistanceOptions: 
    :vartype DistanceOptions: ACERXN._DistanceOptions
    :ivar Engine: The input for the computational engine used to compute energy and forces.
    :vartype Engine: EngineBlock
    :ivar 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).
    :vartype GeomGenRelatedScreeningOptions: ACERXN._GeomGenRelatedScreeningOptions
    :ivar IntermediateGeneration: Options used exclusively in intermediate generation (Step 1)
    :vartype IntermediateGeneration: ACERXN._IntermediateGeneration
    :ivar Intermediates: If needed specify intermediates.
    :vartype Intermediates: ACERXN._Intermediates
    :ivar MappingOptions: The options used for the chemical distance computations. Currently only used in step2, but in future will also be available in step1.
    :vartype MappingOptions: ACERXN._MappingOptions
    :ivar 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).
    :vartype MatrixRelatedScreeningOptions: ACERXN._MatrixRelatedScreeningOptions
    :ivar MoleculeSpecificMatrixScreeningOptions: Molecule specific options that may be moved to System settings in future.
    :vartype MoleculeSpecificMatrixScreeningOptions: ACERXN._MoleculeSpecificMatrixScreeningOptions
    :ivar NetworkCreation: Options exclusively used for network creation (Step 2)
    :vartype NetworkCreation: ACERXN._NetworkCreation
    :ivar NetworkMinimization: Options exclusively used for network minimization (Step 3)
    :vartype NetworkMinimization: ACERXN._NetworkMinimization
    :ivar ReactantFragmentation: Details on how the reactant is split into smallest fragments, and how those are assigned charges and stabilities
    :vartype ReactantFragmentation: ACERXN._ReactantFragmentation
    :ivar RedundantOptions: Options that in this version have only one possible value
    :vartype RedundantOptions: ACERXN._RedundantOptions
    :ivar RunInfo: General run and file-Info on creating an ACErxn network
    :vartype RunInfo: ACERXN._RunInfo
    :ivar 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.
    :vartype System: ACERXN._System
    """
[docs]    class _BasicOptions(FixedBlock):
        r"""
        General options
        
        :ivar AcceptSaturatedActiveAtoms: Accept atoms as active even if they are fully saturated in the minimal fragments. By default this is turned off.
        :vartype AcceptSaturatedActiveAtoms: BoolType | BoolKey
        :ivar Covalent_Radii_Coeff: 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).
        :vartype Covalent_Radii_Coeff: float | FloatKey
        :ivar IM_MaxMolecule: It is the number of constituent molecules in one intermediate state.
        :vartype IM_MaxMolecule: int | IntKey
        :ivar MaxJobs: The number of parallel calculations (geometry optimizations, matrix enumerations, and network construction processes).
        :vartype MaxJobs: int | IntKey
        :ivar MinimumBondOrder: The minimum bond order to be considered a bond
        :vartype MinimumBondOrder: float | FloatKey
        :ivar NProc: The number of cores that are used for the QM geometry optimization for each molecule.
        :vartype NProc: int | IntKey
        :ivar SaveMoleculelist: Saves both screened and unscreened molecules to list, which is written to the Legacy output as Molecule_list
        :vartype SaveMoleculelist: BoolType | BoolKey
        :ivar TotalChargeMethod: 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.
        :vartype TotalChargeMethod: Literal["SumofFragments", "Ionic"]
        """
        def __post_init__(self):
            self.AcceptSaturatedActiveAtoms: BoolType | BoolKey = BoolKey(name='AcceptSaturatedActiveAtoms', comment='Accept atoms as active even if they are fully saturated in the minimal fragments. By default this is turned off.', default=False)
            self.Covalent_Radii_Coeff: float | FloatKey = FloatKey(name='Covalent_Radii_Coeff', comment='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).', default=1.1)
            self.IM_MaxMolecule: int | IntKey = IntKey(name='IM_MaxMolecule', comment='It is the number of constituent molecules in one intermediate state.', default=10000)
            self.MaxJobs: int | IntKey = IntKey(name='MaxJobs', comment='The number of parallel calculations (geometry optimizations, matrix enumerations, and network construction processes).')
            self.MinimumBondOrder: float | FloatKey = FloatKey(name='MinimumBondOrder', comment='The minimum bond order to be considered a bond', default=0.3)
            self.NProc: int | IntKey = IntKey(name='NProc', comment='The number of cores that are used for the QM geometry optimization for each molecule.', default=1)
            self.SaveMoleculelist: BoolType | BoolKey = BoolKey(name='SaveMoleculelist', comment='Saves both screened and unscreened molecules to list, which is written to the Legacy output as Molecule_list', hidden=True, default=True)
            self.TotalChargeMethod: Literal["SumofFragments", "Ionic"] = MultipleChoiceKey(name='TotalChargeMethod', comment='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.', default='SumofFragments', choices=['SumofFragments', 'Ionic'])
[docs]    class _DistanceOptions(FixedBlock):
        r"""
        
        
        :ivar BDE_scaling: 
        :vartype BDE_scaling: float | FloatKey
        """
        def __post_init__(self):
            self.BDE_scaling: float | FloatKey = FloatKey(name='BDE_scaling', default=0.01)
[docs]    class _Engine(EngineBlock):
        r"""
        The input for the computational engine used to compute energy and forces.
        
        """
        def __post_init__(self):
            pass
[docs]    class _GeomGenRelatedScreeningOptions(FixedBlock):
        r"""
        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).
        
        :ivar DiscardAcyclic: 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.
        :vartype DiscardAcyclic: BoolType | BoolKey
        :ivar EnergyScreening: 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.
        :vartype EnergyScreening: BoolType | BoolKey
        :ivar MaxRingNumber: 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.
        :vartype MaxRingNumber: int | IntKey
        :ivar ScreenChangedConnectivity: If the connectivity of an molecule has been changed during the AC->3D process, the corresponding intermediate will be screened.
        :vartype ScreenChangedConnectivity: BoolType | BoolKey
        :ivar ScreenErrorTermination: If a calculation (UFF, DFTB, semi-empirical) is terminated with an error, the corresponding intermediate will be screened.
        :vartype ScreenErrorTermination: BoolType | BoolKey
        """
        def __post_init__(self):
            self.DiscardAcyclic: BoolType | BoolKey = BoolKey(name='DiscardAcyclic', comment='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.', default=False)
            self.EnergyScreening: BoolType | BoolKey = BoolKey(name='EnergyScreening', comment='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.', default=False)
            self.MaxRingNumber: int | IntKey = IntKey(name='MaxRingNumber', comment='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.', default=-1)
            self.ScreenChangedConnectivity: BoolType | BoolKey = BoolKey(name='ScreenChangedConnectivity', comment='If the connectivity of an molecule has been changed during the AC->3D process, the corresponding intermediate will be screened.', default=True)
            self.ScreenErrorTermination: BoolType | BoolKey = BoolKey(name='ScreenErrorTermination', comment='If a calculation (UFF, DFTB, semi-empirical) is terminated with an error, the corresponding intermediate will be screened.', default=False)
[docs]    class _IntermediateGeneration(FixedBlock):
        r"""
        Options used exclusively in intermediate generation (Step 1)
        
        :ivar CompareCharge: When deciding if a molecule has already been computed/created, take into account the charge of the molecule
        :vartype CompareCharge: BoolType | BoolKey
        :ivar FormBondsWithinFragment: 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.
        :vartype FormBondsWithinFragment: BoolType | BoolKey
        :ivar GenXYZ_MaxCycle: The number of adjacency matrix (AC) -> 3D process attempts
        :vartype GenXYZ_MaxCycle: int | IntKey
        :ivar MaxBondsBroken: When generating new intermediates Y from intermediate X, this is the maximum number of bonds that can be broken in X to form Y.
        :vartype MaxBondsBroken: int | IntKey
        :ivar MaxBondsFormed: When generating new intermediates Y from intermediate X, this is the maximum number of bonds that can be formed to create Y from X.
        :vartype MaxBondsFormed: int | IntKey
        :ivar MaxPropagation_Iteration: 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.
        :vartype MaxPropagation_Iteration: int | IntKey
        :ivar Module: RDKit is the only option. The default in the original version of the code was OpenBabel.
        :vartype Module: str | StringKey
        :ivar PropagationMethod: Uses either the novel BondOrderMatrixGenerator for propagation and geometry recovery, or the old function PropogationFromReactant
        :vartype PropagationMethod: Literal["Class", "Function"]
        :ivar ScreenAndOptimizeIntermediates: 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.
        :vartype ScreenAndOptimizeIntermediates: BoolType | BoolKey
        :ivar UsePlamsParallelization: Use the novel GeometryGenerator class to generate 3D geometries from molecule bond matrices
        :vartype UsePlamsParallelization: BoolType | BoolKey
        :ivar UseReactantGeometries: 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
        :vartype UseReactantGeometries: BoolType | BoolKey
        :ivar AmsOptions: Options related to engine calls
        :vartype AmsOptions: ACERXN._IntermediateGeneration._AmsOptions
        :ivar GeometryGenerationOptions: 
        :vartype GeometryGenerationOptions: ACERXN._IntermediateGeneration._GeometryGenerationOptions
        :ivar 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).
        :vartype PruningOptions: ACERXN._IntermediateGeneration._PruningOptions
        """
[docs]        class _AmsOptions(FixedBlock):
            r"""
            Options related to engine calls
            
            :ivar KeepAMSFiles: Keep the files of all AMS calculations in the plams_workdir folder
            :vartype KeepAMSFiles: BoolType | BoolKey
            :ivar KeepAMSRunning: Keep the AMS driver running in the background during the geometry optimizations
            :vartype KeepAMSRunning: BoolType | BoolKey
            :ivar QMcalculation: Filename that defines the method to calculate energy of the intermediates. Example: engine.in
            :vartype QMcalculation: str | StringKey
            :ivar UFF_MaxTime: It can have zero or positive number. This is the maximum time for UFF during the AC->3D process
            :vartype UFF_MaxTime: int | IntKey
            """
            def __post_init__(self):
                self.KeepAMSFiles: BoolType | BoolKey = BoolKey(name='KeepAMSFiles', comment='Keep the files of all AMS calculations in the plams_workdir folder', gui_name='Keep AMS files:', default=False)
                self.KeepAMSRunning: BoolType | BoolKey = BoolKey(name='KeepAMSRunning', comment='Keep the AMS driver running in the background during the geometry optimizations', gui_name='Keep AMS running:', default=True)
                self.QMcalculation: str | StringKey = StringKey(name='QMcalculation', comment='Filename that defines the method to calculate energy of the intermediates. Example: engine.in', hidden=True, default='engine.in')
                self.UFF_MaxTime: int | IntKey = IntKey(name='UFF_MaxTime', comment='It can have zero or positive number. This is the maximum time for UFF during the AC->3D process', hidden=True, default=10)
[docs]        class _GeometryGenerationOptions(FixedBlock):
            r"""
            
            
            :ivar RDKitLogging: When the smilestrings are converted to coordinates using RDKit, logging can be switched on or off.
            :vartype RDKitLogging: BoolType | BoolKey
            :ivar SkipPreOptimization: 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.
            :vartype SkipPreOptimization: BoolType | BoolKey
            """
            def __post_init__(self):
                self.RDKitLogging: BoolType | BoolKey = BoolKey(name='RDKitLogging', comment='When the smilestrings are converted to coordinates using RDKit, logging can be switched on or off.', default=False)
                self.SkipPreOptimization: BoolType | BoolKey = BoolKey(name='SkipPreOptimization', comment='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.', hidden=True, default=False)
[docs]        class _PruningOptions(FixedBlock):
            r"""
            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).
            
            :ivar MaxRingSize: If the newly generated intermediate (or molecule) contains a ring larger than the provided value, it is screened.
            :vartype MaxRingSize: int | IntKey
            :ivar MinRingSize: If the newly generated intermediate (or molecule) contains a ring smaller than the provided value, it is screened.
            :vartype MinRingSize: int | IntKey
            :ivar Pruning_Cyclics: If not set to the default value N, it is the number maximum number of rings allowed in an intermediate.
            :vartype Pruning_Cyclics: BoolType | BoolKey
            """
            def __post_init__(self):
                self.MaxRingSize: int | IntKey = IntKey(name='MaxRingSize', comment='If the newly generated intermediate (or molecule) contains a ring larger than the provided value, it is screened.', default=10000)
                self.MinRingSize: int | IntKey = IntKey(name='MinRingSize', comment='If the newly generated intermediate (or molecule) contains a ring smaller than the provided value, it is screened.', default=3)
                self.Pruning_Cyclics: BoolType | BoolKey = BoolKey(name='Pruning_Cyclics', comment='If not set to the default value N, it is the number maximum number of rings allowed in an intermediate.', hidden=True, default=False)
        def __post_init__(self):
            self.CompareCharge: BoolType | BoolKey = BoolKey(name='CompareCharge', comment='When deciding if a molecule has already been computed/created, take into account the charge of the molecule', default=False)
            self.FormBondsWithinFragment: BoolType | BoolKey = BoolKey(name='FormBondsWithinFragment', comment='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.', default=False)
            self.GenXYZ_MaxCycle: int | IntKey = IntKey(name='GenXYZ_MaxCycle', comment='The number of adjacency matrix (AC) -> 3D process attempts', default=2)
            self.MaxBondsBroken: int | IntKey = IntKey(name='MaxBondsBroken', comment='When generating new intermediates Y from intermediate X, this is the maximum number of bonds that can be broken in X to form Y.', default=2)
            self.MaxBondsFormed: int | IntKey = IntKey(name='MaxBondsFormed', comment='When generating new intermediates Y from intermediate X, this is the maximum number of bonds that can be formed to create Y from X.', default=2)
            self.MaxPropagation_Iteration: int | IntKey = IntKey(name='MaxPropagation_Iteration', comment='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.', default=-1)
            self.Module: str | StringKey = StringKey(name='Module', comment='RDKit is the only option. The default in the original version of the code was OpenBabel.', hidden=True, default='rdkit')
            self.PropagationMethod: Literal["Class", "Function"] = MultipleChoiceKey(name='PropagationMethod', comment='Uses either the novel BondOrderMatrixGenerator for propagation and geometry recovery, or the old function PropogationFromReactant', default='Class', choices=['Class', 'Function'])
            self.ScreenAndOptimizeIntermediates: BoolType | BoolKey = BoolKey(name='ScreenAndOptimizeIntermediates', comment='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.', default=True)
            self.UsePlamsParallelization: BoolType | BoolKey = BoolKey(name='UsePlamsParallelization', comment='Use the novel GeometryGenerator class to generate 3D geometries from molecule bond matrices', default=True)
            self.UseReactantGeometries: BoolType | BoolKey = BoolKey(name='UseReactantGeometries', comment='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', default=True)
            self.AmsOptions: ACERXN._IntermediateGeneration._AmsOptions = self._AmsOptions(name='AmsOptions', comment='Options related to engine calls')
            self.GeometryGenerationOptions: ACERXN._IntermediateGeneration._GeometryGenerationOptions = self._GeometryGenerationOptions(name='GeometryGenerationOptions')
            self.PruningOptions: ACERXN._IntermediateGeneration._PruningOptions = self._PruningOptions(name='PruningOptions', comment='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).')
[docs]    class _Intermediates(FixedBlock):
        r"""
        If needed specify intermediates.
        
        :ivar Intermediate: If specify sub-intermediates.
        :vartype Intermediate: str | StringKey
        """
        def __post_init__(self):
            self.Intermediate: str | StringKey = StringKey(name='Intermediate', comment='If specify sub-intermediates.', unique=False, gui_type='molecule')
[docs]    class _MappingOptions(FixedBlock):
        r"""
        The options used for the chemical distance computations. Currently only used in step2, but in future will also be available in step1.
        
        :ivar Digression_Factor: It can have positive integer. It is delta in the expression for the maximum chemical distance of an intermediate form reactants and products
        :vartype Digression_Factor: int | IntKey
        :ivar Edge_Energy_Threshold: Endergonic reactions whose energy difference is higher than Edge_Energy_Threshold are not connected as edges. Currently not in use.
        :vartype Edge_Energy_Threshold: int | IntKey
        :ivar FullMapping: 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).
        :vartype FullMapping: Literal["Net", "Y", "N"]
        :ivar Kthneighbor: 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)
        :vartype Kthneighbor: int | IntKey
        :ivar MaxDepth_Alpha: Completely equivalent to Digression_Factor, with the exception that it is not used with Digression_Screening in step 1.
        :vartype MaxDepth_Alpha: int | IntKey
        :ivar UseActiveBonds: During the mapping process (computing the chemical distance, assume only the active bonds can be broken or formed)
        :vartype UseActiveBonds: BoolType | BoolKey
        """
        def __post_init__(self):
            self.Digression_Factor: int | IntKey = IntKey(name='Digression_Factor', comment='It can have positive integer. It is delta in the expression for the maximum chemical distance of an intermediate form reactants and products', default=-100)
            self.Edge_Energy_Threshold: int | IntKey = IntKey(name='Edge_Energy_Threshold', comment='Endergonic reactions whose energy difference is higher than Edge_Energy_Threshold are not connected as edges. Currently not in use.', hidden=True, default=10000)
            self.FullMapping: Literal["Net", "Y", "N"] = MultipleChoiceKey(name='FullMapping', comment='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).', default='Net', choices=['Net', 'Y', 'N'])
            self.Kthneighbor: int | IntKey = IntKey(name='Kthneighbor', comment='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)', default=1)
            self.MaxDepth_Alpha: int | IntKey = IntKey(name='MaxDepth_Alpha', comment='Completely equivalent to Digression_Factor, with the exception that it is not used with Digression_Screening in step 1.', hidden=True, default=-100)
            self.UseActiveBonds: BoolType | BoolKey = BoolKey(name='UseActiveBonds', comment='During the mapping process (computing the chemical distance, assume only the active bonds can be broken or formed)', default=True)
[docs]    class _MatrixRelatedScreeningOptions(FixedBlock):
        r"""
        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).
        
        :ivar AllowAldehyde: Determines whether aldehyde anions are acceptable intermediates. Screened after propagation, and before geometry optimization.
        :vartype AllowAldehyde: BoolType | BoolKey
        :ivar AllowCarbenes: Allow carbene molecules among the generated intermediates.
        :vartype AllowCarbenes: BoolType | BoolKey
        :ivar AllowChargedAtoms: The atomic charges are automatically estimated during intermediate generation. If this keyword is set to False, then all estimated charges need to be zero.
        :vartype AllowChargedAtoms: BoolType | BoolKey
        :ivar AllowChargedMolecules: 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.
        :vartype AllowChargedMolecules: BoolType | BoolKey
        :ivar ChargeConservation: 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.
        :vartype ChargeConservation: BoolType | BoolKey
        :ivar CheckElectronegativity: 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.
        :vartype CheckElectronegativity: BoolType | BoolKey
        :ivar DigressionScreening: 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).
        :vartype DigressionScreening: BoolType | BoolKey
        :ivar DiscardAtomicOverCharge: 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.
        :vartype DiscardAtomicOverCharge: BoolType | BoolKey
        :ivar DiscardMolecularOverCharge: If the total charge for an molecule in a intermediate state is smaller than -2 or bigger than +2, it will be screened.
        :vartype DiscardMolecularOverCharge: BoolType | BoolKey
        :ivar MaxAllowedRadicals: 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.
        :vartype MaxAllowedRadicals: int | IntKey
        :ivar MaxMetalElectronCount: It has an integer. It is the maximum number of counted electrons of metal (neutral counting)
        :vartype MaxMetalElectronCount: int | IntKey
        :ivar MaxTotalRingNumber: 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.
        :vartype MaxTotalRingNumber: int | IntKey
        :ivar MetalMaxCoordination: Restricts the maximal number of coordinations of transition metals.
        :vartype MetalMaxCoordination: int | IntKey
        :ivar MetalMinCoordination: Restricts the minimal number of coordinations of transition metals.
        :vartype MetalMinCoordination: int | IntKey
        :ivar MinMetalElectronCount: It has an integer. It is the minimum number of counted electrons of metal (neutral counting)
        :vartype MinMetalElectronCount: int | IntKey
        :ivar MinTotalRingNumber: 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.
        :vartype MinTotalRingNumber: int | IntKey
        :ivar SuperMoleculeCharge: If TotalChargeMethod is set to Ionic, this is the total charge the intermediate (sum of submolecules) always needs to have.
        :vartype SuperMoleculeCharge: float | FloatKey
        """
        def __post_init__(self):
            self.AllowAldehyde: BoolType | BoolKey = BoolKey(name='AllowAldehyde', comment='Determines whether aldehyde anions are acceptable intermediates. Screened after propagation, and before geometry optimization.', default=True)
            self.AllowCarbenes: BoolType | BoolKey = BoolKey(name='AllowCarbenes', comment='Allow carbene molecules among the generated intermediates.', default=True)
            self.AllowChargedAtoms: BoolType | BoolKey = BoolKey(name='AllowChargedAtoms', comment='The atomic charges are automatically estimated during intermediate generation. If this keyword is set to False, then all estimated charges need to be zero.', default=True)
            self.AllowChargedMolecules: BoolType | BoolKey = BoolKey(name='AllowChargedMolecules', comment='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.', default=True)
            self.ChargeConservation: BoolType | BoolKey = BoolKey(name='ChargeConservation', comment='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.', default=True)
            self.CheckElectronegativity: BoolType | BoolKey = BoolKey(name='CheckElectronegativity', comment='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.', default=False)
            self.DigressionScreening: BoolType | BoolKey = BoolKey(name='DigressionScreening', comment='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).', default=False)
            self.DiscardAtomicOverCharge: BoolType | BoolKey = BoolKey(name='DiscardAtomicOverCharge', comment='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.', default=False)
            self.DiscardMolecularOverCharge: BoolType | BoolKey = BoolKey(name='DiscardMolecularOverCharge', comment='If the total charge for an molecule in a intermediate state is smaller than -2 or bigger than +2, it will be screened.', default=False)
            self.MaxAllowedRadicals: int | IntKey = IntKey(name='MaxAllowedRadicals', comment='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.', default=-1)
            self.MaxMetalElectronCount: int | IntKey = IntKey(name='MaxMetalElectronCount', comment='It has an integer. It is the maximum number of counted electrons of metal (neutral counting)', default=100)
            self.MaxTotalRingNumber: int | IntKey = IntKey(name='MaxTotalRingNumber', comment='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.', default=100000)
            self.MetalMaxCoordination: int | IntKey = IntKey(name='MetalMaxCoordination', comment='Restricts the maximal number of coordinations of transition metals.', default=-1)
            self.MetalMinCoordination: int | IntKey = IntKey(name='MetalMinCoordination', comment='Restricts the minimal number of coordinations of transition metals.', default=-1)
            self.MinMetalElectronCount: int | IntKey = IntKey(name='MinMetalElectronCount', comment='It has an integer. It is the minimum number of counted electrons of metal (neutral counting)', default=0)
            self.MinTotalRingNumber: int | IntKey = IntKey(name='MinTotalRingNumber', comment='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.', default=-1)
            self.SuperMoleculeCharge: float | FloatKey = FloatKey(name='SuperMoleculeCharge', comment='If TotalChargeMethod is set to Ionic, this is the total charge the intermediate (sum of submolecules) always needs to have.')
[docs]    class _MoleculeSpecificMatrixScreeningOptions(FixedBlock):
        r"""
        Molecule specific options that may be moved to System settings in future.
        
        :ivar Elements_NoTerminus: 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
        :vartype Elements_NoTerminus: str | StringKey
        :ivar ForbiddenMetalElectronCount: 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.
        :vartype ForbiddenMetalElectronCount: int | IntKey
        :ivar LigandElectronCount: 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).
        :vartype LigandElectronCount: int | IntKey
        :ivar 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.
        :vartype RangeOfValences: ACERXN._MoleculeSpecificMatrixScreeningOptions._RangeOfValences
        """
[docs]        class _RangeOfValences(FixedBlock):
            r"""
            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.
            
            :ivar Element: The element for which the maximum and/or minimum allowed number of bonds is set.
            :vartype Element: str | StringKey
            :ivar MaxNumberOfBonds: The maximum number of bonds allowed for this element.
            :vartype MaxNumberOfBonds: int | IntKey
            :ivar MinNumberOfBonds: The minimum number of bonds allowed for this element.
            :vartype MinNumberOfBonds: int | IntKey
            """
            def __post_init__(self):
                self.Element: str | StringKey = StringKey(name='Element', comment='The element for which the maximum and/or minimum allowed number of bonds is set.')
                self.MaxNumberOfBonds: int | IntKey = IntKey(name='MaxNumberOfBonds', comment='The maximum number of bonds allowed for this element.')
                self.MinNumberOfBonds: int | IntKey = IntKey(name='MinNumberOfBonds', comment='The minimum number of bonds allowed for this element.')
        def __post_init__(self):
            self.Elements_NoTerminus: str | StringKey = StringKey(name='Elements_NoTerminus', comment='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', unique=False)
            self.ForbiddenMetalElectronCount: int | IntKey = IntKey(name='ForbiddenMetalElectronCount', comment='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.', unique=False)
            self.LigandElectronCount: int | IntKey = IntKey(name='LigandElectronCount', comment='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).', unique=False)
            self.RangeOfValences: ACERXN._MoleculeSpecificMatrixScreeningOptions._RangeOfValences = self._RangeOfValences(name='RangeOfValences', comment='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.', unique=False)
[docs]    class _NetworkCreation(FixedBlock):
        r"""
        Options exclusively used for network creation (Step 2)
        
        :ivar FindDelocalizedBonds: Seems to write information on bond delocalization into the Intermediate objects before the network is created.
        :vartype FindDelocalizedBonds: BoolType | BoolKey
        :ivar Screening: Options related to the screening of intermediates
        :vartype Screening: ACERXN._NetworkCreation._Screening
        """
[docs]        class _Screening(FixedBlock):
            r"""
            Options related to the screening of intermediates
            
            :ivar CutoffWRTReactantEnergy: 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.
            :vartype CutoffWRTReactantEnergy: float | FloatKey
            """
            def __post_init__(self):
                self.CutoffWRTReactantEnergy: float | FloatKey = FloatKey(name='CutoffWRTReactantEnergy', comment='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.')
        def __post_init__(self):
            self.FindDelocalizedBonds: BoolType | BoolKey = BoolKey(name='FindDelocalizedBonds', comment='Seems to write information on bond delocalization into the Intermediate objects before the network is created.', default=False)
            self.Screening: ACERXN._NetworkCreation._Screening = self._Screening(name='Screening', comment='Options related to the screening of intermediates')
[docs]    class _NetworkMinimization(FixedBlock):
        r"""
        Options exclusively used for network minimization (Step 3)
        
        :ivar Barrier_cutoff: 
        :vartype Barrier_cutoff: float | FloatKey
        :ivar Pathlength_cutoff: If this value is positive, only those paths are collected whose lengths are less than or equal to the given value in step3.
        :vartype Pathlength_cutoff: int | IntKey
        :ivar YenKSP_K: For given value k, the kth shortest paths are extracted in the final step of ACErxn.
        :vartype YenKSP_K: int | IntKey
        """
        def __post_init__(self):
            self.Barrier_cutoff: float | FloatKey = FloatKey(name='Barrier_cutoff', default=0.0)
            self.Pathlength_cutoff: int | IntKey = IntKey(name='Pathlength_cutoff', comment='If this value is positive, only those paths are collected whose lengths are less than or equal to the given value in step3.', default=-1)
            self.YenKSP_K: int | IntKey = IntKey(name='YenKSP_K', comment='For given value k, the kth shortest paths are extracted in the final step of ACErxn.', default=1)
[docs]    class _ReactantFragmentation(FixedBlock):
        r"""
        Details on how the reactant is split into smallest fragments, and how those are assigned charges and stabilities
        
        :ivar DepthElectronegativitySearch: 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.
        :vartype DepthElectronegativitySearch: int | IntKey
        """
        def __post_init__(self):
            self.DepthElectronegativitySearch: int | IntKey = IntKey(name='DepthElectronegativitySearch', comment='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.', default=1)
[docs]    class _RedundantOptions(FixedBlock):
        r"""
        Options that in this version have only one possible value
        
        :ivar BH_or_Det: 
        :vartype BH_or_Det: str | StringKey
        :ivar Bond_Iteration_Method: According to the input description by Jin Woo, 'Propagation' is the only option, although the default in the ACE code is 'Binary'
        :vartype Bond_Iteration_Method: str | StringKey
        :ivar Command: Is not relevant when AMS is used
        :vartype Command: str | StringKey
        :ivar CreateStereoIsomers: If True, stereo-chemistry of stereo centers is considered during 3D conversion. Not supported in current version.
        :vartype CreateStereoIsomers: BoolType | BoolKey
        :ivar DFTB3: 
        :vartype DFTB3: str | StringKey
        :ivar DFTB_dispersion: 
        :vartype DFTB_dispersion: str | StringKey
        :ivar DistanceMethod: According to the input description by Jin Woo, 'ChemDist' is the only option, although the default in the ACE code is 'BondSimilarity'
        :vartype DistanceMethod: str | StringKey
        :ivar Fragment_number: Fragment numbers for the reactive atoms need to be read at the bottom of the input file. Obsolete if not input file is used.
        :vartype Fragment_number: str | StringKey
        :ivar GeomType: 
        :vartype GeomType: str | StringKey
        :ivar GeomWriteFormat: According to the input description by Jin Woo, 'xyz' is the only option, although the default in the ACE code is 'g09'
        :vartype GeomWriteFormat: str | StringKey
        :ivar Reactive_Atoms: 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
        :vartype Reactive_Atoms: str | StringKey
        :ivar Temperature: It determines the temperature in Kelvin. It is calculation option for semi-empirical or DFTB.
        :vartype Temperature: float | FloatKey
        :ivar UseFragments: 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.
        :vartype UseFragments: BoolType | BoolKey
        :ivar skf_dir: It is the path of the directory that contains skf files. It is replaced by the content of the engine file referenced in QMcalculation
        :vartype skf_dir: str | StringKey
        :ivar BasinHopping: Options related to Basin Hopping
        :vartype BasinHopping: ACERXN._RedundantOptions._BasinHopping
        :ivar Miscellaneous: 
        :vartype Miscellaneous: ACERXN._RedundantOptions._Miscellaneous
        :ivar PruningOptions: Redundant options related to pruning intermediates in step 1 (intermediate generation)
        :vartype PruningOptions: ACERXN._RedundantOptions._PruningOptions
        :ivar SpeciesNetOptions: 
        :vartype SpeciesNetOptions: ACERXN._RedundantOptions._SpeciesNetOptions
        """
[docs]        class _BasinHopping(FixedBlock):
            r"""
            Options related to Basin Hopping
            
            :ivar BH_InternalRotation: 
            :vartype BH_InternalRotation: BoolType | BoolKey
            :ivar BH_Relaxation_Method: 
            :vartype BH_Relaxation_Method: str | StringKey
            :ivar PickOneFragment: 
            :vartype PickOneFragment: BoolType | BoolKey
            :ivar Read_MM_AtomType: 
            :vartype Read_MM_AtomType: str | StringKey
            :ivar Spread_Direction: 
            :vartype Spread_Direction: str | StringKey
            """
            def __post_init__(self):
                self.BH_InternalRotation: BoolType | BoolKey = BoolKey(name='BH_InternalRotation', default=True)
                self.BH_Relaxation_Method: str | StringKey = StringKey(name='BH_Relaxation_Method', default='DFTB')
                self.PickOneFragment: BoolType | BoolKey = BoolKey(name='PickOneFragment', default=True)
                self.Read_MM_AtomType: str | StringKey = StringKey(name='Read_MM_AtomType', default='N')
                self.Spread_Direction: str | StringKey = StringKey(name='Spread_Direction', default='xyz')
[docs]        class _Miscellaneous(FixedBlock):
            r"""
            
            
            :ivar GenerateQST2Input: 
            :vartype GenerateQST2Input: BoolType | BoolKey
            """
            def __post_init__(self):
                self.GenerateQST2Input: BoolType | BoolKey = BoolKey(name='GenerateQST2Input', default=False)
[docs]        class _PruningOptions(FixedBlock):
            r"""
            Redundant options related to pruning intermediates in step 1 (intermediate generation)
            
            :ivar IM_MaxAtoms: 
            :vartype IM_MaxAtoms: int | IntKey
            :ivar PruningUndervalence: 
            :vartype PruningUndervalence: BoolType | BoolKey
            """
            def __post_init__(self):
                self.IM_MaxAtoms: int | IntKey = IntKey(name='IM_MaxAtoms', default=100000)
                self.PruningUndervalence: BoolType | BoolKey = BoolKey(name='PruningUndervalence', default=True)
[docs]        class _SpeciesNetOptions(FixedBlock):
            r"""
            
            
            :ivar Bond_Pick: 
            :vartype Bond_Pick: float | FloatKey
            :ivar Reactant_Pick: 
            :vartype Reactant_Pick: float | FloatKey
            :ivar Uniform_Pick: 
            :vartype Uniform_Pick: BoolType | BoolKey
            """
            def __post_init__(self):
                self.Bond_Pick: float | FloatKey = FloatKey(name='Bond_Pick', default=1.0)
                self.Reactant_Pick: float | FloatKey = FloatKey(name='Reactant_Pick', default=1.0)
                self.Uniform_Pick: BoolType | BoolKey = BoolKey(name='Uniform_Pick', default=True)
        def __post_init__(self):
            self.BH_or_Det: str | StringKey = StringKey(name='BH_or_Det', default='Det')
            self.Bond_Iteration_Method: str | StringKey = StringKey(name='Bond_Iteration_Method', comment="According to the input description by Jin Woo, 'Propagation' is the only option, although the default in the ACE code is 'Binary'", default='Propagation')
            self.Command: str | StringKey = StringKey(name='Command', comment='Is not relevant when AMS is used', default='g09')
            self.CreateStereoIsomers: BoolType | BoolKey = BoolKey(name='CreateStereoIsomers', comment='If True, stereo-chemistry of stereo centers is considered during 3D conversion. Not supported in current version.', hidden=True, default=False)
            self.DFTB3: str | StringKey = StringKey(name='DFTB3', default='N')
            self.DFTB_dispersion: str | StringKey = StringKey(name='DFTB_dispersion')
            self.DistanceMethod: str | StringKey = StringKey(name='DistanceMethod', comment="According to the input description by Jin Woo, 'ChemDist' is the only option, although the default in the ACE code is 'BondSimilarity'", default='ChemDist')
            self.Fragment_number: str | StringKey = StringKey(name='Fragment_number', comment='Fragment numbers for the reactive atoms need to be read at the bottom of the input file. Obsolete if not input file is used.', default='user')
            self.GeomType: str | StringKey = StringKey(name='GeomType', default='xyz')
            self.GeomWriteFormat: str | StringKey = StringKey(name='GeomWriteFormat', comment="According to the input description by Jin Woo, 'xyz' is the only option, although the default in the ACE code is 'g09'", default='xyz')
            self.Reactive_Atoms: str | StringKey = StringKey(name='Reactive_Atoms', comment='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', default='user')
            self.Temperature: float | FloatKey = FloatKey(name='Temperature', comment='It determines the temperature in Kelvin. It is calculation option for semi-empirical or DFTB.', default=298.15)
            self.UseFragments: BoolType | BoolKey = BoolKey(name='UseFragments', comment='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.', default=True)
            self.skf_dir: str | StringKey = StringKey(name='skf_dir', comment='It is the path of the directory that contains skf files. It is replaced by the content of the engine file referenced in QMcalculation', default='/skf/3ob-3-1/')
            self.BasinHopping: ACERXN._RedundantOptions._BasinHopping = self._BasinHopping(name='BasinHopping', comment='Options related to Basin Hopping')
            self.Miscellaneous: ACERXN._RedundantOptions._Miscellaneous = self._Miscellaneous(name='Miscellaneous')
            self.PruningOptions: ACERXN._RedundantOptions._PruningOptions = self._PruningOptions(name='PruningOptions', comment='Redundant options related to pruning intermediates in step 1 (intermediate generation)')
            self.SpeciesNetOptions: ACERXN._RedundantOptions._SpeciesNetOptions = self._SpeciesNetOptions(name='SpeciesNetOptions')
[docs]    class _RunInfo(FixedBlock):
        r"""
        General run and file-Info on creating an ACErxn network
        
        :ivar MinNumberOfShortestPathsWritten: The minimum number of shortest paths written to the shortest_paths.rkf file. Only relevant with Steps=All,Steps=MinimizeNetwork, or Steps=AnalyzeNetwork.
        :vartype MinNumberOfShortestPathsWritten: int | IntKey
        :ivar RestartDir: Path to the folder containing the restart RKF files
        :vartype RestartDir: str | Path | StringKey
        :ivar Steps: Which of the three ACErxn steps to run ((1) GenerateIntermediates, (2) CreateNetwork, (3) MinimizeNetwork, (4) AnalyzeNetwork). The default is to run the first three.
        :vartype Steps: Literal["GenerateIntermediates", "CreateNetwork", "MinimizeNetwork", "AnalyzeNetwork", "All"]
        :ivar UseAllIntermediatesForPaths: If set (default), if two paths are found with the same chemical distance, then only the one including the most intermediates will be kept.
        :vartype UseAllIntermediatesForPaths: BoolType | BoolKey
        """
        def __post_init__(self):
            self.MinNumberOfShortestPathsWritten: int | IntKey = IntKey(name='MinNumberOfShortestPathsWritten', comment='The minimum number of shortest paths written to the shortest_paths.rkf file. Only relevant with Steps=All,Steps=MinimizeNetwork, or Steps=AnalyzeNetwork.', default=5)
            self.RestartDir: str | Path | StringKey = PathStringKey(name='RestartDir', comment='Path to the folder containing the restart RKF files', gui_name='Restart directory:', default='', ispath=True, gui_type='directory')
            self.Steps: Literal["GenerateIntermediates", "CreateNetwork", "MinimizeNetwork", "AnalyzeNetwork", "All"] = MultipleChoiceKey(name='Steps', comment='Which of the three ACErxn steps to run ((1) GenerateIntermediates, (2) CreateNetwork, (3) MinimizeNetwork, (4) AnalyzeNetwork). The default is to run the first three.', default='All', choices=['GenerateIntermediates', 'CreateNetwork', 'MinimizeNetwork', 'AnalyzeNetwork', 'All'])
            self.UseAllIntermediatesForPaths: BoolType | BoolKey = BoolKey(name='UseAllIntermediatesForPaths', comment='If set (default), if two paths are found with the same chemical distance, then only the one including the most intermediates will be kept.', default=True)
[docs]    class _System(FixedBlock):
        r"""
        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.
        
        :ivar AllowCloseAtoms: 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.
        :vartype AllowCloseAtoms: BoolType | BoolKey
        :ivar Charge: The system's total charge in atomic units.
        :vartype Charge: float | FloatKey
        :ivar FractionalCoords: Whether the atomic coordinates in the Atoms block are given in fractional coordinates of the lattice vectors. Requires the presence of the Lattice block.
        :vartype FractionalCoords: BoolType | BoolKey
        :ivar GeometryFile: Read the geometry from a file (instead of from Atoms and Lattice blocks). Supported formats: .xyz
        :vartype GeometryFile: str | Path | StringKey
        :ivar GuessBonds: Whether or not UFF bonds should be guessed.
        :vartype GuessBonds: BoolType | BoolKey
        :ivar LatticeStrain: 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.
        :vartype LatticeStrain: Iterable[float] | FloatListKey
        :ivar MapAtomsToUnitCell: For periodic systems the atoms will be moved to the central cell.
        :vartype MapAtomsToUnitCell: BoolType | BoolKey
        :ivar ModifyAlternativeElements: When using alternative elements (using the nuclear_charge attribute) set the element to the nearest integer Z. If you specify an H atom with a nuclear_charge of 2.9 it is replaced by a Li atom with the same nuclear charge.
        :vartype ModifyAlternativeElements: BoolType | BoolKey
        :ivar PerturbCoordinates: 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).
        :vartype PerturbCoordinates: float | FloatKey
        :ivar PerturbLattice: 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.
        :vartype PerturbLattice: float | FloatKey
        :ivar RandomizeAtomOrder: 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.
        :vartype RandomizeAtomOrder: BoolType | BoolKey
        :ivar ShiftCoordinates: Translate the atoms by the specified shift (three numbers).
        :vartype ShiftCoordinates: Iterable[float] | FloatListKey
        :ivar SuperCell: 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).
        :vartype SuperCell: Iterable[int] | IntListKey
        :ivar SuperCellTrafo: Create a supercell of the input system (only possible for periodic systems) :math:`\vec{a}_i' = \sum_j T_{ij} \vec{a}_j`. The integer numbers represent the supercell transformation :math:`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)).
        :vartype SuperCellTrafo: Iterable[int] | IntListKey
        :ivar Symmetrize: 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. 
        :vartype Symmetrize: BoolType | BoolKey
        :ivar Symmetry: 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.
        :vartype 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)"]
        :ivar Atoms: The atom types and coordinates. Unit can be specified in the header. Default unit is Angstrom.
        :vartype Atoms: str | Sequence[str] | FreeBlock
        :ivar 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.
        :vartype BondOrders: str | Sequence[str] | FreeBlock
        :ivar DefineRegion: Defines a region of atoms using more comprehensive selecting methods
        :vartype DefineRegion: ACERXN._System._DefineRegion
        :ivar ElectrostaticEmbedding: Container for electrostatic embedding options, which can be combined.
        :vartype ElectrostaticEmbedding: ACERXN._System._ElectrostaticEmbedding
        :ivar Lattice: Up to three lattice vectors. Unit can be specified in the header. Default unit is Angstrom.
        :vartype Lattice: str | Sequence[str] | FreeBlock
        :ivar LoadForceFieldAtomTypes: This is a mechanism to set the ForceField.Type attribute in the input. This information is currently only used by the ForceField engine.
        :vartype LoadForceFieldAtomTypes: ACERXN._System._LoadForceFieldAtomTypes
        :ivar LoadForceFieldCharges: This is a mechanism to set the ForceField.Charge attribute in the input. This information is currently only used by the ForceField engine.
        :vartype LoadForceFieldCharges: ACERXN._System._LoadForceFieldCharges
        :ivar Region: Properties for each region specified in the Atoms block.
        :vartype Region: ACERXN._System._Region
        """
[docs]        class _Atoms(FreeBlock):
            r"""
            The atom types and coordinates. Unit can be specified in the header. Default unit is Angstrom.
            
            """
            def __post_init__(self):
                pass
[docs]        class _BondOrders(FreeBlock):
            r"""
            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.
            
            """
            def __post_init__(self):
                pass
[docs]        class _DefineRegion(FixedBlock):
            r"""
            Defines a region of atoms using more comprehensive selecting methods
            
            :ivar AtomRange: Specifies a region by selecting all atoms with indices between a certain range (including the beginning and ending index). Input format is: beginIndex endingIndex
            :vartype AtomRange: Iterable[int] | IntListKey
            :ivar Axis: 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
            :vartype Axis: Iterable[float] | FloatListKey
            :ivar Box: Specifies a region by selecting all atoms that are present inside a box in space. Input format is: Xmin, Xmax, Ymin, Ymax, Zmin, Zmax
            :vartype Box: Iterable[float] | FloatListKey
            :ivar Name: Name of the specific region
            :vartype Name: str | StringKey
            """
            def __post_init__(self):
                self.AtomRange: Iterable[int] | IntListKey = IntListKey(name='AtomRange', comment='Specifies a region by selecting all atoms with indices between a certain range (including the beginning and ending index). Input format is: beginIndex endingIndex')
                self.Axis: Iterable[float] | FloatListKey = FloatListKey(name='Axis', comment='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')
                self.Box: Iterable[float] | FloatListKey = FloatListKey(name='Box', comment='Specifies a region by selecting all atoms that are present inside a box in space. Input format is: Xmin, Xmax, Ymin, Ymax, Zmin, Zmax')
                self.Name: str | StringKey = StringKey(name='Name', comment='Name of the specific region')
[docs]        class _ElectrostaticEmbedding(FixedBlock):
            r"""
            Container for electrostatic embedding options, which can be combined.
            
            :ivar ElectricField: 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.
            :vartype ElectricField: Iterable[float] | FloatListKey
            :ivar MultipolePotential: External point charges (and dipoles).
            :vartype MultipolePotential: ACERXN._System._ElectrostaticEmbedding._MultipolePotential
            """
[docs]            class _MultipolePotential(FixedBlock):
                r"""
                External point charges (and dipoles).
                
                :ivar ChargeModel: A multipole may be represented by a point (with a singular potential at its location) or by a spherical Gaussian distribution.
                :vartype ChargeModel: Literal["Point", "Gaussian"]
                :ivar ChargeWidth: 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.
                :vartype ChargeWidth: float | FloatKey
                :ivar 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.
                :vartype Coordinates: str | Sequence[str] | FreeBlock
                """
[docs]                class _Coordinates(FreeBlock):
                    r"""
                    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.
                    
                    """
                    def __post_init__(self):
                        pass
                def __post_init__(self):
                    self.ChargeModel: Literal["Point", "Gaussian"] = MultipleChoiceKey(name='ChargeModel', comment='A multipole may be represented by a point (with a singular potential at its location) or by a spherical Gaussian distribution.', default='Point', choices=['Point', 'Gaussian'])
                    self.ChargeWidth: float | FloatKey = FloatKey(name='ChargeWidth', comment='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.', default=-1.0)
                    self.Coordinates: str | Sequence[str] | FreeBlock = self._Coordinates(name='Coordinates', comment='Positions and values of the multipoles, one per line. Each line has the following format:\n\nx y z q, or\nx y z q µx µy µz.\n\nHere 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). \n\nPeriodic systems are not supported.', header=True)
            def __post_init__(self):
                self.ElectricField: Iterable[float] | FloatListKey = FloatListKey(name='ElectricField', comment='External homogeneous electric field with three Cartesian components: ex, ey, ez, the default unit being V/Å.\n\nIn atomic units: Hartree/(e bohr) = 51.422 V/Angstrom; the relation to SI units is: 1 Hartree/(e bohr) = 5.14 ... e11 V/m.\n\nSupported by the engines adf, band, dftb and mopac.\n\nFor 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.', unit='V/Angstrom')
                self.MultipolePotential: ACERXN._System._ElectrostaticEmbedding._MultipolePotential = self._MultipolePotential(name='MultipolePotential', comment='External point charges (and dipoles).')
[docs]        class _Lattice(FreeBlock):
            r"""
            Up to three lattice vectors. Unit can be specified in the header. Default unit is Angstrom.
            
            """
            def __post_init__(self):
                pass
[docs]        class _LoadForceFieldAtomTypes(FixedBlock):
            r"""
            This is a mechanism to set the ForceField.Type attribute in the input. This information is currently only used by the ForceField engine.
            
            :ivar File: Name of the (kf) file. It needs to be the result of a forcefield calculation.
            :vartype File: str | StringKey
            """
            def __post_init__(self):
                self.File: str | StringKey = StringKey(name='File', comment='Name of the (kf) file. It needs to be the result of a forcefield calculation.')
[docs]        class _LoadForceFieldCharges(FixedBlock):
            r"""
            This is a mechanism to set the ForceField.Charge attribute in the input. This information is currently only used by the ForceField engine.
            
            :ivar CheckGeometryRMSD: 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.
            :vartype CheckGeometryRMSD: BoolType | BoolKey
            :ivar File: Name of the (kf) file
            :vartype File: str | StringKey
            :ivar MaxGeometryRMSD: The geometry of the charge producing calculation is compared to the one of the region, and need to be the same within this tolerance.
            :vartype MaxGeometryRMSD: float | FloatKey
            :ivar Region: Region for which the charges should be loaded
            :vartype Region: str | StringKey
            :ivar Section: Section name of the kf file
            :vartype Section: str | StringKey
            :ivar Variable: Variable name of the kf file
            :vartype Variable: str | StringKey
            """
            def __post_init__(self):
                self.CheckGeometryRMSD: BoolType | BoolKey = BoolKey(name='CheckGeometryRMSD', comment='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.', default=False)
                self.File: str | StringKey = StringKey(name='File', comment='Name of the (kf) file')
                self.MaxGeometryRMSD: float | FloatKey = FloatKey(name='MaxGeometryRMSD', comment='The geometry of the charge producing calculation is compared to the one of the region, and need to be the same within this tolerance.', default=0.1, unit='Angstrom')
                self.Region: str | StringKey = StringKey(name='Region', comment='Region for which the charges should be loaded', default='*')
                self.Section: str | StringKey = StringKey(name='Section', comment='Section name of the kf file', default='AMSResults')
                self.Variable: str | StringKey = StringKey(name='Variable', comment='Variable name of the kf file', default='Charges')
[docs]        class _Region(FixedBlock):
            r"""
            Properties for each region specified in the Atoms block.
            
            :ivar Properties: Properties for each region specified in the Atoms block.
            :vartype Properties: str | Sequence[str] | FreeBlock
            """
[docs]            class _Properties(FreeBlock):
                r"""
                Properties for each region specified in the Atoms block.
                
                """
                def __post_init__(self):
                    pass
            def __post_init__(self):
                self.Properties: str | Sequence[str] | FreeBlock = self._Properties(name='Properties', comment='Properties for each region specified in the Atoms block.')
        def __post_init__(self):
            self.AllowCloseAtoms: BoolType | BoolKey = BoolKey(name='AllowCloseAtoms', comment='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.', default=False)
            self.Charge: float | FloatKey = FloatKey(name='Charge', comment="The system's total charge in atomic units.", gui_name='Total charge:', default=0.0, engines='-forcefield')
            self.FractionalCoords: BoolType | BoolKey = BoolKey(name='FractionalCoords', comment='Whether the atomic coordinates in the Atoms block are given in fractional coordinates of the lattice vectors. Requires the presence of the Lattice block.', default=False)
            self.GeometryFile: str | Path | StringKey = PathStringKey(name='GeometryFile', comment='Read the geometry from a file (instead of from Atoms and Lattice blocks). Supported formats: .xyz', ispath=True)
            self.GuessBonds: BoolType | BoolKey = BoolKey(name='GuessBonds', comment='Whether or not UFF bonds should be guessed.', default=False)
            self.LatticeStrain: Iterable[float] | FloatListKey = FloatListKey(name='LatticeStrain', comment='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.')
            self.MapAtomsToUnitCell: BoolType | BoolKey = BoolKey(name='MapAtomsToUnitCell', comment='For periodic systems the atoms will be moved to the central cell.', default=False)
            self.ModifyAlternativeElements: BoolType | BoolKey = BoolKey(name='ModifyAlternativeElements', comment='When using alternative elements (using the nuclear_charge attribute) set the element to the nearest integer Z. If you specify an H atom with a nuclear_charge of 2.9 it is replaced by a Li atom with the same nuclear charge.', default=False)
            self.PerturbCoordinates: float | FloatKey = FloatKey(name='PerturbCoordinates', comment='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).', default=0.0, unit='Angstrom')
            self.PerturbLattice: float | FloatKey = FloatKey(name='PerturbLattice', comment='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.', default=0.0)
            self.RandomizeAtomOrder: BoolType | BoolKey = BoolKey(name='RandomizeAtomOrder', comment='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.', default=False)
            self.ShiftCoordinates: Iterable[float] | FloatListKey = FloatListKey(name='ShiftCoordinates', comment='Translate the atoms by the specified shift (three numbers).', unit='Bohr')
            self.SuperCell: Iterable[int] | IntListKey = IntListKey(name='SuperCell', comment='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).')
            self.SuperCellTrafo: Iterable[int] | IntListKey = IntListKey(name='SuperCellTrafo', comment="Create a supercell of the input system (only possible for periodic systems) :math:`\\vec{a}_i' = \\sum_j T_{ij} \\vec{a}_j`. The integer numbers represent the supercell transformation :math:`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)).")
            self.Symmetrize: BoolType | BoolKey = BoolKey(name='Symmetrize', comment='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. ', default=False)
            self.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)"] = MultipleChoiceKey(name='Symmetry', comment='Use (sub)symmetry with this Schoenflies symbol. Can only be used for molecules. Orientation should be correct for the (sub)symmetry. If used icw Symmetrize, the symmetrization will not reorient the molecule.', default='AUTO', choices=['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)'])
            self.Atoms: str | Sequence[str] | FreeBlock = self._Atoms(name='Atoms', comment='The atom types and coordinates. Unit can be specified in the header. Default unit is Angstrom.', header=True)
            self.BondOrders: str | Sequence[str] | FreeBlock = self._BondOrders(name='BondOrders', comment='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.')
            self.DefineRegion: ACERXN._System._DefineRegion = self._DefineRegion(name='DefineRegion', comment='Defines a region of atoms using more comprehensive selecting methods', hidden=True, unique=False)
            self.ElectrostaticEmbedding: ACERXN._System._ElectrostaticEmbedding = self._ElectrostaticEmbedding(name='ElectrostaticEmbedding', comment='Container for electrostatic embedding options, which can be combined.')
            self.Lattice: str | Sequence[str] | FreeBlock = self._Lattice(name='Lattice', comment='Up to three lattice vectors. Unit can be specified in the header. Default unit is Angstrom.', header=True)
            self.LoadForceFieldAtomTypes: ACERXN._System._LoadForceFieldAtomTypes = self._LoadForceFieldAtomTypes(name='LoadForceFieldAtomTypes', comment='This is a mechanism to set the ForceField.Type attribute in the input. This information is currently only used by the ForceField engine.')
            self.LoadForceFieldCharges: ACERXN._System._LoadForceFieldCharges = self._LoadForceFieldCharges(name='LoadForceFieldCharges', comment='This is a mechanism to set the ForceField.Charge attribute in the input. This information is currently only used by the ForceField engine.', unique=False)
            self.Region: ACERXN._System._Region = self._Region(name='Region', comment='Properties for each region specified in the Atoms block.', unique=False, header=True)
    def __post_init__(self):
        self.Product: str | StringKey = StringKey(name='Product', comment='Make one or more product molecule.', hidden=True, unique=False, gui_type='molecule')
        self.Reactant: str | StringKey = StringKey(name='Reactant', comment='Make one or more reactant molecule.', hidden=True, unique=False, gui_type='molecule')
        self.BasicOptions: ACERXN._BasicOptions = self._BasicOptions(name='BasicOptions', comment='General options')
        self.DistanceOptions: ACERXN._DistanceOptions = self._DistanceOptions(name='DistanceOptions')
        self.Engine: EngineBlock = self._Engine(name='Engine', comment='The input for the computational engine used to compute energy and forces.', unique=False, header=True, default_engine='ForceField')
        self.GeomGenRelatedScreeningOptions: ACERXN._GeomGenRelatedScreeningOptions = self._GeomGenRelatedScreeningOptions(name='GeomGenRelatedScreeningOptions', comment='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).')
        self.IntermediateGeneration: ACERXN._IntermediateGeneration = self._IntermediateGeneration(name='IntermediateGeneration', comment='Options used exclusively in intermediate generation (Step 1)')
        self.Intermediates: ACERXN._Intermediates = self._Intermediates(name='Intermediates', comment='If needed specify intermediates.', hidden=True, unique=False)
        self.MappingOptions: ACERXN._MappingOptions = self._MappingOptions(name='MappingOptions', comment='The options used for the chemical distance computations. Currently only used in step2, but in future will also be available in step1.')
        self.MatrixRelatedScreeningOptions: ACERXN._MatrixRelatedScreeningOptions = self._MatrixRelatedScreeningOptions(name='MatrixRelatedScreeningOptions', comment='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).')
        self.MoleculeSpecificMatrixScreeningOptions: ACERXN._MoleculeSpecificMatrixScreeningOptions = self._MoleculeSpecificMatrixScreeningOptions(name='MoleculeSpecificMatrixScreeningOptions', comment='Molecule specific options that may be moved to System settings in future.')
        self.NetworkCreation: ACERXN._NetworkCreation = self._NetworkCreation(name='NetworkCreation', comment='Options exclusively used for network creation (Step 2)')
        self.NetworkMinimization: ACERXN._NetworkMinimization = self._NetworkMinimization(name='NetworkMinimization', comment='Options exclusively used for network minimization (Step 3)')
        self.ReactantFragmentation: ACERXN._ReactantFragmentation = self._ReactantFragmentation(name='ReactantFragmentation', comment='Details on how the reactant is split into smallest fragments, and how those are assigned charges and stabilities')
        self.RedundantOptions: ACERXN._RedundantOptions = self._RedundantOptions(name='RedundantOptions', comment='Options that in this version have only one possible value', hidden=True)
        self.RunInfo: ACERXN._RunInfo = self._RunInfo(name='RunInfo', comment='General run and file-Info on creating an ACErxn network')
        self.System: ACERXN._System = self._System(name='System', comment='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.', unique=False, header=True, gui_type='Repeat at least once', shared_id='AMSSystem')