---
# System prepended metadata

title: '**Unidad 3. Análisis de datos de secuenciación RNA-Seq**'
tags: [Clase NGS]

---

# **Unidad 3. Análisis de datos de secuenciación RNA-Seq**
#### Dra. Laura Liliana López Galindo    (lilopez@cicese.edu.mx)

---

## Acceso a [OMICA](http://omica.cicese.mx/docs/index.html)
Acceder al servicor con tu cuenta de omica. 
Utilizar `-YC` cuando se requiera despliegue gráfico. Los símbolos ## indican el número de curso asignado al usuario.
```javascript=
ssh curso##@omica
```
Substituir el doble hash (##) por el número de cuenta asignado (ver tabla 1).
:::success
:key: **Password:** Curso-tmp##
::: 

* **Tabla 1.** Asignación de cuentas en OMICA

| Estudiante | Cuenta  | Estudiante | Cuenta  |
| ---------- | ------  | ---------- | ------  |
| Sebastián  | curso02 | Alan       | curso11 |
| Alberto    | curso03 | Brenda     | curso12 |
| Erick      | curso04 | Victor     | curso13 |
| Willian    | curso05 | Luis Adrian| curso14 |
| Eugenio    | curso06 | Lizt       | curso15 |
| Luz        | curso07 | Karla      | curso16 |
| Jesús A.   | curso08 |            | curso17 |
| Antonio    | curso09 | Estefany   | curso18 |
| Melissa    | curso10 | José Luis  | curso19 |

Revisar los archivos ocultos.
```javascript=
ls -a
```
Pegar en el `.bash_profile` los paths de los programas que serán utilizados durante el curso.
```javascript=
nano .bash_profile
```
Pegar los siguientes `path` de los programas que serán utilizados durante el análisis transcriptómico. 
```javascript=
# Software for transcriptomic analysis
export PATH=$PATH:/LUSTRE/apps/bioinformatica/FastQC_v0.11.7
export PATH=$PATH:/LUSTRE/bioinformatica_data/genomica_funcional/bin/Trimmomatic-0.36
export PATH=$PATH:/LUSTRE/apps/bioinformatica/trinityrnaseq-2.4.0
export PATH=$PATH:/LUSTRE/apps/bioinformatica/trinityrnaseq-2.4.0/util
export PATH=$PATH:/LUSTRE/apps/bioinformatica/trinityrnaseq-2.4.0/Analysis/DifferentialExpression
export PATH=$PATH:/LUSTRE/apps/bioinformatica/trinityrnaseq-2.4.0/trinity-plugins/parafly-code/bin
export PATH=$PATH:/LUSTRE/apps/bioinformatica/trinityrnaseq-2.4.0/trinity-plugins/parafly/bin
export R_LIBRARY_PATH=/LUSTRE/apps/R-3.3.1/lib64/R/library
export PATH=$PATH:/LUSTRE/bioinformatica_data/genomica_funcional/bin/ncbi-blast-2.4.0+/bin
export PATH=$PATH:/LUSTRE/apps/bioinformatica/TransDecoder-3.0.1
export PATH=$PATH:/LUSTRE/bioinformatica_data/RNA/ricardo/bioinformatics/transdecoder
export PATH=$PATH:/LUSTRE/bioinformatica_data/genomica_funcional/bin/signalp-4.1
export PATH=$PATH:/LUSTRE/bioinformatica_data/genomica_funcional/bin/tmhmm-2.0c/bin
export PATH=$PATH:/LUSTRE/bioinformatica_data/genomica_funcional/bin/Trinotate/util/rnammer_support
export PATH=$PATH:/LUSTRE/bioinformatica_data/genomica_funcional/bin/rnammer
export PATH=$PATH:/LUSTRE/bioinformatica_data/genomica_funcional/bin/hmmer-3.1b2-linux-intel-x86_64/binaries
export PATH=$PATH:/LUSTRE/apps/bioinformatica/Trinotate/PerlLib
export PATH=$PATH:/LUSTRE/apps/bioinformatica/Trinotate/auto
export PATH=$PATH:/LUSTRE/apps/bioinformatica/samtools-1.7/bin
export PATH=$PATH:/LUSTRE/apps/bioinformatica/bowtie2
export PATH=$PATH:/LUSTRE/bioinformatica_data/genomica_funcional/bin/RSEM
export PATH=$PATH:/LUSTRE/bioinformatica_data/genomica_funcional/Laura/bin/transrate-1.0.3-linux-x86_64/transrate
```
Actualizar el archivo .bash_profile
```javascript=
source .bash_profile
```
Moverse a la carpeta `curso2020` y crear carpeta de trabajo `Transcriptomica` y acceder.
```javascript=
cd curso2020
mkdir Transcriptomica 
cd Transcriptomica
```
Crear link simbólico de las secuencias que serán utilizadas. Sintaxis `ln -s ORIGEN DESTINO`
```javascript=
ln -s /LUSTRE/bioinformatica_data/genomica_funcional/Laura/Curso_2020/RAW_READS/ ./
ls
```
La carpeta `RAW_READS` contiene un set de 16 archivos `.fastq` con secuencias o lecturas crudas provenientes de una secuenciación en un equipo Illumina HISEQ-4000 en formato pair-end de gónada de ostiones *Crassostrea virginica* indiferenciados expuestos a tres diferentes concentraciones de hidrocarburos. Este subconjunto de muestras en su totalidad está compuesto por 8 millones de lecturas. Los tratamientos son los siguientes:
	
* 	Ctrl: ostiones en el día en que arranca la exposición a hidrocarburos, sin petróleo.
* 	T1: ostiones en el día 7 de exposición a 200 ug/L
* 	T2: ostiones en el día 14 de exposición a 200 ug/L
* 	T3: ostiones en el día 21 de exposición a 200 ug/L
* 	rep1: réplica biológica 1
* 	rep2: réplica biológica 2
* 	R1: Lectura forward
* 	R2: Lectura reverse

Checar el formato del archivo `.fastq` y obtener el número de secuencias de cada archivo.
```javascript=
cd RAW_READS
head Ctrl_rep1_500k_R1.fastq
cat Ctrl_rep1_500k_R1.fastq | grep "^@M03978" | wc -l

# Imprimirá en pantalla el número de coincidencias (Lecturas) por archivo.
find . -type f -name "*.fastq" | xargs grep -c "^@M03978"				
```
---

## Análisis de calidad de las lecturas con [FastQC](https://dnacore.missouri.edu/PDF/FastQC_Manual.pdf) y [MultiQC](https://multiqc.info/) 

En la carpeta de `Transcriptomica`, crear carpeta `FASTQC` y con las subcarpetas `FASTQC_PRE` y `FASTQC_POST`. Acceder a carpeta `FASTQC_PRE`
```javascript=
cd ..
mkdir -p FASTQC/{FASTQC_PRE,FASTQC_POST}
cd FASTQC/FASTQC_PRE/
```
Realizar análisis de calidad de las secuencias con el programa `FastQC`. Se obtendrán N archivos `.html` y `fastqc.zip` . Sintaxis `fastqc [-t # ] [path to file] [-o output dir]`
```javascript=
fastqc -t 8 ../../RAW_READS/*.fastq -o ./ 	
```
```javascript=
ls  	
```
:::info
:bulb: **NOTA:** A partir de este paso lo que sigue es copiar los archivos `.html` a nuestra PC. Para ello sigan las instrucciones siguientes:
:::
**Paso 1.** Abrir una nueva terminal 
**Paso 2.** Acceder a nuestra carpeta de `OMICA`
```javascript=
$ cd Documentos/curso2020/OMICA
```
**Paso 3.** Crear en `OMICA` un directorio con el nombre `FASTQC` y dentro de él, dos que se llamen `FASTQC_PRE` y `FASTQC_POST`.
```javascript=
$ mkdir -p FASTQC/{FASTQC_PRE,FASTQC_POST}
```
**Paso 4.** Acceder al directorio `FASTQC_PRE`
```javascript=
$ cd FASTQC_PRE
```
**Paso 5.** Copiar dentro de este directorio todos los archivos `.html` que generamos en el cluster.
```javascript=
$ scp curso01@omica:/home/curso01/curso2020/Transcriptomica/FASTQC/FASTQC_PRE/*.html ./
```
**Paso 6.** Revisión individual de archivos `.html` en navegador `firefox` o en el navegador que tengan instalado, para verificar la calidad de las lecturas de secuenciación. 
```javascript=
$ firefox Ctrl_rep1_500k_R1_fastqc.html 
```

:::info
:+1: **Ahora regresamos a trabajar en `OMICA` ** 
:::
### -- MULTIQC -- 
Si se quiere hacer una comparación entre todos los valores de calidad de las secuencias, se puede utilizar el programa `MultiQC` que utiliza los archivos generados por `FastQC`. Se requiere un ambiente para el programa que está basado en `python 2.7`

Exportar el ambiente.
```javascript=
# Para verificar si existe el ambiente.
$ conda info --envs								

# Para crear el ambiente.
$ export PATH=/LUSTRE/apps/Anaconda/conda2/bin:$PATH 

# Actualizar .bashrc
$ source .bashrc

# Activar ambiente
$ source activate multiqc_py2.7					

# Desactivar ambiente
$ source deactivate multiqc_py2.7					
```
En la carpeta de trabajo `Transcriptomica`, crear la carpeta `MULTIQC`, acceder y correr `MultiQC` activando el ambiente `multiqc_py2.7`. Se generaran las carpetas `multiqc_data`, `multiqc_plots` y `multiqc_reports.html`. Revisar archivo `.html`. Al finalizar desactivar el ambiente `multiqc_py2.7`.
```javascript=
$ cd ../../	
$ mkdir MULTIQC
$ cd MULTIQC/
$ mkdir PRE POST
$ source activate multiqc_py2.7
$ multiqc ../FASTQC/FASTQC_PRE/*.zip -o ./PRE --data-format json --export
```
```javascript=
$ source deactivate multiqc_py2.7
```
Revisar el archivo `.html` obtenido con `MultiQC` dentro de la carpeta `PRE`.
```javascript=
$ cd PRE/
$ firefox multiqc_report.html
```
**NOTA:** Si no se puede visualizar el archivo `.html` dentro del servidor OMICA se deberá descargar el archivo a nuestras computadoras personales. Los pasos a seguir se enuncian a continuación. **Seguir los pasos que realizamos anteriormente.**

**1.** Abrir una terminal nueva (esta terminal nueva no está conectada al servidor de OMICA)
**2.** Crear una carpeta de trabajo dentro de sus `Documentos`
```javascript=
cd Documentos
mkdir -p curso2020/Transcriptomica/MULTIQC/PRE
cd curso2020/Transcriptomica/MULTIQC/PRE
scp curso01@omica:/home/curso01/curso2020/Transcriptomica/MULTIQC/PRE/multiqc_report.html ./
password:Curso-tmp01    
```
**3.** Revisar el archivo `.hmtl` obtenido con el programa `MultiQC`
```javascript=
firefox multiqc_report.html
```
**4.** Cerrar esta terminal en cuanto se termine de revisar el archivo `.html`

---
## Limpieza y eliminación de lecturas de mala calidad con [Trimmomatic](http://www.usadellab.org/cms/uploads/supplementary/Trimmomatic/TrimmomaticManual_V0.32.pdf)

##### A partir de aquí se usaran scripts basados en slurm (manejador de tareas en Omica).
En este paso se usará el programa `Trimmomatic`, para eliminar las secuencias de mala calidad, así como índices o adaptadores de secuenciación que pudieran haber quedado.

Crear la carpeta `TRIMMOMATIC` en la carpeta `Transcriptomica` y acceder a ella.
```javascript=
cd ../../
mkdir TRIMMOMATIC
cd TRIMMOMATIC
```
Copiar el archivo `TruSeq3-PE-2.fa`, el cual contiene los índices y adaptadores de secuenciación utilizados por Illumina.
```javascript=
cp /LUSTRE/bioinformatica_data/genomica_funcional/apps/Trimmomatic-0.39/adapters/TruSeq3-PE-2.fa ./
```
Generar el script al cual llamaremos `trimmomatic.slrm`
```javascript=
nano trimmomatic.slrm
```
El slrm debe contener lo siguiente:
```javascript=
#!/bin/sh

###Directivas

SBATCH -p cicese
#SBATCH --job-name=trimmomatic
#SBATCH --output=trimmomatic-%j.log
#SBATCH --error=trimmomatic-%j.err
#SBATCH -N 1
#SBATCH --ntasks-per-node=8
#SBATCH -t 06-00:00:00


TRIM=/LUSTRE/apps/bioinformatica/Trimmomatic-0.40

cd ${SLURM_SUBMIT_DIR}

java -jar $TRIM/trimmomatic-0.40-rc1.jar PE ../RAW_READS/INT15_1.fq.gz ../RAW_READS/INT15_2.fq.gz -baseout INT15.fastq \
ILLUMINACLIP:TruSeq3-PE-2.fa:2:30:10 LEADING:5 TRAILING:5 SLIDINGWINDOW:4:15 MINLEN:36

java -jar $TRIM/trimmomatic-0.40-rc1.jar PE ../RAW_READS/INT23_1.fq.gz ../RAW_READS/INT23_2.fq.gz -baseout INT23.fastq \
ILLUMINACLIP:TruSeq3-PE-2.fa:2:30:10 LEADING:5 TRAILING:5 SLIDINGWINDOW:4:15 MINLEN:36

java -jar $TRIM/trimmomatic-0.40-rc1.jar PE ../RAW_READS/INT26_1.fq.gz ../RAW_READS/INT26_2.fq.gz -baseout INT26.fastq \
ILLUMINACLIP:TruSeq3-PE-2.fa:2:30:10 LEADING:5 TRAILING:5 SLIDINGWINDOW:4:15 MINLEN:36

java -jar $TRIM/trimmomatic-0.40-rc1.jar PE ../RAW_READS/INT27_1.fq.gz ../RAW_READS/INT27_2.fq.gz -baseout INT27.fastq \
ILLUMINACLIP:TruSeq3-PE-2.fa:2:30:10 LEADING:5 TRAILING:5 SLIDINGWINDOW:4:15 MINLEN:36

java -jar $TRIM/trimmomatic-0.40-rc1.jar PE ../RAW_READS/INT5_1.fq.gz ../RAW_READS/INT5_2.fq.gz -baseout INT5.fastq \
ILLUMINACLIP:TruSeq3-PE-2.fa:2:30:10 LEADING:5 TRAILING:5 SLIDINGWINDOW:4:15 MINLEN:36

java -jar $TRIM/trimmomatic-0.40-rc1.jar PE ../RAW_READS/INT6_1.fq.gz ../RAW_READS/INT6_2.fq.gz -baseout INT6.fastq \
ILLUMINACLIP:TruSeq3-PE-2.fa:2:30:10 LEADING:5 TRAILING:5 SLIDINGWINDOW:4:15 MINLEN:36

java -jar $TRIM/trimmomatic-0.40-rc1.jar PE ../RAW_READS/INT8_1.fq.gz ../RAW_READS/INT8_2.fq.gz -baseout INT8.fastq \
ILLUMINACLIP:TruSeq3-PE-2.fa:2:30:10 LEADING:5 TRAILING:5 SLIDINGWINDOW:4:15 MINLEN:36

java -jar $TRIM/trimmomatic-0.40-rc1.jar PE ../RAW_READS/INT9_1.fq.gz ../RAW_READS/INT9_2.fq.gz -baseout INT9.fastq \
ILLUMINACLIP:TruSeq3-PE-2.fa:2:30:10 LEADING:5 TRAILING:5 SLIDINGWINDOW:4:15 MINLEN:36


exit 0
```
Correr el script `trimmomatic.slrm` 
```javascript=
sbatch trimmomatic.slrm
squeue
```
Crear carpetas `TRIM_P` y `TRIM_U` y mover los archivos que correspondan a cada carpeta.
```javascript=
ls 
mkdir TRIM_P TRIM_U
mv *U.fastq TRIM_U/
mv *P.fastq TRIM_P/
ls 
ls TRIM_P/
```
Ahora se recomienda revisar las secuencias pareadas con `FastQC` y `MultiQC` como se realizó en los pasos anteriores. Para ello deben moverse a la carpeta `FASTQC_POST` para correr el script.
```javascript=
cd ../FASTQC/FASTQC_POST/
fastqc -t 8 ../../TRIMMOMATIC/TRIM_P/*.fastq -o ./  				
ls 
```
Correr el script de `MultiQC` en la carpeta respectiva y checar archivo `.html`
```javascript=
cd ../../MULTIQC/POST
source activate multiqc_py2.7
multiqc ../../FASTQC/FASTQC_POST/*.zip -o ./ --data-format json --export
```
``` javascript=
source deactivate multiqc_py2.7
```
Revisar el archivo `.html` obtenido con `MultiQC` dentro de la carpeta `POST`.
```javascript=
cd POST/
firefox multiqc_report.html
```
**NOTA:** Si no se puede visualizar el archivo `.html` dentro del servidor OMICA se deberá descargar el archivo a nuestras computadoras personales. Los pasos a seguir se enuncian a continuación.

**1.** Abrir una terminal nueva (esta terminal nueva no está conectada al servidor de OMICA)
**2.** Crear dentro de la carpeta `Documentos/curso2020/Transcriptomica/MULTIQC` una carpeta con el nombre `POST`
```javascript=
cd Documentos/curso2020/Transcriptomica/MULTIQC
mkdir POST
cd POST/
scp curso01@omica:/home/curso01/curso2020/Transcriptomica/MULTIQC/POST/multiqc_report.html ./
password:Curso-tmp01    
```
**3.** Revisar el archivo `.hmtl` obtenido con el programa `MultiQC`
```javascript=
firefox multiqc_report.html
```
**4.** Cerrar esta terminal en cuanto se termine de revisar el archivo `.html`

---
## Ensamble del transcriptoma *de novo* con [Trinity](https://github.com/trinityrnaseq/trinityrnaseq/wiki)

Crear en la carpeta `Transcriptomica` el directorio `ENSAMBLE` y una subcarpeta con el nombre `De_novo`. Acceder a esta última.
```javascript=
cd curso2020/Transcriptomica
mkdir -p ENSAMBLE/De_novo
cd ENSAMBLE/De_novo
```
Dentro de la carpeta `De_novo`, crear un `link simbólico` de las lecturas pareadas que obtuvimos con `Trimmomatic`.
```javascript=
ln -s ../../TRIMMOMATIC/TRIM_P/*.fastq ./
ls
```
Crear en esta carpeta un archivo de texto con columnas separadas por tabulador al que denominaremos `samples_file.txt`
```javascript=
nano samples_file.txt
```
La estructura del archivo se muestra a continuación:
```javascript=
IFM    IFM_1    INT5_1P.fastq    INT5_2P.fastq
IFM    IFM_2    INT6_1P.fastq    INT6_2P.fastq
IFM    IFM_3    INT15_1P.fastq    INT15_2P.fastq
I30    I30_1    INT8_1P.fastq    INT8_2P.fastq
I30    I30_2    INT9_1P.fastq    INT9_2P.fastq
I30    I30_3    INT23_1P.fastq    INT23_2P.fastq
I60    I60_1    INT26_1P.fastq    INT26_2P.fastq
I60    I60_2    INT27_1P.fastq    INT27_2P.fastq
```

Verificar la estructura tabular del archivo `samples_file.txt`. La tabulación se muestra con el simbolo `^I` y el final de la línea con simbolo `$`.
```javascript=
cat -TE samples_file.txt
```
Una vez que ya tenemos creado el `link simbólico` de las lecturas limpias y el archivo `samples_file.txt`, ahora se debe crear el script para correr el ensamble *de novo*.
```javascript=
nano ensamble.slrm
```
El slrm debe contener lo siguiente:
```javascript=


#!/bin/bash

# Directivas
#SBATCH --job-name=Trinity-denovo
#SBATCH --output=slurm-%j.log
#SBATCH --error=slurm-%j.err
#SBATCH --nodes 2
#SBATCH --mem=100GB
#SBATCH --ntasks-per-node=24
#SBATCH -t 6-00:00:00
#SBATCH -p cicese


#export some soft
export PATH=$PATH:/LUSTRE/apps/bioinformatica/bowtie2/bin/
export PATH=$PATH:/LUSTRE/apps/bioinformatica/samtools-1.17/bin/
export PATH=$PATH:/LUSTRE/apps/bioinformatica/jellyfish-2.3.0/
export PATH=$PATH:/LUSTRE/apps/bioinformatica/salmon/bin/
module load conda-2023
module load trinityrnaseq-v2.15.1

#my vars

R1=INT15_1P.fastq,INT5_1P.fastq,INT6_1P.fastq,INT8_1P.fastq,INT9_1P.fastq,INT23_1P.fastq,INT26_1P.fastq,INT27_1P.fastq \
R2=INT15_2P.fastq,INT5_2P.fastq,INT6_2P.fastq,INT8_2P.fastq,INT9_2P.fastq,INT23_2P.fastq,INT26_2P.fastq,INT27_2P.fastq \
OUTDIR="Trinity_ensamble"
LIBT="RF"
Trinity --no_version_check --seqType fq --max_memory 100G \
--no_bowtie \
--CPU 24 --left $R1 --right $R2 \
--normalize_reads \
--output $OUTDIR
#--full_cleanup"

# see the time spent
START=`date +%s`

# Run trinity
###$TRINITY  $PARM

END=`date +%s`

RUNTIME=$(($END-$START))

echo "run time -> $RUNTIME"

exit 0

```
Una vez terminado el script `ensamble.slrm`, proceder a ejecutarlo.
```javascript=
sbatch ensamble.slrm
squeue
```
Se generaran dos archivos un `.err` en donde podremos verificar si hay algún error durante la ejecución del script y un `.log` en donde podemos ver cómo va avanzando el proceso del ensamble. También se generará una carpeta `trinity_ensamble` (si se quita el comentario en `--output trinity_ensamble`, dentro de la cual encontraremos un archivo `Trinity.fasta` en donde se encuentran todos los contigs generados del ensamble. Para saber si la ejecución del ensamble terminó, revisar el manejador de tareas de Omica o revisar el final del archivo `.log`. En este archivo debe aparecer la siguiente leyenda:

#################################################
Butterfly assemblies are written to /LUSTRE/bioinformatica_data/curso2019/accounts/curso01/Transcriptomica/ENSAMBLE/Trinity.fasta
#################################################

Para obtener las estadísticas básicas del ensamble, se debe correr el siguiente comando dentro de la carpeta `trinity_out_dir` que es donde se encuentra el archivo `Trinity.fasta`:
```javascript=
TrinityStats.pl Trinity.fasta > Trinitystats.txt
more Trinitystats.txt
```

---
Validación del ensamble con Transrate
---
Entrar a la carpeta `curso2020/Transcriptómica`, crear la carpeta `TRANSRATE` y acceder a ella.
```javascript=
mkdir TRANSRATE
cd TRANSRATE
```
Concatenar las lecturas pareadas limpias obtenidas con `Trimmomatic`. Concatenar todas las `R1` en un archivo y realizar la misma acción con las `R2` en otro archivo. 
```javascript=
cat ../TRIMMOMATIC/TRIM_P/*1P.fastq > All_reads_1P.fastq
cat ../TRIMMOMATIC/TRIM_P/*2P.fastq > All_reads_2P.fastq
ls 
```
Crear enlace simbólico del ensamble *de novo* `Trinity.fasta` generado previamente a esta carpeta.
```javascript=
ln -s ../ENSAMBLE/De_novo/trinity_out_dir/Trinity.fasta ./
```
Una vez que se tiene tanto las lecturas concatenadas como el ensamble, se debe proceder a crear el archivo `.slrm` para someter la tarea a Omica.

Crear el archivo Transrate.slrm
```javascript=
nano Transrate.slrm
```
A continuación se encuentra lo que debe contener el archivo `Transrate.slrm`. El tiempo que tarda en generar los resultados dependerá del número de lecturas que se estén manejando. En este caso el número de lecturas es de 8 millones por lo que no deberá tardar más de 5 a 10 minutos.
```javascript=
#!/bin/bash

#SBATCH -p cicese
#SBATCH --job-name=transrate
#SBATCH --output=transrate-%j.log
#SBATCH --error=transrate-%j.err
#SBATCH -N 1
#SBATCH --mem=100GB
#SBATCH --ntasks-per-node=24
#SBATCH -t 06-00:00:00

export PATH=/LUSTRE/apps/bioinformatica/.local/bin:$PATH
export PATH=/LUSTRE/apps/bioinformatica/ruby2/ruby-2.2.0/bin:$PATH
export LD_LIBRARY_PATH=/LUSTRE/apps/bioinformatica/ruby2/ruby-2.2.0/lib:$LD_LIBRARY_PATH

TRANSRATE=/LUSTRE/apps/bioinformatica/ruby2/ruby-2.2.0/bin

cd $SLURM_SUBMIT_DIR

$TRANSRATE/transrate \
--assembly Trinity.tmp.fasta \
--left All_reads_1P.fastq \
--right All_reads_2P.fastq \
--threads 8 \
--output gcontigs \

exit 0

```
Someter tarea a manejador de tareas de Omica 
```javascript=
sbatch Transrate.slrm
squeue
```
Al término de la tarea se debe obtener una carpeta denominada `gcontigs` con una subcarpeta `Trinity`. Esta última contendrá dos archivos principalmente `good.Trinity.fasta` y `bad.Trinity.fasta`, los cuales contienen los contigs tanto de buena como de mala calidad, respectivamente. 

En la carpeta `TRANSRATE` se debió haber generado un archivo `.log` que contiene todas las métricas que genera el programa `Transrate`. En este podemos checar estas métricas en pantalla. De igual forma estas métricas quedan almacenadas en un archivo denominado `assemblies.csv` dentro de la carpeta `gcontigs`. 

---

###### tags: `Clase NGS`