8 de febrero de 2013

Filogenias universales 16S

Un obituario en el último número de Science (8 Feb 2013) me ha hecho recordar el tremendo impacto que ha tenido el trabajo del desaparecido Carl Woese en nuestra visión de la historia evolutiva, ya que a partir de sus logros pudimos comparar por primera vez con precisión molecular las historias evolutivas de linajes tan distantes como las bacterias y los animales. Además de descubrir por el camino nada menos que a las arqueobacterias, el uso de las secuencias de los genes ribosomales 16S como fuente de información filogenética todavía es rutinario, a pesar de sus limitaciones y de los avances tecnológicos, y a pesar de que ahora se hable más de redes que de árboles. Si no que se lo pregunten a los que se dedican a la metagenómica...

En las siguientes figuras se resume el impacto de la introducción de los análisis de genes 16S:

Árbol filogenético de Haeckel (tomado de http://mmbr.asm.org/content/51/2/221.long).
Árbol de distancias basado en el alineamiento de 260 secuencias de rRNA 16S (tomado de http://mmbr.asm.org/content/51/2/221.long).

Al releer la revisión de Woese del año 1987 lo que más me ha sorprendido ha sido ver que no sólo se usó secuencias, sino que se molestó en analizar en detalle la estructura de los RNAs ribosomales, e incluso localizó a nivel de estructura secundaria las zonas que permitían distinguir los grandes linajes evolutivos, como se muestra en la siguiente figura. Está ya todo inventado también aquí?

(tomada de http://mmbr.asm.org/content/51/2/221.long)

Un saludo y buen finde,
Bruno




22 de enero de 2013

Tutorial en el congreso BIFI2013

Hola,
nuestro laboratorio (www.eead.csic.es/compbio) coordinará un tutorial el viernes 1 de Febrero a las 15.00 horas como parte del congreso BIFI 2013. El título es:



Taller de análisis bioinformático de proteínas reguladoras

Resumen: En este taller veremos cómo estudiar por medio de herramientas bioinformáticas propiedades de las proteínas reguladoras, como las regiones intrínsecamente desordenadas, su interfaz de reconocimiento de ADN y la predicción de posibles elementos cis.

Duración: 2 horas

Cómo llegar: http://goo.gl/maps/RFJmj 

Un saludo,
Bruno

PD Un artículo nuestro reciente donde estudiamos el desorden en plantas: http://www.biomedcentral.com/1471-2229/12/165

11 de enero de 2013

Indexando archivos FASTA

Hola y feliz año nuevo con retraso!
Recientemente me he visto en la necesidad de acceder de maneara aleatoria a secuencias de un archivo FASTA de gran tamaño, en mi caso cercano a los 2 Gb,
con las secuencias formateadas en una sola línea.

Primero probé con las herramientas de BLAST+, en concreto:
$ makeblastdb -in archivo.fasta -parse_seqid

Con la idea de posteriormente consultar las secuencias con algo como (más ejemplos aquí):

$ blastdbcmd -query -db archivo.fasta

Sin embargo, la generación del índice se hizo eterna y de hecho la aborté, por problemas que desconozco y no he seguido mirando.

Posteriormente, tras buscar en Google encontré dos caminos en Perl:

1)  con ayuda de scripts de Bioperl: bp_index.pl y bp_fetch.pl

2) con ayuda del módulo core Tie::File, como muestro en el ejemplo a continuación, mi solución preferida, un saludo:

 #!/usr/bin/perl -w  
 use strict;  
 use Tie::File;  
   
 my $fasta_file = '/path/to/file.fasta';  
   
 my (%index_fasta,@fasta_array);  
 open(FASTA,$fasta_file) ||   
    die "# cannot open $fasta_file\n";  
 while(<FASTA>)  
 {  
    if(/^> any typical marker in header, such as gi (\S+)/)  
    {  
       $index_fasta{$1} = $.;   
    }  
 }  
 close(FASTA);   
 printf("# indexed %d sequences in file %s\n\n",  
    scalar(keys(%index_fasta)),$fasta_file);  
   
 tie(@fasta_array,'Tie::File',$fasta_file) ||   
    die "# cannot tie file $fasta_file\n";  
   
 print "ejemplo: secuencia con identificador 'id12':\n";  
 print "$fasta_array[$index_fasta{'id12'}-1]\n".  
    "$fasta_array[$index_fasta{'id12'}]\n";  

21 de diciembre de 2012

Bioinformatic Merry Christmas!!!

My boss is very nervous when I prepare this blog entry at the end of December, and this 'crisis' year I wanted to prepare the best bioinformatic inspirated Christmas card ever..
Merry Bioinformatic Christmas!

If you are not as geek as us, here is written in flat words... MERRY CHRISTMAS AND HAPPY NEW YEAR 2013!!!

If you want to replicate the Christmas greeting, go to this link, or to the 'retrieve' section in UniProt and introduce the following protein identifiers: P0A183, O02437, Q40309, Q6L5Z2, E0ZPQ6.
 

30 de noviembre de 2012

comparando secuencias de igual longitud

Hola,
hoy quería compartir recetas en Perl para la comparación eficiente de secuencias de igual longitud. Las dos funciones que vamos a ver devuelven como resultado listas con las posiciones (contando desde 0) en las que difieren dos secuencias.

Para qué sirve esto? En general, para calcular distancias de edición (edit distances); en bioinformática es una manera, por ejemplo, de comparar oligos de igual longitud o secuencias extraídas de un alineamiento múltilple, incluyendo gaps. El siguiente código fuente incluye una subrutina en Perl (con el operador binario ^ y la función pos) y otra en C embebido para hacer la misma operación por dos caminos:

 use strict;  
 use warnings;  
 my $seq1 = 'ACTGGA';  
 my $seq2 = 'AGTG-A';  
   
 my @Pdiffs = find_diffs($seq1,$seq2);  
 my @Cdiffs = find_diffs_C($seq1,$seq2);  
   
 printf("# version Perl\ndiferencias = %d\n%s\n",scalar(@Pdiffs),join(',',@Pdiffs));  
 printf("# version C\ndiferencias = %d\n%s\n",scalar(@Cdiffs),join(',',@Cdiffs));  
   
 sub find_diffs  
 {  
    my ($seqA,$seqB) = @_;  
    my $XOR = $seqA ^ $seqB; 
    my @diff;   
    while($XOR =~ /([^\0])/g)  
    {   
       push(@diff,pos($XOR)-1);  
    }  
    return @diff;  
 }  
   
 use Inline C => <<'END_C';  
 void find_diffs_C(char* x, char* y)   
 {                        
   int i;   
    Inline_Stack_Vars;                               
   Inline_Stack_Reset;                                                                
   for(i=0; x[i] && y[i]; ++i) {                          
    if(x[i] != y[i]) {                              
     Inline_Stack_Push(sv_2mortal(newSViv(i)));                 
    }                                       
   }   
    Inline_Stack_Done;                                                                  
 }     
 END_C  
Podéis ver en stackoverflow otras versiones y su comparación en base a su tiempo de cálculo,
un saludo,
Bruno