Fragment-index-based peptide database search algorithm (experimental). More...

#include <OpenMS/ANALYSIS/ID/ProSEAlgorithm.h>

Inheritance diagram for ProSEAlgorithm:

Classes
struct	AnnotatedHit_
	Slimmer structure as storing all scored candidates in PeptideHit objects takes too much space. More...

struct	CalibrationResult_
	Result of a calibration pass. More...

struct	CandidatePoolStats_
	Running summary of the complete candidate pool of one spectrum. More...

struct	CoIsolatedPSM_
	The PSM of a precursor co-isolated with the selected one (chimeric:enabled), until its residual spectrum is built. More...

struct	DecoyStrategy_
	Resolved decoy handling for one concrete input database. More...

struct	DeisotopingSettings_
	MS2 deisotoping rule of preprocessSpectra_(). More...

struct	LocalFragmentEvidence_
	Local fragment evidence of one candidate (annotate:local_fragment_evidence). More...

struct	MergedResult
	The pooled evaluation of a multi-file search (the ProSE tool's -out_merged). More...

struct	MultiFileSearchResult
	Multi-file search result bundle. More...

struct	PercolatorRescoring
	Outcome of the Percolator rescoring of one search run (see rescoreWithPercolator() and the parameter 'rescore'). More...

struct	ProteinMapping_
	The protein occurrences of the sequences of a search's hits (peptide:protein_mapping = index). More...

struct	RunStatistics
	Per-run identification statistics for the end-of-search report. More...

struct	SearchContext
	Prepared per-database state shared across multiple spectrum files. More...

struct	SearchResult
	Comprehensive search result including modification analysis. More...

struct	SharedSearchStats
	Configuration, database and fragment-index facts shared across all input files of one ProSE invocation. More...

struct	SpectraCounts_

Public Types
enum class	ExitCodes { EXECUTION_OK , INPUT_FILE_EMPTY , UNEXPECTED_RESULT , UNKNOWN_ERROR , ILLEGAL_PARAMETERS }
	Exit codes. More...

Public Types inherited from ProgressLogger
enum	LogType { CMD , GUI , NONE }
	Possible log types. More...

Public Member Functions
	ProSEAlgorithm ()

ExitCodes	search (const std::string &in_spectra, const std::string &in_db, std::vector< ProteinIdentification > &prot_ids, PeptideIdentificationList &pep_ids) const
	Search spectra in a spectrum file (mzML or Bruker .d) against a protein database using an FI-backed workflow.

void	annotatePsmQValues (PeptideIdentificationList &peptide_ids) const
	Annotate PSM q-values by target-decoy competition of the best hit of each spectrum, as FDR:PSM does.

bool	applyDeferredPsmFDR (const std::vector< ProteinIdentification > &protein_ids, PeptideIdentificationList &peptide_ids, bool rescored, double psm_fdr, PeptideIdentificationList *inference_only_psms=nullptr) const
	Apply the PSM-level FDR that a search with Percolator rescoring deferred.

SearchResult	searchWithModificationAnalysis (const std::string &in_spectra, const std::string &in_db, const std::string &output_base_name="") const
	Search with comprehensive results including modification analysis tables.

ExitCodes	search (PeakMap &spectra, const std::vector< FASTAFile::FASTAEntry > &fasta_db, std::vector< ProteinIdentification > &prot_ids, PeptideIdentificationList &pep_ids) const
	In-memory search: search spectra against a protein database without file I/O.

SearchContext	prepareContext (const std::vector< FASTAFile::FASTAEntry > &fasta_db) const
	Build a SearchContext (decoy-augmented database + FragmentIndex) for reuse.

SearchContext	prepareContext (const std::vector< FASTAFile::FASTAEntry > &fasta_db, bool electron_ions) const
	Build a SearchContext whose FragmentIndex also holds c and z+1 ions.

ExitCodes	search (PeakMap &spectra, SearchContext &ctx, std::vector< ProteinIdentification > &prot_ids, PeptideIdentificationList &pep_ids) const
	In-memory search using a pre-built SearchContext.

SearchResult	searchWithModificationAnalysis (PeakMap &spectra, const std::vector< FASTAFile::FASTAEntry > &fasta_db, const std::string &output_base_name="") const
	In-memory search with modification analysis: no file I/O required.

MultiFileSearchResult	searchWithModificationAnalysis (const std::vector< std::string > &in_spectra_files, const std::vector< FASTAFile::FASTAEntry > &fasta_db, const std::vector< std::string > &output_base_names={}, const std::string &aggregate_base_name="", bool build_pooled_aggregate=true) const
	Multi-file search with modification analysis (in-memory FASTA).

MultiFileSearchResult	searchWithModificationAnalysis (const std::vector< std::string > &in_spectra_files, const std::string &in_db, const std::vector< std::string > &output_base_names={}, const std::string &aggregate_base_name="", bool build_pooled_aggregate=true) const
	Multi-file search with modification analysis (FASTA file path).

MergedResult	mergeFileResults (MultiFileSearchResult &result, const StringList &in_spectra_files, bool remove_decoys=true) const
	Pools result (moving its PSMs out), infers proteins across files, applies FDR:protein of this instance with picked-protein FDR if decoy proteins were identified and then, by default, removes the decoys. Throws Exception::InvalidValue if Percolator rescored only some files.

void	setKeepPreFdrPsms (bool keep)

Public Member Functions inherited from DefaultParamHandler
	DefaultParamHandler (const std::string &name)
	Constructor with name that is displayed in error messages.

	DefaultParamHandler (const DefaultParamHandler &rhs)
	Copy constructor.

virtual	~DefaultParamHandler ()
	Destructor.

DefaultParamHandler &	operator= (const DefaultParamHandler &rhs)
	Assignment operator.

virtual bool	operator== (const DefaultParamHandler &rhs) const
	Equality operator.

void	setParameters (const Param &param)
	Sets the parameters.

const Param &	getParameters () const
	Non-mutable access to the parameters.

const Param &	getDefaults () const
	Non-mutable access to the default parameters.

const std::string &	getName () const
	Non-mutable access to the name.

void	setName (const std::string &name)
	Mutable access to the name.

const std::vector< std::string > &	getSubsections () const
	Non-mutable access to the registered subsections.

Public Member Functions inherited from ProgressLogger
	ProgressLogger ()
	Constructor.

virtual	~ProgressLogger ()
	Destructor.

	ProgressLogger (const ProgressLogger &other)
	Copy constructor.

ProgressLogger &	operator= (const ProgressLogger &other)
	Assignment Operator.

void	setLogType (LogType type) const
	Sets the progress log that should be used. The default type is NONE!

LogType	getLogType () const
	Returns the type of progress log being used.

void	setLogger (ProgressLoggerImpl *logger)
	Sets the logger to be used for progress logging.

void	startProgress (SignedSize begin, SignedSize end, const std::string &label) const
	Initializes the progress display.

void	setProgress (SignedSize value) const
	Sets the current progress.

void	endProgress (UInt64 bytes_processed=0) const

void	nextProgress () const
	increment progress by 1 (according to range begin-end)

Static Public Member Functions
static bool	applyCompleteSetProteinFDR (std::vector< ProteinIdentification > &protein_ids, PeptideIdentificationList &peptide_ids, const std::string &decoy_string, bool decoy_is_prefix, double protein_fdr, bool remove_decoys, const PeptideIdentificationList &inference_only_psms)
	Finalize protein-level FDR on a COMPLETE protein set (a single input file, or a merged cross-file aggregate).

static std::string	inferProteins (std::vector< ProteinIdentification > &protein_ids, const PeptideIdentificationList &peptide_ids, const PeptideIdentificationList &inference_only_psms=PeptideIdentificationList())
	The protein inference of the protein FDR (applyCompleteSetProteinFDR()) and of mergeFileResults().

static PercolatorRescoring	rescoreWithPercolator (std::vector< ProteinIdentification > &protein_ids, PeptideIdentificationList &peptide_ids, int threads)
	Rescore the PSMs of one search run in-process with Percolator, as the parameter 'rescore' does in every search.

static PeakMap	loadSpectra (const std::string &filename, const std::function< bool(const MSSpectrum &)> &keep={})
	The MS2 spectra of a spectrum file as the searches of this class read them.

static void	updateFinalStats (RunStatistics &stats, const PeptideIdentificationList &peptide_ids, const std::string &enzyme, bool fdr_applied)

static std::string	renderTotalTime (const SharedSearchStats &sh)
	The total time of a run, by part: "total <s>s \| search of the file(s) <s>s \| outputs <s>s (of which -qpx_extended <s>s)", from `sh's` seconds_total, seconds_output and seconds_qpx_extended (the last part only if positive). The end of the report of renderRunSummary(), and of ProSE's report of several files.

static void	renderRunSummary (const RunStatistics &stats, const SharedSearchStats &shared, const OpenSearchModificationAnalysis::OpenSearchAnalysisResult &mod_analysis, bool is_open_search, std::ostream &os)

static void	renderModificationSummary (const OpenSearchModificationAnalysis::OpenSearchAnalysisResult &mod_analysis, std::ostream &os)

static std::string	renderRunSummaryYaml (const MultiFileSearchResult &mfres, const std::vector< std::pair< std::string, std::vector< std::string > > > &manifest, Size files_failed, Size files_total)

Static Public Member Functions inherited from DefaultParamHandler
static void	writeParametersToMetaValues (const Param &write_this, MetaInfoInterface &write_here, const std::string &key_prefix="")
	Writes all parameters to meta values.

Static Public Attributes
static constexpr const char *	CHIMERIC_RANK = "chimeric_rank"

Protected Types
enum class	DecoyMode_ { AUTO , GENERATE , IGNORE }
	How decoys are obtained/recognised for a search (parameter "decoys"). More...

Protected Member Functions
void	updateMembers_ () override
	This method is used to update extra member variables at the end of the setParameters() method.

void	annotateIonPriors_ (const PeakMap &spectra, const FragmentIonLikelihoodModel::PeakLists &evidence, std::vector< ProteinIdentification > &protein_ids, PeptideIdentificationList &peptide_ids) const
	Learn per-run fragment ion likelihoods from confident PSMs and annotate every hit with them.

DecoyStrategy_	resolveDecoyStrategy_ (const std::vector< FASTAFile::FASTAEntry > &db) const
	Decide how to obtain/recognise decoys for `db`.

Param	fragmentIndexParameters_ (bool electron_ions=false) const
	ProSE parameters made safe to hand to a FragmentIndex.

SpectrumGenerators_	spectrumGenerators_ () const
	Generators for scoring, annotation and calibration, configured from the ions:* parameters.

Size	countElectronActivated_ (const PeakMap &spectra) const
	Number of spectra that ions:by_activation also scores with c and z+1 ions (0 if it is off)

std::vector< FASTAFile::FASTAEntry >	buildDecoyAugmentedDB_ (const std::vector< FASTAFile::FASTAEntry > &fasta_db, const DecoyStrategy_ &strategy) const
	Build the searched database according to `strategy`.

std::vector< FASTAFile::FASTAEntry >	buildDecoyAugmentedDB_ (std::vector< FASTAFile::FASTAEntry > &&fasta_db, const DecoyStrategy_ &strategy) const
	As above, but takes the entries of `fasta_db` over instead of copying them.

SearchContext	prepareContext_ (std::vector< FASTAFile::FASTAEntry > &&fasta_db, bool electron_ions, const std::function< const PeakMap *(Size)> &searched_spectra={}) const

bool	restrictIndexToSpectra_ () const

bool	chimericSearch_ () const

void	searchCoIsolated_ (const PeakMap &spectra, const std::vector< std::vector< AnnotatedHit_ > > &annotated_hits, FragmentIndex &fi, const std::vector< FASTAFile::FASTAEntry > &db, const SpectrumGenerators_ &generators, double fragment_tol, bool fragment_tol_ppm, bool open_search_mode, std::vector< CoIsolatedPSM_ > &psms, std::vector< std::vector< AnnotatedHit_ > > &hits, std::vector< CandidatePoolStats_ > &pool_stats) const
	Search the precursors co-isolated with the selected one in what the spectrum's other PSMs leave of it (chimeric:enabled), after the andes chimeric cascade.

std::vector< FASTAFile::FASTAEntry >	buildCalibrationSample_ (const std::vector< FASTAFile::FASTAEntry > &full_db) const
	Build a strided protein sample for chunked calibration.

ExitCodes	searchChunked_ (PeakMap &spectra, std::vector< FASTAFile::FASTAEntry > &full_db, const DecoyStrategy_ &strategy, std::vector< ProteinIdentification > &protein_ids, PeptideIdentificationList &peptide_ids) const
	Chunked database search implementation.

void	scoreSpectraAgainstIndex_ (const PeakMap &spectra, FragmentIndex &fi, const std::vector< FASTAFile::FASTAEntry > &db, const SpectrumGenerators_ &generators, double effective_fragment_tol, bool fragment_mass_tolerance_unit_ppm, bool open_search_mode, std::vector< std::vector< AnnotatedHit_ > > &annotated_hits, std::vector< CandidatePoolStats_ > &pool_stats, const std::string &progress_label, const PeakMap *query_spectra=nullptr) const
	Score all spectra against one FragmentIndex.

void	postProcessHits_ (const PeakMap &exp, std::vector< std::vector< ProSEAlgorithm::AnnotatedHit_ > > &annotated_hits, const std::vector< CandidatePoolStats_ > &pool_stats, std::vector< ProteinIdentification > &protein_ids, PeptideIdentificationList &peptide_ids, Size top_hits, const StringList &modifications_fixed, const StringList &modifications_variable, Int peptide_missed_cleavages, double precursor_mass_tolerance, double fragment_mass_tolerance, const std::string &precursor_mass_tolerance_unit_ppm, const std::string &fragment_mass_tolerance_unit_ppm, const Int precursor_min_charge, const Int precursor_max_charge, const std::string &enzyme, const std::string &database_name, const PeakMap evidence_spectra=nullptr, const std::vector< Size > evidence_parent=nullptr) const
	Filter and annotate search results.

void	annotatePeptDeepFeatures_ (const PeakMap &spectra, std::vector< ProteinIdentification > &protein_ids, PeptideIdentificationList &peptide_ids) const
	Adds PeptDeep-prediction-derived rescoring features to the PSMs.

int	scoringMaxCharge_ (int precursor_charge) const
	Fragment charges that score a candidate of the given precursor charge; also used by the calibration pass.

double	computeModMatchTolerance_ () const

CalibrationResult_	runCalibrationPass_ (PeakMap &spectra, FragmentIndex &fragment_index, const std::vector< FASTAFile::FASTAEntry > &db, const PeakMap *query_spectra=nullptr) const
	Run a fast calibration pass on a subset of spectra to estimate mass accuracy.

PercolatorRescoring	applyPsmFDR_ (std::vector< ProteinIdentification > &protein_ids, PeptideIdentificationList &peptide_ids, bool has_decoys, RunStatistics &stats, PeptideIdentificationList pre_fdr_psms=nullptr, PeptideIdentificationList inference_only_psms=nullptr) const

void	collectInferenceOnlyPsms_ (const PeptideIdentificationList &peptide_ids, double psm_fdr, PeptideIdentificationList &inference_only_psms) const

void	collectRunStatistics_ (const PeakMap &spectra, const std::vector< ProteinIdentification > &protein_ids, const PeptideIdentificationList &peptide_ids, RunStatistics &stats) const

SpectraCounts_	countSpectra_ (const PeakMap &spectra) const
	Helper: the SpectraCounts_ of `spectra`.

void	preprocessSearchedSpectra_ (PeakMap &spectra, const std::string &input, FragmentIonLikelihoodModel::PeakLists &ion_evidence, PeakMap evidence_spectra, PeakMap query_spectra) const

Protected Member Functions inherited from DefaultParamHandler
void	defaultsToParam_ ()
	Updates the parameters after the defaults have been set in the constructor.

Static Protected Member Functions
static void	preprocessSpectra_ (PeakMap &exp, double fragment_mass_tolerance, bool fragment_mass_tolerance_unit_ppm, bool deisotope_requested, Size peaks_keep_n, Int peaks_window_top, const std::string &window_type, const DeisotopingSettings_ &deisotoping, FragmentIonLikelihoodModel::PeakLists ion_evidence=nullptr, bool ion_evidence_scored_peaks=false, PeakMap evidence_spectra=nullptr, PeakMap *query_spectra=nullptr)
	filter, deisotope, decharge spectra

static void	preprocessSpectra_ (PeakMap &exp, double fragment_mass_tolerance, bool fragment_mass_tolerance_unit_ppm, bool deisotope_requested, Size peaks_keep_n, Int peaks_window_top, const std::string &window_type="auto")
	preprocessSpectra_() with the DeisotopingSettings_ defaults (the behaviour before its parameters existed)

static AASequence	reversedNoiseSequence_ (const AASequence &sequence)
	Reversed sequence keeping the C-terminal residue and every residue's modification: the noise hypothesis of a confident PSM.

static void	filterLocalPeaks_ (MSSpectrum &spectrum, Size peaks_per_window)
	Keep the strongest peaks in each non-overlapping 100 Da window, including a short final window.

static std::vector< double >	localPeakDensities_ (const MSSpectrum &spectrum)
	Peak counts per Da in a fixed +/-50 m/z window around each peak of a sorted spectrum.

static LocalFragmentEvidence_	localFragmentEvidence_ (const MSSpectrum &spectrum, const MSSpectrum &theoretical, const std::vector< double > &densities, double tolerance, bool ppm)
	Compute local fragment-match evidence on the spectrum before window/top-N peak filtering.

static LocalFragmentEvidence_	localFragmentEvidence_ (const MSSpectrum &spectrum, const MSSpectrum &theoretical, int max_charge, const std::vector< double > &densities, double tolerance, bool ppm, std::vector< double > &alternatives)

static bool	isElectronActivated_ (const MSSpectrum &spectrum)
	True if the precursor of `spectrum` was activated by electrons (ETD, ECD, EThcD or ETciD)

static MSSpectrum	residualSpectrum_ (const MSSpectrum &spectrum, const std::vector< UInt32 > &removed, const Precursor &precursor)

static ProteinMapping_	buildProteinMapping_ (const FragmentIndex &index, const std::vector< FASTAFile::FASTAEntry > &db, std::vector< UInt32 > candidates, const Param &indexer_parameters)
	Collects the protein occurrences of the sequences of the index peptides `candidates`.

static bool	applyProteinMapping_ (const ProteinMapping_ &mapping, const std::vector< FASTAFile::FASTAEntry > &db, const Param &indexer_parameters, std::vector< ProteinIdentification > &protein_ids, PeptideIdentificationList &peptide_ids, std::string &fallback_reason)
	Writes what PeptideIndexing::run(`db`, `protein_ids`, `peptide_ids`) with `indexer_parameters` writes: the evidences, target_decoy and protein_references of every hit, the protein hits and the PeptideIndexer:* search parameters.

static bool	accessionHasDecoyMarker_ (const std::string &accession, const std::string &marker, bool is_prefix)

static void	poolSearchedFiles_ (std::vector< SearchResult > &per_file, bool move_psms, const StringList &in_spectra_files, std::vector< ProteinIdentification > &protein_ids, PeptideIdentificationList &peptide_ids)

static void	capturePreFdrStats_ (const PeptideIdentificationList &peptide_ids, RunStatistics &stats)

static double	maxRetainedScore_ (const PeptideIdentificationList &peptide_ids)

Protected Attributes
bool	peptdeep_enable_ {false}

std::string	peptdeep_ms2_model_

std::string	peptdeep_rt_model_

std::string	peptdeep_instrument_ {"QE"}

double	peptdeep_nce_ {-1.0}

std::string	peptdeep_rt_model_type_ {"b_spline"}

int	peptdeep_batch_size_ {500}

double	precursor_mass_tolerance_lower_ {10.0}
	positive magnitude (default matches the param)

double	precursor_mass_tolerance_upper_ {10.0}
	positive magnitude (default matches the param)

std::string	precursor_mass_tolerance_unit_ {"ppm"}

Size	precursor_min_charge_

Size	precursor_max_charge_

double	fragment_mass_tolerance_

std::string	fragment_mass_tolerance_unit_

bool	deisotope_requested_ {true}

bool	scoring_multiple_charges_ {false}
	Resolved scoring:fragment_charges: score charges above 1.

int	scoring_max_charge_ {2}
	Upper fragment charge bound (fragment:max_charge)

bool	mass_accuracy_score_ {false}
	Resolved scoring:method: mass-accuracy weighted HyperScore.

double	mass_error_sd_ppm_ {7.0}
	Width of the mass-accuracy kernel in ppm (scoring:mass_error_sd)

Size	peaks_keep_n_ {0}
	NLargest cap on MS2 peaks before scoring; 0 = resolution-aware auto (peaks:keep_n)

Int	peaks_window_top_ {20}
	WindowMower peaks-per-100Da before scoring (peaks:window_top)

std::string	peaks_window_type_ {"auto"}
	Resolution-aware treatment of the final peak window.

DeisotopingSettings_	deisotoping_
	MS2 deisotoping rule (fragment:deisotope_*)

bool	query_raw_spectrum_ {false}
	Retrieve candidates with the spectrum before deisotoping and local filtering (fragment:query_spectrum)

StringList	modifications_fixed_

StringList	modifications_variable_

Size	modifications_max_variable_mods_per_peptide_

std::string	enzyme_

DecoyMode_	decoy_mode_ {DecoyMode_::AUTO}

std::string	decoy_prefix_

bool	rescore_ {true}
	rescore: Percolator rescoring of every run before its PSM-level FDR

double	fdr_psm_ {0.0}

bool	fdr_psm_by_scored_charges_ {true}
	FDR:PSM_groups: separate competitions per number of scored fragment charges.

double	fdr_protein_ {0.0}

double	fdr_protein_inference_psm_ {0.1}
	FDR:protein_inference_PSM: q-value cutoff of the PSMs of the protein inference.

StringList	annotate_psm_

bool	self_trained_ion_priors_ {false}
	annotate:self_trained_ion_priors

FragmentIonLikelihoodModel::ContextSet	ion_prior_model_ {FragmentIonLikelihoodModel::ContextSet::RICH}
	annotate:ion_prior_model

bool	ion_prior_scored_peaks_ {false}
	annotate:ion_prior_peaks == scored

int	ion_prior_max_fragment_charge_ {2}
	annotate:ion_prior_max_fragment_charge (capped at precursor charge - 1)

double	ion_prior_train_fdr_ {0.01}
	annotate:ion_prior_train_fdr: TDC q-value threshold of the training PSMs

Size	ion_prior_min_psms_ {100}
	annotate:ion_prior_min_psms: training PSMs required per fold

bool	ion_prior_feature_llr_ {true}
	annotate:ion_prior_features holds ion_prior_llr

bool	ion_prior_feature_explained_ {true}
	annotate:ion_prior_features holds ion_prior_explained

bool	ion_prior_feature_topk_ {false}
	annotate:ion_prior_features holds ion_prior_topk_observed

Size	peptide_min_size_

Size	peptide_max_size_

Size	peptide_missed_cleavages_

EnzymaticDigestion::Specificity	peptide_enzyme_specificity_ {EnzymaticDigestion::SPEC_FULL}

Size	report_top_hits_

bool	isotope_error_observed_minus_theoretical_ {true}

bool	add_a_ions_ {false}

bool	add_b_ions_ {true}

bool	add_c_ions_ {false}

bool	add_x_ions_ {false}

bool	add_y_ions_ {true}

bool	add_z_ions_ {false}

bool	add_zp1_ions_ {false}

bool	ions_by_activation_ {true}
	add c and z+1 ions for electron-activated spectra

bool	protein_mapping_from_index_ {true}
	peptide:protein_mapping = index

Size	database_chunk_size_ {0}
	0 = disabled; >0 = chunk DB into groups of this many proteins

bool	calibration_enabled_ {false}

double	calibration_subset_ratio_ {0.1}

bool	chimeric_enabled_ {false}
	chimeric:enabled: also search the precursors co-isolated with the selected one

Size	calibration_min_psms_ {50}

CalibrationResult_	last_calibration_result_

RunStatistics	last_run_stats_

PercolatorRescoring	last_percolator_

bool	keep_pre_fdr_psms_ = false

PeptideIdentificationList	pre_fdr_peptide_ids_

PeptideIdentificationList	inference_only_peptide_ids_

double	last_mod_match_tolerance_used_ {-1.0}

Protected Attributes inherited from DefaultParamHandler
Param	param_
	Container for current parameters.

Param	defaults_
	Container for default parameters. This member should be filled in the constructor of derived classes!

std::vector< std::string >	subsections_
	Container for registered subsections. This member should be filled in the constructor of derived classes!

std::string	error_name_
	Name that is displayed in error messages during the parameter checking.

bool	check_defaults_
	If this member is set to false no checking if parameters in done;.

bool	warn_empty_defaults_
	If this member is set to false no warning is emitted when defaults are empty;.

Protected Attributes inherited from ProgressLogger
LogType	type_

time_t	last_invoke_

ProgressLoggerImpl *	current_logger_

Private Member Functions
bool	isOpenSearchMode_ () const
	Helper function to determine if open search should be used based on tolerance.

Additional Inherited Members
Static Protected Attributes inherited from ProgressLogger
static int	recursion_depth_

Detailed Description

Fragment-index-based peptide database search algorithm (experimental).

Provides a self-contained search engine that matches MS/MS spectra against a protein database using an FI (Fragment Index). Typical usage:

Configure parameters via DefaultParamHandler (mass tolerances, enzyme, charges, etc.)
Call search() with an input spectrum file (mzML or Bruker .d) and a FASTA database to populate identification outputs (ProteinIdentification and PeptideIdentificationList)
Intended for educational/prototyping use and to demonstrate FI-backed searching

Notes:

Used by the ProSE TOPP tool
Experimental; interfaces and behavior may change

Class Documentation

◆ OpenMS::ProSEAlgorithm::CalibrationResult_

struct OpenMS::ProSEAlgorithm::CalibrationResult_

Result of a calibration pass.

Holds the estimated precursor and fragment tolerances computed from confident PSMs during the calibration pass. When success is false, the tolerance values are undefined and should not be used.

Class Members
double	cal_lower {0}	calibrated lower magnitude (valid iff !extreme_bias && success)
double	cal_upper {0}	calibrated upper magnitude (valid iff !extreme_bias && success)
bool	extreme_bias {false}	\|shift\| >= spread — writeback skipped (test observability)
double	fragment_shift {0}	reserved for future fragment m/z shift correction
double	fragment_tolerance {0}	estimated fragment tolerance (same unit as configured)
double	precursor_shift {0}	signed median of precursor errors (calibration bias)
double	precursor_spread {0}	median(\|e - shift\|) + 3 * MAD(\|e - shift\|)
bool	success {false}	true if enough PSMs were found for reliable estimation

◆ OpenMS::ProSEAlgorithm::CoIsolatedPSM_

struct OpenMS::ProSEAlgorithm::CoIsolatedPSM_

The PSM of a precursor co-isolated with the selected one (chimeric:enabled), until its residual spectrum is built.

Class Members
Size	parent = 0	index of its spectrum in the searched spectra
Precursor	precursor	the co-isolated precursor: that of the spectrum with its m/z and charge
vector< UInt32 >	removed	the peaks of the spectrum that its residual spectrum leaves out (ascending)

◆ OpenMS::ProSEAlgorithm::DecoyStrategy_

struct OpenMS::ProSEAlgorithm::DecoyStrategy_

Resolved decoy handling for one concrete input database.

Produced by resolveDecoyStrategy_() and consumed by buildDecoyAugmentedDB_() and the downstream PeptideIndexing / FDR steps, so the same decoys that are searched are also the ones scored.

Class Members
string	decoy_string	effective marker for PeptideIndexing + protein FDR
bool	generate {false}	reverse target proteins to synthesise decoys
bool	have_decoys {false}	searched DB will contain decoys (FDR possible)
bool	is_prefix {true}	position of decoy_string
bool	strip_existing {false}	drop pre-existing decoy entries before searching
bool	strip_is_prefix {true}	position of strip_string
string	strip_string	marker of pre-existing decoys to strip

◆ OpenMS::ProSEAlgorithm::DeisotopingSettings_

struct OpenMS::ProSEAlgorithm::DeisotopingSettings_

MS2 deisotoping rule of preprocessSpectra_().

Filled from the parameters fragment:deisotope_* by updateMembers_(), whose defaults are the Sage-like rule (min_peaks = 2, charge_cap_precursor: charges up to the precursor charge, at most 3, and sum_intensity). The member defaults are the behaviour before these parameters existed (envelopes of at least three peaks, charges 1-3 in every spectrum, the monoisotopic peak keeps its own intensity); the preprocessSpectra_() overload without settings uses them.

Class Members
bool	charge_cap_precursor {false}	fragment:deisotope_charge_cap = precursor
unsigned int	min_peaks {3}	fragment:deisotope_min_peaks
bool	sum_intensity {false}	fragment:deisotope_sum_intensity

◆ OpenMS::ProSEAlgorithm::LocalFragmentEvidence_

struct OpenMS::ProSEAlgorithm::LocalFragmentEvidence_

Local fragment evidence of one candidate (annotate:local_fragment_evidence).

Class Members
double	chance_match_surprise = 0.0
double	mass_competition_evidence = 0.0

◆ OpenMS::ProSEAlgorithm::MergedResult

struct OpenMS::ProSEAlgorithm::MergedResult

The pooled evaluation of a multi-file search (the ProSE tool's -out_merged).

Class Members
PeptideIdentificationList	peptide_ids	PSMs of all files; meta value 'id_merge_index' = input position of the file (inputs with distinct paths)
bool	protein_fdr_applied = false	picked-protein FDR applied and its filter at FDR:protein (and, with remove_decoys, the decoys removed)
vector< ProteinIdentification >	protein_ids	one pooled run; empty if no file succeeded

◆ OpenMS::ProSEAlgorithm::MultiFileSearchResult

struct OpenMS::ProSEAlgorithm::MultiFileSearchResult

Multi-file search result bundle.

Returned by the file-list searchWithModificationAnalysis() overloads. Holds one SearchResult per input file (in per_file, in input order) and a single aggregate result whose peptide_ids are the concatenation of all per-file PSMs and whose modification_analysis is computed once on the pooled set of PSMs.

Special cases for aggregate:

When the input list contains exactly one file, aggregate is left almost-empty (only is_open_search and exit_code are set) — the single-file pooled aggregate would just duplicate per_file[0] and re-run modification analysis on the same PSMs. Callers should use per_file[0] for the result in this case.
When every per-file run failed, aggregate.exit_code is set to the first non-OK per-file exit code (so callers can inspect it without walking the per_file vector).
When the caller passed build_pooled_aggregate = false, the pooled PSM copy is not retained: aggregate is left almost-empty (only is_open_search and exit_code), exactly as in the single-file case. In OPEN search the pooling still happens internally because the aggregate modification analysis needs it, so aggregate.modification_analysis is populated as usual and only aggregate.protein_ids / aggregate.peptide_ids are released afterwards. In closed search nothing is pooled at all.
When Percolator (parameter 'rescore') rescored only some of the files, their runs report different search engines (Percolator / ProSE) and are not merged: nothing is pooled (a warning is logged), so aggregate is left almost-empty as above, also in open search.

The aggregate's protein_ids template is taken from the first successful per-file result (search parameters are identical across files by construction), with the primary MS run path overwritten to list every input file. Its PSMs carry the meta value 'id_merge_index', the input position of their file (for inputs with distinct paths), also when other files failed.

Class Members
SearchResult	aggregate
bool	decoy_is_prefix = true	Position of `decoy_string` (true = prefix, false = suffix).
string	decoy_string	Effective decoy marker resolved from the shared database, for a caller-side merged-PSM protein-FDR step (e.g. the ProSE TOPP tool's -out_merged path). Empty when the search was target-only (decoys=ignore).
bool	have_decoys = false	True when the searched databases contained decoys (FDR possible).
vector< SearchResult >	per_file
SharedSearchStats	shared	Configuration / database / fragment-index facts shared across all input files (the index is built once and reused), for the end-of-search report.

◆ OpenMS::ProSEAlgorithm::PercolatorRescoring

struct OpenMS::ProSEAlgorithm::PercolatorRescoring

Outcome of the Percolator rescoring of one search run (see rescoreWithPercolator() and the parameter 'rescore').

With 'rescore' off nothing is attempted: applied is false and skipped_reason empty.

Class Members
bool	applied = false	True if the PSMs were rescored.
string	skipped_reason	Why the PSMs were not rescored, as a sentence to show to the user (empty if `applied` or not attempted)
string	warning	A caveat of an applied rescoring, as a sentence to show to the user (empty if none): Percolator's sanity check replaced the learned model by the best single feature (Percolator::usedDefaultDirection())

◆ OpenMS::ProSEAlgorithm::RunStatistics

struct OpenMS::ProSEAlgorithm::RunStatistics

Per-run identification statistics for the end-of-search report.

Populated by collectRunStatistics_() once a single spectrum file has been searched (post-FDR), plus a few fields captured at well-defined points during search() (target/decoy counts pre-FDR, achieved q-value, timing). All counts refer to one input file. Cross-file/shared facts (database, fragment index, configuration) live in SharedSearchStats instead.

Class Members
double	achieved_psm_fdr = -1.0	max retained q-value after FDR (<0 = n/a)
map< Int, Size >	charge_histogram	precursor charge -> PSM count
Size	charge_out_of_range_spectra = 0	MS2 spectra not searched: their charge is outside precursor:min/max_charge.
Size	decoy_psms = 0	decoy PSMs in the final IDs (after FDR, if applied)
bool	fdr_applied = false	true if PSM-level FDR filtering ran
double	frag_err_mad = 0.0
double	frag_err_median = 0.0
double	frag_err_recommended = 0.0
bool	frag_tol_valid = false	true if fragment-error estimate present The same of the annotated b and y fragment peaks (without neutral losses) of these PSMs; within the searched fragment tolerance (unmatched peaks have no error)
double	hyperscore_max = 0.0
double	hyperscore_median = 0.0
double	hyperscore_min = 0.0
string	input_file	spectrum file this run searched (basename or path)
Size	matched_spectra = 0	spectra with >=1 retained PSM in the final IDs (after FDR, if applied)
map< Size, Size >	missed_cleavage_histogram	missed cleavages -> PSM count
Size	ms2_spectra = 0	number of MS2 spectra in the input
double	prec_err_mad = 0.0
double	prec_err_median = 0.0
double	prec_err_recommended = 0.0
bool	prec_tol_valid = false	true if precursor-error estimate present Mass error estimate (ppm) of the top hits of the target PSMs (at least 10): the median of the signed errors (observed minus theoretical; of the precursor corrected by the hit's isotope error, in an open search of the PSMs without a delta mass, within 0.05 Da of zero, only), their median absolute deviation from it (unscaled), and the recommended symmetric tolerance ceil(\|median\| + 3 * 1.4826 * MAD)
Size	profile_spectra = 0	MS2 spectra recorded as profile (not centroided) spectra.
bool	score_stats_valid = false	true if hyperscore_* below are meaningful
double	seconds_calibration = 0.0	calibration pass wall time (0 if disabled)
double	seconds_fdr = 0.0	FDR filtering wall time (0 if not applied)
double	seconds_search = 0.0	scoring + post-processing wall time
Size	target_psms = 0	target PSMs in the final IDs (after FDR, if applied)
Size	unique_peptides = 0	distinct peptide sequences among top hits
Size	unique_proteins = 0	distinct protein accessions among top hits

◆ OpenMS::ProSEAlgorithm::SearchContext

struct OpenMS::ProSEAlgorithm::SearchContext

Prepared per-database state shared across multiple spectrum files.

Holds the (decoy-augmented) protein database and the built FragmentIndex so that searching N spectrum files against the same FASTA pays the index build cost only once. Construct via prepareContext() and pass to the context-taking search() overload.

Class Members
vector< FASTAEntry >	db
bool	decoy_is_prefix = true	Position of `decoy_string` (true = prefix, false = suffix).
string	decoy_string	Effective decoy marker carried by `db` (auto-detected for external decoys, or the configured prefix for internally generated ones). Empty when the search is target-only. Feeds PeptideIndexing and the protein-level FDR so they recognise the same decoys that were searched.
bool	electron_ions = false	True when `fragment_index` also holds c and z+1 ions for electron-activated spectra (ions:by_activation); only those spectra are matched against them. See prepareContext(). search() does not add them to a context: for such spectra and a context without these ions, it builds a temporary index for the call.
FragmentIndex	fragment_index
bool	have_decoys = false	True when `db` contains decoy entries (generated or external), i.e. target-decoy FDR is possible.
bool	release_fragment_index_after_scoring = false	When true, the context-taking search() overload will release `fragment_index` (via clear()) after scoreSpectraAgainstIndex_ returns, reclaiming its heap footprint before the PeptideIndexing Aho-Corasick pass — which is otherwise the RSS high-water mark on large databases. Set by single-use callers (e.g. the internal search(spectra, fasta_db, ...) wrapper that creates a throw-away ctx). Default false preserves the reuse contract for callers that built ctx via prepareContext() and want to run multiple search() calls against it.

◆ OpenMS::ProSEAlgorithm::SearchResult

struct OpenMS::ProSEAlgorithm::SearchResult

Comprehensive search result including modification analysis.

This structure contains all outputs from an open search including:

Standard protein and peptide identifications
Delta mass statistics table (histogram of mass shifts)
PTM statistics table (mapped modifications with residue analysis)
Per-run identification statistics for the end-of-search report

Class Members
ExitCodes	exit_code = ExitCodes::EXECUTION_OK
PeptideIdentificationList	inference_only_peptide_ids	The PSMs whose q-values pass FDR:protein_inference_PSM but not FDR:PSM (targets and decoys, with the q-value as main score): the protein inference and the picked-protein FDR use them with `peptide_ids`, but they are not reported (see applyCompleteSetProteinFDR()). The multi-file searches fill it with FDR:protein > 0 and an FDR:PSM filter below FDR:protein_inference_PSM, and mergeFileResults() moves it out; the single-file searchWithModificationAnalysis() overloads use it for their protein FDR and return it empty.
bool	is_open_search = false
OpenSearchAnalysisResult	modification_analysis
PeptideIdentificationList	peptide_ids
PercolatorRescoring	percolator	Outcome of the Percolator rescoring of this run (parameter 'rescore')
PeptideIdentificationList	pre_fdr_peptide_ids	the PSMs before rescoring and FDR:PSM; only filled with setKeepPreFdrPsms(true)
vector< ProteinIdentification >	protein_ids
RunStatistics	stats

◆ OpenMS::ProSEAlgorithm::SharedSearchStats

struct OpenMS::ProSEAlgorithm::SharedSearchStats

Configuration, database and fragment-index facts shared across all input files of one ProSE invocation.

Computed once (the fragment index is built once and reused), so these costs/counts must NOT be summed per file. Populated by the multi-file searchWithModificationAnalysis() overloads.

Class Members
bool	calibration_enabled = false
bool	chunked = false
string	database_file	FASTA path (empty for in-memory db)
Size	db_decoy_proteins = 0	decoy entries in the searched (augmented) db
Size	db_target_proteins = 0	target entries in the searched (augmented) db
string	decoy_mode	"generated" \| "external" \| "none (target-only)"
string	enzyme
vector< string >	fixed_mods
double	fragment_tol = 0.0
string	fragment_tol_unit
Size	indexed_fragments = 0	theoretical fragments in the index (summed over chunks)
Size	indexed_peptides = 0	peptides in the fragment index (summed over chunks)
vector< string >	ion_series
Int	max_charge = 0
Int	min_charge = 0
Size	missed_cleavages = 0
bool	open_search = false
bool	peptide_mass_mode = false
double	precursor_tol_lower = 0.0
string	precursor_tol_unit
double	precursor_tol_upper = 0.0
double	protein_fdr_threshold = 0.0
double	psm_fdr_threshold = 0.0
double	seconds_index_build = 0.0	decoy generation + fragment index build wall time
double	seconds_output = 0.0	of seconds_total, the wall time after the search of the files: the outputs (set by the caller)
double	seconds_qpx_extended = 0.0	of seconds_output, ProSE's -qpx_extended work: the spectra and predictions of the PSMs (set by the caller)
double	seconds_total = 0.0	whole-search wall time (set by the caller)
vector< string >	variable_mods

◆ OpenMS::ProSEAlgorithm::SpectraCounts_

struct OpenMS::ProSEAlgorithm::SpectraCounts_

The MS2 spectra of a spectrum file, those recorded as profile spectra and those that are not searched because their precursor charge lies outside of precursor:min_charge..max_charge (FragmentIndex::precursorCharges())

Class Members
Size	charge_out_of_range = 0
Size	ms2 = 0
Size	profile = 0

Member Enumeration Documentation

◆ DecoyMode_

enum class DecoyMode_

strongprotected

How decoys are obtained/recognised for a search (parameter "decoys").

Enumerator
AUTO	ensure decoys: use those already present, otherwise generate
GENERATE	always (re)generate decoys from the targets (strip existing first)
IGNORE	search targets only; remove any decoys present in the database

◆ ExitCodes

enum class ExitCodes

strong

Exit codes.

Enumerator
EXECUTION_OK
INPUT_FILE_EMPTY
UNEXPECTED_RESULT
UNKNOWN_ERROR
ILLEGAL_PARAMETERS

Constructor & Destructor Documentation

◆ ProSEAlgorithm()

ProSEAlgorithm ( )

Member Function Documentation

◆ accessionHasDecoyMarker_()

static bool accessionHasDecoyMarker_	(	const std::string &	accession,
		const std::string &	marker,
		bool	is_prefix
	)

staticprotected

Helper: does accession carry the decoy marker at the given position? Empty marker → false. Pure std::string (no String dependency).

◆ annotateIonPriors_()

void annotateIonPriors_	(	const PeakMap &	spectra,
		const FragmentIonLikelihoodModel::PeakLists &	evidence,
		std::vector< ProteinIdentification > &	protein_ids,
		PeptideIdentificationList &	peptide_ids
	)		const

protected

Learn per-run fragment ion likelihoods from confident PSMs and annotate every hit with them.

Implements annotate:self_trained_ion_priors. The spectra are split into two folds by the parity of their scan_index. Each fold trains its own FragmentIonLikelihoodModel on its rank-one target hits at target-decoy competition q <= annotate:ion_prior_train_fdr of the native score, computed within the fold, with their reversed sequences matched against the same spectra as noise. Every hit is then scored by the model of the other fold (cross-fitting), so neither a PSM's own spectrum nor its label, nor any other label of its fold, enters the model that scores it; targets and decoys are scored alike. Both folds need annotate:ion_prior_min_psms training PSMs (a fold without a decoy hit has the estimate (0 + 1) / T); otherwise all features of the file are 0 and a warning is logged. This run-level gate is the one place where the labels of a fold reach its own features: at the boundary, a single label (in either fold) decides whether both folds get their cross-fitted features or all zeros. The gate treats targets and decoys alike, but it is not formally independent of the labels. Adds the feature names to the search parameters' extra_features and records the settings that determine the features (annotate:ion_prior_*) and the training set (ion_prior:*). Native scores and the retained candidates are unchanged. Call after PeptideIndexing (target/decoy labels) and before FDR (which overwrites the native scores). Does nothing when the ion priors are off, which includes target-only searches (decoys=ignore).

Parameters

[in]	spectra	Preprocessed spectra, indexed by the scan_index meta value of the PSMs (precursor activation selects the ion series).
[in]	evidence	Peak lists of the same spectra from preprocessSpectra_.
[in,out]	protein_ids	Search parameters of protein_ids[0] receive the feature names and training facts.
[in,out]	peptide_ids	Every hit receives the meta values of annotate:ion_prior_features (ion_prior_llr, ion_prior_explained, ion_prior_topk_observed).

◆ annotatePeptDeepFeatures_()

void annotatePeptDeepFeatures_	(	const PeakMap &	spectra,
		std::vector< ProteinIdentification > &	protein_ids,
		PeptideIdentificationList &	peptide_ids
	)		const

protected

Adds PeptDeep-prediction-derived rescoring features to the PSMs.

No-op unless both peptdeep:ms2_model and peptdeep:rt_model are set. Warns and does nothing when OpenMS was built without ONNX support, so an ini file that requests the models still runs (without those features) on such a build.

◆ annotatePsmQValues()

void annotatePsmQValues ( PeptideIdentificationList & peptide_ids ) const

Annotate PSM q-values by target-decoy competition of the best hit of each spectrum, as FDR:PSM does.

Uses FalseDiscoveryRate (decoy hits are kept and annotated) and replaces hit scores by q-values; no filtering. With FDR:PSM_groups = 'scored_charges' and multiply charged fragments scored (scoring:fragment_charges), PSMs whose best hits were scored with different numbers of fragment charges compete separately, because HyperScore grows with the number of theoretical ions. With one group, or a group without target or decoy hits, all PSMs compete together.

Parameters

[in,out] peptide_ids PSMs with target_decoy annotations (PeptideIndexing).

◆ applyCompleteSetProteinFDR()

static bool applyCompleteSetProteinFDR	(	std::vector< ProteinIdentification > &	protein_ids,
		PeptideIdentificationList &	peptide_ids,
		const std::string &	decoy_string,
		bool	decoy_is_prefix,
		double	protein_fdr,
		bool	remove_decoys,
		const PeptideIdentificationList &	inference_only_psms
	)

static

Finalize protein-level FDR on a COMPLETE protein set (a single input file, or a merged cross-file aggregate).

Runs protein inference (BasicProteinInferenceAlgorithm, see inferProteins()), picked-protein FDR (Savitski et al. 2015), threshold filtering at protein_fdr, then removes decoys and repairs indistinguishable-protein / protein-group / peptide-evidence references so the result stores as schema-valid, decoy-free idXML.

The inference and the picked-protein FDR use the reported PSMs (peptide_ids, e.g. those that pass FDR:PSM) together with inference_only_psms (e.g. those up to FDR:protein_inference_PSM), as ProteomicsLFQ infers proteins on PSMs of a looser cutoff before it filters them at its PSM FDR: more decoy proteins for the picked FDR, and the score of a protein is the best PEP of its PSMs (the raw search engine score without a PEP, see inferProteins()). The reported PSMs stay as they are, but for the decoys that the finalization removes; the proteins and groups that none of them references afterwards (the decoys, and the proteins only inference_only_psms support) are removed.

Shared by the file-based single-file search() above, mergeFileResults() and the ProSE TOPP tool's single-file finalization, so the exact IDFilter sequence and ordering live in one place (they previously existed as copies that could drift).

Precondition: protein_ids is non-empty and the set is statistically complete — picked-protein FDR does not compose across runs. The caller gates on "decoys present" and "FDR requested"; this helper additionally skips (with a warning) when no decoy proteins survive inference, to avoid target-only q-values.

With remove_decoys false the decoys are kept, as mergeFileResults() keeps them: the picked-protein FDR keeps the decoy proteins, with q-values, the filter at protein_fdr applies to them as to the targets, the decoy PSMs stay, and only the references to the proteins the filter removed go.

Parameters

[in,out]	protein_ids	Protein identifications (operates on protein_ids[0]).
[in,out]	peptide_ids	The reported PSMs; only the best hit of each is kept, and decoy PSMs are removed (unless `remove_decoys` is false).
[in]	decoy_string	Accession marker identifying decoy proteins.
[in]	decoy_is_prefix	Whether `decoy_string` is a prefix (true) or suffix (false).
[in]	protein_fdr	Picked-protein q-value threshold (expected > 0).
[in]	remove_decoys	Remove the decoy PSMs and proteins (the finalization, as in the ProSE tool).
[in]	inference_only_psms	PSMs that the inference and the picked-protein FDR use as well, but that are not reported (SearchResult::inference_only_peptide_ids); their identifiers are ignored. No default, so that a caller cannot drop the searches' inference-only PSMs unnoticed: pass the search result's (empty with FDR:PSM 0 or FDR:protein_inference_PSM at or below FDR:PSM), or an empty list for PSMs without them.

Returns: Whether the picked-protein FDR was applied: false if it was skipped (an empty decoy_string, or no decoy protein left after the inference, which uses the best hit of each PSM only).

◆ applyDeferredPsmFDR()

bool applyDeferredPsmFDR	(	const std::vector< ProteinIdentification > &	protein_ids,
		PeptideIdentificationList &	peptide_ids,
		bool	rescored,
		double	psm_fdr,
		PeptideIdentificationList *	inference_only_psms = `nullptr`
	)		const

Apply the PSM-level FDR that a search with Percolator rescoring deferred.

For PSMs that rescoreWithPercolator() rescored (rescored), the scores are Percolator q-values already. Otherwise they get q-values by annotatePsmQValues() first (FDR:PSM_groups of this instance), provided the run has decoy proteins (protein hits with 'target_decoy' "decoy"). The PSMs are then filtered at psm_fdr (IDFilter::filterHitsByScore); target and decoy PSMs are filtered alike, decoys are not removed (that is the protein FDR's finalization, see applyCompleteSetProteinFDR()).

The searches of this class apply it after rescoreWithPercolator() when the parameter 'rescore' is on.

Parameters

[in]	protein_ids	The runs of the search; the first one tells whether there are decoys.
[in,out]	peptide_ids	PSMs of the run, rescored by rescoreWithPercolator() or with their search engine scores.
[in]	rescored	Whether rescoreWithPercolator() rescored `peptide_ids` (its `applied`).
[in]	psm_fdr	PSM q-value threshold.
[out]	inference_only_psms	If given, receives the PSMs that the filter removes but whose q-values pass FDR:protein_inference_PSM of this instance, for the protein inference (SearchResult::inference_only_peptide_ids); left empty if nothing was filtered.

Returns: False if nothing was filtered: psm_fdr <= 0, no runs or no PSMs, or PSMs that were not rescored without decoy proteins to estimate the FDR with.

◆ applyProteinMapping_()

static bool applyProteinMapping_	(	const ProteinMapping_ &	mapping,
		const std::vector< FASTAFile::FASTAEntry > &	db,
		const Param &	indexer_parameters,
		std::vector< ProteinIdentification > &	protein_ids,
		PeptideIdentificationList &	peptide_ids,
		std::string &	fallback_reason
	)

staticprotected

Writes what PeptideIndexing::run(db, protein_ids, peptide_ids) with indexer_parameters writes: the evidences, target_decoy and protein_references of every hit, the protein hits and the PeptideIndexer:* search parameters.

Returns: false, with fallback_reason set and nothing changed, if mapping cannot reproduce PeptideIndexing for these identifications (e.g. a hit whose sequence it does not hold); then PeptideIndexing has to run.

◆ applyPsmFDR_()

PercolatorRescoring applyPsmFDR_	(	std::vector< ProteinIdentification > &	protein_ids,
		PeptideIdentificationList &	peptide_ids,
		bool	has_decoys,
		RunStatistics &	stats,
		PeptideIdentificationList *	pre_fdr_psms = `nullptr`,
		PeptideIdentificationList *	inference_only_psms = `nullptr`
	)		const

protected

Helper: the PSM-level FDR of one search run, the last step of every search path. With 'rescore' on, rescores the PSMs with Percolator first (rescoreWithPercolator()) and then applies FDR:PSM with applyDeferredPsmFDR(); otherwise applies FDR:PSM to the search engine scores (if has_decoys). Fills the FDR fields of stats. If pre_fdr_psms is given, it receives the PSMs before the rescoring and FDR:PSM (see setKeepPreFdrPsms()); inference_only_psms receives the PSMs between FDR:PSM and FDR:protein_inference_PSM (with FDR:protein only, see SearchResult::inference_only_peptide_ids; cleared otherwise).

Returns: The outcome of the rescoring (not applied, no reason with 'rescore' off).

◆ buildCalibrationSample_()

std::vector< FASTAFile::FASTAEntry > buildCalibrationSample_ ( const std::vector< FASTAFile::FASTAEntry > & full_db ) const

protected

Build a strided protein sample for chunked calibration.

Sample size is tied to database_chunk_size_ so the calibration FI never exceeds the user's declared memory budget. Crucial for immunopeptidomics (non-specific digestion) where a fixed-size 5000-protein sample would generate tens of GB of fragment index. Strided rather than first-N so small chunk_size values don't starve the calibration pool (#9182).

Note: very small chunk_size may still produce a calibration pool below calibration_min_psms_; calibration then no-ops silently (follow-up issue: pool PSMs across first-K chunks of the main search loop).

◆ buildDecoyAugmentedDB_() [1/2]

std::vector< FASTAFile::FASTAEntry > buildDecoyAugmentedDB_	(	const std::vector< FASTAFile::FASTAEntry > &	fasta_db,
		const DecoyStrategy_ &	strategy
	)		const

protected

Build the searched database according to strategy.

Optionally strips pre-existing decoys and/or generates fresh decoys by reversing the target proteins. Produces FASTA entries only — does not construct a FragmentIndex.

◆ buildDecoyAugmentedDB_() [2/2]

std::vector< FASTAFile::FASTAEntry > buildDecoyAugmentedDB_	(	std::vector< FASTAFile::FASTAEntry > &&	fasta_db,
		const DecoyStrategy_ &	strategy
	)		const

protected

As above, but takes the entries of fasta_db over instead of copying them.

◆ buildProteinMapping_()

static ProteinMapping_ buildProteinMapping_	(	const FragmentIndex &	index,
		const std::vector< FASTAFile::FASTAEntry > &	db,
		std::vector< UInt32 >	candidates,
		const Param &	indexer_parameters
	)

staticprotected

Collects the protein occurrences of the sequences of the index peptides candidates.

Parameters

[in]	index	The searched fragment index (built from `db`); must still hold its peptides
[in]	db	The searched database
[in]	candidates	Indices into FragmentIndex::getPeptides(): the candidates of the hits (in any order, repeats allowed)
[in]	indexer_parameters	The parameters PeptideIndexing would run with

◆ capturePreFdrStats_()

static void capturePreFdrStats_	(	const PeptideIdentificationList &	peptide_ids,
		RunStatistics &	stats
	)

staticprotected

Helper: capture statistics that must be read BEFORE FDR filtering, namely target/decoy PSM counts (via the "target_decoy" meta set by PeptideIndexing; "target+decoy" counts as target, matching OpenMS FDR semantics) and the HyperScore distribution (FDR overwrites each hit's score with its q-value). Fills stats.target_psms, stats.decoy_psms, stats.hyperscore_* and stats.score_stats_valid.

◆ chimericSearch_()

bool chimericSearch_ ( ) const

inlineprotected

Whether co-isolated precursors are searched (chimeric:enabled, which database:chunk_size > 0 does not support). The file-based searches then also read the survey scans.

◆ collectInferenceOnlyPsms_()

void collectInferenceOnlyPsms_	(	const PeptideIdentificationList &	peptide_ids,
		double	psm_fdr,
		PeptideIdentificationList &	inference_only_psms
	)		const

protected

Helper: copies of the PSMs of peptide_ids whose q-values (main scores) are above psm_fdr and at most FDR:protein_inference_PSM, appended to inference_only_psms (nothing if that cutoff is not above psm_fdr).

◆ collectRunStatistics_()

void collectRunStatistics_	(	const PeakMap &	spectra,
		const std::vector< ProteinIdentification > &	protein_ids,
		const PeptideIdentificationList &	peptide_ids,
		RunStatistics &	stats
	)		const

protected

Helper: fill a RunStatistics with identification counts, distributions and per-run tolerance estimation for one searched file (post-FDR). Silent; rendering is done separately (ProSE TOPP tool or renderRunSummary()). Fields filled at other points (target/decoy counts, achieved FDR, timing) are left untouched.

◆ computeModMatchTolerance_()

double computeModMatchTolerance_ ( ) const

inlineprotected

Scalar tolerance passed to OpenSearchModificationAnalysis under asymmetric bounds. Uses the tighter of the two positive magnitudes — semantically correct for UniMod Δmass matching precision. OpenSearchModificationAnalysis internally clamps this at MAX_MOD_MAPPING_TOL_ = 0.02 Da; see spec §7 for rationale.

Zero on one side is a legal one-sided window (e.g., [0, 500] Da = "search only positive mass shifts"). In that case std::min() would collapse to 0, passing a useless zero tolerance into the mod analyzer — masked in ppm mode by the internal clamp, but genuinely broken in Da mode. Fall back to the non-zero side so the mod-matching precision reflects the configured tolerance.

◆ countElectronActivated_()

Size countElectronActivated_ ( const PeakMap & spectra ) const

protected

Number of spectra that ions:by_activation also scores with c and z+1 ions (0 if it is off)

◆ countSpectra_()

SpectraCounts_ countSpectra_ ( const PeakMap & spectra ) const

protected

Helper: the SpectraCounts_ of spectra.

◆ filterLocalPeaks_()

static void filterLocalPeaks_	(	MSSpectrum &	spectrum,
		Size	peaks_per_window
	)

staticprotected

Keep the strongest peaks in each non-overlapping 100 Da window, including a short final window.

◆ fragmentIndexParameters_()

Param fragmentIndexParameters_ ( bool electron_ions = false ) const

protected

ProSE parameters made safe to hand to a FragmentIndex.

FragmentIndex declares its own (unused) boolean "decoys" flag with restrictions {true,false}. ProSE's "decoys" parameter is the richer auto/generate/ignore enum and manages decoys at the database level, so forwarding it verbatim would trip FragmentIndex's validation. This returns getParameters() with "decoys" overridden to "false".

Parameters

[in] electron_ions Also index c and z+1 ions, for electron-activated spectra (ions:by_activation).

◆ inferProteins()

static std::string inferProteins	(	std::vector< ProteinIdentification > &	protein_ids,
		const PeptideIdentificationList &	peptide_ids,
		const PeptideIdentificationList &	inference_only_psms = `PeptideIdentificationList()`
	)

static

The protein inference of the protein FDR (applyCompleteSetProteinFDR()) and of mergeFileResults().

Runs BasicProteinInferenceAlgorithm on the best hits of peptide_ids and inference_only_psms (copies that hold what the inference reads; the PSMs themselves stay unchanged) for the run protein_ids[0], with the algorithm's 'score_type': "PEP" if the PSMs carry a posterior error probability (after Percolator rescoring the main score is the q-value, and the PEP is the meta value MS:1001493), so that a protein scores with the best PEP of its PSMs (as a posterior probability, 1 - PEP), as in ProteomicsLFQ. Otherwise "RAW", the search engine score (e.g. 'ln(hyperscore)', also when FDR:PSM made the q-value the main score and kept the search engine score as a meta value), or the main score if the PSMs carry neither.

Parameters

[in,out]	protein_ids	Protein identifications; protein_ids[0] gets the scores and the indistinguishable groups, and loses the proteins without PSMs.
[in]	peptide_ids	PSMs of the run.
[in]	inference_only_psms	Further PSMs of the run (their identifiers are ignored).

Returns: The 'score_type' used: "PEP", "RAW" or "" (the main score).

◆ isElectronActivated_()

static bool isElectronActivated_ ( const MSSpectrum & spectrum )

staticprotected

True if the precursor of spectrum was activated by electrons (ETD, ECD, EThcD or ETciD)

◆ isOpenSearchMode_()

bool isOpenSearchMode_ ( ) const

inlineprivate

Helper function to determine if open search should be used based on tolerance.

◆ loadSpectra()

static PeakMap loadSpectra	(	const std::string &	filename,
		const std::function< bool(const MSSpectrum &)> &	keep = `{}`
	)

static

The MS2 spectra of a spectrum file as the searches of this class read them.

Sorted by RT, their peaks by m/z. An mzML file is read in chunks that the OpenMP threads of this thread (at most 16) parse in parallel, in one pass over the file; other files (Bruker .d, Thermo .raw), or an mzML file whose layout the chunks do not support (e.g. compressed), with FileHandler::loadExperiment(). For a second look at the spectra of a search, e.g. those of its PSMs (ProSE's -qpx_extended).

Parameters

[in]	filename	The spectrum file (mzML, Bruker .d or Thermo .raw)
[in]	keep	If set, only the spectra it accepts are kept, so that the result holds only those in memory. It is called on several threads at once.

Returns: The spectra

Exceptions

Exception::BaseException as FileHandler::loadExperiment() if the file cannot be read

◆ localFragmentEvidence_() [1/2]

static LocalFragmentEvidence_ localFragmentEvidence_	(	const MSSpectrum &	spectrum,
		const MSSpectrum &	theoretical,
		const std::vector< double > &	densities,
		double	tolerance,
		bool	ppm
	)

staticprotected

Compute local fragment-match evidence on the spectrum before window/top-N peak filtering.

Matches each intact theoretical ion to its nearest experimental peak. Surprise is sum(max(0, -log(2 * tolerance_Da * local_density))). Competition evidence is sum(1 / (1 + alternative_assignments + local_density)). Alternative hypotheses include all configured intact ions and generic H2O/NH3 losses, divided by the fragment charge. Losses only discount ambiguous matches; they are not scored as additional matches and do not require sequence-specific loss eligibility.

Parameters

[in]	spectrum	Sorted experimental spectrum after zero-intensity removal and optional deisotoping, before window/top-N peak filtering.
[in]	theoretical	Sorted intact ions, with the TSG's aligned integer charge array.
[in]	densities	Result of localPeakDensities_(spectrum), reused for all candidates.
[in]	tolerance	Positive, finite matching tolerance.
[in]	ppm	Whether tolerance is given in ppm rather than Da.

Returns: Two additive annotations; zero without matches. Neither is a calibrated PSM p-value.

◆ localFragmentEvidence_() [2/2]

static LocalFragmentEvidence_ localFragmentEvidence_	(	const MSSpectrum &	spectrum,
		const MSSpectrum &	theoretical,
		int	max_charge,
		const std::vector< double > &	densities,
		double	tolerance,
		bool	ppm,
		std::vector< double > &	alternatives
	)

staticprotected

localFragmentEvidence_() restricted to the ions of theoretical with charge <= max_charge, with a caller-owned buffer for the sorted alternative assignments (reused across candidates).

◆ localPeakDensities_()

static std::vector< double > localPeakDensities_ ( const MSSpectrum & spectrum )

staticprotected

Peak counts per Da in a fixed +/-50 m/z window around each peak of a sorted spectrum.

◆ maxRetainedScore_()

static double maxRetainedScore_ ( const PeptideIdentificationList & peptide_ids )

staticprotected

Helper: maximum top-hit score among retained PSMs. After PSM-FDR the score is the q-value, so this is the achieved FDR of the filtered set (-1.0 if empty).

◆ mergeFileResults()

MergedResult mergeFileResults	(	MultiFileSearchResult &	result,
		const StringList &	in_spectra_files,
		bool	remove_decoys = `true`
	)		const

Pools result (moving its PSMs out), infers proteins across files, applies FDR:protein of this instance with picked-protein FDR if decoy proteins were identified and then, by default, removes the decoys. Throws Exception::InvalidValue if Percolator rescored only some files.

The evaluation of the ProSE tool's -out_merged, for the result of a multi-file searchWithModificationAnalysis() with the parameters of this instance:

Pooling: the pooled aggregate of the search (build_pooled_aggregate) is taken as it is. Without one (e.g. build_pooled_aggregate false, or a search of a single file, which builds none), the runs of the files that were searched (exit code EXECUTION_OK) are merged with IDMergerAlgorithm: the PSMs of the files are moved, their runs are copied and stay with the files. 'id_merge_index' is the input position of a PSM's file (its index in in_spectra_files, for inputs with distinct paths), also when other files failed. The pooled run lists in_spectra_files as its primary MS run paths and gets the current date.
Cross-file protein inference (inferProteins(): a protein scores with the best PEP of its PSMs, or the best search engine score without PEPs) on the best hit of each pooled PSM.
With FDR:protein > 0 and decoys in the searched database: applyCompleteSetProteinFDR(), whose inference also uses the PSMs of the files between FDR:PSM and FDR:protein_inference_PSM (per_file[i].inference_only_peptide_ids, which are moved out), with picked-protein FDR (Savitski et al. 2015) and the filter at FDR:protein, provided the inference identified decoy proteins (otherwise a warning, and nothing is filtered). The finalization then removes the decoys, the proteins without a pooled PSM and the references to removed proteins. With remove_decoys false the picked-protein FDR keeps the decoy proteins in the run, with q-values (FalseDiscoveryRate's add_decoy_proteins; the q-values of the targets are the same), and the filter applies to them as to the targets; the decoy PSMs and the decoy proteins that pass are kept, and only the references to the proteins the filter removed go (peptide evidences, indistinguishable proteins and protein groups), so that the result can still be stored, e.g. as idXML. Without the protein FDR the result keeps the targets and decoys.

Parameters

[in,out]	result	The search result. Its pooled aggregate's identifications are moved into the returned result; without an aggregate, the PSMs of the files that were searched are, while the runs of the files (`per_file`[i].protein_ids: search parameters, meta values such as PeptDeepRescoring::NCE_META_VALUE, primary MS run paths) stay as they are. The statistics, exit codes, Percolator outcomes and modification analyses stay, too. Unchanged if Exception::IllegalArgument or Exception::InvalidValue is thrown.
[in]	in_spectra_files	The input files of the search, in its order: one per entry of `result.per_file`.
[in]	remove_decoys	Whether the finalization of the protein FDR removes the decoy PSMs and proteins (default, as in the ProSE tool's -out_merged). False keeps those that pass, e.g. to show them; `protein_fdr_applied` of the result still tells whether the FDR was applied. No effect without the protein FDR.

Returns: The pooled run and PSMs; empty if no file was searched.

Exceptions

Exception::IllegalArgument	if `in_spectra_files` has not one entry per file of `result`.
Exception::InvalidValue	if Percolator ('rescore') rescored only some of the files that were searched: their runs report different search engines and scores and cannot be pooled.

◆ poolSearchedFiles_()

static void poolSearchedFiles_	(	std::vector< SearchResult > &	per_file,
		bool	move_psms,
		const StringList &	in_spectra_files,
		std::vector< ProteinIdentification > &	protein_ids,
		PeptideIdentificationList &	peptide_ids
	)

staticprotected

Helper: pool the runs of the files of per_file that were searched (exit code EXECUTION_OK) with IDMergerAlgorithm into one run (protein_ids, one entry) that lists in_spectra_files as primary MS run paths, and their PSMs (peptide_ids). Copies the identifications, or with move_psms moves the PSMs out of per_file (leaving them empty) and copies the runs, which stay with the files. 'id_merge_index' of a PSM is the input position of its file (its index in per_file and in_spectra_files, for inputs with distinct paths), also when other files failed. Shared by the multi-file search's pooled aggregate and mergeFileResults().

◆ postProcessHits_()

void postProcessHits_	(	const PeakMap &	exp,
		std::vector< std::vector< ProSEAlgorithm::AnnotatedHit_ > > &	annotated_hits,
		const std::vector< CandidatePoolStats_ > &	pool_stats,
		std::vector< ProteinIdentification > &	protein_ids,
		PeptideIdentificationList &	peptide_ids,
		Size	top_hits,
		const StringList &	modifications_fixed,
		const StringList &	modifications_variable,
		Int	peptide_missed_cleavages,
		double	precursor_mass_tolerance,
		double	fragment_mass_tolerance,
		const std::string &	precursor_mass_tolerance_unit_ppm,
		const std::string &	fragment_mass_tolerance_unit_ppm,
		const Int	precursor_min_charge,
		const Int	precursor_max_charge,
		const std::string &	enzyme,
		const std::string &	database_name,
		const PeakMap *	evidence_spectra = `nullptr`,
		const std::vector< Size > *	evidence_parent = `nullptr`
	)		const

protected

Filter and annotate search results.

Trims per-spectrum candidate hits to the top N and converts them into PeptideIdentification objects, adding requested PSM annotations and populating protein-level search metadata.

Parameters

[in]	exp	Input MS experiment providing spectra/metadata for annotation.
[in,out]	annotated_hits	Per-spectrum candidate hits (trimmed to `top_hits` in-place).
[in]	pool_stats	Per-spectrum summary of the full candidate pool as collected by scoreSpectraAgainstIndex_(), used for the pool-derived PSM features (delta score, z-score, candidate count). Must match `annotated_hits` in size.
[out]	protein_ids	Output container for protein-level identification and search metadata.
[out]	peptide_ids	Output container for spectrum-level peptide identifications (PSMs).
[in]	top_hits	Number of top-scoring hits to retain per spectrum (report_top_hits_).
[in]	modifications_fixed	Fixed modifications (by name) used during the search.
[in]	modifications_variable	Variable modifications (by name) used during the search.
[in]	peptide_missed_cleavages	Allowed missed cleavages in digestion.
[in]	precursor_mass_tolerance	Precursor mass tolerance value.
[in]	fragment_mass_tolerance	Fragment mass tolerance value.
[in]	precursor_mass_tolerance_unit_ppm	Precursor tolerance unit ("true"->ppm, "false"->Da).
[in]	fragment_mass_tolerance_unit_ppm	Fragment tolerance unit ("true"->ppm, "false"->Da).
[in]	precursor_min_charge	Minimum precursor charge considered.
[in]	precursor_max_charge	Maximum precursor charge considered.
[in]	enzyme	Digestion enzyme name.
[out]	database_name	Database file name used for the search (stored in protein_ids).
[in]	evidence_spectra	Peak lists retained before local/top-N filtering, aligned with `exp`; required when annotate:local_fragment_evidence is enabled, otherwise unused.
[in]	evidence_parent	For the spectra of `exp` after the first evidence_spectra->size() (the residual spectra of a chimeric search), the index of the spectrum whose peak list in `evidence_spectra` they use; else `evidence_spectra` must be as long as `exp`.

◆ prepareContext() [1/2]

SearchContext prepareContext ( const std::vector< FASTAFile::FASTAEntry > & fasta_db ) const

Build a SearchContext (decoy-augmented database + FragmentIndex) for reuse.

Performs the database preparation and FragmentIndex construction steps so that subsequent calls to search(spectra, ctx, ...) can reuse the same index across many spectrum files. If decoy generation is enabled (parameter "decoys"), decoys are generated and shuffled into the returned context's db member exactly once here.

Parameters

[in] fasta_db Protein sequence database as FASTA entries.

Returns: Prepared SearchContext containing the (possibly decoy-augmented) database and the built FragmentIndex.

Thread-safety: concurrent search() calls reading the same SearchContext are safe (per FragmentIndex query thread-safety contract) as long as calibration:enabled is off. A successful calibration sets the calibrated tolerances as query parameters of the context's FragmentIndex until the call returns, so calibrated searches must not share a context concurrently. Do not call prepareContext() concurrently on the same algorithm instance.

◆ prepareContext() [2/2]

SearchContext prepareContext	(	const std::vector< FASTAFile::FASTAEntry > &	fasta_db,
		bool	electron_ions
	)		const

Build a SearchContext whose FragmentIndex also holds c and z+1 ions.

As prepareContext(fasta_db). With electron_ions, the index also holds c and z+1 ions, which ions:by_activation scores for electron-activated spectra (ETD, ECD, EThcD, ETciD). Only those spectra are matched against them, so other spectra get the same candidates as from prepareContext(fasta_db). Use it when the spectra to search contain such spectra: search() otherwise builds a temporary index with these ions for each call.

Parameters

[in]	fasta_db	Protein sequence database as FASTA entries.
[in]	electron_ions	Also index c and z+1 ions.

Returns: Prepared SearchContext.

◆ prepareContext_()

SearchContext prepareContext_	(	std::vector< FASTAFile::FASTAEntry > &&	fasta_db,
		bool	electron_ions,
		const std::function< const PeakMap *(Size)> &	searched_spectra = `{}`
	)		const

protected

prepareContext(fasta_db, electron_ions) that takes the entries of fasta_db over instead of copying them. With searched_spectra, the index holds only the peptides these spectra can reach (see FragmentIndex::build): the context then serves only one search of these spectra, without calibration.

◆ preprocessSearchedSpectra_()

void preprocessSearchedSpectra_	(	PeakMap &	spectra,
		const std::string &	input,
		FragmentIonLikelihoodModel::PeakLists &	ion_evidence,
		PeakMap *	evidence_spectra,
		PeakMap *	query_spectra
	)		const

protected

Helper: preprocessSpectra_() with the settings of the search, after warning about spectra (of input; empty: not named) that cannot be searched as intended: no MS2 spectra (e.g. an MS1-only file), MS2 spectra recorded as profile spectra, MS2 spectra whose precursor charge lies outside of the charge range (not searched). ion_evidence is filled with annotate:self_trained_ion_priors only.

◆ preprocessSpectra_() [1/2]

static void preprocessSpectra_	(	PeakMap &	exp,
		double	fragment_mass_tolerance,
		bool	fragment_mass_tolerance_unit_ppm,
		bool	deisotope_requested,
		Size	peaks_keep_n,
		Int	peaks_window_top,
		const std::string &	window_type,
		const DeisotopingSettings_ &	deisotoping,
		FragmentIonLikelihoodModel::PeakLists *	ion_evidence = `nullptr`,
		bool	ion_evidence_scored_peaks = `false`,
		PeakMap *	evidence_spectra = `nullptr`,
		PeakMap *	query_spectra = `nullptr`
	)

staticprotected

filter, deisotope, decharge spectra

deisotoping sets the envelope rule of the deisotoper (see DeisotopingSettings_).

With ion_evidence, a compact copy of every spectrum's peaks is kept for the self-trained ion priors (annotate:self_trained_ion_priors): the peaks after deisotoping, before the window and top-N filters, or, with ion_evidence_scored_peaks, the peaks that are scored. The lists are indexed like exp after its sort by RT.

With query_spectra, a copy of each spectrum after zero-intensity removal and m/z sorting, before deisotoping and local filtering, is kept for candidate retrieval (fragment:query_spectrum=raw); with evidence_spectra, a copy after deisotoping, before window/top-N filtering (annotate:local_fragment_evidence). Both are aligned with exp after its sort by RT.

◆ preprocessSpectra_() [2/2]

static void preprocessSpectra_	(	PeakMap &	exp,
		double	fragment_mass_tolerance,
		bool	fragment_mass_tolerance_unit_ppm,
		bool	deisotope_requested,
		Size	peaks_keep_n,
		Int	peaks_window_top,
		const std::string &	window_type = `"auto"`
	)

staticprotected

preprocessSpectra_() with the DeisotopingSettings_ defaults (the behaviour before its parameters existed)

◆ renderModificationSummary()

static void renderModificationSummary	(	const OpenSearchModificationAnalysis::OpenSearchAnalysisResult &	mod_analysis,
		std::ostream &	os
	)

static

Render the modification-discovery section (top PTMs, unknown delta masses) to os. Shared by the per-file and aggregate report blocks.

◆ renderRunSummary()

static void renderRunSummary	(	const RunStatistics &	stats,
		const SharedSearchStats &	shared,
		const OpenSearchModificationAnalysis::OpenSearchAnalysisResult &	mod_analysis,
		bool	is_open_search,
		std::ostream &	os
	)

static

Render a human-readable single-run summary block (configuration recap, database/index stats, identification results, tolerance estimate, timing and — for open searches — modification discovery) to os. shared carries the configuration/db/index context (built once).

◆ renderRunSummaryYaml()

static std::string renderRunSummaryYaml	(	const MultiFileSearchResult &	mfres,
		const std::vector< std::pair< std::string, std::vector< std::string > > > &	manifest,
		Size	files_failed,
		Size	files_total
	)

static

Serialize the complete end-of-search report to a machine-readable YAML string: shared configuration/database/index facts, per-file identification statistics, the output-file manifest (label -> written paths) and failed/total file counts. Hand-rolled (no YAML library dependency); every string scalar is double-quoted so values containing ':' (e.g. Windows paths) or other YAML metacharacters round-trip safely, and non-finite numbers are emitted as null.

◆ renderTotalTime()

static std::string renderTotalTime ( const SharedSearchStats & sh )

static

The total time of a run, by part: "total <s>s | search of the file(s) <s>s | outputs <s>s (of which -qpx_extended <s>s)", from sh's seconds_total, seconds_output and seconds_qpx_extended (the last part only if positive). The end of the report of renderRunSummary(), and of ProSE's report of several files.

◆ rescoreWithPercolator()

static PercolatorRescoring rescoreWithPercolator	(	std::vector< ProteinIdentification > &	protein_ids,
		PeptideIdentificationList &	peptide_ids,
		int	threads
	)

static

Rescore the PSMs of one search run in-process with Percolator, as the parameter 'rescore' does in every search.

Trains Percolator (Percolator::rescorePSMs) on the standard PIN feature set (PercolatorInfile::getStandardFeatureSet) plus the search engine features of the run (the search parameters' 'extra_features', or 'score' without them), with train_best_positive, target-decoy competition (post_processing_tdc), all PSMs for training (subset_max_train 0) and nonparametric PEPs, as the percolator executable. Percolator q-values become the main score (score type "q-value"; the SVM score and PEP are kept as meta values), only the best hit per spectrum is kept, and the runs are marked as post-processed by Percolator (search engine "Percolator", version "3.08-vendored", meta value 'percolator' and the "Percolator:*" search parameter meta values PercolatorAdapter writes).

The searches of this class call it for every run when the parameter 'rescore' is on (the default), in place of their PSM-level FDR, which then follows on the rescored PSMs (applyDeferredPsmFDR()). Call it directly only to rescore PSMs of a search with 'rescore' off, whose FDR filtering must then be off too (FDR:PSM and FDR:protein 0), so that Percolator gets all target and decoy PSMs.

The PSMs are not rescored, and stay unchanged, with fewer than 100 PSMs, without decoy PSMs or if Percolator fails; skipped_reason of the result then says why. Nothing is logged about the skip, so that the caller can report it with its context (e.g. the input file).

Parameters

[in,out]	protein_ids	The runs of the search; the first one gives the enzyme and the search engine features. Marked as post-processed by Percolator if the PSMs were rescored.
[in,out]	peptide_ids	Target and decoy PSMs of the run (with 'target_decoy' annotations and peptide evidences, as from PeptideIndexing).
[in]	threads	Threads Percolator may use: it trains one model per cross-validation fold, so more than 3 do not help (values above 3 use 3, values <= 0 use 3).

Returns: Whether the PSMs were rescored, and if not, why.

◆ residualSpectrum_()

static MSSpectrum residualSpectrum_	(	const MSSpectrum &	spectrum,
		const std::vector< UInt32 > &	removed,
		const Precursor &	precursor
	)

staticprotected

The residual spectrum of a co-isolated PSM: spectrum without the peaks removed (ascending indices), with precursor as its precursor and without the meta values of CoIsolationDetector::annotate()

◆ resolveDecoyStrategy_()

DecoyStrategy_ resolveDecoyStrategy_ ( const std::vector< FASTAFile::FASTAEntry > & db ) const

protected

Decide how to obtain/recognise decoys for db.

Detects pre-existing decoys via the common-marker heuristic (OpenMS::DecoyHelper), falling back to the configured decoy_prefix for custom markers, then maps the "decoys" mode (auto/generate/ignore) onto a concrete DecoyStrategy_.

◆ restrictIndexToSpectra_()

bool restrictIndexToSpectra_ ( ) const

inlineprotected

Whether a single-use context may index only the peptides the searched spectra can reach: not with calibration, which may change the precursor windows after the index is built, and not with chimeric search, whose co-isolated precursors the index restriction does not know.

◆ reversedNoiseSequence_()

static AASequence reversedNoiseSequence_ ( const AASequence & sequence )

staticprotected

Reversed sequence keeping the C-terminal residue and every residue's modification: the noise hypothesis of a confident PSM.

◆ runCalibrationPass_()

CalibrationResult_ runCalibrationPass_	(	PeakMap &	spectra,
		FragmentIndex &	fragment_index,
		const std::vector< FASTAFile::FASTAEntry > &	db,
		const PeakMap *	query_spectra = `nullptr`
	)		const

protected

Run a fast calibration pass on a subset of spectra to estimate mass accuracy.

Scores a TIC-ranked subset of spectra against the fragment index, collects precursor and fragment mass errors from high-confidence PSMs, and returns calibrated tolerances using median + 3*MAD estimation.

Parameters

[in]	spectra	Preprocessed MS/MS spectra (subset is selected internally by TIC).
[in,out]	fragment_index	Pre-built fragment index for candidate lookup.
[in]	db	Protein database (for sequence reconstruction of candidates).
[in]	query_spectra	Optional spectra for candidate retrieval, aligned with `spectra`.

Returns: CalibrationResult_ with estimated tolerances, or success=false if insufficient PSMs.

◆ scoreSpectraAgainstIndex_()

void scoreSpectraAgainstIndex_	(	const PeakMap &	spectra,
		FragmentIndex &	fi,
		const std::vector< FASTAFile::FASTAEntry > &	db,
		const SpectrumGenerators_ &	generators,
		double	effective_fragment_tol,
		bool	fragment_mass_tolerance_unit_ppm,
		bool	open_search_mode,
		std::vector< std::vector< AnnotatedHit_ > > &	annotated_hits,
		std::vector< CandidatePoolStats_ > &	pool_stats,
		const std::string &	progress_label,
		const PeakMap *	query_spectra = `nullptr`
	)		const

protected

Score all spectra against one FragmentIndex.

Shared by the non-chunked and chunked search paths. Appends per-scan AnnotatedHit_ entries to annotated_hits and prunes each spectrum to max(report_top_hits_, 2) candidates to bound memory. Expects a pre-built FragmentIndex whose parameters already reflect any calibrated tolerances the caller wants to apply.

Parameters

[in]	spectra	Preprocessed MS2 spectra to score.
[in]	fi	Pre-built FragmentIndex to query for candidates.
[in]	db	Database the FragmentIndex was built from, used to reconstruct candidate sequences.
[in]	generators	Generators for the theoretical spectrum of each candidate, chosen per spectrum.
[in]	effective_fragment_tol	Fragment mass tolerance to score with (calibrated, if calibration ran).
[in]	fragment_mass_tolerance_unit_ppm	Whether `effective_fragment_tol` is in ppm rather than Da.
[in]	open_search_mode	Whether to record the precursor delta mass on each hit.
[in,out]	annotated_hits	Per-spectrum candidate hits, one entry per spectrum.
[in,out]	pool_stats	Per-spectrum summary of the full (unpruned) candidate pool, one entry per spectrum. Accumulated rather than overwritten, so chunked callers can pass the same vector for every chunk.
[in]	progress_label	Label shown by the progress logger for this scoring pass.
[in]	query_spectra	Optional spectra for candidate retrieval, aligned with `spectra` (fragment:query_spectrum=raw); scoring always uses `spectra`.

◆ scoringMaxCharge_()

int scoringMaxCharge_ ( int precursor_charge ) const

inlineprotected

Fragment charges that score a candidate of the given precursor charge; also used by the calibration pass.

◆ search() [1/3]

ExitCodes search	(	const std::string &	in_spectra,
		const std::string &	in_db,
		std::vector< ProteinIdentification > &	prot_ids,
		PeptideIdentificationList &	pep_ids
	)		const

Search spectra in a spectrum file (mzML or Bruker .d) against a protein database using an FI-backed workflow.

Populates protein and peptide identifications, including search meta data, PSM hits, and search engine annotations. Parameters are taken from this instance (DefaultParamHandler).

Parameters

[in]	in_spectra	Input path to the spectra file (mzML or Bruker .d) containing MS/MS spectra to search.
[in]	in_db	Input path to the protein sequence database in FASTA format.
[out]	prot_ids	Output container receiving search meta data and protein-level information.
[out]	pep_ids	Output container receiving spectrum-level peptide identifications (PSMs).

Returns: ExitCodes indicating success (EXECUTION_OK) or the encountered error condition.

Side effects:

Updates ProgressLogger during processing.
Assigns identifiers and sets search engine name/version in prot_ids/pep_ids.

Errors:

May signal invalid parameters via ILLEGAL_PARAMETERS exit code.
May propagate OpenMS exceptions (e.g., I/O or parse errors) from underlying components.

◆ search() [2/3]

ExitCodes search	(	PeakMap &	spectra,
		const std::vector< FASTAFile::FASTAEntry > &	fasta_db,
		std::vector< ProteinIdentification > &	prot_ids,
		PeptideIdentificationList &	pep_ids
	)		const

In-memory search: search spectra against a protein database without file I/O.

Same as the file-based search() but takes pre-loaded spectra and FASTA entries directly. Spectra are preprocessed in-place (filtered, deisotoped, normalized).

Parameters

[in,out]	spectra	MS/MS spectra to search (preprocessed in-place).
[in]	fasta_db	Protein sequence database as FASTA entries.
[out]	prot_ids	Output protein-level identifications.
[out]	pep_ids	Output spectrum-level peptide identifications (PSMs).

Returns: ExitCodes indicating success or error.

Internally this is a thin wrapper around prepareContext() + the context-taking search() overload, so the FragmentIndex is rebuilt on every call. For repeated searches against the same database, prefer calling prepareContext() once and reusing the resulting SearchContext.

◆ search() [3/3]

ExitCodes search	(	PeakMap &	spectra,
		SearchContext &	ctx,
		std::vector< ProteinIdentification > &	prot_ids,
		PeptideIdentificationList &	pep_ids
	)		const

In-memory search using a pre-built SearchContext.

Searches spectra against the database and FragmentIndex held in ctx. The fragment index build cost (decoy generation, peptide/fragment generation, sorting, bucketing) is paid by prepareContext() and is not repeated here, making this overload the right choice when searching many spectrum files against the same database.

Parameters

[in,out]	spectra	MS/MS spectra to search (preprocessed in-place).
[in,out]	ctx	Pre-built SearchContext from prepareContext(). Taken by non-const reference because the underlying FragmentIndex query API is non-const, even though the index content is not modified during the search; the `db` member is also handed non-const to the downstream PeptideIndexing step (which requires a non-const reference).
[out]	prot_ids	Output protein-level identifications.
[out]	pep_ids	Output spectrum-level peptide identifications (PSMs).

Returns: ExitCodes indicating success or error.

◆ searchChunked_()

ExitCodes searchChunked_	(	PeakMap &	spectra,
		std::vector< FASTAFile::FASTAEntry > &	full_db,
		const DecoyStrategy_ &	strategy,
		std::vector< ProteinIdentification > &	protein_ids,
		PeptideIdentificationList &	peptide_ids
	)		const

protected

Chunked database search implementation.

Splits full_db into chunks of database_chunk_size_ proteins, builds a FragmentIndex per chunk, scores all spectra against each chunk, and accumulates hits before a single post-processing pass. full_db is the already-resolved database (decoys generated/stripped per strategy); strategy carries the effective decoy marker for PeptideIndexing and FDR. Taken by non-const reference because PeptideIndexing::run() mutates it.

Returns: EXECUTION_OK on success; INPUT_FILE_EMPTY / UNEXPECTED_RESULT / UNKNOWN_ERROR on PeptideIndexing failure.

◆ searchCoIsolated_()

void searchCoIsolated_	(	const PeakMap &	spectra,
		const std::vector< std::vector< AnnotatedHit_ > > &	annotated_hits,
		FragmentIndex &	fi,
		const std::vector< FASTAFile::FASTAEntry > &	db,
		const SpectrumGenerators_ &	generators,
		double	fragment_tol,
		bool	fragment_tol_ppm,
		bool	open_search_mode,
		std::vector< CoIsolatedPSM_ > &	psms,
		std::vector< std::vector< AnnotatedHit_ > > &	hits,
		std::vector< CandidatePoolStats_ > &	pool_stats
	)		const

protected

Search the precursors co-isolated with the selected one in what the spectrum's other PSMs leave of it (chimeric:enabled), after the andes chimeric cascade.

Runs one round per co-isolated precursor rank: round k searches the k-th co-isolated precursor (meta values of CoIsolationDetector::annotate()) of every spectrum with at least one hit, at its m/z and charge, against the spectrum without the peaks claimed so far. The best hit of the spectrum claims its peaks first, and the best hit of each co-isolated precursor (its winner) claims its peaks before the next round: every peak within the fragment tolerance of one of its theoretical ions. Hits with the best hit's peptide are left out. A co-isolated precursor is dropped when its winner repeats a PSM of the spectrum (the peptide and charge of a hit of the spectrum or of an earlier winner). The residual spectra are scored in batches and not kept.

Parameters

	spectra	The searched spectra
	annotated_hits	The hits of each spectrum of `spectra`
	fi	The fragment index of the search
	db	The searched database
	generators	Theoretical spectrum generators of the search
	fragment_tol	Fragment mass tolerance
	fragment_tol_ppm	Whether `fragment_tol` is in ppm (else Da)
	open_search_mode	Whether the search is an open search
[out]	psms	The co-isolated PSMs, in spectrum order and, within a spectrum, in detection order
[out]	hits	The hits of each of `psms` (at most chimeric:top_hits and report:top_hits), the winner first
[out]	pool_stats	The candidate-pool statistics of each of `psms`

◆ searchWithModificationAnalysis() [1/4]

SearchResult searchWithModificationAnalysis	(	const std::string &	in_spectra,
		const std::string &	in_db,
		const std::string &	output_base_name = `""`
	)		const

Search with comprehensive results including modification analysis tables.

This method performs a peptide database search and additionally returns structured modification analysis results for open search mode. This is the recommended method for modification discovery workflows.

The method automatically:

Detects open search mode based on precursor tolerance
Computes delta mass statistics
Maps delta masses to known modifications
Generates PTM statistics with residue localization
Writes TSV output files if output_base_name is provided
Applies FDR:protein as search() does, after the modification analysis

Parameters

in_spectra	Input path to the spectra file (mzML or Bruker .d) containing MS/MS spectra
in_db	Input path to the protein sequence database in FASTA format
output_base_name	Optional base name for output files (TSV tables)

Returns: SearchResult containing identifications and modification analysis

Example usage:

ProSEAlgorithm algo;
Param p = algo.getParameters();
p.setValue("precursor:mass_tolerance_lower", 500.0);  // Open search
p.setValue("precursor:mass_tolerance_upper", 500.0);
p.setValue("precursor:mass_tolerance_unit", "Da");
algo.setParameters(p);
 
auto result = algo.searchWithModificationAnalysis("spectra.mzML", "database.fasta", "output");
if (result.exit_code == ExitCodes::EXECUTION_OK && result.is_open_search)
{
  // Access PTM statistics
  for (const auto& ptm : result.modification_analysis.ptm_stats.entries)
  {
    std::cout << ptm.name << ": " << ptm.count << " PSMs" << std::endl;
  }
 
  // Access delta mass statistics
  for (const auto& dm : result.modification_analysis.delta_mass_stats.entries)
  {
    std::cout << dm.delta_mass << " Da: " << dm.count << " PSMs" << std::endl;
  }
}

◆ searchWithModificationAnalysis() [2/4]

MultiFileSearchResult searchWithModificationAnalysis	(	const std::vector< std::string > &	in_spectra_files,
		const std::string &	in_db,
		const std::vector< std::string > &	output_base_names = `{}`,
		const std::string &	aggregate_base_name = `""`,
		bool	build_pooled_aggregate = `true`
	)		const

Multi-file search with modification analysis (FASTA file path).

Convenience overload that loads the FASTA database from in_db and delegates to the in-memory multi-file overload. The database file path is recorded in each per-file ProteinIdentification's SearchParameters (and on the aggregate result).

build_pooled_aggregate is forwarded unchanged; see the in-memory overload for its exact effect on aggregate.

See also: searchWithModificationAnalysis(const std::vector<std::string>&, const std::vector<FASTAFile::FASTAEntry>&, const std::vector<std::string>&, const std::string&, bool) const

◆ searchWithModificationAnalysis() [3/4]

MultiFileSearchResult searchWithModificationAnalysis	(	const std::vector< std::string > &	in_spectra_files,
		const std::vector< FASTAFile::FASTAEntry > &	fasta_db,
		const std::vector< std::string > &	output_base_names = `{}`,
		const std::string &	aggregate_base_name = `""`,
		bool	build_pooled_aggregate = `true`
	)		const

Multi-file search with modification analysis (in-memory FASTA).

Builds a single SearchContext (decoy generation + FragmentIndex) from fasta_db and reuses it across all input spectrum files. Each input file produces its own SearchResult including a per-file modification analysis (TSV written if a non-empty per-file base name is provided). An additional aggregate SearchResult is computed by pooling all per-file peptide identifications and running modification analysis once on the pooled set (see build_pooled_aggregate to skip retaining that second copy of every PSM).

Progress: the search of each input file is a progress step of its own, labelled "Searching <file name> (i of n)..." (i from 1, in input order). Consumers identify the per-file step by this label. Every start of a per-file step is balanced by its end, also if the search of the file fails or throws; the steps nested in it are not exception-safe (one that an exception leaves stays open). The steps of the search of the file (index build, filtering, scoring, ...) nest one level below it (depth 0 for the per-file step, depth 1 inside), but this nesting holds only with one OpenMP thread: with more, the background reading of the next mzML file shares the static step depth of the ProgressLogger, and the depths reported are not reliable. Chunk-major searches (database:chunk_size > 0 with a database of more proteins, decoys included, than the chunk size) emit no per-file step.

Parameters

[in]	in_spectra_files	Spectrum file paths (mzML or Bruker .d).
[in]	fasta_db	Protein sequence database as FASTA entries.
[in]	output_base_names	Optional per-file base names for modification-analysis TSV outputs. Must be empty or have the same length as `in_spectra_files`. Empty entries skip TSV writing for that file.
[in]	aggregate_base_name	Optional base name for the aggregate modification-analysis TSV output. Empty disables aggregate TSV writing (the aggregate analysis is still computed).
[in]	build_pooled_aggregate	Whether the pooled PSM set is retained in `aggregate`. Pooling copies every per-file PSM a second time, so callers that never read `aggregate.peptide_ids` should pass false. With false, `aggregate.protein_ids` and `aggregate.peptide_ids` come back empty (only `is_open_search` and `exit_code` are set); the aggregate modification analysis is unaffected — in open search the pooled set is still built internally, analyzed, and then released. Default true (unchanged behavior).

Returns: MultiFileSearchResult bundling per-file results and aggregate.

Errors:

Throws Exception::InvalidParameter if output_base_names is non-empty and its size differs from in_spectra_files.

◆ searchWithModificationAnalysis() [4/4]

SearchResult searchWithModificationAnalysis	(	PeakMap &	spectra,
		const std::vector< FASTAFile::FASTAEntry > &	fasta_db,
		const std::string &	output_base_name = `""`
	)		const

In-memory search with modification analysis: no file I/O required.

Same as the file-based searchWithModificationAnalysis() but takes pre-loaded data.

Parameters

[in,out]	spectra	MS/MS spectra (preprocessed in-place).
[in]	fasta_db	Protein sequence database as FASTA entries.
[in]	output_base_name	Optional base name for TSV output files.

Returns: SearchResult containing identifications and modification analysis.

◆ setKeepPreFdrPsms()

void setKeepPreFdrPsms ( bool keep )

inline

With keep = true, the multi-file searchWithModificationAnalysis() overloads also return the PSMs of each file before the rescoring ('rescore') and FDR:PSM, in SearchResult::pre_fdr_peptide_ids (e.g. for a Percolator .pin): the search engine scores, every reported hit and the decoys. Default: false (no copy).

◆ spectrumGenerators_()

SpectrumGenerators_ spectrumGenerators_ ( ) const

protected

Generators for scoring, annotation and calibration, configured from the ions:* parameters.

◆ updateFinalStats()

static void updateFinalStats	(	RunStatistics &	stats,
		const PeptideIdentificationList &	peptide_ids,
		const std::string &	enzyme,
		bool	fdr_applied
	)

static

Recompute result-level statistics (matched count, unique peptide/protein counts, charge & missed-cleavage histograms, target/decoy counts and achieved PSM FDR) from a FINAL, post-processed PSM list. Use this when the identifications are mutated AFTER search() returns — e.g. the ProSE TOPP tool's Percolator rescoring + deferred FDR — so the report reflects what the user actually receives. Does NOT touch ms2_spectra, the HyperScore distribution (captured pre-FDR during the search) or any timing field. fdr_applied records whether a PSM-level FDR filter was applied; when true achieved_psm_fdr is set to the maximum retained q-value.

◆ updateMembers_()

void updateMembers_ ( )

overrideprotectedvirtual

This method is used to update extra member variables at the end of the setParameters() method.

Also call it at the end of the derived classes' copy constructor and assignment operator.

The default implementation is empty.

bool chimeric_enabled_ {false}

protected

chimeric:enabled: also search the precursors co-isolated with the selected one

◆ CHIMERIC_RANK

constexpr const char* CHIMERIC_RANK = "chimeric_rank"

staticconstexpr

PSM meta value of a chimeric search (chimeric:enabled): 1 for a PSM of the selected precursor, 2 for one of a precursor co-isolated with it

◆ database_chunk_size_

Size database_chunk_size_ {0}

protected

0 = disabled; >0 = chunk DB into groups of this many proteins

◆ decoy_mode_

DecoyMode_ decoy_mode_ {DecoyMode_::AUTO}

protected

double mass_error_sd_ppm_ {7.0}

protected

Width of the mass-accuracy kernel in ppm (scoring:mass_error_sd)

◆ modifications_fixed_

StringList modifications_fixed_

protected

◆ modifications_max_variable_mods_per_peptide_

Size modifications_max_variable_mods_per_peptide_

protected

◆ precursor_mass_tolerance_lower_

double precursor_mass_tolerance_lower_ {10.0}

mutableprotected

positive magnitude (default matches the param)

Calibration overwrites these with the calibrated magnitudes for the duration of search(); pure runtime-state mutation that does not affect the logical const-ness of search(), matching the mutable pattern used by last_calibration_result_.

◆ precursor_mass_tolerance_unit_

std::string precursor_mass_tolerance_unit_ {"ppm"}

protected

◆ precursor_mass_tolerance_upper_

double precursor_mass_tolerance_upper_ {10.0}

mutableprotected

positive magnitude (default matches the param)

◆ precursor_max_charge_

Size precursor_max_charge_

protected

Size report_top_hits_

protected

◆ rescore_

bool rescore_ {true}

protected

rescore: Percolator rescoring of every run before its PSM-level FDR

◆ scoring_max_charge_

int scoring_max_charge_ {2}

protected

Upper fragment charge bound (fragment:max_charge)

◆ scoring_multiple_charges_

bool scoring_multiple_charges_ {false}

protected

Resolved scoring:fragment_charges: score charges above 1.

◆ self_trained_ion_priors_

bool self_trained_ion_priors_ {false}

protected

annotate:self_trained_ion_priors

Classes

Public Types

Public Member Functions

Static Public Member Functions

Static Public Attributes

Protected Types

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Private Member Functions

Additional Inherited Members

Detailed Description

Class Documentation

◆ OpenMS::ProSEAlgorithm::CalibrationResult_

◆ OpenMS::ProSEAlgorithm::CoIsolatedPSM_

◆ OpenMS::ProSEAlgorithm::DecoyStrategy_

◆ OpenMS::ProSEAlgorithm::DeisotopingSettings_

◆ OpenMS::ProSEAlgorithm::LocalFragmentEvidence_

◆ OpenMS::ProSEAlgorithm::MergedResult

◆ OpenMS::ProSEAlgorithm::MultiFileSearchResult

◆ OpenMS::ProSEAlgorithm::PercolatorRescoring

◆ OpenMS::ProSEAlgorithm::RunStatistics

◆ OpenMS::ProSEAlgorithm::SearchContext

◆ OpenMS::ProSEAlgorithm::SearchResult

◆ OpenMS::ProSEAlgorithm::SharedSearchStats

◆ OpenMS::ProSEAlgorithm::SpectraCounts_

Member Enumeration Documentation

◆ DecoyMode_

◆ ExitCodes

Constructor & Destructor Documentation

◆ ProSEAlgorithm()

Member Function Documentation

◆ accessionHasDecoyMarker_()

◆ annotateIonPriors_()

◆ annotatePeptDeepFeatures_()

◆ annotatePsmQValues()

◆ applyCompleteSetProteinFDR()

◆ applyDeferredPsmFDR()

◆ applyProteinMapping_()

◆ applyPsmFDR_()

◆ buildCalibrationSample_()

◆ buildDecoyAugmentedDB_() [1/2]

◆ buildDecoyAugmentedDB_() [2/2]

◆ buildProteinMapping_()

◆ capturePreFdrStats_()

◆ chimericSearch_()

◆ collectInferenceOnlyPsms_()

◆ collectRunStatistics_()

◆ computeModMatchTolerance_()

◆ countElectronActivated_()

◆ countSpectra_()

◆ filterLocalPeaks_()

◆ fragmentIndexParameters_()

◆ inferProteins()

◆ isElectronActivated_()

◆ isOpenSearchMode_()

◆ loadSpectra()

◆ localFragmentEvidence_() [1/2]

◆ localFragmentEvidence_() [2/2]

◆ localPeakDensities_()

◆ maxRetainedScore_()

◆ mergeFileResults()

◆ poolSearchedFiles_()

◆ postProcessHits_()

◆ prepareContext() [1/2]

◆ prepareContext() [2/2]

◆ prepareContext_()

◆ preprocessSearchedSpectra_()

◆ preprocessSpectra_() [1/2]

◆ preprocessSpectra_() [2/2]

◆ renderModificationSummary()

◆ renderRunSummary()

◆ renderRunSummaryYaml()

◆ renderTotalTime()

◆ rescoreWithPercolator()

◆ residualSpectrum_()

◆ resolveDecoyStrategy_()

◆ restrictIndexToSpectra_()

◆ reversedNoiseSequence_()

◆ runCalibrationPass_()