pandora_lib_promethion/src/config.rs

#[derive(Debug, Clone)]
pub struct Config {
    pub pod_dir: String,
    pub result_dir: String,
    pub align: AlignConfig,
    pub reference: String,
    pub reference_name: String,
    pub dict_file: String,
    pub refseq_gff: String,
    pub docker_max_memory_go: u16,
    pub savana_bin: String,
    pub savana_threads: u8,
    pub tumoral_name: String,
    pub normal_name: String,
    pub haplotagged_bam_tag_name: String,
    pub count_dir_name: String,
    pub count_bin_size: u32,
    pub count_n_chunks: u32,
    pub savana_output_dir: String,
    pub savana_copy_number: String,
    pub savana_read_counts: String,
    pub germline_phased_vcf: String,
    pub savana_passed_vcf: String,
    pub conda_sh: String,
    pub savana_force: bool,
    pub deepvariant_output_dir: String,
    pub severus_bin: String,
    pub severus_force: bool,
    pub severus_threads: u8,
    pub vntrs_bed: String,
    pub severus_pon: String,
    pub severus_output_dir: String,
    pub severus_solo_output_dir: String,
    pub longphase_bin: String,
    pub longphase_threads: u8,
    pub longphase_modcall_vcf: String,
    pub modkit_bin: String,
    pub modkit_summary_threads: u8,
    pub modkit_summary_file: String,
    pub longphase_modcall_threads: u8,
    pub deepvariant_threads: u8,
    pub deepvariant_bin_version: String,
    pub deepvariant_model_type: String,
    pub deepvariant_force: bool,
    pub deepsomatic_output_dir: String,
    pub deepsomatic_threads: u8,
    pub deepsomatic_bin_version: String,
    pub deepsomatic_model_type: String,
    pub deepsomatic_force: bool,
    pub bam_min_mapq: u8,
    pub bam_n_threads: u8,
    pub db_cases_path: String,
    pub somatic_pipe_stats: String,

    pub clairs_threads: u8,
    pub clairs_force: bool,
    pub clairs_platform: String,
    pub clairs_output_dir: String,
    pub mask_bed: String,
    pub somatic_min_constit_depth: u16,
    pub somatic_max_alt_constit: u16,
    pub entropy_seq_len: usize,
    pub min_shannon_entropy: f64,
    pub nanomonsv_bin: String,
    pub nanomonsv_output_dir: String,
    pub nanomonsv_force: bool,
    pub nanomonsv_threads: u8,
    pub nanomonsv_passed_vcf: String,
    pub nanomonsv_solo_output_dir: String,
    pub nanomonsv_solo_passed_vcf: String,
    pub somatic_pipe_force: bool,
    pub somatic_pipe_threads: u8,
    pub min_high_quality_depth: u32,
    pub min_n_callers: u8,
    pub somatic_scan_force: bool,
    pub early_bed: String,
    pub late_bed: String,
    pub panels: Vec<(String, String)>,
    pub cpg_bed: String,
    pub max_depth_low_quality: u32,
}

// Here comes names that can't be changed from output of tools
lazy_static! {
    static ref DEEPVARIANT_OUTPUT_NAME: &'static str = "{id}_{time}_DeepVariant.vcf.gz";
    static ref CLAIRS_OUTPUT_NAME: &'static str = "output.vcf.gz";
    static ref CLAIRS_OUTPUT_INDELS_NAME: &'static str = "indel.vcf.gz";
    static ref CLAIRS_GERMLINE_NORMAL: &'static str = "clair3_normal_germline_output.vcf.gz";
    static ref CLAIRS_GERMLINE_TUMOR: &'static str = "clair3_tumor_germline_output.vcf.gz";
}

