*SELENOPROTEINES EN PROTISTES*

MATERIALS I MÈTODES

Tot seguit veurem els passos que hem realitzat per tal d'identificar la presència de selenoproteïnes en els catorze genomes dels diferents protistes. Per tal d'agilitzar els processos i poder obtenir uns resultats més acurats afegint major quantitat de queries, hem creat una sèrie de programes que anirem veient a continuació. El sistema operatiu que hem fet servir és Linux, en concret la distribució Fedora Core 14 (Laughlin).

OBTENCIÓ DE DADES

Query

La query o seqüència model és la proteïna o regió protèica coneguda que intentarem relacionar amb els genomes en estudi. En el nostre cas seran seqüències de múltiples selenoproteïnes que ja s'han trobat en altres organismes, i les farem servir per a realitzar una comparació a partir de la qual inferirem si, degut a la homologia entre genomes, hem trobat una selenoproteïna en un nou microorganisme.

Aquestes queries s'han obtingut majoritàriament de la base de dades SelenoDB, de la qual hem seleccionat la cadena polipeptídica. A més a més hem buscat organismes en els quals ja s'havien trobat les proteïnes en treballs d'altres anys. Totes elles s'han importat en format fasta per tal d'evitar problemes de compatibilitat.

És important tenir en compte que molts programes bioinformàtics no poden interpretar el símbol "U", que indica una selenoproteïna, amb un codó STOP. Per això en tots els casos hem hagut de substituir les "U" que anàvem trobant per "X".

Genomes

Els genomes dels protistes que analitzem han estat facilitats pel departament de Bioinformàtica de la Universitat Pompeu Fabra, a través del seu cluster de docència, accessible des de la següent ruta: /cursos/BI/genomes/protists/2012.

BLAST: alineament de seqüències

