# Aula 04/11

Primeiro começa com a limpeza primeiro do arquivo fasta, dps do arquivo GFF que é os que tem as coordenadas dos cromossomos.

Pré processamento de dados de transcriptoma (RNA-seq)

é fundamental manter a organização dos diretorios.

prinseq poda de sequencias de baixa qualidade, cauda poli A, sequencias mts curtas.

****para abrir o screen digita screen -x ai aparece o que tem aberto, para remover algum ocloca screen -r completa com o tab o nome se qer excluir da exit, ou control a + k tudo junto*****

Tophat>>> Star
Tophat> detecção abinitio de sitios de splicing:nao precisa passar nenhuma coordenada de sitios de junção, ele é responsável pela identificação desses sitios.

STAR --runThreadN 7 \
--runMode genomeGenerate \
--genomeFastaFiles ./genome.fa \
--genomeDir ./star_index \
--sjdbGTFfile ./genome.gtf \
--sjdbOverhang 149
STAR --runThreadN 7 \
--genomeDir ./state/partition1/jcardoso/Ref/star_index \
--readFilesIn ./home/jcardoso/sim/raw/SAMPLEA1_R1.fastq \
./home/jcardoso/sim/raw/SAMPLEA1_R2.fastq \
--sjdbGTFfile ./state/partition1/jcardoso/Ref/genome.gtf \
--outFileNamePrefix ./state/partition1/jcardoso/Ref/star_out/align

FAST QC: ferramenta para controle de qualidade.

para rodar coloca fasqc e abre o arquivo fast q;

colapsar sequencias: remover a redundancia,isso n é recomendado para rnaseq. è recomendado para identificaçao de variantes.

prinseq: mantem a qalidade da base no resultado final.

Trimagem por qualidade.

tem uma sequencia e a regiao avaliada é a right, ele funciona como avaliação por janela , ai cada base tem um valor q ela vale. Uma janela vamos supor q é de tamanho 3, a primeira avaliação é feita com as 3 primeiras bases do lado direito. Trim qual step, é quanto que vai pular para uma outra avaliação
Depois tem o tipo de medida q vai fazer, no caso a média, ai ele faz a média dos 3 valores das ultimas 3 bases. Essa pontuação é em relaçao a qualidade, qto maior melhor, ex 30 1 erro a cada mil base. TRim qual right é um valor de qualidade ex a media menor qe tal valor a base é aliminada

trim qual window - 3
trim qual step -1
trim qual type
trim qual righ
trim qual rule - é a regra, maior menor ou igual

Prinseq: trimagem de cauda Poli A, a filtragem de cauda poli A pode reduzir o numero de falsos positivos nos alinhamentos. A eliminação de regioes de baixa qualidade pode reduzir o numero de falso negativos . Se elimina a cauda poli a pq ela n tem identidade com o genoma.

arquivo singletons: fica as sequencias |R1 que perderam os pares R2

Sequencia de baixa complexidade: relacionada com bases repetidas, qqto mais repetição menor a complexidade.

Primeiro remove adapatdor e dps sequencias de baixa complexidade;

prinseq-lite.pl -fastq
/home/gfrezarim/sim/raw/SAMPLEA1_R1.fastq \
-fastq2 /home/gfrezarim/sim/raw/SAMPLEA1_R2.fastq \
-trim_qual_window 3 \
-trim_qual_step 1 \
-trim_qual_right 30 \
-trim_qual_type mean \
-trim_qual_rule lt \
-out_good ./output/processed/prinseq/SAMPLEA1 \
-out_bad ./output/processed/prinseq/SAMPLEA1.bad \
-lc_method dust \
-lc_threshold 30 \
-min_len 20 \
-trim_tail_right 5 \
-trim_tail_left 5\
-ns_max_p 80 \
-noniupac \
> ./output/processed/prinseq/SAMPLEA1.out.log \
2> ./output/processed/prinseq/SAMPLEA1.err.log

mkdir -p output/processed/fastqc/pre

fastqc -t 2 /home/gfrezarim/sim/raw/SAMPLEA1_R1.fastq -o ./output/processed/fastqc/pre/
fastqc -t 2 /home/gfrezarim/sim/raw/SAMPLEA1_R2.fastq -o ./output/processed/fastqc/pre/

