Construction hash intron [Résolu]

[shadow19c]

Bonjour,merci pour ton aide si precieuse (mme la bioinformaticienne), le but c'est a partir du premier programme le hash , on a construit le hash des introns identifier par l'identifiant Aster-***** avec le numero d'acide amine (position) qui donne la taille, pareil pour CV-****, ensuite je fais un blast qui fait un blast des orthologues grace au fichier reciprocal best blast hits;
Donc je dois apres les commandes que je lance recuperer le fichier out.bl, En fait mon programme doit a partir de collection de position de deux sequences pour query my @positions=(24,48,54,92,137,235,275,324)
et subject my @positions=(25,60,80,192), aller verifier si ces positions existent sur l'alignement et si ces positions sont l'une face a l'autre.
Je m'explique mieux:
on prend un exemple si je prend le premier bloc
Query: 160 DSVIAAMSKRGQDRLHHVIRILAEKGHVKELATAFYGNYTVQDLLDATHXXXXXXXXXXX 219
+ I A+ ++ +L V+ IL E G V EL T ++GNY++QDL++A
Sbjct: 264 EQAINALQRKSYQKLTRVVDILIESGKVPELVTHYFGNYSIQDLMEACFKLRKSFEKQGR 323

je dois prendre en premier l'index de chaque sequence : 160 pour query et 264 pour subject ,ceci nous permet de nous positionner sur les sequences en effet, lorsque nous allons commencer le lecture des tables, on saura que la lettre D est positionne a 160, puis S a 161 ainsi de suite pour query , et E 264 pour subject. ENsuite pour chque position je verifie si cette position nexiste pas dans ma collection,ainsi si par exemple javais une lettre qui etait a la position 54 pour query et qu'en face(Ceci est important, il faut que la lettre de subject soit en face) j'ai une lettre qui est a la position 80, donc comme deux positions qui existent dans les tables positions et quils sont en face l'une a lautre alors cest bon je renvoi ces deux valeurs 54 et 80, et je continue la lecture jusqua la fin du bloc et puis je continue la meme chose pour les autres blocs recursivement.

EN faisant attention que si jai un x ou - soit sur query ou subject je passe et je fais avancer mes curseurs en meme temps, donc je saute la partie ou il y a X ou - sur la sequence ou il ya mais aussi sur la sequence den face meme si ces des lettres je dois avancer de la meme facon sur les deux sequences;

En fait, si je prend les deux sequences d'un bloc je mets dans une table et javance les curseurs en meme temps position un par un je pourrai faire ceci.


Donc je dois automatiser le systeme en construisant les hashs je les laisse , ensuite pour chaque couple Aster-*** CV-**** je fais le bast, sorti out;bl je bloque le systeme , je cherche les introns orthologues, ensuite si il existe je renvoi la taille des intron qui correspondent $hash{$id}{$aa}=$taille;

Pour chaque couple, et je recommence pour les autres couples.

[Jasmine80]

Donc, si j'ai bien compris


On a deux séquences alignées avec des positions variable et il faut retrouver les positions correspondantes. Ainsi dans ton exemple :

Code :

1
2
3
Query: 160 DSVIAAMSKRGQDRLHHVIRILAEKGHVKELATAFYGNYTVQDLLDATHXXXXXXXXXXX 219
                    + I A+ ++ +L V+ IL E G V EL T ++GNY++QDL++A
Sbjct: 264 EQAINALQRKSYQKLTRVVDILIESGKVPELVTHYFGNYSIQDLMEACFKLRKSFEKQGR 323

query D 160 est en vis à vis de E 264 on garde donc les positions 160-264 dans un tableau ... faut-il que les 2 AA soient identiques (donc ici D != E donc à ne pas garder?)

Si on tombe sur un gap, on passe la position pour les 2 séquences


est-ce bien ça?

[Jasmine80]

A ta place, j'essaierais quelque chose dans ce genre :

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#!usr/bin/perl
 
use strict;
use warnings;
 
 
 
my $query_seq = 'DSVIAAMSKRGQDRLHHVIRILAEKGHVKELATAFYGNYTVQDLLDATHXXXXXXXXXXX';
my $sbjct_seq = 'EQAINALQRKSYQKLTRVVDILIESGKVPELVTHYFGNYSIQDLMEACFKLRKSFEKQGR';
 
