use openreadout_core::model::FileInfo;
use openreadout_core::parallel::ReadContext;
use openreadout_core::{Dataset, Error, Result};
use schemars::JsonSchema;
use serde::Deserialize;
use crate::analyze::{PeaksOutput, PeaksRequest, run_peaks};
use crate::bands::RegionBaseline;
use crate::extract::{
Aggregate, ChromRequest, ChromatogramOutput, Polarity, Target, Tolerance, extract,
};
use crate::peaks::{AreaTimeUnit, BaselineMode, PeakParams, PickRule};
use crate::targets::Compound;
pub const DEFAULT_CHROMATOGRAM_POINTS: usize = 500;
pub const MAX_CHROMATOGRAM_POINTS: usize = 20_000;
#[derive(Debug, Default, Deserialize, JsonSchema)]
pub struct SourceArgs {
#[serde(default)]
pub tic: bool,
#[serde(default)]
pub bpc: bool,
#[serde(default)]
pub mz: Vec<f64>,
pub ppm: Option<f64>,
pub da: Option<f64>,
#[serde(default)]
pub transitions: Vec<String>,
pub transition_tol: Option<f64>,
#[serde(default)]
pub traces: Vec<u32>,
pub channel: Option<u32>,
pub sweep: Option<u32>,
#[serde(default)]
pub run: u32,
pub ms_level: Option<u32>,
pub polarity: Option<String>,
pub scan_filter: Option<String>,
pub precursor: Option<f64>,
pub precursor_tol: Option<f64>,
pub rt_range: Option<[f64; 2]>,
pub mz_range: Option<[f64; 2]>,
#[serde(default)]
pub profile: bool,
pub aggregate: Option<String>,
}
impl SourceArgs {
pub fn request(&self) -> Result<ChromRequest> {
let mut r = ChromRequest::default();
if self.tic {
r.targets.push(Target::Tic);
}
if self.bpc {
r.targets.push(Target::Bpc);
}
r.targets
.extend(self.mz.iter().map(|&mz| Target::Xic { mz }));
for t in &self.transitions {
let bad = || Error::Usage(format!("transition {t:?}: expected \"Q1>Q3\""));
let (a, b) = t
.split_once('>')
.or_else(|| t.split_once('/'))
.ok_or_else(bad)?;
r.targets.push(Target::Srm {
q1: a.trim().parse().map_err(|_| bad())?,
q3: b.trim().parse().map_err(|_| bad())?,
});
}
r.targets
.extend(self.traces.iter().map(|&trace| Target::Trace {
trace,
channel: self.channel,
}));
if self.traces.is_empty() && self.channel.is_some() {
r.targets.push(Target::Trace {
trace: 0,
channel: self.channel,
});
}
if let Some(p) = self.ppm {
r.tolerance = Tolerance::Ppm(p);
}
if let Some(d) = self.da {
r.tolerance = Tolerance::Da(d);
}
if let Some(t) = self.transition_tol {
r.transition_tolerance_da = t;
}
r.run = self.run;
r.sweep = self.sweep.unwrap_or(0);
r.ms_level = self.ms_level;
r.polarity = self
.polarity
.as_deref()
.map(str::parse::<Polarity>)
.transpose()?;
r.scan_filter.clone_from(&self.scan_filter);
r.precursor_mz = self.precursor;
if let Some(t) = self.precursor_tol {
r.precursor_tolerance_da = t;
}
r.rt_range_min = self.rt_range;
r.mz_range = self.mz_range;
r.profile = self.profile;
r.aggregate = match self.aggregate.as_deref() {
None | Some("sum") => Aggregate::Sum,
Some("max") => Aggregate::Max,
Some(o) => return Err(Error::Usage(format!("aggregate {o:?}: use sum or max"))),
};
Ok(r)
}
}
#[derive(Debug, Default, Deserialize, JsonSchema)]
pub struct ChromatogramQuery {
#[serde(flatten)]
pub source: SourceArgs,
pub max_points: Option<usize>,
}
#[derive(Debug, Default, Deserialize, JsonSchema)]
pub struct PeaksQuery {
#[serde(flatten)]
pub source: SourceArgs,
pub smooth: Option<u32>,
pub min_snr: Option<f64>,
pub min_height: Option<f64>,
pub min_width: Option<f64>,
pub baseline: Option<String>,
#[serde(default)]
pub area_seconds: bool,
pub rt: Option<f64>,
pub window: Option<f64>,
pub pick: Option<String>,
#[serde(default)]
pub integrate: Vec<[f64; 2]>,
#[serde(default)]
pub x_range: Vec<[f64; 2]>,
#[serde(default)]
pub compounds: Vec<Compound>,
#[serde(default)]
pub summary_only: bool,
}
pub fn chromatogram(
ds: &mut dyn Dataset,
info: &FileInfo,
q: &ChromatogramQuery,
ctx: &ReadContext<'_>,
) -> Result<ChromatogramOutput> {
let req = q.source.request()?;
let mut out = extract(ds, info, &req, ctx)?;
let max = q
.max_points
.unwrap_or(DEFAULT_CHROMATOGRAM_POINTS)
.clamp(1, MAX_CHROMATOGRAM_POINTS);
for c in &mut out.chromatograms {
c.decimate(max);
}
Ok(out)
}
pub fn peaks(
ds: &mut dyn Dataset,
info: &FileInfo,
a: &PeaksQuery,
ctx: &ReadContext<'_>,
) -> Result<PeaksOutput> {
let mut r = PeaksRequest {
chrom: a.source.request()?,
default_window_min: a.window,
integrate: a.integrate.clone(),
compounds: a.compounds.clone(),
x_ranges: a.x_range.clone(),
..PeaksRequest::default()
};
let mut p = PeakParams {
smooth: a.smooth,
min_height: a.min_height,
min_width_min: a.min_width,
rt_range_min: a.source.rt_range,
..PeakParams::default()
};
if let Some(s) = a.min_snr {
p.min_snr = s;
}
if let Some(b) = &a.baseline {
match b.to_ascii_lowercase().as_str() {
"linear" | "straight" => r.region_baseline = RegionBaseline::Linear,
"none" | "zero" | "off" => r.region_baseline = RegionBaseline::None,
_ => p.baseline = b.parse::<BaselineMode>()?,
}
}
if a.area_seconds {
p.area_time_unit = AreaTimeUnit::S;
}
r.params = p;
if let Some(k) = &a.pick {
r.pick = k.parse::<PickRule>()?;
}
if let Some(rt) = a.rt {
r.expect = Some((
rt,
a.window.unwrap_or(crate::analyze::DEFAULT_RT_WINDOW_MIN),
));
}
let (mut out, _) = run_peaks(ds, info, &r, ctx)?;
if a.summary_only {
for c in &mut out.chromatograms {
c.peaks.clear();
}
for s in &mut out.spectra {
s.peaks.clear();
}
}
Ok(out)
}