protected override void UpdateResultWithChromPeakAndLCScanInfo(TargetedResultBase result, ChromPeak bestPeak)
{
var uimfRun = result.Run as UIMFRun;
result.ChromPeakSelected = bestPeak;
result.ScanSet = new ScanSet(uimfRun.CurrentScanSet.PrimaryScanNumber);
}
public static void writeStandardInfoToResult(TargetedResultDTO tr, TargetedResultBase result)
{
if (result.Target == null)
{
throw new ArgumentNullException("Cannot create result object. MassTag is null.");
}
if (result.Run == null)
{
throw new ArgumentNullException("Cannot create result object. Run is null.");
}
tr.DatasetName = result.Run.DatasetName;
tr.TargetID = result.Target.ID;
tr.ChargeState = result.Target.ChargeState;
tr.NumMSScansSummed = result.NumMSScansSummed;
tr.EmpiricalFormula = result.Target.EmpiricalFormula;
tr.Code = result.Target.Code;
tr.IndexOfMostAbundantPeak = result.IsotopicProfile == null ? (short)0 : (short)result.IsotopicProfile.GetIndexOfMostIntensePeak();
tr.Intensity = result.IsotopicProfile == null ? 0f : (float)result.IntensityAggregate;
tr.IntensityI0 = result.IsotopicProfile == null ? 0f : (float)result.IsotopicProfile.GetMonoAbundance();
tr.IntensityMostAbundantPeak = result.IsotopicProfile == null ? 0f : (float)result.IsotopicProfile.getMostIntensePeak().Height;
tr.IScore = (float)result.InterferenceScore;
tr.MonoMass = result.IsotopicProfile == null ? result.Target.MonoIsotopicMass : result.IsotopicProfile.MonoIsotopicMass;
tr.MonoMZ = result.IsotopicProfile == null ? result.Target.MZ : result.IsotopicProfile.MonoPeakMZ;
tr.MonoMassCalibrated = result.MonoIsotopicMassCalibrated;
tr.MassErrorBeforeCalibration = result.MassErrorBeforeAlignment;
tr.MassErrorAfterCalibration = result.MassErrorAfterAlignment;
tr.ScanLC = result.GetScanNum();
tr.NET = (float)result.GetNET();
tr.NETError = result.Target.NormalizedElutionTime - tr.NET;
tr.NumChromPeaksWithinTol = result.NumChromPeaksWithinTolerance;
tr.NumQualityChromPeaksWithinTol = result.NumQualityChromPeaks;
tr.FitScore = (float)result.Score;
if (result.ChromPeakSelected != null)
{
var sigma = result.ChromPeakSelected.Width / 2.35;
tr.ScanLCStart = (int)Math.Round(result.ChromPeakSelected.XValue - sigma);
tr.ScanLCEnd = (int)Math.Round(result.ChromPeakSelected.XValue + sigma);
}
if (result.FailedResult)
{
tr.FailureType = result.FailureType.ToString();
}
tr.ErrorDescription = result.ErrorDescription ?? "";
}
//public override void FindFeature(DeconTools.Backend.Core.ResultCollection resultColl)
//{
// resultColl.ResultType = Globals.ResultType.O16O18_MASSTAG_RESULT;
// MassTagResultBase result = resultColl.GetMassTagResult(resultColl.Run.CurrentMassTag);
// if (result == null)
// {
// result = resultColl.CreateMassTagResult(resultColl.Run.CurrentMassTag);
// }
// if (result.ScanSet == null)
// {
// result.ScanSet = resultColl.Run.CurrentScanSet;
// }
// result.IsotopicProfile = m_featureFinder.FindFeature(resultColl.Run.PeakList, this.TheorFeature, this.ToleranceInPPM, this.NeedMonoIsotopicPeak);
// addInfoToResult(result);
//}
private void addInfoToResult(TargetedResultBase result)
{
if (result.IsotopicProfile != null)
{
result.IsotopicProfile.ChargeState = result.Target.ChargeState;
result.IsotopicProfile.MonoIsotopicMass = (result.IsotopicProfile.GetMZ() - Globals.PROTON_MASS) * result.Target.ChargeState;
result.IntensityAggregate = result.IsotopicProfile.getMostIntensePeak().Height; // may need to change this to sum the top n peaks.
}
((O16O18TargetedResultObject)result).RatioO16O18 = m_quantifier.GetAdjusted_I0_I4_YeoRatio(result.IsotopicProfile, result.Target.IsotopicProfile);
//((O16O18_TResult)result).RatioO16O18 = m_quantifier.Get_I0_I4_ratio(result.IsotopicProfile);
}
public static TargetedResultDTO CreateTargetedResult(TargetedResultBase result)
{
TargetedResultDTO tr;
if (result is MassTagResult)
{
tr = new UnlabelledTargetedResultDTO();
writeStandardInfoToResult(tr, result);
addAdditionalInfo(tr, result as MassTagResult);
}
else if (result is O16O18TargetedResultObject)
{
tr = new O16O18TargetedResultDTO();
writeStandardInfoToResult(tr, result);
addAdditionalInfo(tr, result as O16O18TargetedResultObject);
}
else if (result is N14N15_TResult)
{
tr = new N14N15TargetedResultDTO();
writeStandardInfoToResult(tr, result);
addAdditionalInfo(tr, result as N14N15_TResult);
}
else if (result is SipperLcmsTargetedResult)
{
tr = new SipperLcmsFeatureTargetedResultDTO();
writeStandardInfoToResult(tr, result);
addAdditionalInfo(tr, result as SipperLcmsTargetedResult);
}
else if (result is TopDownTargetedResult)
{
tr = new TopDownTargetedResultDTO();
writeStandardInfoToResult(tr, result);
addAdditionalInfo(tr, result as TopDownTargetedResult);
}
else if (result is DeuteratedTargetedResultObject)
{
tr = new DeuteratedTargetedResultDTO();
writeStandardInfoToResult(tr, result);
addAdditionalInfo(tr, result as DeuteratedTargetedResultObject);
}
else
{
throw new NotImplementedException();
}
return(tr);
}
public override ChromCorrelationData CorrelateData(Run run, TargetedResultBase result, int startScan, int stopScan)
{
var chromCorrData = CorrelateO16O18Profiles(run, result.IsotopicProfile, startScan, stopScan);
if (result is O16O18TargetedResultObject o16O18Result)
{
if (chromCorrData.CorrelationDataItems.Any())
{
o16O18Result.ChromCorrO16O18SingleLabel = chromCorrData.CorrelationDataItems[0].CorrelationRSquaredVal;
o16O18Result.ChromCorrO16O18DoubleLabel = chromCorrData.CorrelationDataItems[1].CorrelationRSquaredVal;
}
}
return(chromCorrData);
}
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);
}
private bool resultPassesCriteria(TargetedResultBase result)
{
var passesCriteria = true;
if (result.FailedResult)
{
return(false);
}
if (result.ChromPeakSelected == null)
{
return(false);
}
if (result.IsotopicProfile == null)
{
return(false);
}
if (result.NumQualityChromPeaks > AlignerParameters.NumChromPeaksAllowedDuringSelection)
{
return(false);
}
if (result.Flags.Count > 0)
{
return(false);
}
if (result.ChromPeakSelected.Height < AlignerParameters.MinimumChromPeakIntensityCriteria)
{
return(false);
}
if (result.Score > AlignerParameters.UpperFitScoreAllowedCriteria)
{
return(false);
}
if (result.InterferenceScore > AlignerParameters.IScoreAllowedCriteria)
{
return(false);
}
return(passesCriteria);
}
private void AddFeatureToResult(TargetedResultBase result, IsotopicProfile iso)
{
//TODO: the IsotopicProfileType is wrong...
switch (IsotopicProfileType)
{
case Globals.IsotopicProfileType.UNLABELED:
result.IsotopicProfile = iso;
break;
case Globals.IsotopicProfileType.LABELED:
result.AddLabeledIso(iso);
break;
default:
result.IsotopicProfile = iso;
break;
}
}
protected void AddScoresToPeakQualityData(ChromPeakQualityData pq, TargetedResultBase currentResult)
{
if (currentResult.IsotopicProfile == null)
{
pq.IsotopicProfileFound = false;
return;
}
else
{
pq.IsotopicProfileFound = true;
pq.Abundance = currentResult.IntensityAggregate;
pq.FitScore = currentResult.Score;
pq.InterferenceScore = currentResult.InterferenceScore;
pq.IsotopicProfile = currentResult.IsotopicProfile;
var resultHasFlags = (currentResult.Flags != null && currentResult.Flags.Count > 0);
pq.IsIsotopicProfileFlagged = resultHasFlags;
pq.ScanLc = currentResult.Run.CurrentScanSet.PrimaryScanNumber;
}
}
private void ApplyMassCalibration(TargetedResultBase result)
{
Result.MonoIsotopicMassCalibrated = Result.GetCalibratedMonoisotopicMass();
Result.MassErrorBeforeAlignment = Result.GetMassErrorBeforeAlignmentInPPM();
Result.MassErrorAfterAlignment = Result.GetMassErrorAfterAlignmentInPPM();
}
public override void Execute(ResultCollection resultList)
{
Check.Require(resultList.Run.CurrentMassTag != null, this.Name + " failed. MassTag was not defined.");
TargetedResultBase currentResult = resultList.GetTargetedResult(resultList.Run.CurrentMassTag);
if (msgen == null)
{
msgen = MSGeneratorFactory.CreateMSGenerator(resultList.Run.MSFileType);
msgen.IsTICRequested = false;
}
TargetBase currentTarget = resultList.Run.CurrentMassTag;
// Set the MS Generator to use a window around the target so that we do not grab a lot of unecessary data from the UIMF file
List <MSPeak> theoIsotopicPeakList = currentTarget.IsotopicProfile.Peaklist.Where(x => x.Height > 0.1).OrderBy(x => x.XValue).ToList();
msgen.MinMZ = theoIsotopicPeakList[0].XValue - 1.1;
msgen.MaxMZ = theoIsotopicPeakList[theoIsotopicPeakList.Count - 1].XValue + 1.1;
float normalizedElutionTime;
if (currentResult.Run.CurrentMassTag.ElutionTimeUnit == Globals.ElutionTimeUnit.ScanNum)
{
normalizedElutionTime = resultList.Run.CurrentMassTag.ScanLCTarget / (float)currentResult.Run.GetNumMSScans();
}
else
{
normalizedElutionTime = resultList.Run.CurrentMassTag.NormalizedElutionTime;
}
//collect Chrom peaks that fall within the NET tolerance
List <ChromPeak> peaksWithinTol = new List <ChromPeak>(); //
foreach (ChromPeak peak in resultList.Run.PeakList)
{
if (Math.Abs(peak.NETValue - normalizedElutionTime) <= Parameters.NETTolerance) //peak.NETValue was determined by the ChromPeakDetector or a future ChromAligner Task
{
peaksWithinTol.Add(peak);
}
}
List <ChromPeakQualityData> peakQualityList = new List <ChromPeakQualityData>();
//iterate over peaks within tolerance and score each peak according to MSFeature quality
#if DEBUG
int tempMinScanWithinTol = resultList.Run.GetScanValueForNET(normalizedElutionTime - Parameters.NETTolerance);
int tempMaxScanWithinTol = resultList.Run.GetScanValueForNET(normalizedElutionTime + Parameters.NETTolerance);
int tempCenterTol = resultList.Run.GetScanValueForNET(normalizedElutionTime);
Console.WriteLine("SmartPeakSelector --> NETTolerance= " + Parameters.NETTolerance + "; chromMinCenterMax= " + tempMinScanWithinTol + "\t" + tempCenterTol + "" +
"\t" + tempMaxScanWithinTol);
Console.WriteLine("MT= " + currentResult.Target.ID + ";z= " + currentResult.Target.ChargeState + "; mz= " + currentResult.Target.MZ.ToString("0.000") + "; ------------------------- PeaksWithinTol = " + peaksWithinTol.Count);
#endif
currentResult.NumChromPeaksWithinTolerance = peaksWithinTol.Count;
currentResult.NumQualityChromPeaks = -1;
ChromPeak bestChromPeak;
if (currentResult.NumChromPeaksWithinTolerance > _parameters.NumChromPeaksAllowed)
{
bestChromPeak = null;
}
else
{
foreach (var chromPeak in peaksWithinTol)
{
ChromPeakQualityData pq = new ChromPeakQualityData(chromPeak);
peakQualityList.Add(pq);
// TODO: Currently hard-coded to sum only 1 scan
SetScansForMSGenerator(chromPeak, resultList.Run, 1);
//This resets the flags and the scores on a given result
currentResult.ResetResult();
//generate a mass spectrum
msgen.Execute(resultList);
//find isotopic profile
TargetedMSFeatureFinder.Execute(resultList);
//get fit score
fitScoreCalc.Execute(resultList);
//get i_score
resultValidator.Execute(resultList);
//collect the results together
AddScoresToPeakQualityData(pq, currentResult);
#if DEBUG
pq.Display();
#endif
}
//run a algorithm that decides, based on fit score mostly.
bestChromPeak = determineBestChromPeak(peakQualityList, currentResult);
}
currentResult.ChromPeakQualityList = peakQualityList;
SetScansForMSGenerator(bestChromPeak, resultList.Run, Parameters.NumScansToSum);
UpdateResultWithChromPeakAndLCScanInfo(currentResult, bestChromPeak);
}
public void AddResult(TargetedResultBase resultToConvert)
{
var result = ResultDTOFactory.CreateTargetedResult(resultToConvert);
this.Results.Add(result);
}
public abstract ChromCorrelationData CorrelateData(Run run, TargetedResultBase result, int startScan, int stopScan);
protected virtual void UpdateResultWithChromPeakAndLCScanInfo(TargetedResultBase result, ChromPeak bestPeak)
{
result.AddSelectedChromPeakAndScanSet(bestPeak, result.Run.CurrentScanSet, IsotopicProfileType);
result.WasPreviouslyProcessed = true; //indicate that this result has been added to... use this to help control the addition of labelled (N15) data
}
protected virtual ChromPeak determineBestChromPeak(List <ChromPeakQualityData> peakQualityList, TargetedResultBase currentResult)
{
//flagging algorithm checks for peak-to-the-left. This is ok for peptides whose first isotope
//is most abundant, but not good for large peptides in which the mono peak is of lower intensity.
var goodToFilterOnFlaggedIsotopicProfiles = currentResult.Target.IsotopicProfile.GetIndexOfMostIntensePeak() < 5;
var filteredList1 = (from n in peakQualityList
where n.IsotopicProfileFound &&
n.FitScore < 1 && n.InterferenceScore < 1
select n).ToList();
if (goodToFilterOnFlaggedIsotopicProfiles)
{
filteredList1 = filteredList1.Where(p => p.IsIsotopicProfileFlagged == false).ToList();
}
ChromPeak bestpeak;
currentResult.NumQualityChromPeaks = filteredList1.Count;
if (filteredList1.Count == 0)
{
bestpeak = null;
currentResult.FailedResult = true;
currentResult.FailureType = DeconTools.Backend.Globals.TargetedResultFailureType.ChrompeakNotFoundWithinTolerances;
}
else if (filteredList1.Count == 1)
{
bestpeak = filteredList1[0].Peak;
}
else
{
filteredList1 = filteredList1.OrderBy(p => p.FitScore).ToList();
var numCandidatesWithLowFitScores = filteredList1.Count(p => p.FitScore < _parameters.UpperLimitOfGoodFitScore);
currentResult.NumQualityChromPeaks = numCandidatesWithLowFitScores;
var diffFirstAndSecondFitScores = Math.Abs(filteredList1[0].FitScore - filteredList1[1].FitScore);
var differenceIsSmall = (diffFirstAndSecondFitScores < 0.05);
if (differenceIsSmall)
{
if (_parameters.MultipleHighQualityMatchesAreAllowed)
{
if (filteredList1[0].Abundance >= filteredList1[1].Abundance)
{
bestpeak = filteredList1[0].Peak;
}
else
{
bestpeak = filteredList1[1].Peak;
}
}
else
{
bestpeak = null;
currentResult.FailedResult = true;
currentResult.FailureType = DeconTools.Backend.Globals.TargetedResultFailureType.TooManyHighQualityChrompeaks;
}
}
else
{
bestpeak = filteredList1[0].Peak;
}
}
return(bestpeak);
}
protected virtual ChromPeak determineBestChromPeak(List <ChromPeakQualityData> peakQualityList, TargetedResultBase currentResult)
{
var filteredList1 = (from n in peakQualityList
where n.IsotopicProfileFound == true &&
n.FitScore < 1 && n.InterferenceScore < 1
select n).ToList();
ChromPeak bestpeak;
currentResult.NumQualityChromPeaks = filteredList1.Count;
if (filteredList1.Count == 0)
{
bestpeak = null;
currentResult.FailedResult = true;
currentResult.FailureType = DeconTools.Backend.Globals.TargetedResultFailureType.ChrompeakNotFoundWithinTolerances;
}
else if (filteredList1.Count == 1)
{
bestpeak = filteredList1[0].Peak;
}
else
{
filteredList1 = filteredList1.OrderBy(p => p.FitScore).ToList();
var diffFirstAndSecondFitScores = Math.Abs(filteredList1[0].FitScore - filteredList1[1].FitScore);
var differenceIsSmall = (diffFirstAndSecondFitScores < 0.05);
if (differenceIsSmall)
{
if (_parameters.MultipleHighQualityMatchesAreAllowed)
{
if (filteredList1[0].Abundance >= filteredList1[1].Abundance)
{
bestpeak = filteredList1[0].Peak;
}
else
{
bestpeak = filteredList1[1].Peak;
}
}
else
{
bestpeak = null;
currentResult.FailedResult = true;
currentResult.FailureType = DeconTools.Backend.Globals.TargetedResultFailureType.TooManyHighQualityChrompeaks;
}
}
else
{
bestpeak = filteredList1[0].Peak;
}
}
// If any of the peaks were good, then we want to make sure to not consider the result an error.
// I added this because if the last peak checked had an error, the entire result was still flagged as having an error.
if (bestpeak != null)
{
currentResult.FailedResult = false;
currentResult.FailureType = DeconTools.Backend.Globals.TargetedResultFailureType.None;
}
return(bestpeak);
}
public static void CreateTargetedResult(TargetedResultBase result, TargetedResultDTO resultLight)
{
writeStandardInfoToResult(resultLight, result);
}
public override ChromCorrelationData CorrelateData(Run run, TargetedResultBase result, int startScan, int stopScan)
{
{
return(CorrelatePeaksWithinIsotopicProfile(run, result.IsotopicProfile, startScan, stopScan));
}
}
