public NETAndMassAligner()
{
_massTagList = new List <TargetBase>();
_featuresToBeAligned = new TargetedResultRepository();
this.Result = new AlignmentResult();
this.AlignerParameters = new NETAndMassAlignerParameters();
}
public void doAlignmentTest1()
{
RunFactory rf = new RunFactory();
Run run = rf.CreateRun(FileRefs.RawDataMSFiles.OrbitrapStdFile1);
string deconToolsResultFile = @"D:\Temp\output7\targetedFeatures.txt";
UnlabelledTargetedResultFromTextImporter importer = new UnlabelledTargetedResultFromTextImporter(deconToolsResultFile);
TargetedResultRepository repo = importer.Import();
string massTagFile = @"\\protoapps\UserData\Slysz\Data\MassTags\qcshew_standard_file_allMassTags.txt";
MassTagCollection mtc = new MassTagCollection();
MassTagFromTextFileImporter mtimporter = new MassTagFromTextFileImporter(massTagFile);
mtc = mtimporter.Import();
NETAndMassAligner aligner = new NETAndMassAligner();
aligner.SetFeaturesToBeAligned(repo.Results);
aligner.SetReferenceMassTags(mtc.MassTagList);
aligner.Execute(run);
Assert.IsNotNull(run.AlignmentInfo);
Assert.IsNotNull(run.AlignmentInfo.marrNETFncTimeInput);
Assert.AreEqual(2273.0f, run.AlignmentInfo.marrNETFncTimeInput[0]);
float testScan = 6005;
float testNET1 = run.AlignmentInfo.GetNETFromTime(testScan);
Assert.AreEqual(0.3253423m, (decimal)testNET1);
}
public void importerTest1()
{
string importedResultFile = Path.Combine(FileRefs.OutputFolderPath, "UnlabelledTargetedResultsExporterOutput1.txt");
UnlabelledTargetedResultFromTextImporter importer = new UnlabelledTargetedResultFromTextImporter(importedResultFile);
TargetedResultRepository repo = importer.Import();
Assert.IsNotNull(repo);
Assert.IsTrue(repo.Results.Count > 0);
TargetedResult testResult1 = repo.Results[0];
Assert.AreEqual("QC_Shew_08_04-pt5-2_11Jan09_Sphinx_08-11-18", testResult1.DatasetName);
Assert.AreEqual(24698, testResult1.MassTagID);
Assert.AreEqual(3, testResult1.ChargeState);
Assert.AreEqual(5880, testResult1.ScanLC);
Assert.AreEqual(5876, testResult1.ScanLCStart);
Assert.AreEqual(5888, testResult1.ScanLCEnd);
Assert.AreEqual(0.3160, (decimal)testResult1.NET);
Assert.AreEqual(1, testResult1.NumChromPeaksWithinTol);
Assert.AreEqual(2311.07759, (decimal)testResult1.MonoMass);
Assert.AreEqual(771.36647, (decimal)testResult1.MonoMZ);
Assert.AreEqual(8247913, (decimal)testResult1.Intensity);
Assert.AreEqual(0.0119, (decimal)testResult1.FitScore);
Assert.AreEqual(0, (decimal)testResult1.IScore);
}
public void ExportNET_andMass_AlignmentDataTest1()
{
string exportNETFilename = Path.Combine(FileRefs.OutputFolderPath, "exportedNETAlignmentInfo1.txt");
string exportMassFilename = Path.Combine(FileRefs.OutputFolderPath, "exportedMassAlignmentInfo1.txt");
RunFactory rf = new RunFactory();
Run run = rf.CreateRun(FileRefs.RawDataMSFiles.OrbitrapStdFile1);
string deconToolsResultFile = @"D:\Temp\output7\targetedFeatures.txt";
UnlabelledTargetedResultFromTextImporter importer = new UnlabelledTargetedResultFromTextImporter(deconToolsResultFile);
TargetedResultRepository repo = importer.Import();
string massTagFile = @"\\protoapps\UserData\Slysz\Data\MassTags\qcshew_standard_file_allMassTags.txt";
MassTagCollection mtc = new MassTagCollection();
MassTagFromTextFileImporter mtimporter = new MassTagFromTextFileImporter(massTagFile);
mtc = mtimporter.Import();
NETAndMassAligner aligner = new NETAndMassAligner();
aligner.SetFeaturesToBeAligned(repo.Results);
aligner.SetReferenceMassTags(mtc.MassTagList);
aligner.Execute(run);
NETAlignmentInfoToTextExporter exporter = new NETAlignmentInfoToTextExporter(exportNETFilename);
exporter.ExportAlignmentInfo(run.AlignmentInfo);
MassAlignmentInfoToTextExporter massInfoexporter = new MassAlignmentInfoToTextExporter(exportMassFilename);
massInfoexporter.ExportAlignmentInfo(run.AlignmentInfo);
}
public ManualViewingWithoutRawDataViewModel(TargetedResultRepository resultRepository, FileInputsInfo fileInputs = null)
: this(fileInputs)
{
_resultRepositorySource = resultRepository;
GetImageFileReferences(FileInputs.ResultImagesFolderPath);
SetResults();
}
public ManualViewingWithoutRawDataViewModel(FileInputsInfo fileInputs = null)
{
Results = new ObservableCollection<ResultWithImageInfo>();
_fileInputsInfo = fileInputs;
FileInputs = new FileInputsViewModel(fileInputs);
FileInputs.PropertyChanged += FileInputsPropertyChanged;
_resultRepositorySource = new TargetedResultRepository();
}
public void findFeatureIn_dataset_with_bad_massCalibration_test1()
{
//mass error in this dataset is typically ~50ppm.
var datasetFile = @"D:\Data\Orbitrap\Subissue01\QC_Shew_10_01-pt5-1_8Feb10_Doc_09-12-24.RAW";
var massTagFile = @"\\protoapps\UserData\Slysz\Data\QCShew_MassiveTargeted\MassTags\QCShew_Formic_MassTags_Bin10_first10.txt";
var workflowParameterFile = @"\\protoapps\UserData\Slysz\Data\QCShew_MassiveTargeted\WorkflowParameterFiles\UnlabelledTargeted_WorkflowParameters_noSum.xml";
var run = RunUtilities.CreateAndLoadPeaks(datasetFile, datasetFile.Replace(".RAW", "_peaks.txt"));
RunUtilities.AlignRunUsingAlignmentInfoInFiles(run);
Assert.IsTrue(run.MassIsAligned);
Assert.IsTrue(run.NETIsAligned);
var parameters = new BasicTargetedWorkflowParameters();
parameters.LoadParameters(workflowParameterFile);
var workflow = new BasicTargetedWorkflow(parameters);
workflow.Run = run;
var mtc = new TargetCollection();
var mtimporter = new MassTagFromTextFileImporter(massTagFile);
mtc = mtimporter.Import();
var mt1 = (from n in mtc.TargetList where n.ID == 24702 && n.ChargeState == 4 select n).First();
run.CurrentMassTag = mt1;
workflow.Execute();
var repo = new TargetedResultRepository();
repo.AddResult(workflow.Result);
Console.WriteLine("theor mono mass = " + mt1.MonoIsotopicMass);
Console.WriteLine("theorMZ = " + mt1.MZ);
Console.WriteLine("theorNET = " + mt1.NormalizedElutionTime);
Console.WriteLine("obsScan = " + repo.Results[0].ScanLC);
Console.WriteLine("obsNET = " + repo.Results[0].NET);
Console.WriteLine("NETError = " + repo.Results[0].NETError);
Console.WriteLine("obsMZ = " + repo.Results[0].MonoMZ);
Console.WriteLine("monoMass = " + repo.Results[0].MonoMass);
Console.WriteLine("obsMonoMassCalibrated = " + repo.Results[0].MonoMassCalibrated);
Console.WriteLine("MassErrorBeforeAlignment = " + (mt1.MZ - repo.Results[0].MonoMZ) / mt1.MZ * 1e6);
Console.WriteLine("MassErrorAfterAlignment = " + repo.Results[0].MassErrorBeforeCalibration);
}
protected TargetedWorkflowExecutor(WorkflowExecutorBaseParameters parameters, WorkflowParameters workflowParameters, string datasetPath, BackgroundWorker backgroundWorker = null)
{
this.DatasetPath = datasetPath;
RunIsDisposed = true;
_backgroundWorker = backgroundWorker;
this.WorkflowParameters = parameters;
_workflowParameters = workflowParameters;
ResultRepository = new TargetedResultRepository();
InitializeWorkflow();
}
public ViewAndAnnotateViewModel()
{
FileInputs = new FileInputsViewModel();
_resultRepositorySource = new TargetedResultRepository();
Results = new ObservableCollection<SipperLcmsFeatureTargetedResultDTO>();
var workflowParameters = new SipperTargetedWorkflowParameters();
Workflow = new SipperTargetedWorkflow(workflowParameters);
ChromGraphXWindowWidth = 600;
MsGraphMinX = 400;
MsGraphMaxX = 1400;
ShowFileAndResultsList = true;
MassSpecVisibleWindowWidth = 15;
}
public void TestTargetedWorkflowExecutorMod()
{
const string executorParameterFile = @"\\protoapps\UserData\Kaipo\TopDown\test2paramsmod.xml";
var executorParameters = new TopDownTargetedWorkflowExecutorParameters();
executorParameters.LoadParameters(executorParameterFile);
string resultsFolderLocation = Path.Combine(executorParameters.OutputFolderBase, "Results");
const string testDatasetPath = @"\\protoapps\UserData\Kaipo\TopDown\test2\Proteus_Peri_intact_ETD.raw";
const string testDatasetName = "Proteus_Peri_intact_ETD";
string expectedResultsFilename = Path.Combine(resultsFolderLocation, testDatasetName + "_quant.txt");
if (File.Exists(expectedResultsFilename))
{
File.Delete(expectedResultsFilename);
}
var executor = new TopDownTargetedWorkflowExecutor(executorParameters, testDatasetPath);
executor.Execute();
// Output chrom data
var wf = executor.TargetedWorkflow as TopDownTargetedWorkflow;
Console.Write("***** chrom data *****\n");
foreach (var resultData in wf.TargetResults)
{
int id = resultData.Key;
TargetedResultBase result = resultData.Value;
double chromPeakSelected = (result.ChromPeakSelected != null) ? result.ChromPeakSelected.XValue : -1;
Console.Write("TargetID=" + id + "; ChromPeakSelected=" + chromPeakSelected + "\n");
for (int i = 0; i < result.ChromValues.Xvalues.Length; i++)
{
Console.Write(result.ChromValues.Xvalues[i] + "\t" + result.ChromValues.Yvalues[i] + "\n");
}
Console.Write("\n");
}
Console.Write("**********************\n");
Assert.IsTrue(File.Exists(expectedResultsFilename));
var importer = new UnlabelledTargetedResultFromTextImporter(expectedResultsFilename);
TargetedResultRepository repository = importer.Import();
Assert.AreEqual(9, repository.Results.Count);
}
protected TargetedWorkflowExecutor(WorkflowExecutorBaseParameters parameters, Run run, BackgroundWorker backgroundWorker = null)
{
Run = run;
RunIsDisposed = true;
if (Run != null)
{
DatasetPath = Run.DataSetPath;
}
_backgroundWorker = backgroundWorker;
this.WorkflowParameters = parameters;
ResultRepository = new TargetedResultRepository();
InitializeWorkflow();
}
public void exporterTest1()
{
var testFile = DeconTools.UnitTesting2.FileRefs.RawDataMSFiles.OrbitrapStdFile1;
var peaksTestFile = DeconTools.UnitTesting2.FileRefs.PeakDataFiles.OrbitrapPeakFile_scans5500_6500;
var massTagFile = @"\\protoapps\UserData\Slysz\Data\MassTags\qcshew_standard_file_NETVals0.3-0.33.txt";
var exportedResultFile = Path.Combine(FileRefs.OutputFolderPath, "UnlabelledTargetedResultsExporterOutput1.txt");
if (File.Exists(exportedResultFile))
{
File.Delete(exportedResultFile);
}
var run = RunUtilities.CreateAndAlignRun(testFile, peaksTestFile);
var mtc = new TargetCollection();
var mtimporter = new MassTagFromTextFileImporter(massTagFile);
mtc = mtimporter.Import();
var selectedMassTags = mtc.TargetList.OrderBy(p => p.ID).Take(10).ToList();
TargetedWorkflowParameters parameters = new BasicTargetedWorkflowParameters();
var workflow = new BasicTargetedWorkflow(run, parameters);
foreach (var mt in selectedMassTags)
{
run.CurrentMassTag = mt;
workflow.Execute();
}
var repo = new TargetedResultRepository();
repo.AddResults(run.ResultCollection.GetMassTagResults());
var exporter = new UnlabelledTargetedResultToTextExporter(exportedResultFile);
exporter.ExportResults(repo.Results);
}
public HTMLReportGenerator(TargetedResultRepository repo, FileInputsInfo fileInputs)
{
_resultRepository = repo;
_fileInputsInfo = fileInputs;
_resultsWithImageInfo = new List<ResultWithImageInfo>();
foreach (var targetedResultDto in repo.Results)
{
ResultWithImageInfo r = new ResultWithImageInfo((SipperLcmsFeatureTargetedResultDTO)targetedResultDto);
_resultsWithImageInfo.Add(r);
}
GetImageFileReferences(_fileInputsInfo.ResultImagesFolderPath);
MapResultsToImages();
}
public ViewAndAnnotateViewModel(TargetedResultRepository resultRepository, FileInputsInfo fileInputs = null)
: this(fileInputs)
{
_resultRepositorySource = resultRepository;
SetResults(_resultRepositorySource.Results);
if (IsAllDataReady)
{
OnAllDataLoadedAndReady(new EventArgs());
}
}
public override void Execute()
{
List <TargetedResultBase> resultsPassingCriteria;
_targetedResultRepository = new TargetedResultRepository();
var featuresAreImportedFromFile = !string.IsNullOrEmpty(AlignerParameters.ImportedFeaturesFilename);
if (featuresAreImportedFromFile)
{
//load them from the Features file
var importer = new UnlabelledTargetedResultFromTextImporter(AlignerParameters.ImportedFeaturesFilename);
var repo = importer.Import();
_targetedResultRepository.Results = repo.Results;
}
else
{
Check.Require(Run.ResultCollection.MSPeakResultList != null && Run.ResultCollection.MSPeakResultList.Count > 0, "Dataset's Peak-level data is empty. This is needed for chromatogram generation.");
//execute targeted feature finding to find the massTags in the raw data
_workflow = new BasicTargetedWorkflow(Run, AlignerParameters);
var netGrouping = 0.2;
double chromTolerance = 5; //in ppm
var progressString = "First trying to find alignment targets using narrow mass tolerances.... ";
ReportProgress(0, progressString);
var firstPassResults = FindTargetsThatPassSpecifiedMassTolerance(netGrouping, chromTolerance);
if (firstPassResults.Count < 10)
{
//try another netGrouping
netGrouping = 0.3;
chromTolerance = 20;
progressString = "Couldn't find enough. Now trying wider mass tolerance = " + chromTolerance;
ReportProgress(0, progressString);
var secondPassResults = FindTargetsThatPassSpecifiedMassTolerance(netGrouping, chromTolerance);
firstPassResults.AddRange(secondPassResults);
}
if (firstPassResults.Count < 10)
{
netGrouping = 0.4;
chromTolerance = 50;
progressString = "Ok this is a tough one. Now going even wider. Mass tolerance = " + chromTolerance;
ReportProgress(0, progressString);
var thirdPassResults = FindTargetsThatPassSpecifiedMassTolerance(netGrouping, chromTolerance);
firstPassResults.AddRange(thirdPassResults);
}
var ppmErrors = getMassErrors(firstPassResults);
var filteredUsingGrubbsPPMErrors = MathUtilities.filterWithGrubbsApplied(ppmErrors);
var canUseNarrowTolerances = executeDecisionOnUsingTightTolerances(filteredUsingGrubbsPPMErrors);
if (canUseNarrowTolerances)
{
var avgPPMError = filteredUsingGrubbsPPMErrors.Average();
var stdev = MathUtilities.GetStDev(filteredUsingGrubbsPPMErrors);
var tolerance = Math.Abs(avgPPMError) + 2 * stdev;
this.AlignerParameters.ChromGenTolerance = (int)Math.Ceiling(tolerance);
this.AlignerParameters.MSToleranceInPPM = (int)Math.Ceiling(tolerance);
progressString = "STRICT_Matches_AveragePPMError = \t" + avgPPMError.ToString("0.00") + "; Stdev = \t" + stdev.ToString("0.00000");
ReportProgress(0, progressString);
progressString = "NOTE: using the new PPMTolerance= " + this.AlignerParameters.ChromGenTolerance;
ReportProgress(0, progressString);
_workflow = new BasicTargetedWorkflow(Run, AlignerParameters);
}
else
{
double avgPPMError = 0;
double stdev = 0;
if (filteredUsingGrubbsPPMErrors.Count != 0)
{
avgPPMError = filteredUsingGrubbsPPMErrors.Average();
stdev = MathUtilities.GetStDev(filteredUsingGrubbsPPMErrors);
}
progressString = "STRICT_Matches_AveragePPMError = \t" + avgPPMError.ToString("0.00") + "; Stdev = \t" + stdev.ToString("0.00000");
ReportProgress(0, progressString);
progressString = "Cannot use narrow ppm tolerances during NET/Mass alignment. Either the massError was too high or couldn't find enough strict matches.";
ReportProgress(0, progressString);
// find a way to work with datasets with masses way off but low stdev
}
resultsPassingCriteria = FindTargetsThatPassCriteria();
_targetedResultRepository.AddResults(resultsPassingCriteria);
}
var canDoAlignment = _targetedResultRepository.Results.Count > 0;
if (canDoAlignment)
{
doAlignment();
}
}
public void Execute()
{
//Load results
SipperResultFromTextImporter importer = new SipperResultFromTextImporter(_fileInputs.TargetsFilePath);
_resultRepositorySource = importer.Import();
//Load Parameters
WorkflowParameters.LoadParameters(_fileInputs.ParameterFilePath);
//Sort by dataset
var sortedDatasets = (from n in _resultRepositorySource.Results orderby n.DatasetName select n);
//Set output folder
//iterate over results
int resultCounter = 0;
foreach (SipperLcmsFeatureTargetedResultDTO result in sortedDatasets)
{
resultCounter++;
CurrentResult = result;
if (result.DatasetName != CurrentDatasetName)
{
if (Run != null)
{
Run.Close();
}
InitializeRun(result.DatasetName);
}
SetCurrentWorkflowTarget(result);
Workflow.Execute();
double fwhm;
if (Workflow.Result.IsotopicProfile != null)
{
fwhm = Workflow.Result.IsotopicProfile.GetFWHM();
}
else
{
fwhm = DefaultMSPeakWidth;
}
TheorProfileXYData = TheorXYDataCalculationUtilities.GetTheoreticalIsotopicProfileXYData(Workflow.Result.Target.IsotopicProfile, fwhm);
if (resultCounter % NumResultsPerFolder == 0)
{
_subFolderCounter++;
}
OutputImages();
}
}
public void executeWorkflowTest1()
{
var testFile = FileRefs.SipperRawDataFile;
var exportedResultFile = Path.Combine(FileRefs.OutputFolderPath, "ExportedSipperResults1.txt");
var peaksFile =
@"\\protoapps\UserData\Slysz\Standard_Testing\Targeted_FeatureFinding\SIPPER_standard_testing\Yellow_C13_070_23Mar10_Griffin_10-01-28_peaks.txt";
var run = RunUtilities.CreateAndLoadPeaks(testFile, peaksFile);
var lcmsfeaturesFile =
@"\\protoapps\UserData\Slysz\Standard_Testing\Targeted_FeatureFinding\SIPPER_standard_testing\Yellow_C13_070_23Mar10_Griffin_10-01-28_LCMSFeatures.txt";
// load LCMSFeatures as targets
var importer =
new LcmsTargetFromFeaturesFileImporter(lcmsfeaturesFile);
var lcmsTargetCollection = importer.Import();
// load MassTags
var massTagFile1 =
@"\\protoapps\UserData\Slysz\Standard_Testing\Targeted_FeatureFinding\SIPPER_standard_testing\Yellow_C13_070_23Mar10_Griffin_10-01-28_MassTags.txt";
var massTagImporter = new MassTagFromTextFileImporter(massTagFile1);
var massTagCollection = massTagImporter.Import();
//enriched
var testMassTags = new int[] { 355116553, 355129038, 355160150, 355162540, 355163371 };
var filteredLcmsFeatureTargets = (from n in lcmsTargetCollection.TargetList
where testMassTags.Contains(((LcmsFeatureTarget)n).FeatureToMassTagID)
select n).ToList();
TargetCollection.UpdateTargetsWithMassTagInfo(filteredLcmsFeatureTargets, massTagCollection.TargetList);
TargetedWorkflowParameters parameters = new BasicTargetedWorkflowParameters();
parameters.ChromPeakSelectorMode = Globals.PeakSelectorMode.ClosestToTarget;
var workflow = new SipperTargetedWorkflow(run, parameters);
foreach (var target in filteredLcmsFeatureTargets)
{
run.CurrentMassTag = target;
workflow.Execute();
}
var results = run.ResultCollection.GetMassTagResults();
var repo = new TargetedResultRepository();
repo.AddResults(run.ResultCollection.GetMassTagResults());
var exporter = new SipperResultToLcmsFeatureExporter(exportedResultFile);
exporter.ExportResults(repo.Results);
}
public void Execute()
{
Check.Require(_run != null, "Run has not been defined.");
//Use Features file if it exists; if not, find the quality Features
List <MassTagResultBase> resultsPassingCriteria;
_targetedResultRepository = new TargetedResultRepository();
if (ImportedFeaturesFilename == null || ImportedFeaturesFilename.Length == 0)
{
Check.Require(_run.ResultCollection.MSPeakResultList != null && _run.ResultCollection.MSPeakResultList.Count > 0, "Dataset's Peak-level data is empty. This is needed for chromatogram generation.");
resultsPassingCriteria = FindTargetsThatPassCriteria();
_targetedResultRepository.AddResults(resultsPassingCriteria);
if (AreFeaturesSavedToTextFile)
{
string outputfolder;
if (ExportAlignmentFolder == null || ExportAlignmentFolder.Length == 0)
{
outputfolder = _run.DataSetPath;
}
else
{
outputfolder = ExportAlignmentFolder;
}
string exportTargetedFeaturesFile = Path.Combine(outputfolder, _run.DatasetName + "_alignedFeatures.txt");
UnlabelledTargetedResultToTextExporter exporter = new UnlabelledTargetedResultToTextExporter(exportTargetedFeaturesFile);
exporter.ExportResults(_targetedResultRepository.Results);
}
}
else
{
//load them from the Features file
UnlabelledTargetedResultFromTextImporter importer = new UnlabelledTargetedResultFromTextImporter(ImportedFeaturesFilename);
TargetedResultRepository repo = importer.Import();
_targetedResultRepository.Results = repo.Results;
}
//do alignment
NETAndMassAligner aligner = new NETAndMassAligner();
aligner.SetFeaturesToBeAligned(_targetedResultRepository.Results);
aligner.SetReferenceMassTags(this.MassTagList);
aligner.Execute(this._run);
//save the alignment data
if (IsAlignmentInfoExported)
{
string outputfolder;
if (ExportAlignmentFolder == null || ExportAlignmentFolder.Length == 0)
{
outputfolder = _run.DataSetPath;
}
else
{
outputfolder = ExportAlignmentFolder;
}
string exportNETAlignmentFilename = Path.Combine(outputfolder, _run.DatasetName + "_NETAlignment.txt");
string exportMZAlignmentFilename = Path.Combine(outputfolder, _run.DatasetName + "_MZAlignment.txt");
MassAlignmentInfoToTextExporter mzAlignmentExporter = new MassAlignmentInfoToTextExporter(exportMZAlignmentFilename);
mzAlignmentExporter.ExportAlignmentInfo(_run.AlignmentInfo);
NETAlignmentInfoToTextExporter netAlignmentExporter = new NETAlignmentInfoToTextExporter(exportNETAlignmentFilename);
netAlignmentExporter.ExportAlignmentInfo(_run.AlignmentInfo);
}
}
public Project()
{
ResultRepository = new TargetedResultRepository();
FileInputs = new FileInputsInfo();
}
public Project(TargetedResultRepository targetedResultRepository, FileInputsInfo fileInputsInfo)
{
ResultRepository = targetedResultRepository;
FileInputs = fileInputsInfo;
}
public AutoprocessorViewModel(TargetedResultRepository resultRepository, FileInputsInfo fileInputs = null)
: this(fileInputs)
{
_resultRepository = resultRepository;
}
public void TestTargetedWorkflowExecutor()
{
const string executorParameterFile = @"\\protoapps\UserData\Kaipo\TopDown\test2params.xml";
var executorParameters = new TopDownTargetedWorkflowExecutorParameters();
executorParameters.LoadParameters(executorParameterFile);
string resultsFolderLocation = Path.Combine(executorParameters.OutputFolderBase, "IqResults");
const string testDatasetPath = @"\\protoapps\UserData\Kaipo\TopDown\test2\Proteus_Peri_intact_ETD.raw";
const string testDatasetName = "Proteus_Peri_intact_ETD";
string expectedResultsFilename = Path.Combine(resultsFolderLocation, testDatasetName + "_quant.txt");
if (File.Exists(expectedResultsFilename))
{
File.Delete(expectedResultsFilename);
}
var executor = new TopDownTargetedWorkflowExecutor(executorParameters, testDatasetPath);
string proteinSeq =
@"A.VDKTNPYALMEDAAQKTFDKLKTEQPEIRKNPELLREIVQQELLPYVHIKYAGALVLGPYYRNATPAQRDAYFAAFKDYLAQVYGQALAMYEGQEYRIEPAKPFADKSNLTIRVTIIDKNGRPPVRLDFQWRKNSKTGEWQAYDMIAEGVSMITTKQNEWSDILSAKGVDGLTKQLEISAKTPITLDEKK.";
executor.Targets.TargetList = executor.Targets.TargetList.Where(p => p.Code == proteinSeq).ToList();
executor.Execute();
// Output chrom data
//var wf = executor.TargetedWorkflow as TopDownTargetedWorkflow;
//Console.Write("***** chrom data *****\n");
//foreach (var resultData in wf.TargetResults)
//{
// int id = resultData.Key;
// TargetedResultBase result = resultData.Value;
// double chromPeakSelected = (result.ChromPeakSelected != null) ? result.ChromPeakSelected.XValue : -1;
// Console.Write("TargetID=" + id + "; ChromPeakSelected=" + chromPeakSelected + "\n");
// for (int i = 0; i < result.ChromValues.Xvalues.Length; i++)
// {
// //Console.Write(result.ChromValues.Xvalues[i] + "\t" + result.ChromValues.Yvalues[i] + "\n");
// }
// //Console.Write("\n");
//}
Console.Write("**********************\n");
Assert.IsTrue(File.Exists(expectedResultsFilename));
var importer = new UnlabelledTargetedResultFromTextImporter(expectedResultsFilename);
TargetedResultRepository repository = importer.Import();
Assert.AreEqual(1, repository.Results.Count);
//// expected results as tuples in format: <target id, charge state, scan lc>
//var expectedResults = new HashSet<Tuple<long, int, int>>
//{
// new Tuple<long, int, int>(1, 8, 1583),
// new Tuple<long, int, int>(2, 23, 2643),
// new Tuple<long, int, int>(3, 21, 1853),
// new Tuple<long, int, int>(4, 14, 2303),
// new Tuple<long, int, int>(5, 17, 2339),
// new Tuple<long, int, int>(6, 26, 4630),
// new Tuple<long, int, int>(7, 26, 3583),
// new Tuple<long, int, int>(8, 7, 3709),
// new Tuple<long, int, int>(9, 42, 3439),
//};
//foreach (TargetedResultDTO result in repository.Results)
//{
// expectedResults.Remove(new Tuple<long, int, int>(result.TargetID, result.ChargeState, result.ScanLC));
//}
//Assert.IsEmpty(expectedResults);
}