impl Default for Config {
    fn default() -> Self {
        Self {
            pod_dir: "/data/run_data".to_string(),
            align: Default::default(),

            // Reference genome
            reference: "/data/ref/hs1/chm13v2.0.fa".to_string(),
            reference_name: "hs1".to_string(),
            dict_file: "/data/ref/hs1/chm13v2.0.dict".to_string(),
            refseq_gff: "/data/ref/hs1/chm13v2.0_RefSeq_Liftoff_v5.1_sorted.gff3.gz".to_string(),

            docker_max_memory_go: 400,

            // File structure
            result_dir: "/data/longreads_basic_pipe".to_string(),

            tumoral_name: "diag".to_string(),
            normal_name: "mrd".to_string(),
            haplotagged_bam_tag_name: "HP".to_string(),

            count_dir_name: "counts".to_string(),
            count_bin_size: 1_000,
            count_n_chunks: 1_000,

            bam_min_mapq: 40,
            bam_n_threads: 150,

            db_cases_path: "/data/cases.sqlite".to_string(),

            //
            mask_bed: "{result_dir}/{id}/diag/mask.bed".to_string(),

            germline_phased_vcf: "{result_dir}/{id}/diag/{id}_variants_constit_phased.vcf.gz
"
            .to_string(),
            conda_sh: "/data/miniconda3/etc/profile.d/conda.sh".to_string(),

            somatic_pipe_stats: "{result_dir}/{id}/diag/somatic_pipe_stats"
            .to_string(),

            // DeepVariant
            deepvariant_output_dir: "{result_dir}/{id}/{time}/DeepVariant".to_string(),
            deepvariant_threads: 150,
            deepvariant_bin_version: "1.8.0".to_string(),
            deepvariant_model_type: "ONT_R104".to_string(),
            deepvariant_force: false,

            // DeepSomatic
            deepsomatic_output_dir: "{result_dir}/{id}/{time}/DeepSomatic".to_string(),
            deepsomatic_threads: 155,
            deepsomatic_bin_version: "1.8.0".to_string(),
            deepsomatic_model_type: "ONT".to_string(),
            deepsomatic_force: false,

            // ClairS
            clairs_output_dir: "{result_dir}/{id}/diag/ClairS".to_string(),
            clairs_threads: 155,
            clairs_platform: "ont_r10_dorado_sup_5khz_ssrs".to_string(),
            clairs_force: false,

            // Savana
            savana_bin: "savana".to_string(),
            // savana_bin: "/home/prom/.local/bin/savana".to_string(),
            savana_threads: 150,
            savana_output_dir: "{result_dir}/{id}/diag/savana".to_string(),
            savana_passed_vcf: "{output_dir}/{id}_diag_savana_PASSED.vcf.gz".to_string(),
            savana_copy_number: "{output_dir}/{id}_diag_{reference_name}_{haplotagged_bam_tag_name}_segmented_absolute_copy_number.tsv".to_string(),
            savana_read_counts: "{output_dir}/{id}_diag_{reference_name}_{haplotagged_bam_tag_name}_raw_read_counts.tsv".to_string(),
            savana_force: false,

            // Severus
            severus_bin: "/data/tools/Severus/severus.py".to_string(),
            severus_threads: 32,
            vntrs_bed: "/data/ref/hs1/vntrs_chm13.bed".to_string(),
            severus_pon: "/data/ref/hs1/PoN_1000G_chm13.tsv.gz".to_string(),
            severus_output_dir: "{result_dir}/{id}/diag/severus".to_string(),
            severus_solo_output_dir: "{result_dir}/{id}/{time}/severus".to_string(),
            severus_force: false,

            // Longphase
            longphase_bin: "/data/tools/longphase_linux-x64".to_string(),
            longphase_threads: 150,
            longphase_modcall_threads: 8, // ! out of memory
            longphase_modcall_vcf:
                "{result_dir}/{id}/{time}/5mC_5hmC/{id}_{time}_5mC_5hmC_modcall.vcf.gz".to_string(),

            // modkit
            modkit_bin: "modkit".to_string(),
            modkit_summary_threads: 50,
            modkit_summary_file: "{result_dir}/{id}/{time}/{id}_{time}_5mC_5hmC_summary.txt"
                .to_string(),

            // Nanomonsv
            // tabix, bgzip, mafft in PATH
            // pip install pysam, parasail;  pip install nanomonsv
            nanomonsv_bin: "/home/prom/.local/bin/nanomonsv".to_string(),
            nanomonsv_output_dir: "{result_dir}/{id}/{time}/nanomonsv".to_string(),
            nanomonsv_threads: 150,
            nanomonsv_force: false,
            nanomonsv_passed_vcf: "{output_dir}/{id}_diag_nanomonsv_PASSED.vcf.gz".to_string(),

            nanomonsv_solo_output_dir: "{result_dir}/{id}/{time}/nanomonsv-solo".to_string(),
            nanomonsv_solo_passed_vcf: "{output_dir}/{id}_{time}_nanomonsv-solo_PASSED.vcf.gz"
                .to_string(),

            // Scan
            somatic_scan_force: false,

            // Pipe
            somatic_pipe_force: true,
            somatic_pipe_threads: 150,
            somatic_min_constit_depth: 5,
            somatic_max_alt_constit: 1,
            entropy_seq_len: 10,
            min_shannon_entropy: 1.0,

            max_depth_low_quality: 20,
            min_high_quality_depth: 14, 
            min_n_callers: 1,
            early_bed: "/data/ref/hs1/replication_early_25_hs1.bed".to_string(),
            late_bed: "/data/ref/hs1/replication_late_75_hs1.bed".to_string(),
            panels: vec![
                ("OncoT".to_string(), "/data/ref/hs1/V1_V2_V3_V4_V5_intersect_targets_hs1_uniq.bed".to_string()),
                ("variable_chips".to_string(), "/data/ref/hs1/top_1500_sd_pos.bed".to_string()),
            ],
            cpg_bed: "/data/ref/hs1/hs1/hs1_CpG.bed".to_string(),
        }
    }
}

