Struct PeptideDb 

pub struct PeptideDb {
    pub peptides: Vec<TheoPeptide>,
    pub n_targets: usize,
    pub n_decoys: usize,
}

Mass-sorted peptide database with binary-search candidate lookup.

Fields

peptides: Vec<TheoPeptide>

Sorted ascending by mass.

n_targets: usize

n_decoys: usize

Implementations

impl PeptideDb

pub fn build(fasta_path: impl AsRef<Path>, cfg: &DigestConfig) -> Result<Self>

Build the database from a FASTA file using the given digest config.

Examples found in repository

examples/export_quant_digest.rs (line 14)

fn main() -> Result<()> {
    let args: Vec<_> = std::env::args().skip(1).collect();
    ensure!(
        args.len() == 3,
        "usage: export_quant_digest FASTA DIGEST_CONFIG_JSON OUTPUT_TSV"
    );
    let mut config: DigestConfig = serde_json::from_str(&std::fs::read_to_string(&args[1])?)?;
    config.generate_decoys = false;
    let db = PeptideDb::build(&args[0], &config)?;
    let mut peptides: Vec<_> = db.peptides.iter().filter(|p| !p.decoy).collect();
    peptides.sort_by(|a, b| {
        a.sequence
            .cmp(&b.sequence)
            .then_with(|| a.mass.total_cmp(&b.mass))
    });
    let file = std::fs::OpenOptions::new()
        .write(true)
        .create_new(true)
        .open(&args[2])?;
    let mut out = std::io::BufWriter::new(file);
    writeln!(out, "sequence\tmass\tproteins")?;
    for p in &peptides {
        let mut proteins: Vec<_> = p.proteins.iter().map(|x| x.as_ref()).collect();
        proteins.sort();
        proteins.dedup();
        writeln!(out, "{}\t{}\t{}", p.sequence, p.mass, proteins.join(";"))?;
    }
    out.flush()?;
    eprintln!("{} target peptide entries", peptides.len());
    Ok(())
}

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn candidates(&self, lo: f64, hi: f64) -> &[TheoPeptide]

Candidate peptides whose mass falls in [lo, hi] (inclusive), as a slice of the sorted vector.