MIXomics: An R package for omics feature selection and multiple data integration

Horizontal: multiplicas tecnicas com mts metodologias, pra que dali ele extraia biomarcadores.

mintl vertical mulltivariate

ddiablo : multiple data integration with a single multivariate model

Da pra usar o for pra evitar ficar rodando varias vezes o pre e pos

#! /bin/bash
for r1 in 'ls * _R1.fastq' ; do
echo $ {i}
r2= 'echo' $(r1) | sed 's/_R1.fastq/_R2.fastq/'
echo ${r1} ${r2}
fastqc -t 2 \
${r1}

-o ./output/processed/fastqc/pre/
fastqc -t 2 \
${r2}
-o ./output/processed/fastqc/pre/

done

ai dps do underline vejo ql a caracteristica da sequencia q ueeo rodar, elas estçao dentro do raw, e todas elas termina com *_R1.fastq
dps do do e que vai ser executado pra cada arquivo q teme sse comando,, entao o que fizer entre do e done sera execcutado pra cada arquivo .Faz o msm para R2

A variavel alterada dentro do lop é o R1 que cada vez muda,

> ! /bin/bash
> for r1 in 'ls * _R1.fastq' ; do
> echo $ {i}
>
> r2= 'echo' $(r1) | sed 's/_R1.fastq/_R2.fastq/'
> name = basename ${r1} | sed 's/_R1_fastq//'
> echo "Fastq evaluation using sample ${name}: {r1} & ${r2}...""
>
>
> fastqc -t 2 \
> ${r1}
> -o ./output/processed/fastqc/pre/ \
> > -o ./output/processed/fastqc/pre/${name}_R1.log.out.txt\
> > 2> ./ output/processed/fastqc/pre/${name}_R1.log.err.txt\
>
>
> fastqc -t 2 \
> ${r2}
> -o ./output/processed/fastqc/pre/ \
> > -o ./output/processed/fastqc/pre/${name}_R2.log.out.txt\
> > 2> ./ output/processed/fastqc/pre/${name}_R2.log.err.txt\

######################################################

#!/bin/bash

mkdir -p ./output/processed/fastqc/pre

for r1 in `ls raw/*_R1.fastq`; do
r2=`echo ${r1} | sed 's/_R1.fastq/_R2.fastq/'`

name=`basename ${r1} | sed 's/_R1.fastq//'`
echo "FastQC evaluation using sample ${name}: ${r1} & ${r2} ..."

fastqc -t 2 \
${r1} \
-o ./output/processed/fastqc/pre/ \
> ./output/processed/fastqc/pre/${name}_R1.log.out.txt \
2> ./output/processed/fastqc/pre/${name}_R1.log.err.txt

fastqc -t 2 \
${r2} \
-o ./output/processed/fastqc/pre/ \
> ./output/processed/fastqc/pre/${name}_R2.log.out.txt \
2> ./output/processed/fastqc/pre/${name}_R2.log.err.txt
done

#!/bin/bash

mkdir -p ./output/processed/fastqc/pre

for r1 in `ls raw/*_R1.fastq`; do
        r2=`echo ${r1} | sed 's/_R1.fastq/_R2.fastq/'`

        name=`basename ${r1} | sed 's/_R1.fastq//'`
        echo "FastQC evaluation using sample ${name}: ${r1} & ${r2} ..."

        fastqc -t 2 \
                ${r1} \
                -o ./output/processed/fastqc/pre/ \
                > ./output/processed/fastqc/pre/${name}_R1.log.out.txt \
                2> ./output/processed/fastqc/pre/${name}_R1.log.err.txt

        fastqc -t 2 \
                ${r2} \
                -o ./output/processed/fastqc/pre/ \
                > ./output/processed/fastqc/pre/${name}_R2.log.out.txt \
                2> ./output/processed/fastqc/pre/${name}_R2.log.err.txt


mkdir -p ./output/processed/prinseq

prinseq-lite.pl -fastq ${r1} \
                -fastq2 ${r2} \
                -out_format 3 \
                -trim_qual_window 3 \
                -trim_qual_step 1 \
                -trim_qual_right 30 \
                -trim_qual_type mean \
                -trim_qual_rule lt \
                -out_good ./output/processed/prinseq/${name}.prinseq \
                -out_bad ./output/processed/prinseq/${name}.prinseq.bad \
                -lc_method dust \
                -lc_threshold 30 \
                -min_len 20 \
                -trim_tail_right 5 \
                -trim_tail_left 5\
                -ns_max_p 80 \
                -noniupac \
                > ./output/processed/prinseq/${name}.prinseq.out.log \
                2> ./output/processed/prinseq/${name}.prinseq.err.log
                
              mkdir -p ./output/processed/fastqc/pos  
                
              fastqc -t 2 \
                ./output/processed/prinseq/${name}.prinseq_1.fastq \
                -o ./output/processed/fastqc/pos/ \
                > ./output/processed/fastqc/pre/${name}_R1.log.out.txt \
                2> ./output/processed/fastqc/pre/${name}_R1.log.err.txt

        fastqc -t 2 \
                $./output/processed/prinseq/${name}.prinseq_2.fastq \
                -o ./output/processed/fastqc/pos/ \
                > ./output/processed/fastqc/pre/${name}_R2.log.out.txt \
                2> ./output/processed/fastqc/pre/${name}_R2.log.err.txt  




done

Criação de diretorio é feito antes for r1 *fastq pega todos arquivos r1, cada interação um arquivo diferente. Automaticamente eu pego o r2 que é o r1 sibstituindo o r2.

O nome base tb vai ser utilizado durantre várias etapas, é usado o nome da amostra!! é o nome do arquivo sem a parte do diretorio. E ainda substitui o R1 por fast 1 por nada, pq eu queero apenas o nome do arquivo , eu nquero mais o fastq. só quro o nome dele q sera sample a1, sample a2,
Agora substitui em um local opara ter resultado entao primeiroo o fastq pro r1 e pro r2, é só por entao r1 e re $, e colocar nome $, ai faz uma impressão na tela. Ai o prinseq eu coloco a entradaq eh o arquivo bruto e a saida que eh o prinseq


POsso mudar o script pra ele rodar em qlqr lugar , ex em um direotrio desconhecido

Podemos informar pro arquivo onde estçao as entradas fastq. Esse script n podia ter sido executado dentro de raw,

Precisa ter dois diretorios um de entrada e um de saida.
Desde que eu tenha uma pasta q tenha meus arquivos posso roda assim
Então esse .raw se os meus dados estivessem em outra pasta eu só precisaria colocar o nome da pastaa ai e o nome de saida!! ecopiar o script embaixo , o link na vdd só colocar wget e colar o link dps habilitar cm chmod a+x nomedoarquivo e dps ./ pra rodar ./preprocess2.

https://raw.githubusercontent.com/dgpinheiro/bioaat/master/preprocess2.sh

#!/bin/bash

indir=$1

# SE ${indir} NÃO EXISTE, SE NÃO FOI PASSADO ARGUMENTO NA LINHA DE COMANDO
if [ ! ${indir} ]; then
echo "Missing input directory."
exit
fi

# SE ${indir} NÃO É DIRETÓRIO
if [ ! -d ${indir} ]; then
echo "Wrong input directory (${indir})."
exit
fi

outdir=$2

# SE ${outdir} EXISTE, SE FOI PASSADO ARGUMENTO NA LINHA DE COMANDO
if [ ! ${outdir} ]; then
echo "Missing output directory."
exit
fi

# SE ${outdir} NÃO É DIRETÓRIO
if [ ! -d ${outdir} ]; then
echo "Wrong output directory (${outdir})."
exit
fi

mkdir -p ${outdir}/processed/fastqc/pre
mkdir -p ${outdir}/processed/prinseq
mkdir -p ${outdir}/processed/fastqc/pos

for r1 in `ls ${indir}/*_R1.fastq`; do
r2=`echo ${r1} | sed 's/_R1.fastq/_R2.fastq/'`

name=`basename ${r1} | sed 's/_R1.fastq//'`
echo "FastQC pre-evaluation using sample ${name}: ${r1} & ${r2} ..."

