/// <summary>
/// Initializes a new instance of the <see cref="DriftTimeTarget"/> class with H+ as default
/// ionization, which is a default for peptides.
/// </summary>
/// <param name="libraryEntryName">
/// The library Entry Name.
/// </param>
/// <param name="normalizedDriftTimeInMs">
/// The drift time.
/// </param>
/// <param name="peptide">
/// The peptide.
/// </param>
/// <param name="chargeState">
/// The charge State.
/// </param>
public DriftTimeTarget(string libraryEntryName, double normalizedDriftTimeInMs, PeptideTarget peptide, int chargeState = 1)
: base(peptide.EmpiricalFormula, IonizationMethod.Protonated, libraryEntryName, chargeState)
{
peptide.DriftTimeTargetList.Add(this);
this.NormalizedDriftTimeInMs = normalizedDriftTimeInMs;
this.TargetType = TargetType.MoleculeWithKnownDriftTime;
}
public void AppendResultsOfTargetToCsv(PeptideTarget target)
{
string modificationString = "";
foreach (var modification in target.ModificationList)
{
modificationString += modification.Name + ":" + modification.AccessionNum + ";";
}
StringBuilder peptideInfo = new StringBuilder();
peptideInfo.Append(target.ID + ",");
peptideInfo.Append(target.PeptideSequence + ",");
peptideInfo.Append(modificationString + ","); // TODO: Mods
peptideInfo.Append(target.EmpiricalFormula + ",");
peptideInfo.Append(target.MonoisotopicMass + ",");
double targetElutionTime = target.NormalizedElutionTime;
foreach (LcImsTargetResult result in target.ResultList)
{
int chargeState = result.ChargeState;
IEnumerable<DriftTimeTarget> possibleDriftTimeTargets = target.DriftTimeTargetList.Where(x => x.ChargeState == chargeState).OrderBy(x => Math.Abs(x.NormalizedDriftTimeInMs - result.DriftTime));
double targetDriftTime = 0;
double driftTimeError = 0;
if (possibleDriftTimeTargets.Any())
{
DriftTimeTarget driftTimeTarget = possibleDriftTimeTargets.First();
targetDriftTime = driftTimeTarget.NormalizedDriftTimeInMs;
driftTimeError = result.DriftTime - targetDriftTime;
}
double observedMz = result.IsotopicProfile != null ? result.IsotopicProfile.MonoPeakMZ : 0;
double abundance = result.IsotopicProfile != null ? result.IsotopicProfile.GetAbundance() : 0;
double elutionTimeError = result.NormalizedElutionTime - targetElutionTime;
double correlationAverage = 0;
StringBuilder resultInfo = new StringBuilder();
resultInfo.Append(result.ChargeState + ",");
resultInfo.Append(observedMz + ",");
resultInfo.Append(result.PpmError + ",");
resultInfo.Append(result.ScanLcRep + ",");
resultInfo.Append(result.IsotopicFitScore + ",");
resultInfo.Append(abundance + ",");
resultInfo.Append(targetElutionTime + ",");
resultInfo.Append(result.NormalizedElutionTime + ",");
resultInfo.Append(elutionTimeError + ",");
resultInfo.Append(targetDriftTime + ",");
resultInfo.Append(result.DriftTime + ",");
resultInfo.Append(driftTimeError + ",");
resultInfo.Append(correlationAverage + ",");
resultInfo.Append(result.AnalysisStatus.ToString());
this.TextWriter.WriteLine(peptideInfo.ToString() + resultInfo.ToString());
}
}
public void TestVerySaturatedPeptide()
{
string uimfFileLocation = Cheetah;
LcImsPeptideSearchParameters parameters = new LcImsPeptideSearchParameters
{
ChargeStateMax = 2,
NetTolerance = 0.03,
IsotopicFitScoreThreshold = 0.15,
MassToleranceInPpm = 30,
NumPointForSmoothing = 9
};
string peptide = "NFPSPVDAAFR";
double net = 0.45;
PeptideTarget target = new PeptideTarget(1, peptide, net);
LcImsPeptideSearchWorkfow lcImsPeptideSearchWorkfow = new LcImsPeptideSearchWorkfow(uimfFileLocation, parameters);
lcImsPeptideSearchWorkfow.RunInformedWorkflow(target);
}
public void TestSinglePeptideDidNotFind()
{
string uimfFileLocation = Cheetah;
//string netAlignmentFileLocation = @"..\..\..\testFiles\Sarc_MS2_90_6Apr11_Cheetah_11-02-19_NetAlign.csv";
//IInterpolation interpolation = AlignmentImporter.ReadFile(netAlignmentFileLocation);
LcImsPeptideSearchParameters parameters = new LcImsPeptideSearchParameters
{
ChargeStateMax = 5,
NetTolerance = 0.2,
IsotopicFitScoreThreshold = 0.15,
MassToleranceInPpm = 30,
NumPointForSmoothing = 9
};
string peptide = "TILDDLRAEDHFSVIDFNQNIR";
double net = 0.48228999972343445;
List<Modification> modificationList = new List<Modification>();
//modificationList.Add(Modification.Oxidation);
//modificationList.Add(Modification.Carbamidomethylation);
//modificationList.Add(Modification.Carbamidomethylation);
PeptideTarget target = new PeptideTarget(1, peptide, net, modificationList);
LcImsPeptideSearchWorkfow lcImsPeptideSearchWorkfow = new LcImsPeptideSearchWorkfow(uimfFileLocation, parameters, null);
var correlationResult = lcImsPeptideSearchWorkfow.RunInformedWorkflow(target);
Console.WriteLine(correlationResult.ReferenceLcImsTargetResult.NormalizedElutionTime);
}
public void TestSinglePeptide2()
{
string uimfFileLocation = Cheetah;
LcImsPeptideSearchParameters parameters = new LcImsPeptideSearchParameters
{
ChargeStateMax = 5,
NetTolerance = 0.2,
IsotopicFitScoreThreshold = 0.15,
MassToleranceInPpm = 30,
NumPointForSmoothing = 9
};
string peptide = "ATVLNYLPK";
double net = 0.3612;
PeptideTarget target = new PeptideTarget(1, peptide, net);
DriftTimeTarget driftTimeTarget = new DriftTimeTarget("Test Target", 19.62, target, 2);
target.DriftTimeTargetList.Add(driftTimeTarget);
LcImsPeptideSearchWorkfow lcImsPeptideSearchWorkfow = new LcImsPeptideSearchWorkfow(uimfFileLocation, parameters);
ChargeStateCorrelationResult correlationResult = lcImsPeptideSearchWorkfow.RunInformedWorkflow(target);
using (ImsTargetResultExporter resultsExporter = new ImsTargetResultExporter("outputSingle.csv"))
{
if (correlationResult != null) resultsExporter.AppendCorrelationResultToCsv(correlationResult);
}
}
public void TestSinglePeptide()
{
string uimfFileLocation = Cheetah;
LcImsPeptideSearchParameters parameters = new LcImsPeptideSearchParameters
{
ChargeStateMax = 5,
NetTolerance = 0.1,
IsotopicFitScoreThreshold = 0.15,
MassToleranceInPpm = 30,
ScanWindowWidth = 4,
NumPointForSmoothing = 9
};
string peptide = "DGWHSWPIAHQWPQGPSAVDAAFSWEEK";
double net = 0.4832;
PeptideTarget target = new PeptideTarget(1, peptide, net);
LcImsPeptideSearchWorkfow lcImsPeptideSearchWorkfow = new LcImsPeptideSearchWorkfow(uimfFileLocation, parameters);
lcImsPeptideSearchWorkfow.RunInformedWorkflow(target);
}
public void TestInterestingPeptideThatHasOverlappingInterferenceTowardsEndOfElution()
{
string uimfFileLocation = @"..\..\..\testFiles\Sarc_MS2_90_6Apr11_Cheetah_11-02-19.uimf";
string netAlignmentFileLocation = @"..\..\..\testFiles\Sarc_MS2_90_6Apr11_Cheetah_11-02-19_NetAlign.csv";
IInterpolation interpolation = AlignmentImporter.ReadFile(netAlignmentFileLocation);
LcImsPeptideSearchParameters parameters = new LcImsPeptideSearchParameters
{
ChargeStateMax = 5,
NetTolerance = 0.03,
IsotopicFitScoreThreshold = 0.15,
MassToleranceInPpm = 30,
NumPointForSmoothing = 9
};
string peptide = "LCHCPVGYTGPFCDVDTK";
double net = 0.3041;
List<Modification> modificationList = new List<Modification>();
//modificationList.Add(Modification.Oxidation);
modificationList.Add(Modification.Carbamidomethylation);
modificationList.Add(Modification.Carbamidomethylation);
modificationList.Add(Modification.Carbamidomethylation);
PeptideTarget target = new PeptideTarget(1, peptide, net, modificationList);
LcImsPeptideSearchWorkfow lcImsPeptideSearchWorkfow = new LcImsPeptideSearchWorkfow(uimfFileLocation, parameters, interpolation);
var correlationResult = lcImsPeptideSearchWorkfow.RunInformedWorkflow(target);
Console.WriteLine(correlationResult.ReferenceLcImsTargetResult.NormalizedElutionTime);
}
public void TestDataExtractionSpeedSingleTarget()
{
string uimfFileLocation = Cheetah;
LcImsPeptideSearchParameters parameters = new LcImsPeptideSearchParameters
{
ChargeStateMax = 5,
NetTolerance = 0.1,
IsotopicFitScoreThreshold = 0.15,
MassToleranceInPpm = 30,
NumPointForSmoothing = 9
};
string peptide = "QGHNSVFLIKGDK";
double net = 0.2493;
PeptideTarget target = new PeptideTarget(1, peptide, net);
List<PeptideTarget> targetList = new List<PeptideTarget>();
targetList.Add(target);
LcImsPeptideSearchWorkfow lcImsPeptideSearchWorkfow = new LcImsPeptideSearchWorkfow(uimfFileLocation, parameters);
lcImsPeptideSearchWorkfow.ExtractData(targetList);
}
public ChargeStateCorrelationResult(PeptideTarget imsTarget, LcImsTargetResult referenceLcImsTargetResult)
{
this.ImsTarget = imsTarget;
this.ReferenceLcImsTargetResult = referenceLcImsTargetResult;
this.CorrelationMap = new Dictionary<LcImsTargetResult, double>();
}
/// <summary>
/// The run informed workflow.
/// </summary>
/// <param name="target">
/// The Target.
/// </param>
/// <returns>
/// The <see cref="ChargeStateCorrelationResult"/>.
/// </returns>
public ChargeStateCorrelationResult RunInformedWorkflow(PeptideTarget target)
{
Composition targetComposition = target.CompositionWithoutAdduct;
double targetMass = targetComposition.Mass;
string empiricalFormula = targetComposition.ToPlainString();
double targetNet = target.NormalizedElutionTime;
double targetNetMin = targetNet - this._parameters.NetTolerance;
double targetNetMax = targetNet + this._parameters.NetTolerance;
double reverseAlignedNetMin = targetNetMin;
double reverseAlignedNetMax = targetNetMax;
if (this._netAlignment != null)
{
double reverseAlignedNet = this.GetReverseAlignedNet(targetNet);
reverseAlignedNetMin = reverseAlignedNet - this._parameters.NetTolerance;
reverseAlignedNetMax = reverseAlignedNet + this._parameters.NetTolerance;
}
int scanLcSearchMin = (int)Math.Floor(reverseAlignedNetMin * this.NumberOfFrames);
int scanLcSearchMax = (int)Math.Ceiling(reverseAlignedNetMax * this.NumberOfFrames);
int iteration = (targetComposition == null) ? 1 : this._parameters.ChargeStateMax;
for (int chargeState = 1; chargeState <= iteration; chargeState++)
{
if (targetComposition != null)
{
Ion targetIon = new Ion(targetComposition, chargeState);
target.MassWithAdduct = targetIon.GetMonoIsotopicMz();
}
double minMzForSpectrum = target.MassWithAdduct - (1.6 / chargeState);
double maxMzForSpectrum = target.MassWithAdduct + (4.6 / chargeState);
// Generate Theoretical Isotopic Profile
IsotopicProfile theoreticalIsotopicProfile = this._theoreticalFeatureGenerator.GenerateTheorProfile(empiricalFormula, chargeState);
List<Peak> theoreticalIsotopicProfilePeakList = theoreticalIsotopicProfile.Peaklist.Cast<Peak>().ToList();
// Find XIC Features
IEnumerable<FeatureBlob> featureBlobs = this.FindFeatures(target.MassWithAdduct, scanLcSearchMin, scanLcSearchMax);
// Filter away small XIC peaks
featureBlobs = FeatureDetection.FilterFeatureList(featureBlobs, 0.25);
if(!featureBlobs.Any())
{
LcImsTargetResult result = new LcImsTargetResult
{
ChargeState = chargeState,
AnalysisStatus = AnalysisStatus.XicNotFound
};
target.ResultList.Add(result);
}
// Check each XIC Peak found
foreach (var featureBlob in featureBlobs)
{
// Setup result object
LcImsTargetResult result = new LcImsTargetResult
{
ChargeState = chargeState,
AnalysisStatus = AnalysisStatus.Positive
};
target.ResultList.Add(result);
FeatureBlobStatistics statistics = featureBlob.CalculateStatistics();
int unsaturatedIsotope = 0;
FeatureBlob isotopeFeature = null;
int scanLcMin = statistics.ScanLcMin;
int scanLcMax = statistics.ScanLcMax;
int scanImsMin = statistics.ScanImsMin;
int scanImsMax = statistics.ScanImsMax;
// TODO: Verify that there are no peaks at isotope #s 0.5 and 1.5?? (If we filter on drift time, this shouldn't actually be necessary)
// Find an unsaturated peak in the isotopic profile
for (int i = 1; i < 10; i++)
{
if (!statistics.IsSaturated) break;
// Target isotope m/z
double isotopeTargetMz = (target.CompositionWithoutAdduct != null) ? new Ion(targetComposition, chargeState).GetIsotopeMz(i) : target.MassWithAdduct;
// Find XIC Features
IEnumerable<FeatureBlob> newFeatureBlobs = this.FindFeatures(isotopeTargetMz, scanLcMin - 20, scanLcMax + 20);
// If no feature, then get out
if (!newFeatureBlobs.Any())
{
statistics = null;
break;
}
bool foundFeature = false;
foreach (var newFeatureBlob in newFeatureBlobs.OrderByDescending(x => x.PointList.Count))
{
var newStatistics = newFeatureBlob.CalculateStatistics();
if(newStatistics.ScanImsRep <= scanImsMax && newStatistics.ScanImsRep >= scanImsMin && newStatistics.ScanLcRep <= scanLcMax && newStatistics.ScanLcRep >= scanLcMin)
{
isotopeFeature = newFeatureBlob;
foundFeature = true;
break;
}
}
if(!foundFeature)
{
statistics = null;
break;
}
statistics = isotopeFeature.CalculateStatistics();
unsaturatedIsotope = i;
}
// Bad Feature, so get out
if (statistics == null)
{
result.AnalysisStatus = AnalysisStatus.IsotopicProfileNotFound;
continue;
}
// TODO: Calculate accurate NET and drift time using quadratic equation
int scanLcRep = statistics.ScanLcRep + 1;
int scanImsRep = statistics.ScanImsRep;
// Calculate NET using aligned data if applicable
double net = scanLcRep / this.NumberOfFrames;
if (this._netAlignment != null)
{
net = this._netAlignment.Interpolate(net);
}
FeatureBlob featureToUseForResult = unsaturatedIsotope > 0 ? isotopeFeature : featureBlob;
// Set data to result
result.FeatureBlobStatistics = statistics;
result.IsSaturated = unsaturatedIsotope > 0;
result.ScanLcRep = statistics.ScanLcRep;
result.NormalizedElutionTime = net;
result.DriftTime = this._uimfReader.GetDriftTime(statistics.ScanLcRep, statistics.ScanImsRep, true);
result.XicFeature = featureToUseForResult;
// Don't consider bogus results
if (scanImsRep < 5 || scanImsRep > this.NumberOfScans - 5)
{
result.AnalysisStatus = AnalysisStatus.DriftTimeError;
continue;
}
// Don't consider bogus results
if (scanLcRep < 3 || scanLcRep > this.NumberOfFrames - 4)
{
result.AnalysisStatus = AnalysisStatus.ElutionTimeError;
continue;
}
// TODO: ViperCompatibleMass Alignment???
if (target.TargetType == TargetType.Peptide)
{
// Filter by NET
if (net > targetNetMax || net < targetNetMin)
{
result.AnalysisStatus = AnalysisStatus.ElutionTimeError;
continue;
}
}
//Console.WriteLine(Target.PeptideSequence + "\t" + targetMass + "\t" + targetMz + "\t" + scanLcRep);
// Get ViperCompatibleMass Spectrum Data
XYData massSpectrum = this.GetMassSpectrum(scanLcRep, scanImsRep, minMzForSpectrum, maxMzForSpectrum);
List<Peak> massSpectrumPeakList = this._peakDetector.FindPeaks(massSpectrum);
//WriteXYDataToFile(massSpectrum, targetMz);
// Find Isotopic Profile
List<Peak> massSpectrumPeaks;
IsotopicProfile observedIsotopicProfile = this._msFeatureFinder.IterativelyFindMSFeature(massSpectrum, theoreticalIsotopicProfile, out massSpectrumPeaks);
// Add data to result
result.MassSpectrum = massSpectrum;
// No need to move on if the isotopic profile is not found
if (observedIsotopicProfile == null || observedIsotopicProfile.MonoIsotopicMass < 1)
{
result.AnalysisStatus = AnalysisStatus.IsotopicProfileNotFound;
continue;
}
// Add data to result
result.IsotopicProfile = observedIsotopicProfile;
result.MonoisotopicMass = observedIsotopicProfile.MonoIsotopicMass;
result.PpmError = Math.Abs(PeptideUtil.PpmError(targetMass, observedIsotopicProfile.MonoIsotopicMass));
// If not enough peaks to reach unsaturated isotope, no need to move on
if (observedIsotopicProfile.Peaklist.Count <= unsaturatedIsotope)
{
result.AnalysisStatus = AnalysisStatus.IsotopicProfileNotFound;
continue;
}
// If the mass error is too high, then ignore
if (result.PpmError > this._parameters.MassToleranceInPpm)
{
result.AnalysisStatus = AnalysisStatus.MassError;
continue;
}
// Correct for Saturation if needed
if (unsaturatedIsotope > 0)
{
IsotopicProfileUtil.AdjustSaturatedIsotopicProfile(observedIsotopicProfile, theoreticalIsotopicProfile, unsaturatedIsotope);
}
//WriteMSPeakListToFile(observedIsotopicProfile.Peaklist, targetMz);
// TODO: This is a hack to fix an issue where the peak width is being calculated way too large which causes the leftOfMonoPeakLooker to use too wide of a tolerance
MSPeak monoPeak = observedIsotopicProfile.getMonoPeak();
if (monoPeak.Width > 0.15) monoPeak.Width = 0.15f;
// Filter out flagged results
MSPeak peakToLeft = this._leftOfMonoPeakLooker.LookforPeakToTheLeftOfMonoPeak(monoPeak, observedIsotopicProfile.ChargeState, massSpectrumPeaks);
if (peakToLeft != null)
{
result.AnalysisStatus = AnalysisStatus.PeakToLeft;
continue;
}
double isotopicFitScore;
// Calculate isotopic fit score
if(unsaturatedIsotope > 0)
{
int unsaturatedScanLc = this.FindFrameNumberUseForIsotopicProfile(target.MassWithAdduct, scanLcRep, scanImsRep);
if (unsaturatedScanLc > 0)
{
// Use the unsaturated profile if we were able to get one
XYData unsaturatedMassSpectrum = this.GetMassSpectrum(unsaturatedScanLc, scanImsRep, minMzForSpectrum, maxMzForSpectrum);
//WriteXYDataToFile(unsaturatedMassSpectrum, targetMz);
List<Peak> unsaturatedMassSpectrumPeakList = this._peakDetector.FindPeaks(unsaturatedMassSpectrum);
isotopicFitScore = this._isotopicPeakFitScoreCalculator.GetFit(theoreticalIsotopicProfilePeakList, unsaturatedMassSpectrumPeakList, 0.15, this._parameters.MassToleranceInPpm);
}
else
{
// Use the saturated profile
isotopicFitScore = this._isotopicPeakFitScoreCalculator.GetFit(theoreticalIsotopicProfilePeakList, massSpectrumPeakList, 0.15, this._parameters.MassToleranceInPpm);
}
}
else
{
isotopicFitScore = this._isotopicPeakFitScoreCalculator.GetFit(theoreticalIsotopicProfilePeakList, massSpectrumPeakList, 0.15, this._parameters.MassToleranceInPpm);
}
// Add data to result
result.IsotopicFitScore = isotopicFitScore;
// Filter out bad isotopic fit scores
if (isotopicFitScore > this._parameters.IsotopicFitScoreThreshold && unsaturatedIsotope == 0)
{
result.AnalysisStatus = AnalysisStatus.IsotopicFitScoreError;
continue;
}
Console.WriteLine(chargeState + "\t" + unsaturatedIsotope + "\t" + statistics.ScanLcMin + "\t" + statistics.ScanLcMax + "\t" + statistics.ScanLcRep + "\t" + statistics.ScanImsMin + "\t" + statistics.ScanImsMax + "\t" + statistics.ScanImsRep + "\t" + isotopicFitScore.ToString("0.0000") + "\t" + result.NormalizedElutionTime.ToString("0.0000") + "\t" + result.DriftTime.ToString("0.0000"));
}
// TODO: Isotope Correlation (probably not going to do because of saturation issues)
}
// Charge State Correlation (use first unsaturated XIC feature)
List<ChargeStateCorrelationResult> chargeStateCorrelationResultList = new List<ChargeStateCorrelationResult>();
ChargeStateCorrelationResult bestCorrelationResult = null;
double bestCorrelationSum = -1;
List<LcImsTargetResult> resultList = target.ResultList.Where(x => x.AnalysisStatus == AnalysisStatus.Positive).OrderBy(x => x.IsotopicFitScore).ToList();
int numResults = resultList.Count;
for (int i = 0; i < numResults; i++)
{
LcImsTargetResult referenceResult = resultList[i];
ChargeStateCorrelationResult chargeStateCorrelationResult = new ChargeStateCorrelationResult(target, referenceResult);
chargeStateCorrelationResultList.Add(chargeStateCorrelationResult);
for (int j = i + 1; j < numResults; j++)
{
LcImsTargetResult testResult = resultList[j];
double correlation = FeatureCorrelator.CorrelateFeaturesUsingLc(referenceResult.XicFeature, testResult.XicFeature);
chargeStateCorrelationResult.CorrelationMap.Add(testResult, correlation);
Console.WriteLine(referenceResult.FeatureBlobStatistics.ScanLcRep + "\t" + referenceResult.FeatureBlobStatistics.ScanImsRep + "\t" + testResult.FeatureBlobStatistics.ScanLcRep + "\t" + testResult.FeatureBlobStatistics.ScanImsRep + "\t" + correlation);
}
List<LcImsTargetResult> possibleBestResultList;
double correlationSum = chargeStateCorrelationResult.GetBestCorrelation(out possibleBestResultList);
if(correlationSum > bestCorrelationSum)
{
bestCorrelationSum = correlationSum;
bestCorrelationResult = chargeStateCorrelationResult;
}
}
// TODO: Score Target
// TODO: Quantify Target (return isotopic profile abundance)
return bestCorrelationResult;
}
public bool Equals(PeptideTarget other)
{
return MoleculeUtil.AreCompositionsEqual(this.CompositionWithAdduct, other.CompositionWithAdduct) &&
this.NormalizedElutionTime == other.NormalizedElutionTime &&
this.TargetDescriptor == other.TargetDescriptor &&
this.PeptideSequence == other.PeptideSequence;
}
public static List<PeptideTarget> ImportMassTags(string serverName, string databaseName, double maxMsgfSpecProb = 1e-10, bool isForCalibration = false)
{
List<PeptideTarget> targetList = new List<PeptideTarget>();
// Build connection string
string connectionString = BuildConnectionString(serverName, databaseName);
// Using connection
var dbFactory = DbProviderFactories.GetFactory("System.Data.SqlClient");
using (var connection = dbFactory.CreateConnection())
{
connection.ConnectionString = connectionString;
connection.Open();
// Execute query
string queryString = isForCalibration ? GetQueryForCalibration() : GetQuery();
using (DbCommand command = connection.CreateCommand())
{
command.CommandText = queryString;
command.CommandTimeout = 120;
DbDataReader reader = command.ExecuteReader();
PeptideTarget currentImsTarget = null;
while (reader.Read())
{
int massTagId = Convert.ToInt32(reader["Mass_Tag_ID"]);
string peptide = Convert.ToString(reader["peptide"]);
double normalizedElutionTime = Convert.ToDouble(reader["Avg_GANET"]);
int modCount = Convert.ToInt16(reader["Mod_Count"]);
List<Modification> modificationList = new List<Modification>();
if(modCount > 0)
{
string modificationString = Convert.ToString(reader["Mod_Description"]);
string[] splitModString = modificationString.Split(',');
foreach (var singleModString in splitModString)
{
string modificationName = singleModString.Split(':')[0];
Modification modification = _dmsModToInformedModMap[modificationName];
modificationList.Add(modification);
}
}
bool isSameTarget = IsSameTarget(currentImsTarget, peptide, normalizedElutionTime, modificationList);
if(!isSameTarget)
{
currentImsTarget = new PeptideTarget(massTagId, peptide, normalizedElutionTime, modificationList);
targetList.Add(currentImsTarget);
}
int chargeState = Convert.ToInt16(reader["Conformer_Charge"]);
double driftTime = Convert.ToDouble(reader["Drift_Time_Avg"]);
DriftTimeTarget driftTimeTarget = new DriftTimeTarget(massTagId.ToString(CultureInfo.InvariantCulture), driftTime, currentImsTarget.EmpiricalFormula, new IonizationAdduct(chargeState));
currentImsTarget.DriftTimeTargetList.Add(driftTimeTarget);
}
}
}
return targetList;
}
public static bool IsSameTarget(PeptideTarget currentImsTarget, string peptide, double normalizedElutionTime, List<Modification> modificationList)
{
int modCount = modificationList.Count;
if (currentImsTarget != null)
{
if (currentImsTarget.PeptideSequence == peptide && Math.Abs(currentImsTarget.NormalizedElutionTime - normalizedElutionTime) < 0.00001)
{
if (modCount == currentImsTarget.ModificationList.Count)
{
if (modCount == 0) return true;
else
{
if (currentImsTarget.ModificationList[0] == modificationList[0]) return true;
}
}
}
}
return false;
}
