Struct IntensityMatrix 

pub struct IntensityMatrix {

    pub search_guidance: Option<SearchGuidance>,
    pub consensus: Vec<ConsensusFeature>,
    pub n_features: usize,
    pub n_runs: usize,
    pub run_names: Vec<String>,
    pub reference_run: String,
    pub feature_mz: Vec<f64>,
    pub feature_mass: Vec<f64>,
    pub feature_charge: Vec<u8>,
    pub feature_rt: Vec<f64>,
    pub feature_im: Vec<f64>,
    pub feature_combined_score: Vec<f64>,
    pub feature_seed_run: Vec<String>,
    pub feature_n_contributing_runs: Vec<usize>,
    pub hills_per_run: Vec<usize>,
    pub intensities: Vec<f64>,
    pub q_values: Vec<f64>,
    pub decoy_intensities: Vec<f64>,
    pub entries: Vec<LfqEntry>,
}

Final intensity matrix: features (rows) × runs (columns).

Fields

search_guidance: Option<SearchGuidance>

Peptide identities and donor evidence, present only in search-guided mode.

consensus: Vec<ConsensusFeature>

Original consensus membership retained for long-format evidence export.

n_features: usize

n_runs: usize

run_names: Vec<String>

reference_run: String

feature_mz: Vec<f64>

feature_mass: Vec<f64>

feature_charge: Vec<u8>

feature_rt: Vec<f64>

feature_im: Vec<f64>

feature_combined_score: Vec<f64>

Seed feature’s combined_score (isotope × chromato cosine) per consensus row.

feature_seed_run: Vec<String>

Name of the run that provided the seed feature for each consensus row.

feature_n_contributing_runs: Vec<usize>

Number of runs that contributed at least one detection to each consensus group.

hills_per_run: Vec<usize>

Hill count per run (recorded as each run’s hills were streamed in).

intensities: Vec<f64>

q_values: Vec<f64>

decoy_intensities: Vec<f64>

Decoy intensities, same flat layout as intensities. All zeros when run_tdc = false.

entries: Vec<LfqEntry>

Full per-(feature, run) target + decoy entries with detail stats. Empty when run_tdc = false and details are not requested.

Implementations

impl IntensityMatrix

pub fn intensity(&self, feat: usize, run: usize) -> f64

Examples found in repository

examples/support/lfq_matrices.rs (line 52)

pub fn matrices(m: &IntensityMatrix, folder: &Path) -> anyhow::Result<()> {
    let meta = [
        "massCalib",
        "mz",
        "charge",
        "rtApex",
        "im",
        "combined_score",
        "seed_run",
        "n_contributing_runs",
    ];
    for (kind, name) in [
        "consensus_features.tsv",
        "intensity_matrix.tsv",
        "qvalue_matrix.tsv",
        "decoy_intensity_matrix.tsv",
    ]
    .iter()
    .enumerate()
    {
        let mut out = csv::WriterBuilder::new()
            .delimiter(b'\t')
            .from_path(folder.join(name))?;
        let mut header: Vec<String> = meta.iter().map(|s| s.to_string()).collect();
        if kind == 0 {
            header.extend(["n_runs_detected", "group_score", "group_qvalue"].map(String::from));
        } else {
            header.extend(m.run_names.clone());
        }
        out.write_record(header)?;
        for (i, g) in m.consensus.iter().enumerate() {
            let mut row = vec![
                format!("{:.6}", g.neutral_mass),
                format!("{:.6}", g.ref_mz),
                g.charge.to_string(),
                format!("{:.6}", g.ref_rt),
                if g.ref_im == 0.0 {
                    String::new()
                } else {
                    format!("{:.6}", g.ref_im)
                },
                format!("{:.6}", g.seed_combined_score),
                m.run_names[g.seed_run_idx].clone(),
                g.n_contributing_runs.to_string(),
            ];
            if kind == 0 {
                row.extend([
                    (0..m.n_runs)
                        .filter(|&r| m.intensity(i, r) > 0.0)
                        .count()
                        .to_string(),
                    format!("{:.6}", g.group_score),
                    format!("{:.6}", g.group_qvalue),
                ]);
            } else {
                for r in 0..m.n_runs {
                    let v = match kind {
                        1 => m.intensity(i, r),
                        2 => m.q_value(i, r),
                        _ => m.decoy_intensity(i, r),
                    };
                    row.push(if kind == 2 {
                        format!("{v:.4}")
                    } else if v > 0.0 {
                        format!("{v:.5e}")
                    } else {
                        "0".into()
                    });
                }
            }
            out.write_record(row)?;
        }
        out.flush()?;
    }
    let mut audit = csv::WriterBuilder::new()
        .delimiter(b'\t')
        .from_path(folder.join("ownership.tsv"))?;
    audit.write_record([
        "feature_idx",
        "run_idx",
        "is_decoy",
        "intensity",
        "ownership_status",
        "owned_samples",
        "excluded_samples",
        "competing_feature",
        "apex_rt",
        "bhattacharyya",
        "coelution",
        "preceding_signal_fraction",
    ])?;
    for e in &m.entries {
        audit.write_record([
            e.feature_idx.to_string(),
            e.run_idx.to_string(),
            e.is_decoy.to_string(),
            e.intensity.to_string(),
            e.ownership_status.to_string(),
            e.owned_samples.to_string(),
            e.excluded_samples.to_string(),
            e.competing_feature
                .map(|i| i.to_string())
                .unwrap_or_default(),
            e.apex_rt.to_string(),
            e.spectral_bhattacharyya.to_string(),
            e.coelution.to_string(),
            e.preceding_signal_fraction.to_string(),
        ])?;
    }
    audit.flush()?;
    Ok(())
}

