Université d'Évry Val d'Essonne INSTITUT PASTEUR Cours Monseigneur Roméro 25-28, rue du Dr Roux 91025 Évry Cedex 75724 75724 Paris cedex 15

Rapport de stage

DESS Compétences Complémentaires en Informatique

Année 2001 - 2002

Spécification et simulation des systèmes biologiques Etudes de faisabilité : Représentation du complexe

MPF au cours cycle cellulaire à l'aide d'UML Rose-Real Time™

SAUTEJEAU Grégory

Maître de Stage Roux-Rouquié Magali

Directeur de recherche-CNRS Unité Biosystémique Modélisation Ingénierie

Remerciements

Ce travail a été réalisé à l’Institut Pasteur, dans le laboratoire de Biosystémique

Modélisation Ingénierie dirigé par Magali Roux-Rouquié.

Je tiens à remercier Magali Roux-Rouquié pour m’avoir permis de faire mon stage au sein

de son unité et pour m’avoir guidé au cours de celui-ci.

Je remercie Camille Rosenthal-Sabroux, professeur à l’Université Paris-Dauphine, pour

m’avoir introduit aux principes de la modélisation UML.

Je remercie également Nasser Kettani, Directeur du Marketing chez Rational Software,

pour son aide précieuse à l’introduction à Rose-RT et pour m’avoir permis de suivre la

formation dispensée par sa société.

Je voudrais remercier tout particulièrement Bernard Dupré, responsable technique chez

Rational Softawre pour l’enseignement de qualité qu’il nous a donné lors de la formation à Rose-

RT et pour sa disponibilité et ses conseils lors de la réalisation du modèle.

Un merci à toute l’équipe de l’ARC-INRIA « Calculs de Processus et Biologie des

Réseaux Moléculaires » pour ses conseils à propos de notre travail et sa réflexion sur le sujet.

Je remercie aussi Julien Renner, stagiaire avec moi sur ce projet, pour son soutien, sa

bonne humeur et son investissement dans le projet tout au long du stage.

1

SOMMAIRE

SOMMAIRE...................................................................................................................................2

INTRODUCTION :........................................................................................................................4

I. PRESENTATION DE L’INSTITUT PASTEUR................................................................5

A. HISTORIQUE ..........................................................................................................................5 B. ORGANISATION GENERALE DE L’INSTITUT PASTEUR.............................................................6 C. CARTE D’IDENTITE DE L’INSTITUT PASTEUR .........................................................................8 D. MISSION ................................................................................................................................9 E. UNE STRATEGIE TOURNEE VERS L'AVENIR.............................................................................9

II. PROBLEMATIQUE GENERALE DE L’UNITE DE BIO-SYSTEMIQUE MODELISATION INGENIERIE ..............................................................................................10

III. REALISATION, IMPLEMENTATION ET TEST D’UN MODELE DE PROCESSUS BIOLOGIQUE DANS ROSE RT ...................................................................12

A. CONCEPTS ET METHODES DES SYSTEMES TEMPS-REELS......................................................14 B. PRESENTATION DU LANGAGE DE MODELISATION UNIFIE : UML POUR RT ..........................14

1. Concepts de base de l’approche objet............................................................................14 2. Introduction à UML .......................................................................................................17

C. L’ATELIER DE GENIE LOGICIEL ROSE RT ............................................................................27 1. Capsule...........................................................................................................................27 2. Port.................................................................................................................................28 3. Protocole ........................................................................................................................29 4. Capsule englobante ........................................................................................................30

a. Composition ...............................................................................................................30 b. Agrégation..................................................................................................................31

5. Cardinalité .....................................................................................................................31 6. Machine à état d’une classe active ................................................................................32

D. MODELE BIOLOGIQUE..........................................................................................................34 E. MODELE REALISE ................................................................................................................36

1. Description générale ......................................................................................................36 2. Implémentation du modèle .............................................................................................38

a. Lancement de la simulation........................................................................................38 b. Création d’une protéine (cycline B) ...........................................................................39 c. Création d’un complexe (cycline B/cdk1) .................................................................40 d. Importation des protéines à l’intérieur d’un complexe(cycline B/cdk1)....................41 e. Conditions de formation d’un complexe (cyclineB/cdk1/wee1)................................43 f. Phosphorylation de cdk1 par wee1.............................................................................45 g. Destruction d’un complexe (CyclineB/cdk1/wee1) ...................................................47 h. Activation des cak et des polo....................................................................................48 i. L’activation de la cdk1...............................................................................................49 j. Inhibition par la p21 ...................................................................................................49

3. Exécution du modèle ......................................................................................................50

2

IV. BILAN ET CONCLUSION.............................................................................................57

V. BIBLIOGRAPHIE...............................................................................................................59

VI. ANNEXES.........................................................................................................................61

3

Introduction :

Ce stage de DESS s’est déroulé au sein de l’institut Pasteur, à Paris, sous la responsabilité de Magali Roux-Rouquié, Directeur de recherche CNRS dans l’unité " Structure Bio-Systémique – Modélisation Ingénierie ", et en collaboration avec Julien Renner, stagiaire issu du DESS informatique des systèmes complexes biologiques de Bordeaux. Le but de ce stage était de développer un modèle de représentation et de simulation du complexe cycline B/cdk1 au cours cycle cellulaire à l’aide de la technologie UML - Real Time.

En effet, nous envisageons ici les systèmes biologiques comme des systèmes complexes. Ceux-ci modifient continuellement le couplage entre leurs composants et sont eux-mêmes modifiés en fonctionnant. Exprimé dans le paradigme systémique, ceci revient à décrire un système par la fonction de ses composants (pour un état du système, décrire les activités réalisées et les entités qui les réalisent), et leur évolution (décrire la chronique des changements d’état en réponse aux signaux de l’environnement). Pour ce faire, on doit disposer d’une notation adaptée à la description, à la conception et à l’implémentation des métamodèles conceptuels.

UML (Unified Modeling Language) permet une représentation graphique qui décrit la structure statique (diagrammes de classes) et le comportement dynamique (diagrammes de structure, diagrammes d’état-transition, etc…) d’un système. Ceci est particulièrement intéressant au vu de la complexité des systèmes biologiques. Ce rapport comportera tout d’abord une présentation de l’institut Pasteur. Puis, dans une seconde partie, je présenterai la problématique générale de l’unité de bio-systémique modélisation ingénierie. La troisième partie concernera la réalisation, l’implémentation et le test d’un modèle de processus biologique dans Rose RT.

4

I. Présentation de l’Institut Pasteur

A. Historique

L'Institut Pasteur, fondé par décret du 4 juin 1887, est inauguré le 14 novembre 1888. Il a été créé grâce au succès d'une souscription internationale, pour permettre à Louis Pasteur d'étendre la vaccination contre la rage, de développer l'étude des maladies infectieuses et de diffuser les connaissances. Très rapidement des pasteuriens vont essaimer à travers le monde, pour diffuser la vaccination contre la rage mais aussi la sérothérapie antidiphtérique, la vaccination contre la variole selon le principe de Jenner, et pour étudier les caractères particuliers de maladies exotiques et les soigner. C'est une fondation privée, à but non lucratif, reconnue d'utilité publique.

Dès la création de son institut, Pasteur réunit des scientifiques d'horizons divers. Les cinq premiers services ont alors à leur tête deux normaliens : Emile Duclaux (Microbie générale) et Charles Chamberland (Microbie appliquée à l'hygiène) ; un biologiste, Elie Metchnikoff (Microbie morphologique) ; et deux médecins, Joseph Grancher (Rage) et Emile Roux (Microbie technique). Un an après l'inauguration de l'Institut Pasteur, Roux mettra en place le premier enseignement de microbiologie jamais dispensé au monde, intitulé alors " Cours de Microbie technique ". Très rapidement, des chercheurs vont essaimer à travers le monde, pour appliquer et transmettre la " méthode pasteurienne " et pour étudier les caractères particuliers de maladies exotiques.

Ainsi, parallèlement à l'essor de l'Institut Pasteur, se constituera le Réseau international des Instituts Pasteur et Instituts associés qui compte aujourd'hui quelque 20 établissements implantés sur les cinq continents. L'Institut Pasteur fut l'un des berceaux de la Microbiologie, de l'Immunologie et de la Biologie moléculaire.

Depuis l'origine, les Pasteuriens ont apporté des contributions majeures dans les connaissances sur les structures et les fonctions du vivant, sur les agents infectieux et les maladies qu'ils provoquent. Leurs apports concerneront notamment la rage, la peste, la diphtérie, le tétanos, le typhus, la fièvre jaune, la tuberculose, la poliomyélite, ou encore l'hépatite B et le Sida. Des chercheurs s'illustreront par la découverte des anatoxines, du BCG, des sulfamides, des anti-histaminiques. D'autres joueront un rôle fondamental dans la naissance de la biologie moléculaire ainsi que dans celle du génie génétique.

5

B. Organisation générale de l’Institut Pasteur

Figure 1 : Organisation Générale de l'Institut Pasteur.

Figure 2 : Comité exécutif.

6

Le Directeur Général (Philippe Kourilsky) est le représentant légal de l'Institut Pasteur, le directeur général est responsable de la politique générale de l'Institut Pasteur et de son bon fonctionnement (figures 1 et 2). Il prend les décisions nécessaires à la mise en place de cette politique, est le supérieur hiérarchique direct des chefs de département, préside le Comité exécutif, dont les membres l'assistent dans ses fonctions, ainsi que son bureau et préside également le Conseil stratégique interne. Le directeur général est nommé par le Conseil d'Administration pour une durée de 6 ans, renouvelable une seule fois.

Le Directeur Général Adjoint pour l'Administration et les Finances (Jean Castex) assiste le directeur général pour les questions touchant aux affaires non scientifiques, notamment pour les affaires administratives et financières, sans avoir pour autant d'autorité hiérarchique sur les autres directeurs concernés (figures 1 et 2). Il participe aux réunions du Conseil d'Administration et de son bureau et a délégation de signature du directeur général, en l'absence et/ou à la demande de ce dernier, pour l'ensemble des actes administratifs, financiers et juridiques impliquant l'Institut Pasteur.

Le Directeur Général Adjoint pour les Affaires Scientifiques et Médicales (Alain Gouyette)assiste le directeur général dans la conduite des affaires de nature scientifique ou médicale, sans avoir d'autorité hiérarchique sur les autres directeurs concernés (figures 1 et 2). Il participe aux réunions du Conseil d'Administration et de son bureau et a délégation du directeur général, en l'absence et/ou à la demande de ce dernier, pour l'ensemble des questions scientifiques. Il est assisté pour les Affaires Scientifiques par le Il est assisté pour les Affaires Scientifiques par le Directeur de l'évaluation scientifique, Alain ISRAEL.

