1use openreadout_core::model::FileInfo;
6use openreadout_core::parallel::ReadContext;
7use openreadout_core::{Dataset, Error, Result};
8use schemars::JsonSchema;
9use serde::Deserialize;
10
11use crate::analyze::{PeaksOutput, PeaksRequest, run_peaks};
12use crate::bands::RegionBaseline;
13use crate::extract::{
14 Aggregate, ChromRequest, ChromatogramOutput, Polarity, Target, Tolerance, extract,
15};
16use crate::peaks::{AreaTimeUnit, BaselineMode, PeakParams, PickRule};
17use crate::targets::Compound;
18
19pub const DEFAULT_CHROMATOGRAM_POINTS: usize = 500;
21pub const MAX_CHROMATOGRAM_POINTS: usize = 20_000;
23
24#[derive(Debug, Default, Deserialize, JsonSchema)]
26pub struct SourceArgs {
27 #[serde(default)]
29 pub tic: bool,
30 #[serde(default)]
32 pub bpc: bool,
33 #[serde(default)]
35 pub mz: Vec<f64>,
36 pub ppm: Option<f64>,
38 pub da: Option<f64>,
40 #[serde(default)]
42 pub transitions: Vec<String>,
43 pub transition_tol: Option<f64>,
45 #[serde(default)]
47 pub traces: Vec<u32>,
48 pub channel: Option<u32>,
50 pub sweep: Option<u32>,
52 #[serde(default)]
54 pub run: u32,
55 pub ms_level: Option<u32>,
57 pub polarity: Option<String>,
59 pub scan_filter: Option<String>,
61 pub precursor: Option<f64>,
63 pub precursor_tol: Option<f64>,
65 pub rt_range: Option<[f64; 2]>,
67 pub mz_range: Option<[f64; 2]>,
69 #[serde(default)]
72 pub profile: bool,
73 pub aggregate: Option<String>,
75}
76
77impl SourceArgs {
78 pub fn request(&self) -> Result<ChromRequest> {
80 let mut r = ChromRequest::default();
81 if self.tic {
82 r.targets.push(Target::Tic);
83 }
84 if self.bpc {
85 r.targets.push(Target::Bpc);
86 }
87 r.targets
88 .extend(self.mz.iter().map(|&mz| Target::Xic { mz }));
89 for t in &self.transitions {
90 let bad = || Error::Usage(format!("transition {t:?}: expected \"Q1>Q3\""));
91 let (a, b) = t
92 .split_once('>')
93 .or_else(|| t.split_once('/'))
94 .ok_or_else(bad)?;
95 r.targets.push(Target::Srm {
96 q1: a.trim().parse().map_err(|_| bad())?,
97 q3: b.trim().parse().map_err(|_| bad())?,
98 });
99 }
100 r.targets
101 .extend(self.traces.iter().map(|&trace| Target::Trace {
102 trace,
103 channel: self.channel,
104 }));
105 if self.traces.is_empty() && self.channel.is_some() {
106 r.targets.push(Target::Trace {
107 trace: 0,
108 channel: self.channel,
109 });
110 }
111 if let Some(p) = self.ppm {
112 r.tolerance = Tolerance::Ppm(p);
113 }
114 if let Some(d) = self.da {
115 r.tolerance = Tolerance::Da(d);
116 }
117 if let Some(t) = self.transition_tol {
118 r.transition_tolerance_da = t;
119 }
120 r.run = self.run;
121 r.sweep = self.sweep.unwrap_or(0);
122 r.ms_level = self.ms_level;
123 r.polarity = self
124 .polarity
125 .as_deref()
126 .map(str::parse::<Polarity>)
127 .transpose()?;
128 r.scan_filter.clone_from(&self.scan_filter);
129 r.precursor_mz = self.precursor;
130 if let Some(t) = self.precursor_tol {
131 r.precursor_tolerance_da = t;
132 }
133 r.rt_range_min = self.rt_range;
134 r.mz_range = self.mz_range;
135 r.profile = self.profile;
136 r.aggregate = match self.aggregate.as_deref() {
137 None | Some("sum") => Aggregate::Sum,
138 Some("max") => Aggregate::Max,
139 Some(o) => return Err(Error::Usage(format!("aggregate {o:?}: use sum or max"))),
140 };
141 Ok(r)
142 }
143}
144
145#[derive(Debug, Default, Deserialize, JsonSchema)]
147pub struct ChromatogramQuery {
148 #[serde(flatten)]
150 pub source: SourceArgs,
151 pub max_points: Option<usize>,
154}
155
156#[derive(Debug, Default, Deserialize, JsonSchema)]
158pub struct PeaksQuery {
159 #[serde(flatten)]
161 pub source: SourceArgs,
162 pub smooth: Option<u32>,
164 pub min_snr: Option<f64>,
166 pub min_height: Option<f64>,
168 pub min_width: Option<f64>,
170 pub baseline: Option<String>,
174 #[serde(default)]
176 pub area_seconds: bool,
177 pub rt: Option<f64>,
179 pub window: Option<f64>,
181 pub pick: Option<String>,
183 #[serde(default)]
185 pub integrate: Vec<[f64; 2]>,
186 #[serde(default)]
191 pub x_range: Vec<[f64; 2]>,
192 #[serde(default)]
194 pub compounds: Vec<Compound>,
195 #[serde(default)]
197 pub summary_only: bool,
198}
199
200pub fn chromatogram(
202 ds: &mut dyn Dataset,
203 info: &FileInfo,
204 q: &ChromatogramQuery,
205 ctx: &ReadContext<'_>,
206) -> Result<ChromatogramOutput> {
207 let req = q.source.request()?;
208 let mut out = extract(ds, info, &req, ctx)?;
209 let max = q
210 .max_points
211 .unwrap_or(DEFAULT_CHROMATOGRAM_POINTS)
212 .clamp(1, MAX_CHROMATOGRAM_POINTS);
213 for c in &mut out.chromatograms {
214 c.decimate(max);
215 }
216 Ok(out)
217}
218
219pub fn peaks(
221 ds: &mut dyn Dataset,
222 info: &FileInfo,
223 a: &PeaksQuery,
224 ctx: &ReadContext<'_>,
225) -> Result<PeaksOutput> {
226 let mut r = PeaksRequest {
227 chrom: a.source.request()?,
228 default_window_min: a.window,
229 integrate: a.integrate.clone(),
230 compounds: a.compounds.clone(),
231 x_ranges: a.x_range.clone(),
232 ..PeaksRequest::default()
233 };
234 let mut p = PeakParams {
235 smooth: a.smooth,
236 min_height: a.min_height,
237 min_width_min: a.min_width,
238 rt_range_min: a.source.rt_range,
239 ..PeakParams::default()
240 };
241 if let Some(s) = a.min_snr {
242 p.min_snr = s;
243 }
244 if let Some(b) = &a.baseline {
245 match b.to_ascii_lowercase().as_str() {
246 "linear" | "straight" => r.region_baseline = RegionBaseline::Linear,
247 "none" | "zero" | "off" => r.region_baseline = RegionBaseline::None,
248 _ => p.baseline = b.parse::<BaselineMode>()?,
249 }
250 }
251 if a.area_seconds {
252 p.area_time_unit = AreaTimeUnit::S;
253 }
254 r.params = p;
255 if let Some(k) = &a.pick {
256 r.pick = k.parse::<PickRule>()?;
257 }
258 if let Some(rt) = a.rt {
259 r.expect = Some((
260 rt,
261 a.window.unwrap_or(crate::analyze::DEFAULT_RT_WINDOW_MIN),
262 ));
263 }
264 let (mut out, _) = run_peaks(ds, info, &r, ctx)?;
265 if a.summary_only {
266 for c in &mut out.chromatograms {
267 c.peaks.clear();
268 }
269 for s in &mut out.spectra {
270 s.peaks.clear();
271 }
272 }
273 Ok(out)
274}