my $q_start = 160;
my $s_start = 264;
 
 
my @tab1 = split(//,$query_seq);
my @tab2 = split(//,$sbjct_seq);
 
for my $i (0..$#tab1){
 
	if (($tab1[$i] !~ m/[-X]/) && ($tab2[$i] !~ m/[-X]/)){
		# vérification que les positions n'existent pas déjà dans tables positions
		# ???
	}
 
	$q_start ++;
	$s_start ++;
}

[shadow19c]

En fait, les lettres on ne se sert a rien.En fait, le plus important ces les positions des lettres.
JE prend les blocs des deux sequences je mets dans une table, ensuite jecommence la lecture des deux sequences l'une comme l'autre.
Cest a dire, les curseurs de chaue table doit avancer de la meme facon., en meme temps.
Et je regarde mes hash, et les positions, en fait cest un aligenement d'aa qui doit etre en face lune a lautre, si jai correspondance dans ma collection je regarde si ils sont alignes.
Et si il ya correspondance et aligenement des deux positionnement je renvoi la tailles des introns correspondant, pour Aster-*** et CV-***, et je passe a lautre bloc, ensuite des que jai fini , je recommence le blast, puis out.bl puis on recommence la correspondance et a chaque fois je renvoi les tailles des introns a chaque fois

JE ne sais pas comment je vais mettre le calcul dans lalgo et ensuite lui dire de faire le calcul des que cest fini je passe a lautre en faisant la correspondance des ID


merci

[shadow19c]

Voici un code qui marche, mais jarrive pas a la faire pour tous les blocs:

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
#!usr/bin/perl
use strict;
use warnings;
 
my $query_seq = 'DSVIAAMSKRGQDRLHHVIRILAEKGHVKELATAFYGNYTVQDLLDATHXXXXXXXXXXX';
my $sbjct_seq = 'EQAINALQRKSYQKLTRVVDILIESGKVPELVTHYFGNYSIQDLMEACFKLRKSFEKQGR';
my $q_start = 160;
my $s_start = 264;
my @q_pos = (20, 125, 133, 172, 185, 255);
my @s_pos = (20, 5, 133, 255, 276);
 
my $length = length($query_seq);
 
foreach my $l (@q_pos) {
    next if $l < $q_start;
    last if $l >= $q_start + $length; # ou $l > $q_end si on récupère $q_end dans le fichier
    my $c = substr($query_seq, $l - $q_start, 1); #On récupère le caractère a la position dans la chaine $query_seq
    my $d = substr($sbjct_seq, $l - $q_start, 1); #On récupère le caractère a la position dans la chaine $sbjct_seq
    next if ($c =~ m/[-X]/ or $d =~ m/[-X]/);
    my $k = $l - $q_start + $s_start;
    if (grep {$_ eq $k} @s_pos) {
    print "Found: positions ($l, $k) values ($c, $d) \n" ;
    }

Voila ce que j'ai essaye de faire pour un grand fichier:

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
 
 
#!/usr/bin/perl
 
use strict;
use warnings;
 
 
#Variables
my @positions=(24,48,54,92,137,235,275,324); #Liste des positions que tu souhaites verifier
my @positions2=(26,65,145,189);
my $query_seq;
my $sbjct_seq;
my ($depart_bloc,$fin_bloc)=(0,0);
my ($depart_bloc2,$fin_bloc2)=(0,0);
my $numero_bloc = 1;
 
open (BLAST_FILE,"<out.bl") or die ("Impossible de lire blast.txt\n");
while(<BLAST_FILE>)
{
	if(/Query: (\d+)\s+(.+)\s+(\d+)/)	#Ajout de \s+ pour gerer s'il y a plus d'un espacement
	{
		$depart_bloc=$1;  #Index de depart du bloc
		$query_seq=$2;    #Sequence Query
		$fin_bloc=$3;     #Index de fin du bloc
 
	}
	elsif(/Sbjct: \d+\s+(.+)/)
	{		
		$depart_bloc2=$1;
		print $sbjct_seq=$2;   #Sequence Sbjct	
	}
 
        #Si les deux sequences "Query" et "Sbjct" ont ete trouvees, on a un nouveau bloc:
	if((defined $query_seq) && (defined $sbjct_seq) && ($query_seq =~ m/\w/) && ($sbjct_seq =~ m/\w/))
	{
                #Separation des caracteres des sequences dans un tableau
		my @tab1 = split(//,$query_seq);
		my @tab2 = split(//,$sbjct_seq);
 
		my $length = length(@tab1);
 
		 my $r = $depart_bloc;
		 my $s = $depart_bloc2;
 
		foreach my $l (@positions) {
   			 next if $l < $r ;
   			 last if $l >= $s  + $length; # ou $l > $q_end si on récupère $q_end dans le fichier
   			 my $c = substr($query_seq, $l - $r, 1); #On récupère le caractère a la position dans la chaine $query_seq
    			 my $d = substr($sbjct_seq, $l - $r, 1); #On récupère le caractère a la position dans la chaine $sbjct_seq
   			next if ($c =~ m/[-X]/ or $d =~ m/[-X]/);
    			my $k = $l - $r + $$s;
   			 if (grep {$_ eq $k} @positions2) {
    				print "Found: positions ($l, $k) values ($c, $d) \n" ;
   			 }
 
 }
 
		# on vide les variables
		$query_seq = '';
		$sbjct_seq = '';
 
 
	}
 
}

[shadow19c]

Bonjour, voici un code exhaustive que j'ai fait avec un pote, maitenant faut que je l'ajoute dans le premier programme en affichant a la fin un exemple
C169v2-04488 [les differents tailles des introns] Aster-06787[les differents tailles des introns]...
Ainsi de suiteil faut que je l'automatise pour le premier code:

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
 
    #!/usr/bin/perl
    use strict;
    use warnings;
    use autodie qw(open close);   # open/close succeed or die
 
    # modifiable si le format du fichier change
    my $Query_string = '^Query:\s(\d+)\s+(.+)\s(\d+)\s*$';
    my $Sbjct_string = '^Sbjct:\s(\d+)\s+(.+)\s(\d+)\s*$';
    # peut être passé en parametre au script, etc
    my @Query_positions = (24,48,54,92,137,235,275,324);
    my @Sbjct_positions = (26,65,145,189);
    # fichier de données
    my $filename = "out.bl";
 
    # On fait tout dans une subroutine histoire d'avoir le tout bien modulaire
    # et les parametres importants comme parametres de la subroutine, ce qui
    # facilitera l'écriture avec passage des parametres sur la ligne de commande
    # du script (l'extension logique de ce script)
    processFile(\$filename, \$Query_string, \@Query_positions, \$Sbjct_string, \@Sbjct_positions);
 
    sub processFile {
     my ($filename, $Query_string, $Query_positions, $Sbjct_string, $Sbjct_positions) = @_;
     # creation des structures associées a une ligne utile
     my $Query = initStructure($Query_string, $Query_positions);
     my $Sbjct = initStructure($Sbjct_string, $Sbjct_positions);
 
     open my $fh, '<', "$$filename";
     my ($linenum, $bloc, $part) = (0, 0, 0);
     use constant {
       STATE_START  => 0,
       STATE_SCORE  => 1,
       STATE_QUERY  => 2,
       STATE_SBJCT  => 3,
     };
     my $state = STATE_START;
     while (<$fh> ) {
       ++$linenum;
       if (/^Score\s+=/) {
         ++$bloc;
         $part = 0;
         if (($state != STATE_START) && ($state != STATE_SBJCT)) {
        print "Warning: Unexpected Score at line $linenum\n";
         }
         $state = STATE_SCORE;
       }
       if (/${$Query->{pattern}}/o) {
         ++$part;
         adjustData($Query->{data}, $1, $2, $3);
         if (($state != STATE_SCORE) && ($state != STATE_SBJCT)) {
        print "Warning: Unexpected Query at line $linenum\n";
         }
         $state = STATE_QUERY;
       }
       if (/${$Sbjct->{pattern}}/o) {
         adjustData($Sbjct->{data}, $1, $2, $3);
         if ($state != STATE_QUERY) {
        ++$part;
        print "Warning: Unexpected Sbjct at line $linenum\n";
         }
         else {
        processBlocPart($bloc, $part, $Query, $Sbjct);
         }
         $state = STATE_SBJCT;
       }
     }
     close $fh;
     if ($state != STATE_SBJCT) {
       print "Warning: Unexpected end of file\n";
     }
    }
 
    # cree la structure associee a une ligne de donnees interessantes
    sub initStructure {
     my ($pattern, $position) = @_;
     my $hashref = {
             pattern   => $pattern,  #reference sur la chaine de pattern
             positions => $position, #reference sur l'array des positions
             data => {               #reference sur un hash des infos de la ligne
                  start => 0,
                  end   => 0,
                  line  => "",
                 },
            };
     return $hashref;
    }
 
    # remplit les champs d'un hash data passée par reference
    sub adjustData {
     my $dataref = shift;
     $dataref->{start} = shift;
     $dataref->{line}  = shift;
     $dataref->{end}   = shift;
    }
 
    # on a une portion de bloc, on regarde si on a des matches pour les positions cherchees
    sub processBlocPart {
     my ($bloc, $part, $Query, $Sbjct) = @_;
     foreach my $l (@{$Query->{positions}}) {
       next if ($l < $Query->{data}->{start});
       last if ($l > $Query->{data}->{end});
       my $c = substr($Query->{data}->{line}, $l - $Query->{data}->{start}, 1);
       my $d = substr($Sbjct->{data}->{line}, $l - $Query->{data}->{start}, 1);
       next if ($c =~ m/[-X]/ or $d =~ m/[-X]/);
       my $k = $l - $Query->{data}->{start} + $Sbjct->{data}->{start};
       print "Testing in bloc $bloc, part $part: positions ($l, $k) values ($c, $d): " ;
       if (grep {$_ eq $k} @{$Sbjct->{positions}} ) {
         print "Found a match!\n" ;
       } else {
         print "no match.\n" ;
       }

merci beaucoup pour votre aide