def testAppend(self):
"""Test appending to the StateDataReporter output."""
with tempfile.TemporaryDirectory() as tempdir:
# Create a Simulation and produce 10 steps of output.
filename = os.path.join(tempdir, 'templog.txt')
simulation = app.Simulation(
self.pdb.topology, self.system,
mm.LangevinMiddleIntegrator(300 * unit.kelvin,
1.0 / unit.picosecond,
0.002 * unit.picoseconds))
simulation.context.setPositions(self.pdb.positions)
simulation.reporters.append(
app.StateDataReporter(filename, 1, step=True))
simulation.step(10)
# Create a new Simulation and append 5 more steps of output.
simulation = app.Simulation(
self.pdb.topology, self.system,
mm.LangevinMiddleIntegrator(300 * unit.kelvin,
1.0 / unit.picosecond,
0.002 * unit.picoseconds))
simulation.context.setPositions(self.pdb.positions)
simulation.reporters.append(
app.StateDataReporter(filename, 1, step=True, append=True))
simulation.step(5)
# See if the log contents are correct.
del simulation
lines = open(filename).read().split('\n')
self.assertTrue(lines[0].startswith('#'))
for i in range(10):
self.assertEqual(lines[i + 1], f'{i+1}')
for i in range(5):
self.assertEqual(lines[i + 11], f'{i+1}')
def equilibrate(
pdb_file: str,
top_file: str,
log_file: str,
output_pdb: str,
solvent_type: str,
gpu_index: int,
log_steps: int,
dt_ps: float,
temperature_kelvin: float,
heat_bath_friction_coef: float,
):
"""Run equilibration and output PDB file at the end"""
sim = configure_simulation(
pdb_file,
top_file,
solvent_type,
gpu_index,
dt_ps,
temperature_kelvin,
heat_bath_friction_coef,
)
# Configure simulation output log
sim.reporters.append(
app.StateDataReporter(
log_file,
log_steps,
step=True,
time=True,
speed=True,
potentialEnergy=True,
temperature=True,
totalEnergy=True,
))
# Run equilibration
sim.step(nsteps)
# Report a PDB file at the end of equilibration
state = sim.context.getState(getPositions=True)
with open(output_pdb, "w") as f:
app.PDBFile.writeFile(sim.topology, state.getPositions(), f)
)
# 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
print('Minimizing energy')
sim.minimizeEnergy(maxIterations=500)
# Set up the reporters to report energies and coordinates every 100 steps
sim.reporters.append(
app.StateDataReporter(sys.stdout,
100,
step=True,
potentialEnergy=True,
kineticEnergy=True,
temperature=True))
sim.reporters.append(NetCDFReporter('dhfr_gb.nc', 100, crds=True))
# Run dynamics
print('Running dynamics')
sim.step(10000)
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,
enforcePeriodicBox=True))
simulation.reporters.append(HDF5Reporter('villin_hp35_solvated.h5', 50000))
simulation.step(1000000)
simulation.reporters[2].close()
final_positions = simulation.context.getState(getPositions=True).getPositions()
app.PDBFile.writeFile(modeller.topology, final_positions,
open('villin_hp35_solvated_last.pdb', 'w'))