.. _trinity:

=======
Trinity
=======

.. contents:: Nesta seção:
   :local:
   :depth: 2

Descrição
=========

De acordo com a `página do Trinity <https://github.com/trinityrnaseq/trinityrnaseq/wiki>`_, Trinity é um método para reconstrução de transcriptomas a partir de dados RNA-seq, desenvolvido no Broad Institute e na Universidade Hebraica de Jerusalém.

Versões Disponíveis
===================

* trinity/2.8.5 (default)
* trinity/2.15.1

Carregando o Módulo
===================

.. code-block:: bash

   # Carregar Trinity
   module load trinity/2.15.1

   # Verificar instalação
   Trinity --version

Montagem Básica
===============

.. code-block:: bash
   :caption: submit_trinity_basic.sh

   #!/bin/bash
   #SBATCH -J trinity_basic
   #SBATCH -N 1
   #SBATCH -c 8
   #SBATCH -t 48:00:00
   #SBATCH --mem=64G

   export INPUT="reads.left.fq.gz reads.right.fq.gz"
   export OUTPUT="trinity_out_dir/"

   module load trinity/2.15.1

   job-nanny Trinity --seqType fq \
                     --max_memory $(($SLURM_MEM_PER_NODE / 1024))G \
                     --left reads.left.fq.gz \
                     --right reads.right.fq.gz \
                     --SS_lib_type RF \
                     --CPU $SLURM_CPUS_PER_TASK \
                     --output trinity_out_dir

Montagem Strand-specific
========================

.. code-block:: bash
   :caption: submit_trinity_strand.sh

   #!/bin/bash
   #SBATCH -J trinity_strand
   #SBATCH -N 1
   #SBATCH -c 16
   #SBATCH -t 72:00:00
   #SBATCH --mem=128G

   export INPUT="reads_1.fq.gz reads_2.fq.gz"
   export OUTPUT="trinity_strand/"

   module load trinity/2.15.1

   job-nanny Trinity --seqType fq \
                     --max_memory $(($SLURM_MEM_PER_NODE / 1024))G \
                     --left reads_1.fq.gz \
                     --right reads_2.fq.gz \
                     --SS_lib_type RF \
                     --CPU $SLURM_CPUS_PER_TASK \
                     --output trinity_strand \
                     --full_cleanup

Montagem Single-end
===================

.. code-block:: bash
   :caption: submit_trinity_single.sh

   #!/bin/bash
   #SBATCH -J trinity_single
   #SBATCH -N 1
   #SBATCH -c 8
   #SBATCH -t 48:00:00
   #SBATCH --mem=64G

   export INPUT="reads.fq.gz"
   export OUTPUT="trinity_single/"

   module load trinity/2.15.1

   job-nanny Trinity --seqType fq \
                     --max_memory $(($SLURM_MEM_PER_NODE / 1024))G \
                     --single reads.fq.gz \
                     --CPU $SLURM_CPUS_PER_TASK \
                     --output trinity_single

Montagem com Múltiplas Amostras
===============================

.. code-block:: bash
   :caption: submit_trinity_multiple.sh

   #!/bin/bash
   #SBATCH -J trinity_multiple
   #SBATCH -N 1
   #SBATCH -c 16
   #SBATCH -t 96:00:00
   #SBATCH --mem=128G

   export INPUT="samples.txt"
   export OUTPUT="trinity_merged/"

   module load trinity/2.15.1

   job-nanny Trinity --seqType fq \
                     --max_memory $(($SLURM_MEM_PER_NODE / 1024))G \
                     --samples_file samples.txt \
                     --CPU $SLURM_CPUS_PER_TASK \
                     --output trinity_merged

.. code-block:: text
   :caption: samples.txt

   cond_A    sample1    sample1_R1.fq.gz    sample1_R2.fq.gz
   cond_A    sample2    sample2_R1.fq.gz    sample2_R2.fq.gz
   cond_B    sample3    sample3_R1.fq.gz    sample3_R2.fq.gz
   cond_B    sample4    sample4_R1.fq.gz    sample4_R2.fq.gz

Incluir reads não pareadas
==========================

.. code-block:: bash
   :caption: submit_trinity_with_unpaired.sh

   #!/bin/bash
   #SBATCH -J trinity_unpaired
   #SBATCH -N 1
   #SBATCH -c 16
   #SBATCH -t 72:00:00
   #SBATCH --mem=128G

   export INPUT="reads_1.fq.gz reads_2.fq.gz unpaired.fq.gz"
   export OUTPUT="trinity_with_unpaired/"

   module load trinity/2.15.1

   job-nanny Trinity --seqType fq \
                     --max_memory $(($SLURM_MEM_PER_NODE / 1024))G \
                     --left reads_1.fq.gz \
                     --right reads_2.fq.gz \
                     --single unpaired.fq.gz \
                     --CPU $SLURM_CPUS_PER_TASK \
                     --output trinity_with_unpaired

Quantificação de Abundância
===========================

.. code-block:: bash
   :caption: submit_abundance_estimation.sh

   #!/bin/bash
   #SBATCH -J abundance
   #SBATCH -N 1
   #SBATCH -c 8
   #SBATCH -t 24:00:00
   #SBATCH --mem=32G

   export INPUT="trinity_out_dir.Trinity.fasta reads_1.fq.gz reads_2.fq.gz"
   export OUTPUT="abundance/"

   module load trinity/2.15.1

   # Alinhar reads com Bowtie2
   job-nanny bowtie2-build trinity_out_dir.Trinity.fasta trinity_index
   job-nanny bowtie2 -x trinity_index \
                     -1 reads_1.fq.gz \
                     -2 reads_2.fq.gz \
                     -p $SLURM_CPUS_PER_TASK \
                     | samtools sort -o aligned.bam

   # Estimar abundância
   job-nanny samtools index aligned.bam
   job-nanny samtools idxstats aligned.bam > counts.txt

