public void OptimizePSMScoreRatios_PREVIOUSVersion(DBOptions options, double desired_fdr)
{
List <Precursor> sortedPrecursorPrecision = new List <Precursor>(this);
sortedPrecursorPrecision.Sort(Precursor.ComparePrecursorScore);
double ratioPrecursorPrecision = FDRizer <Precursor> .ComputeAtFDR(sortedPrecursorPrecision, desired_fdr).Count / (double)this.Count;
List <Precursor> sortedFragments = new List <Precursor>(this);
sortedFragments.Sort(Precursor.CompareMatchingProductsFraction);
double ratioFragments = FDRizer <Precursor> .ComputeAtFDR(sortedFragments, desired_fdr).Count / (double)this.Count;
List <Precursor> sortedIntensities = new List <Precursor>(this);
sortedIntensities.Sort(Precursor.CompareMatchingIntensityFraction);
double ratioIntensities = FDRizer <Precursor> .ComputeAtFDR(sortedIntensities, desired_fdr).Count / (double)this.Count;
List <Precursor> sortedPeptides = new List <Precursor>(this);
sortedPeptides.Sort(Precursor.ComparePeptideScore);
double ratioPeptideScore = FDRizer <Precursor> .ComputeAtFDR(sortedPeptides, desired_fdr).Count / (double)this.Count;
double totalRatios = ratioPrecursorPrecision + ratioFragments + ratioIntensities + ratioPeptideScore;
options.dPrecursor = ratioPrecursorPrecision / totalRatios;
options.dMatchingProductFraction = ratioFragments / totalRatios;
options.dIntensityFraction = ratioIntensities / totalRatios;
options.dPeptideScore = ratioPeptideScore / totalRatios;
options.ConSole.WriteLine("New score ratios [" + totalRatios + " total ratios] ------------------------------------- ");
options.ConSole.WriteLine(" PeptideSpectrumMatch.dPrecursor: " + options.dPrecursor);
options.ConSole.WriteLine(" PeptideSpectrumMatch.dMatchingProductFraction: " + options.dMatchingProductFraction);
options.ConSole.WriteLine(" PeptideSpectrumMatch.dIntensityFraction: " + options.dIntensityFraction);
options.ConSole.WriteLine(" PeptideSpectrumMatch.dPeptideScore: " + options.dPeptideScore);
options.ConSole.WriteLine("------------------------------------------------------------------------------------------ ");
}
public List <Query> ComputeAtFDR(double desired_fdr)
{
if (uptimizer == null)
{
List <Comparison <Query> > sorts = new List <Comparison <Query> >();
sorts.Add(CompareScore);
uptimizer = new FDRizer <Query>(this, sorts, null);
}
else
{
uptimizer.ReStart();
}
return(uptimizer.Launch(desired_fdr));
}
public List <ProteinGroupMatch> ComputeAtFDR(double desired_fdr)
{
if (uptimizer == null)
{
List <Comparison <ProteinGroupMatch> > sorts = new List <Comparison <ProteinGroupMatch> >();
sorts.Add(CompareProbabilityScore);
sorts.Add(ComparePeptideMatchesCount);
uptimizer = new FDRizer <ProteinGroupMatch>(this, sorts, null);
}
else
{
uptimizer.ReStart();
}
return(uptimizer.Launch(desired_fdr));
}
public void OptimizePSMScoreRatios_PREVIOUSVersion(DBOptions options, double desired_fdr)
{
//TODO find a Max flow approach to modelize the score optimization routine to maximize Targets versus Decoys
List <PeptideSpectrumMatch> sortedPrecursorPrecision = new List <PeptideSpectrumMatch>(this);
sortedPrecursorPrecision.Sort(PeptideSpectrumMatches.ComparePrecursorScore);
double ratioPrecursorPrecision = FDRizer <PeptideSpectrumMatch> .ComputeAtFDR(sortedPrecursorPrecision, desired_fdr).Count / (double)this.Count;
List <PeptideSpectrumMatch> sortedFragments = new List <PeptideSpectrumMatch>(this);
sortedFragments.Sort(PeptideSpectrumMatches.CompareMatchingProductsFraction);
double ratioFragments = FDRizer <PeptideSpectrumMatch> .ComputeAtFDR(sortedFragments, desired_fdr).Count / (double)this.Count;
List <PeptideSpectrumMatch> sortedIntensities = new List <PeptideSpectrumMatch>(this);
sortedIntensities.Sort(PeptideSpectrumMatches.CompareMatchingIntensityFraction);
double ratioIntensities = FDRizer <PeptideSpectrumMatch> .ComputeAtFDR(sortedIntensities, desired_fdr).Count / (double)this.Count;
List <PeptideSpectrumMatch> sortedPeptides = new List <PeptideSpectrumMatch>(this);
sortedPeptides.Sort(PeptideSpectrumMatches.ComparePeptideScore);
double ratioPeptideScore = FDRizer <PeptideSpectrumMatch> .ComputeAtFDR(sortedPeptides, desired_fdr).Count / (double)this.Count;
double totalRatios = ratioPrecursorPrecision + ratioFragments + ratioIntensities + ratioPeptideScore;
options.dPrecursor += ratioPrecursorPrecision / totalRatios;
options.dMatchingProductFraction += ratioFragments / totalRatios;
options.dIntensityFraction += ratioIntensities / totalRatios;
options.dPeptideScore += ratioPeptideScore / totalRatios;
double somme = options.dPrecursor + options.dMatchingProductFraction + options.dIntensityFraction + options.dPeptideScore;
options.dPrecursor /= somme;
options.dMatchingProductFraction /= somme;
options.dIntensityFraction /= somme;
options.dPeptideScore /= somme;
//options.dPrecursor = ratioPrecursorPrecision / totalRatios;
//options.dMatchingProductFraction = ratioFragments / totalRatios;
//options.dIntensityFraction = ratioIntensities / totalRatios;
//options.dPeptideScore = ratioPeptideScore / totalRatios;
options.ConSole.WriteLine("New score ratios [" + totalRatios + " total ratios] ------------------------------------- ");
options.ConSole.WriteLine(" PeptideSpectrumMatch.dPrecursor: " + options.dPrecursor);
options.ConSole.WriteLine(" PeptideSpectrumMatch.dMatchingProductFraction: " + options.dMatchingProductFraction);
options.ConSole.WriteLine(" PeptideSpectrumMatch.dIntensityFraction: " + options.dIntensityFraction);
options.ConSole.WriteLine(" PeptideSpectrumMatch.dPeptideScore: " + options.dPeptideScore);
options.ConSole.WriteLine("------------------------------------------------------------------------------------------ ");
}
public List <PeptideSpectrumMatch> ComputeAtFDR(double desired_fdr, bool precursorErrorOnly)
{
if (uptimizer == null)
{
List <Comparison <PeptideSpectrumMatch> > sorts = new List <Comparison <PeptideSpectrumMatch> >();
if (precursorErrorOnly)
{
sorts.Add(CompareProductScore);
}
else
{
//sorts.Add(CompareMatchingIntensity);
sorts.Add(CompareMaxQuantScore);
// sorts.Add(ComparePrecursorScore);
// sorts.Add(CompareMatchingProductsFraction);
// sorts.Add(CompareMatchingProducts);
//sorts.Add(CompareProteinScore);
//sorts.Add(ComparePeptideScore);
}
uptimizer = new FDRizer <PeptideSpectrumMatch>(this, sorts, null);
}
return(uptimizer.Launch(desired_fdr));
}
public List <Precursor> ComputeAtFDR(double desired_fdr)
{
if (uptimizer == null)
{
List <Comparison <Precursor> > sorts = new List <Comparison <Precursor> >();
sorts.Add(Precursor.OptimizedBestPSMComparison);
//sorts.Add(Precursor.CompareOptimizedScore);
sorts.Add(Precursor.CompareMatchingProducts);
//sorts.Add(Precursor.CompareMatchingProductsFraction);
sorts.Add(Precursor.ComparePrecursorScore);
sorts.Add(Precursor.CompareMatchingIntensityFraction);
sorts.Add(Precursor.ComparePeptideScore);
sorts.Add(Precursor.CompareProteinScore);
//sorts.Add(Precursor.CompareProductScore);
//sorts.Add(Precursor.CompareScore);
//sorts.Add(Precursor.CompareNbChargedPrecursor);//*/
uptimizer = new FDRizer <Precursor>(this, sorts, null);
}
else
{
uptimizer.ReStart();
}
List <Precursor> fdrList = uptimizer.Launch(desired_fdr);
List <Precursor> sortedProbability = new List <Precursor>(this);
sortedProbability.Sort(Precursor.CompareProbabilityScore);
sortedProbability = FDRizer <Precursor> .ComputeAtFDR(sortedProbability, desired_fdr);
if (sortedProbability.Count > fdrList.Count)
{
fdrList = sortedProbability;
}
return(fdrList);
}
public List <PeptideMatch> ComputeAtFDR(double desired_fdr)
{
if (uptimizer == null)
{
List <Comparison <PeptideMatch> > sorts = new List <Comparison <PeptideMatch> >();
//sorts.Add(CompareMatchingProducts);
//sorts.Add(CompareMatchingProductsFraction);
//sorts.Add(CompareMatchingIntensityFraction);
//sorts.Add(CompareProductScore);
// sorts.Add(CompareCumulPrecursorScore);
sorts.Add(CompareCumulPrecursorOptimizedScore);
// sorts.Add(CompareBestPrecursorScore);
sorts.Add(CompareBestPrecursorOptimizedScore);
sorts.Add(CompareScore);
//sorts.Add(CompareNbCluster);
//sorts.Add(ComparePrecursorMassError);
uptimizer = new FDRizer <PeptideMatch>(this, sorts, null);
}
else
{
uptimizer.ReStart();
}
if (uptimizer2 == null)
{
List <Comparison <PeptideMatch> > sorts = new List <Comparison <PeptideMatch> >();
//sorts.Add(CompareMatchingProducts);
//sorts.Add(CompareMatchingProductsFraction);
//sorts.Add(CompareMatchingIntensityFraction);
//sorts.Add(CompareProductScore);
// sorts.Add(CompareCumulPrecursorScore);
sorts.Add(CompareCumulPrecursorOptimizedScore);
// sorts.Add(CompareBestPrecursorScore);
sorts.Add(CompareBestPrecursorOptimizedScore);
sorts.Add(CompareScore);
//sorts.Add(CompareNbCluster);
//sorts.Add(ComparePrecursorMassError);
uptimizer2 = new FDRizer2 <PeptideMatch>(this, sorts, null);
}
else
{
uptimizer2.ReStart();
}
List <PeptideMatch> fdrList = uptimizer.Launch(desired_fdr);
List <PeptideMatch> fdrList2 = uptimizer2.Launch(desired_fdr);
if (fdrList.Count < fdrList2.Count)
{
return(fdrList2);
}
else
{
return(fdrList);
}
//List<PeptideMatch> sortedProbability = new List<PeptideMatch>(this);
//sortedProbability.Sort(PeptideSearcher.DescendingOptimizedScoreComparison);
//sortedProbability = FDRizer<PeptideMatch>.ComputeAtFDR(sortedProbability, desired_fdr);
//if (sortedProbability.Count > fdrList.Count)
// fdrList = sortedProbability;
//return fdrList;
}
