Struct Feature 

pub struct Feature {
    pub hills: Vec<Hill>,
    pub charge: u8,
    pub cosine_score: f64,
    pub ppm_error: f64,
}

A detected isotope feature: a group of hills forming an isotope envelope.

hills are sorted by mz (monoisotopic first). charge == 0 means unknown charge (single peak, no isotope partners found).

Fields

hills: Vec<Hill>

charge: u8

cosine_score: f64

Mean chromatographic cosine similarity (in scan/RT space) between adjacent isotope hills in the chain. Bounded [0, 1]. Measures whether the isotope hills co-elute in time — not whether their intensities match an averagine pattern.

ppm_error: f64

Implementations

impl Feature

pub fn monoisotopic_hill(&self) -> &Hill

pub fn monoisotopic_mz(&self) -> f64

Examples found in repository

examples/streaming_api.rs (line 126)

fn tracer_with_ms2(path: &std::path::Path, config: &KothConfig) {
    // `run_pipeline_with_ms2` forces MS2 emission on; equivalently, set
    // `PipelineOptions { emit_ms2: true, ..Default::default() }` on any entry.
    let out = run_pipeline_with_ms2(path, config, &PipelineOptions::default())
        .expect("pipeline with ms2");

    // Group the flat MS2 hill set into DIA channels (each hill already carries
    // its window in `hill.isolation_window`; this is just the convenience view).
    let windows: Vec<(IsolationWindow, Vec<Hill>)> = group_ms2_hills_by_window(out.ms2_hills);
    println!(
        "[tracer+ms2] {} MS1 features, {} DIA isolation windows",
        out.features.len(),
        windows.len()
    );

    // Precursor -> window mapping: a precursor feature is isolated by every
    // window whose [lower, upper] contains its (charge-1) precursor m/z.
    for f in out.features.iter().filter(|f| f.feature.charge > 0).take(3) {
        let mz = f.feature.monoisotopic_mz(); // precursor m/z of the feature
        let isolating: Vec<&(IsolationWindow, Vec<Hill>)> = windows
            .iter()
            .filter(|(w, _)| w.lower <= mz && mz <= w.upper)
            .collect();
        let n_frag: usize = isolating.iter().map(|(_, hs)| hs.len()).sum();
        println!(
            "[tracer+ms2]   precursor m/z {:.4} z{} -> {} window(s), {} candidate fragment hills",
            mz,
            f.feature.charge,
            isolating.len(),
            n_frag
        );
    }
}

pub fn faims_cv(&self) -> Option<f32>

FAIMS compensation voltage of this feature, inherited from its monoisotopic hill. Feature assembly guarantees all member hills share this value.

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

Neutral monoisotopic mass, undoing polarity’s adduct (mz·z ∓ z·proton).

pub fn rt_apex(&self) -> f64

Examples found in repository

examples/lfq_member_geometry.rs (line 66)

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 rt_start(&self) -> f64

pub fn rt_end(&self) -> f64

pub fn im_apex(&self) -> f64

Examples found in repository

examples/lfq_member_geometry.rs (line 67)

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 total_intensity(&self) -> f64

Examples found in repository

examples/streaming_api.rs (line 48)

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
        );
    }
}

// ---------------------------------------------------------------------------
// koth_tracer-style consumer: take ownership of the hill set to build a trace
// index, then fold features incrementally without holding the whole vector.
// ---------------------------------------------------------------------------
#[derive(Default)]
struct TracerSink {
    hills: Vec<Hill>, // owned once, up front — used to trace precursor<->fragment
    n_features: usize,
    total_intensity: f64,
}

impl PipelineSink for TracerSink {
    fn on_hills(&mut self, hills: Vec<Hill>) {
        // koth_tracer indexes the finalized hill set here (m/z, RT, IM) so it
        // can attribute fragment hills to precursor features as they arrive.
        println!("[tracer] indexing {} finalized hills", hills.len());
        self.hills = hills;
    }

    fn on_feature(&mut self, feature: ScoredFeature) {
        // Consume-and-drop: fold each feature into whatever the tracer keeps.
        // The full feature vector is never materialized on the consumer side.
        let f: &Feature = &feature.feature;
        self.total_intensity += f.total_intensity();
        self.n_features += 1;
        // `feature` is dropped here, freeing its memory before the next arrives.
    }

pub fn n_scans_total(&self) -> usize

pub fn elution_profile(&self) -> (usize, usize, Vec<f64>)

Combined elution profile: sum of all isotope hill intensities per scan. Returns (min_scan, max_scan, profile_vec).

pub fn total_intensity_at_apex(&self) -> f64

Total intensity at the apex scan (summed across all isotope hills).

pub fn apex_scan(&self) -> usize

Apex scan index: scan where the sum of all isotope hill intensities is highest.

pub fn isotope_profile_apex(&self) -> Vec<f64>

Isotope profile at the apex scan: one intensity per hill.

pub fn mono_scan_list(&self) -> Vec<usize>

Scan list for monoisotopic hill.

pub fn mono_intensity_list(&self) -> &[f32]

Intensity list for monoisotopic hill.

Trait Implementations

impl Clone for Feature

fn clone(&self) -> Feature

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Feature

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

Formats the value using the given formatter.