public void importPeaksLargeFileTest2()
{
string testFile = textFilename2;
List <MSPeakResult> peakList = new List <MSPeakResult>();
PeakImporterFromText importer = new PeakImporterFromText(testFile);
Stopwatch sw = new Stopwatch();
sw.Start();
importer.ImportPeaks(peakList);
sw.Stop();
Console.WriteLine("Import time = " + sw.ElapsedMilliseconds);
sw.Reset();
Assert.AreEqual(4852790, peakList.Count);
sw.Start();
List <MSPeakResult> testList = peakList.Where(p => p.MSPeak.XValue > 700.01 && p.MSPeak.XValue < 700.03).ToList();
sw.Stop();
Console.WriteLine("test chrom time = " + sw.ElapsedMilliseconds);
sw.Reset();
sw.Start();
List <MSPeakResult> testList2 = peakList.Where(p => p.MSPeak.XValue > 891.01 && p.MSPeak.XValue < 891.03).ToList();
sw.Stop();
Console.WriteLine("test chrom time = " + sw.ElapsedMilliseconds);
reportChromatogram(testList);
}
public void LoadChromData(Run run)
{
if (string.IsNullOrEmpty(ChromSourceDataFilePath))
{
ChromSourceDataFilePath = GetPossiblePeaksFile();
}
if (string.IsNullOrEmpty(ChromSourceDataFilePath))
{
Console.WriteLine("Creating _Peaks.txt file for " + this.Run.DatasetName + " at " + this.Run.DataSetPath);
IqLogger.Log.Info("Creating _Peaks.txt");
ChromSourceDataFilePath = CreatePeaksForChromSourceData();
}
else
{
IqLogger.Log.Info("Using Existing _Peaks.txt");
}
IqLogger.Log.Info("Peak Loading Started...");
var peakImporter = new PeakImporterFromText(ChromSourceDataFilePath, _backgroundWorker);
peakImporter.ImportPeaks(this.Run.ResultCollection.MSPeakResultList);
IqLogger.Log.Info("Peak Loading Complete. Number of peaks loaded= " + Run.ResultCollection.MSPeakResultList.Count);
}
public void BadCorrelationTest1()
{
var dataset =
@"\\protoapps\UserData\Slysz\Standard_Testing\Targeted_FeatureFinding\O16O18_standard_testing\Test1_VladAlz\RawData\Alz_P01_A01_097_26Apr12_Roc_12-03-15.RAW";
var run = new RunFactory().CreateRun(dataset);
var peaksDataFile = dataset.ToLower().Replace(".raw", "_peaks.txt");
var peakImporter = new PeakImporterFromText(peaksDataFile);
peakImporter.ImportPeaks(run.ResultCollection.MSPeakResultList);
double chromToleranceInPPM = 10;
var startScan = 2340;
var stopScan = 2440;
var smoother = new SavitzkyGolaySmoother(9, 2);
var testMZVal1 = 719.80349;
var peakChromGen = new PeakChromatogramGenerator(chromToleranceInPPM);
run.XYData = peakChromGen.GenerateChromatogram(run, startScan, stopScan, testMZVal1, chromToleranceInPPM);
run.XYData = smoother.Smooth(run.XYData);
var chromdata1 = run.XYData.TrimData(startScan, stopScan);
var testMZVal2 = 722.325;
run.XYData = peakChromGen.GenerateChromatogram(run, startScan, stopScan, testMZVal2, chromToleranceInPPM);
run.XYData = smoother.Smooth(run.XYData);
var chromdata2 = run.XYData.TrimData(startScan, stopScan);
//chromdata1.Display();
//Console.WriteLine();
//chromdata2.Display();
ChromatogramCorrelatorBase correlator = new ChromatogramCorrelator(3);
double slope = 0;
double intercept = 0;
double rsquaredVal = 0;
correlator.GetElutionCorrelationData(chromdata1, chromdata2, out slope, out intercept, out rsquaredVal);
Console.WriteLine("slope = \t" + slope);
Console.WriteLine("intercept = \t" + intercept);
Console.WriteLine("rsquared = \t" + rsquaredVal);
for (var i = 0; i < chromdata1.Xvalues.Length; i++)
{
Console.WriteLine(chromdata1.Xvalues[i] + "\t" + chromdata1.Yvalues[i] + "\t" + chromdata2.Yvalues[i]);
}
}
public void TraditionalWorkflowTestOrbitrapData_useThrashV1_test2()
{
var parameterFile =
@"\\protoapps\UserData\Slysz\DeconTools_TestFiles\ParameterFiles\LTQ_Orb\LTQ_Orb_SN2_PeakBR1pt3_PeptideBR1_Thrash_scan6000_9000 - oldThrash.xml";
var run = new RunFactory().CreateRun(FileRefs.RawDataMSFiles.OrbitrapStdFile1);
var expectedIsosFile = Path.Combine(run.DataSetPath, run.DatasetName + "_isos.csv");
var expectedScansFile = Path.Combine(run.DataSetPath, run.DatasetName + "_scans.csv");
var expectedPeaksFile = Path.Combine(run.DataSetPath, run.DatasetName + "_peaks.txt");
if (File.Exists(expectedIsosFile))
{
File.Delete(expectedIsosFile);
}
if (File.Exists(expectedScansFile))
{
File.Delete(expectedScansFile);
}
if (File.Exists(expectedPeaksFile))
{
File.Delete(expectedPeaksFile);
}
var parameters = new DeconToolsParameters();
parameters.LoadFromOldDeconToolsParameterFile(parameterFile);
//parameters.MSGeneratorParameters.MinLCScan = 6005;
//parameters.MSGeneratorParameters.MaxLCScan = 6005;
var workflow = ScanBasedWorkflow.CreateWorkflow(run, parameters);
workflow.Execute();
Assert.IsTrue(File.Exists(expectedIsosFile), "Isos file was not created.");
Assert.IsTrue(File.Exists(expectedScansFile), "Scans file was not created.");
Assert.IsTrue(File.Exists(expectedPeaksFile), "Peaks file was not created.");
var isosImporter = new IsosImporter(expectedIsosFile, run.MSFileType);
var isos = isosImporter.Import();
Assert.AreEqual(186, isos.Count);
var peakImporter = new PeakImporterFromText(expectedPeaksFile);
var peaklist = new List <MSPeakResult>();
peakImporter.ImportPeaks(peaklist);
Assert.AreEqual(809, peaklist.Count);
var sumIntensities = isos.Select(p => p.IntensityAggregate).Sum();
//Assert.AreEqual(263499300d, Math.Round(sumIntensities));
var sumPeakIntensities = peaklist.Select(p => p.Height).Sum();
//Assert.AreEqual(605170496.0f, sumPeakIntensities);
}
public void TraditionalWorkflowTestOrbitrapData_DetectPeaksOnly()
{
var parameterFile = FileRefs.ParameterFiles.Orbitrap_Scans6000_6050ParamFile;
var run = new RunFactory().CreateRun(FileRefs.RawDataMSFiles.OrbitrapStdFile1);
var expectedIsosFile = Path.Combine(run.DataSetPath, run.DatasetName + "_isos.csv");
var expectedScansFile = Path.Combine(run.DataSetPath, run.DatasetName + "_scans.csv");
var expectedPeaksFile = Path.Combine(run.DataSetPath, run.DatasetName + "_peaks.txt");
if (File.Exists(expectedIsosFile))
{
File.Delete(expectedIsosFile);
}
if (File.Exists(expectedScansFile))
{
File.Delete(expectedScansFile);
}
if (File.Exists(expectedPeaksFile))
{
File.Delete(expectedPeaksFile);
}
var parameters = new DeconToolsParameters();
parameters.LoadFromOldDeconToolsParameterFile(parameterFile);
parameters.ScanBasedWorkflowParameters.DeconvolutionType = Globals.DeconvolutionType.None;
parameters.MSGeneratorParameters.MinLCScan = 6005;
parameters.MSGeneratorParameters.MaxLCScan = 6005;
var workflow = ScanBasedWorkflow.CreateWorkflow(run, parameters);
workflow.Execute();
Assert.IsTrue(File.Exists(expectedIsosFile), "Isos file was not created.");
Assert.IsTrue(File.Exists(expectedScansFile), "Scans file was not created.");
Assert.IsTrue(File.Exists(expectedPeaksFile), "Peaks file was not created.");
var peakImporter = new PeakImporterFromText(expectedPeaksFile);
var peaklist = new List <MSPeakResult>();
peakImporter.ImportPeaks(peaklist);
Assert.AreEqual(809, peaklist.Count);
var isosImporter = new IsosImporter(expectedIsosFile, run.MSFileType);
var isos = isosImporter.Import();
Assert.AreEqual(0, isos.Count);
}
public static void GetPeaks(Run run, string expectedPeaksFile, BackgroundWorker bw = null)
{
if (bw == null)
{
bw = new BackgroundWorker
{
WorkerReportsProgress = true,
WorkerSupportsCancellation = true
};
}
var peakImporter = new PeakImporterFromText(expectedPeaksFile, bw);
peakImporter.ImportPeaks(run.ResultCollection.MSPeakResultList);
if (!run.PrimaryLcScanNumbers.Any())
{
run.PrimaryLcScanNumbers = FindPrimaryLcScanNumbers(run.ResultCollection.MSPeakResultList);
}
}
public void importPeaksFromText()
{
string testFile = textFilename;
List <MSPeakResult> peakList = new List <MSPeakResult>();
PeakImporterFromText importer = new PeakImporterFromText(testFile);
importer.ImportPeaks(peakList);
Assert.AreEqual(1096, peakList[1095].PeakID);
Assert.AreEqual(6005, peakList[1095].Scan_num);
Assert.AreEqual(754.37393, (decimal)peakList[1095].MSPeak.XValue);
Assert.AreEqual(3266908, (decimal)peakList[1095].MSPeak.Height);
Assert.AreEqual(0.0148, (decimal)peakList[1095].MSPeak.Width);
Assert.AreEqual(32.92, (decimal)peakList[1095].MSPeak.SN);
Assert.AreEqual(4088, peakList.Count);
}
public void CorrelationTest2_UsingExecutorMethod()
{
var run = new RunFactory().CreateRun(FileRefs.RawDataMSFiles.OrbitrapStdFile1);
var peakImporter = new PeakImporterFromText(FileRefs.PeakDataFiles.OrbitrapPeakFile_scans5500_6500);
peakImporter.ImportPeaks(run.ResultCollection.MSPeakResultList);
var mt = TestUtilities.GetMassTagStandard(1);
run.CurrentMassTag = mt;
var unlabelledTheorGenerator = new JoshTheorFeatureGenerator();
unlabelledTheorGenerator.GenerateTheorFeature(mt);
double chromToleranceInPPM = 10;
var startScan = 5460;
var stopScan = 5755;
var smoother = new SavitzkyGolaySmoother(3, 2);
var peakChromGen = new PeakChromatogramGenerator(chromToleranceInPPM);
run.XYData = peakChromGen.GenerateChromatogram(run, startScan, stopScan, mt.IsotopicProfile.Peaklist[0].XValue, chromToleranceInPPM);
run.XYData = smoother.Smooth(run.XYData);
var result = run.ResultCollection.GetTargetedResult(mt);
ChromatogramCorrelatorBase correlator = new ChromatogramCorrelator(3);
var corrData = correlator.CorrelatePeaksWithinIsotopicProfile(run, mt.IsotopicProfile, startScan, stopScan);
Debug.Assert(corrData.CorrelationDataItems != null, "corrData.CorrelationDataItems != null");
Assert.AreEqual(0.98m, (decimal)Math.Round((double)corrData.CorrelationDataItems[1].CorrelationRSquaredVal, 2));
foreach (var item in corrData.CorrelationDataItems)
{
Console.WriteLine(item.CorrelationRSquaredVal);
}
}
private void LoadPeaks()
{
try
{
_peaksFilename = this.Run.DataSetPath + "\\" + this.Run.DatasetName + "_peaks.txt";
if (!File.Exists(_peaksFilename))
{
GeneralStatusMessage =
"Creating chromatogram data (_peaks.txt file); this is only done once. It takes 1 - 5 min .......";
var deconParam = (TargetedWorkflowParameters)Workflow.WorkflowParameters;
var peakCreationParameters = new PeakDetectAndExportWorkflowParameters();
peakCreationParameters.PeakBR = deconParam.ChromGenSourceDataPeakBR;
peakCreationParameters.PeakFitType = Globals.PeakFitType.QUADRATIC;
peakCreationParameters.SigNoiseThreshold = deconParam.ChromGenSourceDataSigNoise;
var peakCreator = new PeakDetectAndExportWorkflow(Run, peakCreationParameters, _backgroundWorker);
peakCreator.Execute();
}
}
catch (Exception ex)
{
GeneralStatusMessage = ex.Message;
return;
}
GeneralStatusMessage = "Loading chromatogram data (_peaks.txt file) .......";
try
{
PeakImporterFromText peakImporter = new PeakImporterFromText(_peaksFilename, _backgroundWorker);
peakImporter.ImportPeaks(this.Run.ResultCollection.MSPeakResultList);
}
catch (Exception ex)
{
GeneralStatusMessage = ex.Message;
return;
//throw new ApplicationException("Peaks failed to load. Maybe the details below will help... \n\n" + ex.Message + "\nStacktrace: " + ex.StackTrace, ex);
}
if (Run.ResultCollection.MSPeakResultList != null && Run.ResultCollection.MSPeakResultList.Count > 0)
{
int numPeaksLoaded = Run.ResultCollection.MSPeakResultList.Count;
GeneralStatusMessage = "Chromatogram data LOADED. (# peaks= " + numPeaksLoaded + ")";
}
else
{
GeneralStatusMessage = "No Chromatogram data!!! Check your _peaks.txt file for correct format.";
}
}
public void InitializeRun(string dataset)
{
string runFilename;
if (this.ExecutorParameters.CopyRawFileLocal)
{
ReportGeneralProgress("Started copying raw data to local folder: " + this.ExecutorParameters.FolderPathForCopiedRawDataset);
var attr = File.GetAttributes(dataset);
DirectoryInfo sourceDirInfo;
DirectoryInfo targetDirInfo;
if ((attr & FileAttributes.Directory) == FileAttributes.Directory)
{
sourceDirInfo = new DirectoryInfo(dataset);
runFilename = Path.Combine(this.ExecutorParameters.FolderPathForCopiedRawDataset, sourceDirInfo.Name);
targetDirInfo = new DirectoryInfo(runFilename);
FileUtilities.CopyAll(sourceDirInfo, targetDirInfo);
ReportGeneralProgress("Copying complete.");
}
else
{
var fileinfo = new FileInfo(dataset);
sourceDirInfo = fileinfo.Directory;
runFilename = Path.Combine(this.ExecutorParameters.FolderPathForCopiedRawDataset, Path.GetFileName(dataset));
targetDirInfo = new DirectoryInfo(this.ExecutorParameters.FolderPathForCopiedRawDataset);
if (!File.Exists(runFilename))
{
FileUtilities.CopyAll(fileinfo, targetDirInfo);
ReportGeneralProgress("Copying complete.");
}
else
{
ReportGeneralProgress("Datafile already exists on local drive. Using existing datafile.");
}
}
}
else
{
runFilename = dataset;
}
//create Run
var rf = new RunFactory();
Run = rf.CreateRun(runFilename);
var runInstantiationFailed = (Run == null);
if (runInstantiationFailed)
{
ReportGeneralProgress("Run initialization FAILED. Likely a filename problem. Or missing manufacturer .dlls");
return;
}
else
{
ReportGeneralProgress("Run initialized successfully.");
}
//Retrieve alignment data if it exists
CopyAlignmentInfoIfExists();
//check and load chrom source data (_peaks.txt)
var peaksFileExists = CheckForPeaksFile();
if (!peaksFileExists)
{
ReportGeneralProgress("Creating _Peaks.txt file for extracted ion chromatogram (XIC) source data ... takes 1-5 minutes");
CreatePeaksForChromSourceData();
ReportGeneralProgress("Done creating _Peaks.txt file");
}
else
{
ReportGeneralProgress("Using existing _Peaks.txt file");
}
ReportGeneralProgress("Peak loading started...");
var baseFileName = Path.Combine(this.Run.DataSetPath, this.Run.DatasetName);
var possibleFilename1 = baseFileName + "_peaks.txt";
if (File.Exists(possibleFilename1))
{
//create background worker so that updates don't go out to console.
//BackgroundWorker bw = new BackgroundWorker();
//bw.WorkerSupportsCancellation = true;
//bw.WorkerReportsProgress = true;
//TODO: keep an eye on errors connected to background worker here.
var peakImporter = new PeakImporterFromText(possibleFilename1, _backgroundWorker);
peakImporter.ImportPeaks(this.Run.ResultCollection.MSPeakResultList);
}
else
{
ReportGeneralProgress("CRITICAL FAILURE. Chrom source data (_peaks.txt) file not loaded.");
return;
}
// Grab the primary LC Scan numbers if they are not already filled out
if (!Run.PrimaryLcScanNumbers.Any())
{
Run.PrimaryLcScanNumbers = RunUtilities.FindPrimaryLcScanNumbers(this.Run.ResultCollection.MSPeakResultList);
}
ReportGeneralProgress("Peak Loading complete.");
return;
}
public void TraditionalWorkflowTestOrbitrapData1()
{
var parameterFile = FileRefs.ParameterFiles.Orbitrap_Scans6000_6050ParamFile;
var run = new RunFactory().CreateRun(FileRefs.RawDataMSFiles.OrbitrapStdFile1);
var expectedIsosFile = Path.Combine(run.DataSetPath, run.DatasetName + "_isos.csv");
var expectedScansFile = Path.Combine(run.DataSetPath, run.DatasetName + "_scans.csv");
var expectedPeaksFile = Path.Combine(run.DataSetPath, run.DatasetName + "_peaks.txt");
if (File.Exists(expectedIsosFile))
{
File.Delete(expectedIsosFile);
}
if (File.Exists(expectedScansFile))
{
File.Delete(expectedScansFile);
}
if (File.Exists(expectedPeaksFile))
{
File.Delete(expectedPeaksFile);
}
var parameters = new DeconToolsParameters();
parameters.LoadFromOldDeconToolsParameterFile(parameterFile);
parameters.ScanBasedWorkflowParameters.DeconvolutionType = Globals.DeconvolutionType.ThrashV1;
parameters.MSGeneratorParameters.MinLCScan = 6005;
parameters.MSGeneratorParameters.MaxLCScan = 6005;
var workflow = ScanBasedWorkflow.CreateWorkflow(run, parameters);
workflow.Execute();
Assert.IsTrue(File.Exists(expectedIsosFile), "Isos file was not created.");
Assert.IsTrue(File.Exists(expectedScansFile), "Scans file was not created.");
Assert.IsTrue(File.Exists(expectedPeaksFile), "Peaks file was not created.");
var isosImporter = new IsosImporter(expectedIsosFile, run.MSFileType);
var isos = isosImporter.Import();
Assert.AreEqual(186, isos.Count);
var peakImporter = new PeakImporterFromText(expectedPeaksFile);
var peaklist = new List <MSPeakResult>();
peakImporter.ImportPeaks(peaklist);
Assert.AreEqual(809, peaklist.Count);
var sumIntensities = isos.Select(p => p.IntensityAggregate).Sum();
Assert.AreEqual(266185816d, Math.Round(sumIntensities));
var sumPeakIntensities = peaklist.Select(p => p.Height).Sum();
Assert.AreEqual(605170496.0f, sumPeakIntensities);
}
private void InitializeRun(string datasetName)
{
//Datasets have to all be in the same folder
//currently works for datasets that have a File reference as
//opposed to datasets having a Folder reference (Agilent/Bruker)
DirectoryInfo dirInfo = new DirectoryInfo(_fileInputs.DatasetDirectory);
var fileInfo = dirInfo.GetFiles(datasetName + ".*");
if (!fileInfo.Any())
{
throw new FileNotFoundException("Run could not be initialized. File not found");
}
RunFactory rf = new RunFactory();
Run = rf.CreateRun(fileInfo.First().FullName);
bool peaksFileExists = checkForPeaksFile();
if (!peaksFileExists)
{
ReportGeneralProgress("Creating extracted ion chromatogram (XIC) source data... takes 1-5 minutes.. only needs to be done once.");
CreatePeaksForChromSourceData();
ReportGeneralProgress("Done creating XIC source data.");
}
string baseFileName;
baseFileName = this.Run.DataSetPath + "\\" + this.Run.DatasetName;
string expectedPeaksFilename = baseFileName + "_peaks.txt";
if (File.Exists(expectedPeaksFilename))
{
PeakImporterFromText peakImporter = new PeakImporterFromText(expectedPeaksFilename, _backgroundWorker);
peakImporter.ImportPeaks(this.Run.ResultCollection.MSPeakResultList);
}
else
{
ReportGeneralProgress(DateTime.Now + "\tCRITICAL FAILURE. Chrom source data (_peaks.txt) file not loaded.");
return;
}
ReportGeneralProgress(DateTime.Now + "\tPeak Loading complete.");
return;
}
public void CorrelationTest1()
{
//TODO: test something
var run = new RunFactory().CreateRun(FileRefs.RawDataMSFiles.OrbitrapStdFile1);
var peakImporter = new PeakImporterFromText(FileRefs.PeakDataFiles.OrbitrapPeakFile_scans5500_6500);
peakImporter.ImportPeaks(run.ResultCollection.MSPeakResultList);
var mt = TestUtilities.GetMassTagStandard(1);
run.CurrentMassTag = mt;
var unlabelledTheorGenerator = new JoshTheorFeatureGenerator();
unlabelledTheorGenerator.GenerateTheorFeature(mt);
double chromToleranceInPPM = 10;
var startScan = 5460;
var stopScan = 5755;
var smoother = new SavitzkyGolaySmoother(3, 2);
var peakChromGen = new PeakChromatogramGenerator(chromToleranceInPPM);
run.XYData = peakChromGen.GenerateChromatogram(run, startScan, stopScan, mt.IsotopicProfile.Peaklist[0].XValue, chromToleranceInPPM);
run.XYData = smoother.Smooth(run.XYData);
var chromdata1 = run.XYData.TrimData(startScan, stopScan);
run.XYData = peakChromGen.GenerateChromatogram(run, startScan, stopScan, mt.IsotopicProfile.Peaklist[3].XValue, chromToleranceInPPM);
run.XYData = smoother.Smooth(run.XYData);
var chromdata2 = run.XYData.TrimData(startScan, stopScan);
//chromdata1.Display();
//Console.WriteLine();
//chromdata2.Display();
ChromatogramCorrelatorBase correlator = new ChromatogramCorrelator(3);
double slope = 0;
double intercept = 0;
double rsquaredVal = 0;
correlator.GetElutionCorrelationData(chromdata1, chromdata2, out slope, out intercept, out rsquaredVal);
Console.WriteLine(mt);
Console.WriteLine("slope = \t" + slope);
Console.WriteLine("intercept = \t" + intercept);
Console.WriteLine("rsquared = \t" + rsquaredVal);
for (var i = 0; i < chromdata1.Xvalues.Length; i++)
{
Console.WriteLine(chromdata1.Xvalues[i].ToString("0") + "\t" + chromdata1.Yvalues[i].ToString("0") + "\t" + chromdata2.Yvalues[i]);
}
}
public void ChromAnalysisForAllSelectedPrecursors()
{
var isDataSmoothed = true;
var numPointsInSmoothing = 9;
var smoother = new DeconTools.Backend.ProcessingTasks.Smoothers.SavitzkyGolaySmoother(numPointsInSmoothing, 2);
var graphGenerator = new BasicGraphControl();
var thermoFile1 = @"\\protoapps\UserData\Slysz\DeconTools_TestFiles\Orbitrap\QC_Shew_08_04-pt5-2_11Jan09_Sphinx_08-11-18.RAW";
var run = new RunFactory().CreateRun(thermoFile1);
var outputFolderForChromGraphs = @"\\protoapps\DataPkgs\Public\2012\684_DeconMSn_research1\ChromatogramImages";
if (!Directory.Exists(outputFolderForChromGraphs))
{
Directory.CreateDirectory(outputFolderForChromGraphs);
}
var scanSetCollection = new ScanSetCollection();
var scanStart = run.MinLCScan;
var scanStop = run.MaxLCScan;
scanSetCollection.Create(run, scanStart, scanStop, 1, 1, true);
var sb = new StringBuilder();
var expectedPeaksFile = Path.Combine(run.DataSetPath, run.DatasetName + "_peaks.txt");
if (!File.Exists(expectedPeaksFile))
{
var peakCreatorParams = new PeakDetectAndExportWorkflowParameters();
peakCreatorParams.PeakBR = 1.75;
var peakCreator = new PeakDetectAndExportWorkflow(run, peakCreatorParams);
peakCreator.Execute();
}
var peakImporter = new PeakImporterFromText(expectedPeaksFile);
peakImporter.ImportPeaks(run.ResultCollection.MSPeakResultList);
double ppmTol = 50;
var peakChromatogramGenerator = new PeakChromatogramGenerator(ppmTol, Globals.ChromatogramGeneratorMode.MZ_BASED);
var scansetList = scanSetCollection.ScanSetList;
var scanCounter = 0;
var currentBin = 0;
foreach (var scanSet in scansetList)
{
run.CurrentScanSet = scanSet;
var currentScanLevel = run.GetMSLevel(scanSet.PrimaryScanNumber);
if (currentScanLevel > 1)
{
scanCounter++;
var precursorInfo = run.GetPrecursorInfo(scanSet.PrimaryScanNumber);
var scanInfo = run.GetScanInfo(scanSet.PrimaryScanNumber);
var scanWindowSize = 400;
var startScan = scanSet.PrimaryScanNumber - scanWindowSize / 2;
var stopScan = scanSet.PrimaryScanNumber + scanWindowSize / 2;
run.XYData = peakChromatogramGenerator.GenerateChromatogram(run, startScan, stopScan, precursorInfo.PrecursorMZ, ppmTol);
if (run.XYData == null)
{
run.XYData = new XYData();
run.XYData.Xvalues = new double[] { 0, 1, 2 };
run.XYData.Yvalues = new double[] { 0, 1, 2 };
Console.WriteLine(scanSet.PrimaryScanNumber + "\t" + precursorInfo.MSLevel + "\t" + precursorInfo.PrecursorMZ +
"\t" + precursorInfo.PrecursorScan + "--------- NO XYData!!! -------------");
}
else
{
if (isDataSmoothed)
{
run.XYData = smoother.Smooth(run.XYData);
}
}
Console.WriteLine(scanSet.PrimaryScanNumber + "\t" + precursorInfo.MSLevel + "\t" + precursorInfo.PrecursorMZ +
"\t" + precursorInfo.PrecursorScan);
graphGenerator.GenerateGraph(run.XYData.Xvalues, run.XYData.Yvalues);
var line = graphGenerator.GraphPane.CurveList[0] as LineItem;
line.Line.IsVisible = true;
line.Symbol.Size = 2;
line.Symbol.Type = SymbolType.Circle;
graphGenerator.GraphPane.XAxis.Title.Text = "scan";
graphGenerator.GraphPane.YAxis.Title.Text = "intensity";
graphGenerator.GraphPane.XAxis.Scale.MinAuto = true;
graphGenerator.GraphPane.YAxis.Scale.MinAuto = false;
graphGenerator.GraphPane.YAxis.Scale.Min = 0;
graphGenerator.GraphPane.XAxis.Scale.FontSpec.Size = 12;
graphGenerator.AddVerticalLineToGraph(scanSet.PrimaryScanNumber, 3);
graphGenerator.AddAnnotationRelativeAxis(scanInfo, 0.3, 0.1);
if (scanCounter > 500)
{
currentBin++;
scanCounter = 0;
}
var currentOutputFolder = Path.Combine(outputFolderForChromGraphs, "bin" + currentBin);
if (!Directory.Exists(currentOutputFolder))
{
Directory.CreateDirectory(currentOutputFolder);
}
var baseFilename = Path.Combine(currentOutputFolder,
scanSet.PrimaryScanNumber.ToString().PadLeft(5, '0') + "_mz" + precursorInfo.PrecursorMZ);
string outputGraphFilename;
string outputXYData;
if (isDataSmoothed)
{
outputGraphFilename = baseFilename + "_smoothed_chrom.png";
outputXYData = baseFilename + "_smoothed_xydata.txt";
}
else
{
outputXYData = baseFilename + "_xydata.txt";
outputGraphFilename = baseFilename + "_chrom.png";
}
graphGenerator.SaveGraph(outputGraphFilename);
TestUtilities.WriteToFile(run.XYData, outputXYData);
}
}
Console.WriteLine(sb.ToString());
}
private void LoadPeaks()
{
try
{
_peaksFilename = Path.Combine(this.Run.DataSetPath, this.Run.DatasetName + "_peaks.txt");
var fiPeaksFile = new FileInfo(_peaksFilename);
if (!fiPeaksFile.Exists)
{
var alternatePeaksFilePath = Path.Combine(System.IO.Path.GetTempPath(), this.Run.DatasetName + "_peaks.txt");
if (File.Exists(alternatePeaksFilePath))
{
_peaksFilename = alternatePeaksFilePath;
fiPeaksFile = new FileInfo(_peaksFilename);
}
}
if (_recreatePeaksFile || !fiPeaksFile.Exists)
{
_recreatePeaksFile = false;
// Make sure we have write access to the folder with the dataset file
try
{
using (var swPeaksfile = new StreamWriter(new FileStream(fiPeaksFile.FullName, FileMode.Create, FileAccess.Write)))
{
swPeaksfile.WriteLine("Test");
}
}
catch (UnauthorizedAccessException)
{
// Create the _peaks.txt file in the user's temprorary folder
_peaksFilename = Path.Combine(System.IO.Path.GetTempPath(), this.Run.DatasetName + "_peaks.txt");
fiPeaksFile = new FileInfo(_peaksFilename);
}
fiPeaksFile.Refresh();
if (fiPeaksFile.Exists)
fiPeaksFile.Delete();
GeneralStatusMessage =
"Creating chromatogram data (_peaks.txt file); this is only done once. It takes 1 - 5 min .......";
var peakCreationParameters = new PeakDetectAndExportWorkflowParameters();
peakCreationParameters.PeakBR = ChromSourcePeakDetectorPeakBr;
peakCreationParameters.PeakFitType = Globals.PeakFitType.QUADRATIC;
peakCreationParameters.SigNoiseThreshold = ChromSourcePeakDetectorSigNoise;
peakCreationParameters.OutputFolder = fiPeaksFile.Directory.FullName;
var peakCreator = new PeakDetectAndExportWorkflow(Run, peakCreationParameters, _backgroundWorker);
peakCreator.Execute();
}
}
catch (Exception ex)
{
GeneralStatusMessage = ex.Message;
return;
}
GeneralStatusMessage = "Loading chromatogram data (_peaks.txt file) .......";
try
{
PeakImporterFromText peakImporter = new PeakImporterFromText(_peaksFilename, _backgroundWorker);
peakImporter.ImportPeaks(this.Run.ResultCollection.MSPeakResultList);
}
catch (Exception ex)
{
GeneralStatusMessage = ex.Message;
return;
//throw new ApplicationException("Peaks failed to load. Maybe the details below will help... \n\n" + ex.Message + "\nStacktrace: " + ex.StackTrace, ex);
}
if (Run.ResultCollection.MSPeakResultList != null && Run.ResultCollection.MSPeakResultList.Count > 0)
{
int numPeaksLoaded = Run.ResultCollection.MSPeakResultList.Count;
GeneralStatusMessage = "Chromatogram data LOADED. (# peaks= " + numPeaksLoaded + ")";
}
else
{
GeneralStatusMessage = "No Chromatogram data!!! Check your _peaks.txt file for correct format.";
}
}
