Mostrando entradas con la etiqueta proteína. Mostrar todas las entradas
Mostrando entradas con la etiqueta proteína. Mostrar todas las entradas

28 de julio de 2017

Tabla de estabilidad de sustituciones de aminoácidos

Hola,
a menudo nos preguntamos qué efecto puede tener un cambio de aminoácido sobre la estabilidad de una proteína. Una pregunta relacionada es si tendrá fenotipo una sustitución no sinónima (missense). De hecho hay toda una colección de herramientas que se han desarrollado para esto (ver por ejemplo el curso de bioinformática estructural). El trabajo reciente de Rocklin et al (2017), donde estudian la estabilidad de miles de miniproteínas (hasta 50aa) sintéticas y unas 500 naturales del PDB, nos proporciona la mejor respuesta hasta la fecha. Aunque es un artículo complejo, en esencia lo que hacen es medir la estabilidad de miles de proteínas expresándolas y exponiéndolas a proteasas en levadura.
De esa manera pueden estimar el efecto que tienen mutaciones individuales dependiendo de su contexto de estructura secundaria, ya sea una alfa-hélice, una lámina beta o un lazo o loop:
Efecto sobre la estabilidad de mutaciones en diferentes contextos estructurales. Los valores negativos, como los de la prolina en general, son desestabilizadores. Adaptada de http://science.sciencemag.org/content/357/6347/168.full.

En la siguiente figura se muestran ejemplos de mutaciones desestabilizadoras en amarillo:

Adaptada de http://science.sciencemag.org/content/357/6347/168.full.

Hasta pronto,
Bruno

13 de febrero de 2016

Expresión regular de la familia de las O-fucosiltransferasas



