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