#[derive(Debug, Clone)]
pub struct AlignConfig {
    pub dorado_bin: String,
    pub dorado_basecall_arg: String,
    pub ref_fa: String,
    pub ref_mmi: String,
    pub samtools_view_threads: u16,
    pub samtools_sort_threads: u16,
}

impl Default for AlignConfig {
    fn default() -> Self {
        Self {
            dorado_bin: "/data/tools/dorado-0.9.1-linux-x64/bin/dorado".to_string(),
            dorado_basecall_arg: "-x 'cuda:0,1,2,3' sup,5mC_5hmC".to_string(),
            // to specify cuda devices (exclude the T1000)
            ref_fa: "/data/ref/hs1/chm13v2.0.fa".to_string(),
            ref_mmi: "/data/ref/chm13v2.0.mmi".to_string(),
            samtools_view_threads: 20,
            samtools_sort_threads: 50,
        }
    }
}

impl Config {
    pub fn tumoral_dir(&self, id: &str) -> String {
        format!("{}/{}/{}", self.result_dir, id, self.tumoral_name)
    }

    pub fn normal_dir(&self, id: &str) -> String {
        format!("{}/{}/{}", self.result_dir, id, self.normal_name)
    }

    pub fn solo_dir(&self, id: &str, time: &str) -> String {
        format!("{}/{}/{}", self.result_dir, id, time)
    }

    pub fn solo_bam(&self, id: &str, time: &str) -> String {
        format!(
            "{}/{}_{}_{}.bam",
            self.solo_dir(id, time),
            id,
            time,
            self.reference_name,
        )
    }

    pub fn tumoral_bam(&self, id: &str) -> String {
        format!(
            "{}/{}_{}_{}.bam",
            self.tumoral_dir(id),
            id,
            self.tumoral_name,
            self.reference_name,
        )
    }

    pub fn normal_bam(&self, id: &str) -> String {
        format!(
            "{}/{}_{}_{}.bam",
            self.normal_dir(id),
            id,
            self.normal_name,
            self.reference_name,
        )
    }

    pub fn tumoral_haplotagged_bam(&self, id: &str) -> String {
        format!(
            "{}/{}_{}_{}_{}.bam",
            self.tumoral_dir(id),
            id,
            self.tumoral_name,
            self.reference_name,
            self.haplotagged_bam_tag_name
        )
    }

    pub fn normal_haplotagged_bam(&self, id: &str) -> String {
        format!(
            "{}/{}_{}_{}_{}.bam",
            self.normal_dir(id),
            id,
            self.normal_name,
            self.reference_name,
            self.haplotagged_bam_tag_name
        )
    }

    pub fn normal_dir_count(&self, id: &str) -> String {
        format!("{}/{}", self.normal_dir(id), self.count_dir_name)
    }

    pub fn tumoral_dir_count(&self, id: &str) -> String {
        format!("{}/{}", self.tumoral_dir(id), self.count_dir_name)
    }

    pub fn mask_bed(&self, id: &str) -> String {
        self.mask_bed
            .replace("{result_dir}", &self.result_dir)
            .replace("{id}", id)
    }

    pub fn germline_phased_vcf(&self, id: &str) -> String {
        self.germline_phased_vcf
            .replace("{result_dir}", &self.result_dir)
            .replace("{id}", id)
    }

    pub fn somatic_pipe_stats(&self, id: &str) -> String {
        self.somatic_pipe_stats
            .replace("{result_dir}", &self.result_dir)
            .replace("{id}", id)
    }

    // DeepVariant
    pub fn deepvariant_output_dir(&self, id: &str, time: &str) -> String {
        self.deepvariant_output_dir
            .replace("{result_dir}", &self.result_dir)
            .replace("{id}", id)
            .replace("{time}", time)
    }

    pub fn deepvariant_solo_output_vcf(&self, id: &str, time: &str) -> String {
        format!(
            "{}/{}",
            self.deepvariant_output_dir(id, time),
            *DEEPVARIANT_OUTPUT_NAME
        )
        .replace("{id}", id)
        .replace("{time}", time)
    }

