def setRawRdcConstraintItemMembers(self):
for i in range(0,2):
(chainCode,seqCode,spinSystemId,seqInsertCode,atomName) = getNameInfo(self.resSetNames[i])
self.rawConstraintItem.members.append(self.rawConstraintItemMemberClass(chainCode,seqCode,atomName))
def resonanceInfo(self, guiParent, resonanceName):
infoValues = getNameInfo(resonanceName)
infoItems = [
'Original chain code:', 'Original sequence code:',
'Original atom name:'
]
if infoValues[2] != None and infoValues[1] == None:
infoValues = infoValues[0:1] + infoValues[2:3] + infoValues[4:]
infoItems[1] = 'Original spin system code:'
elif infoValues[3]:
#Combine seqCode and seqInsertCode
infoValues = infoValues[0:1] + (str(infoValues[1]) +
infoValues[3], ) + infoValues[4:]
else:
infoValues = infoValues[0:2] + infoValues[4:]
infoList = []
infoDict = {}
for i in range(0, len(infoItems)):
infoList.append(infoItems[i])
infoDict[infoItems[i]] = infoValues[i]
infoText = "This name reflects the information from the imported file(s)."
popup = InfoPopup(guiParent, 'Resonance name info', infoText, infoList,
infoDict)
self.waitWindow(guiParent, popup)
return popup
def findResonances(self, resName):
(chainCode, seqCode, spinSystemId, seqInsertCode,
atomName) = getNameInfo(resName)
#print '\tsearch for resonance', (chainCode,seqCode,spinSystemId,seqInsertCode,atomName)
resonance = None
targetMolSystem = None
if len(self.project.molSystems) == 1 and self.defaultMolSystem == None:
targetMolSystem = self.project.molSystems[0]
elif self.defaultMolSystem != None:
targetMolSystem = self.project.findFirstMolSystem(
name=self.defaultMolSystem)
targetChain = None
if targetMolSystem != None:
if len(targetMolSystem.chains
) == 1 and self.defaultChainCode == None:
targetChain = targetMolSystem.chains[0]
elif self.defaultChainCode != None:
targetChain = targetMolSystem.findFirstChain(
code=self.defaultChainCode)
targetResidue = None
if seqCode != None and targetChain != None:
targetResidue = targetChain.findFirstResidue(seqCode=seqCode)
targetAtoms = []
targetAtomSets = []
#print atomName
atomNameLength = len(atomName)
while atomName[-1] == '*':
#print 'pre',atomName
atomName = atomName[:-1]
#print 'post',atomName
#print atomName
if targetResidue != None:
for atom in targetResidue.atoms:
if atom.name.startswith(atomName) and len(
atom.name) == atomNameLength:
targetAtoms.append(atom)
targetAtomSets.append(atom.atomSet)
targetResonances = set()
for atom in targetAtoms:
for resonanceSet in atom.atomSet.resonanceSets:
#for resonance in resonanceSet.resonances:
targetResonances.update(resonanceSet.resonances)
#print ''
if len(targetResonances) > 1:
selectName = '.'.join((chainCode, ` seqCode `, atomName), )
resonanceIds = [
` resonance.serial ` for resonance in targetResonances
]
print 'Warning: found more than one resonance for peak (%s) %s' % (
def setRawRdcConstraintItemMembers(self):
itemResonances = getResonancesFromPairwiseConstraintItem(self.item)
for i in range(0, 2):
(chainCode, seqCode, spinSystemId, seqInsertCode,
atomName) = getNameInfo(self.resSetNames[i])
resLabel = self.getResonanceResLabel(itemResonances[i])
self.rawConstraintItem.members.append(
self.rawConstraintItemMemberClass(chainCode, seqCode, resLabel,
atomName))
def setRawDistanceConstraintItemMembers(self):
for i in range(0, 2):
(chainCode, seqCode, spinSystemId, seqInsertCode,
atomName) = getNameInfo(self.resSetNames[i])
if atomName == allResidueAtoms_kw:
atomName = None
self.rawConstraintItem.members.append(
self.rawConstraintItemMemberClass(chainCode, seqCode,
atomName))
def setRawRdcConstraintItemMembers(self):
for coordSystem in ['OO', 'Z', 'X', 'Y']:
self.rawConstraintItem.members.append(
self.rawConstraintItemMemberClass(self.refFrameSegId,
self.refFrameResId,
coordSystem))
for i in range(0, 2):
(chainCode, seqCode, spinSystemId, seqInsertCode,
atomName) = getNameInfo(self.resSetNames[i])
self.rawConstraintItem.members.append(
self.rawConstraintItemMemberClass(chainCode, seqCode,
atomName))
def setRawDistanceConstraintItemMembers(self):
for i in range(2):
resonanceToAtom = self.ccpInfo[i][3]
residue = resonanceToAtom.getResidue()
(chainCode, seqCode, spinSystemId, seqInsertCode,
atomName) = getNameInfo(self.resSetNames[i])
if atomName == allResidueAtoms_kw:
atomName = None
# Using residue.seqCode - OK since useCcpnChainInfo = True for all exports
self.rawConstraintItem.members.append(
self.rawConstraintItemMemberClass(chainCode, residue.seqId,
atomName,
residue.ccpCode.upper()))
def setRawDistanceConstraintItemMembers(self):
itemResonances = getResonancesFromPairwiseConstraintItem(self.item)
for i in range(0, 2):
resonance = itemResonances[i]
resLabel = self.getResonanceResLabel(resonance)
(chainCode, seqCode, spinSystemId, seqInsertCode,
atomName) = getNameInfo(self.resSetNames[i])
if atomName == allResidueAtoms_kw:
print " Error: not handling residue level constraints for %s." % self.format
continue
self.rawConstraintItem.members.append(
self.rawConstraintItemMemberClass(chainCode, seqCode, resLabel,
atomName))
def writeMappingFile(project, outFile, originalFormats=None):
if originalFormats:
checkFormatList = originalFormats
else:
checkFormatList = allFormatsDict.keys()
#
# First check if there's any mapping info at all...
#
formatList = []
allResonances = project.currentNmrProject.sortedResonances()
for format in checkFormatList:
resonancesDict = getApplResNames(format, allResonances)
if resonancesDict != {}:
formatList.append(format)
if formatList == []:
#
# No resonances linked
#
return False
formatList.sort()
fout = open(outFile, 'w')
#
# Write top header with time/user info
#
fout.write("#" + newline)
fout.write("# CcpNmr atom name mapping file." + newline)
fout.write("#" + newline)
fout.write(
"# Contains list of original names from the imported file(s) and the" +
newline)
fout.write("# atom names they were mapped to in the data model." + newline)
fout.write("#" + newline)
fout.write("# File written on %s." % time.ctime() + newline)
fout.write("#" + newline * 2)
for format in formatList:
resonancesDict = getApplResNames(format, allResonances)
resonanceNames = []
#
# Do some sorting...
#
resonancesSortDict = {}
for resonanceName in resonancesDict.keys():
(chainCode, seqCode, spinSystemId, seqInsertCode,
atomName) = getNameInfo(resonanceName)
if seqCode == None:
continue
seqCode = returnInt(seqCode)
if not resonancesSortDict.has_key(chainCode):
resonancesSortDict[chainCode] = {}
if not resonancesSortDict[chainCode].has_key(seqCode):
resonancesSortDict[chainCode][seqCode] = {}
if not resonancesSortDict[chainCode][seqCode].has_key(
seqInsertCode):
resonancesSortDict[chainCode][seqCode][seqInsertCode] = {}
resonancesSortDict[chainCode][seqCode][seqInsertCode][
atomName] = resonanceName
chainCodeList = resonancesSortDict.keys()
chainCodeList.sort()
for chainCode in chainCodeList:
seqCodeList = resonancesSortDict[chainCode].keys()
seqCodeList.sort()
for seqCode in seqCodeList:
seqInsertCodeList = resonancesSortDict[chainCode][
seqCode].keys()
seqInsertCodeList.sort()
for seqInsertCode in seqInsertCodeList:
atomNameList = resonancesSortDict[chainCode][seqCode][
seqInsertCode].keys()
atomNameList.sort()
for atomName in atomNameList:
resonanceNames.append(
resonancesSortDict[chainCode][seqCode]
[seqInsertCode][atomName])
#
# Write it all out
#
if resonancesDict != {}:
fout.write(drawBox("Origin file format: %s" % format, liner="*"))
fout.write(newline)
fout.write(" %-15s %-15s %s" %
('Original name', 'Mapped to atoms',
'Molecules:chains:residues'))
fout.write(newline * 2)
for resonanceName in resonanceNames:
resonances = resonancesDict[resonanceName]
atomNames = []
resCodes = []
moleculeNames = []
chainCodes = []
for resonance in resonances:
atomName = ""
resonanceSet = resonance.resonanceSet
if resonanceSet:
for atomSet in resonanceSet.atomSets:
#
# Get some info out of data model for clarity...
#
residue = atomSet.findFirstAtom().residue
resCode = residue.molResidue.ccpCode + str(
residue.seqCode) + string.strip(
residue.seqInsertCode)
chainCode = residue.chain.code
moleculeName = residue.chain.molecule.name
if resCode not in resCodes:
resCodes.append(resCode)
if chainCode not in chainCodes:
chainCodes.append(chainCode)
if moleculeName not in moleculeNames:
moleculeNames.append(moleculeName)
#
# Get name of atom(s) this resonance was mapped to
#
atomName += atomSet.name + "/"
if atomName:
atomName = atomName[:-1]
if atomName not in atomNames:
atomNames.append(atomName)
if atomNames != []:
moleculeText = string.join(moleculeNames, ',')
chainText = string.join(chainCodes, ',')
resCodesText = string.join(resCodes, ',')
addText = moleculeText + ':' + chainText + ':' + resCodesText
fout.write(" %-15s -> %-15s %s" %
("'" + resonanceName + "'",
string.join(atomNames, ','), addText))
else:
fout.write(" %-15s %-15s" %
("'" + resonanceName + "'", 'NOT LINKED'))
fout.write(newline)
return True
def getFormatFileInformation(self,resonances,importFormatName):
"""
This function will pull the original chain/residue/atom names from the resonances
that were created on file import (and input to this function).
Created are:
self.formatFileChainDict = {'chainCode': [(seqCode1,seqInsertCode1),(seqCode2,seqInsertCode2), ...]}
self.formatFileResidueDict = {'chainCode': {(seqCode,seqInsertCode): [residueLabel, [atomName1, atomName2, ...]]}}
self.formatFileHasResLabels True/False, indicates whether residue labels are available.
"""
self.formatFileChainDict = {}
self.formatFileResidueDict = {}
self.formatFileHasResLabels = False
for resonance in resonances:
#
# Now set up resonance stuff... for either normal or fixed resonances
#
resonanceLinked = False
resonanceSet = resonance.resonanceSet
# This should never be true, keep anyway.
if resonanceSet:
atomSets = resonanceSet.atomSets
for atomSet in atomSets:
if atomSet.atoms:
resonanceLinked = True
break
#
# Only handle if not linked
#
if not resonanceLinked:
resNames = updateResonanceNamesDict(resonance,{},importFormatName)
resLabel = None
resLabelAppData = resonance.findFirstApplicationData(application = importFormatName, keyword = 'origResLabel')
if resLabelAppData:
resLabel = resLabelAppData.value
for resName in resNames:
#
# Check if the name can be decomposed or not (no use if not!)
#
(chainCode,seqCode,spinSystemId,seqInsertCode,atomName) = getNameInfo(resName,verbose = 0)
if seqCode != None:
# Keep track of reported chainCodes for linking later on
if not self.formatFileChainDict.has_key(chainCode):
self.formatFileChainDict[chainCode] = []
self.formatFileResidueDict[chainCode] = {}
seqCodeKey = (seqCode,seqInsertCode)
# Also keep track of reported seqCodes and seqInsertCodes
if seqCodeKey not in self.formatFileChainDict[chainCode]:
self.formatFileChainDict[chainCode].append(seqCodeKey)
self.formatFileResidueDict[chainCode][seqCodeKey] = [resLabel,[]]
if resLabel:
self.formatFileHasResLabels = True
if atomName not in self.formatFileResidueDict[chainCode][seqCodeKey][1]:
self.formatFileResidueDict[chainCode][seqCodeKey][1].append(atomName)
if not self.formatFileResidueDict[chainCode][seqCodeKey][0] and resLabel:
self.formatFileResidueDict[chainCode][seqCodeKey][0] = resLabel
self.formatFileHasResLabels = True
def setRawDihedralConstraintItemMembers(self):
#
# For Dyana, set the angle name (and derive correct angle name from atom names if none found)
#
(chain, seqId, atomName, resToAtom) = self.ccpInfo[0]
molecule = chain.molecule
if not self.moleculeTorsions.has_key(molecule):
if self.verbose:
print " Error: unknown molecule '%s'!" % (molecule.name)
return
#
# Find out which residue this torsion angle is for and make a list of chemAtoms...
#
seqIds = {}
chemAtoms = []
constraintResonances = self.constraint.resonances
for i in range(0, self.constraintResNum):
(chain, seqId, atomName, resToAtom) = self.ccpInfo[i]
if not seqIds.has_key(seqId):
seqIds[seqId] = 0
seqIds[seqId] += 1
chemAtoms.append(resToAtom.chemAtom)
resLabel = self.getResonanceResLabel(constraintResonances[i])
(chainCode, seqCode, spinSystemId, seqInsertCode,
atomName) = getNameInfo(self.resSetNames[i])
self.rawConstraintItem.members.append(
self.rawConstraintItemMemberClass(chainCode, seqCode, resLabel,
atomName))
if len(seqIds) > 1:
seqId = -99999999999
maxNum = 0
for tSeqId in seqIds.keys():
if seqIds[tSeqId] > maxNum or (seqIds[tSeqId] == maxNum
and tSeqId > seqId):
maxNum = seqIds[tSeqId]
seqId = tSeqId
else:
seqId = seqIds.keys()[0]
residue = chain.findFirstResidue(seqId=seqId)
if not residue:
if self.verbose:
print " Error: could not identify residue with seqId %d in chain '%s'!" % (
seqId, chain.code)
return
molRes = residue.molResidue
if not molRes or not self.moleculeTorsions[molecule].has_key(molRes):
if self.verbose:
print " Error: no molresidue for residue with seqId %d in chain '%s'!" % (
seqId, chain.code)
return
#
# Now get the relevant torsion angles for this molecule, molResidue, and determine which one it is...
#
# Note that (in torsion terms) H-N-CA-HA is the same as N-H-HA-CA! (described by _inout)
#
matchPatterns = {
'forward': {},
'backward': {},
'forward_inout': {},
'backward_inout': {}
}
matchInfo = (('forward', (0, 1, 2, 3)), ('backward', (3, 2, 1, 0)),
('forward_inout', (1, 0, 3, 2)), ('backward_inout',
(2, 3, 0, 1)))
torsion = None
for (torsion, atomList) in self.moleculeTorsions[molecule][molRes]:
#
# Check matching atoms...
#
for (matchType, matchIndexes) in matchInfo:
match = ""
# AtomList sometimes not complete!
if len(atomList) == self.constraintResNum:
for i in range(0, self.constraintResNum):
caIndex = matchIndexes[i]
if chemAtoms[caIndex] == atomList[i][1]:
match += "1"
else:
match += "0"
if match == '1111':
# All is fine...
matchPatterns = {}
break
else:
matchPatterns[matchType][match] = torsion
if not matchPatterns:
break
#
# Try to see if the angle can be converted...
#
if matchPatterns or not torsion:
#print molRes.ccpCode
#for ca in chemAtoms:
# print ca.name,
#print
torsion = None
#for (matchType,matchIndexes) in matchInfo:
# patterns = matchPatterns[matchType].keys()
# patterns.sort()
# for pattern in patterns:
# print " ",matchType,pattern,
# for ca in matchPatterns[matchType][pattern].chemAtoms:
# print ca.name,
# print
for pattern in ("0111", "1110", "0110"):
for (matchType, matchIndexes) in matchInfo:
if matchPatterns[matchType].has_key(pattern):
torsion = matchPatterns[matchType][pattern]
if matchType[:8] == 'backward':
chemAtoms.reverse()
if matchType[-5:] == 'inout':
tca = chemAtoms[:]
chemAtoms[0] = tca[1]
chemAtoms[1] = tca[0]
chemAtoms[2] = tca[3]
chemAtoms[3] = tca[2]
break
#
# Have to work 'locally' within chemComp for this... use prev/next coords as well
#
if torsion:
# TODO: need something similar to chemComp XML file copying here?!??!
ccc = None
for coordSysName in ('ideal', 'pdb'):
ccc = self.project.findFirstChemCompCoord(
sourceName=coordSysName,
molType=molRes.molType,
ccpCode=molRes.ccpCode
) # , showError = self.messageReporter.showError)
if ccc:
break
# TODO: really need to calculate angle between two sets of 3 atoms, with 2 atoms shared (??)
angles = {}
#print torsion.name
for (angleType, caList) in (('ref', torsion.chemAtoms),
('actual', chemAtoms)):
coords = []
angles[angleType] = None
for ca in caList:
if not ca:
coords.append(None)
else:
#print ca.name,
coord = ccc.findFirstChemAtomCoord(chemAtom=ca)
if coord:
coords.append((coord.x, coord.y, coord.z))
else:
coords.append(None)
#print
#print coords
if None not in coords:
angles[angleType] = calcTorsionAngleDegrees(
coords[0], coords[1], coords[2], coords[3])
else:
#
# Special case... O used instead of CA for OMEGA
#
if torsion.name == 'OMEGA' and angleType == 'actual':
if coords[2] and coords[3]:
angles['actual'] = angles['ref'] - 180.00
if chemAtoms[3].name == 'H':
angles['actual'] += 180.00
if None not in angles.values():
#
# Have all reference info, now reset the value...
#
#print angles
# TODO: IS THIS ALWAYS CORRECT??? CHECK WITH WAYNE!!
angleDiff = angles['ref'] - angles['actual']
lowerLimit = self.rawConstraint.lowerAngle + angleDiff
upperLimit = self.rawConstraint.upperAngle + angleDiff
if lowerLimit > 360.0 and upperLimit > 360.0:
lowerLimit -= 360.0
upperLimit -= 360.0
#print angleDiff, lowerLimit, upperLimit
self.rawConstraint.setAngleData(lowerLimit, upperLimit)
else:
torsion = None
if torsion:
namingSystem = torsion.chemComp.findFirstNamingSystem(
name=self.namingSystemName)
if namingSystem:
torsionSysName = torsion.findFirstSysName(
namingSystem=namingSystem)
if torsionSysName:
self.rawConstraint.name = torsionSysName.sysName
elif self.verbose:
print " Error: could not find a %s sysName for %s, angle name %s" % (
self.namingSystemName, molRes.ccpCode, torsion.name)
elif self.verbose:
print " Error: could not find a %s naming system for chemComp %s" % (
self.namingSystemName, molRes.ccpCode)
else:
if self.verbose:
if None not in chemAtoms:
print " Error: could not define a torsion angle name for %s, atoms %s-%s-%s-%s." % (
molRes.ccpCode, chemAtoms[0].name, chemAtoms[1].name,
chemAtoms[2].name, chemAtoms[3].name)
else:
print " Error: could not define a torsion angle name for %s because of missing chemAtoms" % (
molRes.ccpCode)
def duplicateResonances(nmrConstraintStore,format,mappingDict):
#
# Check which resonances have to be copied, and copy...
#
resonanceMappingDict = {}
copyResonances = []
resonanceDict = {}
copyConstraints = []
constrLinks = ['dihedralConstraints','chemShiftConstraints']
copyConstraintItems = {}
copyConstraintItemsList = []
#
# First determine which resonances are eligible for copying, and create a dictionary with resNames...
#
for resonance in nmrConstraintStore.sortedFixedResonances():
applData = resonance.findFirstApplicationData(application = format, keyword = assign_kw)
if applData:
resName = applData.value
resonanceDict[resName] = resonance
(chain,seqCode,spinSystemId,seqInsertCode,atomName) = getNameInfo(resName)
if mappingDict.has_key(chain):
copyResonances.append(resonance)
#
# Then determine which constraint/items have to be copied (all resonances have to have the same chainCode!!)
#
for resonance in copyResonances:
#
# Constraints
#
for constrLink in constrLinks:
for constr in getattr(resonance,constrLink):
copyConstraint = 1
for otherRes in constr.resonances:
if otherRes not in copyResonances:
copyConstraint = 0
break
if copyConstraint and constr not in copyConstraints:
j = 0
constrKey = (constr.parent.serial,constr.serial)
for j in range(0,):
if constrKey < (copyConstraints[j].parent.serial,copyConstraints[j].serial):
copyConstraints.insert(j,constr)
break
listLen = len(copyConstraints)
if j == (listLen - 1) or listLen == 0:
copyConstraints.append(constr)
#
# ConstraintItems
#
for constrItem in resonance.sortedPairwiseConstraintItems():
copyConstraintItem = 1
for otherRes in constrItem.resonances:
if otherRes not in copyResonances:
copyConstraintItem = 0
break
if copyConstraintItem:
if not copyConstraintItems.has_key(constrItem.constraint):
copyConstraintItems[constrItem.constraint] = []
j = 0
constrKey = (constrItem.constraint.parent.serial,constrItem.constraint.serial)
for j in range(0,len(copyConstraintItemsList)):
if constrKey < (copyConstraintItemsList[j].parent.serial,copyConstraintItemsList[j].serial):
copyConstraintItemsList.insert(j,constrItem.constraint)
break
listLen = len(copyConstraintItemsList)
#print constrKey, j, listLen
if j == (listLen - 1) or listLen == 0:
copyConstraintItemsList.append(constrItem.constraint)
if constrItem not in copyConstraintItems[constrItem.constraint]:
copyConstraintItems[constrItem.constraint].append(constrItem)
#
# Now copy the resonances or find an existing resonance...
#
for resonance in copyResonances:
applData = resonance.findFirstApplicationData(application = format, keyword = assign_kw)
applDataClass = applData.__class__
resName = applData.value
(chain,seqCode,spinSystemId,seqInsertCode,atomName) = getNameInfo(resName)
resonanceMappingDict[resonance] = {}
resonance.removeApplicationData(applData)
newValue = getResName(mappingDict[chain][0],seqCode,atomName,seqInsertCode = seqInsertCode)
resonance.addApplicationData(applDataClass(application = format, keyword = assign_kw, value = newValue))
for i in range(1,len(mappingDict[chain])):
newChainCode = mappingDict[chain][i]
newResName = getResName(newChainCode,seqCode,atomName,seqInsertCode = seqInsertCode)
if resonanceDict.has_key(newResName):
newResonance = resonanceDict[newResName]
print " Using existing resonance %s..." % newResName
else:
print " Creating new resonance %s..." % newResName
newResonance = nmrConstraintStore.newFixedResonance(isotopeCode = resonance.isotopeCode)
resonanceDict[newResName] = newResonance
copyResonanceInfo(resonance,newResonance,toResName = newResName)
applData = newResonance.findFirstApplicationData(application = format, keyword = assign_kw)
applDataClass = applData.__class__
newResonance.removeApplicationData(applData)
newResonance.addApplicationData(applDataClass(application = format, keyword = assign_kw, value = newResName))
#
# Constraints and constraint items have to be deleted and recreated later...
#
for constrLink in constrLinks:
for constr in getattr(newResonance,constrLink):
constr.delete()
for constrItem in newResonance.pairwiseConstraintItems:
constrItem.delete()
resonanceMappingDict[resonance][newChainCode] = newResonance
#
# Loop over the 'new' chain codes...
#
print
print "########################## "
print "# Duplicating resonances # "
print "########################## "
print
for i in range(1,len(mappingDict[chain])):
newChainCode = mappingDict[chain][i]
#
# Copy the relevant dihedral constraints...
#
for constraint in copyConstraints:
print " Copying constraint %d.%d" % (constraint.parent.serial,constraint.serial)
print " Resonances %s" % ', '.join([getResNameText(res) for res in constraint.resonances])
(newResonances, oldToNewResonanceDict) = getMappedResonances(constraint,resonanceMappingDict,newChainCode)
print " to %s" % ', '.join([getResNameText(res) for res in newResonances])
newConstr = constraint.__class__(constraint.parent,resonances = newResonances)
copyAttributeInfo(constraint,newConstr)
for constrItem in constraint.sortedItems():
newConstrItem = constrItem.__class__(newConstr, upperLimit = 1.0, lowerLimit = 0.0)
copyAttributeInfo(constrItem,newConstrItem)
print
#
# ..and the constraints from the relevant constraintItems...
#
for constraint in copyConstraintItemsList:
print " Copying constraint %d.%d" % (constraint.parent.serial,constraint.serial)
newConstr = constraint.__class__(constraint.parent)
copyAttributeInfo(constraint,newConstr)
if hasattr(constraint,'weight'):
newConstr.weight = constraint.weight
for constrItem in constraint.sortedItems():
print " Copying item with resonances %s" % ', '.join([getResNameText(res) for res in constrItem.resonances])
if constrItem in copyConstraintItems[constraint]:
(newResonances, oldToNewResonanceDict) = getMappedResonances(constrItem,resonanceMappingDict,newChainCode)
else:
newResonances = constrItem.resonances
oldToNewResonanceDict = {}
print " to %s" % ', '.join([getResNameText(res) for res in newResonances])
newConstrItem = constrItem.__class__(newConstr,resonances = newResonances)
if constrItem.className in ('DistanceConstraintItem', 'HBondConstraintItem', 'JCouplingConstraintItem', 'RdcConstraintItem'):
firstResonance = constrItem.firstResonance
if oldToNewResonanceDict:
firstResonance = oldToNewResonanceDict[firstResonance]
newConstrItem.firstResonance = firstResonance
copyAttributeInfo(constrItem,newConstrItem)
print
print "###################### "
print "# End of duplication # "
print "###################### "
print
def matchResonToMolSys(resonances,
molSystem,
assignFormat=None,
test=False,
matchMode=False):
#
# Some quick validity checks...
#
if not resonances or (type(resonances) not in (type(('',)),type([]))) or \
not (isinstance(resonances[0],Nmr.Resonance) or isinstance(resonances[0],NmrConstraint.FixedResonance)):
print " Invalid resonance list input - aborting."
return None
#
# Get info from the resonances
#
resChainDict = {}
resResidueDict = {}
for resonance in resonances:
#
# Now set up resonance stuff... for either normal or fixed resonances
#
resonanceLinked = 0
resonanceSet = resonance.resonanceSet
if resonanceSet:
atomSets = resonanceSet.atomSets
for atomSet in atomSets:
atoms = atomSet.atoms
if atoms:
resonanceLinked = 1
break
#
# Only handle if not linked - useless otherwise (???)
#
if not resonanceLinked:
resNames = updateResonanceNamesDict(resonance, {}, assignFormat)
resLabel = None
resLabelAppData = resonance.findFirstApplicationData(
application=assignFormat, keyword='origResLabel')
if resLabelAppData:
resLabel = resLabelAppData.value
for resName in resNames:
#
# Check if the name can be decomposed or not (no use if not!)
#
(chainCode, seqCode, spinSystemId, seqInsertCode,
atomName) = getNameInfo(resName, verbose=0)
if seqCode != None:
# Keep track of reported chainCodes for linking later on
if not resChainDict.has_key(chainCode):
resChainDict[chainCode] = []
resResidueDict[chainCode] = {}
seqCodeKey = (seqCode, seqInsertCode)
# Also keep track of reported seqCodes and seqInsertCodes
if seqCodeKey not in resChainDict[chainCode]:
resChainDict[chainCode].append(seqCodeKey)
resResidueDict[chainCode][seqCodeKey] = [resLabel, []]
if atomName not in resResidueDict[chainCode][seqCodeKey][
1]:
resResidueDict[chainCode][seqCodeKey][1].append(
atomName)
if not resResidueDict[chainCode][seqCodeKey][
0] and resLabel:
resResidueDict[chainCode][seqCodeKey][0] = resLabel
if test:
print resResidueDict
return matchToMolSys(resChainDict,
resResidueDict,
molSystem,
test=test,
matchMode=matchMode)
def setRawDistanceConstraintItemMembers(self):
#
# Expand the information... is necessary for Concoord (only handles individual atoms)
#
atomNameLists = []
for i in range(0, 2):
atomNameLists.append([])
resonanceToAtom = self.ccpInfo[i][3]
chemAtomOrigName = self.ccpInfo[i][2]
if resonanceToAtom.chemAtomSet:
chemAtomOrSet = resonanceToAtom.chemAtomSet
else:
chemAtomOrSet = resonanceToAtom.chemAtom
if chemAtomOrSet:
chemCompVar = resonanceToAtom.getResidue().chemCompVar
namingSystem = chemCompVar.chemComp.findFirstNamingSystem(
name=self.namingSystemName)
if namingSystem:
chemAtomSysName = findChemAtomSysName(
namingSystem, {'sysName': chemAtomOrigName})
else:
chemAtomSysName = None
if chemAtomSysName:
chemAtom = chemCompVar.findFirstChemAtom(
name=chemAtomSysName.atomName,
subType=chemAtomSysName.atomSubType)
else:
chemAtom = chemCompVar.findFirstChemAtom(
name=chemAtomOrigName)
if not chemAtom:
chemAtomSetSysName = findChemAtomSetSysName(
namingSystem, {'sysName': chemAtomOrigName})
if chemAtomSetSysName:
chemAtomSet = chemCompVar.findFirstChemAtomSet(
name=chemAtomSetSysName.atomName,
subType=chemAtomSetSysName.atomSubType)
else:
chemAtomSet = chemCompVar.findFirstChemAtomSet(
name=chemAtomOrigName)
if chemAtomSet:
(chainCode, seqCode, spinSystemId, seqInsertCode,
atomName) = getNameInfo(self.resSetNames[i])
if chemAtomSet.chemAtomSets:
chemAtomSets = list(chemAtomSet.chemAtomSets)
else:
chemAtomSets = [chemAtomSet]
for chemAtomSet in chemAtomSets:
chemAtomSysNames = self.getChemAtomSysNamesFromSet(
chemAtomSet, chemCompVar, findIupac=1)
for chemAtomSysName in chemAtomSysNames:
if chemAtomSysName:
atomNameLists[-1].append(
getResName(
chainCode,
seqCode,
chemAtomSysName,
seqInsertCode=seqInsertCode))
else:
print " Error: problems with decompressing Concoord name %s - sysNames missing for %s" % (
self.resSetNames[i], chemAtomSet.name)
else:
print " Error: can't decompress Concoord name %s" % self.resSetNames[
i]
#
# If no names use default
#
if not atomNameLists[-1]:
atomNameLists[-1].append(self.resSetNames[i])
#
# Now write them one by one...
#
itemResonances = getResonancesFromPairwiseConstraintItem(self.item)
for resSetName0 in atomNameLists[0]:
# TODO: bit risky this one! What if original names (eg GLU-) are being used?!
resonance = itemResonances[0]
resLabel0 = resonance.resonanceSet.findFirstAtomSet(
).findFirstAtom().residue.molResidue.chemComp.ccpCode.upper()
(chainCode0, seqCode0, spinSystemId0, seqInsertCode0,
atomName0) = getNameInfo(resSetName0)
if atomName0 == allResidueAtoms_kw:
print " Error: not handling residue level constraints for %s." % self.format
continue
for resSetName1 in atomNameLists[1]:
# TODO: bit risky this one! What if original names (eg GLU-) are being used?!
resonance = itemResonances[1]
resLabel1 = resonance.resonanceSet.findFirstAtomSet(
).findFirstAtom().residue.molResidue.chemComp.ccpCode.upper()
(chainCode1, seqCode1, spinSystemId1, seqInsertCode1,
atomName1) = getNameInfo(resSetName1)
if atomName1 == allResidueAtoms_kw:
print " Error: not handling residue level constraints for %s." % self.format
continue
#
# Now set all items and members...
#
self.rawConstraint.items.append(self.rawConstraintItemClass())
self.rawConstraintItem = self.rawConstraint.items[-1]
self.rawConstraintItem.members.append(
self.rawConstraintItemMemberClass())
self.rawConstraintItem.members[-1].setInfo(
chainCode0, seqCode0, resLabel0, atomName0)
self.rawConstraintItem.members.append(
self.rawConstraintItemMemberClass())
self.rawConstraintItem.members[-1].setInfo(
chainCode1, seqCode1, resLabel1, atomName1)
def setChainLinks(self,
forceChainMappings=None,
resetMapping=False,
verbose=0):
self.status = True
#
# Don't bother if no chains...
#
if not self.molSystem.chains:
self.messageReporter.showError(
"Error",
"No chains present in molecular system, cannot link CCPN to external format information.",
parent=self.guiParent)
self.status = False
return self.status
#
# Delete if available and resetting mapping
#
if self.nameMapping and resetMapping:
self.nameMapping.delete()
self.nameMapping = None
#
# Set name mapping (if not yet available)
#
if not self.nameMapping:
#
# This also includes selection of correct name mapping (namingSys)
# TODO: always set isOriginalImport to True?
#
if hasattr(self, 'namingSystemName'):
namingSystemName = self.namingSystemName
else:
namingSystemName = None
self.getNameMapping(namingSystemName=namingSystemName,
isOriginalImport=True,
resetMapping=resetMapping)
#
# Force chain mapping, this is always tried even if mappings available.
# Everything has to match or won't work.
#
if forceChainMappings:
forceMapping = 1
for forceChainMapping in forceChainMappings:
chainCode = forceChainMapping[0]
chain = self.molSystem.findFirstChain(code=chainCode)
if not chain:
print " Error: forceChainMappings chain code '%s' is not present in molSystem! Aborting..." % chainCode
forceMapping = 0
break
if forceMapping:
# TODO: formatLastSeqCode necessary here? Currently not implemented....
for forceChainMapping in forceChainMappings:
chainCode = forceChainMapping[0]
chain = self.molSystem.findFirstChain(code=chainCode)
formatChainCode = forceChainMapping[1]
firstSeqId = forceChainMapping[2]
offset = forceChainMapping[3]
if len(forceChainMapping) == 5:
seqInsertCode = forceChainMapping[4]
else:
seqInsertCode = defaultSeqInsertCode
self.setChainMappingDicts(chain,
formatChainCode,
firstSeqId=firstSeqId,
offset=offset,
seqInsertCode=seqInsertCode)
return self.status
#
# Check for chain mapping - take from name mapping if available *and* complete
#
self.setMappingFromChainMappings = False
if self.nameMapping.chainMappings:
deleteFormatChains = []
setChainMappings = []
doSet = 1
for chainMapping in self.nameMapping.chainMappings:
#print "CHAIN MAPPING", chainMapping.chainCode, chainMapping.formatChainCode, chainMapping.formatFirstSeqCode
chain = self.molSystem.findFirstChain(
code=chainMapping.chainCode)
if chain:
#
# Additional check to see whether these codes make sense or not...
#
residueMatches = 1
totalResidues = 1
if hasattr(self, 'resUnassignedNames'):
residueMatches = 0
totalResidues = 0
residueList = []
formatChainCode = chainMapping.formatChainCode
formatFirstSeqCode = chainMapping.formatFirstSeqCode
formatSeqInsertCode = chainMapping.formatSeqInsertCode
if chainMapping.formatLastSeqCode != None:
formatLastSeqCode = chainMapping.formatLastSeqCode
else:
formatLastSeqCode = formatFirstSeqCode + chain.molecule.seqLength
for resName in self.resUnassignedNames.keys():
(chainCode, seqCode, spinSystemId, seqInsertCode,
atomName) = getNameInfo(resName, verbose=0)
if (seqCode, seqInsertCode) not in residueList:
residueList.append((seqCode, seqInsertCode))
totalResidues += 1
if formatChainCode == chainCode and formatSeqInsertCode == seqInsertCode and seqCode >= formatFirstSeqCode and seqCode <= formatLastSeqCode:
residueMatches += 1
if residueMatches == totalResidues:
setChainMappings.append(
(chain, chainMapping.formatChainCode,
chainMapping))
if not chainMapping.formatChainCode in deleteFormatChains:
deleteFormatChains.append(
chainMapping.formatChainCode)
else:
doSet = 0
break
else:
doSet = 0
print " Error invalid chain codes for this molecular system - doing manual selection"
self.formatChainCodeDict = {}
self.ccpChainDict = {}
break
#
# Now check whether all is good and set dicts if so...
#
if doSet:
self.setMappingFromChainMappings = True
for (chain, formatChainCode, chainMapping) in setChainMappings:
self.setChainMappingDicts(chain,
formatChainCode,
chainMapping=chainMapping,
verbose=verbose)
for formatChainCode in deleteFormatChains:
#print formatChainCode,
if self.formatChains.has_key(formatChainCode):
#print " DELETED",
del self.formatChains[formatChainCode]
#print
#
# If no format chains left, mapping is set so continue
#
if chain and not self.formatChains:
return self.status
#
# Only go ahead if one chain in project and one chain reported,
# otherwise USER INTERACTION to link up!
#
linkChains = 1
if len(self.molSystem.chains) == 1 and len(
self.formatChains.keys()) == 1:
#
# Do some initialization
#
formatChainCode = (self.formatChains.keys())[0]
chain = self.molSystem.sortedChains()[0]
#
# Now check for the first seqCode in the data model chain that matches the
# first seqCode of the format.
#
if self.formatChains[formatChainCode]:
(seqCode,
seqInsertCode) = self.formatChains[formatChainCode][0]
residues = chain.sortedResidues()
for resPos in range(len(residues)):
residue = residues[resPos]
if residue.seqCode == seqCode and residue.seqInsertCode == seqInsertCode:
#
# Additional check: is the number of residues left big enough?
#
if len(chain.residues) - resPos >= len(
self.formatChains[formatChainCode]):
#
# And does the last sequence code match as well?
#
residue = chain.sortedResidues()[
resPos +
len(self.formatChains[formatChainCode]) - 1]
(seqCode, seqInsertCode
) = self.formatChains[formatChainCode][-1]
if residue.seqCode == seqCode and residue.seqInsertCode == seqInsertCode:
self.setSeqAndInsertCodeToChainMapping(
formatChainCode,
self.formatChains[formatChainCode],
chain,
resPos,
verbose=verbose)
linkChains = 0
break
if linkChains == 1:
#
# User interaction
# Link chains to chains that were reported for new resonances
#
interaction = self.multiDialog.ChainLink(
self.guiParent,
self.formatChains,
self.molSystem,
forceDefaultChainMapping=self.forceDefaultChainMapping,
doInteraction=self.allowPopups)
#
# Chain mapping returned?
#
if hasattr(interaction,
'chainDict') and interaction.chainDict != {}:
for chain in interaction.chainDict:
(formatChainCode, firstSeqId,
seqAndInsertCodesList) = interaction.chainDict[chain]
#
# Quick check to see if possibly seqCodes have to be reset... could be more
# sophisticated.
#
nmrRes = chain.findFirstResidue(seqId=firstSeqId)
firstResidueSeqId = chain.sortedResidues()[0].seqId
if self.allowPopups and not self.minimalPrompts and nmrRes.seqCode != seqAndInsertCodesList[
0][0]:
if self.messageReporter.showYesNo(
"Reset sequence codes",
"Do you want to reset the sequence codes for chain '%s' in the data model to reflect the original ones?"
% chain.code):
#
# Reset seqCode for nmrResidues
#
for seqCodeIndex in range(
0, len(seqAndInsertCodesList)):
(seqCode, seqInsertCode
) = seqAndInsertCodesList[seqCodeIndex]
nmrRes = chain.sortedResidues()[
firstSeqId - firstResidueSeqId +
seqCodeIndex]
nmrRes.seqCode = seqCode
nmrRes.seqInsertCode = seqInsertCode
#
# Setting chain mapping in formatChainCodeDict
#
self.setSeqAndInsertCodeToChainMapping(
formatChainCode,
seqAndInsertCodesList,
chain,
firstSeqId - firstResidueSeqId,
verbose=verbose)
else:
# Only really bomb out if nothing set, otherwise try to at least map what we can...
if not self.setMappingFromChainMappings:
self.status = False
else:
print " Missing mappings for format chains: %s. Continuing because other mappings were set." % str(
self.formatChains.keys())
interaction.destroy()
#
# Setting self.formatChainCodeDict to {} is a way to invalidate this routine! ??
#
if self.formatChainCodeDict == {}:
self.status = False
#
# Return status
#
return self.status
