def setUp(self):
prmtop = app.AmberPrmtopFile('systems/water-box-216.prmtop')
system = prmtop.createSystem(nonbondedMethod=app.PME,
nonbondedCutoff=0.9 * unit.nanometers,
constraints=app.HBonds,
rigidWater=True,
ewaldErrorTolerance=0.0005)
integrator = mm.LangevinIntegrator(300 * unit.kelvin,
1.0 / unit.picoseconds,
2.0 * unit.femtoseconds)
self.simulation = app.Simulation(
prmtop.topology, system, integrator,
mm.Platform.getPlatformByName('Reference'))
def _configure_amber_implicit(
pdb_file: PathLike,
top_file: Optional[PathLike],
dt_ps: float,
temperature_kelvin: float,
heat_bath_friction_coef: float,
platform: "openmm.Platform",
platform_properties: dict,
) -> Tuple["app.Simulation", Optional["app.PDBFile"]]:
# Configure system
if top_file is not None:
pdb = None
top = app.AmberPrmtopFile(str(top_file))
system = top.createSystem(
nonbondedMethod=app.CutoffNonPeriodic,
nonbondedCutoff=1.0 * u.nanometer,
constraints=app.HBonds,
implicitSolvent=app.OBC1,
)
else:
pdb = app.PDBFile(str(pdb_file))
top = pdb.topology
forcefield = app.ForceField("amber99sbildn.xml", "amber99_obc.xml")
system = forcefield.createSystem(
top,
nonbondedMethod=app.CutoffNonPeriodic,
nonbondedCutoff=1.0 * u.nanometer,
constraints=app.HBonds,
)
# Configure integrator
integrator = openmm.LangevinIntegrator(
temperature_kelvin * u.kelvin,
heat_bath_friction_coef / u.picosecond,
dt_ps * u.picosecond,
)
integrator.setConstraintTolerance(0.00001)
sim = app.Simulation(top, system, integrator, platform,
platform_properties)
# Returning the pdb file object for later use to reduce I/O.
# If a topology file is passed, the pdb variable is None.
return sim, pdb
def _configure_amber_explicit(
top_file: PathLike,
dt_ps: float,
temperature_kelvin: float,
heat_bath_friction_coef: float,
platform: "openmm.Platform",
platform_properties: dict,
explicit_barostat: str,
) -> "app.Simulation":
top = app.AmberPrmtopFile(str(top_file))
system = top.createSystem(
nonbondedMethod=app.PME,
nonbondedCutoff=1.0 * u.nanometer,
constraints=app.HBonds,
)
# Congfigure integrator
integrator = openmm.LangevinIntegrator(
temperature_kelvin * u.kelvin,
heat_bath_friction_coef / u.picosecond,
dt_ps * u.picosecond,
)
if explicit_barostat == "MonteCarloBarostat":
system.addForce(
openmm.MonteCarloBarostat(1 * u.bar,
temperature_kelvin * u.kelvin))
elif explicit_barostat == "MonteCarloAnisotropicBarostat":
system.addForce(
openmm.MonteCarloAnisotropicBarostat(
(1, 1, 1) * u.bar, temperature_kelvin * u.kelvin, False, False,
True))
else:
raise ValueError(
f"Invalid explicit_barostat option: {explicit_barostat}")
sim = app.Simulation(top.topology, system, integrator, platform,
platform_properties)
return sim
extra_bonds = pd.DataFrame(extra_bonds, columns=s.bonds.columns,
index=range(s.bonds.index.max() + 1, s.bonds.index.max() + 1 + len(extra_bonds)))
s.bonds = s.bonds.append(extra_bonds)
# Check that the bonds correspond with the correct molecule
s.bonds = s.bonds[(s.bonds['molecule'] == s.atom_list['residue_name'].loc[s.bonds['i']].values) |
s.bonds['molecule'].isin(['Actin-ADP', 'ABP', 'CaMKII'])]
print(s.system.getDefaultPeriodicBoxVectors())
s.setForces(BundleConstraint=aligned, PlaneConstraint=system2D, CaMKII_Force=camkii_force)
top = openmm.app.PDBxFile(f'{Sname}.cif')
coord = openmm.app.PDBxFile(f'{Sname}.cif')
# Set up simulation
temperature = sjob["temperature"] * u.kelvin
integrator = openmm.LangevinIntegrator(temperature, .0001 / u.picosecond, 1 * u.picoseconds)
simulation = openmm.app.Simulation(top.topology, s.system, integrator, platform)
simulation.context.setPositions(coord.positions)
# Modify parameters
simulation.context.setParameter("g_eps", sjob["epsilon"])
frequency = sjob["frequency"]
# Add reporters
simulation.reporters.append(openmm.app.DCDReporter(f'{Sname}.dcd', frequency), )
simulation.reporters.append(
openmm.app.StateDataReporter(stdout, frequency, step=True, time=True, potentialEnergy=True, totalEnergy=True,
temperature=True,
separator='\t', ))
simulation.reporters.append(
openmm.app.StateDataReporter(f'{Sname}.log', frequency, step=True, time=True, totalEnergy=True,
def minimize_potential_energy(
chimera,
ff: str,
output: str = "/tmp/build",
keep_output_files=True,
cuda=False,
restraint_backbone: bool = True
) -> Tuple[unit.quantity.Quantity, Chimera]:
"""
:param chimera: A chimera object where to perform the minimization
:param forcefield: The forcefield to use for the minimization. Select between "amber" and "charmm"
:param output: A folder where to keep the files. If not provided they will be stored in the /tmp folder and later removed.
:param cuda: Whether to use GPU acceleration
:param restraint_backbone: Keep the backbone atoms constraint in space
:return: The chimera object that was minimized and the potential energy value.
"""
if not os.path.exists(output):
os.mkdir(output)
smol = prepare_protein(chimera)
smol.write(f"{output}/protein.pdb")
pdb = PDBFile(f"{output}/protein.pdb")
parm = load_file(f"{output}/protein.pdb")
modeller = Modeller(pdb.topology, pdb.positions)
if ff == 'amber':
forcefield = ForceField('amber14-all.xml', 'amber14/tip3pfb.xml')
if ff == 'charmm':
forcefield = ForceField('charmm36.xml', 'charmm36/tip3p-pme-b.xml')
modeller.addSolvent(forcefield, padding=1.0 * unit.nanometer)
system = forcefield.createSystem(modeller.topology,
nonbondedMethod=PME,
nonbondedCutoff=1 * unit.nanometer,
constraints=HBonds)
if restraint_backbone:
# Applies an external force on backbone atoms
# This allows the backbone to stay rigid, while severe clashes can still be resolved
force = mm.CustomExternalForce("k*((x-x0)^2+(y-y0)^2+(z-z0)^2)")
force.addGlobalParameter(
"k", 5.0 * unit.kilocalories_per_mole / unit.angstroms**2)
force.addPerParticleParameter("x0")
force.addPerParticleParameter("y0")
force.addPerParticleParameter("z0")
for idx, atom_crd in enumerate(parm.positions):
if idx >= len(parm.atoms): continue
if parm.atoms[idx] in ('CA', 'C', 'N'):
force.addParticle(idx, atom_crd.value_in_unit(unit.nanometers))
system.addForce(force)
integrator = mm.LangevinIntegrator(temperature, friction, error_tolerance)
simulation = Simulation(modeller.topology, system, integrator)
simulation.context.setPositions(modeller.positions)
# Get pre-minimization energy (scoring)
state = simulation.context.getState(getEnergy=True, getForces=True)
pre_energy = state.getPotentialEnergy().in_units_of(
unit.kilocalories_per_mole)
logger.info(f"Energy before minimization {pre_energy}")
# Setup CPU minimization
integrator.setConstraintTolerance(distance_tolerance)
simulation.minimizeEnergy()
post_position = simulation.context.getState(
getPositions=True).getPositions()
post_state = simulation.context.getState(getEnergy=True, getForces=True)
if cuda:
min_coords = simulation.context.getState(getPositions=True)
platform = mm.Platform.getPlatformByName('CUDA')
properties = {'CudaPrecision': 'mixed'}
gpu_integrator = mm.VariableLangevinIntegrator(temperature, friction,
error_tolerance)
gpu_integrator.setConstraintTolerance(distance_tolerance)
gpu_min = Simulation(modeller.topology, system, gpu_integrator,
platform, properties)
gpu_min.context.setPositions(min_coords.getPositions())
gpu_min.minimizeEnergy()
post_position = gpu_min.context.getState(
getPositions=True).getPositions()
post_state = gpu_min.context.getState(getEnergy=True, getForces=True)
post_energy = post_state.getPotentialEnergy().in_units_of(
unit.kilocalories_per_mole)
logger.info(f"Energy after minimization {post_energy}")
PDBFile.writeFile(modeller.topology,
post_position,
open(f"{output}/structure_minimized.pdb", 'w'),
keepIds=True)
min_mol = Chimera(filename=f"{output}/structure_minimized.pdb")
if keep_output_files is False:
shutil.rmtree(output)
return post_energy, min_mol
for v in val:
anames = '-'.join([pdbatoms[i].name for i in v[0]])
anums = '-'.join([str(i) for i in v[0]])
print("%20s %20s %5s %-s" % (anames, anums, v[1], v[2]))
# The rest of this is not needed.
sys.exit()
# Create the OpenMM system
system = forcefield.createSystem(pdb.topology, [mol],
nonbondedMethod=PME,
nonbondedCutoff=1.0 * unit.nanometers,
rigidWater=True)
# Set up an OpenMM simulation
integrator = openmm.LangevinIntegrator(temperature, friction, time_step)
platform = openmm.Platform.getPlatformByName('CUDA')
simulation = Simulation(pdb.topology, system, integrator)
simulation.context.setPositions(pdb.positions)
simulation.context.setVelocitiesToTemperature(temperature)
netcdf_reporter = NetCDFReporter('water_traj.nc', trj_freq)
simulation.reporters.append(netcdf_reporter)
simulation.reporters.append(
StateDataReporter('water_data.csv',
data_freq,
step=True,
potentialEnergy=True,
temperature=True,
density=True))
print(simulation.context.getState(getEnergy=True).getPotentialEnergy())
print('Loading Gromacs files...')
top = load_file('dhfr_gas.top', xyz='dhfr_gas.gro')
# Create the OpenMM system
print('Creating OpenMM System')
system = top.createSystem(
nonbondedMethod=app.NoCutoff,
constraints=app.HBonds,
implicitSolvent=app.GBn2,
implicitSolventSaltConc=0.1 * u.moles / u.liter,
)
# Create the integrator to do Langevin dynamics
integrator = mm.LangevinIntegrator(
300 * u.kelvin, # Temperature of heat bath
1.0 / u.picoseconds, # Friction coefficient
2.0 * u.femtoseconds, # Time step
)
# Define the platform to use; CUDA, OpenCL, CPU, or Reference. Or do not specify
# the platform to use the default (fastest) platform
platform = mm.Platform.getPlatformByName('CUDA')
prop = dict(CudaPrecision='mixed') # Use mixed single/double precision
# Create the Simulation object
sim = app.Simulation(top.topology, system, integrator, platform, prop)
# Set the particle positions
sim.context.setPositions(top.positions)
# Minimize the energy
def runOneTest(testName, options):
"""Perform a single benchmarking simulation."""
explicit = (testName not in ('gbsa', 'amoebagk'))
amoeba = (testName in ('amoebagk', 'amoebapme'))
apoa1 = testName.startswith('apoa1')
amber = (testName.startswith('amber'))
hydrogenMass = None
print()
if amoeba:
print('Test: %s (epsilon=%g)' % (testName, options.epsilon))
elif testName == 'pme':
print('Test: pme (cutoff=%g)' % options.cutoff)
else:
print('Test: %s' % testName)
print('Ensemble: %s' % options.ensemble)
platform = mm.Platform.getPlatformByName(options.platform)
# Create the System.
temperature = 300 * unit.kelvin
if explicit:
friction = 1 * (1 / unit.picoseconds)
else:
friction = 91 * (1 / unit.picoseconds)
if amoeba:
constraints = None
epsilon = float(options.epsilon)
if explicit:
ff = app.ForceField('amoeba2009.xml')
pdb = app.PDBFile('5dfr_solv-cube_equil.pdb')
cutoff = 0.7 * unit.nanometers
vdwCutoff = 0.9 * unit.nanometers
system = ff.createSystem(pdb.topology,
nonbondedMethod=app.PME,
nonbondedCutoff=cutoff,
vdwCutoff=vdwCutoff,
constraints=constraints,
ewaldErrorTolerance=0.00075,
mutualInducedTargetEpsilon=epsilon,
polarization=options.polarization)
else:
ff = app.ForceField('amoeba2009.xml', 'amoeba2009_gk.xml')
pdb = app.PDBFile('5dfr_minimized.pdb')
cutoff = 2.0 * unit.nanometers
vdwCutoff = 1.2 * unit.nanometers
system = ff.createSystem(pdb.topology,
nonbondedMethod=app.NoCutoff,
constraints=constraints,
mutualInducedTargetEpsilon=epsilon,
polarization=options.polarization)
for f in system.getForces():
if isinstance(f, mm.AmoebaMultipoleForce) or isinstance(
f, mm.AmoebaVdwForce) or isinstance(
f, mm.AmoebaGeneralizedKirkwoodForce) or isinstance(
f, mm.AmoebaWcaDispersionForce):
f.setForceGroup(1)
dt = 0.002 * unit.picoseconds
if options.ensemble == 'NVE':
integ = mm.MTSIntegrator(dt, [(0, 2), (1, 1)])
else:
integ = mm.MTSLangevinIntegrator(temperature, friction, dt,
[(0, 2), (1, 1)])
positions = pdb.positions
elif amber:
dirname = downloadAmberSuite()
names = {
'amber20-dhfr': 'JAC',
'amber20-factorix': 'FactorIX',
'amber20-cellulose': 'Cellulose',
'amber20-stmv': 'STMV'
}
fileName = names[testName]
prmtop = app.AmberPrmtopFile(
os.path.join(dirname, f'PME/Topologies/{fileName}.prmtop'))
inpcrd = app.AmberInpcrdFile(
os.path.join(dirname, f'PME/Coordinates/{fileName}.inpcrd'))
topology = prmtop.topology
positions = inpcrd.positions
dt = 0.004 * unit.picoseconds
method = app.PME
cutoff = options.cutoff
constraints = app.HBonds
system = prmtop.createSystem(nonbondedMethod=method,
nonbondedCutoff=cutoff,
constraints=constraints)
if options.ensemble == 'NVE':
integ = mm.VerletIntegrator(dt)
else:
integ = mm.LangevinMiddleIntegrator(temperature, friction, dt)
else:
if apoa1:
ff = app.ForceField('amber14/protein.ff14SB.xml',
'amber14/lipid17.xml', 'amber14/tip3p.xml')
pdb = app.PDBFile('apoa1.pdb')
if testName == 'apoa1pme':
method = app.PME
cutoff = options.cutoff
elif testName == 'apoa1ljpme':
method = app.LJPME
cutoff = options.cutoff
else:
method = app.CutoffPeriodic
cutoff = 1 * unit.nanometers
hydrogenMass = 1.5 * unit.amu
elif explicit:
ff = app.ForceField('amber99sb.xml', 'tip3p.xml')
pdb = app.PDBFile('5dfr_solv-cube_equil.pdb')
if testName == 'pme':
method = app.PME
cutoff = options.cutoff
else:
method = app.CutoffPeriodic
cutoff = 1 * unit.nanometers
else:
ff = app.ForceField('amber99sb.xml', 'amber99_obc.xml')
pdb = app.PDBFile('5dfr_minimized.pdb')
method = app.CutoffNonPeriodic
cutoff = 2 * unit.nanometers
if options.heavy:
dt = 0.005 * unit.picoseconds
constraints = app.AllBonds
hydrogenMass = 4 * unit.amu
if options.ensemble == 'NVE':
integ = mm.VerletIntegrator(dt)
else:
integ = mm.LangevinIntegrator(temperature, friction, dt)
else:
dt = 0.004 * unit.picoseconds
constraints = app.HBonds
if options.ensemble == 'NVE':
integ = mm.VerletIntegrator(dt)
else:
integ = mm.LangevinMiddleIntegrator(temperature, friction, dt)
positions = pdb.positions
system = ff.createSystem(pdb.topology,
nonbondedMethod=method,
nonbondedCutoff=cutoff,
constraints=constraints,
hydrogenMass=hydrogenMass)
if options.ensemble == 'NPT':
system.addForce(mm.MonteCarloBarostat(1 * unit.bar, temperature, 100))
print('Step Size: %g fs' % dt.value_in_unit(unit.femtoseconds))
properties = {}
initialSteps = 5
if options.device is not None and platform.getName() in ('CUDA', 'OpenCL'):
properties['DeviceIndex'] = options.device
if ',' in options.device or ' ' in options.device:
initialSteps = 250
if options.precision is not None and platform.getName() in ('CUDA',
'OpenCL'):
properties['Precision'] = options.precision
# Run the simulation.
integ.setConstraintTolerance(1e-5)
if len(properties) > 0:
context = mm.Context(system, integ, platform, properties)
else:
context = mm.Context(system, integ, platform)
context.setPositions(positions)
if amber:
if inpcrd.boxVectors is not None:
context.setPeriodicBoxVectors(*inpcrd.boxVectors)
mm.LocalEnergyMinimizer.minimize(
context, 100 * unit.kilojoules_per_mole / unit.nanometer)
context.setVelocitiesToTemperature(temperature)
steps = 20
while True:
time = timeIntegration(context, steps, initialSteps)
if time >= 0.5 * options.seconds:
break
if time < 0.5:
steps = int(
steps * 1.0 / time
) # Integrate enough steps to get a reasonable estimate for how many we'll need.
else:
steps = int(steps * options.seconds / time)
print('Integrated %d steps in %g seconds' % (steps, time))
print('%g ns/day' %
(dt * steps * 86400 / time).value_in_unit(unit.nanoseconds))
box_geometry='truncated octahedral',
clearance='14.0 angstroms',
to_form='molsysmt.MolSys',
engine="OpenMM",
verbose=False)
_ = msm.convert(molsys, to_form='villin_hp35_solvated.msmpk')
# simulation
print('Trajectory files...')
modeller = msm.convert(molsys, to_form='openmm.Modeller')
forcefield = app.ForceField("amber14-all.xml", "amber14/tip3p.xml")
system = forcefield.createSystem(modeller.topology,
nonbondedMethod=app.PME,
nonbondedCutoff=1.2 * unit.nanometer,
constraints=app.HBonds)
integrator = mm.LangevinIntegrator(300 * unit.kelvin, 1.0 / unit.picosecond,
2.0 * unit.femtoseconds)
platform = mm.Platform.getPlatformByName('CUDA')
simulation = app.Simulation(modeller.topology, system, integrator, platform)
simulation.context.setPositions(modeller.positions)
simulation.minimizeEnergy()
simulation.context.setVelocitiesToTemperature(300 * unit.kelvin)
simulation.reporters.append(
app.StateDataReporter(stdout,
50000,
progress=True,
potentialEnergy=True,
temperature=True,
remainingTime=True,
totalSteps=1000000))
simulation.reporters.append(
app.DCDReporter('villin_hp35_solvated.dcd', 50000,
def openmm_energy(prm,
structure,
coords,
box=None,
cutoff=None,
switch_dist=None):
from openmm import unit
from openmm import app
import openmm
from parmed.amber import AmberParm
if box is not None and not np.all(box == 0):
if cutoff is None:
raise RuntimeError(
"You need to provide a cutoff when passing a box")
a = unit.Quantity(
(box[0] * unit.angstrom, 0 * unit.angstrom, 0 * unit.angstrom))
b = unit.Quantity(
(0 * unit.angstrom, box[1] * unit.angstrom, 0 * unit.angstrom))
c = unit.Quantity(
(0 * unit.angstrom, 0 * unit.angstrom, box[2] * unit.angstrom))
structure.box_vectors = (a, b, c)
if isinstance(structure, AmberParm):
system = structure.createSystem(
nonbondedMethod=app.CutoffPeriodic,
nonbondedCutoff=0 if cutoff is None else cutoff *
unit.angstrom,
switchDistance=0 if switch_dist is None else switch_dist *
unit.angstrom,
)
else:
system = structure.createSystem(
prm,
nonbondedMethod=app.CutoffPeriodic,
nonbondedCutoff=0 if cutoff is None else cutoff *
unit.angstrom,
switchDistance=0 if switch_dist is None else switch_dist *
unit.angstrom,
)
system.setDefaultPeriodicBoxVectors(a, b, c)
else:
if isinstance(structure, AmberParm):
system = structure.createSystem()
else:
system = structure.createSystem(prm)
disableDispersionCorrection(system)
integrator = openmm.LangevinIntegrator(300 * unit.kelvin,
1 / unit.picoseconds,
2 * unit.femtoseconds)
try:
platform = openmm.Platform.getPlatformByName("CUDA")
properties = {"CudaPrecision": "double"}
except Exception:
platform = openmm.Platform.getPlatformByName("CPU")
properties = {}
context = openmm.Context(system, integrator, platform, properties)
# Run OpenMM with given coordinates
context.setPositions(coords * unit.angstrom)
energies = parmed.openmm.energy_decomposition(structure, context)
state = context.getState(getForces=True)
forces = state.getForces(asNumpy=True).value_in_unit(
unit.kilocalories_per_mole / unit.angstrom)
if "angle" not in energies:
energies["angle"] = 0
if "dihedral" not in energies:
energies["dihedral"] = 0
if "improper" not in energies:
energies["improper"] = 0
return energies, forces
non_bonded_force.addParticle(charge_1, sigma_1, epsilon_1)
system.addParticle(mass_2)
non_bonded_force.addParticle(charge_2, sigma_2, epsilon_2)
system.setDefaultPeriodicBoxVectors([3.0, 0.0, 0.0] * unit.nanometers,
[0.0, 3.0, 0.0] * unit.nanometers,
[0.0, 0.0, 3.0] * unit.nanometers)
_ = system.addForce(non_bonded_force)
step_size = 2 * unit.femtoseconds
temperature = 300 * unit.kelvin
friction = 1.0 / unit.picosecond
integrator = mm.LangevinIntegrator(temperature, friction, step_size)
platform_name = 'CUDA'
platform = mm.Platform.getPlatformByName(platform_name)
context = mm.Context(system, integrator, platform)
initial_positions = np.zeros([2, 3], np.float32) * unit.angstroms
initial_velocities = np.zeros([2, 3],
np.float32) * unit.angstroms / unit.picoseconds
initial_positions[1, 0] = 1.0 * unit.nanometers
context.setPositions(initial_positions)
context.setVelocities(initial_velocities)
def add_integrators(sim_openmm, model, state_prefix=None):
"""
Assign the proper integrator to this OpenMM simulation.
"""
if model.openmm_settings.langevin_integrator is not None:
target_temperature = \
model.openmm_settings.langevin_integrator.target_temperature
friction_coefficient = \
model.openmm_settings.langevin_integrator.friction_coefficient
random_seed = \
model.openmm_settings.langevin_integrator.random_seed
timestep = \
model.openmm_settings.langevin_integrator.timestep
rigid_constraint_tolerance = \
model.openmm_settings.langevin_integrator\
.rigid_tolerance
sim_openmm.timestep = timestep
sim_openmm.umbrella_integrator = openmm.LangevinIntegrator(
target_temperature * unit.kelvin,
friction_coefficient / unit.picoseconds,
timestep * unit.picoseconds)
if random_seed is not None:
sim_openmm.umbrella_integrator.setRandomNumberSeed(random_seed)
#sim_openmm.rev_integrator = openmm.VerletIntegrator(
# timestep*unit.picoseconds)
sim_openmm.rev_integrator = seekr2plugin.ElberLangevinIntegrator(
target_temperature * unit.kelvin,
friction_coefficient / unit.picoseconds,
timestep * unit.picoseconds, sim_openmm.rev_output_filename)
if random_seed is not None:
sim_openmm.rev_integrator.setRandomNumberSeed(random_seed + 1)
sim_openmm.rev_integrator.setEndOnSrcMilestone(True)
#sim_openmm.fwd_integrator = openmm.VerletIntegrator(
# timestep*unit.picoseconds)
sim_openmm.fwd_integrator = seekr2plugin.ElberLangevinIntegrator(
target_temperature * unit.kelvin,
friction_coefficient / unit.picoseconds,
timestep * unit.picoseconds, sim_openmm.fwd_output_filename)
if random_seed is not None:
sim_openmm.fwd_integrator.setRandomNumberSeed(random_seed + 2)
sim_openmm.fwd_integrator.setEndOnSrcMilestone(False)
if rigid_constraint_tolerance is not None:
sim_openmm.umbrella_integrator.setConstraintTolerance(
rigid_constraint_tolerance)
sim_openmm.rev_integrator.setConstraintTolerance(
rigid_constraint_tolerance)
sim_openmm.fwd_integrator.setConstraintTolerance(
rigid_constraint_tolerance)
if state_prefix is not None:
sim_openmm.fwd_integrator.setSaveStateFileName(state_prefix)
else:
raise Exception("Settings not provided for available "\
"integrator type(s).")
return
