Struct ScoredFeature 

pub struct ScoredFeature {
    pub feature: Feature,
    pub neutron_offset: i8,
    pub isotope_score: f64,
    pub cosine_score: f64,
    pub combined_score: f64,
    pub theoretical_pattern: Vec<f64>,
}

Feature with isotope pattern scoring applied.

Carries three distinct quality scores so downstream stages (alignment, consensus grouping, LFQ filters) can filter on whichever makes sense for their purpose. All three are bounded [0, 1]; higher = better.

Fields

feature: Feature

neutron_offset: i8

Neutron offset applied: -1, 0, or 1. Non-zero means the observed monoisotopic peak is actually M+|offset|.

isotope_score: f64

Isotope-pattern score: Bhattacharyya coefficient between the observed apex-scan isotope intensities and the theoretical averagine template. Measures “does the isotope envelope look like a peptide?”.

cosine_score: f64

Chromatographic cosine score: mirror of feature.cosine_score — the mean cosine similarity (in time domain) between adjacent isotope hills. Measures “do the isotope hills co-elute?”.

combined_score: f64

Combined score: isotope_score × cosine_score. The default quality knob used by alignment, consensus grouping, and feature retention. High requires both a good pattern match AND tight co-elution.

theoretical_pattern: Vec<f64>

Theoretical averagine isotope pattern (normalized to sum=1)

Implementations

impl ScoredFeature

pub fn monoisotopic_mz(&self) -> f64

Corrected monoisotopic m/z (adjusted by neutron_offset).

Examples found in repository

examples/lfq_member_geometry.rs (line 65)

fn main() -> anyhow::Result<()> {
    let args: Vec<_> = std::env::args().skip(1).collect();
    anyhow::ensure!(
        args.len() == 5,
        "usage: lfq_member_geometry BATCH CONFIG MEMBERS_TSV OUT_TSV ID,ID"
    );
    let cfg = AlignConfig::from_toml(&PathBuf::from(&args[1]))?;
    let paths = discover_runs(&PathBuf::from(&args[0]))?;
    let runs: Vec<_> = paths
        .iter()
        .map(|r| {
            Ok(RunInput {
                name: r.name.clone(),
                features: read_features(&r.features_path)?,
                hills: Vec::new(),
                scan_times: Vec::new(),
                rt_bounds: None,
            })
        })
        .collect::<anyhow::Result<_>>()?;
    check_batch_mobility_scales(
        paths
            .iter()
            .zip(&runs)
            .map(|(p, r)| (p, r.features.as_slice())),
    )?;
    let alignment = align_runs(&runs, &cfg.alignment);
    let ids: HashSet<usize> = args[4]
        .split(',')
        .map(str::parse)
        .collect::<Result<_, _>>()?;
    let mut input = csv::ReaderBuilder::new()
        .delimiter(b'\t')
        .from_path(&args[2])?;
    let mut output = csv::WriterBuilder::new()
        .delimiter(b'\t')
        .from_path(&args[3])?;
    output.write_record([
        "candidate_id",
        "run_id",
        "feature_idx",
        "mass",
        "rt",
        "im",
        "quality",
        "is_primary",
        "neutron_offset",
    ])?;
    for row in input.records() {
        let row = row?;
        let id: usize = row[0].parse()?;
        if !ids.contains(&id) {
            continue;
        }
        let r: usize = row[1].parse()?;
        let f: usize = row[2].parse()?;
        let feat = &runs[r].features[f];
        let mz = feat.monoisotopic_mz();
        let rt = feat.feature.rt_apex();
        let im = feat.feature.im_apex();
        let (mz, rt, im) = if r == alignment.reference_idx {
            (mz, rt, im)
        } else {
            let a = &alignment.alignments[&runs[r].name];
            (a.correct_mz(mz, rt), a.warp_rt(rt), a.correct_im(im, rt))
        };
        let mass = (mz - 1.007276466621) * feat.feature.charge as f64;
        output.write_record([
            id.to_string(),
            r.to_string(),
            f.to_string(),
            mass.to_string(),
            rt.to_string(),
            im.to_string(),
            feat.combined_score.to_string(),
            row[3].to_string(),
            feat.neutron_offset.to_string(),
        ])?;
    }
    output.flush()?;
    Ok(())
}

pub fn monoisotopic_neutral_mass(&self, polarity: Polarity) -> Option<f64>

Corrected neutral monoisotopic mass.

Examples found in repository

examples/streaming_api.rs (line 54)

fn uno_style(path: &std::path::Path, config: &KothConfig) {
    // One call, everything owned in memory. No files touched.
    let out = run_pipeline(path, config, &PipelineOptions::default()).expect("pipeline");

    // uno searches MS1 features by neutral mass + charge + RT.
    let searchable: Vec<&ScoredFeature> = out
        .features
        .iter()
        .filter(|f| f.feature.charge > 0) // same set the features file would hold
        .collect();

    println!(
        "[uno] {} hills, {} charged features available for MS1 search",
        out.hills.len(),
        searchable.len()
    );
    if let Some(top) = searchable.iter().max_by(|a, b| {
        a.feature
            .total_intensity()
            .partial_cmp(&b.feature.total_intensity())
            .unwrap()
    }) {
        println!(
            "[uno]   most intense: mass {:?} z{} score {:.3}",
            top.monoisotopic_neutral_mass(koth_ms::Polarity::Positive),
            top.feature.charge,
            top.combined_score
        );
    }
}

Trait Implementations

impl Clone for ScoredFeature

fn clone(&self) -> ScoredFeature

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ScoredFeature

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

Formats the value using the given formatter.