def test_combine_molecules_sites_deepdiff(openff, xml, acetone, rfree_data, tmpdir): """ Test combining molecules with virtual sites and ensure they are correctly applied and the energy break down matches. """ with tmpdir.as_cwd(): openff.run(acetone) acetone_ref_system = xmltodict.parse(open("serialised.xml").read()) pyridine = Ligand.from_file(file_name=get_data("pyridine.sdf")) xml.run(molecule=pyridine, input_files=[get_data("pyridine.xml")]) pyridine_ref_system = xmltodict.parse(open("serialised.xml").read()) combined_xml = _combine_molecules( molecules=[acetone, pyridine], parameters=elements, rfree_data=rfree_data ).getroot() messy = ET.tostring(combined_xml, "utf-8") pretty_xml = parseString(messy).toprettyxml(indent="") print(pretty_xml) with open("combined.xml", "w") as xml_doc: xml_doc.write(pretty_xml) root = combined_xml.find("QUBEKit") assert qubekit.__version__ == root.get("Version") # load up new systems and compare combinded_ff = app.ForceField("combined.xml") acetone_combine_system = xmltodict.parse( XmlSerializer.serialize( combinded_ff.createSystem( acetone.to_openmm_topology(), nonbondedCutoff=0.9, removeCMMotion=False, ) ) ) # slight differences in masses we need to ignore acetone_diff = DeepDiff( acetone_ref_system, acetone_combine_system, ignore_order=True, significant_digits=6, exclude_regex_paths="mass", ) assert len(acetone_diff) == 0 # add v-site pyridine_mod = app.Modeller( pyridine.to_openmm_topology(), pyridine.openmm_coordinates() ) pyridine_mod.addExtraParticles(combinded_ff) pyridine_combine_system = xmltodict.parse( XmlSerializer.serialize(combinded_ff.createSystem(pyridine_mod.topology)) ) pyridine_diff = DeepDiff( pyridine_ref_system, pyridine_combine_system, ignore_order=True, significant_digits=6, exclude_regex_paths="mass", ) assert len(pyridine_diff) == 0
def setUp(self): self.pdb = app.PDBFile('systems/alanine-dipeptide-implicit.pdb') self.forcefield = app.ForceField('amber99sbildn.xml') self.system = self.forcefield.createSystem( self.pdb.topology, nonbondedMethod=app.CutoffNonPeriodic, constraints=app.HBonds)
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 simulate(pdbcode, pdb_filename): from openmm import app import openmm.openmm as mm from openmm import unit from sys import stdout # Load the PDB file. pdb = app.PDBFile(pdb_filename) # Set up implicit solvent forcefield. #forcefield = app.ForceField('amber99sbildn.xml') forcefield = app.ForceField('amber10.xml') # Create the system. system = forcefield.createSystem(pdb.topology, nonbondedMethod=app.NoCutoff, constraints=app.HBonds) # Create an integrator. integrator = mm.LangevinIntegrator(300 * unit.kelvin, 91.0 / unit.picoseconds, 1.0 * unit.femtoseconds) # Create a context. context = mm.Context(system, integrator) context.setPositions(pdb.positions) # Check to make sure energy is finite. state = context.getState(getEnergy=True) potential = state.getPotentialEnergy() / unit.kilocalories_per_mole if numpy.isnan(potential): raise Exception("Initial energy for %s is NaN." % pdbcode) # Minimize. tolerance = 1.0 * unit.kilocalories_per_mole / unit.angstroms maxIterations = 50 mm.LocalEnergyMinimizer.minimize(context, tolerance, maxIterations) # Check to make sure energy is finite. state = context.getState(getEnergy=True) potential = state.getPotentialEnergy() / unit.kilocalories_per_mole if numpy.isnan(potential): raise Exception("Energy for %s is NaN after minimization." % pdbcode) # Simulate. nsteps = 500 integrator.step(nsteps) # Check to make sure energy is finite. state = context.getState(getEnergy=True) potential = state.getPotentialEnergy() / unit.kilocalories_per_mole if numpy.isnan(potential): raise Exception("Energy for %s is NaN after simulation." % pdbcode) del context, integrator print("Simulation completed: potential = %.3f kcal/mol" % potential) return
def test_combine_molecules_deepdiff(acetone, openff, coumarin, tmpdir, rfree_data): with tmpdir.as_cwd(): openff.run(acetone) acetone_ref_system = xmltodict.parse(open("serialised.xml").read()) openff.run(coumarin) coumarin_ref_system = xmltodict.parse(open("serialised.xml").read()) combined_xml = _combine_molecules( molecules=[acetone, coumarin], parameters=elements, rfree_data=rfree_data ).getroot() messy = ET.tostring(combined_xml, "utf-8") pretty_xml = parseString(messy).toprettyxml(indent="") with open("combined.xml", "w") as xml_doc: xml_doc.write(pretty_xml) root = combined_xml.find("QUBEKit") assert qubekit.__version__ == root.get("Version") # load up new systems and compare combinded_ff = app.ForceField("combined.xml") acetone_combine_system = xmltodict.parse( XmlSerializer.serialize( combinded_ff.createSystem( acetone.to_openmm_topology(), nonbondedCutoff=0.9, removeCMMotion=False, ) ) ) # slight differences in masses we need to ignore acetone_diff = DeepDiff( acetone_ref_system, acetone_combine_system, ignore_order=True, significant_digits=6, exclude_regex_paths="mass", ) assert len(acetone_diff) == 0 coumarin_combine_system = xmltodict.parse( XmlSerializer.serialize( combinded_ff.createSystem( coumarin.to_openmm_topology(), nonbondedCutoff=0.9, removeCMMotion=False, ) ) ) coumarin_diff = DeepDiff( coumarin_ref_system, coumarin_combine_system, ignore_order=True, significant_digits=6, exclude_regex_paths="mass", ) assert len(coumarin_diff) == 0
def test_combine_molecules_offxml_plugin_deepdiff(tmpdir, coumarin, rfree_data): """Make sure that systems made from molecules using the xml method match offxmls with plugins""" # we need to recalculate the Nonbonded terms using the fake Rfree coumarin_copy = coumarin.copy(deep=True) # apply symmetry to make sure systems match MBISCharges.apply_symmetrisation(coumarin_copy) with tmpdir.as_cwd(): # make the offxml using the plugin interface _combine_molecules_offxml( molecules=[coumarin_copy], parameters=elements, rfree_data=rfree_data, filename="openff.offxml", water_model="tip3p", ) offxml = ForceField( "openff.offxml", load_plugins=True, allow_cosmetic_attributes=True ) # check the plugin is being used vdw = offxml.get_parameter_handler("QUBEKitvdWTS") # make sure we have the parameterize tags assert len(vdw._cosmetic_attribs) == 1 assert len(vdw.parameters) == 28 alpha = rfree_data.pop("alpha") beta = rfree_data.pop("beta") lj = LennardJones612(free_parameters=rfree_data, alpha=alpha, beta=beta) # get new Rfree data lj.run(coumarin_copy) coumarin_copy.write_parameters("coumarin.xml") coumarin_ref_system = xmltodict.parse( XmlSerializer.serialize( app.ForceField("coumarin.xml").createSystem( topology=coumarin_copy.to_openmm_topology(), nonbondedCutoff=9 * unit.angstroms, removeCMMotion=False, ) ) ) coumarin_off_system = xmltodict.parse( XmlSerializer.serialize( offxml.create_openmm_system( Molecule.from_rdkit(coumarin_copy.to_rdkit()).to_topology() ) ) ) coumarin_diff = DeepDiff( coumarin_ref_system, coumarin_off_system, ignore_order=True, significant_digits=6, exclude_regex_paths="mass", ) assert len(coumarin_diff) == 1 for item in coumarin_diff["iterable_item_added"].values(): assert item["@k"] == "0"
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 _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 parse(filename): """ Parses XML file and returns deserialized object. The return value depends on the serialized object, summarized below - System : returns openmm.System - State : returns openmm.State - Integrator : returns openmm.Integrator subclass - ForceField : returns openmm.app.ForceField Parameters ---------- filename : str or file-like The file name or file object containing the XML-serialized object Returns ------- obj : System, State, Integrator, or ForceField The deserialized object Notes ----- OpenMM requires the entire contents of this file read into memory. As a result, this function may require a significant amount of memory. """ import openmm as mm from openmm import app if isinstance(filename, str): with closing(genopen(filename, 'r')) as f: contents = f.read() else: contents = filename.read() # ForceField is not handled by XmlSerializer if '<ForceField' in contents: obj = StringIO() obj.write(contents) obj.seek(0) return app.ForceField(obj) obj = mm.XmlSerializer.deserialize(contents) if isinstance(obj, mm.State): return _OpenMMStateContents(obj) return obj
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 create_openmm_system(sim_openmm, model, anchor, frame=0, load_state_file=None): """ Create an openmm System() object. """ building_directory = os.path.join(model.anchor_rootdir, anchor.directory, anchor.building_directory) box_vectors = None num_frames = 0 positions_obj = None if anchor.__class__.__name__ in ["MMVT_toy_anchor", "Elber_toy_anchor"]: if load_state_file is not None: positions = None num_frames = 1 elif anchor.starting_positions is not None: positions_frames = np.array(anchor.starting_positions) \ * openmm.unit.nanometers positions = positions_frames[frame] num_frames = len(positions_frames) else: raise Exception( "No starting state or starting positions provided.") else: if anchor.amber_params is not None: prmtop_filename = os.path.join(building_directory, anchor.amber_params.prmtop_filename) prmtop = openmm_app.AmberPrmtopFile(prmtop_filename) #assert anchor.amber_params.pdb_coordinates_filename is not None if anchor.amber_params.pdb_coordinates_filename is None \ or anchor.amber_params.pdb_coordinates_filename == "": positions_obj = None positions = None sim_openmm.try_to_load_state = True else: pdb_coordinates_filename = os.path.join( building_directory, anchor.amber_params.pdb_coordinates_filename) positions_obj = openmm_app.PDBFile(pdb_coordinates_filename) #assert anchor.amber_params.box_vectors is not None box_vectors = anchor.amber_params.box_vectors topology = prmtop.topology elif anchor.forcefield_params is not None: forcefield_filenames = [] for forcefield_filename in \ anchor.forcefield_params.built_in_forcefield_filenames: forcefield_filenames.append(forcefield_filename) for forcefield_filename in \ anchor.forcefield_params.custom_forcefield_filenames: forcefield_filenames.append( os.path.join(building_directory, forcefield_filename)) print("anchor.forcefield_params.pdb_filename:", anchor.forcefield_params.pdb_coordinates_filename) pdb_filename = os.path.join( building_directory, anchor.forcefield_params.pdb_coordinates_filename) print("pdb_filename:", pdb_filename) pdb = openmm_app.PDBFile(pdb_filename) forcefield = openmm_app.ForceField(*forcefield_filenames) box_vectors = anchor.forcefield_params.box_vectors topology = pdb.topology positions_obj = pdb positions = None elif anchor.charmm_params is not None: raise Exception("Charmm systems not yet implemented") else: raise Exception("No Amber or Charmm input settings detected.") #assert box_vectors is not None, "No source of box vectors provided." nonbonded_method = model.openmm_settings.nonbonded_method.lower() if nonbonded_method == "pme": nonbondedMethod = openmm_app.PME elif nonbonded_method == "nocutoff": nonbondedMethod = openmm_app.NoCutoff elif nonbonded_method == "cutoffnonperiodic": nonbondedMethod = openmm_app.CutoffNonPeriodic elif nonbonded_method == "cutoffperiodic": nonbondedMethod = openmm_app.CutoffPeriodic elif nonbonded_method == "ewald": nonbondedMethod = openmm_app.Ewald else: raise Exception("nonbonded method not found: %s", model.openmm_settings.nonbonded_method) if model.openmm_settings.constraints is None: constraints_str = None else: constraints_str = model.openmm_settings.constraints if constraints_str is None: constraints = None elif constraints_str.lower() == "none": constraints = None elif constraints_str.lower() == "hbonds": constraints = openmm_app.HBonds elif constraints_str.lower() == "allbonds": constraints = openmm_app.AllBonds elif constraints_str.lower() == "hangles": constraints = openmm_app.HAngles else: raise Exception("constraints not found: %s", model.openmm_settings.constraints) if model.openmm_settings.hydrogenMass is not None: hydrogenMass = model.openmm_settings.hydrogenMass * openmm.unit.amu else: hydrogenMass = None rigidWater = model.openmm_settings.rigidWater if anchor.__class__.__name__ in ["MMVT_toy_anchor", "Elber_toy_anchor"]: system, topology = make_toy_system_object(model) else: if anchor.amber_params is not None: system = prmtop.createSystem( nonbondedMethod=nonbondedMethod, nonbondedCutoff=model.openmm_settings.nonbonded_cutoff, constraints=constraints, hydrogenMass=hydrogenMass, rigidWater=rigidWater) elif anchor.forcefield_params is not None: system = forcefield.createSystem( pdb.topology, nonbondedMethod=nonbondedMethod, nonbondedCutoff=model.openmm_settings.nonbonded_cutoff, constraints=constraints, hydrogenMass=hydrogenMass, rigidWater=rigidWater) elif anchor.charmm_params is not None: raise Exception("Charmm input settings not yet implemented") else: print("Settings for Amber or Charmm simulations not found") if positions_obj is not None: positions = positions_obj.getPositions(frame=frame) assert frame >= 0, "Cannot have negative frame index" assert frame < positions_obj.getNumFrames(), \ "Frame index {} out of range.".format(frame) num_frames = positions_obj.getNumFrames() return system, topology, positions, box_vectors, num_frames
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
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))
def create_openmm_system(sim_openmm, model, anchor): """ Create an openmm System() object. """ building_directory = os.path.join(model.anchor_rootdir, anchor.directory, anchor.building_directory) box_vectors = None if anchor.amber_params is not None: prmtop_filename = os.path.join(building_directory, anchor.amber_params.prmtop_filename) prmtop = openmm_app.AmberPrmtopFile(prmtop_filename) assert anchor.amber_params.pdb_coordinates_filename is not None pdb_coordinates_filename = os.path.join( building_directory, anchor.amber_params.pdb_coordinates_filename) positions = openmm_app.PDBFile(pdb_coordinates_filename) #assert anchor.amber_params.box_vectors is not None box_vectors = anchor.amber_params.box_vectors topology = prmtop elif anchor.forcefield_params is not None: forcefield_filenames = [] for forcefield_filename in \ anchor.forcefield_params.built_in_forcefield_filenames: forcefield_filenames.append(forcefield_filename) for forcefield_filename in \ anchor.forcefield_params.custom_forcefield_filenames: forcefield_filenames.append( os.path.join(building_directory, forcefield_filename)) pdb_filename = os.path.join(building_directory, anchor.forcefield_params.pdb_filename) pdb = openmm_app.PDBFile(pdb_filename) forcefield = openmm_app.ForceField(*forcefield_filenames) box_vectors = anchor.forcefield_params.box_vectors topology = pdb positions = pdb elif anchor.charmm_params is not None: raise Exception("Charmm systems not yet implemented") else: raise Exception("No Amber or Charmm input settings detected.") #assert box_vectors is not None, "No source of box vectors provided." nonbonded_method = model.openmm_settings.nonbonded_method.lower() if nonbonded_method == "pme": nonbondedMethod = openmm_app.PME elif nonbonded_method == "nocutoff": nonbondedMethod = openmm_app.NoCutoff elif nonbonded_method == "cutoffnonperiodic": nonbondedMethod = openmm_app.CutoffNonPeriodic elif nonbonded_method == "cutoffperiodic": nonbondedMethod = openmm_app.CutoffPeriodic elif nonbonded_method == "ewald": nonbondedMethod = openmm_app.Ewald else: raise Exception("nonbonded method not found: %s", model.openmm_settings.nonbonded_method) if model.openmm_settings.constraints is None: constraints_str = None else: constraints_str = model.openmm_settings.constraints if constraints_str is None: constraints = None elif constraints_str.lower() == "none": constraints = None elif constraints_str.lower() == "hbonds": constraints = openmm_app.HBonds elif constraints_str.lower() == "allbonds": constraints = openmm_app.AllBonds elif constraints_str.lower() == "hangles": constraints = openmm_app.HAngles else: raise Exception("constraints not found: %s", model.openmm_settings.constraints) if model.openmm_settings.hydrogenMass: hydrogenMass = model.openmm_settings.hydrogenMass * openmm.unit.amu else: hydrogenMass = model.openmm_settings.hydrogenMass rigidWater = model.openmm_settings.rigidWater if anchor.amber_params is not None: system = prmtop.createSystem( nonbondedMethod=nonbondedMethod, nonbondedCutoff=model.openmm_settings.nonbonded_cutoff, constraints=constraints, hydrogenMass=hydrogenMass, rigidWater=rigidWater) elif anchor.forcefield_params is not None: system = forcefield.createSystem( pdb.topology, nonbondedMethod=nonbondedMethod, nonbondedCutoff=model.openmm_settings.nonbonded_cutoff, constraints=constraints, hydrogenMass=hydrogenMass, rigidWater=rigidWater) elif anchor.charmm_params is not None: raise Exception("Charmm input settings not yet implemented") else: print("Settings for Amber or Charmm simulations not found") return system, topology, positions, box_vectors
molsys = msm.build.solvate( [molsys, { 'forcefield': 'AMBER14', 'water_model': 'TIP3P' }], 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,