La secrétaire générale (Véronique Wallon) assiste le directeur général dans la conduite des grands projets collectifs de l'Institut, notamment lorsqu'ils ont à la fois une dimension scientifique et une dimension non scientifique (figures 1 et 2). Elle est en outre chargée de la coordination des actions et des travaux de la direction.

7

C. Carte d’identité de l’Institut Pasteur

L’Institut Pasteur est une fondation privée reconnue d'utilité publique. Le tableau 1 montre les chiffres clés au 1er janvier 2002

Date de création 1887 Effectif 2500, de 63 nationalités

Budget 2002 174 millions d'euros Unités de recherche 130, réparties dans 12 Départements de recherche Elèves et stagiaires 1000 par an

Centres Nationaux de Référence 22

Centres Collaborateurs O.M.S. 10

Réseau International 21 Instituts Pasteur et Instituts associés (8500 personnes)

Start-up en biotechnologie

9 (Hybrigenics, Diatos, Cellectis, Eco Process Energie Environnement, Evologic, Pasteur Media Vita, Celogos,

Theraptosis, BT Pharma, Biocortech)

Centre Médical 81 500 vaccinations, 26 200 consultations, 70 000 analyses

Tableau 1 : Chiffres-clés au 1er janvier 2002

Applications de la Recherche :

- 330 brevets prioritaires (dont 39 nouveaux déposés en 2001)- 20 programmes de Recherche et Développement en collaboration avec un partenaire industriel

- 165 contrats de licences et sous-licences (dont 30 signés en 2001) et 9 contrats de vente

de matériel biologique

Les partenaires sont Aventis Pasteur pour les vaccins, Bio-Rad pour le diagnostic, Procter et

Gamble pour l'hygiène et Hybrigenics pour la protéomique fonctionnelle (maladies infectieuses).

8

D. Mission

L’Institut Pasteur est une fondation privée à but non lucratif dont la mission est de contribuer à la prévention et au traitement des maladies, en priorité infectieuses, par la recherche, l’enseignement, et des actions de santé publique. L'Institut Pasteur est une fondation qui a pour objet :

- L'étude des maladies infectieuses, parasitaires et immunitaires, ainsi que les moyens propres à les prévenir et à les combattre.

- La poursuite et le développement des travaux de recherche sur les micro-organismes, sur

leur rôle dans les processus naturels, normaux ou pathologiques et sur les réactions qu'ils provoquent.

- L'étude et l'enseignement de la microbiologie dans toutes ses branches, ainsi que la

formation de personnel scientifique et technique, en vue de la promotion de la recherche en microbiologie fondamentale et appliquée.

- L'étude de tous les phénomènes théoriques ou pratiques liés à la microbiologie, à

l'immunologie ou, d'une manière générale, à la biologie fondamentale ou appliquée, et les recherches en ces domaines.

E. Une stratégie tournée vers l'avenir

Conscient de sa nécessaire adaptation à l'évolution très rapide de la recherche biologique

et de ses applications, notamment biotechnologiques, l'Institut Pasteur s'est fixé quatre priorités à l'aube du XXIe siècle :

- Une stratégie scientifique ciblée vers la microbiologie et les pathologies infectieuses, ainsi

que l'immunologie, dans un souci constant d'excellence. - Une ouverture renforcée vers l'extérieur :

o Nationale, à travers des accords et collaborations avec ses partenaires les plus proches, parmi les organismes de recherche (CNRS, INSERM…), les universités, les hôpitaux (Necker, Cochin…), l'Institut Pasteur de Lille, la Fondation Mérieux, mais aussi avec ses partenaires industriels (Aventis Pasteur, Biorad, Procter & Gamble…).

o internationale, avec le développement du réseau des Instituts Pasteur et Institut Associés.

- Une organisation interne réactive, avec la mise en place de programmes de recherche

transversaux ambitieux pilotés par de jeunes chercheurs, la limitation de la durée des mandats, et une mobilité accrue des personnels pasteuriens.

- Un maintien de son autonomie par une valorisation croissante des résultats de recherche et

une augmentation des ressources liées au mécénat

9

II. Problématique générale de l’unité de Bio-Systémique Modélisation Ingénierie

Le stage s’est déroulé dans la structure « Bio-Systémique Modélisation Ingénierie» (BSMI) qui est une unité récente de l’Institut Pasteur, créée en 2001, et composée de deux directeurs de recherche ; Magali Roux-Rouquié, directeur de recherche-CNRS en assure la responsabilité. Pendant la période de mon stage, l’unité a accueilli un autre stagiaire sur le même sujet, Julien Renner, issu du DESS informatique des systèmes complexes biologiques de Bordeaux.

L'activité de l'unité Biosystémique Modélisation Ingénierie, s'établit sur une problématique de modélisation des processus considérant les systèmes biologiques comme des systèmes réactifs.

Cette démarche s’inscrit dans le cadre général du paradigme systémique, centré sur l’action, et qui décrit l’activité d’une entité par la trajectoire de ses états, les transitions d’un état à un autre intervenant en réponse à un message de l’environnement interne ou externe de l’entité. Cette conception est très pertinente en biologie post-génomique, alors qu’il convient désormais de décrire et de comprendre le fonctionnement des composants des systèmes vivants. Le paradigme systémique et le formalisme qui lui est associé permettent de décrire une entité biologique en évolution dans son environnement et soumise à des évènements externes et internes qui conditionnent son comportement, lequel affecte à son tour son environnement. Cette conception est pertinente pour une représentation dynamique des fonctions biologiques décrites classiquement, dans le paradigme analytique classique, par des substantifs verbaux [M. Roux-Rouquié, J.-L. LeMoigne, C. R. Biologies 325 (2002) 419-430].

Différents formalismes permettent de décrire les états d’un système et son évolution, ils sont continus ou discrets, statiques ou dynamiques, déterministes ou stochastiques. La spécification des systèmes temps-réel peut être regroupée en deux familles de formalismes : d'une part, les méthodes algébriques et logiques en général spécifiques à une classe de problèmes (programmation par contraintes, équations différentielles cinétiques, etc.) et d'autre part, les langages graphiques formels (tels que les réseaux de Pétri) ou le "Unified Modeling Language" (UML) qui permet de modéliser sans les dissocier la structure, la fonction et l'évolution d'un système. Au cours d’une précédente étude, nous avons montré que UML répondait aux critères d’un langage de modélisation systémique : diagramme d’état-transition, prise en compte de l’environnement, etc [M. Roux-Rouquié et al., International Conference THE SCIENCE OF DESIGN, Software design, INSA-Lyon, 15-16 March (2002), In press].

Ces travaux permettent d'exprimer explicitement et d'organiser les différentes vues sous lesquelles un système biologique peut être appréhendé, vue statique des composants, vue synchronique des états, vue diachronique des changements d'états. La modélisation d'un processus (cycle cellulaire, voies de signalisation, etc.) résulte de l'articulation de ces trois vues.

10

La mise en œuvre de ce projet est réalisée dans un cadre fortement interdisciplinaire et se conduit au travers de plusieurs collaborations avec :

- le LAMSADE (CNRS) et la société RATIONAL Software - le consortium international EXPRESSION PROFILE INTERNATIONAL

CONSORTIUM (EPIC, partenaires : CNRS & Systems Biology Institute, (Seattle, USA) - l'ARC-INRIA : Calculs de Processus et Biologie des Réseaux Moléculaires (partenaires :

INRIA, CNRS et la société HYBRIGENICS)

En outre, notre projet participe à plusieurs manifestations d'intérêt dans le cadre : - du 6e PCRDT - MOBYDIC : Modelling Language for Systems Biology: Analysis, Simulation,

