diff --git a/CSP2.nf b/CSP2.nf
index 8a410bf..9ead7a5 100755
--- a/CSP2.nf
+++ b/CSP2.nf
@@ -122,196 +122,218 @@ if (help1 == "help") {
 // Assess run mode
 if (params.runmode == "") {
     error "--runmode must be specified..."
-} else if (!['align','assemble', 'screen', 'snp'].contains(params.runmode)){
+} else if (!['align','assemble', 'screen', 'snp','conda_init'].contains(params.runmode)){
     error "--runmode must be 'align','assemble', 'screen', or 'snp', not ${params.runmode}..."
 }
 
-// Ensure necessary data is provided given the run mode
+// If runmode is conda_init, launch a local process to spurn the generation of the conda environment and exit
+if (params.runmode != "conda_init") {
+
+    // Ensure necessary data is provided given the run mode
+    // Runmode 'assemble'
+    //  - Requires: --reads/--ref_reads
+    //  - Runs SKESA and summarzies output FASTA 
+    if (params.runmode == "assemble"){
+        if((params.reads == "") && (params.ref_reads == "")){
+            error "Runmode is --assemble but no read data provided via --reads/--ref_reads"
+        } 
+    }
 
-// Runmode 'assemble'
-//  - Requires: --reads/--ref_reads
-//  - Runs SKESA and summarzies output FASTA 
-if (params.runmode == "assemble"){
-    if((params.reads == "") && (params.ref_reads == "")){
-        error "Runmode is --assemble but no read data provided via --reads/--ref_reads"
-    } 
-}
+    // Runmode 'align'
+    //  - Requires: --reads/--fasta/--snpdiffs
+    //  - Optional: --ref_reads/--ref_fasta/--ref_id
+    //  - Runs MUMmer, generates .snpdiffs, and alignment summary.
+    //      - If references are provided via --ref_reads/--ref_fasta/--ref_id, non-reference samples are aligned to each reference
+    //      - If no references are provided, alignments are all-vs-all
+    //      - If --snpdiffs are provided, their FASTAs will be autodetected and, if present, used as queries or references as specified by --ref_reads/--ref_fasta/--ref_id
+    //      - Does NOT perform QC filtering
+
+    else if (params.runmode == "align"){
+        if((params.fasta == "") && (params.reads == "") && (params.snpdiffs == "")){
+            error "Runmode is --align but no query data provided via --fasta/--reads/--snpdiffs"
+        } 
+    }
 
-// Runmode 'align'
-//  - Requires: --reads/--fasta/--snpdiffs
-//  - Optional: --ref_reads/--ref_fasta/--ref_id
-//  - Runs MUMmer, generates .snpdiffs, and alignment summary.
-//      - If references are provided via --ref_reads/--ref_fasta/--ref_id, non-reference samples are aligned to each reference
-//      - If no references are provided, alignments are all-vs-all
-//      - If --snpdiffs are provided, their FASTAs will be autodetected and, if present, used as queries or references as specified by --ref_reads/--ref_fasta/--ref_id
-//      - Does NOT perform QC filtering
-
-else if (params.runmode == "align"){
-    if((params.fasta == "") && (params.reads == "") && (params.snpdiffs == "")){
-        error "Runmode is --align but no query data provided via --fasta/--reads/--snpdiffs"
+    // Runmode 'screen'
+    //  - Requires: --reads/--fasta/--snpdiffs
+    //  - Optional: --ref_reads/--ref_fasta/--ref_id
+    //  - Generates .snpdiffs files (if needed), applies QC, and generates alignment summaries and SNP distance estimates
+    //      - If references are provided via --ref_reads/--ref_fasta/--ref_id, non-reference samples are aligned to each reference
+    //      - If no references are provided, alignments are all-vs-all
+    //      - If --snpdiffs are provided, (1) they will be QC filtered and included in the output report and (2) their FASTAs will be autodetected and, if present, used as queries or references as specified by --ref_reads/--ref_fasta/--ref_id
+
+    else if (params.runmode == "screen"){
+        if((params.fasta == "") && (params.reads == "") && (params.snpdiffs == "")){
+            error "Runmode is --screen but no query data provided via --snpdiffs/--reads/--fasta"
+        }
+    }
+
+    // Runmode 'snp'
+    //  - Requires: --reads/--fasta/--snpdiffs
+    //  - Optional: --ref_reads/--ref_fasta/--ref_id
+    //  - If references are not provided, runs RefChooser using all FASTAs to choose references (--n_ref sets how many references to choose)
+    //  - Each query is aligned to each reference, and pairwise SNP distances for all queries are generated based on that reference
+    //  - Generates .snpdiffs files (if needed), applies QC, and generates SNP distance data between all queries based on their alignment to each reference
+    else if (params.runmode == "snp"){
+        if((params.snpdiffs == "") && (params.fasta == "") && (params.reads == "")) {
+            error "Runmode is --snp but no query data provided via --snpdiffs/--reads/--fasta"
+        }
     } 
-}
 
-// Runmode 'screen'
-//  - Requires: --reads/--fasta/--snpdiffs
-//  - Optional: --ref_reads/--ref_fasta/--ref_id
-//  - Generates .snpdiffs files (if needed), applies QC, and generates alignment summaries and SNP distance estimates
-//      - If references are provided via --ref_reads/--ref_fasta/--ref_id, non-reference samples are aligned to each reference
-//      - If no references are provided, alignments are all-vs-all
-//      - If --snpdiffs are provided, (1) they will be QC filtered and included in the output report and (2) their FASTAs will be autodetected and, if present, used as queries or references as specified by --ref_reads/--ref_fasta/--ref_id
-
-else if (params.runmode == "screen"){
-    if((params.fasta == "") && (params.reads == "") && (params.snpdiffs == "")){
-        error "Runmode is --screen but no query data provided via --snpdiffs/--reads/--fasta"
+    // Set directory structure
+    if (params.outroot == "") {
+        output_directory = file(params.out)
+    } else {
+        out_root = file(params.outroot)
+        output_directory = file("${out_root}/${params.out}")
     }
-}
 
-// Runmode 'snp'
-//  - Requires: --reads/--fasta/--snpdiffs
-//  - Optional: --ref_reads/--ref_fasta/--ref_id
-//  - If references are not provided, runs RefChooser using all FASTAs to choose references (--n_ref sets how many references to choose)
-//  - Each query is aligned to each reference, and pairwise SNP distances for all queries are generated based on that reference
-//  - Generates .snpdiffs files (if needed), applies QC, and generates SNP distance data between all queries based on their alignment to each reference
-else if (params.runmode == "snp"){
-    if((params.snpdiffs == "") && (params.fasta == "") && (params.reads == "")) {
-        error "Runmode is --snp but no query data provided via --snpdiffs/--reads/--fasta"
+    // If the output directory exists, create a new subdirectory with the default output name ("CSP2_<TIME>")
+    if(!output_directory.getParent().isDirectory()){
+        error "Parent directory for output (--outroot) is not a valid directory [${output_directory.getParent()}]..."
+    } else if(output_directory.isDirectory()){
+        output_directory = file("${output_directory}/CSP2_${new java.util.Date().getTime()}")
+        output_directory.mkdirs()
+    } else{
+        output_directory.mkdirs()
     }
-} 
-
-// Set directory structure
-if (params.outroot == "") {
-    output_directory = file(params.out)
-} else {
-    out_root = file(params.outroot)
-    output_directory = file("${out_root}/${params.out}")
-}
-
-// If the output directory exists, create a new subdirectory with the default output name ("CSP2_<TIME>")
-if(!output_directory.getParent().isDirectory()){
-    error "Parent directory for output (--outroot) is not a valid directory [${output_directory.getParent()}]..."
-} else if(output_directory.isDirectory()){
-    output_directory = file("${output_directory}/CSP2_${new java.util.Date().getTime()}")
-    output_directory.mkdirs()
-} else{
-    output_directory.mkdirs()
-}
 
-if(params.tmp_dir != ""){
-    tempdir = file(params.tmp_dir)
+    if(params.tmp_dir != ""){
+        tempdir = file(params.tmp_dir)
 
-    if(tempdir.isDirectory()){
-        temp_dir = file("${tempdir}/CSP2_${new java.util.Date().getTime()}_tmp")
-        temp_dir.mkdirs()
-        params.temp_dir = file(temp_dir)
+        if(tempdir.isDirectory()){
+            temp_dir = file("${tempdir}/CSP2_${new java.util.Date().getTime()}_tmp")
+            temp_dir.mkdirs()
+            params.temp_dir = file(temp_dir)
 
-    } else if(tempdir.getParent().isDirectory()){
-        tempdir.mkdirs()
-        params.temp_dir = tempdir
+        } else if(tempdir.getParent().isDirectory()){
+            tempdir.mkdirs()
+            params.temp_dir = tempdir
+        } else{
+            error "Parent directory for temp directory --tmp_dir (${params.tmp_dir}) is not a valid directory..."
+        }
     } else{
-        error "Parent directory for temp directory --tmp_dir (${params.tmp_dir}) is not a valid directory..."
+        params.temp_dir = ""
     }
-} else{
-    params.temp_dir = ""
-}
-
-// Set MUMmer and SNP directories
-mummer_directory = file("${output_directory}/MUMmer_Output")
-snpdiffs_directory = file("${output_directory}/snpdiffs")
-snp_directory = file("${output_directory}/SNP_Analysis")
 
-// Set paths for output files 
-isolate_data_file = file("${output_directory}/Isolate_Data.tsv")
-screening_results_file = file("${output_directory}/Screening_Results.tsv")
+    // Set MUMmer and SNP directories
+    mummer_directory = file("${output_directory}/MUMmer_Output")
+    snpdiffs_directory = file("${output_directory}/snpdiffs")
+    snp_directory = file("${output_directory}/SNP_Analysis")
 
-// In --runmode assembly, results save to output_directory
-if(params.runmode == "assemble"){
-    ref_mode = false
+    // Set paths for output files 
+    isolate_data_file = file("${output_directory}/Isolate_Data.tsv")
+    screening_results_file = file("${output_directory}/Screening_Results.tsv")
 
-    log_directory = file("${output_directory}")
-    assembly_directory = file("${output_directory}")
+    // In --runmode assembly, results save to output_directory
+    if(params.runmode == "assemble"){
+        ref_mode = false
 
-    // Set dummy paths for log files
-    screen_log_dir = file("${log_directory}/Screening_Logs")
-    snp_log_dir = file("${log_directory}/SNP_Logs")
-    ref_id_file = file("${log_directory}/Reference_IDs.txt")
-    mummer_log_directory = file("${log_directory}/MUMmer_Logs")
-    mash_dir = file("${log_directory}/sketch_dir")
+        log_directory = file("${output_directory}")
+        assembly_directory = file("${output_directory}")
 
-} else{
+        // Set dummy paths for log files
+        screen_log_dir = file("${log_directory}/Screening_Logs")
+        snp_log_dir = file("${log_directory}/SNP_Logs")
+        ref_id_file = file("${log_directory}/Reference_IDs.txt")
+        mummer_log_directory = file("${log_directory}/MUMmer_Logs")
+        mash_dir = file("${log_directory}/sketch_dir")
 
-    // Get reference mode
-    if(params.ref_reads == "" && params.ref_fasta == "" && params.ref_id == ""){
-        ref_mode = false
     } else{
-        ref_mode = true
-    }
-    
-    // Set directories
-    log_directory = file("${output_directory}/logs")
-    assembly_directory = file("${output_directory}/Assemblies")
-    mummer_log_directory = file("${log_directory}/MUMmer_Logs")
-    ref_id_file = file("${log_directory}/Reference_IDs.txt")
-
-    // Create directories
-    log_directory.mkdirs()
-    mummer_directory.mkdirs()
-    mummer_log_directory.mkdirs()
-    snpdiffs_directory.mkdirs()
-
-    // Touch Reference_IDs.txt to establish it
-    file(ref_id_file).text = ''
-
-    // Set paths for log subdirectories
-    screen_log_dir = file("${log_directory}/Screening_Logs")
-    snp_log_dir = file("${log_directory}/SNP_Logs")
-    mash_dir = file("${log_directory}/sketch_dir")
-
-    // If --reads/--ref_reads are provided, prepare a directory for assemblies
-    if((params.reads != "") || (params.ref_reads != "")){
-        assembly_directory.mkdirs()
-    }
 
-    // If runmode is snp, prepare a directory for SNP analysis + logs
-    if(params.runmode == "snp"){
-        snp_directory.mkdirs()
-        snp_log_dir.mkdirs()
-        if(!ref_mode){
-            mash_dir.mkdirs()
-        }        
-    }
+        // Get reference mode
+        if(params.ref_reads == "" && params.ref_fasta == "" && params.ref_id == ""){
+            ref_mode = false
+        } else{
+            ref_mode = true
+        }
+        
+        // Set directories
+        log_directory = file("${output_directory}/logs")
+        assembly_directory = file("${output_directory}/Assemblies")
+        mummer_log_directory = file("${log_directory}/MUMmer_Logs")
+        ref_id_file = file("${log_directory}/Reference_IDs.txt")
+
+        // Create directories
+        log_directory.mkdirs()
+        mummer_directory.mkdirs()
+        mummer_log_directory.mkdirs()
+        snpdiffs_directory.mkdirs()
+
+        // Touch Reference_IDs.txt to establish it
+        file(ref_id_file).text = ''
+
+        // Set paths for log subdirectories
+        screen_log_dir = file("${log_directory}/Screening_Logs")
+        snp_log_dir = file("${log_directory}/SNP_Logs")
+        mash_dir = file("${log_directory}/sketch_dir")
+
+        // If --reads/--ref_reads are provided, prepare a directory for assemblies
+        if((params.reads != "") || (params.ref_reads != "")){
+            assembly_directory.mkdirs()
+        }
 
-    // If runmode is screen, prepare a directory for screening logs
-    if(params.runmode == "screen"){
-        screen_log_dir.mkdirs()
+        // If runmode is snp, prepare a directory for SNP analysis + logs
+        if(params.runmode == "snp"){
+            snp_directory.mkdirs()
+            snp_log_dir.mkdirs()
+            if(!ref_mode){
+                mash_dir.mkdirs()
+            }        
+        }
+
+        // If runmode is screen, prepare a directory for screening logs
+        if(params.runmode == "screen"){
+            screen_log_dir.mkdirs()
+        }
     }
-}
 
-// Parameterize variables to pass between scripts
-params.output_directory = file(output_directory)
-params.log_directory = file(log_directory)
-params.screen_log_dir = file(screen_log_dir)
-params.snp_log_dir = file(snp_log_dir)
-params.assembly_directory = file(assembly_directory)
-params.mummer_directory = file(mummer_directory)
-params.mummer_log_directory = file(mummer_log_directory)
-params.snpdiffs_directory = file(snpdiffs_directory)
-params.snp_directory = file(snp_directory)
-params.ref_id_file = file(ref_id_file)
-params.mash_directory = file(mash_dir)
-
-params.ref_mode = ref_mode
-
-// Set up modules if needed
-params.load_python_module = params.python_module == "" ? "" : "module load -s ${params.python_module}"
-params.load_skesa_module = params.skesa_module == "" ? "" : "module load -s ${params.skesa_module}"
-params.load_bedtools_module = params.bedtools_module == "" ? "" : "module load -s ${params.bedtools_module}"
-params.load_bbtools_module = params.bbtools_module == "" ? "" : "module load -s ${params.bbtools_module}"
-params.load_mummer_module = params.mummer_module == "" ? "" : "module load -s ${params.mummer_module}"
-params.load_mash_module = params.mash_module == "" ? "" : "module load -s ${params.mash_module}"
-
-// Save params to log file
-params.each { key, value ->
-    file("${log_directory}/CSP2_Params.txt") << "$key = $value\n"
+    // Parameterize variables to pass between scripts
+    params.output_directory = file(output_directory)
+    params.log_directory = file(log_directory)
+    params.screen_log_dir = file(screen_log_dir)
+    params.snp_log_dir = file(snp_log_dir)
+    params.assembly_directory = file(assembly_directory)
+    params.mummer_directory = file(mummer_directory)
+    params.mummer_log_directory = file(mummer_log_directory)
+    params.snpdiffs_directory = file(snpdiffs_directory)
+    params.snp_directory = file(snp_directory)
+    params.ref_id_file = file(ref_id_file)
+    params.mash_directory = file(mash_dir)
+
+    params.ref_mode = ref_mode
+
+    // Set up modules if needed
+    params.load_python_module = params.python_module == "" ? "" : "module load -s ${params.python_module}"
+    params.load_skesa_module = params.skesa_module == "" ? "" : "module load -s ${params.skesa_module}"
+    params.load_bedtools_module = params.bedtools_module == "" ? "" : "module load -s ${params.bedtools_module}"
+    params.load_bbtools_module = params.bbtools_module == "" ? "" : "module load -s ${params.bbtools_module}"
+    params.load_mummer_module = params.mummer_module == "" ? "" : "module load -s ${params.mummer_module}"
+    params.load_mash_module = params.mash_module == "" ? "" : "module load -s ${params.mash_module}"
+
+    // Save params to log file
+    params.each { key, value ->
+        file("${log_directory}/CSP2_Params.txt") << "$key = $value\n"
+    }
+} else{
+    params.output_directory = "./"
+    params.log_directory = "./"
+    params.screen_log_dir = "./"
+    params.snp_log_dir = "./"
+    params.assembly_directory = "./"
+    params.mummer_directory = "./"
+    params.mummer_log_directory = "./"
+    params.snpdiffs_directory = "./"
+    params.snp_directory = "./"
+    params.ref_id_file = "./"
+    params.mash_directory = "./"
+    params.ref_mode = false
+    params.load_python_module = ""
+    params.load_skesa_module = ""
+    params.load_bedtools_module = ""
+    params.load_bbtools_module = ""
+    params.load_mummer_module = ""
+    params.load_mash_module = ""
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
@@ -324,76 +346,91 @@ include {runRefChooser} from "./subworkflows/refchooser/main.nf"
 
 workflow{
     
-    // Read in data
-    input_data = fetchData()
-
-    query_data = input_data.query_data
-    reference_data = input_data.reference_data
-    snpdiffs_data = input_data.snpdiff_data
-
-    // Create channel for pre-aligned data [(Query_1,Query_2),SNPDiffs_File]
-    prealigned = snpdiffs_data
-    .map { it -> tuple([it[0], it[1]].sort().join(',').toString(), it[2]) }
-    .unique{it -> it[0]}
-    
-    // If run mode is 'assemble', tasks are complete
-    if((params.runmode == "align") || (params.runmode == "screen") || (params.runmode == "snp")){
+    if(params.runmode == "conda_init"){
+        conda_init()
+    } else{
+        // Read in data
+        input_data = fetchData()
 
-        // If there is no reference data, align all query_data against each other
-        if(!ref_mode){
+        query_data = input_data.query_data
+        reference_data = input_data.reference_data
+        snpdiffs_data = input_data.snpdiff_data
 
-            if((params.runmode == "align") || (params.runmode == "screen")){
-                seen_combinations = []
-                
-                to_align = query_data.combine(query_data) // Self-combine query data
-                .collect().flatten().collate(4)
-                .filter{it -> (it[1].toString() != "null") && (it[3].toString() != "null")} // Can't align without FASTA
-                .filter{ it -> // Get unique combinations
+        // Create channel for pre-aligned data [(Query_1,Query_2),SNPDiffs_File]
+        prealigned = snpdiffs_data
+        .map { it -> tuple([it[0], it[1]].sort().join(',').toString(), it[2]) }
+        .unique{it -> it[0]}
         
-                combination = ["${it[0]}", "${it[2]}"].sort()
-                
-                if(combination in seen_combinations) {
-                    return false
-                } else {
-                    seen_combinations << combination
-                    return true
-                }}
-            } 
+        // If run mode is 'assemble', tasks are complete
+        if((params.runmode == "align") || (params.runmode == "screen") || (params.runmode == "snp")){
+
+            // If there is no reference data, align all query_data against each other
+            if(!ref_mode){
+
+                if((params.runmode == "align") || (params.runmode == "screen")){
+                    seen_combinations = []
+                    
+                    to_align = query_data.combine(query_data) // Self-combine query data
+                    .collect().flatten().collate(4)
+                    .filter{it -> (it[1].toString() != "null") && (it[3].toString() != "null")} // Can't align without FASTA
+                    .filter{ it -> // Get unique combinations
             
-            // If running SNP pipeline without references, run RefChooser to choose references
-            else if(params.runmode == "snp"){
-                reference_data = runRefChooser(query_data)
+                    combination = ["${it[0]}", "${it[2]}"].sort()
+                    
+                    if(combination in seen_combinations) {
+                        return false
+                    } else {
+                        seen_combinations << combination
+                        return true
+                    }}
+                } 
                 
+                // If running SNP pipeline without references, run RefChooser to choose references
+                else if(params.runmode == "snp"){
+                    reference_data = runRefChooser(query_data)
+                    
+                    to_align = query_data
+                    .combine(reference_data)
+                    .filter{it -> (it[1].toString() != "null") && (it[3].toString() != "null")} // Can't align without FASTA
+                }
+            }
+
+            // If references are provided, align all queries against all references
+            else{
                 to_align = query_data
                 .combine(reference_data)
                 .filter{it -> (it[1].toString() != "null") && (it[3].toString() != "null")} // Can't align without FASTA
             }
-        }
 
-        // If references are provided, align all queries against all references
-        else{
-            to_align = query_data
-            .combine(reference_data)
-            .filter{it -> (it[1].toString() != "null") && (it[3].toString() != "null")} // Can't align without FASTA
-        }
-
-        // Don't align things that are already aligned via --snpdiffs
-        unaligned = to_align
-        .map { it -> tuple([it[0], it[2]].sort().join(',').toString(),it[0], it[1], it[2], it[3]) }
-        .unique{it -> it[0]}
-        .join(prealigned, by:0, remainder:true)
-        .filter{it -> it[5].toString() == "null"}
-        .map{it -> [it[1], it[2], it[3], it[4]]}
-        | collect | flatten | collate(4)
-
-        all_snpdiffs = alignGenomes(unaligned,snpdiffs_data)
-        .ifEmpty { error "No .snpdiffs to process..." }
-        .collect().flatten().collate(3)
-        
-        if(params.runmode == "screen"){
-            runScreen(all_snpdiffs)
-        } else if(params.runmode == "snp"){
-            runSNPPipeline(all_snpdiffs,reference_data)
+            // Don't align things that are already aligned via --snpdiffs
+            unaligned = to_align
+            .map { it -> tuple([it[0], it[2]].sort().join(',').toString(),it[0], it[1], it[2], it[3]) }
+            .unique{it -> it[0]}
+            .join(prealigned, by:0, remainder:true)
+            .filter{it -> it[5].toString() == "null"}
+            .map{it -> [it[1], it[2], it[3], it[4]]}
+            | collect | flatten | collate(4)
+
+            all_snpdiffs = alignGenomes(unaligned,snpdiffs_data)
+            .ifEmpty { error "No .snpdiffs to process..." }
+            .collect().flatten().collate(3)
+            
+            if(params.runmode == "screen"){
+                runScreen(all_snpdiffs)
+            } else if(params.runmode == "snp"){
+                runSNPPipeline(all_snpdiffs,reference_data)
+            }
         }
     }
+}
+
+// Dummy process to stimulate conda env generation
+process conda_init {
+    executor = 'local'
+    cpus = 1
+    maxForks = 1
+    
+    script:
+    """
+    """
 }
\ No newline at end of file
diff --git a/bin/chooseRefs.py b/bin/chooseRefs.py
index b73f12b..c2d20b2 100644
--- a/bin/chooseRefs.py
+++ b/bin/chooseRefs.py
@@ -83,9 +83,9 @@ def fasta_info(file_path):
     return [file_path,contig_count,assembly_bases,n50,n90,l50,l90]
 
 parser = argparse.ArgumentParser(description='Choose reference isolates based on FASTA metrics and mean distances.')
-parser.add_argument('--ref_count', type=int, help='Number of reference isolates to select')
+parser.add_argument('--ref_count', type=int, default=1, help='Number of reference isolates to select')
 parser.add_argument('--mash_triangle_file', type=str, help='Path to the mash triangle file')
-parser.add_argument('--trim_name', type=str, help='Trim name')
+parser.add_argument('--trim_name', nargs='?', const="", default="", type=str, help='Trim name')
 args = parser.parse_args()
 
 ref_count = args.ref_count
@@ -186,6 +186,8 @@ def fasta_info(file_path):
 non_ref_df = cluster_df.loc[~cluster_df['Isolate_ID'].isin(refs_chosen)].sort_values('Base_Score', ascending=False)
 non_ref_df['Is_Ref'] = False
 final_ref_df['Is_Ref'] = True
-pd.concat([final_ref_df, non_ref_df]).reset_index(drop=True).to_csv(ref_file, index=False, sep="\t")
+
+with open(ref_file, 'w') as f:
+    pd.concat([final_ref_df, non_ref_df]).reset_index(drop=True).to_csv(f, index=False, sep="\t")
 
 print(",".join(final_ref_df['Path'].tolist()))
\ No newline at end of file
diff --git a/bin/compileSNPResults.py b/bin/compileSNPResults.py
index f2c7bd1..d063700 100644
--- a/bin/compileSNPResults.py
+++ b/bin/compileSNPResults.py
@@ -467,17 +467,20 @@ def getWarnings(df):
 # Output data
 
 # Mean assembly stats
-isolate_mean_df.reset_index().to_csv(mean_isolate_file,sep='\t',index=False)
+with open(mean_isolate_file, 'w') as f:
+    isolate_mean_df.reset_index().to_csv(f,sep='\t',index=False)
 
 # Isolate assembly stats
 isolate_assembly_stats = isolate_stats.loc[isolate_stats['Measure'].isin(['Contig_Count','Assembly_Bases','L50','L90','N50','N90'])].drop(['Min','Max','StdDev','Count'],axis=1).rename(columns = {'Mean':'Value'})
-isolate_assembly_stats.to_csv(isolate_assembly_stats_file,sep='\t',index=False)
+with open(isolate_assembly_stats_file,'w') as f:
+    isolate_assembly_stats.to_csv(f,sep='\t',index=False)
 
 # Isolate alignment stats
 isolate_align_stats = pd.concat([align_stats,isolate_cocalled_stats,isolate_snp_stats,isolate_stdev_stats]).reset_index(drop=True)
 for col in ['Min', 'Mean', 'Max', 'StdDev', 'Zscore']:
     isolate_align_stats[col] = isolate_align_stats[col].astype("float").round(3)
-isolate_align_stats.to_csv(align_stats_file,sep='\t',index=False)
+with open(align_stats_file,'w') as f:
+    isolate_align_stats.to_csv(f,sep='\t',index=False)
 
 # Reference Assembly Stats
 ref_align_summary_df = ref_summary_df.loc[(~ref_summary_df['Measure'].isin(['Contig_Count','Assembly_Bases','L50','L90','N50','N90'])) & (~pd.isna(ref_summary_df['Zscore']))]
@@ -492,7 +495,9 @@ def getWarnings(df):
 ref_isolate_align_stats = align_stats.loc[(align_stats['Isolate_Type'] == "Reference") & (align_stats['Measure'].isin(['Self_Aligned','Compare_Aligned']))].drop(['Isolate_Type'],axis=1).rename(columns = {'Isolate_ID':'Reference_ID'})[['Reference_ID','Measure','Mean','StdDev','Min','Max','Count','Zscore','QC']]
 
 ref_mean_summary_stats = pd.concat([ref_mean_summary_df,ref_isolate_align_stats])
-ref_mean_summary_stats.to_csv(ref_mean_summary_file,sep='\t',index=False)
+
+with open(ref_mean_summary_file,'w') as f:
+    ref_mean_summary_stats.to_csv(f,sep='\t',index=False)
 
 end_time = time.time()
 
@@ -505,10 +510,12 @@ def getWarnings(df):
     
     # Comparisons if multiple refs
     if len(reference_ids) > 1:
-        comparison_df.to_csv(snp_comparison_file,sep="\t",index = False)
+        with open(snp_comparison_file,"w") as f:
+            comparison_df.to_csv(f,sep="\t",index = False)
         log.write(f"\t- Saved SNP distance comparisons across references to {snp_comparison_file}\n")
     
     # Failures/warnings
     if warn_fail_df.shape[0] > 0:
-        warn_fail_df.to_csv(qc_file,sep="\t",index=False)
+        with open(qc_file,"w") as f:
+            warn_fail_df.to_csv(f,sep="\t",index=False)
         log.write(f"\t- Saved QC warnings/failures to {qc_file}\n")
\ No newline at end of file
diff --git a/bin/fetchReads.py b/bin/fetchReads.py
index 29491b9..1859778 100644
--- a/bin/fetchReads.py
+++ b/bin/fetchReads.py
@@ -8,10 +8,10 @@
 # Parse args
 parser = argparse.ArgumentParser(description='Fetch Reads')
 parser.add_argument('--read_dir', type=str, help='path to directory containing read files')
-parser.add_argument('--read_filetype', type=str, help='read filetype information')
-parser.add_argument('--forward_suffix', type=str, help='forward suffix')
-parser.add_argument('--reverse_suffix', type=str, help='reverse suffix')
-parser.add_argument('--trim_name', type=str, help='trim name')
+parser.add_argument('--read_filetype',default='fastq.gz', type=str, help='read filetype information')
+parser.add_argument('--forward_suffix',default='_1.fastq.gz', type=str, help='forward suffix')
+parser.add_argument('--reverse_suffix',default = '_2.fastq.gz', type=str, help='reverse suffix')
+parser.add_argument('--trim_name', nargs='?', const="", default="", type=str, help='Trim name')
 args = parser.parse_args()
 
 # Get path to directory containing read files
diff --git a/bin/runSNPPipeline.py b/bin/runSNPPipeline.py
index e324052..8b00885 100644
--- a/bin/runSNPPipeline.py
+++ b/bin/runSNPPipeline.py
@@ -507,7 +507,8 @@ def screenSNPDiffs(snpdiffs_file,trim_name, min_cov, min_len, min_iden, ref_edge
                                              
                     # Write filtered SNP data to file
                     snp_file = log_file.replace(".log","_SNPs.tsv")
-                    filtered_snp_df.to_csv(snp_file, sep="\t", index=False)
+                    with open(snp_file,"w") as f:
+                        filtered_snp_df.to_csv(f, sep="\t", index=False)
                     
                     filtered_snp_df.loc[:, 'Query_ID'] = query_id
                     
@@ -636,17 +637,17 @@ def getFinalPurge(df):
 parser.add_argument('--output_directory', type=str, help='Output Directory')
 parser.add_argument('--log_directory', type=str, help='Log Directory')
 parser.add_argument('--snpdiffs_file', type=str, help='Path to SNPdiffs file')
-parser.add_argument('--min_cov', type=float, help='Minimum coverage')
-parser.add_argument('--min_len', type=int, help='Minimum length')
-parser.add_argument('--min_iden', type=float, help='Minimum identity')
-parser.add_argument('--ref_edge', type=int, help='Reference edge')
-parser.add_argument('--query_edge', type=int, help='Query edge')
-parser.add_argument('--density_windows', type=str, help='Density windows')
-parser.add_argument('--max_snps', type=str, help='Maximum SNPs')
-parser.add_argument('--trim_name', type=str, help='Trim name')
-parser.add_argument('--max_missing', type=float, help='Maximum missing')
-parser.add_argument('--tmp_dir', type=str, help='Temporary directory')
-parser.add_argument('--rescue', type=str, help='Rescue edge SNPs (rescue/norescue)')
+parser.add_argument('--min_cov', default=85,type=float, help='Minimum coverage')
+parser.add_argument('--min_len', default=500,type=int, help='Minimum length')
+parser.add_argument('--min_iden', default=99,type=float, help='Minimum identity')
+parser.add_argument('--ref_edge', default=150,type=int, help='Reference edge')
+parser.add_argument('--query_edge', default=150,type=int, help='Query edge')
+parser.add_argument('--density_windows', default="1000,125,15",type=str, help='Density windows')
+parser.add_argument('--max_snps', default="3,2,1", type=str, help='Maximum SNPs')
+parser.add_argument('--trim_name', nargs='?', const="", default="", type=str, help='Trim name')
+parser.add_argument('--max_missing',default=50, type=float, help='Maximum missing')
+parser.add_argument('--tmp_dir',default="", type=str, help='Temporary directory')
+parser.add_argument('--rescue', default="norescue",type=str, help='Rescue edge SNPs (rescue/norescue)')
 args = parser.parse_args()
 
 reference_id = args.reference_id
@@ -750,7 +751,8 @@ def getFinalPurge(df):
 
     # Save reference screening
     results_df = pd.DataFrame([item.result()[0] for item in results], columns = output_columns)
-    results_df.to_csv(reference_screening_file, sep="\t", index=False)
+    with open(reference_screening_file,"w") as f:
+        results_df.to_csv(f, sep="\t", index=False)
 
     # Get reference bed dfs
     covered_df = pd.concat([item.result()[1] for item in results])
@@ -940,7 +942,8 @@ def getFinalPurge(df):
             locus_coverage_df = snp_coverage_df.merge(ref_base_coverage_df, how='outer', on='Ref_Loc').merge(uncovered_count_df, how='outer', on='Ref_Loc').merge(purged_count_df, how='outer', on='Ref_Loc').fillna(0)
             locus_coverage_df.loc[:, ['SNP_Count','Ref_Base_Count','Uncovered_Count','Purged_Count']] = locus_coverage_df.loc[:, ['SNP_Count','Ref_Base_Count','Uncovered_Count','Purged_Count']].astype(int)
             locus_coverage_df['Missing_Ratio'] = ((locus_coverage_df['Uncovered_Count'] + locus_coverage_df['Purged_Count']) / (1+len(pass_qc_isolates))) * 100
-            locus_coverage_df.to_csv(locus_category_file, sep="\t", index=False)
+            with open(locus_category_file,"w") as f:
+                locus_coverage_df.to_csv(f, sep="\t", index=False)
             
             # Get isolate coverage stats
             min_isolate_cols = ['Query_ID','SNP','Ref_Base','Percent_Missing','Purged','Uncovered','Rescued_SNP','Purged_Ref_Edge']
@@ -964,7 +967,8 @@ def getFinalPurge(df):
                 isolate_coverage_df.loc[isolate_coverage_df['Query_ID'] == reference_id, 'Purged_Ref_Edge'] = ref_edge_df['Ref_Loc'].nunique()
             
             isolate_coverage_df = isolate_coverage_df[min_isolate_cols + possible_purged_cols].sort_values(by = 'Percent_Missing',ascending = False).reset_index(drop=True)
-            isolate_coverage_df.to_csv(query_coverage_file, sep="\t", index=False)
+            with open(query_coverage_file,'w') as f:
+                isolate_coverage_df.to_csv(f, sep="\t", index=False)
             
             with open(log_file,"a+") as log:
                 log.write(f"\t- SNP coverage information: {locus_category_file}\n")
@@ -1039,42 +1043,52 @@ def getFinalPurge(df):
         pairwise_df = pd.DataFrame([(pairwise[0], pairwise[1], 0,np.nan) for pairwise in pairwise_combinations],columns = ['Query_1','Query_2','SNP_Distance','SNPs_Cocalled'])
         preserved_pairwise_df = pairwise_df.copy()
         
-        pairwise_df.to_csv(raw_pairwise, sep="\t", index=False)
-        preserved_pairwise_df.to_csv(preserved_pairwise, sep="\t", index=False)
+        with open(raw_pairwise,"w") as f:
+            pairwise_df.to_csv(f, sep="\t", index=False)
+        with open(preserved_pairwise,"w") as f:
+            preserved_pairwise_df.to_csv(f, sep="\t", index=False)
         
         # Create matrix
         idx = sorted(set(pairwise_df['Query_1']).union(pairwise_df['Query_2']))
         mirrored_distance_df = pairwise_df.pivot(index='Query_1', columns='Query_2', values='SNP_Distance').reindex(index=idx, columns=idx).fillna(0, downcast='infer').pipe(lambda x: x+x.values.T).applymap(lambda x: format(x, '.0f'))
         mirrored_distance_df.index.name = ''
-        mirrored_distance_df.to_csv(raw_matrix,sep="\t")
-        mirrored_distance_df.to_csv(preserved_matrix,sep="\t")
+        with open(raw_matrix,"w") as f:
+            mirrored_distance_df.to_csv(f,sep="\t")
+        with open(preserved_matrix,"w") as f:
+            mirrored_distance_df.to_csv(f,sep="\t")
 
     else:
         raw_distance_results = parallelAlignment(alignment)
         raw_pairwise_df = pd.DataFrame(raw_distance_results, columns=['Query_1', 'Query_2', 'SNP_Distance', 'SNPs_Cocalled'])
-        raw_pairwise_df.to_csv(raw_pairwise, sep="\t", index=False)
+        with open(raw_pairwise,"w") as f:
+            raw_pairwise_df.to_csv(f, sep="\t", index=False)
 
         if len(locs_pass_missing) == snp_count:
             preserved_pairwise_df = raw_pairwise_df.copy()
-            preserved_pairwise_df.to_csv(preserved_pairwise, sep="\t", index=False)
+            with open(preserved_pairwise,"w") as f:
+                preserved_pairwise_df.to_csv(f, sep="\t", index=False)
         elif len(locs_pass_missing) == 0:
             preserved_pairwise_df = pd.DataFrame([(pairwise[0], pairwise[1], 0,np.nan) for pairwise in pairwise_combinations],columns = ['Query_1','Query_2','SNP_Distance','SNPs_Cocalled'])
-            preserved_pairwise_df.to_csv(preserved_pairwise, sep="\t", index=False)
+            with open(preserved_pairwise,"w") as f:
+                preserved_pairwise_df.to_csv(f, sep="\t", index=False)        
         else:
             preserved_distance_results = parallelAlignment(preserved_alignment)
             preserved_pairwise_df = pd.DataFrame(preserved_distance_results, columns=['Query_1', 'Query_2', 'SNP_Distance', 'SNPs_Cocalled'])
-            preserved_pairwise_df.to_csv(preserved_pairwise, sep="\t", index=False)
-    
+            with open(preserved_pairwise,"w") as f:
+                preserved_pairwise_df.to_csv(f, sep="\t", index=False)    
+        
         # Create matrix
         idx = sorted(set(raw_pairwise_df['Query_1']).union(raw_pairwise_df['Query_2']))
         mirrored_distance_df = raw_pairwise_df.pivot(index='Query_1', columns='Query_2', values='SNP_Distance').reindex(index=idx, columns=idx).fillna(0, downcast='infer').pipe(lambda x: x+x.values.T).applymap(lambda x: format(x, '.0f'))
         mirrored_distance_df.index.name = ''
-        mirrored_distance_df.to_csv(raw_matrix,sep="\t")
+        with open(raw_matrix,"w") as f:
+            mirrored_distance_df.to_csv(f,sep="\t")
         
         idx = sorted(set(preserved_pairwise_df['Query_1']).union(preserved_pairwise_df['Query_2']))
         mirrored_distance_df = preserved_pairwise_df.pivot(index='Query_1', columns='Query_2', values='SNP_Distance').reindex(index=idx, columns=idx).fillna(0, downcast='infer').pipe(lambda x: x+x.values.T).applymap(lambda x: format(x, '.0f'))
         mirrored_distance_df.index.name = ''
-        mirrored_distance_df.to_csv(preserved_matrix,sep="\t")
+        with open(preserved_matrix,"w") as f:
+            mirrored_distance_df.to_csv(f,sep="\t")
 
     # Clean up pybedtools temp
     helpers.cleanup(verbose=False,remove_all = False)
diff --git a/bin/saveSNPDiffs.py b/bin/saveSNPDiffs.py
index 7a09644..026ade0 100644
--- a/bin/saveSNPDiffs.py
+++ b/bin/saveSNPDiffs.py
@@ -30,7 +30,7 @@ def processHeader(header_row,file_path,trim_name):
 parser.add_argument("--snpdiffs_file", help="Path to the SNP diffs list file")
 parser.add_argument("--summary_file", help="Path to the summary file")
 parser.add_argument("--isolate_file", help="Path to the isolate data file")
-parser.add_argument("--trim_name", help="Trim name")
+parser.add_argument('--trim_name', nargs='?', const="", default="", type=str, help='Trim name')
 parser.add_argument("--ref_id_file", help="Path to the reference IDs file")
 args = parser.parse_args()
 
@@ -58,7 +58,8 @@ def processHeader(header_row,file_path,trim_name):
         header_rows.append(processHeader(top_line,snpdiffs_file,trim_name))
 
 output_data = pd.concat(header_rows, ignore_index=True)
-output_data.to_csv(summary_file, sep='\t', index=False)
+with open(summary_file,"w") as f:
+    output_data.to_csv(f, sep='\t', index=False)
 
 # If ref_ids is empty, save isolate data
 ref_header = ['Reference_ID','Reference_Assembly','Reference_Contig_Count','Reference_Assembly_Bases','Reference_N50','Reference_N90','Reference_L50','Reference_L90','Reference_SHA256']
@@ -79,5 +80,6 @@ def processHeader(header_row,file_path,trim_name):
 cols = combined_df.columns.tolist()
 cols = cols[:1] + cols[-1:] + cols[1:-1]
 combined_df = combined_df[cols]
-combined_df.to_csv(isolate_data_file, sep='\t', index=False)
+with open(isolate_data_file,"w") as f:
+    combined_df.to_csv(f, sep='\t', index=False)
 
diff --git a/bin/screenSNPDiffs.py b/bin/screenSNPDiffs.py
index 5d7bede..89567f0 100644
--- a/bin/screenSNPDiffs.py
+++ b/bin/screenSNPDiffs.py
@@ -502,7 +502,8 @@ def screenSNPDiffs(snpdiffs_file,trim_name, min_cov, min_len, min_iden, ref_edge
                     
                     # Write filtered SNP data to file
                     snp_file = log_file.replace(".log","_SNPs.tsv")
-                    filtered_snp_df.to_csv(snp_file, sep="\t", index=False)
+                    with open(snp_file,"w") as f:
+                        filtered_snp_df.to_csv(f, sep="\t", index=False)
                     
                     csp2_screen_snps = filtered_snp_df[filtered_snp_df.Cat == "SNP"].shape[0]
                     
@@ -548,17 +549,17 @@ def screenSNPDiffs(snpdiffs_file,trim_name, min_cov, min_len, min_iden, ref_edge
 parser = argparse.ArgumentParser()
 parser.add_argument("--snpdiffs_file", help="Path to the file containing SNP diffs")
 parser.add_argument("--log_dir", help="Path to the log directory")
-parser.add_argument("--min_cov", type=float, help="Minimum coverage")
-parser.add_argument("--min_len", type=int, help="Minimum length")
-parser.add_argument("--min_iden", type=float, help="Minimum identity")
-parser.add_argument("--ref_edge", type=int, help="Reference edge")
-parser.add_argument("--query_edge", type=int, help="Query edge")
-parser.add_argument("--density_windows", help="Density windows (comma-separated)")
-parser.add_argument("--max_snps", help="Maximum SNPs (comma-separated)")
-parser.add_argument("--trim_name", help="Trim name")
+parser.add_argument("--min_cov", default=85, type=float, help="Minimum coverage")
+parser.add_argument("--min_len", default=500,type=int, help="Minimum length")
+parser.add_argument("--min_iden", default=99,type=float, help="Minimum identity")
+parser.add_argument("--ref_edge", default=150,type=int, help="Reference edge")
+parser.add_argument("--query_edge", default=150,type=int, help="Query edge")
+parser.add_argument("--density_windows",default="1000,125,15", help="Density windows (comma-separated)")
+parser.add_argument("--max_snps", default="3,2,1",help="Maximum SNPs (comma-separated)")
+parser.add_argument('--trim_name', nargs='?', const="", default="", type=str, help='Trim name')
 parser.add_argument("--output_file", help="Output file")
 parser.add_argument("--ref_id", help="Reference IDs file")
-parser.add_argument("--tmp_dir", help="TMP dir")
+parser.add_argument("--tmp_dir",default="", help="TMP dir")
 
 args = parser.parse_args()
 
@@ -630,7 +631,8 @@ def screenSNPDiffs(snpdiffs_file,trim_name, min_cov, min_len, min_iden, ref_edge
                 'MUMmer_gSNPs','MUMmer_gIndels']
 
     results_df = pd.DataFrame([item.result() for item in results], columns = output_columns)
-    results_df.to_csv(output_file, sep="\t", index=False)
+    with open(output_file,"w") as f:
+        results_df.to_csv(f, sep="\t", index=False)
 except:
     run_failed = True
     print("Exception occurred:\n", traceback.format_exc())
diff --git a/bin/userSNPDiffs.py b/bin/userSNPDiffs.py
index 6ddb516..cfc95c0 100644
--- a/bin/userSNPDiffs.py
+++ b/bin/userSNPDiffs.py
@@ -31,7 +31,7 @@ def processHeader(header_row,snpdiffs_path):
 
 parser = argparse.ArgumentParser()
 parser.add_argument("--snpdiffs_file", help="Path to the SNP diffs list file")
-parser.add_argument("--trim_name", help="Trim name")
+parser.add_argument('--trim_name', nargs='?', const="", default="", type=str, help='Trim name')
 args = parser.parse_args()
 
 snpdiffs_list_file = args.snpdiffs_file
diff --git a/conf/profiles.config b/conf/profiles.config
index f27753a..11e31a0 100644
--- a/conf/profiles.config
+++ b/conf/profiles.config
@@ -85,11 +85,12 @@ profiles {
         conda.cacheDir = "${projectDir}/CSP2_env"
         process.conda = "${projectDir}/conf/CSP2.yaml"
         
-        process.queue = 'CSP2'
+        process.queue = "ondemand-small"
+
         executor.$slurm.exitReadTimeout = 120000
 
         process.executor = 'slurm'
-        params.cores = 20
+        params.cores = 1
         params.python_module = ""
         params.mummer_module = ""
         params.skesa_module = ""
diff --git a/nextflow.config b/nextflow.config
index c041142..76f973a 100644
--- a/nextflow.config
+++ b/nextflow.config
@@ -12,6 +12,19 @@ conda.enabled = true
 // Import profile settings
 includeConfig "conf/profiles.config"
 
+// CPU/memory settings
+process {
+    withLabel: 'mummerMem' {
+        task_name = 'CSP2-MUMmer'
+        cpus = 1
+        memory = '4 GB'
+    }
+    withLabel: 'skesaMem' {
+        task_name = 'CSP2-SKESA'
+        memory = '12 GB'
+    }
+}
+
 // Global default params
 params {
 
diff --git a/subworkflows/alignData/main.nf b/subworkflows/alignData/main.nf
index f9507a0..8c27feb 100644
--- a/subworkflows/alignData/main.nf
+++ b/subworkflows/alignData/main.nf
@@ -66,8 +66,7 @@ workflow alignGenomes{
 
 process runMUMmer{
 
-    cpus = 1
-    memory '4 GB'
+    label 'mummerMem'
 
     input:
     tuple val(query_name),val(query_fasta),val(ref_name),val(ref_fasta)
diff --git a/subworkflows/fetchData/main.nf b/subworkflows/fetchData/main.nf
index e5bf3a6..653f092 100644
--- a/subworkflows/fetchData/main.nf
+++ b/subworkflows/fetchData/main.nf
@@ -19,8 +19,8 @@ user_snpdiffs_list = file("${log_directory}/Imported_SNPDiffs.txt")
 findReads = file("${projectDir}/bin/fetchReads.py")
 userSNPDiffs = file("${projectDir}/bin/userSNPDiffs.py")
 
-// Set SKESA cores to 5 or fewer
-skesa_cpus = (params.cores as Integer) >= 5 ? 5 : (params.cores as Integer)
+// Set SKESA cores to 4 or fewer
+skesa_cpus = (params.cores as Integer) >= 4 ? 4 : params.cores as Integer
 
 workflow {
     main:
@@ -272,12 +272,16 @@ workflow getAssemblies{
         } else{
             error "$fasta_dir is not a valid directory or file..."
         }
+
         fasta_data = ch_fasta
-        .filter { file(it).exists() }
+        .map { filePath ->
+            if (!file(filePath).exists()) { error "$filePath is not a valid directory or file..." }
+            return filePath }
         .map { filePath ->
             def fileName = file(filePath).getBaseName()
             def sampleName = fileName.replaceAll(trim_this, "")
-            tuple(sampleName, filePath)}
+            tuple(sampleName, filePath)
+        }
     }
 }
 workflow processSNPDiffs{
@@ -313,8 +317,10 @@ workflow processSNPDiffs{
         }
 
         snpdiffs_data = ch_snpdiffs
-            .filter { file(it).exists() }
-            .collect() | getSNPDiffsData | splitCsv | collect | flatten | collate(19)
+        .map { filePath ->
+            if (!file(filePath).exists()) { error "$filePath is not a valid directory or file..." }
+            return filePath }
+        .collect() | getSNPDiffsData | splitCsv | collect | flatten | collate(19)
 
         // (1) SNPDiffs_File, (2) Query_ID, (3) Query_Assembly, (4) Query_Contig_Count, (5) Query_Assembly_Bases, 
         // (6) Query_N50, (7) Query_N90, (8) Query_L50, (9) Query_L90, (10) Query_SHA256,
@@ -493,8 +499,10 @@ workflow assembleReads{
     assembled_data = assembly_output.map{it->tuple(it[0],it[3])}
 }
 process skesaAssemble{
-    memory '12 GB' // Add readcount/memory check?
+    label 'skesaMem'
 
+    cpus = skesa_cpus
+    
     input:
     tuple val(sample_name),val(read_type),val(read_location)