BLAST és un programa informàtic que s'encarrega de cercar regions de similitud entre seqüències. Compara seqüències nucleotídiques o proteiques (el que anomena "query") amb una base de dades que conté les seqüències amb les quals es vol trobar l'homologia (l'anomenat "subject"). A més, calcula la significància estadística de tots els resultats o hits .

Per tal de cercar els possibles alineaments entre el nostre genoma i les selenoproteïnes conegudes, vam utilitzar el programa tBLASTn, un dels flavours de BLAST, que ens compara DNA (seqüència nucleotídica dels genomes disponibles a la base de dades) contra proteïnes (seqüència aminoacídica de la nostra query). Aquest programa, doncs, serveix per trobar una seqüència d'aminoàcids dins d'un genoma.

A la pràctica, podrem executar-lo amb la comanda:

blastall -p tblastn -i fitxerquery.fa -d nombbddBLAST -o fitxerdesortida

On fitxerquery.fa ha de ser el fitxer que contingui la seqüència query, nombbddBLAST ha de ser el nom de la base de dades BLAST en la qual volem fer la cerca, i fitxerdesortida ha de ser el nom d'un fitxer dins el qual volem que BLAST ens emmagatzemi els resultats de la cerca.

El fitxer de sortida contindrà una comparació o alineament de les dues seqüències i un e-value que és el valor que ens indicarà la significança estadística d'aquest. A més, també disposarem de les posicions del genoma en el qual troba la nostra query. D'aquesta manera, el BLAST ens ha servit per orientar-nos en el genoma del microorganisme i saber a quina regió es troba la possible selenoproteina que estem buscant.

Per a interpretar el resultat, hem considerat l'e-value, hem filtrat els valors superiors a 0.0001 i ens hem quedat amb els inferiors. A més, hem comprovat que la regió de la U correspongui amb la zona alineada del genoma. Si les seqüències no s'alineen correctament cal buscar queries alternatives i tornar a començar.

En resum, utilitzant tblastn hem comparat les seqüències query i la base de dades amb els genomes de protistes (/cursos/BI/genomes/protists/2012/nom_protists). No obstant, hem fet servir el següent programa blast.bash per tal de facilitar la feina.

Codi:

#!/bin/bash 

# Contacte: xian.weng01@estudiant.upf.edu
# Aqui estan els permisos per executar els programes

export PATH=/cursos/BI/bin/ncbiblast/bin:$PATH
cp /cursos/BI/bin/ncbiblast/.ncbirc ~/

# Aixo es per a detectar les queries que s'utilitzaran

for proteines_fa in ./queries/*; do {
basename_fa=`basename $proteines_fa`
proteina=${basename_fa%.fa}
proteines=$proteines" $proteina"
} done

# Aquests comandes serveix generar noves carpetes buides d'on treballara el programa


rm -r out_blast
mkdir out_blast
rm -r output_blast
mkdir output_blast
rm -r blast_selec
mkdir blast_selec

# Les comandes següents serveix per obtenir el tblastn de cada query contra cada genoma:

rm resultats_blast.txt 2> error.temp

	for protein in $proteines ; do {
		for genomes in A.laibachii_Nc14 A.rara C.fasciculata D.discoideum_AX4 D.fasciculatum F.cylindrus G.niphandrodes L.donovani_BPK282A1 L.tarentolae P.capsici P.polycephalum S.arctica T.congolense I.multifiliis_strain_G5; do {

			patro1=`cat ./queries/$protein.fa | egrep ">"`
			patro2=${patro1#*>}
			echo $patro2 > temppatro
			patro=`cut -f 1 -d " " temppatro`
			rm temppatro
			#el primer tblastn ens dóna resultats resumits i filtre els resultats inferiors al e-value que hem determinat
			blastall -p tblastn -i ./queries/$protein.fa -d /cursos/BI/genomes/protists/2012/$genomes/genome.fa -o output_blast/$protein.$genomes.txt -m 9 -e 0.0001
			# aquest segon tblastn ens dona resultats extesos			
			blastall -p tblastn -i ./queries/$protein.fa -d /cursos/BI/genomes/protists/2012/$genomes/genome.fa -o out_blast/$protein.$genomes.txt -e 0.0001
			echo ">${protein}_$genomes:" >> resultats_blast.txt
			egrep $patro output_blast/$protein.$genomes.txt | egrep e- >> resultats_blast.txt
			x=`egrep $patro ./output_blast/$protein.$genomes.txt | egrep e-`
		
			if [ "$x" != "" ]; then
				egrep $patro output_blast/$protein.$genomes.txt | egrep e- > arxiu.temp
				mkdir ./blast_selec/$protein 2> error.temp
				mkdir ./blast_selec/$protein/$genomes 2> error.temp
				./ordenarhits.pl $protein $genomes < arxiu.temp 
			
			fi
		
		
			echo ${protein}_$genomes fet
		} done
	} done

rm ./*.temp

Codi "ordenarhits.pl":

#!/usr/bin/perl

# Codi perl que acompanya al programa blast.bash per tal d'ordenar els hits que apareixen en el tblastn
# Contacte: xian.weng01@estudiant.upf.edu

use strict;
my $contador=0;

while ()
{
    open (fitxersortida, ">./blast_selec/$ARGV[0]/$ARGV[1]/hit$contador.txt");
    chomp;
    print fitxersortida "$_";
    close (fitxersortida);
    $contador++;
}

Extracció genomica

Fastaindex

A continuació s'ha d'extreure la regió genòmica on l'alineament amb el tBLASTn indicava que es podria trobar la selenoproteïna. Abans que res s'ha d'indexar el genoma. Per això es fa servir la comanda:

fastaindex genome.fa genome.index

On a genome.fa hem de d'escriure la localització en l'ordinador per trobar el genoma del protista i genome.index fa referència al fitxer de sortida. El que obtindrem serà el genoma indexat.

Fastafetch

La seqüenciació dels genomes es donen en fitxers amb format multifasta dels quals es necessari l'extracció de la regió d´interès. Això ho podem fer a partir de l'indexació del genoma. Això ho podem fer amb la següent comanda:

fastafetch ruta_fitxer_base_dades.fa genome.index nom_contig > fastafetch.fa

On hem de especificar la ruta a seguir per tal de trobar el genoma en la base de dades del departament de Bioinformàtica, el fitxer index creat, el nom del contig que vull exteure y per últim crear un fitxer que emmagatzemi la regió obtinguda pel programa fastafetch.

Fastasubseq

Un cop extret el contig s'ha utilitzat el programa fastasubseq per a extreure de forma més precisa el fragment que s'ha estimat que possiblement contindrà la selenoproteïna. És a dir, es pot tallar la regió per a obtenir la seqüència alineada en el tBLASTn. La comanda és la següent:

fastasubseq fastafetch.fa start length > fastasubseq.fa

Start correspon al número del nucleòtid on comença la nostra query i length a la longitud (posició final - posició inicial). En aquest pas d'extracció de la regió, per assegurar-nos que no tallem cap exó i que podrem incloure l´element SECIS, agafem 50000 nucleòtids. L'extracció la realitzem a partir del fitxer obtingut amb fastafetch. Per últim s'emmagatzema la regió tallada en un fitxer (fastasubseq.fa).

Aquests passos s'han automatitzat amb el programa boom.bash

Anotació genomica

Exonerate

El següent a realitzat és assegurar-nos que el nostre hit es troba dins d'un exó, i que per tant, codifica per una proteïna. Per això, es realitzen les anotacions dels gens que estem buscant amb Exonerate, alineant el fragment de DNA que hem extret amb Fastasubseq amb la seqüència de DNA de la proteïna inicial. Fem servir la comanda:

exonerate -m p2g --showtargetgff -q fitxerquery.fa -t fastasubseq.fa > exonerate.fa

En l'arxiu de sortida tindrem una representació de l'alineament entre la query i la regió extreta amb el fastasubseq. En aquest punt cal mirar si la X de la query està alineada amb un asterisc, cosa que indicaria un codó STOP o més probablement, en aquest cas, la presència d'una selenocisteïna. Alternativament, podem trobar una cisteïna si tractem amb un homòleg de cisteïna. Després d'això hem utilitzat la següent comanda per obtenir un fitxer amb format .gff que ens digui si tenim inclòs la regió en un exó:

egrep –w exon exonerate.fa > fitxer_resultat_exonerate.gff

Obtenció del cDNA en fasta

S'extreu la seqüència que s'ha alineat a l'exonerate amb format fasta, a partir del fitxer gff, utilitzant el programa fastaseqfromGFF.pl. Posteriorment, mitjançant fastatranslate es tradueix el cDNA obtingut a proteïna. Per fer això introduim la seguent comanda:

fastatranslate cdnacandidat > proteinacandidat

On cdnacandidat és la regió que volem traduir.

Aquests programes estan inclosos en boom.bash.

Codi:

#!/bin/bash

export PATH=/cursos/BI/bin/ncbiblast/bin:$PATH             
cp /cursos/BI/bin/ncbiblast/.ncbirc ~/ 
export PATH=/cursos/BI/bin/exonerate/i386/bin:$PATH 
export PATH=/cursos/BI/bin:$PATH 

rm resultats_exonerate.txt 2> error.temp

# Aquest programa inclou exonerate, fastaindex, fastafetch, fastasubseq, fastaseqfromGFF, fastatranslate.
# Contacte: xian.weng01@estudiant.upf.edu

adresa="/cursos/BI/genomes/protists/2012"

# Aqui es troba el fastaindex:
rm -r index
mkdir index

for genome in A.laibachii_Nc14 A.rara C.fasciculata D.discoideum_AX4 D.fasciculatum F.cylindrus G.niphandrodes L.donovani_BPK282A1 L.tarentolae P.capsici P.polycephalum S.arctica T.congolense I.multifiliis_strain_G5; 
	do {
   	fastaindex /cursos/BI/genomes/protists/2012/$genome/genome.fa ./index/$genome.index 

} done

# Això serveix per tenir noves carpetes buides:
rm -r exonerate_output
mkdir exonerate_output
rm -r regions
mkdir regions
rm -r subseq
mkdir subseq
rm -r cDNA
mkdir cDNA
rm -r translate
mkdir translate
for proteins in blast_selec/* ; do {
       for genome in $proteins/* ; do {
               for hit in $genome/*; do {

		### Assignem a les variables els noms sense rutes ni extensions (sense "/exemple/" ni ".etc")
		
		proteins=`basename $proteins`
        	genome=`basename $genome`
        	hit=`basename $hit`
		hit=${hit%.txt}

		echo ${proteins}_${genome}_${hit}:

		### Això és per a detectar l'identificador que apareix al fitxer fasta a la primera línea

		patro1=`cat ./blast_selec/$proteins/$genome/$hit.txt | egrep e-`
		patro2=${patro1#*>}
		echo $patro2 > temppatro
		patro=`cut -f 1 -d " " temppatro`
		rm temppatro       

		### Aixo serveix per saber amb quina regio treballarem
		
		regio=`cut -f 2 ./blast_selec/$proteins/$genome/$hit.txt`
		fastafetch $adresa/$genome/genome.fa ./index/$genome.index $regio > ./regions/$regio.fa

		### Això serveix per obtenir les posicions d'inici i final de la regio

		inici=`cut -f 9 ./blast_selec/$proteins/$genome/$hit.txt`
		final=`cut -f 10 ./blast_selec/$proteins/$genome/$hit.txt`

		if [ "$inici" -gt "$final" ]; then
		inici="$final"
		fi
		
		#definim l'inici 20000 nucleotids per davant de l'inici de l'alineament de blast i d'ençà agafarem 50000 nucleotids per asegurarnos que nos ens deixem res
		start=$(( $inici - 20000 ))
		length="50000"
		echo $start $length

		### fastasubseq : retalla la regió que hem delimitat

		fastasubseq ./regions/$regio.fa $start $length > ./subseq/${proteins}_${genome}_${hit}_genomic.fa 2> error_msg.temp

		### Això ens servirà per modificar variables en cas que no hi hagi prou bases en la regio o que l'inici estigui massa aprop
					
		error=`cat error_msg.temp`
		if [ "$error" != "" ]; then
			error_llarg=`cat error_msg.temp | egrep "before end"`
			error_curt=`cat error_msg.temp | egrep "Unknown flag"`
						
			### Si es passa de llarg, establim la llargada perquè arribi al final
			if [ "$error_llarg" != "" ]; then
				length=$error_llarg						
				length=${length##*(}
				length=${length%)}
				length=$(( $length - $start))
				fastasubseq ./regions/$regio.fa $start $length > ./subseq/${proteins}_${genome}_${hit}_genomic.fa
			fi
						
			### Si l'inici està massa aprop establim l'start en 0
			if [ "$error_curt" != "" ]; then
				start="0"
				fastasubseq ./regions/$regio.fa $start $length > ./subseq/${proteins}_${genome}_${hit}_genomic.fa 2> error_msg_2.temp
				error_2=`cat error_msg_2.temp`
				if [ "$error_2" != "" ]; then
					error_2_llarg=`cat error_msg_2.temp | egrep "before end"`
					if [ "$error_2_llarg" != "" ]; then
						length=$error_2_llarg						
						length=${length##*(}
						length=${length%)}
						length=$(( $length - $start))
						fastasubseq ./regions/$regio.fa $start $length > ./subseq/${proteins}_${genome}_${hit}_genomic.fa 2> error_msg_3.temp
					fi
				fi 
			fi
		fi

		
		### EXONERATE : Predicció de gens
		
		echo "	Iniciant exonerate:"

		exonerate -m p2g --showtargetgff -q ./queries/$proteins.fa -t ./subseq/${proteins}_${genome}_${hit}_genomic.fa --exhaustive > ./exonerate_output/exonerate_${proteins}_${genome}_${hit}.gff 2> error_de_substitucio.temp
	
		### Per si al fasta de sequencia hi ha Us, els substituirem i tornarem a fer l'exonerate.				

		Uenquery=`cat Uenquery.temp | egrep "Unknown amino acid"`
		echo $Uenquery
		if [ "$Uenquery" = "** FATAL ERROR **: Unknown amino acid [U]" ]; then
			if [ "$interruptor_UX" = "0" ]; then
				./changeu.pl < ./queries/$proteins.fa > ${protein}_temporal.txt
				interruptor_UX="1"
			fi
		#Sempre fem servir l'exonerate amb exhaustive tot i trigar més temps però ens dóna més resultats positius per continuar:
			exonerate -m p2g --showtargetgff -q ${proteins}_temporal.txt -t ./subseq/${proteins}_${genome}_${hit}_genomic.fa --exhaustive > ./exonerate_output/exonerate_${proteins}_${genome}_${hit}.gff 2> error_de_substitucio2.temp				
		fi
		gene=`grep gene ./exonerate_output/exonerate_${proteins}_${genome}_${hit}.gff`
		if [ "$gene" != "" ]; then
			echo ${proteins}_${genome}_${hit} : >> resultats_exonerate.txt
		fi

		echo "	Exonerate acabat"	

		#Extracció del cDNA i traducció a proteina				
		
		exon=`grep -w exon ./exonerate_output/exonerate_${proteins}_${genome}_${hit}.gff`
		grep -w exon ./exonerate_output/exonerate_${proteins}_${genome}_${hit}.gff > exon.temp
		if [ "$exon" != "" ]; then
			fastaseqfromGFF.pl ./subseq/${proteins}_${genome}_${hit}_genomic.fa exon.temp > ./cDNA/cDNA_${proteins}_${genome}_${hit}.fa
			fastatranslate ./cDNA/cDNA_${proteins}_${genome}_${hit}.fa > ./translate/aa_${proteins}_${genome}_${hit}.fa
		fi
	
		echo ${proteins}_${genome}_${hit} fet
		
		} done
	} done
} done

rm *.temp

Codi "changeu.pl":

#!/usr/bin/perl

# Aquest programa perl acompanya al programa boom.bash per tal de canviar les Xs per les Us quan correm l'exonerate
# Contacte: xian.weng01@estudiant.upf.edu

use strict;

my @v;
my $string;
my $counter = 0;

#la barra que engloba STDIN s'han de canviar per (més gran que i més petit que per funcionar)
while (/STDIN/)
{
    if ($counter == 0)
    {
	print $_;
    }
    if ($counter > 0)
    {

	@v=split(//,$_);
	
	while (<@v>)
	{
	    if ($_ eq "U")
	    {
		$string.= "X";
	    }
	    else
	    {
		$string.=$_;
	    }
	}
    }
    $counter++;
    $string.="\n";
}

print $string;

Genewise

De manera paral·lela a Exonerate, s'ha realitzat l'anàlisi per Genewise, per tal d’obtenir alineaments del hit de tblastn. A més, el genewise és capaç d'extreure la proteïna predita. Per tal fer fer servir el genewise, la comanda que emprem és:

$ genewise -pep -pretty -cdna -gff fitxerquery.fa genewise.fa

L'automatització del genewise es troba en genewise.bash.

Codi:

#!/bin/bash

#Contacte: xian.weng01@estudiant.upf.edu
#Permisos pels programes:

export WISECONFIGDIR=/cursos/BI/soft/wise-2.2.0/wisecfg
export PATH=/cursos/BI/bin:$PATH

#Per obtenir carpetes buides

rm -r genewise
mkdir genewise
rm -r SECIS
mkdir SECIS
rm -r gw
mkdir gw

#Bucles que escanejen tots els hits per a cada organisme i proteïna (igual que Exonerate)

for proteins in blast_selec/* ; do {
       for genome in $proteins/* ; do {
		for hit in $genome/*; do {
		
		proteins=`basename $proteins`
        	genome=`basename $genome`
        	hit=`basename $hit`
		hit=${hit%.txt}
		
		
		#Si tenim subseq per aquell hit
	
			#Realitzem l'anàlisi resumit per obtenir la proteïna en forward i en reverse
			genewise -pep -both queries/$proteins.fa subseq/${proteins}_${genome}_${hit}_genomic.fa > genewise/genewise_${proteins}_${genome}_${hit}.txt	
			#Realitzem l'anàlisi en versió "maco" per publicar els resultats de l'alineament
			genewise -pep -pretty -cdna -gff queries/$proteins.fa subseq/$subseq/${proteins}_${genome}_${hit}_genomic.fa > gw/gw_${proteins}_${genome}_${hit}.txt
	
			#Seleccionem la proteïna més llarga
			prot=`cat genewise/genewise_${proteins}_${genome}_${hit}.txt`
		
			if [ "$prot" != "" ]; then
		
				./longest.pl < genewise/genewise_${proteins}_${genome}_${hit}.txt > genewise/PEP_g_${proteins}_${genome}_${hit}.fa
		
			echo ${proteins}_${genome}_${hit} fet

		
		fi

		#SECIS search-Busca elements SECIS en la subseq que hem utilitzat per predir la proteïna
		
		SECISearch.pl < subseq/${proteins}_${genome}_${hit}_genomic.fa > SECIS/${proteins}_${genome}_${hit}.txt

		} done

		echo all hits of $genome done
	} done
} done

Codi "longest.pl":

#!/usr/bin/perl -w

#Aquest programa acompanya al programa genewise.bash que permet extreure la proteina predita i ens dona un fitxer preparat pel t_coffee

use strict;

my @v;
my $inici=0;
my $longv=0;
my $c1=0;
my $par1=0;
my $par2=0;
my $temp1="";
my $temp2="";

#la barra que engloba STDIN s'han de canviar per (més gran que i més petit que per funcionar)

while (/STDIN/)
{
    @v=split(//,$_);
    $longv=scalar(@v);
    $c1=0;
    while ($c1 < $longv)
    {
	if ($v[$c1] eq ">")
	{
	    $inici++;
	}
	
	if ($inici==2)
	{
	    $temp2.=$v[$c1];
	    $par2++;
	}
	else
	{
	    $temp1.=$v[$c1];
	    $par1++;
	}
	$c1++;
	
    }

}

if ($par1 > $par2)
{
    print $temp1;
}
else
{
    print $temp2;
}

T_coffee

Utilitzem el programa T_coffee per alinear la nostra seqüència query amb la seqüència de la proteïna obtinguda amb els passos anteriors amb la comanda:

t_coffee fitxer_query.fa prot.fa

Per realitzar-ho fem servir el programa T_coffee.bash.

Amb aquest arxiu, en el que ens mostra és l'alineament entre les dues proteïnes. Es podrà dir que tenim una possible selenoproteïna quan un guió (-) del genoma a analitzar s'alinea amb una selenocisteïna de la query. Si enlloc del guió, s'obté una cisteïna (C) llavors es conclourà que estem davant un d'un possible homòleg de cisteïna.

Codi:

#!/bin/bash

export WISECONFIGDIR=/cursos/BI/soft/wise-2.2.0/wisecfg

rm -r t_coffee_e
mkdir t_coffee_e
rm -r t_coffee_g
mkdir t_coffee_g

# Aquest programa serveix per obtenir els T_coffee dels peptids en exonerate (cal escollir la pauta de lectura manualment i guardar amb el prefix PEP_e_) i del genewise
# Contacte: xian.weng01@estudiant.upf.edu

for file in translate/PEP_e_* ; do {
name=`basename $file`
name=${name%.fa}
name=${name#PEP_e_}

protein=${name%%_*}
echo $name
echo $protein
t_coffee queries/$protein.fa $file > ./t_coffee_e/t_coffee_e_$name.txt 2> error.temp
mv $protein.aln ./t_coffee_e/t_coffee_e_$name.aln
mv $protein.html ./t_coffee_e/t_coffee_e_$name.html
echo $file done
} done

for file in genewise/PEP_g_* ; do {
name=`basename $file`
name=${name%.fa}
name=${name#PEP_g_}

protein=${name%%_*}
echo $name
echo $protein
t_coffee queries/$protein.fa $file > ./t_coffee_g/t_coffee_g_$name.txt 2> error.temp
mv $protein.aln ./t_coffee_g/t_coffee_g_$name.aln
mv $protein.html ./t_coffee_g/t_coffee_g_$name.html
echo $file done
} done

rm *.temp

Blastp

Un cop confirmat el correcte alineament entre la query i la regió del genoma que hem analitzat, realitzem un blastp per veure si la proteïna obtinguda té els dominis característics de la seva família de selenoproteïnes.

Recerca d'elements SECIS

Les selenoproteïnes necessiten elements SECIS en 3' per portar a terme la traducció. Es busquen aquests elements en els nostres contigs ja que seran indicatius de la presència de selenoproteïnes. Per a dur a terme aquesta tasca fem servir el programa SECISearch 2.19 .

SECISearch localitza els elements SECIS i en prediu l'estructura tridimensional. En una primera inst'ancia, el programa empra criteris m´es restrictius per`o si no d´ona resultats podem escollir criteris m´es permisius. En el nostre cas en particular, l'automatitzaci´o del SECISearch es troba en el mateix programa que el genewise.bash

Cerca de maquinària de traducció

La presència de les proteïnes que conformen la maquinària de traducció de selenoproteïnes en el genoma del microorganisme analitzat dona més fiabilitat a la hipòtesi que en efecte, el microorganisme determinat té selenoproteïnes. Per això, hem analitzat les proteïnes eEF-Sec, Pstk, SBP2, SEc43, Sec S, Sps 2 i tRNA-Sec. Si el resultat del blastp que hem realitzat és positiu, és a dir, troba una proteïna homòloga, significa que el microorganisme té la maquinària.

Maneig d'informació

Per tal de manejar les dades de manera eficient vàrem crear un compte Dropbox en el que hem anat treballant com a una carpeta dins de la nostra UXXXXX/Dropbox. Aquesta sessió del Dropbox s'hi accedia mitjançant la terminal de l'ordinador. A més, si descarregàvem el programa Dropbox amb dropbox.bash ens permetia treballar de manera simultània entre els diferents ordinadors com si fós una carpeta qualsevol en el mateix ordinador. Així aquest sistema ens ha proporcionat una avantatge per la seva contínua i automatica sincronització de carpetes que ens evitava la pèrdua de dades si l'ordinador es bloquejava.

Recerca de selenoproteïnes
en Protistes

APARTATS

MATERIALS I MÈTODES

OBTENCIÓ DE DADES

Query

Genomes

BLAST: alineament de seqüències

Extracció genomica

Fastaindex

Fastafetch

Fastasubseq

Anotació genomica

Exonerate

Obtenció del cDNA en fasta

Genewise

T_coffee

Blastp

Recerca d'elements SECIS

Cerca de maquinària de traducció

Maneig d'informació

Recerca de selenoproteïnes en Protistes

APARTATS

MATERIALS I MÈTODES

OBTENCIÓ DE DADES

Query

Genomes

BLAST: alineament de seqüències

Extracció genomica

Fastaindex

Fastafetch

Fastasubseq

Anotació genomica

Exonerate

Obtenció del cDNA en fasta

Genewise

T_coffee

Blastp

Recerca d'elements SECIS

Cerca de maquinària de traducció

Maneig d'informació

Recerca de selenoproteïnes
en Protistes