public static GraphML_List <Precursor> GetIsotopes(Track track, DBOptions dbOptions, Tracks listTracks, Sample entry)
{
double isotopicMzTolerance = dbOptions.precursorMassTolerance.Value * 0.5;
if (dbOptions.precursorMassTolerance.Units == MassToleranceUnits.ppm)
{
isotopicMzTolerance = (isotopicMzTolerance / 1e6) * track.MZ;
}
GraphML_List <Precursor> bestIsotopes = new GraphML_List <Precursor>();
for (int charge = dbOptions.MaximumPrecursorChargeState; charge >= dbOptions.MinimumPrecursorChargeState; charge--)
{
GraphML_List <Precursor> isotopes = new GraphML_List <Precursor>();
for (int nbIsotope = 1; nbIsotope < 5; nbIsotope++)
{
double bestDeltaMz = isotopicMzTolerance;
Track bestTrack = null;
double massShift = Numerics.IsotopicMassShift(nbIsotope, charge);
double mzIsotope = track.MZ + massShift;
foreach (Track trackToTest in listTracks.GetTracksInMzRange(mzIsotope, isotopicMzTolerance))
{
if (trackToTest.RT >= track.RT_Min &&
trackToTest.RT <= track.RT_Max)
{
double mzDiff = Math.Abs(mzIsotope - trackToTest.MZ);
if (mzDiff < bestDeltaMz)//TODO Is the best isotope the most precise one or the most intense?? Use a scoring function!
{
bestDeltaMz = mzDiff;
bestTrack = trackToTest;
}
}
}
if (bestTrack != null)
{
isotopes.Add(new Precursor(bestTrack, charge, entry, Constants.C12_C13_MASS_DIFFERENCE * nbIsotope, null));
}
else
{
break;
}
}
if (isotopes.Count > bestIsotopes.Count)//TODO Best way to compare isotope potentials? Number of isotopes? Delta Mass? Intensity ratios?
{
bestIsotopes = isotopes;
}
}
return(bestIsotopes);
}
public static GraphML_List <Precursor> GetOtherCharges(Precursor precursor, DBOptions dbOptions, Tracks listTracks, Sample entry)
{
GraphML_List <Precursor> otherPrecursor = new GraphML_List <Precursor>();
for (int charge = dbOptions.MaximumPrecursorChargeState; charge >= 1; charge--)
{
if (charge != precursor.Charge)
{
double aimedMZ = Numerics.MZFromMass(precursor.Mass, charge);
double chargeMzTolerance = dbOptions.precursorMassTolerance.Value * 0.5;
if (dbOptions.precursorMassTolerance.Units == MassToleranceUnits.ppm)
{
chargeMzTolerance = (chargeMzTolerance / 1e6) * aimedMZ;
}
double bestDeltaMz = chargeMzTolerance;
Track bestTrack = null;
foreach (Track trackToTest in listTracks.GetTracksInMzRange(aimedMZ, chargeMzTolerance))
{
if (trackToTest.RT >= precursor.Track.RT_Min &&
trackToTest.RT <= precursor.Track.RT_Max)
{
double mzDiff = Math.Abs(aimedMZ - trackToTest.MZ);
if (mzDiff < bestDeltaMz)//TODO Is the best isotope the most precise one or the closest in intensity?? Use a scoring function to get both!
{
bestDeltaMz = mzDiff;
bestTrack = trackToTest;
}
}
}
if (bestTrack != null)
{
otherPrecursor.Add(new Precursor(bestTrack, charge, precursor.sample, 0, GetIsotopes(bestTrack, dbOptions, listTracks, entry)));
}
}
}
return(otherPrecursor);
}
public void GenerateQueries(Sample entry, Spectra spectra, Tracks tracks)//, double mz, double rt, double intensity)
{
Dictionary <Track, Precursor> Tracks = new Dictionary <Track, Precursor>();
Dictionary <Track, Precursor> Isotopes = new Dictionary <Track, Precursor>();
//Create one query per Spectrum-Precursor duo, including Isotopes in the process to ease search
//For further analysis, maintain a list of precursors (excluding isotopes)
int nbMissedTrack = 0;
//vsSDF sdf = entry.GetSDF();// Samples.LoadSDF(entry);
//tracks.PrepareRtSort();
//sdf.TRACKS_LIST.PrepareRtSort();
spectra.Sort(ProductSpectrum.AscendingPrecursorMassComparison);
foreach (ProductSpectrum spectrum in spectra)
{
NbSpectrum++;
double intensityCumul = 0.0;
bool foundCharge = false;
Track closestTrack = null;
List <Query> newQueries = new List <Query>();
//TODO No threshold on sdf files, and preferably a C# routine that does what MassSense do
foreach (Track track in tracks.GetTracksInMzRange(spectrum.PrecursorMZ, spectrum.IsolationWindow * dbOptions.EffectiveIsolationWindowRatio))//TODO Optimize this value
{
Precursor prec = null;
if (track.RT_Min <= spectrum.RetentionTimeInMin &&
track.RT_Max >= spectrum.RetentionTimeInMin)
{
if (closestTrack == null || Math.Abs(track.MZ - spectrum.PrecursorMZ) < Math.Abs(closestTrack.MZ - spectrum.PrecursorMZ))
{
closestTrack = track;
}
if (Isotopes.ContainsKey(track))
{
break;
}
if (Tracks.ContainsKey(track))
{
prec = Tracks[track];
}
else
{
GraphML_List <Precursor> isotopes = GetIsotopes(track, dbOptions, tracks, entry);
if (isotopes.Count > 0)
{
prec = new Precursor(track, isotopes[0].Charge, entry, 0.0, isotopes);
Tracks.Add(track, prec);
prec.OtherCharges = GetOtherCharges(prec, dbOptions, tracks, entry);
foreach (Precursor isotope in prec.Isotopes)
{
if (!Isotopes.ContainsKey(isotope.Track))
{
Isotopes.Add(isotope.Track, isotope);
}
}
}
}
if (prec != null)
{
intensityCumul += track.INTENSITY;
newQueries.Add(new Query(dbOptions, entry, spectrum, prec, NbSpectrum));
if (prec.Charge == spectrum.PrecursorCharge)
{
foundCharge = true;
}
}
}
}
if (!foundCharge)
{
/*if (closestTrack != null && Tracks.ContainsKey(closestTrack) && Math.Abs(Numerics.CalculateMassError(closestTrack.MZ, spectrum.PrecursorMZ, dbOptions.precursorMassTolerance.Units)) < dbOptions.precursorMassTolerance.Value)
* {
* if(closestTrack.RT_Min > (float)(spectrum.RetentionTimeInMin - dbOptions.ComputedRetentionTimeDiff))
* closestTrack.RT_Min = (float)(spectrum.RetentionTimeInMin - dbOptions.ComputedRetentionTimeDiff);
* if (closestTrack.RT_Max < (float)(spectrum.RetentionTimeInMin + dbOptions.ComputedRetentionTimeDiff))
* closestTrack.RT_Max = (float)(spectrum.RetentionTimeInMin + dbOptions.ComputedRetentionTimeDiff);
* if (closestTrack.INTENSITY < spectrum.PrecursorIntensity)
* closestTrack.INTENSITY = spectrum.PrecursorIntensity;
*
* Precursor prec = Tracks[closestTrack];
* if (prec.Charge == spectrum.PrecursorCharge)
* {
* Add(new Query(dbOptions, entry, spectrum, prec, NbSpectrum));
* }
* else
* {
* Precursor newPrec = new Precursor(closestTrack, spectrum.PrecursorCharge, entry);
* Add(new Query(dbOptions, entry, spectrum, newPrec, NbSpectrum));
* }
* }
* else//*/
{
nbMissedTrack++;
closestTrack = new Track((float)spectrum.PrecursorMZ, (float)spectrum.RetentionTimeInMin, spectrum.PrecursorIntensity,
(float)(spectrum.RetentionTimeInMin - dbOptions.ComputedRetentionTimeDiff), (float)(spectrum.RetentionTimeInMin + dbOptions.ComputedRetentionTimeDiff),
true);
Precursor prec = new Precursor(closestTrack, spectrum.PrecursorCharge, entry);
Tracks.Add(closestTrack, prec);
Add(new Query(dbOptions, entry, spectrum, prec, NbSpectrum));
}
}//*/
if (newQueries.Count > 0)
{
//Remove precursors if estimated fragment intensities are too low (based on precursor intensity ratios and isolation window placement)
foreach (Query q in newQueries)
{
//if (q.precursor.Track.INTENSITY > intensityCumul * dbOptions.MinimumPrecursorIntensityRatioInIsolationWindow)//Need to be 5% of all intensity
//{
this.Add(q);
//}
}
}
Console.Write("\r{0}% ", ((100 * NbSpectrum) / spectra.Count));
}
Console.Write("\r{0}% ", 100);
//Sort queries to ease search
this.Sort(AscendingPrecursorMassComparison);
foreach (Track track in Tracks.Keys)
{
if (!Isotopes.ContainsKey(track))
{
Precursors.Add(Tracks[track]);
}
}
//TODO Validate this approach
//REMOVE QUERIES RELATED TO AN ISOTOPE and Compute the average CoElution
Dictionary <ProductSpectrum, double> DicOfSpectrumIntensities = new Dictionary <ProductSpectrum, double>();
for (int i = 0; i < this.Count;)
{
Query query = this[i];
if (!Isotopes.ContainsKey(query.precursor.Track))
{
if (!DicOfSpectrumIntensities.ContainsKey(query.spectrum))
{
DicOfSpectrumIntensities.Add(query.spectrum, query.precursor.Track.INTENSITY);
}
else
{
DicOfSpectrumIntensities[query.spectrum] += query.precursor.Track.INTENSITY;
}
i++;
}
else
{
this.RemoveAt(i);
}
}
//REMOVE Queries with Precursor intensities too low
for (int i = 0; i < this.Count;)
{
Query query = this[i];
if (query.precursor.Track.INTENSITY < DicOfSpectrumIntensities[query.spectrum] * dbOptions.MinimumPrecursorIntensityRatioInIsolationWindow)
{
this.RemoveAt(i);
}
else
{
i++;
}
}//*/
Dictionary <ProductSpectrum, int> DicOfSpectrumTracks = new Dictionary <ProductSpectrum, int>();
for (int i = 0; i < this.Count;)
{
Query query = this[i];
if (!Isotopes.ContainsKey(query.precursor.Track))
{
if (!DicOfSpectrumTracks.ContainsKey(query.spectrum))
{
DicOfSpectrumTracks.Add(query.spectrum, 1);
}
else
{
DicOfSpectrumTracks[query.spectrum]++;
}
i++;
}
else
{
this.RemoveAt(i);
}
}
double averageNbPrecursorPerSpectrum = 0;
int nbSpectrumMatchedToTrack = 0;
foreach (ProductSpectrum spectrum in DicOfSpectrumTracks.Keys)
{
nbSpectrumMatchedToTrack++;
averageNbPrecursorPerSpectrum += DicOfSpectrumTracks[spectrum];
}
dbOptions.ConSole.WriteLine(entry.sSDF + " :" + Precursors.Count + " precursors [" + Isotopes.Count + " isotopes] spreaded in " + Count + " queries [" + nbMissedTrack + " trackless precursors]");
dbOptions.ConSole.WriteLine("Average Precursors per Spectrum : " + averageNbPrecursorPerSpectrum / (double)nbSpectrumMatchedToTrack);
}
