public XYData GetChromatogram(int startFrame, int stopFrame, int startIMSScan, int stopIMSScan, double targetMZ, double toleranceInPPM)
{
var toleranceInMZ = toleranceInPPM / 1e6 * targetMZ;
var lowerMZ = targetMZ - toleranceInMZ;
var upperMZ = targetMZ + toleranceInMZ;
var frameVals = new List <double>();
var intensityVals = new List <double>();
for (var frame = startFrame; frame <= stopFrame; frame++)
{
var frameSet = new ScanSet(frame);
var scan = new ScanSet(startIMSScan, startIMSScan, stopIMSScan);
var xyData = GetMassSpectrum(frameSet, scan, lowerMZ, upperMZ);
double sumIntensities = 0;
if (xyData?.Yvalues != null && xyData.Yvalues.Length > 0)
{
sumIntensities = xyData.Yvalues.Sum();
}
frameVals.Add(frame);
intensityVals.Add(sumIntensities);
}
var chromXYData = new XYData
{
Xvalues = frameVals.ToArray(),
Yvalues = intensityVals.ToArray()
};
return(chromXYData);
}
public override XYData GetMassSpectrum(ScanSet scanset)
{
double[] xvals;
double[] yvals;
if (scanset.PrimaryScanNumber > MaxLCScan)
{
throw new ArgumentOutOfRangeException("Cannot get mass spectrum. Exceeded max scan (which = " + MaxLCScan + ")");
}
if (scanset.PrimaryScanNumber < MinLCScan)
{
throw new ArgumentOutOfRangeException("Cannot get mass spectrum. Exceeded min scan (which = " + MinLCScan + ")");
}
_reader.GetSpectrum(scanset.PrimaryScanNumber, out xvals, out yvals);
var xydata = new XYData {
Xvalues = xvals, Yvalues = yvals
};
return(xydata);
}
public void PeakDetectorDemo1()
{
//In this list on Scan 6005 we can see what the peak of the parent is. Slide 4 1059.45898 is the Monoisotopic peak of Scan 6009
var run = new RunFactory().CreateRun(FileRefs.RawDataMSFiles.OrbitrapStdFile1);
var testScan = new ScanSet(6009);
run.CurrentScanSet = testScan;
var msgen = MSGeneratorFactory.CreateMSGenerator(run.MSFileType);
var peakDetector = new DeconToolsPeakDetectorV2();
msgen.Execute(run.ResultCollection);
peakDetector.Execute(run.ResultCollection);
var sb = new StringBuilder();
foreach (var peak in run.PeakList)
{
sb.Append(peak.XValue + "\t" + peak.Height + "\t" + peak.Width + "\n");
}
Console.WriteLine("----------------------PeakList---------------");
Console.WriteLine("m/z\tintensity\twidth");
Console.WriteLine(sb.ToString());
}
public override XYData GetMassSpectrum(ScanSet scanSet)
{
Check.Require(scanSet != null, "Can't get mass spectrum; inputted set of scans is null");
Check.Require(scanSet.IndexValues.Count > 0, "Can't get mass spectrum; no scan numbers inputted");
if (scanSet == null)
{
return(null);
}
var xyData = new XYData();
if (scanSet.IndexValues.Count == 1) //this is the case of only wanting one MS spectrum
{
getAgilentSpectrum(scanSet.PrimaryScanNumber);
xyData.Xvalues = m_spec.XArray;
xyData.Yvalues = m_spec.YArray.Select(p => (double)p).ToArray();
}
else
{
//throw new NotImplementedException("Summing isn't supported for Agilent.D files - yet");
//this is an implementation of Anuj's summing algorithm 4-2-2012.
double[] xVals = null;
float[] yVals = null;
double minMZ = 0; double maxMZ = 0;
getSummedSpectrum(scanSet, ref xVals, ref yVals, minMZ, maxMZ);
xyData.Xvalues = xVals;
xyData.Yvalues = yVals.Select(p => (double)p).ToArray();
}
return(xyData);
}
public void PeakDetectorOnCentroidedDataTest2()
{
var run = new RunFactory().CreateRun(FileRefs.RawDataMSFiles.OrbitrapStdFile1);
var scan = new ScanSet(6006); //this is a MS2 scan
var msgen = MSGeneratorFactory.CreateMSGenerator(run.MSFileType);
// Note that setting the PeakFitType to Apex will not matter since RawDataType is Centroided
// It would only matter if the RawDataType was Profile
var peakDetector = new DeconToolsPeakDetectorV2(0, 0, Globals.PeakFitType.APEX, true);
peakDetector.RawDataType = Globals.RawDataType.Centroided;
peakDetector.SignalToNoiseThreshold = 0;
peakDetector.PeakToBackgroundRatio = 0;
peakDetector.IsDataThresholded = true;
run.CurrentScanSet = scan;
msgen.Execute(run.ResultCollection);
peakDetector.Execute(run.ResultCollection);
Console.WriteLine("Num XY datapoints in mass spectrum= " + run.XYData.Xvalues.Length);
Console.WriteLine("numPeaks = " + run.PeakList.Count);
Assert.AreEqual(run.XYData.Xvalues.Length, run.PeakList.Count);
//TestUtilities.DisplayXYValues(run.XYData);
//TestUtilities.DisplayPeaks(run.PeakList);
}
public void getMSMSDataTest1()
{
//Create the run
var runFactory = new RunFactory();
var run = runFactory.CreateRun(FileRefs.RawDataMSFiles.OrbitrapStdFile1);
//Create the task
Task msgen = MSGeneratorFactory.CreateMSGenerator(run.MSFileType);
var peakdetector = new DeconToolsPeakDetectorV2();
var startScan = 6000;
var stopScan = 7000;
for (var i = startScan; i < stopScan; i++)
{
if (run.GetMSLevel(i) == 2)
{
var scanset = new ScanSet(i);
run.CurrentScanSet = scanset;
msgen.Execute(run.ResultCollection);
peakdetector.Execute(run.ResultCollection);
Console.Write("Working on Scan " + scanset.PrimaryScanNumber);
Console.WriteLine("; XYPair count = " + run.XYData.Xvalues.Length);
Console.WriteLine("num peaks= " + run.PeakList.Count);
}
}
}
public void PeakDetectorOnCentroidedDataTest1()
{
var run = new RunFactory().CreateRun(FileRefs.RawDataMSFiles.OrbitrapStdFile1);
var scan = new ScanSet(6006); //this is a centroided MS2 scan
var msgen = MSGeneratorFactory.CreateMSGenerator(run.MSFileType);
var peakDetector = new DeconToolsPeakDetectorV2(0, 0, Globals.PeakFitType.QUADRATIC, true);
peakDetector.RawDataType = Globals.RawDataType.Centroided;
peakDetector.IsDataThresholded = true;
run.CurrentScanSet = scan;
msgen.Execute(run.ResultCollection);
peakDetector.Execute(run.ResultCollection);
Console.WriteLine("Num XY datapoints in mass spectrum= " + run.XYData.Xvalues.Length);
Console.WriteLine("numPeaks = " + run.PeakList.Count);
Assert.AreEqual(run.XYData.Xvalues.Length, run.PeakList.Count);
//TestUtilities.DisplayXYValues(run.XYData);
//TestUtilities.DisplayPeaks(run.PeakList);
}
public void peak_interference_UIMF_expectInterference_test1()
{
var uimfFrame1200_142 = FileRefs.RawDataBasePath + @"\UIMF\Sarc_MS_90_21Aug10_Cheetah_10-08-02_0000_frame1200_scan142.txt";
Run run = new DeconTools.Backend.Runs.MSScanFromTextFileRun(uimfFrame1200_142);
var scanSet = new ScanSet(0);
run.CurrentScanSet = scanSet;
var msgen = MSGeneratorFactory.CreateMSGenerator(run.MSFileType);
msgen.MinMZ = 200;
msgen.MaxMZ = 2000;
var peakDetector = new DeconToolsPeakDetectorV2(4, 3, DeconTools.Backend.Globals.PeakFitType.QUADRATIC, true);
var decon = new HornDeconvolutor();
decon.MinIntensityForScore = 10;
decon.DeleteIntensityThreshold = 10;
decon.MaxFitAllowed = 0.4;
decon.MinMZ = 200;
decon.MaxMZ = 2000;
decon.IsMZRangeUsed = false;
var zeroFiller = new DeconToolsZeroFiller();
msgen.Execute(run.ResultCollection);
zeroFiller.Execute(run.ResultCollection);
peakDetector.Execute(run.ResultCollection);
decon.Execute(run.ResultCollection);
//Assert.AreEqual(93, run.ResultCollection.ResultList.Count);
var testResult = run.ResultCollection.ResultList.Where(p => p.IsotopicProfile.MonoPeakMZ > 428 && p.IsotopicProfile.MonoPeakMZ < 430).First();
var monoPeak = testResult.IsotopicProfile.getMonoPeak();
var lastPeak = testResult.IsotopicProfile.Peaklist[testResult.IsotopicProfile.Peaklist.Count - 1];
var startIndexOfXYData = MathUtils.BinarySearchWithTolerance(run.XYData.Xvalues, monoPeak.XValue - 3, 0, (run.XYData.Xvalues.Length - 1), 2);
//interference scorer
var interferenceScorer = new InterferenceScorer();
var stopwatch = new Stopwatch();
stopwatch.Start();
var scanPeaks = run.PeakList.Select <Peak, MSPeak>(i => (MSPeak)i).ToList();
var interferenceScore = interferenceScorer.GetInterferenceScore(scanPeaks, testResult.IsotopicProfile.Peaklist, monoPeak.XValue - 1.1,
lastPeak.XValue + lastPeak.Width);
stopwatch.Stop();
Console.WriteLine("interference= " + interferenceScore);
Console.WriteLine("Time taken = " + stopwatch.ElapsedMilliseconds);
}
public void CheckBackgroundIntensityTest1()
{
Run run = new XCaliburRun2(FileRefs.RawDataMSFiles.OrbitrapStdFile1);
var scan = new ScanSet(6005);
var msgen = MSGeneratorFactory.CreateMSGenerator(run.MSFileType);
var peakDetector = new DeconToolsPeakDetectorV2();
peakDetector.PeakToBackgroundRatio = 1.3;
peakDetector.SignalToNoiseThreshold = 2;
peakDetector.PeakFitType = Globals.PeakFitType.QUADRATIC;
peakDetector.IsDataThresholded = true;
var oldPeakDetector = new DeconToolsPeakDetectorV2(1.3, 2, DeconTools.Backend.Globals.PeakFitType.QUADRATIC, true);
peakDetector.IsDataThresholded = true;
run.CurrentScanSet = scan;
msgen.Execute(run.ResultCollection);
peakDetector.Execute(run.ResultCollection);
oldPeakDetector.Execute(run.ResultCollection);
//Assert.AreEqual(peakDetector.BackgroundIntensity, oldPeakDetector.BackgroundIntensity);
}
public override XYData GenerateMS(Run run, ScanSet lcScanset, ScanSet imsscanset = null)
{
Check.Require(run != null, "MS_Generator failed; 'Run' has not yet been defined");
if (run == null)
{
return(null);
}
Check.Require(!(run is UIMFRun), "MS Generator failed; You tried to use the 'Generic_MS_Generator.' Try using the 'UIMF_MSGenerator' instead");
if (lcScanset == null)
{
return(null);
}
var xydata = run.GetMassSpectrum(lcScanset, MinMZ, MaxMZ);
//TODO: this doesn't really belong here!
if (IsTICRequested)
{
lcScanset.TICValue = GetTIC(xydata, this.MinMZ, this.MaxMZ);
}
return(xydata);
}
public void agilentDeconTest1()
{
RunFactory runFact = new RunFactory();
Run run = runFact.CreateRun(agilentFile);
MSGeneratorFactory msfactory = new MSGeneratorFactory();
Task msgen = msfactory.CreateMSGenerator(run.MSFileType);
DeconToolsPeakDetector peakDet = new DeconToolsPeakDetector();
peakDet.PeakBackgroundRatio = 7;
peakDet.SigNoiseThreshold = 3;
HornDeconvolutor decon = new HornDeconvolutor();
ScanSet scan1821 = new ScanSet(1821);
run.CurrentScanSet = scan1821;
msgen.Execute(run.ResultCollection);
run.XYData = run.XYData.TrimData(450, 520, TODO);
peakDet.Execute(run.ResultCollection);
decon.Execute(run.ResultCollection);
TestUtilities.DisplayMSFeatures(run.ResultCollection.ResultList);
}
public override XYData GetMassSpectrum(ScanSet scanset, double minMZ, double maxMZ)
{
Check.Require(scanset != null, "Can't get mass spectrum; inputted set of scans is null");
Check.Require(scanset.IndexValues.Count > 0, "Can't get mass spectrum; no scan numbers inputted");
var totScans = this.GetNumMSScans();
var xvals = new double[0];
var yvals = new double[0];
if (scanset.IndexValues.Count == 1) //this is the case of only wanting one MS spectrum
{
//TODO: Old DeconTools reference!!
this.RawData.GetSpectrum(scanset.IndexValues[0], ref xvals, ref yvals, false);
}
else
{
throw new NotImplementedException("Summing is not yet supported for ICR2LS_MS Data files.");
//this.rawData.GetSummedSpectra(scanset.getLowestScanNumber(), scanset.getHighestScanNumber(), minMZ, maxMZ, ref xvals, ref yvals);
}
var xydata = new XYData();
xydata.Xvalues = xvals;
xydata.Yvalues = yvals;
xydata = xydata.TrimData(minMZ, maxMZ);
return(xydata);
}
public override XYData GetMassSpectrum(ScanSet scanset)
{
//if (scanset.IndexValues.Count > 1)
//{
// throw new NotImplementedException("Summing was attempted on YafMS data, but summing hasn't been implemented");
//}
//double[] xvals = null;
//float[] yvals = null;
// m_reader.GetSpectrum(this.SpectraID, scanset.PrimaryScanNumber, ref xvals, ref yvals);
//TODO: This simple scanset only method is not implemented in XCaliburRun
double[] xvals = null;
float[] yvals = null;
if (scanset.IndexValues.Count <= 1)
{
m_reader.GetSpectrum(this.SpectraID, scanset.PrimaryScanNumber, ref xvals, ref yvals);
}
else
{
xvals = new double[0];
yvals = new float[0];
this.getSummedSpectrum(scanset, ref xvals, ref yvals);
}
var xydata = new XYData();
xydata.Xvalues = xvals;
xydata.Yvalues = yvals.Select(p => (double)p).ToArray();
return(xydata);
}
public void GetMassSpectrumWithSummingTest1()
{
var run = new UIMFRun(FileRefs.RawDataMSFiles.UIMFStdFile3);
var frame = new ScanSet(163, 162, 164);
var scan = new IMSScanSet(121);
var xydata = run.GetMassSpectrum(frame, scan, 0, 50000);
var testMZ = 627.2655682;
var maxIntensityForTestMZ = 0;
for (var i = 0; i < xydata.Xvalues.Length; i++)
{
if (xydata.Xvalues[i] > (testMZ - 0.1) && xydata.Xvalues[i] < (testMZ + 0.1))
{
if (xydata.Yvalues[i] > maxIntensityForTestMZ)
{
maxIntensityForTestMZ = (int)xydata.Yvalues[i];
}
}
}
Assert.AreEqual(126568, maxIntensityForTestMZ);
}
public override XYData GetMassSpectrum(ScanSet scanset, double minMZ, double maxMZ)
{
//TODO: Update upon error fix.... the YAFMS library is throwing an error if I give an m/z outside it's expected range. So until that is fixed, I'll go get all the m/z values and trim them myself
double[] xvals = null;
float[] yvals = null;
if (scanset.IndexValues.Count <= 1)
{
m_reader.GetSpectrum(SpectraID, scanset.PrimaryScanNumber, ref xvals, ref yvals);
}
else
{
xvals = new double[0];
yvals = new float[0];
getSummedSpectrum(scanset, ref xvals, ref yvals, minMZ, maxMZ);
}
var xydata = new XYData
{
Xvalues = xvals,
Yvalues = yvals.Select(p => (double)p).ToArray()
};
return(xydata);
}
public void Test1()
{
string testfile = @"D:\Data\From_Nicola\AC2_Neg_highpH_14Apr13_Sauron_13-04-03.raw";
Run run = new RunFactory().CreateRun(testfile);
TestUtilities.DisplayRunInformation(run);
var msgen = MSGeneratorFactory.CreateMSGenerator(run.MSFileType);
ScanSet scanSet = new ScanSet(4100);
run.CurrentScanSet = scanSet;
msgen.Execute(run.ResultCollection);
DeconToolsPeakDetectorV2 peakDetector = new DeconToolsPeakDetectorV2();
peakDetector.Execute(run.ResultCollection);
run.PeakList = run.PeakList.Where(p => p.XValue > 742 && p.XValue < 749).ToList();
HornDeconvolutor hornDeconvolutor = new HornDeconvolutor();
hornDeconvolutor.ChargeCarrierMass = -1.00727649;
hornDeconvolutor.Execute(run.ResultCollection);
TestUtilities.DisplayMSFeatures(run.ResultCollection.ResultList);
}
public void findMSFeaturesInOrbitrapData_Test1()
{
Run run = new XCaliburRun2(FileRefs.RawDataMSFiles.OrbitrapStdFile1);
var scanSet = new ScanSet(6005);
run.CurrentScanSet = scanSet;
var msgen = MSGeneratorFactory.CreateMSGenerator(run.MSFileType);
var peakDetector = new DeconToolsPeakDetectorV2(1.3, 2, DeconTools.Backend.Globals.PeakFitType.QUADRATIC, true);
var decon = new HornDeconvolutor();
msgen.Execute(run.ResultCollection);
peakDetector.Execute(run.ResultCollection);
decon.Execute(run.ResultCollection);
Assert.AreEqual(93, run.ResultCollection.ResultList.Count);
//order and get the most intense msfeature
run.ResultCollection.ResultList = run.ResultCollection.ResultList.OrderByDescending(p => p.IntensityAggregate).ToList();
var testIso = run.ResultCollection.ResultList[0];
Assert.AreEqual(13084442, testIso.IntensityAggregate);
Assert.AreEqual(2, testIso.IsotopicProfile.ChargeState);
Assert.AreEqual(0.01012m, (decimal)Math.Round(testIso.IsotopicProfile.Score, 5));
Assert.AreEqual(3, testIso.IsotopicProfile.Peaklist.Count);
Assert.AreEqual(481.274105402604m, (decimal)testIso.IsotopicProfile.Peaklist[0].XValue);
Assert.AreEqual(481.775412188198m, (decimal)testIso.IsotopicProfile.Peaklist[1].XValue);
Assert.AreEqual(482.276820274024m, (decimal)testIso.IsotopicProfile.Peaklist[2].XValue);
TestUtilities.DisplayMSFeatures(run.ResultCollection.ResultList);
// TestUtilities.DisplayPeaks(run.PeakList);
}
public void deconWithRAPID_Then_ValidateTest1()
{
Run run = new XCaliburRun2(FileRefs.RawDataMSFiles.OrbitrapStdFile1);
ScanSet scanSet = new ScanSet(6005);
run.CurrentScanSet = scanSet;
MSGenerator msgen = MSGeneratorFactory.CreateMSGenerator(run.MSFileType);
DeconToolsPeakDetectorV2 peakDetector = new DeconToolsPeakDetectorV2(1.3, 2, DeconTools.Backend.Globals.PeakFitType.QUADRATIC, true);
RapidDeconvolutor decon = new RapidDeconvolutor();
ResultValidatorTask validator = new ResultValidatorTask();
msgen.Execute(run.ResultCollection);
peakDetector.Execute(run.ResultCollection);
decon.Execute(run.ResultCollection);
validator.Execute(run.ResultCollection);
Assert.AreEqual(190, run.ResultCollection.ResultList.Count);
IsosResult testResult = run.ResultCollection.ResultList[0];
Assert.AreEqual(0.0213668719893332m, (decimal)testResult.InterferenceScore);
//TestUtilities.DisplayMSFeatures(run.ResultCollection.ResultList);
}
public void deconWithTHRASH_Then_ValidateTest1()
{
Run run = new XCaliburRun2(FileRefs.RawDataMSFiles.OrbitrapStdFile1);
var scanSet = new ScanSet(6005);
run.CurrentScanSet = scanSet;
var msgen = MSGeneratorFactory.CreateMSGenerator(run.MSFileType);
var peakDetector = new DeconToolsPeakDetectorV2(1.3, 2, DeconTools.Backend.Globals.PeakFitType.QUADRATIC, true);
var decon = new HornDeconvolutor();
var validator = new ResultValidatorTask();
msgen.Execute(run.ResultCollection);
peakDetector.Execute(run.ResultCollection);
decon.Execute(run.ResultCollection);
validator.Execute(run.ResultCollection);
Assert.AreEqual(93, run.ResultCollection.ResultList.Count);
var testResult = run.ResultCollection.ResultList[0];
Assert.AreEqual(0.0532199478712594m, (decimal)testResult.InterferenceScore);
//TestUtilities.DisplayMSFeatures(run.ResultCollection.ResultList);
}
public override XYData GetMassSpectrum(ScanSet scanSet, double minMZ, double maxMZ)
{
Check.Require(scanSet != null, "Can't get mass spectrum; inputted set of scans is null");
Check.Require(scanSet.IndexValues.Count > 0, "Can't get mass spectrum; no scan numbers inputted");
var totScans = this.GetNumMSScans();
var xvals = new double[0];
var yvals = new double[0];
//if (scanSet.IndexValues.Count == 1) //this is the case of only wanting one MS spectrum
//{
// this.rawData.GetSpectrum(scanSet.IndexValues[0], ref xvals, ref yvals);
//}
//else
//{
// int upperscan = Math.Min(scanSet.getHighestScanNumber(), this.GetNumMSScans());
// int lowerscan = Math.Max(scanSet.getLowestScanNumber(), 1);
// this.rawData.GetSummedSpectra(lowerscan, upperscan, minMZ, maxMZ, ref xvals, ref yvals);
//}
var upperscan = Math.Min(scanSet.getHighestScanNumber(), this.GetNumMSScans());
var lowerscan = Math.Max(scanSet.getLowestScanNumber(), 1);
//TODO: Old DeconTools reference!! remove this
this.RawData.GetSummedSpectra(lowerscan, upperscan, minMZ, maxMZ, ref xvals, ref yvals);
var xydata = new XYData();
xydata.Xvalues = xvals;
xydata.Yvalues = yvals;
return(xydata);
}
public ActionResult DeleteConfirmed(int id)
{
ScanSet scanSet = db.ScanSet.Find(id);
db.ScanSet.Remove(scanSet);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public void GetMassSpectrumTest1()
{
BrukerSolarixRun run = new BrukerSolarixRun(FileRefs.RawDataMSFiles.BrukerSolarixFile1);
ScanSet scanset = new ScanSet(4);
run.GetMassSpectrum(scanset, 0, 50000);
//run.XYData.Display();
}
public void GetSpectrum1000Test1()
{
Run run = new BrukerRun(@"\\protoapps\UserData\Slysz\DeconTools_TestFiles\Bruker\Bruker_9T\RSPH_Aonly_01_run1_11Oct07_Andromeda_07-09-02\acqus");
ScanSet scanSet = new ScanSet(1001);
run.GetMassSpectrum(scanSet);
run.XYData.Display();
}
/// <summary>
/// Returns the mass spectrum for a specified LC ScanSet and a IMS ScanSet.
/// </summary>
/// <param name="lcScanSet"></param>
/// <param name="imsScanSet"></param>
/// <param name="minMZ"></param>
/// <param name="maxMZ"></param>
public override XYData GetMassSpectrum(ScanSet lcScanSet, ScanSet imsScanSet, double minMZ, double maxMZ)
{
Check.Require(imsScanSet.GetScanCount() > 0, string.Format(
"Cannot get spectrum. Number of scans in ScanSet ({0}) is 0", nameof(imsScanSet)));
Check.Require(lcScanSet.GetScanCount() > 0, string.Format(
"Cannot get spectrum. Number of frames in FrameSet ({0}) is 0", nameof(lcScanSet)));
var startFrameNumber = lcScanSet.GetLowestScanNumber();
var endFrameNumber = lcScanSet.GetHighestScanNumber();
var startScanNumber = imsScanSet.GetLowestScanNumber();
var endScanNumber = imsScanSet.GetHighestScanNumber();
// TODO: If lowest and highest scan numbers are both 0, should we be summing the mass spectrum?
var frameType = (UIMFData.FrameType)GetMSLevel(lcScanSet.PrimaryScanNumber);
try
{
// Prior to January 2015 the SpectrumCache class in the UIMFReader used Dictionary<int, int> for ListOfIntensityDictionaries
// This caused some datasets, e.g. EXP-Mix5_1um_pos_19Jan15_Columbia_DI, to run out of memory when caching 10 spectra
// The UIMFLibrary now uses List<int, int>, which takes up less memory (at the expense having slower lookups by BinNumber, though this does not affect DeconTools' use of the UIMFLibrary)
mReader.SpectraToCache = 10;
mReader.MaxSpectrumCacheMemoryMB = 750;
mReader.GetSpectrum(
startFrameNumber, endFrameNumber, frameType,
startScanNumber, endScanNumber,
minMZ, maxMZ,
out var xVals, out var yVals);
var xyData = new XYData();
if (xVals == null || xVals.Length == 0)
{
xyData.Xvalues = null;
xyData.Yvalues = null;
return(xyData);
}
xyData.Xvalues = xVals;
xyData.Yvalues = yVals.Select <int, double>(i => i).ToArray();
if (xyData.Xvalues[0] < minMZ || xyData.Xvalues[xyData.Xvalues.Length - 1] > maxMZ)
{
xyData = xyData.TrimData(minMZ, maxMZ);
}
return(xyData);
}
catch (Exception ex)
{
Console.WriteLine("Error in UIMF GetMassSpectrum: " + ex.Message);
throw;
}
}
public void getSummedSpectrum(ScanSet scanSet, ref double[] xvals, ref float[] yvals, double minX, double maxX)
{
// [gord] idea borrowed from Anuj! Jan 2010
//the idea is to convert the mz value to a integer. To avoid losing precision, we multiply it by 'precision'
//the integer is added to a dictionary generic list (sorted)
var mz_intensityPair = new SortedDictionary <long, float>();
var precision = 1e6; // if the precision is set too high, can get artifacts in which the intensities for two m/z values should be added but are separately registered.
//double[] tempXvals = new double[0];
//float[] tempYvals = new float[0];
double[] tempXvals = null;
float[] tempYvals = null;
var minXLong = (long)(minX * precision + 0.5);
var maxXLong = (long)(maxX * precision + 0.5);
for (var scanCounter = 0; scanCounter < scanSet.IndexValues.Count; scanCounter++)
{
//this.RawData.GetSpectrum(scanSet.IndexValues[scanCounter], ref tempXvals, ref tempYvals);
m_reader.GetSpectrum(this.SpectraID, scanSet.IndexValues[scanCounter], ref tempXvals, ref tempYvals);
for (var i = 0; i < tempXvals.Length; i++)
{
var tempmz = (long)Math.Floor(tempXvals[i] * precision + 0.5);
if (tempmz < minXLong || tempmz > maxXLong)
{
continue;
}
if (mz_intensityPair.ContainsKey(tempmz))
{
mz_intensityPair[tempmz] += tempYvals[i];
}
else
{
mz_intensityPair.Add(tempmz, tempYvals[i]);
}
}
}
if (mz_intensityPair.Count == 0)
{
return;
}
var summedXVals = mz_intensityPair.Keys.ToList();
xvals = new double[summedXVals.Count];
yvals = mz_intensityPair.Values.ToArray();
for (var i = 0; i < summedXVals.Count; i++)
{
xvals[i] = summedXVals[i] / precision;
}
}
public void bruker15T_GetMassSpectrumTest1()
{
BrukerV2Run run = new BrukerV2Run(FileRefs.RawDataMSFiles.Bruker15TFile1);
ScanSet scanset = new ScanSet(4);
run.GetMassSpectrum(scanset, 0, 50000);
Assert.AreEqual(789.967903595286m, (decimal)run.XYData.Xvalues[129658]);
Assert.AreEqual(9503829, run.XYData.Yvalues[129658]);
}
public void Test1()
{
var peakAssociator = new PeakToMSFeatureAssociator();
Run run = new XCaliburRun2(FileRefs.RawDataMSFiles.OrbitrapStdFile1);
var scanSet = new ScanSet(6005);
run.CurrentScanSet = scanSet;
var msgen = MSGeneratorFactory.CreateMSGenerator(run.MSFileType);
var peakDetector = new DeconToolsPeakDetectorV2(1.3, 2, DeconTools.Backend.Globals.PeakFitType.QUADRATIC, true);
var decon = new HornDeconvolutor();
msgen.Execute(run.ResultCollection);
peakDetector.Execute(run.ResultCollection);
decon.Execute(run.ResultCollection);
peakAssociator.Execute(run.ResultCollection);
var numPeaksAssociatedWithFeatures = 0;
foreach (var msfeature in run.ResultCollection.ResultList)
{
foreach (var peak in msfeature.IsotopicProfile.Peaklist)
{
numPeaksAssociatedWithFeatures++;
}
}
var numPeaksInPeakListWithAssociations = 0;
foreach (MSPeak peak in run.PeakList)
{
Console.WriteLine(peak.MSFeatureID + "\t" + peak.XValue + "\t" + peak.Height + "\t");
if (peak.MSFeatureID != -1)
{
numPeaksInPeakListWithAssociations++;
}
}
//I don't think I can assume this... msfeature1 might overlap and share a peak with msfeature2
//Assert.AreEqual(numPeaksAssociatedWithFeatures, numPeaksInPeakListWithAssociations);
Console.WriteLine("total peaks associated with MSFeatures = " + numPeaksAssociatedWithFeatures);
Console.WriteLine("total peaks in original peaklist that were associated = " + numPeaksInPeakListWithAssociations);
Console.WriteLine("fraction peaks assigned = " + (double)(numPeaksInPeakListWithAssociations / (double)run.PeakList.Count));
}
public void GetSpectrum_Bruker9T_Test1()
{
var run = new BrukerV3Run(FileRefs.RawDataMSFiles.Bruker9TStandardFile1);
var xydata = new XYData();
var scanSet = new ScanSet(300);
xydata = run.GetMassSpectrum(scanSet);
Assert.That(xydata.Xvalues != null);
Assert.That(xydata.Xvalues.Length > 0);
Assert.AreEqual(98897, xydata.Xvalues.Length);
}
public void GetSpectrum_Bruker12T_ser_Test1()
{
var run = new BrukerV3Run(FileRefs.RawDataMSFiles.BrukerSolarix12TFile1);
var xydata = new XYData();
var scanSet = new ScanSet(2);
xydata = run.GetMassSpectrum(scanSet);
Assert.That(xydata.Xvalues != null);
Assert.That(xydata.Xvalues.Length > 0);
Assert.AreEqual(204162, xydata.Xvalues.Length);
}
public void ComparePeakFitterVsAreaFitter()
{
var massTagFile1 = Path.Combine(FileRefs.RawDataBasePath, "TargetedWorkflowStandards", "QCShew_peptidesWithObsCountGreaterThan1000.txt");
//load target
var masstagImporter = new MassTagFromTextFileImporter(massTagFile1);
var targets = masstagImporter.Import().TargetList;
var run = new RunFactory().CreateRun(FileRefs.RawDataMSFiles.OrbitrapStdFile1);
var msgen = MSGeneratorFactory.CreateMSGenerator(run.MSFileType);
var peakDetector = new DeconToolsPeakDetectorV2(1.3, 2, Globals.PeakFitType.QUADRATIC, true);
var scanSet = new ScanSet(9575);
run.CurrentScanSet = scanSet;
msgen.Execute(run.ResultCollection);
peakDetector.Execute(run.ResultCollection);
var selectedTarget = targets.First(p => p.ID == 635428 && p.ChargeState == 3);
var theorFeatureGen = new JoshTheorFeatureGenerator(Backend.Globals.LabellingType.NONE, 0.005);
theorFeatureGen.GenerateTheorFeature(selectedTarget);
var peakForFWHM = run.PeakList.First(p => p.XValue > 768.38 && p.XValue < 768.39);
var theorXYdata =
TheorXYDataCalculationUtilities.GetTheoreticalIsotopicProfileXYData(selectedTarget.IsotopicProfile,
peakForFWHM.Width);
theorXYdata.NormalizeYData();
var areaFitter = new AreaFitter();
var areaFitScore = areaFitter.GetFit(theorXYdata, run.XYData, 0.1);
var peakLeastSquaresFitter = new PeakLeastSquaresFitter();
var peakBasedFitScore = peakLeastSquaresFitter.GetFit(new List <Peak>(selectedTarget.IsotopicProfile.Peaklist), run.PeakList, 0.1, 25);
Console.WriteLine("fit score based on XYData = " + areaFitScore);
Console.WriteLine("fit score based on Peaks= " + peakBasedFitScore);
Assert.IsTrue(peakBasedFitScore < 0.1);
}
private void CreateMsPlotForScanByScanAnalysis(ScanSet scanSet)
{
XYData xydata = new XYData();
xydata.Xvalues = MassSpecXyData == null ? new double[] { 400, 1500 } : MassSpecXyData.Xvalues;
xydata.Yvalues = MassSpecXyData == null ? new double[] { 0, 0 } : MassSpecXyData.Yvalues;
string msGraphTitle = "Observed MS - Scan: " + scanSet;
MsGraphMaxY = (float)xydata.getMaxY(MsGraphMinX, MsGraphMaxX);
PlotModel plotModel = new PlotModel(msGraphTitle);
plotModel.TitleFontSize = 11;
plotModel.Padding = new OxyThickness(0);
plotModel.PlotMargins = new OxyThickness(0);
plotModel.PlotAreaBorderThickness = 0;
var series = new OxyPlot.Series.LineSeries();
series.MarkerSize = 1;
series.Color = OxyColors.Black;
for (int i = 0; i < xydata.Xvalues.Length; i++)
{
series.Points.Add(new DataPoint(xydata.Xvalues[i], xydata.Yvalues[i]));
}
var xAxis = new LinearAxis(AxisPosition.Bottom, "m/z");
xAxis.Minimum = MsGraphMinX;
xAxis.Maximum = MsGraphMaxX;
var yAxis = new LinearAxis(AxisPosition.Left, "Intensity");
yAxis.Minimum = 0;
yAxis.AbsoluteMinimum = 0;
yAxis.Maximum = MsGraphMaxY + MsGraphMaxY * 0.05;
//yAxis.Maximum = maxIntensity + (maxIntensity * .05);
//yAxis.AbsoluteMaximum = maxIntensity + (maxIntensity * .05);
yAxis.AxisChanged += OnYAxisChange;
yAxis.StringFormat = "0.0E0";
xAxis.AxislineStyle = LineStyle.Solid;
xAxis.AxislineThickness = 1;
yAxis.AxislineStyle = LineStyle.Solid;
yAxis.AxislineThickness = 1;
plotModel.Series.Add(series);
plotModel.Axes.Add(xAxis);
plotModel.Axes.Add(yAxis);
ObservedIsoPlot = plotModel;
}
