bascet 0.4.0

Bascet is a tool to preprocess single-cell data, handling barcode detection, trimming, QC, and managing the execution of custom tools for each cell
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118


use std::path::PathBuf;
use std::env;

use crate::mapcell::CompressionMode;
use crate::mapcell::MissingFileMode;
use crate::mapcell::MapCellFunction;

use crate::kmer::kmc_counter::KmerCounter;


#[derive(Clone, Debug)] 
pub struct MapCellMinHashFQ {
}
impl MapCellFunction for MapCellMinHashFQ {

    fn invoke(
        &self,
        input_dir: &PathBuf,
        output_dir: &PathBuf,
        _num_threads: usize
    ) -> anyhow::Result<(bool, String)> {

        //Define files
        let input_file_r1 = input_dir.join("r1.fq"); 
        let input_file_r2 = input_dir.join("r2.fq"); 
        let output_file = output_dir.join("minhash.txt");

        //Parse parameters
        let kmer_size: usize = get_param_kmer_size().unwrap_or(31);
        let num_min_hash = get_param_num_minhash().unwrap_or(1000);
        let max_reads = get_param_max_reads().unwrap_or(100000000);

        log::debug!("Chosen KMER size: {}", kmer_size);
        log::debug!("Chosen #minhash: {}", num_min_hash);

        //Example: novaseq cell of 8M reads - this took quite some time with this function
        let mut min_hash = KmerCounter::get_minhash_fq(
            input_file_r1,
            input_file_r2,
            kmer_size,
            num_min_hash,
            max_reads
        ).expect("Could not get minhash");

        KmerCounter::store_minhash_seq(
            kmer_size,
            &mut min_hash,
            &output_file
        );
            
        Ok((true, String::from("")))
    }  

    fn get_missing_file_mode(&self) -> MissingFileMode {
        MissingFileMode::Skip
    }

    fn get_compression_mode(&self, _fname: &str) -> CompressionMode {
        CompressionMode::Default
    }

    fn get_expect_files(&self) -> Vec<String> {
        let mut expect = Vec::new();
        expect.push("r1.fq".to_string()); 
        expect.push("r2.fq".to_string()); 
        expect
    }

    fn get_recommend_threads(&self) -> usize {
        1
    }


    fn preflight_check(&self) -> bool {
        // KMER_SIZE must be set
        //get_param_kmer_size().is_some()
        true
    }
}




fn get_param_kmer_size() -> Option<usize> {
    let key = "KMER_SIZE";
    let val = env::var(key);
    if let Ok(val) = val {
        Some(val.parse::<usize>().unwrap())
    } else {
        None
    }
}



fn get_param_num_minhash() -> Option<usize> {
    let key = "NUM_MINHASH";
    let val = env::var(key);
    if let Ok(val) = val {
        Some(val.parse::<usize>().unwrap())
    } else {
        None
    }
}




fn get_param_max_reads() -> Option<usize> {
    let key = "MAX_READS";
    let val = env::var(key);
    if let Ok(val) = val {
        Some(val.parse::<usize>().unwrap())
    } else {
        None
    }
}