Ir para o conteúdo

Parte 3: Chamada conjunta em uma coorte

Tradução assistida por IA - saiba mais e sugira melhorias

Anteriormente, você construiu um pipeline de chamada de variantes por amostra que processou os dados de cada amostra de forma independente. Agora vamos estendê-lo para implementar a chamada conjunta de variantes, conforme descrito na Parte 1 (caso de uso multi-amostra).

Como começar a partir desta seção

Esta seção do curso pressupõe que você completou a Parte 1: Visão Geral do Método, Parte 2: Chamada de variantes por amostra e tem um pipeline genomics.nf funcionando.

Se você não completou a Parte 2 ou quer começar do zero para esta parte, pode usar a solução da Parte 2 como ponto de partida. Execute estes comandos de dentro do diretório nf4-science/genomics/:

cp solutions/part2/genomics-2.nf genomics.nf
cp solutions/part2/nextflow.config .
cp solutions/part2/modules/* modules/

Isso fornece um fluxo de trabalho completo de chamada de variantes por amostra. Você pode testar se ele executa com sucesso executando o seguinte comando:

nextflow run genomics.nf -profile test

Tarefa

Nesta parte do curso, vamos estender o fluxo de trabalho para fazer o seguinte:

  1. Gerar um arquivo de índice para cada arquivo BAM de entrada usando Samtools
  2. Executar o GATK HaplotypeCaller em cada arquivo BAM de entrada para gerar um GVCF de chamadas de variantes genômicas por amostra
  3. Coletar todos os GVCFs e combiná-los em um armazenamento de dados GenomicsDB
  4. Executar genotipagem conjunta no armazenamento de dados GVCF combinado para produzir um VCF em nível de coorte
BAMSamtools indexBAM indexIntervalsReference+ index & dictGATK HaplotypeCallerGVCF + indexx multiple samplesGVCF + indexGVCF + indexGVCF + indexGenomicsDBvariant storeGATK GenomicsDBImportGATK GenotypeGVCFsJoint-calledVCFGVCF mode

Isso implementa o método descrito na Parte 1: Visão Geral do Método (segunda seção cobrindo o caso de uso multi-amostra) e se baseia diretamente no fluxo de trabalho produzido pela Parte 2: Chamada de variantes por amostra.

Plano da lição

Dividimos isso em duas etapas:

  1. Modificar a etapa de chamada de variantes por amostra para produzir um GVCF. Isso abrange a atualização de comandos e saídas do processo.
  2. Adicionar uma etapa de genotipagem conjunta que combina e genotipa os GVCFs por amostra. Isso introduz o operador collect(), closures Groovy para construção de linha de comando e processos com múltiplos comandos.

Isso automatiza as etapas da segunda seção da Parte 1: Visão geral do método, onde você executou esses comandos manualmente em seus contêineres.

Dica

Certifique-se de estar no diretório de trabalho correto: cd /workspaces/training/nf4-science/genomics

1. Modificar a etapa de chamada de variantes por amostra para produzir um GVCF

O pipeline da Parte 2 produz arquivos VCF, mas a chamada conjunta requer arquivos GVCF. Precisamos ativar o modo de chamada de variantes GVCF e atualizar a extensão do arquivo de saída.

Lembre-se do comando de chamada de variantes GVCF da Parte 1:

gatk HaplotypeCaller \
        -R /data/ref/ref.fasta \
        -I /data/bam/reads_mother.bam \
        -O reads_mother.g.vcf \
        -L /data/ref/intervals.bed \
        -ERC GVCF

Comparado ao comando base HaplotypeCaller que encapsulamos na Parte 2, as diferenças são o parâmetro -ERC GVCF e a extensão de saída .g.vcf.

1.1. Informar ao HaplotypeCaller para emitir um GVCF e atualizar a extensão de saída

Abra o arquivo de módulo modules/gatk_haplotypecaller.nf para fazer duas alterações:

  • Adicione o parâmetro -ERC GVCF ao comando GATK HaplotypeCaller;
  • Atualize o caminho do arquivo de saída para usar a extensão .g.vcf correspondente, conforme convenção do GATK.

Certifique-se de adicionar uma barra invertida (\) no final da linha anterior quando adicionar -ERC GVCF.

modules/gatk_haplotypecaller.nf
22
23
24
25
26
27
28
29
    """
    gatk HaplotypeCaller \
        -R ${ref_fasta} \
        -I ${input_bam} \
        -O ${input_bam}.g.vcf \
        -L ${interval_list} \
        -ERC GVCF
    """
modules/gatk_haplotypecaller.nf
22
23
24
25
26
27
28
    """
    gatk HaplotypeCaller \
        -R ${ref_fasta} \
        -I ${input_bam} \
        -O ${input_bam}.vcf \
        -L ${interval_list}
    """

Também precisamos atualizar o bloco de saída para corresponder à nova extensão de arquivo. Como mudamos a saída do comando de .vcf para .g.vcf, o bloco output: do processo deve refletir a mesma mudança.

1.2. Atualizar a extensão do arquivo de saída no bloco de saídas do processo

modules/gatk_haplotypecaller.nf
17
18
19
    output:
    path "${input_bam}.g.vcf"     , emit: vcf
    path "${input_bam}.g.vcf.idx" , emit: idx
modules/gatk_haplotypecaller.nf
17
18
19
    output:
    path "${input_bam}.vcf"     , emit: vcf
    path "${input_bam}.vcf.idx" , emit: idx

Também precisamos atualizar a configuração de publicação e saída do fluxo de trabalho para refletir as novas saídas GVCF.

1.3. Atualizar os alvos de publicação para as novas saídas GVCF

Como agora estamos produzindo GVCFs em vez de VCFs, devemos atualizar a seção publish: do fluxo de trabalho para usar nomes mais descritivos. Também organizaremos os arquivos GVCF em seu próprio subdiretório para maior clareza.

genomics.nf
47
48
49
50
    publish:
    indexed_bam = SAMTOOLS_INDEX.out
    gvcf = GATK_HAPLOTYPECALLER.out.vcf
    gvcf_idx = GATK_HAPLOTYPECALLER.out.idx
genomics.nf
47
48
49
50
    publish:
    indexed_bam = SAMTOOLS_INDEX.out
    vcf = GATK_HAPLOTYPECALLER.out.vcf
    vcf_idx = GATK_HAPLOTYPECALLER.out.idx

Agora atualize o bloco de saída para corresponder.

1.4. Atualizar o bloco de saída para a nova estrutura de diretórios

Também precisamos atualizar o bloco output para colocar os arquivos GVCF em um subdiretório gvcf.

genomics.nf
53
54
55
56
57
58
59
60
61
62
63
output {
    indexed_bam {
        path 'indexed_bam'
    }
    gvcf {
        path 'gvcf'
    }
    gvcf_idx {
        path 'gvcf'
    }
}
genomics.nf
53
54
55
56
57
58
59
60
61
62
63
output {
    indexed_bam {
        path 'bam'
    }
    vcf {
        path 'vcf'
    }
    vcf_idx {
        path 'vcf'
    }
}

Com o módulo, alvos de publicação e bloco de saída todos atualizados, podemos testar as alterações.

1.5. Executar o pipeline

Execute o fluxo de trabalho para verificar se as alterações funcionam.

nextflow run genomics.nf -profile test
Saída do comando 
N E X T F L O W   ~  version 25.10.2

┃ Launching `genomics.nf` [nostalgic_franklin] DSL2 - revision: f2c0a93c6a

executor >  local (6)
[cc/fbc705] SAMTOOLS_INDEX (3)       | 3 of 3 ✔
[27/0d7eb9] GATK_HAPLOTYPECALLER (2) | 3 of 3 ✔

A saída do Nextflow parece a mesma de antes, mas os arquivos .g.vcf e seus arquivos de índice agora estão organizados em subdiretórios.

Conteúdo do diretório (links simbólicos encurtados) 
results/
├── gvcf/
│   ├── reads_father.bam.g.vcf -> */27/0d7eb9*/reads_father.bam.g.vcf
│   ├── reads_father.bam.g.vcf.idx -> */27/0d7eb9*/reads_father.bam.g.vcf.idx
│   ├── reads_mother.bam.g.vcf -> */e4/4ed55e*/reads_mother.bam.g.vcf
│   ├── reads_mother.bam.g.vcf.idx -> */e4/4ed55e*/reads_mother.bam.g.vcf.idx
│   ├── reads_son.bam.g.vcf -> */08/e95962*/reads_son.bam.g.vcf
│   └── reads_son.bam.g.vcf.idx -> */08/e95962*/reads_son.bam.g.vcf.idx
└── indexed_bam/
    ├── reads_father.bam -> */9a/c7a873*/reads_father.bam
    ├── reads_father.bam.bai -> */9a/c7a873*/reads_father.bam.bai
    ├── reads_mother.bam -> */f1/8d8486*/reads_mother.bam
    ├── reads_mother.bam.bai -> */f1/8d8486*/reads_mother.bam.bai
    ├── reads_son.bam -> */cc/fbc705*/reads_son.bam
    └── reads_son.bam.bai -> */cc/fbc705*/reads_son.bam.bai

Se você abrir um dos arquivos GVCF e percorrê-lo, poderá verificar que o GATK HaplotypeCaller produziu arquivos GVCF conforme solicitado.

Conclusão

Quando você altera o nome do arquivo de saída de um comando de ferramenta, o bloco output: do processo e a configuração de publicação/saída devem ser atualizados para corresponder.

O que vem a seguir?

Aprenda a coletar o conteúdo de um canal e passá-los para o próximo processo como uma única entrada.

2. Adicionar uma etapa de genotipagem conjunta

Agora precisamos coletar os GVCFs por amostra, combiná-los em um armazenamento de dados GenomicsDB e executar a genotipagem conjunta para produzir um VCF em nível de coorte. Conforme abordado na Parte 1, esta é uma operação de duas ferramentas: GenomicsDBImport combina os GVCFs, depois GenotypeGVCFs produz as chamadas de variantes finais. Vamos encapsular ambas as ferramentas em um único processo chamado GATK_JOINTGENOTYPING.

Lembre-se dos dois comandos da Parte 1:

gatk GenomicsDBImport \
    -V reads_mother.g.vcf \
    -V reads_father.g.vcf \
    -V reads_son.g.vcf \
    -L /data/ref/intervals.bed \
    --genomicsdb-workspace-path family_trio_gdb

gatk GenotypeGVCFs \
    -R /data/ref/ref.fasta \
    -V gendb://family_trio_gdb \
    -O family_trio.vcf

O primeiro comando recebe os GVCFs por amostra e um arquivo de intervalos, e produz um armazenamento de dados GenomicsDB. O segundo recebe esse armazenamento de dados, um genoma de referência, e produz o VCF final em nível de coorte. O URI do contêiner é o mesmo do HaplotypeCaller: community.wave.seqera.io/library/gatk4:4.5.0.0--730ee8817e436867.

2.1. Configurar as entradas

O processo de genotipagem conjunta precisa de dois tipos de entradas que ainda não temos: um nome de coorte arbitrário e as saídas GVCF coletadas de todas as amostras agrupadas.

2.1.1. Adicionar um parâmetro cohort_name

Precisamos fornecer um nome arbitrário para a coorte. Mais adiante na série de treinamento você aprenderá como usar metadados de amostra para esse tipo de coisa, mas por enquanto apenas declaramos um parâmetro CLI usando params.

genomics.nf
18
19
20
21
22
    intervals: Path

    // Nome base para o arquivo de saída final
    cohort_name: String
}
genomics.nf
18
19
    intervals: Path
}

Usaremos este parâmetro para nomear o arquivo de saída final.

2.1.2. Adicionar um valor padrão para cohort_name no perfil de teste

Também adicionamos um valor padrão para o parâmetro cohort_name no perfil de teste:

nextflow.config
 4
 5
 6
 7
 8
 9
10
11
test {
    params.input = "${projectDir}/data/samplesheet.csv"
    params.reference = "${projectDir}/data/ref/ref.fasta"
    params.reference_index = "${projectDir}/data/ref/ref.fasta.fai"
    params.reference_dict = "${projectDir}/data/ref/ref.dict"
    params.intervals = "${projectDir}/data/ref/intervals.bed"
    params.cohort_name = "family_trio"
}
nextflow.config
 4
 5
 6
 7
 8
 9
10
test {
    params.input = "${projectDir}/data/samplesheet.csv"
    params.reference = "${projectDir}/data/ref/ref.fasta"
    params.reference_index = "${projectDir}/data/ref/ref.fasta.fai"
    params.reference_dict = "${projectDir}/data/ref/ref.dict"
    params.intervals = "${projectDir}/data/ref/intervals.bed"
}

Em seguida, precisaremos reunir as saídas por amostra para que possam ser processadas juntas.

2.1.3. Reunir as saídas do HaplotypeCaller entre as amostras

Se conectássemos o canal de saída de GATK_HAPLOTYPECALLER diretamente no novo processo, o Nextflow chamaria o processo em cada GVCF de amostra separadamente. Queremos agrupar todos os três GVCFs (e seus arquivos de índice) para que o Nextflow os entregue todos juntos a uma única chamada de processo.

Podemos fazer isso usando o operador de canal collect(). Adicione as seguintes linhas ao corpo do workflow, logo após a chamada a GATK_HAPLOTYPECALLER:

genomics.nf
48
49
50
51
52
53
        intervals_file
    )

    // Coletar saídas de chamada de variantes entre amostras
    all_gvcfs_ch = GATK_HAPLOTYPECALLER.out.vcf.collect()
    all_idxs_ch = GATK_HAPLOTYPECALLER.out.idx.collect()
genomics.nf
48
49
        intervals_file
    )

Detalhando isso:

  1. Pegamos o canal de saída de GATK_HAPLOTYPECALLER usando a propriedade .out.
  2. Como nomeamos as saídas usando emit: na seção 1, podemos selecionar os GVCFs com .vcf e os arquivos de índice com .idx. Sem saídas nomeadas, teríamos que usar .out[0] e .out[1].
  3. O operador collect() agrupa todos os arquivos em um único elemento, então all_gvcfs_ch contém todos os três GVCFs juntos, e all_idxs_ch contém todos os três arquivos de índice juntos.

Podemos coletar os GVCFs e seus arquivos de índice separadamente (em vez de mantê-los juntos em tuplas) porque o Nextflow preparará todos os arquivos de entrada juntos para execução, então os arquivos de índice estarão presentes ao lado dos GVCFs.

Dica

Você pode usar o operador view() para inspecionar o conteúdo dos canais antes e depois de aplicar operadores de canal.

2.2. Escrever o processo de genotipagem conjunta e chamá-lo no fluxo de trabalho

Seguindo o mesmo padrão que usamos na Parte 2, escreveremos a definição do processo em um arquivo de módulo, o importaremos no fluxo de trabalho e o chamaremos nas entradas que acabamos de preparar.

2.2.1. Construir uma string para dar a cada GVCF um argumento -V

Antes de começarmos a preencher a definição do processo, há uma coisa a resolver. O comando GenomicsDBImport espera um argumento -V separado para cada arquivo GVCF, assim:

gatk GenomicsDBImport \
    -V reads_mother.bam.g.vcf \
    -V reads_father.bam.g.vcf \
    -V reads_son.bam.g.vcf \
    ...

Se escrevêssemos -V ${all_gvcfs_ch}, o Nextflow simplesmente concatenaria os nomes de arquivo e essa parte do comando ficaria assim:

-V reads_mother.bam.g.vcf reads_father.bam.g.vcf reads_son.bam.g.vcf

Mas precisamos que a string fique assim:

-V reads_mother.bam.g.vcf -V reads_father.bam.g.vcf -V reads_son.bam.g.vcf

Importante, precisamos construir essa string dinamicamente a partir de quaisquer arquivos que estejam no canal coletado. O Nextflow (via Groovy) fornece uma maneira concisa de fazer isso:

def gvcfs_line = all_gvcfs.collect { gvcf -> "-V ${gvcf}" }.join(' ')

Detalhando isso:

  1. all_gvcfs.collect { gvcf -> "-V ${gvcf}" } itera sobre cada caminho de arquivo e adiciona -V antes dele, produzindo ["-V A.g.vcf", "-V B.g.vcf", "-V C.g.vcf"].
  2. .join(' ') os concatena com espaços: "-V A.g.vcf -V B.g.vcf -V C.g.vcf".
  3. O resultado é atribuído a uma variável local gvcfs_line (definida com def), que podemos interpolar no template de comando.

Esta linha vai dentro do bloco script: do processo, antes do template de comando. Você pode colocar código Groovy arbitrário entre script: e as aspas triplas de abertura """ do template de comando.

Então você poderá se referir a toda essa string como gvcfs_line no bloco script: do processo.

2.2.2. Preencher o módulo para o processo de genotipagem conjunta

Em seguida, podemos abordar a escrita do processo completo.

Abra modules/gatk_jointgenotyping.nf e examine o esboço da definição do processo.

Vá em frente e preencha a definição do processo usando as informações fornecidas acima, depois verifique seu trabalho contra a solução na aba "Depois" abaixo.

modules/gatk_jointgenotyping.nf
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
#!/usr/bin/env nextflow

/*
 * Combinar GVCFs em armazenamento de dados GenomicsDB e executar genotipagem conjunta para produzir chamadas em nível de coorte
 */
process GATK_JOINTGENOTYPING {

    container

    input:

    output:

    script:
    """

    """
}
modules/gatk_jointgenotyping.nf
 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
#!/usr/bin/env nextflow

/*
 * Combinar GVCFs em armazenamento de dados GenomicsDB e executar genotipagem conjunta para produzir chamadas em nível de coorte
 */
process GATK_JOINTGENOTYPING {

    container "community.wave.seqera.io/library/gatk4:4.5.0.0--730ee8817e436867"

    input:
    path all_gvcfs
    path all_idxs
    path interval_list
    val cohort_name
    path ref_fasta
    path ref_index
    path ref_dict

    output:
    path "${cohort_name}.joint.vcf"     , emit: vcf
    path "${cohort_name}.joint.vcf.idx" , emit: idx

    script:
    def gvcfs_line = all_gvcfs.collect { gvcf -> "-V ${gvcf}" }.join(' ')
    """
    gatk GenomicsDBImport \
        ${gvcfs_line} \
        -L ${interval_list} \
        --genomicsdb-workspace-path ${cohort_name}_gdb

    gatk GenotypeGVCFs \
        -R ${ref_fasta} \
        -V gendb://${cohort_name}_gdb \
        -L ${interval_list} \
        -O ${cohort_name}.joint.vcf
    """
}

Há várias coisas que vale a pena destacar aqui.

Como anteriormente, várias entradas são listadas mesmo que os comandos não as referenciem diretamente: all_idxs, ref_index e ref_dict. Listá-las garante que o Nextflow prepare esses arquivos no diretório de trabalho ao lado dos arquivos que aparecem nos comandos, que o GATK espera encontrar com base em convenções de nomenclatura.

A variável gvcfs_line usa a closure Groovy descrita acima para construir os argumentos -V para GenomicsDBImport.

Este processo executa dois comandos em série, assim como você faria no terminal. GenomicsDBImport combina os GVCFs por amostra em um armazenamento de dados, depois GenotypeGVCFs lê esse armazenamento de dados e produz o VCF final em nível de coorte. O armazenamento de dados GenomicsDB (${cohort_name}_gdb) é um artefato intermediário usado apenas dentro do processo; ele não aparece no bloco de saída.

Uma vez que você tenha completado isso, o processo está pronto para uso. Para usá-lo no fluxo de trabalho, você precisará importar o módulo e adicionar uma chamada de processo.

2.2.3. Importar o módulo

Adicione a instrução de importação a genomics.nf, abaixo das instruções de importação existentes:

genomics.nf
3
4
5
6
// Instruções INCLUDE de módulos
include { SAMTOOLS_INDEX } from './modules/samtools_index.nf'
include { GATK_HAPLOTYPECALLER } from './modules/gatk_haplotypecaller.nf'
include { GATK_JOINTGENOTYPING } from './modules/gatk_jointgenotyping.nf'
genomics.nf
3
4
5
// Instruções INCLUDE de módulos
include { SAMTOOLS_INDEX } from './modules/samtools_index.nf'
include { GATK_HAPLOTYPECALLER } from './modules/gatk_haplotypecaller.nf'

O processo agora está disponível no escopo do fluxo de trabalho.

2.2.4. Adicionar a chamada do processo

Adicione a chamada a GATK_JOINTGENOTYPING no corpo do fluxo de trabalho, após as linhas collect():

genomics.nf
53
54
55
56
57
58
59
60
61
62
63
64
    all_idxs_ch = GATK_HAPLOTYPECALLER.out.idx.collect()

    // Combinar GVCFs em um armazenamento de dados GenomicsDB e aplicar genotipagem conjunta
    GATK_JOINTGENOTYPING(
        all_gvcfs_ch,
        all_idxs_ch,
        intervals_file,
        params.cohort_name,
        ref_file,
        ref_index_file,
        ref_dict_file
    )
genomics.nf
53
    all_idxs_ch = GATK_HAPLOTYPECALLER.out.idx.collect()

O processo agora está totalmente conectado. Em seguida, configuramos como as saídas são publicadas.

2.3. Configurar o tratamento de saídas

Precisamos publicar as saídas do VCF conjunto. Adicione alvos de publicação e entradas de bloco de saída para os resultados de genotipagem conjunta.

2.3.1. Adicionar alvos de publicação para o VCF conjunto

Adicione o VCF conjunto e seu índice à seção publish: do fluxo de trabalho:

genomics.nf
66
67
68
69
70
71
    publish:
    indexed_bam = SAMTOOLS_INDEX.out
    gvcf = GATK_HAPLOTYPECALLER.out.vcf
    gvcf_idx = GATK_HAPLOTYPECALLER.out.idx
    joint_vcf = GATK_JOINTGENOTYPING.out.vcf
    joint_vcf_idx = GATK_JOINTGENOTYPING.out.idx
genomics.nf
66
67
68
69
    publish:
    indexed_bam = SAMTOOLS_INDEX.out
    gvcf = GATK_HAPLOTYPECALLER.out.vcf
    gvcf_idx = GATK_HAPLOTYPECALLER.out.idx

Agora atualize o bloco de saída para corresponder.

2.3.2. Adicionar entradas de bloco de saída para o VCF conjunto

Adicione entradas para os arquivos VCF conjunto. Vamos colocá-los na raiz do diretório de resultados, já que esta é a saída final.

genomics.nf
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
output {
    indexed_bam {
        path 'indexed_bam'
    }
    gvcf {
        path 'gvcf'
    }
    gvcf_idx {
        path 'gvcf'
    }
    joint_vcf {
        path '.'
    }
    joint_vcf_idx {
        path '.'
    }
}
genomics.nf
74
75
76
77
78
79
80
81
82
83
84
output {
    indexed_bam {
        path 'indexed_bam'
    }
    gvcf {
        path 'gvcf'
    }
    gvcf_idx {
        path 'gvcf'
    }
}

Com o processo, alvos de publicação e bloco de saída todos no lugar, podemos testar o fluxo de trabalho completo.

2.4. Executar o fluxo de trabalho

Execute o fluxo de trabalho para verificar se tudo funciona.

nextflow run genomics.nf -profile test -resume
Saída do comando 
N E X T F L O W   ~  version 25.10.2

┃ Launching `genomics.nf` [crazy_marconi] DSL2 - revision: 5da9afc841

executor >  local (1)
[9a/c7a873] SAMTOOLS_INDEX (2)       | 3 of 3, cached: 3 ✔
[e4/4ed55e] GATK_HAPLOTYPECALLER (2) | 3 of 3, cached: 3 ✔
[a6/7cc8ed] GATK_JOINTGENOTYPING     | 1 of 1 ✔

As duas primeiras etapas estão em cache da execução anterior, e a nova etapa GATK_JOINTGENOTYPING é executada uma vez nas entradas coletadas de todas as três amostras. O arquivo de saída final, family_trio.joint.vcf (e seu índice), está no diretório de resultados.

Conteúdo do diretório (links simbólicos encurtados) 
results/
├── family_trio.joint.vcf -> */a6/7cc8ed*/family_trio.joint.vcf
├── family_trio.joint.vcf.idx -> */a6/7cc8ed*/family_trio.joint.vcf.idx
├── gvcf/
│   ├── reads_father.bam.g.vcf -> */27/0d7eb9*/reads_father.bam.g.vcf
│   ├── reads_father.bam.g.vcf.idx -> */27/0d7eb9*/reads_father.bam.g.vcf.idx
│   ├── reads_mother.bam.g.vcf -> */e4/4ed55e*/reads_mother.bam.g.vcf
│   ├── reads_mother.bam.g.vcf.idx -> */e4/4ed55e*/reads_mother.bam.g.vcf.idx
│   ├── reads_son.bam.g.vcf -> */08/e95962*/reads_son.bam.g.vcf
│   └── reads_son.bam.g.vcf.idx -> */08/e95962*/reads_son.bam.g.vcf.idx
└── indexed_bam/
    ├── reads_father.bam -> */9a/c7a873*/reads_father.bam
    ├── reads_father.bam.bai -> */9a/c7a873*/reads_father.bam.bai
    ├── reads_mother.bam -> */f1/8d8486*/reads_mother.bam
    ├── reads_mother.bam.bai -> */f1/8d8486*/reads_mother.bam.bai
    ├── reads_son.bam -> */cc/fbc705*/reads_son.bam
    └── reads_son.bam.bai -> */cc/fbc705*/reads_son.bam.bai

Se você abrir o arquivo VCF conjunto, poderá verificar que o fluxo de trabalho produziu as chamadas de variantes esperadas.

family_trio.joint.vcf
40
41
42
43
#CHROM	POS	ID	REF	ALT	QUAL	FILTER	INFO	FORMAT	reads_father	reads_mother	reads_son
20_10037292_10066351	3480	.	C	CT	1625.89	.	AC=5;AF=0.833;AN=6;BaseQRankSum=0.220;DP=85;ExcessHet=0.0000;FS=2.476;MLEAC=5;MLEAF=0.833;MQ=60.00;MQRankSum=0.00;QD=21.68;ReadPosRankSum=-1.147e+00;SOR=0.487	GT:AD:DP:GQ:PL	0/1:15,16:31:99:367,0,375	1/1:0,18:18:54:517,54,0	1/1:0,26:26:78:756,78,0
20_10037292_10066351	3520	.	AT	A	1678.89	.	AC=5;AF=0.833;AN=6;BaseQRankSum=1.03;DP=80;ExcessHet=0.0000;FS=2.290;MLEAC=5;MLEAF=0.833;MQ=60.00;MQRankSum=0.00;QD=22.39;ReadPosRankSum=0.701;SOR=0.730	GT:AD:DP:GQ:PL	0/1:18,13:31:99:296,0,424	1/1:0,18:18:54:623,54,0	1/1:0,26:26:78:774,78,0
20_10037292_10066351	3529	.	T	A	154.29	.	AC=1;AF=0.167;AN=6;BaseQRankSum=-5.440e-01;DP=104;ExcessHet=0.0000;FS=1.871;MLEAC=1;MLEAF=0.167;MQ=60.00;MQRankSum=0.00;QD=7.71;ReadPosRankSum=-1.158e+00;SOR=1.034	GT:AD:DP:GQ:PL	0/0:44,0:44:99:0,112,1347	0/1:12,8:20:99:163,0,328	0/0:39,0:39:99:0,105,1194

Você agora tem um fluxo de trabalho de chamada conjunta de variantes automatizado e totalmente reproduzível!

Nota

Tenha em mente que os arquivos de dados que fornecemos cobrem apenas uma pequena porção do cromossomo 20. O tamanho real de um conjunto de chamadas de variantes seria contado em milhões de variantes. É por isso que usamos apenas pequenos subconjuntos de dados para fins de treinamento!

Conclusão

Você sabe como coletar saídas de um canal e agrupá-las como uma única entrada para outro processo. Você também sabe como construir uma linha de comando usando closures Groovy e como executar múltiplos comandos em um único processo.

O que vem a seguir?

Dê um grande tapinha nas costas! Você completou o curso Nextflow para Genômica.

Vá para o resumo final do curso para revisar o que você aprendeu e descobrir o que vem a seguir.