Introduction 2 I. Présentation de l’Institut Pasteur 3

B.Implémentation

La cellule peut communiquer avec son environnement extérieur par l’intermédiaire de son port public « RExCell », équivalent à un récepteur extracellulaire en biologie (Figure 16).

Cette capsule gère l’arrivée des messages extracellulaire et de certains messages intracellulaires. Elle permet de les rediriger à l’intérieur de la cellule suivant le type de message reçu , comme une demande de transcription, une information sur l’état d’avancement de la réplication ou sur l’état de l’ADN (s’il y a eu une mutation).

1.Lancement de la simulation

Lorsque la simulation débute, certaines capsules existent au démarrage (capsules non hachurées), se sont :

• 
  la computation qui contient
  

• 
  « complex_follow_up »
  
• 
  « concentration_follow_up »
  
• 
  « information_follow_up »
  

• 
  la protéine_production
  
• 
  la replication
  

Les autres sont créées dynamiquement. Il s’agit des protéines et des complexes que nous allons manipuler (capsules hachurées). Certaines protéines sont créées dès le lancement, on considère qu’elles sont présentes tout au long du cycle.

• 
  cdk1
  
• 
  wee1
  
• 
  cak
  
• 
  polo
  
• 
  cdc25c
  

Les autres apparaîtront et disparaîtront au cours du cycle:

• 
  la cycline B
  
• 
  tous les complexes (agrégation entre deux ou plusieurs objets)
  
• 
  la p21
  

Lors de la création de ces protéines, leurs références sont stockées dans des piles spécifiques à chaque type de protéine dans le but de pouvoir gérer les différentes ressources.

• 
  Code pour la création des cdk1 et le stockage de leurs références
  

La référence est de type « RTActorId ». On utilise une variable pour récupérer la valeur de cette référence au moment de la création d’une capsule, ici cdk1. On va créer un nombre fixé de protéines à l’aide du service de « frame » en utilisant la méthode « incarnate ». Les références sont stockées dans des piles spécifiques à chaque état d’une protéine ou d’un complexe. Toutes les piles sont stockées dans une classe passive appelée « liste_piles ».

RTActorId a;
for (int I = 0 ; I < MAX_cdk1 ; i++) //création d’un nombre fixé de cdk1
{

a=frame.incarnate(cdk1); // Service de frame

liste_piles.pool_cdk1.empile(a); // on empile la référence dans la pile appropriée

}
La création d’une capsule cdk1 entraîne au niveau de son diagramme d’état la transition « initial » qui lui permet de se trouver dans l’état « cdk1_free » (Figure 17). Cet état représente la cdk1 libre et non phosphorylée.

2.Création d’une protéine (cycline B)

La fabrication de cycline B commence lorsque l’on injecte un message « start » au niveau du port « Extracell_com » de la sous capsule « information_follow_up » de la « computation ». L’injection des messages lors de la simulation ne peut se faire que par l’intermédiaire d’un port terminal, c’est pourquoi celle-ci se fait par le port « Extracell_com » et non par le port « RexCell » (Figure 16).

Un fois le message injecté, la capsule chargée du traitement de l’information va envoyer à la capsule « protein_production » une demande de transcription d’une cycline B, par l’intermédiaire du port « ask_transcription ». Cette capsule, du fait de sa complexité, n’a pas encore été détaillé et comporte deux boites noires qui simulent la transcription et la traduction. Le regroupement de ces deux mécanismes permet de simplifier la simulation de la fabrication d’une protéine. L’arrivée d’une demande de transcription va permettre l’envoi d’un message de création d’une protéine cycline B à la cellule (une création dynamique ne peut se faire qu’à l’intérieur de sa capsule englobante). Ce message ne sera envoyé qu’après un délai de quelques secondes, introduit délibérément, afin de ralentir la simulation.

a)Gestion des envois de messages vers des destinataires multiples

Pour envoyer un message, ici grâce à la méthode « send() », on doit spécifier le nom du port par lequel il sera envoyé et le nom du message. Un message peut comporter ou non des paramètres. Si le port est dupliqué et que l’on veut envoyer un message vers une instance spécifique du port, on utilise la méthode « sendAt(numero_du_port) ».

creation.CcycB().send(); // message CcycB par le port creation, sans paramètre.

b)Gestion du temps

timer.informIn(RTTimespec(2,0));

timer est le nom du port qui permet d’avoir accès au service de temps, il est de type « Timing ». InformIn est la méthode qui déclenche un chronomètre pour une durée de type « RTTimespec » et de valeur 2 secondes et 0 nanosecondes. Lorsque le temps spécifié est écoulé, la capsule reçoit un message « timeout » qui permet de déclancher une transition.

3.Création d’un complexe (cycline B/cdk1)

