Example #1
0
        public void importTest1()
        {
            var testFile = Path.Combine(FileRefs.ImportedData, "ImportedSipperResults1.txt");
            var importer = new SipperResultFromTextImporter(testFile);

            var results = importer.Import();

            Assert.IsNotNull(results);
            Assert.IsTrue(results.Results.Count > 0);

            var testResult1 = results.Results.First() as SipperLcmsFeatureTargetedResultDTO;

            Assert.IsNotNull(testResult1);
            Assert.IsNotNull(testResult1.LabelDistributionVals);

            Assert.IsTrue(testResult1.LabelDistributionVals.Length > 0);

            Console.WriteLine(testResult1.ToStringWithDetailsAsRow());
        }
        public void executeWorkflow1()
        {
            var executorParameterFile =
                @"\\protoapps\UserData\Slysz\Standard_Testing\Targeted_FeatureFinding\SIPPER_standard_testing\workflowExecutor_parameters.xml";
            WorkflowExecutorBaseParameters executorParameters = new LcmsFeatureTargetedWorkflowExecutorParameters();

            executorParameters.LoadParameters(executorParameterFile);

            var testDatasetPath = FileRefs.SipperRawDataFile;
            var testDatasetName = "Yellow_C13_070_23Mar10_Griffin_10-01-28";

            var expectedResultsFilename = executorParameters.OutputFolderBase + "\\Results" + "\\" + testDatasetName + "_results.txt";

            if (File.Exists(expectedResultsFilename))
            {
                File.Delete(expectedResultsFilename);
            }


            TargetedWorkflowExecutor executor = new LcmsFeatureTargetedWorkflowExecutor(executorParameters, testDatasetPath);

            executor.Execute();

            Assert.IsTrue(File.Exists(expectedResultsFilename));

            var importer   = new SipperResultFromTextImporter(expectedResultsFilename);
            var repository = importer.Import();

            Assert.AreEqual(9, repository.Results.Count);

            var result1 = repository.Results[2];

            Assert.AreEqual(8586, result1.TargetID);
            Assert.AreEqual(2, result1.ChargeState);
            Assert.AreEqual(6512, result1.ScanLC);
            Assert.AreEqual(1543.82565m, (decimal)Math.Round(result1.MonoMass, 5));
        }
        public void LoadResults(string resultFile)
        {
            _resultRepositorySource.Results.Clear();

            FileInfo fileInfo = new FileInfo(resultFile);

            if (fileInfo.Exists)
            {
                SipperResultFromTextImporter importer = new SipperResultFromTextImporter(resultFile);
                var tempResults = importer.Import();

                _resultRepositorySource.Results.AddRange(tempResults.Results);
            }

            SetResults(_resultRepositorySource.Results);
        }
        public void process_test1()
        {
            AutoprocessorViewModel viewModel=new AutoprocessorViewModel();

            // Instrument data file
            string testRawDataFile =
                @"\\protoapps\UserData\Slysz\Standard_Testing\Targeted_FeatureFinding\SIPPER_standard_testing\Yellow_C13_070_23Mar10_Griffin_10-01-28.raw";

            string expectedResultsFile = Path.GetDirectoryName(testRawDataFile) + "\\Results\\" +
                                         RunUtilities.GetDatasetName(testRawDataFile) + "_results.txt";

            if (File.Exists(expectedResultsFile)) File.Delete(expectedResultsFile);

            // Parameter file
            string testWorkflowFile =
                @"\\protoapps\UserData\Slysz\Standard_Testing\Targeted_FeatureFinding\SIPPER_standard_testing\SipperTargetedWorkflowParameters1.xml";

            // Targets file
            string testTargetFile1 =
                @"\\protoapps\UserData\Slysz\Standard_Testing\Targeted_FeatureFinding\SIPPER_standard_testing\Yellow_C13_070_23Mar10_Griffin_10-01-28_testing_results.txt";

            viewModel.FileInputs.CreateFileLinkage(testRawDataFile);
            viewModel.FileInputs.CreateFileLinkage(testTargetFile1);
            viewModel.FileInputs.CreateFileLinkage(testWorkflowFile);

            viewModel.Execute();

            Thread.Sleep(12000);   // the viewModel has a background worker and we need to pause to let the processing complete in the background

            Assert.That(File.Exists(expectedResultsFile));
            SipperResultFromTextImporter importer = new SipperResultFromTextImporter(expectedResultsFile);
            var resultRepo = importer.Import();

            Assert.AreEqual(19, resultRepo.Results.Count);

            var testResult = (DeconTools.Workflows.Backend.Results.SipperLcmsFeatureTargetedResultDTO)resultRepo.Results[1];
            Assert.AreEqual("Yellow_C13_070_23Mar10_Griffin_10-01-28", testResult.DatasetName);
            Assert.AreEqual(7585, testResult.TargetID);
            Assert.AreEqual("C63H109N17O21", testResult.EmpiricalFormula);
            Assert.AreEqual(11805, testResult.ScanLC);
        }
        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 LoadUnlabeledResults(string filePath)
 {
     SipperResultFromTextImporter importer = new SipperResultFromTextImporter(filePath);
     UnlabeledResults = (from SipperLcmsFeatureTargetedResultDTO n in importer.Import().Results select n).ToList();
 }