def main():
"""
This test shows various operators within Bond and BondContainer classes
"""
print "************************************************************************************"
print " This test shows various operators within Bond and BondContainer classes "
print "************************************************************************************ \n"
print "Testing Bond and BondContainer"
b1 = Bond( 1, 2, 1.233, "hooke")
b2 = Bond( 3, 4, 0.5, "hooke")
b3 = Bond( )
b4 = Bond( 3, 8, 0.5, "stiff")
bonds = BondContainer()
bonds.put(b1)
bonds.put(b2)
bonds.put(b3)
bonds.put(b4)
del b1, b2, b3, b4
print "\n Cleaning memory for initial objects \n"
print "Check for pre-existing bond"
if bonds.hasBond([2,1]):
print "bond 1--2 exists"
else:
print "bond 1--2 does NOT exists"
print "Check for pre-existing bond"
if bonds.hasBond([2,3]):
print "bond 2--3 exists"
else:
print "bond 2--3 does NOT exist"
print " "
print "Bonds: ", bonds
print " "
print "Test iterator for bond container "
for gid, bondObj in bonds:
print "bondID = ", gid, "bond object ", bondObj.__dict__
print " "
searchID = 2
print "Testing 'in' operator for searchID ", searchID, " in bonds"
if searchID in bonds:
print "ID ",searchID, " in bonds"
else:
print "nope"
print "-----------------------------------------------------"
print "bonds.getTypeInfoDict() ", bonds.getTypeInfoDict()
print "-----------------------------------------------------"
print " "
print "Here's an issue... globalID's are assigned by ParticleContainer class "
print "Setting Bond object with gid's of Particles needs to be done after PC class set "
print "or there could be conflicts \n"
def main():
"""
This test shows how reorder (compress) global IDs for a StructureContainer
"""
p1 = Particle([0.2, 1.3, 33.0], "Si", 2.0, 1.23)
p2 = Particle([5.0, 2.3, -22.1], "C", 1.0, 2.34)
p3 = Particle([5.0, 2.3, -20.1], "C", 1.0, 2.34)
b1 = Bond(1, 2, 1.233, "hooke")
b2 = Bond(2, 3, 0.500, "hooke")
atoms1 = ParticleContainer()
atoms1.put(p1)
atoms1.put(p2)
atoms1.put(p3)
bonds1 = BondContainer()
bonds1.put(b1)
bonds1.put(b2)
polymer1 = StructureContainer(atoms1, bonds1) # Complete structure 1
p1other = Particle([0.0, 2.3, -20.1], "C", 1.0, 2.34)
p2other = Particle([50.0, 0.3, -0.1], "Ar", 2.0, 2.34)
p3other = Particle([50.0, 0.3, -0.1], "Ar", 2.0, 2.34)
b1other = Bond(1, 3, 1.233,
"hooke") # Correct ptclIDs for second structure
atoms2 = ParticleContainer()
atoms2.put(p1other)
atoms2.put(p2other)
atoms2.put(p3other)
del atoms2[2] # remove 2nd particle so ID's are non-consecutive
bonds2 = BondContainer()
bonds2.put(b1other)
polymer2 = StructureContainer(atoms2,
bonds2) # Complete structure 1 completely
del p1, p2, p3, p1other, p2other, b1, b2, b1other, atoms1, atoms2, bonds1, bonds2
print "\n Cleaning memory for initial objects \n"
print "-------------------- Before adding --------------------"
print "polymer1 = ", polymer1
print "polymer2 = ", polymer2
print " "
print "-------------------- After adding --------------------"
polymer2 += polymer1
print "polymer2 = ", polymer2
polymer2.compressPtclIDs()
print "-------------------- After compressing --------------------"
print "polymer2 = ", polymer2
def main():
"""
This test shows how to add StructureContainer objects together
A special test to double-check re-labeling ... add a big container to a 'small' one
"""
print "***************************************************************************************"
print " This test shows how to add StructureContainer objects together "
print " A special test to double-check re-labeling ... add a big container to a 'small' one "
print "*************************************************************************************** \n"
p1 = Particle([1.1, 1.1, 1.1], "Si", 2.0, 1.23)
p2 = Particle([2.2, 2.2, 2.2], "C", 1.0, 2.34)
p3 = Particle([3.3, 3.3, 3.3], "C", 1.0, 2.34)
b1 = Bond(1, 2, 1.111, "hooke")
b2 = Bond(2, 3, 2.222, "hooke")
atoms1 = ParticleContainer()
atoms1.put(p1)
atoms1.put(p2)
atoms1.put(p3)
bonds1 = BondContainer()
bonds1.put(b1)
bonds1.put(b2)
polymer1 = StructureContainer(atoms1,
bonds1) # Complete structure 1 completely
p1other = Particle([1.11, 1.11, 1.11], "C", 1.0, 2.34)
p2other = Particle([2.22, 2.22, 2.22], "Ar", 2.0, 2.34)
b1other = Bond(1, 2, 1.1,
"hooke-2") # Correct ptclIDs for second structure
atoms2 = ParticleContainer()
atoms2.put(p1other)
atoms2.put(p2other)
bonds2 = BondContainer()
bonds2.put(b1other)
polymer2 = StructureContainer(atoms2,
bonds2) # Complete structure 1 completely
del p1, p2, p3, p1other, p2other, b1, b2, b1other, atoms1, atoms2, bonds1, bonds2
print "\n Cleaning memory for initial objects \n"
print "-------------------- Before adding --------------------"
print "polymer1 = ", polymer1
print "polymer2 = ", polymer2
print " "
print "-------------------- After adding --------------------"
# polymer1 += polymer2
polymer2 += polymer1
print "polymer2 = ", polymer2
def runStrucAdd(numPtcls1, numPtcls2):
"""
Creates structures with ptcls and bonds between consecutive IDs
Adds and reports timing
Args:
numPtcls1 (int): # of ptcls in first struc
numPtcls2 (int): # of ptcls in second struc
Returns:
(initTime, addTime, compressTime)
"""
atoms1 = ParticleContainer()
bonds1 = BondContainer()
atoms2 = ParticleContainer()
bonds2 = BondContainer()
start_time = time.time()
for n in range(numPtcls1):
pobj1 = Particle([1.1, 1.1, 1.1], "Si", 2.0, float(n + 1))
atoms1.put(pobj1)
for n in range(1, numPtcls1):
bobj1 = Bond(n, n + 1, 1.233, "hooke-1")
bonds1.put(bobj1)
for n in range(numPtcls2):
pobj2 = Particle([2.2, 2.2, 2.2], "C", 1.0, float(n + 1))
atoms2.put(pobj2)
for n in range(1, numPtcls2):
bobj2 = Bond(n, n + 1, 1.233, "hooke-2")
bonds2.put(bobj2)
end_time = time.time()
initTime = end_time - start_time
polymer1 = StructureContainer(atoms1, bonds1) # Complete structure 1
polymer2 = StructureContainer(atoms2, bonds2) # Complete structure 2
del atoms1, atoms2
print "\n Cleaning memory for initial objects \n"
start_time = time.time()
polymer1 += polymer2
end_time = time.time()
addTime = end_time - start_time
start_time = time.time()
polymer1.compressPtclIDs()
end_time = time.time()
compressTime = end_time - start_time
return (numPtcls1, numPtcls2, initTime, addTime, compressTime)
def main():
"""
This test shows how the setPtclPos method works to externally set all particle
positions from a list
"""
print "************************************************************************************"
print " This test shows how the setPtclPos method works to externally set all particle "
print " positions from a list"
print "************************************************************************************ \n"
p1 = Particle([0.2, 1.3, 33.0], "Si", 2.0, 1.23)
p2 = Particle([5.0, 2.3, -22.1], "C", 1.0, 2.34)
p3 = Particle([5.0, 2.3, -20.1], "C", 1.0, 2.34)
p4 = Particle([0.0, 2.3, -20.1], "C", 1.0, 2.34)
b1 = Bond(1, 2, 1.233, "hooke")
b2 = Bond(2, 3, 0.500, "hooke")
b3 = Bond(3, 4, 2.301, "hooke")
b4 = Bond(1, 3, 0.828, "hooke")
atoms1 = ParticleContainer()
atoms1.put(p1)
atoms1.put(p2)
atoms1.put(p3)
atoms1.put(p4)
bonds = BondContainer()
bonds.put(b1)
bonds.put(b2)
bonds.put(b3)
bonds.put(b4)
del p1, p2, p3, p4, b1, b2, b3, b4
polymer1 = StructureContainer(atoms1, bonds)
del atoms1, bonds
polymer1.setBoxLengths([[-3.0, 100], [-5, 23.0], [34.3, 100.1]])
print "Initial state of structure before reset ", polymer1
newPtclPos = [[1, 0.111, 0.222, 0.333], [2, 0.222, 0.333, 0.444],
[4, 0.444, 0.555, 0.666]]
print "new positions = ", newPtclPos
polymer1.setPtclPositions(newPtclPos)
ptclPosList = polymer1.getPtclPositions()
print "new positions from structure = ", ptclPosList
print " "
print "After position reset/get ", polymer1
def main():
"""
This test shows how to save/dump/restore state of structureContainers using pickle
"""
print "************************************************************************************"
print " This test shows how to save/dump/restore state of structureContainers using pickle"
print "************************************************************************************ \n"
p1 = Particle([0.2, 1.3, 33.0], "Si", 2.0, 1.23)
p2 = Particle([5.0, 2.3, -22.1], "C", 1.0, 2.34)
p3 = Particle([5.0, 2.3, -20.1], "C", 1.0, 2.34)
p4 = Particle([0.0, 2.3, -20.1], "C", 1.0, 2.34)
b1 = Bond(1, 2, 1.233, "hooke")
b2 = Bond(2, 3, 0.500, "hooke")
b3 = Bond(3, 4, 2.301, "hooke")
b4 = Bond(1, 3, 0.828, "hooke")
atoms1 = ParticleContainer()
atoms1.put(p1)
atoms1.put(p2)
atoms1.put(p3)
atoms1.put(p4)
bonds = BondContainer()
bonds.put(b1)
bonds.put(b2)
bonds.put(b3)
bonds.put(b4)
del p1, p2, p3, p4, b1, b2, b3, b4
polymer1 = StructureContainer(atoms1, bonds)
del atoms1, bonds
polymer1.setBoxLengths([[-3.0, 100], [-5, 23.0], [34.3, 100.1]])
print "Initial state of structure before dump ", polymer1
print "-------------------------------------------------------------------------------- \n"
polymer1.dump('polymer1')
polymerNew = StructureContainer()
polymerNew.restore('polymer1.pkl')
print "After load from pickle \n"
print polymerNew
print "-------------------------------------------------------------------------------- \n"
def main():
"""
This test shows how to set up Structure container with Particle/Bond-Containers
and shows how IDs changed in StructureContainer propagate to values set in BondContainer for its
held particle ID values
Illustrates how a substructure method can return subgroup
"""
print "*****************************************************************************************************"
print " This test shows how to set up Structure container with Particle/Bond-Containers \n"
print " and shows how IDs changed in StructureContainer propagate to values set in BondContainer for its "
print " held particle ID values \n"
print " Illustrates how a substructure method can return subgroup"
print "************************************************************************************ \n"
p1 = Particle( [0.2, 1.3, 33.0], "Si", 2.0, 1.23)
p2 = Particle( [5.0, 2.3, -22.1], "C", 1.0, 2.34)
p3 = Particle( [5.0, 2.3, -20.1], "C", 1.0, 2.34)
p4 = Particle( [0.0, 2.3, -20.1], "C", 1.0, 2.34)
p5 = Particle( [0.2, 1.3, 33.0], "Si", 2.0, 1.23)
b1 = Bond( 5, 2, 1.233, "hooke") # This setup mimics earlier state of test
b2 = Bond( 2, 3, 0.500, "hooke") # Still matches with diagram
b3 = Bond( 3, 4, 2.301, "hooke")
b4 = Bond( 5, 3, 0.828, "hooke")
atoms1 = ParticleContainer()
atoms1.put(p1)
atoms1.put(p2)
atoms1.put(p3)
atoms1.put(p4)
atoms1.put(p5)
del atoms1[1] # This is to mimic state of container for an older test
bonds = BondContainer()
bonds.put(b1)
bonds.put(b2)
bonds.put(b3)
bonds.put(b4)
del p1, p2, p3, p4, b1, b2, b3, b4
polymer1 = StructureContainer(atoms1, bonds)
del atoms1, bonds
print "********************************************************** \n"
print polymer1
print diagramAfter
print "********************************************************** \n"
print "-------------------------------------------------------------------------------- \n"
print "********************************************************** \n"
print "Testing polymer1.getSubStructure([5,2])"
print " currently ID's are reassigned in substructure \n"
subpolymer = polymer1.getSubStructure([5,2])
print subpolymer
print diagramAfter
print "********************************************************** \n"
print "********************************************************** \n"
print "polymer1 Struture after returning sub-structure"
print polymer1
print "********************************************************** \n"
print "-------------------------------------------------------------------------------- \n"
print "********************************************************** \n"
print "Testing polymer1.getSubStructure([2,3,4])"
print " currently ID's are reassigned in substructure \n"
subpolymer = polymer1.getSubStructure([2,3,4])
print subpolymer
print diagramAfter
print "********************************************************** \n"
def main():
"""
Illustrates how a substructure method returns subgroup with ONLY particle container included
This is for speed considerations
"""
print "**********************************************************************************************"
print "Illustrates how a substructure method returns subgroup with ONLY particle container included"
print "This is for speed considerations"
print "**********************************************************************************************\n"
p1 = Particle([1.1, 1.1, 1.1], "Si", 2.0, 1.23)
p2 = Particle([2.2, 2.2, 2.2], "Si", 1.0, 2.34)
p3 = Particle([3.3, 3.3, 3.3], "Si", 1.0, 2.34)
p4 = Particle([4.4, 4.4, 4.4], "Si", 1.0, 2.34)
p5 = Particle([5.5, 5.5, 5.5], "C", 1.0, 2.34) # 1
p6 = Particle([6.6, 6.6, 6.6], "C", 1.0, 2.34) # 2
p7 = Particle([7.7, 7.7, 7.7], "C", 1.0, 2.34) # 3
p8 = Particle([8.8, 8.8, 8.8], "C", 1.0, 2.34) # 4
b1 = Bond(1, 2, 1.11, "hooke")
b2 = Bond(2, 3, 2.22, "hooke")
b3 = Bond(3, 4, 3.33, "hooke")
b4 = Bond(4, 5, 4.44, "hooke")
b5 = Bond(5, 6, 5.55, "hooke")
b6 = Bond(6, 7, 6.66, "hooke")
b7 = Bond(7, 8, 7.77, "hooke")
a1 = Angle(1, 2, 3, 1.11, "harmonic")
a2 = Angle(2, 3, 4, 2.22, "harmonic")
a3 = Angle(3, 4, 5, 3.33, "harmonic")
a4 = Angle(4, 5, 6, 4.44, "harmonic")
a5 = Angle(5, 6, 7, 5.55, "harmonic")
a6 = Angle(6, 7, 8, 6.66, "harmonic")
d1 = Dihedral(1, 2, 3, 4, 1.11, "stiff")
d2 = Dihedral(2, 3, 4, 5, 2.22, "stiff")
d3 = Dihedral(3, 4, 5, 6, 3.33, "stiff")
d4 = Dihedral(4, 5, 6, 7, 4.44, "stiff")
d5 = Dihedral(5, 6, 7, 8, 5.55, "stiff")
atoms1 = ParticleContainer()
atoms1.put(p1)
atoms1.put(p2)
atoms1.put(p3)
atoms1.put(p4)
atoms1.put(p5)
atoms1.put(p6)
atoms1.put(p7)
atoms1.put(p8)
bonds = BondContainer()
bonds.put(b1)
bonds.put(b2)
bonds.put(b3)
bonds.put(b4)
bonds.put(b5)
bonds.put(b6)
bonds.put(b7)
angles = AngleContainer()
angles.put(a1)
angles.put(a2)
angles.put(a3)
angles.put(a4)
angles.put(a5)
angles.put(a6)
dihedrals = DihedralContainer()
dihedrals.put(d1)
dihedrals.put(d2)
dihedrals.put(d3)
dihedrals.put(d4)
dihedrals.put(d5)
del p1, p2, p3, p4, p5, p6, p7, p8
del b1, b2, b3, b4, b5, b6, b7
del a1, a2, a3, a4, a5, a6
del d1, d2, d3, d4, d5
polymer1 = StructureContainer(atoms1, bonds, angles, dihedrals)
del atoms1, bonds, angles, dihedrals
print "********************************************************** \n"
print "polymer1 Structure before returning sub-structure"
print polymer1
print "********************************************************** \n"
print "-------------------------------------------------------------------------------- \n"
print "********************************************************** \n"
print "Testing polymer1.getSubParticleContainer([2,3,4])"
print " currently ID's are reassigned in substructure \n"
subPtclC = polymer1.getSubStructure([2, 3, 4], particlesOnly=True)
print subPtclC
print "********************************************************** \n"
def main():
"""
This shows operations on empty StructureContainer objects for 'robustness'
"""
print "************************************************************************************"
print " This shows operations on empty StructureContainer objects for 'robustness'"
print "************************************************************************************ \n"
atoms1 = ParticleContainer()
bonds1 = BondContainer()
p1 = Particle([0.2, 1.3, 33.0], "Si", 2.0, 1.23)
p2 = Particle([5.0, 2.3, -22.1], "C", 1.0, 2.34)
p3 = Particle([5.0, 2.3, -20.1], "C", 1.0, 2.34)
b1 = Bond(1, 2, 1.233, "hooke")
b2 = Bond(2, 3, 0.500, "hooke")
atoms1.put(p1)
atoms1.put(p2)
atoms1.put(p3)
bonds1.put(b1)
bonds1.put(b2)
atoms2 = ParticleContainer()
bonds2 = BondContainer()
polymer1 = StructureContainer(atoms1, bonds1) # Non-empty structure 1
polymer2 = StructureContainer(atoms2, bonds2) # Empty structure 2
# ------------------------------------------------------------------------------------------------------------------------
print "Non-empty container", polymer1
print "Empty container", polymer2
print "Testing empty dump"
polymer2.dump("empty")
print "Testing empty compressPtclIDs"
polymer2.compressPtclIDs()
print "Testing empty getSubStructure"
subStruc = polymer2.getSubStructure([])
print "subStruc = ", subStruc
print "Testing empty getPtclPositions"
posList = polymer2.getPtclPositions()
print "posList = ", posList
print "------------------------------------------------------------------------------------ \n"
print "Testing struc add --> non-empty (polymer1) += empty (polymer2)"
polymer1 += polymer2
print "polymer1 = ", polymer1
print "------------------------------------------------------------------------------------ \n"
print "polymer2 = ", polymer2
print "------------------------------------------------------------------------------------ \n"
print "Testing struc add --> empty (polymer2) += non-empty (polymer1)"
polymer2 += polymer1
print "polymer2 = ", polymer2
print "------------------------------------------------------------------------------------ \n"
print "polymer1 = ", polymer1
print "------------------------------------------------------------------------------------ \n"
print "Testing empty getSubStructure with non-zero id list (should return ERROR)"
polymer3 = StructureContainer()
subStruc = polymer3.getSubStructure([1, 2])
print "subStruc = ", subStruc
def __iadd__(self, other):
"""
'Magic' method to implement the '+=' operator (eg struc1 += struc2)
Compare global IDs of particles and reassign globalIDs for particle
container using the max ID between the two lists. Tracks these changes
for all other (bond, angle, dihedral) containers that reference particleIDs
"""
self.verbose = False
# Empty container checks
if len(other) == 0: # If struc2 is empty (has no particles)
return self # simply return unchanged current container
if len(self) == 0: # If struc1 (this struc) is empty (has no particles)
return copy.deepcopy(other) # full copy other and return
#
# Special method for connecting building blocks
#
# Count number of connectors
connect_along_bond = False
if( self.type != "mol" and other.type != "mol"):
# IF not complete molecules that will just be added
# connect along bonds
connect_along_bond = True
self.cnt_connectors()
other.cnt_connectors()
if( self.verbose ):
log_line = "\n building block 1 type {} ".format(self.type )
log_line += "\n building block 1 has {} connections ".format(self.connect_cnt )
log_line += "\n building block 1 has {} func connections ".format(self.func_connect_cnt )
log_line += "\n building block 2 type {} ".format(other.type )
log_line += "\n building block 2 has {} connections ".format(other.connect_cnt )
log_line += "\n building block 2 has {} func connections ".format(other.func_connect_cnt )
print log_line
self.connect_id = "term_"
self.cap_id = "termcap_"
other.connect_id = "term_"
other.cap_id = "termcap_"
if( self.type == "unit" and other.type == "unit"):
self.connectionpoint = 1
other.connectionpoint = 0
new_termpoint = 1
elif( self.type == "term" and other.type == "unit"):
# elif( self.connect_cnt == 1 and other.connect_cnt == 2 ):
self.connectionpoint = 0
other.connectionpoint = 0
new_termpoint = 0
elif( self.type == "term" and other.type == "term"):
# elif( self.connect_cnt == 1 and other.connect_cnt == 1 ):
self.connectionpoint = 0
other.connectionpoint = 0
new_termpoint = -1
elif( self.type == "unit" and other.type == "term"):
#elif( self.connect_cnt == 2 and other.connect_cnt == 1 ):
self.connectionpoint = 1
other.connectionpoint = 0
new_termpoint = -1
elif( self.type == "unit" and other.type == "func"):
#elif( self.connect_cnt == 2 and other.connect_cnt == 1 ):
self.connect_id = "func_"
self.cap_id = "funccap_"
# this is zero since each functional possition will be removed once a functional group is added
self.connectionpoint = 0
other.connect_id = "term_"
other.connectionpoint = 0
new_termpoint = -1
else:
error_line = " Unknow connection configuration {} - {} \n".format(self.type, other.type )
error_line += " building block 1 has {} connnections \n".format(self.connect_cnt)
error_line += " building block 2 has {} connnections \n".format(other.connect_cnt)
sys.exit(error_line)
if( self.verbose ):
log_line = "\n Adding connection along bond "
log_line += "\n Connecting block 2 {} at point {} ".format(other.connect_id,other.connectionpoint )
log_line += "\n to block 1 {} at point {} ".format(self.connect_id,self.connectionpoint )
print log_line
# Shift second buildingblock so first connector is bonded to the second connector of first buildingblock
if( self.verbose ): print " Shift along bonds "
self.align_termbond(self.connectionpoint,origin="term")
other.align_termbond(other.connectionpoint,origin="termcap")
if( self.verbose ): print " Find terminal atoms "
self.get_connectors(self.connectionpoint)
other.get_connectors(other.connectionpoint)
bond_length = np.array([self.ptclC[self.pid_term].radii + other.ptclC[other.pid_term].radii,0.0,0.0])
# Shift second building block to have the correct bond length
other.ptclC.shift((bond_length-1.0*np.array(other.ptclC[other.pid_term].position)))
# Delete termcaps
self.bondC.deletepid(self.pid_termcap)
other.bondC.deletepid(other.pid_termcap)
del self.ptclC[self.pid_termcap]
del other.ptclC[other.pid_termcap]
# Reset term tags to null
self.ptclC[self.pid_term].tagsDict["cplytag"] = ""
other.ptclC[other.pid_term].tagsDict["cplytag"] = ""
# If an intern ring connection is made change the fftype
if( self.ptclC[self.pid_term].tagsDict["ring"] > 0 and other.ptclC[other.pid_term].tagsDict["ring"] > 0 ):
#print " ring self ", self.ptclC[self.pid_term].tagsDict["ring"]
#print " ring other ", other.ptclC[other.pid_term].tagsDict["ring"]
self.ptclC[self.pid_term].tagsDict["fftype"] = 'C!'
other.ptclC[other.pid_term].tagsDict["fftype"] = 'C!'
# sys.exit(" ring test ")
idFromToDict = dict() # Need to keep track of all ptcl ID changes at once
# {fromID1:toID1, fromID2:toID2...}
# eg {1:3, 3:5, 2:20...}
bondC = BondContainer() # Local bond container copy so ptclIDs
angleC = AngleContainer() # Local angle container copy so ptclIDs
dihC = DihedralContainer() # Local dihedral container copy so ptclIDs
bondC = copy.deepcopy(other.bondC) # inside can be changed (for adding below)
angleC = copy.deepcopy(other.angleC) # inside can be changed (for adding below)
dihC = copy.deepcopy(other.dihC) # inside can be changed (for adding below)
impC = copy.deepcopy(other.impC) # inside can be changed (for adding below)
keys1 = self.ptclC.particles.keys() # global IDs of particles in this object
keys2 = other.ptclC.particles.keys() # global IDs in object being added
self.ptclC.maxgid= max(keys1 + keys2) # find max globalID in keys, set this object maxID
self.get_max()
other.get_max()
# Update chain, residue and charge group number
if( self.max_chain == other.max_chain ):
other.shift_tag("qgroup",self.max_qgroup )
other.shift_tag("residue",self.max_residue )
other.shift_tag("ring",self.max_ring )
else:
other.add_chain(self.max_chain )
for ptclkey2 in other.ptclC.particles:
self.ptclC.put(other.ptclC.particles[ptclkey2]) # Pushes ptcl to this struc's ptcl container
fromPtclID = ptclkey2 # Track IDs from--->to
toPtclID = self.ptclC.maxgid # --> toID (to is the maxid of this ptclC)
idFromToDict[fromPtclID]=toPtclID # Store ID changes
if( connect_along_bond ):
# Add inter building block bond
if( self.verbose ): print " Add inter building block bond "
bb_bb = Bond(self.pid_term,idFromToDict[other.pid_term])
self.bondC.put(bb_bb)
bondC.replacePtclIDs(idFromToDict) # Use tracked list of ID changes
self.bondC += bondC # Now add bondC with 'corrected' IDs
angleC.replacePtclIDs(idFromToDict) # Now add angleC with 'corrected' IDs
self.angleC += angleC # Use tracked list of ID changes
dihC.replacePtclIDs(idFromToDict) # Use tracked list of ID changes
self.dihC += dihC # Now add dihC with 'corrected' IDs
impC.replacePtclIDs(idFromToDict) # Use tracked list of ID changes
self.impC += impC # Now add impC with 'corrected' IDs
if( connect_along_bond ):
self.compressPtclIDs()
self.bondC_nblist()
if ( new_termpoint >= 0 ):
if( self.verbose ): print " Add new cplytag to "
self.get_connectors(new_termpoint)
self.ptclC[self.pid_term].tagsDict["cplytag"] = "term_C({})".format(self.pid_term)
self.ptclC[self.pid_termcap].tagsDict["cplytag"] = "termcap_H({})_on_C({})".format(self.pid_termcap,self.pid_term)
# Append segments
for seg_i in other.segments:
self.segments.append(seg_i)
return self
def main():
"""
Tests a specifc workflow for LAMMPS that uses the simulationLAMMPS1 derived class
"""
global g
global p
# Get useful methods
g=Geometry()
# Get comm object
p = mpiBase.getMPISerialObject()
rank = p.getRank()
size = p.getCommSize()
# Sync random stream for tests
random.seed(0)
#############################################################################################
#
# Generate list of [gid, x,y,z] points ---> allPoints list
# copied on all processors. # Global pt index included
# UNITS distance --> A [0.1 nm]
#
#############################################################################################
rad_avg = 15.0 # Moving to use this to make
rad_sig = 0.025 # initial cubic grid thats used to pass to MD
ptcl_dist = 10.0 #
# NOTE: this is an arbitrary choice
cutoff_dist = math.sqrt(2)*((2.00 * rad_avg) + ptcl_dist)
nQD_spacing = (2.00 * rad_avg) + ptcl_dist
# Makes number of points along side grid
nQDs = [5, 5, 5]
sysLs = setSystemSizes(nQDs, nQD_spacing)
# Set boundary condition list (used in PBC calc)
xL = sysLs[0]
yL = sysLs[1]
zL = sysLs[2]
bcLs = [0.0, yL[1]-yL[0], zL[1]-zL[0] ] # x is NOT PB
# Status info
if rank == 0:
print "rad_avg = ", rad_avg
print "rad_sig = ", rad_sig
print "cutoff_dist = ", cutoff_dist
print " "
print "bcLs = ", bcLs
print "sysLs = ", sysLs
print " "
#############################################################################################
# Generate initial points
p.barrier()
tmpPoints = setRandomGridPoints(nQDs, rad_avg, ptcl_dist) # Generate global pts lst
allPoints = p.bcast(tmpPoints) # ensures rand pts same across procs
numpoints = len(allPoints) # Total number of points (for diag)
if numpoints == 0:
print "Number of points generated == 0"
sys.exit(3)
myPoints = p.splitListOnProcs(allPoints) # Split elements on across processors
p.barrier()
#############################################################################################
###################################################################
# Store particles in struc and find neighbors/bonds
# ptPos includes index eg. [1, 3.4, 1.2, -2.0]
nanoPtcls = ParticleContainer()
nanoBonds = BondContainer()
for ptPos in allPoints:
axisLoc = [bcLs[1]/2.0, bcLs[2]/2.0]
cylinderRadius = 120.0
inside = isPtInCylinder(ptPos[1:], axisLoc, "yz", cylinderRadius)
if inside:
pt = Particle(ptPos[1:], type="QDbig", mass=2.0)
tagsD = {"molnum":1, "QDSizeAvg":20.0}
else:
pt = Particle(ptPos[1:], type="QDsmall", mass=1.0)
tagsD = {"molnum":1, "QDSizeAvg":15.0}
pt.setTagsDict(tagsD)
nanoPtcls.put(pt)
p.barrier()
# Get bond info
allDist, allNeighbors, numTotalNeighbors, allBonds = \
setQDNeighbors(myPoints, allPoints, cutoff_dist, bcLs, rank, size)
if rank == 0:
print "Begin building bond container"
# Put bonds into container
for bond in allBonds:
if not nanoBonds.hasBond(bond): # Check if bond is unique
bnd = Bond(bond[0], bond[1], type="normBond") # Put into STREAMM object
nanoBonds.put(bnd) # add if not in container
p.barrier()
if rank == 0:
print "length of bond container = ", len(nanoBonds)
###############################################################################
############################################################################
# Write LAMMPS file with atoms/bonds
strucQD = StructureContainer(nanoPtcls, nanoBonds)
simObjQD = SimulationLAMMPS1("LammpsAug14", verbose=False)
simObjQD.setStructureContainer(strucQD)
if isinstance(simObjQD, SimulationLAMMPS1):
print "strucQD is a SimulationLAMMPS1"
else:
print "strucQD is NOT a SimulationLAMMPS1"
boxSizes = sysLs
strucQD.setBoxLengths(boxSizes)
small_rad_avg = 15.0
big_bond_min = (2.0* rad_avg) + ptcl_dist
small_sigma_min = ((2.0*small_rad_avg) + ptcl_dist) / pow(2, 1/6.)
big_sigma_min = ((2.0* rad_avg) + ptcl_dist) / pow(2, 1/6.)
ptclParamMap = {("QDsmall", "epsilon"):1.0, ("QDsmall", "sigma"):small_sigma_min,
("QDbig", "epsilon"):1.0, ("QDbig", "sigma"):big_sigma_min}
# Just one bond type for now
bondParamMap = {("normBond", "Kenergy"):1.0, ("normBond", "r0"):big_bond_min}
if rank == 0:
# nanoPtcls.scatterPlot()
# strucQD.dumpLammpsInputFile("qd.data", ptclParamMap, bondParamMap)
# strucQD.writeInput("qd.data", ptclParamMap, bondParamMap)
# simObjQD.writeInput("qd.data", ptclParamMap, bondParamMap)
simObjQD.setCoeffs(ptclParamMap, bondParamMap)
simObjQD.writeInput("qd.data")
# For format of test check
os.system("cat qd.data")
def main():
"""
This test shows structureContainer functionality with angles included
"""
print "************************************************************************************"
print " This test shows structureContainer functionality with angles included"
print "************************************************************************************ \n"
p1 = Particle( [1.1, 1.1, 1.1], "Si", 2.0, 1.23)
p2 = Particle( [2.2, 2.2, 2.2], "Si", 1.0, 2.34)
p3 = Particle( [3.3, 3.3, 3.3], "Si", 1.0, 2.34)
#
p4 = Particle( [4.4, 4.4, 4.4], "C", 1.0, 2.34) # 1
p5 = Particle( [5.5, 5.5, 5.5], "C", 1.0, 2.34) # 2
p6 = Particle( [6.6, 6.6, 6.6], "C", 1.0, 2.34) # 3
b1 = Bond( 1, 2, 1.11, "hooke")
b2 = Bond( 2, 3, 2.22, "hooke")
#
b3 = Bond( 1, 2, 3.33, "hooke")
b4 = Bond( 2, 3, 4.44, "hooke")
a1 = Angle(1, 2, 3, 1.11, "harmonic")
#
a2 = Angle(1, 2, 3, 2.22, "harmonic")
atoms1 = ParticleContainer()
atoms2 = ParticleContainer()
atoms1.put(p1)
atoms1.put(p2)
atoms1.put(p3)
#
atoms2.put(p4)
atoms2.put(p5)
atoms2.put(p6)
bonds1 = BondContainer()
bonds2 = BondContainer()
bonds1.put(b1)
bonds1.put(b2)
bonds2.put(b3)
bonds2.put(b4)
angles1 = AngleContainer()
angles2 = AngleContainer()
angles1.put(a1)
angles2.put(a2)
polymer1 = StructureContainer(atoms1, bonds1, angles1)
polymer2 = StructureContainer(atoms2, bonds2, angles2)
del p1, p2, p3, p4, p5, p6, b1, b2, b3, b4, a1, a2
del atoms1, atoms2, bonds1, bonds2, angles1, angles2
print "\n Cleaning memory for initial objects \n"
print "-------------------- Initial structures --------------------"
print "polymer1 = ", polymer1
print "polymer2 = ", polymer2
print " "
print "-------------- After adding (polymer1 += polymer2) ----------------"
polymer2 += polymer1
print "polymer2 = ", polymer2
def main():
"""
This test shows compressing IDs when structureContainer has angles included
"""
p1 = Particle([1.1, 1.1, 1.1], "Si", 2.0, 1.23)
p2 = Particle([2.2, 2.2, 2.2], "Si", 1.0, 2.34)
p3 = Particle([3.3, 3.3, 3.3], "Si", 1.0, 2.34)
p4 = Particle([0.0, 0.0, 0.0], "Si", 1.0, 2.34)
#
p5 = Particle([4.4, 4.4, 4.4], "C", 1.0, 2.34) # 1
p6 = Particle([5.5, 5.5, 5.5], "C", 1.0, 2.34) # 2
p7 = Particle([6.6, 6.6, 6.6], "C", 1.0, 2.34) # 3
b1 = Bond(1, 3, 1.11, "hooke")
b2 = Bond(3, 4, 2.22, "hooke")
#
b3 = Bond(1, 2, 3.33, "hooke")
b4 = Bond(2, 3, 4.44, "hooke")
a1 = Angle(1, 3, 4, 1.11, "harmonic")
#
a2 = Angle(1, 2, 3, 2.22, "harmonic")
atoms1 = ParticleContainer()
atoms2 = ParticleContainer()
atoms1.put(p1)
atoms1.put(p2)
atoms1.put(p3)
atoms1.put(p4)
#
atoms2.put(p5)
atoms2.put(p6)
atoms2.put(p7)
del atoms1[2] # remove 2nd particle so ID's are non-consecutive
bonds1 = BondContainer()
bonds2 = BondContainer()
bonds1.put(b1)
bonds1.put(b2)
bonds2.put(b3)
bonds2.put(b4)
angles1 = AngleContainer()
angles2 = AngleContainer()
angles1.put(a1)
angles2.put(a2)
polymer1 = StructureContainer(atoms1, bonds1, angles1)
polymer2 = StructureContainer(atoms2, bonds2, angles2)
del p1, p2, p3, p4, p5, p6, b1, b2, b3, b4, a1, a2
del atoms1, atoms2, bonds1, bonds2, angles1, angles2
print "\n Cleaning memory for initial objects \n"
print "-------------------- Initial structures --------------------"
print "polymer1 = ", polymer1
print "polymer2 = ", polymer2
print " "
print "-------------- After adding (polymer2 += polymer1) ----------------"
polymer2 += polymer1
print "polymer2 = ", polymer2
polymer2.compressPtclIDs()
print "-------------------- After compressing --------------------"
print "polymer2 = ", polymer2
def main():
"""
This test shows various operators within Dihedral and DihedralContainer classes
Also shows memory management structure and access methods
"""
print "************************************************************************************"
print " This test shows various operators within Dihedral and DihedralContainer classes "
print " Also shows memory management structure and access methods "
print "************************************************************************************ \n"
p1 = Particle([1.1, 1.1, 1.1], "Si", 2.0, 1.23)
p2 = Particle([2.2, 2.2, 2.2], "Si", 1.0, 2.34)
p3 = Particle([3.3, 3.3, 3.3], "Si", 1.0, 2.34)
p4 = Particle([4.4, 4.4, 4.4], "Si", 1.0, 2.34)
#
p5 = Particle([5.5, 5.5, 5.5], "C", 1.0, 2.34)
p6 = Particle([6.6, 6.6, 6.6], "C", 1.0, 2.34)
p7 = Particle([7.7, 7.7, 7.7], "C", 1.0, 2.34)
p8 = Particle([8.8, 8.8, 8.8], "C", 1.0, 2.34)
b1 = Bond(1, 2, 1.11, "hooke")
b2 = Bond(2, 3, 2.22, "hooke")
#
b3 = Bond(1, 2, 3.33, "hooke")
b4 = Bond(1, 2, 4.44, "hooke")
d1 = Dihedral(1, 2, 3, 4, 1.11, "stiff")
#
d2 = Dihedral(1, 2, 3, 4, 2.22, "stiff")
atoms1 = ParticleContainer()
atoms2 = ParticleContainer()
atoms1.put(p1)
atoms1.put(p2)
atoms1.put(p3)
#
atoms2.put(p4)
atoms2.put(p5)
atoms2.put(p6)
bonds1 = BondContainer()
bonds2 = BondContainer()
bonds1.put(b1)
bonds1.put(b2)
bonds2.put(b3)
bonds2.put(b4)
dihedrals1 = DihedralContainer()
dihedrals2 = DihedralContainer()
dihedrals1.put(d1)
dihedrals2.put(d2)
del p1, p2, p3, p4, p5, p6, b1, b2, b3, b4, d1, d2
print "\n Cleaning memory for initial objects \n"
print "dihedral1 container"
print dihedrals1
print " "
print "dihedral2 container"
print dihedrals2
print "Testing 'in' operator (1 in dihedrals1)"
if (1 in dihedrals1):
print "dihedrals1 contains gid 1"
else:
print "key not found in dihedrals1"
print "Testing 'in' operator (5 in dihedrals1)"
if (5 in dihedrals1):
print "dihedrals1 contains gid 5"
else:
print "key not found in dihedrals1"
print " "
dihedrals1 += dihedrals2
print "Will print the new dihedrals1 after adding dihedrals1 += dihedrals2"
print dihedrals1
print "Check for pre-existing dihedral"
if dihedrals1.hasDihedral([4, 3, 2, 1]):
print "dihedral 1--2--3--4 exists"
else:
print "dihedral 1--2--3--4 does NOT exists"
print "Check for pre-existing dihedral"
if dihedrals1.hasDihedral([2, 3, 1, 4]):
print "dihedral 2--3--1--4 exists"
else:
print "dihedral 2--3--1--4 does NOT exists"
def main():
"""
This test shows structureContainer functionality with dihedrals included
"""
print "************************************************************************************"
print " This test shows structureContainer functionality with dihedrals included"
print "************************************************************************************ \n"
p1 = Particle([1.1, 1.1, 1.1], "Si", 2.0, 1.23)
p2 = Particle([2.2, 2.2, 2.2], "Si", 1.0, 2.34)
p3 = Particle([3.3, 3.3, 3.3], "Si", 1.0, 2.34)
p4 = Particle([4.4, 4.4, 4.4], "Si", 1.0, 2.34)
#
p5 = Particle([5.5, 5.5, 5.5], "C", 1.0, 2.34) # 1
p6 = Particle([6.6, 6.6, 6.6], "C", 1.0, 2.34) # 2
p7 = Particle([7.7, 7.7, 7.7], "C", 1.0, 2.34) # 3
p8 = Particle([8.8, 8.8, 8.8], "C", 1.0, 2.34) # 4
b1 = Bond(1, 2, 1.11, "hooke")
b2 = Bond(2, 3, 2.22, "hooke")
b3 = Bond(3, 4, 3.33, "hooke")
#
b4 = Bond(1, 2, 4.44, "hooke")
b5 = Bond(2, 3, 5.55, "hooke")
b6 = Bond(3, 4, 6.66, "hooke")
a1 = Angle(1, 2, 3, 1.11, "harmonic")
#
a2 = Angle(1, 2, 3, 2.22, "harmonic")
d1 = Dihedral(1, 2, 3, 4, 1.11, "stiff")
#
d2 = Dihedral(1, 2, 3, 4, 2.22, "stiff")
atoms1 = ParticleContainer()
atoms2 = ParticleContainer()
atoms1.put(p1)
atoms1.put(p2)
atoms1.put(p3)
atoms1.put(p4)
#
atoms2.put(p5)
atoms2.put(p6)
atoms2.put(p7)
atoms2.put(p8)
bonds1 = BondContainer()
bonds2 = BondContainer()
bonds1.put(b1)
bonds1.put(b2)
bonds1.put(b3)
#
bonds2.put(b4)
bonds2.put(b5)
bonds2.put(b6)
angles1 = AngleContainer()
angles2 = AngleContainer()
angles1.put(a1)
angles2.put(a2)
dih1 = DihedralContainer()
dih2 = DihedralContainer()
dih1.put(d1)
dih2.put(d2)
polymer1 = StructureContainer(atoms1, bonds1, angles1, dih1)
polymer2 = StructureContainer(atoms2, bonds2, angles2, dih2)
del p1, p2, p3, p4, p5, p6, p7, p8
del b1, b2, b3, b4, b5, b6, a1, a2, d1, d2
del atoms1, atoms2, bonds1, bonds2, angles1, angles2, dih1, dih2
print "\n Cleaning memory for initial objects \n"
print "-------------------- Initial structures --------------------"
print "polymer1 = ", polymer1
print "polymer2 = ", polymer2
print " "
print "-------------- After adding (polymer1 += polymer2) ----------------"
polymer2 += polymer1
print "polymer2 = ", polymer2
def main():
"""
This test shows various operators within Angle and AngleContainer classes.
Shows memory management structure and access methods
"""
p1 = Particle([1.1, 1.1, 1.1], "Si", 2.0, 1.23)
p2 = Particle([2.2, 2.2, 2.2], "Si", 1.0, 2.34)
p3 = Particle([3.3, 3.3, 3.3], "Si", 1.0, 2.34)
#
p4 = Particle([4.4, 4.4, 4.4], "C", 1.0, 2.34) # ptcl 1
p5 = Particle([5.5, 5.5, 5.5], "C", 1.0, 2.34) # ptcl 2
p6 = Particle([6.6, 6.6, 6.6], "C", 1.0, 2.34) # ptcl 3
b1 = Bond(1, 2, 1.11, "hooke")
b2 = Bond(2, 3, 2.22, "hooke")
#
b3 = Bond(1, 2, 3.33, "hooke")
b4 = Bond(2, 3, 4.44, "hooke")
a1 = Angle(1, 2, 3, 1.11, "harmonic")
#
a2 = Angle(1, 2, 3, 2.22, "harmonic")
atoms1 = ParticleContainer()
atoms2 = ParticleContainer()
atoms1.put(p1)
atoms1.put(p2)
atoms1.put(p3)
#
atoms2.put(p4)
atoms2.put(p5)
atoms2.put(p6)
bonds1 = BondContainer()
bonds2 = BondContainer()
bonds1.put(b1)
bonds1.put(b2)
bonds2.put(b3)
bonds2.put(b4)
angles1 = AngleContainer()
angles2 = AngleContainer()
angles1.put(a1)
angles2.put(a2)
del p1, p2, p3, p4, p5, p6, b1, b2, b3, b4, a1, a2
print "\n Cleaning memory for initial objects \n"
print "angles1 container"
print angles1
print " "
print "angles2 container"
print angles2
print "Testing 'in' operator (1 in angles1)"
if (1 in angles1):
print "angles1 contains gid 1"
else:
print "key not found in angles1"
print "Testing 'in' operator (5 in angles1)"
if (5 in angles1):
print "angles1 contains gid 5"
else:
print "key not found in angles1"
print " "
angles1 += angles2
print "Will print the new angles1 after adding angles1 += angles2"
print angles1
print "Check for pre-existing angle"
if angles1.hasAngle([3, 2, 1]):
print "angle 1--2--3 exists"
else:
print "angle 1--2--3 does NOT exists"
print "Check for pre-existing angle"
if angles1.hasAngle([2, 3, 1]):
print "angle 2--3--1 exists"
else:
print "angle 2--3--1 does NOT exists"
def main():
"""
This test shows how to add StructureContainer objects together
"""
print "************************************************************************************"
print " This test shows how to add StructureContainer objects together "
print "************************************************************************************ \n"
p1 = Particle([0.2, 1.3, 33.0], "Si", 2.0, 1.23)
p2 = Particle([5.0, 2.3, -22.1], "C", 1.0, 2.34)
p3 = Particle([5.0, 2.3, -20.1], "C", 1.0, 2.34)
b1 = Bond(1, 2, 1.233, "hooke")
b2 = Bond(2, 3, 0.500, "hooke")
atoms1 = ParticleContainer()
atoms1.put(p1)
atoms1.put(p2)
atoms1.put(p3)
bonds1 = BondContainer()
bonds1.put(b1)
bonds1.put(b2)
polymer1 = StructureContainer(atoms1, bonds1) # Complete structure 1
p1other = Particle([0.0, 2.3, -20.1], "C", 1.0, 2.34)
p2other = Particle([50.0, 0.3, -0.1], "Ar", 2.0, 2.34)
b1other = Bond(1, 2, 1.233,
"hooke") # Correct ptclIDs for second structure
atoms2 = ParticleContainer()
atoms2.put(p1other)
atoms2.put(p2other)
bonds2 = BondContainer()
bonds2.put(b1other)
polymer2 = StructureContainer(atoms2, bonds2) # Complete structure 2
print "Number of particles in polymer2 = ", polymer2.getPtclNum()
del p1, p2, p3, p1other, p2other, b1, b2, b1other, atoms1, atoms2, bonds1, bonds2
print "\n Cleaning memory for initial objects \n"
print "-------------------- Before adding --------------------"
print "polymer1 = ", polymer1
print "polymer2 = ", polymer2
print " "
print "-------------------- After adding --------------------"
polymer1 += polymer2
print "polymer1 = ", polymer1
print "Number of particles in polymer1 after add = ", polymer1.getPtclNum()
print "-------------------- Results (check above) --------------------"
print " 1---b1---2---b2---3 + 1---b1----2 should go to"
print " "
print " 1---b1---2---b2---3 4---b3----5 \n"
print " "
print "------ After adding polymer 2 should be unchanged--------------"
print "polymer2 = ", polymer2
def __iadd__(self, other):
"""
'Magic' method to implement the '+=' operator (eg struc1 += struc2)
Compare global IDs of particles and reassign globalIDs for particle
container using the max ID between the two lists. Tracks these changes
for all other (bond, angle, dihedral) containers that reference particleIDs
"""
self.verbose = False
# Empty container checks
if len(other) == 0: # If struc2 is empty (has no particles)
return self # simply return unchanged current container
if len(self
) == 0: # If struc1 (this struc) is empty (has no particles)
return copy.deepcopy(other) # full copy other and return
#
# Special method for connecting building blocks
#
# Count number of connectors
connect_along_bond = False
if (self.type != "mol" and other.type != "mol"):
# IF not complete molecules that will just be added
# connect along bonds
connect_along_bond = True
self.cnt_connectors()
other.cnt_connectors()
if (self.verbose):
log_line = "\n building block 1 type {} ".format(self.type)
log_line += "\n building block 1 has {} connections ".format(
self.connect_cnt)
log_line += "\n building block 1 has {} func connections ".format(
self.func_connect_cnt)
log_line += "\n building block 2 type {} ".format(other.type)
log_line += "\n building block 2 has {} connections ".format(
other.connect_cnt)
log_line += "\n building block 2 has {} func connections ".format(
other.func_connect_cnt)
print log_line
self.connect_id = "term_"
self.cap_id = "termcap_"
other.connect_id = "term_"
other.cap_id = "termcap_"
if (self.type == "unit" and other.type == "unit"):
self.connectionpoint = 1
other.connectionpoint = 0
new_termpoint = 1
elif (self.type == "term" and other.type == "unit"):
# elif( self.connect_cnt == 1 and other.connect_cnt == 2 ):
self.connectionpoint = 0
other.connectionpoint = 0
new_termpoint = 0
elif (self.type == "term" and other.type == "term"):
# elif( self.connect_cnt == 1 and other.connect_cnt == 1 ):
self.connectionpoint = 0
other.connectionpoint = 0
new_termpoint = -1
elif (self.type == "unit" and other.type == "term"):
#elif( self.connect_cnt == 2 and other.connect_cnt == 1 ):
self.connectionpoint = 1
other.connectionpoint = 0
new_termpoint = -1
elif (self.type == "unit" and other.type == "func"):
#elif( self.connect_cnt == 2 and other.connect_cnt == 1 ):
self.connect_id = "func_"
self.cap_id = "funccap_"
# this is zero since each functional possition will be removed once a functional group is added
self.connectionpoint = 0
other.connect_id = "term_"
other.connectionpoint = 0
new_termpoint = -1
else:
error_line = " Unknow connection configuration {} - {} \n".format(
self.type, other.type)
error_line += " building block 1 has {} connnections \n".format(
self.connect_cnt)
error_line += " building block 2 has {} connnections \n".format(
other.connect_cnt)
sys.exit(error_line)
if (self.verbose):
log_line = "\n Adding connection along bond "
log_line += "\n Connecting block 2 {} at point {} ".format(
other.connect_id, other.connectionpoint)
log_line += "\n to block 1 {} at point {} ".format(
self.connect_id, self.connectionpoint)
print log_line
# Shift second buildingblock so first connector is bonded to the second connector of first buildingblock
if (self.verbose): print " Shift along bonds "
self.align_termbond(self.connectionpoint, origin="term")
other.align_termbond(other.connectionpoint, origin="termcap")
if (self.verbose): print " Find terminal atoms "
self.get_connectors(self.connectionpoint)
other.get_connectors(other.connectionpoint)
bond_length = np.array([
self.ptclC[self.pid_term].radii +
other.ptclC[other.pid_term].radii, 0.0, 0.0
])
# Shift second building block to have the correct bond length
other.ptclC.shift(
(bond_length -
1.0 * np.array(other.ptclC[other.pid_term].position)))
# Delete termcaps
self.bondC.deletepid(self.pid_termcap)
other.bondC.deletepid(other.pid_termcap)
del self.ptclC[self.pid_termcap]
del other.ptclC[other.pid_termcap]
# Reset term tags to null
self.ptclC[self.pid_term].tagsDict["cplytag"] = ""
other.ptclC[other.pid_term].tagsDict["cplytag"] = ""
# If an intern ring connection is made change the fftype
if (self.ptclC[self.pid_term].tagsDict["ring"] > 0
and other.ptclC[other.pid_term].tagsDict["ring"] > 0):
#print " ring self ", self.ptclC[self.pid_term].tagsDict["ring"]
#print " ring other ", other.ptclC[other.pid_term].tagsDict["ring"]
self.ptclC[self.pid_term].tagsDict["fftype"] = 'C!'
other.ptclC[other.pid_term].tagsDict["fftype"] = 'C!'
# sys.exit(" ring test ")
idFromToDict = dict(
) # Need to keep track of all ptcl ID changes at once
# {fromID1:toID1, fromID2:toID2...}
# eg {1:3, 3:5, 2:20...}
bondC = BondContainer() # Local bond container copy so ptclIDs
angleC = AngleContainer() # Local angle container copy so ptclIDs
dihC = DihedralContainer() # Local dihedral container copy so ptclIDs
bondC = copy.deepcopy(
other.bondC) # inside can be changed (for adding below)
angleC = copy.deepcopy(
other.angleC) # inside can be changed (for adding below)
dihC = copy.deepcopy(
other.dihC) # inside can be changed (for adding below)
impC = copy.deepcopy(
other.impC) # inside can be changed (for adding below)
keys1 = self.ptclC.particles.keys(
) # global IDs of particles in this object
keys2 = other.ptclC.particles.keys(
) # global IDs in object being added
self.ptclC.maxgid = max(
keys1 + keys2) # find max globalID in keys, set this object maxID
self.get_max()
other.get_max()
# Update chain, residue and charge group number
if (self.max_chain == other.max_chain):
other.shift_tag("qgroup", self.max_qgroup)
other.shift_tag("residue", self.max_residue)
other.shift_tag("ring", self.max_ring)
else:
other.add_chain(self.max_chain)
for ptclkey2 in other.ptclC.particles:
self.ptclC.put(other.ptclC.particles[ptclkey2]
) # Pushes ptcl to this struc's ptcl container
fromPtclID = ptclkey2 # Track IDs from--->to
toPtclID = self.ptclC.maxgid # --> toID (to is the maxid of this ptclC)
idFromToDict[fromPtclID] = toPtclID # Store ID changes
if (connect_along_bond):
# Add inter building block bond
if (self.verbose): print " Add inter building block bond "
bb_bb = Bond(self.pid_term, idFromToDict[other.pid_term])
self.bondC.put(bb_bb)
bondC.replacePtclIDs(idFromToDict) # Use tracked list of ID changes
self.bondC += bondC # Now add bondC with 'corrected' IDs
angleC.replacePtclIDs(
idFromToDict) # Now add angleC with 'corrected' IDs
self.angleC += angleC # Use tracked list of ID changes
dihC.replacePtclIDs(idFromToDict) # Use tracked list of ID changes
self.dihC += dihC # Now add dihC with 'corrected' IDs
impC.replacePtclIDs(idFromToDict) # Use tracked list of ID changes
self.impC += impC # Now add impC with 'corrected' IDs
if (connect_along_bond):
self.compressPtclIDs()
self.bondC_nblist()
if (new_termpoint >= 0):
if (self.verbose): print " Add new cplytag to "
self.get_connectors(new_termpoint)
self.ptclC[
self.pid_term].tagsDict["cplytag"] = "term_C({})".format(
self.pid_term)
self.ptclC[self.pid_termcap].tagsDict[
"cplytag"] = "termcap_H({})_on_C({})".format(
self.pid_termcap, self.pid_term)
# Append segments
for seg_i in other.segments:
self.segments.append(seg_i)
return self
