def midge(argServer=None): assert argServer (resonances, noesyPeaks, intensityFactors) = getCloudsResonanceList(argServer) # now make the noesy F2 assignments! print len(resonances), 'Resonances' print len(noesyPeaks), 'Noesy peaks' constraintList = optimiseRelaxation(resonances, noesyPeaks, intensityMax=36000000, intensityFactors=intensityFactors, tmix=60, sf=500, tcor=3, rleak=2) structure = argServer.getStructure() if structure: for constraint in constraintList.constraints: resonances = list(constraint, findFirstItem().resonances) atomSets1 = list(resonances[0].resonanceSet.atomSets) atomSets2 = list(resonances[1].resonanceSet.atomSets) distance = getAtomSetsDistance(atomSets1, atomSets2, structure) constraint.setDetails('Known Dist: %4.3f' % (distance)) return constraintList
def within_distance_on_structure(structure, resonances, maxDist): '''Check whether the distance between two resonances is within the maximum allowed distance. ''' atomSets1 = resonances[0].resonanceSet.atomSets atomSets2 = resonances[1].resonanceSet.atomSets distance = getAtomSetsDistance(atomSets1, atomSets2, structure, method='noe') if distance > maxDist: return False else: return True
def showResonancesConnection(self, resonance1, resonance2): if resonance1.resonanceSet and resonance2.resonanceSet: atomSets1 = resonance1.resonanceSet.atomSets atomSets2 = resonance2.resonanceSet.atomSets value = getAtomSetsDistance(atomSets1, atomSets2, self.structure, self.model, method=self.distMethod) color = self.getNoeColor(value) self.showAtomSetsConnection(atomSets1, atomSets2, value, color=color)
def setModel(self, model): if model is not self.model: self.model = model oldConn = self.connections[:] drawConn = self.showAtomSetsConnection self.connections = [] self.structFrame.clearConnections() self.update() for atomSets1, atomSets2, cBond, color, value in oldConn: value = getAtomSetsDistance(atomSets1, atomSets2, self.structure, self.model, method=self.distMethod) drawConn(atomSets1, atomSets2, value, color)
def setDistMethod(self, name): distMethod = distanceMethods.get(name, 'noe') if distMethod != self.distMethod: self.distMethod = distMethod for i, data in enumerate(self.connections): atomSets1, atomSets2, cBond, oldColor, oldVal = data value = getAtomSetsDistance(atomSets1, atomSets2, self.structure, self.model, method=self.distMethod) color = self.getNoeColor(value) cBond.setColor(color) cBond.setAnnotation('%.3f' % value) self.connections[i][3] = color self.connections[i][4] = value self.updateAfter()
def cheatForTesting(self, atomSelection='H'): """ Makes a perfect cloud from a structure. """ project = self.project structure = self.guiParent.argumentServer.getStructure() constraintStore = makeNmrConstraintStore(project) distConstraintList = NmrConstraint.DistanceConstraintList( constraintStore) chain = structure.findFirstCoodChain() structureGeneration.hydrogenResonances = [] molSystem = structure.molSystem atomSets = [] resonances = [] i = 0 for resonance in project.currentNmrProject.resonances: if resonance.isotopeCode == '1H': if resonance.resonanceSet: atomSet = resonance.resonanceSet.findFirstAtomSet() atom = atomSet.findFirstAtom() seqId = atom.residue.seqId if (seqId < 9) or (seqId > 78): continue if atom.residue.chain.molSystem is molSystem: if atomSelection == 'methyl': if len(atomSet.atoms) == 3: if atom.residue.ccpCode not in ('Ala', 'Val', 'Ile', 'Leu', 'Thr', 'Met'): continue elif atom.name != 'H': continue elif atomSelection == 'amide': if atom.name != 'H': continue if atom.name == 'H': resonance.name = 'HN' else: resonance.name = 'H' resonances.append(resonance) atomSets.append(list(resonance.resonanceSet.atomSets)) i += 1 print "Found %d atomSets" % (len(atomSets)) weight = 1 adcWeight = 1 constrDict = {} N = len(atomSets) for i in range(N - 1): atomSets0 = atomSets[i] residue0 = atomSets0[0].findFirstAtom().residue.seqId print "R", residue0 for j in range(i + 1, N): if j == i: continue atomSets1 = atomSets[j] dist = getAtomSetsDistance(atomSets0, atomSets1, structure) if not dist: continue if dist < 5.5: fixedResonance0 = getFixedResonance( constraintStore, resonances[i]) fixedResonance1 = getFixedResonance( constraintStore, resonances[j]) constrDict[i] = 1 constrDict[j] = 1 constraint = NmrConstraint.DistanceConstraint( distConstraintList, weight=weight, targetValue=dist, upperLimit=dist + (dist / 10), lowerLimit=dist - (dist / 10), error=dist / 5) item = NmrConstraint.DistanceConstraintItem( constraint, resonances=[fixedResonance0, fixedResonance1]) elif (atomSets1[0].findFirstAtom().name == 'H') and (atomSets0[0].findFirstAtom().name == 'H') and (dist > 7): #else: fixedResonance0 = getFixedResonance( constraintStore, resonances[i]) fixedResonance1 = getFixedResonance( constraintStore, resonances[j]) constrDict[i] = 1 constrDict[j] = 1 constraint = NmrConstraint.DistanceConstraint( distConstraintList, weight=adcWeight, targetValue=75, upperLimit=175, lowerLimit=5.0, error=94.5) item = NmrConstraint.DistanceConstraintItem( constraint, resonances=[fixedResonance0, fixedResonance1]) return (distConstraintList, resonances)
def calculateDistances(self): # setup normalisation factor intensityMax # self.maxIter # what if failure ? resDict = {} for resonance in self.project.currentNmrProject.resonances: resDict[resonance.serial] = resonance self.resonances = self.origResonances intensityFactors = [1.0 for x in range(len(self.resonances))] # optimiseRelaxation will remove unconstrained resonances self.distanceConstraintList = optimiseRelaxation( self.resonances, self.noesyPeaks, intensityMax=self.maxIntens, intensityFactors=intensityFactors, tmix=self.mixTime, sf=self.specFreq, tcor=self.corrTime, rleak=self.leakRate) constrainSpinSystems(self.distanceConstraintList) # for testing calculate distances from structure overrides any resonances: uses assigned ones #(self.distanceConstraintList, self.resonances) = self.cheatForTesting() #self.antiDistConstraintList = self.distanceConstraintList protonNumbs = {'CH3': 3, 'Haro': 2, 'HN': 1, 'H': 1} PI = 3.1415926535897931 GH = 2.6752e4 HB = 1.05459e-27 CONST = GH * GH * GH * GH * HB * HB tc = 1.0e-9 * self.corrTime wh = 2.0 * PI * self.specFreq * 1.0e6 j0 = CONST * tc j1 = CONST * tc / (1.0 + wh * wh * tc * tc) j2 = CONST * tc / (1.0 + 4.0 * wh * wh * tc * tc) #jself = 6.0*j2 + 3.0*j1 + j0 jcross = 6.0 * j2 - j0 if self.distanceConstraintList: constraintStore = self.distanceConstraintList.nmrConstraintStore dict = { 'HN': ['H'], 'HN HA': ['H', 'HA', 'HA1', 'HA2'], 'HN HA HB': ['H', 'HA', 'HA1', 'HA2', 'HB', 'HB2', 'HB3'] } self.antiDistConstraintList = makeNoeAdcs( self.resonances, self.noesyPeakList.dataSource, constraintStore, allowedAtomTypes=dict[self.adcAtomTypes]) if self.structure: N = len(self.resonances) sigmas = [[] for i in range(N)] for i in range(N): sigmas[i] = [0.0 for j in range(N)] for constraint in self.distanceConstraintList.constraints: resonances = list(constraint, findFirstItem().resonances) ri = resDict[resonances[0].resonanceSerial] rj = resDict[resonances[1].resonanceSerial] i = self.resonances.index(ri) j = self.resonances.index(rj) atomSets1 = list(ri.resonanceSet.atomSets) atomSets2 = list(rj.resonanceSet.atomSets) if atomSets1 == atomSets2: ass = list(atomSets1) atomSets1 = [ ass[0], ] atomSets2 = [ ass[-1], ] distance = getAtomSetsDistance(atomSets1, atomSets2, self.structure) r = distance * 1e-8 nhs = protonNumbs[rj.name] sigma = 0.1 * jcross * nhs / (r**6) sigmas[i][j] = sigma constraint.setDetails('Known Dist: %4.3f' % (distance)) #for constraint in self.antiDistConstraintList.constraints: # atomSets1 = list(resonances[0].resonanceSet.atomSets) # atomSets2 = list(resonances[1].resonanceSet.atomSets) # distance = getAtomSetsDistance(atomSets1, atomSets2, self.structure) # constraint.setDetails('Known Dist: %4.3f' % (distance)) fp = open('sigmas.out', 'w') for i in range(N - 1): for j in range(i + 1, N): if sigmas[i][j] != 0.0: fp.write('%3.1d %3.1d %9.2e\n' % (i, j, sigmas[i][j])) #fp.write('\n') fp.close() self.setButtonStates()
def showPeakConnection(self, peak): peakContribs = peak.peakContribs dimAtomSets = [] dimIsotopes = [] for peakDim in peak.sortedPeakDims(): isotope = None for contrib in peakDim.peakDimContribs: resonance = contrib.resonance resonanceSet = resonance.resonanceSet if resonanceSet: atomSets = resonanceSet.atomSets isotope = resonance.isotopeCode dimAtomSets.append( (peakDim, contrib.peakContribs, atomSets, isotope)) dimIsotopes.append(isotope) M = len(dimAtomSets) atomSetsPairs = set() if dimIsotopes.count('1H') > 1: hOnly = True else: hOnly = False for i in range(M - 1): peakDimI, peakContribsI, atomSetsI, isotopeI = dimAtomSets[i] if hOnly and (isotopeI != '1H'): continue for j in range(i + 1, M): peakDimJ, peakContribsJ, atomSetsJ, isotopeJ = dimAtomSets[j] if peakDimJ is peakDimI: continue if isotopeI != isotopeJ: continue if hOnly and (isotopeJ != '1H'): continue if atomSetsI == atomSetsJ: continue if peakContribs: for peakContrib in peakContribsJ: if peakContrib in peakContribsI: atomSetsPairs.add(frozenset([atomSetsI, atomSetsJ])) break else: atomSetsPairs.add(frozenset([atomSetsI, atomSetsJ])) if len(atomSetsPairs): for atomSetsI, atomSetsJ in atomSetsPairs: value = getAtomSetsDistance(atomSetsI, atomSetsJ, self.structure, self.model, method=self.distMethod) color = self.getNoeColor(value) self.showAtomSetsConnection(atomSetsI, atomSetsJ, value, color=color) # If the AtomSets could not be paired just highlight the respective atoms. else: for i in range(M): peakDimI, peakContribsI, atomSetsI, isotopeI = dimAtomSets[i] self.highlightAtoms(atomSetsI)
def makeConstraintsFromStructure(argServer, structure=None, atomRoots=None, threshold=5.5, tolerance=0.1, adcThreshold=7.0, atomTypes=('H', ), adcAtoms=('H', )): # find all NMR visible atom pairs within a specified distance to # generate distance constraints if not structure: structure = argServer.getStructure() from ccpnmr.analysis.core.AssignmentBasic import newResonance from ccpnmr.analysis.core.StructureBasic import getAtomSetsDistance from ccpnmr.analysis.core.ConstraintBasic import getFixedResonance, makeNmrConstraintHead notVisible = { 'Lys': ["H''", "HZ1", "HZ2", "HZ3"], 'Arg': ["H''", "HH11", "HH12", "HH21", "HH22", "CZ"], 'Ser': [ "H''", "HG", ], 'Cys': [ "H''", "HG", ], 'His': ["H''", "HD1", "CG"], 'Thr': [ "H''", "HG1", ], 'Tyr': ["H''", "HH", "CG"], 'Phe': ["H''", "CG"], 'Glu': [ "H''", "HE2", ], 'Asp': [ "H''", "HD2", ], 'Trp': ["H''", "CG", "CD2", "CE2"], } project = structure.root chain = structure.findFirstCoordChain().chain atomSetDict = {} anchorAtomSets = {} amideAtomSets = [] resonanceDict = {} adcAtomSets = {} print "Getting atomSets and resonances" for residue in chain.residues: atomSetDict[residue] = [] exclude = notVisible.get(residue.ccpCode) or [ "H''", ] for atom in residue.atoms: if atom.name[0] not in atomTypes: continue if atom.name in exclude: continue atomSet = atom.atomSet if atomSet: if resonanceDict.get(atomSet) is None: if atomSet.resonanceSets: resonanceSet = atomSet.findFirstResonanceSet() i = list(resonanceSet.atomSets).index(atomSet) if i >= len(resonanceSet.resonances): i = 0 resonance = resonanceSet.resonances[i] else: resonance = newResonance(project, isotopeCode='1H') resonanceDict[atomSet] = resonance atomSetDict[residue].append(atomSet) if atom.name in ('H', 'H1'): amideAtomSets.append(atomSet) elif (residue.ccpCode == 'PRO') and (atom.name == 'HD2'): amideAtomSets.append(atomSet) if atomRoots: if atom.name in atomRoots: anchorAtomSets[atomSet] = 1 else: anchorAtomSets[atomSet] = 1 if adcAtoms and (atom.name in adcAtoms): adcAtomSets[atomSet] = 1 print "Calculating distances" resonanceDists = [] resonanceDists2 = [] for amide1 in amideAtomSets: residue1 = amide1.finsFirstAtom().residue print " %d %s" % (residue1.seqCode, residue1.ccpCode) for amide2 in amideAtomSets: residue2 = amide2.findFirstAtom().residue if amide1 is amide2: amideDist = 0.0 else: amideDist = getAtomSetsDistance((amide1, ), (amide2, ), structure) if (amideDist is not None) and (amideDist <= 25.0): for atomSet1 in atomSetDict[residue1]: if anchorAtomSets.get(atomSet1) is None: continue for atomSet2 in atomSetDict[residue2]: if atomSet1 is atomSet2: continue dist = getAtomSetsDistance((atomSet1, ), (atomSet2, ), structure) if dist and dist <= threshold: resonanceDists.append( (dist, resonanceDict[atomSet1], resonanceDict[atomSet2])) if adcAtoms: for atomSet1 in atomSetDict[residue1]: if anchorAtomSets.get(atomSet1) is None: continue if adcAtomSets.get(atomSet1) is None: continue for atomSet2 in atomSetDict[residue2]: if adcAtomSets.get(atomSet2) is None: continue if atomSet1 is atomSet2: continue dist = getAtomSetsDistance((atomSet1, ), (atomSet2, ), structure) if dist >= adcThreshold: resonanceDists2.append( (dist, resonanceDict[atomSet1], resonanceDict[atomSet2])) print "Generating constraints" if resonanceDists: constraintHead = makeNmrConstraintHead(project) constraintList = constraintHead.newDistanceConstraintList() for dist, resonance1, resonance2, in resonanceDists: if resonance1 is resonance2: continue fixedResonance1 = getFixedResonance(constraintHead, resonance1) fixedResonance2 = getFixedResonance(constraintHead, resonance2) delta = tolerance * dist minDist = max(0.0, dist - delta) maxDist = dist + delta constraint = constraintList.newDistanceConstraint( weight=1.0, origData=dist, targetValue=dist, upperLimit=maxDist, lowerLimit=minDist, error=delta) item = constraint.newDistanceConstraintItem( resonances=[fixedResonance1, fixedResonance2]) if adcAtoms: constraintList2 = constraintHead.newDistanceConstraintList() # make ADCs for dist, resonance1, resonance2, in resonanceDists2: if resonance1 is resonance2: continue dist = 75.0 fixedResonance1 = getFixedResonance(constraintHead, resonance1) fixedResonance2 = getFixedResonance(constraintHead, resonance2) minDist = 5.0 maxDist = 150 delta = maxDist - minDist constraint = constraintList2.newDistanceConstraint( weight=1.0, origData=dist, targetValue=dist, upperLimit=maxDist, lowerLimit=minDist, error=delta) item = constraint.newDistanceConstraintItem( resonances=[fixedResonance1, fixedResonance2]) print "Done"
def calculateDistances(self): resonances = list(self.resonances) resDict = {} for resonance in resonances: resDict[resonance.serial] = resonance ratioHD = self.ratioHDEntry.get() or self.ratioHD tmix1 = self.tmix1Entry.get() or 60 tmix2 = self.tmix2Entry.get() or 120 tmix3 = self.tmix3Entry.get() or 200 data = [(tmix1, self.noesyPeakList1), (tmix2, self.noesyPeakList2), (tmix3, self.noesyPeakList3)] data.sort() mixingTimes = [x[0] for x in data] peakLists = [x[1] for x in data] # get a clean, symmetric and normalised NOE matrix noeMatrix = getNoeMatrixFromPeaks(self.noesyPeaks, resonances, peakLists, mixingTimes, ratioHD=ratioHD, analysis=self.guiParent) # optimiseRelaxation will remove unconstrained resonances self.distanceConstraintList, resonances = optimiseRelaxation( resonances, noeMatrix, self.mixTime, self.specFreq, self.corrTime, self.leakRate, self.carbonLabel, self.nitrogenLabel, maxIter=self.maxIter) #constrainSpinSystems(self.distanceConstraintList) # for testing calculate distances from structure overrides any resonances: uses assigned ones #(self.distanceConstraintList, self.resonances) = self.cheatForTesting() #self.antiDistConstraintList = self.distanceConstraintList protonNumbs = {'CH3': 3, 'Haro': 2, 'HN': 1, 'H': 1} PI = 3.1415926535897931 GH = 2.6752e4 HB = 1.05459e-27 CONST = GH * GH * GH * GH * HB * HB tc = 1.0e-9 * self.corrTime wh = 2.0 * PI * self.specFreq * 1.0e6 j0 = CONST * tc j1 = CONST * tc / (1.0 + wh * wh * tc * tc) j2 = CONST * tc / (1.0 + 4.0 * wh * wh * tc * tc) #jself = 6.0*j2 + 3.0*j1 + j0 jcross = 6.0 * j2 - j0 if self.distanceConstraintList and self.noesyPeakList: constraintHead = self.distanceConstraintList.nmrConstraintStore if self.adcAtomTypes: adcDict = { 'HN': ['H'], 'HN HA': ['H', 'HA', 'HA1', 'HA2'], 'HN HA HB': ['H', 'HA', 'HA1', 'HA2', 'HB', 'HB2', 'HB3'] } allowedAtomTypes = adcDict[self.adcAtomTypes] print "Making ADCs" self.antiDistConstraintList = makeNoeAdcs( resonances[:], self.noesyPeakList.dataSource, constraintHead, allowedAtomTypes=allowedAtomTypes) print "Done ADCs" if self.structure: N = len(self.resonances) sigmas = [[] for i in range(N)] for i in range(N): sigmas[i] = [0.0 for j in range(N)] for constraint in self.distanceConstraintList.constraints: item = constraint.findFirstItem() resonances = list(item.resonances) ri = resDict[resonances[0].resonanceSerial] rj = resDict[resonances[1].resonanceSerial] i = self.resonances.index(ri) j = self.resonances.index(rj) atomSets1 = list(ri.resonanceSet.atomSets) atomSets2 = list(rj.resonanceSet.atomSets) if atomSets1 == atomSets2: ass = list(atomSets1) atomSets1 = [ ass[0], ] atomSets2 = [ ass[-1], ] distance = getAtomSetsDistance(atomSets1, atomSets2, self.structure) r = distance * 1e-8 nhs = protonNumbs[rj.name] sigma = 0.1 * jcross * nhs / (r**6) sigmas[i][j] = sigma constraint.setOrigData(distance) self.update()
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)