Dominios de función desconocida (DUF) en proteínas

Hola,

como ya hemos mencionado en otras ocasiones aquí, las proteínas habitualmente tienen uno o más dominios con determinadas funciones. Por eso cuando analizas secuencias de proteínas recursos como Pfam (incluída en Interpro) o CDD son muy útiles.

El crecimiento de las colecciones de secuencias es tan rápido que a veces se definen dominios o familias de proteínas sin saber realmente qué función tienen. Sabemos que existen, porque sus secuencias están conservadas en los genomas de diferentes organismos y se pueden alinear, pero todavía no hay evidencias de en qué procesos bioquímicos participan. Son los llamados Domains of Unknown Function (DUF).

Hace unos unos años Carlos Cantalapiedra y yo descubrimos tránscritos en cebada y en Arabidopsis thaliana que contenían dominios DUF. Entre ellos está por ejemplo DUF3615, pero todavía no sabemos si son importantes o no:

Figura 1. Dominios de Pfam encontrados en tránscritos accesorios de Arabidopsis thaliana (izq) y cebada (der). Fuente: https://doi.org/10.3389/fpls.2017.00184

La continuación de esta historia la encontramos en un artículo muy reciente, donde los autores descubren una pareja de proteínas, una de ellas DUF1644, que tanto en arroz como maiz interaccionan entre ellas y, al hacerlo, afectan al número de granos producidos, un caracter de enorme interés en la agricultura:

Figura 2. Interacción entre KRN2 y DUF1644 confirmada en ensayos Y1H (A) y ensayos de complementación con luciferasa en hojas de tabaco(B). Adaptada de https://doi.org/10.1126/science.abg7985

 

Queda claro que los dominios DUF son una fuente interesante por explorar. Lo lógico sería que con el tiempo se vayan convirtiendo en familias de función conocida, pero la verdad es que este ejemplo tampoco nos dice mucho de la  función de DUF1644, solamente que interacciona con otras proteínas.

Hasta pronto,

Bruno

modelado comparativo de proteínas multidominio

Hola,
en muchas ocasiones el modelado por homología o comparativo es  la única manera que tenemos trabajar con la estructura de una proteína que todavía no está en el Protein Data Bank. De hecho muchos artículos han sido publicados con figuras construidas sobre este tipo de modelos porque ayudan a comprender y poner en contexto tridimensional los resultados.

Interfaz entre dos monómeros modelada por homología, tomada de https://science.sciencemag.org/content/364/6445/1095.

Sin embargo, casi todas las herramientas que existen para modelar proteínas se han centrado históricamente en modelar dominios de proteína uno a uno, cuando la realidad es que muchas proteínas contienen varios dominios. Precisamente para modelar las conformaciones de este tipo de proteínas ha sido publicado recientemente https://zhanglab.ccmb.med.umich.edu/DEMO.

Diagrama de flujo de DEMO, tomado de https://www.pnas.org/content/116/32/15930.

Con la ayuda de DEMO podrás ensamblar dominios previamente modelados de dos en dos. El algoritmo consulta una colección no redundante de estructuras multidominio y optimiza las orientaciones entre dominios, además de que puede usar datos experimentales (cross-linking y crioEM) para guiar el proceso.

Un saludo, Bruno

Probando deltablast

Hola,
hace tiempo que tenía pendiente escribir sobre una de las ramas más recientes de la familia de programas BLAST, que se llama deltablast, publicada el año pasado. La lectura del artículo original sugiere que este programa se desarrolló a partir de la publicación del algoritmo CS-BLAST (context specific BLAST).
Pero realmente la historia no comienza aquí.
Todo empezó con el algoritmo PSI-BLAST, una versión iterativa de BLASTP, que en vez comparar una secuencia de proteína contra una librería de secuencias, construye un perfil de la secuencia problema y ése es el que compara contra la librería, ganando en sensibilidad. Todo esto con un coste en tiempo de cálculo modesto.
Qué problema tiene esto? Pues que el perfil se construye en tiempo real con los homólogos encontrados en iteraciones previas de manera automática y en ocasiones se pueden contaminar y producir resultados no idóneos.

(tomada de http://www.ncbi.nlm.nih.gov/pmc/articles/PMC2645910)

CS-BLAST, que en realidad es como un preprocesamiento de BLAST, logró superar estos problemas precalculando los perfiles, que capturan información del contexto, y de hecho mejoró la sensibilidad a la hora de detectar homólogos remotos, que han perdido claramente la similitud de secuencia.

Pues bien, deltablast es un programa del NCBI que se inspira en estas experiencias para superar a capacidad de búsqueda de CS-BLAST, apoyándose en la colección de dominios Conserved Domains Database (CDD):

(tomada de http://www.biology-direct.com/content/7/1/12)

El programa es muy sencillo de usar en la web, aquí os explico como probarlo localmente en vuestra máquina:
1) descarga la última versión de BLAST+ para tu arquitectura de
ftp://ftp.ncbi.nih.gov/blast/executables/LATEST
 
2) descomprime el software en una carpeta, por ejemplo soft/

3) descarga una copia de CDD de ftp://ftp.ncbi.nih.gov/blast/db/cdd_delta.tar.gz

