def assignPeaksAutomatic(argServer,
ambiguous=True,
peaks=None,
shiftRanges=None,
tolerances=None,
aliasing=True,
findAssigned=False):
from ccpnmr.analysis.core.AssignmentAdvanced import possiblePeakAssigments
from ccpnmr.analysis.core.AssignmentBasic import assignResToDim
if not peaks:
peaks = argServer.getCurrentPeaks()
for peak in peaks:
resonances = possiblePeakAssigments(peak,
shiftRanges=shiftRanges,
tolerances=tolerances,
aliasing=aliasing,
findAssigned=findAssigned)
hasMultiple = bool([ll for ll in resonances if len(ll) > 1])
print ambiguous, hasMultiple, resonances, [
ll for ll in resonances if len(ll) > 1
]
if ambiguous or not hasMultiple:
for ii, peakDim in enumerate(peak.sortedPeakDims()):
for resonance in resonances[ii]:
assignResToDim(peakDim, resonance)
def pickPeaksFromCing(cingPeakList, peakList, resonanceDict):
for cingPeak in cingPeakList:
peakList.root.override = True
peak = pickPeak(peakList, cingPeak.positions, unit='ppm', doFit=False,
serial=cingPeak.xeasyIndex)
peakList.root.override = False
setManualPeakIntensity(peak, value=cingPeak.height.value, intensityType="height")
if len(peak.peakDims) == len(cingPeak.resonances):
for j, peakDim in enumerate(peak.sortedPeakDims()):
cingResonance = cingPeak.resonances[j]
resonance = resonanceDict.get(cingResonance)
if resonance is not None:
assignResToDim(peakDim, resonance)
else:
# original, fixed
for j, peakDim in enumerate(peak.sortedPeakDims()):
numAssignments = len(cingPeak.resonances) / len(peak.peakDims)
ccpnResonances = []
indx = j
for k in range(numAssignments):
cingResonance = cingPeak.resonances[indx]
resonance = resonanceDict.get(cingResonance)
ccpnResonances.append(resonance)
indx += len(peak.peakDims)
for res in ccpnResonances:
if res is not None:
assignResToDim(peakDim, res)
print "Peaks Picked"
def assignAllNewResonances(argServer=None, peaks=None):
assert argServer or peaks
if not peaks:
peaks = argServer.getCurrentPeaks()
# e.g. Assign all of an unassigned HSQC to different Hn and N resonances
for peak in peaks:
for peakDim in peak.peakDims:
if len(peakDim.peakDimContribs) < 1:
assignResToDim(peakDim)
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 assignSelectedPeaks(self):
selectedPeakLinks = self.displayPeakTable.currentObjects
for pl in selectedPeakLinks:
peak = pl.getPeak()
if peak:
for resonance, dimension in zip(pl.getResonances(),
peak.getDimensions()):
ccpnResonance = resonance.getCcpnResonance()
ccpnDimension = dimension.getCcpnDimension()
if ccpnResonance and ccpnDimension:
assignResToDim(ccpnDimension, ccpnResonance)
def assignAmbigPeaks(peaks, resonances):
tolerance = 0.015
shifts = []
N - len(resonances)
for resonance in resonances:
shifts.append(resonance.findFirstShift().value)
for peak in peaks:
for peakDim in peak.peakDims:
ppm = pnt2ppm(peakDim.position,peakDim.dataDimRef)
candidates = []
for i in range(N):
if abs(ppm-shift) <= tolerance:
candidates.append(i)
if len(candidates) == 1:
resonance = resonances[candidates[0]]
assignResToDim(peakDim,resonance)
def duplicateResidueAssignments(residueA, residueB, experimentChains=None):
"""
Assign residueB to an equivalent set of resonances as residueA
Optional dictionary, keyed by experiment to specifiy which chain (should be parent of residueA
or residueB or None - for both) an experiment's peak assignments should go with.
.. describe:: Input
MolSystem.Residue, MolSystem.Residue, Dict of Nmr.Experiment:MolSystem.Chain (or None)
.. describe:: Output
None
"""
from ccpnmr.analysis.core.AssignmentBasic import assignResToDim
project = residueA.root
nmrProject = project.currentNmrProject
atomSetDict = {}
for atom in residueB.atoms:
atomSet = atom.atomSet
if atomSet:
atomSetDict[atomSet.name] = atomSet
if experimentChains is None:
experimentChains = {}
else:
for experiment in experimentChains:
chain = experimentChains[experiment]
molSystems = experiment.molSystems
if chain and chain.molSystem not in molSystems:
experiment.addMolSystem(chain.molSystem)
else:
if residueA.chain.molSystem not in molSystems:
experiment.addMolSystem(residueA.chain.molSystem)
if residueB.chain.molSystem not in molSystems:
experiment.addMolSystem(residueB.chain.molSystem)
resonancesA = getResidueResonances(residueA)
resonancesB = getResidueResonances(residueB)
resonancesDictA = {}
for resonance in resonancesA:
atomSetNames = [ass.name for ass in resonance.resonanceSet.atomSets]
atomSetNames.sort()
key = tuple(atomSetNames)
resonancesDictA[key] = resonancesDictA.get(key, []) + [
resonance,
]
resonancesDictB = {}
for resonance in resonancesB:
atomSetNames = [ass.name for ass in resonance.resonanceSet.atomSets]
atomSetNames.sort()
key = tuple(atomSetNames)
resonancesDictB[key] = resonancesDictB.get(key, []) + [
resonance,
]
transfers = []
pureTransfer = True
for key in resonancesDictA.keys():
resonances1 = resonancesDictA[key]
resonances2 = resonancesDictB.get(key, [])
atomSets = []
for atomSetName in key:
if atomSetDict.has_key(atomSetName):
atomSets.append(atomSetDict[atomSetName])
if len(atomSets) == len(
key
): # If we find all equiv atom sets in destination (not always true if different res type)
# Duplications of resonances is only done if needed at a per atomSet level
doDuplicate = False
contribs = set()
for resonance1 in resonances1:
contribs.update(resonance1.peakDimContribs)
if contribs:
for contrib in contribs:
experiment = contrib.peakDim.peak.peakList.dataSource.experiment
if experimentChains.get(
experiment, residueB.chain
) is not residueB.chain: # Not a plain transfer
doDuplicate = True
pureTransfer = False
break
else: # All orphans
for experiment in experimentChains:
if experimentChains[experiment] is not residueB.chain:
doDuplicate = True
pureTransfer = False
break
if doDuplicate: # Not a plain transfer Need to make new resonances
while len(resonances2) < len(resonances1):
resonances2.append(None)
for i, resonance1 in enumerate(resonances1):
resonance2 = resonances2[i]
peakDimContribs = list(resonance1.peakDimContribs)
if peakDimContribs:
for peakDimContrib in peakDimContribs:
peakDim = peakDimContrib.peakDim
experiment = peakDim.peak.peakList.dataSource.experiment
chainB = experimentChains.get(experiment)
if chainB is None: # Duplication on this peak
if resonance2 is None:
resonance2 = nmrProject.newResonance(
isotopeCode=resonances1[0].isotopeCode)
assignAtomsToRes(atomSets, resonance2)
resonances2[i] = resonance2
assignResToDim(peakDim,
resonance2,
doWarning=False)
elif chainB is residueB.chain: # Transfer this peak
if resonance2 is None:
resonance2 = nmrProject.newResonance(
isotopeCode=resonances1[0].isotopeCode)
assignAtomsToRes(atomSets, resonance2)
resonances2[i] = resonance2
assignResToDim(peakDim,
resonance2,
doWarning=False)
for peakContrib in peakDimContrib.peakContribs:
if len(peakContrib.peakDimContribs) < 2:
peakContrib.delete()
if not peakDimContrib.isDeleted:
peakDimContrib.delete()
else:
if resonance2 is None:
resonance2 = nmrProject.newResonance(
isotopeCode=resonances1[0].isotopeCode)
assignAtomsToRes(atomSets, resonance2)
resonances2[i] = resonance2
else:
# Plain transfer, move existing resonances to different atoms
transfers.append((resonances1, atomSets))
# Transfer original spin system to destination residue
# to keep existing links and attrs (pure transfers only)
spinSystem = nmrProject.findFirstResonanceGroup(residue=residueA)
if spinSystem and pureTransfer:
spinSystem.residue = residueB
spinSystem.ccpCode = residueB.ccpCode
spinSystem.chains = [
residueB.chain,
]
# Clear all resonance to spinSystem links first so
# that assigniment can pickup the original spin system
for resonances, atomSets in transfers:
for resonance in resonances:
resonance.resonanceGroup = None
for resonances, atomSets in transfers:
for resonance in resonances:
assignAtomsToRes(atomSets, resonance)
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 transferAssignments(self):
'''Transfer assignments to project depending
on the settings from the GUI.
'''
self.fetchOptions()
if not self.dataModel or (not self.resonanceToDimension
and not self.spinSystemToResidue):
return
strategy = self.strategy
lookupSpinSystem = [
self.getAssignedSpinSystem, self.getBestScoringSpinSystem,
self.getUserDefinedSpinSystem, self.getSelectedSolutionSpinSystem
][self.spinSystemType]
residues = self.dataModel.chain.residues
spinSystemSequence = [lookupSpinSystem(res) for res in residues]
ccpnSpinSystems = []
ccpnResidues = []
# if self.spinSystemType == 0 it means that it for sure already
# assigned like this
if self.spinSystemToResidue and not self.spinSystemType == 0:
for spinSys, res in zip(spinSystemSequence, residues):
if spinSys and res:
ccpnSpinSystems.append(spinSys.getCcpnResonanceGroup())
ccpnResidues.append(res.getCcpnResidue())
assignSpinSystemstoResidues(ccpnSpinSystems,
ccpnResidues,
strategy=strategy,
guiParent=self.guiParent)
if self.resonanceToDimension:
allSpectra = self.allSpectra
if self.intra:
for residue, spinSystem in zip(residues, spinSystemSequence):
if not spinSystem:
continue
intraLink = residue.getIntraLink(spinSystem)
for pl in intraLink.getPeakLinks():
peak = pl.getPeak()
if not allSpectra and peak.getSpectrum(
) is not self.spectrum:
continue
if not peak:
continue
resonances = pl.getResonances()
if self.noDiagonal and len(
set(resonances)) < len(resonances):
continue
for resonance, dimension in zip(
resonances, peak.getDimensions()):
ccpnResonance = resonance.getCcpnResonance()
ccpnDimension = dimension.getCcpnDimension()
assignResToDim(ccpnDimension, ccpnResonance)
if self.sequential:
for residue, spinSystemA, spinSystemB in zip(
residues, spinSystemSequence, spinSystemSequence[1:]):
if not spinSystemA or not spinSystemB:
continue
link = residue.getLink(spinSystemA, spinSystemB)
for pl in link.getPeakLinks():
peak = pl.getPeak()
if not allSpectra and peak.getSpectrum(
) is not self.spectrum:
continue
if not peak:
continue
resonances = pl.getResonances()
if self.noDiagonal and len(
set(resonances)) < len(resonances):
continue
for resonance, dimension in zip(
resonances, peak.getDimensions()):
ccpnResonance = resonance.getCcpnResonance()
ccpnDimension = dimension.getCcpnDimension()
assignResToDim(ccpnDimension, ccpnResonance)
self.guiParent.resultsTab.update()
def pickAssignSpecFromRoot(argServer, rootPeakList=None, targetPeakList=None):
toleranceDict = {'1H': 0.03, '13C': 0.1, '15N': 0.15}
assert argServer or (rootPeakList and targetPeakList)
if argServer:
project = argServer.getProject()
else:
project = rootPeakList.root
spectra = []
for experiment in project.currentNmrProject.sortedExperiments():
for spectrum in experiment.sortedDataSources():
spectra.append(spectrum)
if not rootPeakList:
rootSpec = argServer.getSpectrum(spectra)
rootPeakList = argServer.getPeakList(rootSpec)
rootSpec = rootPeakList.dataSource
rootIsotopes = getSpectrumIsotopes(rootSpec)
tolerances = []
for isotope in rootIsotopes:
tolerance = argServer.askFloat(
'%s tolerance' % isotope, toleranceDict.get(
isotope, 0.1)) or toleranceDict.get(isotope, 0.1)
tolerances.append(tolerance)
if not targetPeakList:
targetSpectra = []
for experiment in project.currentNmrProject.experiments:
for spectrum in experiment.dataSources:
isotopes = getSpectrumIsotopes(spectrum)
n = 0
for isotope in rootIsotopes:
if isotope in isotopes:
isotopes.remove(isotope)
n += 1
if n == len(rootIsotopes):
targetSpectra.append(spectrum)
targetSpec = argServer.getSpectrum(targetSpectra)
targetPeakList = argServer.getPeakList(targetSpec)
targetSpec = targetPeakList.dataSource
if not targetSpec:
argServer.showWarning('No suitable target spectra found.')
# Determine mapping of root to target dimensions according to data dim isotopes.
# - Only ask user if there are multiple possibilities.
mapping = []
targetIsotopes = getSpectrumIsotopes(targetSpec)
i = 0
for isotope in rootIsotopes:
if targetIsotopes.count(isotope) == 1:
mapping.append(targetIsotopes.index(isotope))
else:
j = 0
matches = []
for targetIsotope in targetIsotopes:
if targetIsotope == isotope:
matches.append(j)
j += 1
for j in matches[:-1]:
if argServer.askYesNo(
'Match root dimension %d (%s) to target dimension %d?'
% (i + 1, isotope, j + 1)):
mapping.append(j)
break
else:
mapping.append(matches[-1])
i += 1
fullRegion = []
for dataDim in targetSpec.sortedDataDims():
if dataDim.className == 'FreqDataDim':
dataDimRef = getPrimaryDataDimRef(dataDim)
valueMax = pnt2ppm(1, dataDimRef)
valueMin = pnt2ppm(dataDim.numPoints, dataDimRef)
fullRegion.append([valueMin, valueMax])
else:
fullRegion.append([1, dataDim.numPoints])
M = len(rootPeakList.peaks)
c = 0
foundPeaks = 0
for peak in rootPeakList.peaks:
region = list(fullRegion)
for i, peakDim in enumerate(peak.sortedPeakDims()):
if peakDim.dataDimRef:
error = tolerances[i]
value = peakDim.value
region[mapping[i]] = (value - error, value + error)
peaks = searchPeaks([
targetPeakList,
], region)
peaks.extend(findPeaks(targetPeakList, region))
# possible to grow the region here of no peaks are found
for peak2 in peaks:
for intens in peak.peakIntensities:
if str(intens.value) == 'inf':
peaks.remove(peak2)
peak2.delete()
break
foundPeaks += len(peaks)
c += 1
for i, peakDim in enumerate(peak.sortedPeakDims()):
for peak2 in peaks:
peakDim2 = peak2.sortedPeakDims()[mapping[i]]
if len(peakDim2.peakDimContribs) < 1:
for contrib in peakDim.peakDimContribs:
assignResToDim(peakDim2,
contrib.resonance,
doWarning=0)
print 'Root peak %d of %d' % (c, M)
if argServer:
name = '%s:%s' % (targetPeakList.dataSource.experiment.name,
targetPeakList.dataSource.name)
argServer.showInfo('Picked %d peaks in %s' % (foundPeaks, name))
return targetPeakList.peaks
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)
def fixProchiralSwaps(project, sdt=0.04):
# Threshold shift SD for action
nmr = project.currentNmrProject
prochirals = set()
for resonance in nmr.resonances:
resonanceSet = resonance.resonanceSet
if not resonanceSet:
continue
resonances = resonanceSet.resonances
if len(resonances) == 2:
prochirals.add(resonances)
shiftLists = nmr.findAllMeasurementLists(className='ShiftList')
shiftLists = [(len(sl.measurements), sl) for sl in shiftLists if sl.experiments]
shiftLists.sort()
shiftList = shiftLists[-1][1]
nSwaps = 0
for resonanceA, resonanceB in prochirals:
shiftA = resonanceA.findFirstShift(parentList=shiftList)
shiftB = resonanceB.findFirstShift(parentList=shiftList)
if not (shiftA and shiftB):
continue
sdA = shiftA.error
sdB = shiftB.error
if (sdA > sdt) or (sdB > sdt):
if shiftB.value < shiftA.value:
resonanceA, resonanceB = resonanceB, resonanceA
contribsA = resonanceA.peakDimContribs
contribsB = resonanceB.peakDimContribs
peakDimsA = set([c.peakDim for c in contribsA])
peakDimsB = set([c.peakDim for c in contribsB])
#peakDimsA = [pd for pd in peakDimsA0 if pd not in peakDimsB0]
#peakDimsB = [pd for pd in peakDimsB0 if pd not in peakDimsA0]
ppms = []
peakDims = []
for peakDim in peakDimsA:
ppms.append(peakDim.value)
peakDims.append(peakDim)
for peakDim in peakDimsB:
ppms.append(peakDim.value)
peakDims.append(peakDim)
if not ppms:
continue
centers, clusters, clusterIndices = kMeansPlusPlus(ppms, 2) #@UnusedVariable clusters
centerA, centerB = centers
if abs(centerA - centerB) < sdt:
continue
peakDimsA = [peakDims[i] for i in clusterIndices[0]]
peakDimsB = [peakDims[i] for i in clusterIndices[1]]
if centerB < centerA:
peakDimsA, peakDimsB = peakDimsB, peakDimsA
for peakDim in peakDimsA:
contribA = peakDim.findFirstPeakDimContrib(resonance=resonanceA)
contribB = peakDim.findFirstPeakDimContrib(resonance=resonanceB)
if contribB:
peakContribs = contribB.peakContribs
contribB.delete()
if not contribA:
assignResToDim(peakDim, resonanceA, peakContribs=peakContribs)
nSwaps += 1
for peakDim in peakDimsB:
contribB = peakDim.findFirstPeakDimContrib(resonance=resonanceB)
contribA = peakDim.findFirstPeakDimContrib(resonance=resonanceA)
if contribA:
peakContribs = contribA.peakContribs
contribA.delete()
if not contribB:
assignResToDim(peakDim, resonanceB, peakContribs=peakContribs)
nSwaps += 1
return nSwaps
def assignCloseSingleShiftMatches(peakList):
spectrum = peakList.dataSource
experiment = spectrum.experiment
shiftList = experiment.shiftList
hDims = findSpectrumDimsByIsotope(spectrum, '1H')
tolerances = getDimTolerances(spectrum)
bondedDims = getBondedDimsDict(spectrum)
info = (experiment.name, spectrum.name, peakList.serial,
len(peakList.peaks))
print 'Assigning obvious shift matches for %s:%s:%d - %d peaks' % info
c = 0
for peak in peakList.peaks:
if c and (c % 100 == 0):
print ' %d' % (c, )
c += 1
peakDims = peak.sortedPeakDims()
boundResonances = {}
for dim in hDims:
peakDim = peakDims[dim]
if not peakDim.peakDimContribs:
resonances = []
shifts = findMatchingPeakDimShifts(peakDim,
shiftRanges=None,
tolerance=tolerances[dim],
aliasing=True,
findAssigned=False)
dim2 = bondedDims.get(dim)
peakDim2 = None
if dim2 is not None:
peakDim2 = peakDims[dim2]
shifts2 = []
if peakDim2.peakDimContribs:
for contrib in peakDim2.peakDimContribs:
shift = contrib.resonance.findFirstShift(
parentList=shiftList)
if shift:
shifts2.append(shift)
else:
shifts2 = findMatchingPeakDimShifts(
peakDim2,
shiftRanges=None,
tolerance=tolerances[dim2],
aliasing=True,
findAssigned=False)
for shift in shifts:
resonance1 = shift.resonance
for shift2 in shifts2:
resonance2 = shift2.resonance
if areResonancesBound(resonance1, resonance2):
resonances.append(resonance1)
boundResonances[resonance1] = resonance2
break
else:
for shift in shifts:
resonances.append(shift.resonance)
if len(resonances) == 1:
resonance = resonances[0]
assignResToDim(peakDim, resonance, doWarning=False)
resonance2 = boundResonances.get(resonance)
if peakDim2 and (resonance2 is not None):
assignResToDim(peakDim2, resonance2, doWarning=False)
def fixProchiralSwaps(project, sdt=0.04):
# Threshold shift SD for action
nmr = project.currentNmrProject
prochirals = set()
for resonance in nmr.resonances:
resonanceSet = resonance.resonanceSet
if not resonanceSet:
continue
resonances = resonanceSet.resonances
if len(resonances) == 2:
prochirals.add(resonances)
shiftLists = nmr.findAllMeasurementLists(className='ShiftList')
shiftLists = [(len(sl.measurements), sl) for sl in shiftLists
if sl.experiments]
shiftLists.sort()
shiftList = shiftLists[-1][1]
nSwaps = 0
for resonanceA, resonanceB in prochirals:
shiftA = resonanceA.findFirstShift(parentList=shiftList)
shiftB = resonanceB.findFirstShift(parentList=shiftList)
if not (shiftA and shiftB):
continue
sdA = shiftA.error
sdB = shiftB.error
if (sdA > sdt) or (sdB > sdt):
if shiftB.value < shiftA.value:
resonanceA, resonanceB = resonanceB, resonanceA
contribsA = resonanceA.peakDimContribs
contribsB = resonanceB.peakDimContribs
peakDimsA = set([c.peakDim for c in contribsA])
peakDimsB = set([c.peakDim for c in contribsB])
#peakDimsA = [pd for pd in peakDimsA0 if pd not in peakDimsB0]
#peakDimsB = [pd for pd in peakDimsB0 if pd not in peakDimsA0]
ppms = []
peakDims = []
for peakDim in peakDimsA:
ppms.append(peakDim.value)
peakDims.append(peakDim)
for peakDim in peakDimsB:
ppms.append(peakDim.value)
peakDims.append(peakDim)
if not ppms:
continue
centers, clusters, clusterIndices = kMeansPlusPlus(
ppms, 2) #@UnusedVariable clusters
centerA, centerB = centers
if abs(centerA - centerB) < sdt:
continue
peakDimsA = [peakDims[i] for i in clusterIndices[0]]
peakDimsB = [peakDims[i] for i in clusterIndices[1]]
if centerB < centerA:
peakDimsA, peakDimsB = peakDimsB, peakDimsA
for peakDim in peakDimsA:
contribA = peakDim.findFirstPeakDimContrib(
resonance=resonanceA)
contribB = peakDim.findFirstPeakDimContrib(
resonance=resonanceB)
if contribB:
peakContribs = contribB.peakContribs
contribB.delete()
if not contribA:
assignResToDim(peakDim,
resonanceA,
peakContribs=peakContribs)
nSwaps += 1
for peakDim in peakDimsB:
contribB = peakDim.findFirstPeakDimContrib(
resonance=resonanceB)
contribA = peakDim.findFirstPeakDimContrib(
resonance=resonanceA)
if contribA:
peakContribs = contribA.peakContribs
contribA.delete()
if not contribB:
assignResToDim(peakDim,
resonanceB,
peakContribs=peakContribs)
nSwaps += 1
return nSwaps
def pickAssignSpecFromRoot(rootPeaks,
targetPeakList,
tolerances=None,
progressBar=None,
pickNew=True,
diagTolerance=None,
waterExclusion=None):
"""Descrn: Pick peaks in a spectrum based upon a root peak list
and assign picked peaks to root resonances.
Inputs: List of Nmr.Peaks, Nmr.PeakList, List of Floats (target dim order),
memops.gui.ProgressBar, Boolean, Float or None,
2-Tuple of Floats (min, max) or None
Output: Nmr.Peaks, Dict of Int:Int (dim mapping root:target)
"""
# TBD: perhaps a list of peaks rather than a set should be passed in
rootPeakList = tuple(rootPeaks)[0].peakList
project = rootPeakList.root
spectrum0 = rootPeakList.dataSource
spectrum1 = targetPeakList.dataSource
if not tolerances:
tolerances = []
for dataDim in spectrum1.sortedDataDims():
tolerances.append(getAnalysisDataDim(dataDim).assignTolerance)
expDimRefs0 = ExperimentBasic.getOnebondExpDimRefs(spectrum0.experiment)
expDimRefs1 = ExperimentBasic.getOnebondExpDimRefs(spectrum1.experiment)
if not expDimRefs0:
msg = 'Spectrum %s:%s has no directly bonded dims.'
showWarning('Failure',
msg % (spectrum0.experiment.name, spectrum0.name))
return
if not expDimRefs1:
msg = 'Spectrum %s:%s has no directly bonded dims.'
showWarning('Failure',
msg % (spectrum1.experiment.name, spectrum1.name))
return
# could really do with a generic get matching dataDims function
# TBD try PeakBasic.getDataDimMapping()
dimMapping = {}
for expDimRef0, expDimRef1 in expDimRefs0:
dataDim0 = spectrum0.findFirstDataDim(expDim=expDimRef0.expDim)
dataDim1 = spectrum0.findFirstDataDim(expDim=expDimRef1.expDim)
isotopes0 = expDimRef0.isotopeCodes
isotopes1 = expDimRef1.isotopeCodes
if '1H' in isotopes0 or '1H' in isotopes1:
break
boundDims = set([dataDim0.dim, dataDim1.dim])
for expDimRef2, expDimRef3 in expDimRefs1:
isotopes2 = expDimRef2.isotopeCodes
isotopes3 = expDimRef3.isotopeCodes
dataDim2 = spectrum1.findFirstDataDim(expDim=expDimRef2.expDim)
dataDim3 = spectrum1.findFirstDataDim(expDim=expDimRef3.expDim)
if not (dataDim2 and dataDim3):
continue
if (isotopes0 == isotopes2) and (isotopes1 == isotopes3):
dimMapping[dataDim0.dim] = dataDim2.dim
dimMapping[dataDim1.dim] = dataDim3.dim
break
elif (isotopes0 == isotopes3) and (isotopes1 == isotopes2):
dimMapping[dataDim0.dim] = dataDim3.dim
dimMapping[dataDim1.dim] = dataDim2.dim
break
if not dimMapping:
msg = 'Could not find equivalent dims in spectra %s:%s & %s:%s'
data = (spectrum0.experiment.name, spectrum0.name,
spectrum1.experiment.name, spectrum1.name)
showWarning('Failure', msg % data)
return
if progressBar:
progressBar.total = len(rootPeaks)
progressBar.set(0)
progressBar.open()
fullRegion = []
getDimRef = ExperimentBasic.getPrimaryDataDimRef
targetDims = targetPeakList.dataSource.sortedDataDims()
targetDims = [(getDimRef(dd), dd) for dd in targetDims]
targetIsotopes = [
','.join(ddr.expDimRef.isotopeCodes) for (ddr, dd) in targetDims
]
for dataDimRef, dataDim in targetDims:
valueMax = pnt2ppm(1, dataDimRef)
valueMin = pnt2ppm(dataDim.numPoints, dataDimRef)
fullRegion.append([valueMin, valueMax])
foundPeaks = []
for peak in rootPeaks:
peakRegion = list(fullRegion)
rootIsotopes = []
rootMapDims = set()
values = []
boundPeakDims = [
pd for pd in peak.sortedPeakDims() if pd.dim in boundDims
]
for i, peakDim in enumerate(boundPeakDims):
error = tolerances[i]
value = peakDim.value
j = dimMapping[peakDim.dim] - 1
peakRegion[j] = (value - error, value + error)
rootIsotopes.append(targetIsotopes[j])
rootMapDims.add(j)
values.append(value)
regions = [
peakRegion,
]
if diagTolerance:
for i, isotopes in enumerate(targetIsotopes):
if (i not in rootMapDims) and (isotopes in rootIsotopes):
value = values[rootIsotopes.index(isotopes)]
# Chop in two at diagonal
regions2 = []
for region in regions:
regionA = list(region)
regionB = list(region)
valueMin, valueMax = region[i]
regionA[i] = (valueMin, value - diagTolerance)
regionB[i] = (value + diagTolerance, valueMax)
regions2.append(regionA)
regions2.append(regionB)
regions = regions2
if waterExclusion:
waterMin, waterMax = waterExclusion
for i, isotopes in enumerate(targetIsotopes):
if (i not in rootMapDims) and (isotopes in rootIsotopes):
regions2 = []
# Chop at water
for region in regions:
valueMin, valueMax = region[i]
if valueMin < waterMin < valueMax:
regionA = list(region)
regionA[i] = (valueMin, waterMin)
regions2.append(regionA)
if valueMin < waterMax < valueMax:
regionB = list(region)
regionB[i] = (waterMax, valueMax)
regions2.append(regionB)
elif valueMin < waterMax < valueMax:
regionB = list(region)
regionB[i] = (waterMax, valueMax)
regions2.append(regionB)
else:
regions2.append(region)
regions = regions2
peaks = []
for region in regions:
peaks.extend(searchPeaks([
targetPeakList,
], region))
if pickNew:
peaks.extend(findPeaks(targetPeakList, region))
# possible to grow the region here if no peaks are found
for peak2 in peaks:
for intens in peak.peakIntensities:
if str(intens.value) == 'inf':
peaks.remove(peak2)
peak2.delete()
break
foundPeaks.extend(peaks)
for i, peakDim in enumerate(boundPeakDims):
dim2 = dimMapping[peakDim.dim]
resonances = [c.resonance for c in peakDim.peakDimContribs]
tolerance = tolerances[i]
for peak2 in peaks:
peakDim2 = peak2.findFirstPeakDim(dim=dim2)
if not peakDim2.peakDimContribs:
for resonance in resonances:
assignResToDim(peakDim2,
resonance,
tolerance=10 * tolerance,
doWarning=False)
if progressBar:
progressBar.increment()
if progressBar:
progressBar.close()
return foundPeaks, dimMapping
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 disambiguateNoesyPeaks(noesy2dPeakList,noesy3dPeakList,tocsy3dPeakList,hsqcPeakList):
# assign HSQC resonances and spin systems
# assign pick 3d tocsy F1 F3
# assign tocsy F2
# assign pick 3d noesy F1 F3
tolerances = [0.04, 0.04, 0.4]
t1 = tolerances[0]/2.0
t2 = tolerances[1]/2.0
spinSystems = []
for peak in hsqcPeakList.peaks:
for peakDim in peak.peakDims:
if peakDim.dataDim.expDim.isAcquisition:
resonance = peakDim.findFirstpeakDimContrib().resonance
spinSystems.append(resonance.resonanceGroup)
break
ii = 0
for spinSystem in spinSystems:
resonances = spinSystem.resonances
intraPeaks = []
interPeaks = []
anchors = []
t3peaks = []
n3peaks = []
matched = []
# find 3d tocsy and 3d noesy peaks for spin system
for resonance in resonances:
for contrib in resonance.peakDimContribs:
peak = contrib.peakDim.peak
if peak.peakList is noesy3dPeakList:
n3peaks.append(peak)
elif peak.peakList is tocsy3dPeakList:
t3peaks.append(peak)
# get intra list
for pn in n3peaks:
match = None
score = 0
for pt in t3peaks:
s = matchPeaks(pt,pn,tolerances)
if s and (s>score):
score = s
match = pt
if match and match.sortedPeakDims()[1].peakDimContribs:
assignResToDim(pn.sortedPeakDims()[1],match.sortedPeakDims()[1].findFirstpeakDimContrib().resonance)
intraPeaks.append(pn)
# get unambiguous inter list
for pn in n3peaks:
if pn not in intraPeaks:
peakDim = pn.sortedPeakDims()[1]
if peakDim.peakDimContribs and peakDim.findFirstpeakDimContrib().resonance:
interPeaks.append(pn)
ppm = getPeakDimPpm(peakDim)
position = peakDim.position + (peakDim.numAliasing*peakDim.dataDimRef.dataDim.numPointsOrig)
shifts = findMatchingShifts(peakDim.dataDimRef,position,tolerance=t1)
if shifts and len(shifts) == 1:
assignResToDim(pn.sortedPeakDims()[1],shifts[0].resonance)
interPeaks.append(pn)
else:
shifts = findMatchingShifts(peakDim.dataDimRef,position,tolerance=t1)
if not shifts:
pass
#assignResToDim(peakDim)
#interPeaks.append(pn)
elif len(shifts) == 1:
assignResToDim(peakDim,shifts[0].resonance)
interPeaks.append(pn)
peaks3d = intraPeaks
peaks3d.extend(interPeaks)
ii += 1
print "SS", ii, spinSystem
# pick assign 2d equivalents to intra and unambiguous 3d and find anchor point peaks
for p3 in peaks3d:
matched = {}
f = 0.0
n = 0
pd1 = p3.sortedPeakDims()[0]
pd2 = p3.sortedPeakDims()[1]
ppm1 = getPeakDimPpm(pd1)
ppm2 = getPeakDimPpm(pd2)
region = [[ppm1-t1,ppm1+t1],[ppm2-t2,ppm2+t2]]
n2peaks = searchPeaks([noesy2dPeakList,], region)
n2peaks.extend( findPeaks(noesy2dPeakList, region))
match = None
score = 0
if len(n2peaks) == 1:
match = n2peaks[0]
else:
for p2 in n2peaks:
s = matchPeakDims(p3.peakDims,p2.peakDims,tolerances[:2])
if s and (s>score):
score = s
match = p2
if match:
anchors.append( (match,p3) )
f += match.findFirstPeakIntensity().value/p3.findFirstPeakIntensity().value
n += 1
peakDimsM = match.sortedPeakDims()
clearPeakDim(peakDimsM[0])
clearPeakDim(peakDimsM[1])
assignResToDim(peakDimsM[0],pd1.findFirstpeakDimContrib().resonance)
assignResToDim(peakDimsM[1],pd2.findFirstpeakDimContrib().resonance)
matched[p3] = 1
region = [[ppm2-t1,ppm2+t1],[ppm1-t2,ppm1+t2]]
n2peaks = searchPeaks([noesy2dPeakList,], region)
n2peaks.extend(findPeaks(noesy2dPeakList, region))
match = None
score = 0
if len(n2peaks) == 1:
match = n2peaks[0]
else:
for p2 in n2peaks:
s = matchPeakDims(p3.peakDims,p2.peakDims,tolerances[:2])
if s and (s>score):
score = s
match = p2
if match:
peakDimsM = match.sortedPeakDims()
anchors.append( (match,p3) )
f += match.findFirstPeakIntensity().value/p3.findFirstPeakIntensity().value
n += 1
clearPeakDim(peakDimsM[0])
clearPeakDim(peakDimsM[1])
assignResToDim(peakDimsM[0],pd1.findFirstpeakDimContrib().resonance)
assignResToDim(peakDimsM[1],pd2.findFirstpeakDimContrib().resonance)
matched[p3] = 1
if matched:
f /= n
# use the peaks that intially failed in the 2d picking
for p3 in peaks3d:
if not matched.get(p3):
pd1 = p3.sortedPeakDims()[0]
pd2 = p3.sortedPeakDims()[1]
r1 = pd1.findFirstpeakDimContrib().resonance
r2 = pd2.findFirstpeakDimContrib().resonance
ppm1 = getPeakDimPpm(pd1)
ppm2 = getPeakDimPpm(pd2)
region = [[ppm1-tolerances[0],ppm1+tolerances[0]],[ppm2-tolerances[1],ppm2+tolerances[1]]]
peaks = searchPeaks([noesy2dPeakList,], region)
peaks.extend( findPeaks(noesy2dPeakList, region) )
for p2 in peaks:
p2.annotation = '*'
p2.findFirstPeakIntensity().value = p3.findFirstPeakIntensity().value * f
assignResToDim(p2.sortedPeakDims()[0],r1)
assignResToDim(p2.sortedPeakDims()[1],r2)
region = [[ppm2-tolerances[0],ppm2+tolerances[0]],[ppm1-tolerances[1],ppm1+tolerances[1]]]
peaks = searchPeaks([noesy2dPeakList,], region)
for p2 in peaks:
p2.annotation = '*'
p2.findFirstPeakIntensity().value = p3.findFirstPeakIntensity().value * f
assignResToDim(p2.sortedPeakDims()[0],r2)
assignResToDim(p2.sortedPeakDims()[1],r1)
return noesy2dPeakList
resonances = list(noesy2dPeakList.root.resonances)
N = len(resonances)
print "Final 2d matches for %d resonances" % N
for i in range(N-1):
print "R", i
for j in range(i+1,N):
ppm1 = resonances[i].findFirstShift().value
ppm2 = resonances[j].findFirstShift().value
region = [[ppm1-t1,ppm1+t1],[ppm2-t2,ppm2+t2]]
peaks = searchPeaks([noesy2dPeakList,], region)
if not peaks:
peaks = findPeaks(noesy2dPeakList, region)
if len(peaks) == 1:
for peakDim in peaks[0].peakDims:
shifts = findMatchingShifts(peakDim.dataDimRef,position,tolerance=t1)
if len(shifts) == 1:
assignResToDim(peakDim,shifts[0].resonance)
return noesy2dPeakList
def networkAnchorAssign(peakLists,
intensityType='height',
strictness=2,
threshold=1.0,
isotopeTolerances=None,
assignPeakList=True,
constraintSet=None,
labelling=None,
minLabelFraction=0.1,
scale=None,
distParams=None,
structure=None,
progressBar=None,
nexus=None):
if not peakLists:
return
if isotopeTolerances:
TOLERANCE_DICT = isotopeTolerances
distanceFunction = None
if distParams:
distanceFunction = lambda val: getNoeDistance(val, distParams)
project = peakLists[0].root
nmrProject = peakLists[0].topObject
molSystem = project.findFirstMolSystem()
shiftList = peakLists[0].dataSource.experiment.shiftList
isotopes = set([])
# Get known network of connectivities inc covalent and NOE
network = {}
covalent = {}
# Assign some peaks with uniquely matching shifts
for peakList in peakLists:
if labelling is True:
expLabelling = peakList.dataSource.experiment
else:
expLabelling = labelling
network, covalent = getCloseSingleShiftMatches(
peakList,
network,
covalent,
labelling=expLabelling,
minLabelFraction=minLabelFraction,
intensityType=intensityType,
progressBar=progressBar)
# Get existing assigned NOE network
totalPeaks = 0
for peakList in peakLists:
if not peakList.peaks:
continue
meanIntensity = getMeanPeakIntensity(peakList.peaks,
intensityType=intensityType)
if scale:
meanIntensity = scale
spectrum = peakList.dataSource
distDims = getThroughSpaceDataDims(spectrum)
for dataDim in distDims:
isotopes.update(getDataDimIsotopes(dataDim))
hDims = [dd.dim - 1 for dd in distDims]
numPeaks = len(peakList.peaks)
totalPeaks += numPeaks
info = (spectrum.experiment.name, spectrum.name, peakList.serial,
numPeaks)
if progressBar:
progressBar.setText(
'Get existing NOE network\nfor %s:%s:%d - %d peaks' % info)
progressBar.set(0)
progressBar.total = numPeaks
progressBar.open()
progressBar.update_idletasks()
else:
print 'Get existing NOE network for %s:%s:%d - %d peaks' % info
if len(hDims) != 2:
continue
for peak in peakList.peaks:
if progressBar:
progressBar.increment()
peakDims = peak.sortedPeakDims()
peakDim1 = peakDims[hDims[0]]
contribs1 = peakDim1.peakDimContribs
if contribs1:
peakDim2 = peakDims[hDims[1]]
contribs2 = peakDim2.peakDimContribs
if contribs2:
peakIntensity = peak.findFirstPeakIntensity(
intensityType=intensityType)
if peakIntensity:
intensity = peakIntensity.value
intensity /= float(len(contribs1))
intensity /= float(len(contribs2))
#intensity /= meanIntensity
for contrib1 in contribs1:
resonance1 = contrib1.resonance
if network.get(resonance1) is None:
covalent[resonance1] = {}
network[resonance1] = {}
intensity2 = intensity
if resonance1.resonanceSet:
intensity2 /= float(
len(resonance1.resonanceSet.
findFirstAtomSet().atoms))
for contrib2 in contribs2:
resonance2 = contrib2.resonance
if network.get(resonance2) is None:
network[resonance2] = {}
covalent[resonance2] = {}
if resonance2.resonanceSet:
intensity2 /= float(
len(resonance2.resonanceSet.
findFirstAtomSet().atoms))
if not contrib2.peakContribs:
if not contrib1.peakContribs:
network[resonance1][resonance2] = [
intensity2, peak
]
network[resonance2][resonance1] = [
intensity2, peak
]
else:
for peakContrib in contrib2.peakContribs:
if peakContrib in contrib1.peakContribs:
network[resonance1][resonance2] = [
intensity2, peak
]
network[resonance2][resonance1] = [
intensity2, peak
]
break
else:
pass # Should warn
covalentIntensity = 5.0 # Need to optimise this
# Get covalent network
if progressBar:
progressBar.setText('Getting covalent network')
progressBar.set(0)
progressBar.total = len(nmrProject.resonances)
progressBar.open()
progressBar.update_idletasks()
else:
print 'Getting covalent network - %d resonances' % len(
nmrProject.resonances)
neighbours = {}
chemAtomToAtom = {}
c = 0
for resonance in nmrProject.resonances:
if progressBar:
progressBar.increment()
if resonance.isotopeCode not in isotopes:
continue
resonanceSet = resonance.resonanceSet
if not resonanceSet:
continue
if network.get(resonance) is None:
network[resonance] = {}
covalent[resonance] = {}
for atomSet in resonanceSet.atomSets:
for atom in atomSet.atoms:
residue = atom.residue
if chemAtomToAtom.get(residue) is None:
chemAtomToAtom[residue] = {}
for atom2 in residue.atoms:
chemAtomToAtom[residue][atom2.chemAtom] = atom2
chemAtom = atom.chemAtom
if chemAtom.waterExchangeable:
continue
chemAtoms = neighbours.get(chemAtom)
if chemAtoms is None:
chemAtoms = []
for atom2 in residue.atoms:
if atom2 is atom:
continue
chemAtom2 = atom2.chemAtom
if DEFAULT_ISOTOPES.get(
chemAtom2.elementSymbol) not in isotopes:
continue
numBonds = getNumConnectingBonds(atom, atom2, limit=6)
if numBonds < 5:
chemAtoms.append(chemAtom2)
neighbours[chemAtom] = chemAtoms
atoms = []
for chemAtomB in chemAtoms:
atom2 = chemAtomToAtom[residue].get(chemAtomB)
if atom2 is not None:
atoms.append(atom2)
residue2 = getLinkedResidue(residue, 'prev')
if residue2:
for atom2 in residue2.atoms:
chemAtom2 = atom2.chemAtom
if DEFAULT_ISOTOPES.get(
chemAtom2.elementSymbol) not in isotopes:
continue
numBonds = getNumConnectingBonds(atom, atom2, limit=6)
if numBonds < 5:
atoms.append(atom2)
residue2 = getLinkedResidue(residue, 'next')
if residue2:
for atom2 in residue2.atoms:
chemAtom2 = atom2.chemAtom
if DEFAULT_ISOTOPES.get(
chemAtom2.elementSymbol) not in isotopes:
continue
numBonds = getNumConnectingBonds(atom, atom2, limit=6)
if numBonds < 5:
atoms.append(atom2)
for atom2 in atoms:
atomSet2 = atom2.atomSet
if atomSet2 and (atomSet2 is not atomSet):
for resonanceSet2 in atomSet2.resonanceSets:
for resonance2 in resonanceSet2.resonances:
if network.get(resonance2) is None:
network[resonance2] = {}
covalent[resonance2] = {}
if network[resonance].get(
resonance2
) is None: # Not already in network
network[resonance][resonance2] = [
covalentIntensity, None
]
network[resonance2][resonance] = [
covalentIntensity, None
]
covalent[resonance][resonance2] = True
covalent[resonance2][resonance] = True
c += 1
#print 'Atom pair network connections %d' % c
c = 0
for ss in nmrProject.resonanceGroups:
ss2 = findConnectedSpinSystem(ss, delta=-1)
if ss2:
for r1 in ss.resonances:
if r1.isotopeCode not in isotopes:
continue
for r2 in ss.resonances:
if r2.isotopeCode not in isotopes:
continue
if network.get(r1) is None:
network[r1] = {}
covalent[r1] = {}
if network.get(r2) is None:
network[r2] = {}
covalent[r2] = {}
if network[r1].get(r2) is None:
network[r1][r2] = [covalentIntensity, None]
network[r2][r1] = [covalentIntensity, None]
covalent[r1][r2] = True
covalent[r2][r1] = True
c += 1
#print 'Anonymous intra residue connections %d' % c
done = {}
iter = 0
nAssign = 1
k = 0
dataSets = []
while nAssign > 0:
#while iter < 1:
data = []
nAssign = 0
iter += 1
if progressBar:
progressBar.setText('Anchoring iteration %d' % iter)
progressBar.set(0)
progressBar.total = totalPeaks
progressBar.open()
progressBar.update_idletasks()
else:
print 'Anchoring iteration %d' % iter
closeResonancesDict = {}
for peakList in peakLists:
if not peakList.peaks:
continue
spectrum = peakList.dataSource
distDims = getThroughSpaceDataDims(spectrum)
hDims = [dd.dim - 1 for dd in distDims]
tolerances = getDimTolerances(spectrum)
bondedDims = getBondedDimsDict(spectrum)
#meanIntensity = getMeanPeakIntensity(peakList.peaks, intensityType=intensityType)
info = (spectrum.experiment.name, spectrum.name, peakList.serial,
len(peakList.peaks))
#print ' Using %s:%s:%d - %d peaks' % info
if len(hDims) != 2:
continue
for peak in peakList.peaks:
if progressBar:
progressBar.increment()
if done.get(peak):
continue
peakDims = peak.sortedPeakDims()
if peakDims[hDims[0]].peakDimContribs:
if peakDims[hDims[1]].peakDimContribs:
continue
boundResonances = {}
if closeResonancesDict.get(peak) is None:
possibles = []
for dim in hDims:
peakDim = peakDims[dim]
if peakDim.peakDimContribs:
possibles.append([
contrib.resonance
for contrib in peakDim.peakDimContribs
])
continue
resonances = []
shifts = findMatchingPeakDimShifts(
peakDim,
shiftRanges=None,
tolerance=tolerances[dim],
aliasing=True,
findAssigned=False)
dim2 = bondedDims.get(dim)
peakDim2 = None
if dim2 is not None:
peakDim2 = peakDims[dim2]
shifts2 = findMatchingPeakDimShifts(
peakDim2,
shiftRanges=None,
tolerance=tolerances[dim2],
aliasing=True,
findAssigned=False)
for shift in shifts:
resonance1 = shift.resonance
for shift2 in shifts2:
resonance2 = shift2.resonance
if areResonancesBound(
resonance1, resonance2):
if labelling:
fraction = getResonancePairLabellingFraction(
resonance1, resonance2,
expLabelling)
if fraction < minLabelFraction:
continue
resonances.append(resonance1)
boundResonances[
resonance1] = resonance2
break
else:
for shift in shifts:
resonance = shift.resonance
if labelling:
fraction = getResonanceLabellingFraction(
resonance, expLabelling)
if fraction < minLabelFraction:
continue
resonances.append(resonance)
possibles.append(resonances)
closeResonancesDict[peak] = possibles
else:
possibles = closeResonancesDict[peak]
if not possibles[0]:
continue # warn
if not possibles[1]:
continue # warn
peakIntensity = peak.findFirstPeakIntensity(
intensityType=intensityType)
if not peakIntensity:
print 'Peak missing intensity', peak
continue
else:
intensity = peakIntensity.value #/meanIntensity
scores = {}
numbers = {}
bestScore = None
bestPair = None
for resonance1 in possibles[0]:
if not resonance1.resonanceGroup:
continue
if network.get(resonance1) is None:
continue
anchors1 = network[resonance1].keys()
spinSystem1 = resonance1.resonanceGroup
for resonance2 in possibles[1]:
if not resonance2.resonanceGroup:
continue
if network.get(resonance2) is None:
continue
anchors2 = network[resonance2].keys()
pair = (resonance1, resonance2)
spinSystem2 = resonance2.resonanceGroup
for resonance3 in anchors1:
spinSystem3 = resonance3.resonanceGroup
if (strictness > 0) and spinSystem3:
check = False
if (spinSystem3 is spinSystem1) or (
spinSystem3 is spinSystem2):
check = True
if (strictness > 1) and spinSystem3.residue:
if spinSystem1.residue:
if abs(spinSystem1.residue.seqCode -
spinSystem3.residue.seqCode
) < 2:
check = True
if spinSystem2.residue:
if abs(spinSystem2.residue.seqCode -
spinSystem3.residue.seqCode
) < 2:
check = True
else:
check = True
if check and (resonance3 in anchors2):
intensityA, peakA = network[resonance1][
resonance3]
intensityB, peakB = network[resonance2][
resonance3]
if scores.get(pair) is None:
scores[pair] = 0.0
numbers[pair] = 0.0
shift1 = resonance1.findFirstShift(
parentList=shiftList)
shift2 = resonance2.findFirstShift(
parentList=shiftList)
if shift1 and shift2:
delta1 = abs(peakDims[hDims[0]].realValue -
shift1.value)
delta2 = abs(peakDims[hDims[1]].realValue -
shift2.value)
tol1 = TOLERANCE_DICT[
resonance1.isotopeCode]
tol2 = TOLERANCE_DICT[
resonance2.isotopeCode]
match1 = (tol1 - delta1) / tol1
match2 = (tol2 - delta2) / tol2
scores[
pair] += intensityA * intensityB * match1 * match2
numbers[pair] += 1
nGood = 0
for pair in scores.keys():
resonance1, resonance2 = pair
score = scores[pair]
if score > threshold:
nGood += 1
if (bestScore is None) or (score > bestScore):
bestScore = score
bestPair = pair
#if bestScore and (nGood < 2):
for pair in scores.keys():
resonance1, resonance2 = pair
if scores[pair] < threshold:
#if len(scores.keys()) > 1:
continue
else:
intensity2 = intensity / nGood
bestPair = pair
bestScore = scores[pair]
for i in (0, 1):
resonance = bestPair[i]
if assignPeakList:
assignResToDim(peakDims[hDims[i]],
resonance,
doWarning=False)
bound = boundResonances.get(resonance)
if bound:
dim2 = bondedDims.get(hDims[i])
if dim2 is not None:
assignResToDim(peakDims[dim2],
bound,
doWarning=False)
if network.get(resonance) is None:
network[resonance] = {}
#name1 = makeResonanceGuiName(bestPair[0])
#name2 = makeResonanceGuiName(bestPair[1])
if resonance1.resonanceSet:
intensity2 /= float(
len(resonance1.resonanceSet.findFirstAtomSet().
atoms))
if resonance2.resonanceSet:
intensity2 /= float(
len(resonance2.resonanceSet.findFirstAtomSet().
atoms))
if labelling:
intensity2 /= getResonanceLabellingFraction(
resonance1, expLabelling)
intensity2 /= getResonanceLabellingFraction(
resonance2, expLabelling)
nAssign += 1
covalent[bestPair[0]][bestPair[1]] = None
covalent[bestPair[1]][bestPair[0]] = None
network[bestPair[0]][bestPair[1]] = [intensity2, peak]
network[bestPair[1]][bestPair[0]] = [intensity2, peak]
done[peak] = True
#print ' Assigned:', nAssign
dataSets.append(data)
from ccpnmr.analysis.core.ConstraintBasic import getDistancesFromIntensity, getIntensityDistanceTable
from ccpnmr.analysis.core.ConstraintBasic import makeNmrConstraintStore, getFixedResonance
if constraintSet is None:
constraintSet = makeNmrConstraintStore(nmrProject)
if not constraintSet:
return
constraintList = constraintSet.newDistanceConstraintList()
peakConstraints = {}
doneResonances = {}
for resonance1 in network.keys():
fixedResonance1 = getFixedResonance(constraintSet, resonance1)
for resonance2 in network[resonance1].keys():
if resonance1 is resonance2:
continue
key = [resonance1.serial, resonance2.serial]
key.sort()
key = tuple(key)
if doneResonances.get(key):
continue
else:
doneResonances[key] = True
if covalent.get(resonance1):
if covalent[resonance1].get(resonance2):
# J connected are close so what do we do...?
#print "Skip", makeResonanceGuiName(resonance1), makeResonanceGuiName(resonance2)
continue
fixedResonance2 = getFixedResonance(constraintSet, resonance2)
intensity, peak = network[resonance1][resonance2]
if peak:
peakList = peak.peakList
spectrum = peakList.dataSource
experiment = spectrum.experiment
if not distanceFunction:
noeDistClasses = getIntensityDistanceTable(spectrum)
distanceFunction = lambda val: getDistancesFromIntensity(
noeDistClasses, val)
constraint = peakConstraints.get(peak)
if not constraint:
constraint = constraintList.newDistanceConstraint(
weight=1.0, origData=intensity)
peakContrib = constraint.newConstraintPeakContrib(
experimentSerial=experiment.serial,
dataSourceSerial=spectrum.serial,
peakListSerial=peakList.serial,
peakSerial=peak.serial)
peakConstraints[peak] = constraint
else:
intensity += constraint.origData
dist, minDist, maxDist = distanceFunction(intensity /
meanIntensity)
error = abs(maxDist - minDist)
constraint.origData = intensity
constraint.targetValue = dist
constraint.upperLimit = maxDist
constraint.lowerLimit = minDist
constraint.error = error
item = constraint.newDistanceConstraintItem(
resonances=[fixedResonance1, fixedResonance2])
return constraintList
def makeDecoupledPeakList(argServer):
peakList = argServer.getPeakList()
spectrum = peakList.dataSource
peakAssignDict = {}
for peak in peakList.peaks:
assignKey = []
for peakDim in peak.sortedPeakDims():
resonances = [c.resonance for c in peakDim.peakDimContribs]
resonances = frozenset(resonances)
assignKey.append(resonances)
assignKey = tuple(assignKey)
if assignKey not in peakAssignDict:
peakAssignDict[assignKey] = []
peakAssignDict[assignKey].append(peak)
if not peakAssignDict:
argServer.showWarning('No assignments detected')
return
newPeakList = spectrum.newPeakList()
nDim = spectrum.numDim
for assignKey in peakAssignDict:
peaks = peakAssignDict[assignKey]
position = [0.0] * nDim
height = 0.0
volume = 0.0
for peak in peaks:
peakDims = peak.sortedPeakDims()
for i, peakDim in enumerate(peakDims):
position[i] += peakDim.position
heightIntensity = peak.findFirstPeakIntensity(
intensityType='height')
volumeIntensity = peak.findFirstPeakIntensity(
intensityType='volume')
if heightIntensity:
height += heightIntensity.value
if volumeIntensity:
volume += volumeIntensity.value
n = float(len(peaks))
for i in range(nDim):
position[i] /= n
newPeak = pickPeak(newPeakList, position, doFit=False)
newPeakDims = newPeak.sortedPeakDims()
setManualPeakIntensity(newPeak, height, 'height')
setManualPeakIntensity(newPeak, volume, 'volume')
for i, peakDim in enumerate(newPeakDims):
resonances = assignKey[i]
for resonance in resonances:
assignResToDim(peakDim,
resonance,
tolerance=1.0,
doWarning=False)
argServer.showWarning('Made new peak list with %d peaks' %
len(newPeakList.peaks))
def transferAssignments(self):
'''Transfer assignments to project depending
on the settings from the GUI.
'''
self.fetchOptions()
if not self.dataModel or (not self.resonanceToDimension and not self.spinSystemToResidue):
return
strategy = self.strategy
lookupSpinSystem = [self.getAssignedSpinSystem,
self.getBestScoringSpinSystem,
self.getUserDefinedSpinSystem,
self.getSelectedSolutionSpinSystem][self.spinSystemType]
residues = self.dataModel.chain.residues
spinSystemSequence = [lookupSpinSystem(res) for res in residues]
ccpnSpinSystems = []
ccpnResidues = []
# if self.spinSystemType == 0 it means that it for sure already
# assigned like this
if self.spinSystemToResidue and not self.spinSystemType == 0:
for spinSys, res in zip(spinSystemSequence, residues):
if spinSys and res:
ccpnSpinSystems.append(spinSys.getCcpnResonanceGroup())
ccpnResidues.append(res.getCcpnResidue())
assignSpinSystemstoResidues(ccpnSpinSystems,
ccpnResidues,
strategy=strategy,
guiParent=self.guiParent)
if self.resonanceToDimension:
allSpectra = self.allSpectra
if self.intra:
for residue, spinSystem in zip(residues, spinSystemSequence):
if not spinSystem:
continue
intraLink = residue.getIntraLink(spinSystem)
for pl in intraLink.getPeakLinks():
peak = pl.getPeak()
if not allSpectra and peak.getSpectrum() is not self.spectrum:
continue
if not peak:
continue
resonances = pl.getResonances()
if self.noDiagonal and len(set(resonances)) < len(resonances):
continue
for resonance, dimension in zip(resonances, peak.getDimensions()):
ccpnResonance = resonance.getCcpnResonance()
ccpnDimension = dimension.getCcpnDimension()
assignResToDim(ccpnDimension, ccpnResonance)
if self.sequential:
for residue, spinSystemA, spinSystemB in zip(residues,
spinSystemSequence,
spinSystemSequence[1:]):
if not spinSystemA or not spinSystemB:
continue
link = residue.getLink(spinSystemA, spinSystemB)
for pl in link.getPeakLinks():
peak = pl.getPeak()
if not allSpectra and peak.getSpectrum() is not self.spectrum:
continue
if not peak:
continue
resonances = pl.getResonances()
if self.noDiagonal and len(set(resonances)) < len(resonances):
continue
for resonance, dimension in zip(resonances, peak.getDimensions()):
ccpnResonance = resonance.getCcpnResonance()
ccpnDimension = dimension.getCcpnDimension()
assignResToDim(ccpnDimension, ccpnResonance)
self.guiParent.resultsTab.update()
def updateClusterAssignments(cluster, refPeak=None):
"""
Initialise a peak cluster object by enforcing consistent assignments
across its component peaks and by setting its annotation approprately.
.. describe:: Input
Nmr.PeakCluster, Nmr.Peak
.. describe:: Output
None
"""
from ccpnmr.analysis.core.AssignmentBasic import assignResToDim
dimResonances = {}
components = {}
peaks = list(cluster.peaks)
if refPeak:
if len(refPeak.peakClusters) > 1:
return
inPeaks = [
refPeak,
]
else:
# Avoid mixing assignments
inPeaks = [pk for pk in peaks if len(pk.peakClusters) < 2]
for peak in inPeaks:
for peakDim in peak.peakDims:
dim = peakDim.dim
if dimResonances.get(dim) is None:
dimResonances[dim] = set([])
components[dim] = set([])
for contrib in peakDim.peakDimContribs:
if isinstance(contrib, Nmr.PeakDimContribN):
component = contrib.peakDimComponent
if component:
resonances = contrib.resonances
components[dim].add(resonances)
else:
resonance = contrib.resonance
component = contrib.peakDimComponent
if component:
components[dim].add((resonance, ))
else:
dimResonances[dim].add(resonance)
clusterType = cluster.clusterType
for peak in peaks:
for peakDim in peak.peakDims:
if not peakDim.dataDimRef:
continue
dim = peakDim.dim
dataDimRef = None
if clusterType == MULTIPLET_TYPE:
dataDimRef = getCouplingDataDimRef(peakDim.dataDim)
if dataDimRef:
resonancesList = components.get(dim, [])
if resonancesList:
component = peakDim.findFirstPeakDimComponent(
dataDimRef=dataDimRef)
if not component:
continue # Scaling factor unkown
if component.dataDimRef.expDimRef.unit != 'Hz':
continue
for resonances in resonancesList:
if len(resonances) != 2:
continue
contrib = component.findFirstPeakDimContrib(
resonances=resonances)
if not contrib:
contrib = peakDim.newPeakDimContribN(
resonances=resonances,
peakDimComponent=component)
#else:
# For non split dim, or non multiplet cluster: propagate assignments
# Split dims assigned differently bacause simple position based
# shift values are not appropriate
# TBD: Symmetry requires mapping
# Ensure consistent assignments, with refPeak when avail
resonances = dimResonances[dim]
for contrib in peakDim.peakDimContribs:
if isinstance(contrib, Nmr.PeakDimContribN):
continue
if contrib.resonance not in resonances:
for peakContrib in contrib.peakContribs:
if len(peakContrib.peakDimContribs) < 2:
peakContrib.delete()
contrib.delete()
for resonance in resonances:
#if resonance not in existingResonancesA[peak][dim]:
assignResToDim(peakDim, resonance)
updateClusterAnnotation(cluster)
