def run(self, production_steps=200, start='ala2_1stFrame.pdb', production='ala2_production.pdb'): #### ?!!!!!!!!!!!!!!!! #from __future__ import print_function from simtk.openmm import app import simtk.openmm as mm from simtk import unit from sys import stdout nonbondedCutoff = 1.0 * unit.nanometers timestep = 2.0 * unit.femtoseconds temperature = 300 * unit.kelvin #save_frequency = 100 #Every 100 steps, save the trajectory save_frequency = 10 #Every 1 steps, save the trajectory pdb = app.PDBFile(start) forcefield = app.ForceField('amber99sb.xml', 'tip3p.xml') ala2_model = app.Modeller(pdb.topology, pdb.positions) #Hydrogens will be constrained after equilibrating system = forcefield.createSystem(ala2_model.topology, nonbondedMethod=app.PME, nonbondedCutoff=nonbondedCutoff, constraints=app.HBonds, rigidWater=True, ewaldErrorTolerance=0.0005) system.addForce(mm.MonteCarloBarostat( 1 * unit.bar, temperature, 100)) #Apply Monte Carlo Pressure changes in 100 timesteps integrator = mm.LangevinIntegrator(temperature, 1.0 / unit.picoseconds, timestep) integrator.setConstraintTolerance(0.00001) platform = mm.Platform.getPlatformByName('CPU') simulation = app.Simulation(ala2_model.topology, system, integrator, platform) simulation.context.setPositions(ala2_model.positions) simulation.context.setVelocitiesToTemperature(temperature) simulation.reporters.append(app.PDBReporter(production, save_frequency)) simulation.reporters.append( app.StateDataReporter('stateReporter_constantPressure.txt', 1000, step=True, totalEnergy=True, temperature=True, volume=True, progress=True, remainingTime=True, speed=True, totalSteps=production_steps, separator='\t')) print('Running Production...') simulation.step(production_steps) print('Done!') import mdtraj as md trj = md.load(production) return trj
def equilibrate(self, ff_name, water_name): input_pdb_filename = self.get_initial_pdb_filename(ff_name, water_name) equil_pdb_filename = self.get_equil_pdb_filename(ff_name, water_name) equil_dcd_filename = self.get_equil_dcd_filename(ff_name, water_name) equil_protein_pdb_filename = self.get_equil_protein_pdb_filename( ff_name, water_name) utils.make_path(equil_pdb_filename) if os.path.exists(equil_pdb_filename): return ff = app.ForceField('%s.xml' % ff_name, '%s.xml' % water_name) pdb = app.PDBFile(input_pdb_filename) modeller = app.Modeller(pdb.topology, pdb.positions) modeller.addSolvent(ff, model=water_mapping[water_name], padding=self.padding, ionicStrength=self.ionic_strength) topology = modeller.getTopology() positions = modeller.getPositions() system = ff.createSystem(topology, nonbondedMethod=app.PME, nonbondedCutoff=self.cutoff, constraints=app.HBonds) integrator = mm.LangevinIntegrator(self.temperature, self.equil_friction, self.equil_timestep) system.addForce( mm.MonteCarloBarostat(self.pressure, self.temperature, self.barostat_frequency)) platform = mm.Platform.getPlatformByName("CUDA") platform.setPropertyDefaultValue("CudaDeviceIndex", os.environ["CUDA_VISIBLE_DEVICES"]) simulation = app.Simulation(topology, system, integrator, platform=platform) simulation.context.setPositions(positions) print('Minimizing.') simulation.minimizeEnergy() simulation.context.setVelocitiesToTemperature(self.temperature) print('Equilibrating.') simulation.reporters.append( app.PDBReporter(equil_pdb_filename, self.n_equil_steps - 1)) simulation.reporters.append( app.DCDReporter(equil_dcd_filename, self.equil_output_frequency)) simulation.step(self.n_equil_steps) del simulation del system traj = md.load(equil_dcd_filename, top=equil_pdb_filename)[-1] traj.save(equil_pdb_filename) top, bonds = traj.top.to_dataframe() atom_indices = top.index[top.chainID == 0].values traj.restrict_atoms(atom_indices) traj.save(equil_protein_pdb_filename)
ref_pdb = app.PDBFile(ini_pdb_file) topology, positions = ref_pdb.topology, ref_pdb.positions templates = sop.util.template_dict(topology, n_beads) ff_kwargs = {} ff_kwargs["mass_ply"] = mass_ply ff_kwargs["eps_ply"] = coeff[0]*0.5*unit.kilojoule_per_mole ff_kwargs["sigma_ply"] = sigma_ply ff_filename = "ff_cgs.xml" sop.build_ff.polymer_in_solvent(n_beads, "r12", "NONE", saveas=ff_filename, bond_cutoff=bond_cutoff - 1, **ff_kwargs) forcefield = app.ForceField(ff_filename) system = forcefield.createSystem(topology, ignoreExternalBonds=True, residueTemplates=templates) if using_cv: system.addForce(Ucv_force) else: system.addForce(Up_force) if collision_rate == 0: # gamma = m/D ? does temperature enter? collision_rate = ((mass_ply/unit.amu)/D)/unit.picosecond else: collision_rate = collision_rate/unit.picosecond ensemble = "NVT"
from __future__ import print_function from simtk.openmm import app import simtk.openmm as mm from simtk import unit from sys import stdout # Load the PDB file into an object pdb = app.PDBFile('trpcage.pdb') # Load the force field file into an object forcefield = app.ForceField('amber99sbildn.xml', 'tip3p.xml') # Create system object using information in the force field: # forcefield: contains parameters of interactions # topology: lists of atoms, residues, and bonds system = forcefield.createSystem(pdb.topology, nonbondedMethod=app.PME, nonbondedCutoff=1.0 * unit.nanometers, constraints=app.HBonds, rigidWater=True, ewaldErrorTolerance=0.0005) # Create a Langevin integrator for temperature control integrator = mm.LangevinIntegrator(300 * unit.kelvin, 1.0 / unit.picoseconds, 2.0 * unit.femtoseconds) # Add a Monte Carlo barostat to the system for pressure control system.addForce( mm.MonteCarloBarostat(1 * unit.atmospheres, 300 * unit.kelvin, 25)) # Use the CPU platform
if len(sys.argv) != 8: print( 'usage %s <cuda device index> < temp K > < t_equil ns > < t_sim ns > < fric 1/ps > < pdb > < frame > ' ) exit(1) temp = float(sys.argv[2]) t_equil = float(sys.argv[3]) t_sim = float(sys.argv[4]) fric = float(sys.argv[5]) pdb_str = sys.argv[6] pdb_frame = int(sys.argv[7]) pdb = md.load(pdb_str) forcefield = app.ForceField('amber99sbildn.xml', 'amber99_obc.xml') system = forcefield.createSystem(pdb.topology.to_openmm(), nonbondedMethod=app.CutoffNonPeriodic, nonbondedCutoff=2.0 * unit.nanometers, constraints=app.HBonds) integrator = mm.LangevinIntegrator(temp * unit.kelvin, fric / unit.picoseconds, 2.0 * unit.femtoseconds) integrator.setConstraintTolerance(0.00001) platform = mm.Platform.getPlatformByName('CUDA') properties = {'CudaPrecision': 'mixed', 'CudaDeviceIndex': sys.argv[1]} simulation = app.Simulation(pdb.topology.to_openmm(), system, integrator, platform, properties) simulation.context.setPositions(pdb.xyz[pdb_frame])
def runOneTest(testName, options): """Perform a single benchmarking simulation.""" explicit = (testName in ('rf', 'pme', 'amoebapme')) amoeba = (testName in ('amoebagk', 'amoebapme')) apoa1 = testName.startswith('apoa1') hydrogenMass = None print() if amoeba: print('Test: %s (epsilon=%g)' % (testName, options.epsilon)) elif testName == 'pme': print('Test: pme (cutoff=%g)' % options.cutoff) else: print('Test: %s' % testName) platform = mm.Platform.getPlatformByName(options.platform) # Create the System. if amoeba: constraints = None epsilon = float(options.epsilon) if explicit: ff = app.ForceField('amoeba2009.xml') pdb = app.PDBFile('5dfr_solv-cube_equil.pdb') cutoff = 0.7*unit.nanometers vdwCutoff = 0.9*unit.nanometers system = ff.createSystem(pdb.topology, nonbondedMethod=app.PME, nonbondedCutoff=cutoff, vdwCutoff=vdwCutoff, constraints=constraints, ewaldErrorTolerance=0.00075, mutualInducedTargetEpsilon=epsilon, polarization=options.polarization) else: ff = app.ForceField('amoeba2009.xml', 'amoeba2009_gk.xml') pdb = app.PDBFile('5dfr_minimized.pdb') cutoff = 2.0*unit.nanometers vdwCutoff = 1.2*unit.nanometers system = ff.createSystem(pdb.topology, nonbondedMethod=app.NoCutoff, constraints=constraints, mutualInducedTargetEpsilon=epsilon, polarization=options.polarization) for f in system.getForces(): if isinstance(f, mm.AmoebaMultipoleForce) or isinstance(f, mm.AmoebaVdwForce) or isinstance(f, mm.AmoebaGeneralizedKirkwoodForce) or isinstance(f, mm.AmoebaWcaDispersionForce): f.setForceGroup(1) dt = 0.002*unit.picoseconds integ = mm.MTSIntegrator(dt, [(0,2), (1,1)]) else: if apoa1: ff = app.ForceField('amber14/protein.ff14SB.xml', 'amber14/lipid17.xml', 'amber14/tip3p.xml') pdb = app.PDBFile('apoa1.pdb') if testName == 'apoa1pme': method = app.PME cutoff = options.cutoff elif testName == 'apoa1ljpme': method = app.LJPME cutoff = options.cutoff else: method = app.CutoffPeriodic cutoff = 1*unit.nanometers friction = 1*(1/unit.picoseconds) elif explicit: ff = app.ForceField('amber99sb.xml', 'tip3p.xml') pdb = app.PDBFile('5dfr_solv-cube_equil.pdb') if testName == 'pme': method = app.PME cutoff = options.cutoff else: method = app.CutoffPeriodic cutoff = 1*unit.nanometers friction = 1*(1/unit.picoseconds) else: ff = app.ForceField('amber99sb.xml', 'amber99_obc.xml') pdb = app.PDBFile('5dfr_minimized.pdb') method = app.CutoffNonPeriodic cutoff = 2*unit.nanometers friction = 91*(1/unit.picoseconds) if options.heavy: dt = 0.005*unit.picoseconds constraints = app.AllBonds hydrogenMass = 4*unit.amu integ = mm.LangevinIntegrator(300*unit.kelvin, friction, dt) else: dt = 0.004*unit.picoseconds constraints = app.HBonds hydrogenMass = None integ = mm.LangevinMiddleIntegrator(300*unit.kelvin, friction, dt) system = ff.createSystem(pdb.topology, nonbondedMethod=method, nonbondedCutoff=cutoff, constraints=constraints, hydrogenMass=hydrogenMass) print('Step Size: %g fs' % dt.value_in_unit(unit.femtoseconds)) properties = {} initialSteps = 5 if options.device is not None and platform.getName() in ('CUDA', 'OpenCL'): properties['DeviceIndex'] = options.device if ',' in options.device or ' ' in options.device: initialSteps = 250 if options.precision is not None and platform.getName() in ('CUDA', 'OpenCL'): properties['Precision'] = options.precision # Run the simulation. integ.setConstraintTolerance(1e-5) if len(properties) > 0: context = mm.Context(system, integ, platform, properties) else: context = mm.Context(system, integ, platform) context.setPositions(pdb.positions) context.setVelocitiesToTemperature(300*unit.kelvin) steps = 20 while True: time = timeIntegration(context, steps, initialSteps) if time >= 0.5*options.seconds: break if time < 0.5: steps = int(steps*1.0/time) # Integrate enough steps to get a reasonable estimate for how many we'll need. else: steps = int(steps*options.seconds/time) print('Integrated %d steps in %g seconds' % (steps, time)) print('%g ns/day' % (dt*steps*86400/time).value_in_unit(unit.nanoseconds))
def __init__(self, **kwargs): super(LoopSoftening, self).__init__(**kwargs) self.description = 'Alchemical Loop Softening script' padding = 9.0 * unit.angstrom explicit_solvent_model = 'tip3p' setup_path = 'data/mtor' # Create topology, positions, and system. from pkg_resources import resource_filename gaff_xml_filename = resource_filename('sams', 'data/gaff.xml') system_generators = dict() ffxmls = [gaff_xml_filename, 'amber99sbildn.xml', 'tip3p.xml'] forcefield_kwargs = { 'nonbondedMethod': app.CutoffPeriodic, 'nonbondedCutoff': 9.0 * unit.angstrom, 'implicitSolvent': None, 'constraints': app.HBonds, 'rigidWater': True } # Load topologies and positions for all components print('Creating mTOR test system...') forcefield = app.ForceField(*ffxmls) from simtk.openmm.app import PDBFile, Modeller pdb_filename = resource_filename( 'sams', os.path.join(setup_path, 'mtor_pdbfixer_apo.pdb')) pdbfile = PDBFile(pdb_filename) modeller = app.Modeller(pdbfile.topology, pdbfile.positions) print('Adding solvent...') modeller.addSolvent(forcefield, model=explicit_solvent_model, padding=padding) self.topology = modeller.getTopology() self.positions = modeller.getPositions() print('Creating system...') self.system = forcefield.createSystem(self.topology, **forcefield_kwargs) # DEBUG: Write PDB outfile = open('initial.pdb', 'w') PDBFile.writeFile(self.topology, self.positions, outfile) outfile.close() # Atom Selection using MDtraj res_pairs = [[403, 483], [1052, 1109]] t = md.load(pdb_filename) alchemical_atoms = set() for x in res_pairs: start = min(t.top.select('residue %s' % min(x))) end = max(t.top.select('residue %s' % max(x))) + 1 alchemical_atoms.union(set(range(start, end))) # Create thermodynamic states. print('Creating alchemically-modified system...') temperature = 300 * unit.kelvin pressure = 1.0 * unit.atmospheres from alchemy import AbsoluteAlchemicalFactory factory = AbsoluteAlchemicalFactory( self.system, ligand_atoms=alchemical_atoms, annihilate_electrostatics=True, alchemical_torsions=True, annihilate_sterics=True, softcore_beta=0.0) # turn off softcore electrostatics self.system = factory.createPerturbedSystem() print('Setting up alchemical intermediates...') from sams import ThermodynamicState self.thermodynamic_states = list() for state in range(26): parameters = { 'lambda_sterics': 1.0, 'lambda_electrostatics': (1.0 - float(state) / 25.0) } self.thermodynamic_states.append( ThermodynamicState(system=self.system, temperature=temperature, parameters=parameters)) for state in range(1, 26): parameters = { 'lambda_sterics': (1.0 - float(state) / 25.0), 'lambda_electrostatics': 0.0 } self.thermodynamic_states.append( ThermodynamicState(system=self.system, temperature=temperature, parameters=parameters)) #minimize(self.system, self.positions) minimize(self.system) # Create SAMS samplers print('Setting up samplers...') from sams.samplers import SamplerState, MCMCSampler, ExpandedEnsembleSampler, SAMSSampler thermodynamic_state_index = 0 # initial thermodynamic state index thermodynamic_state = self.thermodynamic_states[ thermodynamic_state_index] sampler_state = SamplerState(positions=self.system.positions) self.mcmc_sampler = MCMCSampler( sampler_state=sampler_state, thermodynamic_state=thermodynamic_state, ncfile=self.ncfile) self.mcmc_sampler.pdbfile = open('output.pdb', 'w') self.mcmc_sampler.topology = self.topology self.mcmc_sampler.verbose = True self.exen_sampler = ExpandedEnsembleSampler(self.mcmc_sampler, self.thermodynamic_states) self.exen_sampler.verbose = True self.sams_sampler = SAMSSampler(self.exen_sampler) self.sams_sampler.verbose = True
def openmm_system(self): """Initialise the OpenMM system we will use to evaluate the energies.""" # load the initial coords into the system and initialise pdb = app.PDBFile(self.pdb) # count the amount of atoms in the structure for atom in pdb.topology.atoms(): self.natoms += 1 # must use a custom version of the tip3p water moddel forcefield = app.ForceField(self.xml, 'tip3p_opls.xml') self.modeller = app.Modeller( pdb.topology, pdb.positions) # set the intial positions from the pdb # Now we need to solvate the system self.modeller.addSolvent(forcefield, model='tip3p', padding=1 * unit.nanometer) # write out the solvated system coords app.PDBFile.writeFile(self.modeller.topology, self.modeller.positions, open('output.pdb', 'w')) # now we create the system and add the lj correction self.system = forcefield.createSystem(self.modeller.topology, nonbondedMethod=app.PME, constraints=None, nonbondedCutoff=1.1 * unit.nanometer) if self.opls: self.opls_lj() # set control parameters temperature = 298.15 * unit.kelvin integrator = mm.LangevinIntegrator(temperature, 5 / unit.picoseconds, 0.001 * unit.picoseconds) # add preasure to the system self.system.addForce( mm.MonteCarloBarostat(1 * unit.bar, 300 * unit.kelvin)) # create the simulation context self.simulation = app.Simulation(self.modeller.topology, self.system, integrator) # set the positions to the solvated system self.simulation.context.setPositions(self.modeller.positions) # get the energy of the sytem print( self.simulation.context.getState( getEnergy=True).getPotentialEnergy()) # check the energy break down struct = pmd.load_file('output.pdb') ecomps = (pmd.openmm.energy_decomposition_system(struct, self.system)) tot_ene = 0.0 for i in range(0, len(ecomps)): tot_ene += ecomps[i][1] print(ecomps[i][0], ecomps[i][1]) print('Total-energy %6.6f' % tot_ene) # serialize the system serialized_system = mm.XmlSerializer.serialize(self.system) outfile = open('test.xml', 'w') outfile.write(serialized_system) outfile.close() # now minimize the system self.simulation.minimizeEnergy(maxIterations=100) # now run the simulation self.simulation.reporters.append(app.PDBReporter('run.pdb', 1000)) self.simulation.reporters.append( app.StateDataReporter('run.txt', 1000, step=True, potentialEnergy=True, temperature=True)) self.simulation.step(100000)
temp = 298.15 * unit.kelvin rcut = 12 * unit.angstroms rswitch = 11 * unit.angstroms rcutIn = 8 * unit.angstroms rswitchIn = 5 * unit.angstroms tau = 10 * unit.femtoseconds gamma = 0.1 / unit.femtoseconds reportInterval = 90 // args.timestep platform = openmm.Platform.getPlatformByName(platform_name) properties = dict(Precision='mixed') if platform_name == 'CUDA' else dict() if args.device != 'None': properties['DeviceIndex'] = args.device pdb = app.PDBFile('water.pdb') forcefield = app.ForceField('water.xml') openmm_system = forcefield.createSystem(pdb.topology, nonbondedMethod=openmm.app.PME, nonbondedCutoff=rcut, rigidWater=False, removeCMMotion=False) nbforce = openmm_system.getForce(atomsmm.findNonbondedForce(openmm_system)) nbforce.setUseSwitchingFunction(True) nbforce.setSwitchingDistance(rswitch) nbforce.setUseDispersionCorrection(False) if args.timestep > 3: respa_system = atomsmm.RESPASystem(openmm_system, rcutIn, rswitchIn,
def create_system(guest_mol, host_pdb, handlers, restr_search_radius, restr_force_constant, intg_temperature, stage): """ Initialize a self-encompassing System object that we can serialize and simulate. Parameters ---------- guest_mol: rdkit.ROMol guest molecule host_pdb: openmm.PDBFile host system from OpenMM handlers: list of timemachine.ops.Gradients forcefield handlers used to parameterize the system restr_search_radius: float how far away we search from the ligand to define the binding pocket atoms. restr_force_constant: float strength of the harmonic oscillator for the restraint intg_temperature: float temperature of the integrator in Kelvin stage: int (0 or 1) a free energy specific variable that determines how we decouple. """ guest_masses = np.array([a.GetMass() for a in guest_mol.GetAtoms()], dtype=np.float64) amber_ff = app.ForceField('amber99sbildn.xml', 'amber99_obc.xml') host_system = amber_ff.createSystem(host_pdb.topology, nonbondedMethod=app.NoCutoff, constraints=None, rigidWater=False) host_fns, host_masses = openmm_deserializer.deserialize_system(host_system) num_host_atoms = len(host_masses) num_guest_atoms = guest_mol.GetNumAtoms() # Name, Args, vjp_fn final_gradients = [] for item in host_fns: if item[0] == 'LennardJones': host_lj_params = item[1] elif item[0] == 'Charges': host_charge_params = item[1] elif item[0] == 'GBSA': host_gb_params = item[1][0] host_gb_props = item[1][1:] elif item[0] == 'Exclusions': host_exclusions = item[1] else: final_gradients.append((item[0], item[1])) guest_exclusion_idxs, guest_scales = nonbonded.generate_exclusion_idxs( guest_mol, scale12=1.0, scale13=1.0, scale14=0.5) guest_exclusion_idxs += num_host_atoms guest_lj_exclusion_scales = guest_scales guest_charge_exclusion_scales = guest_scales host_exclusion_idxs = host_exclusions[0] host_lj_exclusion_scales = host_exclusions[1] host_charge_exclusion_scales = host_exclusions[2] combined_exclusion_idxs = np.concatenate( [host_exclusion_idxs, guest_exclusion_idxs]) combined_lj_exclusion_scales = np.concatenate( [host_lj_exclusion_scales, guest_lj_exclusion_scales]) combined_charge_exclusion_scales = np.concatenate( [host_charge_exclusion_scales, guest_charge_exclusion_scales]) # We build up a map of handles to a corresponding vjp_fn that takes in adjoints of output parameters # for nonbonded terms, the vjp_fn has been modified to take in combined parameters handler_vjp_fns = {} for handle in handlers: results = handle.parameterize(guest_mol) if isinstance(handle, bonded.HarmonicBondHandler): bond_idxs, (bond_params, handler_vjp_fn) = results bond_idxs += num_host_atoms final_gradients.append(("HarmonicBond", (bond_idxs, bond_params))) elif isinstance(handle, bonded.HarmonicAngleHandler): angle_idxs, (angle_params, handler_vjp_fn) = results angle_idxs += num_host_atoms final_gradients.append( ("HarmonicAngle", (angle_idxs, angle_params))) elif isinstance(handle, bonded.ProperTorsionHandler): torsion_idxs, (torsion_params, handler_vjp_fn) = results torsion_idxs += num_host_atoms final_gradients.append( ("PeriodicTorsion", (torsion_idxs, torsion_params))) elif isinstance(handle, bonded.ImproperTorsionHandler): torsion_idxs, (torsion_params, handler_vjp_fn) = results torsion_idxs += num_host_atoms final_gradients.append( ("PeriodicTorsion", (torsion_idxs, torsion_params))) elif isinstance(handle, nonbonded.LennardJonesHandler): guest_lj_params, guest_lj_vjp_fn = results combined_lj_params, handler_vjp_fn = concat_with_vjps( host_lj_params, guest_lj_params, None, guest_lj_vjp_fn) elif isinstance(handle, nonbonded.SimpleChargeHandler): guest_charge_params, guest_charge_vjp_fn = results combined_charge_params, handler_vjp_fn = concat_with_vjps( host_charge_params, guest_charge_params, None, guest_charge_vjp_fn) elif isinstance(handle, nonbonded.GBSAHandler): guest_gb_params, guest_gb_vjp_fn = results combined_gb_params, handler_vjp_fn = concat_with_vjps( host_gb_params, guest_gb_params, None, guest_gb_vjp_fn) elif isinstance(handle, nonbonded.AM1BCCHandler): guest_charge_params, guest_charge_vjp_fn = results combined_charge_params, handler_vjp_fn = concat_with_vjps( host_charge_params, guest_charge_params, None, guest_charge_vjp_fn) elif isinstance(handle, nonbonded.AM1CCCHandler): guest_charge_params, guest_charge_vjp_fn = results combined_charge_params, handler_vjp_fn = concat_with_vjps( host_charge_params, guest_charge_params, None, guest_charge_vjp_fn) else: raise Exception("Unknown Handler", handle) handler_vjp_fns[handle] = handler_vjp_fn host_conf = [] for x, y, z in host_pdb.positions: host_conf.append([to_md_units(x), to_md_units(y), to_md_units(z)]) host_conf = np.array(host_conf) conformer = guest_mol.GetConformer(0) mol_a_conf = np.array(conformer.GetPositions(), dtype=np.float64) mol_a_conf = mol_a_conf / 10 # convert to md_units x0 = np.concatenate([host_conf, mol_a_conf]) # combined geometry v0 = np.zeros_like(x0) pocket_atoms = find_protein_pocket_atoms(x0, num_host_atoms, restr_search_radius) N_C = num_host_atoms + num_guest_atoms N_A = num_host_atoms cutoff = 100000.0 if stage == 0: combined_lambda_plane_idxs = np.zeros(N_C, dtype=np.int32) combined_lambda_offset_idxs = np.zeros(N_C, dtype=np.int32) elif stage == 1: combined_lambda_plane_idxs = np.zeros(N_C, dtype=np.int32) combined_lambda_offset_idxs = np.zeros(N_C, dtype=np.int32) combined_lambda_offset_idxs[num_host_atoms:] = 1 else: assert 0 final_gradients.append( ('Nonbonded', (np.asarray(combined_charge_params), np.asarray(combined_lj_params), combined_exclusion_idxs, combined_charge_exclusion_scales, combined_lj_exclusion_scales, combined_lambda_plane_idxs, combined_lambda_offset_idxs, cutoff))) final_gradients.append( ('GBSA', (np.asarray(combined_charge_params), np.asarray(combined_gb_params), combined_lambda_plane_idxs, combined_lambda_offset_idxs, *host_gb_props, cutoff, cutoff))) ligand_idxs = np.arange(N_A, N_C, dtype=np.int32) # restraints if stage == 0: lamb_flag = 1 lamb_offset = 0 if stage == 1: lamb_flag = 0 lamb_offset = 1 # unweighted center of mass restraints avg_xi = np.mean(x0[ligand_idxs], axis=0) avg_xj = np.mean(x0[pocket_atoms], axis=0) ctr_dij = np.sqrt(np.sum((avg_xi - avg_xj)**2)) combined_masses = np.concatenate([host_masses, guest_masses]) # restraints final_gradients.append( ('CentroidRestraint', (ligand_idxs, pocket_atoms, combined_masses, restr_force_constant, ctr_dij, lamb_flag, lamb_offset))) ssc = standard_state.harmonic_com_ssc(restr_force_constant, ctr_dij, intg_temperature) return x0, combined_masses, ssc, final_gradients, handler_vjp_fns
def generate_vacuum_hostguest_proposal(current_mol_name="B2", proposed_mol_name="MOL"): """ Generate a test vacuum topology proposal, current positions, and new positions triplet from two IUPAC molecule names. Parameters ---------- current_mol_name : str, optional name of the first molecule proposed_mol_name : str, optional name of the second molecule Returns ------- topology_proposal : perses.rjmc.topology_proposal The topology proposal representing the transformation current_positions : np.array, unit-bearing The positions of the initial system new_positions : np.array, unit-bearing The positions of the new system """ from openmoltools import forcefield_generators from openmmtools import testsystems from perses.utils.openeye import smiles_to_oemol from perses.utils.data import get_data_filename host_guest = testsystems.HostGuestVacuum() unsolv_old_system, old_positions, top_old = host_guest.system, host_guest.positions, host_guest.topology ligand_topology = [res for res in top_old.residues()] current_mol = forcefield_generators.generateOEMolFromTopologyResidue( ligand_topology[1]) # guest is second residue in topology proposed_mol = smiles_to_oemol('C1CC2(CCC1(CC2)C)C') initial_smiles = oechem.OEMolToSmiles(current_mol) final_smiles = oechem.OEMolToSmiles(proposed_mol) gaff_xml_filename = get_data_filename("data/gaff.xml") forcefield = app.ForceField(gaff_xml_filename, 'tip3p.xml') forcefield.registerTemplateGenerator( forcefield_generators.gaffTemplateGenerator) solvated_system = forcefield.createSystem(top_old, removeCMMotion=False) gaff_filename = get_data_filename('data/gaff.xml') system_generator = SystemGenerator( [gaff_filename, 'amber99sbildn.xml', 'tip3p.xml'], forcefield_kwargs={ 'removeCMMotion': False, 'nonbondedMethod': app.NoCutoff }) geometry_engine = geometry.FFAllAngleGeometryEngine() proposal_engine = SmallMoleculeSetProposalEngine( [initial_smiles, final_smiles], system_generator, residue_name=current_mol_name) #generate topology proposal topology_proposal = proposal_engine.propose(solvated_system, top_old, current_mol=current_mol, proposed_mol=proposed_mol) #generate new positions with geometry engine new_positions, _ = geometry_engine.propose(topology_proposal, old_positions, beta) return topology_proposal, old_positions, new_positions
def benchmark_dhfr(verbose=False, num_batches=100, steps_per_batch=1000): pdb_path = "tests/data/5dfr_solv_equil.pdb" host_pdb = app.PDBFile(pdb_path) protein_ff = app.ForceField("amber99sbildn.xml", "tip3p.xml") host_system = protein_ff.createSystem( host_pdb.topology, nonbondedMethod=app.NoCutoff, constraints=None, rigidWater=False ) host_coords = host_pdb.positions box = host_pdb.topology.getPeriodicBoxVectors() box = np.asarray(box / box.unit) host_fns, host_masses = openmm_deserializer.deserialize_system(host_system, cutoff=1.0) host_conf = [] for x, y, z in host_coords: host_conf.append([to_md_units(x), to_md_units(y), to_md_units(z)]) host_conf = np.array(host_conf) x0 = host_conf v0 = np.zeros_like(host_conf) benchmark( "dhfr-apo", host_masses, 0.0, x0, v0, box, host_fns, verbose=verbose, num_batches=num_batches, steps_per_batch=steps_per_batch, ) benchmark( "dhfr-apo-barostat-interval-25", host_masses, 0.0, x0, v0, box, host_fns, verbose=verbose, num_batches=num_batches, steps_per_batch=steps_per_batch, barostat_interval=25, ) benchmark( "dhfr-apo-hmr-barostat-interval-25", host_masses, 0.0, x0, v0, box, host_fns, verbose=verbose, hmr=True, num_batches=num_batches, steps_per_batch=steps_per_batch, barostat_interval=25, )
def _built_template(molecule, force_field_source): """Builds a force field template object. Parameters ---------- molecule: openforcefield.topology.Molecule The molecule to templatize. force_field_source: LigParGenForceFieldSource The tleap source which describes which parameters to apply. Returns ------- simtk.openmm.app.ForceField The force field template. """ from simtk import unit as simtk_unit initial_request_url = force_field_source.request_url empty_stream = io.BytesIO(b"\r\n") total_charge = molecule.total_charge if isinstance(total_charge, simtk_unit.Quantity): total_charge = total_charge.value_in_unit( simtk_unit.elementary_charge) charge_model = "cm1abcc" if (force_field_source.preferred_charge_model == LigParGenForceFieldSource.ChargeModel.CM1A_1_14 or not np.isclose(total_charge, 0.0)): charge_model = "cm1a" if (force_field_source.preferred_charge_model != LigParGenForceFieldSource.ChargeModel.CM1A_1_14): logger.warning( f"The preferred charge model is {str(force_field_source.preferred_charge_model)}, " f"however the system is charged and so the " f"{str(LigParGenForceFieldSource.ChargeModel.CM1A_1_14)} model will be used in its " f"place.") data_body = { "smiData": (None, molecule.to_smiles()), "molpdbfile": ("", empty_stream), "checkopt": (None, 0), "chargetype": (None, charge_model), "dropcharge": (None, str(total_charge)), } # Perform the initial request for LigParGen to parameterize the molecule. request = requests.post(url=initial_request_url, files=data_body) # Cleanup the empty stream empty_stream.close() if request.status_code != requests.codes.ok: return f"The request failed with return code {request.status_code}." response_content = request.content # Retrieve the server file name. force_field_file_name = re.search(r"value=\"/tmp/(.*?).xml\"", response_content.decode()) if force_field_file_name is None: return "The request could not successfully be completed." force_field_file_name = force_field_file_name.group(1) # Download the force field xml file. download_request_url = force_field_source.download_url download_force_field_body = { "go": (None, "XML"), "fileout": (None, f"/tmp/{force_field_file_name}.xml"), } request = requests.post(url=download_request_url, files=download_force_field_body) if request.status_code != requests.codes.ok: return f"The request to download the system xml file failed with return code {request.status_code}." force_field_response = request.content force_field_path = "template.xml" with open(force_field_path, "wb") as file: file.write(force_field_response) return app.ForceField(force_field_path)
def test_ffxml_simulation(): """Test converting toluene and benzene smiles to oemol to ffxml to openmm simulation.""" with utils.enter_temp_directory(): m0 = openmoltools.openeye.smiles_to_oemol("Cc1ccccc1") charged0 = openmoltools.openeye.get_charges(m0) m1 = openmoltools.openeye.smiles_to_oemol("c1ccccc1") charged1 = openmoltools.openeye.get_charges(m1) ligands = [charged0, charged1] n_atoms = [15, 12] trajectories, ffxml = openmoltools.openeye.oemols_to_ffxml(ligands) eq(len(trajectories), len(ligands)) pdb_filename = utils.get_data_filename("chemicals/proteins/1vii.pdb") temperature = 300 * u.kelvin friction = 0.3 / u.picosecond timestep = 0.01 * u.femtosecond protein_traj = md.load(pdb_filename) protein_traj.center_coordinates() protein_top = protein_traj.top.to_openmm() protein_xyz = protein_traj.openmm_positions(0) for k, ligand in enumerate(ligands): ligand_traj = trajectories[k] ligand_traj.center_coordinates() eq(ligand_traj.n_atoms, n_atoms[k]) eq(ligand_traj.n_frames, 1) #Move the pre-centered ligand sufficiently far away from the protein to avoid a clash. min_atom_pair_distance = ( (ligand_traj.xyz[0]**2.).sum(1)**0.5).max() + ( (protein_traj.xyz[0]**2.).sum(1)**0.5).max() + 0.3 ligand_traj.xyz += np.array([1.0, 0.0, 0.0 ]) * min_atom_pair_distance ligand_xyz = ligand_traj.openmm_positions(0) ligand_top = ligand_traj.top.to_openmm() ffxml.seek(0) forcefield = app.ForceField("amber10.xml", ffxml, "tip3p.xml") model = app.modeller.Modeller(protein_top, protein_xyz) model.add(ligand_top, ligand_xyz) model.addSolvent(forcefield, padding=0.4 * u.nanometer) system = forcefield.createSystem(model.topology, nonbondedMethod=app.PME, nonbondedCutoff=1.0 * u.nanometers, constraints=app.HAngles) integrator = mm.LangevinIntegrator(temperature, friction, timestep) simulation = app.Simulation(model.topology, system, integrator) simulation.context.setPositions(model.positions) print("running") simulation.step(1)
if args.L is not None: print('CAUTION: (cubic) box L {} entered, overriding boxfile {}'.format( args.L, args.boxfile)) box_L = args.L periodic_box_vectors = [[box_L, 0., 0.], [0., box_L, 0.], [0., 0., box_L]] else: periodic_box_vectors = np.loadtxt(args.boxfile) ff_list = args.fflist pdb = app.PDBFile sys_pdb = app.PDBFile(args.initpdb) top = sys_pdb.topology # === Set up simulation === forcefield = app.ForceField(*ff_list) unmatched_residues = forcefield.getUnmatchedResidues(top) print('\n=== Unmatched residues ===\n') print(unmatched_residues) print('\n=== Periodic Box ===') print(periodic_box_vectors) top.setPeriodicBoxVectors(periodic_box_vectors * unit.nanometer) print('\n=== Making System ===') system = forcefield.createSystem(sys_pdb.topology, nonbondedMethod=nonbonded_method, nonbondedCutoff=nonbonded_cutoff, ewaldErrorTolerance=ewald_tol, rigidWater=True, constraints=None)
temp = 298.15 * unit.kelvin rcut = 12 * unit.angstroms rswitch = 11 * unit.angstroms rcutIn = 8 * unit.angstroms rswitchIn = 5 * unit.angstroms tau = 10 * unit.femtoseconds gamma = 0.1 / unit.femtoseconds reportInterval = 90 // args.timestep platform = openmm.Platform.getPlatformByName(platform_name) properties = dict(Precision='mixed') if platform_name == 'CUDA' else dict() if args.device != 'None': properties['DeviceIndex'] = args.device pdb = app.PDBFile('ethylene_glycol.pdb') forcefield = app.ForceField('ethylene_glycol.xml') openmm_system = forcefield.createSystem(pdb.topology, nonbondedMethod=openmm.app.PME, nonbondedCutoff=rcut, rigidWater=False, removeCMMotion=False) nbforce = openmm_system.getForce(atomsmm.findNonbondedForce(openmm_system)) nbforce.setUseSwitchingFunction(True) nbforce.setSwitchingDistance(rswitch) nbforce.setUseDispersionCorrection(False) if args.timestep > 3: respa_system = atomsmm.RESPASystem(openmm_system, rcutIn, rswitchIn,
nc_filename = "repex.nc" n_replicas = 3 # number of temperature replicas T_min = 298.0 * u.kelvin # minimum temperature T_max = 600.0 * u.kelvin # maximum temperature T_i = [ T_min + (T_max - T_min) * (math.exp(float(i) / float(n_replicas-1)) - 1.0) / (math.e - 1.0) for i in range(n_replicas) ] pdb_filename = "1VII.pdb" temperature = 300 * u.kelvin friction = 0.3 / u.picosecond timestep = 2.0 * u.femtosecond forcefield = app.ForceField("amber10.xml", "tip3p.xml") pdb = app.PDBFile(pdb_filename) model = app.modeller.Modeller(pdb.topology, pdb.positions) model.addSolvent(forcefield, padding=0.4 * u.nanometer) system = forcefield.createSystem(model.topology, nonbondedMethod=app.PME, nonbondedCutoff=1.0 * u.nanometers, constraints=app.HAngles) states = [ ThermodynamicState(system=system, temperature=T_i[i]) for i in range(n_replicas) ] simulation = ReplicaExchange(states, [model.getPositions()] * n_replicas, nc_filename) # initialize the replica-exchange simulation simulation.minimize = False simulation.number_of_iterations = 2 # set the simulation to only run 2 iterations simulation.timestep = 2.0 * u.femtoseconds # set the timestep for integration simulation.nsteps_per_iteration = 50 # run 50 timesteps per iteration
output_frequency = 250 dcd_frequency = 5000 steps_per_hmc = 250 timestep = 2.0 * u.femtoseconds friction = 1.0 / u.picoseconds temperature = 300. * u.kelvin pressure = 1.0 * u.atmospheres barostat_frequency = 25 n_steps = 500000000 cutoff = 1.0 * u.nanometers output_frequency = 500 ffxml_filename = "%s.xml" % cas ff = app.ForceField(ffxml_filename) dcd_filename = "./water/production_%s.dcd" % integrator_type log_filename = "./water/production_%s.log" % integrator_type pdb = app.PDBFile("../tip3p.pdb") topology = pdb.topology positions = pdb.positions system = ff.createSystem(topology, nonbondedMethod=app.PME, nonbondedCutoff=cutoff, constraints=app.HBonds) integrators = {
def prepare_pdb(pdb, chains='A', ff=('amber99sbildn.xml', 'tip3p.xml'), ph=7, pad=10 * unit.angstroms, nbonded=app.PME, constraints=app.HBonds, crystal_water=True): """ Fetch, solvate and minimize a protein PDB structure. Parameters ---------- pdb : str PDB Id. chains : str or list Chain(s) to keep in the system. ff : tuple of xml ff files. Forcefields for parametrization. ph : float pH value for adding missing hydrogens. pad: Quantity object Padding around macromolecule for filling box with water. nbonded : object The method to use for nonbonded interactions. Allowed values are NoCutoff, CutoffNonPeriodic, CutoffPeriodic, Ewald, PME, or LJPME. constraints : object Specifies which bonds and angles should be implemented with constraints. Allowed values are None, HBonds, AllBonds, or HAngles. crystal_water : bool Keep crystal water. """ # Load forcefield. logger.info('Retrieving %s from PDB...', pdb) ff = app.ForceField(*ff) # Retrieve structure from PDB. fixer = PDBFixer(pdbid=pdb) # Remove unselected chains. logger.info('Removing all chains but %s', chains) all_chains = [c.id for c in fixer.topology.chains()] fixer.removeChains(chainIds=set(all_chains) - set(chains)) # Find missing residues. logger.info('Finding missing residues...') fixer.findMissingResidues() # Replace nonstandard residues. logger.info('Replacing nonstandard residues...') fixer.findNonstandardResidues() fixer.replaceNonstandardResidues() # Add missing atoms. logger.info('Adding missing atoms...') fixer.findMissingAtoms() fixer.addMissingAtoms() # Remove heterogens. logger.info('Removing heterogens...') fixer.removeHeterogens(keepWater=crystal_water) # Add missing hydrogens. logger.info('Adding missing hydrogens appropriate for pH %s', ph) fixer.addMissingHydrogens(ph) if nbonded in [app.PME, app.CutoffPeriodic, app.Ewald]: # Add solvent. logger.info('Adding solvent...') fixer.addSolvent(padding=pad) # Write PDB file. logger.info('Writing PDB file to "%s"...', '%s-pdbfixer.pdb' % pdb) app.PDBFile.writeFile(fixer.topology, fixer.positions, open('%s-pdbfixer.pdb' % pdb, 'w')) # Create OpenMM System. logger.info('Creating OpenMM system...') system = ff.createSystem(fixer.topology, nonbondedMethod=nbonded, constraints=constraints, rigidWater=True, removeCMMotion=False) # Minimimze to update positions. logger.info('Minimizing...') integrator = mm.VerletIntegrator(1.0 * unit.femtosecond) context = mm.Context(system, integrator) context.setPositions(fixer.positions) mm.LocalEnergyMinimizer.minimize(context) # pylint: disable=unexpected-keyword-arg, no-value-for-parameter state = context.getState(getPositions=True) fixer.positions = state.getPositions() # Write final coordinates. logger.info('Writing PDB file to "%s"...', '%s-minimized.pdb' % pdb) with open('%s-minimized.pdb' % pdb, 'w') as fp: app.PDBFile.writeFile(fixer.topology, fixer.positions, fp) # Serialize final coordinates. logger.info('Serializing to XML...') serialize_system(context, system, integrator)
def runOneTest(testName, options): """Perform a single benchmarking simulation.""" explicit = (testName in ('rf', 'pme', 'amoebapme')) amoeba = (testName in ('amoebagk', 'amoebapme')) hydrogenMass = None print() if amoeba: print('Test: %s (epsilon=%g)' % (testName, options.epsilon)) elif testName == 'pme': print('Test: pme (cutoff=%g)' % options.cutoff) else: print('Test: %s' % testName) platform = mm.Platform.getPlatformByName(options.platform) # Create the System. if amoeba: constraints = None epsilon = float(options.epsilon) if epsilon == 0: polarization = 'direct' else: polarization = 'mutual' if explicit: ff = app.ForceField('amoeba2009.xml') pdb = app.PDBFile('5dfr_solv-cube_equil.pdb') cutoff = 0.7 * unit.nanometers vdwCutoff = 0.9 * unit.nanometers system = ff.createSystem(pdb.topology, nonbondedMethod=app.PME, nonbondedCutoff=cutoff, vdwCutoff=vdwCutoff, constraints=constraints, ewaldErrorTolerance=0.00075, mutualInducedTargetEpsilon=epsilon, polarization=polarization) else: ff = app.ForceField('amoeba2009.xml', 'amoeba2009_gk.xml') pdb = app.PDBFile('5dfr_minimized.pdb') cutoff = 2.0 * unit.nanometers vdwCutoff = 1.2 * unit.nanometers system = ff.createSystem(pdb.topology, nonbondedMethod=app.NoCutoff, constraints=constraints, mutualInducedTargetEpsilon=epsilon, polarization=polarization) dt = 0.001 * unit.picoseconds else: if explicit: ff = app.ForceField('amber99sb.xml', 'tip3p.xml') pdb = app.PDBFile('5dfr_solv-cube_equil.pdb') if testName == 'pme': method = app.PME cutoff = options.cutoff else: method = app.CutoffPeriodic cutoff = 1 * unit.nanometers else: ff = app.ForceField('amber99sb.xml', 'amber99_obc.xml') pdb = app.PDBFile('5dfr_minimized.pdb') method = app.CutoffNonPeriodic cutoff = 2 * unit.nanometers if options.heavy: dt = 0.005 * unit.picoseconds constraints = app.AllBonds hydrogenMass = 4 * unit.amu else: dt = 0.002 * unit.picoseconds constraints = app.HBonds hydrogenMass = None system = ff.createSystem(pdb.topology, nonbondedMethod=method, nonbondedCutoff=cutoff, constraints=constraints, hydrogenMass=hydrogenMass) print('Step Size: %g fs' % dt.value_in_unit(unit.femtoseconds)) properties = {} initialSteps = 5 if options.device is not None: if platform.getName() == 'CUDA': properties['CudaDeviceIndex'] = options.device elif platform.getName() == 'OpenCL': properties['OpenCLDeviceIndex'] = options.device if ',' in options.device or ' ' in options.device: initialSteps = 250 if options.precision is not None: if platform.getName() == 'CUDA': properties['CudaPrecision'] = options.precision elif platform.getName() == 'OpenCL': properties['OpenCLPrecision'] = options.precision # Run the simulation. integ = mm.LangevinIntegrator(300 * unit.kelvin, 91 * (1 / unit.picoseconds), dt) integ.setConstraintTolerance(1e-5) if len(properties) > 0: context = mm.Context(system, integ, platform, properties) else: context = mm.Context(system, integ, platform) context.setPositions(pdb.positions) context.setVelocitiesToTemperature(300 * unit.kelvin) steps = 20 while True: time = timeIntegration(context, steps, initialSteps) if time >= 0.5 * options.seconds: break if time < 0.5: steps = int( steps * 1.0 / time ) # Integrate enough steps to get a reasonable estimate for how many we'll need. else: steps = int(steps * options.seconds / time) print('Integrated %d steps in %g seconds' % (steps, time)) print('%g ns/day' % (dt * steps * 86400 / time).value_in_unit(unit.nanoseconds))
from __future__ import print_function from simtk.openmm import app import simtk.openmm as mm from simtk import unit import sys import mbpol pdb = app.PDBFile("water14_cluster.pdb") forcefield = app.ForceField("mbpol.xml") #<MBPolElectrostaticsForce thole-charge-charge="0.4" thole-charge-dipole="0.4" thole-dipole-dipole="0.055" thole-dipole-dipole-singlebond="0.626"> expected = [0.4, 0.4, 0.055, 0.626, 0.055] #<MBPolElectrostaticsForce thole-charge-charge="1" thole-charge-dipole="2" thole-dipole-dipole="3" thole-dipole-dipole-singlebond="4"> #expected = [1, 2, 3, 4, 3] for param, expected_param in zip(forcefield._forces[0].thole, expected): assert (param == expected_param) print("Test Passed")
def solvate_and_minimize(topology, positions, phase=''): """ Solvate the given system and minimize. Parameters ---------- topology : simtk.openmm.Topology The topology positions : simtk.unit.Quantity of numpy.array of (natoms,3) with units compatible with nanometer. The positions phase : string, optional, default='' The phase prefix to prepend to written files. Returns ------- topology : simtk.openmm.app.Topology The new Topology object system : simtk.openm.System The solvated system. positions : simtk.unit.Quantity of dimension natoms x 3 with units compatible with angstroms The minimized positions. """ # Solvate (if desired) and create system. logger.info("Solvating...") forcefield = app.ForceField(*ffxmls) modeller = app.Modeller(topology, positions) modeller.addHydrogens(forcefield=forcefield, pH=pH) # DEBUG if is_periodic: # Add solvent if in a periodic box. modeller.addSolvent(forcefield, padding=padding, model=water_name) system = forcefield.createSystem(modeller.topology, nonbondedMethod=nonbonded_method, nonbondedCutoff=nonbonded_cutoff, constraints=constraints) if is_periodic: system.addForce(openmm.MonteCarloBarostat(pressure, temperature, barostat_frequency)) logger.info("System has %d atoms." % system.getNumParticles()) # DEBUG print "modeller.topology.chains(): %s" % str([ chain.id for chain in modeller.topology.chains() ]) # Serialize to XML files. logger.info("Serializing to XML...") system_filename = os.path.join(workdir, 'system.xml') write_file(system_filename, openmm.XmlSerializer.serialize(system)) if minimize: # Create simulation. logger.info("Creating simulation...") errorTol = 0.001 integrator = openmm.VariableLangevinIntegrator(temperature, collision_rate, errorTol) simulation = app.Simulation(modeller.topology, system, integrator) simulation.context.setPositions(modeller.positions) # Print potential energy. potential = simulation.context.getState(getEnergy=True).getPotentialEnergy() logger.info("Potential energy is %12.3f kcal/mol" % (potential / unit.kilocalories_per_mole)) # Write modeller positions. logger.info("Writing modeller output...") filename = os.path.join(workdir, phase + 'modeller.pdb') app.PDBFile.writeFile(simulation.topology, modeller.positions, open(filename, 'w')) # Minimize energy. logger.info("Minimizing energy...") simulation.minimizeEnergy(maxIterations=max_minimization_iterations) #integrator.step(max_minimization_iterations) state = simulation.context.getState(getEnergy=True) potential_energy = state.getPotentialEnergy() if np.isnan(potential_energy / unit.kilocalories_per_mole): raise Exception("Potential energy is NaN after minimization.") logger.info("Potential energy after minimiziation: %.3f kcal/mol" % (potential_energy / unit.kilocalories_per_mole)) modeller.positions = simulation.context.getState(getPositions=True).getPositions() # Print potential energy. potential = simulation.context.getState(getEnergy=True).getPotentialEnergy() logger.info("Potential energy is %12.3f kcal/mol" % (potential / unit.kilocalories_per_mole)) # Write minimized positions. filename = os.path.join(workdir, phase + 'minimized.pdb') app.PDBFile.writeFile(simulation.topology, modeller.positions, open(filename, 'w')) # Clean up del simulation # Return the modeller instance. return [modeller.topology, system, modeller.positions]
molecule_structure = forcefield.create_parmed_structure(topology=molecule.to_topology(), positions=molecule.positions) print('Molecule:', molecule_structure) # # Load and parameterize the protein # # Load the protein topology protein_pdb_filename = get_data_filename('proteins/T4-protein.pdb') protein_pdbfile = app.PDBFile(protein_pdb_filename) # Load the AMBER protein force field, along with a solvent force field from simtk.openmm import app protein_forcefield = 'amber99sbildn.xml' solvent_forcefield = 'tip3p.xml' forcefield = app.ForceField(protein_forcefield, solvent_forcefield) # Parameterize the protein protein_system = forcefield.createSystem(proteinpdb.topology) # Create a ParmEd Structure for the protein protein_structure = parmed.openmm.load_topology(proteinpdb.topology, protein_system, xyz=proteinpdb.positions) print('Protein:', protein_structure) # Combine the ParmEd Structure objects to produce a fully parameterized complex # that can now be exported to AMBER, CHARMM, OpenMM, and other packages # Note that the addition should always add the small molecule second so the box vectors if the first item (the protein) are to be preserved complex_structure = protein_structure + molecule_structure print('Complex:', complex_structure)
def __init__(self, molecules: List[str], output_filename: str, ncmc_switching_times: Dict[str, int], equilibrium_steps: Dict[str, int], timestep: unit.Quantity, initial_molecule: str=None, geometry_options: Dict=None): self._molecules = [SmallMoleculeSetProposalEngine.canonicalize_smiles(molecule) for molecule in molecules] environments = ['explicit', 'vacuum'] temperature = 298.15 * unit.kelvin pressure = 1.0 * unit.atmospheres constraints = app.HBonds self._storage = NetCDFStorage(output_filename) self._ncmc_switching_times = ncmc_switching_times self._n_equilibrium_steps = equilibrium_steps self._geometry_options = geometry_options # Create a system generator for our desired forcefields. from perses.rjmc.topology_proposal import SystemGenerator system_generators = dict() from pkg_resources import resource_filename gaff_xml_filename = resource_filename('perses', 'data/gaff.xml') barostat = openmm.MonteCarloBarostat(pressure, temperature) system_generators['explicit'] = SystemGenerator([gaff_xml_filename, 'tip3p.xml'], forcefield_kwargs={'nonbondedMethod': app.PME, 'nonbondedCutoff': 9.0 * unit.angstrom, 'implicitSolvent': None, 'constraints': constraints, 'ewaldErrorTolerance': 1e-5, 'hydrogenMass': 3.0*unit.amu}, barostat=barostat) system_generators['vacuum'] = SystemGenerator([gaff_xml_filename], forcefield_kwargs={'nonbondedMethod': app.NoCutoff, 'implicitSolvent': None, 'constraints': constraints, 'hydrogenMass': 3.0*unit.amu}) # # Create topologies and positions # topologies = dict() positions = dict() from openmoltools import forcefield_generators forcefield = app.ForceField(gaff_xml_filename, 'tip3p.xml') forcefield.registerTemplateGenerator(forcefield_generators.gaffTemplateGenerator) # Create molecule in vacuum. from perses.utils.openeye import extractPositionsFromOEMol from openmoltools.openeye import smiles_to_oemol, generate_conformers if initial_molecule: smiles = initial_molecule else: smiles = np.random.choice(molecules) molecule = smiles_to_oemol(smiles) molecule = generate_conformers(molecule, max_confs=1) topologies['vacuum'] = forcefield_generators.generateTopologyFromOEMol(molecule) positions['vacuum'] = extractPositionsFromOEMol(molecule) # Create molecule in solvent. modeller = app.Modeller(topologies['vacuum'], positions['vacuum']) modeller.addSolvent(forcefield, model='tip3p', padding=9.0 * unit.angstrom) topologies['explicit'] = modeller.getTopology() positions['explicit'] = modeller.getPositions() # Set up the proposal engines. proposal_metadata = {} proposal_engines = dict() for environment in environments: proposal_engines[environment] = SmallMoleculeSetProposalEngine(self._molecules, system_generators[environment]) # Generate systems systems = dict() for environment in environments: systems[environment] = system_generators[environment].build_system(topologies[environment]) # Define thermodynamic state of interest. thermodynamic_states = dict() thermodynamic_states['explicit'] = states.ThermodynamicState(system=systems['explicit'], temperature=temperature, pressure=pressure) thermodynamic_states['vacuum'] = states.ThermodynamicState(system=systems['vacuum'], temperature=temperature) # Create SAMS samplers from perses.samplers.samplers import ExpandedEnsembleSampler, SAMSSampler mcmc_samplers = dict() exen_samplers = dict() sams_samplers = dict() for environment in environments: storage = NetCDFStorageView(self._storage, envname=environment) if self._geometry_options: n_torsion_divisions = self._geometry_options['n_torsion_divsions'][environment] use_sterics = self._geometry_options['use_sterics'][environment] else: n_torsion_divisions = 180 use_sterics = False geometry_engine = geometry.FFAllAngleGeometryEngine(storage=storage, n_torsion_divisions=n_torsion_divisions, use_sterics=use_sterics) move = mcmc.LangevinSplittingDynamicsMove(timestep=timestep, splitting="V R O R V", n_restart_attempts=10) chemical_state_key = proposal_engines[environment].compute_state_key(topologies[environment]) if environment == 'explicit': sampler_state = states.SamplerState(positions=positions[environment], box_vectors=systems[environment].getDefaultPeriodicBoxVectors()) else: sampler_state = states.SamplerState(positions=positions[environment]) mcmc_samplers[environment] = mcmc.MCMCSampler(thermodynamic_states[environment], sampler_state, move) exen_samplers[environment] = ExpandedEnsembleSampler(mcmc_samplers[environment], topologies[environment], chemical_state_key, proposal_engines[environment], geometry_engine, options={'nsteps': self._ncmc_switching_times[environment]}, storage=storage, ncmc_write_interval=self._ncmc_switching_times[environment]) exen_samplers[environment].verbose = True sams_samplers[environment] = SAMSSampler(exen_samplers[environment], storage=storage) sams_samplers[environment].verbose = True # Create test MultiTargetDesign sampler. from perses.samplers.samplers import MultiTargetDesign target_samplers = {sams_samplers['explicit']: 1.0, sams_samplers['vacuum']: -1.0} designer = MultiTargetDesign(target_samplers, storage=self._storage) # Store things. self.molecules = molecules self.environments = environments self.topologies = topologies self.positions = positions self.system_generators = system_generators self.proposal_engines = proposal_engines self.thermodynamic_states = thermodynamic_states self.mcmc_samplers = mcmc_samplers self.exen_samplers = exen_samplers self.sams_samplers = sams_samplers self.designer = designer
solvated_pdb_filename = 'solvated.pdb' minimized_pdb_filename = 'minimized.pdb' equilibrated_pdb_filename = 'equilibrated.pdb' system_xml_filename = 'system.xml' integrator_xml_filename = 'integrator.xml' state_xml_filename = 'state.xml' # Read in the heavy atom model pdb_filename = 'input/6nb8_2ajf_complex_fixed.pdb' print('Loading %s' % pdb_filename) pdb = app.PDBFile(pdb_filename) # Use Amber 14SB print("Loading forcefield: %s" % ffxml_filenames) forcefield = app.ForceField(*ffxml_filenames) # Add hydrogens and solvate print('Adding hydrogens and solvent...') modeller = app.Modeller(pdb.topology, pdb.positions) modeller.addHydrogens(forcefield) modeller.addSolvent(forcefield, model=water_model, padding=solvent_padding, ionicStrength=ionic_strength) print('System has %d atoms' % modeller.topology.getNumAtoms()) # Write initial model print('Writing initial solvated system to %s' % output_prefix + solvated_pdb_filename) with open(output_prefix + solvated_pdb_filename, 'w') as outfile:
import simtk.openmm as mm from simtk import unit import sys import mbpol ##### Input system in pdb format # In[ ]: pdb = app.PDBFile("water14_cluster.pdb") ##### Define the type of potential, first file defines all elements, only the water model is in the second xml file # In[ ]: forcefield = app.ForceField(mbpol.__file__.replace('mbpol.py', 'mbpol.xml')) # use tip4p #forcefield = app.ForceField("tip4pfb.xml") ##### Create the System, define an integrator, define the Simulation # In[ ]: system = forcefield.createSystem(pdb.topology, nonbondedMethod=app.CutoffNonPeriodic, nonbondedCutoff=1e3 * unit.nanometer) integrator = mm.VerletIntegrator(0.00001 * unit.femtoseconds) # In[ ]: platform = mm.Platform.getPlatformByName('Reference')
def test_mutate_from_every_amino_to_every_other(): """ Make sure mutations are successful between every possible pair of before-and-after residues Mutate Ecoli F-ATPase alpha subunit to all 20 amino acids (test going FROM all possibilities) Mutate each residue to all 19 alternatives """ import perses.rjmc.topology_proposal as topology_proposal aminos = [ 'ALA', 'ARG', 'ASN', 'ASP', 'CYS', 'GLN', 'GLU', 'GLY', 'HIS', 'ILE', 'LEU', 'LYS', 'MET', 'PHE', 'PRO', 'SER', 'THR', 'TRP', 'TYR', 'VAL' ] failed_mutants = 0 pdbid = "2A7U" topology, positions = load_pdbid_to_openmm(pdbid) modeller = app.Modeller(topology, positions) for chain in modeller.topology.chains(): pass modeller.delete([chain]) ff_filename = "amber99sbildn.xml" max_point_mutants = 1 ff = app.ForceField(ff_filename) system = ff.createSystem(modeller.topology) chain_id = 'A' metadata = dict() system_generator = topology_proposal.SystemGenerator([ff_filename]) pm_top_engine = topology_proposal.PointMutationEngine( modeller.topology, system_generator, chain_id, proposal_metadata=metadata, max_point_mutants=max_point_mutants, always_change=True) current_system = system current_topology = modeller.topology current_positions = modeller.positions pm_top_engine._allowed_mutations = list() for k, proposed_amino in enumerate(aminos): pm_top_engine._allowed_mutations.append((str(k + 2), proposed_amino)) pm_top_proposal = pm_top_engine.propose(current_system, current_topology) current_system = pm_top_proposal.new_system current_topology = pm_top_proposal.new_topology for chain in current_topology.chains(): if chain.id == chain_id: # num_residues : int num_residues = len(chain._residues) break new_sequence = list() for residue in current_topology.residues(): if residue.index == 0: continue if residue.index == (num_residues - 1): continue if residue.name in ['HID', 'HIE']: residue.name = 'HIS' new_sequence.append(residue.name) for i in range(len(aminos)): assert new_sequence[i] == aminos[i] pm_top_engine = topology_proposal.PointMutationEngine( current_topology, system_generator, chain_id, proposal_metadata=metadata, max_point_mutants=max_point_mutants) from perses.rjmc.topology_proposal import append_topology old_topology = app.Topology() append_topology(old_topology, current_topology) new_topology = app.Topology() append_topology(new_topology, current_topology) old_chemical_state_key = pm_top_engine.compute_state_key(old_topology) for chain in new_topology.chains(): if chain.id == chain_id: # num_residues : int num_residues = len(chain._residues) break for proposed_location in range(1, num_residues - 1): print('Making mutations at residue %s' % proposed_location) original_residue_name = chain._residues[proposed_location].name matching_amino_found = 0 for proposed_amino in aminos: pm_top_engine._allowed_mutations = [(str(proposed_location + 1), proposed_amino)] new_topology = app.Topology() append_topology(new_topology, current_topology) old_system = current_system old_topology_natoms = sum([1 for atom in old_topology.atoms()]) old_system_natoms = old_system.getNumParticles() if old_topology_natoms != old_system_natoms: msg = 'PolymerProposalEngine: old_topology has %d atoms, while old_system has %d atoms' % ( old_topology_natoms, old_system_natoms) raise Exception(msg) metadata = dict() for atom in new_topology.atoms(): atom.old_index = atom.index index_to_new_residues, metadata = pm_top_engine._choose_mutant( new_topology, metadata) if len(index_to_new_residues) == 0: matching_amino_found += 1 continue print('Mutating %s to %s' % (original_residue_name, proposed_amino)) residue_map = pm_top_engine._generate_residue_map( new_topology, index_to_new_residues) for res_pair in residue_map: residue = res_pair[0] name = res_pair[1] assert residue.index in index_to_new_residues.keys() assert index_to_new_residues[residue.index] == name assert residue.name + '-' + str( residue.id) + '-' + name in metadata['mutations'] new_topology, missing_atoms = pm_top_engine._delete_excess_atoms( new_topology, residue_map) new_topology = pm_top_engine._add_new_atoms( new_topology, missing_atoms, residue_map) for res_pair in residue_map: residue = res_pair[0] name = res_pair[1] assert residue.name == name atom_map = pm_top_engine._construct_atom_map( residue_map, old_topology, index_to_new_residues, new_topology) templates = pm_top_engine._ff.getMatchingTemplates(new_topology) assert [ templates[index].name == residue.name for index, (residue, name) in enumerate(residue_map) ] new_chemical_state_key = pm_top_engine.compute_state_key( new_topology) new_system = pm_top_engine._system_generator.build_system( new_topology) pm_top_proposal = topology_proposal.TopologyProposal( new_topology=new_topology, new_system=new_system, old_topology=old_topology, old_system=old_system, old_chemical_state_key=old_chemical_state_key, new_chemical_state_key=new_chemical_state_key, logp_proposal=0.0, new_to_old_atom_map=atom_map) assert matching_amino_found == 1
import mdtraj as md import numpy as np # ## Setting up the engine # Now we set things up for the OpenMM simulation. We will need a `openmm.System` object and an `openmm.Integrator` object. # # To learn more about OpenMM, read the [OpenMM documentation](http://docs.openmm.org). The code we use here is based on output from the convenient web-based [OpenMM builder](http://builder.openmm.org). # In[2]: # this cell is all OpenMM specific forcefield = app.ForceField('amber96.xml', 'tip3p.xml') pdb = app.PDBFile("AD_initial_frame.pdb") system = forcefield.createSystem( pdb.topology, nonbondedMethod=app.PME, nonbondedCutoff=1.0*unit.nanometers, constraints=app.HBonds, rigidWater=True, ewaldErrorTolerance=0.0005 ) hi_T_integrator = VVVRIntegrator( 500*unit.kelvin, 1.0/unit.picoseconds, 2.0*unit.femtoseconds) hi_T_integrator.setConstraintTolerance(0.00001)
#from mbnrgplugin import MBnrgForce #system = System() #force = MBnrgForce() #system.addForce(force) from simtk.openmm import app, System import simtk.openmm as mm from simtk import unit import sys import mbnrg pdb = app.PDBFile("water3.pdb") print(pdb.topology) forcefield = app.ForceField(mbnrg.__file__.replace('mbnrg.py', 'mbnrg.xml')) system = forcefield.createSystem(pdb.topology) integrator = mm.VerletIntegrator(0.00001*unit.femtoseconds) platform = mm.Platform.getPlatformByName('Reference') simulation = app.Simulation(pdb.topology, system, integrator, platform) simulation.context.setPositions(pdb.positions) state = simulation.context.getState(getForces=True, getEnergy=True) potential_energy = state.getPotentialEnergy() print("Energy:") print(potential_energy.in_units_of(unit.kilocalorie_per_mole)) print("Gradients") kilocalorie_per_mole_per_angstrom = unit.kilocalorie_per_mole/unit.angstrom
import parmed from simtk.openmm import app, XmlSerializer # convert to sdf first off_mol = OFFMolecule.from_file("MOL.pdb") off_mol.to_file("MOL.sdf", "sdf") # make the qube mol qb_mol1 = Ligand.from_file("MOL.sdf") # apply params OpenFF(qb_mol1) # write out the params qb_mol1.write_parameters("temp") # now load a second molecule qb_mol2 = Ligand.from_file("MOL.sdf") # apply params from xml XML(qb_mol2, input_file="MOL.xml") # transfer the torsions qb_mol2.PeriodicTorsionForce = qb_mol1.PeriodicTorsionForce qb_mol2.combination = "opls" qb_mol2.write_parameters(name="new") # now build the parmed system pdb = app.PDBFile("MOL.pdb") ff = app.ForceField("new.xml") system = ff.createSystem(pdb.topology) p_sys = parmed.openmm.load_topology(pdb.topology, system, xyz=pdb.positions) p_sys.save("test.prmtop")