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