    pub fn deepvariant_normal_output_dir(&self, id: &str) -> String {
        self.deepvariant_output_dir(id, &self.normal_name)
    }

    pub fn deepvariant_tumoral_output_dir(&self, id: &str) -> String {
        self.deepvariant_solo_passed_vcf(id, &self.tumoral_name)
    }

    pub fn deepvariant_solo_passed_vcf(&self, id: &str, time: &str) -> String {
        format!(
            "{}/{}_{}_DeepVariant_PASSED.vcf.gz",
            self.deepvariant_output_dir(id, time),
            id,
            time
        )
    }

    pub fn deepvariant_normal_passed_vcf(&self, id: &str) -> String {
        self.deepvariant_solo_passed_vcf(id, &self.normal_name)
    }

    pub fn deepvariant_tumoral_passed_vcf(&self, id: &str) -> String {
        self.deepvariant_solo_passed_vcf(id, &self.tumoral_name)
    }

    // DeepSomatic
    pub fn deepsomatic_output_dir(&self, id: &str) -> String {
        self.deepsomatic_output_dir
            .replace("{result_dir}", &self.result_dir)
            .replace("{id}", id)
            .replace("{time}", &self.tumoral_name)
    }

    pub fn deepsomatic_output_vcf(&self, id: &str) -> String {
        format!(
            "{}/{}_{}_DeepSomatic.vcf.gz",
            self.deepsomatic_output_dir(id),
            id,
            self.tumoral_name
        )
    }

    pub fn deepsomatic_passed_vcf(&self, id: &str) -> String {
        format!(
            "{}/{}_{}_DeepSomatic_PASSED.vcf.gz",
            self.deepvariant_normal_output_dir(id),
            id,
            self.tumoral_name
        )
    }

    // ClairS
    pub fn clairs_output_dir(&self, id: &str) -> String {
        self.clairs_output_dir
            .replace("{result_dir}", &self.result_dir)
            .replace("{id}", id)
    }

    pub fn clairs_output_vcfs(&self, id: &str) -> (String, String) {
        let dir = self.clairs_output_dir(id);
        (
            format!("{dir}/{}", *CLAIRS_OUTPUT_NAME),
            format!("{dir}/{}", *CLAIRS_OUTPUT_INDELS_NAME),
        )
    }

    pub fn clairs_passed_vcf(&self, id: &str) -> String {
        format!(
            "{}/{}_{}_clairs_PASSED.vcf.gz",
            self.clairs_output_dir(id),
            id,
            self.tumoral_name
        )
    }

    pub fn clairs_germline_normal_vcf(&self, id: &str) -> String {
        let dir = self.clairs_output_dir(id);
        format!("{dir}/{}", *CLAIRS_GERMLINE_NORMAL)
    }

    pub fn clairs_germline_tumor_vcf(&self, id: &str) -> String {
        let dir = self.clairs_output_dir(id);
        format!("{dir}/{}", *CLAIRS_GERMLINE_TUMOR)
    }

    pub fn clairs_germline_passed_vcf(&self, id: &str) -> String {
        let dir = self.clairs_output_dir(id);
        format!("{dir}/{id}_diag_clair3-germline_PASSED.vcf.gz")
    }

    // Nanomonsv
    pub fn nanomonsv_output_dir(&self, id: &str, time: &str) -> String {
        self.nanomonsv_output_dir
            .replace("{result_dir}", &self.result_dir)
            .replace("{id}", id)
            .replace("{time}", time)
    }

    pub fn nanomonsv_passed_vcf(&self, id: &str) -> String {
        self.nanomonsv_passed_vcf
            .replace("{output_dir}", &self.nanomonsv_output_dir(id, "diag"))
            .replace("{id}", id)
    }

    // Nanomonsv solo
    pub fn nanomonsv_solo_output_dir(&self, id: &str, time: &str) -> String {
        self.nanomonsv_solo_output_dir
            .replace("{result_dir}", &self.result_dir)
            .replace("{id}", id)
            .replace("{time}", time)
    }

    pub fn nanomonsv_solo_passed_vcf(&self, id: &str, time: &str) -> String {
        self.nanomonsv_solo_passed_vcf
            .replace("{output_dir}", &self.nanomonsv_solo_output_dir(id, time))
            .replace("{id}", id)
            .replace("{time}", time)
    }

    // Savana
    pub fn savana_output_dir(&self, id: &str) -> String {
        self.savana_output_dir
            .replace("{result_dir}", &self.result_dir)
            .replace("{id}", id)
    }

