ClInt/assembly.nf at main · Integrative-Transcriptomics/ClInt · 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
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
nextflow.enable.dsl=2

include { MAPPING as REMAPPING } from './mapping.nf'

process TRINITY_DENOVO {
    label 'assembly'
    input:
        path reads
    output:
        path "Trinity*.fasta"

    script:
    """
    echo "Working on ${reads}"
    Trinity \
    --seqType fq \
    --max_memory 10G \
    --single ${reads} \
    --CPU ${task.cpus} \
    --output \$PWD/trinity/

    #--left ${reads} --right ${reads} # If paired-ends
    mv trinity/Trinity.fasta TrinityDeNovo_${sorted_aligned_bam}.fasta
    """

    stub:
    """
    touch TrinityDeNovo_${sorted_aligned_bam}.fasta
    """
}

process TRINITY_GUIDED {
    label 'assembly'
    input:
        path sorted_aligned_bam

    output:
        path "Trinity-GG_${sorted_aligned_bam}.fasta"
        // path "*Trinity-GG*.fasta"


    script:
    def max_intron = 10000
    """
    ls -lah
    Trinity \
    --genome_guided_bam \$PWD/$sorted_aligned_bam \
    --genome_guided_max_intron ${max_intron} \
    --max_memory 40G \
    --CPU ${task.cpus} \
    --output \$PWD/trinity/

    mv trinity/Trinity-GG.fasta Trinity-GG_${sorted_aligned_bam}.fasta
    """

    stub:
    """
    touch Trinity-GG_${sorted_aligned_bam}.fasta
    """
}

process RNASpades {
    label 'assembly'
    input:
        path reads

    output:
        path "rnaspades_${reads.baseName}.fasta"

    script:
    """
    spades.py --rna -t ${task.cpus} -s ${reads} -o spades_out
    mv spades_out/transcripts.fasta rnaspades_${reads.baseName}.fasta
    """

    stub:
    """
    touch rnaspades_${reads.baseName}.fasta
    """
}


workflow ASSEMBLY {
    take:
        reads
        bam_files
        ref
    main:
        // Check each element of the assembly array, and run the appropriate assembly processes
        // (e.g. Trinity, RNASpades, etc.)
        // FIXME: Find a way to avoid needing to initialise empty channels & concat/mix them later
        //        as well as maybe a way to simplify the code

        // Initialising channels to empty files
        transcripts_fasta = Channel.empty()
        denovo = Channel.empty()
        guided = Channel.empty()
        spades = Channel.empty()

        // Note If adding any methods here, make sure to add them to publishDir as well in `variant_calling.nf`

        params.assembly.each { method ->
            method = method.toLowerCase()

            if ("${method}" == "trinity") {
                trinity_mode = params.trinity_type.toLowerCase()
                if ("${trinity_mode}" == "denovo") {
                    denovo = TRINITY_DENOVO(reads)
                } else if ("${trinity_mode}" == "guided") {
                    guided = TRINITY_GUIDED(bam_files)
                } else {
                    error "ERROR: Assembly method not recognised"
                }
            } else if ("${method}" == "rnaspades") {
                spades = RNASpades(reads)
            } else {
                error "ERROR: Assembly method \"${method}\" not recognised"
            }
        }
        // Only accept fasta files
        REMAPPING(ref, transcripts_fasta.mix(guided,spades,denovo))
        bams = REMAPPING.out
    emit:
        bams
}