# **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`
Sign in with Wallet
Connect another wallet