/*
* public PeptideSpectrumMatch OptimizedBestPsm(Peptide peptide, bool checkMods)
* {
* PeptideSpectrumMatch bestPsm = null;
* foreach (clCondition condition in conditions)
* foreach (clReplicate replicate in condition.replicates)
* foreach (Precursor precursor in replicate.precursors)
* {
* PeptideSpectrumMatch match = precursor.OptimizedBestPsm(peptide, checkMods);
* if(bestPsm == null || bestPsm.OptimizedScore() < match.OptimizedScore())
* bestPsm = match;
* }
* return bestPsm;
* }//*/
public Precursor OptimizedBestPrecursor(Peptide peptide, bool checkMods = false)
{
double score = 0;
Precursor best = null;
foreach (clCondition condition in conditions)
{
if (condition != null)
{
foreach (clReplicate replicate in condition.replicates)
{
foreach (Precursor precursor in replicate.precursors)
{
double tmpScore = precursor.ProbabilityScore(peptide, checkMods);
if (tmpScore > score)
{
score = tmpScore;
best = precursor;
}
}
}
}
}
return(best);
}
public void Add(Precursor precursor)
{
if (replicates[precursor.sample.PROJECT.REPLICATE - 1] == null)
{
replicates[precursor.sample.PROJECT.REPLICATE - 1] = new clReplicate();
}
replicates[precursor.sample.PROJECT.REPLICATE - 1].Add(precursor);
}
}//*/
public void Add(Precursor precursor)
{
if (conditions[precursor.sample.PROJECT.CONDITION - 1] == null)
{
conditions[precursor.sample.PROJECT.CONDITION - 1] = new clCondition(samples[precursor.sample.PROJECT.CONDITION].Count);
}
conditions[precursor.sample.PROJECT.CONDITION - 1].Add(precursor);
//score = -1;
}
/// <summary>
/// Constructor used for Unit tests
/// </summary>
/// <param name="masses"></param>
public Queries(DBOptions options, double[] masses)
{
Precursors = new Precursors();
foreach (double mass in masses)
{
Precursor precursor = new Precursor();
precursor.Mass = mass;
Add(new Query(options, null, null, precursor));
Precursors.Add(precursor);
}
}
public Query(DBOptions dbOptions, Sample entry, ProductSpectrum spectrum, Precursor precursor, int spectraIndex = -1)
{
this.options = dbOptions;
this.sample = entry;
this.psms = new PeptideSpectrumMatches();
this.spectrum = spectrum;
this.precursor = precursor;
this.spectrumIndex = spectraIndex;
if (spectrum != null && precursor != null)
{
this.TrapDistance = Math.Abs(spectrum.PrecursorMZ - precursor.Track.MZ);
}
}
public Precursor BestPrecursor(bool checkMods = false)
{
double score = 0;
Precursor best = null;
foreach (Cluster cluster in clusters)
{
Precursor tmp = cluster.OptimizedBestPrecursor(peptide, checkMods);
if (tmp != null)
{
double tmpScore = tmp.ProbabilityScore(peptide, checkMods);
if (tmpScore > score)
{
score = tmpScore;
best = tmp;
}
}
}
return(best);
}
/*
* public List<PeptideSpectrumMatch> GetPSMs(double fdr, double decoyOverTargetRatio = 1, int nbMaxPsm = 1)
* {
* return FDR.PSMs(clusters, fdr, decoyOverTargetRatio, nbMaxPsm);
* }//*/
/*
* public List<PeptideMatch> GetPeptides(double fdr)
* {
* if (peptides != null)
* return FDR.Peptides(peptides, fdr);
* else
* return null;
* }
*
* public List<ProteinGroupMatch> GetProteins(double fdr)
* {
* if (proteins != null)
* return FDR.Proteins(proteins, fdr);
* else
* return null;
* }//*/
public static int DescendingProteinScoreComparison(Precursor left, Precursor right)
{
PeptideSpectrumMatch psmLeft = left.OptimizedBestPsm();
if (psmLeft != null)
{
PeptideSpectrumMatch psmRight = right.OptimizedBestPsm();
if (psmRight != null)
{
return(-(psmLeft.ProteinScore.CompareTo(psmRight.ProteinScore)));
}
else
{
return(-1);
}
}
else
{
return(1);
}
}
private double Score(Precursor a, Precursor b)
{
if (a.sample != b.sample && NbCommonSequences(a, b) > 0)
{
//Zero based score
//double tmp = Math.Abs(MassTolerance.CalculateMassError(a.Track.MZ, b.Track.MZ, MassToleranceUnits.ppm) / options.MzTol);
double tmp = Math.Abs(Numerics.MzDifference(a.Track.MZ, b.Track.MZ, options.precursorMassTolerance.Units)) / options.precursorMassTolerance.Value;
if (tmp < 1)
{
tmp = 0.2 * (2 * tmp +
Math.Abs(a.Track.RT - b.Track.RT) / options.ComputedRetentionTimeDiff + //TODO check if it is in seconds?
(a.Charge == b.Charge ? 0 : 1) +
0.1 * Math.Abs(Math.Log10(a.Track.INTENSITY) - Math.Log10(b.Track.INTENSITY)));
if (tmp < 1)
{
return(1 - tmp);
}
}
}
return(0);
}
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);
}
private int NbCommonSequences(Precursor a, Precursor b)
{
int common = 0;
foreach (PeptideSpectrumMatch psmA in a.psms)
{
bool seen = true;
foreach (PeptideSpectrumMatch psmB in b.psms)
{
if (psmA.Peptide.IsSamePeptide(psmB.Peptide, true))
{
seen = true;
break;
}
}
if (seen)
{
common++;
}
}
return(common);
}
public static int CompareNbChargedPrecursor(Precursor left, Precursor right)
{
return(-left.OtherCharges.Count.CompareTo(right.OtherCharges.Count));
}
public static int ComparePeptideScore(Precursor left, Precursor right)
{
return(-left.BestPSMPeptideScore().CompareTo(right.BestPSMPeptideScore()));
}
public static int CompareProbabilityScore(Precursor left, Precursor right)
{
return(-left.ProbabilityScore().CompareTo(right.ProbabilityScore()));
}
public static int CompareProteinScore(Precursor left, Precursor right)
{
return(-left.OptimizedBestPsm().ProteinScore.CompareTo(right.OptimizedBestPsm().ProteinScore));
}
public static int CompareMatchingProducts(Precursor left, Precursor right)
{
return(-left.OptimizedBestPsm().MatchingProducts.CompareTo(right.OptimizedBestPsm().MatchingProducts));
}
public static int CompareMatchingProductsFraction(Precursor left, Precursor right)
{
return(-left.BestPSMMatchingProductsFraction().CompareTo(right.BestPSMMatchingProductsFraction()));
}
public IEnumerable <ProductMatch> EnumerateAllProductMz(IEnumerable <ProductType> productTypes, Precursor precursor)
{
ProductMatch match = new ProductMatch();
for (int r = 1; r < Length; r++)
{
foreach (ProductType product_type in productTypes)
{
double product_mass = CalculateProductMass(product_type, r);
for (int c = precursor.Charge; c > 0; c--)
{
match.theoMz = Numerics.MZFromMass(product_mass, c);
match.charge = c;
//for (int iso = 0; iso < precursor.Isotopes.Count + 1; iso++)
yield return(match);// product_mz;// +Utilities.IsotopicMassShift(iso, c);
}
}
}
}
public void Add(Precursor precursor)
{
precursors.Add(precursor);
}
public static int OptimizedBestPSMComparison(Precursor left, Precursor right)
{
return(-left.OptimizedBestPsmScore().CompareTo(right.OptimizedBestPsmScore()));
}
public static int DescendingIntensityFractionComparison(Precursor left, Precursor right)
{
return(-(left.OptimizedBestPsm().MatchingIntensityFraction.CompareTo(right.OptimizedBestPsm().MatchingIntensityFraction)));
}
public static int OptimizedScoreComparison(Precursor left, Precursor right)
{
return(-left.ProbabilityScore().CompareTo(right.ProbabilityScore()));
}
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);
}
