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 add_simulations(sim_openmm, model, topology, positions, box_vectors): """ """ sim_openmm.umbrella_simulation = openmm_app.Simulation( topology.topology, sim_openmm.umbrella_system, sim_openmm.umbrella_integrator, sim_openmm.platform, sim_openmm.properties) #for force in self.sim_openmm.rev_system.getForces(): # print("force name:", force.__class__.__name__, # "force.usesPeriodicBoundaryConditions():", # force.usesPeriodicBoundaryConditions()) #exit() sim_openmm.rev_simulation = openmm_app.Simulation( topology.topology, sim_openmm.rev_system, sim_openmm.rev_integrator, sim_openmm.platform, sim_openmm.properties) sim_openmm.fwd_simulation = openmm_app.Simulation( topology.topology, sim_openmm.fwd_system, sim_openmm.fwd_integrator, sim_openmm.platform, sim_openmm.properties) sim_openmm.umbrella_simulation.context.setPositions(positions.positions) if box_vectors is not None: sim_openmm.umbrella_simulation.context.setPeriodicBoxVectors( *box_vectors.to_quantity()) if model.openmm_settings.run_minimization: sim_openmm.umbrella_simulation.minimizeEnergy() sim_openmm.umbrella_simulation.context.setVelocitiesToTemperature( model.openmm_settings.initial_temperature * unit.kelvin) assert sim_openmm.timestep is not None return
def add_simulation(sim_openmm, model, topology, positions, box_vectors): """ Assign the OpenMM simulation object for MMVT. """ sim_openmm.simulation = openmm_app.Simulation(topology.topology, sim_openmm.system, sim_openmm.integrator, sim_openmm.platform, sim_openmm.properties) sim_openmm.simulation.context.setPositions(positions.positions) if box_vectors is not None: sim_openmm.simulation.context.setPeriodicBoxVectors( *box_vectors.to_quantity()) if model.openmm_settings.run_minimization: print("Warning: running minimizations. It is recommended that "\ "structures are minimized and verified by the user before "\ "running SEEKR, since minimizations might cause the system "\ "to drift out of the MMVT cell.") sim_openmm.simulation.minimizeEnergy() sim_openmm.simulation.context.setVelocitiesToTemperature( model.openmm_settings.initial_temperature * unit.kelvin) assert sim_openmm.timestep is not None return
def test_local_coord_sites(): """Make sure that the internal prep of vs positions matches that given by OpenMM.""" # make a system mol = app.PDBFile(os.path.join("files", "vs_mol.pdb")) modeller = app.Modeller(topology=mol.topology, positions=mol.positions) forcefield = app.ForceField( os.path.join("files", "forcefield", "vs_mol.xml")) modeller.addExtraParticles(forcefield) system = forcefield.createSystem(modeller.topology, constraints=None) integrator = mm.VerletIntegrator(1.0 * unit.femtoseconds) platform = mm.Platform.getPlatformByName("Reference") simulation = app.Simulation(modeller.topology, system, integrator, platform) simulation.context.setPositions(modeller.positions) # update the site positions simulation.context.computeVirtualSites() # one vs and it should be last vs_pos = simulation.context.getState(getPositions=True).getPositions( asNumpy=True)[-1] # now compute and compare vsinfo = PrepareVirtualSites(system=system) new_pos = ResetVirtualSites_fast(positions=modeller.positions, vsinfo=vsinfo)[-1] assert np.allclose(vs_pos._value, np.array([new_pos.x, new_pos.y, new_pos.z]))
def setUp(self): with open('systems/alanine-dipeptide-implicit.pdb') as f: pdb = app.PDBFile(f) forcefield = app.ForceField('amber99sbildn.xml') system = forcefield.createSystem(pdb.topology, nonbondedMethod=app.CutoffNonPeriodic, nonbondedCutoff=1.0*unit.nanometers, constraints=app.HBonds) self.simulation = app.Simulation(pdb.topology, system, mm.VerletIntegrator(0.002*unit.picoseconds)) self.simulation.context.setPositions(pdb.positions)
def Calculate_ParmEd(gro_file, top_file, sysargs, defines): #===============================# #| ParmEd object creation |# #===============================# # Make sure the proper defines from the .mdp file are passed into the GromacsTopologyFile() :) ParmEd_GmxTop = gromacs.GromacsTopologyFile(top_file) ParmEd_GmxGro = gromacs.GromacsGroFile.parse(gro_file) ParmEd_GmxTop.box = ParmEd_GmxGro.box ParmEd_GmxTop.positions = ParmEd_GmxGro.positions #===============================# #| OpenMM simulation setup |# #===============================# # ParmEd creates System object system = ParmEd_GmxTop.createSystem(**sysargs) # Keep a record of which atoms are real (not virtual sites) isAtom = [] for i in range(system.getNumParticles()): isAtom.append(system.getParticleMass(i).value_in_unit(u.dalton) > 0.0) # Setting force groups enables energy components analysis for i, f in enumerate(system.getForces()): f.setForceGroup(i) if isinstance(f, mm.NonbondedForce): f.setUseDispersionCorrection(True) integ = mm.VerletIntegrator(1.0 * u.femtosecond) plat = mm.Platform.getPlatformByName('Reference') # Create Simulation object simul = app.Simulation(ParmEd_GmxTop.topology, system, integ, plat) simul.context.setPositions(ParmEd_GmxGro.positions) simul.context.applyConstraints(1e-12) # Obtain OpenMM potential energy state = simul.context.getState(getPositions=True, getEnergy=True, getForces=True) parmed_energy = state.getPotentialEnergy() parmed_forces = state.getForces() pos = np.array(state.getPositions().value_in_unit(u.angstrom)).reshape( -1, 3) # Obtain and save constrained positions # M = Molecule(gro_file) # M.xyzs[0] = pos # M.write('constrained.gro') # Print OpenMM-via-ParmEd energy components Ecomps_OMM = energy_components(simul) printcool_dictionary(Ecomps_OMM, title="OpenMM energy components via ParmEd") parmed_forces = np.array([ f for i, f in enumerate( parmed_forces.value_in_unit(u.kilojoule_per_mole / u.nanometer)) if isAtom[i] ]) return parmed_energy, parmed_forces, Ecomps_OMM
def testAppend(self): """Test appending to an existing trajectory.""" fname = tempfile.mktemp(suffix='.dcd') pdb = app.PDBFile('systems/alanine-dipeptide-implicit.pdb') ff = app.ForceField('amber99sb.xml', 'tip3p.xml') system = ff.createSystem(pdb.topology) # Create a simulation and write some frames to a DCD file. integrator = mm.VerletIntegrator(0.001 * unit.picoseconds) simulation = app.Simulation(pdb.topology, system, integrator, mm.Platform.getPlatformByName('Reference')) dcd = app.DCDReporter(fname, 2) simulation.reporters.append(dcd) simulation.context.setPositions(pdb.positions) simulation.context.setVelocitiesToTemperature(300 * unit.kelvin) simulation.step(10) self.assertEqual(5, dcd._dcd._modelCount) del simulation del dcd len1 = os.stat(fname).st_size # Create a new simulation and have it append some more frames. integrator = mm.VerletIntegrator(0.001 * unit.picoseconds) simulation = app.Simulation(pdb.topology, system, integrator, mm.Platform.getPlatformByName('Reference')) dcd = app.DCDReporter(fname, 2, append=True) simulation.reporters.append(dcd) simulation.context.setPositions(pdb.positions) simulation.context.setVelocitiesToTemperature(300 * unit.kelvin) simulation.step(10) self.assertEqual(10, dcd._dcd._modelCount) len2 = os.stat(fname).st_size self.assertTrue(len2 - len1 > 3 * 4 * 5 * system.getNumParticles()) del simulation del dcd os.remove(fname)
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
def add_simulation(sim_openmm, model, topology, positions, box_vectors, load_state_file=None): """ Assign the OpenMM simulation object for MMVT. """ sim_openmm.simulation = openmm_app.Simulation(topology, sim_openmm.system, sim_openmm.integrator, sim_openmm.platform, sim_openmm.properties) if positions is not None: sim_openmm.simulation.context.setPositions(positions) if load_state_file is not None: print("loading state file") sim_openmm.simulation.loadState(load_state_file) state = sim_openmm.simulation.context.getState(getPositions=True) positions = state.getPositions(positions) else: sim_openmm.simulation.context.setVelocitiesToTemperature( model.openmm_settings.initial_temperature * unit.kelvin) if box_vectors is not None: sim_openmm.simulation.context.setPeriodicBoxVectors( *box_vectors.to_quantity()) if model.openmm_settings.run_minimization: assert positions is not None, "If states are being loaded as starting"\ "positions, minimizations cannot be activated." print("Warning: running minimizations. It is recommended that "\ "structures are minimized and verified by the user before "\ "running SEEKR, since minimizations might cause the system "\ "to drift out of the MMVT cell.") sim_openmm.simulation.minimizeEnergy() assert sim_openmm.timestep is not None return positions
def _equil_NPT_OpenMM_protocol_0(topology, positions, temperature=300.0 * _unit.kelvin, pressure=1.0 * _unit.atmosphere, time=1.0 * _unit.nanosecond, forcefield=None, verbose=True, progress_bar=True): import numpy as np import openmm.app as app import openmm as mm from openmmtools.integrators import LangevinIntegrator, GeodesicBAOABIntegrator if progress_bar: from tqdm import tqdm else: def tqdm(arg): return arg #item needs to be openmm.modeller forcefield = app.ForceField("amber99sbildn.xml", "tip3p.xml") topology = item.topology positions = item.positions system = forcefield_generator.createSystem(topology, contraints=app.HBonds, nonbondedMethod=app.PME, nonbondedCutoff=1.0 * _unit.nanometers, rigidWater=True, ewaldErrorTolerance=0.0005) ## Thermodynamic State kB = _unit.BOLTZMANN_CONSTANT_kB * _unit.AVOGADRO_CONSTANT_NA temperature = temperature pressure = pressure ## Barostat barostat_frequency = 25 # steps barostat = mm.MonteCarloBarostat(pressure, temperature, barostat_frequency) system.addForce(barostat) ## Integrator friction = 1.0 / _unit.picosecond step_size = 2.0 * _unit.femtoseconds integrator = LangevinIntegrator(temperature, friction, step_size) integrator.setConstraintTolerance(0.00001) ## Platform platform = mm.Platform.getPlatformByName('CUDA') properties = {'CudaPrecision': 'mixed'} ## Simulation simulation = app.Simulation(topology, system, integrator, platform, properties) simulation.context.setPositions(positions) simulation.context.setVelocitiesToTemperature(temperature) time_equilibration = time time_iteration = 0.2 * _unit.picoseconds number_iterations = int(time_equilibration / time_iteration) steps_iteration = int(time_iteration / step_size) steps_equilibration = number_iterations * steps_iteration ## Reporters net_mass, n_degrees_of_freedom = m3t.get(system, net_mass=True, n_degrees_of_freedom=True) niters = number_iterations data = dict() data['time'] = _unit.Quantity(np.zeros([niters], np.float64), _unit.picoseconds) data['potential'] = _unit.Quantity(np.zeros([niters], np.float64), _unit.kilocalories_per_mole) data['kinetic'] = _unit.Quantity(np.zeros([niters], np.float64), _unit.kilocalories_per_mole) data['volume'] = _unit.Quantity(np.zeros([niters], np.float64), _unit.angstroms**3) data['density'] = _unit.Quantity(np.zeros([niters], np.float64), _unit.gram / _unit.centimeters**3) data['kinetic_temperature'] = unit.Quantity(np.zeros([niters], np.float64), _unit.kelvin) for iteration in tqdm(range(number_iterations)): integrator.step(steps_iteration) state = simulation.context.getState(getEnergy=True) time = state.getTime() potential_energy = state.getPotentialEnergy() kinetic_energy = state.getKineticEnergy() volume = state.getPeriodicBoxVolume() density = (net_mass / volume).in_units_of(unit.gram / unit.centimeter**3) kinetic_temperature = (2.0 * kinetic_energy / kB / n_degrees_of_freedom).in_units_of( unit.kelvin) # (1/2) ndof * kB * T = KE data['time'][iteration] = time data['potential'] = potential_energy data['kinetic'] = kinetic_energy data['volume'] = volume data['density'] = density data['kinetic_temperature'] = kinetic_temperature final_state = simulation.context.getState(getPositions=True, getVelocities=True) final_positions = final_state.getPositions() final_velocities = final_state.getVelocities() return final_positions, final_velocities, data
) # 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 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,
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, enforcePeriodicBox=True)) simulation.reporters.append(HDF5Reporter('villin_hp35_solvated.h5', 50000))
) # 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(ala2_solv.topology, system, integrator, platform, prop) # Set the particle positions sim.context.setPositions(ala2_crds.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( StateDataReporter(sys.stdout, 100, step=True, potentialEnergy=True, kineticEnergy=True,