    pub fn savana_output_vcf(&self, id: &str) -> String {
        let output_dir = self.savana_output_dir(id);

        format!(
            "{output_dir}/{id}_{}_{}_{}.classified.somatic.vcf",
            self.tumoral_name, self.reference_name, self.haplotagged_bam_tag_name
        )
    }

    pub fn savana_passed_vcf(&self, id: &str) -> String {
        self.savana_passed_vcf
            .replace("{output_dir}", &self.savana_output_dir(id))
            .replace("{id}", id)
    }

    // {output_dir}/{id}_diag_{reference_name}_{haplotagged_bam_tag_name}
    pub fn savana_read_counts(&self, id: &str) -> String {
        self.savana_read_counts
            .replace("{output_dir}", &self.savana_output_dir(id))
            .replace("{id}", id)
            .replace("{reference_name}", &self.reference_name)
            .replace("{haplotagged_bam_tag_name}", &self.haplotagged_bam_tag_name)
    }

    pub fn savana_copy_number(&self, id: &str) -> String {
        self.savana_copy_number
            .replace("{output_dir}", &self.savana_output_dir(id))
            .replace("{id}", id)
            .replace("{reference_name}", &self.reference_name)
            .replace("{haplotagged_bam_tag_name}", &self.haplotagged_bam_tag_name)
    }

    // Severus
    pub fn severus_output_dir(&self, id: &str) -> String {
        self.severus_output_dir
            .replace("{result_dir}", &self.result_dir)
            .replace("{id}", id)
    }

    pub fn severus_output_vcf(&self, id: &str) -> String {
        let output_dir = self.severus_output_dir(id);
        format!("{output_dir}/somatic_SVs/severus_somatic.vcf")
    }

    pub fn severus_passed_vcf(&self, id: &str) -> String {
        format!(
            "{}/{}_diag_severus_PASSED.vcf.gz",
            &self.severus_output_dir(id),
            id
        )
    }

    // Severus solo
    pub fn severus_solo_output_dir(&self, id: &str, time: &str) -> String {
        self.severus_solo_output_dir
            .replace("{result_dir}", &self.result_dir)
            .replace("{id}", id)
            .replace("{time}", time)
    }

    pub fn severus_solo_output_vcf(&self, id: &str, time: &str) -> String {
        let output_dir = self.severus_solo_output_dir(id, time);
        format!("{output_dir}/all_SVs/severus_all.vcf")
    }

    pub fn severus_solo_passed_vcf(&self, id: &str, time: &str) -> String {
        format!(
            "{}/{}_{}_severus-solo_PASSED.vcf.gz",
            &self.severus_solo_output_dir(id, time),
            id,
            time
        )
    }

    pub fn constit_vcf(&self, id: &str) -> String {
        self.clairs_germline_passed_vcf(id)
        // format!("{}/{}_variants_constit.vcf.gz", self.tumoral_dir(id), id)
    }

    pub fn constit_phased_vcf(&self, id: &str) -> String {
        format!(
            "{}/{}_variants_constit_phased.vcf.gz",
            self.tumoral_dir(id),
            id
        )
    }

    // SomaticScan
    pub fn somatic_scan_solo_output_dir(&self, id: &str, time: &str) -> String {
        format!("{}/counts", self.solo_dir(id, time))
    }

    pub fn somatic_scan_normal_output_dir(&self, id: &str) -> String {
        self.somatic_scan_solo_output_dir(id, &self.normal_name)
    }

    pub fn somatic_scan_tumoral_output_dir(&self, id: &str) -> String {
        self.somatic_scan_solo_output_dir(id, &self.tumoral_name)
    }

    pub fn somatic_scan_solo_count_file(&self, id: &str, time: &str, contig: &str) -> String {
        format!(
            "{}/{}_count.tsv.gz",
            self.somatic_scan_solo_output_dir(id, time),
            contig
        )
    }

    pub fn somatic_scan_normal_count_file(&self, id: &str, contig: &str) -> String {
        self.somatic_scan_solo_count_file(id, &self.normal_name, contig)
    }

    pub fn somatic_scan_tumoral_count_file(&self, id: &str, contig: &str) -> String {
        self.somatic_scan_solo_count_file(id, &self.tumoral_name, contig)
    }

    // Modkit
    pub fn modkit_summary_file(&self, id: &str, time: &str) -> String {
        self.modkit_summary_file
            .replace("{result_dir}", &self.result_dir)
            .replace("{id}", id)
            .replace("{time}", time)
    }

    pub fn longphase_modcall_vcf(&self, id: &str, time: &str) -> String {
        self.longphase_modcall_vcf
            .replace("{result_dir}", &self.result_dir)
            .replace("{id}", id)
            .replace("{time}", time)
    }
}