Split hifiasm

CHANGELOG.md

@@ -47,6 +47,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - [#962](https://github.com/genomic-medicine-sweden/nallo/pull/962) - Changed peddy inputs from ranked to annotated or unannotated variants, depending on availability
 - [#964](https://github.com/genomic-medicine-sweden/nallo/pull/964) - Limit `--snv_calling_processes` to `1` for sentieon due to issues with duplicated variants (see #926)
 - [#966](https://github.com/genomic-medicine-sweden/nallo/pull/966) - Refactored the code related to variant ranking to reduce code duplication
+- [#969](https://github.com/genomic-medicine-sweden/nallo/pull/969) - Split hifiasm process into two so they can have different resources: first only create bins then assembly with the bins already created
 - [#974](https://github.com/genomic-medicine-sweden/nallo/pull/974) - Updated FastQC nf-core module
 - [#975](https://github.com/genomic-medicine-sweden/nallo/pull/975) - Moved params from `nallo.nf` to main workflow
 - [#975](https://github.com/genomic-medicine-sweden/nallo/pull/975) - Renamed `ch_databases` to `ch_echtvar_databases` for clarity

conf/base.config

@@ -50,7 +50,7 @@ process {
     withLabel:process_high_memory {
         memory = { 200.GB * task.attempt }
     }
-    withName: 'HIFIASM' {
+    withName: 'HIFIASM_ASSEMBLY|HIFIASM_BINS' {
         time   = { 36.h  * task.attempt }
     }
     withLabel:error_ignore {

conf/modules/genome_assembly.config

@@ -24,12 +24,13 @@ process {
         ]
     }
 
-    withName: '.*:GENOME_ASSEMBLY:HIFIASM' {
+    withName: '.*:GENOME_ASSEMBLY:HIFIASM_ASSEMBLY|.*:GENOME_ASSEMBLY:HIFIASM_BINS' {
         ext.args = { [
             "${params.extra_hifiasm_options}",
             "${params.hifiasm_preset}",
             '--dual-scaf',
-            '--telo-m CCCTAA'
+            '--telo-m CCCTAA',
+            '--bin-only'
         ].join(' ') }
     }
 

modules.json

@@ -203,7 +203,7 @@
                     },
                     "hifiasm": {
                         "branch": "master",
-                        "git_sha": "b00cfb8947da7842e8f249cc0c5bb8544cfac18e",
+                        "git_sha": "a20dba808c5ce99afe6d40d7fc072c74ca317c8d",
                         "installed_by": ["modules"]
                     },
                     "hificnv": {

subworkflows/local/genome_assembly/main.nf

@@ -1,25 +1,25 @@
-include { CAT_FASTQ } from '../../../modules/nf-core/cat/fastq/main'
-include { HIFIASM   } from '../../../modules/nf-core/hifiasm'
-include { YAK_COUNT } from '../../../modules/nf-core/yak/count/main'
-include { GFASTATS  } from '../../../modules/nf-core/gfastats/main'
+include { CAT_FASTQ                   } from '../../../modules/nf-core/cat/fastq/main'
+include { HIFIASM as HIFIASM_BINS     } from '../../../modules/nf-core/hifiasm'
+include { HIFIASM as HIFIASM_ASSEMBLY } from '../../../modules/nf-core/hifiasm'
+include { YAK_COUNT                   } from '../../../modules/nf-core/yak/count/main'
+include { GFASTATS                    } from '../../../modules/nf-core/gfastats/main'
 
 // This subworkflow assembles and outputs haplotypes from a set of reads (grouped per sample), using hifiasm and gfastats.
 // It assumes that while each sample can have multiple files, each sample belongs to one family at most.
 workflow GENOME_ASSEMBLY {
-
     take:
-    ch_reads     // channel: [ val(meta), fastqs ]
-    trio_binning //    bool: Should we use trio binning mode where possible?
+    ch_reads // channel: [ val(meta), fastqs ]
+    trio_binning // bool: Should we use trio binning mode where possible?
 
     main:
     if (trio_binning) {
         // First, we need to branch the samples based on their relationship
         ch_reads
             .branch { meta, _reads ->
                 def is_parent = meta.relationship in ['father', 'mother']
-                paired_parents             : is_parent && meta.has_other_parent
-                children_with_both_parents : meta.relationship == 'child' && meta.two_parents
-                other                      : true
+                paired_parents: is_parent && meta.has_other_parent
+                children_with_both_parents: meta.relationship == 'child' && meta.two_parents
+                other: true
             }
             .set { ch_branched_samples }
 
@@ -32,85 +32,102 @@ workflow GENOME_ASSEMBLY {
             }
             .set { ch_paired_parents_for_yak }
 
-        CAT_FASTQ (
+        CAT_FASTQ(
             ch_paired_parents_for_yak.cat
         )
 
-        YAK_COUNT (
+        YAK_COUNT(
             CAT_FASTQ.out.reads.concat(ch_paired_parents_for_yak.no_cat)
         )
 
         YAK_COUNT.out.yak
-            // Because a parent can have multiple children, and meta.children is a list of all children,
-            // we need to return one tuple per child.
             .flatMap { meta, yak ->
                 (meta.children ?: []).collect { child_id ->
                     [child_id, meta, yak]
                 }
             }
             .branch { child_id, meta, yak ->
                 paternal: meta.relationship == 'father'
-                    return [ child_id, yak ]
+                return [child_id, yak]
                 maternal: meta.relationship == 'mother'
-                    return [ child_id, yak ]
+                return [child_id, yak]
             }
             .set { ch_yak_output }
 
         // Creates the input for trio-binned assemblies (children with both parents)
         ch_branched_samples.children_with_both_parents
-            .map { meta, reads -> [ meta.id, meta, reads ] }
+            .map { meta, reads -> [meta.id, meta, reads] }
             .join(ch_yak_output.paternal)
             .join(ch_yak_output.maternal)
             .map { _id, meta, reads, yak_paternal, yak_maternal ->
-                [ meta, reads, yak_paternal, yak_maternal ]
+                [meta, reads, yak_paternal, yak_maternal]
             }
             .set { ch_with_both_parents }
 
         // Create the input for hifiasm by combining the non-trio binned samples with the trio-binned samples.
         ch_branched_samples.other
             .concat(ch_branched_samples.paired_parents)
             .map { meta, fastqs ->
-                [ meta, fastqs, [], [] ]
+                [meta, fastqs, [], []]
             }
             .concat(ch_with_both_parents)
             .multiMap { meta, reads, yak_paternal, yak_maternal ->
-                reads : [ meta, reads       , []           ]
-                yak   : [ meta, yak_paternal, yak_maternal ]
+                reads: [meta, reads, []]
+                yak: [meta, yak_paternal, yak_maternal]
             }
             .set { ch_hifiasm_in }
-    } else {
+    }
+    else {
         ch_reads
             .multiMap { meta, reads ->
-                reads : [ meta, reads, [] ]
-                yak   : [ [], [], [] ]
+                reads: [meta, reads, []]
+                yak: [meta, [], []]
             }
             .set { ch_hifiasm_in }
     }
 
-    HIFIASM (
+    HIFIASM_BINS(
         ch_hifiasm_in.reads,
         ch_hifiasm_in.yak,
-        [[],[],[]],
-        [[],[]]
+        [[], [], []],
+        [[], []],
+    )
+
+    // Explicitly key bins/reads/yak by sample ID before assembly so each sample gets its own bins and yaks.
+    ch_hifiasm_in.reads
+        .join(ch_hifiasm_in.yak, failOnMismatch: true, failOnDuplicate: true)
+        .join(HIFIASM_BINS.out.bin_files, failOnMismatch: true, failOnDuplicate: true)
+        .multiMap { meta, reads, ul_reads, yak_paternal, yak_maternal, bin_files ->
+            reads: [meta, reads, ul_reads]
+            bins: [meta, bin_files]
+            yak: [meta, yak_paternal, yak_maternal]
+        }
+        .set { ch_hifiasm_assembly_in }
+
+    HIFIASM_ASSEMBLY(
+        ch_hifiasm_assembly_in.reads,
+        ch_hifiasm_assembly_in.yak,
+        [[], [], []],
+        ch_hifiasm_assembly_in.bins,
     )
 
-    HIFIASM.out.hap1_contigs
-        .map { meta, fasta -> [ meta + [ 'haplotype': 1 ], fasta ] }
+    HIFIASM_ASSEMBLY.out.hap1_contigs
+        .map { meta, fasta -> [meta + ['haplotype': 1], fasta] }
         .set { ch_gfastats_paternal_in }
 
-    HIFIASM.out.hap2_contigs
-        .map { meta, fasta -> [ meta + [ 'haplotype': 2 ], fasta ] }
+    HIFIASM_ASSEMBLY.out.hap2_contigs
+        .map { meta, fasta -> [meta + ['haplotype': 2], fasta] }
         .set { ch_gfastats_maternal_in }
 
     GFASTATS(
         ch_gfastats_paternal_in.mix(ch_gfastats_maternal_in),
         'fasta',
         '',
         '',
-        [[],[]],
-        [[],[]],
-        [[],[]],
-        [[],[]]
+        [[], []],
+        [[], []],
+        [[], []],
+        [[], []],
     )
 
     emit: