---
# System prepended metadata

title: Aula 04/11

---

#  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 


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




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, 

![](https://i.imgur.com/J3ad1dc.png)
 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´´´
             
             