pub fn q_value(&self, feat: usize, run: usize) -> f64

Examples found in repository

examples/support/lfq_matrices.rs (line 62)

pub fn matrices(m: &IntensityMatrix, folder: &Path) -> anyhow::Result<()> {
    let meta = [
        "massCalib",
        "mz",
        "charge",
        "rtApex",
        "im",
        "combined_score",
        "seed_run",
        "n_contributing_runs",
    ];
    for (kind, name) in [
        "consensus_features.tsv",
        "intensity_matrix.tsv",
        "qvalue_matrix.tsv",
        "decoy_intensity_matrix.tsv",
    ]
    .iter()
    .enumerate()
    {
        let mut out = csv::WriterBuilder::new()
            .delimiter(b'\t')
            .from_path(folder.join(name))?;
        let mut header: Vec<String> = meta.iter().map(|s| s.to_string()).collect();
        if kind == 0 {
            header.extend(["n_runs_detected", "group_score", "group_qvalue"].map(String::from));
        } else {
            header.extend(m.run_names.clone());
        }
        out.write_record(header)?;
        for (i, g) in m.consensus.iter().enumerate() {
            let mut row = vec![
                format!("{:.6}", g.neutral_mass),
                format!("{:.6}", g.ref_mz),
                g.charge.to_string(),
                format!("{:.6}", g.ref_rt),
                if g.ref_im == 0.0 {
                    String::new()
                } else {
                    format!("{:.6}", g.ref_im)
                },
                format!("{:.6}", g.seed_combined_score),
                m.run_names[g.seed_run_idx].clone(),
                g.n_contributing_runs.to_string(),
            ];
            if kind == 0 {
                row.extend([
                    (0..m.n_runs)
                        .filter(|&r| m.intensity(i, r) > 0.0)
                        .count()
                        .to_string(),
                    format!("{:.6}", g.group_score),
                    format!("{:.6}", g.group_qvalue),
                ]);
            } else {
                for r in 0..m.n_runs {
                    let v = match kind {
                        1 => m.intensity(i, r),
                        2 => m.q_value(i, r),
                        _ => m.decoy_intensity(i, r),
                    };
                    row.push(if kind == 2 {
                        format!("{v:.4}")
                    } else if v > 0.0 {
                        format!("{v:.5e}")
                    } else {
                        "0".into()
                    });
                }
            }
            out.write_record(row)?;
        }
        out.flush()?;
    }
    let mut audit = csv::WriterBuilder::new()
        .delimiter(b'\t')
        .from_path(folder.join("ownership.tsv"))?;
    audit.write_record([
        "feature_idx",
        "run_idx",
        "is_decoy",
        "intensity",
        "ownership_status",
        "owned_samples",
        "excluded_samples",
        "competing_feature",
        "apex_rt",
        "bhattacharyya",
        "coelution",
        "preceding_signal_fraction",
    ])?;
    for e in &m.entries {
        audit.write_record([
            e.feature_idx.to_string(),
            e.run_idx.to_string(),
            e.is_decoy.to_string(),
            e.intensity.to_string(),
            e.ownership_status.to_string(),
            e.owned_samples.to_string(),
            e.excluded_samples.to_string(),
            e.competing_feature
                .map(|i| i.to_string())
                .unwrap_or_default(),
            e.apex_rt.to_string(),
            e.spectral_bhattacharyya.to_string(),
            e.coelution.to_string(),
            e.preceding_signal_fraction.to_string(),
        ])?;
    }
    audit.flush()?;
    Ok(())
}

