Struct KothConfig 

pub struct KothConfig {
    pub file: FileConfig,
    pub hills: HillsConfig,
    pub hills_ms2: Option<HillsMs2Overrides>,
    pub features: FeaturesConfig,
    pub scoring: ScoringConfig,
    pub output: OutputConfig,
}

Fields

file: FileConfig

hills: HillsConfig

hills_ms2: Option<HillsMs2Overrides>

Optional per-field overrides for MS2 (DIA fragment) hill detection. Absent (None) ⇒ MS2 hills use [hills] verbatim (byte-identical to the pre-existing behavior). Present ⇒ MS2 hill detection inherits [hills] and applies only the fields set here. See KothConfig::ms2_hills.

features: FeaturesConfig

scoring: ScoringConfig

output: OutputConfig

Implementations

impl KothConfig

pub fn from_toml(path: &Path) -> Result<KothConfig, Error>

Examples found in repository

examples/validate_configs.rs (line 12)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    for path in std::env::args().skip(1) {
        let p = std::path::Path::new(&path);
        if p.file_name()
            .unwrap()
            .to_string_lossy()
            .starts_with("koth_align")
        {
            koth_ms::config::AlignConfig::from_toml(p)?;
        } else {
            koth_ms::config::KothConfig::from_toml(p)?;
        }
        println!("parsed {}", path);
    }
    Ok(())
}

examples/replay_features.rs (line 35)

fn main() -> anyhow::Result<()> {
    let args = Args::parse();
    rayon::ThreadPoolBuilder::new()
        .num_threads(args.threads)
        .build_global()?;
    let start = Instant::now();
    let hills = read_hills(&args.hills).context("read cached hills")?;
    let read_s = start.elapsed().as_secs_f64();
    for config_path in &args.config {
        let label = config_path
            .file_stem()
            .context("config needs a file stem")?;
        let out = args.output.join(label);
        anyhow::ensure!(!out.exists(), "refusing to overwrite {}", out.display());
        let config = KothConfig::from_toml(config_path)?;
        let start = Instant::now();
        let features = koth_ms::run_features(&hills, &config.features, &config.file)?;
        let feature_s = start.elapsed().as_secs_f64();
        let start = Instant::now();
        let scored = koth_ms::run_scoring(
            &features,
            &config.scoring,
            &config.features,
            config.file.polarity,
        );
        let scoring_s = start.elapsed().as_secs_f64();
        std::fs::create_dir_all(&out)?;
        let start = Instant::now();
        write_features_parquet(&scored, &out.join("features.parquet"), config.file.polarity)?;
        let write_s = start.elapsed().as_secs_f64();
        std::fs::write(out.join("config.toml"), config.to_toml_string()?)?;
        let report = serde_json::json!({
            "hills": hills.len(), "features_before_filter": features.len(),
            "features_after_filter": scored.len(), "read_hills_s": read_s,
            "feature_s": feature_s, "scoring_s": scoring_s, "write_s": write_s,
            "input": args.hills, "config": config_path, "threads": args.threads,
        });
        std::fs::write(
            out.join("timing.json"),
            serde_json::to_string_pretty(&report)?,
        )?;
        println!(
            "{}: {} features, detection {:.2}s, scoring {:.2}s, writing {:.2}s",
            label.to_string_lossy(),
            scored.len(),
            feature_s,
            scoring_s,
            write_s
        );
    }
    Ok(())
}

pub fn to_toml_string(&self) -> Result<String, Error>

Examples found in repository

examples/replay_features.rs (line 51)

fn main() -> anyhow::Result<()> {
    let args = Args::parse();
    rayon::ThreadPoolBuilder::new()
        .num_threads(args.threads)
        .build_global()?;
    let start = Instant::now();
    let hills = read_hills(&args.hills).context("read cached hills")?;
    let read_s = start.elapsed().as_secs_f64();
    for config_path in &args.config {
        let label = config_path
            .file_stem()
            .context("config needs a file stem")?;
        let out = args.output.join(label);
        anyhow::ensure!(!out.exists(), "refusing to overwrite {}", out.display());
        let config = KothConfig::from_toml(config_path)?;
        let start = Instant::now();
        let features = koth_ms::run_features(&hills, &config.features, &config.file)?;
        let feature_s = start.elapsed().as_secs_f64();
        let start = Instant::now();
        let scored = koth_ms::run_scoring(
            &features,
            &config.scoring,
            &config.features,
            config.file.polarity,
        );
        let scoring_s = start.elapsed().as_secs_f64();
        std::fs::create_dir_all(&out)?;
        let start = Instant::now();
        write_features_parquet(&scored, &out.join("features.parquet"), config.file.polarity)?;
        let write_s = start.elapsed().as_secs_f64();
        std::fs::write(out.join("config.toml"), config.to_toml_string()?)?;
        let report = serde_json::json!({
            "hills": hills.len(), "features_before_filter": features.len(),
            "features_after_filter": scored.len(), "read_hills_s": read_s,
            "feature_s": feature_s, "scoring_s": scoring_s, "write_s": write_s,
            "input": args.hills, "config": config_path, "threads": args.threads,
        });
        std::fs::write(
            out.join("timing.json"),
            serde_json::to_string_pretty(&report)?,
        )?;
        println!(
            "{}: {} features, detection {:.2}s, scoring {:.2}s, writing {:.2}s",
            label.to_string_lossy(),
            scored.len(),
            feature_s,
            scoring_s,
            write_s
        );
    }
    Ok(())
}

pub fn ms2_hills(&self) -> HillsConfig

Resolve the HillsConfig to use for MS2 (DIA fragment) hill detection.

When [hills_ms2] is absent this returns self.hills unchanged — the MS2 path is byte-for-byte identical to using [hills] directly. When present, MS2 hill detection inherits every [hills] value and overwrites only the fields set under [hills_ms2] (see HillsMs2Overrides).

Pipeline entry points (run_pipeline_with_ms2, run_pipeline_streaming, …) and the binary route MS2 detection through this method, so a single KothConfig drives MS1 and MS2 hill settings independently.

Trait Implementations

impl Clone for KothConfig

fn clone(&self) -> KothConfig

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for KothConfig

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Default for KothConfig

fn default() -> KothConfig

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for KothConfig

where KothConfig: Default,

fn deserialize<__D>( __deserializer: __D, ) -> Result<KothConfig, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for KothConfig

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.