Lorsqu’une cycline a été produite, la cellule doit envoyer un message à la sous capsule « concentration_follow_up » de la « computation », afin qu’elle puisse mettre à jour la concentration de la protéine qui a été formée. Ceci déclenche aussitôt l’envoi d’un message à la sous-capsule « complex_follow_up ». Si la protéine formée peut se lier avec une autre protéine ou avec un complexe protéique disponible dans la cellule (conditions biologiques données), cette capsule va alors envoyer un message de demande de formation de complexe à la « cellule » et décrémenter les valeurs des attributs des concentrations concernées. La capsule « cellule » va ensuite créer dynamiquement le complexe, et les deux protéines qui le composent y seront immédiatement importées. La cycline B pouvant se lier à une cdk1, la « cellule » va former un complexe cycline B./.cdk1.

• 
  Code pour la création d’un complexe
  

Un complexe cycline B / cdk1 est composé d’une cycline B et d’une cdk1. Au moment de la création de ce complexe, celui ci va importer, dans sa structure, les deux protéines qui vont le composer. Pour cela, le complexe devra avoir accès aux références de ces deux protéines. Pour transmettre ces adresses, la cellule va créer un objet « listeAdressesProteines » de type « ListeAdressesProteines » qui est une classe passive. Cette classe contient des attributs de type RTActorId qui vont servir à stocker les références des protéines qui seront importées dans le nouveau complexe formé par la cellule. La cellule peut ensuite créer la capsule « cplx_cycB_cdk1 ». Cette création prend en paramètre : le nom de l’instance de la capsule (cplx_cycB_cdk1) qui va être créée dans la « cellule », le nom de la capsule (Cplx_cycB_cdk1) et la référence de l’objet contenant les références mémoires des protéines qui vont composer le complexe. La référence du complexe est stockée dans une pile.

//avant de former un complexe, on vérifie si les piles d'adresses ne sont pas vides
if((liste_piles.pool_cdk1.compteur>0)&&(liste_piles.pool_cycB.compteur>0))

{
ListeAdressesProteines listeAdressesProtéines // Création de l’objet

// listeAdressesProtéines
// On dépile les références des capsules à incarner dans les attributs correspondants de l’objet

// listeAdressesProtéines

listeAdressesProteines.id_cdk1 = liste_piles.pool_cdk1.depile();

listeAdressesProteines.id_cycB = liste_piles.pool_cycB.depile();

RTActorId a = frame.incarnate(cplx_cycB_cdk1, Cplx_cycB_cdk1, &listeAdressesProteines);

liste_piles.pool_cycB_cdk1.empile(a);

}

else (gestion des erreurs) ;

4. Importation de protéines (à l’intérieur du complexe cycline B/cdk1)

Lorsque le complexe est formé, la transition initiale est effectuée au niveau de son diagramme d’état et il se retrouve dans l’état « complexe_cree » (Figure 18). Au cours de cette transition, le complexe va importer les deux protéines qui le composent.

a)Code de l’importation :

Le complexe récupère les données de l’objet « listeAdressesProteines » dont la référence lui a été fournie en paramètre lors de sa création par la « cellule ». Puis il importe les protéines grâce au port de « frame ». Lors de l’importation, on indique la référence de la capsule importée ainsi que le nom de son instance.

ListeAdressesProteines *listeAdressesProteines = (ListeAdressesProteines *)getMsg()->getData(); // récupération des données contenues dans l’objet

frame.import(listeAdressesProteines->id_cycB, cycB); // importation des capsules

frame.import(listeAdressesProteines->id_cdk1, cdk1); // dans la structure du complexe

b)Gestion d’un nouveau complexe

Quand les deux protéines sont importées, la cdk1 reçoit un message « RTbound » par le port « binding » (déclenché automatiquement par le système) pour lui spécifier qu’elle est complexée à une cycline B. La cdk1 passe alors dans l’état englobant « complex_cyclinB_cdk1 » (Figure 17). Cet état contient l’ensemble des sous états possibles de la ck1, liée à la cycline B.

• 
  Diagramme d’état de la cdk1
  

Figure 17 : Diagramme d’état de cdk1.
Lorsque le complexe cycline B / cdk1 est formé par la « cellule » sur demande de « complexe_follow_up », la cdk1 reçoit le message « bound » de la cycline B. Ceci provoque le passage de la cdk1 de l’état « cdk1_free » au super état « complex_cycB_cdk1 ». Plus précisément, dans le sous état « cdk1 » qui est l’état initial de « complex_cycB_cdk1 ». Ce super état contient l’ensemble des sous états possibles de la cdk1 liée à la cycline B.

• 
  Si le complexe Cycline B / cdk1 forme un complexe avec la Wee1, celle-ci lui enverra le message « wee1_phosphorylation » qui fera passer la cdk1 dans l’état cdk1_p_wee1. cela signifie que la cdk1 a été phosphorylée par wee1 sur une Tyrosine 15. Cette phosphorylation a pour effet l’inhibition de la cdk1.
  

