use crate::data::utility::reconstruct_compressed_data;
use rusqlite::{params, Connection};
use std::fs;
use std::io::Write;
use std::path::{Path, PathBuf};
const BIN_PREFIX_PAD: u64 = 64;
const FRAMES_DDL: &str = "CREATE TABLE Frames (
Id INTEGER PRIMARY KEY,
Time REAL, ScanMode INTEGER, Polarity TEXT, MsMsType INTEGER,
TimsId INTEGER, MaxIntensity REAL, SummedIntensities REAL,
NumScans INTEGER, NumPeaks INTEGER, MzCalibration INTEGER,
T1 REAL, T2 REAL, TimsCalibration INTEGER, PropertyGroup INTEGER,
AccumulationTime REAL, RampTime REAL);";
#[derive(Debug, Clone)]
pub struct TdfWriterConfig {
pub num_scans: u32,
pub digitizer_num_samples: u32,
pub mz_range: (f64, f64),
pub one_over_k0_range: (f64, f64),
pub compression_level: i32,
pub scan_mode: i64,
pub reference_d: Option<String>,
}
impl Default for TdfWriterConfig {
fn default() -> Self {
TdfWriterConfig {
num_scans: 709,
digitizer_num_samples: 400_000,
mz_range: (100.0, 1700.0),
one_over_k0_range: (0.6, 1.6),
compression_level: 1,
scan_mode: 9,
reference_d: None,
}
}
}
use rusqlite::types::Value;
struct FramesTemplate {
columns: Vec<String>,
values: Vec<Value>,
idx: OverrideIdx,
}
struct OverrideIdx {
id: Option<usize>,
time: Option<usize>,
scan_mode: Option<usize>,
ms_ms_type: Option<usize>,
tims_id: Option<usize>,
max_intensity: Option<usize>,
summed: Option<usize>,
num_scans: Option<usize>,
num_peaks: Option<usize>,
}
impl FramesTemplate {
fn resolve(columns: &[String]) -> OverrideIdx {
let find = |name: &str| columns.iter().position(|c| c == name);
OverrideIdx {
id: find("Id"),
time: find("Time"),
scan_mode: find("ScanMode"),
ms_ms_type: find("MsMsType"),
tims_id: find("TimsId"),
max_intensity: find("MaxIntensity"),
summed: find("SummedIntensities"),
num_scans: find("NumScans"),
num_peaks: find("NumPeaks"),
}
}
fn from_reference(conn: &Connection) -> Result<Self, Box<dyn std::error::Error>> {
conn.execute_batch(
"CREATE TABLE Frames AS SELECT * FROM ref.Frames WHERE 0;
CREATE UNIQUE INDEX IF NOT EXISTS FramesIdIndex ON Frames(Id);",
)?;
let columns: Vec<String> = {
let stmt = conn.prepare("SELECT * FROM ref.Frames LIMIT 0")?;
stmt.column_names().into_iter().map(|s| s.to_string()).collect()
};
let ncol = columns.len();
let values: Vec<Value> = conn.query_row("SELECT * FROM ref.Frames ORDER BY Id LIMIT 1", [], |row| {
(0..ncol).map(|i| row.get::<_, Value>(i)).collect::<rusqlite::Result<Vec<Value>>>()
})?;
let idx = Self::resolve(&columns);
Ok(FramesTemplate { columns, values, idx })
}
fn placeholder(conn: &Connection) -> Result<Self, Box<dyn std::error::Error>> {
conn.execute_batch(FRAMES_DDL)?;
let columns: Vec<String> = vec![
"Id", "Time", "ScanMode", "Polarity", "MsMsType", "TimsId", "MaxIntensity",
"SummedIntensities", "NumScans", "NumPeaks", "MzCalibration", "T1", "T2",
"TimsCalibration", "PropertyGroup", "AccumulationTime", "RampTime",
].into_iter().map(String::from).collect();
let values: Vec<Value> = vec![
Value::Integer(0), Value::Real(0.0), Value::Integer(9), Value::Text("+".into()),
Value::Integer(0), Value::Integer(0), Value::Real(0.0), Value::Real(0.0),
Value::Integer(0), Value::Integer(0), Value::Integer(1), Value::Real(100.0),
Value::Real(100.0), Value::Integer(1), Value::Integer(1), Value::Real(100.0),
Value::Real(100.0),
];
let idx = Self::resolve(&columns);
Ok(FramesTemplate { columns, values, idx })
}
}
pub struct RenderedFrame {
pub frame_id: u32,
pub retention_time: f64,
pub ms_ms_type: u8,
pub scans: Vec<u32>,
pub tofs: Vec<u32>,
pub intensities: Vec<u32>,
}
pub struct EncodedBlock {
pub block: Vec<u8>,
pub num_peaks: i64,
pub max_intensity: f64,
pub summed_intensities: f64,
}
pub fn encode_frame_block(
scans: &[u32],
tofs: &[u32],
intensities: &[u32],
num_scans: u32,
compression_level: i32,
) -> Result<EncodedBlock, Box<dyn std::error::Error>> {
let block = reconstruct_compressed_data(
scans.to_vec(),
tofs.to_vec(),
intensities.to_vec(),
num_scans,
compression_level,
)?;
let mut acc: std::collections::HashMap<(u32, u32), u64> =
std::collections::HashMap::with_capacity(scans.len());
for i in 0..scans.len() {
*acc.entry((scans[i], tofs[i])).or_insert(0) += intensities[i] as u64;
}
let summed: f64 = intensities.iter().map(|&x| x as u128).sum::<u128>() as f64;
let max_i = acc.values().copied().max().unwrap_or(0) as f64;
Ok(EncodedBlock {
block,
num_peaks: acc.len() as i64,
max_intensity: max_i,
summed_intensities: summed,
})
}
pub struct DdaPrecursor {
pub id: i64,
pub largest_peak_mz: f64,
pub average_mz: f64,
pub monoisotopic_mz: f64,
pub charge: i64,
pub scan_number: f64,
pub intensity: f64,
pub parent: i64,
}
pub struct DdaPasefWindow {
pub frame: i64,
pub scan_num_begin: i64,
pub scan_num_end: i64,
pub isolation_mz: f64,
pub isolation_width: f64,
pub collision_energy: f64,
pub precursor: i64,
}
struct FrameMetaRow {
id: u32,
time: f64,
ms_ms_type: i64,
tims_id: u64,
max_intensity: f64,
summed_intensities: f64,
num_peaks: i64,
}
pub struct TdfWriter {
dir: PathBuf,
conn: Connection,
bin: fs::File,
position: u64,
config: TdfWriterConfig,
frames: Vec<FrameMetaRow>,
template: FramesTemplate,
copied_from_reference: bool,
dia_frame_to_group: Option<Vec<(u32, u32)>>,
dda_schedule: Option<(Vec<DdaPrecursor>, Vec<DdaPasefWindow>)>,
}
impl TdfWriter {
pub fn create(dir: impl AsRef<Path>, config: TdfWriterConfig) -> Result<Self, Box<dyn std::error::Error>> {
let dir = dir.as_ref().to_path_buf();
fs::create_dir_all(&dir)?;
let conn = Connection::open(dir.join("analysis.tdf"))?;
let (template, copied_from_reference) = match &config.reference_d {
Some(ref_path) => {
let ref_tdf = Path::new(ref_path).join("analysis.tdf");
if !ref_tdf.exists() {
return Err(format!("reference .d has no analysis.tdf: {}", ref_tdf.display()).into());
}
conn.execute("ATTACH DATABASE ?1 AS ref", params![ref_tdf.to_str().unwrap()])?;
conn.execute_batch(
"CREATE TABLE MzCalibration AS SELECT * FROM ref.MzCalibration;
CREATE TABLE TimsCalibration AS SELECT * FROM ref.TimsCalibration;
CREATE TABLE GlobalMetadata AS SELECT * FROM ref.GlobalMetadata;",
)?;
conn.execute_batch("CREATE TABLE Segments AS SELECT * FROM ref.Segments;")?;
let template = FramesTemplate::from_reference(&conn)?;
conn.execute("DETACH DATABASE ref", [])?;
(template, true)
}
None => {
Self::create_placeholder_tables(&conn)?;
let template = FramesTemplate::placeholder(&conn)?;
(template, false)
}
};
let mut bin = fs::OpenOptions::new().write(true).create(true).truncate(true).open(dir.join("analysis.tdf_bin"))?;
bin.write_all(&[0u8; BIN_PREFIX_PAD as usize])?;
Ok(TdfWriter {
dir,
conn,
bin,
position: BIN_PREFIX_PAD,
config,
frames: Vec::new(),
template,
copied_from_reference,
dia_frame_to_group: None,
dda_schedule: None,
})
}
pub fn set_dia_schedule(&mut self, frame_to_group: Vec<(u32, u32)>) {
self.dia_frame_to_group = Some(frame_to_group);
}
pub fn set_dda_schedule(&mut self, precursors: Vec<DdaPrecursor>, pasef: Vec<DdaPasefWindow>) {
self.config.scan_mode = 8;
self.dda_schedule = Some((precursors, pasef));
}
pub fn write_frame(&mut self, frame: &RenderedFrame) -> Result<(), Box<dyn std::error::Error>> {
let blk = encode_frame_block(
&frame.scans,
&frame.tofs,
&frame.intensities,
self.config.num_scans,
self.config.compression_level,
)?;
self.append_encoded_frame(frame.frame_id, frame.retention_time, frame.ms_ms_type, blk)
}
pub fn append_encoded_frame(
&mut self,
frame_id: u32,
retention_time: f64,
ms_ms_type: u8,
blk: EncodedBlock,
) -> Result<(), Box<dyn std::error::Error>> {
let expected = self.frames.len() as u32 + 1;
if frame_id != expected {
return Err(format!(
"frames must be written in order: expected id {expected}, got {frame_id}"
)
.into());
}
let tims_id = self.position;
self.bin.write_all(&blk.block)?;
self.position += blk.block.len() as u64;
self.frames.push(FrameMetaRow {
id: frame_id,
time: retention_time,
ms_ms_type: ms_ms_type as i64,
tims_id,
max_intensity: blk.max_intensity,
summed_intensities: blk.summed_intensities,
num_peaks: blk.num_peaks,
});
Ok(())
}
pub fn finalize(mut self) -> Result<(), Box<dyn std::error::Error>> {
if self.dia_frame_to_group.is_some() && self.dda_schedule.is_some() {
return Err("acquisition is either DIA or DDA, not both (both schedules were set)".into());
}
if self.dda_schedule.is_some() {
self.validate_dda_schedule()?;
}
self.bin.flush()?;
self.write_frames_table()?;
if self.copied_from_reference {
let last_frame = self.frames.iter().map(|f| f.id).max().unwrap_or(0) as i64;
let _ = self.conn.execute("UPDATE Segments SET LastFrame = ?1", params![last_frame]);
self.conn.execute(
"UPDATE GlobalMetadata SET Value = '0' WHERE Key = 'ClosedProperly'",
[],
)?;
self.conn.execute(
"UPDATE GlobalMetadata SET Value = '2' WHERE Key = 'TimsCompressionType'",
[],
)?;
} else {
self.write_global_metadata()?;
self.write_calibration_tables()?;
}
if self.dia_frame_to_group.is_some() {
self.write_dia_tables()?;
}
if self.dda_schedule.is_some() {
self.write_dda_tables()?;
}
self.conn.execute(
"UPDATE GlobalMetadata SET Value = '1' WHERE Key = 'ClosedProperly'",
[],
)?;
Ok(())
}
fn validate_dda_schedule(&self) -> Result<(), Box<dyn std::error::Error>> {
use std::collections::{HashMap, HashSet};
let (precursors, pasef) = self.dda_schedule.as_ref().unwrap();
let frame_type: HashMap<u32, i64> = self.frames.iter().map(|f| (f.id, f.ms_ms_type)).collect();
let mut ids: HashSet<i64> = HashSet::new();
for p in precursors {
if !ids.insert(p.id) {
return Err(format!(
"duplicate Precursors.Id {} — pass one canonical row per precursor (per-event \
Parent/Intensity/ScanNumber belong in the sidecar answer key)",
p.id
)
.into());
}
match frame_type.get(&(p.parent as u32)) {
Some(0) => {}
Some(t) => return Err(format!("Precursor {} Parent {} is a MsMsType={} frame, not MS1", p.id, p.parent, t).into()),
None => return Err(format!("Precursor {} Parent {} is not a written frame", p.id, p.parent).into()),
}
}
let mut bands: HashSet<(i64, i64)> = HashSet::new();
for w in pasef {
if !ids.contains(&w.precursor) {
return Err(format!("PASEF band (frame {}) references unknown Precursor {}", w.frame, w.precursor).into());
}
match frame_type.get(&(w.frame as u32)) {
Some(8) => {}
Some(t) => return Err(format!("PASEF Frame {} is MsMsType={}, expected 8 (MS2)", w.frame, t).into()),
None => return Err(format!("PASEF Frame {} is not a written frame", w.frame).into()),
}
if w.scan_num_begin < 0 || w.scan_num_end <= w.scan_num_begin
|| w.scan_num_end as u32 > self.config.num_scans
{
return Err(format!(
"PASEF band [{}, {}] invalid for {} scans", w.scan_num_begin, w.scan_num_end, self.config.num_scans
)
.into());
}
if !bands.insert((w.frame, w.scan_num_begin)) {
return Err(format!("duplicate PASEF (Frame {}, ScanNumBegin {}) — bands need distinct start scans", w.frame, w.scan_num_begin).into());
}
}
Ok(())
}
fn write_dia_tables(&self) -> Result<(), Box<dyn std::error::Error>> {
let frame_to_group = self.dia_frame_to_group.as_ref().unwrap();
let ref_path = self
.config
.reference_d
.as_ref()
.ok_or("DIA output needs --reference-d for the window definitions")?;
let ref_tdf = Path::new(ref_path).join("analysis.tdf");
self.conn.execute("ATTACH DATABASE ?1 AS refdia", params![ref_tdf.to_str().unwrap()])?;
self.conn
.execute_batch("CREATE TABLE DiaFrameMsMsWindows AS SELECT * FROM refdia.DiaFrameMsMsWindows;")?;
self.conn.execute("DETACH DATABASE refdia", [])?;
self.conn.execute_batch(
"CREATE TABLE DiaFrameMsMsInfo (Frame INTEGER PRIMARY KEY, WindowGroup INTEGER);",
)?;
let tx = self.conn.unchecked_transaction()?;
{
let mut stmt = tx.prepare("INSERT INTO DiaFrameMsMsInfo (Frame, WindowGroup) VALUES (?1, ?2)")?;
for &(frame, group) in frame_to_group {
stmt.execute(params![frame, group])?;
}
}
tx.commit()?;
Ok(())
}
fn write_dda_tables(&self) -> Result<(), Box<dyn std::error::Error>> {
let (precursors, pasef) = self.dda_schedule.as_ref().unwrap();
self.conn.execute_batch(
"CREATE TABLE Precursors (
Id INTEGER PRIMARY KEY,
LargestPeakMz REAL NOT NULL, AverageMz REAL NOT NULL, MonoisotopicMz REAL,
Charge INTEGER, ScanNumber REAL NOT NULL, Intensity REAL NOT NULL, Parent INTEGER,
FOREIGN KEY(Parent) REFERENCES Frames(Id));
CREATE INDEX PrecursorsParentIndex ON Precursors (Parent);",
)?;
let tx = self.conn.unchecked_transaction()?;
{
let mut stmt = tx.prepare(
"INSERT INTO Precursors
(Id, LargestPeakMz, AverageMz, MonoisotopicMz, Charge, ScanNumber, Intensity, Parent)
VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8)",
)?;
for p in precursors {
stmt.execute(params![
p.id, p.largest_peak_mz, p.average_mz, p.monoisotopic_mz,
p.charge, p.scan_number, p.intensity, p.parent
])?;
}
}
tx.commit()?;
self.conn.execute_batch(
"CREATE TABLE PasefFrameMsMsInfo (
Frame INTEGER NOT NULL, ScanNumBegin INTEGER NOT NULL, ScanNumEnd INTEGER NOT NULL,
IsolationMz REAL NOT NULL, IsolationWidth REAL NOT NULL, CollisionEnergy REAL NOT NULL,
Precursor INTEGER, PRIMARY KEY(Frame, ScanNumBegin),
FOREIGN KEY(Frame) REFERENCES Frames(Id),
FOREIGN KEY(Precursor) REFERENCES Precursors(Id)) WITHOUT ROWID;",
)?;
let tx = self.conn.unchecked_transaction()?;
{
let mut stmt = tx.prepare(
"INSERT INTO PasefFrameMsMsInfo
(Frame, ScanNumBegin, ScanNumEnd, IsolationMz, IsolationWidth, CollisionEnergy, Precursor)
VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7)",
)?;
for w in pasef {
stmt.execute(params![
w.frame, w.scan_num_begin, w.scan_num_end,
w.isolation_mz, w.isolation_width, w.collision_energy, w.precursor
])?;
}
}
tx.commit()?;
Ok(())
}
pub fn path(&self) -> &Path {
&self.dir
}
fn create_placeholder_tables(conn: &Connection) -> Result<(), Box<dyn std::error::Error>> {
conn.execute_batch(
"CREATE TABLE GlobalMetadata (Key TEXT PRIMARY KEY, Value TEXT);
CREATE TABLE MzCalibration (
Id INTEGER PRIMARY KEY, ModelType INTEGER,
DigitizerTimebase REAL, DigitizerDelay REAL, T1 REAL, T2 REAL,
dC1 REAL, dC2 REAL, C0 REAL, C1 REAL, C2 REAL, C3 REAL, C4 REAL);
CREATE TABLE TimsCalibration (
Id INTEGER PRIMARY KEY, ModelType INTEGER,
C0 REAL, C1 REAL, C2 REAL, C3 REAL, C4 REAL,
C5 REAL, C6 REAL, C7 REAL, C8 REAL, C9 REAL);",
)?;
Ok(())
}
fn write_frames_table(&self) -> Result<(), Box<dyn std::error::Error>> {
let cols = &self.template.columns;
let collist = cols.join(", ");
let placeholders = (1..=cols.len()).map(|i| format!("?{i}")).collect::<Vec<_>>().join(", ");
let sql = format!("INSERT INTO Frames ({collist}) VALUES ({placeholders})");
let idx = &self.template.idx;
let tx = self.conn.unchecked_transaction()?;
{
let mut stmt = tx.prepare(&sql)?;
for f in &self.frames {
let mut row = self.template.values.clone();
if let Some(i) = idx.id { row[i] = Value::Integer(f.id as i64); }
if let Some(i) = idx.time { row[i] = Value::Real(f.time); }
if let Some(i) = idx.scan_mode { row[i] = Value::Integer(self.config.scan_mode); }
if let Some(i) = idx.ms_ms_type { row[i] = Value::Integer(f.ms_ms_type); }
if let Some(i) = idx.tims_id { row[i] = Value::Integer(f.tims_id as i64); }
if let Some(i) = idx.max_intensity { row[i] = Value::Integer(f.max_intensity as i64); }
if let Some(i) = idx.summed { row[i] = Value::Integer(f.summed_intensities as i64); }
if let Some(i) = idx.num_scans { row[i] = Value::Integer(self.config.num_scans as i64); }
if let Some(i) = idx.num_peaks { row[i] = Value::Integer(f.num_peaks); }
stmt.execute(rusqlite::params_from_iter(row.iter()))?;
}
}
tx.commit()?;
Ok(())
}
fn write_global_metadata(&self) -> Result<(), Box<dyn std::error::Error>> {
let kv: Vec<(&str, String)> = vec![
("SchemaType", "TDF".into()),
("SchemaVersionMajor", "3".into()),
("SchemaVersionMinor", "7".into()),
("AcquisitionSoftwareVendor", "timsim".into()),
("InstrumentVendor", "Bruker".into()),
("TimsCompressionType", "2".into()), ("MaxNumPeaksPerScan", "1000".into()),
("MzAcqRangeLower", format!("{}", self.config.mz_range.0)),
("MzAcqRangeUpper", format!("{}", self.config.mz_range.1)),
("OneOverK0AcqRangeLower", format!("{}", self.config.one_over_k0_range.0)),
("OneOverK0AcqRangeUpper", format!("{}", self.config.one_over_k0_range.1)),
("DigitizerNumSamples", format!("{}", self.config.digitizer_num_samples)),
("ClosedProperly", "0".into()),
];
let tx = self.conn.unchecked_transaction()?;
{
let mut stmt = tx.prepare("INSERT OR REPLACE INTO GlobalMetadata (Key, Value) VALUES (?1, ?2)")?;
for (k, v) in kv {
stmt.execute(params![k, v])?;
}
}
tx.commit()?;
Ok(())
}
fn write_calibration_tables(&self) -> Result<(), Box<dyn std::error::Error>> {
self.conn.execute(
"INSERT INTO MzCalibration
(Id, ModelType, DigitizerTimebase, DigitizerDelay, T1, T2, dC1, dC2, C0, C1, C2, C3, C4)
VALUES (1, 2, 1.0, 0.0, 100.0, 100.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0)",
[],
)?;
self.conn.execute(
"INSERT INTO TimsCalibration
(Id, ModelType, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9)
VALUES (1, 2, 1.0, ?1, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0)",
params![(self.config.num_scans as i64 - 1)], )?;
Ok(())
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::data::handle::{
SimpleIndexConverter, TimsData, TimsIndexConverter, TimsLazyLoder, TimsRawDataLayout,
};
#[test]
fn ms1_d_round_trips_through_the_reader() {
let dir = std::env::temp_dir().join(format!("timsim_tdf_writer_test_{}", std::process::id()));
let _ = fs::remove_dir_all(&dir);
let cfg = TdfWriterConfig { num_scans: 100, ..Default::default() };
let frames = vec![
RenderedFrame {
frame_id: 1,
retention_time: 0.5,
ms_ms_type: 0,
scans: vec![2, 2, 10, 40],
tofs: vec![100, 350, 200, 500],
intensities: vec![10, 20, 30, 40],
},
RenderedFrame {
frame_id: 2,
retention_time: 1.0,
ms_ms_type: 0,
scans: vec![5, 50],
tofs: vec![123, 456],
intensities: vec![7, 99],
},
RenderedFrame {
frame_id: 3, retention_time: 1.5,
ms_ms_type: 0,
scans: vec![],
tofs: vec![],
intensities: vec![],
},
];
let mut w = TdfWriter::create(&dir, cfg).unwrap();
for f in &frames {
w.write_frame(f).unwrap();
}
w.finalize().unwrap();
let layout = TimsRawDataLayout::new(dir.to_str().unwrap());
assert_eq!(layout.frame_meta_data.len(), 3, "reader saw wrong frame count");
let converter = TimsIndexConverter::Simple(SimpleIndexConverter::from_boundaries(
100.0, 1700.0, 400_000, 0.6, 1.6, 99,
));
let reader = TimsLazyLoder { raw_data_layout: layout, index_converter: converter };
for f in &frames {
let raw = reader.get_raw_frame(f.frame_id);
let scans = crate::data::utility::flatten_scan_values(&raw.scan, true);
let mut got: Vec<(u32, u32, u32)> = scans
.iter()
.zip(raw.tof.iter())
.zip(raw.intensity.iter())
.map(|((&s, &t), &i)| (s, t, i as u32))
.collect();
got.sort_unstable();
let mut want: Vec<(u32, u32, u32)> = f
.scans
.iter()
.zip(f.tofs.iter())
.zip(f.intensities.iter())
.map(|((&s, &t), &i)| (s, t, i))
.collect();
want.sort_unstable();
assert_eq!(got, want, "frame {} raw data did not round-trip", f.frame_id);
}
let _ = fs::remove_dir_all(&dir);
}
#[test]
fn dda_d_round_trips_with_reselected_precursor() {
use crate::data::meta::read_pasef_frame_ms_ms_info;
let dir = std::env::temp_dir().join(format!("timsim_tdf_dda_test_{}", std::process::id()));
let _ = fs::remove_dir_all(&dir);
let ms_types = [0u8, 8, 8, 0, 8];
let cfg = TdfWriterConfig { num_scans: 100, scan_mode: 8, ..Default::default() };
let mut w = TdfWriter::create(&dir, cfg).unwrap();
for (i, &t) in ms_types.iter().enumerate() {
w.write_frame(&RenderedFrame {
frame_id: i as u32 + 1,
retention_time: i as f64 * 0.1,
ms_ms_type: t,
scans: vec![10 + i as u32, 40],
tofs: vec![200, 500],
intensities: vec![50, 90],
})
.unwrap();
}
let precursors = vec![
DdaPrecursor { id: 100, largest_peak_mz: 596.9, average_mz: 596.7, monoisotopic_mz: 596.6, charge: 2, scan_number: 20.5, intensity: 4600.0, parent: 1 },
DdaPrecursor { id: 200, largest_peak_mz: 712.4, average_mz: 712.2, monoisotopic_mz: 712.1, charge: 3, scan_number: 50.0, intensity: 2100.0, parent: 1 },
];
let pasef = vec![
DdaPasefWindow { frame: 2, scan_num_begin: 10, scan_num_end: 32, isolation_mz: 596.9, isolation_width: 2.0, collision_energy: 31.5, precursor: 100 },
DdaPasefWindow { frame: 2, scan_num_begin: 40, scan_num_end: 62, isolation_mz: 712.4, isolation_width: 3.0, collision_energy: 34.0, precursor: 200 },
DdaPasefWindow { frame: 5, scan_num_begin: 10, scan_num_end: 32, isolation_mz: 596.9, isolation_width: 2.0, collision_energy: 31.6, precursor: 100 },
];
w.set_dda_schedule(precursors, pasef);
w.finalize().unwrap();
let bands = read_pasef_frame_ms_ms_info(dir.to_str().unwrap()).unwrap();
assert_eq!(bands.len(), 3, "all PASEF bands must round-trip");
let for_100: Vec<&_> = bands.iter().filter(|b| b.precursor_id == 100).collect();
assert_eq!(for_100.len(), 2, "re-selected precursor 100 must keep both bands");
let frames_100: std::collections::HashSet<i64> = for_100.iter().map(|b| b.frame_id).collect();
assert_eq!(frames_100, [2i64, 5].into_iter().collect(), "precursor 100's two events are frames 2 and 5");
let conn = Connection::open(dir.join("analysis.tdf")).unwrap();
let n_prec: i64 = conn.query_row("SELECT COUNT(*) FROM Precursors", [], |r| r.get(0)).unwrap();
assert_eq!(n_prec, 2, "one Precursors row per ion");
let non8: i64 = conn.query_row("SELECT COUNT(*) FROM Frames WHERE ScanMode != 8", [], |r| r.get(0)).unwrap();
assert_eq!(non8, 0, "DDA frames must have ScanMode 8");
let pasef_not_ms2: i64 = conn.query_row(
"SELECT COUNT(*) FROM PasefFrameMsMsInfo p LEFT JOIN Frames f ON p.Frame = f.Id WHERE f.MsMsType != 8 OR f.Id IS NULL",
[], |r| r.get(0)).unwrap();
assert_eq!(pasef_not_ms2, 0, "every PASEF Frame must be an MS2 frame");
let bad_parent: i64 = conn.query_row(
"SELECT COUNT(*) FROM Precursors pr LEFT JOIN Frames f ON pr.Parent = f.Id WHERE f.MsMsType != 0 OR f.Id IS NULL",
[], |r| r.get(0)).unwrap();
assert_eq!(bad_parent, 0, "every Precursor.Parent must be an MS1 survey frame");
let fk_violations: i64 = conn.query_row("SELECT COUNT(*) FROM pragma_foreign_key_check", [], |r| r.get(0)).unwrap();
assert_eq!(fk_violations, 0, "foreign_key_check must be clean");
let closed: String = conn.query_row("SELECT Value FROM GlobalMetadata WHERE Key='ClosedProperly'", [], |r| r.get(0)).unwrap();
assert_eq!(closed, "1", "ClosedProperly stamped after all writes");
let _ = fs::remove_dir_all(&dir);
}
#[test]
fn dda_rejects_orphan_pasef_band() {
let dir = std::env::temp_dir().join(format!("timsim_tdf_dda_reject_{}", std::process::id()));
let _ = fs::remove_dir_all(&dir);
let cfg = TdfWriterConfig { num_scans: 100, scan_mode: 8, ..Default::default() };
let mut w = TdfWriter::create(&dir, cfg).unwrap();
for (i, &t) in [0u8, 8].iter().enumerate() {
w.write_frame(&RenderedFrame {
frame_id: i as u32 + 1, retention_time: 0.0, ms_ms_type: t,
scans: vec![10], tofs: vec![100], intensities: vec![5],
}).unwrap();
}
let precursors = vec![DdaPrecursor { id: 1, largest_peak_mz: 500.0, average_mz: 500.0, monoisotopic_mz: 500.0, charge: 2, scan_number: 10.0, intensity: 100.0, parent: 1 }];
let pasef = vec![DdaPasefWindow { frame: 2, scan_num_begin: 5, scan_num_end: 20, isolation_mz: 500.0, isolation_width: 2.0, collision_energy: 30.0, precursor: 999 }];
w.set_dda_schedule(precursors, pasef);
assert!(w.finalize().is_err(), "an orphan PASEF band must be rejected before writing");
let _ = fs::remove_dir_all(&dir);
}
}