pub fn decoy_intensity(&self, feat: usize, run: usize) -> f64

Examples found in repository

examples/support/lfq_matrices.rs (line 63)

pub fn matrices(m: &IntensityMatrix, folder: &Path) -> anyhow::Result<()> {
    let meta = [
        "massCalib",
        "mz",
        "charge",
        "rtApex",
        "im",
        "combined_score",
        "seed_run",
        "n_contributing_runs",
    ];
    for (kind, name) in [
        "consensus_features.tsv",
        "intensity_matrix.tsv",
        "qvalue_matrix.tsv",
        "decoy_intensity_matrix.tsv",
    ]
    .iter()
    .enumerate()
    {
        let mut out = csv::WriterBuilder::new()
            .delimiter(b'\t')
            .from_path(folder.join(name))?;
        let mut header: Vec<String> = meta.iter().map(|s| s.to_string()).collect();
        if kind == 0 {
            header.extend(["n_runs_detected", "group_score", "group_qvalue"].map(String::from));
        } else {
            header.extend(m.run_names.clone());
        }
        out.write_record(header)?;
        for (i, g) in m.consensus.iter().enumerate() {
            let mut row = vec![
                format!("{:.6}", g.neutral_mass),
                format!("{:.6}", g.ref_mz),
                g.charge.to_string(),
                format!("{:.6}", g.ref_rt),
                if g.ref_im == 0.0 {
                    String::new()
                } else {
                    format!("{:.6}", g.ref_im)
                },
                format!("{:.6}", g.seed_combined_score),
                m.run_names[g.seed_run_idx].clone(),
                g.n_contributing_runs.to_string(),
            ];
            if kind == 0 {
                row.extend([
                    (0..m.n_runs)
                        .filter(|&r| m.intensity(i, r) > 0.0)
                        .count()
                        .to_string(),
                    format!("{:.6}", g.group_score),
                    format!("{:.6}", g.group_qvalue),
                ]);
            } else {
                for r in 0..m.n_runs {
                    let v = match kind {
                        1 => m.intensity(i, r),
                        2 => m.q_value(i, r),
                        _ => m.decoy_intensity(i, r),
                    };
                    row.push(if kind == 2 {
                        format!("{v:.4}")
                    } else if v > 0.0 {
                        format!("{v:.5e}")
                    } else {
                        "0".into()
                    });
                }
            }
            out.write_record(row)?;
        }
        out.flush()?;
    }
    let mut audit = csv::WriterBuilder::new()
        .delimiter(b'\t')
        .from_path(folder.join("ownership.tsv"))?;
    audit.write_record([
        "feature_idx",
        "run_idx",
        "is_decoy",
        "intensity",
        "ownership_status",
        "owned_samples",
        "excluded_samples",
        "competing_feature",
        "apex_rt",
        "bhattacharyya",
        "coelution",
        "preceding_signal_fraction",
    ])?;
    for e in &m.entries {
        audit.write_record([
            e.feature_idx.to_string(),
            e.run_idx.to_string(),
            e.is_decoy.to_string(),
            e.intensity.to_string(),
            e.ownership_status.to_string(),
            e.owned_samples.to_string(),
            e.excluded_samples.to_string(),
            e.competing_feature
                .map(|i| i.to_string())
                .unwrap_or_default(),
            e.apex_rt.to_string(),
            e.spectral_bhattacharyya.to_string(),
            e.coelution.to_string(),
            e.preceding_signal_fraction.to_string(),
        ])?;
    }
    audit.flush()?;
    Ok(())
}