Análise de Expressão Diferencial
================================

.. code-block:: bash
   :caption: submit_expression_analysis.sh

   #!/bin/bash
   #SBATCH -J expression
   #SBATCH -N 1
   #SBATCH -c 8
   #SBATCH -t 24:00:00
   #SBATCH --mem=32G

   export INPUT="trinity_out_dir.Trinity.fasta"
   export OUTPUT="expression/"

   module load trinity/2.15.1
   module load R/4.0.2

   # Alinhar todas as amostras e quantificar
   for sample in sample1 sample2 sample3 sample4; do
       /usr/bin/time -v bowtie2 -x trinity_index \
                     -1 ${sample}_1.fq.gz \
                     -2 ${sample}_2.fq.gz \
                     -p $SLURM_CPUS_PER_TASK \
                     | samtools sort -o ${sample}.bam
       
       samtools index ${sample}.bam
       samtools idxstats ${sample}.bam > ${sample}.counts
   done

   # Criar matriz de contagem
   cat > create_matrix.R << 'EOF'
   library(edgeR)
   library(limma)

   # Combinar contagens
   samples <- c("sample1", "sample2", "sample3", "sample4")
   counts <- data.frame(row.names=1:1000)  # ajustar

   for (s in samples) {
       data <- read.table(paste0(s, ".counts"), 
                          col.names=c("ref", "len", "mapped", "unmapped"))
       counts[[s]] <- data$mapped
   }

   # Análise de expressão diferencial
   group <- factor(c("A", "A", "B", "B"))
   dge <- DGEList(counts=counts, group=group)
   dge <- calcNormFactors(dge)
   design <- model.matrix(~group)
   v <- voom(dge, design)
   fit <- lmFit(v, design)
   fit <- eBayes(fit)

   # Resultados
   results <- topTable(fit, coef=2, n=Inf)
   write.csv(results, "diff_expression.csv")
   EOF

   Rscript create_matrix.R

Job Array para Múltiplas Amostras
=================================

.. code-block:: bash
   :caption: submit_trinity_array.sh

   #!/bin/bash
   #SBATCH -J trinity_array
   #SBATCH --array=1-5
   #SBATCH -N 1
   #SBATCH -c 8
   #SBATCH -t 48:00:00
   #SBATCH --mem=64G

   SAMPLES=(
       "sample1"
       "sample2"
       "sample3"
       "sample4"
       "sample5"
   )

   SAMPLE=${SAMPLES[$SLURM_ARRAY_TASK_ID-1]}
   export INPUT="${SAMPLE}_1.fq.gz ${SAMPLE}_2.fq.gz"
   export OUTPUT="${SAMPLE}_trinity/"

   module load trinity/2.15.1

   job-nanny Trinity --seqType fq \
                     --max_memory $(($SLURM_MEM_PER_NODE / 1024))G \
                     --left ${SAMPLE}_1.fq.gz \
                     --right ${SAMPLE}_2.fq.gz \
                     --CPU $SLURM_CPUS_PER_TASK \
                     --output ${SAMPLE}_trinity \
                     --full_cleanup

Análise de Resultados
=====================

.. code-block:: bash
   :caption: analyze_trinity.sh

   #!/bin/bash
   #SBATCH -J analyze_trinity
   #SBATCH -N 1
   #SBATCH -n 1
   #SBATCH -t 04:00:00
   #SBATCH --mem=8G

   module load trinity/2.15.1

   # Estatísticas da montagem
   $TRINITY_HOME/util/TrinityStats.pl trinity_out_dir/Trinity.fasta > assembly_stats.txt

   # Extrair contigs longos
   awk '/^>/ {if (seqlen) print seqlen; print; seqlen=0; next} 
        {seqlen+=length($0)} END {print seqlen}' \
       trinity_out_dir/Trinity.fasta > contig_lengths.txt

   # Contar contigs por tamanho
   echo "Contigs > 1kb: $(awk '$1>1000' contig_lengths.txt | wc -l)" >> assembly_stats.txt
   echo "Contigs > 2kb: $(awk '$1>2000' contig_lengths.txt | wc -l)" >> assembly_stats.txt
   echo "Contigs > 5kb: $(awk '$1>5000' contig_lengths.txt | wc -l)" >> assembly_stats.txt

   # BUSCO (se disponível)
   if command -v busco &> /dev/null; then
       busco -i trinity_out_dir/Trinity.fasta \
             -l eukaryota_odb10 \
             -o busco_out \
             -m transcriptome
   fi

Referências
===========

- Documentação: https://github.com/trinityrnaseq/trinityrnaseq/wiki
- Tutorial: https://github.com/trinityrnaseq/trinityrnaseq/wiki/Running-Trinity
- Publicação: https://www.nature.com/articles/nbt.1883

.. seealso::

   - :ref:`spades` - Montagem de genomas
   - :ref:`rsem` - Quantificação de expressão
   - :ref:`salmon` - Quantificação de transcriptomas
   - :ref:`processando_simulacoes` - Como submeter jobs