def set_up_reporters(self, simulation):
"""
Sets up reporters according to options
specified by arguments in md_param.
See keywords in the Molecular Dynamics section of
the manual for more information.
Parameters
----------
simulation : OpenMM simulation object
Adds reporters to simulation object
"""
pot = False
kin = False
enrgy = False
temp = False
den = False
if self.return_trajectory_interval != 0:
if self.trajectory_format == 'NetCDF':
simulation.reporters.append(
NetCDFReporter(self.return_trajectory_filename,
self.return_trajectory_interval))
if self.return_checkpoint_interval != 0:
simulation.reporters.append(
OM_app.CheckpointReporter(self.return_checkpoint_filename,
self.return_checkpoint_interval))
if self.return_info:
if 'potentialEnergy' in self.return_info:
pot = True
if 'kineticEnergy' in self.return_info:
kin = True
if 'totalEnergy' in self.return_info:
enrgy = True
if 'temperature' in self.return_info:
temp = True
if 'density' in self.return_info:
den = True
simulation.reporters.append(
OM_app.StateDataReporter(self.return_info_filename,
self.return_info_interval,
step=True,
potentialEnergy=pot,
kineticEnergy=kin,
totalEnergy=enrgy,
temperature=temp,
density=den))
def test_openmm_etoh_sim():
path = './etoh_test/sim_openmm/'
topology = 'etoh.prmtop'
coordinates = 'etoh.rst7'
md_out = 'etoh_openmm.csv'
prmtop = app.AmberPrmtopFile(path+topology)
inpcrd = app.AmberInpcrdFile(path+coordinates)
settings = {
'nonbonded_method': app.PME,
'nonbonded_cutoff': 9*unit.angstrom,
'constraints': app.HBonds,
'temperature': 298.15*unit.kelvin,
'friction': 1/unit.picosecond,
'timestep': 0.002*unit.picosecond
}
system = prmtop.createSystem(
nonbondedMethod = settings['nonbonded_method'],
nonbondedCutoff = settings['nonbonded_cutoff'],
constraints = settings['constraints']
)
barostat = mm.MonteCarloBarostat(1.0*unit.bar,298.15*unit.kelvin,25)
system.addForce(barostat)
integrator = LangevinIntegrator(
settings['temperature'],
settings['friction'],
settings['timestep']
)
simulation = app.Simulation(prmtop.topology, system, integrator, mm.Platform.getPlatformByName('CPU'))
simulation.context.setPositions(inpcrd.positions)
simulation.context.setPeriodicBoxVectors(*inpcrd.boxVectors)
simulation.reporters.append(NetCDFReporter(path+'etoh_openmm.nc', 250))
simulation.reporters.append(
app.StateDataReporter(
path+md_out, 250,
step=True,
time=True,
potentialEnergy=True,
kineticEnergy=True,
totalEnergy=True,
temperature=True,
volume=True,
density=True
)
)
simulation.step(100000)
def add_reporters(
simulation,
outs='traj.pdb data.csv screen'.split(),
freqs=(1, 1, 100),
screen='step totalEnergy temperature'.split(),
data='step time potentialEnergy totalEnergy temperature'.split()):
"""Define the simulation reporters.
Parameters
----------
simulation : Simulation object.
outs : list
Output files.
freqs : list
Frequencies in time-steps.
screen : list
Quantities for stdout.
screen : list
Quantities for data file.
"""
simulation.reporters = []
for fp, dt in zip(outs, freqs):
if fp in 'screen stdout'.split(): # to stdout
reporter = StateDataReporter(sys.stdout, dt,
**{q: True
for q in screen})
simulation.reporters.append(reporter)
continue
try:
fp = Path(fp)
except TypeError as e:
if hasattr(fp, 'write'):
reporter = StateDataReporter(fp, dt,
**{q: True
for q in screen})
else:
raise ValueError('Not a valid file: %r' % fp) from e
else: # file path
if fp.suffix == '.pdb':
reporter = PDBReporter(str(fp), dt)
elif fp.suffix == '.nc':
reporter = NetCDFReporter(str(fp), dt)
elif fp.suffix == '.csv':
reporter = StateDataReporter(str(fp), dt,
**{q: True
for q in data})
simulation.reporters.append(reporter)
def run_md(self, simulation, seed=None, save=True):
"""
Run MD with OpenMM.
"""
if self.md["minimized_coordinates"]:
simulation.context.setPositions(self.md["minimized_coordinates"])
if seed is not None:
log.debug("Velocity random number seed: {}".format(seed))
simulation.context.setVelocitiesToTemperature(
self.md["temperature"] * unit.kelvin, seed
)
else:
simulation.context.setVelocitiesToTemperature(
self.md["temperature"] * unit.kelvin
)
if save:
reporter = NetCDFReporter(
self.md["output"], self.md["reporter_frequency"], cell=False
)
simulation.reporters.append(reporter)
simulation.reporters.append(
app.StateDataReporter(
self.md["data"],
self.md["reporter_frequency"],
step=True,
potentialEnergy=True,
temperature=True,
density=True,
)
)
log.info("Running OpenMM MD...")
simulation.step(self.md["steps"])
log.info("MD completed.")
if save:
reporter.close()
return simulation
param = forcefield.getParameter(smirks=smirkseries)
for i,j in zip(paramlist1,paramlist2):
param[paramtype1] = str(i)
param[paramtype2] = str(j)
forcefield.setParameter(param, smirks=smirkseries)
system = forcefield.createSystem(topology, [mol])
#Do simulation
integrator = mm.LangevinIntegrator(temperature*kelvin, friction/picoseconds, time_step*femtoseconds)
platform = mm.Platform.getPlatformByName('Reference')
simulation = app.Simulation(topology, system, integrator)
simulation.context.setPositions(positions)
simulation.context.setVelocitiesToTemperature(temperature*kelvin)
netcdf_reporter = NetCDFReporter('traj_evidence/'+molname[ind]+'_evidence.nc',trj_freq)#'_'+smirkseries+'_'+paramtype1+str(i)+'_'+paramtype2+str(j)+'.nc', trj_freq)
simulation.reporters.append(netcdf_reporter)
simulation.reporters.append(app.StateDataReporter('StateData_evidence/data_'+molname[ind]+'_evidence.csv',data_freq, step=True, potentialEnergy=True, temperature=True, density=True))#'_'+smirkseries+'_'+paramtype1+str(i)+'_'+paramtype2+str(j)+'.csv', data_freq, step=True, potentialEnergy=True, temperature=True, density=True))
print("Starting simulation")
start = time.clock()
simulation.step(num_steps)
end = time.clock()
print("Elapsed time %.2f seconds" % (end-start))
netcdf_reporter.close()
print("Done!")
#Do simulation
#integrator = mm.LangevinIntegrator(temperature*kelvin, friction/picoseconds, time_step*femtoseconds)
#platform = mm.Platform.getPlatformByName('Reference')
integrator = ommtoolsints.LangevinIntegrator(kinetic_temperature, collision_frequency, step_size)
barostat = MonteCarloBarostat(pressure, kinetic_temperature, barostat_frequency)
system.addForce(barostat)
#platform = mm.Platform.getPlatformByName('Reference')
#properties = {'None'}
platform = Platform.getPlatformByName('CUDA')
properties = {'CudaPrecision': 'mixed','DeterministicForces': 'true'}
simulation = Simulation(pdb.topology, system, integrator, platform, properties)
simulation.context.setPositions(pdb.positions)
simulation.context.setVelocitiesToTemperature(kinetic_temperature)
simulation.minimizeEnergy()
#print(simulation.context.getSystem)
#print(pdb.positions)
netcdf_reporter = NetCDFReporter('traj_cychex_neat/Lang_2_baro10step_pme1e-5/'+name+'_'+smirkseries1+'_'+eps+epsval1+'_'+rmin+rminval1+'_'+smirkseries2+'_'+eps+epsval2+'_'+rmin+rminval2+'_wNoConstraints_1fsts.nc', traj_freq)
#pdb_reporter = PDBReporter('traj_cychex_neat/'+name+'_'+smirkseries+'_'+eps+epsval+'_'+rmin+rminval+'_1fs.pdb', traj_freq)
simulation.reporters.append(netcdf_reporter)
#simulation.reporters.append(pdb_reporter)
simulation.reporters.append(StateDataReporter(stdout, data_freq, step=True, potentialEnergy=True, temperature=True, density=True))
simulation.reporters.append(StateDataReporter('StateData_cychex_neat/Lang_2_baro10step_pme1e-5/'+name+'_'+smirkseries1+'_'+eps+epsval1+'_'+rmin+rminval1+'_'+smirkseries2+'_'+eps+epsval2+'_'+rmin+rminval2+'_wNoConstraints_1fsts.csv', data_freq, step=True, potentialEnergy=True, temperature=True, density=True))
print("Starting simulation")
start = time.clock()
simulation.step(num_steps)
end = time.clock()
print("Elapsed time %.2f seconds" % (end-start))
netcdf_reporter.close()
print("Done!")
system = prmtop.createSystem(
#nonbondedMethod=PME,
nonbondedCutoff=1 * nanometer,
constraints=HBonds)
integrator = LangevinIntegrator(300 * kelvin, 0.5 / picoseconds,
2.0 * femtoseconds)
simulation = Simulation(prmtop.topology, system, integrator)
simulation.context.setPositions(inpcrd.positions)
if inpcrd.boxVectors is not None:
simulation.context.setPeriodicBoxVectors(*inpcrd.boxVectors)
print("Minimizing system...")
# Minimize energy
simulation.minimizeEnergy()
print("Preparing output files...")
# Create a RestartReporter which will output the restart file
simulation.reporters.append(
RestartReporter('nacl_eq.rst', 1, prmtop.topology.getNumAtoms()))
# Create a NetCDF reporter which outputs a trajectory file
# This is used to calculate the initial progress coordinate in get_pcoord.sh
simulation.reporters.append(NetCDFReporter('nacl_eq.nc', 1))
# Run the simulation for a single frame so that files can be outputed
simulation.step(1)
# Rename the restart file, because the parmEd reporter adds an extension
os.rename('nacl_eq.rst.1', 'nacl_eq.rst')
print("Done")
#nonbondedMethod=PME,
nonbondedCutoff=1 * nanometer,
constraints=HBonds)
# LangevinIntegrator(temperature, frictionCoefficient, timeStepLength)
integrator = LangevinIntegrator(300 * kelvin, 0.5 / picoseconds, TIMESTEP)
simulation = Simulation(prmtop.topology, system, integrator)
simulation.context.setPositions(inpcrd.positions)
if inpcrd.boxVectors is not None:
simulation.context.setPeriodicBoxVectors(*inpcrd.boxVectors)
# Create a reporter which will output the trajectory (seg.nc) file
# Every 50 frames, add the coordinates to the trajectory file output
# After 2500 frames, coordinates will be added 50 times
# This is why pcoord_len (progress coordinate length) is 50, because
# the pccord will be an array of length 50: one distance for every frame
simulation.reporters.append(NetCDFReporter(trajectoryFile, 50))
#Create restart reporter which will output a .rst file
#RestartReporter(restartFile, numberOfSteps, numberOfAtoms, usesPeriodicBoundaryConditions)
simulation.reporters.append(
RestartReporter(restartFile, TIMESTEPS, prmtop.topology.getNumAtoms()))
#Create log reporter which will output seg.log
#TODO: What data should this report?
simulation.reporters.append(
StateDataReporter(logFile,
TIMESTEPS,
step=True,
potentialEnergy=True,
temperature=True))
oechem.OEReadMolecule(ifs, mol)
oechem.OETriposAtomNames(mol)
# 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())
simulation.minimizeEnergy()
print(simulation.context.getState(getEnergy=True).getPotentialEnergy())
# Run the simulation
print("Starting simulation")
def test_reporter():
tempdir = os.path.join(dir, 'test1')
os.makedirs(tempdir)
pdb = PDBFile(get_fn('native.pdb'))
forcefield = ForceField('amber99sbildn.xml', 'amber99_obc.xml')
# NO PERIODIC BOUNARY CONDITIONS
system = forcefield.createSystem(pdb.topology,
nonbondedMethod=CutoffNonPeriodic,
nonbondedCutoff=1.0 * nanometers,
constraints=HBonds,
rigidWater=True)
integrator = LangevinIntegrator(300 * kelvin, 1.0 / picoseconds,
2.0 * femtoseconds)
integrator.setConstraintTolerance(0.00001)
platform = Platform.getPlatformByName('Reference')
simulation = Simulation(pdb.topology, system, integrator, platform)
simulation.context.setPositions(pdb.positions)
simulation.context.setVelocitiesToTemperature(300 * kelvin)
hdf5file = os.path.join(tempdir, 'traj.h5')
ncfile = os.path.join(tempdir, 'traj.nc')
dcdfile = os.path.join(tempdir, 'traj.dcd')
reporter = HDF5Reporter(hdf5file,
2,
coordinates=True,
time=True,
cell=True,
potentialEnergy=True,
kineticEnergy=True,
temperature=True,
velocities=True)
reporter2 = NetCDFReporter(ncfile,
2,
coordinates=True,
time=True,
cell=True)
reporter3 = DCDReporter(dcdfile, 2)
simulation.reporters.append(reporter)
simulation.reporters.append(reporter2)
simulation.reporters.append(reporter3)
simulation.step(100)
reporter.close()
reporter2.close()
with HDF5TrajectoryFile(hdf5file) as f:
got = f.read()
yield lambda: eq(got.temperature.shape, (50, ))
yield lambda: eq(got.potentialEnergy.shape, (50, ))
yield lambda: eq(got.kineticEnergy.shape, (50, ))
yield lambda: eq(got.coordinates.shape, (50, 22, 3))
yield lambda: eq(got.velocities.shape, (50, 22, 3))
yield lambda: eq(got.cell_lengths, None)
yield lambda: eq(got.cell_angles, None)
yield lambda: eq(got.time, 0.002 * 2 * (1 + np.arange(50)))
yield lambda: f.topology == md.load(get_fn('native.pdb')).top
with NetCDFTrajectoryFile(ncfile) as f:
xyz, time, cell_lengths, cell_angles = f.read()
yield lambda: eq(cell_lengths, None)
yield lambda: eq(cell_angles, None)
yield lambda: eq(time, 0.002 * 2 * (1 + np.arange(50)))
hdf5_traj = md.load(hdf5file)
dcd_traj = md.load(dcdfile, top=get_fn('native.pdb'))
netcdf_traj = md.load(ncfile, top=get_fn('native.pdb'))
# we don't have to convert units here, because md.load already
# handles that
assert hdf5_traj.unitcell_vectors is None
yield lambda: eq(hdf5_traj.xyz, netcdf_traj.xyz)
yield lambda: eq(hdf5_traj.unitcell_vectors, netcdf_traj.unitcell_vectors)
yield lambda: eq(hdf5_traj.time, netcdf_traj.time)
yield lambda: eq(dcd_traj.xyz, hdf5_traj.xyz)
def runNCMC(platform_name, nstepsNC, nprop, outfname):
#Generate the ParmEd Structure
prmtop = '../complex_wat.prmtop'
inpcrd = '../ligand3.equi.rst'
struct = parmed.load_file(prmtop, xyz=inpcrd)
print('Structure: %s' % struct.topology)
nstepsNC = 1000
#Define some options
opt = {
'temperature': 300.0,
'friction': 1,
'dt': 0.002,
'nIter': 25000,
'nstepsNC': nstepsNC,
'nstepsMD': 1000,
'nprop': nprop,
'nonbondedMethod': 'PME',
'nonbondedCutoff': 10,
'constraints': 'HBonds',
'freeze_distance': 5.0,
'trajectory_interval': 1000,
'reporter_interval': 1000,
'ncmc_traj': False,
'write_move': False,
'platform': platform_name,
'outfname': 'gmx',
'NPT': False,
'verbose': False
}
#Define the 'model' object we are perturbing here.
# Calculate particle masses of object to be moved
resname = "LIG"
dihedral_atoms = ["C10", "C9", "C3", "C2"]
alch_list = [
'C9', 'H92', 'H93', 'C1', 'C2', 'C3', 'C4', 'C5', 'C6', 'H1', 'H4',
'H6', 'C7', 'H71', 'H72', 'H73', 'C8', 'H81', 'H82', 'H83'
]
ligand = FlipMove(struct, prmtop, inpcrd, dihedral_atoms, alch_list,
resname)
# Initialize object that proposes moves.
ligand_mover = MoveEngine(ligand)
# Generate the MD, NCMC, ALCHEMICAL Simulation objects
simulations = SimulationFactory(struct, ligand_mover, **opt)
simulations.createSimulationSet()
# Add reporters to MD simulation.
#traj_reporter = openmm.app.DCDReporter(outfname+'-nc{}.dcd'.format(nstepsNC), opt['trajectory_interval'])
progress_reporter = openmm.app.StateDataReporter(
sys.stdout,
separator="\t",
reportInterval=opt['reporter_interval'],
step=True,
totalSteps=opt['nIter'] * opt['nstepsMD'],
time=True,
speed=True,
progress=True,
remainingTime=True)
#simulations.md.reporters.append(traj_reporter)
simulations.md.reporters.append(progress_reporter)
netcdf_reporter = NetCDFReporter('gmx.nc', 500)
simulations.md.reporters.append(netcdf_reporter)
# Run BLUES Simulation
blues = Simulation(simulations, ligand_mover, **opt)
blues.run(opt['nIter'])
# saving last restart
restrt = RestartReporter('blues.rst', 1, struct.ptr('natom'))
state = simulations.md.context.getState(getPositions=True,
getEnergy=True,
getVelocities=True,
enforcePeriodicBox=True)
restrt.report(simulations.md, state)
# new_sys.addForce(MonteCarloBarostat(1 * unit.bar, 298.15 * unit.kelvin))
integrator = LangevinIntegrator(298.15 * unit.kelvin, 1.0 / unit.picoseconds,
0.002 * unit.picoseconds)
# integrator.setIntegrationForceGroups(set([0]))
simulation = app.Simulation(modeller.topology, system, integrator, platform)
simulation.context.setPositions(modeller.positions)
simulation.minimizeEnergy()
state = simulation.context.getState(getPositions=True)
PDBFile.writeFile(modeller.topology,
state.getPositions(),
file=open("equil.pdb", "w"))
simulation.reporters.append(
StateDataReporter('data.txt',
100,
step=True,
potentialEnergy=True,
temperature=True,
density=True,
volume=True))
simulation.reporters.append(NetCDFReporter('output.nc', 100))
start = time()
simulation.step(10000)
end = time()
print(end - start)
# Load a SMIRNOFF small molecule forcefield for alkanes, ethers, and alcohols
forcefield = ForceField(
get_data_filename('forcefield/Frosst_AlkEthOH_parmAtFrosst.ffxml'))
# Create the OpenMM system
topology = generateTopologyFromOEMol(mol)
system = forcefield.createSystem(topology, [mol])
# Set up an OpenMM simulation
integrator = openmm.LangevinIntegrator(temperature, friction, time_step)
platform = openmm.Platform.getPlatformByName('Reference')
simulation = app.Simulation(topology, system, integrator)
simulation.context.setPositions(positions)
simulation.context.setVelocitiesToTemperature(temperature)
netcdf_reporter = NetCDFReporter('trajectory.nc', trj_freq)
simulation.reporters.append(netcdf_reporter)
simulation.reporters.append(
app.StateDataReporter('data.csv',
data_freq,
step=True,
potentialEnergy=True,
temperature=True,
density=True))
# Run the simulation
print("Starting simulation")
start = time.clock()
simulation.step(num_steps)
end = time.clock()
def test_reporter_subset():
tempdir = os.path.join(dir, 'test2')
os.makedirs(tempdir)
pdb = PDBFile(get_fn('native2.pdb'))
pdb.topology.setUnitCellDimensions([2, 2, 2])
forcefield = ForceField('amber99sbildn.xml', 'amber99_obc.xml')
system = forcefield.createSystem(pdb.topology,
nonbondedMethod=CutoffPeriodic,
nonbondedCutoff=1 * nanometers,
constraints=HBonds,
rigidWater=True)
integrator = LangevinIntegrator(300 * kelvin, 1.0 / picoseconds,
2.0 * femtoseconds)
integrator.setConstraintTolerance(0.00001)
platform = Platform.getPlatformByName('Reference')
simulation = Simulation(pdb.topology, system, integrator, platform)
simulation.context.setPositions(pdb.positions)
simulation.context.setVelocitiesToTemperature(300 * kelvin)
hdf5file = os.path.join(tempdir, 'traj.h5')
ncfile = os.path.join(tempdir, 'traj.nc')
dcdfile = os.path.join(tempdir, 'traj.dcd')
atomSubset = [0, 1, 2, 4, 5]
reporter = HDF5Reporter(hdf5file,
2,
coordinates=True,
time=True,
cell=True,
potentialEnergy=True,
kineticEnergy=True,
temperature=True,
velocities=True,
atomSubset=atomSubset)
reporter2 = NetCDFReporter(ncfile,
2,
coordinates=True,
time=True,
cell=True,
atomSubset=atomSubset)
reporter3 = DCDReporter(dcdfile, 2, atomSubset=atomSubset)
simulation.reporters.append(reporter)
simulation.reporters.append(reporter2)
simulation.reporters.append(reporter3)
simulation.step(100)
reporter.close()
reporter2.close()
reporter3.close()
t = md.load(get_fn('native.pdb'))
t.restrict_atoms(atomSubset)
with HDF5TrajectoryFile(hdf5file) as f:
got = f.read()
eq(got.temperature.shape, (50, ))
eq(got.potentialEnergy.shape, (50, ))
eq(got.kineticEnergy.shape, (50, ))
eq(got.coordinates.shape, (50, len(atomSubset), 3))
eq(got.velocities.shape, (50, len(atomSubset), 3))
eq(got.cell_lengths, 2 * np.ones((50, 3)))
eq(got.cell_angles, 90 * np.ones((50, 3)))
eq(got.time, 0.002 * 2 * (1 + np.arange(50)))
assert f.topology == md.load(get_fn('native.pdb'),
atom_indices=atomSubset).topology
with NetCDFTrajectoryFile(ncfile) as f:
xyz, time, cell_lengths, cell_angles = f.read()
eq(cell_lengths, 20 * np.ones((50, 3)))
eq(cell_angles, 90 * np.ones((50, 3)))
eq(time, 0.002 * 2 * (1 + np.arange(50)))
eq(xyz.shape, (50, len(atomSubset), 3))
hdf5_traj = md.load(hdf5file)
dcd_traj = md.load(dcdfile, top=hdf5_traj)
netcdf_traj = md.load(ncfile, top=hdf5_traj)
# we don't have to convert units here, because md.load already handles
# that
eq(hdf5_traj.xyz, netcdf_traj.xyz)
eq(hdf5_traj.unitcell_vectors, netcdf_traj.unitcell_vectors)
eq(hdf5_traj.time, netcdf_traj.time)
eq(dcd_traj.xyz, hdf5_traj.xyz)
eq(dcd_traj.unitcell_vectors, hdf5_traj.unitcell_vectors)
integrator.setRandomNumberSeed(trial)
print(f"Random seed of this run is: {integrator.getRandomNumberSeed()}")
platform = mm.Platform.getPlatformByName('OpenCL')
print("Done specifying integrator and platform for simulation.")
platform.setPropertyDefaultValue('Precision', 'mixed')
print("Done setting the precision to mixed.")
simulation = Simulation(prmtop.topology, system, integrator, platform)
simulation.context.setPositions(pdb.positions)
print("Done recording a context for positions.")
context = simulation.context
context.setVelocitiesToTemperature(temperature)
print("Done assigning velocities.")
storage_path = os.path.join(work_dir,'traj.nc')
#potential_path = os.path.join(work_dir,'potential.txt')
simulation.reporters.append(NetCDFReporter(storage_path, reportInterval=250000, coordinates=True))
#simulation.reporters.append(StateDataReporter(potential_path, 1, step=True, potentialEnergy=True))
print("Done specifying simulation.")
simulation.step(steps)
# Serialize state
print('Serializing state to state.xml...')
state = context.getState(getPositions=True, getVelocities=True, getEnergy=True, getForces=True)
with open('state.xml', 'w') as outfile:
xml = XmlSerializer.serialize(state)
outfile.write(xml)
# Serialize system
print('Serializing System to system.xml...')
system.setDefaultPeriodicBoxVectors(*state.getPeriodicBoxVectors())
with open('system.xml', 'w') as outfile:
integrator = LangevinIntegrator(300 * kelvin, 1 / picosecond,
0.002 * picoseconds)
from paprika.openmm import *
opmm_sim = OpenMM_GB_simulation()
OpenMM_GB_simulation.add_openmm_restraints(opmm_sim, system, restraints,
"attach", 1)
simulation = Simulation(prmtop.topology, system, integrator,
mm.Platform.getPlatformByName('Reference'))
simulation.context.setPositions(inpcrd.positions)
if inpcrd.boxVectors is not None:
simulation.context.setPeriodicBoxVectors(*inpcrd.boxVectors)
simulation.minimizeEnergy()
#simulation.reporters.append(PDBReporter('cb6-but_output.pdb', 500))
simulation.reporters.append(NetCDFReporter('paprika_openmm_test.nc', 500))
simulation.reporters.append(
StateDataReporter(stdout,
500,
step=True,
potentialEnergy=True,
temperature=True,
volume=True,
density=True))
simulation.step(1000)
system = forcefield.createSystem(pdb.topology,mols,nonbondedMethod=PME,nonbondedCutoff=1.2*nanometers)
integrator = LangevinIntegrator(293*kelvin, 1/picosecond, 0.002*picoseconds)
barostat = MonteCarloBarostat(1.01*bar, 293.0*kelvin, 25)
system.addForce(barostat)
#platform = mm.Platform.getPlatformByName('Reference')
platform = mm.Platform.getPlatformByName('CUDA')
properties = {'CudaPrecision': 'mixed','DeterministicForces': 'true'}
simulation = Simulation(pdb.topology, system, integrator, platform, properties)
simulation.context.setPositions(pdb.positions)
simulation.minimizeEnergy()
netcdf_reporter = NetCDFReporter('traj_cychex_neat/'+name+'_'+smirkseries+'_'+eps+epsval+'_'+rmin+rminval+'_cont.nc', traj_freq)
pdb_reporter = PDBReporter('traj_cychex_neat/'+name+'_'+smirkseries+'_'+eps+epsval+'_'+rmin+rminval+'_cont.pdb', traj_freq)
simulation.reporters.append(netcdf_reporter)
simulation.reporters.append(pdb_reporter)
simulation.reporters.append(StateDataReporter(stdout, data_freq, step=True, potentialEnergy=True, temperature=True, density=True))
simulation.reporters.append(StateDataReporter('StateData_cychex_neat/'+name+'_'+smirkseries+'_'+eps+epsval+'_'+rmin+rminval+'_cont.csv', data_freq, step=True, potentialEnergy=True, temperature=True, density=True))
print("Starting simulation")
start = time.clock()
simulation.step(num_steps)
end = time.clock()
print("Elapsed time %.2f seconds" % (end-start))
netcdf_reporter.close()
print("Done!")
def _minimizeOverlaps(self, platform, membrane):
hydrogen_mass = 3 * unit.amu
system = self.structure.createSystem(nonbondedMethod=app.PME,
nonbondedCutoff=1 *
unit.nanometer,
rigidWater=True,
flexibleConstraints=False,
constraints=app.HBonds,
hydrogenMass=hydrogen_mass,
removeCMMotion=False)
backup_system = deepcopy(system)
for index in self.atom_to_freeze:
system.setParticleMass(int(index), 0.0 * unit.dalton)
integrator = mm.LangevinIntegrator(300 * unit.kelvin,
1.0 / unit.picoseconds,
2 * unit.femtosecond)
simulation = app.Simulation(self.structure.topology, system,
integrator, platform)
simulation.context.setPositions(self.structure.positions)
simulation.minimizeEnergy(tolerance=0.1 * unit.kilojoule / unit.mole,
maxIterations=0)
positions = simulation.context.getState(
getPositions=True).getPositions()
min_potential = atomsmm.splitPotentialEnergy(system,
self.structure.topology,
positions)
for key, value in min_potential.items():
self.logger.debug(key, value)
simulation.saveCheckpoint('porinMembraneSystem.chk')
integrator = mm.LangevinIntegrator(300 * unit.kelvin,
1.0 / unit.picoseconds,
2 * unit.femtosecond)
simulation = app.Simulation(self.structure.topology, backup_system,
integrator, platform)
simulation.context.setPositions(positions)
simulation.context.setVelocitiesToTemperature(300 * unit.kelvin)
simulation.reporters.append(
app.StateDataReporter(
'relax-ligand-system.log',
100,
step=True,
temperature=True,
potentialEnergy=True,
totalEnergy=True,
speed=True,
))
topology = md.Topology.from_openmm(self.structure.topology)
atom_indices = topology.select('(protein and not resname ' +
membrane + ')' + ' or resname ' +
self.lig_name)
simulation.reporters.append(
NetCDFReporter('relax-ligand-system.nc',
100,
atomSubset=atom_indices))
simulation.step(100000)
positions = simulation.context.getState(
getPositions=True).getPositions()
PDBxFile.writeFile(self.structure.topology, positions,
open("atomistic-system-combined.pdbx", 'w'))
forcefield.setParameter(param, smirks=smirkseries)
system = forcefield.createSystem(topology, [mol])
"""
#Do simulation
integrator = mm.LangevinIntegrator(temperature * kelvin,
friction / picoseconds,
time_step * femtoseconds)
platform = mm.Platform.getPlatformByName('CUDA')
properties = {'CudaPrecision': 'mixed', 'DeterministicForces': 'true'}
simulation = app.Simulation(topology, system, integrator, platform,
properties)
simulation.context.setPositions(positions)
simulation.context.setVelocitiesToTemperature(temperature * kelvin)
netcdf_reporter = NetCDFReporter(
molname[ind] + '_vacuum.nc', trj_freq
) #NetCDFReporter('traj4ns_c1143/'+molname[ind]+'_'+smirkseries+'_'+paramtype1+str(i)+'_'+paramtype2+str(j)+'.nc', trj_freq)
simulation.reporters.append(netcdf_reporter)
#simulation.reporters.append(app.StateDataReporter('StateData4ns_c1143/data_'+molname[ind]+'_'+smirkseries+'_'+paramtype1+str(i)+'_'+paramtype2+str(j)+'.csv', data_freq, step=True, potentialEnergy=True, temperature=True, density=True))
simulation.reporters.append(
app.StateDataReporter(sys.stdout,
1000,
step=True,
potentialEnergy=True,
temperature=True))
print("Starting simulation")
start = time.clock()
simulation.step(num_steps)
end = time.clock()
print("Elapsed time %.2f seconds" % (end - start))
# Load forcefield
forcefield = ForceField('forcefield/smirnoff99Frosst.ffxml')
#Define system
topology = generateTopologyFromOEMol(mol)
system = forcefield.createSystem(topology, [mol])
#Do simulation - SMIRFF
integrator = mm.LangevinIntegrator(temperature * kelvin,
friction / picoseconds,
time_step * femtoseconds)
#platform = mm.Platform.getPlatformByName('Reference')
simulation = app.Simulation(topology, system, integrator)
simulation.context.setPositions(positions)
simulation.context.setVelocitiesToTemperature(temperature * kelvin)
netcdf_reporter = NetCDFReporter(os.path.join(outdir, molname + '.nc'),
trj_freq)
simulation.reporters.append(netcdf_reporter)
simulation.reporters.append(
app.StateDataReporter('data.csv',
data_freq,
step=True,
potentialEnergy=True,
temperature=True,
density=True))
print("Starting simulation for %s" % molname)
start = time.clock()
simulation.step(num_steps)
end = time.clock()
print("Elapsed time %.2f seconds" % (end - start))
#integrator.setRandomNumberSeed(129)
with open('openmm_system.xml', 'r') as infile:
openmm_system = XmlSerializer.deserialize(infile.read())
pdbx = app.PDBxFile('mem_prot_md_system.pdbx')
positions = [(pos[0], pos[1], pos[2] + 1 * unit.nanometers)
for pos in pdbx.positions]
openmm_simulation = app.Simulation(pdbx.topology, openmm_system, integrator,
platform)
####### Reading positions from mdtraj trajectory ##########################
#topology = md.Topology.from_openmm(pdbx.topology)
#t = md.load('traj.nc',top=topology)
#positions = t.openmm_positions(1999)
############################################################################
openmm_simulation.context.setPositions(positions)
mdtraj_reporter = NetCDFReporter('steered_forward.nc', 500)
openmm_simulation.reporters.append(mdtraj_reporter)
openmm_simulation.reporters.append(
app.StateDataReporter('state_forward.log',
500,
step=True,
potentialEnergy=True,
temperature=True))
cvforce = []
for force in openmm_system.getForces():
forceType = force.__class__.__name__
if forceType == 'CustomCVForce':
cvforce.append(force)
openmm_simulation.context.setParameter(
for ind, i in enumerate(SMIRKS_and_params):
temp = i[0] + '_' + i[1] + '_' + str(theta_current[ind])
filename_string.append(temp)
filename_string = '_'.join(filename_string)
#Do simulation
integrator = mm.LangevinIntegrator(temperature * kelvin,
friction / picoseconds,
time_step * femtoseconds)
platform = mm.Platform.getPlatformByName('Reference')
simulation = app.Simulation(topology, system, integrator)
simulation.context.setPositions(positions)
simulation.context.setVelocitiesToTemperature(temperature * kelvin)
traj_name = 'traj_posterior/' + molname[
moldex] + '_' + filename_string + '.nc'
netcdf_reporter = NetCDFReporter(traj_name, trj_freq)
simulation.reporters.append(netcdf_reporter)
simulation.reporters.append(
app.StateDataReporter('StateData_posterior/data_' + molname[moldex] +
'_' + filename_string + '.csv',
data_freq,
step=True,
potentialEnergy=True,
temperature=True,
density=True))
print("Starting simulation")
start = time.clock()
simulation.step(num_steps)
end = time.clock()
dihedral_restraint3.addTorsion(D_i[0], H_i[0], H_i[1], H_i[2], [k, theta_0])
# Add Forces to system
system.addForce(dist_restraint)
system.addForce(angle_restraint1)
system.addForce(dihedral_restraint1)
system.addForce(angle_restraint2)
system.addForce(dihedral_restraint2)
system.addForce(dihedral_restraint3)
simulation = Simulation(prmtop.topology, system, integrator,
mm.Platform.getPlatformByName('Reference'))
simulation.context.setPositions(inpcrd.positions)
if inpcrd.boxVectors is not None:
simulation.context.setPeriodicBoxVectors(*inpcrd.boxVectors)
simulation.minimizeEnergy()
simulation.reporters.append(NetCDFReporter('cb6-but-dum_output_6rest.nc', 500))
simulation.reporters.append(
StateDataReporter(stdout,
500,
step=True,
potentialEnergy=True,
temperature=True,
volume=True,
density=True))
simulation.step(100000)
