pub mod strategies;
use strategies::{best_segment, maximal_segments, split_low_quality, trim_by_quality};
#[derive(Debug, Clone, Copy, PartialEq, Eq, clap::ValueEnum)]
pub enum QualityMethod {
Ends,
Best,
Segments,
Runs,
}
impl QualityMethod {
pub fn label(self) -> &'static str {
match self {
QualityMethod::Ends => "ends",
QualityMethod::Best => "best",
QualityMethod::Segments => "segments",
QualityMethod::Runs => "runs",
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct QualityOp {
pub method: QualityMethod,
pub cutoff: u8,
pub min_low_quality_run: usize,
pub end_cutoff: u8,
}
impl QualityOp {
pub fn new(method: QualityMethod, cutoff: u8) -> Self {
QualityOp {
method,
cutoff,
min_low_quality_run: 1,
end_cutoff: cutoff,
}
}
pub fn runs(cutoff: u8, min_low_quality_run: usize) -> Self {
QualityOp {
min_low_quality_run,
..QualityOp::new(QualityMethod::Runs, cutoff)
}
}
fn apply(&self, phred: &[u8]) -> Vec<(usize, usize)> {
let pieces = match self.method {
QualityMethod::Ends => return trim_by_quality(phred, self.cutoff),
QualityMethod::Best => return best_segment(phred, self.cutoff),
QualityMethod::Segments => maximal_segments(phred, self.cutoff),
QualityMethod::Runs => split_low_quality(phred, self.cutoff, self.min_low_quality_run),
};
if self.end_cutoff <= self.cutoff {
return pieces;
}
pieces
.into_iter()
.flat_map(|(s, e)| {
trim_by_quality(&phred[s..e], self.end_cutoff)
.into_iter()
.map(move |(ts, te)| (s + ts, s + te))
})
.collect()
}
}
#[derive(Debug, Clone, Default)]
pub struct TrimPlan {
pub head: usize,
pub tail: usize,
pub quality: Option<QualityOp>,
}
pub fn apply(
seq: &[u8],
phred: &[u8],
plan: &TrimPlan,
adapters: Option<&crate::adapter::AdapterConfig>,
barcode: Option<(usize, usize)>,
) -> Vec<(usize, usize)> {
debug_assert_eq!(
seq.len(),
phred.len(),
"Sequence and quality lengths must be equal"
);
let seq_len = seq.len();
let (outer_start, outer_end) = match barcode {
Some((s, e)) => (s.min(seq_len), e.clamp(s.min(seq_len), seq_len)),
None => (0, seq_len),
};
if outer_start >= outer_end {
return vec![];
}
let process_segment = |s: usize, e: usize, out: &mut Vec<(usize, usize)>| {
let s = s.max(outer_start);
let e = e.min(outer_end);
if s >= e {
return;
}
let s = s.saturating_add(plan.head).min(e);
let e = e.saturating_sub(plan.tail).max(s);
if s >= e {
return;
}
let wp = &phred[s..e];
let offset = |v: Vec<(usize, usize)>, out: &mut Vec<(usize, usize)>| {
out.extend(v.into_iter().map(|(is, ie)| (is + s, ie + s)));
};
match &plan.quality {
None => out.push((s, e)),
Some(op) => offset(op.apply(wp), out),
}
};
let mut out = Vec::new();
match adapters {
None => {
process_segment(0, seq_len, &mut out);
},
Some(cfg) => {
for (s, e) in crate::adapter::adapter_segments(seq, cfg) {
process_segment(s, e, &mut out);
}
},
}
out
}
#[cfg(test)]
mod tests {
use super::*;
fn adapter_config() -> crate::adapter::AdapterConfig {
crate::adapter::AdapterConfig {
adapters: vec![crate::adapter::Adapter {
name: "junction".into(),
seq: b"GGGGTTTTGGGGTTTT".to_vec(),
role: crate::adapter::Role::Adapter,
}],
error_rate: 0.0,
end_size: 8,
split: true,
min_piece: 1,
candidate_index: std::sync::OnceLock::new(),
amplicon: false,
}
}
#[test]
fn adapter_segments_are_cropped_once_before_quality_processing() {
let ac = adapter_config();
let seq = [vec![b'C'; 64], ac.adapters[0].seq.clone(), vec![b'A'; 64]].concat();
let mut phred = vec![40; seq.len()];
phred[20..24].fill(2);
phred[104..108].fill(2);
let plan = TrimPlan {
head: 3,
tail: 5,
quality: Some(QualityOp::runs(9, 4)),
};
assert_eq!(
apply(&seq, &phred, &plan, Some(&ac), None),
vec![(3, 20), (24, 59), (83, 104), (108, 139)]
);
assert_eq!(
apply(&seq, &phred, &plan, Some(&ac), Some((10, 135))),
vec![(13, 20), (24, 59), (83, 104), (108, 130)]
);
let end_trim = TrimPlan {
quality: Some(QualityOp::new(QualityMethod::Ends, 20)),
..plan.clone()
};
assert_eq!(
apply(&seq, &phred, &end_trim, Some(&ac), None),
vec![(3, 59), (83, 139)]
);
let best = TrimPlan {
quality: Some(QualityOp::new(QualityMethod::Best, 20)),
..plan
};
assert_eq!(
apply(&seq, &phred, &best, Some(&ac), None),
vec![(24, 59), (108, 139)]
);
}
#[test]
fn split_segments_are_offset_to_read_coordinates() {
let seq = vec![b'C'; 200];
let mut phred = vec![40; seq.len()];
phred[80..100].fill(2);
let plan = TrimPlan {
head: 3,
tail: 5,
quality: Some(QualityOp::new(QualityMethod::Segments, 20)),
};
assert_eq!(
apply(&seq, &phred, &plan, None, None),
vec![(3, 80), (100, 195)]
);
}
#[test]
fn end_cutoff_trims_the_ends_of_an_unsplit_read() {
let phred = [vec![12u8; 5], vec![30; 100], vec![12; 5]].concat();
let seq = vec![b'A'; phred.len()];
for method in [QualityMethod::Segments, QualityMethod::Runs] {
let op = QualityOp::new(method, 10);
let plan = |quality| TrimPlan {
quality: Some(quality),
..TrimPlan::default()
};
assert_eq!(
apply(&seq, &phred, &plan(op.clone()), None, None),
vec![(0, 110)],
"{method:?}"
);
let strict = QualityOp {
end_cutoff: 20,
..op
};
assert_eq!(
apply(&seq, &phred, &plan(strict), None, None),
vec![(5, 105)],
"{method:?}"
);
}
}
#[test]
fn end_cutoff_trims_every_piece_of_a_split_read() {
let phred = [
vec![12u8; 5],
vec![30; 80],
vec![12; 3],
vec![2; 30],
vec![14; 4],
vec![30; 80],
vec![12; 5],
vec![2; 30],
vec![15; 60],
]
.concat();
let seq = vec![b'A'; phred.len()];
let runs = TrimPlan {
quality: Some(QualityOp {
end_cutoff: 20,
..QualityOp::runs(10, 10)
}),
..TrimPlan::default()
};
assert_eq!(
apply(&seq, &phred, &runs, None, None),
vec![(5, 85), (122, 202)]
);
let segments = TrimPlan {
quality: Some(QualityOp {
end_cutoff: 20,
..QualityOp::new(QualityMethod::Segments, 10)
}),
..TrimPlan::default()
};
assert_eq!(
apply(&seq, &phred, &segments, None, None),
vec![(5, 85), (122, 202)]
);
}
#[test]
fn end_cutoff_at_or_below_the_cutoff_keeps_the_method_output() {
let mut state = 5u64;
for _ in 0..500 {
let len = 1 + (lcg(&mut state) % 400) as usize;
let phred: Vec<u8> = (0..len).map(|_| (lcg(&mut state) % 40) as u8).collect();
let seq = vec![b'A'; len];
for op in [
QualityOp::runs(12, 3),
QualityOp::new(QualityMethod::Segments, 12),
] {
let plan = |quality| TrimPlan {
quality: Some(quality),
..TrimPlan::default()
};
let want = apply(&seq, &phred, &plan(op.clone()), None, None);
for end_cutoff in [0, 7, 12] {
let lower = QualityOp {
end_cutoff,
..op.clone()
};
assert_eq!(apply(&seq, &phred, &plan(lower), None, None), want);
}
}
}
}
fn lcg(state: &mut u64) -> u64 {
*state = state
.wrapping_mul(6_364_136_223_846_793_005)
.wrapping_add(1_442_695_040_888_963_407);
*state >> 33
}
#[test]
fn terminal_adapter_is_recognized_before_barcode_restriction_and_crop() {
let ac = adapter_config();
let seq = [ac.adapters[0].seq.clone(), vec![b'C'; 64]].concat();
let phred = vec![40; seq.len()];
let plan = TrimPlan {
head: 3,
tail: 5,
quality: None,
};
assert_eq!(apply(&seq, &phred, &plan, Some(&ac), None), vec![(19, 75)]);
assert_eq!(
apply(&seq, &phred, &plan, Some(&ac), Some((12, 70))),
vec![(19, 65)]
);
}
#[test]
fn unmatched_read_is_cropped_and_quality_split() {
let ac = adapter_config();
let seq = vec![b'C'; 64];
let mut phred = vec![40; seq.len()];
phred[20..24].fill(2);
let plan = TrimPlan {
head: 3,
tail: 5,
quality: Some(QualityOp::runs(9, 4)),
};
assert_eq!(
apply(&seq, &phred, &plan, Some(&ac), None),
vec![(3, 20), (24, 59)]
);
}
#[test]
fn crop_can_consume_one_adapter_segment_without_consuming_its_sibling() {
let ac = adapter_config();
let seq = [vec![b'C'; 24], ac.adapters[0].seq.clone(), vec![b'A'; 64]].concat();
let phred = vec![40; seq.len()];
let plan = TrimPlan {
head: 20,
tail: 5,
quality: None,
};
assert_eq!(apply(&seq, &phred, &plan, Some(&ac), None), vec![(60, 99)]);
assert!(apply(&seq, &phred, &plan, Some(&ac), Some((0, 24))).is_empty());
}
#[test]
fn no_quality_op_is_fixed_crop() {
let phred = vec![30u8; 20];
let seq = vec![b'A'; 20];
let plan = TrimPlan {
head: 5,
tail: 3,
quality: None,
};
assert_eq!(apply(&seq, &phred, &plan, None, None), vec![(5, 17)]);
}
#[test]
fn crop_then_quality_offsets_back() {
let mut phred = vec![40u8; 20];
phred[0] = 2;
phred[1] = 2;
let seq = vec![b'A'; 20];
let plan = TrimPlan {
head: 2,
tail: 0,
quality: Some(QualityOp::new(QualityMethod::Ends, 30)),
};
assert_eq!(apply(&seq, &phred, &plan, None, None), vec![(2, 20)]);
}
#[test]
fn short_segments_are_emitted_not_filtered() {
let phred = vec![40u8; 4];
let seq = vec![b'A'; 4];
let plan = TrimPlan {
head: 0,
tail: 0,
quality: None,
};
assert_eq!(apply(&seq, &phred, &plan, None, None), vec![(0, 4)]);
}
#[test]
fn empty_when_crop_exceeds_length() {
let phred = vec![40u8; 4];
let seq = vec![b'A'; 4];
let plan = TrimPlan {
head: 3,
tail: 3,
quality: None,
};
assert_eq!(
apply(&seq, &phred, &plan, None, None),
Vec::<(usize, usize)>::new()
);
}
#[test]
fn adapter_stage_runs_before_quality_op() {
use crate::adapter::{Adapter, AdapterConfig, Role};
let adapter = b"ACGTACGTACGT";
let mut seq = adapter.to_vec();
seq.extend_from_slice(b"GGGGGGGGGGGG");
let mut phred = vec![40u8; seq.len()];
phred[12..15].fill(2);
let plan = TrimPlan {
head: 2,
tail: 1,
quality: Some(QualityOp::new(QualityMethod::Ends, 20)),
};
let ac = AdapterConfig {
adapters: vec![Adapter {
name: "a".into(),
seq: adapter.to_vec(),
role: Role::Adapter,
}],
error_rate: 0.2,
end_size: 20,
split: false,
min_piece: 1,
candidate_index: std::sync::OnceLock::new(),
amplicon: false,
};
assert_eq!(apply(&seq, &phred, &plan, Some(&ac), None), vec![(15, 23)]);
}
#[test]
fn crop_without_adapters_uses_the_full_read() {
let phred = vec![30u8; 20];
let seq = vec![b'A'; 20];
let plan = TrimPlan {
head: 5,
tail: 3,
quality: None,
};
assert_eq!(apply(&seq, &phred, &plan, None, None), vec![(5, 17)]);
}
}
#[cfg(test)]
mod barcode_tests {
use super::*;
#[test]
fn barcode_window_precedes_the_crop() {
let seq = vec![b'A'; 20];
let phred = vec![40u8; 20];
let plan = TrimPlan {
head: 2,
tail: 1,
quality: None,
};
assert_eq!(
apply(&seq, &phred, &plan, None, Some((5, 15))),
vec![(7, 14)]
);
}
#[test]
fn crop_beyond_the_barcode_window_keeps_nothing() {
let seq = vec![b'A'; 20];
let phred = vec![40u8; 20];
let plan = TrimPlan {
head: 6,
tail: 6,
quality: None,
};
let kept = apply(&seq, &phred, &plan, None, Some((5, 15)));
assert!(kept.is_empty());
}
}