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 ForceField(EngineBlock):
r"""
:ivar AllowMissingParameters: When parameters are not found for bonds, angles, dihedrals, or inversions, the first entry in the database will be used.
:vartype AllowMissingParameters: BoolType | BoolKey
:ivar AntechamberIntegration: 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.
:vartype AntechamberIntegration: BoolType | BoolKey
:ivar AntechamberTask: If antechamber is invoked to guess atomtypes and charges (GAFF force field), select the task for charge guessing with MOPAC
:vartype AntechamberTask: Literal["GeometryOptimization", "SinglePoint"]
:ivar BondsUsage: 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.
:vartype BondsUsage: Literal["Input", "None", "Guess", "Auto"]
:ivar CheckDuplicateRules: 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.
:vartype CheckDuplicateRules: BoolType | BoolKey
:ivar DipoleConvergenceThreshold: 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.
:vartype DipoleConvergenceThreshold: float | FloatKey
:ivar DoChargeCheck: Check that the sum of atomic (partial) charges equals the total charge of the system.
:vartype DoChargeCheck: BoolType | BoolKey
:ivar EngineConstraints: Set to false to ignore constraints implied by the engine.
:vartype EngineConstraints: BoolType | BoolKey
:ivar ForceFieldFile: Path to the force field parameter file
:vartype ForceFieldFile: str | Path | StringKey
:ivar ForceFieldPatchFile: 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.
:vartype ForceFieldPatchFile: str | Path | StringKey
:ivar GuessCharges: Use another engine to calculate/guess the charges to be used by the force field.
:vartype GuessCharges: BoolType | BoolKey
:ivar KeepAntechamberFolder: If atom-typing is performed with antechamber, keep the folder after the call to antechamber
:vartype KeepAntechamberFolder: BoolType | BoolKey
:ivar LinearizationEnergyForRepulsion: 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.
:vartype LinearizationEnergyForRepulsion: float | FloatKey
:ivar NeighborListSkin: Thickness of the buffer region added to the NonBondedCutoff when building a neighbor list.
:vartype NeighborListSkin: float | FloatKey
:ivar NonBondedCutoff: 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.
:vartype NonBondedCutoff: float | FloatKey
:ivar PairInteractionTapering: 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.
:vartype PairInteractionTapering: Literal["None", "Potential", "Force", "CHARMM", "CHARMM-Force"]
:ivar TaperPairInteractions: 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.
:vartype TaperPairInteractions: BoolType | BoolKey
:ivar Type: Type of force field to be used
:vartype Type: Literal["UFF", "Amber95", "GAFF", "Tripos5.2", "APPLE&P", "UserDefined"]
:ivar Verbosity: Controls the verbosity of the engine.
:vartype Verbosity: Literal["Silent", "Normal", "Verbose", "VeryVerbose"]
:ivar APPLE&P: Options for the APPLE&P force field.
:vartype APPLE&P: ForceField._APPLE&P
:ivar EnergyTerms: expert key, that allows you to disable specific energy terms.
:vartype EnergyTerms: ForceField._EnergyTerms
:ivar EwaldSummation: Configures the details of the particle mesh Ewald (PME) summation of the Coulomb interaction.
:vartype EwaldSummation: ForceField._EwaldSummation
:ivar GAFF: Specific keywords for the GAFF force field type
:vartype GAFF: ForceField._GAFF
:ivar GuessChargesConfig: Guess charges to be used by the forcefield
:vartype GuessChargesConfig: ForceField._GuessChargesConfig
:ivar LAMMPSOffload: Offload the calculation to LAMMPS via AMSPipe.
:vartype LAMMPSOffload: ForceField._LAMMPSOffload
:ivar LoadCharges: Load charges from a file to be used as forcefield charges
:vartype LoadCharges: ForceField._LoadCharges
:ivar 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).
:vartype SoftCorePotentials: ForceField._SoftCorePotentials
:ivar UFF: Option for the UFF force filed.
:vartype UFF: ForceField._UFF
"""
[docs] class _APPLE_AND_P(FixedBlock):
r"""
Options for the APPLE&P force field.
:ivar LongRangeCorrection: 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.
:vartype LongRangeCorrection: BoolType | BoolKey
:ivar MuMu14Scaling: Scaling factor for dipole-dipole interactions between atoms connected to 3rd order (via a dihedral).
:vartype MuMu14Scaling: float | FloatKey
:ivar QMu14Scaling: Scaling factor for charge-dipole interactions between atoms connected to 3rd order (via a dihedral).
:vartype QMu14Scaling: float | FloatKey
:ivar QQ14Scaling: Scaling factor for charge-charge interactions between atoms connected to 3rd order (via a dihedral).
:vartype QQ14Scaling: float | FloatKey
:ivar RD14Scaling: Scaling factor for repulsion/dispersion interactions between atoms connected to 3rd order (via a dihedral).
:vartype RD14Scaling: float | FloatKey
:ivar TholeParam: (UNUSED) Parameter for the exponential Thole screening for the induced dipole-dipole interactions.
:vartype TholeParam: float | FloatKey
"""
def __post_init__(self):
self.LongRangeCorrection: BoolType | BoolKey = BoolKey(name='LongRangeCorrection', comment='Add a long-range dispersion correction to the energy and pressure for 3D-periodic systems. \n\nThis correction should be enabled only for a homogeneous liquid.', gui_name='Add long-range correction:', default=True)
self.MuMu14Scaling: float | FloatKey = FloatKey(name='MuMu14Scaling', comment='Scaling factor for dipole-dipole interactions between atoms connected to 3rd order (via a dihedral).', gui_name='Mu-Mu 3rd-neighbor scaling:', default=1.0)
self.QMu14Scaling: float | FloatKey = FloatKey(name='QMu14Scaling', comment='Scaling factor for charge-dipole interactions between atoms connected to 3rd order (via a dihedral).', gui_name='Q-Mu 3rd-neighbor scaling:', default=0.2)
self.QQ14Scaling: float | FloatKey = FloatKey(name='QQ14Scaling', comment='Scaling factor for charge-charge interactions between atoms connected to 3rd order (via a dihedral).', gui_name='Q-Q 3rd-neighbor scaling:', default=1.0)
self.RD14Scaling: float | FloatKey = FloatKey(name='RD14Scaling', comment='Scaling factor for repulsion/dispersion interactions between atoms connected to 3rd order (via a dihedral).', gui_name='RD 3rd-neighbor scaling:', default=1.0)
self.TholeParam: float | FloatKey = FloatKey(name='TholeParam', comment='(UNUSED) Parameter for the exponential Thole screening for the induced dipole-dipole interactions.', hidden=True, gui_name='Thole screening parameter:', default=0.0)
[docs] class _EnergyTerms(FixedBlock):
r"""
expert key, that allows you to disable specific energy terms.
:ivar Angle: Whether to use angle (bend) energy.
:vartype Angle: BoolType | BoolKey
:ivar Coulomb: Whether to use coulomb energy.
:vartype Coulomb: BoolType | BoolKey
:ivar Dispersion: Whether to use dispersion energy.
:vartype Dispersion: BoolType | BoolKey
:ivar Inversion: Whether to use inversion energy.
:vartype Inversion: BoolType | BoolKey
:ivar Stretch: Whether to use stretch energy.
:vartype Stretch: BoolType | BoolKey
:ivar Torsion: Whether to use torsion energy.
:vartype Torsion: BoolType | BoolKey
"""
def __post_init__(self):
self.Angle: BoolType | BoolKey = BoolKey(name='Angle', comment='Whether to use angle (bend) energy.', default=True)
self.Coulomb: BoolType | BoolKey = BoolKey(name='Coulomb', comment='Whether to use coulomb energy.', default=True)
self.Dispersion: BoolType | BoolKey = BoolKey(name='Dispersion', comment='Whether to use dispersion energy.', default=True)
self.Inversion: BoolType | BoolKey = BoolKey(name='Inversion', comment='Whether to use inversion energy.', default=True)
self.Stretch: BoolType | BoolKey = BoolKey(name='Stretch', comment='Whether to use stretch energy.', default=True)
self.Torsion: BoolType | BoolKey = BoolKey(name='Torsion', comment='Whether to use torsion energy.', default=True)
[docs] class _EwaldSummation(FixedBlock):
r"""
Configures the details of the particle mesh Ewald (PME) summation of the Coulomb interaction.
:ivar Alpha: 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.
:vartype Alpha: float | FloatKey
:ivar Enabled: 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.
:vartype Enabled: BoolType | BoolKey
:ivar GridSpacing: 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.
:vartype GridSpacing: float | FloatKey
:ivar RealSpaceCutoff: 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).
:vartype RealSpaceCutoff: float | FloatKey
:ivar Tolerance: 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.
:vartype Tolerance: float | FloatKey
"""
def __post_init__(self):
self.Alpha: float | FloatKey = FloatKey(name='Alpha', comment='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.', default=-1.0, unit='1/Angstrom')
self.Enabled: BoolType | BoolKey = BoolKey(name='Enabled', comment='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.', default=True)
self.GridSpacing: float | FloatKey = FloatKey(name='GridSpacing', comment='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.', default=0.5, unit='Angstrom')
self.RealSpaceCutoff: float | FloatKey = FloatKey(name='RealSpaceCutoff', comment='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).', default=0.0, unit='Angstrom')
self.Tolerance: float | FloatKey = FloatKey(name='Tolerance', comment='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.', default=1e-10)
[docs] class _GAFF(FixedBlock):
r"""
Specific keywords for the GAFF force field type
:ivar ForceFieldPatchFile: Path to the force field patch parameter file (additional parameters, missing from main file). Cannot be used when atomtypes are guessed.
:vartype ForceFieldPatchFile: str | Path | StringKey
"""
def __post_init__(self):
self.ForceFieldPatchFile: str | Path | StringKey = PathStringKey(name='ForceFieldPatchFile', comment='Path to the force field patch parameter file (additional parameters, missing from main file). Cannot be used when atomtypes are guessed.', unique=False, gui_name='Force field patch file:', ispath=True)
[docs] class _GuessChargesConfig(FixedBlock):
r"""
Guess charges to be used by the forcefield
:ivar EngineType: Engine that can calculate or guess charges
:vartype EngineType: str | StringKey
"""
def __post_init__(self):
self.EngineType: str | StringKey = StringKey(name='EngineType', comment='Engine that can calculate or guess charges', default='dftb')
[docs] class _LAMMPSOffload(FixedBlock):
r"""
Offload the calculation to LAMMPS via AMSPipe.
:ivar Enabled: Enable offloading the force field evaluation to LAMMPS instead of handling it internally in AMS. This is currently only supported for Type=UFF.
:vartype Enabled: BoolType | BoolKey
:ivar UseGPU: Accelerate LAMMPS calculations using a GPU. Requires a LAMMPS library built with the GPU package.
:vartype UseGPU: BoolType | BoolKey
:ivar UseGPUForKSpace: When UseGPU is enabled, also use the GPU to accelerate reciprocal space electrostatic interactions. Disabling this can improve performance on less powerful GPUs.
:vartype UseGPUForKSpace: BoolType | BoolKey
:ivar UseGPUForNeighbor: When UseGPU is enabled, also use the GPU to accelerate neighbor searches. Disabling this can improve performance on less powerful GPUs.
:vartype UseGPUForNeighbor: BoolType | BoolKey
:ivar UseOpenMP: Parallelize LAMMPS calculations using OpenMP threading. Requires a LAMMPS library built with the OMP package.
:vartype UseOpenMP: BoolType | BoolKey
:ivar WorkerCommand: 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.
:vartype WorkerCommand: str | StringKey
:ivar 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.
:vartype Input: str | Sequence[str] | FreeBlock
"""
def __post_init__(self):
self.Enabled: BoolType | BoolKey = BoolKey(name='Enabled', comment='Enable offloading the force field evaluation to LAMMPS instead of handling it internally in AMS. This is currently only supported for Type=UFF.', default=False)
self.UseGPU: BoolType | BoolKey = BoolKey(name='UseGPU', comment='Accelerate LAMMPS calculations using a GPU. Requires a LAMMPS library built with the GPU package.', default=False)
self.UseGPUForKSpace: BoolType | BoolKey = BoolKey(name='UseGPUForKSpace', comment='When UseGPU is enabled, also use the GPU to accelerate reciprocal space electrostatic interactions. Disabling this can improve performance on less powerful GPUs.', default=True)
self.UseGPUForNeighbor: BoolType | BoolKey = BoolKey(name='UseGPUForNeighbor', comment='When UseGPU is enabled, also use the GPU to accelerate neighbor searches. Disabling this can improve performance on less powerful GPUs.', default=True)
self.UseOpenMP: BoolType | BoolKey = BoolKey(name='UseOpenMP', comment='Parallelize LAMMPS calculations using OpenMP threading. Requires a LAMMPS library built with the OMP package.', default=False)
self.WorkerCommand: str | StringKey = StringKey(name='WorkerCommand', comment='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.', default='exec lmp')
self.Input: str | Sequence[str] | FreeBlock = self._Input(name='Input', comment="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.")
[docs] class _LoadCharges(FixedBlock):
r"""
Load charges from a file to be used as forcefield charges
:ivar File: Name of the (kf) file
:vartype File: 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.File: str | StringKey = StringKey(name='File', comment='Name of the (kf) file')
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 _SoftCorePotentials(FixedBlock):
r"""
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).
:ivar Alpha: 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).
:vartype Alpha: float | FloatKey
:ivar Enabled: Set to True to use the scaled soft-core LJ potentials.
:vartype Enabled: BoolType | BoolKey
:ivar Lambda: The scaling parameter for the LJ interaction term for free energy perturbation (the window).
:vartype Lambda: float | FloatKey
"""
def __post_init__(self):
self.Alpha: float | FloatKey = FloatKey(name='Alpha', comment='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).', default=0.5)
self.Enabled: BoolType | BoolKey = BoolKey(name='Enabled', comment='Set to True to use the scaled soft-core LJ potentials.', default=False)
self.Lambda: float | FloatKey = FloatKey(name='Lambda', comment='The scaling parameter for the LJ interaction term for free energy perturbation (the window).', default=1.0)
[docs] class _UFF(FixedBlock):
r"""
Option for the UFF force filed.
:ivar AtomTypesFile: Expert option: Select the file that defines how UFF determines the atom types
:vartype AtomTypesFile: str | StringKey
:ivar Database: Expert option: Select the file that defines the UFF parameters per atom type
:vartype Database: str | StringKey
:ivar ElementsFile: Expert option: Select the file that defines the elements known to UFF
:vartype ElementsFile: str | StringKey
:ivar IgnoreInputBonds: Developer option: Ignore the bonds from the input. This mean UFF will either reuse bonds from a previous result, or will guess the bonds.
:vartype IgnoreInputBonds: BoolType | BoolKey
:ivar Library: Selects the used parameter library.
:vartype Library: Literal["UFF", "UFF4MOF", "UFF4MOF-II"]
"""
def __post_init__(self):
self.AtomTypesFile: str | StringKey = StringKey(name='AtomTypesFile', comment='Expert option: Select the file that defines how UFF determines the atom types', default='mmatomtypes_db')
self.Database: str | StringKey = StringKey(name='Database', comment='Expert option: Select the file that defines the UFF parameters per atom type', default='general_db')
self.ElementsFile: str | StringKey = StringKey(name='ElementsFile', comment='Expert option: Select the file that defines the elements known to UFF', default='elements_db')
self.IgnoreInputBonds: BoolType | BoolKey = BoolKey(name='IgnoreInputBonds', comment='Developer option: Ignore the bonds from the input. This mean UFF will either reuse bonds from a previous result, or will guess the bonds.', hidden=True, default=False)
self.Library: Literal["UFF", "UFF4MOF", "UFF4MOF-II"] = MultipleChoiceKey(name='Library', comment='Selects the used parameter library.', gui_name='Force field library:', default='UFF', choices=['UFF', 'UFF4MOF', 'UFF4MOF-II'])
def __post_init__(self):
self.AllowMissingParameters: BoolType | BoolKey = BoolKey(name='AllowMissingParameters', comment='When parameters are not found for bonds, angles, dihedrals, or inversions, the first entry in the database will be used.', default=False)
self.AntechamberIntegration: BoolType | BoolKey = BoolKey(name='AntechamberIntegration', comment='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.', gui_name='Automatic atom typing:', default=False)
self.AntechamberTask: Literal["GeometryOptimization", "SinglePoint"] = MultipleChoiceKey(name='AntechamberTask', comment='If antechamber is invoked to guess atomtypes and charges (GAFF force field), select the task for charge guessing with MOPAC', default='GeometryOptimization', choices=['GeometryOptimization', 'SinglePoint'])
self.BondsUsage: Literal["Input", "None", "Guess", "Auto"] = MultipleChoiceKey(name='BondsUsage', comment='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.', default='Auto', choices=['Input', 'None', 'Guess', 'Auto'])
self.CheckDuplicateRules: BoolType | BoolKey = BoolKey(name='CheckDuplicateRules', comment='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.', default=True)
self.DipoleConvergenceThreshold: float | FloatKey = FloatKey(name='DipoleConvergenceThreshold', comment='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.', default=1e-06, unit='eBohr')
self.DoChargeCheck: BoolType | BoolKey = BoolKey(name='DoChargeCheck', comment='Check that the sum of atomic (partial) charges equals the total charge of the system.', default=False)
self.EngineConstraints: BoolType | BoolKey = BoolKey(name='EngineConstraints', comment='Set to false to ignore constraints implied by the engine.', default=True)
self.ForceFieldFile: str | Path | StringKey = PathStringKey(name='ForceFieldFile', comment='Path to the force field parameter file', gui_name='Force field library:', default='', ispath=True)
self.ForceFieldPatchFile: str | Path | StringKey = PathStringKey(name='ForceFieldPatchFile', comment='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.', hidden=True, ispath=True)
self.GuessCharges: BoolType | BoolKey = BoolKey(name='GuessCharges', comment='Use another engine to calculate/guess the charges to be used by the force field.', default=False)
self.KeepAntechamberFolder: BoolType | BoolKey = BoolKey(name='KeepAntechamberFolder', comment='If atom-typing is performed with antechamber, keep the folder after the call to antechamber', default=False)
self.LinearizationEnergyForRepulsion: float | FloatKey = FloatKey(name='LinearizationEnergyForRepulsion', comment='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.', default=3.0, unit='Hartree')
self.NeighborListSkin: float | FloatKey = FloatKey(name='NeighborListSkin', comment='Thickness of the buffer region added to the NonBondedCutoff when building a neighbor list.', default=2.5, unit='Angstrom')
self.NonBondedCutoff: float | FloatKey = FloatKey(name='NonBondedCutoff', comment='Distance beyond which the non-bonded pair interactions (Coulomb and Van der Waals) will be ignored.\n\n The interactions are smoothly damped starting from 0.9*NonBondedCutoff. \n\n Has no effect on the Coulomb term for 3D-periodic systems, as Ewald summation is used.', default=15.0, unit='Angstrom')
self.PairInteractionTapering: Literal["None", "Potential", "Force", "CHARMM", "CHARMM-Force"] = MultipleChoiceKey(name='PairInteractionTapering', comment='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.\n\nPotential - 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).\nForce - 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.\nCHARMM - use a different polynomial that does not have a decaying 2nd derivative at NonBondedCutoff.\nCHARMM-Force - use the same switching function as CHARMM but apply it both to the energy and the forces.', default='Potential', choices=['None', 'Potential', 'Force', 'CHARMM', 'CHARMM-Force'])
self.TaperPairInteractions: BoolType | BoolKey = BoolKey(name='TaperPairInteractions', comment='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.', default=True)
self.Type: Literal["UFF", "Amber95", "GAFF", "Tripos5.2", "APPLE&P", "UserDefined"] = MultipleChoiceKey(name='Type', comment='Type of force field to be used', default='UFF', choices=['UFF', 'Amber95', 'GAFF', 'Tripos5.2', 'APPLE&P', 'UserDefined'])
self.Verbosity: Literal["Silent", "Normal", "Verbose", "VeryVerbose"] = MultipleChoiceKey(name='Verbosity', comment='Controls the verbosity of the engine.', default='Silent', choices=['Silent', 'Normal', 'Verbose', 'VeryVerbose'])
self.APPLE_AND_P: ForceField._APPLE&P = self._APPLE_AND_P(name='APPLE&P', comment='Options for the APPLE&P force field.')
self.EnergyTerms: ForceField._EnergyTerms = self._EnergyTerms(name='EnergyTerms', comment='expert key, that allows you to disable specific energy terms.')
self.EwaldSummation: ForceField._EwaldSummation = self._EwaldSummation(name='EwaldSummation', comment='Configures the details of the particle mesh Ewald (PME) summation of the Coulomb interaction.')
self.GAFF: ForceField._GAFF = self._GAFF(name='GAFF', comment='Specific keywords for the GAFF force field type')
self.GuessChargesConfig: ForceField._GuessChargesConfig = self._GuessChargesConfig(name='GuessChargesConfig', comment='Guess charges to be used by the forcefield')
self.LAMMPSOffload: ForceField._LAMMPSOffload = self._LAMMPSOffload(name='LAMMPSOffload', comment='Offload the calculation to LAMMPS via AMSPipe.')
self.LoadCharges: ForceField._LoadCharges = self._LoadCharges(name='LoadCharges', comment='Load charges from a file to be used as forcefield charges')
self.SoftCorePotentials: ForceField._SoftCorePotentials = self._SoftCorePotentials(name='SoftCorePotentials', comment='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).')
self.UFF: ForceField._UFF = self._UFF(name='UFF', comment='Option for the UFF force filed.')
