def setupProject(self, dirPath, projectName): self.projectDirPath = dirPath try: self.ccpnProject = loadProject(dirPath) print "Read existing CCPN project..." except: print "Creating new CCPN project..." projectName = returnMemopsWord(projectName) self.ccpnProject = Implementation.MemopsRoot(name=projectName) self.nmrProject = self.ccpnProject.newNmrProject( name=self.ccpnProject.name) if not os.path.exists(dirPath): os.mkdir(dirPath) repository = self.ccpnProject.findFirstRepository(name='userData') if not repository.url.path == dirPath: url = Implementation.Url(path=dirPath) repository.url = url # TODO: check name of project: if not same CRASH OUT! return self.ccpnProject
def setupProject(self): # Create a CCPN project (defined locally in script!) self.ccpnProject = Implementation.MemopsRoot(name = self.idCode) self.nmrProject = self.ccpnProject.newNmrProject(name = self.ccpnProject.name) # Tag with the data (new as of 17/11/2008) appDataCreationDate = Implementation.AppDataString(application = "DataHandler", keyword = 'creationDate', value = self.timeFlag) self.nmrProject.addApplicationData(appDataCreationDate)
def modifyPackageLocators(project, repositoryName, repositoryPath, packageNames, resetPackageLocator=True, resetRepository=False): """ Resets package locators for specified packages to specified repository. Use as, for example: modifyPackageLocators(project,'newChemComps','/mydir/data/chemComps/',('ccp.molecule.ChemComp','ccp.molecule.ChemCompCoord')) Additional args: - resetPackageLocator: True will reset the package locator completely, removing old info False will add the repository to the package locator. - resetRepository: True will reset url for the repository, even if it already exists False will not reset the url for the repository if it already exists Returns the relevant repository. """ repository = project.findFirstRepository(name=repositoryName) ss = normalisePath(repositoryPath) if not repository: repository = project.newRepository(name=repositoryName, url=Implementation.Url(path=ss)) elif resetRepository and repository.url.path != repositoryPath: repository.url = Implementation.Url(path=ss) for packageName in packageNames: packageLocator = project.findFirstPackageLocator( targetName=packageName) if not packageLocator: raise ApiError("Cannot modify repository 'any' for package %s" % packageName) if resetPackageLocator: packageLocator.repositories = (repository, ) elif not repository in packageLocator.repositories: packageLocator.addRepository(repository) return repository
def setupContactOccurrenceInfo_nonCcpnBased(self, molTypes, confidence, hasDistanceInfo=True, useProteinFamilies=False): from ccp.general.Constants import standardResidueCcpCodes from memops.api import Implementation # # This is to doublecheck that top-level values don't get mixed with lower level ones.. # self.hasDistanceInfo = hasDistanceInfo self.useProteinFamilies = useProteinFamilies # # Warning: this only sets info for standard residues. Should be good enough, # use CCPN if not. # self.molTypes = molTypes self.ccpCodes = {} for molType in self.molTypes: self.ccpCodes[molType] = standardResidueCcpCodes[molType] self.importContactShortDicts() self.setInvConfidence(confidence) project = Implementation.MemopsRoot(name='test') self.createAtomSetInfo(project)
def setPeak(self): """ Cannot overwrite for Sparky: have to delete all old peaks and create all new ones. """ if self.rawPeak.num != None: details = "Original number %d" % self.rawPeak.num else: details = "No original number" self.peak = Nmr.Peak(self.peakList, details=details) # # Also set original number in applicationdata so can be reused for writing # if self.rawPeak.num != None: self.peak.addApplicationData( Implementation.AppDataInt(application=self.format, keyword=peakNum_kw, value=self.rawPeak.num)) # Sparky specific - has to be reset for every peak self.resLabelCodes = []
def convert(projectName, rootDir): datasetDir = os.path.join(rootDir, projectName) nijmegenDir = os.path.join(datasetDir, "Nijmegen") authorDir = os.path.join(datasetDir, "Authors") os.chdir(nijmegenDir) projectPath = os.path.join(nijmegenDir, projectName) if os.path.exists(projectPath): shutil.rmtree(projectPath) project = Implementation.MemopsRoot(name=projectName) nmrProject = project.newNmrProject(name=project.name) structureGeneration = nmrProject.newStructureGeneration() guiRoot = Tkinter.Tk() format = PseudoPdbFormat(project, guiRoot, verbose=1) globPattern = authorDir + '/*.pdb' fileList = glob(globPattern) nTdebug("From %s will read files: %s" % (globPattern, fileList)) format.readCoordinates(fileList, strucGen=structureGeneration, minimalPrompts=1, linkAtoms=0) project.saveModified() tgzFileName = "../" + projectName + ".tgz" cmd = "tar -czf %s %s" % (tgzFileName, projectName) do_cmd(cmd)
def createPpmFreqDataSource(exp,dsName,dsType,numDim): ds = Nmr.DataSource(exp,name = dsName, numDim = numDim, dataType = dsType) for dim in range(0,numDim): expDim = exp.findFirstExpDim(dim = (dim + 1)) expDimRefs = expDim.sortedExpDimRefs() refIsotopeCode = expDimRefs[0].isotopeCodes[0] # User first expDimRef to set number of points # Set numPoints, numPointsOrig to 20 for H, 250 for C,N! if refIsotopeCode == '1H': numPoints = 1024 valuePerPoint = 6.5 else: numPoints = 256 if refIsotopeCode == '13C': valuePerPoint = 100.0 elif refIsotopeCode== '15N': valuePerPoint = 40.0 else: valuePerPoint = 1.0 # Setting up empty freqdatadim and associated datadimref... # Assuming that imaginary data will be deleted! freqDataDim = Nmr.FreqDataDim(ds, expDim = expDim, dim = (dim + 1), isComplex = True,valuePerPoint = valuePerPoint, numPoints = numPoints, numPointsOrig = numPoints) # Tag to mark that this is a 'default' freqDataDim freqDataDim.addApplicationData(Implementation.AppDataBoolean(application = ccpNmr_kw, keyword = 'default', value = True)) # Set sensible dataDimRef info. setDataDimRefs(ds) return ds
def tagProject(self): """ Return True on error """ for atomKey in vascoAtomIdLoL: atomType = atomKey[0] (rerefValue, rerefError) = self.rerefInfo[atomKey] if rerefValue != None: appData1 = Implementation.AppDataFloat( value=rerefValue, application='VASCO', keyword='correction_%s' % atomType) appData2 = Implementation.AppDataFloat( value=rerefError, application='VASCO', keyword='correctionError_%s' % atomType) self.shiftList.addApplicationData(appData1) self.shiftList.addApplicationData(appData2)
def tagAsFresh(ccpnObject): appData = ccpnObject.findFirstApplicationData(keyword = freshTag) if not appData: appData = Implementation.AppDataBoolean(application = 'pdbeCcGeneration', keyword = freshTag, value = True) ccpnObject.addApplicationData(appData) appData.value = True
def addDynamicTensor(self): if self.alignMedium: tensor = Implementation.SymmTracelessMatrix(aAxial=0.0,aRhombic=0.0, alpha=0.0,beta=0.0, gamma=0.0) self.alignMedium.dynamicAlignment = tensor self.updateAlignMediaAfter(self.alignMedium)
def setPeakExtras(self): # # chiProb is 1 for pure noise in nmrDraw # self.peak.figOfMerit = 1 - self.rawPeak.chiProb clustIdAppData = Implementation.AppDataInt(application=self.format, keyword='clustId', value=self.rawPeak.clustId) self.peak.addApplicationData(clustIdAppData) numPeaksClustAppData = Implementation.AppDataInt( application=self.format, keyword='numPeaksClust', value=self.rawPeak.numPeaksClust) self.peak.addApplicationData(numPeaksClustAppData)
def setCcpNmrResonanceName(resonance,refAtom,atomName = None, forceChange = 0): # # Set the CCP names # # Full 'resonance' name on application data level # Just atom (group) name on resonance level! # residue = refAtom.residue seqCode = residue.seqCode chainCode = residue.chain.code if atomName == None: atomName = refAtom.name resName = chainCode + tagSep + str(seqCode) + tagSep + atomName # Set resonance name if resonance.name == None or forceChange == 1: resonance.name = atomName # Here only look for ONE match - don't want multiple matches for ccp names... assignData = resonance.findFirstApplicationData(application = ccpNmr_kw, keyword = assign_kw) if assignData: if assignData.value != resName: if forceChange == 0: print " Warning: couldn't set ccpNmr resonance name %s (name already set to %s)" % (resName,assignData.value) else: assignData.delete() resonance.addApplicationData(Implementation.AppDataString( application = ccpNmr_kw, keyword = assign_kw, value = resName)) else: resonance.addApplicationData(Implementation.AppDataString( application = ccpNmr_kw, keyword = assign_kw, value = resName)) else: if resonance.name != atomName: print " Warning: couldn't set ccpNmr name %s for resonance %s (name already set)" % (atomName,resonance.name) resName = resonance.name return resName
def tagAriaInput(self, object): appData = object.findFirstApplicationData(application=ccpNmr_kw, keyword=isAriaInput_kw) if not appData: object.addApplicationData( Implementation.AppDataBoolean(application=ccpNmr_kw, keyword=isAriaInput_kw, value=True))
def setDataSourceDataStore(dataSource, dataUrlPath, localPath, dataLocationStore=None, dataUrl=None): # # Get DataLocationStore # if not dataLocationStore: setCurrentStore(dataSource.root, 'DataLocationStore') dataLocationStore = dataSource.root.currentDataLocationStore # # Get (or create) DataUrl # # TODO should this search function go elsewhere? if not dataUrl: for tmpDataUrl in dataLocationStore.dataUrls: if tmpDataUrl.url.dataLocation == dataUrlPath: dataUrl = tmpDataUrl if not dataUrl: dataUrlPath = uniIo.normalisePath(dataUrlPath) dataUrl = dataLocationStore.newDataUrl(url=Implementation.Url( path=dataUrlPath)) # # Create a BlockedBinaryMatrix. TODO: could be other classes that are set up this way - rename func and make general,, pass in class? # localPath = uniIo.normalisePath(localPath) blockedBinaryMatrix = dataLocationStore.newBlockedBinaryMatrix( path=localPath, dataUrl=dataUrl) """ TODO Set here as well, or do this later after returning object: blockSizes Int 0..* Block sizes in dimension order complexStoredBy ComplexStorage 1..1 The ordering of real and imaginary parts of hypercomplex numbers in the data matrix. See ComplexStorage type for details hasBlockPadding Boolean 1..1 Are data padded to fill all blocks completely? Alternatively incomplete blocks store only the actual data. headerSize Int 1..1 Header size in bytes isBigEndian Boolean 1..1 Are data big-endian (alternative little-endian). isComplex Boolean 0..* Are numbers complex (if True) or real/integer (if False). nByte Int 1..1 Number of bytes per number numPoints Int 0..* number of points for each matrix dimension - also defines dimensionality of matrix. The number of points is the same for real or complex data, in the sense that n complex points require 2n real numbers for storage. numRecords Int 1..1 Number of matrix records in file. All other information in the object describes a single record. numberType NumberType 1..1 Type of numbers held in matrix """ dataSource.dataStore = blockedBinaryMatrix return blockedBinaryMatrix
def setCcpnProjectRepository(self,ccpnDir = 'ccpn'): # Replaces setCcpnProjectPaths outputPath = os.path.join(self.entryDir,ccpnDir) # In new API have to make sure that old files are removed first! if os.path.exists(outputPath): shutil.rmtree(outputPath) repository = self.ccpnProject.findFirstRepository(name = 'userData') repository.url = Implementation.Url(path = outputPath)
def saveTemporaryChemCompOrCoord(chemCompOrCoord,testMode = True, isFresh = False): """ Saves the XML for a chemComp(Coord) object to a temporary directory. testMode If False, will use archive/, otherwise will use test/ for existingFilePath. isFresh If False, will remove tag that indicates chemComp(Coord) generated from scratch If True, will set the tag. """ # # Set/remove tag that indicates whether chemComp is newly generated or not # if isFresh: tagAsFresh(chemCompOrCoord) else: removeFreshTag(chemCompOrCoord) if chemCompOrCoord.className == 'ChemCompCoord': className = 'ChemCompCoord' else: className = 'ChemComp' tempRepositoryName = 'temporaryChemComp' tempRepository = chemCompOrCoord.root.findFirstRepository(name = tempRepositoryName) if not tempRepository: tempRepository = chemCompOrCoord.root.newRepository(name= tempRepositoryName, url=Implementation.Url(path=tempChemCompDir)) curStdOut = sys.stdout textPipe = TextPipe([]) sys.stdout = textPipe chemCompOrCoord.saveTo(tempRepository) sys.stdout = curStdOut #sys.stdout = sys.__stdout__ print print " *** CCPN save output ***" for text in textPipe.textArea: if text.strip(): print " %s" % text.strip() print # This was failing horribly in large runs, now fixed (Wim 2010/03/08) filePath = glob.glob(os.path.join(tempRepository.url.path,'ccp','molecule',className,"*%s*%s*.xml" % (chemCompOrCoord.molType,getCcpFileString(chemCompOrCoord.ccpCode))))[0] (localPath,localFileName) = os.path.split(filePath) existingFilePath = findChemCompOrCoordFilePath(chemCompOrCoord, testMode = testMode) return (filePath,existingFilePath)
def convertStar2Ccpn(projectName, rootDir, inputDir="XPLOR", outputDir="CCPN"): """The structure when done will be: rootDir -> -> inputDir -> xxxx.pdb etc. -> outputDir -> xxxx -> ccp etc. -> xxxx.tgz (the resulting CCPN data) E.g. taf3Piscataway -> Authors -> all.pdb etc. -> Nijmegen -> taf3Piscataway -> ccp etc. -> taf3Piscataway.tgz Or in iCingSetup the rootDir is eg: /Library/WebServer/Documents/tmp/cing/ano/WjtXOz with project name gb1 WjtXOz -> XPLOR -> gb1.pdb etc. -> CCPN -> gb1 -> ccpn etc. -> gb1.tgz The in and out paths are relative to the rootDir. """ nTerror("This routine is untested and shouldn't be used without.") inputDir = os.path.join(rootDir, inputDir) outputDir = os.path.join(rootDir, outputDir) if not os.path.exists(inputDir): nTerror("Failed to find") if os.path.exists(outputDir): shutil.rmtree(outputDir) os.mkdir(outputDir) os.chdir(outputDir) ccpnProjectPath = os.path.join(outputDir, projectName) if os.path.exists(ccpnProjectPath): shutil.rmtree(ccpnProjectPath) project = Implementation.MemopsRoot(name=projectName) guiRoot = Tkinter.Tk() # headless possible? importStarChemicalShifts(project, inputDir, guiRoot, allowPopups=0, minimalPrompts=1, verbose=0) project.saveModified() tgzFileName = "../" + projectName + ".tgz" cmd = "tar -czf %s %s" % (tgzFileName, projectName) do_cmd(cmd) guiRoot.destroy()
def newProject(projectName, path=None, removeExisting=False, showYesNo=None): """ Create, and return, a new project using a specified path (directory). If path is not specified it takes the current working directory. The path can be either absolute or relative. The 'userData' repository is pointed to the path. The 'backup' repository is pointed to the path + '_backup'. If either of these paths already exist (either as files or as directories): If removeExisting: Delete the path Else if showYesNo: Ask the user if it is ok to delete the path If yes, delete. If no return None. Else: Raise an IOError """ # relies on knowing that repositories to move have these names, and these values for path suffix repositoryNameMap = {'userData': '', 'backup': '_backup'} if not path: path = os.getcwd() for name in repositoryNameMap.keys(): fullPath = joinPath(path, projectName) + repositoryNameMap[name] answer = checkRemoveIfExists(fullPath, removeExisting, showYesNo) if answer is None: return None project = Implementation.MemopsRoot(name=projectName) for name in repositoryNameMap.keys(): fullPath = normalisePath(joinPath(path, projectName) + repositoryNameMap[name], makeAbsolute=True) repository = project.findFirstRepository(name=name) repository.url = Implementation.Url(path=fullPath) return project
def majorUpgradeToCurrent(oldRoot, oldVersionStr, newName=None, newDir=None, oldTags=None, doSave=True): """ Do major upgrade of oldRoot tree to current version. NB oldRoot tree must be all loaded in memory """ if oldVersionStr == currentVersionStr: return oldRoot from memops.api import Implementation # make new project and move old directory if necessary oldName = oldRoot.name if newName is None: newName = oldName newRoot = Implementation.MemopsRoot(name=newName) if newDir is None: newPath = getDataDir(oldRoot, oldVersionStr) else: newPath = uniIo.normalisePath((os.path.join(newDir, newName)), makeAbsolute=True) newRoot.packageLocator.findFirstRepository().url = (Implementation.Url( path=newPath)) newRoot.findFirstRepository(name='backup').url = (Implementation.Url( path=newPath + '_backup')) upgrader = DataUpgrader(oldVersionStr, newRoot, oldRoot, oldTags=oldTags) # make upgrade return upgrader.majorUpgrade(doSave=doSave)
def resetPackageLocators(project): carbDataPath = uniIo.normalisePath( os.path.join(os.path.abspath('..'), 'data')) print 'Location of local carbohydrate ChemComps: [%s]' % carbDataPath carbDataUrl = Implementation.Url(path=carbDataPath) carbDataRepos = project.newRepository(name='carbData', url=carbDataUrl) chemPackLoc = project.findFirstPackageLocator( targetName='ccp.molecule.ChemComp') chemPackLoc.addRepository(carbDataRepos)
def newProject(self): if self.project: # Project already present if not self.closeProject(): # If we don't close the current project do nothing return name = askString(title='Project name', prompt='Enter project name:',parent=self) if name: # Make the API Project object project = Implementation.MemopsRoot(name=name) nmrProject = project.newNmrProject(name = project.name) self.initProject(project)
def changeDataStoreUrl(dataStore, newPath): """ Change the url for this dataStore, so at the end we have dataStore.dataUrl.url.path = newPath. This changes all dataUrls with the same old path if the old path does not exist and the new one does. """ newPath = uniIo.normalisePath(newPath, makeAbsolute=True) oldDataUrl = dataStore.dataUrl oldUrl = oldDataUrl.url oldPath = oldUrl.dataLocation oldExists = os.path.exists(oldPath) if newPath != oldPath: dataLocationStore = dataStore.dataLocationStore newUrl = Implementation.Url( path=newPath) # TBD: should use oldUrl.clone(path=newPath) # first check if have a dataUrl with this path newDataUrl = dataLocationStore.findFirstDataUrl(url=newUrl) if not newDataUrl: # if old path exists and there is more than one dataStore with # this dataUrl then create new one dataUrlStores = dataLocationStore.findAllDataStores( dataUrl=oldDataUrl) if oldExists and len(dataUrlStores) > 1: newDataUrl = dataLocationStore.newDataUrl(name=oldDataUrl.name, url=newUrl) # if have found or have created newDataUrl then set dataStore to point to it # else just change url of oldDataUrl (which could affect other dataStores) if newDataUrl: dataStore.dataUrl = newDataUrl else: oldDataUrl.url = newUrl # if old path does not exist and new path exists then change urls of # all data urls which have old path to new path (there might be none) if not oldExists: newExists = os.path.exists(newPath) if newExists: for dataUrl in dataLocationStore.dataUrls: if dataUrl.url == oldUrl: dataUrl.url = newUrl
def convertCyana2Ccpn(projectName, rootDir): guiRoot = Tkinter.Tk() datasetDir = os.path.join(rootDir, projectName) nijmegenDir = os.path.join(datasetDir, "Nijmegen") authorDir = os.path.join(datasetDir, "Authors") os.chdir(nijmegenDir) projectPath = os.path.join(nijmegenDir, projectName) if os.path.exists(projectPath): shutil.rmtree(projectPath) project = Implementation.MemopsRoot(name=projectName) importCyanaCoorAndRes(project, authorDir, guiRoot) project.saveModified() tgzFileName = "../" + projectName + ".tgz" cmd = "tar -czf %s %s" % (tgzFileName, projectName) do_cmd(cmd) guiRoot.destroy()
def updateTensor(self, aAxial=None, aRhombic=None, alpha=None, beta=None, gamma=None): aAxial = aAxial or self.tensor.aAxial aRhombic = aRhombic or self.tensor.aRhombic alpha = alpha or self.tensor.alpha beta = beta or self.tensor.beta gamma = gamma or self.tensor.gamma tensor = Implementation.SymmTracelessMatrix(aAxial=aAxial, aRhombic=aRhombic, alpha=alpha,beta=beta, gamma=gamma) if self.alignMedium: if self.tensor is self.alignMedium.dynamicAlignment: self.alignMedium.dynamicAlignment = tensor elif self.tensor is self.alignMedium.staticAlignment: self.alignMedium.staticAlignment = tensor self.tensor = tensor
def createShift(self,resonance,chemShift): # # For xeasy also use chemShift to create atomSerial application data. # # Warning: if there is already an atomSerial available for this resonance # it will be overwritten!! # applData = resonance.findFirstApplicationData(application = self.format, keyword = self.atomSerialKeyword) if applData: resonance.removeApplicationData(applData) resonance.addApplicationData(Implementation.AppDataInt(application = self.format, keyword = self.atomSerialKeyword, value = chemShift.atomSerial)) # # Create shift linked to resonance # return Nmr.Shift(self.measurementList, value = chemShift.value, error = chemShift.valueError, resonance = resonance)
def setupProject(self, fileName, projectName): self.projectFileName = fileName try: self.ccpnProject = XmlIO.loadProjectFile(fileName) print "Read existing CCPN project..." except: print "Creating new CCPN project..." projectName = returnMemopsWord(projectName) self.ccpnMemopsRoot = Implementation.MemopsRoot(name=projectName) self.nmrProject = Nmr.NmrProject(self.ccpnProject, name=self.ccpnProject.name) # # Set the location... # (path, file) = splitPath(fileName) self.ccpnProject.path = file self.ccpnProject.url.path = path outputPath = os.path.join(path, projectName) try: os.stat(outputPath) except: os.mkdir(outputPath) for url in self.ccpnProject.urls: if url != self.ccpnProject.url: url.path = outputPath # TODO: check name of project: if not same CRASH OUT! return self.ccpnProject
def getDataStoringFromFilepath(memopsRoot, fullFilePath, preferDataUrls=None, dataLocationStore=None, keepDirectories=1): # make absolute,, normalised path fullFilePath = uniIo.normalisePath(fullFilePath, makeAbsolute=True) dataUrl, filePath = findDataStoringFromFilepath(memopsRoot, fullFilePath, preferDataUrls, dataLocationStore, keepDirectories) if dataUrl is None: urlPath = uniIo.normalisePath((fullFilePath[:-len(filePath)])) dataLocationStore = memopsRoot.currentDataLocationStore dataUrl = dataLocationStore.newDataUrl(url=Implementation.Url( path=urlPath)) dataUrl.name = 'auto-%s' % dataUrl.serial # return (dataUrl, filePath)
def setNmrStarExportInfo(self, importFormatName): resonances = self.formatConversion.getFormatClass( importFormatName).newResonances # # Copy over original assignment info for NMR-STAR export! # for resonance in resonances: for appData in resonance.findAllApplicationData( application=importFormatName): newAppData = None if appData.keyword == 'assign': newAppData = Implementation.AppDataString( application='nmrStar', keyword='origAssign', value=appData.value) elif appData.keyword == 'origResLabel': newAppData = appData if newAppData: resonance.addApplicationData(newAppData)
def __init__(self, parent, project=None, *args, **kw): if not project: self.project = Implementation.MemopsRoot( name='defaultUtilityProject') else: self.project = project self.waiting = False self.waitingAtom = False self.molType = 'protein' self.scheme = None self.isotopomer = None self.isotopomerV = False # Not None self.ccpCodeV = None self.element = 'C' self.atomLabelTuple = None self.isotopes = [x[0] for x in getSortedIsotopes(self.project, 'C')] self.defaultAbun = {} BasePopup.__init__(self, parent=parent, title='Molecule : Reference Isotope Schemes', **kw)
def createShift(self, resonance, chemShift): # # For xeasy also use chemShift to create atomSerial application data. # # Warning: if there is already an atomSerial available for this resonance # it will be overwritten!! # applData = resonance.findFirstApplicationData( application=self.format, keyword=self.atomSerialKeyword) if applData: resonance.removeApplicationData(applData) resonance.addApplicationData( Implementation.AppDataInt(application=self.format, keyword=self.atomSerialKeyword, value=chemShift.atomSerial)) # # Create shift linked to resonance - NOTE changed so can read in all atom serials, even if no shift value given! # if chemShift.value: self.convertCount[self.mainCode][1][self.valueCode] += 1 shift = self.measurementList.newShift(value=chemShift.value, error=chemShift.valueError, resonance=resonance) else: shift = None return shift