Discussion :

[Jasmine80]

Voici mes données :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
$TEM_ref   = 'TCTGTGCCGCCGTCATTACCATGAGCGATAACAGCGCCGCCAATCTGCTGCTGGCCACCG’;
$contig    = 'TCTGTGCCGCCGCCATTACCATGAGCGATAACATCGCCGCCAATCTGCTGCTGGCCACCG’;
$consensus = 'TCTGTGCCGCCGYCATTACCATGAGCGATAACAKCGCCGCCAATCTGCTGCTGGCCACCG’;

car dans le code génétique (connu par le programme) : Y = T ou C et K = G ou T. On peut donc travailler sur $consensus directement ($consensus est le consensus de $TEM_ref et $ contig) et ainsi connaitre les différences entre $TEM_ref et $contig.

Je dois comparer $contig à $TEM_ref et vérifier que l'AGC de $TEM_ref est bien présent dans $contig (ce qui n'est pas le cas ici, car $contig contient ATG donc dans $consensus, c'est un K car T ou G).
$contig est variable et peut être différent de $TEM_ref à d'autres positions que AGC, par exemple dans ce cas, il y a un C au lieu d'un T mais cela n'est pas important car seul l'AGC compte.


Est-ce clair? Comment procéderiez-vous?


Merci pour votre aide.

Nb : je dois utiliser une boucle car il y a plusieurs triplets à vérifier et pas seulement AGC, je compte faire un tableau comptenant les différents triplets à vérifier et leur position dans la TEM_ref mais peut-être y a-t-il plus simple.

[Jasmine80]

peut-être quelque chose du genre :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
$consensus = 'TCTGTGCCGCCGYCATTACCATGAGCGATAACAKCGCCGCCAATCTGCTGCTGGCCACCG...’;
my ($mut1, $mut2 ...) = $consensus =~ m/[a-z]{32}([a-z]{3})[a-z]{22}([a-z]{3}).../i;

avec $mut1 qui vaut 'AKC' et $mut2 vaut 'CCG' .... $mut3

[Philou67430]

