def add_to_openmm(self, openmm_system): """ Add CMAPTorsionForce to openmm system. :param openmm_system: System object to receive the force """ cmap_force = openmm.CMAPTorsionForce() cmap_force.addMap(self._gly_map.shape[0], self._gly_map.flatten()) cmap_force.addMap(self._pro_map.shape[0], self._pro_map.flatten()) cmap_force.addMap(self._ala_map.shape[0], self._ala_map.flatten()) cmap_force.addMap(self._gen_map.shape[0], self._gen_map.flatten()) # loop over all of the contiguous chains of amino acids for chain in self._iterate_cmap_chains(): # loop over the interior residues n_res = len(chain) for i in range(1, n_res - 1): map_index = self._map_index[chain[i].res_name] # subtract one from all of these to get zero-based indexing, # as in openmm c_prev = chain[i - 1].index_C - 1 n = chain[i].index_N - 1 ca = chain[i].index_CA - 1 c = chain[i].index_C - 1 n_next = chain[i + 1].index_N - 1 cmap_force.addTorsion(map_index, c_prev, n, ca, c, n, ca, c, n_next) openmm_system.addForce(cmap_force)
def _addCMAPToSystem(self, sys): """Create the CMAP terms """ if not self._hasTable('torsiontorsion_cmap_term'): return # Create CMAP torsion terms cmap = mm.CMAPTorsionForce() sys.addForce(cmap) cmap_indices = {} for name in [k for k in self._tables.keys() if k.startswith('cmap')]: size2 = self._conn.execute('SELECT COUNT(*) FROM %s' % name).fetchone()[0] fsize = math.sqrt(size2) if fsize != int(fsize): raise ValueError('Non-square CMAPs are not supported') size = int(fsize) map = [0 for i in range(size2)] for phi, psi, energy in self._conn.execute("SELECT phi, psi, energy FROM %s" % name): i = int((phi % 360) / (360.0 / size)) j = int((psi % 360) / (360.0 / size)) map[i+size*j] = energy index = cmap.addMap(size, map*kilocalorie_per_mole) cmap_indices[name] = index q = """SELECT p0, p1, p2, p3, p4, p5, p6, p7, cmapid FROM torsiontorsion_cmap_term INNER JOIN torsiontorsion_cmap_param ON torsiontorsion_cmap_term.param=torsiontorsion_cmap_param.id""" for p0, p1, p2, p3, p4, p5, p6, p7, cmapid in self._conn.execute(q): cmap.addTorsion(cmap_indices[cmapid], p0, p1, p2, p3, p4, p5, p6, p7)
def add_interactions(self, state: interfaces.IState, openmm_system: mm.System, topology: app.Topology) -> mm.System: if not self._active: return openmm_system cmap_force = mm.CMAPTorsionForce() cmap_force.addMap(self._gly_map.shape[0], self._gly_map.flatten()) cmap_force.addMap(self._pro_map.shape[0], self._pro_map.flatten()) cmap_force.addMap(self._ala_map.shape[0], self._ala_map.flatten()) cmap_force.addMap(self._gen_map.shape[0], self._gen_map.flatten()) # loop over all of the contiguous chains of amino acids for chain in self._iterate_cmap_chains(): # loop over the interior residues n_res = len(chain) for i in range(1, n_res - 1): map_index = residue_to_map[chain[i].res_name] c_prev = chain[i - 1].index_C n = chain[i].index_N ca = chain[i].index_CA c = chain[i].index_C n_next = chain[i + 1].index_N cmap_force.addTorsion(map_index, c_prev, n, ca, c, n, ca, c, n_next) openmm_system.addForce(cmap_force) return openmm_system
def test_CMAP(self): f = mm.CMAPTorsionForce() energy = np.random.randn(10*10) f.addMap(10, energy) size, energy_out = f.getMapParameters(0) assert size == 10 np.testing.assert_array_almost_equal(energy, np.asarray(energy_out))
def test_CMAP(self): f = mm.CMAPTorsionForce() energy = np.random.randn(10 * 10) f.addMap(10, energy) size, energy_out = f.getMapParameters(0) energy_out = energy_out.value_in_unit_system(unit.md_unit_system) self.assertEqual(size, 10) np.testing.assert_array_almost_equal(energy, np.asarray(energy_out))
def _addCMAPToSystem(self, sys): """Create the CMAP terms """ go = [] for (fcounter, conn, tables, offset) in self._localVars(): if not self._hasTable('torsiontorsion_cmap_term', tables): go.append(False) else: go.append(True) if any(go): # Create CMAP torsion terms cmap = mm.CMAPTorsionForce() sys.addForce(cmap) else: return cmap_indices = {} for (fcounter, conn, tables, offset) in self._localVars(): if not go[fcounter]: continue for name in [ k for k in list(tables.keys()) if k.startswith('cmap') ]: size2 = conn.execute('SELECT COUNT(*) FROM %s' % name).fetchone()[0] fsize = math.sqrt(size2) if fsize != int(fsize): raise ValueError('Non-square CMAPs are not supported') size = int(fsize) map = [0 for i in range(size2)] for phi, psi, energy in conn.execute( "SELECT phi, psi, energy FROM %s" % name): i = int((phi % 360) / (360.0 / size)) j = int((psi % 360) / (360.0 / size)) map[i + size * j] = energy index = cmap.addMap(size, map * kilocalorie_per_mole) cmap_indices[name] = index q = """SELECT p0, p1, p2, p3, p4, p5, p6, p7, cmapid FROM torsiontorsion_cmap_term INNER JOIN torsiontorsion_cmap_param ON torsiontorsion_cmap_term.param=torsiontorsion_cmap_param.id""" for p0, p1, p2, p3, p4, p5, p6, p7, cmapid in conn.execute(q): p0 += offset p1 += offset p2 += offset p3 += offset p4 += offset p5 += offset p6 += offset p7 += offset cmap.addTorsion(cmap_indices[cmapid], p0, p1, p2, p3, p4, p5, p6, p7)
def createSystem(self, nonbondedMethod=ff.NoCutoff, nonbondedCutoff=1.0*unit.nanometer, constraints=None, rigidWater=True, implicitSolvent=None, soluteDielectric=1.0, solventDielectric=78.5, ewaldErrorTolerance=0.0005, removeCMMotion=True, hydrogenMass=None): """Construct an OpenMM System representing the topology described by this prmtop file. Parameters ---------- nonbondedMethod : object=NoCutoff The method to use for nonbonded interactions. Allowed values are NoCutoff, CutoffNonPeriodic, CutoffPeriodic, Ewald, PME, or LJPME. nonbondedCutoff : distance=1*nanometer The cutoff distance to use for nonbonded interactions constraints : object=None Specifies which bonds and angles should be implemented with constraints. Allowed values are None, HBonds, AllBonds, or HAngles. rigidWater : boolean=True If true, water molecules will be fully rigid regardless of the value passed for the constraints argument implicitSolvent : object=None If not None, the implicit solvent model to use. The only allowed value is OBC2. soluteDielectric : float=1.0 The solute dielectric constant to use in the implicit solvent model. solventDielectric : float=78.5 The solvent dielectric constant to use in the implicit solvent model. ewaldErrorTolerance : float=0.0005 The error tolerance to use if nonbondedMethod is Ewald, PME, or LJPME. removeCMMotion : boolean=True If true, a CMMotionRemover will be added to the System hydrogenMass : mass=None The mass to use for hydrogen atoms bound to heavy atoms. Any mass added to a hydrogen is subtracted from the heavy atom to keep their total mass the same. Returns ------- System the newly created System """ # Create the System. sys = mm.System() boxVectors = self.topology.getPeriodicBoxVectors() if boxVectors is not None: sys.setDefaultPeriodicBoxVectors(*boxVectors) elif nonbondedMethod in (ff.CutoffPeriodic, ff.Ewald, ff.PME, ff.LJPME): raise ValueError('Illegal nonbonded method for a non-periodic system') nb = mm.NonbondedForce() sys.addForce(nb) if implicitSolvent is OBC2: gb = mm.GBSAOBCForce() gb.setSoluteDielectric(soluteDielectric) gb.setSolventDielectric(solventDielectric) sys.addForce(gb) nb.setReactionFieldDielectric(1.0) elif implicitSolvent is not None: raise ValueError('Illegal value for implicitSolvent') bonds = None angles = None periodic = None rb = None harmonicTorsion = None cmap = None mapIndices = {} bondIndices = [] topologyAtoms = list(self.topology.atoms()) exceptions = [] fudgeQQ = float(self._defaults[4]) # Build a lookup table to let us process dihedrals more quickly. dihedralTypeTable = {} for key in self._dihedralTypes: if key[1] != 'X' and key[2] != 'X': if (key[1], key[2]) not in dihedralTypeTable: dihedralTypeTable[(key[1], key[2])] = [] dihedralTypeTable[(key[1], key[2])].append(key) if (key[2], key[1]) not in dihedralTypeTable: dihedralTypeTable[(key[2], key[1])] = [] dihedralTypeTable[(key[2], key[1])].append(key) wildcardDihedralTypes = [] for key in self._dihedralTypes: if key[1] == 'X' or key[2] == 'X': wildcardDihedralTypes.append(key) for types in dihedralTypeTable.values(): types.append(key) # Loop over molecules and create the specified number of each type. for moleculeName, moleculeCount in self._molecules: moleculeType = self._moleculeTypes[moleculeName] for i in range(moleculeCount): # Record the types of all atoms. baseAtomIndex = sys.getNumParticles() atomTypes = [atom[1] for atom in moleculeType.atoms] try: bondedTypes = [self._atomTypes[t][1] for t in atomTypes] except KeyError as e: raise ValueError('Unknown atom type: ' + e.message) bondedTypes = [b if b is not None else a for a, b in zip(atomTypes, bondedTypes)] # Add atoms. for fields in moleculeType.atoms: if len(fields) >= 8: mass = float(fields[7]) else: mass = float(self._atomTypes[fields[1]][3]) sys.addParticle(mass) # Add bonds. atomBonds = [{} for x in range(len(moleculeType.atoms))] for fields in moleculeType.bonds: atoms = [int(x)-1 for x in fields[:2]] types = tuple(bondedTypes[i] for i in atoms) if len(fields) >= 5: params = fields[3:5] elif types in self._bondTypes: params = self._bondTypes[types][3:5] elif types[::-1] in self._bondTypes: params = self._bondTypes[types[::-1]][3:5] else: raise ValueError('No parameters specified for bond: '+fields[0]+', '+fields[1]) # Decide whether to use a constraint or a bond. useConstraint = False if rigidWater and topologyAtoms[baseAtomIndex+atoms[0]].residue.name == 'HOH': useConstraint = True if constraints in (AllBonds, HAngles): useConstraint = True elif constraints is HBonds: elements = [topologyAtoms[baseAtomIndex+i].element for i in atoms] if elem.hydrogen in elements: useConstraint = True # Add the bond or constraint. length = float(params[0]) if useConstraint: sys.addConstraint(baseAtomIndex+atoms[0], baseAtomIndex+atoms[1], length) else: if bonds is None: bonds = mm.HarmonicBondForce() sys.addForce(bonds) bonds.addBond(baseAtomIndex+atoms[0], baseAtomIndex+atoms[1], length, float(params[1])) # Record information that will be needed for constraining angles. atomBonds[atoms[0]][atoms[1]] = length atomBonds[atoms[1]][atoms[0]] = length # Add angles. degToRad = math.pi/180 for fields in moleculeType.angles: atoms = [int(x)-1 for x in fields[:3]] types = tuple(bondedTypes[i] for i in atoms) if len(fields) >= 6: params = fields[4:] elif types in self._angleTypes: params = self._angleTypes[types][4:] elif types[::-1] in self._angleTypes: params = self._angleTypes[types[::-1]][4:] else: raise ValueError('No parameters specified for angle: '+fields[0]+', '+fields[1]+', '+fields[2]) # Decide whether to use a constraint or a bond. useConstraint = False if rigidWater and topologyAtoms[baseAtomIndex+atoms[0]].residue.name == 'HOH': useConstraint = True if constraints is HAngles: elements = [topologyAtoms[baseAtomIndex+i].element for i in atoms] if elements[0] == elem.hydrogen and elements[2] == elem.hydrogen: useConstraint = True elif elements[1] == elem.oxygen and (elements[0] == elem.hydrogen or elements[2] == elem.hydrogen): useConstraint = True # Add the bond or constraint. theta = float(params[0])*degToRad if useConstraint: # Compute the distance between atoms and add a constraint if atoms[0] in atomBonds[atoms[1]] and atoms[2] in atomBonds[atoms[1]]: l1 = atomBonds[atoms[1]][atoms[0]] l2 = atomBonds[atoms[1]][atoms[2]] length = math.sqrt(l1*l1 + l2*l2 - 2*l1*l2*math.cos(theta)) sys.addConstraint(baseAtomIndex+atoms[0], baseAtomIndex+atoms[2], length) else: if angles is None: angles = mm.HarmonicAngleForce() sys.addForce(angles) angles.addAngle(baseAtomIndex+atoms[0], baseAtomIndex+atoms[1], baseAtomIndex+atoms[2], theta, float(params[1])) if fields[3] == '5': # This is a Urey-Bradley term, so add the bond. if bonds is None: bonds = mm.HarmonicBondForce() sys.addForce(bonds) k = float(params[3]) if k != 0: bonds.addBond(baseAtomIndex+atoms[0], baseAtomIndex+atoms[2], float(params[2]), k) # Add torsions. for fields in moleculeType.dihedrals: atoms = [int(x)-1 for x in fields[:4]] types = tuple(bondedTypes[i] for i in atoms) dihedralType = fields[4] reversedTypes = types[::-1]+(dihedralType,) types = types+(dihedralType,) if (dihedralType in ('1', '2', '4', '9') and len(fields) > 7) or (dihedralType == '3' and len(fields) > 10): paramsList = [fields] else: # Look for a matching dihedral type. paramsList = None if (types[1], types[2]) in dihedralTypeTable: dihedralTypes = dihedralTypeTable[(types[1], types[2])] else: dihedralTypes = wildcardDihedralTypes for key in dihedralTypes: if all(a == b or a == 'X' for a, b in zip(key, types)) or all(a == b or a == 'X' for a, b in zip(key, reversedTypes)): paramsList = self._dihedralTypes[key] if 'X' not in key: break if paramsList is None: raise ValueError('No parameters specified for dihedral: '+fields[0]+', '+fields[1]+', '+fields[2]+', '+fields[3]) for params in paramsList: if dihedralType in ('1', '4', '9'): # Periodic torsion k = float(params[6]) if k != 0: if periodic is None: periodic = mm.PeriodicTorsionForce() sys.addForce(periodic) periodic.addTorsion(baseAtomIndex+atoms[0], baseAtomIndex+atoms[1], baseAtomIndex+atoms[2], baseAtomIndex+atoms[3], int(float(params[7])), float(params[5])*degToRad, k) elif dihedralType == '2': # Harmonic torsion k = float(params[6]) if k != 0: if harmonicTorsion is None: harmonicTorsion = mm.CustomTorsionForce('0.5*k*(theta-theta0)^2') harmonicTorsion.addPerTorsionParameter('theta0') harmonicTorsion.addPerTorsionParameter('k') sys.addForce(harmonicTorsion) harmonicTorsion.addTorsion(baseAtomIndex+atoms[0], baseAtomIndex+atoms[1], baseAtomIndex+atoms[2], baseAtomIndex+atoms[3], (float(params[5])*degToRad, k)) else: # RB Torsion c = [float(x) for x in params[5:11]] if any(x != 0 for x in c): if rb is None: rb = mm.RBTorsionForce() sys.addForce(rb) rb.addTorsion(baseAtomIndex+atoms[0], baseAtomIndex+atoms[1], baseAtomIndex+atoms[2], baseAtomIndex+atoms[3], c[0], c[1], c[2], c[3], c[4], c[5]) # Add CMAP terms. for fields in moleculeType.cmaps: atoms = [int(x)-1 for x in fields[:5]] types = tuple(bondedTypes[i] for i in atoms) if len(fields) >= 8 and len(fields) >= 8+int(fields[6])*int(fields[7]): params = fields elif types in self._cmapTypes: params = self._cmapTypes[types] elif types[::-1] in self._cmapTypes: params = self._cmapTypes[types[::-1]] else: raise ValueError('No parameters specified for cmap: '+fields[0]+', '+fields[1]+', '+fields[2]+', '+fields[3]+', '+fields[4]) if cmap is None: cmap = mm.CMAPTorsionForce() sys.addForce(cmap) mapSize = int(params[6]) if mapSize != int(params[7]): raise ValueError('Non-square CMAPs are not supported') map = [] for i in range(mapSize): for j in range(mapSize): map.append(float(params[8+mapSize*((j+mapSize//2)%mapSize)+((i+mapSize//2)%mapSize)])) map = tuple(map) if map not in mapIndices: mapIndices[map] = cmap.addMap(mapSize, map) cmap.addTorsion(mapIndices[map], baseAtomIndex+atoms[0], baseAtomIndex+atoms[1], baseAtomIndex+atoms[2], baseAtomIndex+atoms[3], baseAtomIndex+atoms[1], baseAtomIndex+atoms[2], baseAtomIndex+atoms[3], baseAtomIndex+atoms[4]) # Set nonbonded parameters for particles. for fields in moleculeType.atoms: params = self._atomTypes[fields[1]] if len(fields) > 6: q = float(fields[6]) else: q = float(params[4]) nb.addParticle(q, float(params[6]), float(params[7])) if implicitSolvent is OBC2: if fields[1] not in self._implicitTypes: raise ValueError('No implicit solvent parameters specified for atom type: '+fields[1]) gbparams = self._implicitTypes[fields[1]] gb.addParticle(q, float(gbparams[4]), float(gbparams[5])) for fields in moleculeType.bonds: atoms = [int(x)-1 for x in fields[:2]] bondIndices.append((baseAtomIndex+atoms[0], baseAtomIndex+atoms[1])) # Record nonbonded exceptions. for fields in moleculeType.pairs: atoms = [int(x)-1 for x in fields[:2]] types = tuple(atomTypes[i] for i in atoms) if len(fields) >= 5: params = fields[3:5] elif types in self._pairTypes: params = self._pairTypes[types][3:5] elif types[::-1] in self._pairTypes: params = self._pairTypes[types[::-1]][3:5] elif not self._genpairs: raise ValueError('No pair parameters defined for atom ' 'types %s and gen-pairs is "no"' % types) else: continue # We'll use the automatically generated parameters atom1params = nb.getParticleParameters(baseAtomIndex+atoms[0]) atom2params = nb.getParticleParameters(baseAtomIndex+atoms[1]) exceptions.append((baseAtomIndex+atoms[0], baseAtomIndex+atoms[1], atom1params[0]*atom2params[0]*fudgeQQ, params[0], params[1])) for fields in moleculeType.exclusions: atoms = [int(x)-1 for x in fields] for atom in atoms[1:]: if atom > atoms[0]: exceptions.append((baseAtomIndex+atoms[0], baseAtomIndex+atom, 0, 0, 0)) # Create nonbonded exceptions. nb.createExceptionsFromBonds(bondIndices, fudgeQQ, float(self._defaults[3])) for exception in exceptions: nb.addException(exception[0], exception[1], exception[2], float(exception[3]), float(exception[4]), True) # Finish configuring the NonbondedForce. methodMap = {ff.NoCutoff:mm.NonbondedForce.NoCutoff, ff.CutoffNonPeriodic:mm.NonbondedForce.CutoffNonPeriodic, ff.CutoffPeriodic:mm.NonbondedForce.CutoffPeriodic, ff.Ewald:mm.NonbondedForce.Ewald, ff.PME:mm.NonbondedForce.PME, ff.LJPME:mm.NonbondedForce.LJPME} nb.setNonbondedMethod(methodMap[nonbondedMethod]) nb.setCutoffDistance(nonbondedCutoff) nb.setEwaldErrorTolerance(ewaldErrorTolerance) # Adjust masses. if hydrogenMass is not None: for atom1, atom2 in self.topology.bonds(): if atom1.element == elem.hydrogen: (atom1, atom2) = (atom2, atom1) if atom2.element == elem.hydrogen and atom1.element not in (elem.hydrogen, None): transferMass = hydrogenMass-sys.getParticleMass(atom2.index) sys.setParticleMass(atom2.index, hydrogenMass) sys.setParticleMass(atom1.index, sys.getParticleMass(atom1.index)-transferMass) # Add a CMMotionRemover. if removeCMMotion: sys.addForce(mm.CMMotionRemover()) return sys