def configure_simulation( pdb_file: str, top_file: Optional[str], solvent_type: str, gpu_index: int, dt_ps: float, temperature_kelvin: float, heat_bath_friction_coef: float, ) -> simtk.openmm.app.Simulation: # Configure hardware try: platform = omm.Platform_getPlatformByName("CUDA") platform_properties = {"DeviceIndex": str(gpu_index), "CudaPrecision": "mixed"} except Exception: platform = omm.Platform_getPlatformByName("OpenCL") platform_properties = {"DeviceIndex": str(gpu_index)} # Select implicit or explicit solvent configuration if solvent_type == "implicit": sim, coords = configure_amber_implicit( pdb_file, top_file, dt_ps, temperature_kelvin, heat_bath_friction_coef, platform, platform_properties, ) else: assert solvent_type == "explicit" assert top_file is not None sim, coords = configure_amber_explicit( pdb_file, top_file, dt_ps, temperature_kelvin, heat_bath_friction_coef, platform, platform_properties, ) # Set simulation positions if coords.get_coordinates().shape[0] == 1: sim.context.setPositions(coords.positions) else: positions = random.choice(coords.get_coordinates()) sim.context.setPositions(positions / 10) # Minimize energy and equilibrate sim.minimizeEnergy() sim.context.setVelocitiesToTemperature( temperature_kelvin * u.kelvin, random.randint(1, 10000) ) return sim
def configure_simulation( ctx, sim_type="implicit", gpu_index=0, dt_ps=0.002 * u.picoseconds, temperature_kelvin=300 * u.kelvin, ): logger.info(f"configure_simulation: {sim_type} {ctx.pdb_file}") # Configure hardware try: platform = omm.Platform_getPlatformByName("CUDA") platform_properties = { "DeviceIndex": str(gpu_index), "CudaPrecision": "mixed" } except Exception: platform = omm.Platform_getPlatformByName("OpenCL") platform_properties = {"DeviceIndex": str(gpu_index)} # Select implicit or explicit solvent args = ( ctx.pdb_file, ctx.top_file, dt_ps, temperature_kelvin, platform, platform_properties, ) if sim_type == "implicit": sim, coords = configure_amber_implicit(*args) else: assert sim_type == "explicit" sim, coords = configure_amber_explicit(*args) # Set simulation positions if coords.get_coordinates().shape[0] == 1: sim.context.setPositions(coords.positions) else: positions = random.choice(coords.get_coordinates()) sim.context.setPositions(positions / 10) # Minimize energy and equilibrate sim.minimizeEnergy() sim.context.setVelocitiesToTemperature(300 * u.kelvin, random.randint(1, 10000)) return sim
def runEquilibration(equilibrationFiles, reportName, parameters, worker): """ Function that runs the whole equilibration process and returns the final pdb :param equilibrationFiles: tuple with the topology (prmtop) in the first position and the coordinates in the second (inpcrd) :type equilibrationFiles: tuple :param outputPDB: string with the pdb to save :type outputPDB: str :param parameters: Object with the parameters for the simulation :type parameters: :py:class:`/simulationrunner/SimulationParameters` -- SimulationParameters object :param worker: Number of the subprocess :type worker: int :returns: str -- a string with the outputPDB """ prmtop, inpcrd = equilibrationFiles prmtop = app.AmberPrmtopFile(prmtop) inpcrd = app.AmberInpcrdFile(inpcrd) PLATFORM = mm.Platform_getPlatformByName(str(parameters.runningPlatform)) if parameters.runningPlatform == "CUDA": platformProperties = {"Precision": "mixed", "DeviceIndex": getDeviceIndexStr(worker, parameters.devicesPerTrajectory, devicesPerReplica=parameters.maxDevicesPerReplica), "UseCpuPme": "false"} else: platformProperties = {} if worker == 0: utilities.print_unbuffered("Running %d steps of minimization" % parameters.minimizationIterations) if parameters.boxCenter or parameters.cylinderBases: dummies = findDummyAtom(prmtop) assert dummies is not None else: dummies = None simulation = minimization(prmtop, inpcrd, PLATFORM, parameters.constraintsMin, parameters, platformProperties, dummies) # Retrieving the state is expensive (especially when running on GPUs) so we # only called it once and then separate positions and velocities state = simulation.context.getState(getPositions=True, getVelocities=True) positions = state.getPositions() velocities = state.getVelocities() if worker == 0: utilities.print_unbuffered("Running %d steps of NVT equilibration" % parameters.equilibrationLengthNVT) simulation = NVTequilibration(prmtop, positions, PLATFORM, parameters.equilibrationLengthNVT, parameters.constraintsNVT, parameters, reportName, platformProperties, velocities=velocities, dummy=dummies) state = simulation.context.getState(getPositions=True, getVelocities=True) positions = state.getPositions() velocities = state.getVelocities() if worker == 0: utilities.print_unbuffered("Running %d steps of NPT equilibration" % parameters.equilibrationLengthNPT) simulation = NPTequilibration(prmtop, positions, PLATFORM, parameters.equilibrationLengthNPT, parameters.constraintsNPT, parameters, reportName, platformProperties, velocities=velocities, dummy=dummies) state = simulation.context.getState(getPositions=True) root, _ = os.path.splitext(reportName) outputPDB = "%s_NPT.pdb" % root with open(outputPDB, 'w') as fw: app.PDBFile.writeFile(simulation.topology, state.getPositions(), fw) return outputPDB
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)
def run_steered_md( temperature, checkpoint_in_file, csv_out_file, dat_out_file, pdb_out_file, traj_out_file, startdist, spring_constant=50, force_constant_chunk=0.1, init_velocity=0.00001, gpu_id=0, ): if os.path.isfile(pdb_out_file): return spring_k = spring_constant * u.kilocalorie / (u.mole * u.angstrom * u.angstrom) dist_in = startdist * u.angstrom # in angstrom dist_fin = (startdist + 2.5) * u.angstrom # in angstrom steps_per_move = 200 velocity = init_velocity * u.angstrom # Platform definition platform = mm.Platform_getPlatformByName("OpenCL") platformProperties = {} platformProperties["OpenCLPrecision"] = "mixed" platformProperties["OpenCLDeviceIndex"] = gpu_id print("loading pickle") pickle_in = open("complex_system.pickle", "rb") combined_pmd = pickle.load(pickle_in)[0] print(combined_pmd) pickle_in.close() keyInteraction = cal_ints.find_interaction() print(keyInteraction) # Get indexes of heavy atoms in chunk Chunk_Heavy_Atoms = duck_stuff.getHeavyAtomsInSystem(combined_pmd) # Setting System system = combined_pmd.createSystem( nonbondedMethod=app.PME, nonbondedCutoff=9 * u.angstrom, constraints=app.HBonds, hydrogenMass=None, ) # Apply force on all havy atoms of chunk duck_stuff.applyHarmonicPositionalRestraints(system, force_constant_chunk, combined_pmd.positions, Chunk_Heavy_Atoms) # Integrator integrator = mm.LangevinIntegrator(temperature, 4 / u.picosecond, 0.002 * u.picosecond) # Setting Simulation object and loading the checkpoint simulation = app.Simulation(combined_pmd.topology, system, integrator, platform, platformProperties) simulation.loadCheckpoint(checkpoint_in_file) # SMD force definition pullforce = mm.CustomExternalForce("k_sp*0.5*(R-R0)^2; \ R = periodicdistance(x, y, z, x0, y0, z0);" ) pullforce.addPerParticleParameter("k_sp") pullforce.addGlobalParameter("x0", 0.0 * u.nanometer) pullforce.addGlobalParameter("y0", 0.0 * u.nanometer) pullforce.addGlobalParameter("z0", 0.0 * u.nanometer) pullforce.addGlobalParameter("R0", 0.0 * u.nanometer) pullforce.addParticle(keyInteraction[1], [spring_k]) system.addForce(pullforce) # Redefine integrator and simulation, and load checkpoint with new-updated system integrator = mm.LangevinIntegrator(temperature, 4 / u.picosecond, 0.002 * u.picosecond) simulation = app.Simulation(combined_pmd.topology, system, integrator, platform, platformProperties) simulation.loadCheckpoint(checkpoint_in_file) # Initializing energy work_val_old = u.Quantity(value=0, unit=u.kilocalorie / u.mole) # Number of big steps and pull distance steps = int(round((dist_fin - dist_in) / velocity) / steps_per_move) pull_distance = velocity * steps_per_move # Reporters and duck.dat file simulation.reporters.append( app.StateDataReporter( csv_out_file, steps_per_move, step=True, time=True, totalEnergy=True, kineticEnergy=True, potentialEnergy=True, temperature=True, density=True, progress=True, totalSteps=steps_per_move * steps, speed=True, )) simulation.reporters.append(app.DCDReporter(traj_out_file, 100000)) f = open(dat_out_file, "w") # Production in N steps with the update every 200 steps (2 pm) for i in range(steps): # Get current state tu update the system state = simulation.context.getState(getPositions=True) pos_keyInt = state.getPositions() keyInteraction_pos = [ pos_keyInt[keyInteraction[0]], pos_keyInt[keyInteraction[1]], ] # Get radius of starting point and end point R_val = dist_in + float(i + 1) * pull_distance R_val_start = dist_in + float(i) * pull_distance # Get distance of main interaction keyInteraction_dist = np.linalg.norm(keyInteraction_pos[0] - keyInteraction_pos[1]) print(keyInteraction_dist) # Updated system simulation.context.setParameter("x0", keyInteraction_pos[0][0]) simulation.context.setParameter("y0", keyInteraction_pos[0][1]) simulation.context.setParameter("z0", keyInteraction_pos[0][2]) simulation.context.setParameter("R0", R_val) # Calculate force F = -k * x force_val = -spring_k * (keyInteraction_dist - R_val) # Make step simulation.step(steps_per_move) # Calculate work for difference in potential energy in tranzition # W = EK_end - EK_start # EK = 0.5 * k * x^2 spr_energy_end = 0.5 * spring_k * (keyInteraction_dist - R_val)**2 spr_energy_start = 0.5 * spring_k * (keyInteraction_dist - R_val_start)**2 work_val = work_val_old + spr_energy_end - spr_energy_start work_val_old = work_val # Write duck.dat file f.write( str(i) + " " + str(R_val) + " " + str(keyInteraction_dist) + " " + str(force_val) + " " + str(work_val) + "\n") f.close() # Save state in PDB file positions = simulation.context.getState(getPositions=True).getPositions() app.PDBFile.writeFile(simulation.topology, positions, open(pdb_out_file, "w"))
def runProductionSimulation(equilibrationFiles, workerNumber, outputDir, seed, parameters, reportFileName, checkpoint, ligandName, replica_id, trajsPerReplica, epoch_number, restart=False): """ Functions that runs the production run at NPT conditions. If a boxRadius is defined in the parameters section, a Flat-bottom harmonic restrains will be applied between the protein and the ligand :param equilibrationFiles: Tuple with the paths for the Amber topology file (prmtop) and the pdb for the system :type equilibrationFiles: Tuple :param workerNumber: Number of the subprocess :type workerNumber: int :param outputDir: path to the directory where the output will be written :type outputDir: str :param seed: Seed to use to generate the random numbers :type seed: int :param parameters: Object with the parameters for the simulation :type parameters: :py:class:`/simulationrunner/SimulationParameters` -- SimulationParameters object :param reportFileName: Name for the file where the energy report will be written :type reportFileName: str :param checkpoint: Path to the checkpoint from where the production run will be restarted (Optional) :type checkpoint: str :param ligandName: Code Name for the ligand :type ligandName: str :param replica_id: Id of the replica running :type replica_id: int :param trajsPerReplica: Number of trajectories per replica :type trajsPerReplica: int :param restart: Whether the simulation run has to be restarted or not :type restart: bool :param epoch_number: Number of the epoch :type epoch_number: int """ # this number gives the number of the subprocess in the given node deviceIndex = workerNumber # this one gives the number of the subprocess in the overall simulation (i.e # the trajectory file number) workerNumber += replica_id * trajsPerReplica + 1 prmtop, pdb = equilibrationFiles prmtop = app.AmberPrmtopFile(prmtop) trajName = os.path.join( outputDir, constants.AmberTemplates.trajectoryTemplate % (workerNumber, parameters.format)) stateReporter = os.path.join(outputDir, "%s_%s" % (reportFileName, workerNumber)) checkpointReporter = os.path.join( outputDir, constants.AmberTemplates.CheckPointReporterTemplate % workerNumber) lastStep = getLastStep(stateReporter) simulation_length = parameters.productionLength - lastStep # if the string is unicode the PDBReaders fails to read the file (this is # probably due to the fact that openmm was built with python2 in my # computer, will need to test thoroughly with python3) pdb = app.PDBFile(str(pdb)) PLATFORM = mm.Platform_getPlatformByName(str(parameters.runningPlatform)) if parameters.runningPlatform == "CUDA": platformProperties = { "Precision": "mixed", "DeviceIndex": getDeviceIndexStr( deviceIndex, parameters.devicesPerTrajectory, devicesPerReplica=parameters.maxDevicesPerReplica), "UseCpuPme": "false" } else: platformProperties = {} dummies = None if parameters.boxCenter or parameters.cylinderBases: dummies = findDummyAtom(prmtop) if epoch_number > 0: min_sim = minimization(prmtop, pdb, PLATFORM, parameters.constraintsMin, parameters, platformProperties, dummy=dummies) positions = min_sim.context.getState(getPositions=True).getPositions() else: positions = pdb.positions system = prmtop.createSystem(nonbondedMethod=app.PME, nonbondedCutoff=parameters.nonBondedCutoff * unit.angstroms, constraints=app.HBonds, removeCMMotion=True) if parameters.boxCenter or parameters.cylinderBases: addDummyAtomToSystem(system, prmtop.topology, positions, parameters.ligandName, dummies, deviceIndex) system.addForce( mm.AndersenThermostat(parameters.Temperature * unit.kelvin, 1 / unit.picosecond)) integrator = mm.VerletIntegrator(parameters.timeStep * unit.femtoseconds) system.addForce( mm.MonteCarloBarostat(1 * unit.bar, parameters.Temperature * unit.kelvin)) if parameters.constraints is not None: # Add the specified constraints to the system addConstraints(system, prmtop.topology, parameters.constraints) if parameters.boxCenter or parameters.cylinderBases: if parameters.boxType == blockNames.SimulationParams.sphere: if deviceIndex == 0: utilities.print_unbuffered("Adding spherical ligand box") assert len(dummies) == 1 addLigandBox(prmtop.topology, positions, system, parameters.ligandName, dummies[0], parameters.boxRadius, deviceIndex) elif parameters.boxType == blockNames.SimulationParams.cylinder: if deviceIndex == 0: utilities.print_unbuffered("Adding cylinder ligand box") addLigandCylinderBox(prmtop.topology, positions, system, parameters.ligandName, dummies, parameters.boxRadius, deviceIndex) simulation = app.Simulation(prmtop.topology, system, integrator, PLATFORM, platformProperties=platformProperties) utilities.print_unbuffered(workerNumber, equilibrationFiles, dummies, len(positions), prmtop.topology.getNumAtoms(), system.getNumParticles()) simulation.context.setPositions(positions) if restart: with open(str(checkpoint), 'rb') as check: simulation.context.loadCheckpoint(check.read()) stateData = open(str(stateReporter), "a") else: simulation.context.setVelocitiesToTemperature( parameters.Temperature * unit.kelvin, seed) stateData = open(str(stateReporter), "w") if parameters.format == "xtc": simulation.reporters.append( XTCReporter(str(trajName), parameters.reporterFreq, append=restart, enforcePeriodicBox=parameters.postprocessing)) elif parameters.format == "dcd": simulation.reporters.append( app.DCDReporter(str(trajName), parameters.reporterFreq, append=restart, enforcePeriodicBox=parameters.postprocessing)) simulation.reporters.append( app.CheckpointReporter(str(checkpointReporter), parameters.reporterFreq)) simulation.reporters.append( CustomStateDataReporter(stateData, parameters.reporterFreq, step=True, potentialEnergy=True, temperature=True, time_sim=True, volume=True, remainingTime=True, speed=True, totalSteps=simulation_length, separator="\t", append=restart, initialStep=lastStep)) if workerNumber == 1: frequency = min(10 * parameters.reporterFreq, parameters.productionLength) simulation.reporters.append( app.StateDataReporter(sys.stdout, frequency, step=True)) simulation.step(simulation_length) stateData.close()
def openmm_simulate_amber_fs_pep(pdb_file, top_file=None, checkpnt_fname='checkpnt.chk', checkpnt=None, GPU_index=0, output_traj='output.dcd', output_log='output.log', output_cm=None, report_time=10*u.picoseconds,sim_time=10*u.nanoseconds, platform='CUDA'): """ Start and run an OpenMM NVT simulation with Langevin integrator at 2 fs time step and 300 K. The cutoff distance for nonbonded interactions were set at 1.2 nm and LJ switch distance at 1.0 nm, which commonly used with Charmm force field. Long-range nonbonded interactions were handled with PME. Parameters ---------- pdb_file : coordinates file (.gro, .pdb, ...) This is the molecule configuration file contains all the atom position and PBC (periodic boundary condition) box in the system. checkpnt : None or check point file to load GPU_index : Int or Str The device # of GPU to use for running the simulation. Use Strings, '0,1' for example, to use more than 1 GPU output_traj : the trajectory file (.dcd) This is the file stores all the coordinates information of the MD simulation results. output_log : the log file (.log) This file stores the MD simulation status, such as steps, time, potential energy, temperature, speed, etc. output_cm : the h5 file contains contact map information report_time : 10 ps The program writes its information to the output every 10 ps by default sim_time : 10 ns The timespan of the simulation trajectory platform : str Name of platform. Options: 'CUDA', 'OpenCL', or 'CPU' """ if top_file: pdb = pmd.load_file(top_file, xyz=pdb_file) system = pdb.createSystem(nonbondedMethod=app.CutoffNonPeriodic, nonbondedCutoff=1.0*u.nanometer, constraints=app.HBonds, implicitSolvent=app.OBC1) else: pdb = pmd.load_file(pdb_file) forcefield = app.ForceField('amber99sbildn.xml', 'amber99_obc.xml') system = forcefield.createSystem(pdb.topology, nonbondedMethod=app.CutoffNonPeriodic, nonbondedCutoff=1.0*u.nanometer, constraints=app.HBonds) dt = 0.002*u.picoseconds integrator = omm.LangevinIntegrator(300*u.kelvin, 91.0/u.picosecond, dt) integrator.setConstraintTolerance(0.00001) # Select platform if platform is 'CUDA': platform = omm.Platform_getPlatformByName('CUDA') properties = {'DeviceIndex': str(GPU_index), 'CudaPrecision': 'mixed'} elif platform is 'OpenCL': platform = omm.Platform_getPlatformByName('OpenCL') properties = {'DeviceIndex': str(GPU_index)} elif platform is 'CPU': platform, properties = None, None else: raise ValueError(f'Invalid platform name: {platform}') simulation = app.Simulation(pdb.topology, system, integrator, platform, properties) simulation.context.setPositions(random.choice(pdb.get_coordinates())/10) #parmed \AA to OpenMM nm # equilibrate simulation.minimizeEnergy() simulation.context.setVelocitiesToTemperature(300*u.kelvin, random.randint(1, 10000)) simulation.step(int(100*u.picoseconds / (2*u.femtoseconds))) report_freq = int(report_time/dt) simulation.reporters.append(app.DCDReporter(output_traj, report_freq)) if output_cm: simulation.reporters.append(sim.ContactMapReporter(output_cm, report_freq)) simulation.reporters.append(app.StateDataReporter(output_log, report_freq, step=True, time=True, speed=True, potentialEnergy=True, temperature=True, totalEnergy=True)) simulation.reporters.append(app.CheckpointReporter(checkpnt_fname, report_freq)) if checkpnt: simulation.loadCheckpoint(checkpnt) nsteps = int(sim_time/dt) simulation.step(nsteps)
def openmm_simulate_charmm_nvt(top_file, pdb_file, check_point=None, GPU_index=0, output_traj="output.dcd", output_log="output.log", output_cm=None, report_time=10 * u.picoseconds, sim_time=10 * u.nanoseconds): """ Start and run an OpenMM NVT simulation with Langevin integrator at 2 fs time step and 300 K. The cutoff distance for nonbonded interactions were set at 1.2 nm and LJ switch distance at 1.0 nm, which commonly used with Charmm force field. Long-range nonbonded interactions were handled with PME. Parameters ---------- top_file : topology file (.top, .prmtop, ...) This is the topology file discribe all the interactions within the MD system. pdb_file : coordinates file (.gro, .pdb, ...) This is the molecule configuration file contains all the atom position and PBC (periodic boundary condition) box in the system. check_point : None or check point file to load GPU_index : Int or Str The device # of GPU to use for running the simulation. Use Strings, '0,1' for example, to use more than 1 GPU output_traj : the trajectory file (.dcd) This is the file stores all the coordinates information of the MD simulation results. output_log : the log file (.log) This file stores the MD simulation status, such as steps, time, potential energy, temperature, speed, etc. output_cm : the h5 file contains contact map information report_time : 10 ps The program writes its information to the output every 10 ps by default sim_time : 10 ns The timespan of the simulation trajectory """ top = pmd.load_file(top_file, xyz=pdb_file) system = top.createSystem(nonbondedMethod=app.PME, nonbondedCutoff=1.2 * u.nanometer, switchDistance=1.0 * u.nanometer, constraints=app.HBonds) dt = 0.002 * u.picoseconds integrator = omm.LangevinIntegrator(300 * u.kelvin, 1 / u.picosecond, dt) try: platform = omm.Platform_getPlatformByName("CUDA") properties = {'DeviceIndex': str(GPU_index), 'CudaPrecision': 'mixed'} except Exception: platform = omm.Platform_getPlatformByName("OpenCL") properties = {'DeviceIndex': str(GPU_index)} simulation = app.Simulation(top.topology, system, integrator, platform, properties) simulation.context.setPositions(top.positions) simulation.minimizeEnergy() report_freq = int(report_time / dt) simulation.context.setVelocitiesToTemperature(10 * u.kelvin, random.randint(1, 10000)) simulation.reporters.append(app.DCDReporter(output_traj, report_freq)) if output_cm: simulation.reporters.append(ContactMapReporter(output_cm, report_freq)) simulation.reporters.append( app.StateDataReporter(output_log, report_freq, step=True, time=True, speed=True, potentialEnergy=True, temperature=True, totalEnergy=True)) simulation.reporters.append( app.CheckpointReporter('checkpnt.chk', report_freq)) if check_point: simulation.loadCheckpoint(check_point) nsteps = int(sim_time / dt) simulation.step(nsteps)
def __init__(self, mdstate, parmed_structure, opt): super().__init__(mdstate, parmed_structure, opt) opt['platform'] = 'Auto' opt['cuda_opencl_precision'] = 'mixed' topology = parmed_structure.topology positions = mdstate.get_positions() velocities = mdstate.get_velocities() box = mdstate.get_box_vectors() opt['omm_log_fn'] = os.path.join(opt['out_directory'], 'trajectory.log') opt['omm_trj_fn'] = os.path.join(opt['out_directory'], 'trajectory.h5') # Time step in ps if opt['hmr']: self.stepLen = 0.004 * unit.picoseconds opt['Logger'].info("Hydrogen Mass repartitioning is On") else: self.stepLen = 0.002 * unit.picoseconds opt['timestep'] = self.stepLen # Centering the system to the OpenMM Unit Cell if opt['center'] and box is not None: opt['Logger'].info("[{}] Centering is On".format(opt['CubeTitle'])) # Numpy array in A coords = parmed_structure.coordinates # System Center of Geometry cog = np.mean(coords, axis=0) # System box vectors box_v = parmed_structure.box_vectors.in_units_of(unit.angstrom) / unit.angstrom box_v = np.array([box_v[0][0], box_v[1][1], box_v[2][2]]) # Translation vector delta = box_v / 2 - cog # New Coordinates new_coords = coords + delta parmed_structure.coordinates = new_coords positions = parmed_structure.positions mdstate.set_positions(positions) # Constraint type constraints = md_keys_converter[MDEngines.OpenMM]['constraints'][opt['constraints']] # OpenMM system if box is not None: box_v = parmed_structure.box_vectors.value_in_unit(unit.angstrom) box_v = np.array([box_v[0][0], box_v[1][1], box_v[2][2]]) min_box = np.min(box_v) threshold = (min_box / 2.0) * 0.85 if opt['nonbondedCutoff'] < threshold: cutoff_distance = opt['nonbondedCutoff'] * unit.angstroms else: opt['Logger'].warn("[{}] Cutoff Distance too large for the box size. Set the cutoff distance " "to {} A".format(opt['CubeTitle'], threshold)) cutoff_distance = threshold * unit.angstroms self.system = parmed_structure.createSystem(nonbondedMethod=app.PME, nonbondedCutoff=cutoff_distance, constraints=eval("app.%s" % constraints), removeCMMotion=False, hydrogenMass=4.0 * unit.amu if opt['hmr'] else None) else: # Vacuum self.system = parmed_structure.createSystem(nonbondedMethod=app.NoCutoff, constraints=eval("app.%s" % constraints), removeCMMotion=False, hydrogenMass=4.0 * unit.amu if opt['hmr'] else None) # Add Implicit Solvent Force if opt['implicit_solvent'] != 'None': opt['Logger'].info("[{}] Implicit Solvent Selected".format(opt['CubeTitle'])) implicit_force = parmed_structure.omm_gbsa_force(eval("app.%s" % opt['implicit_solvent']), temperature=opt['temperature'] * unit.kelvin, nonbondedMethod=app.PME, nonbondedCutoff=opt['nonbondedCutoff'] * unit.angstroms) self.system.addForce(implicit_force) # OpenMM Integrator integrator = openmm.LangevinIntegrator(opt['temperature'] * unit.kelvin, 1 / unit.picoseconds, self.stepLen) if opt['SimType'] == 'npt': if box is None: raise ValueError("NPT simulation without box vector") # Add Force Barostat to the system self.system.addForce( openmm.MonteCarloBarostat(opt['pressure'] * unit.atmospheres, opt['temperature'] * unit.kelvin, 25)) # Apply restraints if opt['restraints']: opt['Logger'].info("[{}] RESTRAINT mask applied to: {}" "\tRestraint weight: {}".format(opt['CubeTitle'], opt['restraints'], opt['restraintWt'] * unit.kilocalories_per_mole / unit.angstroms ** 2)) # Select atom to restraint res_atom_set = oeommutils.select_oemol_atom_idx_by_language(opt['molecule'], mask=opt['restraints']) opt['Logger'].info("[{}] Number of restraint atoms: {}".format(opt['CubeTitle'], len(res_atom_set))) # define the custom force to restrain atoms to their starting positions force_restr = openmm.CustomExternalForce('k_restr*periodicdistance(x, y, z, x0, y0, z0)^2') # Add the restraint weight as a global parameter in kcal/mol/A^2 force_restr.addGlobalParameter("k_restr", opt['restraintWt'] * unit.kilocalories_per_mole / unit.angstroms ** 2) # Define the target xyz coords for the restraint as per-atom (per-particle) parameters force_restr.addPerParticleParameter("x0") force_restr.addPerParticleParameter("y0") force_restr.addPerParticleParameter("z0") if opt['restraint_to_reference'] and box is not None: opt['Logger'].info("[{}] Restraint to the Reference State Enabled".format(opt['CubeTitle'])) reference_positions = opt['reference_state'].get_positions() coords = np.array(reference_positions.value_in_unit(unit.nanometers)) # System Center of Geometry cog = np.mean(coords, axis=0) # System box vectors box_v = opt['reference_state'].get_box_vectors().value_in_unit(unit.nanometers) box_v = np.array([box_v[0][0], box_v[1][1], box_v[2][2]]) # Translation vector delta = box_v / 2 - cog # New Coordinates corrected_reference_positions = coords + delta for idx in range(0, len(positions)): if idx in res_atom_set: if opt['restraint_to_reference']: xyz = corrected_reference_positions[idx] # nanometers unit else: xyz = positions[idx].in_units_of(unit.nanometers) / unit.nanometers force_restr.addParticle(idx, xyz) self.system.addForce(force_restr) # Freeze atoms if opt['freeze']: opt['Logger'].info("[{}] FREEZE mask applied to: {}".format(opt['CubeTitle'], opt['freeze'])) freeze_atom_set = oeommutils.select_oemol_atom_idx_by_language(opt['molecule'], mask=opt['freeze']) opt['Logger'].info("[{}] Number of frozen atoms: {}".format(opt['CubeTitle'], len(freeze_atom_set))) # Set atom masses to zero for idx in range(0, len(positions)): if idx in freeze_atom_set: self.system.setParticleMass(idx, 0.0) # Platform Selection if opt['platform'] == 'Auto': # Select the platform for plt_name in ['CUDA', 'OpenCL', 'CPU', 'Reference']: try: platform = openmm.Platform_getPlatformByName(plt_name) break except: if plt_name == 'Reference': raise ValueError('It was not possible to select any OpenMM Platform') else: pass if platform.getName() in ['CUDA', 'OpenCL']: for precision in ['mixed', 'single', 'double']: try: # Set platform precision for CUDA or OpenCL properties = {'Precision': precision} if 'gpu_id' in opt and 'OE_VISIBLE_DEVICES' in os.environ and not in_orion(): properties['DeviceIndex'] = opt['gpu_id'] simulation = app.Simulation(topology, self.system, integrator, platform=platform, platformProperties=properties) break except: if precision == 'double': raise ValueError('It was not possible to select any Precision ' 'for the selected Platform: {}'.format(platform.getName())) else: pass else: # CPU or Reference simulation = app.Simulation(topology, self.system, integrator, platform=platform) else: # Not Auto Platform selection try: platform = openmm.Platform.getPlatformByName(opt['platform']) except Exception as e: raise ValueError('The selected platform is not supported: {}'.format(str(e))) if opt['platform'] in ['CUDA', 'OpenCL']: try: # Set platform CUDA or OpenCL precision properties = {'Precision': opt['cuda_opencl_precision']} simulation = app.Simulation(topology, self.system, integrator, platform=platform, platformProperties=properties) except Exception: raise ValueError('It was not possible to set the {} precision for the {} platform' .format(opt['cuda_opencl_precision'], opt['platform'])) else: # CPU or Reference Platform simulation = app.Simulation(topology, self.system, integrator, platform=platform) # Set starting positions and velocities simulation.context.setPositions(positions) # Set Box dimensions if box is not None: simulation.context.setPeriodicBoxVectors(box[0], box[1], box[2]) # If the velocities are not present in the Parmed structure # new velocity vectors are generated otherwise the system is # restarted from the previous State if opt['SimType'] in ['nvt', 'npt']: if velocities is not None: opt['Logger'].info('[{}] RESTARTING simulation from a previous State'.format(opt['CubeTitle'])) simulation.context.setVelocities(velocities) else: # Set the velocities drawing from the Boltzmann distribution at the selected temperature opt['Logger'].info('[{}] GENERATING a new starting State'.format(opt['CubeTitle'])) simulation.context.setVelocitiesToTemperature(opt['temperature'] * unit.kelvin) # Convert simulation time in steps opt['steps'] = int(round(opt['time'] / (self.stepLen.in_units_of(unit.nanoseconds) / unit.nanoseconds))) # Set Reporters for rep in getReporters(**opt): simulation.reporters.append(rep) # OpenMM platform information mmver = openmm.version.version mmplat = simulation.context.getPlatform() str_logger = '\n' + '-' * 32 + ' SIMULATION ' + '-' * 32 str_logger += '\n' + '{:<25} = {:<10}'.format('time step', str(opt['timestep'])) # Host information for k, v in uname()._asdict().items(): str_logger += "\n{:<25} = {:<10}".format(k, v) opt['Logger'].info("[{}] {} : {}".format(opt['CubeTitle'], k, v)) # Platform properties for prop in mmplat.getPropertyNames(): val = mmplat.getPropertyValue(simulation.context, prop) str_logger += "\n{:<25} = {:<10}".format(prop, val) opt['Logger'].info("[{}] {} : {}".format(opt['CubeTitle'], prop, val)) info = "{:<25} = {:<10}".format("OpenMM Version", mmver) opt['Logger'].info("[{}] OpenMM Version : {}".format(opt['CubeTitle'], mmver)) str_logger += '\n' + info info = "{:<25} = {:<10}".format("Platform in use", mmplat.getName()) opt['Logger'].info("[{}] Platform in use : {}".format(opt['CubeTitle'], mmplat.getName())) str_logger += '\n' + info self.mdstate = mdstate self.parmed_structure = parmed_structure self.opt = opt self.str_logger = str_logger self.omm_simulation = simulation return
def runProductionSimulation(equilibrationFiles, workerNumber, outputDir, seed, parameters, reportFileName, checkpoint, ligandName, replica_id, trajsPerReplica, restart=False): """ Functions that runs the production run at NVT conditions. If a boxRadius is defined in the parameters section, a Flat-bottom harmonic restrains will be applied between the protein and the ligand :param equilibrationFiles: Tuple with the paths for the Amber topology file (prmtop) and the pdb for the system :type equilibrationFiles: Tuple :param workerNumber: Number of the subprocess :type workerNumber: int :param outputDir: path to the directory where the output will be written :type outputDir: str :param seed: Seed to use to generate the random numbers :type seed: int :param parameters: Object with the parameters for the simulation :type parameters: :py:class:`/simulationrunner/SimulationParameters` -- SimulationParameters object :param reportFileName: Name for the file where the energy report will be written :type reportFileName: str :param checkpoint: Path to the checkpoint from where the production run will be restarted (Optional) :type checkpoint: str :param ligandName: Code Name for the ligand :type ligandName: str :param replica_id: Id of the replica running :type replica_id: int :param trajsPerReplica: Number of trajectories per replica :type trajsPerReplica: int :param restart: Whether the simulation run has to be restarted or not :type restart: bool """ deviceIndex = workerNumber workerNumber += replica_id * trajsPerReplica + 1 prmtop, pdb = equilibrationFiles prmtop = app.AmberPrmtopFile(prmtop) trajName = os.path.join( outputDir, constants.AmberTemplates.trajectoryTemplate % (workerNumber, parameters.format)) stateReporter = os.path.join(outputDir, "%s_%s" % (reportFileName, workerNumber)) checkpointReporter = os.path.join( outputDir, constants.AmberTemplates.CheckPointReporterTemplate % workerNumber) lastStep = getLastStep(stateReporter) simulation_length = parameters.productionLength - lastStep # if the string is unicode the PDBReaders fails to read the file (this is # probably due to the fact that openmm was built with python2 in my # computer, will need to test thoroughly with python3) pdb = app.PDBFile(str(pdb)) PLATFORM = mm.Platform_getPlatformByName(str(parameters.runningPlatform)) if parameters.runningPlatform == "CUDA": platformProperties = { "Precision": "mixed", "DeviceIndex": getDeviceIndexStr( deviceIndex, parameters.devicesPerTrajectory, devicesPerReplica=parameters.maxDevicesPerReplica), "UseCpuPme": "false" } else: platformProperties = {} system = prmtop.createSystem(nonbondedMethod=app.PME, nonbondedCutoff=parameters.nonBondedCutoff * unit.angstroms, constraints=app.HBonds, removeCMMotion=True) system.addForce( mm.AndersenThermostat(parameters.Temperature * unit.kelvin, 1 / unit.picosecond)) integrator = mm.VerletIntegrator(parameters.timeStep * unit.femtoseconds) system.addForce( mm.MonteCarloBarostat(1 * unit.bar, parameters.Temperature * unit.kelvin)) if parameters.boxRadius: group_ligand = [] group_protein = [] for atom in prmtop.topology.atoms(): if atom.residue.name == ligandName: group_ligand.append(atom.index) elif atom.residue.name not in ("HOH", "Cl-", "Na+"): group_protein.append(atom.index) # Harmonic flat-bottom restrain for the ligand group_ligand = np.array(group_ligand) group_protein = np.array(group_protein) force = mm.CustomCentroidBondForce( 2, 'step(distance(g1,g2)-r) * (k/2) * (distance(g1,g2)-r)^2') force.addGlobalParameter( "k", 5.0 * unit.kilocalories_per_mole / unit.angstroms**2) force.addGlobalParameter("r", parameters.boxRadius * unit.angstroms) force.addGroup(group_protein) force.addGroup(group_ligand) force.addBond( [0, 1], [] ) # the first parameter is the list of indexes of the groups, the second is the list of perbondparameters system.addForce(force) simulation = app.Simulation(prmtop.topology, system, integrator, PLATFORM, platformProperties=platformProperties) simulation.context.setPositions(pdb.positions) if restart: with open(str(checkpoint), 'rb') as check: simulation.context.loadCheckpoint(check.read()) stateData = open(str(stateReporter), "a") else: simulation.context.setVelocitiesToTemperature( parameters.Temperature * unit.kelvin, seed) stateData = open(str(stateReporter), "w") if parameters.format == "xtc": simulation.reporters.append( XTCReporter(str(trajName), parameters.reporterFreq, append=restart)) elif parameters.format == "dcd": simulation.reporters.append( app.DCDReporter(str(trajName), parameters.reporterFreq, append=restart, enforcePeriodicBox=True)) simulation.reporters.append( app.CheckpointReporter(str(checkpointReporter), parameters.reporterFreq)) simulation.reporters.append( CustomStateDataReporter(stateData, parameters.reporterFreq, step=True, potentialEnergy=True, temperature=True, time_sim=True, volume=True, remainingTime=True, speed=True, totalSteps=parameters.productionLength, separator="\t", append=restart, initialStep=lastStep)) if workerNumber == 1: frequency = min(10 * parameters.reporterFreq, parameters.productionLength) simulation.reporters.append( app.StateDataReporter(sys.stdout, frequency, step=True)) simulation.step(simulation_length) stateData.close()
def perform_md( checkpoint_in_file, checkpoint_out_file, csv_out_file, pdb_out_file, force_constant_ligand=1.0, md_len=1.0, force_constant_chunk=0.1, gpu_id=0, ): if os.path.isfile(checkpoint_out_file): return print("loading pickle") pickle_in = open("complex_system.pickle", "rb") pkl = pickle.load(pickle_in) combined_pmd = pkl[0] print(dir(combined_pmd)) key_interaction = pkl[1:] pickle_in.close() MD_len = md_len * u.nanosecond sim_steps = round(MD_len / (0.002 * u.picosecond)) # Platform definition platformProperties = {} if gpu_id != None: platform = mm.Platform_getPlatformByName("CUDA") platformProperties["CudaPrecision"] = "double" else: platform = mm.Platform_getPlatformByName("CPU") platformProperties["DeterministicForces"] = 'true' # Get indexes of heavy atoms in chunk Chunk_Heavy_Atoms = duck_stuff.getHeavyAtomsInSystem(combined_pmd) # Setting System system = combined_pmd.createSystem( nonbondedMethod=app.PME, nonbondedCutoff=9 * u.angstrom, constraints=app.HBonds, hydrogenMass=None, ) # Apply force on all havy atoms of chunk and apply restraint for the ligand-chunk distance duck_stuff.applyHarmonicPositionalRestraints(system, force_constant_chunk, combined_pmd.positions, Chunk_Heavy_Atoms) duck_stuff.applyLigandChunkRestraint( system, force_constant_ligand, 10.0, 2 * u.angstrom, 3 * u.angstrom, 4 * u.angstrom, key_interaction, ) # Integrator integrator = mm.LangevinIntegrator(300 * u.kelvin, 4 / u.picosecond, 0.002 * u.picosecond) # Setting Simulation object and loading the checkpoint simulation = app.Simulation(combined_pmd.topology, system, integrator, platform, platformProperties) simulation.loadCheckpoint(checkpoint_in_file) # Simulation reporters simulation.reporters.append( app.StateDataReporter( csv_out_file, 2000, step=True, time=True, totalEnergy=True, kineticEnergy=True, potentialEnergy=True, temperature=True, density=True, progress=True, totalSteps=sim_steps, speed=True, )) simulation.reporters.append(app.DCDReporter("md.dcd", 100000)) # Production simulation.step(sim_steps) # Save state in checkpoint file and save coordinates in PDB file state = simulation.context.getState(getPositions=True, getVelocities=True) positions = state.getPositions() app.PDBFile.writeFile(simulation.topology, positions, open(pdb_out_file, "w")) simulation.saveCheckpoint(checkpoint_out_file)
Plot = False ############################################################################### ######Conditional Import#### #the if Plot == True: import matplotlib.pyplot as plt import seaborn as sns sns.set_style('ticks') #Platform definition platform = mm.Platform_getPlatformByName("CUDA") platformProperties = {} platformProperties['CudaPrecision'] = 'mixed' platformProperties['CudaDeviceIndex'] = '0' #Read files prmtopName = 'system_solv.prmtop' inpcrdName = 'system_solv.inpcrd' prmtop = app.AmberPrmtopFile(prmtopName) inpcrd = app.AmberInpcrdFile(inpcrdName) #Minimization logging.info('Minimising...')
def simulate_explicit( pdb_file, top_file, check_point=None, GPU_index=0, output_traj="output.dcd", output_log="output.log", output_cm=None, temperature=300., # ion_strength=0., report_time=10, sim_time=10): """ Start and run an OpenMM NPT simulation with Langevin integrator at 2 fs time step and 300 K. The cutoff distance for nonbonded interactions were set at 1.0 nm, which commonly used along with Amber force field. Long-range nonbonded interactions were handled with PME. Water molecules and ions will be added to the system. Parameters ---------- top_file : topology file (.top, .prmtop, ...) This is the topology file discribe all the interactions within the MD system. pdb_file : coordinates file (.gro, .pdb, ...) This is the molecule configuration file contains all the atom position and PBC (periodic boundary condition) box in the system. GPU_index : Int or Str The device # of GPU to use for running the simulation. Use Strings, '0,1' for example, to use more than 1 GPU output_traj : the trajectory file (.dcd) This is the file stores all the coordinates information of the MD simulation results. output_log : the log file (.log) This file stores the MD simulation status, such as steps, time, potential energy, temperature, speed, etc. temperature : float, unit K The temperature the simulation will be running under ion_strength : float The ion concentration in the system, (to be implemented) report_time : 10 ps The frequency that program writes its information to the output in picoseconds, 10^(-12) s sim_time : 10 ns The timespan of the simulation trajectory in nanoseconds, 10^(-9) s """ top = pmd.load_file(top_file, xyz=pdb_file) system = top.createSystem(nonbondedMethod=app.PME, nonbondedCutoff=1 * u.nanometer, constraints=app.HBonds) dt = 0.002 * u.picoseconds integrator = omm.LangevinIntegrator(temperature * u.kelvin, 1 / u.picosecond, dt) system.addForce(omm.MonteCarloBarostat(1 * u.bar, temperature * u.kelvin)) try: platform = omm.Platform_getPlatformByName("CUDA") properties = {'DeviceIndex': str(GPU_index), 'CudaPrecision': 'mixed'} except Exception: platform = omm.Platform_getPlatformByName("OpenCL") properties = {'DeviceIndex': str(GPU_index)} simulation = app.Simulation(top.topology, system, integrator, platform, properties) simulation.context.setPositions(top.positions) simulation.minimizeEnergy() report_time = report_time * u.picoseconds report_freq = int(report_time / dt) simulation.context.setVelocitiesToTemperature(temperature * u.kelvin, np.random.randint(1, 10000)) simulation.reporters.append(app.DCDReporter(output_traj, report_freq)) if output_cm: simulation.reporters.append(ContactMapReporter(output_cm, report_freq)) simulation.reporters.append( app.StateDataReporter(output_log, report_freq, step=True, time=True, speed=True, potentialEnergy=True, temperature=True, totalEnergy=True)) simulation.reporters.append( app.CheckpointReporter('checkpnt.chk', report_freq)) if check_point: simulation.loadCheckpoint(check_point) sim_time = sim_time * u.nanoseconds nsteps = int(sim_time / dt) simulation.step(nsteps)
def openmm_simulate_amber_explicit( pdb_file, top_file=None, check_point=None, GPU_index=0, output_traj="output.dcd", output_log="output.log", output_cm=None, report_time=10 * u.picoseconds, sim_time=10 * u.nanoseconds, reeval_time=None, ): """ Start and run an OpenMM NPT simulation with Langevin integrator at 2 fs time step and 300 K. The cutoff distance for nonbonded interactions were set at 1.0 nm, which commonly used along with Amber force field. Long-range nonbonded interactions were handled with PME. Parameters ---------- top_file : topology file (.top, .prmtop, ...) This is the topology file discribe all the interactions within the MD system. pdb_file : coordinates file (.gro, .pdb, ...) This is the molecule configuration file contains all the atom position and PBC (periodic boundary condition) box in the system. GPU_index : Int or Str The device # of GPU to use for running the simulation. Use Strings, '0,1' for example, to use more than 1 GPU output_traj : the trajectory file (.dcd) This is the file stores all the coordinates information of the MD simulation results. output_log : the log file (.log) This file stores the MD simulation status, such as steps, time, potential energy, temperature, speed, etc. report_time : 10 ps The program writes its information to the output every 10 ps by default sim_time : 10 ns The timespan of the simulation trajectory """ # set up save dir for simulation results work_dir = os.getcwd() time_label = int(time.time()) omm_path = create_md_path(time_label) print(f"Running simulation at {omm_path}") # setting up running path os.chdir(omm_path) top = pmd.load_file(top_file, xyz=pdb_file) system = top.createSystem(nonbondedMethod=app.PME, nonbondedCutoff=1 * u.nanometer, constraints=app.HBonds) dt = 0.002 * u.picoseconds integrator = omm.LangevinIntegrator(300 * u.kelvin, 1 / u.picosecond, dt) system.addForce(omm.MonteCarloBarostat(1 * u.bar, 300 * u.kelvin)) try: platform = omm.Platform_getPlatformByName("CUDA") properties = {'DeviceIndex': str(GPU_index), 'CudaPrecision': 'mixed'} except Exception: platform = omm.Platform_getPlatformByName("OpenCL") properties = {'DeviceIndex': str(GPU_index)} simulation = app.Simulation(top.topology, system, integrator, platform, properties) # simulation.context.setPositions(top.positions) if pdb.get_coordinates().shape[0] == 1: simulation.context.setPositions(pdb.positions) shutil.copy2(pdb_file, './') else: positions = random.choice(pdb.get_coordinates()) simulation.context.setPositions(positions / 10) #parmed \AA to OpenMM nm pdb.write_pdb('start.pdb', coordinates=positions) simulation.minimizeEnergy() simulation.context.setVelocitiesToTemperature(300 * u.kelvin, random.randint(1, 10000)) simulation.step(int(100 * u.picoseconds / (2 * u.femtoseconds))) report_freq = int(report_time / dt) simulation.reporters.append(app.DCDReporter(output_traj, report_freq)) if output_cm: simulation.reporters.append(ContactMapReporter(output_cm, report_freq)) simulation.reporters.append( app.StateDataReporter(output_log, report_freq, step=True, time=True, speed=True, potentialEnergy=True, temperature=True, totalEnergy=True)) simulation.reporters.append( app.CheckpointReporter('checkpnt.chk', report_freq)) if check_point: simulation.loadCheckpoint(check_point) nsteps = int(sim_time / dt) simulation.step(nsteps) if reeval_time: nsteps = int(reeval_time / dt) niter = int(sim_time / reeval_time) for i in range(niter): if os.path.exists('../halt'): return elif os.path.exists('new_pdb'): print("Found new.pdb, starting new sim...") # cleaning up old runs del simulation # starting new simulation with new pdb with open('new_pdb', 'r') as fp: new_pdb = fp.read().split()[0] os.chdir(work_dir) openmm_simulate_amber_explicit( new_pdb, top_file=top_file, check_point=None, GPU_index=GPU_index, output_traj=output_traj, output_log=output_log, output_cm=output_cm, report_time=report_time, sim_time=sim_time, reeval_time=reeval_time, ) else: simulation.step(nsteps) else: nsteps = int(sim_time / dt) simulation.step(nsteps) os.chdir(work_dir) if not os.path.exists('../halt'): openmm_simulate_amber_explicit( pdb_file, top_file=top_file, check_point=None, GPU_index=GPU_index, output_traj=output_traj, output_log=output_log, output_cm=output_cm, report_time=report_time, sim_time=sim_time, reeval_time=reeval_time, ) else: return
def do_equlibrate(force_constant_equilibrate=1.0, gpu_id=0): # Find the interations keyInteraction = cal_ints.find_interaction() # Platform definition platform = mm.Platform_getPlatformByName("OpenCL") platformProperties = {} platformProperties['OpenCLPrecision'] = 'mixed' platformProperties["OpenCLDeviceIndex"] = gpu_id print("loading pickle") pickle_in = open('complex_system.pickle', 'rb') combined_pmd = pickle.load(pickle_in)[0] combined_pmd.symmetry = None pickle_in.close() ################## ################## # Minimisation # ################## ################## print('Minimising...') # Define system system = combined_pmd.createSystem(nonbondedMethod=app.PME, nonbondedCutoff=9 * u.angstrom) # Get indexes of heavy atoms in chunk Chunk_Heavy_Atoms = duck_stuff.getHeavyAtomsInSystem(combined_pmd) # Apply force on all havy atoms of chunk duck_stuff.applyHarmonicPositionalRestraints(system, force_constant_equilibrate, combined_pmd.positions, Chunk_Heavy_Atoms) # Integrator integrator = mm.VerletIntegrator(1 * u.femtosecond) # Define Simulation simulation = app.Simulation(combined_pmd.topology, system, integrator, platform, platformProperties) simulation.context.setPositions(combined_pmd.positions) print(simulation.context.getPlatform().getName()) for key in simulation.context.getPlatform().getPropertyNames(): print( key, simulation.context.getPlatform().getPropertyValue( simulation.context, key)) # Minimizing energy simulation.minimizeEnergy(maxIterations=1000) # Saving minimised positions positions = simulation.context.getState(getPositions=True).getPositions() app.PDBFile.writeFile(simulation.topology, positions, open('minimisation.pdb', 'w')) ########################## ########################## # Equlibration - heating # ########################## ########################## #new minimised positions, however using old restraints # Define new system system = combined_pmd.createSystem(nonbondedMethod=app.PME, nonbondedCutoff=9 * u.angstrom, constraints=app.HBonds, hydrogenMass=None) # Apply force on all havy atoms of chunk and apply restraint for the ligand-chunk distance duck_stuff.applyHarmonicPositionalRestraints(system, force_constant_equilibrate, combined_pmd.positions, Chunk_Heavy_Atoms) duck_stuff.applyLigandChunkRestraint(system, force_constant_equilibrate, 10.0, 2 * u.angstrom, 3 * u.angstrom, 4 * u.angstrom, keyInteraction) # Intergator integrator = mm.LangevinIntegrator(300 * u.kelvin, 4 / u.picosecond, 0.002 * u.picosecond) # Define Simulation simulation = app.Simulation(combined_pmd.topology, system, integrator, platform, platformProperties) simulation.context.setPositions( positions) #changing coordintes to minimized # Reporters simulation.reporters.append( app.StateDataReporter("heating.csv", 1000, time=True, potentialEnergy=True, temperature=True, density=True, remainingTime=True, speed=True, totalSteps=50000)) simulation.reporters.append(app.DCDReporter("heating.dcd", 1000)) # Heating the system print("Heating ... ") simulation.step(50000) # 0.01 ns # Save the positions and velocities positions = simulation.context.getState(getPositions=True).getPositions() velocities = simulation.context.getState( getVelocities=True).getVelocities() app.PDBFile.writeFile(simulation.topology, positions, open('heating_final.pdb', 'w')) #clear reporters simulation.reporters = [] ########################## ########################## # Equlibration - density # ########################## ########################## simulation = duck_stuff.setUpNPTEquilibration(system, combined_pmd, platform, platformProperties, positions, velocities) # Reporters simulation.reporters.append( app.StateDataReporter("density.csv", 1000, time=True, potentialEnergy=True, temperature=True, density=True, remainingTime=True, speed=True, totalSteps=50000)) # Correcting the density print("Correcting density") simulation.step(50000) # 0.01 ns # Save the positions and velocities positions = simulation.context.getState(getPositions=True).getPositions() velocities = simulation.context.getState( getVelocities=True).getVelocities() app.PDBFile.writeFile(simulation.topology, positions, open('density_final.pdb', 'w')) #saving simulation stage checkpoint = 'equil.chk' simulation.saveCheckpoint(checkpoint) return [checkpoint]
import numpy as np import pandas as pd import simtk.openmm as mm from simtk import unit as u from openmmtools import hmc_integrators, testsystems opencl = mm.Platform_getPlatformByName("OpenCL") cuda = mm.Platform_getPlatformByName("CUDA") cpu = mm.Platform_getPlatformByName("CPU") #platform = cpu #platform = opencl platform = cuda n_steps = 5000 temperature = 300. * u.kelvin #testsystem = testsystems.WaterBox(box_edge=3.18 * u.nanometers) # Around 1060 molecules of water testsystem = testsystems.FlexibleWaterBox(box_edge=3.18 * u.nanometers) # Around 1060 molecules of water #testsystem = testsystems.AlanineDipeptideExplicit() system = testsystem.system integrator = mm.LangevinIntegrator(temperature, 0.25 / u.picoseconds, 0.25 * u.femtoseconds) #integrator = hmc_integrators.RandomTimestepGHMC(temperature, 12, 0.25 * u.femtoseconds) context = mm.Context(testsystem.system, integrator, platform) context.setPositions(testsystem.positions) context.setVelocitiesToTemperature(temperature) integrator.step(5000) positions = context.getState(getPositions=True).getPositions()