def makeNoeList(self): if self.refPeakList is self.satPeakList: showWarning('Same Peak List', 'Ref Peak List and Sat Peak List cannot be the same', parent=self) return if self.peakPairs: s1 = self.refPeakList.dataSource s2 = self.satPeakList.dataSource noiseRef = getSpectrumNoise(s1) noiseSat = getSpectrumNoise(s2) es = '%s-%s' % (s1.experiment.name,s2.experiment.name) if len(es) > 50: es = 'Expt(%d)-Expt(%d)' % (s1.experiment.serial,s2.experiment.serial) noeList = self.nmrProject.newNoeList(unit='None',name='Hetero NOE list for %s' % es) noeList.setExperiments([s1.experiment,]) if s1.experiment is not s2.experiment: noeList.addExperiment( s2.experiment ) # TBD: sf, noeValueType, refValue, refDescription resonancePairsSeen = set() for (peakA,peakB) in self.peakPairs: # peakA is sat intensA = getPeakIntensity(peakA,self.intensityType) intensB = getPeakIntensity(peakB,self.intensityType) value = float(intensA)/intensB error = abs(value) * sqrt((noiseSat/intensA)**2 + (noiseRef/intensB)**2) resonances = tuple(self.getPeakResonances(peakA)) frozenResonances = frozenset(resonances) if len(resonances) < 2: pl = peakA.peakList sp = pl.dataSource msg = 'Skipping %s:%s:%d peak %d it has too few resonances assigned' data = (sp.experiment.name, sp.name, pl.serial, peakA.serial) showWarning('Warning',msg % data, parent=self) elif len(resonances) > 2: pl = peakA.peakList sp = pl.dataSource resonanceText = ' '.join([makeResonanceGuiName(r) for r in resonances]) msg = 'Skipping %s:%s:%d peak %d it has too many resonances assigned (%s)' data = (sp.experiment.name, sp.name, pl.serial, peakA.serial, resonanceText) showWarning('Warning', msg % data, parent=self) elif frozenResonances not in resonancePairsSeen: resonancePairsSeen.add(frozenResonances) noeList.newNoe(value=value,resonances=resonances,peaks=[peakA,peakB],error=error) else: resonanceText = ' '.join([makeResonanceGuiName(r) for r in resonances]) msg = 'Skipping duplicate entry for resonances %s' % resonanceText showWarning('Warning', msg, parent=self) self.parent.editMeasurements(measurementList=noeList)
def create_name(self, full=True): '''Returns a resonance name where deuterated and protonated are distinguishable. returns: str name description ''' name = makeResonanceGuiName(self.resonance, fullName=full) if not self.deuterated: return name else: return '{} (D)'.format(name)
def create_name(self, full=True): '''Returns a resonance name where deuterated and protonated are distinguishable. returns: str name description ''' name = makeResonanceGuiName(self.resonance, fullName=full) if not self.deuterated: return name else: return '{} (D)'.format(name)
def getCouplingDimAnnotation(cluster, dim): """ Get a text string representing the assignment status of couplings in a specified dimension represented by a peak cluster .. describe:: Input Nmr.PeakCluster, Int .. describe:: Output String """ from ccpnmr.analysis.core.AssignmentBasic import makeResonanceGuiName annotation = '' if cluster.clusterType == MULTIPLET_TYPE: dimResonances = set([]) dimResonancesAdd = dimResonances.add dimResonancesUpdate = dimResonances.update for peak in cluster.peaks: peakDim = peak.findFirstPeakDim(dim=dim) if peakDim: for component in peakDim.peakDimComponents: for contrib in component.peakDimContribs: if isinstance(contrib, Nmr.PeakDimContribN): dimResonancesUpdate(contrib.resonances) else: dimResonancesAdd(contrib.resonance) names = [makeResonanceGuiName(r) for r in dimResonances] names.sort() # TBD: Set and use component annotations annotation = 'J:' + ','.join(names) # Peak cluster annotations could carry couplings in Hz and possibly isotopes... return annotation
def analysePeaks(peakList): # Row per peak - Cols: height vs PL mean, vol vs PL mean, # sign check, F1 shift delta, F2 shift delta ++ meanVolume = 0.0 meanHeight = 0.0 meanVolume2 = 0.0 meanHeight2 = 0.0 nVolume = 0 nHeight = 0 pos = 0 tot = 0 data0 = [] for peak in peakList.sortedPeaks(): volume = getPeakVolume(peak) height = getPeakHeight(peak) logVolume = None logHeight = None if volume: logVolume = log(abs(volume)) meanVolume += logVolume meanVolume2 += logVolume * logVolume nVolume += 1 else: volume = 0.0 if height: logHeight = log(abs(height)) meanHeight += logHeight meanHeight2 += logHeight * logHeight nHeight += 1 tot += 1 if height > 0: pos += 1 else: height = 0.0 data0.append([peak, volume,logVolume, height, logHeight]) if nVolume: meanVolume /= float(nVolume) meanVolume2 /= float(nVolume) if nHeight: meanHeight /= float(nHeight) meanHeight2 /= float(nHeight) heightSd = sqrt(abs(meanHeight2 - (meanHeight * meanHeight))) # abs() due to float point error - v small negs rather than zero volumeSd = sqrt(abs(meanVolume2 - (meanVolume * meanVolume))) shiftList = peakList.dataSource.experiment.shiftList boundDataDims = {} for dataDim1, dataDim2 in getOnebondDataDims(peakList.dataSource): boundDataDims[dataDim1] = dataDim2 boundDataDims[dataDim2] = dataDim1 data = [] for peak, volume, logVolume, height, logHeight in data0: deltaLogVolume = None deltaLogHeight = None if volume: deltaLogVolume = abs(logVolume - meanVolume) if height: deltaLogHeight = abs(logHeight - meanHeight) maxDeltas = [] assignErrors = {} # Row per peak: - Cols: Causes muli 1bond, # causes atom impossible 1bond, Partly assigned onebond, # missing/extra assign for peakDim in peak.sortedPeakDims(): maxDelta = None isotopeCode = None if shiftList: for contrib in peakDim.peakDimContribs: resonance = contrib.resonance isotopeCode = resonance.isotopeCode shift = resonance.findFirstShift(parentList=shiftList) if shift: delta = abs(peakDim.realValue - shift.value) if (maxDelta is None) or (delta > maxDelta): maxDelta = delta maxDeltas.append([maxDelta,isotopeCode]) for contrib in peakDim.peakDimContribs: resonance = contrib.resonance # Warn the user if prochirals have similar shifts # but only one is linked to the peak. resonanceSet = resonance.resonanceSet if resonanceSet: if len(resonanceSet.atomSets) > 1: resonances2 = list(resonanceSet.resonances) resonances2.remove(resonance) for resonance2 in resonances2: if peakDim.findFirstPeakDimContrib(resonance=resonance2): continue for contrib2 in resonance2.peakDimContribs: if contrib2.peakDim.peak.peakList is peakList: break else: shift = resonance.findFirstShift(parentList=shiftList) shift2 = resonance2.findFirstShift(parentList=shiftList) if shift and shift2: delta = abs(shift.value-shift2.value) analysisDataDim = getAnalysisDataDim(peakDim.dataDim) if analysisDataDim and (delta < analysisDataDim.assignTolerance/5.0): name = makeResonanceGuiName(resonance2, fullName=False) msg = 'Also expected dim %d %s assignment' % (peakDim.dim,name) assignErrors[msg] = True boundDataDim = boundDataDims.get(peakDim.dataDim) if boundDataDim: peakDim2 = peak.findFirstPeakDim(dataDim=boundDataDim) if peakDim.peakDimContribs: if peakDim2.peakDimContribs: # Count number of atomSets to see if result makes sense atomSets1 = set() atomSets2 = set() for contrib2 in peakDim2.peakDimContribs: resonanceSet = contrib2.resonance.resonanceSet if resonanceSet: for atomSet in resonanceSet.atomSets: atomSets2.add(atomSet) for contrib in peakDim.peakDimContribs: resonance = contrib.resonance resonanceSet = resonance.resonanceSet name = makeResonanceGuiName(resonance) bound = getBoundResonances(resonance, recalculate=True) impossibles = [] if resonanceSet: for atomSet in resonanceSet.atomSets: atomSets1.add(atomSet) if bound: nBound = len(bound) for reson in bound: # Correct for multiatom atomSets (CH3 resonances e,g,) resSet = reson.resonanceSet if resSet: ll = [1] for atomSet in resSet.atomSets: length = len(atomSet.atoms) cas = atomSet.findFirstAtom().chemAtom.chemAtomSet if not cas or cas.isEquivalent is not None: # Test excludes e.g. Tyr and Phe side chains # that otherwise give spurious errors ll.append(length) # Add additional number of atoms for each bound resonance nBound += min(ll) - 1 if isotopeCode in ('1H','2H','19F'): if nBound > 1: assignErrors['%s mutiple %s bonds' % (name,isotopeCode)] = True elif resonanceSet: chemAtom = resonance.resonanceSet.findFirstAtomSet().findFirstAtom().chemAtom if nBound > len(chemAtom.chemBonds): assignErrors['%s excessive bonds' % name] = True okAtoms = False foundBound = False for contrib2 in peakDim2.peakDimContribs: resonance2 = contrib2.resonance if resonance2 in bound: resonanceSet2 = resonance2.resonanceSet foundBound = True if resonanceSet and resonanceSet2: if not areResonanceSetAtomsBound(resonanceSet, resonanceSet2): names = [name,makeResonanceGuiName(resonance2)] names.sort() impossibles.append(names) else: okAtoms = True if not okAtoms: for names in impossibles: assignErrors['Impossible bond %s-%s' % tuple(names)] = True if not foundBound: assignErrors['%s no bound partner' % name] = True if isotopeCode in ('1H','2H','19F'): if len(atomSets2) > len(atomSets1): assignErrors['Only %s H to bind %s Non-H' % (len(atomSets1), len(atomSets2))] = True else: assignErrors['Dim %d empty' % peakDim2.dataDim.dim] = True elif peakDim2.peakDimContribs: assignErrors['Dim %d empty' % peakDim.dataDim.dim] = True sortedPeakDims = peak.sortedPeakDims() annotation = ' '.join([pd.annotation or '-' for pd in sortedPeakDims]) locations = [] for pd in sortedPeakDims: if pd.value is None: if pd.position is None: locations.append('Error') else: locations.append('%.2f' % pd.position) else: locations.append('%.2f' % pd.value) location = ' '.join(locations) nearestPeak, nearestDistance = findClosestOtherPeak(peak, scale=2.0) symmetryPeaks = findSymmetryPeaks(peak) datum = [peak.serial,annotation,assignErrors.keys(),location, volume,deltaLogVolume, height,deltaLogHeight,maxDeltas, nearestPeak, nearestDistance, symmetryPeaks] data.append([peak, datum]) posProp = 1.0 if tot: posProp = pos/float(tot) return posProp, volumeSd, heightSd, data
def analyseChemicalShifts(shiftList): updateAllShifts(shiftList) # T1, shifts - Row per resonance - Cols: shift, shiftSD, # maxPeak delta, SD per spectrum ++ data = [] duplicateAssign = {} data2 = [] if shiftList: project = shiftList.root for shift in shiftList.measurements: resonance = shift.resonance assignTuple = getResonanceAtomTuple(resonance) data2.append(['%s%s%8.8s%s' % assignTuple,shift]) duplicateAssign[assignTuple] = duplicateAssign.get(assignTuple, 0) + 1 data2.sort() for name, shift in data2: resonance = shift.resonance deltaMax = None nContribs = 0 bmrbMean = None randomCoil = None typeScore = None resonanceSet = resonance.resonanceSet if resonanceSet: atomSet = resonanceSet.findFirstAtomSet() residue = atomSet.findFirstAtom().residue ccpCode = residue.ccpCode molType = residue.molResidue.molType atomName = atomSet.name chemAtomNmrRef = getChemAtomNmrRef(project, atomName, ccpCode, molType=molType) if chemAtomNmrRef is None: atomName = atomSet.findFirstAtom().name chemAtomNmrRef = getChemAtomNmrRef(project, atomName, ccpCode, molType=molType) if chemAtomNmrRef: # Horrid kludge until we have chem shift ref info per var if (ccpCode == 'Cys') and ('link:SG' in residue.chemCompVar.descriptor): ccpCode = 'Cyss' typeScore = lookupAtomProbability(project, ccpCode, atomName, shift.value, molType) bmrbMean = chemAtomNmrRef.meanValue randomCoil = chemAtomNmrRef.randomCoilValue for contrib in resonance.peakDimContribs: peakDim = contrib.peakDim shiftList1 = peakDim.peak.peakList.dataSource.experiment.shiftList if shiftList1 and (shiftList1 is shiftList): nContribs +=1 delta = abs(peakDim.realValue-shift.value) if (deltaMax is None) or (delta > deltaMax): deltaMax = delta boundWarn = False bound = getBoundResonances(resonance, recalculate=True) if bound: nBound = len(bound) for reson in bound: # Correct for multiatom atomSets (CH3 resonances e,g,) resSet = reson.resonanceSet if resSet: ll = [1] for atomSet in resSet.atomSets: length = len(atomSet.atoms) cas = atomSet.findFirstAtom().chemAtom.chemAtomSet if not cas or cas.isEquivalent is not None: # Test excludes e.g. Tyr and Phe side chains # that otherwise give spurious errors ll.append(length) # Add additional number of atoms for each bound resonance nBound += min(ll) - 1 if resonance.isotopeCode in ('1H','2H','19F'): if nBound > 1: boundWarn = True elif resonanceSet: chemAtom = resonance.resonanceSet.findFirstAtomSet().findFirstAtom().chemAtom if nBound > len(chemAtom.chemBonds): boundWarn = True if resonanceSet and not boundWarn: atom = resonanceSet.findFirstAtomSet().findFirstAtom() for resonance1 in bound: resonanceSet1 = resonance1.resonanceSet if resonanceSet1: for atomSet1 in resonanceSet1.atomSets: for atom1 in atomSet1.atoms: if areAtomsBound(atom, atom1): break else: continue break else: boundWarn = True assignTuple = getResonanceAtomTuple(resonance) sameResBound = [] otherBound = [] residue = getResonanceResidue(resonance) for resonance1 in bound: residue1 = getResonanceResidue(resonance1) if residue1 is residue: sameResBound.append(makeResonanceGuiName(resonance1,fullName=False)) else: otherBound.append(makeResonanceGuiName(resonance1)) boundResonances = '' if residue: ccpCode = getResidueCode(residue) resName1 = '%d%s' % (residue.seqCode,ccpCode) if len(sameResBound) > 1: boundResonances += '%s[%s] ' % (resName1,','.join([x for x in sameResBound])) elif sameResBound: boundResonances += '%s%s ' % (resName1,sameResBound[0]) else: boundResonances += ','.join([x for x in sameResBound]) boundResonances += ','.join([x for x in otherBound]) isDuplicate = False if duplicateAssign.get(assignTuple, 0) > 1: isDuplicate = True resName = makeResonanceGuiName(resonance) datum = [resonance.serial,resonance.isotopeCode,resName,boundResonances, bmrbMean,randomCoil,typeScore,shift.value,shift.error, deltaMax,nContribs,isDuplicate,boundWarn] data.append([shift, datum]) return data
def fitSideChain(shifts, residue, clouds, distrib, useAssignNames=False): ccpCode = residue.ccpCode atomScores = {} project = residue.root from ccpnmr.analysis.core.SpinSystemTyping import getAtomNames, getAtomShiftScore atomSets = {} for shift in shifts: """scores[shift] = None name = None if shift.resonance.assignNames: name = shift.resonance.assignNames elif shift.resonance.name: name = shift.resonance.name name = shift.resonance.name if name == 'HN': name = 'H'""" done = {} atomScores[shift] = {} for atom in residue.atoms: if not atom.chemAtom.waterExchangeable: atomSet = atom.atomSet if atomSet and (done.get(atomSet) is None): atomSetName = atomSet.name atomName = atom.name done[atomSet] = True atomSets[atomSet] = True if atom.chemAtom.elementSymbol == shift.resonance.isotope.chemElement.symbol: score = getAtomShiftScore(project, atomSetName, ccpCode, shift) if not score: score = getAtomShiftScore(project, atomName, ccpCode, shift) if score: atomScores[shift][atomSetName] = log(score) else: atomScores[shift][atomSetName] = None else: atomScores[shift][atomSetName] = None atomNames0 = [(ass.atoms[0].name, ass.name) for ass in atomSets.keys()] # getAtomNames(residue) best = -20000.0 bestM = None passes = 0 J = 0 i = 0 print "Fitting residue %d %s" % (residue.seqCode, residue.ccpCode) #print atomNames0 while passes < (len(atomNames0) * len(atomNames0)): i += 1 if bestM is None: bestM = {} shifts1 = list(shifts) for atomName, atomSetName in atomNames0: if shifts1: j = randint(0, len(shifts1) - 1) bestM[atomName] = shifts1.pop(j) else: bestM[atomName] = None mapping = bestM.copy() else: mapping = bestM.copy() if len(atomNames0) < 2: break j = J J += 1 if J >= len(atomNames0): J = 0 k = j while k == j: k = randint(0, len(atomNames0) - 1) swap = mapping[atomNames0[j][0]] mapping[atomNames0[j][0]] = mapping[atomNames0[k][0]] mapping[atomNames0[k][0]] = swap prior = 0.0 for atomName, atomSetName in atomNames0: shift = mapping[atomName] if shift: s = atomScores[shift][atomSetName] if s: prior += s else: prior += -50.0 likelihood = 0.1 * getAtomCloudScores(mapping, ccpCode, clouds, distrib) score = prior + likelihood if score > best: #print i, score, likelihood, prior passes = 0 best = score bestM = mapping else: passes += 1 # do some provisional assignment if bestM: for atomName in bestM.keys(): shift = bestM[atomName] if shift: resonance = shift.resonance resonance.setName(atomName) atomNames4 = [] if resonance.resonanceSet: for atomSet in resonance.resonanceSet.atomSets: for atom4 in atomSet.atoms: atomNames4.append(atom4.name) if atomNames4 and (atomName not in atomNames4): #print i, best print 'Error %5.5s %3.3f - %s' % ( atomName, shift.value, makeResonanceGuiName(resonance)) for atom4 in residue.atoms: if not atom4.chemAtom.waterExchangeable: print ' %3.3f %5.5s %.3f' % ( shift.value, atom4.atomSet.name, atomScores[shift][atom4.atomSet.name] or -1000.0) return bestM
def update(self, contrib, peakDim, aliasing=False, structure=None, limitedResonances=None, molSystems=None, component=None, noDisplay=False, doubleTol=False, resetScrollbars=True, showMolSystem=False): self.aliasing = aliasing self.contrib = contrib self.resonances = [] self.jCouplings = [] self.structure = structure self.component = component atomSets1 = [] if peakDim: self.peakDim = peakDim elif contrib: self.peakDim = None peakDim = contrib.peakDim else: self.scrolledMatrix.update(objectList=[], textMatrix=[ [], ]) return if component and (component.dataDimRef.expDimRef.unit != 'ppm'): headingList = ['#', 'Names', 'Delta', 'Coupling', 'SD'] tipTexts = TIP_TEXTS2 isCoupling = True else: tipTexts = TIP_TEXTS headingList = ['#', 'Name', 'Delta', 'Shift', 'SD', 'Dist'] isCoupling = False if showMolSystem: tipTexts = tipTexts[:] tipText = 'Mol System of resonance' if isCoupling: tipText += 's' tipTexts.append(tipText) headingList.append('MS') dataDimRef = peakDim.dataDimRef expDimRef = dataDimRef.expDimRef dataDim = dataDimRef.dataDim textMatrix = [] colorMatrix = [] if isCoupling: ppm = getAnalysisDataDim(peakDim.dataDim).assignTolerance points = peakDim.dataDimRef.valueToPoint(ppm) tolerance = component.dataDimRef.pointToValue(points) if doubleTol: tolerance *= 2 # get couplings that might match the splitting for delta, coupling in findMatchingCouplings(component, tolerance): resonanceA, resonanceB = coupling.resonances nameA = makeResonanceGuiName(resonanceA) nameB = makeResonanceGuiName(resonanceB) self.jCouplings.append(coupling) colors = [None, None, None, None, None] if coupling.error >= tolerance: colors[4] = '#d0a0a0' textMatrix.append([ '%d,%d' % (resonanceA.serial, resonanceB.serial), '%s-%s' % (nameA, nameB), '%5.3f' % round(delta, 3), coupling.value, '%5.3f' % round(coupling.error, 3) ]) colorMatrix.append(colors) if showMolSystem: molSystemA = getResonanceMolSystem(resonanceA) or '' molSystemB = getResonanceMolSystem(resonanceB) or '' if molSystemA == molSystemB: texts.append(molSystemA and molSystemA.code) else: texts.append('%s,%s' % (molSystemA and molSystemA.code, molSystemB and molSystemB.code)) colors.append(None) objectList = self.jCouplings else: # set up atomSets for distance calculations where possible if self.structure: for expTransfer in expDimRef.expTransfers: if expTransfer.transferType in longRangeTransfers: expDimRefs = list(expTransfer.expDimRefs) expDimRefs.remove(expDimRef) for peakDim1 in peakDim.peak.sortedPeakDims(): if peakDim1.dataDimRef.expDimRef is expDimRefs[0]: for contrib1 in peakDim1.peakDimContribs: resonance1 = contrib1.resonance if resonance1 and resonance1.resonanceSet: for atomSet in resonance1.resonanceSet.atomSets: atomSets1.append(atomSet) if component: # E.g. MQ or reduced dimensionality dataDimRef2 = component.dataDimRef if dataDimRef is dataDimRef2: ppm = abs(peakDim.value - peakDim.realValue) else: realPoint = ppm2pnt(peakDim.realValue, dataDimRef) deltaPoints = abs(peakDim.position - realPoint) ppm = abs(component.scalingFactor * dataDimRef2.pointToValue(deltaPoints)) peakUnit = dataDimRef2.expDimRef.unit or 'point' else: ppm = peakDim.realValue peakUnit = expDimRef.unit or 'point' shiftList = peakDim.peak.peakList.dataSource.experiment.shiftList shiftUnit = shiftList.unit tolerance = getAnalysisDataDim(dataDim).assignTolerance if doubleTol: tolerance *= 2 shifts = self.givePossAssignments(peakDim, tolerance, ppm) if len(shifts) > 0: # resonance matches temp = [] for shift in shifts: resonance = shift.resonance if limitedResonances is not None: if resonance not in limitedResonances: continue if molSystems: molSystem = getResonanceMolSystem(resonance) if molSystem and (molSystem not in molSystems): continue # Kludge until chain states if ( not molSystem ) and resonance.resonanceGroup and resonance.resonanceGroup.chains: molSystems2 = set([ ch.molSystem for ch in resonance.resonanceGroup.chains ]) if not molSystems2.intersection(molSystems): continue if peakUnit != shiftUnit: shiftValue = unit_converter[(shiftUnit, peakUnit)](shift.value, dataDimRef) else: shiftValue = shift.value points = unit_converter[(peakUnit, 'point')](shiftValue, dataDimRef) numAliasing = findNumAliasing(dataDimRef, points) deltaAliasing = numAliasing - peakDim.numAliasing if deltaAliasing: points -= dataDim.numPointsOrig * deltaAliasing shiftValue = unit_converter[('point', peakUnit)](points, dataDimRef) shift.isDiffAliasing = 1 else: shift.isDiffAliasing = 0 delta = abs(ppm - shiftValue) temp.append((delta, shift)) shift.delta = delta temp.sort() shifts = [x[1] for x in temp] textMatrix = [] colorMatrix = [] for shift in shifts: resonance = shift.resonance if limitedResonances is not None: if resonance not in limitedResonances: continue # wb104, 13 Apr 2016, added below (could check this instead in if statement # but the problem is that shift.delta also needs to exist further down # and also both attributes get deleted at bottom of the loop) if not hasattr(shift, 'isDiffAliasing'): continue if shift.isDiffAliasing: colors = [None, None, '#d0d0a0', None, None, None] else: colors = [None, None, None, None, None, None] name = makeResonanceGuiName(resonance) self.resonances.append(resonance) if shift.error >= tolerance: colors[4] = '#d0a0a0' if self.structure and atomSets1: if resonance.resonanceSet: atomSets2 = list(resonance.resonanceSet.atomSets) dist = getAtomSetsDistance(atomSets1, atomSets2, self.structure, method='noe') else: dist = None else: dist = None texts = [ resonance.serial, name, '%5.3f' % round(shift.delta, 3), shift.value, '%5.3f' % round(shift.error, 3), dist or ' ' ] if showMolSystem: molSystem = getResonanceMolSystem(resonance) texts.append(molSystem and molSystem.code) colors.append(None) textMatrix.append(texts) colorMatrix.append(colors) del shift.isDiffAliasing del shift.delta objectList = self.resonances if not noDisplay: self.scrolledMatrix.update(headingList=headingList, tipTexts=tipTexts, objectList=objectList, textMatrix=textMatrix, colorMatrix=colorMatrix, resetScrollbars=resetScrollbars)
def getResonanceGuiName(self, resonance, fullName=True): """ Analysis resonance name - overrides default version """ return makeResonanceGuiName(resonance, fullName)
def updateMeasurements(self, measurementList=None): headingList = [ '#', 'Resonance', 'Value', 'SD', 'Chain', 'Isotope', 'Fig of\nMerit', 'Peaks', 'Details' ] if measurementList is not None: self.measurementListB = measurementList self.updateListPulldown() if self.measurementListB is None: self.measurement = None measurements = [] else: if self.measurementListB.unit: headingList[2] = 'Value\n(%s)' % (self.measurementListB.unit) measurements = self.measurementListB.sortedMeasurements() if measurements and hasattr(measurements[0], 'resonances'): headingList[1] = 'Resonances' headingList[5] = 'Isotopes' if self.measurement: self.measurementButtons.buttons[0].enable() self.measurementButtons.buttons[2].enable() if self.measurementListB.className == 'ShiftList': self.measurementButtons.buttons[1].enable() else: self.measurementButtons.buttons[1].disable() else: self.measurementButtons.buttons[0].disable() self.measurementButtons.buttons[1].disable() self.measurementButtons.buttons[2].disable() objectList = [] textMatrix = [] i = 0 for measurement in measurements: i += 1 resonanceText = '' isotopeText = '' chainText = '' if hasattr(measurement, 'resonances'): resonanceText = ' '.join( [makeResonanceGuiName(r) for r in measurement.resonances]) isotopeText = ' '.join( [r.isotopeCode for r in measurement.resonances]) residueDict = {} for resonance in measurement.resonances: if resonance.resonanceSet: residue = resonance.resonanceSet.findFirstAtomSet( ).findFirstAtom().residue residueDict[residue] = None keys = residueDict.keys() if len(keys) == 1: residue = keys[0] residueNum = residue.seqCode chainText = '%s:%s' % (residue.chain.molSystem.code, residue.chain.code) elif hasattr(measurement, 'resonance'): resonance = measurement.resonance resonanceText = makeResonanceGuiName(resonance) isotopeText = measurement.resonance.isotopeCode if resonance.resonanceSet: residue = resonance.resonanceSet.findFirstAtomSet( ).findFirstAtom().residue chainText = '%s:%s' % (residue.chain.molSystem.code, residue.chain.code) datum = [ i, resonanceText, measurement.value, measurement.error, chainText, isotopeText, measurement.figOfMerit, len(measurement.peaks), measurement.details or ' ' ] objectList.append(measurement) textMatrix.append(datum) if not objectList: textMatrix.append([]) tipTexts = self.measurementsMatrix.tipTexts # unchanged, despite variable headings self.measurementsMatrix.update(headingList=headingList, objectList=objectList, textMatrix=textMatrix, tipTexts=tipTexts) self.waitingMeasurement = False
def update(self, t1List, t2List, cSize, cDist, sf, lenNh, ict, csaN, paramsS2, paramsRct, graphBounds): self.calcContourLines(sf, lenNh, ict, csaN, paramsS2, paramsRct) self.minT1, self.maxT1, self.minT2, self.maxT2 = graphBounds dataSets = [] dataColors = [] symbols = [] outliers = [] nColors = len(CLUSTER_COLORS) nSymbols = len(CLUSTER_SYMBOLS) cDist2 = cDist**2 if t1List and t2List: t1t2Points = [] resonancesT1 = {} t1Unit = MS_UNIT_MULTIPLIERS[t1List.unit] t2Unit = MS_UNIT_MULTIPLIERS[t2List.unit] for t1 in t1List.measurements: resonancesT1[t1.resonance] = t1 for t2 in t2List.measurements: resonance = t2.resonance t1 = resonancesT1.get(resonance) if t1: xyr = (t1Unit*t1.value,t2Unit*t2.value, resonance) t1t2Points.append(xyr) # Do clustering clusters = [[pt,] for pt in t1t2Points] nMerge = 1 while nMerge: nMerge = 0 for i, clusterA in enumerate(clusters[:-1]): for j in range(i+1,len(clusters)): clusterB = clusters[j] for x1, y1, r1 in clusterA: for x2, y2, r2 in clusterB: dx = x2-x1 dy = y2-y1 if (dx*dx) + (dy*dy) <= cDist2: clusterA += clusterB clusters[j] = [] nMerge += 1 break else: continue break clusters = [c for c in clusters if c] self.outlierLabels = [] for c in clusters: if len(c) < cSize: for x,y,r in c: outliers.append((x,y)) label = makeResonanceGuiName(r) self.outlierLabels.append((label,x,y)) else: data = [xyr[:2] for xyr in c] dataSets.append(data) dataSets.append(outliers) for i, dataSet in enumerate(dataSets): dataSet.sort() dataColors.append(CLUSTER_COLORS[i % nColors]) symbols.append(CLUSTER_SYMBOLS[i % nSymbols]) if outliers: symbols[-1] = 'star' #else: # dataSets.append([(0,0),(1000,1000)]) ScrolledGraph.update(self, dataSets, dataColors, symbols=symbols)