• 
  Si le complexe Cycline B / cdk1 forme un complexe avec la Cak, celle-ci lui enverra le message « cak_phosphorylation » qui fera passer la cdk1 dans l’état cdk1_p_cak. Cela signifie que la cdk1 a été phosphorylée par cak. Dans cet état, la cdk1 est active et ne subira plus de transformation mais pourra effectuer une auto-transition lorsqu’elle se liera à la cdc25c afin de la phosphoryler.
  

• 
  Dans l’état cdk1_p_wee1 la cdk1 peut être :
  

• 
  phosphorylée par cak et passer dans l’état cdk1_pp_wee1_cak
  
• 
  déphosphorylée par cdc25c et retourner dans l’état cdk1 (effet contraire de Wee1, levée de l’inhibition).
  

• 
  Dans l’état cdk1_pp_wee1_cak la cdk1 peut être déphosphorylée par cdc25c et passer dans l’état actif.
  

Figure 18 : Diagramme de structure et d’état du complexe cycline B / cdk1.

5.Condition de formation d’un complexe (cycline B / cdk1/ wee1)

Comme lors de la création d’une protéine, la « cellule » informe la « concentration_follow_up » qu’un complexe cycline B/cdk1 a été créé. Celle-ci va ensuite avertir la capsule « Complex_folow_up », qu’un nouveau complexe cycline B / cdk1 a été créé. Celui-ci peut se lier à wee1, à cak, à cdc25c, ou à un inhibiteur p21 (non présent en début de simulation), mais il faut pour cela que ces protéines soient actives. De plus, pour que le complexe puisse se lier à cdc25c, il faut que la cdk1 ait été préalablement phosphorylée par wee1 (Figure 18). Le complexe cycline B/cdk1 ne peut donc se lier qu’à Wee1, car cak est inactif en début de la simulation. La capsule « Complex_folow_up » demande la formation de complexe après vérification de l’état des ressources disponibles.

• 
  Demande de formation de complexe après création d’un complexe cyclin B/cdk1 dans la cellule
  

Un complexe cycB / cdk1 a été créé, on vérifie l’état des ressources pour voir si on peut former un nouveau complexe entre cycline B / cdk1 et une autre molécule. S’il y a présence d’inhibiteur dans la cellule (ici p21), on créé immédiatement un complexe avec lui pour empêcher cycline B/cdk1 de se lier avec la cak ou wee1.

On vérifie, avant de former un complexe quel qu’il soit, qu’il reste bien des molécules qui le composent dans la « cellule » (au cas où elles auraient été utilisées entre temps). L’ordre de priorité pour la formation des complexe avec cycline B / cdk1 est ici p21, cak et enfin wee1.

On a choisit ici de privilégier la cak par rapport à wee1, mais on pourrait également faire des comparaisons de concentration ou autre chose en fonction de connaissances plus précises sur cet ordre de priorité.

Exemple :
if ((valeurs_concentration.conc_p21>0)&&(valeurs_concentration.conc_cycB_cdk1>0))

{
complex_forming.cycB_cdk1_p21().send(); // Si il y a une p21 et un complexe, on

// envoi la

// demande de formation de complexe

//(cycB_cdk1_p21) par le port complex_forming
valeurs_concentration.conc_p21--; // on décrémente les concentrations

valeurs_concentration.conc_cycB_cdk1--;

}
else

{

if((valeurs_concentration.conc_cycB_cdk1>0)&&(valeurs_concentration.conc_cak_actif>0))

{

complex_forming.cycB_cdk1_cak().send();

valeurs_concentration.conc_cycB_cdk1--;

valeurs_concentration.conc_cak_actif--;

}

else

{

if((valeurs_concentration.conc_cycB_cdk1>0)&&(valeurs_concentration.conc_wee1_actif>0))

{

complex_forming.cycB_cdk1_wee1().send();

valeurs_concentration.conc_cycB_cdk1--;

valeurs_concentration.conc_wee1_actif--;

}

}

}

6.Phosphorylation de cdk1 par wee1 (changement d’état)

Le complexe cycline B/cdk1/wee1 qui a été créé va stocker sa propre référence ainsi que celles de ses capsules englobées dans un objet « adresseProtéines ». Ce stockage est important car au moment où le complexe devra être détruit, il faudra que la « cellule » récupère :

• 
  la référence du complexe afin de le détruire spécifiquement.
  
• 
  la référence de wee1 afin de la remettre dans sa pile afin qu’elle puisse être à nouveau utilisé.
  
• 
  La référence du complexe cycline B/cdk1 sera conservée dans une pile spécifique au complexe dont la cdk1 a été phosphorylée par wee1 (reflet du stock de complexe dans cet état précis). En effet, il nous faudra créer des piles différentes pour chaque état de la cdk1 pour pouvoir séparer les différents types de complexes disponibles.
  