Comparison, and Prediction (PI) - STAGSIM : System-Theoretical Analysis of Genomic and Signalling Models (PI) - BITES : Building a Bioinformatics Integrated Toolbox to Enable Systems Biology (réseau

d'excellence) - ESBIGH : European Systems Biology Initiative; Genomic in the service of Health (super

réseau d'excellence)

11

III. Réalisation, implémentation et test d’un modèle de processus

biologique dans Rose RT

Objectif du stage L’objectif du stage est d’évaluer la pertinence des concepts et des méthodes des systèmes

temps-réel, pour la description et la représentation des processus biologiques, en particulier, la prise en compte de la création dynamique d’objets, la modification du comportement d’un objet en fonction des messages émis par son environnement externe ou interne, le traitement d’évènements concurrents, synchrones ou asynchrones, etc. A ce stade, il ne s’agit donc pas de comparer différents langages de modélisation temps-réel, mais de retenir, sur des critères explicitables, un outil parmi les quelques outils disponibles [notamment, Esterel (Esterel Technologies) et Rapsody (Ilogix)] qui permettent de conduire ce test. Pour ce faire, nous avons sélectionné l’atelier de génie logiciel, Rose-RT (Rational Software), sur la base des critères ci-après : • Utilise le langage UML qui fait l’objet d’un standard (UML :Unified Modeling language),

élaboré par l’OMG (Object Modeling Group). • Les spécifications du langage UML-RT (UML for Real-Time) sont détaillées dans de

nombreux documents. • Les outils développés autour de Rose-RT sont dotés d’autant de fonctionnalités utiles et qui

ne seront pas à développer (par exemple, le RunTimeSystem). • Rose-RT s’appuie sur la modélisation graphique développée dans UML ; ces outils

graphiques permettent de produire des descriptions qui pourront être « partagées » par des biologistes et des informaticiens. C’est d’ailleurs dans l’objectif d’assurer une meilleure adéquation entre la conception (modèle conceptuel) et le logiciel effectivement réalisé que ces outils graphiques ont été conçus.

• • Déroulement du stage •

La première partie de notre stage a consisté à appréhender le modèle biologique. Pour cela nous nous sommes appuyé sur les recherches de Kurt W. Kohn qui à établit une « carte moléculaire des interactions dans le cycle cellulaire des mammifères et le système de réparation de l’ADN » (voir annexe) ainsi que sur de nombreuses publications sur le sujet. (Kohn K.W, 1999).

Notre unité étant en collaboration avec des informaticiens et des logiciens dans le cadre de l’ARC-INRIA sur les calculs de processus et biologie des réseaux moléculaires, nous avons participé à plusieurs réunions et groupes de travail durant lesquelles nous avons présenté le cycle cellulaire, notamment ses régulations et les interactions protéiques.

12

Les principaux axes de recherche de l’arc sont :

Axe 1: Définir une base d'exemples de processus biomoléculaires, ainsi qu'une taxinomie des problèmes ouverts de représentation formelle qui se posent dans la modélisation de ces processus. Axe 2: Comparer différentes modélisations des mécanismes de la base d'exemples dans

différents calculs de processus, à l'aide de critères correspondants aux points délicats du cahier des charges identifiés par l'axe 1 Axe 3: Proposer de nouveaux calculs de processus adaptés au domaine bio-moléculaire, et

réaliser des implémentations prototypes.

Nous avons, parallèlement, contribué à la réflexion sur le modèle informatique et sa réalisation, à l’aide du logiciel Rational Rose RealTime, en compagnie de Nasser Kettani (directeur marketing de Rational Software) et de Camille Rosenthal Sabroux (Lamsade, Paris Dauphine). Ceci nous a permis d’avoir à une première approche du modèle, en essayant de trouver les solutions les plus en adéquation avec la réalité biologique. Cela nous a permis également de nous familiariser avec les concepts objets temps réel utilisés par Rational.

Un stage de formation chez Rational Software sur le sujet « Développement des logiciels temps réel avec UML et Rational Rose RealTime » nous à permis de maîtriser le logiciel et d’acquérir quelques bases en modélisation temps réel. A partir de ces connaissances, nous avons réussi à réaliser le modèle que nous avions conçu dans un premier temps en prenant en compte les contraintes liées à la biologie et à l’informatique.

* * *

Nous avons articulé la présentation de notre travail en trois parties :

1. Concepts et méthode des systèmes temps-réel : UML pour RT et l’atelier de génie logiciel Rose-RT 2. Modèle biologique : Motivations 3. Modélisation et simulation du fonctionnement du complexe MPF dans Rose-RT.

Des annexes nous permettent de renseigner plus complètement certains points particuliers

13

A. Concepts et Méthodes des systèmes temps-réels

Un système temps-réel est un système qui traite des informations en répondant à des stimuli internes et externes pendant une période de temps bien définie. On parle de temps réel non seulement quand le traitement des données suit très rapidement leur acquisition mais aussi lorsqu’il faut traiter le comportement d’objets en nombre très élevé et variable. Pour un système temp-réel, l’exactitude des réponses dépend à la fois de la logique mise en œuvre mais aussi de la rapidité des réponses, l’absence de réponse pouvant être aussi dommageable qu’une réponse erronée Les systèmes temps-réel sont généralement de systèmes complexes composés de très nombreux éléments en interactions et qui doivent s’exécuter, en temps réel, avec une sécurité et une fiabilité dans leur fonctionnement. Une autre propriété essentielle des systèmes temps-réel, est leur prédictibilité ; c’est pourquoi ils sont associés à des outils de simulation qui permettent de les tester et les valider. Les étapes clés dans la réalisation de systèmes temps-réel sont :la spécification, la conception, l’implémentation (programmation), les tests (débogging) et la validation. Les contraintes de fiabilité des systèmes temps-réel ont orienté l’évolution de méthodes de notation de ces systèmes, de la spécification informelle en langage naturel vers des approches formelles ; citons notamment :

- Les diagrammes Etat-transition (machine à états-finis, automates à états-finis) dont le concept a été développé par Stephen Klein dans les années 60 pour la modélisation de tous systèmes informatiques, y compris les systèmes concurrents et les systèmes temps-réel.

- Les réseaux de Pétri développés il y a plus de 30 ans par C. A. Petri pour la modélisation des systèmes concurrents et les systèmes temps-réel.

- Le calcul de systèmes communicants (CCS : Calculus of Communicating Systems) développé par Robin Milner (EdCam) dans les années 80.

Dans cette étude, nous avons appliqué le formalisme des diagrammes d’états-transition pour décrire, représenter et simuler un processus biologique : le contrôle de l’entrée en mitose par le complexe MPF.

B. Présentation du langage de modélisation unifié : UML pour RT (Tiré de : C. Rosenthal-Sabroux, dans Kettani et al., .De Merise à UML, Ed. Eyrolles, Paris 1998)

1. Concepts de base de l’approche objet

UML est un langage de modélisation fondé sur les concepts orientés objet qui sont nés il y a plus de trente ans ; UML n’est donc pas à l’origine des objets ; néanmoins, il en constitue une étape majeure, dans le sens où il unifie les différentes approches et en donne une définition plus formelle. Pour bien comprendre le langage, il est donc nécessaire de commencer par un rappel général de ces concepts. Cette présentation est très brève et ne prétend pas couvrir tous les concepts. Seuls les quatre concepts fondateurs sont introduits : Objet, Classe, Abstraction, Encapsulation et Composant.

14

Système orienté objet L’approche orientée objet est fondée d’abord sur le principe suivant : tout système orienté

objet est en fait une société d’objets qui coopèrent. Pour coopérer, les objets utilisent des messages qu’ils s’envoient entre eux par divers mécanismes qui dépendent de l’environnement de mise en œuvre.

Tout système au sens large avec un contour bien défini peut faire l’objet d’une modélisation

orientée objet. Il peut s’agir d’une entreprise, d’une société quelconque (humaine, animale...), d’un logiciel ou d’un système informatique.

Objet Un objet est un membre d’un système orienté objet. Un objet possède une identité, un état et

un comportement. Les objets sont donc des éléments d’un système défini par son périmètre dans un domaine particulier et non pas des entités qui existent en dehors de tout domaine. Un objet est donc défini dans son domaine par : • Une identité qui constitue le moyen d’identifier l’objet par rapport aux autres objets du

système. Chaque objet dans un système doit avoir une identité. • Un comportement qui définit la manière dont l’objet agit et réagit aux divers messages qui lui

parviennent de son environnement. • Un état qui définit l’une des possibilités dans laquelle un objet peut se trouver à un instant

donné de sa vie. •

Classe Dans la description d’un problème réel, il est impossible de décrire tous les objets de ce

domaine. Les classes sont un moyen pour grouper des objets qui présentent une structure commune et un comportement commun, en un mot des objets qui se ressemblent. Ce regroupement relève de la problématique de la classification qui est particulièrement bien décrite par G. Booch dans [Booch, 1994]. Une classe est donc une abstraction qui décrit plusieurs objets. La relation qui existe entre une classe et ses objets est appelée « instanciation ».

Une classe active est une classe dont les instances sont des objets actifs. Une classe active

représente un flot de contrôle indépendant alors qu’une classe normale (passive) ne met pas de flot en application.

15

Abstraction L’abstraction constitue un des piliers de l’approche orientée objet. On peut en donner deux

définitions qui se complètent :

• processus consistant à identifier une entité en mettant en évidence ses caractéristiques pertinentes du point de vue de son utilisation.

• caractéristiques essentielles d’une entité qui la distinguent de tous les autres types d’entités. Une abstraction définit une frontière relative à la perspective de l’observateur.

Le travail essentiel du concepteur consiste donc à appliquer un bon processus d’abstraction

pour construire de bonnes abstractions. Cette démarche d’abstraction aboutit à construire des systèmes robustes face aux évolutions ; ce qui en constitue le point fondamental. La voiture pour un mécanicien est considérée du point de vue de sa mécanique, alors que le concessionnaire la considère du point de vue de ses équipements et de son prix.

Encapsulation

L’encapsulation accompagne l’abstraction. L’encapsulation permet de présenter une

abstraction à son observateur (son client, son utilisateur) de manière à ne voir justement que les caractéristiques essentielles et surtout à ignorer les détails de sa réalisation. L’encapsulation permet donc de décrire une abstraction sous forme d’une partie visible appelée « interface » et d’une partie cachée appelée « implémentation ».

Composants

Développer un système en assemblant des composants existants (comme construire un

bâtiment avec du préfabriqué) au lieu de fabriquer chaque brique de base est une idée qui a fait son chemin. Les concepts sous-jacents ne sont pas nouveaux ; il est possible de dire maintenant qu’ils sont opérationnels ; ce qui révolutionne définitivement la manière dont on développe les systèmes logiciels. Cette révolution est équivalente à l’introduction des microprocesseurs dans l’industrie des ordinateurs. Un composant est un élément binaire qui expose aux autres composants du système (ses clients) une interface qui leur permet de dialoguer avec le composant en question. Cette interface est un contrat qui définit la manière d’utiliser le composant. Le concept de composant est encore plus riche et plus intéressant que celui de classe car la classe est de plus faible granularité que le composant. Le composant implémente plusieurs classes.

16

2. Introduction à UML

UML est un langage UML (Unified Modeling Language) est un langage de modélisation unifié (ou universel !) et

non pas une méthode. UML a été conçu pour permettre la modélisation de « tous » les phénomènes1 de l’activité de l’entreprise (processus métier, systèmes d'information, systèmes informatiques, composants logiciels...) indépendamment des techniques d’implémentations (système automatisé ou non, langage de programmation...) mises en œuvre par la suite. C'est probablement la première2 fois dans le monde du développement logiciel que plusieurs spécialistes en méthodes, fournisseurs, utilisateurs et organismes de standardisation s’accordent pour proposer un langage unique de modélisation. Cette initiative a recueilli un accueil et une adhésion rarement observés ; même les adversaires du début s’y sont finalement ralliés.

UML est plus qu’une simple notation : un langage de modélisation UML est un langage de modélisation au sens de la théorie des langages. Il contient de ce fait

les éléments constituants de tout langage, à savoir : des concepts, une syntaxe et une sémantique. De plus, UML a choisi une notation supplémentaire ; il s’agit d’une forme visuelle graphique fondée sur des diagrammes. Si l'unification d'une notation est secondaire par rapport aux éléments constituants du langage, elle reste cependant primordiale pour la communication et la compréhension humaine.

Un métamodèle décrit UML UML est un langage fondé sur un métamodèle lui-même décrit en UML. Le métamodèle

d’UML est essentiel, car il donne une vision plus formalisée du langage et il définit toutes les possibilités d'extensibilité de celui-ci. Le métamodèle confirme la puissance d’UML qui peut se décrire en utilisant ses propres concepts et son propre formalisme.

D. Harel, concepteur des machines à états de même nom, a récemment démontré que le langage UML permet de modéliser des systèmes exécutables ; en d’autres termes, UML est lui-même exécutable. Ceci ouvre des possibilités de construction d’outils de simulation et de génération de code formels.

1 G. Booch expliquait récemment que le ministère de la Justice américain modélisait les processus pénitencier de New York avec UML. 2 Merise et Euromethod sont deux tentatives précédentes ; malheureusement, elles se sont limitées à la France ou à l’Europe.

17

Architecture d’UML

L’architecture d’UML est présentée en deux volets : d’une part les constituants élémentaires qui forment la structure complète du langage et d’autre part la structure globale du langage (figure 3).

Diagram m e

El ém ent de m odéli s ation

Cons tituant

Vue

UML

0..*0..*

Processus

Cas d'utilisation

Déploiem ent

Logique

Com posants

Figure 3 : Architecture d’UML.

Constituants d’UML

Les constituants d’UML sont les éléments de modélisation et les diagrammes (figure 4).

• Les éléments de modélisation représentent toutes les propriétés du langage. Ils ne sont pas limités par le symbolisme graphique utilisé ; cependant, les éléments de modélisation doivent être clairs et précis. Étant donné la nature de la chose modélisée (métiers, systèmes...) et surtout son évolution, il est probable que certains phénomènes ne soient même pas encore connus, et les techniques de modélisation évoluent dans les prochaines années. Par ailleurs, les domaines d'application affichent des besoins de modélisation spécifiques. Il y a donc un équilibre judicieux à trouver entre la complétude du langage et sa simplicité. De ce fait, UML définit des mécanismes d'extension qui permettent d’adapter le langage à des utilisations et des domaines particuliers voire de le faire évoluer.

18

• Les diagrammes constituent l'autre composante d’UML. Ils en constituent l'expression visuelle et graphique. Les symboles ne véhiculent pas de sémantique et leur choix est essentiellement une question d’esthétique et d’ergonomie. Il n'y a pas suffisamment de symboles et de formes pour tout représenter. La simplicité et la cohérence doivent rester de mise. Il existe plusieurs concepts sémantiques dans UML qui ne trouvent pas de représentation (notation) graphique. La correspondance entre éléments de modélisation et symboles graphiques n'est pas bijective. La position et l'orientation des éléments est importante dans la mesure où elle facilite la compréhension. UML définit neuf diagrammes, chacun permettant de présenter une perspective de l’architecture du système.

•

Diagram me

Déploie ment Composants Cas d'uti li sation Classes

Objet C ollaboration Séquences Etats -trans ition Activités

Figure 4: Liste des diagrammes UML.

Un des aspects fondamentaux d’UML qui déroute souvent les non-initiés est le fait qu’un diagramme n’est pas un modèle mais une représentation graphique de quelques éléments du modèle. Un diagramme est une projection sur le modèle, une perspective sur le modèle. Un diagramme de classes n’est pas le modèle de classe. Un diagramme de classes ne montre pas toutes les classes avec toutes leurs informations, il deviendrait illisible ; plusieurs diagrammes sont nécessaires pour illustrer le modèle complet.

19

Concepts d’UML, modélisation et processus Une des grandes différences entre UML et les autres approches (orientées objet ou pas) est

l’utilisation de concepts généraux pour décrire différents phénomènes. Même si certains voient en UML un langage complexe, la simplicité a guidé sa conception. L’intérêt des objets est qu’ils offrent l’abstraction, l’encapsulation, la stabilité et surtout l’évolutivité. C’est ce dernier point qui milite en faveur de l’utilisation de la technologie objet pour modéliser des processus métier. En effet, l’apport majeur des technologies objet est l’évolutivité et la flexibilité ; ces deux attributs caractérisent les organisations d’aujourd’hui.

Figure 5 : Système orienté objet.

Le schéma ci-dessus montre un système orienté objet dans lequel les objets interagissent pour exécuter les processus (figure 5). Il montre la difficulté à appréhender un système de cette manière en raison de sa complexité ; les objets interagissent beaucoup. L’approche par les processus (cas d’utilisation) simplifie la tâche ; les groupes d’objets sont considérés processus par processus (figure 6).

%Acheteur

Figure 6 : Système orienté objet approché par les processus.

20

Description d’un processus ou cas d'utilisation La description d’un cas d’utilisation peut se faire de plusieurs manières, de la plus informelle

(textuelle) à la plus formelle (machines à états). Il faut accorder beaucoup d’attention à la description textuelle car elle correspond au support le plus clair et le plus compréhensible par les non-informaticiens. La description d’un processus consiste à détailler les activités internes du processus, c’est-à-dire son flux d’événements. La description du processus métier sert à expliquer aux intervenants du métier leurs rôles, leur travail et leurs autres activités. Il est nécessaire qu’elle soit compréhensible par tout le monde. L’expérience montre que la description textuelle reste la meilleure, en tout cas dans une première approche.

Les critères d’une bonne description textuelle sont les suivants : - utilisation d’un français rigoureux ; - construction progressive et référence à un glossaire des termes du domaine ; - utilisation de phrases courtes et non ambiguës ; - structuration en flux normal et flux alternatifs ;

Par ailleurs, il est important de travailler processus par processus ; en d’autres termes, il faut décrire les processus métier indépendamment les uns des autres. Il peut y avoir plusieurs descriptions d’un même processus métier :

- Une description externe qui donne la vision externe du processus du point de vue de

l’utilisateur (acteur) du métier. Elle décrit ce que doit faire le processus pour « satisfaire » l’acteur. Cette description est probablement le point de départ de toute l’activité de modélisation qui suit.

- Une description interne plus détaillée qui explique comment le processus fonctionne de l’intérieur .

Ces deux descriptions sont nécessaires et minimales. D’autres descriptions peuvent être développées.

21

Descriptions formelles des processus

Les machines à états de D. Harel permettent de décrire de manière formelle les processus métier. Ces machines sont particulièrement intéressantes pour écrire des processus complexes qui reçoivent plusieurs stimuli. Un Diagramme d'Etat Transition est utilisé pour montrer :

– le cycle de vie d’une classe – les événements qui provoquent une transition d’un état à un autre – les actions qui résultent d’un changement d’état

L’espace d’état d’une classe est l’énumération des tous les états possibles d’un objet. L’état d’un objet est l’une des conditions possibles dans lequel un objet peut exister. Les concepts du diagramme d'état/transition sont :

- Etat : Situation d’un objet que l’on désire connaître et gérer. L’état d’un objet dépend de la valeur de ses attributs et de la présence (ou l’absence) de liens avec d’autres objets au sein des associations

- Transition : Passage d’un objet d’un état à un autre. Elle est déclenchée par un événement - Evénement : stimulus qui provoque une (ou plusieurs) transition(s)

Workflows des processus

Une fois les entités identifiées (du moins les candidats), il s’agit ensuite de décrire le flux

d’événements et les activités des processus en utilisant les objets créés. Le flux d’événements est appelé « workflow ». La description d’un « workflow » est très utile : • pour montrer le détail des interactions entre entités • pour identifier les protocole • quand des parties d’un processus sont complexes ou manquent de clarté • quand l’exactitude de la séquence d’activités est importante •

La description complète du workflow ne donne pas lieu à un seul diagramme mais à plusieurs : elle est ainsi plus lisible et communicable. À cet effet, le workflow est découpé en sous-flux (qui sont des séquences incomplètes du flux principal) ; on présente chaque sous-flux dans un diagramme d’interaction. Cette technique est particulièrement intéressante pour identifier, représenter et communiquer des « patterns » d’interaction entre objets. UML définit deux diagrammes d’interaction équivalents ; c’est-à-dire fondés sur la même information sous-jacente mais chacun mettant l’accent sur un aspect particulier de l’interaction : il s’agit des diagrammes de séquence et des diagrammes de collaboration.

Dans un système purement séquentiel, il n’y a qu’un flot de contrôle. Cela signifie qu’un seul

fait peut se produire à la fois. Lorsqu’un programme séquentiel démarre, le contrôle reste au début du programme et les équations sont envoyées les unes après les autres. Même si des faits concurrents se produisent parmi les acteurs en dehors du système, un programme séquentiel traite seulement un événement à la fois et met en attente ou rejette tout événement externe concurrent.

22

Dans un système concurrent il y a plusieurs flots de contrôle, ce qui signifie que plusieurs choses peuvent se produire en même temps. Dans un système concurrent des flots de contrôle multiples simultanés existent, chacun à la tête d’un processus indépendant ou thread. En UML, on utilise une classe active pour représenter un processus ou un thread qui est à la racine d’un flot de contrôle indépendant et qui est concurrent avec tous les autres flots de contrôle.

Diagramme de séquences Un diagramme de séquence permet de montrer si la collaboration entre les objets est bien

définie, si les objets ont les bonnes responsabilités et si le modèle est souple du point de vue des évolutions futures (figure 7).

Chef d 'orches tre A B C D

1: M1

2: M2

3: M3

4: M4

Figure 7 : Diagramme de séquence.

Un diagramme de séquence montre les interactions, entre les objets, arrangée en séquences dans le temps. En particulier, il montre les objets participants dans l’interaction par leur “lignes de vie” et les messages qu’ils échangent ordonnancés dans le temps. Il ne montre pas les associations entre les objets.

Un diagramme de séquence est en deux dimensions : l’axe vertical correspondant au temps tandis que l’axe horizontal recense les objets qui interagissent dans la séquence en question. Une ligne verticale est attachée à chaque objet de la collaboration et montre la « ligne de vie » de l’objet en question. Pou représenter la création ou la destruction d’un objet sur un diagramme de séquence, il faut démarrer ou arrêter sa ligne de vie aux points appropriés ; dans les autres cas de figure, la ligne de vie va du haut en bas du diagramme.

Les diagrammes de séquence sont utiles pour comprendre, documenter et expliquer des modèles et non pour les implémenter. Ils doivent être clairs pour faciliter la communication. Les détails non pertinents doivent être évités.

Un diagramme de séquence montre essentiellement la séquence des événements et ignore les détails des collaborations. UML introduit un diagramme équivalent et complémentaire au diagramme de séquence appelé diagramme de collaboration.

23

Diagramme de collaborations Un diagramme de collaboration montre les interactions entre les objets et leurs liens.

Contrairement au diagramme de séquence, un diagramme de collaboration montre les relations entre les objets. En revanche, un diagramme de collaboration n’intègre pas la dimension du temps.

Le diagramme de collaboration et le diagramme de séquence sont équivalents. Le diagramme de collaboration permet de définir les relations entre les classes. S’il existe un message entre deux objets, il existe alors une relation entre leurs classes respectives. Les diagrammes de collaboration véhiculent des informations.

Classes

Une classe est un ensemble d’objets qui possèdent une structure, un comportement et des

relations similaires. Le nom d’une classe a une portée dans le paquetage dans lequel elle est déclarée ; le nom doit être unique dans son paquetage (parmi les noms de classes).

Dans un système réel, le nombre d’objets est trop important pour pouvoir être appréhendé

proprement et facilement. Le concept de classe est introduit pour prendre en compte cette complexité. Une classe est une représentation abstraite des objets. Il s’agit de regrouper des objets qui se ressemblent (mêmes propriétés, comportements, sémantique…) d’un certain point de vue. Un objet actif sera un objet qui possède un processus ou un thread et qui peut déclencher une activité de contrôle (un processus est un flot lourd qui peut s’exécuter en concurrence avec d’autres processus, un thread est un flot léger qui peut s’exécuter avec d’autres threads à l’intérieur du même processus. Une classe active sera une instanciation d’objets actifs. Contrairement aux classes actives, les classes normales, sont implicitement appelées classes passives car seules elles ne peuvent pas déclencher d’activité de contrôle.

Diagrammes de classes Les classes sont présentées graphiquement dans des diagrammes de classes. Un diagramme

de classes est une collection d’éléments de modèle (statiques), tels que des classes, des interfaces et leurs relations, connectés entre eux comme un graphe. Un diagramme de classes est un graphe d’éléments de modélisation.

Un diagramme de classes permet de représenter des classes et leurs relations. L’élaboration des relations entre classes se fait en étudiant le domaine d’application (pour trouver les relations inhérentes au domaine) et les collaborations entre objets.

24

Stéréotypes Le diagramme de classes tel qu’il est présenté ne montre pas de différences entre les classes ;

elles sont présentées toutes de la même manière. UML introduit la possibilité de classifier les classes3 selon des critères définis par le développeur (analyste, concepteur...) ; un ensemble de critères de classification est appelé : Stéréotype. Il est possible de définir ses propres stéréotypes et de leur associer une représentation graphique particulière ou simplement de les distinguer dans le diagramme de classes.

Un diagramme de classes montre uniquement des aspects statiques du modèle et fait

abstraction des aspects dynamiques ou temporels, même si les éléments du diagramme de classes peuvent avoir un comportement dynamique important.

Dans un projet, il est difficile de construire un diagramme de classes qui montre toutes les

classes du problème avec toutes leurs relations ; car il serait tout simplement illisible. La construction d’un diagramme de classes (ou de tout autre diagramme d’ailleurs) relève de la réponse à la question essentielle : « À qui s’adresse un diagramme donné ? Que veut-on lui communiquer comme message dans ce diagramme ? » L’intérêt principal des langages de modélisation à notation graphique est de réduire la complexité d’une information. Un diagramme de classes peut être considéré comme une coupe particulière dans la perspective logique de l’architecture du système. Dans un projet, plusieurs diagrammes de classes sont construits, chacun montrant une perspective sur le modèle complet.

Opérations Le comportement d’une classe est décrit par l’ensemble de ses responsabilités. Ces

responsabilités sont mises en œuvre par des opérations. Il n’y a pas une relation biunivoque entre une responsabilité et une opération. Pour mettre en œuvre une responsabilité, une classe peut offrir une ou plusieurs opérations. L’analyse des diagrammes d’interaction permet d’identifier les opérations d’une classe. Les messages qui arrivent sur une instance sont candidats pour donner naissance à des opérations. Il n’y a pas nécessairement une relation biunivoque entre un message et une opération, car la prise en compte de plusieurs messages peut être faite par une même opération avec des paramètres différents par exemple. De même, l’envoi d’un message peut faire l’objet de mécanismes complexes qui dépassent le simple appel procédural ; en particulier si les objets sont distribués ou s’ils appartiennent à des fils différents, il faudra alors utiliser des mécanismes de communication sophistiqués pour acheminer les messages plutôt que de simples appels de procédures. Les opérations doivent représenter une abstraction de service de manière à cacher les détails de leur réalisation aux classes clientes. 3 En fait, n’importe quel élément de modélisation peut avoir un stéréotype.

25

Relations entre classes S’il existe des liens entre objets dans les diagrammes d’interaction, cela se traduit

nécessairement par des relations qui existent entre leurs classes respectives. Les liens entre objets doivent être considérés comme des instances de relations entre classes. Les relations sont mises en évidence au cours de l’analyse des scénarios d’abord et du domaine ensuite. Il existe plusieurs types de relations entre classes : l’association (et l’agrégation qui en constitue une variante), l’utilisation et la généralisation.

Les paquetages

Une fois les processus complètement décrits, les relations, les entités (c’est-à-dire les classes

UML) deviennent vite trop nombreuses pour être appréhendés à ce niveau de granularité. Il faut donc regrouper les travailleurs et les entités en unités organisationnelles. Les regroupements peuvent se faire sur les unités de compétence ou selon les structures organisationnelles, comme les départements, les services, les unités ou les divisions. Un paquetage est un groupement d’éléments de modélisation. Un paquetage peut contenir aussi bien des paquetages emboîtés que des éléments de modélisation ordinaires. Le système entier peut être pensé comme un unique paquetage de haut niveau comprenant l’ensemble. Tous les éléments de modélisation d’UML, y compris les diagrammes, peuvent être organisés en paquetages.

26

C. L’atelier de génie Logiciel Rose RT

L’atelier de génie Logiciel Rose RT a été créé exclusivement pour le marché des systèmes embarqués et permet d’élaborer, concevoir, exécuter, tester, observer et débuguer des applications sans jamais quitter l’environnement de développement temps réel. Les concepts mis en œuvre dans rose RT sont ceux de UML pour RT avec les solutions suivantes :

1. Capsule

Les systèmes en temps réel sont basés sur la notion d’objets actifs. Dans Rose Real Time, ces objets sont décrit par leur structure et par leurs états (figure 8).

Le diagramme de structure définit la notion de capsule. Il indique les éléments d’interface

(ports), et éventuellement d’autres capsules dites englobées, ainsi que leurs connections au reste de la capsule.

Figure 8 : Représentation de la capsule d’une classe active

27

2. Port

L’existence de ports permet « d’isoler » la capsule et de traiter de façon asynchrone les messages qui arrivent. Un port est toujours typé par un protocole.

Il existe différents types de ports (figure 9) : Les ports publics sont placés sur la limite de la capsule à laquelle ils appartiennent et

permettent de communiquer avec l’extérieur et de transmettre des messages.

a. Les ports terminaux sont des ports publics qui servent à communiquer directement avec la capsule par l’intermédiaire de sa machine à état.

b. Les ports relais sont des ports publics, ils servent à communiquer avec les capsules

internes. Ce port n’est pas relié à la machine à états de la capsule englobante.

Les ports privés sont internes à la capsule et assurent toutes les communications internes.

Les ports " wired " (avec connecteur) sont reliés à la machine à état de la capsule à laquelle

ils appartiennent. Les ports " unwired " (sans connecteur) non reliés à une machine à état, sont utilisés pour se

connecter à une librairie de service offerte par Rose RT (Run Time System).

Figure 9 : Les differents types de ports dans un diagramme de structure

28

Le Run Time System de Rose Real Time offre cinq types de services (figure 10) :

un service de temps (génération d’événements temporels), un service d’exception, un service de log pour imprimer dans la console DOS à l’exécution, un service de frame qui permet de créer et de détruire dynamiquement des

capsules. un service de communication utilisé pour l’envoi des messages entre les capsules.

Pour utiliser les quatre premiers services, il suffit de les déclarer à l’intérieur d’une

capsule (privés) et sans connecteur (unwired).

Figure 10 : Les services offerts par le Run Time System de Rose Real Time.

3. Protocole

Un protocole est une classe particulière, c’est une sorte de " contrat " établit entre les capsules et spécifiant les messages qui peuvent être échangé entre elles (figure 11). Pour communiquer, deux ports doivent être typés par le même protocole, on dira que mais être conjugués, c'est-à-dire que les messages entrant de l’un sont les messages sortant de l’autre et inversement (ports conjugués).

Figure 11 : Représentation d’un protocole dans le diagramme de classe.

29

4. Capsule englobante

Une capsule peut contenir une ou plusieurs capsules (figure 12). Celles-ci peuvent être présentes dès la création de la capsule englobante ou bien, apparaître plus tard, à un moment donné de la simulation. Dans ce cas, elles peuvent être créées dynamiquement, on dit qu’elles sont incarnées. Elles peuvent être importées, dans ce cas elles ont déjà été crées et on importe simplement leur adresse mémoire. Dans les diagrammes de structure, ces différences sont symbolisées pour les capsules incarnées par des rectangles hachurés, pour les capsules importées par des rectangles gris foncé ; un rectangle gris clair représente une capsule englobée sans référence à son mode de création.

Figure 12 : Les différentes capsules internes

a. Composition Si plusieurs capsules sont présentes à l’intérieur d’une autre capsule, il y a une relation de composition entre la capsule englobante et ses capsules interne (figure 13). A la destruction de la capsule englobante, les capsules englobées seront détruites.

Figure 13 : Relation de composition entre les capsules internes et la capsule englobante, dans le diagramme de structure (droite) et dans le diagramme de classe (gauche)

30

b. Agrégation Si les deux capsules sont importées, il n’y a alors qu’une relation d’agrégation (plugin) entre les capsules internes et la capsule englobante. La destruction de la capsule englobante ne détruit pas ses capsules englobées (figure 14).

Figure 14 : Relation d’agrégation entre les capsules internes et la capsule englobante, dans le diagramme de structure

et dans le diagramme de classe

5. Cardinalité On peut répliquer une capsule ou un port en leur attribuant une cardinalité (figure 15). Si un port est répliqué, on peut envoyer un message sur toutes ses instances (broadcast) ou sur une seule qui sera spécifiée.

Figure 15 : Capsules et ports répliqués.

31

6. Machine à état d’une classe active Le comportement d’une classe active est défini par une machine à états. Dès la création de l’objet, représenté par son diagramme de structure (capsule), une transition met l’objet dans son état initial (figure 16).

Figure 16. Représentation de la capsule d’une classe active et de son diagramme d’états

32

Pour pouvoir changer d’état, un objet devra recevoir un message approprié lui permettant d’effectuer une transition ; un état pourra comporter des sous états(symbole en bas à droite de l’état englobant, figure 12). Si le déclencheur n’est pas spécifié, ce qui ne devrait jamais être le cas, la flèche est interrompue par 2 traits verticaux. Une transition peut être soumise à une condition de garde qui l’emmènera vers un état différent selon le résultat de l’évaluation (état différent si condition est vraie ou fausse). Des actions peuvent être effectuées à différents moments (figure 17):

- en entrée d’état - en sortie d’état - lors d’une transition entre deux états - En entrée et en sortie d’état

Figure 17 : Diagramme d’état avec vue sur les sous-états de l’état englobant.

Pas_declencheur_spécifié

Auto_transition

False

True

declencheur_spécifié

Action_dans_transition

transitiontransitiontransition

Action_en_entree

Condition

Action_en_entree_sortie

Action_en_sortie

transition

Initi lIniti l

état état_englobant

33

D. Modèle biologique

Le modèle biologique retenu concerne une série d’étapes bien caractérisée du cycle cellulaire qui assure un contrôle essentiel autorisant la division d’une entité cellulaire en deux cellules filles.

Les entités sont des protéines (cycline B et CDK1) qui s’associent pour créer un complexe (complexe MPF) qui pourra être activé par des modifications successives (phosphorylations) qui donnent lieu à des changements d’états . Au cours de ces modifications, le complexe acquiert des comportements différents de celui de ses composants.

Ainsi, la régulation de l’activité du MPF nécessite sa modification mettant en jeu plusieurs protéines (figure 18) :

- Une kinase (TyrK15 ou kinase Wee1) phosphoryle Cdk1 sur la tyrosine 15 (Y15). Chez les eucaryotes supérieurs, une autre kinase associée à la membrane nucléaire phosphoryle Cdk1 sur la thréonine 14 (T14). Ces phosphorylations inhibent l'activité kinase du complexe MPF et empêchent une entrée prématurée en division de la cellule (mitose).

- Ces inhibitions peuvent être levées par expression de la protéine Cdc25, une

phosphatase qui déphosphoryle les positions T14 et Y15. Toutefois, la levée de ces inhibitions n’intervient qu’après complète réplication de l'ADN, un mécanisme active TyrK15, et inhibe Cdc25 évitant toute entrée prématurée en phase M.

- Ensuite, une thréonine kinase CAK (Cdk activating kinase, constituée d'une sous-unité

catalytique Cdk7 et d'une sous unité régulatrice de type cycline H), phosphoryle Cdk1 sur la Thréonine 161. Cdk1 est alors activée tout autant qu'elle est associée à une cycline mitotique. Par ailleurs, le MPF devenu actif suractive par phosphorylation le Cdc25 et inhibe la kinase Tyr15.

Figure 18 : Activation du MPF

34

Ces mécanismes autocatalytiques expliquent le passage très brutal en phase M tout en maintenant un contrôle de sécurité interdisant le passage en M si la réplication était incomplète. Cela montre le haut niveau de contrôle de l'entrée en phase M et de rétrocontrôle de l'achèvement de la phase réplicative.

L'activation du MPF initie les évènements successifs de la mitose. En effet, la kinase

Cdk1 du complexe MPF actif phosphoryle de nombreux substrats : histone H1, lamine nucléaire, protéines du fuseau, protéines du nucléole…, ce qui permet l'entrée en mitose et son déroulement ultérieur. Cdk1 peut activer en cascade d'autres protéines kinases, lesquels vont à leur tour phosphoryler d'autres cibles.

La cycline Cdk1 associée à une cycline mitotique (B), constitue le véritable chef

d'orchestre des phosphorylations déclenchant les évènements mitotiques.

35

E. Modèle réalisé

1. Description générale

Notre modèle vise à décrire l’activation du complexe MPF cycline B/cdk1 dans une cellule eucaryote au cours du cycle cellulaire (figure 19).

La cellule est la capsule englobante principale à l’intérieur de laquelle se trouve l'ensemble du système et où auront lieu les créations et destructions de protéines (figure 14). A l’intérieur de la capsule « cellule » simplifiée, il faut distinguer:

les capsules représentant les protéines (cycline, cdk1, wee1, etc.) et les complexes protéiques (cycline/cdk1, , les capsules représentant des mécanismes cellulaires comme la transcription, la

traduction, la réplication et la computation.

Les mécanismes de transcription et de traduction sont regroupés en une seule capsule appelée « protein_production » qui simule la fabrication d’une protéine. Cette capsule et celle de la réplication, ont été très simplifiées. Ce sont en fait des boîtes noires dont on simule le fonctionnement sans le décrire compte tenu de sa complexité.

La computation est le contrôleur, le centre de décision de la cellule, elle regroupe par l’intermédiaire de sous-capsules, les mécanismes intracellulaires qui permettent :

la diffusion d’un message à l’intérieur de la cellule : information_follow_up les lois physico-chimiques qui interviennent dans la formation d’un complexe

protéique ainsi que la vérification des ressources protéiques disponibles : complex_follow_up les osmorécepteurs qui contrôlent la concentration : concentration_follow_up

Afin de pouvoir manipuler les capsules représentant les protéines et les complexes

protéiques au cours de la simulation, il est indispensable de pouvoir récupérer et stocker leurs adresses mémoires. En effet, ces adresses sont nécessaires pour :

importer des protéines à l’intérieur d’un complexe. détruire spécifiquement une capsule donnée

Lorsqu'une capsule est créée, l'opération d’incarnation l'adresse mémoire de celle-ci qui sera stockée dans une pile spécifique. Chaque protéine est indépendante, possède son propre diagramme d’états et une adresse mémoire unique.

36

Figure 19 : Diagramme de structure de la capsule « cellule ».

37

2. Implémentation du modèle

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 19). 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).

a. Lancement de la simulation

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

la computation qui contient o « complex_follow_up » o « concentration_follow_up » o « information_follow_up »

la protéine_production (transcription et traduction,…) la réplication

Les autres sont crées dynamiquement, ce qui constitue un intérêt important de Rose RT. 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:

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

Lors de la création de ces protéines, leurs adresses mémoires sont stockées dans des piles spécifiques à chaque type de protéine et de complexe afin de pouvoir gérer les ressources de chacune d’entre elles. La cdk1 possédera même une pile différente pour chacun de des états.

38

Code pour la création des cdk1 et le stockage des adresses

L’adresse mémoire est de type « RTActorId ». On utilise une variable pour récupérer la valeur de l’adresse 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 adresses 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 clase passive appelée « liste_piles ».

RTActorId a;…………………………………..//Variable servant à récupérer l’adresse for (int I = 0 ; I < MAX_cdk1 ; i++) //création d’un nombre fixé de cdk1 { a=frame.incarnate(cdk1); // Service de frame utilisant la méthode // incarnate liste_piles.pool_cdk1.empile(a); // on empile l’adresse contenue dans la // variable « a »dans la pile appropriée // (pool_cdk1) } 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 20). Cet état représente la cdk1 libre et non phosphorylée.

Figure 20 : Diagramme d’état de cdk1.

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

39

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 ».

Une fois le message injecté, la capsule chargée du traitement de l’information va donc

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ée et comporte deux capsules vides : 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. Exemple d’envoi de message entre la capsule « transcription » et la capsule « cellule »

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 de ce message. Celui-ci 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. Exemple de code utilisant le service de Timing pour introduire un délai lors de l’envoi d’un message « 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éclencher une transition.

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

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

40

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 (figure 19).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, la capsule « cplx_cycB_cdk1 » devra avoir accès aux adresses mémoires 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 adresses 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 l’adresse de l’objet contenant les adresses mémoires des protéines qui vont composer le complexe. L’adresse 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 listeAdressesProteines; // création de l’objet de type // ListeAdressesProteines

listeAdressesProteines.id_cdk1 = liste_piles.pool_cdk1.depile(); //On dépile l’adresse d’une cdk1 à partir de la pile pool_cdk1 stockée dans la classe

//liste_pile. Cette adresse est stockée dans un attribut de l’objet listeAdressesProteines listeAdressesProteines.id_cycB = liste_piles.pool_cycB.depile(); RTActorId a = frame.incarnate(cplx_cycB_cdk1, Cplx_cycB_cdk1, &listeAdressesProteines); …………// adresse de l’objet envoyé en paramètre liste_piles.pool_cycB_cdk1.empile(a); }

d. Importation des protéines à l’intérieur d’un complexe (cycline B/cdk1)

41

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 21). Au cours de cette transition, le complexe va importer les deux protéines qui le composent.

Figure 21 : Diagramme d’état du complexe cycline B / cdk1

Code de l’importation :

Le complexe récupère les données de l’objet listeAdressesProteines dont l’adresse 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 en utilisant la méthode « import ». Lors de l’importation, on indique l’adresse mémoire de la capsule importée ainsi que le nom de son instance.

ListeAdressesProteines *listeAdressesProteines = (ListeAdressesProteines *)getMsg()->getData();....... // récupération des données de l’objet qui contient les adresses

frame.import(listeAdressesProteines->id_cycB, cycB); // Importation de la cycline B. On met en paramètre l’adresse de la capsule (ici on //pointe vers l’attribut qui la contient dans l’objet

frame.import(listeAdressesProteines->id_cdk1, cdk1);

Quand les deux protéines sont importées, la cdk1 reçoit un message rtBound (service fourni par Rose Real Time) par le port « binding » pour lui spécifier qu’elle est complexée à une cycline B (figure 22, à gauche). La cdk1 passe alors dans le super-état « complex_cyclinB_cdk1 » et plus précisément, dans le sous état « cdk1 » qui est l’état initial de

42

l’état « complex_cycB_cdk1 » (figure 22, à droite). 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. 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 active 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 :

o phosphorylée par cak et passer dans l’état cdk1_pp_wee1_cak o 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 22 : Diagramme de structure du complexe cycline B / cdk1(à gauche) et diagramme d’état de la cdk1(à droite)

e. Conditions de formation d’un complexe (cyclineB/cdk1/wee1) Comme lors de la création d’une protéine, la cellule va informer la

« concentration_follow_up » qu’un complexe cycline B/cdk1 a été créé. Celle-ci va ensuite

43

envoyer un message à la capsule « complex_follow_up » pour l’avertir qu’un nouveau complexe cycline B/cdk1 a été créé.

Le complexe cycline B/cdk1 ne peut se lier qu’avec Wee1 au début de la simulation, car tant qu’on a pas injecté d’autres signaux, cak est inactif et p21 n’est pas présente. La capsule « Complex_folow_up » va donc demander la formation d’un complexe cyclineB_cdk1_wee1 après vérification de l’état des ressources disponibles. Exemple de code pour la demande de formation de complexe

Un complexe cycB / cdk1 a été créé, on vérifie l’état des ressources pour voir si on peut former un complexe. S’il y a présence d’inhibiteur dans la cellule, on va créer immédiatement un complexe avec lui pour inhiber le complexe cycline B/cdk1. On vérifie également qu’il reste bien des complexes cycline B/cdk1 dans la cellule (au cas où il aurait été utilisé entre temps).

La vérification de l’état des ressources conduit à plusieurs comportements possibles. 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é.

if ((valeurs_concentration.conc_p21>0)&&(valeurs_concentration.conc_cycB_cdk1>0)) { complex_forming.cycB_cdk1_p21().send(); // s’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 valeurs_concentration.conc_cycB_cdk1--; // concentrations } 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--; } } }

44

f. Phosphorylation de cdk1 par wee1

Le complexe cycline B/cdk1/wee1 qui a été créé va stocker sa propre adresse mémoire 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 :

- l’adresse du complexe afin de le détruire spécifiquement - l’adresse de wee1 afin de la remettre dans sa pile et qu’elle puisse être à nouveau utilisée - l’adresse du complexe cycline B/cdk1 sera conservée dans une pile spécifique aux

complexes dont la cdk1 a été phosphorylé 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.

Code pour récupérer l’adresse du complexe

Pour récupérer son adresse, le complexe utilise la fonction « frame.me() » qui renvoie sa

propre adresse, et stocke la valeur dans une variable qui est un attribut de l’objet adressesProteines.

adressesProteines.id_cycB_cdk1_wee1= frame.me(); Au début de la simulation, la wee1 est directement dans l’état « actif ». Sa liaison avec un

complexe cycline B /cdk1 va la faire passer dans un état « actif_lie » (figure 23). En effet, dans sa transition initiale, le complexe cyclineB_cdk1_wee1 envoi un message à wee1 pour lui spécifier sa liaison avec le complexe cycline B/cdk1.

Figure 23 : Diagramme d’état de wee1

45

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 24.a). 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 » (figure 24.b). Cet état montre que la cdk1 complexée avec une cycline B, a été phosphorylée par 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é phosphoryleé et qu’il peut maintenant être détruit. En biologie, ceci pourrait 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 » (figure 22).

Figure 24 : Diagramm

a

e de structure du complexe Cycline B / cdk1 /wee1(a) e

b

t diagramme d’état de la cdk1 (b).

46

g. Destruction d’un complexe (CyclineB/cdk1/wee1)

Comme pour la création, c’est la cellule englobante qui doit détruire les capsules. L’arrivée du complexe dans l’état « destroy » va provoquer l’envoi d’un message à la cellule vers le port « destroy ». La capsule « cellule » possède un port « destroy » par complexe à détruire car un port ne peut recevoir qu’un seul connecteur. Dans son message, le complexe envoi en paramètre l’objet « adressesProteines » de type « ListeAdressesProteines » contenant les valeurs des adresses du complexe et de ses composants. La cellule récupère ces adresses et va pouvoir détruire spécifiquement ce complexe et empiler les adresses des protéines qui le composaient dans les piles correspondantes. Code de la destruction du complexe

const ListeAdressesProteines *adressesProteines = rtdata; // on récupère les données de l’objet // qui contient les adresses et qui a été //envoyé en paramètre dans le message //envoyé par le complexe à la cellule RTActorId a,b,c; a=adressesProteines->id_cycB_cdk1_wee1; //on récupère les adresses du complexe a b=adressesProteines->id_cycB_cdk1; // détruire, de wee1 et du complexe c=adressesProteines->id_wee1; // cycB_cdk1 qui vient d'être phoshorylé frame.destroy(a); //on détruit le complexe (destroy) cycB_cdk1_wee1 à l’aide du // service de frame.

liste_piles.pool_cycB_cdk1_p_wee1.empile(b); //on met wee1 dans la pile wee1 et le // complexe cycB_cdk1 dans la pile // destinée aux complexes phosphorylés // par wee1 liste_piles.pool_wee1.empile(c); concentration_information.cycB_cdk1_wee1_destroy().send();

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.

47

h. Activation des cak et des polo

Pour l’instant, c’est l’injection d’un signal qui déclenche l’activation des cak et des polo. Le signal est injecté au niveau de la capsule « réplication » par le port du même nom.

En effet, ces protéines ne peuvent pas être activé tant que la réplication n’est pas terminée. Ici, l’injection de ce 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 une cascade de messages. l’envoi d’un message vers le port « replication_state ». Celui-ci arrive dans la capsule « information_follow_up » qui va envoie à son tour, un message d’activation aux cak et aux polo par les ports « cak_cativation » et « polo_activation ». Ces messages vont faire passer les cak et les polo dans l’état « actif » (figure 25).

Au cours de la transition qui les conduit à cet état, ils envoient un message à la capsule

« information_follow_up » pour confirmer leur activation. Lorsque « information_follow_up » reçoit ce message, elle informe la concentration

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 la création de complexes.

Figure 25 : Diagramme d’état de polo (semblable à celui de cak).

La création de complexe 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é par wee1 (effet contraire de Wee1, levée de l’inhibition).

48

i. 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 actif, la cdk1 va se lier avec des cdc25c inactive afin de les activer par phosphorylation. Il s’agit d’une auto-régulation en biologie. Lorsque toutes les cdk1 en complexe avec une cycline b sont activées, la cellule peut entrer dans sa phase de mitose.

j. Inhibition par la p21

Lorsqu’une erreur survient au niveau de l’ADN (réplication incorrecte) , 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 à 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 « ExtraCell_com » et « end_error_dna ».

49

3. Exécution du modèle

Le système que nous avons modélisé peut être exécuté Cela nous permet de vérifier s’il se comporte comme nous l’avons prévu et de visualiser en temps réel l’avancement de la simulation. Pour cela, il faut généré le code, le compiler et enfin lancer la simulation.

- La première étape consiste à créer un composant (figure 26), appelé ici « cellule », dans

« Component view », auquel on spécifiera le type de compilateur utilisé et la capsule englobant le système que l’on souhaite étudier.

- La seconde étape consiste à créer un « processor » dans « Deployement view ». On

affectera à ce processeur les composants que l’on veut exécuter afin d’obtenir des instances exécutables du modèle. A partir de cette instance, on pourra accéder au module d’exécution (Run Time System).

Figure 26 : Création du composant et du processus nécessaire à

la compilation et à l’exécution du modèle

50

Lorsque le Run Time System est lancé (figure 27)modèle est prêt à être exécuté, une fenêtre de contrôle (figure 27 à gauche) nous permet de lancer la simulation, de la stopper, de faire une pause ou de la relancer. Sous ces boutons de commande, une arborescence nous permet d’observer la cellule et les éléments qui la composent. Les « probes » vont nous permettre d’agir sur un port terminal particulier. Par son intermédiaire, on peut injecter des messages et suivre les messages échangés au niveau de ce port grâce à une fenêtre de traces.

On pourra ainsi commander le début de la transcription de cycline B, l’activation des

protéines polo et cak, ou bien perturber le système en injectant un signal d’erreur au niveau de l’ADN, ce qui entraîne la synthèse de l’inhibiteur p21. La figure 28 comporte un « probe » placé sur le port « end_error_dna » qui nous permet d’injecter le signal du levé de l’inhibition.

La partie de droite de la figure 28 permet de suivre l’évolution de la simulation. Ici, par exemple, on voit le diagramme de structure de la capsule « cellule ». La simulation a démarré mais on n’a pas encore injecté le signal de départ (transcription de cycline B). On peut remarquer que les protéines qui ont été créées dynamiquement dès le début de la simulation ne sont plus hachurées mais sont encadrées par un trait noir, contrairement à la p21 par exemple.

En bas, une fenêtre nous permet de suivre l’évolution des valeurs des attributs qui nous intéressent.

Commande de la simulation

Fenêtre du suivi des valeurs des attributs

Figure 27 : Le Run Time System

Probe

Fenêtre du suivi de la simulation

51

Les capsules qui n’ont pas encore été créés dynamiquement sont identifiables dans l’arborescence de la fenêtre de gauche, sous les boutons de commande, par une croix rouge qui précède leur nom. Dès qu’une capsule est créée, la croix disparaît.Par exemple, dans la figure 28, la cdk1 est la seule capsule qui ait été créée, elle n’est plus hachurée dans le diagramme de structure et il n’y a plus de croix dans la fenêtre de gauche.

Figure 28 : Listes des capsules (présentes ou non) et leur représentation dans le diagramme de structure

On peut également suivre la simulation à partir du diagramme de structure d’un complexe.

La figure 29 montre les diagrammes de structure de deux complexes cycline B/ cdk1 : - Le complexe A n’a pas encore été créé, les deux protéines qui le composent n’ont donc

pas encore été importées à l’intérieur de sa structure et les capsules représentant ces protéines sont toujours colorées en gris foncé.

- Le complexe B, par contre, est formé et ses deux protéines importées. Elles sont teintées en gris clair et encadrées d’un trait noir.

Complexe A

Complexe B

Figure 29 : Visualisation de l’importation de capsules. A : capsules non importées, B capsules importées.

52

La figure 30 montre les diagrammes d’états de deux cdk1, complexées avec la cycline D, dans deux états différents. L’état dans lequel se trouve la capsule est identifiable par un cadre noir qui l’entoure.

- La cdk1 A est dans l’état « cdk1 », elle est donc non phosphorylée. - La cdk1 B est dans l’état « cdk1_p_wee1 », ce qui montre qu’elle a été phosphorylée par

wee1. La fenêtre DOS nous permet d’afficher des messages que l’on a créé à l’aide du service de

« log ». Ces affichages permettent de suivre les différentes étapes de l’éxécution. Ici des cdk1 ont été phosphorylées par wee1.

Cdk1 A

Cdk1 B

Figure 30 : Visualisation des états de deux cdk1.

53

La figure 31 nous présente une fenêtre de « traces » qui permet de visualiser les messages qui s’échangent entre des capsules sélectionnées à l’aide de « probes ». Ici, on voit des échanges entre un complexe cycline B/cdk1, wee1 et un complexe cyclineB_cdk1_wee1.

A partir de cette fenêtre on peut générer un diagramme de séquence qui représente

graphiquement les messages échangés et les états des capsules au moment de l’envoi ou la réception de ceux-ci..

a

b

Figure 31 : Diagramme de séquence (a) obtenu à partir de la fenêtre de traces (b).

54

IV. Discussion

Une caractéristique essentielle des objets, tant dans le monde réel (ici, la biologie) que pour leur représentation informatique, c’est leur caractère dynamique : ils peuvent être créés et détruits dynamiquement. Un objet est caractérisé par un état ; en réponse aux sollicitations qu’il reçoit, un objet possède la capacité d’effectuer certaines actions dont l’effet peut modifier son état interne ou requérir l’exécution d’autres actions par d’autres objets. Ainsi, un objet informatique qui représente un « vrai » objet du monde réel pourra réaliser des actions correspondant à chacune des actions du monde réel : il s’agit de la contrepartie dans le système informatique de la vraie « action » du monde réel. La réalisation de logiciels pour décrire et simuler le comportement de systèmes complexes du monde réel ouvre des perspectives pour le traitement des données de la biologie post-génomique.

En tout premier lieu, il est nécessaire de s’attacher à une description rigoureuse du domaine d’intérêt et les spécifications formelles sont la contrepartie dans le système informatique de ce que le logiciel doit faire ; il sera ensuite possible de vérifier le bon fonctionnement (simulation) de ces spécifications. Pour ce faire, on doit disposer d’un langage de modélisation qui prenne en compte divers problèmes de modélisation, notamment (1) la standardisation car l’unification et l’acceptabilité sont des buts recherchés pour faciliter la communication ; (2) néanmoins adaptable car .les domaines d’application sont divers et variés et pouvant évoluer facilement sans avoir à remettre en question le standard. Nous avons retenu en première analyse UML car il répond à ces critères tout en offrant des mécanismes d’extensibilité qui permettent justement de le faire évoluer de manière contrôlée en l’adaptant à divers contextes d’utilisation.

Parmi les différents points d’intérêt que nous avons constaté, nous mentionnerons tout particulièrement :

L’aspect modulaire, qui correspond bien aux méthodes de traitement des systèmes complexes. Dans notre exemple, nous avons traité différents processus très complexes (transcription, traduction, réplication de l’ADN, etc.) comme des boîtes noires sans préjudice du fonctionnement de l’ensemble. Ces différents sous-systèmes pourront être traités ultérieurement, en fonction des disponibilités et des moyens, suivant les mêmes principes. la création dynamique d’objets, propriété essentielle pour la modélisation des systèmes biologiques dont le fonctionnement est assuré par une succession de complexes qui se font et se défont entre les « objets ». Cette propriété est traitée par RoseRT mais absente d’autres outils tel Esterel qui impose que tous les objets soient créés lors du lancement du programme. la propriété d’émergence, propriété définitoire de la notion de système. Une définition mnémonique décrit l’émergence comme la propriété selon laquelle « le tout est plus que la somme des parties » ; autrement dit, le tout a un comportement différent de la somme de ses composants. Dans RoseRT, le comportement du complexe (la capsule englobante) est différent du comportement de ses composants pris individuellement (les capsules englobées).

55

les contraintes sont une autre propriété définitoire des systèmes car elles limitent l’espace des états et définissent le comportement des objets. Le langage de spécifications des contraintes sur les objets (OCL) d’UML permet de colliger les contraintes sur les entités biologiques pour décrire leur comportement dans un processus particulier et ainsi décrire des bibliothèques de contraintes et leur comportement associé. Le comportement déterministe mis en œuvre dans notre modèle pourrait toutefois être élargi à un comportement stochastique par, notamment, l’introduction de capsules génératrice de « bruit » qui simuleront la survenue d’évènements aléatoires. la simulation avec l’outil RQA-RT (Rational Quality Architect-Real Time) permet en fixant un état final de prédire quels sont les scénarios qui y conduisent et d’identifier ainsi les évènements à redouter en réalisant des traces complètes de ces scénarios (signal d’erreur lorsqu’une propriété n’est pas respectée). Dans le cadre du stage, nous n’avons pas eu la possibilité de tester RQA-RT qui sera examiné ultérieurement.

56

V. BILAN et PERSPECTIVES Ce stage effectué dans l’unité de Structure Bio-Systémique – Modélisation Ingénierie de

l’Institut Pasteur a été tout à fait en accord avec la formation dispensée par le DESS compétences complémentaires en informatique suivi à l’université d’Evry. En effet, il m’a permis d’exploiter ma double compétence avec un projet qui a porté autant sur la biologie que sur l’informatique.

Mon premier travail a porté sur la partie biologique. Il a consisté à effectuer des recherches

bibliographiques afin d’étoffer et de mettre à jour mes connaissances sur le modèle étudié. Dans le cadre d’un projet pluridisciplinaire ARC-INRIA (Calculs de Processus et Biologie

des Réseaux Moléculaires), dont les membres sont en majorité des logiciens et des mathématiciens, nous avons participé à plusieurs réunions et groupes de travail. Au cours de ceux-ci, nous leur avons présenté le déroulement des principales étapes du cycle du cycle cellulaire et les principaux concepts d’interactions protéiques. Ces échanges m’ont permis d’appréhender une approche de la biologie d’un autre point de vue.

Avant la création de notre modèle et après avoir bien déterminé le modèle biologique sur lequel nous allions travailler, nous avons établit des prototypes à l’aide de Nasser Kettani, Directeur du Marketing chez Rational Software et de Camille Rosenthal-Sabroux (Université paris dauphine). Cette première étape de modélisation nous a permis de voir les difficultés que l’on peut rencontrer lorsque l’on veut représenter dynamiquement un modèle biologique qui tient compte des trois paramètres essentiels à la compréhension du fonctionnement du vivant : le temps, l'espace et la forme, qui sont aussi les fondements de la modélisation systémique. La principale activité du début de notre stage a été de réfléchir sur la manière de représenter le vivant à l’aide des théories informatiques, notamment en ce qui concerne les interactions protéiques ,les transformations biologiques (phosphorylations…) et mais également sur les parties dont les connaissances sont encore limitées.

Ces prototypes nous ont permis d’avoir une vision globale sur la modélisation de notre modèle biologique.

Un stage de formation de quatre jours chez Rational Software sur le sujet

« Développement des logiciels temps réel avec UML et Rational Rose RealTime » nous à permis de maîtriser le logiciel et d’acquérir quelques bases en modélisation temps réel. A partir de ces connaissances, nous avons réussi à réaliser le modèle que nous avions conçu dans un premier temps en prenant en compte les contraintes liées à la biologie et à l’informatique.

A partir de ce modèle, des outils spécifiques à rose real time nous permettent de tester des

scénarios à l’aide de diagrammes de séquences. Le scénario testé est comparé au scénario qui est réellement joué lors de la simulation. Ces tests pourraient nous permettre de corriger et d’améliorer le modèle en fonction de l’avancée des recherches biologiques.

Cependant, le modèle pourrait être amélioré en prenant plus en compte ces contraintes de localisation, de temps et de forme dont nous avons parlé. Pour cela il suffirait d’ajouter des attributs spécifiques à celles-ci sur lesquels on pourrait également poser des conditions. Par exemple, pour les interactions protéiques, des attributs représentant les séquences d’ADN seraient

57

vérifier avant de créer un complexe. On pourrait alors simuler des erreurs dans ces séquences pour bloquer la formation d’un complexe. La simulation permettra de suivre le fonctionnement des multiples processus biologiques (voies métaboliques, signalisation, divers modules fonctionnels dont le cycle cellulaire, etc.) qui auront été spécifiés à l'étape précédente. La prédiction des comportements sera rendue possible avec, notamment, la recherche des " chemins " conduisant à la vérification d'hypothèses ou de propriétés nouvelles (par exemple, développement d'un état pathologique).

Ce stage m’a permis d’utiliser les connaissances biologiques acquises durant ma formation initiale et de mettre en pratique certains enseignements dispensés pendant l'année (UML, programmation). Il m’a également permis de me familiariser avec la vie professionnelle.

58

VI. Bibliographie Livres : Kettani, N., Mignet, D. , Paré, P. , Rosenthal-Sabroux, C. De Merise à UML, Eyrolles, 1998. Booch, G. Object-Oriented Analysis and Design with Applications, 2 e édition, Addison-Wesley, 1994. Le Moigne, J-L. (1977-94). Théorie du Système Général, Théorie de la Modélisation, 4ème édition, PUF, Paris. Bouzeghoub, M. , Gardarin, G. , Valduriez, P. (1995). Du C++ à Merise Objet, Eyrolles, 2 e édition. Cauvet, C., Rosenthal-Sabroux, C. (2001). Ingénierie des Systèmes d'Information, Hermès. Muller P.A. (1997). Modélisation objet avec UML, Eyrolles. Support de cours : Rational University, (2002). Developing Real-Time Software with Rational Rose RealTime: student manual. Version 2002.05.00. Articles : Brown, N.R., Noble, M., Endicott, J.A., Jonhson, L.N. (1999). The structural basis for specificity of substrate and recruitment peptide for cyclin-dependant Kinases. Nature Cell Biology. Vol 1, 438-443. De Brondt, H.L., Rosenblatt, J., Jancarik, J., Jones, H.D., Morgan, D.O., Kim, S. (1993). Crystal structure of cyclin-dependant Kinase 2. Nature. Vol 363, 595-602. Endicott, J.A., Noble, M., Tucker, J.A. (1999). Cyclin-dependant Kinases: inhibition and substrate recognition. Current Opinion in Structural Biology. Vol 9, 738-744. Kohn K.W. (1999). Molecular Interaction Map of the Mammalian Cell Cycle Contol and DNA Repair Systems. Molecular Biology of the Cell, Vol 10, 2703-2734. Morgan, D.O. (1995). Principles of CDK regulation. Nature. Vol 374, 131-134. Pavletich, N.P. (1999). Mechanisms of Cyclin dependant Kinase Regulation : Structure of Cdks, their Cyclin Activators, and Cip and INK4 Inhibitors. J. Mol. Biol. Vol 287, 821-828.

59

Roux-Rouquié, M., Huynh, N., Kettani, N., Le Moigne, J.L., Rosenthal-Sabroux, C. (2001). The relevance of Modeling Language for Systemic Representation of Biological Process. International Conference THE SCIENCE OF DESIGN, Software design, INSA-Lyon. Roux-Rouquié, M., Le Moigne, J.-L. The systemic paradigm and its relevance to the modelling of biolgical functions. C. R. Biologies 325 (2002) 419-430 Russo, A., Jeffrey, P.D., Pavletich, N.P (1996). Structural basis of cyclin-dependant Kinase activation by phosphorylation. Nature structural biology. Vol 3, number 8. Xiong, Y., Hannon, G.J., Zhang, H., Casso, D., Kobayashi, R., Beach, D. (1993). P21 is a universal inhibitor of cyclin Kinases. Nature. Vol 366, 701-710. Jacobson, I.; Ericsson, M., Jacobson, A. (1994). The object advantage : Business process reengineering with object technology, Addison-Wesley. Kruchten , PH. (1995). The 4 + 1 View Model of Architecture , IEEE Software, vol. 12, N°6, novembre. Sites Web : http://discover.nci.nih.gov

Contenant l’article de Kohn et ses cartes d’interactions moléculaires.

60

VII. Annexes

61