@sjcrh/proteinpaint-rust 2.75.0 → 2.81.5

package/Cargo.toml

@@ -14,7 +14,8 @@ rayon = "1.7.0"
 bgzip = "0.3.1"
 petgraph = "0.6.3"
 rusqlite="0.31.0"
-ndarray = "0.15.6"
+ndarray = "0.16.1"
+hdf5 = { package = "hdf5-metno", version = "0.9.0" }
 nalgebra = {version = "0.32.2", features = ["serde-serialize"]}
 plotters = "0.3.4"
 colorgrad = "0.6.2"
@@ -90,3 +91,7 @@ path="src/genesetORA.rs"
 [[bin]]
 name="computeTopTerms"
 path="src/computeTopTerms.rs"
+
+[[bin]]
+name="readHDF5"
+path="src/readHDF5.rs"

package/package.json

@@ -1,5 +1,5 @@
 {
-	"version": "2.75.0",
+	"version": "2.81.5",
 	"name": "@sjcrh/proteinpaint-rust",
 	"description": "Rust-based utilities for proteinpaint",
 	"main": "index.js",
@@ -38,5 +38,5 @@
 	"devDependencies": {
 		"tape": "^5.2.2"
 	},
-	"pp_release_tag": "v2.75.0"
+	"pp_release_tag": "v2.81.5"
 }

package/src/DEanalysis.rs

@@ -1,6 +1,9 @@
-// cd .. && cargo build --release && json='{"min_count":10,"min_total_count":15,"case":"SJMB030827,SJMB030838,SJMB032893,SJMB031131,SJMB031227","control":"SJMB030488,SJMB030825,SJMB031110","input_file":"/Users/rpaul1/pp_data/files/hg38/sjmb12/rnaseq/geneCounts.txt"}' && time echo $json | target/release/DEanalysis
+// cd .. && cargo build --release && json='{"min_count":10,"min_total_count":15,"case":"SJMB030827,SJMB030838,SJMB032893,SJMB031131,SJMB031227","control":"SJMB030488,SJMB030825,SJMB031110","data_type":"do_DE","storage_type":"text","input_file":"/Users/rpaul1/pp_data/files/hg38/sjmb12/rnaseq/geneCounts.txt"}' && time echo $json | target/release/DEanalysis
+// cd .. && cargo build --release && json='{"data_type":"get_samples","input_file":"/Users/rpaul1/pp_data/files/hg38/ALL-pharmacotyping/rnaseq/counts.h5"}' && time echo $json | target/release/DEanalysis
 // cd .. && cargo build --release && time cat ~/sjpp/test.txt | target/release/DEanalysis
 #![allow(non_snake_case)]
+use hdf5::types::VarLenAscii;
+use hdf5::File as HDF5File;
 use json;
 use nalgebra::base::dimension::Const;
 use nalgebra::base::dimension::Dyn;
@@ -8,6 +11,9 @@ use nalgebra::base::Matrix;
 use nalgebra::base::VecStorage;
 use nalgebra::DMatrix;
 use nalgebra::ViewStorage;
+use ndarray::Array1;
+use ndarray::Array2;
+use ndarray::Dim;
 use serde::{Deserialize, Serialize};
 use serde_json;
 use statrs::statistics::Data;
@@ -55,7 +61,156 @@ fn binary_search(input: &Vec<usize>, y: usize) -> i64 {
     index
 }
 