Après un délai introduit pour améliorer le suivi de la visualisation, wee1 envoi un message à la cdk1 par le port de « phosphorylation » (Figure 19). L’envoi de ce message simule le phénomène de phosphorylation d’une protéine par une protéine kinase en biologie. L’arrivée de ce message au niveau du diagramme de structure de la cdk1 va la faire passer de l’état « cdk1 » à « cdk1_p_wee1 ». Cet état montre que la cdk1 complexée avec une cycline B, a été phosphorylée par wee1.

Figure 19 : Diagramme de structure du complexe Cycline B / cdk1 /wee1.
L’entrée dans cet état va déclencher l’envoi d’un message sur le port « cdk1 » puis sur « destroy_complex ». Ce message prévient le complexe que la cdk1 a été phosphorylée et qu’il peut maintenant être détruit.

En biologie, ceci revient à simuler le processus de changement de conformation moléculaire qui amène à la dissociation du complexe suite à la phosphorylation. La cdk1 va également envoyer un message à la wee1 pour qu’elle puisse repasser dans l’état « actif ».

7.Destruction d’un complexe (Cycline B/cdk1/wee1)

Comme lors d’une création, c’est la cellule englobante qui doit détruire les capsules. Lorsqu’un complexe arrive dans l’état « destroy », toutes les protéines (capsules) du complexe seront libérées récursivement par l’envoi d’un message à leur port. Ces protéines ainsi libérées sont à nouveau disponibles pour former un nouveau complexe.

Enfin on informe la « concentration_follow_up » qu’un complexe a été détruit pour mettre à jour les concentrations en complexe, en wee1 et en complexe cycline B/cdk1 phosphorylé par wee1. La « concentration_follow_up » avertira ensuite la capsule « complex_follow_up » afin de vérifier si d’autres complexes peuvent être créés à partir des capsules libérées.


Message en entrée


Figure 20 : Diagramme d’état du complexe Cycline B / cdk1 /wee1

8.Activation de protéines (Cak et des Polo)

Les protéines Cak et Polo sont responsables de mécanismes de phosphorylation et de déphosphorylation. Pour l’instant, c’est l’injection d’un signal qui déclenche leur activation. Dans une configuration plus complète, ce signal pourrait être émis par une autre protéine. Le signal est injecté au niveau du port « replication » de la capsule « réplication ». En effet, ces protéines ne peuvent pas être activées tant que la réplication n’est pas terminée. Ici, l’injection du signal simule l’achèvement de la réplication en la faisant passer dans l’état « end_replication ». L’entrée dans cet état provoque l’envoi d’un message vers le port « replication_state ». Le message arrive dans la capsule « information_follow_up » qui va envoyer un message d’activation aux cak et aux polo par les ports « cak_activation » et « polo_activation ». Ces messages vont les faire passer dans l’état « actif ». Au cours de la transition qui les conduit dans cet état, cak et polo envoient chacun un message à la capsule « information_follow_up » pour confirmer leur activation.

Lorsque « information_follow_up » reçoit ce message, elle informe la « concentration_follow_up » qu’une cak ou une polo est activée, puis à son tour, la « concentration _follow_up » va en informer la « complex_follow_up ». Selon les différentes ressources, on pourrait avoir création de complexes.
La création de complexes polo/cdc25c va permettre la phosphorylation de cd25c par polo. La cdc25c phosphorylée est ainsi active et va pouvoir se lier à des complexes cycline B/cdk1 qui ont été phosphorylés par wee1 (Figure 21).
Figure 21 : Diagramme d’état de polo.

9.L’activation de la cdk1

Une cdk1, en complexe avec une cycline B, qui est dans l’état « cdk1_p_cak » est une cdk1 active. Afin d’augmenter le nombre de cdk1 actives, la cdk1 va se lier avec des cdc25c inactive afin de les activer à leur tour par phosphorylation. En biologie, on appelle cela une auto régulation. Lorsque toutes les cdk1 en complexe avec une cycline B sont activées, la « cellule » peut entrer dans sa phase de mitose.

10.Inhibition par la p21

Lorsqu’une erreur survient au niveau de l’ADN, la cellule, par l’intermédiaire de mécanismes complexes va permettre la création d’inhibiteur comme la protéine p21. La présence de ces protéines va permettre l’arrêt du cycle cellulaire en bloquant les complexes cycline B / cdk1. Cela permettra à la « cellule » de réparer l’erreur. A la suite de quoi, les inhibiteurs sont dégradés et les complexes libérés. Dans notre modèle, la synthèse et la destruction des p21 sont déclenchées par des signaux « error_dna » et « end_error_dna » au niveau des ports « RexCell » et « end_error_dna ».