Skip to content

GitLab

Commit c6e315a6 authored by Peter Eastman's avatar Peter Eastman
Browse files

Cleanup of code formatting

parent 1d2c0a03
Show whitespace changes
Inline Side-by-side
Showing with 875 additions and 908 deletions
wrappers/python/simtk/openmm/app/forcefield.py
View file @ c6e315a6
...@@ -925,7 +925,6 @@ class GBVIGenerator: ...@@ -925,7 +925,6 @@ class GBVIGenerator:
self.ff = ff self.ff = ff
self.fixedParameters = {} self.fixedParameters = {}
self.fixedParameters['soluteDielectric'] = 1.0 self.fixedParameters['soluteDielectric'] = 1.0
self.fixedParameters['solventDielectric'] = 78.3 self.fixedParameters['solventDielectric'] = 78.3
self.fixedParameters['scalingMethod'] = 1 self.fixedParameters['scalingMethod'] = 1
...@@ -938,8 +937,8 @@ class GBVIGenerator: ...@@ -938,8 +937,8 @@ class GBVIGenerator:
def parseElement(element, ff): def parseElement(element, ff):
generator = GBVIGenerator(ff) generator = GBVIGenerator(ff)
for key in generator.fixedParameters.iterkeys(): for key in generator.fixedParameters.iterkeys():
if( key in element.attrib ): if (key in element.attrib):
generator.fixedParameters[key] = float( element.attrib[key] ) generator.fixedParameters[key] = float(element.attrib[key])
ff._forces.append(generator) ff._forces.append(generator)
for atom in element.findall('Atom'): for atom in element.findall('Atom'):
...@@ -973,11 +972,11 @@ class GBVIGenerator: ...@@ -973,11 +972,11 @@ class GBVIGenerator:
hbGenerator = 0 hbGenerator = 0
for generator in self.ff._forces: for generator in self.ff._forces:
if( generator.__class__.__name__ == 'HarmonicBondGenerator' ): if (generator.__class__.__name__ == 'HarmonicBondGenerator'):
hbGenerator = generator hbGenerator = generator
break break
if( hbGenerator == 0 ): if (hbGenerator == 0):
raise ValueError('HarmonicBondGenerator not found.') raise ValueError('HarmonicBondGenerator not found.')
# add bonds # add bonds
...@@ -995,11 +994,11 @@ class GBVIGenerator: ...@@ -995,11 +994,11 @@ class GBVIGenerator:
force.setNonbondedMethod(methodMap[nonbondedMethod]) force.setNonbondedMethod(methodMap[nonbondedMethod])
force.setCutoffDistance(nonbondedCutoff) force.setCutoffDistance(nonbondedCutoff)
force.setSolventDielectric( self.fixedParameters['solventDielectric'] ) force.setSolventDielectric(self.fixedParameters['solventDielectric'])
force.setSoluteDielectric( self.fixedParameters['soluteDielectric'] ) force.setSoluteDielectric(self.fixedParameters['soluteDielectric'])
force.setBornRadiusScalingMethod( self.fixedParameters['scalingMethod'] ) force.setBornRadiusScalingMethod(self.fixedParameters['scalingMethod'])
force.setQuinticLowerLimitFactor( self.fixedParameters['quinticLowerLimitFactor'] ) force.setQuinticLowerLimitFactor(self.fixedParameters['quinticLowerLimitFactor'])
force.setQuinticUpperBornRadiusLimit( self.fixedParameters['quinticUpperBornRadiusLimit'] ) force.setQuinticUpperBornRadiusLimit(self.fixedParameters['quinticUpperBornRadiusLimit'])
sys.addForce(force) sys.addForce(force)
...@@ -1267,11 +1266,11 @@ class CustomGBGenerator: ...@@ -1267,11 +1266,11 @@ class CustomGBGenerator:
parsers["CustomGBForce"] = CustomGBGenerator.parseElement parsers["CustomGBForce"] = CustomGBGenerator.parseElement
def getAtomPrint( data, atomIndex ): def getAtomPrint(data, atomIndex):
if( atomIndex < len( data.atoms ) ): if (atomIndex < len(data.atoms)):
atom = data.atoms[atomIndex] atom = data.atoms[atomIndex]
returnString = "%4s %4s %5d" % (atom.name, atom.residue.name, atom.residue.index ) returnString = "%4s %4s %5d" % (atom.name, atom.residue.name, atom.residue.index)
else: else:
returnString = "NA" returnString = "NA"
...@@ -1279,7 +1278,7 @@ def getAtomPrint( data, atomIndex ): ...@@ -1279,7 +1278,7 @@ def getAtomPrint( data, atomIndex ):
#============================================================================================= #=============================================================================================
def countConstraint( data ): def countConstraint(data):
bondCount = 0 bondCount = 0
angleCount = 0 angleCount = 0
...@@ -1289,10 +1288,10 @@ def countConstraint( data ): ...@@ -1289,10 +1288,10 @@ def countConstraint( data ):
angleCount = 0 angleCount = 0
for (angle, isConstrained) in zip(data.angles, data.isAngleConstrained): for (angle, isConstrained) in zip(data.angles, data.isAngleConstrained):
if( isConstrained ): if (isConstrained):
angleCount += 1 angleCount += 1
print "Constraints bond=%d angle=%d total=%d" % (bondCount, angleCount, (bondCount+angleCount) ) print "Constraints bond=%d angle=%d total=%d" % (bondCount, angleCount, (bondCount+angleCount))
class AmoebaHarmonicBondGenerator: class AmoebaHarmonicBondGenerator:
...@@ -1320,7 +1319,7 @@ class AmoebaHarmonicBondGenerator: ...@@ -1320,7 +1319,7 @@ class AmoebaHarmonicBondGenerator:
# <AmoebaHarmonicBondForce bond-cubic="-25.5" bond-quartic="379.3125"> # <AmoebaHarmonicBondForce bond-cubic="-25.5" bond-quartic="379.3125">
# <Bond class1="1" class2="2" length="0.1437" k="156900.0"/> # <Bond class1="1" class2="2" length="0.1437" k="156900.0"/>
generator = AmoebaHarmonicBondGenerator( float(element.attrib['bond-cubic']), float(element.attrib['bond-quartic']) ) generator = AmoebaHarmonicBondGenerator(float(element.attrib['bond-cubic']), float(element.attrib['bond-quartic']))
forceField._forces.append(generator) forceField._forces.append(generator)
for bond in element.findall('Bond'): for bond in element.findall('Bond'):
types = forceField._findAtomTypes(bond, 2) types = forceField._findAtomTypes(bond, 2)
...@@ -1332,19 +1331,19 @@ class AmoebaHarmonicBondGenerator: ...@@ -1332,19 +1331,19 @@ class AmoebaHarmonicBondGenerator:
else: else:
outputString = "AmoebaHarmonicBondGenerator: error getting types: %s %s" % ( outputString = "AmoebaHarmonicBondGenerator: error getting types: %s %s" % (
bond.attrib['class1'], bond.attrib['class1'],
bond.attrib['class2'] ) bond.attrib['class2'])
raise ValueError( outputString ) raise ValueError(outputString)
#============================================================================================= #=============================================================================================
def createForce(self, sys, data, nonbondedMethod, nonbondedCutoff, args ): def createForce(self, sys, data, nonbondedMethod, nonbondedCutoff, args):
verbose = 0 verbose = 0
if( self.hasBeenCalled ): if (self.hasBeenCalled):
return return
if( verbose ): if (verbose):
countConstraint( data ) countConstraint(data)
self.hasBeenCalled = 1 self.hasBeenCalled = 1
...@@ -1356,10 +1355,10 @@ class AmoebaHarmonicBondGenerator: ...@@ -1356,10 +1355,10 @@ class AmoebaHarmonicBondGenerator:
else: else:
force = existing[0] force = existing[0]
force.setAmoebaGlobalHarmonicBondCubic( self.cubic ) force.setAmoebaGlobalHarmonicBondCubic(self.cubic)
force.setAmoebaGlobalHarmonicBondQuartic( self.quartic ) force.setAmoebaGlobalHarmonicBondQuartic(self.quartic)
if( verbose ): if (verbose):
print "In AmoebaHarmonicBondGenerator bonds=%d " % (len(data.bonds)) print "In AmoebaHarmonicBondGenerator bonds=%d " % (len(data.bonds))
count = 0 count = 0
...@@ -1375,18 +1374,18 @@ class AmoebaHarmonicBondGenerator: ...@@ -1375,18 +1374,18 @@ class AmoebaHarmonicBondGenerator:
hit = 1 hit = 1
if bond.isConstrained: if bond.isConstrained:
sys.addConstraint(bond.atom1, bond.atom2, self.length[i]) sys.addConstraint(bond.atom1, bond.atom2, self.length[i])
if( verbose ): if (verbose):
atomS1 = getAtomPrint( data, bond.atom1 ) atomS1 = getAtomPrint(data, bond.atom1)
atomS2 = getAtomPrint( data, bond.atom2 ) atomS2 = getAtomPrint(data, bond.atom2)
print "AmoebaHarmonicBondGenerator %5d %5d %5d [%s %s] [%5s %5s] %15.6f %15.6f Constraint" % (count, bond.atom1, bond.atom2, atomS1, atomS2, type1, type2, self.length[i], self.k[i]) print "AmoebaHarmonicBondGenerator %5d %5d %5d [%s %s] [%5s %5s] %15.6f %15.6f Constraint" % (count, bond.atom1, bond.atom2, atomS1, atomS2, type1, type2, self.length[i], self.k[i])
elif self.k[i] != 0: elif self.k[i] != 0:
if( verbose ): if (verbose):
atomS1 = getAtomPrint( data, bond.atom1 ) atomS1 = getAtomPrint(data, bond.atom1)
atomS2 = getAtomPrint( data, bond.atom2 ) atomS2 = getAtomPrint(data, bond.atom2)
print "AmoebaHarmonicBondGenerator %5d %5d %5d [%s %s] [%5s %5s] %15.6f %15.6f" % (count, bond.atom1, bond.atom2, atomS1, atomS2, type1, type2, self.length[i], self.k[i]) print "AmoebaHarmonicBondGenerator %5d %5d %5d [%s %s] [%5s %5s] %15.6f %15.6f" % (count, bond.atom1, bond.atom2, atomS1, atomS2, type1, type2, self.length[i], self.k[i])
force.addBond(bond.atom1, bond.atom2, self.length[i], self.k[i]) force.addBond(bond.atom1, bond.atom2, self.length[i], self.k[i])
break break
if( hit == 0 ): if (hit == 0):
print "AmoebaHarmonicBondGenerator missing: %5d types=[%5s %5s] atoms=[%6d %6d] " % (count, type1, type2, bond.atom1, bond.atom2) print "AmoebaHarmonicBondGenerator missing: %5d types=[%5s %5s] atoms=[%6d %6d] " % (count, type1, type2, bond.atom1, bond.atom2)
count += 1 count += 1
...@@ -1397,7 +1396,7 @@ parsers["AmoebaHarmonicBondForce"] = AmoebaHarmonicBondGenerator.parseElement ...@@ -1397,7 +1396,7 @@ parsers["AmoebaHarmonicBondForce"] = AmoebaHarmonicBondGenerator.parseElement
# Add angle constraint # Add angle constraint
#============================================================================================= #=============================================================================================
def addAngleConstraint( angle, idealAngle, data, sys ): def addAngleConstraint(angle, idealAngle, data, sys):
# Find the two bonds that make this angle. # Find the two bonds that make this angle.
...@@ -1454,7 +1453,7 @@ class AmoebaHarmonicAngleGenerator: ...@@ -1454,7 +1453,7 @@ class AmoebaHarmonicAngleGenerator:
# <AmoebaHarmonicAngleForce angle-cubic="-0.014" angle-quartic="5.6e-05" angle-pentic="-7e-07" angle-sextic="2.2e-08"> # <AmoebaHarmonicAngleForce angle-cubic="-0.014" angle-quartic="5.6e-05" angle-pentic="-7e-07" angle-sextic="2.2e-08">
# <Angle class1="2" class2="1" class3="3" k="0.0637259642196" angle1="122.00" /> # <Angle class1="2" class2="1" class3="3" k="0.0637259642196" angle1="122.00" />
generator = AmoebaHarmonicAngleGenerator( forceField, float(element.attrib['angle-cubic']), float(element.attrib['angle-quartic']), float(element.attrib['angle-pentic']), float(element.attrib['angle-sextic'] ) ) generator = AmoebaHarmonicAngleGenerator(forceField, float(element.attrib['angle-cubic']), float(element.attrib['angle-quartic']), float(element.attrib['angle-pentic']), float(element.attrib['angle-sextic']))
forceField._forces.append(generator) forceField._forces.append(generator)
for angle in element.findall('Angle'): for angle in element.findall('Angle'):
types = forceField._findAtomTypes(angle, 3) types = forceField._findAtomTypes(angle, 3)
...@@ -1465,12 +1464,12 @@ class AmoebaHarmonicAngleGenerator: ...@@ -1465,12 +1464,12 @@ class AmoebaHarmonicAngleGenerator:
generator.types3.append(types[2]) generator.types3.append(types[2])
angleList = [] angleList = []
angleList.append( float(angle.attrib['angle1']) ) angleList.append(float(angle.attrib['angle1']))
try: try:
angleList.append( float(angle.attrib['angle2']) ) angleList.append(float(angle.attrib['angle2']))
try: try:
angleList.append( float(angle.attrib['angle3']) ) angleList.append(float(angle.attrib['angle3']))
except: except:
pass pass
except: except:
...@@ -1481,15 +1480,15 @@ class AmoebaHarmonicAngleGenerator: ...@@ -1481,15 +1480,15 @@ class AmoebaHarmonicAngleGenerator:
outputString = "AmoebaHarmonicAngleGenerator: error getting types: %s %s %s" % ( outputString = "AmoebaHarmonicAngleGenerator: error getting types: %s %s %s" % (
angle.attrib['class1'], angle.attrib['class1'],
angle.attrib['class2'], angle.attrib['class2'],
angle.attrib['class3'] ) angle.attrib['class3'])
raise ValueError( outputString ) raise ValueError(outputString)
#============================================================================================= #=============================================================================================
# createForce is bypassed here since the AmoebaOutOfPlaneBendForce generator must first execute # createForce is bypassed here since the AmoebaOutOfPlaneBendForce generator must first execute
# and partition angles into in-plane and non-in-plane angles # and partition angles into in-plane and non-in-plane angles
#============================================================================================= #=============================================================================================
def createForce(self, sys, data, nonbondedMethod, nonbondedCutoff, args ): def createForce(self, sys, data, nonbondedMethod, nonbondedCutoff, args):
pass pass
#============================================================================================= #=============================================================================================
...@@ -1497,10 +1496,10 @@ class AmoebaHarmonicAngleGenerator: ...@@ -1497,10 +1496,10 @@ class AmoebaHarmonicAngleGenerator:
# non-in-plane angles # non-in-plane angles
#============================================================================================= #=============================================================================================
def createForcePostOpBendAngle( self, sys, data, nonbondedMethod, nonbondedCutoff, angleList, args ): def createForcePostOpBendAngle(self, sys, data, nonbondedMethod, nonbondedCutoff, angleList, args):
verbose = 0 verbose = 0
if( self.hasBeenCalled ): if (self.hasBeenCalled):
return return
self.hasBeenCalled += 1 self.hasBeenCalled += 1
...@@ -1517,12 +1516,12 @@ class AmoebaHarmonicAngleGenerator: ...@@ -1517,12 +1516,12 @@ class AmoebaHarmonicAngleGenerator:
# scalars # scalars
force.setAmoebaGlobalHarmonicAngleCubic( self.cubic ) force.setAmoebaGlobalHarmonicAngleCubic(self.cubic)
force.setAmoebaGlobalHarmonicAngleQuartic( self.quartic ) force.setAmoebaGlobalHarmonicAngleQuartic(self.quartic)
force.setAmoebaGlobalHarmonicAnglePentic( self.pentic ) force.setAmoebaGlobalHarmonicAnglePentic(self.pentic)
force.setAmoebaGlobalHarmonicAngleSextic( self.sextic ) force.setAmoebaGlobalHarmonicAngleSextic(self.sextic)
if( verbose ): if (verbose):
print "In AmoebaHarmonicAngleGenerator angles=%d " % (len(data.angles)) print "In AmoebaHarmonicAngleGenerator angles=%d " % (len(data.angles))
count = 0 count = 0
...@@ -1541,25 +1540,22 @@ class AmoebaHarmonicAngleGenerator: ...@@ -1541,25 +1540,22 @@ class AmoebaHarmonicAngleGenerator:
if (type1 in types1 and type2 in types2 and type3 in types3) or (type1 in types3 and type2 in types2 and type3 in types1): if (type1 in types1 and type2 in types2 and type3 in types3) or (type1 in types3 and type2 in types2 and type3 in types1):
hit = 1 hit = 1
if isConstrained and self.k[i] != 0.0: if isConstrained and self.k[i] != 0.0:
angleDict['idealAngle'] = self.angle[i][0] angleDict['idealAngle'] = self.angle[i][0]
addAngleConstraint( angle, self.angle[i][0], data, sys ) addAngleConstraint(angle, self.angle[i][0], data, sys)
elif self.k[i] != 0: elif self.k[i] != 0:
# print "AmoebaHarmonicAngleGenerator %5d %5d %5d %5d [%5s %5s %5s] %15.6f %15.6f" % (count, angle[0], angle[1], angle[2], type1, type2, type3, self.angle[i], self.k[i]) lenAngle = len(self.angle[i])
lenAngle = len( self.angle[i] ) if (lenAngle > 1):
if( lenAngle > 1 ):
# get k-index by counting number of non-angle hydrogens on the central atom # get k-index by counting number of non-angle hydrogens on the central atom
# based on kangle.f # based on kangle.f
numberOfHydrogens = 0 numberOfHydrogens = 0
for bond in data.atomBonds[angle[1]]: for bond in data.atomBonds[angle[1]]:
atom1 = data.bonds[bond].atom1 atom1 = data.bonds[bond].atom1
atom2 = data.bonds[bond].atom2 atom2 = data.bonds[bond].atom2
if( atom1 == angle[1] and atom2 != angle[0] and atom2 != angle[2] and (sys.getParticleMass( atom2 )/unit.dalton) < 1.90 ): if (atom1 == angle[1] and atom2 != angle[0] and atom2 != angle[2] and (sys.getParticleMass(atom2)/unit.dalton) < 1.90):
numberOfHydrogens += 1 numberOfHydrogens += 1
if( atom2 == angle[1] and atom1 != angle[0] and atom1 != angle[2] and (sys.getParticleMass( atom1 )/unit.dalton) < 1.90 ): if (atom2 == angle[1] and atom1 != angle[0] and atom1 != angle[2] and (sys.getParticleMass(atom1)/unit.dalton) < 1.90):
numberOfHydrogens += 1 numberOfHydrogens += 1
if( numberOfHydrogens < lenAngle ): if (numberOfHydrogens < lenAngle):
angleValue = self.angle[i][numberOfHydrogens] angleValue = self.angle[i][numberOfHydrogens]
else: else:
print "Error: AmoebaHarmonicAngleGenerator angle index=%d is out of range: [0, %5d] " % (numberOfHydrogens, lenAngle) print "Error: AmoebaHarmonicAngleGenerator angle index=%d is out of range: [0, %5d] " % (numberOfHydrogens, lenAngle)
...@@ -1568,9 +1564,9 @@ class AmoebaHarmonicAngleGenerator: ...@@ -1568,9 +1564,9 @@ class AmoebaHarmonicAngleGenerator:
angleValue = self.angle[i][0] angleValue = self.angle[i][0]
angleDict['idealAngle'] = angleValue angleDict['idealAngle'] = angleValue
force.addAngle(angle[0], angle[1], angle[2], angleValue, self.k[i] ) force.addAngle(angle[0], angle[1], angle[2], angleValue, self.k[i])
break break
if( hit == 0 ): if (hit == 0):
print "AmoebaHarmonicAngleGenerator missing: %5d %s %s %s " % (count, type1, type2, type3) print "AmoebaHarmonicAngleGenerator missing: %5d %s %s %s " % (count, type1, type2, type3)
count += 1 count += 1
...@@ -1580,7 +1576,7 @@ class AmoebaHarmonicAngleGenerator: ...@@ -1580,7 +1576,7 @@ class AmoebaHarmonicAngleGenerator:
# in-plane angles # in-plane angles
#============================================================================================= #=============================================================================================
def createForcePostOpBendInPlaneAngle( self, sys, data, nonbondedMethod, nonbondedCutoff, angleList, args ): def createForcePostOpBendInPlaneAngle(self, sys, data, nonbondedMethod, nonbondedCutoff, angleList, args):
verbose = 0 verbose = 0
self.hasBeenCalled += 1 self.hasBeenCalled += 1
...@@ -1598,12 +1594,12 @@ class AmoebaHarmonicAngleGenerator: ...@@ -1598,12 +1594,12 @@ class AmoebaHarmonicAngleGenerator:
# scalars # scalars
force.setAmoebaGlobalHarmonicInPlaneAngleCubic( self.cubic ) force.setAmoebaGlobalHarmonicInPlaneAngleCubic(self.cubic)
force.setAmoebaGlobalHarmonicInPlaneAngleQuartic( self.quartic ) force.setAmoebaGlobalHarmonicInPlaneAngleQuartic(self.quartic)
force.setAmoebaGlobalHarmonicInPlaneAnglePentic( self.pentic ) force.setAmoebaGlobalHarmonicInPlaneAnglePentic(self.pentic)
force.setAmoebaGlobalHarmonicInPlaneAngleSextic( self.sextic ) force.setAmoebaGlobalHarmonicInPlaneAngleSextic(self.sextic)
if( verbose ): if (verbose):
print "In AmoebaHarmonicAngleGenerator angles=%d " % (len(data.angles)) print "In AmoebaHarmonicAngleGenerator angles=%d " % (len(data.angles))
count = 0 count = 0
...@@ -1624,17 +1620,17 @@ class AmoebaHarmonicAngleGenerator: ...@@ -1624,17 +1620,17 @@ class AmoebaHarmonicAngleGenerator:
types3 = self.types3[i] types3 = self.types3[i]
if (type1 in types1 and type2 in types2 and type3 in types3) or (type1 in types3 and type2 in types2 and type3 in types1): if (type1 in types1 and type2 in types2 and type3 in types3) or (type1 in types3 and type2 in types2 and type3 in types1):
if( verbose ): if (verbose):
print "AmoebaHarmonicInPlaneAngleGenerator %5d %5d %5d %5d len=%d [%5s %5s %5s] %15.6f %15.6f" % (count, angle[0], angle[1], angle[2], len(angle), type1, type2, type3, self.angle[i][0], self.k[i]) print "AmoebaHarmonicInPlaneAngleGenerator %5d %5d %5d %5d len=%d [%5s %5s %5s] %15.6f %15.6f" % (count, angle[0], angle[1], angle[2], len(angle), type1, type2, type3, self.angle[i][0], self.k[i])
hit = 1 hit = 1
angleDict['idealAngle'] = self.angle[i][0] angleDict['idealAngle'] = self.angle[i][0]
if( isConstrained and self.k[i] != 0.0 ): if (isConstrained and self.k[i] != 0.0):
addAngleConstraint( angle, self.angle[i][0], data, sys ) addAngleConstraint(angle, self.angle[i][0], data, sys)
else: else:
force.addAngle(angle[0], angle[1], angle[2], angle[3], self.angle[i][0], self.k[i]) force.addAngle(angle[0], angle[1], angle[2], angle[3], self.angle[i][0], self.k[i])
break break
if( hit == 0 ): if (hit == 0):
print "AmoebaHarmonicInPlaneAngleGenerator missing: %5d %s %s " % (count, type1, type2, type3) print "AmoebaHarmonicInPlaneAngleGenerator missing: %5d %s %s " % (count, type1, type2, type3)
count += 1 count += 1
...@@ -1705,32 +1701,32 @@ class AmoebaOutOfPlaneBendGenerator: ...@@ -1705,32 +1701,32 @@ class AmoebaOutOfPlaneBendGenerator:
# get global scalar parameters # get global scalar parameters
generator = AmoebaOutOfPlaneBendGenerator( forceField, element.attrib['type'], generator = AmoebaOutOfPlaneBendGenerator(forceField, element.attrib['type'],
float(element.attrib['opbend-cubic']), float(element.attrib['opbend-cubic']),
float(element.attrib['opbend-quartic']), float(element.attrib['opbend-quartic']),
float(element.attrib['opbend-pentic']), float(element.attrib['opbend-pentic']),
float(element.attrib['opbend-sextic'] ) ) float(element.attrib['opbend-sextic']))
forceField._forces.append(generator) forceField._forces.append(generator)
for angle in element.findall('Angle'): for angle in element.findall('Angle'):
types = generator.findAtomTypes( forceField, angle, 4) types = generator.findAtomTypes(forceField, angle, 4)
if types is not None: if types is not None:
generator.types1.append( types[0] ) generator.types1.append(types[0])
generator.types2.append( types[1] ) generator.types2.append(types[1])
generator.types3.append( types[2] ) generator.types3.append(types[2])
generator.types4.append( types[3] ) generator.types4.append(types[3])
generator.ks.append( float(angle.attrib['k'] ) ) generator.ks.append(float(angle.attrib['k']))
else: else:
outputString = "AmoebaOutOfPlaneBendGenerator: error getting types: %s %s %s %s." % ( outputString = "AmoebaOutOfPlaneBendGenerator: error getting types: %s %s %s %s." % (
angle.attrib['class1'], angle.attrib['class1'],
angle.attrib['class2'], angle.attrib['class2'],
angle.attrib['class3'], angle.attrib['class3'],
angle.attrib['class4'] ) angle.attrib['class4'])
raise ValueError( outputString ) raise ValueError(outputString)
#============================================================================================= #=============================================================================================
# Get middle atom in a angle # Get middle atom in a angle
...@@ -1739,7 +1735,7 @@ class AmoebaOutOfPlaneBendGenerator: ...@@ -1739,7 +1735,7 @@ class AmoebaOutOfPlaneBendGenerator:
# be the middle atom. However, was unsure if this is guaranteed # be the middle atom. However, was unsure if this is guaranteed
#============================================================================================= #=============================================================================================
def getMiddleAtom( self, angle, data ): def getMiddleAtom(self, angle, data):
# find atom shared by both bonds making up the angle # find atom shared by both bonds making up the angle
...@@ -1749,23 +1745,23 @@ class AmoebaOutOfPlaneBendGenerator: ...@@ -1749,23 +1745,23 @@ class AmoebaOutOfPlaneBendGenerator:
for bond in data.atomBonds[atomIndex]: for bond in data.atomBonds[atomIndex]:
atom1 = data.bonds[bond].atom1 atom1 = data.bonds[bond].atom1
atom2 = data.bonds[bond].atom2 atom2 = data.bonds[bond].atom2
if( atom1 != atomIndex ): if (atom1 != atomIndex):
partner = atom1 partner = atom1
else: else:
partner = atom2 partner = atom2
if( partner == angle[0] or partner == angle[1] or partner == angle[2] ): if (partner == angle[0] or partner == angle[1] or partner == angle[2]):
isMiddle += 1 isMiddle += 1
if( isMiddle == 2 ): if (isMiddle == 2):
return atomIndex return atomIndex
return -1 return -1
#============================================================================================= #=============================================================================================
def createForce(self, sys, data, nonbondedMethod, nonbondedCutoff, args ): def createForce(self, sys, data, nonbondedMethod, nonbondedCutoff, args):
verbose = 0 verbose = 0
if( self.hasBeenCalled ): if (self.hasBeenCalled):
return return
self.hasBeenCalled = 1 self.hasBeenCalled = 1
...@@ -1781,10 +1777,10 @@ class AmoebaOutOfPlaneBendGenerator: ...@@ -1781,10 +1777,10 @@ class AmoebaOutOfPlaneBendGenerator:
# set scalars # set scalars
force.setAmoebaGlobalOutOfPlaneBendCubic( self.cubic ) force.setAmoebaGlobalOutOfPlaneBendCubic( self.cubic)
force.setAmoebaGlobalOutOfPlaneBendQuartic( self.quartic ) force.setAmoebaGlobalOutOfPlaneBendQuartic(self.quartic)
force.setAmoebaGlobalOutOfPlaneBendPentic( self.pentic ) force.setAmoebaGlobalOutOfPlaneBendPentic( self.pentic)
force.setAmoebaGlobalOutOfPlaneBendSextic( self.sextic ) force.setAmoebaGlobalOutOfPlaneBendSextic( self.sextic)
count = 0 count = 0
opBondCount = 0 opBondCount = 0
...@@ -1804,8 +1800,8 @@ class AmoebaOutOfPlaneBendGenerator: ...@@ -1804,8 +1800,8 @@ class AmoebaOutOfPlaneBendGenerator:
for (angle, isConstrained) in zip(data.angles, data.isAngleConstrained): for (angle, isConstrained) in zip(data.angles, data.isAngleConstrained):
middleAtom = self.getMiddleAtom( angle, data ) middleAtom = self.getMiddleAtom(angle, data)
if( middleAtom > -1 ): if (middleAtom > -1):
middleType = data.atomType[data.atoms[middleAtom]] middleType = data.atomType[data.atoms[middleAtom]]
middleCovalency = len(data.atomBonds[middleAtom]) middleCovalency = len(data.atomBonds[middleAtom])
else: else:
...@@ -1818,7 +1814,7 @@ class AmoebaOutOfPlaneBendGenerator: ...@@ -1818,7 +1814,7 @@ class AmoebaOutOfPlaneBendGenerator:
# three out-of-plane bend angles are generated. Three in-plane angle # three out-of-plane bend angles are generated. Three in-plane angle
# are also generated. If the conditions are not satisfied the angle is generic angle (not a in-plane angle) # are also generated. If the conditions are not satisfied the angle is generic angle (not a in-plane angle)
if( middleAtom > -1 and middleCovalency == 3 and middleAtom not in skipAtoms ): if (middleAtom > -1 and middleCovalency == 3 and middleAtom not in skipAtoms):
partners = [] partners = []
partnerSet = set() partnerSet = set()
...@@ -1828,7 +1824,7 @@ class AmoebaOutOfPlaneBendGenerator: ...@@ -1828,7 +1824,7 @@ class AmoebaOutOfPlaneBendGenerator:
for bond in data.atomBonds[middleAtom]: for bond in data.atomBonds[middleAtom]:
atom1 = data.bonds[bond].atom1 atom1 = data.bonds[bond].atom1
atom2 = data.bonds[bond].atom2 atom2 = data.bonds[bond].atom2
if( atom1 != middleAtom ): if (atom1 != middleAtom):
partner = atom1 partner = atom1
else: else:
partner = atom2 partner = atom2
...@@ -1837,109 +1833,109 @@ class AmoebaOutOfPlaneBendGenerator: ...@@ -1837,109 +1833,109 @@ class AmoebaOutOfPlaneBendGenerator:
for i in range(len(self.types1)): for i in range(len(self.types1)):
types1 = self.types1[i] types1 = self.types1[i]
types2 = self.types2[i] types2 = self.types2[i]
if( middleType in types2 and partnerType in types1 ): if (middleType in types2 and partnerType in types1):
partners.append( partner ) partners.append(partner)
partnerSet.add( partner ) partnerSet.add(partner)
partnerTypes.append( partnerType ) partnerTypes.append(partnerType)
partnerK.append( self.ks[i] ) partnerK.append(self.ks[i])
if( len(partners) == 3 ): if (len(partners) == 3):
opBondCount += 3 opBondCount += 3
if( verbose ): if (verbose):
print "%5d Opbend: %d type=%s cov=%d " % (opBondCount, middleAtom, middleType, middleCovalency) print "%5d Opbend: %d type=%s cov=%d " % (opBondCount, middleAtom, middleType, middleCovalency)
force.addOutOfPlaneBend(partners[0], middleAtom, partners[1], partners[2], partnerK[2] ) force.addOutOfPlaneBend(partners[0], middleAtom, partners[1], partners[2], partnerK[2])
force.addOutOfPlaneBend(partners[0], middleAtom, partners[2], partners[1], partnerK[1] ) force.addOutOfPlaneBend(partners[0], middleAtom, partners[2], partners[1], partnerK[1])
force.addOutOfPlaneBend(partners[1], middleAtom, partners[2], partners[0], partnerK[0] ) force.addOutOfPlaneBend(partners[1], middleAtom, partners[2], partners[0], partnerK[0])
skipAtoms[middleAtom] = set() skipAtoms[middleAtom] = set()
skipAtoms[middleAtom].add( partners[0] ) skipAtoms[middleAtom].add(partners[0])
skipAtoms[middleAtom].add( partners[1] ) skipAtoms[middleAtom].add(partners[1])
skipAtoms[middleAtom].add( partners[2] ) skipAtoms[middleAtom].add(partners[2])
angleDict = {} angleDict = {}
angleList = [] angleList = []
angleList.append( angle[0] ) angleList.append(angle[0])
angleList.append( angle[1] ) angleList.append(angle[1])
angleList.append( angle[2] ) angleList.append(angle[2])
angleDict['angle'] = angleList angleDict['angle'] = angleList
angleDict['isConstrained'] = 0 angleDict['isConstrained'] = 0
angleSet = set() angleSet = set()
angleSet.add( angle[0] ) angleSet.add(angle[0])
angleSet.add( angle[1] ) angleSet.add(angle[1])
angleSet.add( angle[2] ) angleSet.add(angle[2])
for atomIndex in partnerSet: for atomIndex in partnerSet:
if( atomIndex not in angleSet ): if (atomIndex not in angleSet):
angleList.append( atomIndex ) angleList.append(atomIndex)
if( verbose ): if (verbose):
print "%5d Opbend: middle=%d inPlane1 %d %s" % (opBondCount, middleAtom, len(angleList), str(angleList) ) print "%5d Opbend: middle=%d inPlane1 %d %s" % (opBondCount, middleAtom, len(angleList), str(angleList))
inPlaneAngles.append( angleDict ) inPlaneAngles.append(angleDict)
else: else:
if( verbose ): if (verbose):
print "%5d Opbend: %d type=%s cov=%d xxx" % (opBondCount, middleAtom, middleType, middleCovalency ) print "%5d Opbend: %d type=%s cov=%d xxx" % (opBondCount, middleAtom, middleType, middleCovalency)
print "%5d Opbend: middle=%d inPlane1 %d %s" % (opBondCount, middleAtom, len(angleList), str(angleList) ) print "%5d Opbend: middle=%d inPlane1 %d %s" % (opBondCount, middleAtom, len(angleList), str(angleList))
angleDict = {} angleDict = {}
angleDict['angle'] = angle angleDict['angle'] = angle
angleDict['isConstrained'] = isConstrained angleDict['isConstrained'] = isConstrained
nonInPlaneAngles.append( angleDict ) nonInPlaneAngles.append(angleDict)
else: else:
if( middleAtom > -1 and middleCovalency == 3 and middleAtom in skipAtoms ): if (middleAtom > -1 and middleCovalency == 3 and middleAtom in skipAtoms):
partnerSet = skipAtoms[middleAtom] partnerSet = skipAtoms[middleAtom]
angleDict = {} angleDict = {}
angleList = [] angleList = []
angleList.append( angle[0] ) angleList.append(angle[0])
angleList.append( angle[1] ) angleList.append(angle[1])
angleList.append( angle[2] ) angleList.append(angle[2])
angleDict['angle'] = angleList angleDict['angle'] = angleList
angleDict['isConstrained'] = isConstrained angleDict['isConstrained'] = isConstrained
angleSet = set() angleSet = set()
angleSet.add( angle[0] ) angleSet.add(angle[0])
angleSet.add( angle[1] ) angleSet.add(angle[1])
angleSet.add( angle[2] ) angleSet.add(angle[2])
for atomIndex in partnerSet: for atomIndex in partnerSet:
if( atomIndex not in angleSet ): if (atomIndex not in angleSet):
angleList.append( atomIndex ) angleList.append(atomIndex)
if( verbose ): if (verbose):
print "%5d Opbend: middle=%d inPlane2 %d angleList=%s partnerSet=%s" % (opBondCount, middleAtom, len(angleList), str(angleList), str(partnerSet) ) print "%5d Opbend: middle=%d inPlane2 %d angleList=%s partnerSet=%s" % (opBondCount, middleAtom, len(angleList), str(angleList), str(partnerSet))
inPlaneAngles.append( angleDict ) inPlaneAngles.append(angleDict)
else: else:
angleDict = {} angleDict = {}
angleDict['angle'] = angle angleDict['angle'] = angle
angleDict['isConstrained'] = isConstrained angleDict['isConstrained'] = isConstrained
nonInPlaneAngles.append( angleDict ) nonInPlaneAngles.append(angleDict)
count += 1 count += 1
# get AmoebaHarmonicAngleGenerator and add AmoebaHarmonicAngle and AmoebaHarmonicInPlaneAngle forces # get AmoebaHarmonicAngleGenerator and add AmoebaHarmonicAngle and AmoebaHarmonicInPlaneAngle forces
for force in self.forceField._forces: for force in self.forceField._forces:
if( force.__class__.__name__ == 'AmoebaHarmonicAngleGenerator' ): if (force.__class__.__name__ == 'AmoebaHarmonicAngleGenerator'):
force.createForcePostOpBendAngle( sys, data, nonbondedMethod, nonbondedCutoff, nonInPlaneAngles, args ) force.createForcePostOpBendAngle(sys, data, nonbondedMethod, nonbondedCutoff, nonInPlaneAngles, args)
force.createForcePostOpBendInPlaneAngle( sys, data, nonbondedMethod, nonbondedCutoff, inPlaneAngles, args ) force.createForcePostOpBendInPlaneAngle(sys, data, nonbondedMethod, nonbondedCutoff, inPlaneAngles, args)
if( force.__class__.__name__ == 'AmoebaHarmonicBondGenerator' ): if (force.__class__.__name__ == 'AmoebaHarmonicBondGenerator'):
force.createForce( sys, data, nonbondedMethod, nonbondedCutoff, args ) force.createForce(sys, data, nonbondedMethod, nonbondedCutoff, args)
for force in self.forceField._forces: for force in self.forceField._forces:
if( force.__class__.__name__ == 'AmoebaStretchBendGenerator' ): if (force.__class__.__name__ == 'AmoebaStretchBendGenerator'):
for angleDict in inPlaneAngles: for angleDict in inPlaneAngles:
nonInPlaneAngles.append( angleDict ) nonInPlaneAngles.append(angleDict)
force.createForcePostAmoebaHarmonicBondForce( sys, data, nonbondedMethod, nonbondedCutoff, nonInPlaneAngles, args ) force.createForcePostAmoebaHarmonicBondForce(sys, data, nonbondedMethod, nonbondedCutoff, nonInPlaneAngles, args)
parsers["AmoebaOutOfPlaneBendForce"] = AmoebaOutOfPlaneBendGenerator.parseElement parsers["AmoebaOutOfPlaneBendForce"] = AmoebaOutOfPlaneBendGenerator.parseElement
...@@ -1976,7 +1972,7 @@ class AmoebaTorsionGenerator: ...@@ -1976,7 +1972,7 @@ class AmoebaTorsionGenerator:
# <Torsion class1="3" class2="1" class3="2" class4="3" amp1="0.0" angle1="0.0" amp2="0.0" angle2="3.14159265359" amp3="0.0" angle3="0.0" /> # <Torsion class1="3" class2="1" class3="2" class4="3" amp1="0.0" angle1="0.0" amp2="0.0" angle2="3.14159265359" amp3="0.0" angle3="0.0" />
# <Torsion class1="3" class2="1" class3="2" class4="6" amp1="0.0" angle1="0.0" amp2="0.0" angle2="3.14159265359" amp3="-0.263592" angle3="0.0" /> # <Torsion class1="3" class2="1" class3="2" class4="6" amp1="0.0" angle1="0.0" amp2="0.0" angle2="3.14159265359" amp3="-0.263592" angle3="0.0" />
generator = AmoebaTorsionGenerator( float(element.attrib['torsionUnit']) ) generator = AmoebaTorsionGenerator(float(element.attrib['torsionUnit']))
forceField._forces.append(generator) forceField._forces.append(generator)
# collect particle classes and t1,t2,t3, # collect particle classes and t1,t2,t3,
...@@ -2000,27 +1996,27 @@ class AmoebaTorsionGenerator: ...@@ -2000,27 +1996,27 @@ class AmoebaTorsionGenerator:
angName = 'angle' + suffix angName = 'angle' + suffix
tInfo.append(float(torsion.attrib[angName])) tInfo.append(float(torsion.attrib[angName]))
if( ii == 1 ): if (ii == 1):
generator.t1.append( tInfo ) generator.t1.append(tInfo)
elif( ii == 2 ): elif (ii == 2):
generator.t2.append( tInfo ) generator.t2.append(tInfo)
elif( ii == 3 ): elif (ii == 3):
generator.t3.append( tInfo ) generator.t3.append(tInfo)
else: else:
outputString = "AmoebaTorsionGenerator: error getting types: %s %s %s %s" % ( outputString = "AmoebaTorsionGenerator: error getting types: %s %s %s %s" % (
stretchBend.attrib['class1'], stretchBend.attrib['class1'],
stretchBend.attrib['class2'], stretchBend.attrib['class2'],
stretchBend.attrib['class3'], stretchBend.attrib['class3'],
stretchBend.attrib['class4'] ) stretchBend.attrib['class4'])
raise ValueError( outputString ) raise ValueError(outputString)
#============================================================================================= #=============================================================================================
def createForce(self, sys, data, nontorsionedMethod, nontorsionedCutoff, args): def createForce(self, sys, data, nontorsionedMethod, nontorsionedCutoff, args):
verbose = 0 verbose = 0
if( self.hasBeenCalled ): if (self.hasBeenCalled):
return return
self.hasBeenCalled = 1 self.hasBeenCalled = 1
...@@ -2031,7 +2027,7 @@ class AmoebaTorsionGenerator: ...@@ -2031,7 +2027,7 @@ class AmoebaTorsionGenerator:
sys.addForce(force) sys.addForce(force)
else: else:
force = existing[0] force = existing[0]
if( verbose ): if (verbose):
print "In AmoebaTorsionGenerator torsions=%d " % (len(data.propers)) print "In AmoebaTorsionGenerator torsions=%d " % (len(data.propers))
count = 0 count = 0
for torsion in data.propers: for torsion in data.propers:
...@@ -2051,20 +2047,20 @@ class AmoebaTorsionGenerator: ...@@ -2051,20 +2047,20 @@ class AmoebaTorsionGenerator:
# match types in forward or reverse direction # match types in forward or reverse direction
if (type1 in types1 and type2 in types2 and type3 in types3 and type4 in types4) or (type4 in types1 and type3 in types2 and type2 in types3 and type1 in types4 ): if (type1 in types1 and type2 in types2 and type3 in types3 and type4 in types4) or (type4 in types1 and type3 in types2 and type2 in types3 and type1 in types4):
if( verbose ): if (verbose):
print "AmoebaTorsionGenerator %5d [%5d %5d %5d %5d] [%5s %5s %5s %5s]" % ( print "AmoebaTorsionGenerator %5d [%5d %5d %5d %5d] [%5s %5s %5s %5s]" % (
count, torsion[0], torsion[1], torsion[2], torsion[3], count, torsion[0], torsion[1], torsion[2], torsion[3],
type1, type2, type3, type4) type1, type2, type3, type4)
hit = 1 hit = 1
force.addTorsion(torsion[0], torsion[1], torsion[2], torsion[3], self.t1[i], self.t2[i], self.t3[i] ) force.addTorsion(torsion[0], torsion[1], torsion[2], torsion[3], self.t1[i], self.t2[i], self.t3[i])
break break
if( hit == 0 ): if (hit == 0):
print "AmoebaTorsionGenerator missing: %5d %s %s " % (count, type1, type2, type3, type4) print "AmoebaTorsionGenerator missing: %5d %s %s " % (count, type1, type2, type3, type4)
count += 1 count += 1
if( verbose ): if (verbose):
print "AmoebaTorsionGenerator number of torsions added=%d " % (force.getNumTorsions()) print "AmoebaTorsionGenerator number of torsions added=%d " % (force.getNumTorsions())
parsers["AmoebaTorsionForce"] = AmoebaTorsionGenerator.parseElement parsers["AmoebaTorsionForce"] = AmoebaTorsionGenerator.parseElement
...@@ -2094,7 +2090,7 @@ class AmoebaPiTorsionGenerator: ...@@ -2094,7 +2090,7 @@ class AmoebaPiTorsionGenerator:
# <AmoebaPiTorsionForce piTorsionUnit="1.0"> # <AmoebaPiTorsionForce piTorsionUnit="1.0">
# <PiTorsion class1="1" class2="3" k="28.6604" /> # <PiTorsion class1="1" class2="3" k="28.6604" />
generator = AmoebaPiTorsionGenerator( float(element.attrib['piTorsionUnit']) ) generator = AmoebaPiTorsionGenerator(float(element.attrib['piTorsionUnit']))
forceField._forces.append(generator) forceField._forces.append(generator)
for piTorsion in element.findall('PiTorsion'): for piTorsion in element.findall('PiTorsion'):
...@@ -2106,15 +2102,15 @@ class AmoebaPiTorsionGenerator: ...@@ -2106,15 +2102,15 @@ class AmoebaPiTorsionGenerator:
else: else:
outputString = "AmoebaPiTorsionGenerator: error getting types: %s %s " % ( outputString = "AmoebaPiTorsionGenerator: error getting types: %s %s " % (
piTorsion.attrib['class1'], piTorsion.attrib['class1'],
piTorsion.attrib['class2'] ) piTorsion.attrib['class2'])
raise ValueError( outputString ) raise ValueError(outputString)
#============================================================================================= #=============================================================================================
def createForce(self, sys, data, nonpiTorsionedMethod, nonpiTorsionedCutoff, args): def createForce(self, sys, data, nonpiTorsionedMethod, nonpiTorsionedCutoff, args):
verbose = 0 verbose = 0
if( self.hasBeenCalled ): if (self.hasBeenCalled):
return return
self.hasBeenCalled = 1 self.hasBeenCalled = 1
...@@ -2135,7 +2131,7 @@ class AmoebaPiTorsionGenerator: ...@@ -2135,7 +2131,7 @@ class AmoebaPiTorsionGenerator:
atom1 = bond.atom1 atom1 = bond.atom1
atom2 = bond.atom2 atom2 = bond.atom2
if( len(data.atomBonds[atom1]) == 3 and len(data.atomBonds[atom1]) == 3 ): if (len(data.atomBonds[atom1]) == 3 and len(data.atomBonds[atom1]) == 3):
type1 = data.atomType[data.atoms[atom1]] type1 = data.atomType[data.atoms[atom1]]
type2 = data.atomType[data.atoms[atom2]] type2 = data.atomType[data.atoms[atom2]]
...@@ -2146,7 +2142,7 @@ class AmoebaPiTorsionGenerator: ...@@ -2146,7 +2142,7 @@ class AmoebaPiTorsionGenerator:
types2 = self.types2[i] types2 = self.types2[i]
if (type1 in types1 and type2 in types2) or (type1 in types2 and type2 in types1): if (type1 in types1 and type2 in types2) or (type1 in types2 and type2 in types1):
if( verbose ): if (verbose):
print "AmoebaPiTorsionGenerator %5d %5d %5d [%5s %5s] %15.6f" % (count, atom1, atom2, type1, type2, self.k[i]) print "AmoebaPiTorsionGenerator %5d %5d %5d [%5s %5s] %15.6f" % (count, atom1, atom2, type1, type2, self.k[i])
# piTorsionAtom1, piTorsionAtom2 are the atoms bonded to atom1, excluding atom2 # piTorsionAtom1, piTorsionAtom2 are the atoms bonded to atom1, excluding atom2
...@@ -2163,12 +2159,12 @@ class AmoebaPiTorsionGenerator: ...@@ -2163,12 +2159,12 @@ class AmoebaPiTorsionGenerator:
for bond in data.atomBonds[atom1]: for bond in data.atomBonds[atom1]:
bondedAtom1 = data.bonds[bond].atom1 bondedAtom1 = data.bonds[bond].atom1
bondedAtom2 = data.bonds[bond].atom2 bondedAtom2 = data.bonds[bond].atom2
if( bondedAtom1 != atom1 ): if (bondedAtom1 != atom1):
b1 = bondedAtom1 b1 = bondedAtom1
else: else:
b1 = bondedAtom2 b1 = bondedAtom2
if( b1 != atom2 ): if (b1 != atom2):
if( piTorsionAtom1 == -1 ): if (piTorsionAtom1 == -1):
piTorsionAtom1 = b1 piTorsionAtom1 = b1
else: else:
piTorsionAtom2 = b1 piTorsionAtom2 = b1
...@@ -2176,21 +2172,21 @@ class AmoebaPiTorsionGenerator: ...@@ -2176,21 +2172,21 @@ class AmoebaPiTorsionGenerator:
for bond in data.atomBonds[atom2]: for bond in data.atomBonds[atom2]:
bondedAtom1 = data.bonds[bond].atom1 bondedAtom1 = data.bonds[bond].atom1
bondedAtom2 = data.bonds[bond].atom2 bondedAtom2 = data.bonds[bond].atom2
if( bondedAtom1 != atom2 ): if (bondedAtom1 != atom2):
b1 = bondedAtom1 b1 = bondedAtom1
else: else:
b1 = bondedAtom2 b1 = bondedAtom2
if( b1 != atom1 ): if (b1 != atom1):
if( piTorsionAtom5 == -1 ): if (piTorsionAtom5 == -1):
piTorsionAtom5 = b1 piTorsionAtom5 = b1
else: else:
piTorsionAtom6 = b1 piTorsionAtom6 = b1
force.addPiTorsion( piTorsionAtom1, piTorsionAtom2, piTorsionAtom3, piTorsionAtom4, piTorsionAtom5, piTorsionAtom6, self.k[i]) force.addPiTorsion(piTorsionAtom1, piTorsionAtom2, piTorsionAtom3, piTorsionAtom4, piTorsionAtom5, piTorsionAtom6, self.k[i])
count += 1 count += 1
if( verbose ): if (verbose):
print "AmoebaPiTorsionGenerator number of pi-torsions added=%d " % (force.getNumPiTorsions()) print "AmoebaPiTorsionGenerator number of pi-torsions added=%d " % (force.getNumPiTorsions())
parsers["AmoebaPiTorsionForce"] = AmoebaPiTorsionGenerator.parseElement parsers["AmoebaPiTorsionForce"] = AmoebaPiTorsionGenerator.parseElement
...@@ -2205,7 +2201,7 @@ class AmoebaTorsionTorsionGenerator: ...@@ -2205,7 +2201,7 @@ class AmoebaTorsionTorsionGenerator:
#============================================================================================= #=============================================================================================
def __init__(self ): def __init__(self):
self.types1 = [] self.types1 = []
self.types2 = [] self.types2 = []
...@@ -2224,7 +2220,7 @@ class AmoebaTorsionTorsionGenerator: ...@@ -2224,7 +2220,7 @@ class AmoebaTorsionTorsionGenerator:
@staticmethod @staticmethod
def parseElement(element, forceField): def parseElement(element, forceField):
generator = AmoebaTorsionTorsionGenerator( ) generator = AmoebaTorsionTorsionGenerator()
forceField._forces.append(generator) forceField._forces.append(generator)
maxGridIndex = -1 maxGridIndex = -1
...@@ -2232,7 +2228,7 @@ class AmoebaTorsionTorsionGenerator: ...@@ -2232,7 +2228,7 @@ class AmoebaTorsionTorsionGenerator:
# <TorsionTorsion class1="3" class2="1" class3="2" class4="3" class5="1" grid="0" nx="25" ny="25" /> # <TorsionTorsion class1="3" class2="1" class3="2" class4="3" class5="1" grid="0" nx="25" ny="25" />
for torsionTorsion in element.findall('TorsionTorsion'): for torsionTorsion in element.findall('TorsionTorsion'):
types = forceField._findAtomTypes( torsionTorsion, 5) types = forceField._findAtomTypes(torsionTorsion, 5)
if types is not None: if types is not None:
generator.types1.append(types[0]) generator.types1.append(types[0])
...@@ -2242,7 +2238,7 @@ class AmoebaTorsionTorsionGenerator: ...@@ -2242,7 +2238,7 @@ class AmoebaTorsionTorsionGenerator:
generator.types5.append(types[4]) generator.types5.append(types[4])
gridIndex = int(torsionTorsion.attrib['grid']) gridIndex = int(torsionTorsion.attrib['grid'])
if( gridIndex > maxGridIndex ): if (gridIndex > maxGridIndex):
maxGridIndex = gridIndex maxGridIndex = gridIndex
generator.gridIndex.append(gridIndex) generator.gridIndex.append(gridIndex)
...@@ -2253,7 +2249,7 @@ class AmoebaTorsionTorsionGenerator: ...@@ -2253,7 +2249,7 @@ class AmoebaTorsionTorsionGenerator:
torsionTorsion.attrib['class3'], torsionTorsion.attrib['class3'],
torsionTorsion.attrib['class4'], torsionTorsion.attrib['class4'],
torsionTorsion.attrib['class5'] ) torsionTorsion.attrib['class5'] )
raise ValueError( outputString ) raise ValueError(outputString)
# load grid # load grid
...@@ -2276,9 +2272,9 @@ class AmoebaTorsionTorsionGenerator: ...@@ -2276,9 +2272,9 @@ class AmoebaTorsionTorsionGenerator:
generator.grids = maxGridIndex*[] generator.grids = maxGridIndex*[]
for torsionTorsionGrid in element.findall('TorsionTorsionGrid'): for torsionTorsionGrid in element.findall('TorsionTorsionGrid'):
gridIndex = int( torsionTorsionGrid.attrib[ "grid"] ) gridIndex = int(torsionTorsionGrid.attrib[ "grid"])
nx = int( torsionTorsionGrid.attrib[ "nx"] ) nx = int(torsionTorsionGrid.attrib[ "nx"])
ny = int( torsionTorsionGrid.attrib[ "ny"] ) ny = int(torsionTorsionGrid.attrib[ "ny"])
grid = [] grid = []
gridCol = [] gridCol = []
...@@ -2288,31 +2284,31 @@ class AmoebaTorsionTorsionGenerator: ...@@ -2288,31 +2284,31 @@ class AmoebaTorsionTorsionGenerator:
for gridEntry in torsionTorsionGrid.findall('Grid'): for gridEntry in torsionTorsionGrid.findall('Grid'):
gridRow = [] gridRow = []
gridRow.append( float( gridEntry.attrib['angle1'] ) ) gridRow.append(float(gridEntry.attrib['angle1']))
gridRow.append( float( gridEntry.attrib['angle2'] ) ) gridRow.append(float(gridEntry.attrib['angle2']))
gridRow.append( float( gridEntry.attrib['f'] ) ) gridRow.append(float(gridEntry.attrib['f']))
gridRow.append( float( gridEntry.attrib['fx'] ) ) gridRow.append(float(gridEntry.attrib['fx']))
gridRow.append( float( gridEntry.attrib['fy'] ) ) gridRow.append(float(gridEntry.attrib['fy']))
gridRow.append( float( gridEntry.attrib['fxy'] ) ) gridRow.append(float(gridEntry.attrib['fxy']))
gridCol.append( gridRow ) gridCol.append(gridRow)
gridColIndex += 1 gridColIndex += 1
if( gridColIndex == nx ): if (gridColIndex == nx):
grid.append( gridCol ) grid.append(gridCol)
gridCol = [] gridCol = []
gridColIndex = 0 gridColIndex = 0
if( gridIndex == len(generator.grids) ): if (gridIndex == len(generator.grids)):
generator.grids.append( grid ) generator.grids.append(grid)
else: else:
while( len( generator.grids ) < gridIndex ): while(len(generator.grids) < gridIndex):
generator.grids.append( [] ) generator.grids.append([])
generator.grids[gridIndex] = grid generator.grids[gridIndex] = grid
#============================================================================================= #=============================================================================================
def getChiralAtomIndex(self, data, sys, atomB, atomC, atomD ): def getChiralAtomIndex(self, data, sys, atomB, atomC, atomD):
chiralAtomIndex = -1 chiralAtomIndex = -1
...@@ -2321,44 +2317,44 @@ class AmoebaTorsionTorsionGenerator: ...@@ -2321,44 +2317,44 @@ class AmoebaTorsionTorsionGenerator:
# set chiralAtomIndex to one of these, if they are # set chiralAtomIndex to one of these, if they are
# not the same atom(type/mass) # not the same atom(type/mass)
if( len(data.atomBonds[atomC]) == 4 ): if (len(data.atomBonds[atomC]) == 4):
atomE = -1 atomE = -1
atomF = -1 atomF = -1
for bond in data.atomBonds[atomC]: for bond in data.atomBonds[atomC]:
bondedAtom1 = data.bonds[bond].atom1 bondedAtom1 = data.bonds[bond].atom1
bondedAtom2 = data.bonds[bond].atom2 bondedAtom2 = data.bonds[bond].atom2
hit = -1 hit = -1
if( bondedAtom1 == atomC and bondedAtom2 != atomB and bondedAtom2 != atomD ): if ( bondedAtom1 == atomC and bondedAtom2 != atomB and bondedAtom2 != atomD):
hit = bondedAtom2 hit = bondedAtom2
elif( bondedAtom2 == atomC and bondedAtom1 != atomB and bondedAtom1 != atomD ): elif (bondedAtom2 == atomC and bondedAtom1 != atomB and bondedAtom1 != atomD):
hit = bondedAtom1 hit = bondedAtom1
if( hit > -1 ): if (hit > -1):
if( atomE == -1 ): if (atomE == -1):
atomE = hit atomE = hit
else: else:
atomF = hit atomF = hit
# raise error if atoms E or F not found # raise error if atoms E or F not found
if( atomE == -1 or atomF == -1 ): if (atomE == -1 or atomF == -1):
outputString = "getChiralAtomIndex: error getting bonded partners of atomC=%s %d %s" % (atomC.name, atomC.resiude.index, atomC.resiude.name, ) outputString = "getChiralAtomIndex: error getting bonded partners of atomC=%s %d %s" % (atomC.name, atomC.resiude.index, atomC.resiude.name,)
raise ValueError( outputString ) raise ValueError(outputString)
# check for different type/mass between atoms E & F # check for different type/mass between atoms E & F
typeE = int(data.atomType[data.atoms[atomE]]) typeE = int(data.atomType[data.atoms[atomE]])
typeF = int(data.atomType[data.atoms[atomF]]) typeF = int(data.atomType[data.atoms[atomF]])
if( typeE > typeF ): if (typeE > typeF):
chiralAtomIndex = atomE chiralAtomIndex = atomE
if( typeF > typeE ): if (typeF > typeE):
chiralAtomIndex = atomF chiralAtomIndex = atomF
massE = sys.getParticleMass( atomE )/unit.dalton massE = sys.getParticleMass(atomE)/unit.dalton
massF = sys.getParticleMass( atomE )/unit.dalton massF = sys.getParticleMass(atomE)/unit.dalton
if( massE > massF ): if (massE > massF):
chiralAtomIndex = massE chiralAtomIndex = massE
if( massF > massE ): if (massF > massE):
chiralAtomIndex = massF chiralAtomIndex = massF
return chiralAtomIndex return chiralAtomIndex
...@@ -2368,7 +2364,7 @@ class AmoebaTorsionTorsionGenerator: ...@@ -2368,7 +2364,7 @@ class AmoebaTorsionTorsionGenerator:
def createForce(self, sys, data, nonpiTorsionedMethod, nonpiTorsionedCutoff, args): def createForce(self, sys, data, nonpiTorsionedMethod, nonpiTorsionedCutoff, args):
verbose = 0 verbose = 0
if( self.hasBeenCalled ): if (self.hasBeenCalled):
return return
self.hasBeenCalled = 1 self.hasBeenCalled = 1
...@@ -2393,21 +2389,21 @@ class AmoebaTorsionTorsionGenerator: ...@@ -2393,21 +2389,21 @@ class AmoebaTorsionTorsionGenerator:
for bondIndex in data.atomBonds[ib]: for bondIndex in data.atomBonds[ib]:
bondedAtom1 = data.bonds[bondIndex].atom1 bondedAtom1 = data.bonds[bondIndex].atom1
bondedAtom2 = data.bonds[bondIndex].atom2 bondedAtom2 = data.bonds[bondIndex].atom2
if( bondedAtom1 != ib ): if (bondedAtom1 != ib):
ia = bondedAtom1 ia = bondedAtom1
else: else:
ia = bondedAtom2 ia = bondedAtom2
if( ia != ic and ia != id ): if (ia != ic and ia != id):
for bondIndex in data.atomBonds[id]: for bondIndex in data.atomBonds[id]:
bondedAtom1 = data.bonds[bondIndex].atom1 bondedAtom1 = data.bonds[bondIndex].atom1
bondedAtom2 = data.bonds[bondIndex].atom2 bondedAtom2 = data.bonds[bondIndex].atom2
if( bondedAtom1 != id ): if (bondedAtom1 != id):
ie = bondedAtom1 ie = bondedAtom1
else: else:
ie = bondedAtom2 ie = bondedAtom2
if( ie != ic and ie != ib and ie != ia ): if (ie != ic and ie != ib and ie != ia):
# found candidate set of atoms # found candidate set of atoms
# check if types match in order or reverse order # check if types match in order or reverse order
...@@ -2428,22 +2424,22 @@ class AmoebaTorsionTorsionGenerator: ...@@ -2428,22 +2424,22 @@ class AmoebaTorsionTorsionGenerator:
# match in order # match in order
if( type1 in types1 and type2 in types2 and type3 in types3 and type4 in types4 and type5 in types5 ): if (type1 in types1 and type2 in types2 and type3 in types3 and type4 in types4 and type5 in types5):
chiralAtomIndex = self.getChiralAtomIndex( data, sys, ib, ic, id ) chiralAtomIndex = self.getChiralAtomIndex(data, sys, ib, ic, id)
force.addTorsionTorsion( ia, ib, ic, id, ie, chiralAtomIndex, self.gridIndex[i]) force.addTorsionTorsion(ia, ib, ic, id, ie, chiralAtomIndex, self.gridIndex[i])
# match in reverse order # match in reverse order
if( type5 in types1 and type4 in types2 and type3 in types3 and type2 in types4 and type1 in types5 ): if (type5 in types1 and type4 in types2 and type3 in types3 and type2 in types4 and type1 in types5):
chiralAtomIndex = self.getChiralAtomIndex( data, sys, ib, ic, id ) chiralAtomIndex = self.getChiralAtomIndex(data, sys, ib, ic, id)
force.addTorsionTorsion( ie, id, ic, ib, ia, chiralAtomIndex, self.gridIndex[i]) force.addTorsionTorsion(ie, id, ic, ib, ia, chiralAtomIndex, self.gridIndex[i])
# set grids # set grids
for (index, grid) in enumerate(self.grids): for (index, grid) in enumerate(self.grids):
force.setTorsionTorsionGrid( index, grid ) force.setTorsionTorsionGrid(index, grid)
if( verbose ): if (verbose):
print "AmoebaTorsionTorsionGenerator number of bitorsions added=%d " % (force.getNumTorsionTorsions()) print "AmoebaTorsionTorsionGenerator number of bitorsions added=%d " % (force.getNumTorsionTorsions())
print "AmoebaTorsionTorsionGenerator number of grids added=%d " % (force.getNumTorsionTorsionGrids()) print "AmoebaTorsionTorsionGenerator number of grids added=%d " % (force.getNumTorsionTorsionGrids())
...@@ -2470,7 +2466,7 @@ class AmoebaStretchBendGenerator: ...@@ -2470,7 +2466,7 @@ class AmoebaStretchBendGenerator:
@staticmethod @staticmethod
def parseElement(element, forceField): def parseElement(element, forceField):
generator = AmoebaStretchBendGenerator( ) generator = AmoebaStretchBendGenerator()
forceField._forces.append(generator) forceField._forces.append(generator)
# <AmoebaStretchBendForce stretchBendUnit="1.0"> # <AmoebaStretchBendForce stretchBendUnit="1.0">
...@@ -2492,8 +2488,8 @@ class AmoebaStretchBendGenerator: ...@@ -2492,8 +2488,8 @@ class AmoebaStretchBendGenerator:
outputString = "AmoebaStretchBendGenerator : error getting types: %s %s %s" % ( outputString = "AmoebaStretchBendGenerator : error getting types: %s %s %s" % (
stretchBend.attrib['class1'], stretchBend.attrib['class1'],
stretchBend.attrib['class2'], stretchBend.attrib['class2'],
stretchBend.attrib['class3'] ) stretchBend.attrib['class3'])
raise ValueError( outputString ) raise ValueError(outputString)
#============================================================================================= #=============================================================================================
...@@ -2506,7 +2502,7 @@ class AmoebaStretchBendGenerator: ...@@ -2506,7 +2502,7 @@ class AmoebaStretchBendGenerator:
#============================================================================================= #=============================================================================================
def createForce(self, sys, data, nonbondedMethod, nonbondedCutoff, args ): def createForce(self, sys, data, nonbondedMethod, nonbondedCutoff, args):
pass pass
#============================================================================================= #=============================================================================================
...@@ -2518,7 +2514,7 @@ class AmoebaStretchBendGenerator: ...@@ -2518,7 +2514,7 @@ class AmoebaStretchBendGenerator:
def createForcePostAmoebaHarmonicBondForce(self, sys, data, nonbondedMethod, nonbondedCutoff, angleList, args): def createForcePostAmoebaHarmonicBondForce(self, sys, data, nonbondedMethod, nonbondedCutoff, angleList, args):
verbose = 0 verbose = 0
if( self.hasBeenCalled ): if (self.hasBeenCalled):
return return
self.hasBeenCalled = 1 self.hasBeenCalled = 1
...@@ -2530,14 +2526,14 @@ class AmoebaStretchBendGenerator: ...@@ -2530,14 +2526,14 @@ class AmoebaStretchBendGenerator:
else: else:
force = existing[0] force = existing[0]
if( verbose ): if (verbose):
print "In AmoebaStretchBendGenerator bonds=%d " % (len(data.bonds)) print "In AmoebaStretchBendGenerator bonds=%d " % (len(data.bonds))
count = 0 count = 0
for angleDict in angleList: for angleDict in angleList:
angle = angleDict['angle'] angle = angleDict['angle']
if( 'isConstrained' in angleDict ): if ('isConstrained' in angleDict):
isConstrained = angleDict['isConstrained'] isConstrained = angleDict['isConstrained']
else: else:
isConstrained = 0 isConstrained = 0
...@@ -2558,11 +2554,9 @@ class AmoebaStretchBendGenerator: ...@@ -2558,11 +2554,9 @@ class AmoebaStretchBendGenerator:
# get ideal bond lengths, bondAB, bondCB # get ideal bond lengths, bondAB, bondCB
# get ideal angle # get ideal angle
if( type2 in types2 and ( (type1 in types1 and type3 in types3) or (type3 in types1 and type1 in types3) ) ): if (type2 in types2 and ((type1 in types1 and type3 in types3) or (type3 in types1 and type1 in types3))):
if isConstrained: if isConstrained:
hit = 1 hit = 1
# sys.addConstraint(bond.atom1, bond.atom2, self.length[i])
# print message
else: else:
hit = 1 hit = 1
bondAB = -1.0 bondAB = -1.0
...@@ -2572,34 +2566,34 @@ class AmoebaStretchBendGenerator: ...@@ -2572,34 +2566,34 @@ class AmoebaStretchBendGenerator:
atom1 = data.bonds[bond].atom1 atom1 = data.bonds[bond].atom1
atom2 = data.bonds[bond].atom2 atom2 = data.bonds[bond].atom2
length = data.bonds[bond].length length = data.bonds[bond].length
if( atom1 == angle[0] ): if (atom1 == angle[0]):
bondAB = length bondAB = length
if( atom1 == angle[2] ): if (atom1 == angle[2]):
bondCB = length bondCB = length
if( atom2 == angle[2] ): if (atom2 == angle[2]):
bondCB = length bondCB = length
if( atom2 == angle[0] ): if (atom2 == angle[0]):
bondAB = length bondAB = length
# check that ideal angle and bonds are set # check that ideal angle and bonds are set
if( 'idealAngle' not in angleDict ): if ('idealAngle' not in angleDict):
outputString = "AmoebaStretchBendGenerator: ideal angle is not set for following entry:\n" outputString = "AmoebaStretchBendGenerator: ideal angle is not set for following entry:\n"
outputString += " %5d [%5d %5d %5d] [%5s %5s %5s]" % (count, angle[0], angle[1], angle[2], type1, type2, type3 ) outputString += " %5d [%5d %5d %5d] [%5s %5s %5s]" % (count, angle[0], angle[1], angle[2], type1, type2, type3)
raise ValueError( outputString ) raise ValueError(outputString)
elif( bondAB < 0 or bondCB < 0 ): elif (bondAB < 0 or bondCB < 0):
outputString = "AmoebaStretchBendGenerator: bonds not set: %15.7e %15.7e. for following entry:" % ( bondAB, bondCB) outputString = "AmoebaStretchBendGenerator: bonds not set: %15.7e %15.7e. for following entry:" % (bondAB, bondCB)
outputString += " %5d [%5d %5d %5d] [%5s %5s %5s]" % (count, angle[0], angle[1], angle[2], type1, type2, type3 ) outputString += " %5d [%5d %5d %5d] [%5s %5s %5s]" % (count, angle[0], angle[1], angle[2], type1, type2, type3)
raise ValueError( outputString ) raise ValueError(outputString)
else: else:
if( verbose ): if (verbose):
print "AmoebaStretchBendGenerator %5d [%5d %5d %5d] [%5s %5s %5s] %15.6f %15.6f %15.6f %15.6f" % (count, angle[0], angle[1], angle[2], type1, type2, type3, bondAB, bondCB, angleDict['idealAngle'], self.k1[i]) print "AmoebaStretchBendGenerator %5d [%5d %5d %5d] [%5s %5s %5s] %15.6f %15.6f %15.6f %15.6f" % (count, angle[0], angle[1], angle[2], type1, type2, type3, bondAB, bondCB, angleDict['idealAngle'], self.k1[i])
force.addStretchBend( angle[0], angle[1], angle[2], bondAB, bondCB, angleDict['idealAngle']/radian, self.k1[i]) force.addStretchBend(angle[0], angle[1], angle[2], bondAB, bondCB, angleDict['idealAngle']/radian, self.k1[i])
break break
if( hit == 0 and verbose ): if (hit == 0 and verbose):
print "AmoebaStretchBendGenerator missing: %5d missing [%5d %5d %5d] [%5s %5s %5s] " % (count, angle[0], angle[1], angle[2], type1, type2, type3) print "AmoebaStretchBendGenerator missing: %5d missing [%5d %5d %5d] [%5s %5s %5s] " % (count, angle[0], angle[1], angle[2], type1, type2, type3)
count += 1 count += 1
...@@ -2614,7 +2608,7 @@ class AmoebaVdwGenerator: ...@@ -2614,7 +2608,7 @@ class AmoebaVdwGenerator:
#============================================================================================= #=============================================================================================
def __init__(self, type, radiusrule, radiustype, radiussize, epsilonrule, vdw13Scale, vdw14Scale, vdw15Scale ): def __init__(self, type, radiusrule, radiustype, radiussize, epsilonrule, vdw13Scale, vdw14Scale, vdw15Scale):
self.type = type self.type = type
...@@ -2639,8 +2633,8 @@ class AmoebaVdwGenerator: ...@@ -2639,8 +2633,8 @@ class AmoebaVdwGenerator:
# <Vdw class="1" sigma="0.371" epsilon="0.46024" reduction="1.0" /> # <Vdw class="1" sigma="0.371" epsilon="0.46024" reduction="1.0" />
# <Vdw class="2" sigma="0.382" epsilon="0.422584" reduction="1.0" /> # <Vdw class="2" sigma="0.382" epsilon="0.422584" reduction="1.0" />
generator = AmoebaVdwGenerator( element.attrib['type'], element.attrib['radiusrule'], element.attrib['radiustype'], element.attrib['radiussize'], element.attrib['epsilonrule'], generator = AmoebaVdwGenerator(element.attrib['type'], element.attrib['radiusrule'], element.attrib['radiustype'], element.attrib['radiussize'], element.attrib['epsilonrule'],
float(element.attrib['vdw-13-scale']), float(element.attrib['vdw-14-scale']), float(element.attrib['vdw-15-scale']) ) float(element.attrib['vdw-13-scale']), float(element.attrib['vdw-14-scale']), float(element.attrib['vdw-15-scale']))
forceField._forces.append(generator) forceField._forces.append(generator)
two_six = 1.122462048309372 two_six = 1.122462048309372
...@@ -2655,20 +2649,20 @@ class AmoebaVdwGenerator: ...@@ -2655,20 +2649,20 @@ class AmoebaVdwGenerator:
classType = atom.attrib['class'] classType = atom.attrib['class']
if( generator.radiustype == 'SIGMA' ): if (generator.radiustype == 'SIGMA'):
values[0] *= two_six values[0] *= two_six
if( generator.radiussize == 'DIAMETER' ): if (generator.radiussize == 'DIAMETER'):
values[0] *= 0.5 values[0] *= 0.5
values.append( classType ) values.append(classType)
for t in types[0]: for t in types[0]:
generator.typeMap[t] = values generator.typeMap[t] = values
else: else:
outputString = "AmoebaVdwGenerator: error getting type: %s" % ( atom.attrib['class'] ) outputString = "AmoebaVdwGenerator: error getting type: %s" % (atom.attrib['class'])
raise ValueError( outputString ) raise ValueError(outputString)
#============================================================================================= #=============================================================================================
...@@ -2677,23 +2671,23 @@ class AmoebaVdwGenerator: ...@@ -2677,23 +2671,23 @@ class AmoebaVdwGenerator:
#============================================================================================= #=============================================================================================
@staticmethod @staticmethod
def getBondedParticleSet( particleIndex, data ): def getBondedParticleSet(particleIndex, data):
bondedParticleSet = set() bondedParticleSet = set()
for bond in data.atomBonds[particleIndex]: for bond in data.atomBonds[particleIndex]:
atom1 = data.bonds[bond].atom1 atom1 = data.bonds[bond].atom1
atom2 = data.bonds[bond].atom2 atom2 = data.bonds[bond].atom2
if( atom1 != particleIndex ): if (atom1 != particleIndex):
bondedParticleSet.add( atom1 ) bondedParticleSet.add(atom1)
else: else:
bondedParticleSet.add( atom2 ) bondedParticleSet.add(atom2)
return bondedParticleSet return bondedParticleSet
#============================================================================================= #=============================================================================================
def createForce(self, sys, data, nonbondedMethod, nonbondedCutoff, args ): def createForce(self, sys, data, nonbondedMethod, nonbondedCutoff, args):
sigmaMap = {'ARITHMETIC':1, 'GEOMETRIC':1, 'CUBIC-MEAN':1} sigmaMap = {'ARITHMETIC':1, 'GEOMETRIC':1, 'CUBIC-MEAN':1}
epsilonMap = {'ARITHMETIC':1, 'GEOMETRIC':1, 'HARMONIC':1, 'HHG':1} epsilonMap = {'ARITHMETIC':1, 'GEOMETRIC':1, 'HARMONIC':1, 'HHG':1}
...@@ -2709,35 +2703,35 @@ class AmoebaVdwGenerator: ...@@ -2709,35 +2703,35 @@ class AmoebaVdwGenerator:
# sigma and epsilon combining rules # sigma and epsilon combining rules
if( 'sigmaCombiningRule' in args ): if ('sigmaCombiningRule' in args):
sigmaRule = args['sigmaCombiningRule'].upper() sigmaRule = args['sigmaCombiningRule'].upper()
if( sigmaRule.upper() in sigmaMap ): if (sigmaRule.upper() in sigmaMap):
force.setSigmaCombiningRule( sigmaRule.upper() ) force.setSigmaCombiningRule(sigmaRule.upper())
else: else:
stringList = ' ' . join( str(x) for x in sigmaMap.keys()) stringList = ' ' . join(str(x) for x in sigmaMap.keys())
print "sigma combining rule %s not recognized; valid values are %s; using default." % (sigmaRule, stringList) print "sigma combining rule %s not recognized; valid values are %s; using default." % (sigmaRule, stringList)
else: else:
force.setSigmaCombiningRule( self.radiusrule ) force.setSigmaCombiningRule(self.radiusrule)
if( 'epsilonCombiningRule' in args ): if ('epsilonCombiningRule' in args):
epsilonRule = args['epsilonCombiningRule'].upper() epsilonRule = args['epsilonCombiningRule'].upper()
if( epsilonRule.upper() in epsilonMap ): if (epsilonRule.upper() in epsilonMap):
force.setEpsilonCombiningRule( epsilonRule.upper() ) force.setEpsilonCombiningRule(epsilonRule.upper())
else: else:
stringList = ' ' . join( str(x) for x in epsilonMap.keys()) stringList = ' ' . join(str(x) for x in epsilonMap.keys())
print "epsilon combining rule %s not recognized; valid values are %s; using default." % (epsilonRule, stringList) print "epsilon combining rule %s not recognized; valid values are %s; using default." % (epsilonRule, stringList)
else: else:
force.setEpsilonCombiningRule( self.epsilonrule ) force.setEpsilonCombiningRule(self.epsilonrule)
# cutoff # cutoff
if( 'vdwCutoff' in args ): if ('vdwCutoff' in args):
force.setCutoff( float( args['vdwCutoff'] ) ) force.setCutoff(float(args['vdwCutoff']))
else: else:
force.setCutoff( nonbondedCutoff ) force.setCutoff(nonbondedCutoff)
if( nonbondedMethod == PME ): if (nonbondedMethod == PME):
force.setPBC( 1 ) force.setPBC(1)
force.setUseNeighborList( 1 ) force.setUseNeighborList(1)
else: else:
force = existing[0] force = existing[0]
...@@ -2755,16 +2749,16 @@ class AmoebaVdwGenerator: ...@@ -2755,16 +2749,16 @@ class AmoebaVdwGenerator:
# ivIndex = index of bonded partner for hydrogens; otherwise ivIndex = particle index # ivIndex = index of bonded partner for hydrogens; otherwise ivIndex = particle index
ivIndex = i ivIndex = i
mass = sys.getParticleMass( i )/unit.dalton mass = sys.getParticleMass(i)/unit.dalton
if( mass < 1.9 and len( data.atomBonds[i]) == 1 ): if (mass < 1.9 and len(data.atomBonds[i]) == 1):
bondIndex = data.atomBonds[i][0] bondIndex = data.atomBonds[i][0]
if( data.bonds[bondIndex].atom1 == i ): if (data.bonds[bondIndex].atom1 == i):
ivIndex = data.bonds[bondIndex].atom2 ivIndex = data.bonds[bondIndex].atom2
else: else:
ivIndex = data.bonds[bondIndex].atom1 ivIndex = data.bonds[bondIndex].atom1
force.addParticle( ivIndex, classIndex, values[0], values[1], values[2]) force.addParticle(ivIndex, classIndex, values[0], values[1], values[2])
if( verbose ): if (verbose):
print "Vdw %5d %5d %2d %15.7e %15.7e %15.7e" % (i, ivIndex, classIndex, values[0], values[1], values[2]) print "Vdw %5d %5d %2d %15.7e %15.7e %15.7e" % (i, ivIndex, classIndex, values[0], values[1], values[2])
else: else:
raise ValueError('No vdw type for atom %s' % (atom.name)) raise ValueError('No vdw type for atom %s' % (atom.name))
...@@ -2777,7 +2771,7 @@ class AmoebaVdwGenerator: ...@@ -2777,7 +2771,7 @@ class AmoebaVdwGenerator:
bondedParticleSets = [] bondedParticleSets = []
for i in range(len(data.atoms)): for i in range(len(data.atoms)):
bondedParticleSets.append( AmoebaVdwGenerator.getBondedParticleSet( i, data ) ) bondedParticleSets.append(AmoebaVdwGenerator.getBondedParticleSet(i, data))
for (i,atom) in enumerate(data.atoms): for (i,atom) in enumerate(data.atoms):
...@@ -2787,22 +2781,22 @@ class AmoebaVdwGenerator: ...@@ -2787,22 +2781,22 @@ class AmoebaVdwGenerator:
# 1-3 partners # 1-3 partners
if( self.vdw13Scale == 0.0 ): if (self.vdw13Scale == 0.0):
for bondedParticle in bondedParticleSets[i]: for bondedParticle in bondedParticleSets[i]:
exclusionSet = exclusionSet.union( bondedParticleSets[bondedParticle] ) exclusionSet = exclusionSet.union(bondedParticleSets[bondedParticle])
# self # self
exclusionSet.add(i) exclusionSet.add(i)
if( verbose ): if (verbose):
print "VdwExcl %5d %s || %s" % (i, str(exclusionSet), str(bondedParticleSets[i])) print "VdwExcl %5d %s || %s" % (i, str(exclusionSet), str(bondedParticleSets[i]))
for atomIndex in sorted( exclusionSet ): for atomIndex in sorted(exclusionSet):
atom = data.atoms[atomIndex] atom = data.atoms[atomIndex]
print " %5d [%s %s %d]" % (atomIndex, atom.name, atom.residue.name, atom.residue.index ) print " %5d [%s %s %d]" % (atomIndex, atom.name, atom.residue.name, atom.residue.index)
print "\n" print "\n"
force.setParticleExclusions( i, exclusionSet ) force.setParticleExclusions(i, exclusionSet)
parsers["AmoebaVdwForce"] = AmoebaVdwGenerator.parseElement parsers["AmoebaVdwForce"] = AmoebaVdwGenerator.parseElement
...@@ -2820,7 +2814,7 @@ class AmoebaMultipoleGenerator: ...@@ -2820,7 +2814,7 @@ class AmoebaMultipoleGenerator:
direct11Scale, direct12Scale, direct13Scale, direct14Scale, direct11Scale, direct12Scale, direct13Scale, direct14Scale,
mpole12Scale, mpole13Scale, mpole14Scale, mpole15Scale, mpole12Scale, mpole13Scale, mpole14Scale, mpole15Scale,
mutual11Scale, mutual12Scale, mutual13Scale, mutual14Scale, mutual11Scale, mutual12Scale, mutual13Scale, mutual14Scale,
polar12Scale, polar13Scale, polar14Scale, polar15Scale ): polar12Scale, polar13Scale, polar14Scale, polar15Scale):
self.forceField = forceField self.forceField = forceField
...@@ -2852,44 +2846,44 @@ class AmoebaMultipoleGenerator: ...@@ -2852,44 +2846,44 @@ class AmoebaMultipoleGenerator:
#============================================================================================= #=============================================================================================
@staticmethod @staticmethod
def setAxisType( kIndices ): def setAxisType(kIndices):
# set axis type # set axis type
kIndicesLen = len( kIndices ) kIndicesLen = len(kIndices)
if( kIndicesLen > 3 ): if (kIndicesLen > 3):
ky = kIndices[3] ky = kIndices[3]
else: else:
ky = 0 ky = 0
if( kIndicesLen > 2 ): if (kIndicesLen > 2):
kx = kIndices[2] kx = kIndices[2]
else: else:
kx = 0 kx = 0
if( kIndicesLen > 1 ): if (kIndicesLen > 1):
kz = kIndices[1] kz = kIndices[1]
else: else:
kz = 0 kz = 0
while( len( kIndices ) < 4 ): while(len(kIndices) < 4):
kIndices.append( 0 ) kIndices.append(0)
axisType = mm.AmoebaMultipoleForce.ZThenX axisType = mm.AmoebaMultipoleForce.ZThenX
if( kz == 0 ): if (kz == 0):
axisType = mm.AmoebaMultipoleForce.NoAxisType axisType = mm.AmoebaMultipoleForce.NoAxisType
if( kz != 0 and kx == 0 ): if (kz != 0 and kx == 0):
axisType = mm.AmoebaMultipoleForce.ZOnly axisType = mm.AmoebaMultipoleForce.ZOnly
if( kz < 0 or kx < 0 ): if (kz < 0 or kx < 0):
axisType = mm.AmoebaMultipoleForce.Bisector axisType = mm.AmoebaMultipoleForce.Bisector
if( kx < 0 and ky < 0 ): if (kx < 0 and ky < 0):
axisType = mm.AmoebaMultipoleForce.ZBisect axisType = mm.AmoebaMultipoleForce.ZBisect
if( kz < 0 and kx < 0 and ky < 0 ): if (kz < 0 and kx < 0 and ky < 0):
axisType = mm.AmoebaMultipoleForce.ThreeFold axisType = mm.AmoebaMultipoleForce.ThreeFold
kIndices[1] = abs( kz ) kIndices[1] = abs(kz)
kIndices[2] = abs( kx ) kIndices[2] = abs(kx)
kIndices[3] = abs( ky ) kIndices[3] = abs(ky)
return axisType return axisType
...@@ -2902,7 +2896,7 @@ class AmoebaMultipoleGenerator: ...@@ -2902,7 +2896,7 @@ class AmoebaMultipoleGenerator:
# <Multipole class="1" kz="2" kx="4" c0="-0.22620" d1="0.08214" d2="0.00000" d3="0.34883" q11="0.11775" q21="0.00000" q22="-1.02185" q31="-0.17555" q32="0.00000" q33="0.90410" /> # <Multipole class="1" kz="2" kx="4" c0="-0.22620" d1="0.08214" d2="0.00000" d3="0.34883" q11="0.11775" q21="0.00000" q22="-1.02185" q31="-0.17555" q32="0.00000" q33="0.90410" />
# <Multipole class="2" kz="1" kx="3" c0="-0.15245" d1="0.19517" d2="0.00000" d3="0.19687" q11="-0.20677" q21="0.00000" q22="-0.48084" q31="-0.01672" q32="0.00000" q33="0.68761" /> # <Multipole class="2" kz="1" kx="3" c0="-0.15245" d1="0.19517" d2="0.00000" d3="0.19687" q11="-0.20677" q21="0.00000" q22="-0.48084" q31="-0.01672" q32="0.00000" q33="0.68761" />
generator = AmoebaMultipoleGenerator( forceField, generator = AmoebaMultipoleGenerator(forceField,
element.attrib['direct11Scale'], element.attrib['direct11Scale'],
element.attrib['direct12Scale'], element.attrib['direct12Scale'],
element.attrib['direct13Scale'], element.attrib['direct13Scale'],
...@@ -2921,7 +2915,7 @@ class AmoebaMultipoleGenerator: ...@@ -2921,7 +2915,7 @@ class AmoebaMultipoleGenerator:
element.attrib['polar12Scale'], element.attrib['polar12Scale'],
element.attrib['polar13Scale'], element.attrib['polar13Scale'],
element.attrib['polar14Scale'], element.attrib['polar14Scale'],
element.attrib['polar15Scale'] ) element.attrib['polar15Scale'])
...@@ -2933,7 +2927,7 @@ class AmoebaMultipoleGenerator: ...@@ -2933,7 +2927,7 @@ class AmoebaMultipoleGenerator:
types = forceField._findAtomTypes(atom, 1) types = forceField._findAtomTypes(atom, 1)
if types is not None: if types is not None:
# print "Multipole Atom %s types=%s." %( atom.attrib['type'], str(types) ) # print "Multipole Atom %s types=%s." %(atom.attrib['type'], str(types))
# k-indices not provided default to 0 # k-indices not provided default to 0
...@@ -2942,14 +2936,14 @@ class AmoebaMultipoleGenerator: ...@@ -2942,14 +2936,14 @@ class AmoebaMultipoleGenerator:
kStrings = [ 'kz', 'kx', 'ky' ] kStrings = [ 'kz', 'kx', 'ky' ]
for kString in kStrings: for kString in kStrings:
try: try:
if( atom.attrib[kString] ): if (atom.attrib[kString]):
kIndices.append( int( atom.attrib[kString] )) kIndices.append(int(atom.attrib[kString]))
except: except:
pass pass
# set axis type based on k-Indices # set axis type based on k-Indices
axisType = AmoebaMultipoleGenerator.setAxisType( kIndices ) axisType = AmoebaMultipoleGenerator.setAxisType(kIndices)
# set multipole # set multipole
...@@ -2959,18 +2953,18 @@ class AmoebaMultipoleGenerator: ...@@ -2959,18 +2953,18 @@ class AmoebaMultipoleGenerator:
dipole = [ conversion*float(atom.attrib['d1']), conversion*float(atom.attrib['d2']), conversion*float(atom.attrib['d3'])] dipole = [ conversion*float(atom.attrib['d1']), conversion*float(atom.attrib['d2']), conversion*float(atom.attrib['d3'])]
quadrupole = [] quadrupole = []
quadrupole.append( conversion*float(atom.attrib['q11'])) quadrupole.append(conversion*float(atom.attrib['q11']))
quadrupole.append( conversion*float(atom.attrib['q21'])) quadrupole.append(conversion*float(atom.attrib['q21']))
quadrupole.append( conversion*float(atom.attrib['q31'])) quadrupole.append(conversion*float(atom.attrib['q31']))
quadrupole.append( conversion*float(atom.attrib['q21'])) quadrupole.append(conversion*float(atom.attrib['q21']))
quadrupole.append( conversion*float(atom.attrib['q22'])) quadrupole.append(conversion*float(atom.attrib['q22']))
quadrupole.append( conversion*float(atom.attrib['q32'])) quadrupole.append(conversion*float(atom.attrib['q32']))
quadrupole.append( conversion*float(atom.attrib['q31'])) quadrupole.append(conversion*float(atom.attrib['q31']))
quadrupole.append( conversion*float(atom.attrib['q32'])) quadrupole.append(conversion*float(atom.attrib['q32']))
quadrupole.append( conversion*float(atom.attrib['q33'])) quadrupole.append(conversion*float(atom.attrib['q33']))
for t in types[0]: for t in types[0]:
if( t not in generator.typeMap ): if (t not in generator.typeMap):
generator.typeMap[t] = [] generator.typeMap[t] = []
valueMap = dict() valueMap = dict()
...@@ -2980,11 +2974,11 @@ class AmoebaMultipoleGenerator: ...@@ -2980,11 +2974,11 @@ class AmoebaMultipoleGenerator:
valueMap['dipole'] = dipole valueMap['dipole'] = dipole
valueMap['quadrupole'] = quadrupole valueMap['quadrupole'] = quadrupole
valueMap['axisType'] = axisType valueMap['axisType'] = axisType
generator.typeMap[t].append( valueMap ) generator.typeMap[t].append(valueMap)
else: else:
outputString = "AmoebaMultipoleGenerator: error getting type for multipole: %s" % ( atom.attrib['class'] ) outputString = "AmoebaMultipoleGenerator: error getting type for multipole: %s" % (atom.attrib['class'])
raise ValueError( outputString ) raise ValueError(outputString)
# polarization parameters # polarization parameters
...@@ -2993,48 +2987,48 @@ class AmoebaMultipoleGenerator: ...@@ -2993,48 +2987,48 @@ class AmoebaMultipoleGenerator:
if types is not None: if types is not None:
classIndex = atom.attrib['type'] classIndex = atom.attrib['type']
polarizability = float( atom.attrib['polarizability'] ) polarizability = float(atom.attrib['polarizability'])
thole = float( atom.attrib['thole'] ) thole = float(atom.attrib['thole'])
if( thole == 0 ): if (thole == 0):
pdamp = 0 pdamp = 0
else: else:
pdamp = pow( polarizability, 1.0/6.0 ) pdamp = pow(polarizability, 1.0/6.0)
pgrpMap = dict() pgrpMap = dict()
for index in range( 1, 7): for index in range(1, 7):
pgrp = 'pgrp' + str(index) pgrp = 'pgrp' + str(index)
if( pgrp in atom.attrib ): if (pgrp in atom.attrib):
pgrpMap[int(atom.attrib[pgrp])] = -1 pgrpMap[int(atom.attrib[pgrp])] = -1
for t in types[0]: for t in types[0]:
if( t not in generator.typeMap ): if (t not in generator.typeMap):
outputString = "AmoebaMultipoleGenerator: polarize type not present: %s" % ( atom.attrib['type'] ) outputString = "AmoebaMultipoleGenerator: polarize type not present: %s" % (atom.attrib['type'])
raise ValueError( outputString ) raise ValueError(outputString)
else: else:
typeMapList = generator.typeMap[t] typeMapList = generator.typeMap[t]
hit = 0 hit = 0
for (ii, typeMap ) in enumerate(typeMapList): for (ii, typeMap) in enumerate(typeMapList):
if( typeMap['classIndex'] == classIndex ): if (typeMap['classIndex'] == classIndex):
typeMap['polarizability'] = polarizability typeMap['polarizability'] = polarizability
typeMap['thole'] = thole typeMap['thole'] = thole
typeMap['pdamp'] = pdamp typeMap['pdamp'] = pdamp
typeMap['pgrpMap'] = pgrpMap typeMap['pgrpMap'] = pgrpMap
typeMapList[ii] = typeMap typeMapList[ii] = typeMap
hit = 1 hit = 1
#print "Adding polarize for %s map=%d len=%d keys=%s" % ( classIndex, ii, len( typeMapList), str( typeMap.keys() ) ) #print "Adding polarize for %s map=%d len=%d keys=%s" % (classIndex, ii, len(typeMapList), str(typeMap.keys()))
if( hit == 0 ): if (hit == 0):
outputString = "AmoebaMultipoleGenerator: error getting type for polarize: class index=%s not in multipole list?" % ( atom.attrib['class'] ) outputString = "AmoebaMultipoleGenerator: error getting type for polarize: class index=%s not in multipole list?" % (atom.attrib['class'])
raise ValueError( outputString ) raise ValueError(outputString)
else: else:
outputString = "AmoebaMultipoleGenerator: error getting type for polarize: %s" % ( atom.attrib['class'] ) outputString = "AmoebaMultipoleGenerator: error getting type for polarize: %s" % (atom.attrib['class'])
raise ValueError( outputString ) raise ValueError(outputString)
#============================================================================================= #=============================================================================================
def setPolarGroups(self, data, bonded12ParticleSets, force ): def setPolarGroups(self, data, bonded12ParticleSets, force):
for (atomIndex, atom) in enumerate(data.atoms): for (atomIndex, atom) in enumerate(data.atoms):
...@@ -3049,7 +3043,7 @@ class AmoebaMultipoleGenerator: ...@@ -3049,7 +3043,7 @@ class AmoebaMultipoleGenerator:
for bondedAtomIndex in bondedAtomIndices: for bondedAtomIndex in bondedAtomIndices:
bondedAtomType = int(data.atomType[data.atoms[bondedAtomIndex]]) bondedAtomType = int(data.atomType[data.atoms[bondedAtomIndex]])
bondedAtom = data.atoms[bondedAtomIndex] bondedAtom = data.atoms[bondedAtomIndex]
if( bondedAtomType in pgrpMap ): if (bondedAtomType in pgrpMap):
atom.polarizationGroups[bondedAtomIndex] = 1 atom.polarizationGroups[bondedAtomIndex] = 1
bondedAtom.polarizationGroups[atomIndex] = 1 bondedAtom.polarizationGroups[atomIndex] = 1
...@@ -3057,106 +3051,106 @@ class AmoebaMultipoleGenerator: ...@@ -3057,106 +3051,106 @@ class AmoebaMultipoleGenerator:
for (atomIndex, atom) in enumerate(data.atoms): for (atomIndex, atom) in enumerate(data.atoms):
if( len( data.atoms[atomIndex].polarizationGroupSet ) > 0 ): if (len( data.atoms[atomIndex].polarizationGroupSet) > 0):
continue continue
group = set() group = set()
visited = set() visited = set()
notVisited = set() notVisited = set()
for pgrpAtomIndex in atom.polarizationGroups: for pgrpAtomIndex in atom.polarizationGroups:
group.add( pgrpAtomIndex ) group.add(pgrpAtomIndex)
notVisited.add( pgrpAtomIndex ) notVisited.add(pgrpAtomIndex)
visited.add( atomIndex ) visited.add(atomIndex)
while( len( notVisited ) > 0 ): while(len(notVisited) > 0):
nextAtom = notVisited.pop() nextAtom = notVisited.pop()
if( nextAtom not in visited ): if (nextAtom not in visited):
visited.add( nextAtom ) visited.add(nextAtom)
for ii in data.atoms[nextAtom].polarizationGroups: for ii in data.atoms[nextAtom].polarizationGroups:
group.add( ii ) group.add(ii)
if( ii not in visited ): if (ii not in visited):
notVisited.add( ii ) notVisited.add(ii)
pGroup = group pGroup = group
for pgrpAtomIndex in group: for pgrpAtomIndex in group:
data.atoms[pgrpAtomIndex].polarizationGroupSet.append( pGroup ) data.atoms[pgrpAtomIndex].polarizationGroupSet.append(pGroup)
for (atomIndex, atom) in enumerate(data.atoms): for (atomIndex, atom) in enumerate(data.atoms):
atom.polarizationGroupSet[0] = sorted( atom.polarizationGroupSet[0] ) atom.polarizationGroupSet[0] = sorted(atom.polarizationGroupSet[0])
force.setCovalentMap( atomIndex, mm.AmoebaMultipoleForce.PolarizationCovalent11, atom.polarizationGroupSet[0] ) force.setCovalentMap(atomIndex, mm.AmoebaMultipoleForce.PolarizationCovalent11, atom.polarizationGroupSet[0])
# pgrp12 # pgrp12
for (atomIndex, atom) in enumerate(data.atoms): for (atomIndex, atom) in enumerate(data.atoms):
if( len( data.atoms[atomIndex].polarizationGroupSet ) > 1 ): if (len( data.atoms[atomIndex].polarizationGroupSet) > 1):
continue continue
pgrp11 = set( atom.polarizationGroupSet[0] ) pgrp11 = set(atom.polarizationGroupSet[0])
pgrp12 = set() pgrp12 = set()
for pgrpAtomIndex in pgrp11: for pgrpAtomIndex in pgrp11:
for bonded12 in bonded12ParticleSets[pgrpAtomIndex]: for bonded12 in bonded12ParticleSets[pgrpAtomIndex]:
pgrp12 = pgrp12.union( data.atoms[bonded12].polarizationGroupSet[0] ) pgrp12 = pgrp12.union(data.atoms[bonded12].polarizationGroupSet[0])
pgrp12 = pgrp12 - pgrp11 pgrp12 = pgrp12 - pgrp11
for pgrpAtomIndex in pgrp11: for pgrpAtomIndex in pgrp11:
data.atoms[pgrpAtomIndex].polarizationGroupSet.append( pgrp12 ) data.atoms[pgrpAtomIndex].polarizationGroupSet.append(pgrp12)
for (atomIndex, atom) in enumerate(data.atoms): for (atomIndex, atom) in enumerate(data.atoms):
atom.polarizationGroupSet[1] = sorted( atom.polarizationGroupSet[1] ) atom.polarizationGroupSet[1] = sorted(atom.polarizationGroupSet[1])
force.setCovalentMap( atomIndex, mm.AmoebaMultipoleForce.PolarizationCovalent12, atom.polarizationGroupSet[1] ) force.setCovalentMap(atomIndex, mm.AmoebaMultipoleForce.PolarizationCovalent12, atom.polarizationGroupSet[1])
# pgrp13 # pgrp13
for (atomIndex, atom) in enumerate(data.atoms): for (atomIndex, atom) in enumerate(data.atoms):
if( len( data.atoms[atomIndex].polarizationGroupSet ) > 2 ): if (len(data.atoms[atomIndex].polarizationGroupSet) > 2):
continue continue
pgrp11 = set( atom.polarizationGroupSet[0] ) pgrp11 = set(atom.polarizationGroupSet[0])
pgrp12 = set( atom.polarizationGroupSet[1] ) pgrp12 = set(atom.polarizationGroupSet[1])
pgrp13 = set() pgrp13 = set()
for pgrpAtomIndex in pgrp12: for pgrpAtomIndex in pgrp12:
for bonded12 in bonded12ParticleSets[pgrpAtomIndex]: for bonded12 in bonded12ParticleSets[pgrpAtomIndex]:
pgrp13 = pgrp13.union( data.atoms[bonded12].polarizationGroupSet[0] ) pgrp13 = pgrp13.union(data.atoms[bonded12].polarizationGroupSet[0])
pgrp13 = pgrp13 - pgrp12 pgrp13 = pgrp13 - pgrp12
pgrp13 = pgrp13 - set( pgrp11 ) pgrp13 = pgrp13 - set(pgrp11)
for pgrpAtomIndex in pgrp11: for pgrpAtomIndex in pgrp11:
data.atoms[pgrpAtomIndex].polarizationGroupSet.append( pgrp13 ) data.atoms[pgrpAtomIndex].polarizationGroupSet.append(pgrp13)
for (atomIndex, atom) in enumerate(data.atoms): for (atomIndex, atom) in enumerate(data.atoms):
atom.polarizationGroupSet[2] = sorted( atom.polarizationGroupSet[2] ) atom.polarizationGroupSet[2] = sorted(atom.polarizationGroupSet[2])
force.setCovalentMap( atomIndex, mm.AmoebaMultipoleForce.PolarizationCovalent13, atom.polarizationGroupSet[2] ) force.setCovalentMap(atomIndex, mm.AmoebaMultipoleForce.PolarizationCovalent13, atom.polarizationGroupSet[2])
# pgrp14 # pgrp14
for (atomIndex, atom) in enumerate(data.atoms): for (atomIndex, atom) in enumerate(data.atoms):
if( len( data.atoms[atomIndex].polarizationGroupSet ) > 3 ): if (len(data.atoms[atomIndex].polarizationGroupSet) > 3):
continue continue
pgrp11 = set( atom.polarizationGroupSet[0] ) pgrp11 = set(atom.polarizationGroupSet[0])
pgrp12 = set( atom.polarizationGroupSet[1] ) pgrp12 = set(atom.polarizationGroupSet[1])
pgrp13 = set( atom.polarizationGroupSet[2] ) pgrp13 = set(atom.polarizationGroupSet[2])
pgrp14 = set() pgrp14 = set()
for pgrpAtomIndex in pgrp13: for pgrpAtomIndex in pgrp13:
for bonded12 in bonded12ParticleSets[pgrpAtomIndex]: for bonded12 in bonded12ParticleSets[pgrpAtomIndex]:
pgrp14 = pgrp14.union( data.atoms[bonded12].polarizationGroupSet[0] ) pgrp14 = pgrp14.union(data.atoms[bonded12].polarizationGroupSet[0])
pgrp14 = pgrp14 - pgrp13 pgrp14 = pgrp14 - pgrp13
pgrp14 = pgrp14 - pgrp12 pgrp14 = pgrp14 - pgrp12
pgrp14 = pgrp14 - set( pgrp11 ) pgrp14 = pgrp14 - set(pgrp11)
for pgrpAtomIndex in pgrp11: for pgrpAtomIndex in pgrp11:
data.atoms[pgrpAtomIndex].polarizationGroupSet.append( pgrp14 ) data.atoms[pgrpAtomIndex].polarizationGroupSet.append(pgrp14)
for (atomIndex, atom) in enumerate(data.atoms): for (atomIndex, atom) in enumerate(data.atoms):
atom.polarizationGroupSet[3] = sorted( atom.polarizationGroupSet[3] ) atom.polarizationGroupSet[3] = sorted(atom.polarizationGroupSet[3])
force.setCovalentMap( atomIndex, mm.AmoebaMultipoleForce.PolarizationCovalent14, atom.polarizationGroupSet[3] ) force.setCovalentMap(atomIndex, mm.AmoebaMultipoleForce.PolarizationCovalent14, atom.polarizationGroupSet[3])
#============================================================================================= #=============================================================================================
def createForce(self, sys, data, nonbondedMethod, nonbondedCutoff, args ): def createForce(self, sys, data, nonbondedMethod, nonbondedCutoff, args):
if( self.hasBeenCalled ): if (self.hasBeenCalled ):
return return
self.hasBeenCalled = 1 self.hasBeenCalled = 1
...@@ -3171,60 +3165,38 @@ class AmoebaMultipoleGenerator: ...@@ -3171,60 +3165,38 @@ class AmoebaMultipoleGenerator:
if len(existing) == 0: if len(existing) == 0:
force = mm.AmoebaMultipoleForce() force = mm.AmoebaMultipoleForce()
sys.addForce(force) sys.addForce(force)
if( nonbondedMethod not in methodMap ): if (nonbondedMethod not in methodMap):
print "Warning: AmoebaMultipoleForce: cutoff method not available using NoCutoff." print "Warning: AmoebaMultipoleForce: cutoff method not available using NoCutoff."
force.setNonbondedMethod( mm.AmoebaMultipoleForce.NoCutoff ) force.setNonbondedMethod(mm.AmoebaMultipoleForce.NoCutoff)
else: else:
force.setNonbondedMethod( methodMap[nonbondedMethod] ) force.setNonbondedMethod(methodMap[nonbondedMethod])
force.setCutoffDistance(nonbondedCutoff) force.setCutoffDistance(nonbondedCutoff)
if( 'ewaldErrorTolerance' in args ): if ('ewaldErrorTolerance' in args):
force.setEwaldErrorTolerance(float(args['ewaldErrorTolerance'])) force.setEwaldErrorTolerance(float(args['ewaldErrorTolerance']))
if( 'polarization' in args ): if ('polarization' in args):
polarizationType = args['polarization'] polarizationType = args['polarization']
if( polarizationType.lower() == 'direct' ): if (polarizationType.lower() == 'direct'):
force.setPolarizationType(mm.AmoebaMultipoleForce.Direct) force.setPolarizationType(mm.AmoebaMultipoleForce.Direct)
else: else:
force.setPolarizationType(mm.AmoebaMultipoleForce.Mutual) force.setPolarizationType(mm.AmoebaMultipoleForce.Mutual)
if( 'aEwald' in args ): if ('aEwald' in args):
force.setAEwald( float(args['aEwald'])) force.setAEwald(float(args['aEwald']))
if( 'pmeGridDimensions' in args ): if ('pmeGridDimensions' in args):
force.setPmeGridDimensions(args['pmeGridDimensions']) force.setPmeGridDimensions(args['pmeGridDimensions'])
if( 'mutualInducedMaxIterations' in args ): if ('mutualInducedMaxIterations' in args):
force.setMutualInducedMaxIterations( int( args['mutualInducedMaxIterations'] )) force.setMutualInducedMaxIterations(int(args['mutualInducedMaxIterations']))
if( 'mutualInducedTargetEpsilon' in args ): if ('mutualInducedTargetEpsilon' in args):
force.setMutualInducedTargetEpsilon(float(args['mutualInducedTargetEpsilon'])) force.setMutualInducedTargetEpsilon(float(args['mutualInducedTargetEpsilon']))
else: else:
force = existing[0] force = existing[0]
# OpenMM interface call
# /**
# * Add multipole-related info for a particle
# *
# * @param charge the particle's charge
# * @param molecularDipole the particle's molecular dipole (vector of size 3)
# * @param molecularQuadrupole the particle's molecular quadrupole (vector of size 9)
# * @param axisType the particle's axis type ( ZThenX, Bisector )
# * @param multipoleAtomZ index of first atom used in constructing lab<->molecular frames
# * @param multipoleAtomX index of second atom used in constructing lab<->molecular frames
# * @param multipoleAtomY index of second atom used in constructing lab<->molecular frames
# * @param thole Thole parameter
# * @param dampingFactor dampingFactor parameter
# * @param polarity polarity parameter
# *
# * @return the index of the particle that was added
# */
# int addParticle( double charge, const std::vector<double>& molecularDipole, const std::vector<double>& molecularQuadrupole, int axisType,
# int multipoleAtomZ, int multipoleAtomX, int multipoleAtomY, double thole, double dampingFactor, double polarity )
#
# add particles to force # add particles to force
# throw error if particle type not available # throw error if particle type not available
...@@ -3234,9 +3206,9 @@ class AmoebaMultipoleGenerator: ...@@ -3234,9 +3206,9 @@ class AmoebaMultipoleGenerator:
bonded12ParticleSets = [] bonded12ParticleSets = []
for i in range(len(data.atoms)): for i in range(len(data.atoms)):
bonded12ParticleSet = AmoebaVdwGenerator.getBondedParticleSet( i, data ) bonded12ParticleSet = AmoebaVdwGenerator.getBondedParticleSet(i, data)
bonded12ParticleSet = set( sorted( bonded12ParticleSet ) ) bonded12ParticleSet = set(sorted(bonded12ParticleSet))
bonded12ParticleSets.append( bonded12ParticleSet ) bonded12ParticleSets.append(bonded12ParticleSet)
# 1-3 # 1-3
...@@ -3245,7 +3217,7 @@ class AmoebaMultipoleGenerator: ...@@ -3245,7 +3217,7 @@ class AmoebaMultipoleGenerator:
bonded13Set = set() bonded13Set = set()
bonded12ParticleSet = bonded12ParticleSets[i] bonded12ParticleSet = bonded12ParticleSets[i]
for j in bonded12ParticleSet: for j in bonded12ParticleSet:
bonded13Set = bonded13Set.union( bonded12ParticleSets[j] ) bonded13Set = bonded13Set.union(bonded12ParticleSets[j])
# remove 1-2 and self from set # remove 1-2 and self from set
...@@ -3253,8 +3225,8 @@ class AmoebaMultipoleGenerator: ...@@ -3253,8 +3225,8 @@ class AmoebaMultipoleGenerator:
selfSet = set() selfSet = set()
selfSet.add(i) selfSet.add(i)
bonded13Set = bonded13Set - selfSet bonded13Set = bonded13Set - selfSet
bonded13Set = set( sorted( bonded13Set ) ) bonded13Set = set(sorted(bonded13Set))
bonded13ParticleSets.append( bonded13Set ) bonded13ParticleSets.append(bonded13Set)
# 1-4 # 1-4
...@@ -3263,7 +3235,7 @@ class AmoebaMultipoleGenerator: ...@@ -3263,7 +3235,7 @@ class AmoebaMultipoleGenerator:
bonded14Set = set() bonded14Set = set()
bonded13ParticleSet = bonded13ParticleSets[i] bonded13ParticleSet = bonded13ParticleSets[i]
for j in bonded13ParticleSet: for j in bonded13ParticleSet:
bonded14Set = bonded14Set.union( bonded12ParticleSets[j] ) bonded14Set = bonded14Set.union(bonded12ParticleSets[j])
# remove 1-3, 1-2 and self from set # remove 1-3, 1-2 and self from set
...@@ -3272,8 +3244,8 @@ class AmoebaMultipoleGenerator: ...@@ -3272,8 +3244,8 @@ class AmoebaMultipoleGenerator:
selfSet = set() selfSet = set()
selfSet.add(i) selfSet.add(i)
bonded14Set = bonded14Set - selfSet bonded14Set = bonded14Set - selfSet
bonded14Set = set( sorted( bonded14Set ) ) bonded14Set = set(sorted(bonded14Set))
bonded14ParticleSets.append( bonded14Set ) bonded14ParticleSets.append(bonded14Set)
# 1-5 # 1-5
...@@ -3282,7 +3254,7 @@ class AmoebaMultipoleGenerator: ...@@ -3282,7 +3254,7 @@ class AmoebaMultipoleGenerator:
bonded15Set = set() bonded15Set = set()
bonded14ParticleSet = bonded14ParticleSets[i] bonded14ParticleSet = bonded14ParticleSets[i]
for j in bonded14ParticleSet: for j in bonded14ParticleSet:
bonded15Set = bonded15Set.union( bonded12ParticleSets[j] ) bonded15Set = bonded15Set.union(bonded12ParticleSets[j])
# remove 1-4, 1-3, 1-2 and self from set # remove 1-4, 1-3, 1-2 and self from set
...@@ -3292,8 +3264,8 @@ class AmoebaMultipoleGenerator: ...@@ -3292,8 +3264,8 @@ class AmoebaMultipoleGenerator:
selfSet = set() selfSet = set()
selfSet.add(i) selfSet.add(i)
bonded15Set = bonded15Set - selfSet bonded15Set = bonded15Set - selfSet
bonded15Set = set( sorted( bonded15Set ) ) bonded15Set = set(sorted(bonded15Set))
bonded15ParticleSets.append( bonded15Set ) bonded15ParticleSets.append(bonded15Set)
for (atomIndex, atom) in enumerate(data.atoms): for (atomIndex, atom) in enumerate(data.atoms):
t = data.atomType[atom] t = data.atomType[atom]
...@@ -3307,7 +3279,7 @@ class AmoebaMultipoleGenerator: ...@@ -3307,7 +3279,7 @@ class AmoebaMultipoleGenerator:
for multipoleDict in multipoleList: for multipoleDict in multipoleList:
if( hit != 0 ): if (hit != 0):
break break
kIndices = multipoleDict['kIndices'] kIndices = multipoleDict['kIndices']
...@@ -3316,8 +3288,6 @@ class AmoebaMultipoleGenerator: ...@@ -3316,8 +3288,6 @@ class AmoebaMultipoleGenerator:
kx = kIndices[2] kx = kIndices[2]
ky = kIndices[3] ky = kIndices[3]
#print "Atom %s of %s %d k: %d %d %d keys=%s." %( atom.name, atom.residue.name, atom.residue.index, kz, kx, ky, sorted( multipoleDict.keys() ) )
# assign multipole parameters # assign multipole parameters
# (1) get bonded partners # (1) get bonded partners
# (2) match parameter types # (2) match parameter types
...@@ -3328,28 +3298,28 @@ class AmoebaMultipoleGenerator: ...@@ -3328,28 +3298,28 @@ class AmoebaMultipoleGenerator:
yaxis = -1 yaxis = -1
for bondedAtomZIndex in bondedAtomIndices: for bondedAtomZIndex in bondedAtomIndices:
if( hit != 0 ): if (hit != 0):
break break
bondedAtomZType = int(data.atomType[data.atoms[bondedAtomZIndex]]) bondedAtomZType = int(data.atomType[data.atoms[bondedAtomZIndex]])
bondedAtomZ = data.atoms[bondedAtomZIndex] bondedAtomZ = data.atoms[bondedAtomZIndex]
if( bondedAtomZType == kz ): if (bondedAtomZType == kz):
for bondedAtomXIndex in bondedAtomIndices: for bondedAtomXIndex in bondedAtomIndices:
if( bondedAtomXIndex == bondedAtomZIndex or hit != 0 ): if (bondedAtomXIndex == bondedAtomZIndex or hit != 0):
continue continue
bondedAtomXType = int(data.atomType[data.atoms[bondedAtomXIndex]]) bondedAtomXType = int(data.atomType[data.atoms[bondedAtomXIndex]])
if( bondedAtomXType == kx ): if (bondedAtomXType == kx):
if( ky == 0 ): if (ky == 0):
zaxis = bondedAtomZIndex zaxis = bondedAtomZIndex
xaxis = bondedAtomXIndex xaxis = bondedAtomXIndex
savedMultipoleDict = multipoleDict savedMultipoleDict = multipoleDict
hit = 1 hit = 1
else: else:
for bondedAtomYIndex in bondedAtomIndices: for bondedAtomYIndex in bondedAtomIndices:
if( bondedAtomYIndex == bondedAtomZIndex or bondedAtomYIndex == bondedAtomXIndex or hit != 0 ): if (bondedAtomYIndex == bondedAtomZIndex or bondedAtomYIndex == bondedAtomXIndex or hit != 0):
continue continue
bondedAtomYType = int(data.atomType[data.atoms[bondedAtomYIndex]]) bondedAtomYType = int(data.atomType[data.atoms[bondedAtomYIndex]])
if( bondedAtomYType == ky ): if (bondedAtomYType == ky):
zaxis = bondedAtomZIndex zaxis = bondedAtomZIndex
xaxis = bondedAtomXIndex xaxis = bondedAtomXIndex
yaxis = bondedAtomYIndex yaxis = bondedAtomYIndex
...@@ -3360,7 +3330,7 @@ class AmoebaMultipoleGenerator: ...@@ -3360,7 +3330,7 @@ class AmoebaMultipoleGenerator:
for multipoleDict in multipoleList: for multipoleDict in multipoleList:
if( hit != 0 ): if (hit != 0):
break break
kIndices = multipoleDict['kIndices'] kIndices = multipoleDict['kIndices']
...@@ -3369,8 +3339,6 @@ class AmoebaMultipoleGenerator: ...@@ -3369,8 +3339,6 @@ class AmoebaMultipoleGenerator:
kx = kIndices[2] kx = kIndices[2]
ky = kIndices[3] ky = kIndices[3]
#print "Atom %s of %s %d k: %d %d %d keys=%s." %( atom.name, atom.residue.name, atom.residue.index, kz, kx, ky, sorted( multipoleDict.keys() ) )
# assign multipole parameters # assign multipole parameters
# (1) get bonded partners # (1) get bonded partners
# (2) match parameter types # (2) match parameter types
...@@ -3384,30 +3352,30 @@ class AmoebaMultipoleGenerator: ...@@ -3384,30 +3352,30 @@ class AmoebaMultipoleGenerator:
for bondedAtomZIndex in bondedAtom12Indices: for bondedAtomZIndex in bondedAtom12Indices:
if( hit != 0 ): if (hit != 0):
break break
bondedAtomZType = int(data.atomType[data.atoms[bondedAtomZIndex]]) bondedAtomZType = int(data.atomType[data.atoms[bondedAtomZIndex]])
bondedAtomZ = data.atoms[bondedAtomZIndex] bondedAtomZ = data.atoms[bondedAtomZIndex]
if( bondedAtomZType == kz ): if (bondedAtomZType == kz):
for bondedAtomXIndex in bondedAtom13Indices: for bondedAtomXIndex in bondedAtom13Indices:
if( bondedAtomXIndex == bondedAtomZIndex or hit != 0 ): if (bondedAtomXIndex == bondedAtomZIndex or hit != 0):
continue continue
bondedAtomXType = int(data.atomType[data.atoms[bondedAtomXIndex]]) bondedAtomXType = int(data.atomType[data.atoms[bondedAtomXIndex]])
if( bondedAtomXType == kx and bondedAtomZIndex in bonded12ParticleSets[bondedAtomXIndex] ): if (bondedAtomXType == kx and bondedAtomZIndex in bonded12ParticleSets[bondedAtomXIndex]):
if( ky == 0 ): if (ky == 0):
zaxis = bondedAtomZIndex zaxis = bondedAtomZIndex
xaxis = bondedAtomXIndex xaxis = bondedAtomXIndex
savedMultipoleDict = multipoleDict savedMultipoleDict = multipoleDict
hit = 3 hit = 3
else: else:
for bondedAtomYIndex in bondedAtom13Indices: for bondedAtomYIndex in bondedAtom13Indices:
if( bondedAtomYIndex == bondedAtomZIndex or bondedAtomYIndex == bondedAtomXIndex or hit != 0 ): if (bondedAtomYIndex == bondedAtomZIndex or bondedAtomYIndex == bondedAtomXIndex or hit != 0):
continue continue
bondedAtomYType = int(data.atomType[data.atoms[bondedAtomYIndex]]) bondedAtomYType = int(data.atomType[data.atoms[bondedAtomYIndex]])
if( bondedAtomYType == ky and bondedAtomZIndex in bonded12ParticleSets[bondedAtomYIndex]): if (bondedAtomYType == ky and bondedAtomZIndex in bonded12ParticleSets[bondedAtomYIndex]):
zaxis = bondedAtomZIndex zaxis = bondedAtomZIndex
xaxis = bondedAtomXIndex xaxis = bondedAtomXIndex
yaxis = bondedAtomYIndex yaxis = bondedAtomYIndex
...@@ -3418,7 +3386,7 @@ class AmoebaMultipoleGenerator: ...@@ -3418,7 +3386,7 @@ class AmoebaMultipoleGenerator:
for multipoleDict in multipoleList: for multipoleDict in multipoleList:
if( hit != 0 ): if (hit != 0):
break break
kIndices = multipoleDict['kIndices'] kIndices = multipoleDict['kIndices']
...@@ -3432,13 +3400,13 @@ class AmoebaMultipoleGenerator: ...@@ -3432,13 +3400,13 @@ class AmoebaMultipoleGenerator:
for bondedAtomZIndex in bondedAtom12Indices: for bondedAtomZIndex in bondedAtom12Indices:
if( hit != 0 ): if (hit != 0):
break break
bondedAtomZType = int(data.atomType[data.atoms[bondedAtomZIndex]]) bondedAtomZType = int(data.atomType[data.atoms[bondedAtomZIndex]])
bondedAtomZ = data.atoms[bondedAtomZIndex] bondedAtomZ = data.atoms[bondedAtomZIndex]
if( kx == 0 and kz == bondedAtomZType ): if (kx == 0 and kz == bondedAtomZType):
kz = bondedAtomZIndex kz = bondedAtomZIndex
savedMultipoleDict = multipoleDict savedMultipoleDict = multipoleDict
hit = 5 hit = 5
...@@ -3447,7 +3415,7 @@ class AmoebaMultipoleGenerator: ...@@ -3447,7 +3415,7 @@ class AmoebaMultipoleGenerator:
for multipoleDict in multipoleList: for multipoleDict in multipoleList:
if( hit != 0 ): if (hit != 0):
break break
kIndices = multipoleDict['kIndices'] kIndices = multipoleDict['kIndices']
...@@ -3458,36 +3426,36 @@ class AmoebaMultipoleGenerator: ...@@ -3458,36 +3426,36 @@ class AmoebaMultipoleGenerator:
xaxis = -1 xaxis = -1
yaxis = -1 yaxis = -1
if( kz == 0 ): if (kz == 0):
savedMultipoleDict = multipoleDict savedMultipoleDict = multipoleDict
hit = 6 hit = 6
# add particle if there was a hit # add particle if there was a hit
if( hit != 0 ): if (hit != 0):
if( verbose ): if (verbose):
print "Multipole hit for Atom %5d %4s of %4s %4d type=%5s hitBranch=%d axes: %4d %4d %4d axisType=%1d." % ( atomIndex, print "Multipole hit for Atom %5d %4s of %4s %4d type=%5s hitBranch=%d axes: %4d %4d %4d axisType=%1d." % (atomIndex,
atom.name, atom.residue.name, atom.residue.index, t, hit, zaxis, xaxis, yaxis, savedMultipoleDict['axisType'] ) atom.name, atom.residue.name, atom.residue.index, t, hit, zaxis, xaxis, yaxis, savedMultipoleDict['axisType'])
atom.multipoleDict = savedMultipoleDict atom.multipoleDict = savedMultipoleDict
atom.polarizationGroups = dict() atom.polarizationGroups = dict()
newIndex = force.addParticle( savedMultipoleDict['charge'], savedMultipoleDict['dipole'], savedMultipoleDict['quadrupole'], savedMultipoleDict['axisType'], newIndex = force.addParticle(savedMultipoleDict['charge'], savedMultipoleDict['dipole'], savedMultipoleDict['quadrupole'], savedMultipoleDict['axisType'],
zaxis, xaxis, yaxis, savedMultipoleDict['thole'], savedMultipoleDict['pdamp'], savedMultipoleDict['polarizability']) zaxis, xaxis, yaxis, savedMultipoleDict['thole'], savedMultipoleDict['pdamp'], savedMultipoleDict['polarizability'])
if( atomIndex == newIndex ): if (atomIndex == newIndex):
force.setCovalentMap( atomIndex, mm.AmoebaMultipoleForce.Covalent12, bonded12ParticleSets[atomIndex] ) force.setCovalentMap(atomIndex, mm.AmoebaMultipoleForce.Covalent12, bonded12ParticleSets[atomIndex])
force.setCovalentMap( atomIndex, mm.AmoebaMultipoleForce.Covalent13, bonded13ParticleSets[atomIndex] ) force.setCovalentMap(atomIndex, mm.AmoebaMultipoleForce.Covalent13, bonded13ParticleSets[atomIndex])
force.setCovalentMap( atomIndex, mm.AmoebaMultipoleForce.Covalent14, bonded14ParticleSets[atomIndex] ) force.setCovalentMap(atomIndex, mm.AmoebaMultipoleForce.Covalent14, bonded14ParticleSets[atomIndex])
force.setCovalentMap( atomIndex, mm.AmoebaMultipoleForce.Covalent15, bonded15ParticleSets[atomIndex] ) force.setCovalentMap(atomIndex, mm.AmoebaMultipoleForce.Covalent15, bonded15ParticleSets[atomIndex])
else: else:
raise ValueError("Atom %s of %s %d is out of synch!." %( atom.name, atom.residue.name, atom.residue.index ) ) raise ValueError("Atom %s of %s %d is out of synch!." %(atom.name, atom.residue.name, atom.residue.index))
else: else:
raise ValueError("Atom %s of %s %d was not assigned." %( atom.name, atom.residue.name, atom.residue.index ) ) raise ValueError("Atom %s of %s %d was not assigned." %(atom.name, atom.residue.name, atom.residue.index))
else: else:
raise ValueError('No multipole type for atom %s %s %d' % ( atom.name, atom.residue.name, atom.residue.index ) ) raise ValueError('No multipole type for atom %s %s %d' % (atom.name, atom.residue.name, atom.residue.index))
# set polar groups # set polar groups
self.setPolarGroups( data, bonded12ParticleSets, force ) self.setPolarGroups(data, bonded12ParticleSets, force)
parsers["AmoebaMultipoleForce"] = AmoebaMultipoleGenerator.parseElement parsers["AmoebaMultipoleForce"] = AmoebaMultipoleGenerator.parseElement
...@@ -3499,7 +3467,7 @@ class AmoebaWcaDispersionGenerator: ...@@ -3499,7 +3467,7 @@ class AmoebaWcaDispersionGenerator:
#========================================================================================= #=========================================================================================
def __init__(self, epso, epsh, rmino, rminh, awater, slevy, dispoff, shctd ): def __init__(self, epso, epsh, rmino, rminh, awater, slevy, dispoff, shctd):
self.epso = epso self.epso = epso
self.epsh = epsh self.epsh = epsh
...@@ -3521,14 +3489,14 @@ class AmoebaWcaDispersionGenerator: ...@@ -3521,14 +3489,14 @@ class AmoebaWcaDispersionGenerator:
# <WcaDispersion class="1" radius="0.1855" epsilon="0.46024" /> # <WcaDispersion class="1" radius="0.1855" epsilon="0.46024" />
# <WcaDispersion class="2" radius="0.191" epsilon="0.422584" /> # <WcaDispersion class="2" radius="0.191" epsilon="0.422584" />
generator = AmoebaWcaDispersionGenerator( element.attrib['epso'], generator = AmoebaWcaDispersionGenerator(element.attrib['epso'],
element.attrib['epsh'], element.attrib['epsh'],
element.attrib['rmino'], element.attrib['rmino'],
element.attrib['rminh'], element.attrib['rminh'],
element.attrib['awater'], element.attrib['awater'],
element.attrib['slevy'], element.attrib['slevy'],
element.attrib['dispoff'], element.attrib['dispoff'],
element.attrib['shctd'] ) element.attrib['shctd'])
forceField._forces.append(generator) forceField._forces.append(generator)
# typeMap[] = [ radius, epsilon ] # typeMap[] = [ radius, epsilon ]
...@@ -3541,12 +3509,12 @@ class AmoebaWcaDispersionGenerator: ...@@ -3541,12 +3509,12 @@ class AmoebaWcaDispersionGenerator:
for t in types[0]: for t in types[0]:
generator.typeMap[t] = values generator.typeMap[t] = values
else: else:
outputString = "AmoebaWcaDispersionGenerator: error getting type: %s" % ( atom.attrib['class'] ) outputString = "AmoebaWcaDispersionGenerator: error getting type: %s" % (atom.attrib['class'])
raise ValueError( outputString ) raise ValueError(outputString)
#========================================================================================= #=========================================================================================
def createForce(self, sys, data, nonbondedMethod, nonbondedCutoff, args ): def createForce(self, sys, data, nonbondedMethod, nonbondedCutoff, args):
verbose = 0 verbose = 0
...@@ -3563,22 +3531,22 @@ class AmoebaWcaDispersionGenerator: ...@@ -3563,22 +3531,22 @@ class AmoebaWcaDispersionGenerator:
# add particles to force # add particles to force
# throw error if particle type not available # throw error if particle type not available
force.setEpso( float(self.epso ) ) force.setEpso( float(self.epso ))
force.setEpsh( float(self.epsh ) ) force.setEpsh( float(self.epsh ))
force.setRmino( float(self.rmino ) ) force.setRmino( float(self.rmino ))
force.setRminh( float(self.rminh ) ) force.setRminh( float(self.rminh ))
force.setDispoff( float(self.dispoff ) ) force.setDispoff(float(self.dispoff))
force.setSlevy( float(self.slevy ) ) force.setSlevy( float(self.slevy ))
force.setAwater( float(self.awater ) ) force.setAwater( float(self.awater ))
force.setShctd( float(self.shctd ) ) force.setShctd( float(self.shctd ))
for (i, atom) in enumerate(data.atoms): for (i, atom) in enumerate(data.atoms):
t = data.atomType[atom] t = data.atomType[atom]
if t in self.typeMap: if t in self.typeMap:
values = self.typeMap[t] values = self.typeMap[t]
force.addParticle( values[0], values[1]) force.addParticle(values[0], values[1])
if( verbose ): if (verbose):
print "WcaDispersion %5d %15.7e %15.7e" % (i, values[0], values[1]) print "WcaDispersion %5d %15.7e %15.7e" % (i, values[0], values[1])
else: else:
raise ValueError('No WcaDispersion type for atom %s of %s %d' % (atom.name, atom.residue.name, atom.residue.index)) raise ValueError('No WcaDispersion type for atom %s of %s %d' % (atom.name, atom.residue.name, atom.residue.index))
...@@ -3593,7 +3561,7 @@ class AmoebaGeneralizedKirkwoodGenerator: ...@@ -3593,7 +3561,7 @@ class AmoebaGeneralizedKirkwoodGenerator:
#========================================================================================= #=========================================================================================
def __init__(self, forceField, solventDielectric, soluteDielectric, includeCavityTerm, probeRadius, surfaceAreaFactor ): def __init__(self, forceField, solventDielectric, soluteDielectric, includeCavityTerm, probeRadius, surfaceAreaFactor):
self.forceField = forceField self.forceField = forceField
self.solventDielectric = solventDielectric self.solventDielectric = solventDielectric
...@@ -3634,7 +3602,7 @@ class AmoebaGeneralizedKirkwoodGenerator: ...@@ -3634,7 +3602,7 @@ class AmoebaGeneralizedKirkwoodGenerator:
#========================================================================================= #=========================================================================================
def getObcShct( self, data, atomIndex): def getObcShct(self, data, atomIndex):
atom = data.atoms[atomIndex] atom = data.atoms[atomIndex]
atomicNumber = atom.element.atomic_number atomicNumber = atom.element.atomic_number
...@@ -3642,129 +3610,128 @@ class AmoebaGeneralizedKirkwoodGenerator: ...@@ -3642,129 +3610,128 @@ class AmoebaGeneralizedKirkwoodGenerator:
# shct # shct
if( atomicNumber == 1 ): # H(1) if (atomicNumber == 1): # H(1)
shct = 0.85 shct = 0.85
elif( atomicNumber == 6 ): # C(6) elif (atomicNumber == 6): # C(6)
shct = 0.72 shct = 0.72
elif( atomicNumber == 7 ): # N(7) elif (atomicNumber == 7): # N(7)
shct = 0.79 shct = 0.79
elif( atomicNumber == 8 ): # O(8) elif (atomicNumber == 8): # O(8)
shct = 0.85 shct = 0.85
elif( atomicNumber == 9 ): # F(9) elif (atomicNumber == 9): # F(9)
shct = 0.88 shct = 0.88
elif( atomicNumber == 15 ): # P(15) elif (atomicNumber == 15): # P(15)
shct = 0.86 shct = 0.86
elif( atomicNumber == 16 ): # S(16) elif (atomicNumber == 16): # S(16)
shct = 0.96 shct = 0.96
elif( atomicNumber == 26 ): # Fe(26) elif (atomicNumber == 26): # Fe(26)
shct = 0.88 shct = 0.88
if( shct < 0.0 ): if (shct < 0.0):
shct = 0.80 shct = 0.80
print "getObcShct: Warning no GK overlap scale factor for atom %s of %s %d using default value=%f" % ( atom.name, atom.residue.name, atom.residue.index, shct) print "getObcShct: Warning no GK overlap scale factor for atom %s of %s %d using default value=%f" % (atom.name, atom.residue.name, atom.residue.index, shct)
return shct return shct
#========================================================================================= #=========================================================================================
def getAmoebaTypeRadius( self, data, bondedAtomIndices, atomIndex): def getAmoebaTypeRadius(self, data, bondedAtomIndices, atomIndex):
atom = data.atoms[atomIndex] atom = data.atoms[atomIndex]
atomicNumber = atom.element.atomic_number atomicNumber = atom.element.atomic_number
#print "CCC atomIndex %d ele=%d %s %s %d" % ( atomIndex, atom.element.atomic_number, atom.name, atom.residue.name, atom.residue.index)
radius = -1.0 radius = -1.0
if( atomicNumber == 1 ): # H(1) if (atomicNumber == 1): # H(1)
radius = 0.132 radius = 0.132
if( len( bondedAtomIndices ) < 1 ): if (len(bondedAtomIndices) < 1):
outputString = "AmoebaGeneralizedKirkwoodGenerator: error getting atom bonded to %s of %s %d " % ( atom.name, atom.residue.name, atom.residue.index ) outputString = "AmoebaGeneralizedKirkwoodGenerator: error getting atom bonded to %s of %s %d " % (atom.name, atom.residue.name, atom.residue.index)
raise ValueError( outputString ) raise ValueError(outputString)
for bondedAtomIndex in bondedAtomIndices: for bondedAtomIndex in bondedAtomIndices:
bondedAtomAtomicNumber = data.atoms[bondedAtomIndex].element.atomic_number bondedAtomAtomicNumber = data.atoms[bondedAtomIndex].element.atomic_number
if( bondedAtomAtomicNumber == 7 ): if (bondedAtomAtomicNumber == 7):
radius = 0.11 radius = 0.11
if( bondedAtomAtomicNumber == 8 ): if (bondedAtomAtomicNumber == 8):
radius = 0.105 radius = 0.105
elif( atomicNumber == 3 ): # Li(3) elif (atomicNumber == 3): # Li(3)
radius = 0.15 radius = 0.15
elif( atomicNumber == 6 ): # C(6) elif (atomicNumber == 6): # C(6)
radius = 0.20 radius = 0.20
if( len( bondedAtomIndices ) == 3 ): if (len(bondedAtomIndices) == 3):
radius = 0.205 radius = 0.205
elif( len( bondedAtomIndices ) == 4 ): elif (len(bondedAtomIndices) == 4):
for bondedAtomIndex in bondedAtomIndices: for bondedAtomIndex in bondedAtomIndices:
bondedAtomAtomicNumber = data.atoms[bondedAtomIndex].element.atomic_number bondedAtomAtomicNumber = data.atoms[bondedAtomIndex].element.atomic_number
if( bondedAtomAtomicNumber == 7 or bondedAtomAtomicNumber == 8 ): if (bondedAtomAtomicNumber == 7 or bondedAtomAtomicNumber == 8):
radius = 0.175 radius = 0.175
elif( atomicNumber == 7 ): # N(7) elif (atomicNumber == 7): # N(7)
radius = 0.16 radius = 0.16
elif( atomicNumber == 8 ): # O(8) elif (atomicNumber == 8): # O(8)
radius = 0.155 radius = 0.155
if( len( bondedAtomIndices ) == 2 ): if (len(bondedAtomIndices) == 2):
radius = 0.145 radius = 0.145
elif( atomicNumber == 9 ): # F(9) elif (atomicNumber == 9): # F(9)
radius = 0.154 radius = 0.154
elif( atomicNumber == 10 ): elif (atomicNumber == 10):
radius = 0.146 radius = 0.146
elif( atomicNumber == 11 ): elif (atomicNumber == 11):
radius = 0.209 radius = 0.209
elif( atomicNumber == 12 ): elif (atomicNumber == 12):
radius = 0.179 radius = 0.179
elif( atomicNumber == 14 ): elif (atomicNumber == 14):
radius = 0.189 radius = 0.189
elif( atomicNumber == 15 ): # P(15) elif (atomicNumber == 15): # P(15)
radius = 0.196 radius = 0.196
elif( atomicNumber == 16 ): # S(16) elif (atomicNumber == 16): # S(16)
radius = 0.186 radius = 0.186
elif( atomicNumber == 17 ): elif (atomicNumber == 17):
radius = 0.182 radius = 0.182
elif( atomicNumber == 18 ): elif (atomicNumber == 18):
radius = 0.179 radius = 0.179
elif( atomicNumber == 19 ): elif (atomicNumber == 19):
radius = 0.223 radius = 0.223
elif( atomicNumber == 20 ): elif (atomicNumber == 20):
radius = 0.191 radius = 0.191
elif( atomicNumber == 35 ): elif (atomicNumber == 35):
radius = 2.00 radius = 2.00
elif( atomicNumber == 36 ): elif (atomicNumber == 36):
radius = 0.190 radius = 0.190
elif( atomicNumber == 37 ): elif (atomicNumber == 37):
radius = 0.226 radius = 0.226
elif( atomicNumber == 53 ): elif (atomicNumber == 53):
radius = 0.237 radius = 0.237
elif( atomicNumber == 54 ): elif (atomicNumber == 54):
radius = 0.207 radius = 0.207
elif( atomicNumber == 55 ): elif (atomicNumber == 55):
radius = 0.263 radius = 0.263
elif( atomicNumber == 56 ): elif (atomicNumber == 56):
radius = 0.230 radius = 0.230
if( radius < 0.0 ): if (radius < 0.0):
radius = 2.0 radius = 2.0
print "Warning no GK radius for atom %s of %s %d using default value=%f" % ( atom.name, atom.residue.name, atom.residue.index, radius) print "Warning no GK radius for atom %s of %s %d using default value=%f" % (atom.name, atom.residue.name, atom.residue.index, radius)
return radius return radius
#========================================================================================= #=========================================================================================
def getBondiTypeRadius( self, data, bondedAtomIndices, atomIndex): def getBondiTypeRadius(self, data, bondedAtomIndices, atomIndex):
bondiMap = self.radiusTypeMap['Bondi'] bondiMap = self.radiusTypeMap['Bondi']
atom = data.atoms[atomIndex] atom = data.atoms[atomIndex]
atomicNumber = atom.element.atomic_number atomicNumber = atom.element.atomic_number
if( atomicNumber in bondiMap ): if (atomicNumber in bondiMap):
radius = bondiMap[atomicNumber] radius = bondiMap[atomicNumber]
else: else:
radius = 0.206 radius = 0.206
print "Warning no Bondi radius for atom %s of %s %d using default value=%f" % ( atom.name, atom.residue.name, atom.residue.index, radius) print "Warning no Bondi radius for atom %s of %s %d using default value=%f" % (atom.name, atom.residue.name, atom.residue.index, radius)
return radius return radius
...@@ -3777,16 +3744,16 @@ class AmoebaGeneralizedKirkwoodGenerator: ...@@ -3777,16 +3744,16 @@ class AmoebaGeneralizedKirkwoodGenerator:
# <GeneralizedKirkwood type="1" charge="-0.22620" shct="0.79" /> # <GeneralizedKirkwood type="1" charge="-0.22620" shct="0.79" />
# <GeneralizedKirkwood type="2" charge="-0.15245" shct="0.72" /> # <GeneralizedKirkwood type="2" charge="-0.15245" shct="0.72" />
generator = AmoebaGeneralizedKirkwoodGenerator( forceField, element.attrib['solventDielectric'], element.attrib['soluteDielectric'], generator = AmoebaGeneralizedKirkwoodGenerator(forceField, element.attrib['solventDielectric'], element.attrib['soluteDielectric'],
element.attrib['includeCavityTerm'], element.attrib['includeCavityTerm'],
element.attrib['probeRadius'], element.attrib['surfaceAreaFactor'] ) element.attrib['probeRadius'], element.attrib['surfaceAreaFactor'])
forceField._forces.append(generator) forceField._forces.append(generator)
#========================================================================================= #=========================================================================================
def createForce(self, sys, data, nonbondedMethod, nonbondedCutoff, args ): def createForce(self, sys, data, nonbondedMethod, nonbondedCutoff, args):
if( self.hasBeenCalled ): if (self.hasBeenCalled ):
return return
verbose = 0 verbose = 0
...@@ -3796,14 +3763,14 @@ class AmoebaGeneralizedKirkwoodGenerator: ...@@ -3796,14 +3763,14 @@ class AmoebaGeneralizedKirkwoodGenerator:
existing = [sys.getForce(i) for i in range(sys.getNumForces())] existing = [sys.getForce(i) for i in range(sys.getNumForces())]
amoebaMultipoleForceList = [f for f in existing if type(f) == mm.AmoebaMultipoleForce] amoebaMultipoleForceList = [f for f in existing if type(f) == mm.AmoebaMultipoleForce]
if( len( amoebaMultipoleForceList ) > 0 ): if (len(amoebaMultipoleForceList) > 0):
amoebaMultipoleForce = amoebaMultipoleForceList[0] amoebaMultipoleForce = amoebaMultipoleForceList[0]
else: else:
# call AmoebaMultipoleForceGenerator.createForce() to ensure charges have been set # call AmoebaMultipoleForceGenerator.createForce() to ensure charges have been set
for force in self.forceField._forces: for force in self.forceField._forces:
if( force.__class__.__name__ == 'AmoebaMultipoleGenerator' ): if (force.__class__.__name__ == 'AmoebaMultipoleGenerator'):
force.createForce( sys, data, nonbondedMethod, nonbondedCutoff, args ) force.createForce(sys, data, nonbondedMethod, nonbondedCutoff, args)
# get or create force depending on whether it has already been added to the system # get or create force depending on whether it has already been added to the system
...@@ -3813,20 +3780,20 @@ class AmoebaGeneralizedKirkwoodGenerator: ...@@ -3813,20 +3780,20 @@ class AmoebaGeneralizedKirkwoodGenerator:
force = mm.AmoebaGeneralizedKirkwoodForce() force = mm.AmoebaGeneralizedKirkwoodForce()
sys.addForce(force) sys.addForce(force)
if( 'solventDielectric' in args ): if ('solventDielectric' in args):
force.setSolventDielectric( float( args['solventDielectric'] ) ) force.setSolventDielectric(float(args['solventDielectric']))
else: else:
force.setSolventDielectric( float(self.solventDielectric ) ) force.setSolventDielectric( float(self.solventDielectric))
if( 'soluteDielectric' in args ): if ('soluteDielectric' in args):
force.setSoluteDielectric( float( args['soluteDielectric'] ) ) force.setSoluteDielectric(float(args['soluteDielectric']))
else: else:
force.setSoluteDielectric( float(self.soluteDielectric ) ) force.setSoluteDielectric( float(self.soluteDielectric))
if( 'includeCavityTerm' in args ): if ('includeCavityTerm' in args):
force.setIncludeCavityTerm( int( args['includeCavityTerm'] ) ) force.setIncludeCavityTerm(int(args['includeCavityTerm']))
else: else:
force.setIncludeCavityTerm( int(self.includeCavityTerm) ) force.setIncludeCavityTerm( int(self.includeCavityTerm))
else: else:
print "AmoebaGeneralizedKirkwoodForce exists" print "AmoebaGeneralizedKirkwoodForce exists"
...@@ -3837,28 +3804,28 @@ class AmoebaGeneralizedKirkwoodGenerator: ...@@ -3837,28 +3804,28 @@ class AmoebaGeneralizedKirkwoodGenerator:
# add particles to force # add particles to force
# throw error if particle type not available # throw error if particle type not available
force.setProbeRadius( float(self.probeRadius) ) force.setProbeRadius( float(self.probeRadius))
force.setSurfaceAreaFactor( float(self.surfaceAreaFactor) ) force.setSurfaceAreaFactor( float(self.surfaceAreaFactor))
# 1-2 # 1-2
bonded12ParticleSets = [] bonded12ParticleSets = []
for i in range(len(data.atoms)): for i in range(len(data.atoms)):
bonded12ParticleSet = AmoebaVdwGenerator.getBondedParticleSet( i, data ) bonded12ParticleSet = AmoebaVdwGenerator.getBondedParticleSet(i, data)
bonded12ParticleSet = set( sorted( bonded12ParticleSet ) ) bonded12ParticleSet = set(sorted(bonded12ParticleSet))
bonded12ParticleSets.append( bonded12ParticleSet ) bonded12ParticleSets.append(bonded12ParticleSet)
radiusType = 'Bondi' radiusType = 'Bondi'
for atomIndex in range( 0, amoebaMultipoleForce.getNumMultipoles() ): for atomIndex in range(0, amoebaMultipoleForce.getNumMultipoles()):
multipoleParameters = amoebaMultipoleForce.getMultipoleParameters( atomIndex ) multipoleParameters = amoebaMultipoleForce.getMultipoleParameters(atomIndex)
if( radiusType == 'Amoeba' ): if (radiusType == 'Amoeba'):
radius = self.getAmoebaTypeRadius( data, bonded12ParticleSets[atomIndex], atomIndex) radius = self.getAmoebaTypeRadius(data, bonded12ParticleSets[atomIndex], atomIndex)
else: else:
radius = self.getBondiTypeRadius( data, bonded12ParticleSets[atomIndex], atomIndex) radius = self.getBondiTypeRadius(data, bonded12ParticleSets[atomIndex], atomIndex)
shct = self.getObcShct( data, atomIndex) shct = self.getObcShct(data, atomIndex)
force.addParticle( multipoleParameters[0], radius, shct ) force.addParticle(multipoleParameters[0], radius, shct)
if( verbose ): if (verbose):
print "GeneralizedKirkwood %5d %15.7e %15.7e" % ( atomIndex, multipoleParameters[0], radius, shct) print "GeneralizedKirkwood %5d %15.7e %15.7e" % (atomIndex, multipoleParameters[0], radius, shct)
parsers["AmoebaGeneralizedKirkwoodForce"] = AmoebaGeneralizedKirkwoodGenerator.parseElement parsers["AmoebaGeneralizedKirkwoodForce"] = AmoebaGeneralizedKirkwoodGenerator.parseElement
...@@ -3894,7 +3861,7 @@ class AmoebaUreyBradleyGenerator: ...@@ -3894,7 +3861,7 @@ class AmoebaUreyBradleyGenerator:
# <AmoebaUreyBradleyForce cubic="0.0" quartic="0.0" > # <AmoebaUreyBradleyForce cubic="0.0" quartic="0.0" >
# <UreyBradley class1="74" class2="73" class3="74" k="16003.8" d="0.15537" /> # <UreyBradley class1="74" class2="73" class3="74" k="16003.8" d="0.15537" />
generator = AmoebaUreyBradleyGenerator( float(element.attrib['cubic']), float(element.attrib['quartic']) ) generator = AmoebaUreyBradleyGenerator(float(element.attrib['cubic']), float(element.attrib['quartic']))
forceField._forces.append(generator) forceField._forces.append(generator)
for bond in element.findall('UreyBradley'): for bond in element.findall('UreyBradley'):
types = forceField._findAtomTypes(bond, 3) types = forceField._findAtomTypes(bond, 3)
...@@ -3909,16 +3876,16 @@ class AmoebaUreyBradleyGenerator: ...@@ -3909,16 +3876,16 @@ class AmoebaUreyBradleyGenerator:
else: else:
outputString = "AmoebaUreyBradleyGenerator: error getting types: %s %s %s" % ( outputString = "AmoebaUreyBradleyGenerator: error getting types: %s %s %s" % (
bond.attrib['class1'], bond.attrib['class2'], bond.attrib['class3'] ) bond.attrib['class1'], bond.attrib['class2'], bond.attrib['class3'])
raise ValueError( outputString ) raise ValueError(outputString)
#============================================================================================= #=============================================================================================
def createForce(self, sys, data, nonbondedMethod, nonbondedCutoff, args ): def createForce(self, sys, data, nonbondedMethod, nonbondedCutoff, args):
verbose = 0 verbose = 0
if( self.hasBeenCalled ): if (self.hasBeenCalled):
return return
self.hasBeenCalled = 1 self.hasBeenCalled = 1
...@@ -3932,11 +3899,11 @@ class AmoebaUreyBradleyGenerator: ...@@ -3932,11 +3899,11 @@ class AmoebaUreyBradleyGenerator:
else: else:
force = existing[0] force = existing[0]
force.setAmoebaGlobalUreyBradleyCubic( self.cubic ) force.setAmoebaGlobalUreyBradleyCubic(self.cubic)
force.setAmoebaGlobalUreyBradleyQuartic( self.quartic ) force.setAmoebaGlobalUreyBradleyQuartic(self.quartic)
for (angle, isConstrained) in zip(data.angles, data.isAngleConstrained): for (angle, isConstrained) in zip(data.angles, data.isAngleConstrained):
if( isConstrained ): if (isConstrained):
continue continue
type1 = data.atomType[data.atoms[angle[0]]] type1 = data.atomType[data.atoms[angle[0]]]
type2 = data.atomType[data.atoms[angle[1]]] type2 = data.atomType[data.atoms[angle[1]]]
...@@ -3945,9 +3912,9 @@ class AmoebaUreyBradleyGenerator: ...@@ -3945,9 +3912,9 @@ class AmoebaUreyBradleyGenerator:
types1 = self.types1[i] types1 = self.types1[i]
types2 = self.types2[i] types2 = self.types2[i]
types3 = self.types3[i] types3 = self.types3[i]
if( (type1 in types1 and type2 in types2 and type3 in types3) or (type3 in types1 and type2 in types2 and type1 in types3) ): if ((type1 in types1 and type2 in types2 and type3 in types3) or (type3 in types1 and type2 in types2 and type1 in types3)):
if( verbose ): if (verbose):
print "AmoebaUreyBradleyGenerator %5d %5d %5d [%5s %5s %5s] %15.6f %15.6f" % (angle[0], angle[1], angle[2], type1, type2, type3, self.length[i], self.k[i]) print "AmoebaUreyBradleyGenerator %5d %5d %5d [%5s %5s %5s] %15.6f %15.6f" % (angle[0], angle[1], angle[2], type1, type2, type3, self.length[i], self.k[i])
force.addUreyBradley(angle[0], angle[2], self.length[i], self.k[i]) force.addUreyBradley(angle[0], angle[2], self.length[i], self.k[i])
......
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment