---
# System prepended metadata

title: Programas para análise de variantes

---

Programas para análise de variantes
====

# Dowloading Data
Para fazer download de dados para teste podemos utilizar de bancos de dados genomicos ou de sequenciamento. 

- SRA Toolkit
Para fazer download por essa ferramenta basta utilizar o comando abaixo:
```
fastq-dump ID_SRA
```
 
 
::: success
Para este teste utilizei o conjunto de WES: **SRR1517848**. 
Disponível através da busca de uma amostra padrão de exoma: [Sample NA12878](https://www.internationalgenome.org/data-portal/sample/NA12878)
:::



# FastQC

- Instalação
A 'instalação' do fastQC consiste em apenas descompactar o conteúdo do programa e executa-lo por linha de comando a partir da localização do arquivo `FastQC/fastqc`

- Executando
É possível executar o FastQC em um dos dois modos, como um aplicativo gráfico interativo, no qual você pode carregar dinamicamente os arquivos do FastQ e visualizar seus resultados. 

É possível executar o FastQC  por linha de comando, onde você especifica os arquivos que deseja processar na linha de comandos e o FastQC gera um relatório HTML para cada arquivo sem iniciar uma interface com o usuário. Isso permite que o FastQC seja executado como parte de um pipeline de análise.

Para utilizar o arquivo do fastqc é necessário dar permissão de arquivo executável:

```Bash
# but once you have done that you can run it directly
chmod 755 fastqc
./fastqc
```
Os Resultados das analises do FastQC é gerado em HTML.
:::info

É possivel fazer o link do arquivo fastqc na pasta bin e utiliza-lo de forma direta.
:::




# MultiQC


O MultiQC é um 'agrupador' de informações de qualidade de sequenciamento, ele utiliza dos resultados gerados pelo FastQC para reunir as estatisticas de diferentes arquivos de reads em uma única visualização.

- Instalação Rapida

``` bash
pip3 install multiqc
multiqc --version
```

- Instalação manual
``` bash
wget https://files.pythonhosted.org/packages/d3/4b/1cf18ef697e5daa72dfa55d496167354e6ec7d78e87c696a52f338c2dc63/multiqc-1.8.tar.g

tar -zxvf multiqc-1.8.tar.gz

cd multiqc-1.8

python3 setup.py install

#Checando instalação: 
multiqc --version
```

- Execução
Você pode executar o programa na pasta que contenha os "reports" do Fastqc e ele já le fará um ouutput HTML.
```
multiqc .
```


# Cutadpt
O Cutadapt localiza e remove seqüências de adaptadores, primers, caudas poli-A e outros tipos de sequência indesejada de suas leituras de sequenciamento.
:::warning
Importante ressaltar que a trimmagem dos dados se faz MUITO necessária para dados oriuando de sequenciamento paired-end (Forward e Reversa) uma vez que cada arquivo de sequenciamento pode ter numeros de linhas diferentes entre si e isso pode afetar sua analise
:::

- Instalação
```
sudo apt install cutadapt
```

- Quality Trimming
O parâmetro `-q`(ou `--quality-cutoff`) pode ser usado para trimmar extremidades de baixa qualidade das leituras. Se você especificar um único valor de corte, o final de 3 'de cada leitura será cortado:

```
cutadapt -q 10 -o output.fastq input.fastq
```
Para as leituras da Illumina, isso é suficiente, pois sua qualidade é alta no início, mas diminui no final dos 3 '.

Também é possível também cortar a partir da extremidade 5 ', especificando dois pontos de corte separados por vírgula como ponto de corte 5' e ponto de corte 3 ' . Por exemplo,

```
cutadapt -q 15,10 -o output.fastq input.fastq
```
cortará com qualidade a extremidade 5 'com um ponto de corte de 15 e a extremidade 3' com um ponto de corte de 10. Para aparar apenas a extremidade 5 ', use um ponto de corte de 0 para a extremidade 3', como em `-q 15,0`
:::info
Atualização
```
sudo python3 -m pip install --upgrade cutadapt
```
:::

# BWA (Burrows-Wheeler Aligner)
O BWA é um pacote de software para mapear seqüências pouco divergentes em relação a um genoma de referência grande, como o genoma humano. É composto por três algoritmos: BWA-backtrack, BWA-SW e **BWA-MEM**. O primeiro algoritmo foi projetado para leituras de sequência Illumina de até 100 pb, enquanto o restante dois para seqüências mais longas variaram de 70 pb a 1Mbp. O BWA-MEM e o BWA-SW compartilham recursos semelhantes, como suporte para leitura longa e alinhamento de divisão, mas o BWA-MEM, que é o mais recente, geralmente é recomendado para consultas de alta qualidade, pois é mais rápido e preciso. O BWA-MEM também tem melhor desempenho que o BWA-backtrack para leituras Illumina de 70 a 100 pb.

- Instalação
Fazer download do programa pela página oficial do [BWA](http://bio-bwa.sourceforge.net/)
```
 tar -xvf bwa.tar.bz2   
 cd bwa
 makefile 
```

- Executando
A execução é por linha de comando através do terminal.
```
 cd bwa
 ./ bwa
```



## Indexação da referência
A Indexação do genoma de referência é feita para facilitar o processo de alinhamento e mapeamento de reads.

:::info
**Linha de comando para indexar uma referência em formato fasta (Genoma)**

```bash 
#Modelo:
bwa index -p [OutputName] -a [algoritmo] <Referencia.fasta>

#Na prática
bwa index -p GRCh37_latest_genomic -a bwtsw GRCh37_latest_genomic.fna.gz
```
:::

Parâmetros
`-p [Nome]`, Nome do output da indexação da referência

`-a [sigla do algoritmo]`, Algoritmo que deseja-se utilizar para fazer indexação. os Disponíveis são:
- **`is`**:	IS linear-time algorithm for constructing suffix array. It requires 5.37N memory where N is the size of the database. IS is moderately fast, but does not work with database larger than 2GB. IS is the default algorithm due to its simplicity. The current codes for IS algorithm are reimplemented by Yuta Mori.

- **`bwtsw`**	Algorithm implemented in BWT-SW. This method works with the whole human genome.



## Alinhamento/Mapeamento
O Alinhamento dos reads sobre uma referência serve para identificar em qual posição do genoma cada read pertence. Literalemente alinhar cada sequencia e encontrar em qual pedaço do genoma ela está presente.

:::info
**Alinhamento/Mapeamento em paired end reads**

```bash 
#Modelo:
bwa aln [...] <referencia.fasta>\
<Reads.fq> > <Reads.aln.sai>

#Na prática:

#Forward
bwa aln GRCh38.indexBwa ERR050115/ERR050115_1.fastq.gz > ERR050115_1.sai
#Reverse
bwa aln GRCh38.indexBwa ERR050115/ERR050115_2.fastq.gz > ERR050115_2.sai
```
:::

No `#Modelo` o conjunto _[...]_ representa diferentes parametros que podem ser setados como número de thread e outros, todos identificados no [manual do BWA](http://bio-bwa.sourceforge.net/bwa.shtml)

O Primeiro comando faz o alinhamento do read em formato BWA. O comando `sampe` utiliza o output.sai, suffix array indexes, para gerar o alinhamento em formato SAM.


:::info
**Gerando arquivo em formato SAM**

```bash 
#Modelo:
bwa sampe [...] <in.db.fasta> \
<in1.sai> <in2.sai> \
<in1.fq> <in2.fq> > <out.sam>

#Na prática:
bwa sampe GRCh37_latest_genomic.fna.gz \
SRR1517848_1.sai SRR1517848_2.sai \
SRR1517848_1.fastq SRR1517848_2.fastq > SRR1517848_12.sam
```
:::



# SamTools
O formato SAM (Sequence Alignment / Map) é um formato genérico para armazenar grandes alinhamentos de sequências de nucleotídeos. O formato SAM possui as seguintes colunas de informações: 

![samformat](https://i.imgur.com/6WKIsBc.png)


Para fazer algo significativo com os dados de alinhamento do BWA ou de outros alinhadores (que produzem saída SAM com base em texto), precisamos primeiro converter o SAM em sua contraparte binária, formato BAM. O formato binário é muito mais fácil para os programas de computador trabalharem. 


## Samtool View
Para converter SAM em BAM, usamos o comando samtools `view`.O Samtools segue a convenção do UNIX de enviar sua saída para o UNIX STDOUT, portanto, precisamos usar um operador de redirecionamento (">") para criar um arquivo BAM a partir da saída.

Alguns cuidados quanto a essa conversão devem ser tomados:

- **Unmapped reads:** Alguns reads podem não ser mapeados na referência, esses rades devem ser filtrados com base no número que é encontrado na coluna 'FLAG' do arquivo SAM. Sendo assim os parametros de alinhamento podem mudar de acordo com o output que se deseja: com ou sem reads não mapeados. 

O status de mapeamento do reads é exposto utilizando a seguinte tabela de valores em _bit binários_: 

![](https://i.imgur.com/IpJWBZx.png)



:::info
**Convertendo SAM em BAM com _Samtools view_**

```bash 
#Modelo:
samtools view -b sample.sam > sample.bam

#Na prática:
samtools view -hbF 4 SRR1517848_12.sam >SRR1517848_12.bam
```
:::
`-h`    Inclue o cabeçalho no output
`-b `   Output in the BAM format.
`-S`    Ignorado em novas versões. Anteriormente, essa opção era necessária se a entrada estava no formato SAM, mas agora o formato correto é detectado automaticamente examinando os primeiros caracteres de entrada.
`-F INT` Não produz alinhamentos com nenhum _bit_ definido em INT presente no campo 'FLAG' do read. Basicamente filtra todos os reads que não preenchem o quesito especifica pelo numero INT que é referente a tabela de 'bir binários' acima em _**unmapped reads**_



:::warning
É importante fazer uso do parametro -H para adicionar o cabeçalho do formato SAM no arquivo, já que quando ele foi produzido pelo BWA ele não foi adicionado. 
:::

:::spoiler Sort e Index utilizando SAMTools

- Sort dos reads
A Ordenação(Sort) dos reads de sequenciamentos de acordo com suas cordenadas na sequencia de referência.

:::info
**Ordernando arquivo BAM pós Alinhamento/Mapeamento**

```bash 
#Modelo:
samtools sort sample.bam -o sample.sorted.bam

#Na prática:
samtools sort SRR1517848_12.bam -o SRR1517848_12_sorted.bam

```
___
**Index do arquivo BAM ordenado**

```bash 
#Modelo:
samtools index aln.sorted.bam

#Na prática:
samtools index SRR1517848_12_sorted.bam

```
:::







# Picard
:::info
Descrevi o processo de instalação do Picard mas acho que ele está incluído no GATK, portanto fazendo desnecessário alguns passos.
:::
- Instalação:
As ferramentas de linha de comando do Picard são fornecidas como um único arquivo jar executável. Você pode fazer o download de um pacote compactado que contém o arquivo jar na página do projeto Última versão no Github. O nome do arquivo terá o formato picard-tools-x.y.z.zip.

Abra o pacote baixado e coloque a pasta que contém o arquivo jar em um diretório conveniente no seu disco rígido (ou servidor). Ao contrário dos programas compilados em C, como o Samtools, o Picard não pode ser simplesmente adicionado ao seu PATH, portanto, recomendamos configurar uma variável de ambiente para atuar como um atalho.

Para que as ferramentas funcionem corretamente, você deve ter o Java 1.8 instalado. Para verificar sua versão do java, abra o aplicativo de terminal e execute o seguinte comando:
```
java -version
```
Caso o java não esteja instalado provavelmente o linux vai te dar algumas opções para instalar usando o método `apt-get` entre elas: 
```
#java --version
sudo apt install openjdk-8-jre-headless
#javac --version
sudo apt install openjdk-8-jdk-headless 
```
Para testar se você pode executar as ferramentas Picard, execute o seguinte comando no aplicativo de terminal, fornecendo o caminho completo para o arquivo picard.jar:
```
java -jar /path/to/picard.jar -h 
```
Você deve ver uma lista completa de todas as ferramentas no kit de ferramentas Picard.

- Utilizando as ferramentas Picard
As ferramentas, todas listadas na documentação do Picard, são invocadas da seguinte maneira:
```
java jvm-args -jar picard.jar PicardToolName \
OPTION1 = value1 OPTION2 = value2 ...
```
## Ordenação: SortSam
Ordena arquivos SAM ou BAM por cordenadas em relação a referência e Queryname(QNAME) que é a identificação daquele arquivo/amostra no arquivo SAM(?)
A classificação do ordenamento é primeiro pelo nome da sequencia de referência usando tags de dicionario da referência (?) e psoteriormente pela posição do mapeamento da esquerda pra direita.

_INPUT: SAM ou BAM_

_OUTPUT: SAM ou BAM ordenado_

_SORT_ORDER(parameter): Tipos de ordenamento possíveis: Unsorted, queryname, coordinate, duplicate, unknown_

:::info
**Sort do arquivo BAM**

```bash 
#Modelo:
java -jar picard.jar SortSam \
      I=input.bam \
      O=sorted.bam \
      SORT_ORDER= coordinate

#Na prática:
java -jar ../picard/picard.jar SortSam \
      I= SRR1517848_12.bam\
      O=SRR1517848_12.sorted.bam \
      SORT_ORDER= coordinate

```
:::




## Indexação: BuildBamIndex
Gera um arquivo ".bai" de índice BAM. Essa ferramenta cria um arquivo de índice para a BAM de entrada que permite a pesquisa rápida de dados em um arquivo BAM, como um índice em um banco de dados. Observe que esta ferramenta não pode ser executada em arquivos SAM e que o arquivo BAM de entrada deve ser classificado em ordem de coordenadas (sorted).

_INPUT:	Um arquivo BAM ou URL GA4GH para processar. Deve estar ordenado.

OUTPUT: O arquivo de índice BAM. O padrão é Sample.bai se INPUT for Sample.bam_

```
java -jar picard.jar BuildBamIndex \ 
      I = input.bam
```
:::info
**Index do arquivo BAM**

```bash 
#Modelo:
java -jar picard.jar BuildBamIndex \ 
      I=input.bam

#Na prática:
java -jar ../picard/picard.jar BuildBamIndex \
I=SRR1517848_12.sorted.bam
```
:::


## Identificação de reads duplicadas: MarkDuplicates

Essa ferramenta localiza e identifica leituras duplicadas em um arquivo BAM ou SAM, em que leituras duplicadas são definidas como originárias de um único fragmento de DNA. Podem surgir duplicatas durante a preparação da amostra, por exemplo, construção da biblioteca usando PCR.  Leituras duplicadas também podem resultar de um único cluster de amplificação, detectado incorretamente como múltiplos clusters pelo sensor óptico do instrumento de seqüenciamento.

Depois que as leituras duplicadas são coletadas, a ferramenta diferencia as leituras primária e duplicada usando um algoritmo que classifica as leituras pelas somas do score de qualidade de base (base-quality score).

A saída principal da ferramenta é um novo arquivo SAM ou BAM, no qual duplicatas foram identificadas no campo sinalizadores SAM para cada leitura. 
Embora a anotação de sinalizador bit a bit indique se uma leitura foi marcada como duplicada, ela não identifica o tipo de duplicata. Você pode instruir o programa a marcar todas as duplicatas (Tudo), apenas as duplicadas ópticas (OpticalOnly) ou sem duplicatas (DontTag)

O programa pode receber entradas coordinate-sorted ou classificadas por consulta, no entanto, o comportamento é um pouco diferente. Quando a entrada é coordinate-sorted, posicionamentos não mapeados de registros mapeados e alinhamentos complementares / secundários não são marcados como duplicados. No entanto, quando a entrada é  query-sorted (na verdade, agrupada por consulta), posicionamentos não mapeados e leituras secundárias / suplementares não são excluídas do teste de duplicação e podem ser marcadas como leituras duplicadas.

Se desejado, as duplicatas podem ser removidas usando as opções REMOVE_DUPLICATE e REMOVE_SEQUENCING_DUPLICATES.

```bash
java -jar picard.jar MarkDuplicates \ 
      I = input.bam \ 
      O = marca_duplicados.bam \ 
      M = marca_dup_metrics.txt
      
      java -jar ../picard/picard.jar MarkDuplicates \
      I= SRR1517848_12.sorted.bam \
      O= SRR1517848_12.sorted.MarkDup.bam \
      M= marca_dup_metrics.txt
      
#Depois de marcar as variáveis é necessário fazer um novo ordenamento:

java -jar ../picard/picard.jar SortSam \
      I=SRR1517848_12.sorted.MarkDup.bam\
      O=SRR1517848_12.sorted.MarkDupSort.bam \
      SORT_ORDER= coordinate
```

## GATK (Genome Analysis Toolkit)

O Genome Analysis Toolkit (GATK) é um conjunto de programas desenvolvidos pelo broad institute. 

- Instalação e verificação
O seguinte código de instalação foi removido do seguinte tutorial: [Genome Analysis Toolkit (GATK) . -- GVA2019](https://wikis.utexas.edu/display/bioiteam/Genome+Analysis+Toolkit+%28GATK%29+.+--+GVA2019)
```
cd $WORK/src  
# if you no such file or directory warning, I suggest you create this folder so you can think 'where do I put the programs I download using wget on tacc... $WORK/src' much in the same way you can think 'where do I put binary executable files after I install the files I download on tacc are extracted/installed ... $HOME/local/bin'
 
 
wget https://github.com/broadinstitute/gatk/releases/download/4.1.4.1/gatk-4.1.4.1.zip
unzip gatk-4.1.4.1.zip
 
cp gatk-4.1.4.1/gatk $HOME/.local/bin # again notes about not having a $HOME/local/bin directory
cp gatk-4.1.4.1/*.jar $HOME/.local/bin
# A pasta loal está oculta por isso o "." antes do nome.
 
cd ~
gatk -help # if this does not output a large list of colored text, try the following command and if that does not output colored text get my attention
gatk --list

```

- Execução 
Embora ferramentas individuais exijam opções diferentes e o próprio programa utilize muitas opções diferentes, apenas 3 coisas são  SEMPRE  necessárias:


| Parametro |            Descrição            |
| :-------: |:-------------------------------:|
| Tool name | Que ferramente você quer usar   |
| -R        | Arquivo com a seq de Referência |
| -I        | Arquivo BAM de Input            |










## IGV

O Integrative Genomics Viewer (IGV) é uma ferramenta de visualização de alto desempenho para exploração interativa de grandes conjuntos de dados genômicos integrados. Ele suporta uma ampla variedade de tipos de dados, incluindo dados de seqüência baseados em array e de próxima geração, e anotações genômicas.

- Instalação
Fazer download do programa pela página oficial do [BWA](http://bio-bwa.sourceforge.net/)
```
 tar -xvf bwa.tar.bz2   
 cd bwa
 makefile 
```