Struct FeatureProcessor 

pub struct FeatureProcessor<Y: Clone + Default, I: IsotopicPatternGenerator, S: IsotopicPatternScorer, F: IsotopicFitFilter> {
    pub feature_map: IndexedFeatureMap<Y>,
    pub isotopic_model: I,
    pub scorer: S,
    pub fit_filter: F,
    pub scaling_method: TheoreticalIsotopicDistributionScalingMethod,
    pub prefer_multiply_charged: bool,
    pub minimum_size: usize,
    pub maximum_time_gap: f64,
    pub minimum_intensity: f32,
    /* private fields */
}

Fields

feature_map: IndexedFeatureMap<Y>

isotopic_model: I

scorer: S

fit_filter: F

scaling_method: TheoreticalIsotopicDistributionScalingMethod

prefer_multiply_charged: bool

minimum_size: usize

maximum_time_gap: f64

minimum_intensity: f32

Implementations

impl<Y: Clone + Default, I: IsotopicPatternGenerator, S: IsotopicPatternScorer, F: IsotopicFitFilter> FeatureProcessor<Y, I, S, F>

pub fn new( feature_map: FeatureMap<MZ, Y, Feature<MZ, Y>>, isotopic_model: I, scorer: S, fit_filter: F, minimum_size: usize, maximum_time_gap: f64, minimum_intensity: f32, prefer_multiply_charged: bool, ) -> Self

pub fn builder() -> FeatureProcessorBuilder<Y, I, S, F>

pub fn finalize_fit( &mut self, fit: &FeatureSetFit, detection_threshold: f32, max_missed_peaks: usize, ) -> DeconvolvedSolutionFeature<Y>

pub fn deconvolve( &mut self, error_tolerance: Tolerance, charge_range: ChargeRange, left_search_limit: i8, right_search_limit: i8, search_params: &FeatureSearchParams, convergence: f32, max_iterations: u32, ) -> Result<FeatureMap<Mass, Y, DeconvolvedSolutionFeature<Y>>, DeconvolutionError>

Trait Implementations

impl<Y: Debug + Clone + Default, I: Debug + IsotopicPatternGenerator, S: Debug + IsotopicPatternScorer, F: Debug + IsotopicFitFilter> Debug for FeatureProcessor<Y, I, S, F>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<Y: Clone + Default, I: IsotopicPatternGenerator, S: IsotopicPatternScorer, F: IsotopicFitFilter> FeatureIsotopicFitter<Y> for FeatureProcessor<Y, I, S, F>

fn make_isotopic_pattern( &mut self, mz: f64, charge: i32, search_params: &FeatureSearchParams, ) -> TheoreticalIsotopicPattern

fn fit_theoretical_distribution_on_features( &self, mz: f64, error_tolerance: Tolerance, charge: i32, base_tid: TheoreticalIsotopicPattern, max_missed_peaks: usize, threshold_scale: f32, feature: &Option<CoordinateRange<Y>>, ) -> Vec<FeatureSetFit>

fn fit_theoretical_distribution( &mut self, feature: usize, error_tolerance: Tolerance, charge: i32, left_search: i8, right_search: i8, search_params: &FeatureSearchParams, ) -> Vec<FeatureSetFit>

fn fit_feature_set( &mut self, mz: f64, error_tolerance: Tolerance, charge: i32, search_params: &FeatureSearchParams, feature: &Option<CoordinateRange<Y>>, ) -> Vec<FeatureSetFit>

impl<Y: Clone + Default, I: IsotopicPatternGenerator, S: IsotopicPatternScorer, F: IsotopicFitFilter> FeatureMapMatch<Y> for FeatureProcessor<Y, I, S, F>

fn feature_map(&self) -> &IndexedFeatureMap<Y>

fn feature_map_mut(&mut self) -> &mut IndexedFeatureMap<Y>

fn find_all_features( &self, mz: f64, error_tolerance: Tolerance, ) -> Vec<(usize, &IndexedFeature<Y>)>

fn find_features( &self, mz: f64, error_tolerance: Tolerance, interval: &Option<CoordinateRange<Y>>, ) -> Option<Vec<(usize, &IndexedFeature<Y>)>>

fn match_theoretical_isotopic_distribution( &self, theoretical_distribution: &TheoreticalIsotopicPattern, error_tolerance: Tolerance, interval: &Option<CoordinateRange<Y>>, ) -> Vec<Option<Vec<(usize, &'_ IndexedFeature<Y>)>>>

impl<Y: Clone + Default, I: IsotopicPatternGenerator, S: IsotopicPatternScorer, F: IsotopicFitFilter> GraphFeatureDeconvolution<Y> for FeatureProcessor<Y, I, S, F>

fn score_interpretation(&self) -> ScoreInterpretation

fn add_fit_to_graph(&mut self, fit: FeatureSetFit)

fn prefer_multiply_charged(&self) -> bool

fn skip_feature(&self, feature: &IndexedFeature<Y>) -> bool

fn dependency_graph_mut(&mut self) -> &mut FeatureDependenceGraph

fn populate_graph( &mut self, error_tolerance: Tolerance, charge_range: ChargeRange, left_search: i8, right_search: i8, search_params: &FeatureSearchParams, ) -> usize

fn explore_local<Z: ChargeIterator>( &mut self, feature: usize, error_tolerance: Tolerance, charge_range: Z, left_search: i8, right_search: i8, search_params: &FeatureSearchParams, ) -> usize

fn collect_all_fits<Z: ChargeIterator>( &mut self, feature: usize, error_tolerance: Tolerance, charge_range: Z, left_search: i8, right_search: i8, search_params: &FeatureSearchParams, ) -> usize

fn solve_subgraph_top( &mut self, cluster: DependenceCluster, fits: Vec<(FitRef, FeatureSetFit)>, fit_accumulator: &mut Vec<FeatureSetFit>, ) -> Result<(), DeconvolutionError>

fn select_best_disjoint_subgraphs( &mut self, fit_accumulator: &mut Vec<FeatureSetFit>, ) -> Result<(), DeconvolutionError>

fn graph_step_deconvolve( &mut self, error_tolerance: Tolerance, charge_range: ChargeRange, left_search: i8, right_search: i8, search_params: &FeatureSearchParams, ) -> Result<GraphStepResult, DeconvolutionError>