fastqc -t 2 \
${r1} \
-o ${outdir}/processed/fastqc/pre/ \
> ${outdir}/processed/fastqc/pre/${name}_R1.log.out.txt \
2> ${outdir}/processed/fastqc/pre/${name}_R1.log.err.txt

fastqc -t 2 \
${r2} \
-o ${outdir}/processed/fastqc/pre/ \
> ${outdir}/processed/fastqc/pre/${name}_R2.log.out.txt \
2> ${outdir}/processed/fastqc/pre/${name}_R2.log.err.txt

echo "PrinSeq processing: ${r1} & ${r2} ..."

prinseq-lite.pl -fastq ${r1} \
-fastq2 ${r2} \
-out_format 3 \
-trim_qual_window 3 \
-trim_qual_step 1 \
-trim_qual_right 30 \
-trim_qual_type mean \
-trim_qual_rule lt \
-out_good ${outdir}/processed/prinseq/${name}.prinseq \
-out_bad null \
-lc_method dust \
-lc_threshold 30 \
-min_len 20 \
-trim_tail_right 5 \
-trim_tail_left 5 \
-ns_max_p 80 \
-noniupac \
> ${outdir}/processed/prinseq/${name}.prinseq.out.log \
2> ${outdir}/processed/prinseq/${name}.prinseq.err.log

echo "FastQC pos-evaluation using sample ${name}: ${outdir}/processed/prinseq/${name}.prinseq_1.fastq & ${outdir}/processed/prinseq/${name}_2.prinseq.fastq ..."

fastqc -t 2 \
${outdir}/processed/prinseq/${name}.prinseq_1.fastq \
-o ${outdir}/processed/fastqc/pos/ \
> ${outdir}/processed/fastqc/pos/${name}.prinseq_1.log.out.txt \
2> ${outdir}/processed/fastqc/pos/${name}.prinseq_1.log.err.txt

fastqc -t 2 \
${outdir}/processed/prinseq/${name}_2.prinseq.fastq \
-o ${outdir}/processed/fastqc/pos/ \
> ${outdir}/processed/fastqc/pos/${name}.prinseq_2.log.out.txt \
2> ${outdir}/processed/fastqc/pos/${name}.prinseq_2.log.err.txt

# SE EXISTIR <SAMPLE_NAME>.prinseq_1_singletons.fastq
if [ -e "${outdir}/processed/prinseq/${name}.prinseq_1_singletons.fastq" ]; then
fastqc -t 2 \
${outdir}/processed/prinseq/${name}.prinseq_1_singletons.fastq \
-o ${outdir}/processed/fastqc/pos/ \
> ${outdir}/processed/fastqc/pos/${name}.prinseq_1_singletons.log.out.txt \
2> ${outdir}/processed/fastqc/pos/${name}.prinseq_1_singletons.log.err.txt
fi