Dans ton exemple, peut-on imaginer qu'il puisse exister plusieurs AGC dans $TEM_ref ?
S'il ne peut y en avoir qu'un (ou si l'on ne veut traiter que le premier), voici un exemple qui utiliserais index et substr.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
my @triplet = qw(AGC);
 
foreach my $triplet (@triplet) {
  my $pos_in_TEM = index($TEM_ref, $triplet);
  push @mut, substr($contig, $pos_in_TEM, length($triplet));
}
 
# Le tableau @mut contient pour chaque triplet, la valeur du triplet à la même position dans $contig

Je ne suis pas sûr d'avoir compris ta demande...

[Jasmine80]

Voici ce que j'ai fait :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
			my ($mut1, $mut2, $mut3 ) = $consensus=~ m/[a-z\.]{41}([a-z\.]{3})[a-z]{117}([a-z]{3})[a-z]{219}([a-z]{3})[a-z]{54}/i;
 
			if ($mut1 ne 'AGC'){
 
				my $mut_aa = $myCodonTable->translate($mut1);
				my $ref_aa = $myCodonTable->translate('AGC');
 
				if ($mut1 eq 'AGC'){
					print $bact."\tpas de mutation\t";
				}
				else {
					print $bact."\t".'AGC > '.$mut1." ($mut_aa > $ref_aa)\t";
				}
			}
			if ($mut2 ne 'CGT'){
 
				my $mut_aa = $myCodonTable->translate($mut1);
				my $ref_aa = $myCodonTable->translate('CGT');
 
				if ($mut2 eq 'CGT'){
					print $bact."\tpas de mutation\t";
				}
				else {
					print $bact."\t".'CGT > '.$mut2." ($mut_aa > $ref_aa)\t";
				}
			}
			if ($mut3 ne 'GGT'){
 
				my $mut_aa = $myCodonTable->translate($mut1);
				my $ref_aa = $myCodonTable->translate('GGT');
 
				if ($mut3 eq 'GGT'){
					print $bact."\tpas de mutation\t";
				}
				else {
					print $bact."\t".'GGT > '.$mut3." ($mut_aa > $ref_aa)\t";
				}
			}

car on doit analyser l'AGC puis le CGT et enfin le GGT et donc, pour répondre à ta question, il peut y avoir plusieur AGC dans la séquence mais ce qu'on doit analyser, c'est AGC en position 42, puis le CGT en position 162 (41 + 3 + 117 = 1611) et ensuite le GGT à la position 340 (117 + 3 + 219 = 339). Est-ce plus clair?

[Philou67430]

Non, ce n'est pas plus clair, mais si tu veux dire qu'il faut analyser à chaque fois la première séquence de chacun des 3 triplets AGC, CGT et GGT, mon exemple ci-dessus devrait fonctionner en modifiant la définition de @triplet en :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

my @triplet = qw(AGC CGT GGT);

Si en revanche, il ne faut rechercher CGT qu'après la première occurrence de AGC, et GGT qu'après la première occurrence de CGT faisant suite à AGC, il faut légèrement modifier mon exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
my $start_pos = 0;
foreach my $triplet (@triplet) {
  my $pos_in_TEM = index($TEM_ref, $triplet, $start_pos);
  push @mut, substr($contig, $pos_in_TEM, length($triplet));
  $start_pos = $pos_in_TEM+length($triplet);
}

[Jasmine80]

Non, ce n'est pas plus clair, mais si tu veux dire qu'il faut analyser à chaque fois la première séquence de chacun des 3 triplets AGC, CGT et GGT, mon exemple ci-dessus devrait fonctionner

Désolée, mais ce n'est pas facile à expliquer mais merci pour ton aide :

Il ne faut pas analyser la première occurrence des 3 triplets mais vérifier qu'on trouve bien AGC en position 42, le CGT en position 162 et le GGT à la position 340. Je récupère donc les valeurs des positions
- 42-43-44 et je vérifie que c'est bien AGC ($mut1)
- 162-163-164 et je vérifie que c'est bien CGT ($mut2)
- 340-341-342 et je vérifie que c'est bien GGT ($mut3)

J'utilise donc :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
 
 
			my ($mut1, $mut2, $mut3 ) = $consensus=~ m/[a-z\.]{41}([a-z\.]{3})[a-z]{117}([a-z]{3})[a-z]{219}([a-z]{3})[a-z]{54}/i;
 
			if ($mut1 ne 'AGC'){
 
				my $mut_aa = $myCodonTable->translate($mut1);
				my $ref_aa = $myCodonTable->translate('AGC');
 
				if ($mut1 eq 'AGC'){
					print $bact."\tpas de mutation\t";
				}
				else {
					print $bact."\t".'AGC > '.$mut1." ($mut_aa > $ref_aa)\t";
				}
			}
			if ($mut2 ne 'CGT'){
 
				my $mut_aa = $myCodonTable->translate($mut1);
				my $ref_aa = $myCodonTable->translate('CGT');
 
				if ($mut2 eq 'CGT'){
					print $bact."\tpas de mutation\t";
				}
				else {
					print $bact."\t".'CGT > '.$mut2." ($mut_aa > $ref_aa)\t";
				}
			}
			if ($mut3 ne 'GGT'){
 
				my $mut_aa = $myCodonTable->translate($mut1);
				my $ref_aa = $myCodonTable->translate('GGT');
 
				if ($mut3 eq 'GGT'){
					print $bact."\tpas de mutation\t";
				}
				else {
					print $bact."\t".'GGT > '.$mut3." ($mut_aa > $ref_aa)\t";
				}
			}

mon code fonctionne

[Philou67430]

Tu veux dire que les positions pour chaque triplets sont imposées ?
Dans ce cas, pourquoi ne pas utiliser une table de hashage :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
my %triplet = (AGC => 42, CGT => 162, GGT => 340);
 
foreach my $triplet (keys %triplet) {
  my $pos_in_TEM = $triplet{$triplet};
  $mut = substr($consensus, $pos_in_TEM, length($triplet));
 
  # $mut contient le triplet de $consensus correspondant à la position du triplet en cours de traitement dans TEM.
  if ($mut != $triplet) {
     #
  }
  else {
     #
  }
}

[Jasmine80]

Tu veux dire que les positions pour chaque triplets sont imposées ?
Dans ce cas, pourquoi ne pas utiliser une table de hashage :

C'est vrai que c'est une autre solution. Est-ce mieux que la regexp que j'utilise? Normalement, les séquences doivent toujours avoir ce format mais il vaut peut-être mieux que je vérifie qu'elles ont la bonne longueur et que les positions ne sont pas décalées.

[Philou67430]

L'usage de regexp, dans ce contexte où les positions sont bien déterminées, me semble une solution inadaptée, essentiellement pour des raison de lisibilité et de maintenance.

[Jasmine80]

L'usage de regexp, dans ce contexte où les positions sont bien déterminées, me semble une solution inadaptée, essentiellement pour des raison de lisibilité et de maintenance.

Ok et merci