def cleanAppData(project):
appDataObjectDict = {}
print "Collecting application data... this might take a while."
#findAppData(project,appDataObjectDict)
for nmrExp in project.currentNmrProject.experiments:
findAppData(nmrExp,appDataObjectDict)
for dataSource in nmrExp.dataSources:
findAppData(dataSource,appDataObjectDict)
for peakList in dataSource.peakLists:
findAppData(peakList,appDataObjectDict)
for peak in peakList.peaks:
findAppData(peak,appDataObjectDict)
for expDim in nmrExp.expDims:
# Not this one
for expDimRef in expDim.expDimRefs:
findAppData(expDimRef,appDataObjectDict)
for resonance in project.currentNmrProject.resonances:
findAppData(resonance,appDataObjectDict)
for resGroup in project.currentNmrProject.resonanceGroups:
findAppData(resGroup,appDataObjectDict)
for molSys in project.molSystems:
findAppData(molSys,appDataObjectDict)
for strucEnsemble in molSys.structureEnsembles:
findAppData(strucEnsemble,appDataObjectDict)
for model in strucEnsemble.models:
findAppData(model,appDataObjectDict)
for cChain in strucEnsemble.coordChains:
findAppData(cChain,appDataObjectDict)
for cResidue in cChain.residues:
findAppData(cResidue,appDataObjectDict)
for cAtom in cResidue.atoms:
findAppData(cAtom,appDataObjectDict)
for chain in molSys.chains:
findAppData(chain,appDataObjectDict)
for residue in chain.residues:
findAppData(residue,appDataObjectDict)
for atom in residue.atoms:
findAppData(atom,appDataObjectDict)
print "Finished collecting application data."
for format in ['ccpNmr'] + allFormatsDict.keys():
if appDataObjectDict.has_key(format):
for (object,appData) in appDataObjectDict[format]:
object.removeApplicationData(appData)
print " Deleted application data for %s..." % format
def __init__(self, parent, project):
self.project = project
self.selectedFormats = []
self.defaultText = 'Select file'
self.formats = allFormatsDict.keys()
self.formats.sort()
BasePopup.__init__(self, parent=parent, title= "Project '%s': " % project.name + 'Write ccpNmr mapping file', modal=False, transient=True)
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 getFormatConverterInfoDict():
automaticKeywords = {'Constraints': 'constraintType',
'Measurements': 'measurementType'}
ccpnProject = Implementation.MemopsRoot(name = 'test')
formatNames = allFormatsDict.keys()
formatNames.sort()
for removeFormatName in ('generic','marvin','regine'):
formatNames.pop(formatNames.index(removeFormatName))
formatInfoDict = {}
subClassedFunctions = {}
for formatName in formatNames:
formatLabel = allFormatsDict[formatName]
formatModule = __import__('ccpnmr.format.converters.%sFormat' % formatLabel,{},{},'%sFormat' % formatLabel)
formatClass = getattr(formatModule,'%sFormat' % formatLabel)
formatObject = formatClass(ccpnProject)
formatObject.IOkeywords = copy.deepcopy(formatObject.IOkeywords)
functionNames = formatObject.IOkeywords.keys()
functionNames.sort()
subClasses = formatObject.IOkeywords['subClasses']
functionNames.pop(functionNames.index('subClasses'))
for functionName in functionNames[:]:
for superClass in subClasses.keys():
if functionName in ('read%s' % superClass,'write%s' % superClass):
function = getattr(formatObject,functionName)
addIOkeywordList = []
setNonDictKeywords(function,addIOkeywordList,0)
automaticKeyword = automaticKeywords[superClass]
for subClass in subClasses[superClass]:
subClassFunctionName = functionName.replace(superClass,subClass)
if not subClassedFunctions.has_key(subClassFunctionName):
subClassedFunctions[subClassFunctionName] = functionName
formatObject.IOkeywords[subClassFunctionName].update(formatObject.IOkeywords[functionName])
if formatObject.IOkeywords[subClassFunctionName].has_key(automaticKeyword):
(default,mandatory,infoText) = formatObject.IOkeywords[subClassFunctionName][automaticKeyword]
formatObject.IOkeywords[subClassFunctionName][automaticKeyword] = (default,mandatory,True,infoText)
for (IOkeyword,default,mandatory,isAutomatic,infoText) in addIOkeywordList:
formatObject.IOkeywords[subClassFunctionName][IOkeyword] = (default,mandatory,False,infoText)
functionNames.pop(functionNames.index(functionName))
functionNameInfo = {}
functionWidgetInfo = {}
fileNameInfo = {}
for functionName in functionNames:
isValidFunction = False
for (component,readName,writeName,formatsDict,importWidgets,exportWidgets,void,void) in IoSetupList:
validFunctionNames = [readName,writeName]
if functionName in validFunctionNames:
functionIndex = validFunctionNames.index(functionName)
if formatsDict.has_key(formatName):
# Track 'default' file name
fileNameInfo[functionName] = formatsDict[formatName][0]
if formatsDict[formatName][functionIndex + 1]:
isValidFunction = True
# Now get widget information
if not functionWidgetInfo.has_key(functionName):
functionWidgetInfo[functionName] = {}
# Generic info
if functionIndex == 0:
widgetInfo = importWidgets
else:
widgetInfo = exportWidgets
getWidgetInfo(functionWidgetInfo[functionName],widgetInfo)
# Format specific info
getWidgetInfo(functionWidgetInfo[functionName],formatsDict[formatName][functionIndex + 3])
break
if not isValidFunction:
continue
IOkeywords = formatObject.IOkeywords[functionName].keys()
IOkeywords.sort()
numMandatory = 0
IOkeywordList = []
for IOkeyword in IOkeywords:
if len(formatObject.IOkeywords[functionName][IOkeyword]) == 3:
(default,mandatory,infoText) = formatObject.IOkeywords[functionName][IOkeyword]
isAutomatic = False
else:
(default,mandatory,isAutomatic,infoText) = formatObject.IOkeywords[functionName][IOkeyword]
if mandatory:
IOkeywordList.insert(numMandatory,(IOkeyword,default,mandatory,isAutomatic,infoText))
numMandatory += 1
else:
IOkeywordList.append((IOkeyword,default,mandatory,isAutomatic,infoText))
# Add info (if required)
function = getattr(formatObject,functionName)
setNonDictKeywords(function,IOkeywordList,numMandatory)
if functionName == readName:
actionType = 'import'
elif functionName == writeName:
actionType = 'export'
if not functionNameInfo.has_key(actionType):
functionNameInfo[actionType] = {}
functionNameInfo[actionType][component] = (functionName,IOkeywordList)
#
# Set the info
#
formatInfoDict[formatName] = {}
for actionType in functionNameInfo.keys():
formatInfoDict[formatName][actionType] = {}
for component in functionNameInfo[actionType].keys():
functionName = functionNameInfo[actionType][component][0]
if fileNameInfo.has_key(functionName):
defaultFileName = fileNameInfo[functionName]
else:
defaultFileName = 'noDefaultFile.xxx'
formatInfoDict[formatName][actionType][component] = (functionName,defaultFileName,[])
for (IOkeyword,default,mandatory,isAutomatic,infoText) in functionNameInfo[actionType][component][1]:
if functionWidgetInfo[functionName].has_key(IOkeyword):
(widgetType,defaults,label) = functionWidgetInfo[functionName][IOkeyword]
else:
(widgetType,defaults,label) = (None,None,None)
formatInfoDict[formatName][actionType][component][2].append((IOkeyword,default,mandatory,isAutomatic,infoText,widgetType,defaults,label))
return (formatInfoDict,subClassedFunctions)