def assignSpinSystemPerPeak(argServer=None, peaks=None, dims=None):
assert argServer or peaks
if not peaks:
peaks = argServer.getCurrentPeaks()
if not peaks:
return
for peak in peaks:
spinSystem = None
resonances = []
for i, peakDim in enumerate(peak.sortedPeakDims()):
if (dims is None) or (i in dims):
if len(peakDim.peakDimContribs) == 1:
resonance = peakDim.findFirstPeakDimContrib().resonance
resonances.append(resonance)
for resonance in resonances:
if resonance.resonanceGroup:
spinSystem = resonance.resonanceGroup
for resonance in resonances:
if spinSystem is None:
spinSystem = findSpinSystem(resonance)
addSpinSystemResonance(spinSystem, resonance)
def assign3dTocsyF2NewResonances(argServer,
peakList=None,
diagTolerance=0.5,
waterMinPpm=4.88,
waterMaxPpm=4.94):
assert argServer or peakList
if argServer:
diagTolerance = argServer.askFloat('Diagonal exclusion tolerance', 0.5)
waterMinPpm = argServer.askFloat('Minimum water exclusion ppm ', 4.88)
waterMaxPpm = argServer.askFloat('Maximum water exclusion ppm ', 4.96)
if not peakList:
project = argServer.getProject()
spectra = getSpectraByType(project, 'H[N]_H.TOCSY')
spectra += getSpectraByType(project, 'H_H[N].TOCSY')
if not spectra:
argServer.showWarning('Cannot find any 3d H H N spectra')
return
if len(spectra) > 1:
argServer.showInfo('Choose 3d TOCSY spectrum')
spectrum = argServer.getSpectrum(spectra)
else:
spectrum = spectra[0]
peakList = argServer.getPeakList(spectrum)
spectrum = peakList.dataSource
resonances = []
for peak in peakList.peaks:
peakDims = peak.sortedPeakDims()
peakDim0 = peakDims[0]
peakDim = peakDims[1]
ppm = peakDim.value
if abs(ppm - peakDim0.value) < diagTolerance:
continue
if (ppm >= waterMinPpm) and (ppm <= waterMaxPpm):
continue
if len(peakDim.peakDimContribs) < 1:
resonance = assignResToDim(peakDim).resonance
resonances.append(resonance)
contribs0 = list(peakDim0.peakDimContribs)
if contribs0:
resonance0 = contribs0[0].resonance
if resonance0.resonanceGroup:
addSpinSystemResonance(resonance0.resonanceGroup,
resonance)
else:
resonance = peakDim.findFirstPeakDimContrib().resonance
resonances.append(resonance)
return resonances
def assignSpinSystemPerPeak(argServer=None, peaks=None):
assert argServer or peaks
if not peaks:
peaks = argServer.getCurrentPeaks()
for peak in peaks:
spinSystem = None
resonances = []
peakDims = peak.sortedPeakDims()
for peakDim in peakDims:
if len(peakDim.peakDimContribs) == 1:
resonance = peakDim.peakDimContribs[0].resonance
resonances.append(resonance)
for resonance in resonances:
if resonance.resonanceGroup:
spinSystem = resonance.resonanceGroup
for resonance in resonances:
if spinSystem is None:
spinSystem = findSpinSystem(resonance)
addSpinSystemResonance(spinSystem, resonance)
def assignDimNewResonances(peaks,
dimNum,
diagTolerance=0.5,
waterMinPpm=4.88,
waterMaxPpm=4.92,
assignType=False):
"""Descrn:
Inputs:
Output:
"""
resonances = []
for peak in peaks:
peakDims = peak.sortedPeakDims()
peakDim = peak.findFirstPeakDim(dim=dimNum)
ppm = peakDim.value
# Check for 1H diagonal peaks and water range
if '1H' in peakDim.dataDimRef.expDimRef.isotopeCodes:
if (ppm >= waterMinPpm) and (ppm <= waterMaxPpm):
continue
ignore = False
for peakDim0 in peak.peakDims:
if peakDim0 is not peakDim:
if '1H' in peakDim0.dataDimRef.expDimRef.isotopeCodes:
if abs(ppm - peakDim0.value) < diagTolerance:
ignore = True
break
if ignore:
continue
refExperiment = peak.peakList.dataSource.experiment.refExperiment
if len(peakDim.peakDimContribs) < 1:
resonance = assignResToDim(peakDim).resonance
resonances.append(resonance)
if refExperiment and (refExperiment.nmrExpPrototype.name
in intraSpinSystemExperiments):
contrib0 = None
for peakDim0 in peak.peakDims:
if (peakDim0 is not peakDim) and peakDim0.peakDimContribs:
contrib0 = peakDim0.findFirstPeakDimContrib()
if contrib0:
resonance0 = contrib0.resonance
if resonance0.resonanceGroup:
addSpinSystemResonance(resonance0.resonanceGroup,
resonance)
if assignType:
refExpDimRef = peakDim.dataDimRef.expDimRef.refExpDimRef
if refExpDimRef:
setResonanceTypeFromRefExp(resonance, refExpDimRef)
else:
resonance = peakDim.findFirstPeakDimContrib().resonance
if assignType:
refExpDimRef = peakDim.dataDimRef.expDimRef.refExpDimRef
if refExpDimRef:
setResonanceTypeFromRefExp(resonance, refExpDimRef)
resonances.append(resonance)
return resonances
def initialisePeakList(self):
isAmide = self.isAmide
peakList = self.peakList
if not peakList:
showWarning('Warning',
'No peak list available or selected',
parent=self)
return
experimentType = peakList.dataSource.experiment.refExperiment.name
for peak in peakList.peaks:
peakDims = peak.sortedPeakDims()
spinSystem = None
resonances = []
for peakDim in peakDims:
dataDimRef = peakDim.dataDimRef
if not dataDimRef:
continue
isotopes = dataDimRef.expDimRef.isotopeCodes
if not peakDim.peakDimContribs:
if '15N' in isotopes:
if hasattr(
peak, 'amideConfirmed'
) and peak.amideConfirmed and isAmide.get(peak):
peakDim2 = isAmide[peak].findFirstPeakDim(
dim=peakDim.dim)
contrib2 = peakDim2.findFirstPeakDimContrib()
if contrib2:
contrib = assignResToDim(
peakDim, contrib2.resonance)
else:
contrib = assignResToDim(peakDim)
assignResToDim(peakDim2, contrib.resonance)
else:
contrib = assignResToDim(peakDim)
else:
contrib = assignResToDim(peakDim)
else:
contrib = peakDim.findFirstPeakDimContrib()
if not contrib:
continue
resonance = contrib.resonance
if '13C' in isotopes:
if experimentType == 'H[N[CO]]':
resonance.setAssignNames([
'C',
])
elif experimentType == 'H[N[co[CA]]]':
resonance.setAssignNames([
'CA',
])
continue
resonances.append(resonance)
if isAmide.get(peak) and hasattr(
peak, 'amideConfirmed') and peak.amideConfirmed:
continue
if ('1H' in isotopes) and (experimentType != 'H[C]'):
resonance.setAssignNames([
'H',
])
elif '15N' in isotopes:
resonance.setAssignNames([
'N',
])
for resonance in resonances:
if resonance.resonanceGroup:
spinSystem = resonance.resonanceGroup
for resonance in resonances:
if spinSystem is None:
spinSystem = findSpinSystem(resonance)
addSpinSystemResonance(spinSystem, resonance)
def linkSpinSystemInterIntraResonances(spinSystem,
activeLists,
tolerances=None):
nmrProject = spinSystem.topObject
prevSpinSystem = findConnectedSpinSystem(spinSystem)
allowedRefExps, coRefExps = getSeqAssignRefExperiments(nmrProject.root)
if not prevSpinSystem:
if spinSystem.residue:
residueB = getLinkedResidue(spinSystem.residue, linkCode='prev')
prevSpinSystem = nmrProject.findFirstResonanceGroup(
residue=residueB)
if not prevSpinSystem:
prevSpinSystem = nmrProject.newResonanceGroup()
makeSeqSpinSystemLink(prevSpinSystem, spinSystem)
peaks = []
found = {}
expTypes = {}
linkDims = {}
# go though the peaks associated with this spin system
# within the selected peak lists
# find the indirect, linking dimension
for resonance in spinSystem.resonances:
if resonance.isotopeCode != '15N':
continue
if not isResonanceAmide(resonance):
continue
for contrib in resonance.peakDimContribs:
peakDim = contrib.peakDim
peak = peakDim.peak
if found.get(peak):
continue
peakList = peak.peakList
if peakList not in activeLists:
continue
setupPeakHeight(peak)
intensity = peak.findFirstPeakIntensity(intensityType='height')
if not intensity:
continue
spectrum = peakList.dataSource
expType = expTypes.get(peakList, spectrum.experiment.refExperiment)
expTypes[peakList] = expType
linkDim = linkDims.get(peakList)
if linkDim is None:
boundDict = {}
for dataDimA, dataDimB in getOnebondDataDims(spectrum):
boundDict[dataDimA] = dataDimB
boundDict[dataDimB] = dataDimA
dims = []
for dataDim in spectrum.dataDims:
dataDimRef = getPrimaryDataDimRef(dataDim)
if not dataDimRef:
continue
isotopes = '/'.join(dataDimRef.expDimRef.isotopeCodes)
dims.append((isotopes, dataDim))
dims.sort()
for isotopes, dataDim in dims:
if '13C' == isotopes:
linkDim = (dataDim.dim, isotopes)
break
elif '1H' == isotopes:
dataDimB = boundDict.get(dataDim)
if dataDimB:
dataDimRefB = getPrimaryDataDimRef(dataDimB)
if '15N' in dataDimRefB.expDimRef.isotopeCodes:
continue
linkDim = (dataDim.dim, isotopes)
break
linkDims[peakList] = linkDim
if linkDim is None:
continue
if peakDim.dim is linkDim[0]:
continue
found[peak] = True
peakDimL = peak.findFirstPeakDim(dim=linkDim[0])
isotope = linkDim[1]
peaks.append((peak, expType, peakDimL, isotope, intensity.value))
peakTypes = []
interResonances = {}
intraResonances = {}
for peak, expType, peakDim, isotope, height in peaks:
ppm = peakDim.value
atomType = None
if expType in coRefExps:
isInter = True
elif 'N[coca]' in expType.name:
isInter = False
elif 'N_' in expType.name:
isInter = False
else:
isInter = None
resonance = None
contrib = peakDim.findFirstPeakDimContrib()
if contrib:
resonance = contrib.resonance
if isInter and resonance.assignNames:
atomType = resonance.assignNames[0]
interResonances[atomType] = (resonance, ppm, prevSpinSystem)
if (isInter is False) and resonance.assignNames:
atomType = resonance.assignNames[0]
intraResonances[atomType] = (resonance, ppm, spinSystem)
if not atomType:
atomType = guessAtomType(expType, ppm, height)
peakTypes.append((peakDim, atomType, contrib, isotope, isInter, ppm))
# Get known inter/intra resonance assignments
# for each atom type
for peakDim, atomType, contrib, isotope, isInter, ppm in peakTypes:
if isInter is None:
continue
elif isInter:
resDict = interResonances
uniqSpinSystem = prevSpinSystem
else:
resDict = intraResonances
uniqSpinSystem = spinSystem
if atomType:
resonance, ppm2, ss = resDict.get(atomType, (None, None, None))
if (resonance is None) and contrib:
resDict[atomType] = (contrib.resonance, ppm, uniqSpinSystem)
# Make any new assignments for the unambig peaks
untypedIntra = []
untypedInter = []
for i, data in enumerate(peakTypes):
(peakDim, atomType, contrib, isotope, isInter, ppm) = data
if isInter is None:
continue
elif isInter:
untyped = untypedInter
resDict = interResonances
uniqSpinSystem = prevSpinSystem
else:
resDict = intraResonances
untyped = untypedIntra
uniqSpinSystem = spinSystem
if atomType:
# Get any previously used resonances for this atom type
resonance, ppm2, ss = resDict.get(atomType, (None, None, None))
# If no prev resonance, look at the peak assignment
if (not resonance) and contrib:
resonance = contrib.resonance
# Check to ensure that any existing resonance
# is from the correct, this/prev spin system
if resonance:
spinSystem2 = resonance.resonanceGroup
if spinSystem2 and (spinSystem2 is not uniqSpinSystem):
resonance = None
# If no valid reasonance yet, check named ones
# in the required spin system
if not resonance:
for resonance2 in uniqSpinSystem.resonances:
if atomType in resonance2.assignNames:
resonance = resonance2
break
# If no valid resonance yet, make a new one
if not resonance:
resonance = nmrProject.newResonance(isotopeCode=isotope)
# If peak dim is assigned to the wrong resonance
# clear the assignment
if contrib and contrib.resonance is not resonance:
clearPeakDim(peakDim)
contrib = None
# Ensure the peak dim is assigned correctly
if not contrib:
assignResToDim(peakDim, resonance)
# Check type of resonance set correctly
if not resonance.assignNames:
assignResonanceType(resonance, assignNames=(atomType, ))
# Check spin system set correctly
if resonance.resonanceGroup is not uniqSpinSystem:
addSpinSystemResonance(uniqSpinSystem, resonance)
# Store resonance by atom type, so that it can
# be picked up later
resDict[atomType] = (resonance, ppm, uniqSpinSystem)
else:
untyped.append((peakDim, contrib, isotope, isInter, ppm, i))
uniqResonances = interResonances.values() + intraResonances.values()
# Cluster untyped peaks
interCluster = {}
intraCluster = ()
interData = (untypedInter, interCluster, prevSpinSystem)
intraData = (untypedIntra, intraCluster, spinSystem)
for untyped, clusters, uniqSpinSystem in (interData, intraData):
for peakDim, contrib, isotope, isInter, ppm, i in untyped:
if peakDim in clusters:
continue
if tolerances:
tolerance = tolerances[isotope]
else:
tolerance = getAnalysisDataDim(peakDim.dataDim).assignTolerance
if contrib:
resonance = contrib.resonance
else:
resonance = None
cluster = [peakDim]
interCluster[peakDim] = True
for peakDimB, contribB, isotopeB, isInterB, ppmB, i in untyped:
if isotope != isotopeB:
continue
if abs(ppmB - ppm) > tolerance:
continue
if peakDim.peak.peakList == peakDimB.peak.peakList:
continue
if contribB:
if not resonance:
resonance = contribB.resonance
if resonance is not contribB.resonance:
clearPeakDim(peakDimB)
assignResToDim(peakDimB,
resonance,
tolerance=tolerance)
cluster.append(peakDimB)
clusters[peakDimB] = True
if not resonance:
# Try to macth to any typed peaks
for peakDimB, atomType, contribB, isotopeB, isInterB, ppmB in peakTypes:
if not contribB:
continue
if not atomType:
continue
if isotope != isotopeB:
continue
if abs(ppmB - ppm) > tolerance:
continue
if peakDim.peak.peakList == peakDimB.peak.peakList:
continue
resonance = contribB.resonance
# Set type for this peak
peakTypes[i] = (peakDim, atomType, contrib, isotope,
isInter, ppm)
break
if not resonance:
resonance = nmrProject.newResonance(isotopeCode=isotope)
for peakDimC in cluster:
clearPeakDim(peakDimC)
assignResToDim(peakDimC, resonance, tolerance=tolerance)
uniqResonances.append((resonance, ppm, uniqSpinSystem))
if resonance.resonanceGroup is not uniqSpinSystem:
addSpinSystemResonance(uniqSpinSystem, resonance)
# E.g. Find the HNCA peaks which best match the HNcoCA/iHNCA resonances
matchDict = {}
closestDict = {}
for peakDim, atomType, contrib, isotope, isInter, ppm in peakTypes:
if isInter is not None:
# Not through HNcoCA or iHNCA
continue
if tolerances:
tolerance = tolerances[isotope]
else:
tolerance = getAnalysisDataDim(peakDim.dataDim).assignTolerance
matches = []
shiftList = peakDim.peak.peakList.dataSource.experiment.shiftList
for resonanceB, ppm2, uniqSpinSystem in uniqResonances:
if resonanceB.isotopeCode != isotope:
continue
assignNames = resonanceB.assignNames
if assignNames and (atomType not in assignNames):
continue
if not ppm2:
shift = resonanceB.findFirstShift(parentList=shiftList)
if not shift:
continue
ppm2 = shift.value
delta = abs(ppm - ppm2)
prevDelta = closestDict.get(peakDim)
if (prevDelta is None) or (delta < prevDelta):
closestDict[peakDim] = delta
if delta > tolerance:
continue
matches.append((delta, resonanceB, uniqSpinSystem))
# Best match has smallest delta
if matches:
matches.sort()
delta, resonance, uniqSpinSystem = matches[0]
prevDelta, peakDimB, ss = matchDict.get(resonance,
(None, None, None))
if not peakDimB or (delta < prevDelta):
matchDict[resonance] = (delta, peakDim, uniqSpinSystem)
uniqResonanceDict = {}
for resonance in matchDict.keys():
delta, peakDim, uniqSpinSystem = matchDict[resonance]
uniqResonanceDict[peakDim] = resonance, uniqSpinSystem
# E.g. go through HNCA peaks and assign to
# HNcoCA or iHNCA resonances if required
nonMatched = {}
for peakDim, atomType, contrib, isotope, isInter, ppm in peakTypes:
if isInter is not None:
continue
if closestDict.get(peakDim) is None:
# No inter residue peaks at all
intensity = peak.findFirstPeakIntensity(intensityType='height')
if intensity:
if not nonMatched.has_key(atomType):
nonMatched[atomType] = []
nonMatched[atomType].append(
(-abs(intensity.value), peakDim, contrib, isotope))
continue
match = uniqResonanceDict.get(peakDim)
if match:
resonance, uniqSpinSystem = match
if tolerances:
tolerance = tolerances[isotope]
else:
tolerance = getAnalysisDataDim(peakDim.dataDim).assignTolerance
# untyped through-carbonyl resonance can interit type
# by matching typed peaks
if atomType and not resonance.assignNames:
resonance.addAssignName(atomType)
# e.g. the HNcoCA resonance is the one to put on this HNCA peak
if contrib:
if contrib.resonance is not resonance:
clearPeakDim(peakDim)
assignResToDim(peakDim, resonance, tolerance=tolerance)
else:
assignResToDim(peakDim, resonance, tolerance=tolerance)
else:
# No match to an unambig peak
# store to work out which is best for each atom type
# e.g. just in case we have two intra residue CA possibilites
if not nonMatched.has_key(atomType):
nonMatched[atomType] = []
nonMatched[atomType].append(
(closestDict[peakDim], peakDim, contrib, isotope))
for atomType in nonMatched.keys():
if (atomType in intraResonances) and (atomType in interResonances):
# Both resonances already found, peak is spurious
continue
if (atomType in intraResonances) and (atomType not in interResonances):
# E.g. there was iHNCA but no HNcoCA
otherSpinSystem = prevSpinSystem
elif (atomType not in intraResonances) and (atomType
in interResonances):
# E.g. there was HNcoCA but no iHNCA
otherSpinSystem = spinSystem
else:
# No info
continue
peakDimList = nonMatched[atomType]
peakDimList.sort()
# Assume that if we have two possible ambiguous peaks
# for any given atom type, then the one furthest from an
# unambigous peak is the best to take
deltaPpm, peakDim, contrib, isotope = peakDimList[-1]
if tolerances:
tolerance = tolerances[isotope]
else:
tolerance = getAnalysisDataDim(peakDim.dataDim).assignTolerance
# E.g. this HNCA peak matches no HNcoCA/iHNCA resonances
resonance = None
if contrib:
resonance = contrib.resonance
if resonance:
# Already have an assignment
spinSystem2 = resonance.resonanceGroup
if spinSystem2 is None:
addSpinSystemResonance(otherSpinSystem, resonance)
elif spinSystem2 is not otherSpinSystem:
resonance = nmrProject.newResonance(isotopeCode=isotope)
addSpinSystemResonance(otherSpinSystem, resonance)
clearPeakDim(peakDim)
contrib = assignResToDim(peakDim,
resonance,
tolerance=tolerance)
else:
# Needs a new assignment
for resonance2 in otherSpinSystem.resonances:
if atomType in resonance2.assignNames:
resonance = resonance2
break
if not resonance:
resonance = nmrProject.newResonance(isotopeCode=isotope)
contrib = assignResToDim(peakDim,
resonance,
tolerance=tolerance)
addSpinSystemResonance(otherSpinSystem, resonance)
if not contrib:
# Resonance has come from the spin system due to its atomTypes
contrib = assignResToDim(peakDim,
resonance,
tolerance=2 * tolerance)
if not contrib:
# Existing resonance on spin system was too far away
resonance = nmrProject.newResonance(isotopeCode=isotope)
contrib = assignResToDim(peakDim, resonance, tolerance=tolerance)
addSpinSystemResonance(otherSpinSystem, resonance)
if atomType:
assignNames = (atomType, )
else:
assignNames = []
if not resonance.assignNames:
assignResonanceType(resonance, assignNames=assignNames)