longraredisease/subworkflows/local/snv.nf at 0aabbab2a312e4db0e6438a3ff8c6f2d5b69adc1 · nourmahfel/longraredisease · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
// This workflow is for clair3

include {
    CLAIR3
} from '../../modules/nf-core/clair3/main.nf'
include {
    CLAIR3_FIX
} from '../../modules/local/clair3_fixVCF/main'
include {
    DEEPVARIANT_RUNDEEPVARIANT
} from '../../modules/nf-core/deepvariant/rundeepvariant/main.nf'
include {
    BCFTOOLS_VIEW as BCFTOOLS_FILTER_CLAIR3
} from '../../modules/nf-core/bcftools/view/main.nf'
include {
    BCFTOOLS_VIEW as BCFTOOLS_FILTER_DEEPVARIANT
} from '../../modules/nf-core/bcftools/view/main.nf'

workflow snv_subworkflow {
    take:
    ch_input_clair3         // channel: tuple(val(meta), path(bam), path(bai), val(packaged_model), path(user_model), val(platform))
    fasta                   // channel: tuple(val(meta2), path(fasta))
    fai                     // channel: tuple(val(meta3), path(fai)) - optional
    deepvariant             // boolean, if true, will run deepvariant on the input bam file
    ch_input_deepvariant    // channel: [meta, bam, bai]
    filter_pass_snv         // boolean, if true, will filter for PASS variants

    main:
    ch_versions = Channel.empty()

    // Run CLAIR3 - now with correct input structure
    CLAIR3(
        ch_input_clair3,    // tuple(meta, bam, bai, packaged_model, user_model, platform)
        fasta,              // tuple(meta2, fasta)
        fai                 // tuple(meta3, fai)
    )

    // Fix CLAIR3 VCF
    CLAIR3_FIX(
        CLAIR3.out.vcf,     // path to VCF file
        CLAIR3.out.tbi      // path to TBI file
    )

    // Collect versions
    ch_versions = ch_versions.mix(CLAIR3.out.versions)
    ch_versions = ch_versions.mix(CLAIR3_FIX.out.versions)

    // Handle CLAIR3 filtering
    if (filter_pass_snv) {
        ch_clair3_vcf = CLAIR3_FIX.out.vcf
            .join(CLAIR3_FIX.out.tbi, by: 0)
        BCFTOOLS_FILTER_CLAIR3(
            ch_clair3_vcf,      // tuple(meta, vcf, tbi)
            Channel.value([]),  // empty channel for samples
            Channel.value([]),  // empty channel for regions
            Channel.value([])   // empty channel for filters
        )
        ch_final_clair3_vcf = BCFTOOLS_FILTER_CLAIR3.out.vcf
        ch_final_clair3_tbi = BCFTOOLS_FILTER_CLAIR3.out.tbi
        ch_versions = ch_versions.mix(BCFTOOLS_FILTER_CLAIR3.out.versions)
    } else {
        ch_final_clair3_vcf = CLAIR3_FIX.out.vcf
        ch_final_clair3_tbi = CLAIR3_FIX.out.tbi
    }

    // Handle DeepVariant
    if (deepvariant) {
        DEEPVARIANT_RUNDEEPVARIANT(
            ch_input_deepvariant,
            fasta,
            fai,
            [[:], []],
            [[:], []]
        )
        ch_versions = ch_versions.mix(DEEPVARIANT_RUNDEEPVARIANT.out.versions)

        if (filter_pass_snv) {
            ch_deepvariant_vcf = DEEPVARIANT_RUNDEEPVARIANT.out.vcf
                .join(DEEPVARIANT_RUNDEEPVARIANT.out.vcf_index, by: 0)  // Fixed from vcf_tbi
            BCFTOOLS_FILTER_DEEPVARIANT(
                ch_deepvariant_vcf,
                Channel.value([]),
                Channel.value([]),
                Channel.value([])
            )
            ch_final_deepvariant_vcf = BCFTOOLS_FILTER_DEEPVARIANT.out.vcf
            ch_final_deepvariant_tbi = BCFTOOLS_FILTER_DEEPVARIANT.out.tbi
            ch_versions = ch_versions.mix(BCFTOOLS_FILTER_DEEPVARIANT.out.versions)
        } else {
            ch_final_deepvariant_vcf = DEEPVARIANT_RUNDEEPVARIANT.out.vcf
            ch_final_deepvariant_tbi = DEEPVARIANT_RUNDEEPVARIANT.out.vcf_index  // Fixed from vcf_tbi
        }
    } else {
        // Create empty channels when DeepVariant is not run
        ch_final_deepvariant_vcf = Channel.empty()
        ch_final_deepvariant_tbi = Channel.empty()
    }

    emit:
    clair3_vcf = ch_final_clair3_vcf          // Filtered or unfiltered based on filter_pass
    clair3_tbi = ch_final_clair3_tbi          // Corresponding index
    clair3_phased_vcf = CLAIR3.out.phased_vcf // Optional phased VCF
    clair3_phased_tbi = CLAIR3.out.phased_tbi // Optional phased TBI
    clair3_gvcf = CLAIR3.out.gvcf             // Optional GVCF
    clair3_gtbi = CLAIR3.out.gtbi             // Optional GVCF index
    deepvariant_vcf = ch_final_deepvariant_vcf // Filtered or unfiltered DeepVariant VCF
    deepvariant_tbi = ch_final_deepvariant_tbi // Corresponding index
    versions = ch_versions
}