4) descomprime la base de dominios en un carpeta, de nuevo por ejemplo en  soft/

5) elige una colección de secuencias protéicas contra la que buscar, por ejemplo soft/nr.faa y formatéala con:
 $ soft/ncbi-blast-2.2.27+/bin/makeblastdb nr.faa
 
6) Ya puedes buscar una secuencia de proteína, como ejemplo.faa, contra tu colección de secuencias:
$ soft/ncbi-blast-2.2.27+/bin/deltablast -query ejemplo.faa -db soft/nr.faa -rpsdb soft/cdd_delta

7) Puedes utilizar prácticamente los mismos parámetros que con BLASTP, que puedes consultar haciendo:
$ soft/ncbi-blast-2.2.27+/bin/deltablast -help

Suerte!
Bruno

Gráfico sencillo de dominios sobre secuencia (glifo)

El problema que nos ocupa hoy es el de representar gráficamente dominios o regiones sobre una secuencia de referencia. Quizás el ejemplo más típico sea el de mapear los resultados de una búsqueda BLAST sobre la secuencia de partida, que no siempre alinean contra la secuencia completa.
Por ejemplo, dada una secuencia de 935 aminoácidos, BLAST me devuelve un alineamiento que solapa desde la posición 23 a la 512. Cómo podemos representar esto gŕaficamente de manera sencilla? Es posible usar BioPerl para este fin, como se explica en el taller de (bio)perl, pero si queremos un diagrama como este,


que representa la longitud total de la secuencia y marca el segmento alineado a escala, es mejor recurrir al módulo GD, como se muestra en este programa:

1:  #!/usr/bin/perl -w
2:  # prog2.pl: crea barra PNG con uno o más dominios sobre secuencia de referencia
3:
4:  use strict;
5:  use GD;
6:
7:  # variables globales que definen el tamaño de la figura rectangular
8:  my $ANCHOFIGURA = 100;
9:  my $ALTOFIGURA = 8;
10:  my @COLORDOMINIO= (150,150,150); # en 3 canales RGB
11:
12:  # ejemplo: secuencia de 935 aminoácidos, con un dominio reconocido del 23 al 512
13:  if(pinta_dominios_secuencia(935,'23:512','panel.png'))
14:  {
15:    print "# archivo de salida: panel.png\n";
16:  }
17:
18:  sub pinta_dominios_secuencia
19:  {
20:    # argumentos:
21:    # 1) tamaño de secuencia de referencia
22:    # 2) cadena con dominios separados por compas, como: '23:78,123:189'
23:    # 3) nombre de archivo PNG de salida
24:    my ($length,$domain_definitions,$outPNGfilename) = @_;
25:
26:    my ($n_of_domains,$dom,@domains,$startd,$endd) = (0);
27:
28:    # comprueba los dominios
29:    foreach $dom (split(/,/,$domain_definitions))
30:    {
31:      if($dom =~ /(\d+):(\d+)/)
32:      {
33:        ($startd,$endd) = ($1,$2);
34:        if($startd<1 || $endd > $length)
35:        {
36:          print "# pinta_dominios_secuencia: dominio incorrecto ($dom)\n";
37:          next;
38:        }
39:
40:        push(@domains,[$startd,$endd]);
41:        $n_of_domains++;
42:      }
43:      else{ print "# pinta_dominios_secuencia: dominio incorrecto ($dom)\n"; }
44:    }
45:
46:    if(@domains)
47:    {
48:      my $imagen = GD::Image->new($ANCHOFIGURA,$ALTOFIGURA);
49:
50:      # define colores básicos en 3 canales RGB
51:      my $blanco= $imagen->colorAllocate(255,255,255);
52:      my $negro = $imagen->colorAllocate(0,0,0);
53:      my $color = $imagen->colorAllocate(@COLORDOMINIO);
54:
55:      # crea panel rectangular con dimensiones globales $ANCHOFIGURA y $ALTOFIGURA
56:      $imagen->filledRectangle(0, 0, $ANCHOFIGURA, $ALTOFIGURA, $blanco); # fondo
57:      $imagen->rectangle(0, 0, $ANCHOFIGURA-1, $ALTOFIGURA-1, $negro); # borde
58:
59:      # añade dominios
60:      foreach $dom (@domains)
61:      {
62:          # calcula dimensiones del dominio a escala, eje X
63:          $startd = int( $ANCHOFIGURA * ( $dom->[0] / $length ) );
64:          if($startd < 1){ $startd = 1 } # evita pisar el borde
65:          $endd  = int( $ANCHOFIGURA * ( $dom->[1] / $length ) );
66:          if($endd > $ANCHOFIGURA-2){ $endd = $ANCHOFIGURA-2 } # evita pisar el borde
67:          # con 1 y -2 evitamos el borde en eje Y
68:          $imagen->filledRectangle($startd, 1, $endd, $ALTOFIGURA-2, $color);
69:      }
70:
71:      open(PNG,">$outPNGfilename")
               || die "# pinta_dominios_secuencia: no puedo crear $outPNGfilename\n";
72:      binmode PNG;
73:      print PNG $imagen->png();
74:      close(PNG);
75:    }
76:
77:    return $n_of_domains;
78:  }