private bool AcceptScan(SilacPeakListPair pair, SilacCompoundInfo sci, int lightMaxIndex, double lightMinPPM, double lightMaxPPM, int heavyMaxIndex, double heavyMinPPM, double heavyMaxPPM)
{
//如果轻重标中任意一个最高峰不存在，循环结束。
if (pair.Light[lightMaxIndex].Intensity == 0 || pair.Heavy[heavyMaxIndex].Intensity == 0)
{
return(false);
}
//轻标最高峰的ppm
double lightPPM = PrecursorUtils.mz2ppm(pair.Light[lightMaxIndex].Mz, sci.Light.Profile[lightMaxIndex].Mz - pair.Light[lightMaxIndex].Mz);
if (lightPPM < lightMinPPM || lightPPM > lightMaxPPM)
{
return(false);
}
//重标最高峰的ppm
double heavyPPM = PrecursorUtils.mz2ppm(pair.Heavy[heavyMaxIndex].Mz, sci.Heavy.Profile[heavyMaxIndex].Mz - pair.Heavy[heavyMaxIndex].Mz);
if (heavyPPM < heavyMinPPM || heavyPPM > heavyMaxPPM)
{
return(false);
}
return(true);
}
private SilacCompoundInfo GetSilacCompoundInfo(IPeptideInfo peptideInfo)
{
SilacCompoundInfo sci = _sciBuilder.Build(peptideInfo);
sci.Light.Profile = profileBuilder.GetProfile(sci.Light.Composition, sci.Light.Charge, 0.0001);
sci.Heavy.Profile = profileBuilder.GetProfile(sci.Heavy.Composition, sci.Heavy.Charge, 0.0001);
return(sci);
}
private List <string> GetIdentifiedSpectrumKey(IIdentifiedSpectrum spectrum, SilacCompoundInfo sci)
{
int theoreticalMass = (int)(sci.Light.Mz * sci.Light.Charge + 0.5);
int charge = spectrum.Charge;
List <string> keys = new List <string>();
foreach (IIdentifiedPeptide peptide in spectrum.Peptides)
{
string sequenceCharge = PeptideUtils.GetPureSequence(peptide.Sequence) + "." + charge + "." + theoreticalMass;
keys.Add(sequenceCharge);
}
return(keys);
}
private SilacPeakListPair GetLightHeavyPeakList(IRawFile rawFile, SilacCompoundInfo sci, int maxIndex, double mzTolerance, int scan, bool force = false)
{
PeakList <Peak> pkl = rawFile.GetPeakList(scan);
if (pkl.Count == 0)
{
return(null);
}
var scantime = new ScanTime(scan, rawFile.ScanToRetentionTime(scan));
PeakList <Peak> light = pkl.FindEnvelopeDirectly(sci.Light.Profile, option.ProfileLength, mzTolerance, () => new Peak());
//如果电荷不对，则认为该scan无效。
if (!CheckPeakListCharge(light, maxIndex, sci.Light.Charge) && !force)
{
return(null);
}
PeakList <Peak> heavy = pkl.FindEnvelopeDirectly(sci.Heavy.Profile, option.ProfileLength, mzTolerance, () => new Peak());
//如果电荷不对，则认为该scan无效。
if (!CheckPeakListCharge(heavy, maxIndex, sci.Heavy.Charge) && !force)
{
return(null);
}
//如果轻或者重的总强度为0，则认为该scan无效。
if ((0 == light.Sum(m => m.Intensity) || 0 == heavy.Sum(m => m.Intensity)) && !force)
{
return(null);
}
light.ScanTimes.Add(scantime);
heavy.ScanTimes.Add(scantime);
return(new SilacPeakListPair(light, heavy));
}
public void Quantify(string rawFileName, List <IIdentifiedSpectrum> spectra, string detailDir)
{
if (!Directory.Exists(detailDir))
{
Directory.CreateDirectory(detailDir);
}
var experimental = RawFileFactory.GetExperimental(rawFileName);
Dictionary <string, DifferentRetentionTimeEnvelopes> spectrumKeyMap = new Dictionary <string, DifferentRetentionTimeEnvelopes>();
Dictionary <SilacEnvelopes, List <IIdentifiedSpectrum> > envelopeSpectrumGroup = new Dictionary <SilacEnvelopes, List <IIdentifiedSpectrum> >();
double precursorPPM = GetPrecursorPPM(spectra);
try
{
_rawReader.Open(rawFileName);
int firstScanNumber = _rawReader.GetFirstSpectrumNumber();
int lastScanNumber = _rawReader.GetLastSpectrumNumber();
Progress.SetRange(1, spectra.Count);
int pepCount = 0;
for (int s = 0; s < spectra.Count; s++)
{
Console.WriteLine(s);
IIdentifiedSpectrum spectrum = spectra[s];
SilacQuantificationSummaryItem.ClearAnnotation(spectrum);
if (Progress.IsCancellationPending())
{
throw new UserTerminatedException();
}
int startScan = spectrum.Query.FileScan.FirstScan;
if (startScan > lastScanNumber)
{
spectrum.GetOrCreateQuantificationItem().RatioStr = "OUT_OF_RANGE";
continue;
}
Progress.SetPosition(pepCount++);
IIdentifiedPeptide sp = spectrum.Peptide;
string seq = GetMatchSequence(spectrum);
IPeptideInfo peptideInfo = new IdentifiedPeptideInfo(seq, spectrum.TheoreticalMH, spectrum.Query.Charge);
SilacCompoundInfo sci = GetSilacCompoundInfo(peptideInfo);
//如果轻重离子理论质荷比一样，忽略
if (!sci.IsSilacData())
{
spectrum.GetOrCreateQuantificationItem().RatioStr = "NOT_SILAC";
continue;
}
//如果轻重离子理论质荷比与观测值不一致，忽略
if (!sci.IsMzEquals(spectrum.ObservedMz, MAX_DELTA_MZ))
{
ValidateModifications(seq);
spectrum.GetOrCreateQuantificationItem().RatioStr = "WRONG_IDENTIFICATION";
continue;
}
//如果没有找到相应的FullScan，忽略
int identifiedFullScan = _rawReader.FindPreviousFullScan(startScan, firstScanNumber);
if (-1 == identifiedFullScan)
{
spectrum.GetOrCreateQuantificationItem().RatioStr = "NO_PROFILE";
continue;
}
DifferentRetentionTimeEnvelopes pkls = FindEnvelopes(spectrumKeyMap, spectrum, sci);
SilacEnvelopes envelope = pkls.FindSilacEnvelope(identifiedFullScan);
//如果该scan被包含在已经被定量的结果中，忽略
if (envelope != null)
{
envelope.SetScanIdentified(identifiedFullScan, spectrum.IsExtendedIdentification());
envelopeSpectrumGroup[envelope].Add(spectrum);
continue;
}
//从原始文件中找出该spectrum的定量信息
int maxIndex = Math.Min(option.ProfileLength - 1, pkls.LightProfile.FindMaxIndex());
double mzTolerance = PrecursorUtils.ppm2mz(sci.Light.Mz, option.PPMTolerance);
//如果FullScan没有相应的离子，忽略。（鉴定错误或者扩展定量时候，会出现找不到pair的现象）
SilacPeakListPair splp = GetLightHeavyPeakList(_rawReader, sci, maxIndex, mzTolerance, identifiedFullScan);
if (null == splp)
{
spectrum.GetOrCreateQuantificationItem().RatioStr = "NO_PROFILE";
continue;
}
splp.IsIdentified = true;
splp.IsExtendedIdentification = spectrum.IsExtendedIdentification();
SilacEnvelopes envelopes = new SilacEnvelopes();
envelopes.Add(splp);
//向前查找定量信息
int fullScan = identifiedFullScan;
int scanNumber = 0;
while ((fullScan = _rawReader.FindPreviousFullScan(fullScan - 1, firstScanNumber)) != -1)
{
if (_rawReader.IsBadDataScan(fullScan))
{
continue;
}
scanNumber++;
var item = GetLightHeavyPeakList(_rawReader, sci, maxIndex, mzTolerance, fullScan, scanNumber <= MinScanNumber);
if (null == item)
{
break;
}
envelopes.Add(item);
}
envelopes.Reverse();
//向后查找定量信息
fullScan = identifiedFullScan;
scanNumber = 0;
while ((fullScan = _rawReader.FindNextFullScan(fullScan + 1, lastScanNumber)) != -1)
{
if (_rawReader.IsBadDataScan(fullScan))
{
continue;
}
scanNumber++;
var item = GetLightHeavyPeakList(_rawReader, sci, maxIndex, mzTolerance, fullScan, scanNumber <= MinScanNumber);
if (null == item)
{
break;
}
envelopes.Add(item);
}
//对每个scan计算轻重的离子丰度
envelopes.ForEach(m => m.CalculateIntensity(pkls.LightProfile, pkls.HeavyProfile));
pkls.Add(envelopes);
envelopeSpectrumGroup.Add(envelopes, new List <IIdentifiedSpectrum>());
envelopeSpectrumGroup[envelopes].Add(spectrum);
}
}
finally
{
_rawReader.Close();
}
foreach (string key in spectrumKeyMap.Keys)
{
DifferentRetentionTimeEnvelopes pkls = spectrumKeyMap[key];
foreach (SilacEnvelopes envelopes in pkls)
{
if (0 == envelopes.Count)
{
continue;
}
List <IIdentifiedSpectrum> mps = envelopeSpectrumGroup[envelopes];
double mzTolerance = PrecursorUtils.ppm2mz(mps[0].Query.ObservedMz, option.PPMTolerance);
string scanStr = GetScanRange(envelopes);
string resultFilename = detailDir + "\\" + mps[0].Query.FileScan.Experimental + "." + PeptideUtils.GetPureSequence(mps[0].Sequence) + "." + mps[0].Query.Charge + scanStr + ".silac";
IPeptideInfo peptideInfo = new IdentifiedPeptideInfo(mps[0].GetMatchSequence(), mps[0].TheoreticalMH, mps[0].Query.Charge);
SilacCompoundInfo sci = GetSilacCompoundInfo(peptideInfo);
SilacQuantificationSummaryItem item = new SilacQuantificationSummaryItem(sci.Light.IsSample);
item.RawFilename = rawFileName;
item.SoftwareVersion = this.SoftwareVersion;
item.PeptideSequence = mps[0].Sequence;
item.Charge = mps[0].Charge;
item.LightAtomComposition = sci.Light.Composition.ToString();
item.HeavyAtomComposition = sci.Heavy.Composition.ToString();
item.LightProfile = pkls.LightProfile;
item.HeavyProfile = pkls.HeavyProfile;
item.ObservedEnvelopes = envelopes;
item.ValidateScans(sci, precursorPPM);
item.Smoothing();
item.CalculateRatio();
new SilacQuantificationSummaryItemXmlFormat().WriteToFile(resultFilename, item);
int maxScoreItemIndex = FindMaxScoreItemIndex(mps);
for (int i = 0; i < mps.Count; i++)
{
if (maxScoreItemIndex == i)
{
item.AssignToAnnotation(mps[i], resultFilename);
}
else
{
item.AssignDuplicationToAnnotation(mps[i], resultFilename);
}
}
}
}
foreach (IIdentifiedSpectrum mph in spectra)
{
mph.InitializeRatioEnabled();
}
}
private DifferentRetentionTimeEnvelopes FindEnvelopes(Dictionary <string, DifferentRetentionTimeEnvelopes> peptideChargeMap, IIdentifiedSpectrum spectrum, SilacCompoundInfo sci)
{
var keys = GetIdentifiedSpectrumKey(spectrum, sci);
DifferentRetentionTimeEnvelopes result = null;
foreach (string key in keys)
{
if (peptideChargeMap.ContainsKey(key))
{
result = peptideChargeMap[key];
break;
}
}
if (result == null)
{
result = new DifferentRetentionTimeEnvelopes();
result.LightProfile = sci.Light.Profile;
result.HeavyProfile = sci.Heavy.Profile;
}
foreach (string key in keys)
{
if (!peptideChargeMap.ContainsKey(key))
{
peptideChargeMap.Add(key, result);
}
}
return(result);
}
public void ValidateScans(SilacCompoundInfo sci, double ppmTolerance)
{
int lightMaxIndex = LightProfile.FindMaxIndex();
int heavyMaxIndex = HeavyProfile.FindMaxIndex();
var identified = ObservedEnvelopes.FindAll(m => m.IsIdentified);
int minIdentifiedScan = identified.Min(m => m.Scan);
int maxIdentifiedScan = identified.Max(m => m.Scan);
ObservedEnvelopes.ForEach(m => m.Enabled = m.Scan >= minIdentifiedScan && m.Scan <= maxIdentifiedScan);
int enabledCount = ObservedEnvelopes.FindAll(m => m.Enabled).Count;
if (enabledCount < 5)
{
int preEnabled = (5 - enabledCount) / 2;
if (preEnabled == 0)
{
preEnabled = 1;
}
int postEnabled = 5 - enabledCount - preEnabled;
int first = ObservedEnvelopes.FindIndex(m => m.Enabled);
for (int i = first - 1; i >= 0 && i >= first - preEnabled; i--)
{
ObservedEnvelopes[i].Enabled = true;
}
int last = ObservedEnvelopes.FindLastIndex(m => m.Enabled);
for (int i = last + 1; i < ObservedEnvelopes.Count && i <= last + postEnabled; i++)
{
ObservedEnvelopes[i].Enabled = true;
}
}
var enabled = ObservedEnvelopes.FindAll(m => m.Enabled);
var lightAccumulator = new MeanStandardDeviation(from ob in enabled
let ppm = PrecursorUtils.mz2ppm(sci.Light.Profile[lightMaxIndex].Mz, sci.Light.Profile[lightMaxIndex].Mz - ob.Light[lightMaxIndex].Mz)
select ppm);
var heavyAccumulator = new MeanStandardDeviation(from ob in enabled
let ppm = PrecursorUtils.mz2ppm(sci.Heavy.Profile[heavyMaxIndex].Mz, sci.Heavy.Profile[heavyMaxIndex].Mz - ob.Heavy[heavyMaxIndex].Mz)
select ppm);
double lightPPM = Math.Max(ppmTolerance, lightAccumulator.StdDev * 3);
double heavyPPM = Math.Max(ppmTolerance, heavyAccumulator.StdDev * 3);
var lightMinPPM = lightAccumulator.Mean - lightPPM;
var lightMaxPPM = lightAccumulator.Mean + lightPPM;
var heavyMinPPM = heavyAccumulator.Mean - heavyPPM;
var heavyMaxPPM = heavyAccumulator.Mean + heavyPPM;
int fixedIndex = ObservedEnvelopes.FindIndex(m => m.IsIdentified);
for (int i = fixedIndex; i >= 0; i--)
{
var pair = ObservedEnvelopes[i];
if (pair.Enabled)
{
continue;
}
if (!AcceptScan(pair, sci, lightMaxIndex, lightMinPPM, lightMaxPPM, heavyMaxIndex, heavyMinPPM, heavyMaxPPM))
{
break;
}
pair.Enabled = true;
}
for (int i = fixedIndex; i < ObservedEnvelopes.Count; i++)
{
var pair = ObservedEnvelopes[i];
if (pair.Enabled)
{
continue;
}
if (!AcceptScan(pair, sci, lightMaxIndex, lightMinPPM, lightMaxPPM, heavyMaxIndex, heavyMinPPM, heavyMaxPPM))
{
break;
}
pair.Enabled = true;
}
}
