//! Throwaway benchmark of the de Bruijn graph on a real kmer set: //! `graph_bench [repeat]` builds `GraphDeBruijn` from the //! canonical kmers of an existing layer's unitigs (same call sequence as //! `write_graph_as_unitigs`) and times each phase. use std::path::PathBuf; use std::time::Instant; use obidebruinj::GraphDeBruijn; use obikseq::Sequence; use obiskio::CanonicalKmerIter; use rayon::prelude::*; use std::collections::HashSet; fn main() { let args: Vec = std::env::args().collect(); let path = PathBuf::from(&args[1]); let k: usize = args[2].parse().unwrap(); let repeat: usize = args.get(3).map_or(1, |s| s.parse().unwrap()); obikseq::set_k(k); obikseq::set_m(11); let kmers: Vec<_> = if let Ok(n) = std::env::var("SYNTH") { // synthetic reads: random genome, reads on both strands, 1 % substitutions let n: usize = n.parse().unwrap(); let mut st = 0x9E3779B97F4A7C15u64; let mut rnd = move || { st ^= st << 13; st ^= st >> 7; st ^= st << 17; st }; let genome: Vec = (0..n).map(|_| b"ACGT"[(rnd() % 4) as usize]).collect(); let mut set = std::collections::BTreeSet::new(); for _ in 0..(n / 50) { let start = (rnd() as usize) % (n - 100); let mut read: Vec = genome[start..start + 100].to_vec(); for b in read.iter_mut() { if rnd() % 100 == 0 { *b = b"ACGT"[(rnd() % 4) as usize]; } } for w in read.windows(k) { set.insert(obikseq::Kmer::from_ascii(w).unwrap().canonical()); } } set.into_iter().collect() } else { CanonicalKmerIter::new(&path).unwrap().collect() }; eprintln!("{} kmers", kmers.len()); // Independent count of maximal unitigs: nodes − mutually-unique links // (cycles ignored), computed with a plain HashSet — no use of GraphDeBruijn. if std::env::var("IDEAL").is_ok() { let set: HashSet = kmers.iter().map(|c| c.raw()).collect(); let outs = |a: obikseq::Kmer| -> Vec { (0..4u8) .map(|x| a.push_right(x)) .filter(|b| set.contains(&b.canonical().raw())) .collect() }; let links: usize = kmers .par_iter() .map(|c| { let mut n = 0usize; for o in [c.into_kmer(), c.into_kmer().revcomp()] { let ob = outs(o); if ob.len() == 1 { let b = ob[0]; // in-neighbours of b = revcomp of out-neighbours of revcomp(b) if outs(b.revcomp()).len() == 1 { // count each undirected link once: only from the orientation // whose canonical raw is the smaller end (ties: both seen once per orientation) let (ca, cb) = (o.canonical().raw(), b.canonical().raw()); if ca < cb || (ca == cb && o.raw() <= b.raw()) { n += 1; } else if ca > cb { // seen from the other end too: skip } } } } n }) .sum(); eprintln!("IDEAL: nodes={} links={} -> maximal unitigs ≈ {}", kmers.len(), links, kmers.len() - links); } if std::env::var("IDEALDUMP").is_ok() { let set: HashSet = kmers.iter().map(|c| c.raw()).collect(); let outs = |a: obikseq::Kmer| -> Vec { (0..4u8).map(|x| a.push_right(x)).filter(|b| set.contains(&b.canonical().raw())).collect() }; // oriented kmer a has a mutual predecessor p iff ins(a)=={p} and outs(p)=={a} let pred = |a: obikseq::Kmer| -> Option { let ins: Vec = outs(a.revcomp()).into_iter().map(|b| b.revcomp()).collect(); if ins.len() == 1 && outs(ins[0]).len() == 1 { Some(ins[0]) } else { None } }; let mut seen_chains = std::collections::BTreeSet::new(); for c in &kmers { for o in [c.into_kmer(), c.into_kmer().revcomp()] { if pred(o).is_some() { continue; } let mut text: Vec = (0..k).map(|i| b"ACGT"[o.nucleotide(i) as usize]).collect(); let mut cur = o; loop { let ob = outs(cur); if ob.len() != 1 { break; } let b = ob[0]; if pred(b).is_none() { break; } text.push(b"ACGT"[b.nucleotide(k - 1) as usize]); cur = b; } let s = String::from_utf8(text).unwrap(); let rc: String = s.bytes().rev().map(|c| match c { b'A' => 'T', b'C' => 'G', b'G' => 'C', _ => 'A' }).collect(); seen_chains.insert(if s <= rc { s } else { rc }); } } for u in &seen_chains { println!("IDEALUNITIG {} {}", u.len(), u); } } for r in 0..repeat { let t = Instant::now(); let mut g = GraphDeBruijn::new(); for &kmer in &kmers { g.push(kmer); } let t_push = t.elapsed(); let t = Instant::now(); g.compute_degrees_and_mark_starts(); let t_deg = t.elapsed(); let t = Instant::now(); let n_unitigs = std::sync::atomic::AtomicUsize::new(0); let n_nuc = std::sync::atomic::AtomicUsize::new(0); let dump = std::env::var("DUMP").is_ok(); let seqs = std::sync::Mutex::new(Vec::::new()); g.for_each_unitig(|it| { let mut n = 0usize; let mut text = String::new(); for nuc in it { n += 1; if dump { text.push(b"ACGT"[nuc as usize] as char); } } if dump { seqs.lock().unwrap().push(text); } n_unitigs.fetch_add(1, std::sync::atomic::Ordering::Relaxed); n_nuc.fetch_add(n, std::sync::atomic::Ordering::Relaxed); }); let t_walk = t.elapsed(); if dump { let mut v = seqs.lock().unwrap().clone(); v.sort(); for u in v { println!("UNITIG {} {}", u.len(), u); } } println!( "run {r}: nodes={} push={:.2?} degrees={:.2?} unitigs={:.2?} -> {} unitigs, {} nucleotides", g.len(), t_push, t_deg, t_walk, n_unitigs.load(std::sync::atomic::Ordering::Relaxed), n_nuc.load(std::sync::atomic::Ordering::Relaxed) ); } }