def _get_prmtop(self, mol, prm): from htmd.parameterization.writers import writeFRCMOD, getAtomTypeMapping from tempfile import TemporaryDirectory from subprocess import call from simtk.openmm import app with TemporaryDirectory() as tmpDir: frcFile = os.path.join(tmpDir, 'mol.frcmod') mapping = getAtomTypeMapping(prm) writeFRCMOD(mol, prm, frcFile, typemap=mapping) mol2 = mol.copy() mol2.atomtype[:] = np.vectorize(mapping.get)(mol2.atomtype) molFile = os.path.join(tmpDir, 'mol.mol2') mol2.write(molFile) with open(os.path.join(tmpDir, 'tleap.inp'), 'w') as file: file.writelines( ('loadAmberParams %s\n' % frcFile, 'MOL = loadMol2 %s\n' % molFile, 'saveAmberParm MOL mol.prmtop mol.inpcrd\n', 'quit')) with open(os.path.join(tmpDir, 'tleap.out'), 'w') as out: call(('tleap', '-f', 'tleap.inp'), cwd=tmpDir, stdout=out) prmtop = app.AmberPrmtopFile(os.path.join(tmpDir, 'mol.prmtop')) return prmtop
def _system_from_prmtop(self, prmtop_path, impcrd_path): # load in Amber input files prmtop = app.AmberPrmtopFile(prmtop_path) inpcrd = app.AmberInpcrdFile(incrd_path) from numpy import array, float64 from simtk import unit positions = 10 * array(inpcrd.positions.value_in_unit(unit.nanometers), float64) # Angstroms self._particle_positions = positions # Ordered atoms to match inpcrd order. # PDB can have atoms for a chain not contiguous, e.g. chain A hetatm at end of file. # But inpcrd has reordered so all chain atoms are contiguous. atom_pos = atoms.scene_coords from chimerax.geometry import find_closest_points i1, i2, near = find_closest_points(positions, atom_pos, 1.0) from numpy import empty, int32 ai = empty((len(i1), ), int32) ai[i1] = near self.atoms = oatoms = atoms[ai] # diff = oatoms.scene_coords - positions # print ('diff', diff.max(), diff.min()) # p2a = {tuple(int(x) for x in a.scene_coord):a for a in atoms} # oatoms = [p2a[tuple(int(x) for x in p)] for p in positions] # print('\n'.join('%s %s' %(str(a1), str(a2)) for a1,a2 in zip(atoms, oatoms))) # print ('inpcrd', positions[:10]) # print ('atoms', atom_pos[:10]) # prepare system and integrator system = prmtop.createSystem(nonbondedMethod=app.CutoffNonPeriodic, nonbondedCutoff=1.0 * unit.nanometers, constraints=app.HBonds, rigidWater=True, ewaldErrorTolerance=0.0005) self._system = system
def equilibrate(self): if os.path.exists(self.equil_pdb_filename): return prmtop = app.AmberPrmtopFile(self.prmtop_filename) inpcrd = app.AmberInpcrdFile(self.inpcrd_filename) system = prmtop.createSystem(nonbondedMethod=app.PME, nonbondedCutoff=CUTOFF, constraints=app.HBonds) integrator = mm.LangevinIntegrator(self.temperature, EQUIL_FRICTION, EQUIL_TIMESTEP) system.addForce(mm.MonteCarloBarostat(PRESSURE, self.temperature, BAROSTAT_FREQUENCY)) simulation = app.Simulation(prmtop.topology, system, integrator) simulation.context.setPositions(inpcrd.positions) state = simulation.context.getState(getEnergy=True) print(state.getPotentialEnergy()) print('Minimizing.') simulation.minimizeEnergy() state = simulation.context.getState(getEnergy=True) print(state.getPotentialEnergy()) simulation.context.setVelocitiesToTemperature(self.temperature) print('Equilibrating.') simulation.reporters.append(app.DCDReporter(self.equil_dcd_filename, OUTPUT_FREQUENCY_EQUIL)) simulation.step(N_EQUIL_STEPS) # Re-write a better PDB with correct box sizes. traj = md.load(self.equil_dcd_filename, top=self.prmtop_filename)[-1] traj.save(self.equil_pdb_filename)
def MinimizedEnergy(filepath, gpu=False): prmtop = app.AmberPrmtopFile(f'{filepath}.prmtop') inpcrd = app.AmberInpcrdFile(f'{filepath}.inpcrd') print(f'{filepath}.prmtop') system = prmtop.createSystem(implicitSolvent=app.GBn2, nonbondedMethod=app.CutoffNonPeriodic, nonbondedCutoff=1.0 * unit.nanometers, constraints=app.HBonds, rigidWater=True, ewaldErrorTolerance=0.0005) integrator = mm.LangevinIntegrator(310.15 * unit.kelvin, 1.0 / unit.picoseconds, 2.0 * unit.femtoseconds) integrator.setConstraintTolerance(0.00001) # TODO: This should just recognize whatever the computer is capable of, not force CUDA. if gpu: platform = 'CUDA' else: platform = 'CPU' platform = mm.Platform.getPlatformByName(platform) simulation = app.Simulation(prmtop.topology, system, integrator, platform) simulation.context.setPositions(inpcrd.positions) simulation.minimizeEnergy() energy = simulation.context.getState( getEnergy=True).getPotentialEnergy().value_in_unit(unit.kilojoule / unit.mole) return energy
def _openmm_init(fname_prmtop, platformName=None): prmtop = app.AmberPrmtopFile(fname_prmtop) system = prmtop.createSystem(nonbondedMethod=app.NoCutoff, constraints=app.HBonds, implicitSolvent=None) time_step = 1.0 # fs integrator = omm.LangevinIntegrator(300.0 * unit.kelvin, 1.0 / unit.picoseconds, time_step * unit.femtoseconds) platform = omm.Platform.getPlatformByName('Reference') properties = {} if platformName == 'OpenCL': platform = omm.Platform.getPlatformByName('OpenCL') properties = {'OpenCLPrecision': 'mixed'} if platformName == 'CUDA': platform = omm.Platform.getPlatformByName('CUDA') properties = {'CudaPrecision': 'mixed'} simulation = app.Simulation(prmtop.topology, system, integrator, platform, properties) charge_list = prmtop._prmtop.getCharges() natom = prmtop._prmtop.getNumAtoms() nonbond = np.array(prmtop._prmtop.getNonbondTerms()) return simulation, natom, charge_list, nonbond
def MinimizedEnergy(filepath): prmtop = app.AmberPrmtopFile(f'{filepath}.prmtop') inpcrd = app.AmberInpcrdFile(f'{filepath}.inpcrd') system = prmtop.createSystem(implicitSolvent=app.GBn2, nonbondedMethod=app.CutoffNonPeriodic, nonbondedCutoff=1.0*unit.nanometers, constraints=app.HBonds, rigidWater=True, ewaldErrorTolerance=0.0005) integrator = mm.LangevinIntegrator(300*unit.kelvin, 1.0/unit.picoseconds, 2.0*unit.femtoseconds) integrator.setConstraintTolerance(0.00001) # TODO: This should just recognize whatever the computer is capable of, not force CUDA. platform = mm.Platform.getPlatformByName('CUDA') # TODO: I am not sure if mixed precision is necessary. It dramatically changes the results. properties = {'CudaPrecision': 'mixed'} simulation = app.Simulation(prmtop.topology, system, integrator, platform) simulation.context.setPositions(inpcrd.positions) simulation.minimizeEnergy() energy = simulation.context.getState(getEnergy=True).getPotentialEnergy().value_in_unit(unit.kilojoule/unit.mole) return energy
def _create_implicit_solvent_openmm(self, mol): """ Take a list of oemols, and generate openmm systems and positions for each. Parameters ---------- mol : oemol oemol to be turned into system, positions Returns ------- system : simtk.openmm.System openmm system corresponding to molecule positions : np.array, Quantity nm array of atomic positions """ molecule_name = oeiupac.OECreateIUPACName(mol) openmoltools.openeye.enter_temp_directory() _, tripos_mol2_filename = openmoltools.openeye.molecule_to_mol2( mol, tripos_mol2_filename=molecule_name + '.tripos.mol2', conformer=0, residue_name='MOL') gaff_mol2, frcmod = openmoltools.amber.run_antechamber( molecule_name, tripos_mol2_filename) prmtop_file, inpcrd_file = openmoltools.amber.run_tleap( molecule_name, gaff_mol2, frcmod) prmtop = app.AmberPrmtopFile(prmtop_file) crd = app.AmberInpcrdFile(inpcrd_file) system = prmtop.createSystem(implicitSolvent=self.implicit_solvent, constraints=self.constraints, removeCMMotion=False) positions = crd.getPositions(asNumpy=True) return system, positions
def _get_prmtop(self): from parameterize.parameterization.writers import ( writeFRCMOD, getAtomTypeMapping, ) with TemporaryDirectory() as tmpDir: frcFile = os.path.join(tmpDir, "mol.frcmod") mapping = getAtomTypeMapping(self._parameters) writeFRCMOD(self.molecule, self._parameters, frcFile, typemap=mapping) mol2 = self.molecule.copy() mol2.atomtype[:] = np.vectorize(mapping.get)(mol2.atomtype) molFile = os.path.join(tmpDir, "mol.mol2") mol2.write(molFile) with open(os.path.join(tmpDir, "tleap.inp"), "w") as file: file.writelines(( "loadAmberParams %s\n" % frcFile, "MOL = loadMol2 %s\n" % molFile, "saveAmberParm MOL mol.prmtop mol.inpcrd\n", "quit", )) with open(os.path.join(tmpDir, "tleap.out"), "w") as out: call(("tleap", "-f", "tleap.inp"), cwd=tmpDir, stdout=out) prmtop = app.AmberPrmtopFile(os.path.join(tmpDir, "mol.prmtop")) return prmtop
def setUp(self): self.temperature = 300.0 * unit.kelvin self.pressure = 1.0 * unit.atmospheres self.timestep = 1.0 * unit.femtoseconds self.collision_rate = 9.1 / unit.picoseconds self.pH = 7.4 self.platform_name = 'CPU' testsystems = get_data('edchky_explicit', 'testsystems') self.positions = openmm.XmlSerializer.deserialize( open('{}/edchky-explicit.state.xml'.format( testsystems)).read()).getPositions(asNumpy=True) self.system = openmm.XmlSerializer.deserialize( open('{}/edchky-explicit.sys.xml'.format(testsystems)).read()) self.prmtop = app.AmberPrmtopFile( '{}/edchky-explicit.prmtop'.format(testsystems)) self.cpin_filename = '{}/edchky-explicit.cpin'.format(testsystems) calibration_settings = dict() calibration_settings["temperature"] = self.temperature calibration_settings["timestep"] = self.timestep calibration_settings["pressure"] = self.pressure calibration_settings["collision_rate"] = self.collision_rate calibration_settings["pH"] = self.pH calibration_settings["solvent"] = "explicit" calibration_settings["nsteps_per_trial"] = 5 self.calibration_settings = calibration_settings
def create_system_from_amber(prmtop_filename, crd_filename, verbose=False): """Utility function. Create and return an OpenMM System given a prmtop and crd, AMBER format files. Parameters ---------- prmtop_filename : str (filename) Filename of input AMBER format prmtop file crd_filename : str (filename) Filename of input AMBER format crd file Returns _______ topology : OpenMM Topology system : OpenMM System positions : initial atomic positions (OpenMM) """ # Create System object prmtop = app.AmberPrmtopFile(prmtop_filename) topology = prmtop.topology system = prmtop.createSystem(nonbondedMethod=app.NoCutoff, constraints=None, implicitSolvent=None) # Read coordinates crd = app.AmberInpcrdFile(crd_filename) positions = crd.getPositions() return (topology, system, positions)
def _setup_OpenMM(self, moiety, phase): if not hasattr(self, '_OpenMM_sims'): self._OpenMM_sims = {} key = moiety + phase if not key in self._OpenMM_sims.keys(): import simtk.openmm import simtk.openmm.app as OpenMM_app prmtop = OpenMM_app.AmberPrmtopFile( self.args.FNs['prmtop'][moiety]) inpcrd = OpenMM_app.AmberInpcrdFile( self.args.FNs['inpcrd'][moiety]) OMM_system = prmtop.createSystem(nonbondedMethod=OpenMM_app.NoCutoff, \ constraints=None, implicitSolvent={ 'OpenMM_Gas':None, 'OpenMM_GBn':OpenMM_app.GBn, 'OpenMM_GBn2':OpenMM_app.GBn2, 'OpenMM_HCT':OpenMM_app.HCT, 'OpenMM_OBC1':OpenMM_app.OBC1, 'OpenMM_OBC2':OpenMM_app.OBC2}[phase]) # Set receptor atom mass to zero to facilitate future minimization if moiety == 'R': for i in range(OMM_system.getNumParticles()): OMM_system.setParticleMass(i, 0) elif moiety == 'RL': for i in range(self.top_RL.L_first_atom) + \ range(self.top_RL.L_first_atom + self.top.universe.numberOfAtoms(), \ OMM_system.getNumParticles()): OMM_system.setParticleMass(i, 0) dummy_integrator = simtk.openmm.LangevinIntegrator(300*simtk.unit.kelvin, \ 1/simtk.unit.picosecond, 0.002*simtk.unit.picoseconds) self._OpenMM_sims[key] = OpenMM_app.Simulation(prmtop.topology, \ OMM_system, dummy_integrator)
def test_amber_implicit(prmtop_filename, inpcrd_filename): logger.info("====================================================================") logger.info("Creating system...") from simtk.openmm import app prmtop = app.AmberPrmtopFile(prmtop_filename) reference_system = prmtop.createSystem(constraints=app.HBonds, nonbondedMethod=app.NoCutoff, implicitSolvent=app.OBC1) # Read positions. inpcrd = app.AmberInpcrdFile(inpcrd_filename, loadBoxVectors=False) positions = inpcrd.getPositions(asNumpy=True) # Set box vectors. #box_vectors = inpcrd.getBoxVectors(asNumpy=True) #system.setDefaultPeriodicBoxVectors(box_vectors[0], box_vectors[1], box_vectors[2]) receptor_atoms = range(0,1326) ligand_atoms = range(1326, 1356) # Minimize. logger.info("Minimizing...") timestep = 1.0 * units.femtoseconds integrator = openmm.VerletIntegrator(timestep) context = openmm.Context(reference_system, integrator) context.setPositions(positions) openmm.LocalEnergyMinimizer.minimize(context, 1.0, 100) state = context.getState(getEnergy=True, getPositions=True) positions = state.getPositions(asNumpy=True) del context, integrator logger.info("Done.") alchemical_factory_check(reference_system, positions, receptor_atoms, ligand_atoms) #benchmark(reference_system, positions, receptor_atoms, ligand_atoms) logger.info("====================================================================") logger.info("")
def oemol_to_openmm_system(oemol, molecule_name): """ Create an openmm system out of an oemol Returns ------- system : openmm.System object the system from the molecule positions : [n,3] np.array of floats """ _, tripos_mol2_filename = openmoltools.openeye.molecule_to_mol2( oemol, tripos_mol2_filename=molecule_name + '.tripos.mol2', conformer=0, residue_name='MOL') gaff_mol2, frcmod = openmoltools.openeye.run_antechamber( molecule_name, tripos_mol2_filename) prmtop_file, inpcrd_file = openmoltools.utils.run_tleap( molecule_name, gaff_mol2, frcmod) prmtop = app.AmberPrmtopFile(prmtop_file) # NOTE implicit solvent not supported by this SystemGenerator #system = prmtop.createSystem(implicitSolvent=app.OBC1) system = prmtop.createSystem(implicitSolvent=None) crd = app.AmberInpcrdFile(inpcrd_file) return system, crd.getPositions(asNumpy=True), prmtop.topology
def build(self, target_path="", file_name="out"): build_string = self.build_string if self.chains: for chain in self.chains: self.build_string += chain.structure.init_string for index, chain in enumerate(self.chains): if chain.sequence: self.build_string +=""" CHAIN%s = sequence {%s} """%(index, chain.sequence) else: raise ValueError("Empty Chain Index: %s"%index) chain_string = " ".join(["CHAIN%s"%index for index in range(len(self.chains))]) self.build_string +=""" UNION = combine {%s} saveamberparm UNION %s.prmtop %s.inpcrd quit """%(chain_string, target_path+file_name, target_path+file_name) infile = open("%s%s.in"%(target_path, file_name),"w") infile.write(self.build_string) infile.close() self.build_string = build_string #os.remove("%s%s.in"%(target_path, file_name)) result = subprocess.call("tleap -f %s%s.in"%(target_path,file_name),shell=True) self.prmtop = app.AmberPrmtopFile(target_path+file_name+".prmtop") self.inpcrd = app.AmberInpcrdFile(target_path+file_name+".inpcrd") self.topology = self.prmtop.topology self.positions = self.inpcrd.positions self.system = self.prmtop.createSystem(nonbondedMethod=app.NoCutoff, constraints=None, implicitSolvent=app.OBC1) self.integrator = mm.LangevinIntegrator(300.*unit.kelvin, 1./unit.picosecond, 0.002*unit.picoseconds) self.simulation = app.Simulation(self.topology, self.system, self.integrator) else: raise ValueError('Empty Complex! CANNOT build!')
def production(self): if os.path.exists(self.production_dcd_filename) and os.path.exists(self.production_data_filename): return prmtop = app.AmberPrmtopFile(self.prmtop_filename) pdb = app.PDBFile(self.equil_pdb_filename) system = prmtop.createSystem(nonbondedMethod=app.PME, nonbondedCutoff=CUTOFF, constraints=app.HBonds) integrator = mm.LangevinIntegrator(self.temperature, FRICTION, TIMESTEP) system.addForce(mm.MonteCarloBarostat(PRESSURE, self.temperature, BAROSTAT_FREQUENCY)) simulation = app.Simulation(prmtop.topology, system, integrator) simulation.context.setPositions(pdb.positions) simulation.context.setPeriodicBoxVectors(*pdb.topology.getPeriodicBoxVectors()) simulation.context.setVelocitiesToTemperature(self.temperature) print('Production.') simulation.reporters.append(app.DCDReporter(self.production_dcd_filename, OUTPUT_FREQUENCY)) simulation.reporters.append(app.StateDataReporter(self.production_data_filename, OUTPUT_DATA_FREQUENCY, step=True, potentialEnergy=True, temperature=True, density=True)) converged = False while not converged: simulation.step(N_STEPS) d = pd.read_csv(self.production_data_filename, names=["step", "U", "Temperature", "Density"], skiprows=1) density_ts = np.array(d.Density) [t0, g, Neff] = ts.detectEquilibration(density_ts, nskip=1000) density_ts = density_ts[t0:] density_mean_stderr = density_ts.std() / np.sqrt(Neff) if density_mean_stderr < STD_ERROR_TOLERANCE: converged = True
def parameterize_molecule(molecule, implicitSolvent=app.OBC1, constraints=None, cleanup=True, verbose=False): """ Parameterize the specified molecule for AMBER. Parameters ---------- molecule : openeye.oechem.OEMol The molecule to be parameterized. implicitSolvent : default=app.OBC1 The implicit solvent model to use; one of [None, HCT, OBC1, OBC2, GBn, GBn2] constraints : default=None Constraints to use; one of [None, HBonds, AllBonds, HAngles] cleanup : bool, optional, default=False If True, work done in a temporary working directory will be deleted. Returns ------- system : simtk.openmm.System The OpenMM System of the molecule. topology : simtk.openmm.app.Topology The OpenMM topology of the molecule. positions : The positions of the molecule. gaff_molecule : oechem.OEMol The OEMol molecule with GAFF atom and bond types. """ # Create molecule and geometry. molecule = gaff2xml.openeye.iupac_to_oemol(iupac_name) # Create a a temporary directory. working_directory = tempfile.mkdtemp() old_directory = os.getcwd() os.chdir(working_directory) # Parameterize molecule for AMBER (currently using old machinery for convenience) # TODO: Replace this with gaff2xml stuff amber_prmtop_filename = 'molecule.prmtop' amber_inpcrd_filename = 'molecule.inpcrd' amber_off_filename = 'molecule.off' oldmmtools.parameterizeForAmber(molecule, amber_prmtop_filename, amber_inpcrd_filename, charge_model=None, offfile=amber_off_filename) # Read in the molecule with GAFF atom and bond types print "Overwriting OEMol with GAFF atom and bond types..." gaff_molecule = oldmmtools.loadGAFFMolecule(molecule, amber_off_filename) # Load positions. inpcrd = app.AmberInpcrdFile(amber_inpcrd_filename) positions = inpcrd.getPositions() # Load system (with GB parameters). prmtop = app.AmberPrmtopFile(amber_prmtop_filename) system = prmtop.createSystem(implicitSolvent=implicitSolvent, constraints=constraints) # Clean up temporary files. os.chdir(old_directory) if cleanup: commands.getoutput('rm -r %s' % working_directory) else: print "Work done in %s..." % working_directory return [system, topology, positions, gaff_molecule]
def setup_simulation(self, system, settings): inpcrd = app.AmberInpcrdFile(settings['coordinates']) prmtop = app.AmberPrmtopFile(self.topology) platform, prop = self.setup_platform(settings) simulation = app.Simulation(prmtop.topology, system, self.integrator, platform, prop) simulation.context.setPositions(inpcrd.positions) return simulation
def serialise_system(self): """Serialise the amber style files into an openmm object.""" prmtop = app.AmberPrmtopFile(self.prmtop) system = prmtop.createSystem(nonbondedMethod=app.NoCutoff, constraints=None) with open('serialised.xml', 'w+') as out: out.write(XmlSerializer.serializeSystem(system))
def build_simulation_from_dictionary(self): d = {} d = json.load(open(self.lot_inp_file)) print(d) # crystal use_crystal = d.get('use_crystal', 'no') # PME use_pme = d.get('use_pme', 'no') cutoff = d.get('cutoff', 1.0) # prmtop, inpcrd prmtopfile = d.get('prmtop', None) inpcrdfile = d.get('inpcrd', None) # Integrator will never be used (Simulation requires one) integrator = openmm.VerletIntegrator(1.0) # create simulation object if use_crystal == 'yes': crystal = load_file(prmtopfile, inpcrdfile) if use_pme == 'yes': system = crystal.createSystem( nonbondedMethod=openmm_app.PME, nonbondedCutoff=cutoff * openmm_units.nanometer, ) else: system = crystal.createSystem( nonbondedMethod=openmm_app.NoCutoff, ) self.simulation = openmm_app.Simulation(crystal.topology, system, integrator) # set the box vectors inpcrd = openmm_app.AmberInpcrdFile(inpcrdfile) if inpcrd.boxVectors is not None: print(" setting box vectors") print(inpcrd.boxVectors) self.simulation.context.setPeriodicBoxVectors( *inpcrd.boxVectors) else: prmtop = openmm_app.AmberPrmtopFile(prmtopfile) if use_pme == 'yes': system = prmtop.createSystem( nonbondedMethod=openmm_app.PME, nonbondedCutoff=cutoff * openmm_units.nanometer, ) else: system = prmtop.createSystem( nonbondedMethod=openmm_app.NoCutoff, ) self.simulation = openmm_app.Simulation( prmtop.topology, system, integrator, )
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 _build_system(self, molecule: Ligand, input_files: Optional[List[str]] = None) -> System: """ Build a system using the amber prmtop files, first we must use antechamber to prep the molecule. """ prmtoop_file = self._get_prmtop(molecule=molecule) prmtop = app.AmberPrmtopFile(prmtoop_file) system = prmtop.createSystem(nonbondedMethod=app.NoCutoff, constraints=None) return system
def __init__(self, config: Config): """ :param resource_root: """ super().__init__() self.systemloader_config = config self.prmtop = app.AmberPrmtopFile( self.systemloader_config.resource_root + 'com.prmtop') self.inpcrd = app.AmberInpcrdFile( self.systemloader_config.resource_root + 'com.inpcrd')
def setUp(self): prmtop = app.AmberPrmtopFile('systems/water-box-216.prmtop') system = prmtop.createSystem(nonbondedMethod=app.PME, nonbondedCutoff=0.9*unit.nanometers, constraints=app.HBonds, rigidWater=True, ewaldErrorTolerance=0.0005) integrator = mm.LangevinIntegrator(300*unit.kelvin, 1.0/unit.picoseconds, 2.0*unit.femtoseconds) self.simulation = app.Simulation(prmtop.topology, system, integrator, mm.Platform.getPlatformByName('Reference'))
def 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 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 ligand_energy(): #self.command("saveamberparm ligand ligand.prmtop ligand.inpcrd") #time.sleep(1) from mpmath import mp as math math.prec = 200 lig_top = app.AmberPrmtopFile("ligand.prmtop") lig_crd = app.AmberInpcrdFile("ligand.inpcrd") lig_system = lig_top.createSystem(nonbondedMethod=NoCutoff, nonbondedCutoff=10*nanometer, constraints=HAngles, implicitSolvent=OBC1) lig_integrator = LangevinIntegrator(300*kelvin, 1/picosecond, 0.002*picoseconds) lig_simulation = Simulation(lig_top.topology, lig_system, lig_integrator) lig_simulation.context.setPositions(lig_crd.positions) lig_state = lig_simulation.context.getState(getEnergy = True) lig_energy = lig_state.getPotentialEnergy().value_in_unit(kilojoule_per_mole) return lig_energy
def step(array): global _INFILE global _BETA global _NSTEP beta = _BETA old_positions, Ntides, is_3prime = array internal = Aptamer("leaprc.ff12SB",_INFILE) identifier = Ntides.replace(" ","") internal.sequence(identifier,Ntides.strip()) internal.unify(identifier) internal.command("saveamberparm union %s.prmtop %s.inpcrd"%(identifier,identifier)) time.sleep(2) #print("WhereamI?") print("Identifier: "+Ntides) volume = (2*math.pi)**5 aptamer_top = app.AmberPrmtopFile("%s.prmtop"%identifier) aptamer_crd = app.AmberInpcrdFile("%s.inpcrd"%identifier) # print("loaded") # if is_3prime == 1: en_pos = [mcmc_sample(aptamer_top, aptamer_crd, old_positions, index, Nsteps=_NSTEP) for index in range(10)] # else: # en_pos_task = [mcmc_sample_five(aptamer_top, aptamer_crd, old_positions, index, Nsteps=200) for index in range(20)] # barrier() # en_pos = value(en_pos_task) en = [] positions = [] positions_s = [] for elem in en_pos: en += elem[0] #print(elem[2], elem[1]) positions_s.append([elem[2], elem[1]]) positions = min(positions_s)[1] fil = open("best_structure%s.pdb"%Ntides,"w") app.PDBFile.writeModel(aptamer_top.topology,positions,file=fil) fil.close() del fil Z = volume*math.fsum([math.exp(-beta*elem) for elem in en])/len(en) P = [math.exp(-beta*elem)/Z for elem in en] S = volume*math.fsum([-elem*math.log(elem*volume) for elem in P])/len(P) print("%s : %s"%(Ntides,S)) return positions, Ntides, S
def from_amber(cls, prmtop, inpcrd, temperature=50 * u.kelvin): prmtop = app.AmberPrmtopFile(prmtop) inpcrd = app.AmberInpcrdFile(inpcrd) system = prmtop.createSystem(nonbondedMethod=app.PME, constraints=app.HBonds, nonbondedCutoff=10 * u.angstroms, switchDistance=8 * u.angstroms) thermodynamic_state = ThermodynamicState(system, temperature=temperature) sampler_state = SamplerState( positions=inpcrd.getPositions(asNumpy=True), box_vectors=inpcrd.boxVectors) return Esmacs(thermodynamic_state, sampler_state, prmtop.topology)
def setUp(self): self.temperature = 300.0 * unit.kelvin self.pressure = 1.0 * unit.atmospheres self.timestep = 1.0 * unit.femtoseconds self.collision_rate = 9.1 / unit.picoseconds self.pH = 9.6 self.platform_name = 'CPU' testsystems = get_data('tyr_explicit', 'testsystems') self.positions = openmm.XmlSerializer.deserialize( open('{}/tyr.state.xml'.format(testsystems)).read()).getPositions( asNumpy=True) self.system = openmm.XmlSerializer.deserialize( open('{}/tyr.sys.xml'.format(testsystems)).read()) self.prmtop = app.AmberPrmtopFile('{}/tyr.prmtop'.format(testsystems)) self.cpin_filename = '{}/tyr.cpin'.format(testsystems)
def load_lb(cutoff=1.1 * u.nanometers, constraints=app.HBonds, hydrogenMass=1.0 * u.amu): prmtop_filename = "./input/126492-54-4_1000_300.6.prmtop" pdb_filename = "./input/126492-54-4_1000_300.6_equil.pdb" pdb = app.PDBFile(pdb_filename) prmtop = app.AmberPrmtopFile(prmtop_filename) system = prmtop.createSystem( nonbondedMethod=app.PME, nonbondedCutoff=cutoff, constraints=constraints, hydrogenMass=hydrogenMass ) # Force rigid water here for comparison to other code return system, pdb.positions