Hola, 
el pasado 8 de febrero se publicó en la revista Nature Chemical Biology  (http://dx.doi.org/10.1038/nchembio.2019) un artículo donde se  describen las bases moleculares de la reacción de O-fucosilación. Ésta es una modificación postraduccional poco frecuente, que realizan las enzimas O-fucosiltransferasas, como nos explica la investigadora de nuestro grupo Inmaculada Yruela, una de las autoras del trabajo [reseña completa en www.eead.csic.es]:

"Esta reacción resulta esencial en algunas rutas metabólicas de los organismos eucariotas, incluidas las plantas, para mantener las funciones básicas de las células. El artículo describe el mecanismo por el cual la enzima O-fucosiltransferasa 2 (POFUT2) reconoce sin errores una secuencia de aminoácidos (TSR) de la proteína receptora y le transfiere una molécula de azúcar tipo fucosa –así resulta fucosilada–. Hasta la fecha no se conocía cómo estas enzimas reconocen y se unen a sus sustratos proteicos. La O-fucosilación es esencial para el correcto plegamiento y estabilidad del dominio TSR y el reconocimiento molecular de POFUT2."
Como se ve en el alineamiento, el dominio TSR contiene tres puentes disulfuro y una secuencia consenso en torno a los dos primeras cisteínas CX{2,3}[S|T]CX{2}G , lo que se llama un motivo, como los del repositorio Prosite:
Fragmento de un alineamiento múltiple de dominios TSR, tomado de http://dx.doi.org/10.1038/nchembio.2019

Tras alinear algunas secuencias de ejemplo y perfeccionar la expresión regular, ésta se empleó para identificar todas las secuencias con dominios TSR en los proteomas de Homo sapiens y Caenorhabditis elegans. Más generalmente, el siguiente trozo de código permite localizar dentro de un fichero FASTA todas las secuencias reconocidas por una expresión regular:
 #!/usr/bin/perl  
 use strict;  
   
 # script that takes a FASTA file(s) and scans all protein sequences   
 # looking for matches of a chosen motif expressed as a regular expression  
 # 11042015: edited following comments by JF
   
 # constant as indices to access read_FASTA_file arrays  
 use constant NAME => 0;   
 use constant SEQ => 1;  
   
 #my $motifRE = '.*C[^C]{0,21}.C[^C]{2,6}[S|T].C[^C]{4,75}C[^C]C[^C]{4,15}C.*'; 
 my $motifRE = 'C[^C]{0,21}.C[^C]{2,6}[ST].C[^C]{4,75}C[^C]C[^C]{4,15}C';
   
 if(!@ARGV){ die "# usage: $0  ... \n"; }  
 else{ print "# motif: $motifRE\n"; }  
   
 my ($n_of_matches,@matches) = (0);  
 foreach my $infile (@ARGV)  
 {  
   next if($infile !~ /.fa/);  
   my (@FASTA,$start,$end,$l);  
   my $n_of_sequences = -1;  
   open(FASTA,"<$infile") || die "# cannot read $infile $!:\n";  
   while()  
   {  
    next if(/^$/);  
    if(/^\>(.*?)[\n\r]/)  
    {  
      $n_of_sequences++;   
      $FASTA[$n_of_sequences][NAME] = $1;  
    }                
    else  
    {  
      s/[-\s\n.]//g; #s/[\s|\n|\-|\.]//g;  
      $FASTA[$n_of_sequences][SEQ] .= $_;  
    }  
   }  
   close(FASTA);  
   
   foreach my $seq ( 0 .. $n_of_sequences )  
   {  
    while($FASTA[$seq][SEQ] =~ m/($motifRE)/gi)   
    {  
      #$start=length($`);  
      #$l=length($1);  
      #$end=$start+$l;  

      $start = $-[1];
      $end   = $+[1];
      $l     = $end - $start + 1;

      print ">$FASTA[$seq][NAME] match=($start,$end,$l)\n$1\n";           
    }  
   }  
 }  

Un saludo,
Inma y Bruno

19 de diciembre de 2011

metaDBSite: un metaservidor para predecir la unión de proteínas a DNA

Los meta-servidores son valiosas herramientas en bioinformática para no perder el tiempo mandando trabajos a diferentes servidores y tener que juntar después manualmente los resultados. Un meta-servidor nos ofrece utilizar varios servicios web a la vez desde una interfaz única. Ejemplos de meta-servidores son: NCBI, UniProt, GeneSilico...

Recientemente he  tenido que usar diferentes programas de predicción de interfaces de unión proteína-DNA, y he encontrado la grata sorpresa de que existía un meta-servidor que permitía realizar la predicción de una sola vez utilizando la mayoría de técnicas conocidas, este valioso meta-servidor se llama metaDBSite. No sólo eso, si no que he podido comprobar que siguen dándole soporte.

Os animo a probarlo con una sencilla secuencia proteica:
>1a02_N  
 wplssqsgsyelrievqpkphhRahYetEgsRgavkaptgghpvvqlhgymenkplglqifigtaderilkphafyqvhritgktvtttsyekivgntkvleiplepknnmratidcagilklrnadielrkgetdigRkntrvrlvfrvhipessgrivslqtasnpiecsQRsahelpmverqdtdsclvyggqqmiltgqnftseskvvftekttdgqqiwemeatvdkdksqpnmlfveipeyrnkhirtpvkvnfyvingkrkrsqpqhftyhpv  

Si comprobáis los resultados con los datos de la estructura original (cadena N de la estructura 1a02) podréis ver cómo el mejor de los métodos (BindN-RF) 'adivina' 7 de los 7 residuos que contactan el DNA entre los 18 predichos, si tenemos en cuenta que la proteína tienen 280 aminoácidos, el resultado no está nada mal...




23 de noviembre de 2011

'Fold it' o como el juego agudiza el ingenio

Buenas,
desde hace al menos una década el grupo de David Baker (U.Washington) ha tenido un impacto tremendo en el estudio del plegamiento de las proteínas, yo diría que hasta el punto de ir cocinando poco a poco un premio Nobel, pero el tiempo dirá. Muy brevemente, su trabajo ha consistido en desarrollar algoritmos para la predicción de la estructura de proteínas (por comparación y ab initio) que han ido refinando en sucesivas rondas de CASP (donde siempre quedan entre los mejores) y poniendo a punto con experimentos bastante espectaculares donde comparan sus predicciones con estructuras obtenidas por cristalografía y NMR, obteniendo modelos de una calidad y complejidad sin precedentes, llegando por ejemplo a diseñar una proteína artificial y predecir su estructura terciaria con un error promedio de 1.2A. Una de las aportaciones más extravagantes de este laboratorio tan productivo fue la creación de un juego basado en el problema del plegamiento, que llamaron FoldIt.


El juego permite poner a jugadores de todo el mundo a resolver ejercicios de plegamiento de dificultad variable, tras superar un tutorial donde aprendes las reglas del juego y las herramientas disponibles. La verdad es que hasta hoy no he encontrado una manera más amena de entender qué es un puente de hidrógeno o un choque estérico. Enfin, a lo que voy, lo que parecía simplemente un intento por popularizar el 'problema del plegamiento', que a día de hoy todavía se considera sin resolver, se ha convertido también en una herramienta de innovación, como se publica en el último número de PNAS. Tras estudiar la evolución de las estrategias ganadoras encontradas por la comunidad jugadores, que se pueden guardar como recetas, se observa que se parecen mucho a los propios algoritmos que el grupo de Baker está desarrollando. O dicho de otro modo, parecería que poniendo en forma de juego un problema complejo como esto, con puntuaciones objetivas y reglas sencillas, el ingenio colectivo puede llegar a soluciones parecidas a las de los científicos especialistas, sorprendente?
Un saludo,
Bruno

4 de junio de 2010

Evaluación de un alineamiento de proteínas

Un alineamiento de secuencias proteicas se puede evaluar numéricamente comparando las identidades entre los aminoácidos alineados. Se puede asignar una puntuación a cada par de aminoácidos usando una matriz de sustitución, que describe el ritmo al que un aminoácido en una secuencia cambia a otro a lo largo de la evolución natural.

Las matrices de sustitución más utilizadas son las PAM y las BLOSUM. Éstas matrices son las que utiliza el famoso programa de alineamiento BLAST.

En el siguiente ejemplo se mostrará una sencilla  subrutina en Perl que evalúa un alineamiento de proteínas utilizando la matriz BLOSUM62. Las dos secuencias alineadas se pasan como sendas cadenas de caracteres:


1:  # prog3.pl Evalúa un alineamiento
2:  sub score_alignment {  
3:       my ($type,$score_matrix,$seq1,$seq2)=@_;  
4:       my (@indices,@matrix,@score_results);  
5:       if ($score_matrix eq 'blosum62'){  
6:            @indices = ('C', 'S', 'T', 'P', 'A', 'G', 'N', 'D', 'E', 'Q', 'H', 'R', 'K', 'M', 'I', 'L', 'V', 'F', 'Y', 'W');  
7:            @matrix = (  
8:                 [9, -1, -1, -3, 0, -3, -3, -3, -4, -3, -3, -3, -3, -1, -1, -1, -1, -2, -2, -2],  
9:                 [-1, 4, 1, -1, 1, 0, 1, 0, 0, 0, -1, -1, 0, -1, -2, -2, -2, -2, -2, -3],  
10:                 [-1, 1, 4, 1, -1, 1, 0, 1, 0, 0, 0, -1, 0, -1, -2, -2, -2, -2, -2, -3],  
11:                 [-3, -1, 1, 7, -1, -2, -1, -1, -1, -1, -2, -2, -1, -2, -3, -3, -2, -4, -3, -4],  
12:                 [0, 1, -1, -1, 4, 0, -1, -2, -1, -1, -2, -1, -1, -1, -1, -1, -2, -2, -2, -3],  
13:                 [-3, 0, 1, -2, 0, 6, -2, -1, -2, -2, -2, -2, -2, -3, -4, -4, 0, -3, -3, -2],  
14:                 [-3, 1, 0, -2, -2, 0, 6, 1, 0, 0, -1, 0, 0, -2, -3, -3, -3, -3, -2, -4],  
15:                 [-3, 0, 1, -1, -2, -1, 1, 6, 2, 0, -1, -2, -1, -3, -3, -4, -3, -3, -3, -4],  
16:                 [-4, 0, 0, -1, -1, -2, 0, 2, 5, 2, 0, 0, 1, -2, -3, -3, -3, -3, -2, -3],  
17:                 [-3, 0, 0, -1, -1, -2, 0, 0, 2, 5, 0, 1, 1, 0, -3, -2, -2, -3, -1, -2],  
18:                 [-3, -1, 0, -2, -2, -2, 1, 1, 0, 0, 8, 0, -1, -2, -3, -3, -2, -1, 2, -2],  
19:                 [-3, -1, -1, -2, -1, -2, 0, -2, 0, 1, 0, 5, 2, -1, -3, -2, -3, -3, -2, -3],  
20:                 [-3, 0, 0, -1, -1, -2, 0, -1, 1, 1, -1, 2, 5, -1, -3, -2, -3, -3, -2, -3],  
21:                 [-1, -1, -1, -2, -1, -3, -2, -3, -2, 0, -2, -1, -1, 5, 1, 2, -2, 0, -1, -1],  
22:                 [-1, -2, -2, -3, -1, -4, -3, -3, -3, -3, -3, -3, -3, 1, 4, 2, 1, 0, -1, -3],  
23:                 [-1, -2, -2, -3, -1, -4, -3, -4, -3, -2, -3, -2, -2, 2, 2, 4, 3, 0, -1, -2],  
24:                 [-1, -2, -2, -2, 0, -3, -3, -3, -2, -2, -3, -3, -2, 1, 3, 1, 4, -1, -1, -3],  
25:                 [-2, -2, -2, -4, -2, -3, -3, -3, -3, -3, -1, -3, -3, 0, 0, 0, -1, 6, 3, 1],  
26:                 [-2, -2, -2, -3, -2, -3, -2, -3, -2, -1, 2, -2, -2, -1, -1, -1, -1, 3, 7, 2],  
27:                 [-2, -3, -3, -4, -3, -2, -4, -4, -3, -2, -2, -3, -3, -1, -3, -2, -3, 1, 2, 11]  
28:            );  
29:       }  
30:       if (length($seq1)==length($seq2)){  
31:            my @seq1 = split(//,$seq1);  
32:            my @seq2 = split(//,$seq2);  
33:            for (my $i=0; $i<=$#seq1; $i++) {  
34:                 # Find letters position in matrix  
35:                 my ($pos1) = grep { $indices[$_] eq $seq1[$i] } 0 .. $#indices;  
36:                 my ($pos2) = grep { $indices[$_] eq $seq2[$i] } 0 .. $#indices;  
37:                 if (defined($pos1) && defined($pos2)){  
38:                      push (@score_results, $matrix[$pos1][$pos2]);  
39:                 } else {  
40:                      push (@score_results, '-');  
41:                 }  
42:            }  
43:       } else {  
44:            die "# Both sequences must have the same length to score the alignment\n";  
45:       }  
46:       return @score_results;  
47:  }