def generate_atp(phase='vacuum'): """ modify the AlanineDipeptideVacuum test system to be parametrized with amber14ffsb in vac or solvent (tip3p) """ import openmmtools.testsystems as ts atp = ts.AlanineDipeptideVacuum(constraints=app.HBonds, hydrogenMass=4 * unit.amus) forcefield_files = [ 'gaff.xml', 'amber14/protein.ff14SB.xml', 'amber14/tip3p.xml' ] if phase == 'vacuum': barostat = None system_generator = SystemGenerator(forcefield_files, barostat=barostat, forcefield_kwargs={ 'removeCMMotion': False, 'ewaldErrorTolerance': 1e-4, 'nonbondedMethod': app.NoCutoff, 'constraints': app.HBonds, 'hydrogenMass': 4 * unit.amus }) atp.system = system_generator.build_system( atp.topology) #update the parametrization scheme to amberff14sb elif phase == 'solvent': barostat = openmm.MonteCarloBarostat(1.0 * unit.atmosphere, 300 * unit.kelvin, 50) system_generator = SystemGenerator(forcefield_files, barostat=barostat, forcefield_kwargs={ 'removeCMMotion': False, 'ewaldErrorTolerance': 1e-4, 'nonbondedMethod': app.PME, 'constraints': app.HBonds, 'hydrogenMass': 4 * unit.amus }) if phase == 'solvent': modeller = app.Modeller(atp.topology, atp.positions) modeller.addSolvent(system_generator._forcefield, model='tip3p', padding=9 * unit.angstroms, ionicStrength=0.15 * unit.molar) solvated_topology = modeller.getTopology() solvated_positions = modeller.getPositions() # canonicalize the solvated positions: turn tuples into np.array atp.positions = unit.quantity.Quantity(value=np.array([ list(atom_pos) for atom_pos in solvated_positions.value_in_unit_system(unit.md_unit_system) ]), unit=unit.nanometers) atp.topology = solvated_topology atp.system = system_generator.build_system(atp.topology) return atp, system_generator
def generate_solvated_hybrid_test_topology(current_mol_name="naphthalene", proposed_mol_name="benzene", current_mol_smiles=None, proposed_mol_smiles=None, vacuum=False, render_atom_mapping=False): """ This function will generate a topology proposal, old positions, and new positions with a geometry proposal (either vacuum or solvated) given a set of input iupacs or smiles. The function will (by default) read the iupac names first. If they are set to None, then it will attempt to read a set of current and new smiles. An atom mapping pdf will be generated if specified. Arguments ---------- current_mol_name : str, optional name of the first molecule proposed_mol_name : str, optional name of the second molecule current_mol_smiles : str (default None) current mol smiles proposed_mol_smiles : str (default None) proposed mol smiles vacuum: bool (default False) whether to render a vacuum or solvated topology_proposal render_atom_mapping : bool (default False) whether to render the atom map of the current_mol_name and proposed_mol_name 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 """ import simtk.openmm.app as app from openmoltools import forcefield_generators from openeye import oechem from openmoltools.openeye import iupac_to_oemol, generate_conformers, smiles_to_oemol from openmoltools import forcefield_generators import perses.utils.openeye as openeye from perses.utils.data import get_data_filename from perses.rjmc.topology_proposal import TopologyProposal, SystemGenerator, SmallMoleculeSetProposalEngine import simtk.unit as unit from perses.rjmc.geometry import FFAllAngleGeometryEngine if current_mol_name != None and proposed_mol_name != None: try: old_oemol, new_oemol = iupac_to_oemol( current_mol_name), iupac_to_oemol(proposed_mol_name) old_smiles = oechem.OECreateSmiString( old_oemol, oechem.OESMILESFlag_DEFAULT | oechem.OESMILESFlag_Hydrogens) new_smiles = oechem.OECreateSmiString( new_oemol, oechem.OESMILESFlag_DEFAULT | oechem.OESMILESFlag_Hydrogens) except: raise Exception( f"either {current_mol_name} or {proposed_mol_name} is not compatible with 'iupac_to_oemol' function!" ) elif current_mol_smiles != None and proposed_mol_smiles != None: try: old_oemol, new_oemol = smiles_to_oemol( current_mol_smiles), smiles_to_oemol(proposed_mol_smiles) old_smiles = oechem.OECreateSmiString( old_oemol, oechem.OESMILESFlag_DEFAULT | oechem.OESMILESFlag_Hydrogens) new_smiles = oechem.OECreateSmiString( new_oemol, oechem.OESMILESFlag_DEFAULT | oechem.OESMILESFlag_Hydrogens) except: raise Exception(f"the variables are not compatible") else: raise Exception( f"either current_mol_name and proposed_mol_name must be specified as iupacs OR current_mol_smiles and proposed_mol_smiles must be specified as smiles strings." ) old_oemol, old_system, old_positions, old_topology = openeye.createSystemFromSMILES( old_smiles, title="MOL") #correct the old positions old_positions = openeye.extractPositionsFromOEMol(old_oemol) old_positions = old_positions.in_units_of(unit.nanometers) new_oemol, new_system, new_positions, new_topology = openeye.createSystemFromSMILES( new_smiles, title="NEW") ffxml = forcefield_generators.generateForceFieldFromMolecules( [old_oemol, new_oemol]) old_oemol.SetTitle('MOL') new_oemol.SetTitle('MOL') old_topology = forcefield_generators.generateTopologyFromOEMol(old_oemol) new_topology = forcefield_generators.generateTopologyFromOEMol(new_oemol) if not vacuum: nonbonded_method = app.PME barostat = openmm.MonteCarloBarostat(1.0 * unit.atmosphere, 300.0 * unit.kelvin, 50) else: nonbonded_method = app.NoCutoff barostat = None gaff_xml_filename = get_data_filename("data/gaff.xml") system_generator = SystemGenerator( [gaff_xml_filename, 'amber99sbildn.xml', 'tip3p.xml'], barostat=barostat, forcefield_kwargs={ 'removeCMMotion': False, 'nonbondedMethod': nonbonded_method, 'constraints': app.HBonds, 'hydrogenMass': 4.0 * unit.amu }) system_generator._forcefield.loadFile(StringIO(ffxml)) proposal_engine = SmallMoleculeSetProposalEngine([old_smiles, new_smiles], system_generator, residue_name='MOL') geometry_engine = FFAllAngleGeometryEngine(metadata=None, use_sterics=False, n_bond_divisions=1000, n_angle_divisions=180, n_torsion_divisions=360, verbose=True, storage=None, bond_softening_constant=1.0, angle_softening_constant=1.0, neglect_angles=False) if not vacuum: #now to solvate modeller = app.Modeller(old_topology, old_positions) hs = [ atom for atom in modeller.topology.atoms() if atom.element.symbol in ['H'] and atom.residue.name not in ['MOL', 'OLD', 'NEW'] ] modeller.delete(hs) modeller.addHydrogens(forcefield=system_generator._forcefield) modeller.addSolvent(system_generator._forcefield, model='tip3p', padding=9.0 * unit.angstroms) solvated_topology = modeller.getTopology() solvated_positions = modeller.getPositions() solvated_positions = unit.quantity.Quantity(value=np.array([ list(atom_pos) for atom_pos in solvated_positions.value_in_unit_system(unit.md_unit_system) ]), unit=unit.nanometers) solvated_system = system_generator.build_system(solvated_topology) #now to create proposal top_proposal = proposal_engine.propose( current_system=solvated_system, current_topology=solvated_topology, current_mol=old_oemol, proposed_mol=new_oemol) new_positions, _ = geometry_engine.propose(top_proposal, solvated_positions, beta) if render_atom_mapping: from perses.utils.smallmolecules import render_atom_mapping print( f"new_to_old: {proposal_engine.non_offset_new_to_old_atom_map}" ) render_atom_mapping(f"{old_smiles}to{new_smiles}.png", old_oemol, new_oemol, proposal_engine.non_offset_new_to_old_atom_map) return top_proposal, solvated_positions, new_positions else: vacuum_system = system_generator.build_system(old_topology) top_proposal = proposal_engine.propose(current_system=vacuum_system, current_topology=old_topology, current_mol=old_oemol, proposed_mol=new_oemol) new_positions, _ = geometry_engine.propose(top_proposal, old_positions, beta) if render_atom_mapping: from perses.utils.smallmolecules import render_atom_mapping print(f"new_to_old: {top_proposal._new_to_old_atom_map}") render_atom_mapping(f"{old_smiles}to{new_smiles}.png", old_oemol, new_oemol, top_proposal._new_to_old_atom_map) return top_proposal, old_positions, new_positions
def create_systems(topologies_dict, positions_dict, output_directory, project_prefix, solvate=True): """ Generate the systems ready for equilibrium simulations from a dictionary of topologies and positions Parameters ---------- topologies_dict : dict of str: app.Topoology A dictionary of the topologies to prepare, indexed by SMILES strings positions_dict : dict of str: unit.Quantity array A dictionary of positions for the corresponding topologies, indexed by SMILES strings output_directory : str Location of output files project_prefix : str What to prepend to the names of files for this run solvate : bool, default True Whether to solvate the systems """ barostat = openmm.MonteCarloBarostat(1.0 * unit.atmosphere, temperature, 50) system_generator = SystemGenerator( [ 'amber14/protein.ff14SB.xml', 'gaff.xml', 'amber14/tip3p.xml', 'MCL1_ligands.xml' ], barostat=barostat, forcefield_kwargs={ 'nonbondedMethod': app.PME, 'constraints': app.HBonds, 'hydrogenMass': 4 * unit.amus }, use_antechamber=False) list_of_smiles = list(topologies_dict.keys()) initial_smiles = list_of_smiles[0] initial_topology = topologies_dict[initial_smiles] initial_positions = positions_dict[initial_smiles] if solvate: solvated_initial_positions, solvated_topology, solvated_system = solvate_system( initial_topology.to_openmm(), initial_positions, system_generator) else: solvated_initial_positions = initial_positions solvated_topology = initial_topology solvated_system = system_generator.build_system(solvated_topology) md_topology = md.Topology.from_openmm(solvated_topology) if solvate: num_added = md_topology.n_residues - initial_topology.n_residues if not os.path.exists(output_directory): os.mkdir(output_directory) np.save("{}/{}_{}_initial.npy".format(output_directory, project_prefix, 0), (solvated_initial_positions, md_topology, solvated_system, initial_smiles)) for i in tqdm.trange(1, len(list_of_smiles)): smiles = list_of_smiles[i] topology = topologies_dict[smiles] positions = positions_dict[smiles] if solvate: solvated_positions, solvated_topology, solvated_system = solvate_system( topology.to_openmm(), positions, system_generator, padding=None, num_added=num_added) else: solvated_positions = initial_positions solvated_topology = initial_topology solvated_system = system_generator.build_system(solvated_topology) np.save( "{}/{}_{}_initial.npy".format(output_directory, project_prefix, i), (solvated_positions, md.Topology.from_openmm(solvated_topology), solvated_system, smiles))
class NonequilibriumFEPSetup(object): """ This class is a helper class for nonequilibrium FEP. It generates the input objects that are necessary for the two legs of a relative FEP calculation. For each leg, that is a TopologyProposal, old_positions, and new_positions. Importantly, it ensures that the atom maps in the solvent and complex phases match correctly. """ def __init__(self, protein_pdb_filename, ligand_file, old_ligand_index, new_ligand_index, forcefield_files, pressure=1.0 * unit.atmosphere, temperature=300.0 * unit.kelvin, solvent_padding=9.0 * unit.angstroms): """ Initialize a NonequilibriumFEPSetup object Parameters ---------- protein_pdb_filename : str The name of the protein pdb file ligand_file : str the name of the ligand file (any openeye supported format) ligand_smiles : list of two str The SMILES strings representing the two ligands forcefield_files : list of str The list of ffxml files that contain the forcefields that will be used pressure : Quantity, units of pressure Pressure to use in the barostat temperature : Quantity, units of temperature Temperature to use for the Langevin integrator solvent_padding : Quantity, units of length The amount of padding to use when adding solvent """ self._protein_pdb_filename = protein_pdb_filename self._pressure = pressure self._temperature = temperature self._barostat_period = 50 self._padding = solvent_padding self._ligand_file = ligand_file self._old_ligand_index = old_ligand_index self._new_ligand_index = new_ligand_index self._old_ligand_oemol = self.load_sdf(self._ligand_file, index=self._old_ligand_index) self._new_ligand_oemol = self.load_sdf(self._ligand_file, index=self._new_ligand_index) self._old_ligand_positions = extractPositionsFromOEMOL( self._old_ligand_oemol) ffxml = forcefield_generators.generateForceFieldFromMolecules( [self._old_ligand_oemol, self._new_ligand_oemol]) self._old_ligand_oemol.SetTitle("MOL") self._new_ligand_oemol.SetTitle("MOL") self._new_ligand_smiles = oechem.OECreateSmiString( self._new_ligand_oemol, oechem.OESMILESFlag_DEFAULT | oechem.OESMILESFlag_Hydrogens) #self._old_ligand_smiles = '[H]c1c(c(c(c(c1N([H])c2nc3c(c(n2)OC([H])([H])C4(C(C(C(C(C4([H])[H])([H])[H])([H])[H])([H])[H])([H])[H])[H])nc(n3[H])[H])[H])[H])S(=O)(=O)C([H])([H])[H])[H]' self._old_ligand_smiles = oechem.OECreateSmiString( self._old_ligand_oemol, oechem.OESMILESFlag_DEFAULT | oechem.OESMILESFlag_Hydrogens) print(self._new_ligand_smiles) print(self._old_ligand_smiles) self._old_ligand_topology = forcefield_generators.generateTopologyFromOEMol( self._old_ligand_oemol) self._old_ligand_md_topology = md.Topology.from_openmm( self._old_ligand_topology) self._new_ligand_topology = forcefield_generators.generateTopologyFromOEMol( self._new_ligand_oemol) self._new_liands_md_topology = md.Topology.from_openmm( self._new_ligand_topology) protein_pdbfile = open(self._protein_pdb_filename, 'r') pdb_file = app.PDBFile(protein_pdbfile) protein_pdbfile.close() self._protein_topology_old = pdb_file.topology self._protein_md_topology_old = md.Topology.from_openmm( self._protein_topology_old) self._protein_positions_old = pdb_file.positions self._forcefield = app.ForceField(*forcefield_files) self._forcefield.loadFile(StringIO(ffxml)) print("Generated forcefield") self._complex_md_topology_old = self._protein_md_topology_old.join( self._old_ligand_md_topology) self._complex_topology_old = self._complex_md_topology_old.to_openmm() n_atoms_complex_old = self._complex_topology_old.getNumAtoms() n_atoms_protein_old = self._protein_topology_old.getNumAtoms() self._complex_positions_old = unit.Quantity(np.zeros( [n_atoms_complex_old, 3]), unit=unit.nanometers) self._complex_positions_old[: n_atoms_protein_old, :] = self._protein_positions_old self._complex_positions_old[ n_atoms_protein_old:, :] = self._old_ligand_positions if pressure is not None: barostat = openmm.MonteCarloBarostat(self._pressure, self._temperature, self._barostat_period) self._system_generator = SystemGenerator( forcefield_files, barostat=barostat, forcefield_kwargs={'nonbondedMethod': app.PME}) else: self._system_generator = SystemGenerator(forcefield_files) #self._complex_proposal_engine = TwoMoleculeSetProposalEngine(self._old_ligand_smiles, self._new_ligand_smiles, self._system_generator, residue_name="MOL") self._complex_proposal_engine = TwoMoleculeSetProposalEngine( self._old_ligand_oemol, self._new_ligand_oemol, self._system_generator, residue_name="MOL") self._geometry_engine = FFAllAngleGeometryEngine() self._complex_topology_old_solvated, self._complex_positions_old_solvated, self._complex_system_old_solvated = self._solvate_system( self._complex_topology_old, self._complex_positions_old) self._complex_md_topology_old_solvated = md.Topology.from_openmm( self._complex_topology_old_solvated) print(self._complex_proposal_engine._smiles_list) beta = 1.0 / (kB * temperature) self._complex_topology_proposal = self._complex_proposal_engine.propose( self._complex_system_old_solvated, self._complex_topology_old_solvated) self._complex_positions_new_solvated, _ = self._geometry_engine.propose( self._complex_topology_proposal, self._complex_positions_old_solvated, beta) #now generate the equivalent objects for the solvent phase. First, generate the ligand-only topologies and atom map self._solvent_topology_proposal, self._old_solvent_positions = self._generate_ligand_only_topologies( self._complex_positions_old_solvated, self._complex_positions_new_solvated) self._new_solvent_positions, _ = self._geometry_engine.propose( self._solvent_topology_proposal, self._old_solvent_positions, beta) def load_sdf(self, sdf_filename, index=0): """ Load an SDF file into an OEMol. Since SDF files can contain multiple molecules, an index can be provided as well. Parameters ---------- sdf_filename : str The name of the SDF file index : int, default 0 The index of the molecule in the SDF file Returns ------- mol : openeye.oechem.OEMol object The loaded oemol object """ ifs = oechem.oemolistream() ifs.open(sdf_filename) #get the list of molecules mol_list = [oechem.OEMol(mol) for mol in ifs.GetOEMols()] #we'll always take the first for now mol_to_return = mol_list[index] return mol_to_return def _solvate_system(self, topology, positions, model='tip3p'): """ Generate a solvated topology, positions, and system for a given input topology and positions. For generating the system, the forcefield files provided in the constructor will be used. Parameters ---------- topology : app.Topology Topology of the system to solvate positions : [n, 3] ndarray of Quantity nm the positions of the unsolvated system Returns ------- solvated_topology : app.Topology Topology of the system with added waters solvated_positions : [n + 3(n_waters), 3] ndarray of Quantity nm Solvated positions solvated_system : openmm.System The parameterized system, containing a barostat if one was specified. """ modeller = app.Modeller(topology, positions) hs = [ atom for atom in modeller.topology.atoms() if atom.element.symbol in ['H'] and atom.residue.name != "MOL" ] modeller.delete(hs) modeller.addHydrogens(forcefield=self._forcefield) print("preparing to add solvent") modeller.addSolvent(self._forcefield, model=model, padding=self._padding) solvated_topology = modeller.getTopology() solvated_positions = modeller.getPositions() print("solvent added, parameterizing") solvated_system = self._system_generator.build_system( solvated_topology) print("System parameterized") return solvated_topology, solvated_positions, solvated_system def _generate_ligand_only_topologies(self, old_positions, new_positions): """ This method generates ligand-only topologies and positions from a TopologyProposal containing a solvated complex. The output of this method is then used when building the solvent-phase simulation with the same atom map. Parameters ---------- topology_proposal : perses.rjmc.TopologyProposal TopologyProposal representing the solvated complex transformation Returns ------- old_ligand_topology : app.Topology The old topology without the receptor or solvent new_ligand_topology : app.Topology The new topology without the receptor or solvent old_ligand_positions : [m, 3] ndarray of Quantity nm The positions of the old ligand without receptor or solvent new_ligand_positions : [n, 3] ndarray of Quantity nm The positions of the new ligand without receptor or solvent atom_map : dict of int: it The mapping between the two topologies without ligand or solvent. """ old_complex = md.Topology.from_openmm( self._complex_topology_proposal.old_topology) new_complex = md.Topology.from_openmm( self._complex_topology_proposal.new_topology) complex_atom_map = self._complex_topology_proposal.old_to_new_atom_map old_mol_start_index, old_mol_len = self._complex_proposal_engine._find_mol_start_index( old_complex.to_openmm()) new_mol_start_index, new_mol_len = self._complex_proposal_engine._find_mol_start_index( new_complex.to_openmm()) old_pos = unit.Quantity(np.zeros([len(old_positions), 3]), unit=unit.nanometers) old_pos[:, :] = old_positions old_ligand_positions = old_pos[old_mol_start_index:( old_mol_start_index + old_mol_len), :] new_ligand_positions = new_positions[new_mol_start_index:( new_mol_start_index + new_mol_len), :] #atom_map_adjusted = {} #loop through the atoms in the map. If the old index is creater than the old_mol_start_index but less than that #plus the old mol length, then it is valid to include its adjusted value in the map. #for old_idx, new_idx in complex_atom_map.items(): # if old_idx > old_mol_start_index and old_idx < old_mol_len + old_mol_start_index: # atom_map_adjusted[old_idx - old_mol_len] = new_idx - new_mol_start_index #subset the topologies: old_ligand_topology = old_complex.subset( old_complex.select("resname == 'MOL' ")) new_ligand_topology = new_complex.subset( new_complex.select("resname == 'MOL' ")) #solvate the old ligand topology: old_solvated_topology, old_solvated_positions, old_solvated_system = self._solvate_system( old_ligand_topology.to_openmm(), old_ligand_positions) old_solvated_md_topology = md.Topology.from_openmm( old_solvated_topology) #now remove the old ligand, leaving only the solvent solvent_only_topology = old_solvated_md_topology.subset( old_solvated_md_topology.select("water")) #append the solvent to the new ligand-only topology: new_solvated_ligand_md_topology = new_ligand_topology.join( solvent_only_topology) nsl, b = new_solvated_ligand_md_topology.to_dataframe() #dirty hack because new_solvated_ligand_md_topology.to_openmm() was throwing bond topology error new_solvated_ligand_md_topology = md.Topology.from_dataframe(nsl, b) new_solvated_ligand_omm_topology = new_solvated_ligand_md_topology.to_openmm( ) new_solvated_ligand_omm_topology.setPeriodicBoxVectors( old_solvated_topology.getPeriodicBoxVectors()) #create the new ligand system: new_solvated_system = self._system_generator.build_system( new_solvated_ligand_omm_topology) new_to_old_atom_map = { complex_atom_map[x] - new_mol_start_index: x - old_mol_start_index for x in old_complex.select("resname == 'MOL' ") if x in complex_atom_map.keys() } #adjust the atom map to account for the presence of solvent degrees of freedom: #By design, all atoms after the ligands are water, and should be mapped. n_water_atoms = solvent_only_topology.to_openmm().getNumAtoms() for i in range(n_water_atoms): new_to_old_atom_map[new_mol_len + i] = old_mol_len + i #change the map to accomodate the TP: #new_to_old_atom_map = {value : key for key, value in atom_map_adjusted.items()} #make a TopologyProposal ligand_topology_proposal = TopologyProposal( new_topology=new_solvated_ligand_omm_topology, new_system=new_solvated_system, old_topology=old_solvated_topology, old_system=old_solvated_system, new_to_old_atom_map=new_to_old_atom_map, old_chemical_state_key='A', new_chemical_state_key='B') return ligand_topology_proposal, old_solvated_positions @property def complex_topology_proposal(self): return self._complex_topology_proposal @property def complex_old_positions(self): return self._complex_positions_old_solvated @property def complex_new_positions(self): return self._complex_positions_new_solvated @property def solvent_topology_proposal(self): return self._solvent_topology_proposal @property def solvent_old_positions(self): return self._old_solvent_positions @property def solvent_new_positions(self): return self._new_solvent_positions
def generate_vacuum_topology_proposal(current_mol_name="benzene", proposed_mol_name="toluene", forcefield_kwargs=None, system_generator_kwargs=None): """ Generate a test vacuum topology proposal, current positions, and new positions triplet from two IUPAC molecule names. Constraints are added to the system by default. To override this, set ``forcefield_kwargs = None``. Parameters ---------- current_mol_name : str, optional name of the first molecule proposed_mol_name : str, optional name of the second molecule forcefield_kwargs : dict, optional, default=None Additional arguments to ForceField in addition to 'removeCMMotion': False, 'nonbondedMethod': app.NoCutoff system_generator_kwargs : dict, optional, default=None Dict passed onto SystemGenerator 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 perses.tests.utils import createOEMolFromIUPAC, createSystemFromIUPAC, get_data_filename gaff_filename = get_data_filename('data/gaff.xml') default_forcefield_kwargs = {'removeCMMotion': False, 'nonbondedMethod': app.NoCutoff, 'constraints' : app.HBonds} forcefield_kwargs = default_forcefield_kwargs.update(forcefield_kwargs) if (forcefield_kwargs is not None) else default_forcefield_kwargs system_generator_kwargs = system_generator_kwargs if (system_generator_kwargs is not None) else dict() system_generator = SystemGenerator([gaff_filename, 'amber99sbildn.xml', 'tip3p.xml'], forcefield_kwargs=forcefield_kwargs, **system_generator_kwargs) old_oemol = createOEMolFromIUPAC(current_mol_name) from openmoltools.forcefield_generators import generateTopologyFromOEMol old_topology = generateTopologyFromOEMol(old_oemol) old_positions = extractPositionsFromOEMOL(old_oemol) old_smiles = oechem.OEMolToSmiles(old_oemol) old_system = system_generator.build_system(old_topology) new_oemol = createOEMolFromIUPAC(proposed_mol_name) new_smiles = oechem.OEMolToSmiles(new_oemol) geometry_engine = geometry.FFAllAngleGeometryEngine() proposal_engine = SmallMoleculeSetProposalEngine( [old_smiles, new_smiles], system_generator, residue_name=current_mol_name) #generate topology proposal topology_proposal = proposal_engine.propose(old_system, old_topology, current_mol=old_oemol, proposed_mol=new_oemol) # show atom mapping filename = str(current_mol_name)+str(proposed_mol_name)+'.pdf' render_atom_mapping(filename, old_oemol, new_oemol, topology_proposal.new_to_old_atom_map) #generate new positions with geometry engine new_positions, _ = geometry_engine.propose(topology_proposal, old_positions, beta) # DEBUG: Zero out bonds and angles for one system #print('Zeroing bonds of old system') #for force in topology_proposal.old_system.getForces(): # if force.__class__.__name__ == 'HarmonicAngleForce': # for index in range(force.getNumAngles()): # p1, p2, p3, angle, K = force.getAngleParameters(index) # K *= 0.0 # force.setAngleParameters(index, p1, p2, p3, angle, K) # if False and force.__class__.__name__ == 'HarmonicBondForce': # for index in range(force.getNumBonds()): # p1, p2, r0, K = force.getBondParameters(index) # K *= 0.0 # force.setBondParameters(index, p1, p2, r0, K) # DEBUG : Box vectors #box_vectors = np.eye(3) * 100 * unit.nanometers #topology_proposal.old_system.setDefaultPeriodicBoxVectors(box_vectors[0,:], box_vectors[1,:], box_vectors[2,:]) #topology_proposal.new_system.setDefaultPeriodicBoxVectors(box_vectors[0,:], box_vectors[1,:], box_vectors[2,:]) return topology_proposal, old_positions, new_positions
['gaff2.xml'], barostat=None, forcefield_kwargs={ 'removeCMMotion': False, 'ewaldErrorTolerance': 1e-4, 'nonbondedMethod': app.NoCutoff, 'constraints': app.HBonds, 'hydrogenMass': 4 * unit.amus }) # In[ ]: # In[ ]: old_mol, old_system, old_pos, old_top = createSystemFromSMILES('CCCCO') old_system = system_generator.build_system(old_top) new_mol, new_system, new_pos, new_top = createSystemFromSMILES('CCCCS') new_system = system_generator.build_system(new_top) # In[ ]: num_old_constraints = old_system.getNumConstraints() print(num_old_constraints) for i in range(num_old_constraints): print(old_system.getConstraintParameters(i)) # In[ ]: num_old_constraints = new_system.getNumConstraints() print(num_old_constraints)
def create_systems(topologies_dict, positions_dict, output_directory, project_prefix, solvate=True): """ Generate the systems ready for equilibrium simulations from a dictionary of topologies and positions Parameters ---------- topologies_dict : dict of str: app.Topoology A dictionary of the topologies to prepare, indexed by SMILES strings positions_dict : dict of str: unit.Quantity array A dictionary of positions for the corresponding topologies, indexed by SMILES strings output_directory : str Location of output files project_prefix : str What to prepend to the names of files for this run solvate : bool, default True Whether to solvate the systems """ barostat = openmm.MonteCarloBarostat(1.0*unit.atmosphere, temperature, 50) system_generator = SystemGenerator(['amber14/protein.ff14SB.xml', 'gaff.xml', 'amber14/tip3p.xml', 'MCL1_ligands.xml'], barostat=barostat, forcefield_kwargs={'nonbondedMethod': app.PME, 'constraints': app.HBonds, 'hydrogenMass': 4 * unit.amus}, use_antechamber=False) list_of_smiles = list(topologies_dict.keys()) initial_smiles = list_of_smiles[0] initial_topology = topologies_dict[initial_smiles] initial_positions = positions_dict[initial_smiles] if solvate: solvated_initial_positions, solvated_topology, solvated_system = solvate_system(initial_topology.to_openmm(), initial_positions, system_generator) else: solvated_initial_positions = initial_positions solvated_topology = initial_topology solvated_system = system_generator.build_system(solvated_topology) md_topology = md.Topology.from_openmm(solvated_topology) if solvate: num_added = md_topology.n_residues - initial_topology.n_residues if not os.path.exists(output_directory): os.mkdir(output_directory) np.save("{}/{}_{}_initial.npy".format(output_directory,project_prefix, 0), (solvated_initial_positions, md_topology, solvated_system, initial_smiles)) for i in tqdm.trange(1, len(list_of_smiles)): smiles = list_of_smiles[i] topology = topologies_dict[smiles] positions = positions_dict[smiles] if solvate: solvated_positions, solvated_topology, solvated_system = solvate_system(topology.to_openmm(), positions, system_generator, padding=None, num_added=num_added) else: solvated_positions = initial_positions solvated_topology = initial_topology solvated_system = system_generator.build_system(solvated_topology) np.save("{}/{}_{}_initial.npy".format(output_directory,project_prefix, i), (solvated_positions, md.Topology.from_openmm(solvated_topology), solvated_system, smiles))