def test_alchemy(): import os import simtk.unit as unit import simtk.openmm as openmm import numpy as np import simtk.openmm.app as app import alchemy # Create SystemBuilder objects. from openmmtools import testsystems receptor_pdb_filename = testsystems.get_data_filename("data/T4-lysozyme-L99A-implicit/receptor.pdb") ligand_mol2_filename = testsystems.get_data_filename("data/T4-lysozyme-L99A-implicit/ligand.tripos.mol2") receptor = BiopolymerPDBSystemBuilder(receptor_pdb_filename, pH=7.0) ligand = Mol2SystemBuilder(ligand_mol2_filename, charge=0) complex = ComplexSystemBuilder(ligand, receptor, remove_ligand_overlap=True) timestep = 2 * unit.femtoseconds # timestep temperature = 300.0 * unit.kelvin # simulation temperature collision_rate = 20.0 / unit.picoseconds # Langevin collision rate minimization_tolerance = 10.0 * unit.kilojoules_per_mole / unit.nanometer minimization_steps = 20 plat = "CPU" i=2 platform = openmm.Platform.getPlatformByName(plat) forcefield = app.ForceField systembuilders = [ligand, receptor, complex] receptor_atoms = complex.receptor_atoms ligand_atoms = complex.ligand_atoms factory = alchemy.AbsoluteAlchemicalFactory(systembuilders[i].system, ligand_atoms=ligand_atoms) protocol = factory.defaultComplexProtocolImplicit() systems = factory.createPerturbedSystems(protocol) integrator_interacting = openmm.LangevinIntegrator(temperature, collision_rate, timestep) #test an alchemical intermediate and an unperturbed system: fully_interacting = app.Simulation(systembuilders[i].topology, systems[0], integrator_interacting, platform=plat) fully_interacting.context.setPositions(systembuilders[i].positions) fully_interacting.minimizeEnergy(tolerance=10*unit.kilojoule_per_mole) fully_interacting.reporters.append(app.PDBReporter('fully_interacting.pdb', 10)) for j in range(10): logger.info(str(j)) fully_interacting.step(100) del fully_interacting for p in range(1, len(systems)): logger.info("now simulating " + str(p)) integrator_partialinteracting = openmm.LangevinIntegrator(temperature, collision_rate, timestep) partially_interacting = app.Simulation(systembuilders[i].topology, systems[p], integrator_partialinteracting, platform=plat) partially_interacting.context.setPositions(systembuilders[i].positions) partially_interacting.minimizeEnergy(tolerance=10*unit.kilojoule_per_mole) partially_interacting.reporters.append(app.PDBReporter('partial_interacting'+str(p)+'.pdb', 10)) for k in range(10): logger.info(str(k)) partially_interacting.step(100) del partially_interacting
def simulate(topology, system, positions, output_filename): import simtk.openmm.app as app timestep = 2.0 * unit.femtoseconds collision_rate = 20.0 / unit.picoseconds temperature = 298.0 * unit.kelvin integrator = openmm.LangevinIntegrator(temperature, collision_rate, timestep) niterations = 1000 nsteps = 500 simulation = app.Simulation(topology, system, integrator) simulation.context.setPositions(positions) reporter = app.PDBReporter(output_filename, nsteps) simulation.reporters.append(reporter) # Write first frame. state = simulation.context.getState(getPositions=True) reporter.report(simulation, state) print(" Minimizing...") simulation.minimizeEnergy(maxIterations=50) # Write first frame. state = simulation.context.getState(getPositions=True) reporter.report(simulation, state) print(" Simulating...") for iteration in range(niterations): print(" Iteration %d / %d" % (iteration, niterations)) simulation.step(nsteps) return
def equilibrate(self, ff_name, water_name): input_pdb_filename = self.get_initial_pdb_filename(ff_name, water_name) equil_pdb_filename = self.get_equil_pdb_filename(ff_name, water_name) equil_dcd_filename = self.get_equil_dcd_filename(ff_name, water_name) equil_protein_pdb_filename = self.get_equil_protein_pdb_filename( ff_name, water_name) utils.make_path(equil_pdb_filename) if os.path.exists(equil_pdb_filename): return ff = app.ForceField('%s.xml' % ff_name, '%s.xml' % water_name) pdb = app.PDBFile(input_pdb_filename) modeller = app.Modeller(pdb.topology, pdb.positions) modeller.addSolvent(ff, model=water_mapping[water_name], padding=self.padding, ionicStrength=self.ionic_strength) topology = modeller.getTopology() positions = modeller.getPositions() system = ff.createSystem(topology, nonbondedMethod=app.PME, nonbondedCutoff=self.cutoff, constraints=app.HBonds) integrator = mm.LangevinIntegrator(self.temperature, self.equil_friction, self.equil_timestep) system.addForce( mm.MonteCarloBarostat(self.pressure, self.temperature, self.barostat_frequency)) simulation = app.Simulation(topology, system, integrator) simulation.context.setPositions(positions) print('Minimizing.') simulation.minimizeEnergy() simulation.context.setVelocitiesToTemperature(self.temperature) print('Equilibrating.') simulation.reporters.append( app.PDBReporter(equil_pdb_filename, self.n_equil_steps - 1)) simulation.reporters.append( app.DCDReporter(equil_dcd_filename, self.equil_output_frequency)) simulation.step(self.n_equil_steps) del simulation del system traj = md.load(equil_dcd_filename, top=equil_pdb_filename)[-1] traj.save(equil_pdb_filename) top, bonds = traj.top.to_dataframe() atom_indices = top.index[top.chainID == 0].values traj.restrict_atoms(atom_indices) traj.save(equil_protein_pdb_filename)
def simulate(inpcrd_filenames, prmtop_filenames, path, niterations=10000, implicit=True, gpu=True, niters=0): """ The program simulates three systems: the ligand alone, protein alone, and complex. Input is a dict of files to the input coordinates (.inpcrd) and parameters (.prmtop) as well as the number of iterations. One iteration is one picosecond. Output is a dict of a list of the ennthalpies calculated using mmgbsa for each system. """ from simtk.openmm import app import simtk.openmm as mm from simtk import unit phases = inpcrd_filenames.keys() nsteps_per_iteration = 500 # 1 picosecond enthalpies = dict() for phase in phases: print("on phase", phase) enthalpies[phase] = np.zeros([niterations]) prmtop = app.AmberPrmtopFile(prmtop_filenames[phase]) inpcrd = app.AmberInpcrdFile(inpcrd_filenames[phase]) system = prmtop.createSystem(implicitSolvent=app.GBn2, nonbondedMethod=app.CutoffNonPeriodic, nonbondedCutoff=2.0*unit.nanometers, constraints=app.HBonds) integrator = mm.LangevinIntegrator(310.15*unit.kelvin, 1.0/unit.picoseconds, 2.0*unit.femtoseconds) integrator.setConstraintTolerance(0.00001) if gpu: platform = 'CUDA' else: platform = 'CPU' platform = mm.Platform.getPlatformByName(platform) if gpu: properties = {'CudaPrecision': 'mixed', 'CudaDeviceIndex' : '0'} else: properties = {} simulation = app.Simulation(prmtop.topology, system, integrator, platform, properties) simulation.context.setPositions(inpcrd.positions) if phase == 'com': simulation.reporters.append(app.PDBReporter(path + '/' + phase + '_output.pdb', 10000)) # Minimize & equilibrate simulation.minimizeEnergy() simulation.context.setVelocitiesToTemperature(310.15*unit.kelvin) simulation.step(100) # Run simulation for iteration in range(niterations): simulation.step(nsteps_per_iteration) state = simulation.context.getState(getEnergy=True) potential_energy = state.getPotentialEnergy() enthalpies[phase][iteration] = potential_energy.value_in_unit(unit.kilojoules_per_mole) del simulation del system del platform return enthalpies
def run(self, production_steps=200, start='ala2_1stFrame.pdb', production='ala2_production.pdb'): #### ?!!!!!!!!!!!!!!!! #from __future__ import print_function from simtk.openmm import app import simtk.openmm as mm from simtk import unit from sys import stdout nonbondedCutoff = 1.0 * unit.nanometers timestep = 2.0 * unit.femtoseconds temperature = 300 * unit.kelvin #save_frequency = 100 #Every 100 steps, save the trajectory save_frequency = 10 #Every 1 steps, save the trajectory pdb = app.PDBFile(start) forcefield = app.ForceField('amber99sb.xml', 'tip3p.xml') ala2_model = app.Modeller(pdb.topology, pdb.positions) #Hydrogens will be constrained after equilibrating system = forcefield.createSystem(ala2_model.topology, nonbondedMethod=app.PME, nonbondedCutoff=nonbondedCutoff, constraints=app.HBonds, rigidWater=True, ewaldErrorTolerance=0.0005) system.addForce(mm.MonteCarloBarostat( 1 * unit.bar, temperature, 100)) #Apply Monte Carlo Pressure changes in 100 timesteps integrator = mm.LangevinIntegrator(temperature, 1.0 / unit.picoseconds, timestep) integrator.setConstraintTolerance(0.00001) platform = mm.Platform.getPlatformByName('CPU') simulation = app.Simulation(ala2_model.topology, system, integrator, platform) simulation.context.setPositions(ala2_model.positions) simulation.context.setVelocitiesToTemperature(temperature) simulation.reporters.append(app.PDBReporter(production, save_frequency)) #simulation.reporters.append(app.StateDataReporter('stateReporter_constantPressure.txt', 1000, step=True, # totalEnergy=True, temperature=True, volume=True, progress=True, remainingTime=True, # speed=True, totalSteps=production_steps, separator='\t')) print('Running Production...') simulation.step(production_steps) print('Done!') import mdtraj as md trj = md.load(production) return trj
def testXTCreporter(self): output_PDB = "tests/data/test_xtcreporter.pdb" output_XTC = "tests/data/test_xtcreporter.xtc" top_PDB = "tests/data/top_xtcreporter.pdb" PLATFORM = mm.Platform_getPlatformByName(str('CPU')) prmtop = app.AmberPrmtopFile("tests/data/complex.prmtop") inpcrd = app.AmberInpcrdFile("tests/data/complex.inpcrd") system = prmtop.createSystem(nonbondedMethod=app.PME, nonbondedCutoff=9 * unit.angstroms, constraints=app.HBonds) system.addForce( mm.AndersenThermostat(300 * unit.kelvin, 1 / unit.picosecond)) integrator = mm.VerletIntegrator(2 * unit.femtoseconds) force = mm.CustomExternalForce(str("k*((x-x0)^2+(y-y0)^2+(z-z0)^2)")) force.addGlobalParameter( str("k"), 5.0 * unit.kilocalories_per_mole / unit.angstroms**2) force.addPerParticleParameter(str("x0")) force.addPerParticleParameter(str("y0")) force.addPerParticleParameter(str("z0")) for j, atom in enumerate(prmtop.topology.atoms()): if (atom.name in ('CA', 'C', 'N', 'O') and atom.residue.name != "HOH") or (atom.residue.name == "BEN" and atom.element.symbol != "H"): force.addParticle( j, inpcrd.positions[j].value_in_unit(unit.nanometers)) system.addForce(force) simulation = app.Simulation(prmtop.topology, system, integrator, PLATFORM) if inpcrd.boxVectors is not None: simulation.context.setPeriodicBoxVectors(*inpcrd.boxVectors) simulation.context.setPositions(inpcrd.positions) simulation.minimizeEnergy(maxIterations=10) print("Minimization ended") xtcReporter = XTCReporter(output_XTC, 1) simulation.reporters.append(app.PDBReporter(output_PDB, 1)) simulation.reporters.append(xtcReporter) simulation.step(10) # the XTCReporter does not close the file, so opening the file again # without exiting the function causes problems to the mdtraj reader xtcReporter.close() t_xtc = md.load(str(output_XTC), top=top_PDB) t_pdb = md.load(output_PDB) self.assertEqual(t_pdb.top, t_xtc.top) self.assertEqual(np.sum(np.abs(t_pdb.xyz - t_xtc.xyz) > 1e-3), 0) os.remove(output_PDB) os.remove(output_XTC)
normal_pairs.append(site_no) excep_pairs = np.reshape(excep_pairs, (len(excep_pairs) // 2, 2)) normal_pairs = np.reshape(normal_pairs, (len(normal_pairs) // 2, 2)) system = opls_lj(system) system.addForce(MonteCarloBarostat(1 * unit.bar, TEMP)) integrator = LangevinIntegrator(TEMP, 5 / unit.picosecond, 0.001 * unit.picoseconds) simulation = app.Simulation(modeller.topology, system, integrator) simulation.context.setPositions(modeller.positions) # simulation.context.computeVirtualSites() print('MINIMIZATION STARTED') simulation.minimizeEnergy() # print('Energy at Minima is %3.3f kcal/mol' % (energy._value * KcalPerKJ)) print('MINIMIZATION DONE') simulation.reporters.append(app.PDBReporter('output.pdb', 1000)) simulation.reporters.append( app.StateDataReporter('liquid.txt', 1000, step=True, potentialEnergy=True, temperature=True, density=True)) simulation.step(3000000) np_equ_pos = simulation.context.getState(getPositions=True).getPositions() app.PDBFile.writeFile(simulation.topology, np_equ_pos, open('NPT_EQ_FINAL.pdb', 'w')) state = simulation.context.getState(getEnergy=True) # print(state.getPotentialEnergy())
modeller = app.Modeller(pdb.topology, pdb.positions) modeller.addSolvent(ff, model=base_waters[water_name], padding=padding) topology = modeller.getTopology() positions = modeller.getPositions() system = ff.createSystem(topology, nonbondedMethod=app.PME, nonbondedCutoff=cutoff, constraints=app.HBonds) integrator = mm.LangevinIntegrator(temperature, friction, timestep) system.addForce( mm.MonteCarloBarostat(pressure, temperature, barostat_frequency)) simulation = app.Simulation(topology, system, integrator) simulation.context.setPositions(positions) print('Minimizing...') simulation.minimizeEnergy() simulation.context.setVelocitiesToTemperature(temperature) print('Running.') simulation.reporters.append( app.PDBReporter(output_pdb, equilibrate_output_frequency)) simulation.reporters.append( app.DCDReporter(output_dcd, equilibrate_output_frequency)) simulation.step(n_equil_steps) del simulation del system t = md.load(output_dcd, top=output_pdb) t.save(output_pdb)
platform = mm.Platform.getPlatformByName('CUDA') properties = {'CudaPrecision': 'mixed'} simulation = app.Simulation(pdb.topology, system, integrator, platform, properties) simulation.context.setPositions(pdb.positions) #print('Minimizing...') #simulation.minimizeEnergy() #simulation.context.setVelocitiesToTemperature(88.9407*unit.kelvin) #print('Equilibrating...') #simulation.step(1000) simulation.reporters.append(app.DCDReporter('argon_cluster.dcd', 10)) simulation.reporters.append(app.PDBReporter('argon_cluster_out.pdb', 100000)) simulation.reporters.append( app.StateDataReporter(stdout, 1000, step=True, time=True, potentialEnergy=True, kineticEnergy=True, temperature=True, volume=True, density=True, speed=True, separator='\t')) print('Running Production...') simulation.step(20000)
def production(system, topology, ensemble, temperature, timestep, collision_rate, n_steps, nsteps_out, firstframe_name, log_name, traj_name, final_state_name, n_equil_steps=1000, ini_positions=None, ini_state_name=None, use_switch=False, r_switch=None, pressure=None, minimize=False, cuda=False, gpu_idxs=None, more_reporters=[], dynamics="Langevin", use_platform=None): if use_switch: # set switching function on nonbonded forces for i in range(system.getNumForces()): force = system.getForce(i) if force.__repr__().find("NonbondedForce") > -1: force.setUseSwitchingFunction(True) if r_switch is None: raise IOError("Need to input r_switch if use_switch = True") else: force.setSwitchingDistance(r_switch/unit.nanometer) if ensemble == "NVE": integrator = omm.VerletIntegrator(timestep) else: if dynamics == "Langevin": integrator = omm.LangevinIntegrator(temperature, collision_rate, timestep) elif dynamics == "Brownian": integrator = omm.BrownianIntegrator(temperature, collision_rate, timestep) else: raise IOError("dynamics must be Langevin or Brownian") if ensemble == "NPT": if pressure is None: raise ValueError("If ensemble is NPT need to specficy pressure") system.addForce(omm.MonteCarloBarostat(pressure, temperature)) if not use_platform is None: if use_platform == "CUDA": platform = omm.Platform.getPlatformByName('CUDA') if gpu_idxs is None: properties = {'DeviceIndex': '0'} else: properties = {'DeviceIndex': gpu_idxs} simulation = app.Simulation(topology, system, integrator, platform, properties) elif use_platform == "CPU": platform = omm.Platform.getPlatformByName("CPU") simulation = app.Simulation(topology, system, integrator, platform) else: raise ValueError("use_platform needs to be CUDA or CPU or not specfied") else: simulation = app.Simulation(topology, system, integrator) if not ini_positions is None: # set initial positions and box dimensions simulation.context.setPositions(ini_positions) #simulation.context.setPeriodicBoxVectors() elif not ini_position_file is None: simulation.loadState(ini_state_name) else: raise ValueError("Need to specify initial positions somehow!") if minimize: simulation.minimizeEnergy(tolerance=energy_minimization_tol) # initial equilibration simulation.step(n_equil_steps) # save the first frame minimized simulation.reporters.append(app.PDBReporter(firstframe_name, 1)) simulation.step(1) simulation.reporters.pop(0) # record coordinates simulation.reporters.append(app.DCDReporter(traj_name, nsteps_out)) simulation.reporters.append(app.StateDataReporter(log_name, nsteps_out, step=True, potentialEnergy=True, kineticEnergy=True, temperature=True, density=True, volume=True)) # add user-defined reporters for e.g. forces or velocities if len(more_reporters) > 0: for i in range(len(more_reporters)): simulation.reporters.append(more_reporters[i]) # run simulation! simulation.step(n_steps) # save final state. positions, box vectors. simulation.saveState(final_state_name)
pdb = app.PDBFile(pdb_filename) modeller = app.Modeller(pdb.topology, pdb.positions) modeller.addSolvent(ff, model=base_waters[water_name], padding=padding) topology = modeller.getTopology() positions = modeller.getPositions() system = ff.createSystem(topology, nonbondedMethod=app.PME, nonbondedCutoff=cutoff, constraints=app.HBonds) integrator = mm.LangevinIntegrator(temperature, friction, timestep) system.addForce(mm.MonteCarloBarostat(pressure, temperature, barostat_frequency)) simulation = app.Simulation(topology, system, integrator) simulation.context.setPositions(positions) print('Minimizing...') simulation.minimizeEnergy() simulation.context.setVelocitiesToTemperature(temperature) print('Running.') simulation.reporters.append(app.PDBReporter(output_pdb, equilibrate_output_frequency)) simulation.reporters.append(app.DCDReporter(output_dcd, equilibrate_output_frequency)) simulation.step(n_equil_steps) del simulation del system t = md.load(output_dcd, top=output_pdb) t.save(output_pdb)
def main( paramfile='params.in', overrides={}, quiktest=False, deviceid=None, progressreport=True, soluteRes=[0], lambdaLJ=1.0, lambdaQ=1.0 ): #simtime=2.0, T=298.0, NPT=True, LJcut=10.0, tail=True, useLJPME=False, rigidH2O=True, device=0, quiktest=False): # === PARSE === # args = mdparse.SimulationOptions(paramfile, overrides) # Files gromacs.GROMACS_TOPDIR = args.topdir top_file = args.topfile box_file = args.grofile defines = {} cont = args.cont args.force_active('chkxml', val='chk_{:02n}.xml'.format(cont), msg='first one') args.force_active('chkpdb', val='chk_{:02n}.pdb'.format(cont), msg='first one') if cont > 0: args.force_active('incoord', val='chk_{:02n}.xml'.format(cont - 1), msg='continuing') args.force_active('outpdb', val='output_{:02n}.pdb'.format(cont), msg='continuing') args.force_active('outnetcdf', val='output_{:02n}.nc'.format(cont), msg='continuing') args.force_active('logfile', val='thermo.log_{:02n}'.format(cont), msg='continuing') args.force_active('outdcd', val='output_{:02n}.dcd'.format(cont), msg='continuing') incoord = args.incoord out_pdb = args.outpdb out_netcdf = args.outnetcdf out_dcd = args.outdcd molecTopology = 'topology.pdb' out_nowater = 'output_nowater.nc' out_nowater_dcd = 'output_nowater.dcd' logfile = args.logfile checkpointxml = args.chkxml checkpointpdb = args.chkpdb checkpointchk = 'chk_{:02n}.chk'.format(cont) # Parameters #Temp = args.temperature #K #Pressure = 1 #bar #barostatfreq = 25 #time steps #fric = args.collision_rate #1/ps dt = args.timestep #fs if args.use_fs_interval: reportfreq = int(args.report_interval / dt) netcdffreq = int(args.netcdf_report_interval / dt) #5e4 dcdfreq = int(args.dcd_report_interval / dt) pdbfreq = int(args.pdb_report_interval / dt) checkfreq = int(args.checkpoint_interval / dt) #simtime = int( simtime ) #nanoseconds; make sure division is whole... no remainders... blocksteps = int(args.block_interval / dt) #1e6, steps per block of simulation nblocks = args.nblocks #aiming for 1 block is 1ns else: reportfreq = args.report_interval netcdffreq = args.netcdf_report_interval dcdfreq = args.dcd_report_interval pdbfreq = args.pdb_report_interval checkfreq = args.checkpoint_interval blocksteps = args.block_interval nblocks = args.nblocks if quiktest == True: reportfreq = 1 blocksteps = 10 nblocks = 2 # === Start Making System === # start = time.time() top = gromacs.GromacsTopologyFile(top_file, defines=defines) gro = gromacs.GromacsGroFile.parse(box_file) top.box = gro.box logger.info("Took {}s to create topology".format(time.time() - start)) print(top) constr = { None: None, "None": None, "HBonds": app.HBonds, "HAngles": app.HAngles, "AllBonds": app.AllBonds }[args.constraints] start = time.time() system = top.createSystem(nonbondedMethod=app.PME, ewaldErrorTolerance=args.ewald_error_tolerance, nonbondedCutoff=args.nonbonded_cutoff * u.nanometers, rigidWater=args.rigid_water, constraints=constr) logger.info("Took {}s to create system".format(time.time() - start)) nbm = { "NoCutoff": mm.NonbondedForce.NoCutoff, "CutoffNonPeriodic": mm.NonbondedForce.CutoffNonPeriodic, "Ewald": mm.NonbondedForce.Ewald, "PME": mm.NonbondedForce.PME, "LJPME": mm.NonbondedForce.LJPME }[args.nonbonded_method] ftmp = [ f for ii, f in enumerate(system.getForces()) if isinstance(f, mm.NonbondedForce) ] fnb = ftmp[0] fnb.setNonbondedMethod(nbm) logger.info("Nonbonded method ({},{})".format(args.nonbonded_method, fnb.getNonbondedMethod())) if (not args.dispersion_correction) or (args.nonbonded_method == "LJPME"): logger.info("Turning off tail correction...") fnb.setUseDispersionCorrection(False) logger.info("Check dispersion correction flag: {}".format( fnb.getUseDispersionCorrection())) # --- execute custom forcefield code --- """ if customff: logger.info("Using customff: [{}]".format(customff)) with open(customff,'r') as f: ffcode = f.read() exec(ffcode,globals(),locals()) #python 3, need to pass in globals to allow exec to modify them (i.e. the system object) #print(sys.path) #sys.path.insert(1,'.') #exec("import {}".format(".".join(customff.split(".")[:-1]))) else: logger.info("--- No custom ff code provided ---") fExts=[f for f in system.getForces() if isinstance(f,mm.CustomExternalForce)] logger.info("External forces added: {}".format(fExts)) """ soluteIndices = [] soluteResidues = soluteRes #list of residues to alchemify. modified s.t. soluteRes is already a list #parmed gromacs topology for ir, res in enumerate(top.residues): if ir in soluteResidues: for atom in res.atoms: soluteIndices.append(atom.idx) print("Solute residue: {}".format( [top.residues[ir].atoms for ir in soluteResidues])) print("Solute Indices: {}".format(soluteIndices)) #if using openmm topology. unfortunately don't know how to convert from parmed to openmm#: #topology = parmed.openmm.load_topology(top.topology) #print(type(topology)) #for ir,res in topology.residues(): # if ir in soluteResidues: # for atom in res.atoms: # soluteIndices.append(atom.index) alch = alchemifyIons.alchemist(system, lambdaLJ, lambdaQ) alch.setupSolute(soluteIndices) print(system.getForces()) # === Integrator, Barostat, Additional Constraints === # integrator = set_thermo(system, args) if not hasattr(args, 'constraints') or (str(args.constraints) == "None" and args.rigidwater == False): args.deactivate('constraint_tolerance', "There are no constraints in this system") else: logger.info("Setting constraint tolerance to %.3e" % args.constraint_tolerance) integrator.setConstraintTolerance(args.constraint_tolerance) # === Make Platform === # logger.info("Setting Platform to %s" % str(args.platform)) try: platform = mm.Platform.getPlatformByName(args.platform) except: logger.info( "Warning: %s platform not found, going to Reference platform \x1b[91m(slow)\x1b[0m" % args.platform) args.force_active('platform', "Reference", "The %s platform was not found." % args.platform) platform = mm.Platform.getPlatformByName("Reference") if deviceid is not None or deviceid >= 0: args.force_active('device', deviceid, msg="Using cmdline-input deviceid") if 'device' in args.ActiveOptions and (platform.getName() == "OpenCL" or platform.getName() == "CUDA"): device = str(args.device) # The device may be set using an environment variable or the input file. #if 'CUDA_DEVICE' in os.environ.keys(): #os.environ.has_key('CUDA_DEVICE'): # device = os.environ.get('CUDA_DEVICE',str(args.device)) #elif 'CUDA_DEVICE_INDEX' in os.environ.keys(): #os.environ.has_key('CUDA_DEVICE_INDEX'): # device = os.environ.get('CUDA_DEVICE_INDEX',str(args.device)) #else: # device = str(args.device) if device != None: logger.info("Setting Device to %s" % str(device)) #platform.setPropertyDefaultValue("CudaDevice", device) if platform.getName() == "CUDA": platform.setPropertyDefaultValue("CudaDeviceIndex", device) elif platform.getName() == "OpenCL": print("set OpenCL device to {}".format(device)) platform.setPropertyDefaultValue("OpenCLDeviceIndex", device) else: logger.info("Using the default (fastest) device") else: logger.info( "Using the default (fastest) device, or not using CUDA nor OpenCL") if "Precision" in platform.getPropertyNames() and ( platform.getName() == "OpenCL" or platform.getName() == "CUDA"): platform.setPropertyDefaultValue("Precision", args.cuda_precision) else: logger.info("Not setting precision") args.deactivate( "cuda_precision", msg="Platform does not support setting cuda_precision.") # === Create Simulation === # logger.info("Creating the Simulation object") start = time.time() # Get the number of forces and set each force to a different force group number. nfrc = system.getNumForces() if args.integrator != 'mtsvvvr': for i in range(nfrc): system.getForce(i).setForceGroup(i) ''' for i in range(nfrc): # Set vdW switching function manually. f = system.getForce(i) if f.__class__.__name__ == 'NonbondedForce': #f.setUseSwitchingFunction(False) #f.setSwitchingDistance(1.0*u.nanometers) if 'vdw_switch' in args.ActiveOptions and args.vdw_switch: f.setUseSwitchingFunction(True) f.setSwitchingDistance(args.switch_distance) ''' #create simulation object if args.platform != None: simulation = app.Simulation(top.topology, system, integrator, platform) else: simulation = app.Simulation(top.topology, system, integrator) topomm = mdtraj.Topology.from_openmm(simulation.topology) logger.info("System topology: {}".format(topomm)) #print platform we're using mdparse.printcool_dictionary( { i: simulation.context.getPlatform().getPropertyValue( simulation.context, i) for i in simulation.context.getPlatform().getPropertyNames() }, title="Platform %s has properties:" % simulation.context.getPlatform().getName()) logger.info("--== PME parameters ==--") ftmp = [ f for ii, f in enumerate(simulation.system.getForces()) if isinstance(f, mm.NonbondedForce) ] fnb = ftmp[0] if fnb.getNonbondedMethod() == 4: #check for PME PMEparam = fnb.getPMEParametersInContext(simulation.context) logger.info(fnb.getPMEParametersInContext(simulation.context)) if fnb.getNonbondedMethod() == 5: #check for LJPME PMEparam = fnb.getLJPMEParametersInContext(simulation.context) logger.info(fnb.getLJPMEParametersInContext(simulation.context)) #nmeshx = int(PMEparam[1]*1.5) #nmeshy = int(PMEparam[2]*1.5) #nmeshz = int(PMEparam[3]*1.5) #fnb.setPMEParameters(PMEparam[0],nmeshx,nmeshy,nmeshz) #logger.info(fnb.getPMEParametersInContext(simulation.context)) # Print out some more information about the system logger.info("--== System Information ==--") logger.info("Number of particles : %i" % simulation.context.getSystem().getNumParticles()) logger.info("Number of constraints : %i" % simulation.context.getSystem().getNumConstraints()) for f in simulation.context.getSystem().getForces(): if f.__class__.__name__ == 'NonbondedForce': method_names = [ "NoCutoff", "CutoffNonPeriodic", "CutoffPeriodic", "Ewald", "PME", "LJPME" ] logger.info("Nonbonded method : %s" % method_names[f.getNonbondedMethod()]) logger.info("Number of particles : %i" % f.getNumParticles()) logger.info("Number of exceptions : %i" % f.getNumExceptions()) if f.getNonbondedMethod() > 0: logger.info("Nonbonded cutoff : %.3f nm" % (f.getCutoffDistance() / u.nanometer)) if f.getNonbondedMethod() >= 3: logger.info("Ewald error tolerance : %.3e" % (f.getEwaldErrorTolerance())) logger.info("LJ switching function : %i" % f.getUseSwitchingFunction()) if f.getUseSwitchingFunction(): logger.info("LJ switching distance : %.3f nm" % (f.getSwitchingDistance() / u.nanometer)) # Print the sample input file here. for line in args.record(): print(line) print("Took {}s to make and setup simulation object".format(time.time() - start)) #============================# #| Initialize & Eq/Warm-Up |# #============================# p = simulation.context.getPlatform() if p.getName() == "CUDA" or p.getName() == "OpenCL": print("simulation platform: {}".format(p.getName())) print(p.getPropertyNames()) print(p.getPropertyValue(simulation.context, 'DeviceName')) print("Device Index: {}".format( p.getPropertyValue(simulation.context, 'DeviceIndex'))) if os.path.exists(args.restart_filename) and args.read_restart: print("Restarting simulation from the restart file.") print("Currently is filler") else: # Set initial positions. if incoord.split(".")[-1] == "pdb": pdb = app.PDBFile(incoord) #pmd.load_file(incoord) simulation.context.setPositions(pdb.positions) print('Set positions from pdb, {}'.format(incoord)) molecTopology = incoord elif incoord.split(".")[-1] == "xyz": traj = mdtraj.load(incoord, top=mdtraj.Topology.from_openmm( simulation.topology)) simulation.context.setPositions(traj.openmm_positions(0)) elif incoord.split(".")[-1] == "xml": simulation.loadState(incoord) print('Set positions from xml, {}'.format(incoord)) else: logger.info("Error, can't handle input coordinate filetype") if args.constraint_tolerance > 0.0: simulation.context.applyConstraints( args.constraint_tolerance ) #applies constraints in current frame. logger.info("Initial potential energy is: {}".format( simulation.context.getState(getEnergy=True).getPotentialEnergy())) if args.integrator != 'mtsvvvr': eda = mdparse.EnergyDecomposition(simulation) eda_kcal = OrderedDict([(i, "%10.4f" % (j / 4.184)) for i, j in eda.items()]) mdparse.printcool_dictionary( eda_kcal, title="Energy Decomposition (kcal/mol)") # Minimize the energy. if args.minimize: logger.info("Minimization start, the energy is: {}".format( simulation.context.getState( getEnergy=True).getPotentialEnergy())) simulation.minimizeEnergy() logger.info("Minimization done, the energy is {}".format( simulation.context.getState( getEnergy=True).getPotentialEnergy())) positions = simulation.context.getState( getPositions=True).getPositions() logger.info("Minimized geometry is written to 'minimized.pdb'") app.PDBFile.writeModel(simulation.topology, positions, open('minimized.pdb', 'w')) # Assign velocities. if args.gentemp > 0.0: logger.info( "Generating velocities corresponding to Maxwell distribution at %.2f K" % args.gentemp) simulation.context.setVelocitiesToTemperature(args.gentemp * u.kelvin) # Equilibrate. logger.info("--== Equilibrating (%i steps, %.2f ps) ==--" % (args.equilibrate, args.equilibrate * args.timestep * u.femtosecond / u.picosecond)) if args.report_interval > 0: # Append the ProgressReport for equilibration run. simulation.reporters.append( mdparse.ProgressReport(args, sys.stdout, args.report_interval, simulation, args.equilibrate)) simulation.reporters[-1].t00 = time.time() logger.info("Progress will be reported every %i steps" % args.report_interval) # This command actually does all of the computation. simulation.step(args.equilibrate) if args.report_interval > 0: # Get rid of the ProgressReport because we'll make a new one. simulation.reporters.pop() first = args.equilibrate #============================# #| Production MD simulation |# #============================# logger.info( "--== Production (%i blocks, %i steps total, %.2f ps total) ==--" % (nblocks, nblocks * blocksteps, nblocks * blocksteps * args.timestep * u.femtosecond / u.picosecond)) #===========================================# #| Add reporters for production simulation |# #===========================================# print("===== registering reporters and runnning =====") if args.report_interval > 0: logger.info("Thermo and Progress will be reported every %i steps" % args.report_interval) #simulation.reporters.append(ProgressReport(sys.stdout, args.report_interval, simulation, args.production, first)) mdparse.bak(logfile) simulation.reporters.append( app.StateDataReporter(logfile, reportfreq, step=True, potentialEnergy=True, kineticEnergy=True, temperature=True, volume=True, density=True, speed=True)) #simulation.reporters.append(app.StateDataReporter(stdout, reportfreq, step=True, # potentialEnergy=True, kineticEnergy=True, temperature=True, volume=True, density=True, speed=True)) if progressreport: simulation.reporters.append( mdparse.ProgressReport(args, sys.stdout, reportfreq, simulation, nblocks * blocksteps, first=args.equilibrate)) Prog = simulation.reporters[-1] if args.pdb_report_interval > 0: mdparse.bak(out_pdb) logger.info("PDB Reporter will write to %s every %i steps" % (out_pdb, pdbfreq)) simulation.reporters.append(app.PDBReporter(out_pdb, pdbfreq)) if args.netcdf_report_interval > 0: mdparse.bak(out_netcdf) logger.info("netcdf Reporter will write to %s every %i steps" % (out_netcdf, netcdffreq)) simulation.reporters.append( NetCDFReporter(out_netcdf, netcdffreq, crds=True, vels=args.netcdf_vels, frcs=args.netcdf_frcs)) ''' mdparse.bak(out_nowater) logger.info("netcdf Reporter will write a no-water coordinate file %s every %i steps" %(out_nowater,netcdffreq)) #toptraj = mdtraj.load(molecTopology) #top = toptraj.top top = mdtraj.Topology.from_openmm(simulation.topology) sel = [atom.index for residue in top.residues for atom in residue.atoms if (residue.name!="SOL") and (residue.name!="HOH")] simulation.reporters.append(mdtraj.reporters.NetCDFReporter(out_nowater, netcdffreq, atomSubset = sel)) ''' if args.dcd_report_interval > 0: mdparse.bak(out_dcd) logger.info("dcd Reporter will write to %s every %i steps" % (out_dcd, dcdfreq)) simulation.reporters.append( mdtraj.reporters.DCDReporter(out_dcd, dcdfreq)) ''' mdparse.bak(out_nowater_dcd) logger.info("dcd Reporter will write a no-water coordinate file %s every %i steps" %(out_nowater_dcd, dcdfreq)) #toptraj = mdtraj.load(molecTopology) #top = toptraj.top top = mdtraj.Topology.from_openmm(simulation.topology) sel = [atom.index for residue in top.residues for atom in residue.atoms if (residue.name!="SOL") and (residue.name!="HOH")] simulation.reporters.append(mdtraj.reporters.DCDReporter(out_nowater_dcd, dcdfreq, atomSubset = sel)) #write out a nowater.pdb as topology input top2 = top.subset(sel) xyz0 = np.zeros([len(sel),3]) traj2 = mdtraj.Trajectory(xyz0,topology=top2) traj2.save('output_nowater_top.pdb') top2omm = top2.to_openmm() ''' if args.checkpoint_interval > 0: simulation.reporters.append( app.CheckpointReporter(checkpointchk, checkfreq)) #simulation.reporters.append(app.DCDReporter(out_dcd, writefreq)) #simulation.reporters.append(mdtraj.reporters.HDF5Reporter(out_hdf5, writefreq, velocities=True)) #============================# #| Finally Run! |# #============================# t1 = time.time() if progressreport: Prog.t00 = t1 #simulation.step(args.production) for iblock in range(0, nblocks): logger.info("Starting block {}".format(iblock)) start = time.time() simulation.step(blocksteps) end = time.time() logger.info('Took {} seconds for block {}'.format(end - start, iblock)) simulation.saveState(checkpointxml) positions = simulation.context.getState( getPositions=True, enforcePeriodicBox=True).getPositions() app.PDBFile.writeFile(simulation.topology, positions, open(checkpointpdb, 'w'))
def run_openmm_simulation(sim, n_steps=500000): sim.minimizeEnergy(maxIterations=50000) sim.step(n_steps) pdbreporter = app.PDBReporter('final_frame.pdb', 1) pdbreporter.report(sim, sim.context.getState(-1))
system.addForce(mm.MonteCarloBarostat( 1 * unit.bar, temperature, 100)) #Apply Monte Carlo Pressure changes in 100 timesteps integrator = mm.LangevinIntegrator(temperature, 1.0 / unit.picoseconds, timestep) integrator.setConstraintTolerance(0.00001) platform = mm.Platform.getPlatformByName('CPU') simulation = app.Simulation(ala2_model.topology, system, integrator, platform) simulation.context.setPositions(ala2_model.positions) simulation.context.setVelocitiesToTemperature(temperature) simulation.reporters.append( app.PDBReporter('ala2_production.pdb', save_frequency)) simulation.reporters.append( app.StateDataReporter('stateReporter_constantPressure.txt', 1000, step=True, totalEnergy=True, temperature=True, volume=True, progress=True, remainingTime=True, speed=True, totalSteps=production_steps, separator='\t')) print('Running Production...') simulation.step(production_steps)
which_water = 'tip3p-fb.xml' ff = app.ForceField(which_forcefield, which_water) pdb = app.PDBFile("./%s_fixed.pdb" % code) output_pdb = "./equil.pdb" modeller = app.Modeller(pdb.topology, pdb.positions) modeller.addSolvent(ff, padding=padding, ionicStrength=ionicStrength) topology = modeller.topology positions = modeller.positions system = ff.createSystem(topology, nonbondedMethod=app.PME, nonbondedCutoff=cutoff, constraints=app.HBonds) integrator = mm.LangevinIntegrator(temperature, friction, equilibration_timestep) system.addForce( mm.MonteCarloBarostat(pressure, temperature, barostat_frequency)) simulation = app.Simulation(topology, system, integrator) simulation.context.setPositions(positions) print('Minimizing...') simulation.minimizeEnergy() simulation.context.setVelocitiesToTemperature(temperature) print('Running.') simulation.reporters.append(app.PDBReporter(output_pdb, n_equil_steps - 1)) simulation.step(n_equil_steps)
"Ekin_Amber(kJ/mol)", "SBM_Q", "Q", "dev" ]) + "\n") progress_file.write(",".join( map(str, [ simulation.currentStep, epot_sbm, epot_amber, ekin_sbm, ekin_amber, sbm_Q, best_hummer_q(md.load(pdbname), native)[-1], deviation ])) + "\n") #print ("Step:%i, Epot(SBM/Amber): %s/%s,SBM_Q:%f, Q:%f, dev:%f"%(0,epot_sbm,epot_amber, sbm_Q , best_hummer_q(md.load(pdbname), native), deviation) ) simulation.context.setVelocitiesToTemperature(temperature * unit.kelvin) if verbose: print('Equilibrating...') simulation.step(1000) pdb_reporter = app.PDBReporter(pdbname[:-4] + '_trajectory%s.pdb' % sim_string, 5000) simulation.reporters.append(pdb_reporter) simulation.reporters.append( app.StateDataReporter(pdbname[:-4] + "_data%s.csv" % sim_string, 10000, step=True, potentialEnergy=True, kineticEnergy=True, temperature=True, volume=True, density=True, progress=True, remainingTime=True, speed=True, totalSteps=20000000,
def main(targetVol, tol=1e-4, paramfile='params.in', overrides={}, quiktest=False, deviceid=None, progressreport=True): #simtime=2.0, T=298.0, NPT=True, LJcut=10.0, tail=True, useLJPME=False, rigidH2O=True, device=0, quiktest=False): logger.info("This protocol runs NPT until a target volume is achieved, with given tolerance.") logger.info("Make sure you prescribe pressure and barsostat freq!") # === PARSE === # args = mdparse.SimulationOptions(paramfile, overrides) # === forced parameters special to this protocol === # args.force_active('cont', val=-1, msg="targetVolume protocol, don't use continue flag") args.force_active('equilibrate', val=args.nbarostat*5, msg="targetVolume protocol, just minor warmup") args.force_active('grofile', val="targetVolume.gro", msg="default input gro file with box size for targetVolumeProtocol") if 'incoord' in overrides: args.force_active('incoord', val=overrides['incoord'], msg="user-supplied incoord overrides that in parameter file") if 'pressure' in overrides: args.force_active('pressure', val=overrides['pressure'], msg="user-supplied pressure overrides that in parameter file") if 'nbarostat' in overrides: args.force_active('nbarostat', val=overrides['nbarostat'], msg="user-supplied nbarostat overrides that in parameter file") if args.pressure <= 0.0: logger.info("WARNING: parameter file did not have valid pressure, using default 1.0 bar and nbarostat=25") args.force_active('pressure', val=1.0, msg="Parameter file did not have valid pressure, using default 1.0bar") args.force_active('nbarostat', val=25, msg="Parameter file did not have valid nbarostat, using default 25") elif args.nbarostat <= 0: logger.info("WARNING: parameter file has invalid nbarostat, using default 25") args.force_active('nbarostat', val=25, msg="Parameter file did not have valid nbarostat, using default 25") if args.temperature <= 0.0: logger.info("NPT must have valid thermostat, but temperature not supplied, using default 298K") args.force_active('nbarostat', val=298.0, msg="NPT needs thermostat, but temperature invalid. using default 298.0K") args.force_active('use_fs_interval', val=False, msg="target Vol protocol based on nbarostat time step intervals") args.force_active('report_interval', val=10*args.nbarostat, msg="target Vol protocol based on nbarostat time step intervals") args.force_active('pdb_report_interval', val=0, msg="don't keep track of pdb") args.force_active('netcdf_report_interval', val=0, msg="don't keep trajectory") args.force_active('checkpoint_interval', val=0, msg="don't write .chk files") args.force_active('block_interval', val=10*args.nbarostat, msg="target Vol protocol based on nbarostat intervals") args.force_active('nblocks', val = 5e4, msg="cap the number of barostat moves to try") args.deactivate('outpdb', "not writing pdb trajectory") args.deactivate('outnetcdf', "not writing netcdf trajectory") #args.force_active('outnetcdf', val="targetVolume.nc", "target Volume trajectory writes") args.force_active('logfile', val="targetVolume.log", msg="target Volume protocol log") args.force_active('chkxml', val="targetVolume.xml", msg="target Volume protocol xml") args.force_active('chkpdb', val="targetVolume.pdb", msg="target Volume protocol pdb") # === Files === # gromacs.GROMACS_TOPDIR = args.topdir top_file = args.topfile box_file = args.grofile defines = {} cont = args.cont ''' args.force_active('chkxml',val='chk_{:02n}.xml'.format(cont),msg='first one') args.force_active('chkpdb',val='chk_{:02n}.pdb'.format(cont),msg='first one') if cont > 0: args.force_active('incoord',val='chk_{:02n}.xml'.format(cont-1),msg='continuing') args.force_active('outpdb',val='output_{:02n}.pdb'.format(cont),msg='continuing') args.force_active('outnetcdf',val='output_{:02n}.nc'.format(cont),msg='continuing') args.force_active('logfile',val='thermo.log_{:02n}'.format(cont),msg='continuing') ''' incoord = args.incoord out_pdb = args.outpdb out_netcdf = args.outnetcdf logfile = args.logfile checkpointxml = args.chkxml checkpointpdb = args.chkpdb checkpointchk = 'chk_{:02n}.chk'.format(cont) # Parameters #Temp = args.temperature #K #Pressure = 1 #bar #barostatfreq = 25 #time steps #fric = args.collision_rate #1/ps dt = args.timestep #fs if args.use_fs_interval: reportfreq = int(args.report_interval/dt) netcdffreq = int(args.netcdf_report_interval/dt) #5e4 pdbfreq = int(args.pdb_report_interval/dt) checkfreq = int(args.checkpoint_interval/dt) #simtime = int( simtime ) #nanoseconds; make sure division is whole... no remainders... blocksteps = int(args.block_interval/dt) #1e6, steps per block of simulation nblocks = args.nblocks #aiming for 1 block is 1ns else: reportfreq = args.report_interval netcdffreq = args.netcdf_report_interval pdbfreq = args.pdb_report_interval checkfreq = args.checkpoint_interval blocksteps = args.block_interval nblocks = args.nblocks if quiktest==True: reportfreq = 1 blocksteps = 10 nblocks = 2 # === Start Making System === # top = gromacs.GromacsTopologyFile(top_file, defines=defines) gro = gromacs.GromacsGroFile.parse(box_file) top.box = gro.box constr = {None: None, "None":None,"HBonds":app.HBonds,"HAngles":app.HAngles,"AllBonds":app.AllBonds}[args.constraints] system = top.createSystem(nonbondedMethod=app.PME, ewaldErrorTolerance = args.ewald_error_tolerance, nonbondedCutoff=args.nonbonded_cutoff*u.nanometers, rigidWater = args.rigid_water, constraints = constr) nbm = {"NoCutoff":mm.NonbondedForce.NoCutoff, "CutoffNonPeriodic":mm.NonbondedForce.CutoffNonPeriodic, "Ewald":mm.NonbondedForce.Ewald, "PME":mm.NonbondedForce.PME, "LJPME":mm.NonbondedForce.LJPME}[args.nonbonded_method] ftmp = [f for ii, f in enumerate(system.getForces()) if isinstance(f,mm.NonbondedForce)] fnb = ftmp[0] fnb.setNonbondedMethod(nbm) logger.info("Nonbonded method ({},{})".format(args.nonbonded_method, fnb.getNonbondedMethod()) ) if (not args.dispersion_correction) or (args.nonbonded_method=="LJPME"): logger.info("Turning off tail correction...") fnb.setUseDispersionCorrection(False) logger.info("Check dispersion flag: {}".format(fnb.getUseDispersionCorrection()) ) # === Integrator, Barostat, Additional Constraints === # integrator = set_thermo(system,args) if not hasattr(args,'constraints') or (str(args.constraints) == "None" and args.rigidwater == False): args.deactivate('constraint_tolerance',"There are no constraints in this system") else: logger.info("Setting constraint tolerance to %.3e" % args.constraint_tolerance) integrator.setConstraintTolerance(args.constraint_tolerance) # === Make Platform === # logger.info("Setting Platform to %s" % str(args.platform)) try: platform = mm.Platform.getPlatformByName(args.platform) except: logger.info("Warning: %s platform not found, going to Reference platform \x1b[91m(slow)\x1b[0m" % args.platform) args.force_active('platform',"Reference","The %s platform was not found." % args.platform) platform = mm.Platform.getPlatformByName("Reference") if deviceid is not None or deviceid>=0: args.force_active('device',deviceid,msg="Using cmdline-input deviceid") if 'device' in args.ActiveOptions and (platform.getName()=="OpenCL" or platform.getName()=="CUDA"): device = str(args.device) # The device may be set using an environment variable or the input file. #if 'CUDA_DEVICE' in os.environ.keys(): #os.environ.has_key('CUDA_DEVICE'): # device = os.environ.get('CUDA_DEVICE',str(args.device)) #elif 'CUDA_DEVICE_INDEX' in os.environ.keys(): #os.environ.has_key('CUDA_DEVICE_INDEX'): # device = os.environ.get('CUDA_DEVICE_INDEX',str(args.device)) #else: # device = str(args.device) if device != None: logger.info("Setting Device to %s" % str(device)) #platform.setPropertyDefaultValue("CudaDevice", device) platform.setPropertyDefaultValue("CudaDeviceIndex", device) #platform.setPropertyDefaultValue("OpenCLDeviceIndex", device) else: logger.info("Using the default (fastest) device") else: logger.info("Using the default (fastest) device, or not using CUDA nor OpenCL") if "CudaPrecision" in platform.getPropertyNames() and (platform.getName()=="OpenCL" or platform.getName()=="CUDA"): platform.setPropertyDefaultValue("CudaPrecision", args.cuda_precision) else: logger.info("Not setting precision") args.deactivate("cuda_precision",msg="Platform does not support setting cuda_precision.") # === Create Simulation === # logger.info("Creating the Simulation object") # Get the number of forces and set each force to a different force group number. nfrc = system.getNumForces() if args.integrator != 'mtsvvvr': for i in range(nfrc): system.getForce(i).setForceGroup(i) ''' for i in range(nfrc): # Set vdW switching function manually. f = system.getForce(i) if f.__class__.__name__ == 'NonbondedForce': if 'vdw_switch' in args.ActiveOptions and args.vdw_switch: f.setUseSwitchingFunction(True) f.setSwitchingDistance(args.switch_distance) ''' #create simulation object if args.platform != None: simulation = app.Simulation(top.topology, system, integrator, platform) else: simulation = app.Simulation(top.topology, system, integrator) #print platform we're using mdparse.printcool_dictionary({i:simulation.context.getPlatform().getPropertyValue(simulation.context,i) for i in simulation.context.getPlatform().getPropertyNames()},title="Platform %s has properties:" % simulation.context.getPlatform().getName()) # Print out some more information about the system logger.info("--== System Information ==--") logger.info("Number of particles : %i" % simulation.context.getSystem().getNumParticles()) logger.info("Number of constraints : %i" % simulation.context.getSystem().getNumConstraints()) for f in simulation.context.getSystem().getForces(): if f.__class__.__name__ == 'NonbondedForce': method_names = ["NoCutoff", "CutoffNonPeriodic", "CutoffPeriodic", "Ewald", "PME", "LJPME"] logger.info("Nonbonded method : %s" % method_names[f.getNonbondedMethod()]) logger.info("Number of particles : %i" % f.getNumParticles()) logger.info("Number of exceptions : %i" % f.getNumExceptions()) if f.getNonbondedMethod() > 0: logger.info("Nonbonded cutoff : %.3f nm" % (f.getCutoffDistance() / u.nanometer)) if f.getNonbondedMethod() >= 3: logger.info("Ewald error tolerance : %.3e" % (f.getEwaldErrorTolerance())) logger.info("LJ switching function : %i" % f.getUseSwitchingFunction()) if f.getUseSwitchingFunction(): logger.info("LJ switching distance : %.3f nm" % (f.getSwitchingDistance() / u.nanometer)) # Print the sample input file here. for line in args.record(): print(line) #============================# #| Initialize & Eq/Warm-Up |# #============================# p = simulation.context.getPlatform() if p.getName()=="CUDA" or p.getName()=="OpenCL": print("simulation platform: {}".format(p.getName()) ) print(p.getPropertyNames()) print(p.getPropertyValue(simulation.context,'DeviceName')) print("Device Index: {}".format(p.getPropertyValue(simulation.context,'DeviceIndex'))) if os.path.exists(args.restart_filename) and args.read_restart: print("Restarting simulation from the restart file.") print("Currently is filler") else: # Set initial positions. if incoord.split(".")[1]=="pdb": pdb = pmd.load_file(incoord) simulation.context.setPositions(pdb.positions) elif incoord.split(".")[1]=="xml": simulation.loadState(incoord) else: logger.info("Error, can't handle input coordinate filetype") simulation.context.applyConstraints(args.constraint_tolerance) #applies constraints in current frame. logger.info("Initial potential energy is: {}".format(simulation.context.getState(getEnergy=True).getPotentialEnergy()) ) if args.integrator != 'mtsvvvr': eda = mdparse.EnergyDecomposition(simulation) eda_kcal = OrderedDict([(i, "%10.4f" % (j/4.184)) for i, j in eda.items()]) mdparse.printcool_dictionary(eda_kcal, title="Energy Decomposition (kcal/mol)") # Minimize the energy. if args.minimize: logger.info("Minimization start, the energy is:", simulation.context.getState(getEnergy=True).getPotentialEnergy()) simulation.minimizeEnergy() logger.info("Minimization done, the energy is", simulation.context.getState(getEnergy=True).getPotentialEnergy()) positions = simulation.context.getState(getPositions=True).getPositions() logger.info("Minimized geometry is written to 'minimized.pdb'") app.PDBFile.writeModel(simulation.topology, positions, open('minimized.pdb','w')) # Assign velocities. if args.gentemp > 0.0: logger.info("Generating velocities corresponding to Maxwell distribution at %.2f K" % args.gentemp) simulation.context.setVelocitiesToTemperature(args.gentemp * u.kelvin) # Equilibrate. logger.info("--== Equilibrating (%i steps, %.2f ps) ==--" % (args.equilibrate, args.equilibrate * args.timestep * u.femtosecond / u.picosecond)) if args.report_interval > 0: # Append the ProgressReport for equilibration run. simulation.reporters.append(mdparse.ProgressReport(args, sys.stdout, args.report_interval, simulation, args.equilibrate)) simulation.reporters[-1].t00 = time.time() logger.info("Progress will be reported every %i steps" % args.report_interval) # This command actually does all of the computation. simulation.step(args.equilibrate) if args.report_interval > 0: # Get rid of the ProgressReport because we'll make a new one. simulation.reporters.pop() first = args.equilibrate #============================# #| Production MD simulation |# #============================# logger.info("--== Production (%i blocks, %i steps total, %.2f ps total) ==--" % (nblocks, nblocks*blocksteps, nblocks*blocksteps * args.timestep * u.femtosecond / u.picosecond)) #===========================================# #| Add reporters for production simulation |# #===========================================# print("===== registering reporters and runnning =====") if args.report_interval > 0: logger.info("Thermo and Progress will be reported every %i steps" % args.report_interval) #simulation.reporters.append(ProgressReport(sys.stdout, args.report_interval, simulation, args.production, first)) mdparse.bak(logfile) simulation.reporters.append(app.StateDataReporter(logfile, reportfreq, step=True, potentialEnergy=True, kineticEnergy=True, temperature=True, volume=True, density=True, speed=True)) #simulation.reporters.append(app.StateDataReporter(stdout, reportfreq, step=True, # potentialEnergy=True, kineticEnergy=True, temperature=True, volume=True, density=True, speed=True)) if progressreport: simulation.reporters.append(mdparse.ProgressReport(args, sys.stdout, reportfreq, simulation, nblocks*blocksteps, first=args.equilibrate)) Prog = simulation.reporters[-1] if args.pdb_report_interval > 0: mdparse.bak(out_pdb) logger.info("PDB Reporter will write to %s every %i steps" % (out_pdb, pdbfreq)) simulation.reporters.append(app.PDBReporter(out_pdb, pdbfreq)) if args.netcdf_report_interval > 0: mdparse.bak(out_netcdf) logger.info("netcdf Reporter will write to %s every %i steps" %(out_netcdf, netcdffreq)) simulation.reporters.append(NetCDFReporter(out_netcdf, netcdffreq, crds=True, vels=args.netcdf_vels, frcs=args.netcdf_frcs)) if args.checkpoint_interval > 0: simulation.reporters.append(app.CheckpointReporter(checkpointchk, checkfreq)) #simulation.reporters.append(app.DCDReporter(out_dcd, writefreq)) #simulation.reporters.append(mdtraj.reporters.HDF5Reporter(out_hdf5, writefreq, velocities=True)) #============================# #| Finally Run! |# #============================# t1 = time.time() if progressreport: Prog.t00 = t1 #simulation.step(args.production) if simulation.topology.getUnitCellDimensions() != None : box_vectors = simulation.context.getState().getPeriodicBoxVectors() volume = mdparse.compute_volume(box_vectors) / u.nanometer**3 iblock = 0 err = abs(volume - targetVol)/targetVol while err > tol and iblock < nblocks: logger.info("Starting block {}".format(iblock)) start = time.time() simulation.step(blocksteps) end = time.time() logger.info('Took {} seconds for block {}'.format(end-start,iblock)) if simulation.topology.getUnitCellDimensions() != None : box_vectors = simulation.context.getState().getPeriodicBoxVectors() volume = mdparse.compute_volume(box_vectors) / u.nanometer**3 print("Volume is {}, targeting {}".format(volume, targetVol)) with open("finalL.txt",'w') as f: f.write("{}".format(volume**(1.0/3.0))) err = abs(volume - targetVol)/targetVol iblock = iblock+1 #avoid frequent writes, only write at the end simulation.saveState(checkpointxml) positions = simulation.context.getState(getPositions=True, enforcePeriodicBox=True).getPositions() app.PDBFile.writeFile(simulation.topology, positions, open(checkpointpdb, 'w'))
#platform = mm.Platform.getPlatformByName('CUDA') #properties = {'CudaPrecision': 'mixed'} simulation = app.Simulation(pdb.topology, system, integrator, platform, properties) simulation.context.setPositions(pdb.positions) print('Minimizing...') simulation.minimizeEnergy() simulation.context.setVelocitiesToTemperature(300 * unit.kelvin) print('Equilibrating...') simulation.step(100) simulation.reporters.append(app.DCDReporter('trajectory.dcd', 1000)) simulation.reporters.append(app.PDBReporter('trajectory.pdb', 1000)) simulation.reporters.append( app.StateDataReporter(stdout, 1000, step=True, potentialEnergy=True, kineticEnergy=True, totalEnergy=True, temperature=True, progress=True, remainingTime=True, speed=True, totalSteps=1000, separator='\t')) print('Running Production...')
#Outputs progress to command line simulation.reporters.append( app.StateDataReporter(sys.stdout, skipSteps, step=True, potentialEnergy=True, temperature=True, progress=True, remainingTime=True, speed=True, totalSteps=steps, separator='\t')) #Saves trajectory to .pdb file that can be opened in VMD simulation.reporters.append(app.PDBReporter('trajectory.pdb', skipSteps)) #Saves trajectory file to binary format simulation.reporters.append( mdtraj.reporters.HDF5Reporter('water2.h5', skipSteps)) #Performs the simulation simulation.step(steps) #Close binary trajectory simulation.reporters[2].close() #Read the output file output_file = mdtraj.formats.HDF5TrajectoryFile('water2.h5') data = output_file.read() positions = data.coordinates potE = data.potentialEnergy
a = md.load(output_name) a = a.center_coordinates() a.unitcell_lengths = pbc_lengths a.unitcell_vectors = pbc_vectors a.unitcell_angles = pbc_angles edit_length = a.unitcell_lengths * (2. / 4.) #edit_length = a.unitcell_lengths atom_coords = a.xyz print(atom_coords) added_length = np.tile(edit_length, (a.n_atoms, 1)) atom_coords = atom_coords + added_length print(atom_coords) a.xyz = atom_coords a.save(output_name) #model.addSolvent(forcefield, padding=0.4 * u.nanometer) #system = forcefield.createSystem(model.topology, nonbondedMethod=app.PME, nonbondedCutoff=1.0 * u.nanometers, constraints=app.HAngles) if 0: integrator = mm.LangevinIntegrator(temperature, friction, timestep) simulation = app.Simulation(model.topology, system, integrator) simulation.context.setPositions(model.positions) #simulation.minimizeEnergy(tolerance=2.0) simulation.reporters.append(app.PDBReporter("simulation.pdb", 250)) print("running") simulation.step(2500)
system = prmtop.createSystem(nonbondedMethod=app.PME, nonbondedCutoff=9*u.angstrom, constraints=app.HBonds, hydrogenMass=None) # Set the COM Removal to something sensible for i in range(system.getNumForces()): if (type(system.getForce(i)) == mm.CMMotionRemover): system.getForce(i).setFrequency(1000) applyHarmonicPositionalRestraints(system, 1.0, inpcrd, Chunk_Heavy_Atoms) applyLigandChunkRestraint(system, 1.0, 10.0, 2*u.angstrom, 3*u.angstrom, 4*u.angstrom, keyInteraction) simulation = app.Simulation(prmtop.topology, system, integrator, platform, platformProperties) simulation.context.setPositions(positions) simulation.reporters.append(app.StateDataReporter("heating.csv", 1000, step=True, time=True, totalEnergy=True, kineticEnergy=True, potentialEnergy=True, temperature=True, density=True, progress=True, totalSteps=100000, speed=True)) simulation.reporters.append(app.PDBReporter('heating.pdb', 1000)) simulation.step(100000) # # Save the positions and velocities positions = simulation.context.getState(getPositions=True).getPositions() velocities = simulation.context.getState(getVelocities=True).getVelocities() #clear reporters simulation.reporters = [] ########################## # Equlibration - density # ##########################
integrator = mm.LangevinIntegrator(temperature, equil_friction, equil_timestep) system.addForce( mm.MonteCarloBarostat(pressure, temperature, barostat_frequency)) simulation = app.Simulation(topology, system, integrator, platform=platform) simulation.context.setPositions(positions) print('Minimizing...') simulation.minimizeEnergy() simulation.context.setVelocitiesToTemperature(temperature) print('Equilibrating...') simulation.step(discard_steps) # Don't even save the first XXX ps simulation.reporters.append(app.DCDReporter(dcd_filename, output_frequency)) simulation.reporters.append(app.PDBReporter(out_pdb_filename, n_steps - 1)) simulation.reporters.append( app.StateDataReporter(open(log_filename, 'w'), output_frequency, step=True, time=True, speed=True)) simulation.step(n_steps) del simulation del system t = md.load(dcd_filename, top=out_pdb_filename) t0 = t[-1] t0.unitcell_lengths = t.unitcell_lengths.mean(0) t0.save(out_pdb_filename)
[system, positions, topology ] = [testsystem.system, testsystem.positions, testsystem.topology] # Get NonbondedForce objects for system copy. force = _findForces(system, 'NonbondedForce', first_only=True) # Turn off standard particle interactions. zero_charge = 0.0 * unit.elementary_charge unit_sigma = 1.0 * unit.angstroms zero_epsilon = 0.0 * unit.kilocalories_per_mole for atom in topology.atoms(): [charge, sigma, epsilon] = force.getParticleParameters(atom.index) force.setParticleParameters(atom.index, zero_charge, unit_sigma, zero_epsilon) timestep = 2.0 * unit.femtoseconds collision_rate = 5.0 / unit.picoseconds temperature = 298.0 * unit.kelvin integrator = openmm.LangevinIntegrator(temperature, collision_rate, timestep) niterations = 1000 nsteps = 500 output_filename = 'output.pdb' simulation = app.Simulation(topology, system, integrator) simulation.context.setPositions(positions) simulation.minimizeEnergy(maxIterations=500) simulation.reporters.append(app.PDBReporter(output_filename, nsteps)) simulation.step(niterations * nsteps)
simulation.context.setPositions(pdbfile.positions) # Report total system mass total_mass = 0.0 * unit.amu for index in range(system.getNumParticles()): total_mass += system.getParticleMass(index) print('System mass: %s' % str(total_mass)) # Minimize energy print('Minimizing energy...') simulation.minimizeEnergy() # Append reporters print('Creating reporters...') simulation.reporters.append( app.PDBReporter(output_pdbfile, nsteps_per_snapshot)) simulation.reporters.append( app.StateDataReporter(density_outfile, nsteps_per_density, step=True, time=True, speed=True, density=True, volume=True, potentialEnergy=True, temperature=True)) # Run the simulation print('Running the simulation for %d steps...' % nsteps) simulation.step(nsteps)
print("Creating integrator") integrator = mm.LangevinIntegrator(temp, 1.0 / u.picoseconds, timestep) print("Creating Simulation") sim = app.Simulation(top.topology, system, integrator, platform, properties) print("Setting context") sim.context.setPositions(top.positions) sim.reporters.append( app.StateDataReporter(open('thermo.log', 'a'), 1000, step=True, time=True, potentialEnergy=True, temperature=True, volume=True, speed=True)) sim.reporters.append(app.DCDReporter('trajectory.dcd', 2500)) sim.reporters.append(app.CheckpointReporter('trajectory.chk', 2500)) # Load the checkpoint #with open('my_checkpoint.chk', 'rb') as f: # sim.context.loadCheckpoint(f.read()) print("Running MD") remaining_time = sim_time - sim.context.getState(-1).getTime() remaining_steps = int(round(remaining_time / timestep)) sim.step(remaining_steps) pdbreporter = app.PDBReporter('trajectory.pdb', 5000) pdbreporter.report(sim, sim.context.getState(-1))
def openmm_system(self): """Initialise the OpenMM system we will use to evaluate the energies.""" # load the initial coords into the system and initialise pdb = app.PDBFile(self.pdb) # count the amount of atoms in the structure for atom in pdb.topology.atoms(): self.natoms += 1 # must use a custom version of the tip3p water moddel forcefield = app.ForceField(self.xml, 'tip3p_opls.xml') self.modeller = app.Modeller( pdb.topology, pdb.positions) # set the intial positions from the pdb # Now we need to solvate the system self.modeller.addSolvent(forcefield, model='tip3p', padding=1 * unit.nanometer) # write out the solvated system coords app.PDBFile.writeFile(self.modeller.topology, self.modeller.positions, open('output.pdb', 'w')) # now we create the system and add the lj correction self.system = forcefield.createSystem(self.modeller.topology, nonbondedMethod=app.PME, constraints=None, nonbondedCutoff=1.1 * unit.nanometer) if self.opls: self.opls_lj() # set control parameters temperature = 298.15 * unit.kelvin integrator = mm.LangevinIntegrator(temperature, 5 / unit.picoseconds, 0.001 * unit.picoseconds) # add preasure to the system self.system.addForce( mm.MonteCarloBarostat(1 * unit.bar, 300 * unit.kelvin)) # create the simulation context self.simulation = app.Simulation(self.modeller.topology, self.system, integrator) # set the positions to the solvated system self.simulation.context.setPositions(self.modeller.positions) # get the energy of the sytem print( self.simulation.context.getState( getEnergy=True).getPotentialEnergy()) # check the energy break down struct = pmd.load_file('output.pdb') ecomps = (pmd.openmm.energy_decomposition_system(struct, self.system)) tot_ene = 0.0 for i in range(0, len(ecomps)): tot_ene += ecomps[i][1] print(ecomps[i][0], ecomps[i][1]) print('Total-energy %6.6f' % tot_ene) # serialize the system serialized_system = mm.XmlSerializer.serialize(self.system) outfile = open('test.xml', 'w') outfile.write(serialized_system) outfile.close() # now minimize the system self.simulation.minimizeEnergy(maxIterations=100) # now run the simulation self.simulation.reporters.append(app.PDBReporter('run.pdb', 1000)) self.simulation.reporters.append( app.StateDataReporter('run.txt', 1000, step=True, potentialEnergy=True, temperature=True)) self.simulation.step(100000)
mass, Ts, [hc_hb, hc_a, hc_d], '0.5*Ks*(s_hc - (hc_hb + hc_a + hc_d)/3)^2', Ks=Ks, sigma=sigma, periodic=False) ufed = ufedmm.UnifiedFreeEnergyDynamics([s_hc], temp, height, deposition_period) ufedmm.serialize(ufed, 'ufed_object.yml') integrator = ufedmm.GeodesicLangevinIntegrator(temp, gamma, dt) integrator.setRandomNumberSeed(seed) platform = openmm.Platform.getPlatformByName(args.platform) simulation = ufed.simulation(pdb.topology, system, integrator, platform) simulation.context.setPositions(pdb.positions) simulation.minimizeEnergy(tolerance=0.1 * unit.kilojoules_per_mole) positions = simulation.context.getState(getPositions=True).getPositions() app.PDBFile.writeFile(pdb.topology, positions, open('minimized.pdb', 'w')) simulation.context.setVelocitiesToTemperature(temp, seed) output = ufedmm.Tee(stdout, 'output.csv') simulation.reporters += [ ufedmm.StateDataReporter(output, 100, step=True, multipleTemperatures=True, variables=True, speed=True), app.PDBReporter('output.pdb', 200) ] simulation.step(nsteps)