protected void AddToDistance(List <double> distances, PeakList <Peak> pkl, double theoreticalMz)
{
Peak peak = pkl.FindPeak(theoreticalMz, 0.02).FindMaxIntensityPeak();
if (peak != null)
{
distances.Add(peak.Mz - theoreticalMz);
}
}
public static List <PeakList <T> > GetEnvelopes <T>(PeakList <T> pkl, double ppmTolerance) where T : IPeak
{
var tmp = new PeakList <T>(pkl);
var result = new List <PeakList <T> >();
while (tmp.Count > 0)
{
double mzTolerance = 2 * PrecursorUtils.ppm2mz(tmp[0].Mz, ppmTolerance);
PeakList <T> envelope = tmp.FindEnvelope(tmp[0], mzTolerance, true);
result.Add(envelope);
foreach (T peak in envelope)
{
//Remove all peaks around current peak
PeakList <T> findPeaks = tmp.FindPeak(peak.Mz, peak.Charge, mzTolerance);
foreach (T findPeak in findPeaks)
{
tmp.Remove(findPeak);
}
}
}
/*
* Console.Out.WriteLine("---before merge");
* foreach (PeakList<T> pkl in result)
* {
* Console.Out.WriteLine("---");
* foreach (Peak p in pkl)
* {
* Console.Out.WriteLine(p);
* }
* }
*
* result.Sort(new PeakListMzAscendingComparer<T>());
*
* int current = 0;
*
* while (current < result.Count - 1)
* {
* PeakList<T> currentPkl = result[current];
* if (currentPkl[0].Charge > 0)
* {
* double expectMz = currentPkl[currentPkl.Count - 1].Mz + ChargeDeconvolution.C_GAP / currentPkl[0].Charge;
* double mzTolerance = 4 * Precursor.ppm2mz(currentPkl[0].Mz, ppmTolerance);
* int next = current + 1;
* while (next < result.Count)
* {
* double gap = result[next][0].Mz - expectMz;
* if (gap >= 2.0)
* {
* break;
* }
*
* if (Math.Abs(gap) > mzTolerance)
* {
* next++;
* continue;
* }
*
* if (result[next][0].Charge != currentPkl[0].Charge)
* {
* next++;
* continue;
* }
*
* Console.Out.WriteLine("Current----");
* foreach (T p in currentPkl)
* {
* Console.Out.WriteLine(p);
* }
* Console.Out.WriteLine("Add----");
* foreach (T p in result[next])
* {
* Console.Out.WriteLine(p);
* }
*
* currentPkl.AddRange(result[next]);
*
* Console.Out.WriteLine("To----");
* foreach (T p in currentPkl)
* {
* Console.Out.WriteLine(p);
* }
*
* result.RemoveAt(next);
* }
* }
*
* current++;
* }
*
* Console.Out.WriteLine("---after merge");
* foreach (PeakList<T> pkl in result)
* {
* Console.Out.WriteLine("---");
* foreach (Peak p in pkl)
* {
* Console.Out.WriteLine(p);
* }
* }
*/
return(result);
}
public override IEnumerable <string> Process(string targetDir)
{
foreach (var raw in rawFiles)
{
List <SimplePeakChro> waitingPeaks = new List <SimplePeakChro>();
foreach (var peak in targetPeaks)
{
string file = GetTargetFile(targetDir, raw, peak);
if (force || !File.Exists(file))
{
waitingPeaks.Add(peak);
}
else
{
var p = new SimplePeakChroXmlFormat().ReadFromFile(file);
peak.MaxRetentionTime = p.MaxRetentionTime;
peak.Peaks = p.Peaks;
}
}
if (waitingPeaks.Count == 0)
{
continue;
}
rawReader.Open(raw);
try
{
int firstScan = rawReader.GetFirstSpectrumNumber();
int lastScan = rawReader.GetLastSpectrumNumber();
var lastRt = rawReader.ScanToRetentionTime(lastScan);
waitingPeaks.ForEach(m =>
{
m.Peaks.Clear();
m.MaxRetentionTime = lastRt;
});
Progress.SetMessage("Processing chromotograph extracting...");
Progress.SetRange(firstScan, lastScan);
for (int scan = firstScan; scan <= lastScan; scan++)
{
if (rawReader.GetMsLevel(scan) != 1)
{
continue;
}
Progress.SetPosition(scan);
if (Progress.IsCancellationPending())
{
throw new UserTerminatedException();
}
PeakList <Peak> pkl = rawReader.GetPeakList(scan);
double rt = rawReader.ScanToRetentionTime(scan);
foreach (var peak in waitingPeaks)
{
var env = pkl.FindPeak(peak.Mz, peak.MzTolerance);
Peak findPeak = new Peak(peak.Mz, 0.0, 0);
if (env.Count > 0)
{
if (env.Count == 1)
{
findPeak = env[0];
}
else
{
var charge = env.FindCharge(peak.Charge);
if (charge.Count > 0)
{
if (charge.Count == 1)
{
findPeak = charge[0];
}
else
{
findPeak = charge.FindMaxIntensityPeak();
}
}
else
{
findPeak = env.FindMaxIntensityPeak();
}
}
}
peak.Peaks.Add(new ScanPeak()
{
Mz = findPeak.Mz,
Intensity = findPeak.Intensity,
Scan = scan,
RetentionTime = rt,
Charge = findPeak.Charge,
PPMDistance = PrecursorUtils.mz2ppm(peak.Mz, findPeak.Mz - peak.Mz)
});
}
}
waitingPeaks.ForEach(m => m.TrimPeaks(minRetentionTime));
}
finally
{
rawReader.Close();
}
Progress.SetMessage("Saving ... ");
foreach (var peak in waitingPeaks)
{
string file = GetTargetFile(targetDir, raw, peak);
new SimplePeakChroXmlFormat().WriteToFile(file, peak);
}
Progress.SetMessage("Finished.");
Progress.End();
}
return(new string[] { targetDir });
}
public List <PrecursorItem> QueryPrecursorFromProductIon(QueryItem productIon, double ppmProductTolerance, double ppmPrecursorTolerance)
{
List <PrecursorItem> result = new List <PrecursorItem>();
int firstScan = reader.GetFirstSpectrumNumber();
int lastScan = reader.GetLastSpectrumNumber();
double mzTolerance = PrecursorUtils.ppm2mz(productIon.ProductIonMz, ppmProductTolerance);
PeakList <Peak> lastFullScan = new PeakList <Peak>();
Progress.SetRange(firstScan, lastScan);
for (int scan = firstScan; scan <= lastScan; scan++)
{
Progress.SetPosition(scan);
if (Progress.IsCancellationPending())
{
throw new UserTerminatedException();
}
//ignore ms 1
if (reader.GetMsLevel(scan) == 1)
{
lastFullScan = ReadScan(scan);
continue;
}
//read all peaks
PeakList <Peak> pkl = ReadScan(scan);
//find product ions
PeakList <Peak> productIons = pkl.FindPeak(productIon.ProductIonMz, mzTolerance);
if (productIons.Count == 0)
{
continue;
}
//get minimum product ion intensity
double maxIntensity = pkl.FindMaxIntensityPeak().Intensity;
double relativeIntensity = productIons.FindMaxIntensityPeak().Intensity / maxIntensity;
if (relativeIntensity < productIon.MinRelativeIntensity)
{
continue;
}
Peak peak = reader.GetPrecursorPeak(scan);
double precursorMzTolerance = PrecursorUtils.ppm2mz(peak.Mz, ppmPrecursorTolerance);
var precursorPkl = lastFullScan.FindPeak(peak.Mz, precursorMzTolerance);
bool isotopic = false;
if (precursorPkl.Count == 0)
{
isotopic = true;
precursorPkl = lastFullScan.FindPeak(peak.Mz - 1.0, precursorMzTolerance);
}
if (precursorPkl.Count == 0)
{
precursorPkl = lastFullScan.FindPeak(peak.Mz + 1.0, precursorMzTolerance);
}
var precursorInFullMs = precursorPkl.FindMaxIntensityPeak();
var precursor = new PrecursorItem()
{
Scan = scan,
ProductIonRelativeIntensity = relativeIntensity
};
if (isotopic && precursorInFullMs != null)
{
precursor.PrecursorMZ = precursorInFullMs.Mz;
precursor.IsIsotopic = true;
}
else
{
precursor.PrecursorMZ = peak.Mz;
precursor.IsIsotopic = false;
}
if (precursorInFullMs != null)
{
precursor.PrecursorIntensity = precursorInFullMs.Intensity;
}
result.Add(precursor);
}
var precursorMzs = from item in result
group item by item.PrecursorMZ into mzGroup
let mzcount = mzGroup.Where(m => m.PrecursorIntensity > 0).Count()
orderby mzcount descending
select mzGroup.Key;
foreach (var mz in precursorMzs)
{
double mzPrecursorTolerance = PrecursorUtils.ppm2mz(mz, ppmPrecursorTolerance);
foreach (var item in result)
{
if (!item.IsIsotopic)
{
continue;
}
if (Math.Abs(item.PrecursorMZ - mz) <= mzPrecursorTolerance)
{
item.PrecursorMZ = mz;
}
}
}
return(result);
}
public List <LabelFreeItem> QueryChromotograph(double precursorMz, double ppmTolerance)
{
var result = new List <LabelFreeItem>();
int firstScan = reader.GetFirstSpectrumNumber();
int lastScan = reader.GetLastSpectrumNumber();
double mzTolerance = PrecursorUtils.ppm2mz(precursorMz, ppmTolerance);
Progress.SetRange(firstScan, lastScan);
bool bAppend = false;
for (int scan = firstScan; scan <= lastScan; scan++)
{
Progress.SetPosition(scan);
if (Progress.IsCancellationPending())
{
throw new UserTerminatedException();
}
//ignore ms 2
if (reader.GetMsLevel(scan) != 1)
{
continue;
}
//read all peaks
PeakList <Peak> pkl = ReadScan(scan);
//find product ions
PeakList <Peak> precursorIons = pkl.FindPeak(precursorMz, mzTolerance);
if (precursorIons.Count == 0)
{
if (bAppend)
{
result.Add(new LabelFreeItem()
{
Scan = scan,
RetentionTime = pkl.ScanTimes[0].RetentionTime,
Mz = precursorMz,
Intensity = 0.0
});
}
}
else
{
bAppend = true;
var peak = precursorIons.FindMaxIntensityPeak();
result.Add(new LabelFreeItem()
{
Scan = scan,
RetentionTime = pkl.ScanTimes[0].RetentionTime,
Mz = peak.Mz,
Intensity = peak.Intensity
});
}
}
while (result.Count > 0 && result[result.Count - 1].Intensity == 0)
{
result.RemoveAt(result.Count - 1);
}
return(result);
}
public override IEnumerable <string> Process(string fileName)
{
var result = new FileInfo(targetDir + "\\" + Path.ChangeExtension(new FileInfo(fileName).Name, ".mgf")).FullName;
int charge = 1;
PeakList <Peak> ms1 = new PeakList <Peak>();
//读取ms1
List <string> comments = new List <string>();
comments.Add("COM=" + software);
using (StreamReader sr = new StreamReader(fileName))
{
string line;
while ((line = sr.ReadLine()) != null)
{
if (line.StartsWith("COM="))
{
comments.Add(line);
continue;
}
if (line.StartsWith("BEGIN IONS"))
{
break;
}
comments.Add(line);
var parts = line.Split('\t');
if (parts.Length == 2)
{
try
{
ms1.Add(new Peak(double.Parse(parts[0]), double.Parse(parts[1])));
}
catch (Exception) { }
}
}
}
MascotGenericFormatReader <Peak> reader = new MascotGenericFormatReader <Peak>();
var pkls = reader.ReadFromFile(fileName);
foreach (var pkl in pkls)
{
var mzTolerance = PrecursorUtils.ppm2mz(pkl.PrecursorMZ, precursorTolerance);
var peak = ms1.FindPeak(pkl.PrecursorMZ, mzTolerance).FindMaxIntensityPeak();
if (peak == null)
{
pkl.PrecursorIntensity = ms1.Min(m => m.Intensity);
}
else
{
pkl.PrecursorIntensity = peak.Intensity;
}
}
pkls.Sort((m1, m2) => m2.PrecursorIntensity.CompareTo(m1.PrecursorIntensity));
for (int i = 0; i < pkls.Count; i++)
{
var line = pkls[i].Annotations[MascotGenericFormatConstants.TITLE_TAG] as string;
var m = reg.Match(line);
string experimental;
if (m.Success)
{
experimental = m.Groups[1].Value;
var m2 = nameReg.Match(experimental);
if (m2.Success)
{
if (m2.Groups[2].Value.Length == 1)
{
experimental = m2.Groups[1].Value + "0" + m2.Groups[2].Value;
}
}
}
else
{
experimental = pkls[i].Experimental;
}
pkls[i].Annotations[MascotGenericFormatConstants.TITLE_TAG] = string.Format("{0}.{1}.{2:0}.{3}.dta", experimental, i + 1, pkls[i].PrecursorIntensity, charge);
}
var writer = new MascotGenericFormatWriter <Peak>();
writer.Comments.AddRange(comments);
writer.WriteToFile(result, pkls);
return(new string[] { result });
}
