class ConcatenateTrajectories(Protocol):
"""A protocol which concatenates multiple trajectories into
a single one.
"""
input_coordinate_paths = InputAttribute(
docstring=
"A list of paths to the starting PDB coordinates for each of the trajectories.",
type_hint=list,
default_value=UNDEFINED,
)
input_trajectory_paths = InputAttribute(
docstring="A list of paths to the trajectories to concatenate.",
type_hint=list,
default_value=UNDEFINED,
)
output_coordinate_path = OutputAttribute(
docstring="The path the PDB coordinate file which contains the topology "
"of the concatenated trajectory.",
type_hint=str,
)
output_trajectory_path = OutputAttribute(
docstring="The path to the concatenated trajectory.", type_hint=str)
def _execute(self, directory, available_resources):
import mdtraj
if len(self.input_coordinate_paths) != len(
self.input_trajectory_paths):
raise ValueError(
"There should be the same number of coordinate and trajectory paths."
)
if len(self.input_trajectory_paths) == 0:
raise ValueError("No trajectories were given to concatenate.")
trajectories = []
output_coordinate_path = None
for coordinate_path, trajectory_path in zip(
self.input_coordinate_paths, self.input_trajectory_paths):
output_coordinate_path = output_coordinate_path or coordinate_path
trajectories.append(
mdtraj.load_dcd(trajectory_path, coordinate_path))
self.output_coordinate_path = output_coordinate_path
output_trajectory = (trajectories[0] if len(trajectories) == 1 else
mdtraj.join(trajectories, False, False))
self.output_trajectory_path = path.join(directory,
"output_trajectory.dcd")
output_trajectory.save_dcd(self.output_trajectory_path)
class AveragePropertyProtocol(Protocol, abc.ABC):
"""An abstract base class for protocols which will calculate the
average of a property and its uncertainty via bootstrapping.
"""
bootstrap_iterations = InputAttribute(
docstring="The number of bootstrap iterations to perform.",
type_hint=int,
default_value=250,
merge_behavior=InequalityMergeBehaviour.LargestValue,
)
bootstrap_sample_size = InputAttribute(
docstring="The relative sample size to use for bootstrapping.",
type_hint=float,
default_value=1.0,
merge_behavior=InequalityMergeBehaviour.LargestValue,
)
equilibration_index = OutputAttribute(
docstring=
"The index in the data set after which the data is stationary.",
type_hint=int,
)
statistical_inefficiency = OutputAttribute(
docstring="The statistical inefficiency in the data set.",
type_hint=float)
value = OutputAttribute(docstring="The average value and its uncertainty.",
type_hint=pint.Measurement)
uncorrelated_values = OutputAttribute(
docstring=
"The uncorrelated values which the average was calculated from.",
type_hint=pint.Quantity,
)
def _bootstrap_function(self, **sample_kwargs):
"""The function to perform on the data set being sampled by
bootstrapping.
Parameters
----------
sample_kwargs: dict of str and np.ndarray
A key words dictionary of the bootstrap sample data, where the
sample data is a numpy array of shape=(num_frames, num_dimensions)
with dtype=float.
Returns
-------
float
The result of evaluating the data.
"""
assert len(sample_kwargs) == 1
sample_data = next(iter(sample_kwargs.values()))
return sample_data.mean()
class DummyReplicableProtocol(Protocol):
replicated_value_a = InputAttribute(docstring="",
type_hint=Union[str, int, float],
default_value=UNDEFINED)
replicated_value_b = InputAttribute(docstring="",
type_hint=Union[str, int, float],
default_value=UNDEFINED)
final_value = OutputAttribute(docstring="", type_hint=pint.Measurement)
def _execute(self, directory, available_resources):
pass
class AverageTrajectoryProperty(AveragePropertyProtocol, abc.ABC):
"""An abstract base class for protocols which will calculate the
average of a property from a simulation trajectory.
"""
input_coordinate_file = InputAttribute(
docstring="The file path to the starting coordinates of a trajectory.",
type_hint=str,
default_value=UNDEFINED,
)
trajectory_path = InputAttribute(
docstring="The file path to the trajectory to average over.",
type_hint=str,
default_value=UNDEFINED,
)
class ExtractUncorrelatedStatisticsData(ExtractUncorrelatedData):
"""A protocol which will subsample entries from a statistics array, yielding only uncorrelated
entries as determined from a provided statistical inefficiency and equilibration time.
"""
input_statistics_path = InputAttribute(
docstring="The file path to the statistics to subsample.",
type_hint=str,
default_value=UNDEFINED,
)
output_statistics_path = OutputAttribute(
docstring="The file path to the subsampled statistics.", type_hint=str)
def _execute(self, directory, available_resources):
statistics_array = StatisticsArray.from_pandas_csv(
self.input_statistics_path)
uncorrelated_indices = timeseries.get_uncorrelated_indices(
len(statistics_array) - self.equilibration_index,
self.statistical_inefficiency,
)
uncorrelated_indices = [
index + self.equilibration_index for index in uncorrelated_indices
]
uncorrelated_statistics = StatisticsArray.from_existing(
statistics_array, uncorrelated_indices)
self.output_statistics_path = path.join(directory,
"uncorrelated_statistics.csv")
uncorrelated_statistics.to_pandas_csv(self.output_statistics_path)
self.number_of_uncorrelated_samples = len(uncorrelated_statistics)
class ConcatenateStatistics(Protocol):
"""A protocol which concatenates multiple trajectories into
a single one.
"""
input_statistics_paths = InputAttribute(
docstring="A list of paths to statistics arrays to concatenate.",
type_hint=list,
default_value=UNDEFINED,
)
output_statistics_path = OutputAttribute(
docstring=
"The path the csv file which contains the concatenated statistics.",
type_hint=str,
)
def _execute(self, directory, available_resources):
if len(self.input_statistics_paths) == 0:
raise ValueError("No statistics arrays were given to concatenate.")
arrays = [
StatisticsArray.from_pandas_csv(file_path)
for file_path in self.input_statistics_paths
]
if len(arrays) > 1:
output_array = StatisticsArray.join(*arrays)
else:
output_array = arrays[0]
self.output_statistics_path = path.join(directory,
"output_statistics.csv")
output_array.to_pandas_csv(self.output_statistics_path)
class ExtractUncorrelatedData(Protocol, abc.ABC):
"""An abstract base class for protocols which will subsample
a data set, yielding only equilibrated, uncorrelated data.
"""
equilibration_index = InputAttribute(
docstring=
"The index in the data set after which the data is stationary.",
type_hint=int,
default_value=UNDEFINED,
merge_behavior=InequalityMergeBehaviour.LargestValue,
)
statistical_inefficiency = InputAttribute(
docstring="The statistical inefficiency in the data set.",
type_hint=float,
default_value=UNDEFINED,
merge_behavior=InequalityMergeBehaviour.LargestValue,
)
number_of_uncorrelated_samples = OutputAttribute(
docstring="The number of uncorrelated samples.", type_hint=int)
class BaseEnergyMinimisation(Protocol, abc.ABC):
"""A base class for protocols which will minimise the potential
energy of a given system.
"""
input_coordinate_file = InputAttribute(
docstring="The coordinates to minimise.",
type_hint=str,
default_value=UNDEFINED)
system_path = InputAttribute(
docstring=
"The path to the XML system object which defines the forces present "
"in the system.",
type_hint=str,
default_value=UNDEFINED,
)
tolerance = InputAttribute(
docstring=
"The energy tolerance to which the system should be minimized.",
type_hint=pint.Quantity,
default_value=10 * unit.kilojoules / unit.mole,
)
max_iterations = InputAttribute(
docstring="The maximum number of iterations to perform. If this is 0, "
"minimization is continued until the results converge without regard to "
"how many iterations it takes.",
type_hint=int,
default_value=0,
)
enable_pbc = InputAttribute(
docstring="If true, periodic boundary conditions will be enabled.",
type_hint=bool,
default_value=True,
)
output_coordinate_file = OutputAttribute(
docstring="The file path to the minimised coordinates.", type_hint=str)
class DivideValue(Protocol):
"""A protocol which divides a value by a specified scalar
"""
value = InputAttribute(
docstring="The value to divide.",
type_hint=typing.Union[int, float, pint.Quantity, pint.Measurement,
ParameterGradient],
default_value=UNDEFINED,
)
divisor = InputAttribute(
docstring="The scalar to divide by.",
type_hint=typing.Union[int, float, pint.Quantity],
default_value=UNDEFINED,
)
result = OutputAttribute(
docstring="The result of the division.",
type_hint=typing.Union[int, float, pint.Measurement, pint.Quantity,
ParameterGradient],
)
def _execute(self, directory, available_resources):
self.result = self.value / self.divisor
class DummyInputOutputProtocol(Protocol):
input_value = InputAttribute(
docstring="A dummy input.",
type_hint=Union[str, int, float, pint.Quantity, pint.Measurement, list,
tuple, dict, set, frozenset, ],
default_value=UNDEFINED,
)
output_value = OutputAttribute(
docstring="A dummy output.",
type_hint=Union[str, int, float, pint.Quantity, pint.Measurement, list,
tuple, dict, set, frozenset, ],
)
def _execute(self, directory, available_resources):
self.output_value = self.input_value
class BaseGradientPotentials(Protocol, abc.ABC):
"""A base class for protocols which will evaluate the reduced potentials of a
series of configurations using a set of force field parameters which have been
slightly increased and slightly decreased. These are mainly useful when
estimating gradients with respect to force field parameters using the central
difference method.
"""
force_field_path = InputAttribute(
docstring="The path to the force field which contains the parameters to "
"differentiate the observable with respect to. When reweighting "
"observables, this should be the `target` force field.",
type_hint=str,
default_value=UNDEFINED,
)
statistics_path = InputAttribute(
docstring="The path to a statistics array containing potentials "
"evaluated at each frame of the trajectory using the input "
"`force_field_path` and at the input `thermodynamic_state`.",
type_hint=str,
default_value=UNDEFINED,
)
thermodynamic_state = InputAttribute(
docstring="The thermodynamic state to estimate the gradients at. When "
"reweighting observables, this should be the `target` state.",
type_hint=ThermodynamicState,
default_value=UNDEFINED,
)
substance = InputAttribute(
docstring="The substance which describes the composition of the system.",
type_hint=Substance,
default_value=UNDEFINED,
)
coordinate_file_path = InputAttribute(
docstring="A path to a PDB coordinate file which describes the topology of "
"the system.",
type_hint=str,
default_value=UNDEFINED,
)
trajectory_file_path = InputAttribute(
docstring="A path to the trajectory of configurations",
type_hint=str,
default_value=UNDEFINED,
)
enable_pbc = InputAttribute(
docstring="If true, periodic boundary conditions will be enabled when "
"re-evaluating the reduced potentials.",
type_hint=bool,
default_value=True,
)
parameter_key = InputAttribute(
docstring="The key of the parameter to differentiate with respect to.",
type_hint=ParameterGradientKey,
default_value=UNDEFINED,
)
perturbation_scale = InputAttribute(
docstring="The amount to perturb the parameter by, such that "
"p_new = p_old * (1 +/- `perturbation_scale`)",
type_hint=float,
default_value=1.0e-4,
)
use_subset_of_force_field = InputAttribute(
docstring="If true, the reduced potentials will be estimated using "
"a system which only contains the parameters of interest, e.g. if the "
"gradient of interest is with respect to the VdW epsilon parameter, then "
"all valence / electrostatic terms will be ignored.",
type_hint=bool,
default_value=True,
)
effective_sample_indices = InputAttribute(
docstring="This a placeholder input which is not currently implemented.",
type_hint=list,
default_value=UNDEFINED,
optional=True,
)
reverse_potentials_path = OutputAttribute(
docstring="A file path to the energies evaluated using the parameters"
"perturbed in the reverse direction.",
type_hint=str,
)
forward_potentials_path = OutputAttribute(
docstring="A file path to the energies evaluated using the parameters"
"perturbed in the forward direction.",
type_hint=str,
)
reverse_parameter_value = OutputAttribute(
docstring="The value of the parameter perturbed in the reverse direction.",
type_hint=pint.Quantity,
)
forward_parameter_value = OutputAttribute(
docstring="The value of the parameter perturbed in the forward direction.",
type_hint=pint.Quantity,
)
class CentralDifferenceGradient(Protocol):
"""A protocol which employs the central diference method
to estimate the gradient of an observable A, such that
grad = (A(x-h) - A(x+h)) / (2h)
Notes
-----
The `values` input must either be a list of pint.Quantity, a ProtocolPath to a list
of pint.Quantity, or a list of ProtocolPath which each point to a pint.Quantity.
"""
parameter_key = InputAttribute(
docstring="The key of the parameter to differentiate with respect to.",
type_hint=ParameterGradientKey,
default_value=UNDEFINED,
)
reverse_observable_value = InputAttribute(
docstring="The value of the observable evaluated using the parameters"
"perturbed in the reverse direction.",
type_hint=typing.Union[pint.Quantity, pint.Measurement],
default_value=UNDEFINED,
)
forward_observable_value = InputAttribute(
docstring="The value of the observable evaluated using the parameters"
"perturbed in the forward direction.",
type_hint=typing.Union[pint.Quantity, pint.Measurement],
default_value=UNDEFINED,
)
reverse_parameter_value = InputAttribute(
docstring="The value of the parameter perturbed in the reverse direction.",
type_hint=pint.Quantity,
default_value=UNDEFINED,
)
forward_parameter_value = InputAttribute(
docstring="The value of the parameter perturbed in the forward direction.",
type_hint=pint.Quantity,
default_value=UNDEFINED,
)
gradient = OutputAttribute(
docstring="The estimated gradient", type_hint=ParameterGradient
)
def _execute(self, directory, available_resources):
if self.forward_parameter_value < self.reverse_parameter_value:
raise ValueError(
f"The forward parameter value ({self.forward_parameter_value}) must "
f"be larger than the reverse value ({self.reverse_parameter_value})."
)
reverse_value = self.reverse_observable_value
forward_value = self.forward_observable_value
if isinstance(reverse_value, pint.Measurement):
reverse_value = reverse_value.value
if isinstance(forward_value, pint.Measurement):
forward_value = forward_value.value
gradient = (forward_value - reverse_value) / (
self.forward_parameter_value - self.reverse_parameter_value
)
self.gradient = ParameterGradient(self.parameter_key, gradient)
class ExtractAverageDielectric(analysis.AverageTrajectoryProperty):
"""Extracts the average dielectric constant from a simulation trajectory.
"""
system_path = InputAttribute(
docstring="The path to the XML system object which defines the forces present in the system.",
type_hint=str,
default_value=UNDEFINED,
)
thermodynamic_state = InputAttribute(
docstring="The thermodynamic state at which the trajectory was generated.",
type_hint=ThermodynamicState,
default_value=UNDEFINED,
)
dipole_moments = OutputAttribute(
docstring="The raw (possibly correlated) dipole moments which were used in "
"the dielectric calculation.",
type_hint=pint.Quantity,
)
volumes = OutputAttribute(
docstring="The raw (possibly correlated) which were used in the dielectric calculation.",
type_hint=pint.Quantity,
)
uncorrelated_volumes = OutputAttribute(
docstring="The uncorrelated volumes which were used in the dielectric "
"calculation.",
type_hint=pint.Quantity,
)
def _bootstrap_function(self, **sample_kwargs):
"""Calculates the static dielectric constant from an
array of dipoles and volumes.
Notes
-----
The static dielectric constant is taken from for Equation 7 of [1]
References
----------
[1] A. Glattli, X. Daura and W. F. van Gunsteren. Derivation of an improved simple point charge
model for liquid water: SPC/A and SPC/L. J. Chem. Phys. 116(22):9811-9828, 2002
Parameters
----------
sample_kwargs: dict of str and np.ndarray
A key words dictionary of the bootstrap sample data, where the
sample data is a numpy array of shape=(num_frames, num_dimensions)
with dtype=float. The kwargs should include the dipole moment and
the system volume
Returns
-------
float
The unitless static dielectric constant
"""
dipole_moments = sample_kwargs["dipoles"]
volumes = sample_kwargs["volumes"]
temperature = self.thermodynamic_state.temperature
dipole_mu = dipole_moments.mean(0)
shifted_dipoles = dipole_moments - dipole_mu
dipole_variance = (shifted_dipoles * shifted_dipoles).sum(-1).mean(0) * (
unit.elementary_charge * unit.nanometers
) ** 2
volume = volumes.mean() * unit.nanometer ** 3
e0 = 8.854187817e-12 * unit.farad / unit.meter # Taken from QCElemental
dielectric_constant = 1.0 + dipole_variance / (
3 * unit.boltzmann_constant * temperature * volume * e0
)
return dielectric_constant
def _extract_charges(self):
"""Extracts all of the charges from a system object.
Returns
-------
list of float
"""
from simtk import unit as simtk_unit
charge_list = []
with open(self._system_path, "r") as file:
system = XmlSerializer.deserialize(file.read())
for force_index in range(system.getNumForces()):
force = system.getForce(force_index)
if not isinstance(force, openmm.NonbondedForce):
continue
for atom_index in range(force.getNumParticles()):
charge = force.getParticleParameters(atom_index)[0]
charge = charge.value_in_unit(simtk_unit.elementary_charge)
charge_list.append(charge)
return charge_list
def _extract_dipoles_and_volumes(self):
"""Extract the systems dipole moments and volumes.
Returns
-------
numpy.ndarray
The dipole moments of the trajectory (shape=(n_frames, 3), dtype=float)
numpy.ndarray
The volumes of the trajectory (shape=(n_frames, 1), dtype=float)
"""
import mdtraj
dipole_moments = []
volumes = []
charge_list = self._extract_charges()
for chunk in mdtraj.iterload(
self.trajectory_path, top=self.input_coordinate_file, chunk=50
):
dipole_moments.extend(mdtraj.geometry.dipole_moments(chunk, charge_list))
volumes.extend(chunk.unitcell_volumes)
dipole_moments = np.array(dipole_moments)
volumes = np.array(volumes)
return dipole_moments, volumes
def _execute(self, directory, available_resources):
super(ExtractAverageDielectric, self)._execute(directory, available_resources)
# Extract the dipoles
dipole_moments, volumes = self._extract_dipoles_and_volumes()
self.dipole_moments = dipole_moments * unit.dimensionless
(
dipole_moments,
self.equilibration_index,
self.statistical_inefficiency,
) = timeseries.decorrelate_time_series(dipole_moments)
uncorrelated_length = len(volumes) - self.equilibration_index
sample_indices = timeseries.get_uncorrelated_indices(
uncorrelated_length, self.statistical_inefficiency
)
sample_indices = [index + self.equilibration_index for index in sample_indices]
self.volumes = volumes * unit.nanometer ** 3
uncorrelated_volumes = volumes[sample_indices]
self.uncorrelated_values = dipole_moments * unit.dimensionless
self.uncorrelated_volumes = uncorrelated_volumes * unit.nanometer ** 3
value, uncertainty = bootstrap(
self._bootstrap_function,
self.bootstrap_iterations,
self.bootstrap_sample_size,
dipoles=dipole_moments,
volumes=uncorrelated_volumes,
)
self.value = (value * unit.dimensionless).plus_minus(
uncertainty * unit.dimensionless
)
class ReweightDielectricConstant(reweighting.BaseMBARProtocol):
"""Reweights a set of dipole moments (`reference_observables`) and volumes
(`reference_volumes`) using MBAR, and then combines these to yeild the reweighted
dielectric constant. Uncertainties in the dielectric constant are determined
by bootstrapping.
"""
reference_dipole_moments = InputAttribute(
docstring="A Quantity wrapped np.ndarray of the dipole moments of each "
"of the reference states.",
type_hint=list,
default_value=UNDEFINED,
)
reference_volumes = InputAttribute(
docstring="A Quantity wrapped np.ndarray of the volumes of each of the "
"reference states.",
type_hint=list,
default_value=UNDEFINED,
)
thermodynamic_state = InputAttribute(
docstring="The thermodynamic state at which the trajectory was generated.",
type_hint=ThermodynamicState,
default_value=UNDEFINED,
)
def __init__(self, protocol_id):
super().__init__(protocol_id)
self.bootstrap_uncertainties = True
def _bootstrap_function(
self,
reference_reduced_potentials,
target_reduced_potentials,
**reference_observables,
):
assert len(reference_observables) == 3
transposed_observables = {}
for key in reference_observables:
transposed_observables[key] = np.transpose(reference_observables[key])
values, _, _ = self._reweight_observables(
np.transpose(reference_reduced_potentials),
np.transpose(target_reduced_potentials),
**transposed_observables,
)
average_squared_dipole = values["dipoles_sqr"]
average_dipole_squared = np.linalg.norm(values["dipoles"])
dipole_variance = (average_squared_dipole - average_dipole_squared) * (
unit.elementary_charge * unit.nanometers
) ** 2
volume = values["volumes"] * unit.nanometer ** 3
e0 = 8.854187817e-12 * unit.farad / unit.meter # Taken from QCElemental
dielectric_constant = 1.0 + dipole_variance / (
3
* unit.boltzmann_constant
* self.thermodynamic_state.temperature
* volume
* e0
)
return dielectric_constant
def _execute(self, directory, available_resources):
if len(self.reference_dipole_moments) == 0:
raise ValueError("There were no dipole moments to reweight.")
if len(self.reference_volumes) == 0:
raise ValueError("There were no volumes to reweight.")
if not isinstance(
self.reference_dipole_moments[0], pint.Quantity
) or not isinstance(self.reference_volumes[0], pint.Quantity):
raise ValueError(
"The reference observables should be a list of "
"pint.Quantity wrapped ndarray's.",
)
if len(self.reference_dipole_moments) != len(self.reference_volumes):
raise ValueError(
"The number of reference dipoles does not match the "
"number of reference volumes.",
)
for reference_dipoles, reference_volumes in zip(
self.reference_dipole_moments, self.reference_volumes
):
if len(reference_dipoles) == len(reference_volumes):
continue
raise ValueError(
"The number of reference dipoles does not match the "
"number of reference volumes.",
)
self._reference_observables = self.reference_dipole_moments
dipole_moments = self._prepare_observables_array(self.reference_dipole_moments)
dipole_moments_sqr = np.array(
[[np.dot(dipole, dipole) for dipole in np.transpose(dipole_moments)]]
)
volumes = self._prepare_observables_array(self.reference_volumes)
if self.bootstrap_uncertainties:
self._execute_with_bootstrapping(
unit.dimensionless,
dipoles=dipole_moments,
dipoles_sqr=dipole_moments_sqr,
volumes=volumes,
)
else:
raise ValueError(
"Dielectric constant can only be reweighted in conjunction "
"with bootstrapped uncertainties.",
)
class BaseSimulation(Protocol, abc.ABC):
"""A base class for protocols which will perform a molecular
simulation in a given ensemble and at a specified state.
"""
steps_per_iteration = InputAttribute(
docstring="The number of steps to propogate the system by at "
"each iteration. The total number of steps performed "
"by this protocol will be `total_number_of_iterations * "
"steps_per_iteration`.",
type_hint=int,
merge_behavior=InequalityMergeBehaviour.LargestValue,
default_value=1000000,
)
total_number_of_iterations = InputAttribute(
docstring="The number of times to propogate the system forward by the "
"`steps_per_iteration` number of steps. The total number of "
"steps performed by this protocol will be `total_number_of_iterations * "
"steps_per_iteration`.",
type_hint=int,
merge_behavior=InequalityMergeBehaviour.LargestValue,
default_value=1,
)
output_frequency = InputAttribute(
docstring=
"The frequency (in number of steps) with which to write to the "
"output statistics and trajectory files.",
type_hint=int,
merge_behavior=InequalityMergeBehaviour.SmallestValue,
default_value=3000,
)
checkpoint_frequency = InputAttribute(
docstring=
"The frequency (in multiples of `output_frequency`) with which to "
"write to a checkpoint file, e.g. if `output_frequency=100` and "
"`checkpoint_frequency==2`, a checkpoint file would be saved every "
"200 steps.",
type_hint=int,
merge_behavior=InequalityMergeBehaviour.SmallestValue,
optional=True,
default_value=10,
)
timestep = InputAttribute(
docstring="The timestep to evolve the system by at each step.",
type_hint=pint.Quantity,
merge_behavior=InequalityMergeBehaviour.SmallestValue,
default_value=2.0 * unit.femtosecond,
)
thermodynamic_state = InputAttribute(
docstring="The thermodynamic conditions to simulate under",
type_hint=ThermodynamicState,
default_value=UNDEFINED,
)
ensemble = InputAttribute(
docstring="The thermodynamic ensemble to simulate in.",
type_hint=Ensemble,
default_value=Ensemble.NPT,
)
thermostat_friction = InputAttribute(
docstring="The thermostat friction coefficient.",
type_hint=pint.Quantity,
merge_behavior=InequalityMergeBehaviour.SmallestValue,
default_value=1.0 / unit.picoseconds,
)
input_coordinate_file = InputAttribute(
docstring="The file path to the starting coordinates.",
type_hint=str,
default_value=UNDEFINED,
)
system_path = InputAttribute(
docstring=
"A path to the XML system object which defines the forces present "
"in the system.",
type_hint=str,
default_value=UNDEFINED,
)
enable_pbc = InputAttribute(
docstring="If true, periodic boundary conditions will be enabled.",
type_hint=bool,
default_value=True,
)
allow_gpu_platforms = InputAttribute(
docstring=
"If true, the simulation will be performed using a GPU if available, "
"otherwise it will be constrained to only using CPUs.",
type_hint=bool,
default_value=True,
)
high_precision = InputAttribute(
docstring="If true, the simulation will be run using double precision.",
type_hint=bool,
default_value=False,
)
output_coordinate_file = OutputAttribute(
docstring=
"The file path to the coordinates of the final system configuration.",
type_hint=str,
)
trajectory_file_path = OutputAttribute(
docstring=
"The file path to the trajectory sampled during the simulation.",
type_hint=str,
)
statistics_file_path = OutputAttribute(
docstring=
"The file path to the statistics sampled during the simulation.",
type_hint=str,
)