-fn input_data(
+fn input_data_from_HDF5(
+    hdf5_filename: &String,
+    case_list: &Vec<&str>,
+    control_list: &Vec<&str>,
+) -> (
+    Matrix<f64, Dyn, Dyn, VecStorage<f64, Dyn, Dyn>>,
+    Vec<usize>,
+    Vec<usize>,
+    Vec<String>,
+    Vec<String>,
+) {
+    let file = HDF5File::open(&hdf5_filename).unwrap(); // open for reading
+    let ds_dim = file.dataset("dims").unwrap(); // open the dataset
+    let mut input_vector: Vec<f64> = Vec::with_capacity(500 * 65000);
+    let mut case_indexes: Vec<usize> = Vec::with_capacity(case_list.len());
+    let mut control_indexes: Vec<usize> = Vec::with_capacity(control_list.len());
+    // Check the data type and read the dataset accordingly
+    let data_dim: Array1<_> = ds_dim.read::<usize, Dim<[usize; 1]>>().unwrap();
+    let num_samples = data_dim[0]; // Number of total columns in the dataset
+    let num_genes = data_dim[1]; // Number of total rows in the dataset
+    println!("num_samples bulk:{}", num_samples);
+    println!("num_genes bulk:{}", num_genes);
+
+    let now_gene_names = Instant::now();
+    let ds_gene_names = file.dataset("gene_names").unwrap();
+    println!("ds_gene_names:{:?}", ds_gene_names);
+    let gene_names = ds_gene_names
+        .read::<VarLenAscii, Dim<[usize; 1]>>()
+        .unwrap();
+    println!("\tgene_names = {:?}", gene_names);
+    println!("\tgene_names.shape() = {:?}", gene_names.shape());
+    println!("\tgene_names.strides() = {:?}", gene_names.strides());
+    println!("\tgene_names.ndim() = {:?}", gene_names.ndim());
+    println!("Time for parsing gene names:{:?}", now_gene_names.elapsed());
+
+    let now_gene_symbols = Instant::now();
+    let ds_gene_symbols = file.dataset("gene_symbols").unwrap();
+    println!("ds_gene_symbols:{:?}", ds_gene_symbols);
+    let gene_symbols = ds_gene_symbols
+        .read::<VarLenAscii, Dim<[usize; 1]>>()
+        .unwrap();
+    println!("\tgene_symbols = {:?}", gene_symbols);
+    println!("\tgene_symbols.shape() = {:?}", gene_symbols.shape());
+    println!("\tgene_symbols.strides() = {:?}", gene_symbols.strides());
+    println!("\tgene_symbols.ndim() = {:?}", gene_symbols.ndim());
+    println!(
+        "Time for parsing gene symbols:{:?}",
+        now_gene_symbols.elapsed()
+    );
+
+    let mut gene_names_string: Vec<String> = Vec::with_capacity(gene_names.len());
+    let mut gene_symbols_string: Vec<String> = Vec::with_capacity(gene_symbols.len());
+    for i in 0..gene_names.len() {
+        gene_names_string.push(gene_names[i].to_string());
+        gene_symbols_string.push(gene_symbols[i].to_string());
+    }
+
+    let now_samples = Instant::now();
+    let ds_samples = file.dataset("samples").unwrap();
+    let samples = ds_samples.read::<VarLenAscii, Dim<[usize; 1]>>().unwrap();
+    println!("\tsamples = {:?}", samples);
+    println!("\tsamples.shape() = {:?}", samples.shape());
+    println!("\tsamples.strides() = {:?}", samples.strides());
+    println!("\tsamples.ndim() = {:?}", samples.ndim());
+    println!("Time for parsing samples:{:?}", now_samples.elapsed());
+
+    //Find all columns values that are populated for the given gene
+    let now_counts = Instant::now();
+    let ds_counts = file.dataset("counts").unwrap(); // open the dataset
+
+    let mut global_sample_index = 0;
+    for sample_name in case_list {
+        let sample_index;
+        match samples
+            .iter()
+            .position(|x| x.to_string() == *sample_name.to_string())
+        {
+            Some(index) => {
+                //println!(
+                //    "The index of '{}' is {} in 0-based format (add 1 to compare with R output)",
+                //    sample_name, index
+                //);
+                sample_index = index;
+            }
+            None => panic!(
+                "Sample '{}' not found in the HDF5 file '{}'",
+                sample_name, &hdf5_filename
+            ),
+        }
+
+        let sample_array: Array2<f64> = ds_counts
+            .read_slice_2d((0..gene_names.len(), sample_index..sample_index + 1))
+            .unwrap();
+        //println!("Length of gene array:{:?}", sample_array.len()); // Please check the result
+        input_vector.append(&mut sample_array.as_slice().unwrap().to_vec());
+        case_indexes.push(global_sample_index);
+        global_sample_index += 1;
+    }
+
+    for sample_name in control_list {
+        let sample_index;
+        match samples
+            .iter()
+            .position(|x| x.to_string() == *sample_name.to_string())
+        {
+            Some(index) => {
+                //println!(
+                //    "The index of '{}' is {} in 0-based format (add 1 to compare with R output)",
+                //    sample_name, index
+                //);
+                sample_index = index;
+            }
+            None => panic!(
+                "Sample '{}' not found in the HDF5 file '{}'",
+                sample_name, &hdf5_filename
+            ),
+        }
+        //let data_counts: Array1<_> = ds_counts.read::<f64, Dim<[usize; 1]>>().unwrap();
+        //println!("Data_counts: {:?}", data_counts);
+        let sample_array: Array2<f64> = ds_counts
+            .read_slice_2d((0..gene_names.len(), sample_index..sample_index + 1))
+            .unwrap();
+        //println!("Length of gene array:{:?}", sample_array.len()); // Please check the result
+        input_vector.append(&mut sample_array.as_slice().unwrap().to_vec());
+        control_indexes.push(global_sample_index);
+        global_sample_index += 1;
+    }
+
+    println!("Time for parsing HDF5 data:{:?}", now_counts.elapsed());
+    //println!(
+    //    "case + control length:{}",
+    //    case_list.len() + control_list.len()
+    //);
+    //println!("gene_names length:{}", gene_names.len());
+    //println!("input_vector length:{}", input_vector.len());
+    let dm = DMatrix::from_row_slice(
+        case_list.len() + control_list.len(),
+        gene_names.len(),
+        &input_vector,
+    );
+    (
+        dm.transpose(), // Transposing the matrix
+        case_indexes,
+        control_indexes,
+        gene_names_string,
+        gene_symbols_string,
+    )
+}
+
+fn input_data_from_text(
     filename: &String,
     case_list: &Vec<&str>,
     control_list: &Vec<&str>,
@@ -67,7 +222,6 @@ fn input_data(
     Vec<String>,
 ) {
     let input_time = Instant::now();
-    //let mut rdr = csv::Reader::from_path(path).unwrap();
     let mut file = File::open(filename).unwrap();
     let mut num_lines: usize = 0;
     let mut input_vector: Vec<f64> = Vec::with_capacity(500 * 65000);
@@ -355,6 +509,43 @@ struct PValueIndexes {
     p_value: f64,
 }
 
+// Used to get the sample names from HDF5 file at PP server startup
+fn get_DE_samples(hdf5_filename: &String) {
+    let file = HDF5File::open(&hdf5_filename).unwrap(); // open for reading
+    let now_samples = Instant::now();
+    let ds_samples = file.dataset("samples").unwrap();
+    let samples = ds_samples.read::<VarLenAscii, Dim<[usize; 1]>>().unwrap();
+    println!("\tsamples = {:?}", samples);
+    println!("\tsamples.shape() = {:?}", samples.shape());
+    println!("\tsamples.strides() = {:?}", samples.strides());
+    println!("\tsamples.ndim() = {:?}", samples.ndim());
+    println!("Time for parsing samples:{:?}", now_samples.elapsed());
+
+    let mut output_string = "".to_string();
+    for i in 0..samples.len() {
+        //let item_json = "{\"".to_string()
+        //    + &samples[i].to_string()
+        //    + &"\","
+        //    + &gene_array[i].to_string()
+        //    + &"}";
+
+        //let item_json = format!("{{\"{}\"}}", samples[i].to_string());
+
+        output_string += &format!("{}", samples[i].to_string());
+        //println!("item_json:{}", item_json);
+
+        //let item_json = format!(
+        //    r##"{{"{}",{}}}"##,
+        //    samples[i].to_string().replace("\\", ""),
+        //    gene_array[i].to_string()
+        //);
+        if i != samples.len() - 1 {
+            output_string += &",";
+        }
+    }
+    println!("output_string:{}", output_string);
+}
+
 fn main() {
     //env::set_var("RUST_BACKTRACE", "full");
     let mut input = String::new();
@@ -368,28 +559,6 @@ fn main() {
             match input_json {
                 Ok(json_string) => {
                     let now = Instant::now();
-                    let min_count_option = json_string["min_count"].as_f64().to_owned();
-                    let min_total_count_option = json_string["min_total_count"].as_f64().to_owned();
-                    let min_count;
-                    match min_count_option {
-                        Some(x) => min_count = x,
-                        None => {
-                            panic!("min_count is missing a value")
-                        }
-                    }
-                    let min_total_count;
-                    match min_total_count_option {
-                        Some(x) => min_total_count = x,
-                        None => {
-                            panic!("min_total_count is missing a value")
-                        }
-                    }
-                    let case_string = &json_string["case"].to_owned().as_str().unwrap().to_string();
-                    let control_string = &json_string["control"]
-                        .to_owned()
-                        .as_str()
-                        .unwrap()
-                        .to_string();
                     let file_name = &json_string["input_file"]
                         .to_owned()
                         .as_str()
@@ -397,149 +566,150 @@ fn main() {
                         .to_string()
                         .split(",")
                         .collect();
-                    let case_list: Vec<&str> = case_string.split(",").collect();
-                    let control_list: Vec<&str> = control_string.split(",").collect();
-                    let (input_matrix, case_indexes, control_indexes, gene_names, gene_symbols) =
-                        input_data(file_name, &case_list, &control_list);
-                    let filtering_time = Instant::now();
-                    let (filtered_matrix, lib_sizes, filtered_genes, filtered_gene_symbols) =
-                        filter_by_expr(
-                            min_count,
-                            min_total_count,
-                            &input_matrix,
-                            case_indexes.len(),
-                            control_indexes.len(),
-                            gene_names,
-                            gene_symbols,
-                        );
-                    println!("filtering time:{:?}", filtering_time.elapsed());
-                    //println!("filtered_matrix_rows:{:?}", filtered_matrix.nrows());
-                    //println!("filtered_matrix_cols:{:?}", filtered_matrix.ncols());
-                    let cpm_normalization_time = Instant::now();
-                    let mut normalized_matrix = cpm(&filtered_matrix);
-                    println!(
-                        "cpm normalization time:{:?}",
-                        cpm_normalization_time.elapsed()
-                    );
-                    let tmm_normalization_time = Instant::now();
-                    let norm_factors = tmm_normalization(filtered_matrix, &lib_sizes);
-                    println!(
-                        "tmm normalization time:{:?}",
-                        tmm_normalization_time.elapsed()
-                    );
-                    //println!("norm_factors:{:?}", norm_factors);
-
-                    for col in 0..normalized_matrix.ncols() {
-                        let norm_factor = norm_factors[col];
-                        for row in 0..normalized_matrix.nrows() {
-                            normalized_matrix[(row, col)] =
-                                normalized_matrix[(row, col)] / norm_factor;
-                        }
-                    }
-                    //println!("normalized_matrix:{:?}", normalized_matrix);
-                    println!("Number of cases:{}", case_list.len());
-                    println!("Number of controls:{}", control_list.len());
-                    println!("Time for pre-processing:{:?}", now.elapsed());
-                    // Using Wilcoxon test for differential gene expression
-
-                    let now2 = Instant::now();
-                    let mut p_values: Vec<PValueIndexes> =
-                        Vec::with_capacity(normalized_matrix.nrows());
-                    const THRESHOLD: usize = 50; // This determines whether the Wilcoxon exact test or the normal test will be used based on sample size.
-
-                    //println!("case_indexes:{:?}", case_indexes);
-                    //println!("control_indexes:{:?}", control_indexes);
-                    let num_normalized_rows = normalized_matrix.nrows();
-                    if normalized_matrix.nrows() * normalized_matrix.ncols() < PAR_CUTOFF {
-                        for i in 0..normalized_matrix.nrows() {
-                            let row = normalized_matrix.row(i);
-                            //println!("row:{:?}", row);
-                            let mut treated = Vec::<f64>::new();
-                            let mut control = Vec::<f64>::new();
-                            //println!("conditions:{:?}", conditions);
-                            for j in 0..(case_indexes.len() + control_indexes.len()) {
-                                //println!("row[(0, j)]:{}", row[(0, j)]);
-                                if case_indexes.contains(&j) {
-                                    treated.push(row[(0, j)]);
-                                    //println!("{},{}", input_data_vec.0[i][j], "Diseased");
-                                } else if control_indexes.contains(&j) {
-                                    // + 1 was added because in the input file the first column of thw first row is blank as the first column consists of gene names
-                                    control.push(row[(0, j)]);
-                                    //println!("{},{}", input_data_vec.0[i][j], "Control");
+                    println!("file_name:{}", file_name);
+                    let data_type_option = json_string["data_type"].as_str().to_owned();
+                    match data_type_option {
+                        Some(x) => {
+                            if x == "get_samples" {
+                                get_DE_samples(file_name)
+                            } else if x == "do_DE" {
+                                let min_count_option = json_string["min_count"].as_f64().to_owned();
+                                let min_total_count_option =
+                                    json_string["min_total_count"].as_f64().to_owned();
+                                let storage_type_option =
+                                    json_string["storage_type"].as_str().to_owned();
+                                let storage_type;
+                                match storage_type_option {
+                                    Some(x) => {
+                                        if x == "HDF5" {
+                                            storage_type = "HDF5"
+                                        } else if x == "text" {
+                                            storage_type = "text"
+                                        } else {
+                                            panic!(
+                                                "Unknown storage_type:{}{}",
+                                                x, " Needs to be either HDF5 or text"
+                                            );
+                                        }
+                                    }
+                                    None => panic!("storage_type needs to be HDF5 or text"),
+                                }
+                                let min_count;
+                                match min_count_option {
+                                    Some(x) => min_count = x,
+                                    None => {
+                                        panic!("min_count is missing a value")
+                                    }
+                                }
+                                let min_total_count;
+                                match min_total_count_option {
+                                    Some(x) => min_total_count = x,
+                                    None => {
+                                        panic!("min_total_count is missing a value")
+                                    }
+                                }
+                                let case_string =
+                                    &json_string["case"].to_owned().as_str().unwrap().to_string();
+                                let control_string = &json_string["control"]
+                                    .to_owned()
+                                    .as_str()
+                                    .unwrap()
+                                    .to_string();
+                                let case_list: Vec<&str> = case_string.split(",").collect();
+                                let control_list: Vec<&str> = control_string.split(",").collect();
+                                let (
+                                    input_matrix,
+                                    case_indexes,
+                                    control_indexes,
+                                    gene_names,
+                                    gene_symbols,
+                                );
+                                if storage_type == "text" {
+                                    (
+                                        input_matrix,
+                                        case_indexes,
+                                        control_indexes,
+                                        gene_names,
+                                        gene_symbols,
+                                    ) = input_data_from_text(file_name, &case_list, &control_list);
                                 } else {
-                                    panic!(
-                                        "Column {} could not be classified into case/control",
-                                        j
-                                    );
+                                    // Parsing data from a HDF5 file
+                                    (
+                                        input_matrix,
+                                        case_indexes,
+                                        control_indexes,
+                                        gene_names,
+                                        gene_symbols,
+                                    ) = input_data_from_HDF5(file_name, &case_list, &control_list);
                                 }
-                            }
-                            //println!("treated{:?}", treated);
-                            //println!("control{:?}", control);
-                            let p_value = stats_functions::wilcoxon_rank_sum_test(
-                                treated.clone(),
-                                control.clone(),
-                                THRESHOLD,
-                                't',
-                                true,
-                            ); // Setting continuity correction to true in case of normal approximation
-                            let treated_mean = Data::new(treated).mean();
-                            let control_mean = Data::new(control).mean();
-                            if (treated_mean.unwrap() / control_mean.unwrap())
-                                .log2()
-                                .is_nan()
-                                == false
-                                && (treated_mean.unwrap() / control_mean.unwrap())
-                                    .log2()
-                                    .is_infinite()
-                                    == false
-                            {
-                                p_values.push(PValueIndexes {
-                                    index: i,
-                                    gene_name: filtered_genes[i].to_owned(),
-                                    gene_symbol: filtered_gene_symbols[i].to_owned(),
-                                    fold_change: (treated_mean.unwrap() / control_mean.unwrap())
-                                        .log2(),
-                                    p_value: p_value,
-                                });
-                            }
-                        }
-                    } else {
-                        // Multithreaded implementation of calculating wilcoxon p-values
-                        let normalized_matrix_temp = Arc::new(normalized_matrix);
-                        let filtered_genes_temp = Arc::new(filtered_genes);
-                        let filtered_gene_symbols_temp = Arc::new(filtered_gene_symbols);
-                        let case_indexes_temp = Arc::new(case_indexes);
-                        let control_indexes_temp = Arc::new(control_indexes);
-                        let p_values_temp = Arc::new(Mutex::new(Vec::<PValueIndexes>::new()));
-                        let mut handles = vec![]; // Vector to store handle which is used to prevent one thread going ahead of another
-                        for thread_num in 0..max_threads {
-                            let normalized_matrix_temp = Arc::clone(&normalized_matrix_temp);
-                            let case_indexes_temp = Arc::clone(&case_indexes_temp);
-                            let control_indexes_temp = Arc::clone(&control_indexes_temp);
-                            let p_values_temp = Arc::clone(&p_values_temp);
-                            let filtered_genes_temp = Arc::clone(&filtered_genes_temp);
-                            let filtered_gene_symbols_temp =
-                                Arc::clone(&filtered_gene_symbols_temp);
-                            let handle = thread::spawn(move || {
-                                let mut p_values_thread: Vec<PValueIndexes> = Vec::with_capacity(
-                                    normalized_matrix_temp.nrows() / max_threads,
+                                let filtering_time = Instant::now();
+                                let (
+                                    filtered_matrix,
+                                    lib_sizes,
+                                    filtered_genes,
+                                    filtered_gene_symbols,
+                                ) = filter_by_expr(
+                                    min_count,
+                                    min_total_count,
+                                    &input_matrix,
+                                    case_indexes.len(),
+                                    control_indexes.len(),
+                                    gene_names,
+                                    gene_symbols,
+                                );
+                                println!("filtering time:{:?}", filtering_time.elapsed());
+                                //println!("filtered_matrix_rows:{:?}", filtered_matrix.nrows());
+                                //println!("filtered_matrix_cols:{:?}", filtered_matrix.ncols());
+                                let cpm_normalization_time = Instant::now();
+                                let mut normalized_matrix = cpm(&filtered_matrix);
+                                println!(
+                                    "cpm normalization time:{:?}",
+                                    cpm_normalization_time.elapsed()
                                 );
-                                for i in 0..normalized_matrix_temp.nrows() {
-                                    let remainder: usize = i % max_threads; // Calculate remainder of iteration number divided by max_threads to decide which thread parses the row
-                                    if remainder == thread_num {
-                                        let row = normalized_matrix_temp.row(i);
+                                let tmm_normalization_time = Instant::now();
+                                let norm_factors = tmm_normalization(filtered_matrix, &lib_sizes);
+                                println!(
+                                    "tmm normalization time:{:?}",
+                                    tmm_normalization_time.elapsed()
+                                );
+                                //println!("norm_factors:{:?}", norm_factors);
+
+                                for col in 0..normalized_matrix.ncols() {
+                                    let norm_factor = norm_factors[col];
+                                    for row in 0..normalized_matrix.nrows() {
+                                        normalized_matrix[(row, col)] =
+                                            normalized_matrix[(row, col)] / norm_factor;
+                                    }
+                                }
+                                //println!("normalized_matrix:{:?}", normalized_matrix);
+                                println!("Number of cases:{}", case_list.len());
+                                println!("Number of controls:{}", control_list.len());
+                                println!("Time for pre-processing:{:?}", now.elapsed());
+                                // Using Wilcoxon test for differential gene expression
+
+                                let now2 = Instant::now();
+                                let mut p_values: Vec<PValueIndexes> =
+                                    Vec::with_capacity(normalized_matrix.nrows());
+                                const THRESHOLD: usize = 50; // This determines whether the Wilcoxon exact test or the normal test will be used based on sample size.
+
+                                //println!("case_indexes:{:?}", case_indexes);
+                                //println!("control_indexes:{:?}", control_indexes);
+                                let num_normalized_rows = normalized_matrix.nrows();
+                                if normalized_matrix.nrows() * normalized_matrix.ncols()
+                                    < PAR_CUTOFF
+                                {
+                                    for i in 0..normalized_matrix.nrows() {
+                                        let row = normalized_matrix.row(i);
                                         //println!("row:{:?}", row);
                                         let mut treated = Vec::<f64>::new();
                                         let mut control = Vec::<f64>::new();
                                         //println!("conditions:{:?}", conditions);
-                                        for j in 0..(case_indexes_temp.len()
-                                            + control_indexes_temp.len())
-                                        {
+                                        for j in 0..(case_indexes.len() + control_indexes.len()) {
                                             //println!("row[(0, j)]:{}", row[(0, j)]);
-                                            if case_indexes_temp.contains(&j) {
+                                            if case_indexes.contains(&j) {
                                                 treated.push(row[(0, j)]);
                                                 //println!("{},{}", input_data_vec.0[i][j], "Diseased");
-                                            } else if control_indexes_temp.contains(&j) {
+                                            } else if control_indexes.contains(&j) {
                                                 // + 1 was added because in the input file the first column of thw first row is blank as the first column consists of gene names
                                                 control.push(row[(0, j)]);
                                                 //println!("{},{}", input_data_vec.0[i][j], "Control");
@@ -570,11 +740,10 @@ fn main() {
                                                 .is_infinite()
                                                 == false
                                         {
-                                            p_values_thread.push(PValueIndexes {
+                                            p_values.push(PValueIndexes {
                                                 index: i,
-                                                gene_name: filtered_genes_temp[i].to_owned(),
-                                                gene_symbol: filtered_gene_symbols_temp[i]
-                                                    .to_owned(),
+                                                gene_name: filtered_genes[i].to_owned(),
+                                                gene_symbol: filtered_gene_symbols[i].to_owned(),
                                                 fold_change: (treated_mean.unwrap()
                                                     / control_mean.unwrap())
                                                 .log2(),
@@ -582,27 +751,126 @@ fn main() {
                                             });
                                         }
                                     }
+                                } else {
+                                    // Multithreaded implementation of calculating wilcoxon p-values
+                                    let normalized_matrix_temp = Arc::new(normalized_matrix);
+                                    let filtered_genes_temp = Arc::new(filtered_genes);
+                                    let filtered_gene_symbols_temp =
+                                        Arc::new(filtered_gene_symbols);
+                                    let case_indexes_temp = Arc::new(case_indexes);
+                                    let control_indexes_temp = Arc::new(control_indexes);
+                                    let p_values_temp =
+                                        Arc::new(Mutex::new(Vec::<PValueIndexes>::new()));
+                                    let mut handles = vec![]; // Vector to store handle which is used to prevent one thread going ahead of another
+                                    for thread_num in 0..max_threads {
+                                        let normalized_matrix_temp =
+                                            Arc::clone(&normalized_matrix_temp);
+                                        let case_indexes_temp = Arc::clone(&case_indexes_temp);
+                                        let control_indexes_temp =
+                                            Arc::clone(&control_indexes_temp);
+                                        let p_values_temp = Arc::clone(&p_values_temp);
+                                        let filtered_genes_temp = Arc::clone(&filtered_genes_temp);
+                                        let filtered_gene_symbols_temp =
+                                            Arc::clone(&filtered_gene_symbols_temp);
+                                        let handle = thread::spawn(move || {
+                                            let mut p_values_thread: Vec<PValueIndexes> =
+                                                Vec::with_capacity(
+                                                    normalized_matrix_temp.nrows() / max_threads,
+                                                );
+                                            for i in 0..normalized_matrix_temp.nrows() {
+                                                let remainder: usize = i % max_threads; // Calculate remainder of iteration number divided by max_threads to decide which thread parses the row
+                                                if remainder == thread_num {
+                                                    let row = normalized_matrix_temp.row(i);
+                                                    //println!("row:{:?}", row);
+                                                    let mut treated = Vec::<f64>::new();
+                                                    let mut control = Vec::<f64>::new();
+                                                    //println!("conditions:{:?}", conditions);
+                                                    for j in 0..(case_indexes_temp.len()
+                                                        + control_indexes_temp.len())
+                                                    {
+                                                        //println!("row[(0, j)]:{}", row[(0, j)]);
+                                                        if case_indexes_temp.contains(&j) {
+                                                            treated.push(row[(0, j)]);
+                                                            //println!("{},{}", input_data_vec.0[i][j], "Diseased");
+                                                        } else if control_indexes_temp.contains(&j)
+                                                        {
+                                                            // + 1 was added because in the input file the first column of thw first row is blank as the first column consists of gene names
+                                                            control.push(row[(0, j)]);
+                                                            //println!("{},{}", input_data_vec.0[i][j], "Control");
+                                                        } else {
+                                                            panic!(
+                                        "Column {} could not be classified into case/control",
+                                        j
+                                    );
+                                                        }
+                                                    }
+                                                    //println!("treated{:?}", treated);
+                                                    //println!("control{:?}", control);
+                                                    let p_value =
+                                                        stats_functions::wilcoxon_rank_sum_test(
+                                                            treated.clone(),
+                                                            control.clone(),
+                                                            THRESHOLD,
+                                                            't',
+                                                            true,
+                                                        ); // Setting continuity correction to true in case of normal approximation
+                                                    let treated_mean = Data::new(treated).mean();
+                                                    let control_mean = Data::new(control).mean();
+                                                    if (treated_mean.unwrap()
+                                                        / control_mean.unwrap())
+                                                    .log2()
+                                                    .is_nan()
+                                                        == false
+                                                        && (treated_mean.unwrap()
+                                                            / control_mean.unwrap())
+                                                        .log2()
+                                                        .is_infinite()
+                                                            == false
+                                                    {
+                                                        p_values_thread.push(PValueIndexes {
+                                                            index: i,
+                                                            gene_name: filtered_genes_temp[i]
+                                                                .to_owned(),
+                                                            gene_symbol: filtered_gene_symbols_temp
+                                                                [i]
+                                                                .to_owned(),
+                                                            fold_change: (treated_mean.unwrap()
+                                                                / control_mean.unwrap())
+                                                            .log2(),
+                                                            p_value: p_value,
+                                                        });
+                                                    }
+                                                }
+                                            }
+                                            p_values_temp
+                                                .lock()
+                                                .unwrap()
+                                                .append(&mut p_values_thread);
+                                        });
+                                        handles.push(handle);
+                                    }
+                                    for handle in handles {
+                                        // Wait for all threads to finish before proceeding further
+                                        handle.join().unwrap();
+                                    }
+                                    p_values.append(&mut *p_values_temp.lock().unwrap());
                                 }
-                                p_values_temp.lock().unwrap().append(&mut p_values_thread);
-                            });
-                            handles.push(handle);
+                                //println!("p_values:{:?}", p_values);
+                                println!(
+                                    "Time for running {} wilcoxon tests:{:?}",
+                                    num_normalized_rows,
+                                    now2.elapsed()
+                                );
+                                let adjusted_p_values = adjust_p_values(p_values);
+                                println!("adjusted_p_values:{}", adjusted_p_values);
+                                //let fold_changes =
+                                //    calculate_fold_change(normalized_matrix, case_indexes, control_indexes);
+                            }
                         }
-                        for handle in handles {
-                            // Wait for all threads to finish before proceeding further
-                            handle.join().unwrap();
+                        None => {
+                            panic!("data_type is missing")
                         }
-                        p_values.append(&mut *p_values_temp.lock().unwrap());
                     }
-                    //println!("p_values:{:?}", p_values);
-                    println!(
-                        "Time for running {} wilcoxon tests:{:?}",
-                        num_normalized_rows,
-                        now2.elapsed()
-                    );
-                    let adjusted_p_values = adjust_p_values(p_values);
-                    println!("adjusted_p_values:{}", adjusted_p_values);
-                    //let fold_changes =
-                    //    calculate_fold_change(normalized_matrix, case_indexes, control_indexes);
                 }
                 Err(error) => println!("Incorrect json: {}", error),
             }
@@ -1052,6 +1320,7 @@ fn filter_by_expr(
             positives.push(row);
         }
     }
+    println!("positives length:{}", positives.len());
     //println!("row_sums:{:?}", row_sums);
     //println!("keep_cpm:{:?}", keep_cpm);
     //println!("positive_cpm:{}", positive_cpm);
@@ -1067,12 +1336,17 @@ fn filter_by_expr(
     let mut filtered_genes: Vec<String> = Vec::with_capacity(positives.len());
     let mut filtered_gene_symbols: Vec<String> = Vec::with_capacity(positives.len());
     let mut i = 0;
+    println!("filtered_matrix rows:{}", filtered_matrix.nrows());
+    println!("filtered_matrix cols:{}", filtered_matrix.ncols());
     for index in positives {
         let row = raw_data.row(index);
         filtered_genes.push(gene_names[index].to_owned());
         filtered_gene_symbols.push(gene_symbols[index].to_owned());
         let mut j = 0;
         for item in &row {
+            //println!("index:{}", index);
+            //println!("i:{}", i);
+            //println!("j:{}", j);
             filtered_matrix[(i, j)] = *item;
             j += 1;
         }

package/src/genesetORA.rs

@@ -7,6 +7,7 @@ use rusqlite::{Connection, Result};
 use serde::{Deserialize, Serialize};
 use serde_json;
 use std::cmp::Ordering;
+use std::collections::HashSet;
 use std::io;
 use std::time::Instant;
 
@@ -17,15 +18,6 @@ struct GO_pathway {
     GO_id: String,
 }
 
-#[allow(non_camel_case_types)]
-#[allow(non_snake_case)]
-#[derive(Debug)]
-struct pathway_genes {
-    symbol: String,
-    _ensg: String,
-    _enstCanonical: String,
-}
-
 #[allow(non_camel_case_types)]
 #[allow(non_snake_case)]
 #[derive(Debug, Serialize, Deserialize)]
@@ -39,28 +31,27 @@ struct pathway_p_value {
 }
 
 fn calculate_hypergeometric_p_value(
-    sample_genes: &Vec<&str>,
+    sample_genes: &HashSet<String>,
     num_background_genes: usize,
-    genes_in_pathway: Vec<pathway_genes>,
+    genes_in_pathway: HashSet<String>,
 ) -> (f64, f64, String) {
-    let mut matching_sample_genes_counts = 0.0;
     let mut gene_set_hits: String = "".to_string();
-    for gene in sample_genes {
-        for pathway in &genes_in_pathway {
-            if pathway.symbol == gene.to_string() {
-                matching_sample_genes_counts += 1.0;
-                gene_set_hits += &(gene.to_string() + &",");
-            }
-        }
+
+    let gene_intersections: HashSet<String> = genes_in_pathway
+        .intersection(sample_genes)
+        .cloned()
+        .collect();
+    for gene in &gene_intersections {
+        gene_set_hits += &(gene.to_string() + &",");
     }
 
-    if matching_sample_genes_counts > 0.0 {
+    if gene_intersections.len() > 0 {
         gene_set_hits.pop();
     }
 
     //println!("sample_genes:{:?}", sample_genes);
     //println!("genes_in_pathway:{:?}", genes_in_pathway);
-    //println!("k-1:{}", matching_sample_genes_counts - 1.0);
+    //println!("k-1:{}", gene_intersection.len() - 1.0);
     //println!("M:{}", genes_in_pathway.len() as f64);
     //println!(
     //    "N-M:{}",
@@ -68,7 +59,7 @@ fn calculate_hypergeometric_p_value(
     //);
     //println!("n:{}", sample_genes.len() as f64);
     let p_value = r_mathlib::hypergeometric_cdf(
-        matching_sample_genes_counts - 1.0,
+        gene_intersections.len() as f64 - 1.0,
         genes_in_pathway.len() as f64,
         num_background_genes as f64 - genes_in_pathway.len() as f64,
         sample_genes.len() as f64,
@@ -76,7 +67,7 @@ fn calculate_hypergeometric_p_value(
         false,
     );
     //println!("p_value:{}", p_value);
-    (p_value, matching_sample_genes_counts, gene_set_hits)
+    (p_value, gene_intersections.len() as f64, gene_set_hits)
 }
 
 fn main() -> Result<()> {
@@ -104,8 +95,49 @@ fn main() -> Result<()> {
                     let sample_genes: Vec<&str> =
                         sample_genes_input.as_str().unwrap().split(",").collect();
                     let mut pathway_p_values: Vec<pathway_p_value> = Vec::with_capacity(10000);
+
+                    let genedb_input: &JsonValue = &json_string["genedb"];
+                    let genedb;
+                    match genedb_input.as_str() {
+                        Some(gene_db_string) => genedb = gene_db_string.to_string(),
+                        None => panic!("genedb file path is missing"),
+                    }
+
+                    let filter_non_coding_genes_input: &JsonValue =
+                        &json_string["filter_non_coding_genes"];
+                    let filter_non_coding_genes: bool =
+                        filter_non_coding_genes_input.as_bool().unwrap();
+
+                    let genedbconn = Connection::open(genedb)?;
+                    let genedb_result = genedbconn.prepare(&("select * from codingGenes"));
+                    let mut num_coding_genes: usize = 0;
+                    let mut sample_coding_genes: HashSet<String> = HashSet::with_capacity(24000);
+                    match genedb_result {
+                        Ok(mut x) => {
+                            let mut genes = x.query([])?;
+                            while let Some(coding_gene) = genes.next()? {
+                                num_coding_genes += 1;
+                                //println!("coding_gene:{:?}", coding_gene);
+                                for sample_gene in &sample_genes {
+                                    let code_gene: String = coding_gene.get(0).unwrap();
+                                    if filter_non_coding_genes == true && code_gene == *sample_gene
+                                    {
+                                        sample_coding_genes.insert(code_gene);
+                                    } else if filter_non_coding_genes == false {
+                                        sample_coding_genes.insert(code_gene);
+                                    }
+                                }
+                            }
+                        }
+                        Err(_) => {}
+                    }
+
+                    if sample_coding_genes.len() == 0 {
+                        panic!("All query genes are non-coding");
+                    }
+
                     let background_genes_input: &JsonValue = &json_string["background_genes"];
-                    let mut num_background_genes: usize = 0;
+                    let num_background_genes;
                     match background_genes_input.as_str() {
                         Some(x) => {
                             let background_genes_str: Vec<&str> = x.split(",").collect(); // Background genes is defined for e.g in case of DE analysis
@@ -114,24 +146,7 @@ fn main() -> Result<()> {
                         None => {
                             // Background genes not present for e.g. in hierarchial clustering
                             // Get background genes from the gene database
-                            let genedb_input: &JsonValue = &json_string["genedb"];
-                            let genedb;
-                            match genedb_input.as_str() {
-                                Some(gene_db_string) => genedb = gene_db_string.to_string(),
-                                None => panic!("genedb file path is missing"),
-                            }
-
-                            let genedbconn = Connection::open(genedb)?;
-                            let genedb_result = genedbconn.prepare(&("select * from codingGenes"));
-                            match genedb_result {
-                                Ok(mut x) => {
-                                    let mut genes = x.query([])?;
-                                    while let Some(_gene) = genes.next()? {
-                                        num_background_genes += 1;
-                                    }
-                                }
-                                Err(_) => {}
-                            }
+                            num_background_genes = num_coding_genes;
                         }
                     }
                     //println!("sample_genes:{:?}", sample_genes);
@@ -169,24 +184,17 @@ fn main() -> Result<()> {
                                         //println!("gene_stmt:{:?}", gene_stmt);
 
                                         let mut rows = gene_stmt.query([])?;
-                                        let mut names = Vec::<pathway_genes>::new();
+                                        let mut names = HashSet::<String>::new();
                                         while let Some(row) = rows.next()? {
                                             let a: String = row.get(0)?;
                                             let input_gene_json = json::parse(&a);
                                             match input_gene_json {
                                                 Ok(json_genes) => {
                                                     for json_iter in 0..json_genes.len() {
-                                                        let item = pathway_genes {
-                                                            symbol: json_genes[json_iter]["symbol"]
-                                                                .to_string(),
-                                                            _ensg: json_genes[json_iter]["ensg"]
-                                                                .to_string(),
-                                                            _enstCanonical: json_genes[json_iter]
-                                                                ["enstCanonical"]
+                                                        names.insert(
+                                                            json_genes[json_iter]["symbol"]
                                                                 .to_string(),
-                                                        };
-                                                        //println!("item:{:?}", item);
-                                                        names.push(item);
+                                                        );
                                                     }
                                                 }
                                                 Err(_) => {
@@ -199,7 +207,7 @@ fn main() -> Result<()> {
                                         let gene_set_size = names.len();
                                         let (p_value, matches, gene_set_hits) =
                                             calculate_hypergeometric_p_value(
-                                                &sample_genes,
+                                                &sample_coding_genes,
                                                 num_background_genes,
                                                 names,
                                             );

package/src/readHDF5.rs

@@ -0,0 +1,227 @@
+// Need to set HDF5_DIR and LD_LIBRARY_PATH in ~/.bash_profile
+// Syntax: HDF5_DIR=/usr/local/Homebrew/Cellar/hdf5/1.14.3_1 && echo $HDF5_DIR && cd .. && cargo build --release && json='{"gene":"TP53","hdf5_file":"matrix_with_na_comp_9.h5"}' && time echo $json | target/release/rust_hdf5
+
+use hdf5::types::FixedAscii;
+use hdf5::{File, Result};
+use json;
+use ndarray::Array1;
+use ndarray::Dim;
+use std::io;
+use std::time::Instant;
+
+fn read_hdf5(hdf5_filename: String, gene_name: String) -> Result<()> {
+    let file = File::open(&hdf5_filename)?; // open for reading
+    let ds_dim = file.dataset("data/dim")?; // open the dataset
+
+    // Check the data type and read the dataset accordingly
+    let data_dim: Array1<_> = ds_dim.read::<usize, Dim<[usize; 1]>>()?;
+    let num_samples = data_dim[0]; // Number of total columns in the dataset
+    let num_genes = data_dim[1];
+    println!("num_samples:{}", num_samples);
+    println!("num_genes:{}", num_genes);
+
+    //let now_partial_i = Instant::now();
+    //let data_partial_i: Array1<usize> = ds_i.read_slice_1d(0..20)?;
+    //println!("Data_partial_i: {:?}", data_partial_i);
+    //println!("Time for partial_i dataset:{:?}", now_partial_i.elapsed());
+    //
+    //let now_x = Instant::now();
+    //let ds_x = file.dataset("data/x")?; // open the dataset
+    //let data_x: Array1<_> = ds_x.read::<f64, Dim<[usize; 1]>>()?;
+    //println!("Data_x: {:?}", data_x);
+    //println!("Time for x dataset:{:?}", now_x.elapsed());
+
+    let now_genes = Instant::now();
+    let ds_genes = file.dataset("gene_names")?;
+    let genes = ds_genes.read_1d::<FixedAscii<104>>()?;
+    //println!("\tgenes = {:?}", genes);
+    //println!("\tgenes.shape() = {:?}", genes.shape());
+    //println!("\tgenes.strides() = {:?}", genes.strides());
+    //println!("\tgenes.ndim() = {:?}", genes.ndim());
+    println!("Time for parsing genes:{:?}", now_genes.elapsed());
+
+    let now_samples = Instant::now();
+    let ds_samples = file.dataset("sample_names")?;
+    let samples = ds_samples.read_1d::<FixedAscii<104>>()?;
+    //println!("\tsamples = {:?}", samples);
+    //println!("\tsamples.shape() = {:?}", samples.shape());
+    //println!("\tsamples.strides() = {:?}", samples.strides());
+    //println!("\tsamples.ndim() = {:?}", samples.ndim());
+    println!("Time for parsing samples:{:?}", now_samples.elapsed());
+
+    let gene_index;
+    match genes.iter().position(|&x| x == gene_name) {
+        Some(index) => {
+            println!(
+                "The index of '{}' is {} in 0-based format (add 1 to compare with R output)",
+                gene_name, index
+            );
+            gene_index = index;
+        }
+        None => panic!(
+            "Gene '{}' not found in the HDF5 file '{}'",
+            gene_name, &hdf5_filename
+        ),
+    }
+
+    // Find the number of columns that are populated for that gene
+    let now_p = Instant::now();
+    let ds_p = file.dataset("data/p")?; // open the dataset
+
+    //let data_p: Array1<_> = ds_p.read::<usize, Dim<[usize; 1]>>()?;
+    let data_partial_p: Array1<usize> = ds_p.read_slice_1d(gene_index..gene_index + 2)?;
+    //println!("Data_p: {:?}", data_p);
+    println!("Data_partial_p: {:?}", data_partial_p);
+    println!("Time for p dataset:{:?}", now_p.elapsed());
+
+    let array_start_point = data_partial_p[0];
+    let array_stop_point = data_partial_p[1];
+    let num_populated_cells = data_partial_p[1] - array_start_point;
+    println!("Number of populated cells:{}", num_populated_cells);
+
+    //Find all columns indices that are populated for the given gene
+    let now_i = Instant::now();
+    let ds_i = file.dataset("data/i")?; // open the dataset
+
+    //let data_i: Array1<_> = ds_i.read::<f64, Dim<[usize; 1]>>()?;
+    //println!("Data_i: {:?}", data_i);
+    let populated_column_ids: Array1<usize> =
+        ds_i.read_slice_1d(array_start_point..array_stop_point - 1)?;
+    println!(
+        "Length of populated_column_ids:{}",
+        populated_column_ids.len()
+    );
+
+    // Do a sanity check (for testing)
+    //let mut min = 0;
+    //for i in 0..populated_column_ids.len() {
+    //    if populated_column_ids[i] < min {
+    //        println!("Value is decreasing {},{}", populated_column_ids[i], min);
+    //    } else {
+    //        min = populated_column_ids[i];
+    //    }
+    //}
+    println!("Populated cells:{:?}", populated_column_ids);
+    println!("Time for i dataset:{:?}", now_i.elapsed());
+
+    //Find all columns values that are populated for the given gene
+    let now_x = Instant::now();
+    let ds_x = file.dataset("data/x")?; // open the dataset
+
+    //let data_x: Array1<_> = ds_x.read::<f64, Dim<[usize; 1]>>()?;
+    //println!("Data_x: {:?}", data_x);
+    let populated_column_values: Array1<f64> =
+        ds_x.read_slice_1d(array_start_point..array_stop_point - 1)?;
+    println!(
+        "Length of populated_column_ids:{}",
+        populated_column_values.len()
+    );
+    println!("Time for x dataset:{:?}", now_x.elapsed());
+
+    // Generate the complete array from the sparse array
+
+    let mut gene_array: Array1<f64> = Array1::zeros(num_samples);
+    let time_generating_full_array = Instant::now();
+    //let mut gene_array: Vec<f64> = Vec::with_capacity(num_samples);
+    for index in 0..num_samples {
+        match populated_column_ids.iter().any(|&x| x == index) {
+            true => match populated_column_ids.iter().position(|&x| x == index) {
+                Some(y) => {
+                    gene_array[index] = populated_column_values[y] //gene_array.push(populated_column_values[y]),
+                }
+                None => {} // should not happen because if the index is found, its position in the array should also be found
+            },
+            false => gene_array[index] = 0.0, //gene_array.push(0.0), // If index not found, it means the value is 0 for that sample
+        }
+    }
+
+    let mut output_string = "{".to_string();
+    for i in 0..gene_array.len() {
+        //let item_json = "{\"".to_string()
+        //    + &samples[i].to_string()
+        //    + &"\","
+        //    + &gene_array[i].to_string()
+        //    + &"}";
+
+        //let item_json = format!("{{\"{}\"}}", samples[i].to_string());
+
+        output_string += &format!(
+            "\"{}\":{}",
+            samples[i].to_string(),
+            gene_array[i].to_string()
+        );
+        //println!("item_json:{}", item_json);
+
+        //let item_json = format!(
+        //    r##"{{"{}",{}}}"##,
+        //    samples[i].to_string().replace("\\", ""),
+        //    gene_array[i].to_string()
+        //);
+        if i != gene_array.len() - 1 {
+            output_string += &",";
+        }
+    }
+    output_string += &"}".to_string();
+    output_string = output_string.replace("\\", "");
+    println!(
+        "Time generating full array:{:?}",
+        time_generating_full_array.elapsed()
+    );
+    println!("output_string:{}", output_string);
+
+    // Print individual element in array
+
+    //let arr = v.iter().collect::<Vec<_>>();
+    //for (idx, val) in arr.iter().enumerate() {
+    //    println!("\tarr[{:?}] = {:?} ({:?})", idx, val.to_string(), val.len());
+    //}
+
+    //for item in data_i {
+    //    println!("i:{}", item);
+    //}
+    Ok(())
+}
+
+fn main() -> Result<()> {
+    let mut input = String::new();
+    match io::stdin().read_line(&mut input) {
+        // Accepting the piped input from nodejs (or command line from testing)
+        Ok(_bytes_read) => {
+            //println!("{} bytes read", bytes_read);
+            //println!("{}", input);
+            let input_json = json::parse(&input);
+            match input_json {
+                Ok(json_string) => {
+                    let now = Instant::now();
+                    let hdf5_filename_result = &json_string["hdf5_file"].to_owned();
+                    let hdf5_filename;
+                    match hdf5_filename_result.as_str() {
+                        Some(x) => {
+                            hdf5_filename = x.to_string();
+                        }
+                        None => {
+                            panic!("HDF5 filename not provided");
+                        }
+                    }
+
+                    let gene_result = &json_string["gene"].to_owned();
+                    let gene_name;
+                    match gene_result.as_str() {
+                        Some(x) => {
+                            gene_name = x.to_string();
+                        }
+                        None => {
+                            panic!("Gene name not provided");
+                        }
+                    }
+
+                    read_hdf5(hdf5_filename, gene_name)?;
+                    println!("Time for parsing genes from HDF5:{:?}", now.elapsed());
+                }
+                Err(error) => println!("Incorrect json: {}", error),
+            }
+        }
+        Err(error) => println!("Piping error: {}", error),
+    }
+    Ok(())
+}