# SE EXISTIR <SAMPLE_NAME>.prinseq_2_singletons.fastq
if [ -e "${outdir}/processed/prinseq/${name}.prinseq_2_singletons.fastq" ]; then
fastqc -t 2 \
${outdir}/processed/prinseq/${name}.prinseq_2_singletons.fastq \
-o ${outdir}/processed/fastqc/pos/ \
> ${outdir}/processed/fastqc/pos/${name}.prinseq_2_singletons.log.out.txt \
2> ${outdir}/processed/fastqc/pos/${name}.prinseq_2_singletons.log.err.txt
fi
done'''

Barcode e indice é a msm coisa.
Remoção de adaptdor no 5' é mais raro, no 3' é mais comum, pq se o fragmento eh menor q a qtde de ciclos detrerminada no sequenciador. Se o fragmento tem 200 e vc le 250 ciclos vc le 50 bases alem do framgmaneto .

ter fragmentos menores q a qtde de ciclo é mt comum , por isso é mt comum a trimagem na porção 3' via sequenciamento de adaptador.

Um dos programas q pode ser usado pra trimagem do adaptador na 3' é a ferramenta scythe. É um clssificador bayseano que classifica se a porção com adpatador é de fato um adaptador.

Preto é a sequecia é o fragmaneto verdadeiro, e teve uma sequencia de adaptador correspondente a essa porçao. Se teve corespondente e de alta qualidade é adaptador, agora se aqualidade n é alta, pode n ser. Qdo a qualidade é maior e tem correspondencia tem chance de ser adapatador, tbm qdo a qualidade e menor e n tem correspondencia.

Se for adaptador é feito a trimagem pelo scythe somente na extremidade 3'.
outout file : sequencias ja trimadas
min match: qtde minima de match pra considerar quetem ..??
min keep filtrar sequencia menor ouigual q tamanho de 35.

Precisa ser executado pra r1 e r2 pra dois comandos separados.
Pra cada indice mudao adaptador,

teste rapido pra eliminar os adaptadores é o clipping adapters.

pyenv deactivate

Para trimagem e correção de erros que o atropo é indicado.
-a -A refere-se aos adaptadores 3'.

Atropos: somentes os adaptadores 3' sao suficiente pq ele identifica que as 5' sao complementares .

lliberal: considera a base de maior qualidade

atropos untrimmed é para as reads que n foram trimadas.

Contar o que foi feito para poda de adapatadores , escrever como se fsse um material e metodos

atropos trim --aligner insert \
-e 0.1 \
-n 2 \
-m 1 \
--op-order GAWCQ \
--match-read-wildcards \
-O 20 \
-q 25 \
-T 2 \
--correct-mismatches conservative \
--pair-filter any \
-a AGATCGGAAGAGCACACGTCTGAACTCCAGTCAC \
-A AGATCGGAAGAGCGTCGTGTAGGGAAAGAGTGTAGATCTCGGTGGTCGCCGTATCATT \
-o ./output/processed/atropos/SAMPLEA1_R1.atropos.fastq \
-p ./output/processed/atropos/SAMPLEA1_R2.atropos.fastq \
-pe1 ./raw/SAMPLEA1_R1.fastq \
-pe2 ./raw/SAMPLEA1_R2.fastq \
--untrimmed-output ./output/processed/atropos/SAMPLEA1_R1.atropos.untrimmed.fastq \
--untrimmed-paired-output ./output/processed/atropos/SAMPLEA1_R2.atropos.untrimmed.fastq \
> ./output/processed/atropos/SAMPLEA1_R1.atropos.log.out.txt \
2> ./output/processed/atropos/SAMPLEA1_R1.atropos.log.err.txt

atropos trim -h

# Bioinformática II: Análise transcriptomas: 04/11

Montagem: Reconstrução aproximada das sequencias alvos em suas formas originais.

Profundidade do sequenciamento: Número de reads obtidas.

Cobertura (N):
(numero de leituras x tamanho das leituras)/ Tamanho total
O tamanho total de pares de base no genoma transcriptoma.

Tamanho do gene: Número de bases do gene (L)

Contagem de transcritos do gene (C): numero de leituras que mapearam no gene.

Contagem de transcritos da isoforma (I):
número de leituras que mapearam na isoforma.

N50: medida de contiguidade, o quanto as sequencias são conitnuas

## Pré processamento dos dados

Phred score 30: Um err a cada 1000 bases
kmer: subsequencias dentro de uma sequencia maior, no fastqc avalia a representatividade de determinada subsequencia dentro de uma sequencia maior.

Sequencias superrepresentadas: grande chance de ser RNA ribossomal.

fastUniq: SNPs

PrinSeq: Trimagem de cauda Poli-A: A filtragem de cauda poli-A pode reduzir o numero de falsos positivos nos alinhamentos. A eliminação de regiões de baixa qualidade pode reduzir o numero de falsos negativos.
Se elimina a cauda poliA pois ela nao tem identidade com o genoma.

Sequencias de baixa complexidade: Quanto mais repetições menor a complexidade.
menor valor dust:maior complexidade Ex:
TTTTTTTTT > 100
TATATATATA> 49
TAGTAGTAGTAG> 32
metodo entropia é ao contrario do dust: quanto maior o valor, maior a complexidade.

PrinSeq:

mkdir -p ./output/processed/prinseq
prinseq-lite.pl -fastq /home/jcardoso/sim/raw/SAMPLEA1_R1.fastq \
                -fastq2 /home/jcardoso/sim/raw/SAMPLEA1_R2.fastq \
                -out_format 3 \
                -trim_qual_window 3 \
                -trim_qual_step 1 \
                -trim_qual_right 30 \
                -trim_qual_type mean \
                -trim_qual_rule lt \
                -out_good ./output/processed/prinseq/SAMPLEA1 \
                -out_bad ./output/processed/prinseq/SAMPLEA1.bad \
                -lc_method dust \
                -lc_threshold 30 \
                -min_len 20 \
                -trim_tail_right 5 \
                -trim_tail_left 5\
                -ns_max_p 80 \
                -noniupac \
                > ./output/processed/prinseq/SAMPLEA1.out.log \
                2> ./output/processed/prinseq/SAMPLEA1.err.log

Apenas para renomear o arquivo de saida, para saber de que programa é proveniente.

mkdir -p ./output/processed/prinseq

prinseq-lite.pl -fastq ./raw/SAMPLEA1_R1.fastq \
                -fastq2 ./raw/SAMPLEA1_R2.fastq \
                -out_format 3 \
                -trim_qual_window 3 \
                -trim_qual_step 1 \
                -trim_qual_right 30 \
                -trim_qual_type mean \
                -trim_qual_rule lt \
                -out_good ./output/processed/prinseq/SAMPLEA1.prinseq \
                -out_bad ./output/processed/prinseq/SAMPLEA1.prinseq.bad \
                -lc_method dust \
                -lc_threshold 30 \
                -min_len 20 \
                -trim_tail_right 5 \
                -trim_tail_left 5\
                -ns_max_p 80 \
                -noniupac \
                > ./output/processed/prinseq/SAMPLEA1.prinseq.out.log \
                2> ./output/processed/prinseq/SAMPLEA1.prinseq.err.log

mkdir -p output/processed/fastqc/pre
fastqc -t 2 /home/jcardoso/sim/raw/SAMPLEA1_R1.fastq -o ./output/processed/fastqc/pre/
fastqc -t 2 /home/jcardoso/sim/raw/SAMPLEA1_R2.fastq -o ./output/processed/fastqc/pre/

`mkdir -p output/processed/fastqc/pos`

fastqc -t 2 ./output/processed/prinseq/SAMPLEA1_1.fastq -o ./output/processed/fastqc/pos/

fastqc -t 2 ./output/processed/prinseq/SAMPLEA1_2.prinseq.fastq -o ./output/processed/fastqc/pos/

#### SE EXISTIR SAMPLEA1.prinseq_1_singletons.fastq
`fastqc -t 2 ./output/processed/prinseq/SAMPLEA1.prinseq_1_singletons.fastq -o ./output/processed/fastqc/pos/`
#### SE EXISTIR SAMPLEA1.prinseq_2_singletons.fastq
`fastqc -t 2 ./output/processed/prinseq/SAMPLEA1.prinseq_2_singletons.fastq -o ./output/processed/fastqc/pos/`

* mixOmics: Pacote R

Script for:

#!/bin/bash

mkdir -p ./output/processed/fastqc/pre

for r1 in `ls /home/jcardoso/sim/raw/*_R1.fastq`; do
        r2=`echo ${r1} | sed 's/_R1.fastq/_R2.fastq/'`

        name=`basename ${r1} | sed 's/_R1.fastq//'`
        echo "FastQC evaluation using sample ${name}: ${r1} & ${r2} ..."

        fastqc -t 2 \
                ${r1} \
                -o ./output/processed/fastqc/pre/ \
                > ./output/processed/fastqc/pre/${name}_R1.log.out.txt \
                2> ./output/processed/fastqc/pre/${name}_R1.log.err.txt

        fastqc -t 2 \
                ${r2} \
                -o ./output/processed/fastqc/pre/ \
                > ./output/processed/fastqc/pre/${name}_R2.log.out.txt \
                2> ./output/processed/fastqc/pre/${name}_R2.log.err.txt


mkdir -p ./output/processed/prinseq

prinseq-lite.pl -fastq ${r1} \
                -fastq2 ${r2} \
                -out_format 3 \
                -trim_qual_window 3 \
                -trim_qual_step 1 \
                -trim_qual_right 30 \
                -trim_qual_type mean \
                -trim_qual_rule lt \
                -out_good ./output/processed/prinseq/${name}.prinseq \
                -out_bad ./output/processed/prinseq/${name}.prinseq.bad \
                -lc_method dust \
                -lc_threshold 30 \
                -min_len 20 \
                -trim_tail_right 5 \
                -trim_tail_left 5\
                -ns_max_p 80 \
                -noniupac \
                > ./output/processed/prinseq/${name}.prinseq.out.log \
                2> ./output/processed/prinseq/${name}.prinseq.err.log
                
mkdir -p output/processed/fastqc/pos

fastqc -t 2 \
 ./output/processed/prinseq/${name}.prinseq_1.fastq \
   ./output/processed/prinseq/ \
   -o ./output/processed/fastqc/pos/
fastqc -t 2 \
  ./output/processed/prinseq/{name}.prinseq_2.fastq \
   -o ./output/processed/fastqc/pos/

# SE EXISTIR SAMPLEA1.prinseq_1_singletons.fastq
fastqc -t 2 \
   ./output/processed/prinseq/{name}.prinseq_1_singletons.fastq \
   -o ./output/processed/fastqc/pos/
# SE EXISTIR {name}.prinseq_2_singletons.fastq
fastqc -t 2 \
   ./output/processed/prinseq/{name}.prinseq_2_singletons.fastq \
   -o ./output/processed/fastqc/pos/                         
   done     

Dar permissão de execução:

`chmod a+x `
`./scriptfor.sh`

Script FastQC(pre)+PrinSeq+FastQC(pos)
O script preprocess1.sh foi desenvolvido para uma análise simples considerando que há arquivos *_R1.fastq e *_R2.fastq no diretório ./raw a partir de onde o script deve estar gravado e de onde será executado:

./preprocess1.sh

Geralmente vc realiza a trimagem na extremidade 5', raramente na 3'.Porque se o fragmento é muito curto, do que o valor que colocou durante o ciclo de sequenciamento, a polimerase continua e tem-se reads contendo sequencia de adaptador.

cutadapt: só leva em conta correspondecia nas regioẽs 3', 5' e interna, e não qualidade das bases.
-G e -g tem q passar as 2 sequencias, pois leem da direita para esquerda.
-A e -a é referente a porção 5' da esquerda pra direita.

Para chamar o comando atropos no servidor hammer é necessário ativar o ambiente Python compatível com o programa.

`pyenv activate atropos`

Com o ambiente carregado é possível invocar o comando e visualizar as opções disponível.

atropos -h 
atropos trim -h

Para desativar o ambiente e retornar a o ambiente padrão:

`pyenv deacivate`

Atropos: Somente as sequencias dos adaptadore 3' são suficientes, pois ele consegue identificar que as 5' são complementares dessas.

Ordem de execução melhor que o default: -- op-order GAWCQ (Testes realizados pelo lab do prof Daniel mostraram que essa ordem é melhor que o default, deram mais certo.)

A primeira execução será no modo Insert:

atropos trim --aligner insert \
             -e 0.1 \
             -n 2 \
             -m 1 \
             --op-order GAWCQ \
             --match-read-wildcards \
             -O 20 \
             -q 25 \
             -T 2 \
             --correct-mismatches conservative \
             --pair-filter any \
             -a AGATCGGAAGAGCACACGTCTGAACTCCAGTCAC \
             -A AGATCGGAAGAGCGTCGTGTAGGGAAAGAGTGTAGATCTCGGTGGTCGCCGTATCATT  \
             -o ./output/processed/atropos/SAMPLEA1_R1.atropos.fastq \
             -p ./output/processed/atropos/SAMPLEA1_R2.atropos.fastq \
             -pe1 ./raw/SAMPLEA1_R1.fastq \
             -pe2 ./raw/SAMPLEA1_R2.fastq \
             --untrimmed-output ./output/processed/atropos/SAMPLEA1_R1.atropos.untrimmed.fastq \
             --untrimmed-paired-output ./output/processed/atropos/SAMPLEA1_R2.atropos.untrimmed.fastq \
               > ./output/processed/atropos/SAMPLEA1_R1.atropos.log.out.txt \
              2> ./output/processed/atropos/SAMPLEA1_R1.atropos.log.err.txt´´´