2017-07-08 17:42:46 +02:00
|
|
|
|
\chapter{Travelling Bacteria}\label{chap:partie-otb}
|
|
|
|
|
\minitoc
|
|
|
|
|
\begin{figure}[h]
|
|
|
|
|
\centerline{%
|
|
|
|
|
\includegraphics[width=19cm]{figures/otb2-display}}
|
|
|
|
|
\caption{Fenêtre de rendu du logiciel \tb{} lors d'une simulation comportant
|
|
|
|
|
un grand nombre de bactéries. Les cadres jaunes indiquent l'espace
|
|
|
|
|
actuellement occupé par les bactéries et leur support}
|
|
|
|
|
\label{fig:otb2-display}
|
|
|
|
|
\end{figure}
|
|
|
|
|
|
|
|
|
|
\clearpage
|
|
|
|
|
\section*{Préliminaires}
|
|
|
|
|
Voici quelques notations utilisées dans ce chapitre:
|
|
|
|
|
\begin{itemize}
|
|
|
|
|
\item $(G,+)$ est le groupe engendré par l'ensemble $G$ et la loi $+ : G \times
|
|
|
|
|
G \rightarrow G$.
|
|
|
|
|
\item $\langle G \rangle$ est le groupe libre engendré par l'ensemble des
|
|
|
|
|
générateurs $G$.
|
|
|
|
|
\item $\mathbb{N}_+$ est l'ensemble des entiers naturels privé de $0$.
|
|
|
|
|
\item $\lfloor x \rfloor = \text{max} \{ m \in \mathbb{Z} \,|\, m \leq x \}$ est
|
|
|
|
|
la fonction partie entière de $x \in \mathbb{R}$.
|
|
|
|
|
\item $\orr{u}$ est un vecteur,
|
|
|
|
|
\item $\|\orr{u}\|$ est la norme euclidienne du vecteur $\orr{u}$,
|
|
|
|
|
\item $k \cdot\orr{u}$ est le produit scalaire entre un scalaire $k$ et un
|
|
|
|
|
vecteur \orr{u},
|
|
|
|
|
\item $\orr{u}\cdot\orr{v}$ est le produit scalaire entre deux vecteurs \orr{u}
|
|
|
|
|
et \orr{v},
|
|
|
|
|
\item $\orr{u}\wedge\orr{v}$ est le produit vectoriel entre deux vecteurs
|
|
|
|
|
\orr{u} et \orr{v}.
|
|
|
|
|
\item $\left[ x \right]^{x_{\mathit{max}}}_{x_{\mathit{min}}}
|
|
|
|
|
= \left\{ \begin{array}{ll}
|
|
|
|
|
x_{\mathit{max}} & \text{si}\; x > \mathit{max}\\
|
|
|
|
|
x_{\mathit{min}} & \text{si}\; x < \mathit{min}\\
|
|
|
|
|
x & \text{sinon}
|
|
|
|
|
\end{array}
|
|
|
|
|
\right.$ est la fonction \emph{clamp}.
|
|
|
|
|
\end{itemize}
|
|
|
|
|
|
|
|
|
|
\section{Simuler la morphogenèse des populations}
|
|
|
|
|
En tant que science expérimentale, la recherche en biologie cellulaire et
|
|
|
|
|
moléculaire nécessite d'important moyens matériels afin de tester \emph{in
|
|
|
|
|
vivo} les hypothèses formulées par les chercheurs. Notamment, la préparation
|
|
|
|
|
et l'exécution d'une expérience est…
|
|
|
|
|
\begin{itemize}
|
|
|
|
|
\item consommatrice en temps. Il faut parfois attendre que les cultures d'un
|
|
|
|
|
organisme particulier atteignent l'état désiré\footnote{cf. le projet
|
|
|
|
|
\synbiotic};
|
|
|
|
|
\item consommatrice en ressources. Maintenir les conditions de pression,
|
|
|
|
|
d'humidité, de température, d'acidité, d'oxygénation, etc. nécessite du
|
|
|
|
|
matériel onéreux;
|
|
|
|
|
\end{itemize}
|
|
|
|
|
|
|
|
|
|
D'un côté, de par les moyens engagés, il est difficile d'envisager de tester des
|
|
|
|
|
hypothèses très prospectives ou bien de se faire une idée du résultat probable
|
|
|
|
|
d'une expérience quand beaucoup d'entités interagissent. D'un autre, un plan
|
|
|
|
|
d'expérience comprend idéalement un nombre minimum nécessaire d'expérimentations
|
|
|
|
|
pour valider ou infirmer une hypothèse du modèle, ce nombre pouvant néanmoins
|
|
|
|
|
rester élevé au regard des moyens à disposition. La simulation informatique
|
|
|
|
|
permet, à partir d'un modèle donné, de confirmer ou de rejeter rapidement une
|
|
|
|
|
hypothèse, ce qui peut aider à choisir quelles expérimentations effectuer. Dans
|
|
|
|
|
ce cas c'est un outil d'aide à la décision. Si la simulation est suffisamment
|
|
|
|
|
précise, comme dans la cas de la simulation de la motilité de quelques bactéries
|
|
|
|
|
\Ecoli{} \cite{bray_chemotactic_2007}, elle pourrait même se substituer en
|
|
|
|
|
partie à l'expérimentation \emph{in vivo}; on parlera dans ce cas
|
|
|
|
|
d'expérimentation \emph{in silico}.
|
|
|
|
|
|
|
|
|
|
Nous nous intéressons au problème de la \emph{morphogénèse} c'est à dire à
|
|
|
|
|
l'ensemble des lois qui déterminent les étapes de la forme, de la structure des
|
|
|
|
|
tissus, des organes et des organismes. Les organismes multicellulaires sont le
|
|
|
|
|
fruit d'un grand nombre de divisions cellulaires successives et qui donnent lieu
|
|
|
|
|
à l'apparition d'une forme et de fonctionnalités caractéristiques et
|
|
|
|
|
reproductibles. Comprendre la morphogénèse est un enjeu fondamental pour la
|
|
|
|
|
biologie synthétique (voir à ce propos la section~\ref{sec:synbiotic}).
|
|
|
|
|
|
|
|
|
|
Pour répondre à ce problème et dans le cadre du projet \synbiotic, nous avons
|
|
|
|
|
développé \tb{}, un simulateur des interactions d'une population de bactéries
|
|
|
|
|
\ecoli{} au cours de sa croissance. \tb{} permet de suivre une cellule ou une
|
|
|
|
|
sous partie de cette population au cours du temps de manière similaire aux
|
|
|
|
|
conditions expérimentales et ainsi de tester des hypothèses à l'échelle de la
|
|
|
|
|
population dans le domaine de la biologie synthétique.
|
|
|
|
|
|
|
|
|
|
\subsection{Propriétés attendues}
|
|
|
|
|
Dans le but de fournir aux biologistes le moyen d'expérimenter \emph{in silico}
|
|
|
|
|
la validité d'un modèle concernant l'évolution d'une population de bactéries
|
|
|
|
|
\ecoli{}, nous avons dressé une liste de propriétés nécessaires.
|
|
|
|
|
\begin{description}
|
|
|
|
|
\item[Sorties] Le simulateur permet de recueillir des résultats qualitatifs via
|
|
|
|
|
un affichage graphique, reprenant la métaphore de la boîte de Petri qui
|
|
|
|
|
permettra d'identifier la forme de la population en croissance. Il est
|
|
|
|
|
possible de marquer une sous-partie de la population pour la suivre plus
|
|
|
|
|
facilement. Le simulateur permet de recueillir des résultats quantitatifs, tel
|
|
|
|
|
que le nombre et la position des bactéries dans un fichier texte pour
|
|
|
|
|
traitement ultérieur, par exemple pour la reconnaissance automatique de forme,
|
|
|
|
|
ou des calculs statistiques;
|
|
|
|
|
\item[Entrées] Les conditions initiales de la simulation sont décrites par un
|
|
|
|
|
fichier de configuration dans un langage dédié; au delà des conditions
|
|
|
|
|
initiales de l'expérience, il permettra au moins de fixer quelques paramètres
|
|
|
|
|
du rendu graphique ou textuel, comme la couleur de représentation des
|
|
|
|
|
morphogènes et des bactéries, et de sélectionner quelles informations
|
|
|
|
|
quantitatives seront écrites pendant la simulation;
|
|
|
|
|
\item[Précision] Le simulateur reprend aussi fidèlement que possible les
|
|
|
|
|
connaissances actuelles sur l'aspect mécanique (croissance et collision des
|
|
|
|
|
bactéries) et sur l'aspect chimique (réaction et diffusion de morphogènes).
|
|
|
|
|
Une étape de calibrage sera donc nécessaire par rapport à des comptes rendus
|
|
|
|
|
d'expériences \emph{in vivo};
|
|
|
|
|
\item[Efficacité] Le simulateur est suffisamment efficace pour être utilisable
|
|
|
|
|
sans matériel spécifique; par exemple, passer d'une bactérie à une population
|
|
|
|
|
de l'ordre de $10^4$ bactéries, soit un temps réel d'environ de
|
|
|
|
|
\SI{4}{\hour}\SI{30}{\minute}, nécessitera un temps de simulation
|
|
|
|
|
correspondant de l'ordre de l'heure sur un ordinateur portable contemporain,
|
|
|
|
|
moins encore sur une machine spécialisée;
|
|
|
|
|
\item[Autonomie] Les résultats sont accessibles sans la nécessité de faire
|
|
|
|
|
fonctionner le simulateur sur une grille de calcul, un tel matériel ne servira
|
|
|
|
|
qu'à réduire le temps de simulation afin d'effectuer un plan d'expérience plus
|
|
|
|
|
rapidement;
|
|
|
|
|
\item[Scalabilité] Malgré les points précédents, \tb{} passe à l'échelle et peut
|
|
|
|
|
s'adapter à une machine de calcul dédiée ou à une grille de calcul distribuée;
|
|
|
|
|
plusieurs instances du simulateur peuvent être lancées de manière concurrente;
|
|
|
|
|
\item[Adaptabilité] Il est possible d'ajouter à \tb{} de nouvelles
|
|
|
|
|
fonctionnalités avec peu d'effort: l'architecture du simulateur est modulaire
|
|
|
|
|
et vient avec une documentation claire;
|
|
|
|
|
\item[Stabilité] Comme une simulation complexe peut prendre plusieurs heures, il
|
|
|
|
|
est important que le simulateur ne produise pas d'erreur en cours de
|
|
|
|
|
fonctionnement, autrement dit \tb{} est stable; d'une part le langage utilisé
|
|
|
|
|
apportera des garanties de part des vérifications du système de type, d'autre
|
|
|
|
|
part des tests fonctionnels permettront de valider le fonctionnement correct
|
|
|
|
|
de chaque partie du simulateur;
|
|
|
|
|
\item[Ouverture] Le simulateur est un programme informatique ouvert, son code
|
|
|
|
|
source peut-être téléchargé en ligne, compilé, amélioré et redistribué,
|
|
|
|
|
modifié ou non;
|
|
|
|
|
\end{description}
|
|
|
|
|
|
|
|
|
|
\subsection{\ocaml} % Adaptabilité, stabilité
|
|
|
|
|
Pour répondre aux critères \emph{d'adaptabilité} et de \emph{stabilité},
|
|
|
|
|
nous avons choisi d'implémenter \otb avec le langage \ocaml, un langage de
|
|
|
|
|
programmation fonctionnel, statiquement typé, modulaire et interfaçable avec
|
|
|
|
|
le langage C. \ocaml est à la fois un projet académique avec de solides
|
|
|
|
|
bases théoriques, notamment utilisé comme langage d'implémentation de
|
|
|
|
|
l'assistant de preuve Coq\footnote{cf. la page «à propos» du projet Coq
|
|
|
|
|
\url{https://coq.inria.fr/about-coq}}, et aussi un langage industriel ayant à
|
|
|
|
|
son actif de belles réussites comme l'analyseur statique \textsc{Astrée} en
|
|
|
|
|
usage chez Airbus.
|
|
|
|
|
|
|
|
|
|
\paragraph{Langage de programmation fonctionnel}
|
|
|
|
|
La programmation fonctionnelle est issue du $\lambda$-calcul, un modèle de
|
|
|
|
|
calcul mathématique reposant sur des variables, des applications et des
|
|
|
|
|
abstractions regroupées sous le nom de \emph{$\lambda$-termes}.
|
|
|
|
|
Dans le modèle du $\lambda$-calcul, la règle centrale pour le calcul des
|
|
|
|
|
$\lambda$-termes est la \emph{substitution} dont les deux principaux
|
|
|
|
|
représentants sont l'$\alpha$-conversion et la $\beta$-réduction. Le calcul de
|
|
|
|
|
nouveaux $\lambda$-termes s'effectue par un système de réécriture. C'est ce
|
|
|
|
|
modèle de calcul qui a donné lieu au paradigme de la programmation
|
|
|
|
|
fonctionnelle. Par extension, les langages de programmation fonctionnelle purs
|
|
|
|
|
ont la particularité de considérer la programmation d'un algorithme comme une
|
|
|
|
|
composition de fonctions s'appelant les unes les autres plutôt que comme une
|
|
|
|
|
suite d'instructions qui agissent par effet de bord, c'est-à-dire en modifiant
|
|
|
|
|
l'état de la mémoire. Ils se dissocient de la vision de la machine à état comme
|
|
|
|
|
support de programmation en adoptant un style plus mathématique dans leur
|
|
|
|
|
écriture, proche de la réécriture des $\lambda$-termes. \ocaml dispose ainsi
|
|
|
|
|
\begin{itemize}
|
|
|
|
|
\item de structures de contrôle comme le filtrage par motif,
|
|
|
|
|
\item de clôtures, qui sont des définitions de fonction accompagnées de leur
|
|
|
|
|
environnement lexical, analogues des $\lambda$-termes et
|
|
|
|
|
\item permet de définir des fonctions d'ordre supérieur, c'est-à-dire aux
|
|
|
|
|
fonctions pouvant avoir des fonctions en argument et pouvant retourner des
|
|
|
|
|
fonctions comme résultat.
|
|
|
|
|
\end{itemize}
|
|
|
|
|
Un paradigme de programmation influe sur la syntaxe et la sémantique du langage,
|
|
|
|
|
et comme \ocaml est un langage multiparadigme, empruntant aux paradigmes
|
|
|
|
|
de la programmation fonctionnelle, de la programmation impérative et de la
|
|
|
|
|
programmation orientée objet, il hérite de leurs aspects. \ocaml dispose d'un
|
|
|
|
|
ramasse-miette efficace qui gère la désallocation de la mémoire quand celle-ci
|
|
|
|
|
n'est plus utilisée sans l'intervention de l'utilisateur. Ceci fait de \ocaml
|
|
|
|
|
un langage de programmation de haut niveau. Comme nous le présentons ci-après,
|
|
|
|
|
\ocaml est de plus un langage fonctionnel fortement et statiquement typé.
|
|
|
|
|
|
|
|
|
|
\paragraph{Typage fort et typage statique}
|
|
|
|
|
Les types ont d'abord été introduit en logique combinatoire et dans le
|
|
|
|
|
$\lambda$-calcul dans les années 1930. Ils ont depuis eu un fort impact en
|
|
|
|
|
informatique: ils sont utilisés comme une abstraction d'un programme et
|
|
|
|
|
permettent d'en vérifier certaines propriétés, comme par exemple garantir que le
|
|
|
|
|
résultat d'une fonction appartient à un ensemble d'éléments connus. Dans le
|
|
|
|
|
langage C, un langage bas niveau proche de l'expression d'un processeur, les
|
|
|
|
|
types décrivent la taille de la représentation machine et les règles de
|
|
|
|
|
conversion d'une valeur du langage. En \ocaml, les types sont plutôt utilisés
|
|
|
|
|
pour modéliser les données du programme. \ocaml permet de déclarer des types
|
|
|
|
|
algébriques récursifs permettant par exemple de décrire la structure de listes
|
|
|
|
|
\begin{OCAMLcode}
|
|
|
|
|
type 'a list =
|
|
|
|
|
Nil
|
|
|
|
|
| Cons of 'a * 'a list
|
|
|
|
|
\end{OCAMLcode}
|
|
|
|
|
ou d'arbres binaires
|
|
|
|
|
\begin{OCAMLcode}
|
|
|
|
|
type 'a tree =
|
|
|
|
|
Leaf of 'a
|
|
|
|
|
| Node of 'a tree * 'a tree
|
|
|
|
|
\end{OCAMLcode}
|
|
|
|
|
|
|
|
|
|
\ocaml présente un typage fort. On distingue un typage fort d'un typage faible
|
|
|
|
|
par la manière dont s'effectue la transformation d'un type en un autre: plus
|
|
|
|
|
elle est explicite plus c'est un typage fort, moins elle explicite moins c'est
|
|
|
|
|
un typage faible. Autrement dit, plus un langage est fortement typé, plus il est
|
|
|
|
|
difficile de transformer un type en un autre. Dans le langage C, un opérateur
|
|
|
|
|
appelé \emph{cast} permet aisément de transformer presque n'importe quel type en
|
|
|
|
|
un autre. En \ocaml, cette transformation n'est pas possible dans le cadre de
|
|
|
|
|
fonctionnement normal du langage, donc \ocaml est plus fortement typé que C et
|
|
|
|
|
le système de type d'\ocaml est par conséquent plus riche. Le code source d'un
|
|
|
|
|
programme \ocaml est typé statiquement, c'est à dire que toutes les
|
|
|
|
|
annotations de type sont connues avant la compilation. À l'opposé, dans le cas
|
|
|
|
|
d'un typage dynamique, certaines informations de type peuvent ne pas être
|
|
|
|
|
connues avant la compilation, peuvent rester après la compilation et peuvent
|
|
|
|
|
évoluer durant l'exécution du programme.
|
|
|
|
|
|
|
|
|
|
\ocaml utilise un typage statique et fort et les annotations de type sont
|
|
|
|
|
utilisées à la compilation pour permettre au compilateur de détecter les erreurs
|
|
|
|
|
de types avant l'exécution du programme, ce qui apporte quelques garanties
|
|
|
|
|
concernant le comportement. Par exemple, les types nous permettent d'apporter
|
|
|
|
|
des informations supplémentaires que le compilateur peut prendre en compte.
|
|
|
|
|
Déclarer les types
|
|
|
|
|
\begin{OCAMLcode}
|
|
|
|
|
type nom = Nom of string
|
|
|
|
|
type prenom = Prenom of string
|
|
|
|
|
\end{OCAMLcode}
|
|
|
|
|
permet au compilateur de distinguer deux chaînes de caractères identiques, mais
|
|
|
|
|
dont le sens est différent, ce qui est représenté par deux types différents.
|
|
|
|
|
|
|
|
|
|
\paragraph{Modularité native}
|
|
|
|
|
Lors de la rédaction d'un programme, il est vite nécessaire de «compartimenter»
|
|
|
|
|
le code source, d'abord parce que certaines fonctionnalité sont génériques et
|
|
|
|
|
peuvent être utilisées plusieurs fois dans des contextes différents, mais aussi
|
|
|
|
|
pour des raisons de relecture et de segmentation de l'espace de noms. La
|
|
|
|
|
\emph{modularité} consiste à rassembler les fonctionnalités d'un programme dans
|
|
|
|
|
des modules \emph{indépendants} et \emph{interchangeables}. En \ocaml, la
|
|
|
|
|
modularité est une caractéristique native du langage dans la gestion du code
|
|
|
|
|
source et repose sur trois constructions syntaxiques: les \emph{structures}, les
|
|
|
|
|
\emph{interfaces} et les \emph{modules}. Les structures contiennent
|
|
|
|
|
l'implémentation des modules, les interfaces décrivent les valeurs qui en sont
|
|
|
|
|
accessibles — les valeurs dont l'implémentation n'est pas exposée sont des
|
|
|
|
|
valeurs abstraites, et celles qui n'apparaissent pas du tout dans
|
|
|
|
|
l'implémentation du module sont inaccessibles. Un module peut avoir plusieurs
|
|
|
|
|
interfaces — du moment qu'elles sont toutes compatibles avec les types de
|
|
|
|
|
l'implémentation — et plusieurs modules peuvent vérifier une même interface.
|
|
|
|
|
Enfin, \ocaml dispose de modules paramétriques nommés \emph{foncteurs} qui
|
|
|
|
|
sont des structures paramétrées par d'autres structures.
|
|
|
|
|
|
|
|
|
|
% http://caml.inria.fr/pub/docs/manual-ocaml/intfc.html
|
|
|
|
|
\paragraph{Interface avec le langage C}
|
|
|
|
|
Un aspect important pour les besoins du cahier des charges (voir
|
|
|
|
|
\ref{ss:req-parallel}) est de pouvoir communiquer avec des objets compilés C via
|
|
|
|
|
une interface dédiée, typiquement des bibliothèques écrites et compilés dans ce
|
|
|
|
|
langage. \ocaml propose une interface claire avec des bibliothèques
|
|
|
|
|
logicielles écrites en C, permettant d'empaqueter des valeurs dans des types
|
|
|
|
|
\ocaml conservant les avantages d'un typage fort, de dépaqueter des valeurs
|
|
|
|
|
typées de \ocaml vers un type C arbitraire et surtout de profiter de la
|
|
|
|
|
gestion automatique de la mémoire par le ramasse-miette de \ocaml.
|
|
|
|
|
|
|
|
|
|
\subsection{Calcul parallèle} % Efficacité et Autonomie
|
|
|
|
|
\label{ss:req-parallel}
|
|
|
|
|
Notre simulateur calcule l'évolution d'un grand nombre d'objet de même nature
|
|
|
|
|
simultanément. Pour répondre aux critères \emph{d'efficacité} et
|
|
|
|
|
\emph{d'autonomie} nous avons le choix d'utiliser un GPU, le processeur dédié
|
|
|
|
|
des cartes graphiques, ou bien d'utiliser un cluster: une grappe de serveurs
|
|
|
|
|
interconnectés sur le réseau local. En prenant le nombre d'opérations en virgule
|
|
|
|
|
flottante par seconde, notée \si{FLOPS}, comme référence de la vitesse d'un
|
|
|
|
|
ordinateur, utiliser le parallélisme embarqué dans les GPU semble être la bonne
|
|
|
|
|
manière d'atteindre des vitesses de calcul élevées. Nous nous appuyons sur le
|
|
|
|
|
fait que plus de la moitié des 500 supercalculateurs les plus rapides au monde
|
|
|
|
|
sont construit sur NVidia
|
|
|
|
|
Kepler\footnote{\url{https://www.top500.org/statistics/list/}}, un GPU. Les GPU
|
|
|
|
|
grand public sont accessibles en terme de prix, leur consommation est
|
|
|
|
|
suffisamment faible pour fonctionner sur batterie dans un PC portable et les
|
|
|
|
|
plus puissants atteignent les \SI{10000}{\giga FLOPS}\footnote{%
|
|
|
|
|
\url{https://www.nvidia.com/en-us/geforce/products/10series/titan-x-pascal}\\
|
|
|
|
|
Par exemple, la carte graphique NVidia Titan X possède \num{3584} cœurs
|
|
|
|
|
de calculs, cadencés à \SI{1417}{\mega\hertz} pour un prix avoisinant les
|
|
|
|
|
\num{1200} euros}.Enfin,
|
|
|
|
|
le parallélisme des GPU semble être plus efficace énergétiquement par rapport
|
|
|
|
|
aux CPU en comparant leur \si{\giga FLOPS} par Watt~\cite{dong_step_2014}.
|
|
|
|
|
|
|
|
|
|
%parallélisme SIMD OpenCL
|
|
|
|
|
\paragraph{SIMD}
|
|
|
|
|
La taxinomie de Flynn~\cite{flynn_computer_1972} classifie différentes
|
|
|
|
|
architectures d'ordinateur et comporte quatre catégories selon le type
|
|
|
|
|
d'organisation du flux de données et du flux d'instructions. Le modèle de
|
|
|
|
|
programmation le plus répandu repose sur l'architecture de Von Neumann, ce qui
|
|
|
|
|
correspond à la catégorie \emph{Single Instruction Single Data} (SISD). Les
|
|
|
|
|
ordinateurs de cette catégorie n'exploitent aucun parallélisme et sont purement
|
|
|
|
|
séquentiels, tant au niveau des instructions qu'au niveau de la mémoire. Ce
|
|
|
|
|
modèle de programmation ne correspond pas à la réalité des processeurs
|
|
|
|
|
contemporains qui exploitent le parallélisme des données (plusieurs banques de
|
|
|
|
|
mémoire RAM) ou d'instructions grâce à plusieurs processeurs à plusieurs cœurs.
|
|
|
|
|
À l'extrême opposé de la classification se trouvent les architectures
|
|
|
|
|
\emph{Multiple Instruction on Multiple Data} (MIMD), puis les architectures
|
|
|
|
|
\emph{Multiple Instructions on Single Data} (MISD). Dans le cas des MISD, des
|
|
|
|
|
problèmes de concurrence à la lecture−écriture apparaissent et il est d'usage
|
|
|
|
|
d'avoir recours à des barrières de synchronisation, des sémaphores ou des Mutex.
|
|
|
|
|
SPMD, \emph{Single Program on Multiple Data}, est la technique la plus courante
|
|
|
|
|
pour utiliser le parallélisme des ordinateurs multiprocesseurs contemporain, où
|
|
|
|
|
chaque processeur exécute un programme distinct et possède sa propre mémoire, en
|
|
|
|
|
plus de partager une mémoire globale, la RAM. Finalement, dans les ordinateurs
|
|
|
|
|
contemporains, il existe, en complément d'un CPU et d'une mémoire partagée, des
|
|
|
|
|
cartes de calcul dédiées, comme des cartes graphiques, spécialisées dans le
|
|
|
|
|
calcul vectoriel, capable d'effectuer des opérations rapides sur des grandes
|
|
|
|
|
matrices. L'architecture d'une carte graphique, munie d'un GPU et d'une mémoire
|
|
|
|
|
RAM entre dans la catégorie \emph{Single Instruction on Multiple Data} (SIMD).
|
|
|
|
|
Ces processeurs sont spécialisés dans le traitement en parallèle d'un grand
|
|
|
|
|
nombre de données. Depuis la taxinomie de Flynn, d'autres types de Nous avons
|
|
|
|
|
choisi de tirer parti du parallélisme disponible sur l'ordinateur où est exécuté
|
|
|
|
|
\tb{}, qu'il provienne de plusieurs CPU ou d'une carte graphique.
|
|
|
|
|
|
|
|
|
|
\paragraph{\opencl}
|
|
|
|
|
Afin d'accéder aux périphériques présent sur la plateforme de simulation et de
|
|
|
|
|
les programmer, nous utilisons \opencl (Open Computing Language), un framework
|
|
|
|
|
pour l'écriture de programmes s'exécutant sur des plateformes hétérogènes:
|
|
|
|
|
microprocesseurs (CPU), processeurs graphique (GPU), processeurs de signal
|
|
|
|
|
numérique (DSP), réseau de portes programmables in situ (FPGA) ou autre carte
|
|
|
|
|
accélératrice. \opencl spécifie un langage de programmation, inspiré de C99,
|
|
|
|
|
pour la programmation de ces périphériques ainsi que des interfaces de
|
|
|
|
|
programmation (API) pour le contrôle de la plateforme et l'exécution des
|
|
|
|
|
programmes sur les périphériques. \opencl fournit une interface standard pour
|
|
|
|
|
la programmation parallèle utilisant le parallélisme de tâche et le parallélisme
|
|
|
|
|
de données. Il existe d'autres framework pour la programmation des GPU, comme
|
|
|
|
|
CUDA\footnote{\url{http://www.nvidia.com/object/cuda_home_new.html}}, cependant
|
|
|
|
|
l'avantage de \opencl est qu'il est le seul langage pour le GPGPU (General
|
|
|
|
|
Purpose computing on Graphics Processing Unit) à ne pas être restreint à une
|
|
|
|
|
seule plateforme. En effet, il fonctionne sur une large gamme de matériel et, au
|
|
|
|
|
contraire de CUDA, ne se limite pas à un seul constructeur, ni à un seul type de
|
|
|
|
|
périphérique. \opencl est un standard ouvert maintenu par Khronos
|
|
|
|
|
Group\footnote{\url{https://www.khronos.org/about}}, un consortium technologique
|
|
|
|
|
à but non lucratif. De nombreux constructeurs fournissent une implémentation
|
|
|
|
|
officielle, comme AMD, Intel et Nvidia les principaux constructeurs de CPU et de
|
|
|
|
|
cartes graphiques grand public.
|
|
|
|
|
|
|
|
|
|
\paragraph{\opengl} % Sorties
|
|
|
|
|
Pour répondre au point «Sortie», nous avons choisi d'utiliser \opengl (Open
|
|
|
|
|
Graphics Library), une API multiplateforme, multilangage utilisée pour
|
|
|
|
|
programmer un GPU spécifiquement pour un rendu graphique. Dans le modèle de
|
|
|
|
|
programmation de \opengl, un ensemble de vecteurs dans l'espace en trois
|
|
|
|
|
dimensions sont successivement transformés pour obtenir une projection en deux
|
|
|
|
|
dimension rastérisée. Le programmeur écrit des programme de traitement, des
|
|
|
|
|
shader, qui viennent se brancher à différents points de la chaîne de traitement
|
|
|
|
|
graphique. À l'inverse de \opencl, \opengl est optimisé pour le calcul vectoriel
|
|
|
|
|
et n'est pas approprié pour effectuer des calculs généraux sur les GPU. Cette
|
|
|
|
|
bibliothèque logicielle nous permet de proposer une ou plusieurs fenêtre
|
|
|
|
|
de rendu en temps réel pour présenter des informations qualitatives sur la
|
|
|
|
|
progression d'une simulation.
|
|
|
|
|
|
|
|
|
|
\subsection{Modélisation d'une cellule}
|
|
|
|
|
\begin{figure}[t]
|
|
|
|
|
\centering
|
|
|
|
|
\includegraphics[height=6cm]{figures/EscherichiaColi}\hfill
|
|
|
|
|
\includegraphics[page=1,height=6cm]{figures/bacteria}
|
|
|
|
|
\caption{Une image d'une microscopie électronique à balayage d'une culture de
|
|
|
|
|
\ecoli\ (à gauche) et une représentation simplifiée en deux dimensions d'une
|
|
|
|
|
bactérie \ecoli\ (à droite)}
|
|
|
|
|
\label{fig:ecoli}
|
|
|
|
|
\end{figure}
|
|
|
|
|
|
|
|
|
|
\Ecoli\ est une bactérie bacillaire, c'est à dire en forme de bâtonnet, du genre
|
|
|
|
|
\emph{Escherichia}. C'est une bactérie vivant habituellement dans l'intestin des
|
|
|
|
|
animaux à sang chaud, dont elle constitue 0,1\% de la flore intestinale.
|
|
|
|
|
Découverte en 1885 par Theodor Escherich et étudiée intensivement depuis 60 ans,
|
|
|
|
|
c'est un organisme très utilisé dans le domaine de l'ingénierie biologique et de
|
|
|
|
|
la microbiologie industrielle, notamment pour sa disponibilité et sa facilité de
|
|
|
|
|
culture. La souche K-12, adaptée à l'étude en laboratoire, est également un des
|
|
|
|
|
premiers organisme dont le génome a été séquencé \cite{blattner_complete_1997}.
|
|
|
|
|
|
|
|
|
|
Elle est à l'origine du domaine de la biotechnologie en étant choisie comme
|
|
|
|
|
premier organisme génétiquement modifié contenant de l'ADN recombiné, c'est à
|
|
|
|
|
dire de l'ADN dont la séquence des nucléotides à été altérée pour modifier
|
|
|
|
|
l'expression des gènes de la bactérie. Elle est ensuite utilisée comme hôte pour
|
|
|
|
|
la production de protéines hétérologues (provenant d'un autre organisme),
|
|
|
|
|
notamment pour la production industrielle d'insuline humaine
|
|
|
|
|
\cite{goeddel_expression_1979} mais aussi de vaccins. \ecoli{} est utilisée en
|
|
|
|
|
bioremédiation pour la neutralisation de déchets toxique ou la dépollution des
|
|
|
|
|
sites contaminés et pour la production d'enzymes. Les efforts de recherche se
|
|
|
|
|
concentrent actuellement sur la synthèse par \ecoli{} de protéines plus
|
|
|
|
|
complexes comprenant par exemple des ponts bisulfure ou nécessitant une
|
|
|
|
|
modification post-traductionnelle pour être stables ou bien juste
|
|
|
|
|
fonctionnelles~\cite{han_escherichia_2006}.
|
|
|
|
|
|
|
|
|
|
\begin{table}[hb]
|
|
|
|
|
\centering
|
|
|
|
|
\begin{tabular}{llll}
|
|
|
|
|
\hline
|
|
|
|
|
\textbf{Paramètre} & \textbf{Symbole} & \textbf{Valeur} & \textbf{Unité}\\
|
|
|
|
|
\hline
|
|
|
|
|
Longueur & $L = 2 (l+r)$ & \num{2.5+-0.6} & \si{\micro\meter} \\
|
|
|
|
|
Largeur ou Diamètre & $d = 2r$ & \num{0.88+-0.09} & \si{\micro\meter} \\
|
|
|
|
|
Volume & $V$ & \num{1.4} & \si{\femto\liter} \\
|
|
|
|
|
Vitesse rectiligne & $v$ & \num{29+-6} & \si{\micro\meter\per\second} \\
|
|
|
|
|
Temps de génération & $G$ & 20 — 30 & \si{\minute} \\
|
|
|
|
|
\hline
|
|
|
|
|
\end{tabular}
|
|
|
|
|
\caption{Quelques ordres de grandeur associés aux bactéries \Ecoli{}
|
|
|
|
|
\cite{bremer_modulation_1996,darnton_torque_2007}%
|
|
|
|
|
\cite{britanica_online_encyclopedia_bacteria_2016}}
|
|
|
|
|
\label{tab:ecoli-odg}
|
|
|
|
|
\end{table}
|
|
|
|
|
|
|
|
|
|
\paragraph{La chimiotaxie de \Ecoli}
|
|
|
|
|
Comme la plupart des bactéries bacillaires, \ecoli{} possède une ciliature
|
|
|
|
|
péritriche: elle est assortie de longs flagelles elliptiques, quatre en moyenne,
|
|
|
|
|
recouvrant sa surface qui sont utilisés comme moteur de son déplacement. Ces
|
|
|
|
|
flagelles sont fixés à leur base à un moteur rotatif réversible entraîné par un
|
|
|
|
|
flux de protons et tournent sur eux-mêmes à une fréquence de l'ordre de
|
|
|
|
|
\SI{100}{\hertz}. Suivant le sens de leur rotation, sens direct (CCW pour
|
|
|
|
|
Counter ClockWise) et sens indirect (CW pour ClockWise), ils sont à l'origine de
|
|
|
|
|
deux modes de déplacement:
|
|
|
|
|
\begin{itemize}
|
|
|
|
|
\item le mode «run», les moteurs tournent dans le sens direct et les flagelles
|
|
|
|
|
se regroupent pour propulser la bactérie dans une direction rectiligne. Il
|
|
|
|
|
dure en moyenne \SI{1}{\second};
|
|
|
|
|
\item le mode «tumble», au moins un des moteurs tourne dans le sens indirect.
|
|
|
|
|
Les flagelles se désolidarisent ce qui a pour effet moyen de faire tourner la
|
|
|
|
|
bactérie sur elle-même dans le sens horaire \cite{diluzio_escherichia_2005}.
|
|
|
|
|
Ce mode dure en moyenne \SI{0,1}{\second}.
|
|
|
|
|
\end{itemize}
|
|
|
|
|
Ces deux modes de déplacement alternent successivement et, en fonction de
|
|
|
|
|
l'environnement de la bactérie, les amènent à migrer vers des environnements
|
|
|
|
|
favorables, riches en nutriments et à fuir les environnements toxiques et
|
|
|
|
|
délétères \cite{berg_chemotaxis_1972}.
|
|
|
|
|
Ce phénomène s'appelle la \emph{chimiotaxie}. Il résulte de la transmission
|
|
|
|
|
de signaux extracellulaires, détectés par les récepteurs de la membrane, aux
|
|
|
|
|
moteurs des flagelles qui contrôlent le comportement de la cellule.
|
|
|
|
|
|
|
|
|
|
D'un point de vue macroscopique, \ecoli{} effectue une marche aléatoire
|
|
|
|
|
biaisée vers une direction particulière. Elle détecte la variation
|
|
|
|
|
\emph{dans le temps} de la concentration d'un chimioeffecteur. Ainsi, lorsque
|
|
|
|
|
la bactérie se dirige vers un milieu plus favorable, les réorientations par
|
|
|
|
|
tumble deviennent plus rares et la bactérie peut remonter le gradient de la
|
|
|
|
|
concentration d'une molécule qui se diffuse dans l'environnement. Entre deux
|
|
|
|
|
run, \ecoli{} peut complètement changer de direction, avec un angle allant
|
|
|
|
|
jusqu'à 180°, le plus souvent entre 0° et 90° \cite{turner_real-time_2000}.
|
|
|
|
|
D'un point de vue microscopique, \ecoli{} peut détecter différents acides
|
|
|
|
|
aminés, sucres et dipeptides ainsi que l'acidité, la température et l'état
|
|
|
|
|
d'oxydoréduction.
|
|
|
|
|
|
|
|
|
|
Les récepteurs principaux, comme ceux de l'aspartate (Tar)
|
|
|
|
|
et de la sérine (Tsr), sont très nombreux et sont aux nombre de quelques
|
|
|
|
|
milliers par cellule. Les récepteurs secondaires, comme ceux spécifiques aux
|
|
|
|
|
dipeptides (Tap), ribose et galactose (Trg), et au potentiel d'oxydoréduction
|
|
|
|
|
(Aer), sont bien moins nombreux avec seulement une centaine de copies par
|
|
|
|
|
cellule. Ces récepteurs se regroupent en amas, ce qui induit des dynamiques
|
|
|
|
|
complexes dans la détection de chimioeffecteurs \cite{sourjik_receptor_2004},
|
|
|
|
|
impliquant soit une plus grande sensibilité ou au contraire une plus grande
|
|
|
|
|
diversité de détection.
|
|
|
|
|
|
|
|
|
|
Dans le réseau de régulation génétique, parmi les voies de signalisation
|
|
|
|
|
de la cellule, la voie de réponse chimiotaxique consiste donc en un ensemble
|
|
|
|
|
de protéines réceptrices transmembranaires sus-citées et les produits de six
|
|
|
|
|
gènes chimiotaxiques: CheR, CheB, CheW, CheA, CheY et CheZ. L'information sur
|
|
|
|
|
la liaison de ligants bénéfiques ou nocifs aux récepteurs est transportée
|
|
|
|
|
jusqu'au moteur des flagelles ce qui leur permet de changer le sens de rotation
|
|
|
|
|
du moteur. Il existe plusieurs modèles stochastiques capables de simuler
|
|
|
|
|
en détail la cascade d'évènements entre la liaison d'un chimioeffecteur
|
|
|
|
|
à un récepteur jusqu'au biais des moteurs \cite{shimizu_spatially_2003,
|
|
|
|
|
mello_quantitative_2003}.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
\paragraph{Modèle de croissance}
|
|
|
|
|
\ecoli\ suit un modèle de croissance linéaire
|
|
|
|
|
\cite{zaritsky_growth_1982,kubitschek_cell_1990} par élongation et bien que son
|
|
|
|
|
diamètre décroisse avec l'élongation, cette variation reste négligeable quand
|
|
|
|
|
$L$ est suffisamment grande \cite{trueba_changes_1980,skarstad_cell_1983}. Nous
|
|
|
|
|
considérerons donc que seule sa longueur $L$ (voir \textsc{Fig.}~\ref{tab:ecoli-odg})
|
|
|
|
|
varie lors de la croissance d'une bactérie. Comme toutes les cellules
|
|
|
|
|
procaryotes, \ecoli{} se reproduit par scissiparité. Ce cycle de division
|
|
|
|
|
implique:
|
|
|
|
|
\begin{enumerate}
|
|
|
|
|
\item La réplication de la molécule d'ADN circulaire au sein de la cellule;
|
|
|
|
|
\item La migration après duplication des deux brins d'ADN à chacun des pôles de
|
|
|
|
|
la cellule;
|
|
|
|
|
\item La croissance de la cellule pour laisser la place à un matériel génétique
|
|
|
|
|
plus volumineux;
|
|
|
|
|
\item Le plan équatorial de la cellule se resserre et fini par scinder la
|
|
|
|
|
membrane en deux, de sorte que chaque nouvelle cellule fille ait le même
|
|
|
|
|
matériel génétique.
|
|
|
|
|
\end{enumerate}
|
|
|
|
|
|
|
|
|
|
L'équation \ref{eq:generation-time} présente le calcul du temps de génération
|
|
|
|
|
pour une population de bactéries dont la croissance s'effectue par division
|
|
|
|
|
binaire, où $t$ est le temps en minutes, $n$ est le nombre de générations, $B$
|
|
|
|
|
est le nombre de bactéries au début de la période de temps mesurée et $b$ est le
|
|
|
|
|
nombre de bactéries à la fin de la période de temps mesurée. Cela permet aux
|
|
|
|
|
biologistes de retrouver le temps moyen d'un cycle cellulaire pour la population
|
|
|
|
|
observée.
|
|
|
|
|
|
|
|
|
|
\begin{equation}
|
|
|
|
|
\displaystyle
|
|
|
|
|
G = \frac{t}{n} = \frac{t}{3,3 \times ln (b / B)}
|
|
|
|
|
\label{eq:generation-time}
|
|
|
|
|
\end{equation}
|
|
|
|
|
|
|
|
|
|
\paragraph{Vieillissement et mort cellulaire}
|
|
|
|
|
Il semble que les bactéries se scindant en deux bactéries filles en tout point
|
|
|
|
|
identiques atteignent une sorte d'immortalité, au moins fonctionnelle. Néanmoins
|
|
|
|
|
quand elle n'est pas tuée par des antibiotiques, par manque de nutriments ou par
|
|
|
|
|
le système immunitaire d'organisme multicellulaires, même dans des conditions
|
|
|
|
|
idéales \ecoli{} vieillit~\cite{stewart_aging_2005}. Ce vieillissement résulte
|
|
|
|
|
d'une asymétrie entre les parois membranaires des pôles de la cellule. En effet,
|
|
|
|
|
un de ces pôle est celui de la cellule mère, alors que le second provient du
|
|
|
|
|
plan équatorial de scission de la cellule mère et a été fraîchement créé. En
|
|
|
|
|
partant d'une unique cellule mère, à chaque génération deux cellules possèdent
|
|
|
|
|
les parois membranaires des pôles de la cellule mère susmentionnée. Avec les
|
|
|
|
|
générations, le matériel cellulaire diffusant peu et ayant une longue demi-vie
|
|
|
|
|
s'accumule dans ces «vieux» pôles. Les cellules aux pôles plus âgés produisent
|
|
|
|
|
moins de cellules filles et ont une probabilité de décès spontané plus élevée.
|
|
|
|
|
On peut ainsi donner un âge à chaque pôle prenant en compte le nombre de
|
|
|
|
|
divisions qu'il a subit. Cela permet d'attribuer un âge à chaque cellule, qui
|
|
|
|
|
est définit comme l'âge du pôle le plus âgé. En conséquence, \otb inclus un
|
|
|
|
|
modèle de vieillissement des bactéries pouvant causer le décès spontané (nommé
|
|
|
|
|
apoptose) d'une cellule si sa lignée dépasse une certaine valeur, paramétrable
|
|
|
|
|
en début de simulation.
|
|
|
|
|
|
|
|
|
|
\subsection{Organisation logicielle du simulateur}
|
|
|
|
|
Pour décrire l'organisation logicielle du simulateur, il nous faut parler des
|
|
|
|
|
architectures de \opencl et de \opengl avant de présenter l'architecture de
|
|
|
|
|
\otb afin de comprendre comment ces différents composants communiquent pour
|
|
|
|
|
simuler l'évolution d'une population de bactéries.
|
|
|
|
|
|
|
|
|
|
\subsubsection{Architecture \opencl}\label{sec:archi-cl}
|
|
|
|
|
Nous présentons ici une version simplifiée de l'architecture de \opencl%
|
|
|
|
|
\footnote{\url{http://www.khronos.org/registry/cl/specs/opencl-1.1.pdf}}. Un
|
|
|
|
|
programme \opencl est construit en deux parties: le programme hôte et les
|
|
|
|
|
\emph{kernel}. Le programme hôte s'exécute normalement sur CPU. Dans notre cas,
|
|
|
|
|
c'est la partie du simulateur gérée par \ocaml. Les kernels sont des fonctions
|
|
|
|
|
écrites en C99 destinées à être exécutées sur les périphériques gérés par
|
|
|
|
|
\opencl, comme une carte graphique. Le modèle d'exécution d'\opencl définit
|
|
|
|
|
comment ces kernels sont instanciés sur les différentes unités de calcul
|
|
|
|
|
disponibles.
|
|
|
|
|
|
|
|
|
|
Lorsque l'hôte soumet un kernel à exécuter à \opencl, un espace d'indices est
|
|
|
|
|
définit et, pour chaque indice de cet espace, une instance du kernel est
|
|
|
|
|
exécutée. Cette instance est appelée un \emph{work-item}. Les work-items sont
|
|
|
|
|
regroupés en \emph{work-group}, une division par blocs de l'espace d'indices.
|
|
|
|
|
Les work-items ont accès à quatre types de mémoire: la mémoire globale, la
|
|
|
|
|
mémoire constante, la mémoire locale et la mémoire privée. Chacune de ces
|
|
|
|
|
mémoires est manipulable soit par l'hôte, soit par un work-item, soit par les
|
|
|
|
|
deux. Par exemple, la mémoire privée est réservée à un work-item, la mémoire
|
|
|
|
|
local est accessible à tous les work-items du même work-group, les mémoires
|
|
|
|
|
constantes et globales sont accessibles à l'hôte comme aux work-items.
|
|
|
|
|
|
|
|
|
|
L'hôte peut également demander des transferts de données entre sa mémoire
|
|
|
|
|
principale, la RAM, et les mémoires du device, dans les deux sens, afin de
|
|
|
|
|
fournir des données initiales aux work-items et de récupérer leur travail.
|
|
|
|
|
|
|
|
|
|
\subsubsection{Architecture \opengl}
|
|
|
|
|
Le framework \opengl définit une architecture client-serveur: le client
|
|
|
|
|
fonctionnant sur l'hôte, côté CPU, et le serveur s'exécutant sur la carte
|
|
|
|
|
graphique, côté GPU. La pièce maîtresse du serveur est le \emph{rendering
|
|
|
|
|
pipeline} (chaîne de traitement du rendu), une succession de tâches permettant
|
|
|
|
|
de transformer par étapes un ensemble de vertex, définis dans un espace en trois
|
|
|
|
|
dimensions, en un tableau de pixels en deux dimensions.
|
|
|
|
|
|
|
|
|
|
\begin{figure}[ht]
|
|
|
|
|
\centering
|
|
|
|
|
\includegraphics[width=\textwidth]{figures/openGLPipeline}
|
|
|
|
|
\caption{Vue de haut niveau de la chaîne de traitement de \opengl. Les
|
|
|
|
|
shaders en gras peuvent être définis par l'utilisateur, les shaders en
|
|
|
|
|
pointillé sont optionnels. }
|
|
|
|
|
\label{fig:openGLPipeline}
|
|
|
|
|
\end{figure}
|
|
|
|
|
|
|
|
|
|
Ces étapes peuvent peuvent pour certaines être programmées à l'aide d'un langage
|
|
|
|
|
appelé \emph{GLSL} (OpenGL Shading Language), une variante de C, et sont
|
|
|
|
|
appelées des \emph{shaders} (voir \textsc{Fig.}~\ref{fig:openGLPipeline}). Voici une
|
|
|
|
|
description succinte des shaders programmable utilisés dans \otb, avec leurs
|
|
|
|
|
entrées, leurs sorties et une description de leur rôle:
|
|
|
|
|
\begin{description}
|
|
|
|
|
\item{\bfseries Vertex Shader}
|
|
|
|
|
\begin{itemize}
|
|
|
|
|
\item Entrée: un vertex;
|
|
|
|
|
\item Sortie: un vertex;
|
|
|
|
|
\item Description: ce shader modifie un vertex, par exemple ses attributs de
|
|
|
|
|
position \ç{vec4 gl_Position} ou de taille de point \ç{float gl_PointSize}.
|
|
|
|
|
\end{itemize}
|
|
|
|
|
\item{\bfseries Geometry Shader}
|
|
|
|
|
\begin{itemize}
|
|
|
|
|
\item Entrée: un vertex, une ligne, des triangles;
|
|
|
|
|
\item Sortie: zéro, un ou plusieurs vertex, ligne ou triangles;
|
|
|
|
|
\item Description: ce shader permet d'effectuer des calculs géométriques sur
|
|
|
|
|
les primitives qui lui sont données, soit pour modifier leur attributs, soit
|
|
|
|
|
pour générer de nouveaux points, de nouvelles lignes ou de nouveaux
|
|
|
|
|
triangles. Par exemple, dans \otb, ce shader est utilisé pour construire les
|
|
|
|
|
vertex nécessaire à la représentation d'une bactérie, à partir de trois
|
|
|
|
|
vertex donnés en entrée.
|
|
|
|
|
\end{itemize}
|
|
|
|
|
\item{\bfseries Fragment Shader}
|
|
|
|
|
\begin{itemize}
|
|
|
|
|
\item Entrée: un fragment;
|
|
|
|
|
\item Sortie: une couleur;
|
|
|
|
|
\item Description: ce shader permet d'attribuer une couleur à un pixel sur
|
|
|
|
|
l'écran à partir des informations calculées par le shader de Rasterization.
|
|
|
|
|
C'est ici par exemple que la représentation de chaque bactérie obtient ses
|
|
|
|
|
couleurs.
|
|
|
|
|
\end{itemize}
|
|
|
|
|
\end{description}
|
|
|
|
|
|
|
|
|
|
\subsubsection{Architecture de \otb}
|
|
|
|
|
% Extracted with:
|
|
|
|
|
% $ $grep ^module * 2> /dev/null | sed -e 's/^.*\.ml.\?://' | sort -u | copy
|
|
|
|
|
L'architecture de \tb{} est organisée en modules \ocaml. L'usage de modules a
|
|
|
|
|
été une méthode intuitive pour rapidement prototyper le fonctionnement du
|
|
|
|
|
simulateur. Les modules de \tb{} peuvent être découpés en deux catégories: les
|
|
|
|
|
modules haut niveau, utilisés dans la programmation de la logique du simulateur
|
|
|
|
|
et les modules bas niveau utilisés pour fournir des outils concrets aux modules
|
|
|
|
|
de haut niveau, comme par exemple communiquer avec les périphériques
|
|
|
|
|
d'entrée/sortie via des binding vers des bibliothèques externes. Les modules
|
|
|
|
|
sont écrits avec \ocaml, mais l'accès à \opengl et \opencl ne peut se faire
|
|
|
|
|
que via le langage C, ainsi les modules de bas niveau \texttt{Viewer} et
|
|
|
|
|
\texttt{OpenCL} sont en partie dédiés à la traduction entre l'interface C et
|
|
|
|
|
\ocaml.
|
|
|
|
|
|
|
|
|
|
\begin{figure}[ht]
|
|
|
|
|
\centering
|
|
|
|
|
\includegraphics[width=\textwidth]{figures/otbModules}
|
|
|
|
|
\caption{Organisation des dépendances entre les modules de \tb{}. Les modules
|
|
|
|
|
de bas niveau sont organisés sur le rang inférieur, les modules de haut
|
|
|
|
|
niveau sont sur le rang supérieur.}
|
|
|
|
|
\label{fig:tbModules}
|
|
|
|
|
\end{figure}
|
|
|
|
|
|
|
|
|
|
\paragraph{Entrée} Le point d'entrée par défaut du programme, à savoir la
|
|
|
|
|
fonction d'entrée dans le programme, se trouve dans le module \texttt{Main}. Ce
|
|
|
|
|
dernier fait appel aux autres modules pour construire une simulation et
|
|
|
|
|
l'exécuter.
|
|
|
|
|
|
|
|
|
|
\paragraph{Modules de haut niveau}
|
|
|
|
|
Les modules de haut niveau regroupent les définitions des fonctions dédié au
|
|
|
|
|
travail des modèles: d'une bactérie et d'une population de bactéries, d'un
|
|
|
|
|
environnement de morphogènes, d'une zone délimitant les bords physiques de
|
|
|
|
|
l'environnement de simulation et enfin de l'assemblage des trois modèles
|
|
|
|
|
précédents. Comme indiqué par les flèches de la \textsc{Fig.}~\ref{fig:tbModules}, un
|
|
|
|
|
module de haut dépend d'un ou plusieurs modules bas niveau. Le module
|
|
|
|
|
\texttt{Bacterium} décrit le modèle d'une bactérie ainsi que l'automate
|
|
|
|
|
cellulaire support d'une population de bactéries. Sa fonction la plus notable,
|
|
|
|
|
\texttt{Bacterium.run}, prépare et lance le calcul d'un pas de simulation d'une
|
|
|
|
|
population de bactéries sur le GPU. Le module \texttt{Morphogen}, assez
|
|
|
|
|
symétrique au module \texttt{Bacterium}, décrit l'automate cellulaire modélisant
|
|
|
|
|
la réaction-diffusion des morphogènes. Sa fonction principale,
|
|
|
|
|
\texttt{Morphogen.run} initialise et lance le calcul d'un pas de simulation
|
|
|
|
|
d'une grille de morphogènes sur le GPU. Ces deux modules font appel à quatre
|
|
|
|
|
autres modules de bas niveau qui sont décrits dans le paragraphe suivant.
|
|
|
|
|
\texttt{Zone} est un module de haut niveau modélisant une boîte de Petri de
|
|
|
|
|
taille dynamique en fonction de la répartition des individus qu'elle contient.
|
|
|
|
|
Ses bords sont représentées par un cadre jaune dans la
|
|
|
|
|
\textsc{Fig.}~\ref{fig:otb2-display}. Finalement, le module \texttt{Coupling} décrit le
|
|
|
|
|
modèle complet obtenu par l'interaction entre les bactéries et leur
|
|
|
|
|
environnement. C'est ce modèle qui permet aux bactéries de déposer des
|
|
|
|
|
morphogènes dans leur environnement et de consommer les morphogènes qui y sont
|
|
|
|
|
présent.
|
|
|
|
|
|
|
|
|
|
\begin{figure}[h]
|
|
|
|
|
\centering
|
|
|
|
|
\includegraphics[width=\textwidth]{otb-multi-view}%
|
|
|
|
|
\caption[Présentation des zones dynamiques]{Trois vues d'une même simulation
|
|
|
|
|
avec \num{1174} bactéries présentant, à gauche, une vue globale montrant
|
|
|
|
|
les zones dynamiques (délimitées en rouge, la zone intérieure est celle
|
|
|
|
|
des bactérie, la zone extérieure est celle des morphogènes). À droite sont
|
|
|
|
|
présentés des vues agrandies de la simulation mettant en évidence, en
|
|
|
|
|
haut, le comportement physique des bactéries et, en bas, la diffusion des
|
|
|
|
|
morphogènes.}
|
|
|
|
|
\label{fig:tbModules}
|
|
|
|
|
\end{figure}
|
|
|
|
|
|
|
|
|
|
\paragraph{Modules de bas niveau}
|
|
|
|
|
Le module \texttt{Packfile} regroupe les fonctions de sérialisation nécessaire à
|
|
|
|
|
la sauvegarde dans un fichier de l'état d'une simulation. Le module
|
|
|
|
|
\texttt{BoundingBox} contient les types et les fonctions permettant de définir
|
|
|
|
|
et d'effectuer des calculs courants sur des boîtes encadrantes, une
|
|
|
|
|
représentation rectangulaire d'une zone géométrique.
|
|
|
|
|
|
|
|
|
|
Les modules \texttt{OpenCL} et \texttt{Viewer} sont des modules permettant
|
|
|
|
|
d'accéder à des bibliothèques externes. En effet, \tb{} communique avec la
|
|
|
|
|
carte graphique \emph{via} le langage et framework \opencl pour les calculs
|
|
|
|
|
généraux. Dans un premier temps, nous avons fait appel à un module \ocaml,
|
|
|
|
|
appelé SPOC~\cite{bourgoin_spoc:_2012}, fournissant un binding \opencl et une
|
|
|
|
|
gestion automatique de la mémoire de la carte graphique. Au delà d'une simple
|
|
|
|
|
interface entre \ocaml et \opencl, SPOC abstrait la programmation GPGPU et donne
|
|
|
|
|
un accès transparent à d'autres framework. Cependant, SPOC posant des problèmes
|
|
|
|
|
de stabilité et possédant bien plus de fonctionnalités que nous avions besoin,
|
|
|
|
|
nous avons finalement écrit notre propre interface bas niveau pour \opencl, car
|
|
|
|
|
nous souhaitons manipuler explicitement le transfert entre l'hôte et la carte.
|
|
|
|
|
Cette interface a pour intérêt d'être simple, stable et de donner une grande
|
|
|
|
|
latitude au développeur \ocaml quant à la gestion de la mémoire entre l'hôte et
|
|
|
|
|
la carte graphique. Ce binding est contenu dans le module \texttt{OpenCL}. \tb{}
|
|
|
|
|
communique aussi avec la carte graphique \emph{via} \opengl. De la même manière,
|
|
|
|
|
il existe plusieurs bindings \opengl pour \ocaml. Toutefois, nous n'utilisons
|
|
|
|
|
qu'un faible sous-ensemble des fonctions de l'\api{} d'\opengl et nous avons
|
|
|
|
|
écrit notre propre interface bas niveau, minimale et spécifique à l'utilisation
|
|
|
|
|
de \tb{}. \texttt{Viewer} contient le binding vers \opengl, glew et glfw, trois
|
|
|
|
|
bibliothèques utilisées dans la création de l'interface graphique du simulateur.
|
|
|
|
|
|
|
|
|
|
\subsection{Le langage \sbgp{}}
|
|
|
|
|
Pour répondre au point «Entrée» du cahier des charges, nous avons développé
|
|
|
|
|
notre propre langage afin de faciliter le paramétrage d'une
|
|
|
|
|
simulation \cite{pascalie_developmental_2016} avec \tb{}. \sbgp{} (Synthetic
|
|
|
|
|
Biology Genetic Programming) est un langage déclaratif décrivant les options de
|
|
|
|
|
configuration d'une simulation \otb. Un fichier de configuration de la
|
|
|
|
|
simulation écrit avec \sbgp{} donne une représentation abstraite du génome de la
|
|
|
|
|
bactérie sous la forme d'une machine à états finis et inclus des informations
|
|
|
|
|
supplémentaires pour paramétrer la simulation, comme les couleurs de rendu.
|
|
|
|
|
|
|
|
|
|
\paragraph{Syntaxe}
|
|
|
|
|
Un fichier \sbgp{} est formaté en JSON~\cite{bray_javascript_2014}. Un génome
|
|
|
|
|
\sbgp{} est un objet JSON contenant les blocs suivants:
|
|
|
|
|
\begin{itemize}
|
|
|
|
|
\item \texttt{signals}: la liste des signaux en usage dans la simulation,
|
|
|
|
|
chaque signal est définit par un triplet: nom du signal, coefficient de
|
|
|
|
|
diffusion et coefficient de dégradation;
|
|
|
|
|
\item \texttt{reactions}: la liste des réactions, si elles existent. Chaque
|
|
|
|
|
réaction est définit par un triplet: $(r,p,\tau)$ où $r$ est une liste des
|
|
|
|
|
réactants, $p$ une liste des produits et $\tau$ le taux de réaction;
|
|
|
|
|
\item \texttt{type}: la liste des types identifiés par une étiquette unique;
|
|
|
|
|
\item \texttt{behavior}: le comportement, un objet donnant pour chaque type la
|
|
|
|
|
liste des actions à exécuter à chaque pas de temps;
|
|
|
|
|
\item \texttt{transition}: une matrice de taille
|
|
|
|
|
$card(\text{\texttt{type}}) \times card(\text{\texttt{type}})$
|
|
|
|
|
qui représente la table de transition d'état entre chaque types. La matrice
|
|
|
|
|
donne l'identifiant de la transition si il existe.
|
|
|
|
|
\item \texttt{cond\_transition}: la transition conditionnelle identifiée par
|
|
|
|
|
son étiquette; chaque étiquette dans la table de transition d'état doit
|
|
|
|
|
être défini dans ce bloc
|
|
|
|
|
\end{itemize}
|
|
|
|
|
|
|
|
|
|
Le type de chaque bloc est le suivant:
|
|
|
|
|
\begin{SBGPcode}
|
|
|
|
|
{
|
|
|
|
|
"signals" : [[Sid_i, Deg_rate_i, Diff_rate_i], [...]],
|
|
|
|
|
"reactions" : [[[Pid_i, Pid_j], [Rid_i], Rate_i], [...]],
|
|
|
|
|
"type" : [T0, ..., Tn],
|
|
|
|
|
"behavior" : {T0 : [{InstructionID : [Pid_1, ..., Pid_n]}]}
|
|
|
|
|
"transition" : [type x type] of Condition_name,
|
|
|
|
|
"cond_transition" : [{Condition_name_i : ConditionID}, ..., {...}]
|
|
|
|
|
}
|
|
|
|
|
\end{SBGPcode}
|
|
|
|
|
|
|
|
|
|
\paragraph{Déclaration des signaux}
|
|
|
|
|
Les signaux sont déclarés dans une liste. Chaque signal est un triplet contenant
|
|
|
|
|
le nom du signal sous forme de chaîne de caractères, et les coefficients de
|
|
|
|
|
diffusion et de dégradation sous forme de nombres réels.
|
|
|
|
|
\begin{SBGPcode}
|
|
|
|
|
"signals" : [
|
|
|
|
|
["alpha", 0.05, 0.01],
|
|
|
|
|
["beta", 1.5, 1]
|
|
|
|
|
]
|
|
|
|
|
\end{SBGPcode}
|
|
|
|
|
|
|
|
|
|
\paragraph{Déclaration des réactions}
|
|
|
|
|
Les réactions sont déclarés dans une liste. Chaque réaction consiste en un
|
|
|
|
|
triplet: la liste des réactants, la liste des produits et la constante cinétique
|
|
|
|
|
de la réaction. Par exemple, le bloc \sbgp{} suivant est utilisé pour décrire la
|
|
|
|
|
réaction $2\alpha + \beta \xrightarrow{0.15} \gamma$:
|
|
|
|
|
\begin{SBGPcode}
|
|
|
|
|
"reactions" : [
|
|
|
|
|
[
|
|
|
|
|
["alpha", "alpha", "beta"],
|
|
|
|
|
["gamma"],
|
|
|
|
|
0.15
|
|
|
|
|
]
|
|
|
|
|
]
|
|
|
|
|
\end{SBGPcode}
|
|
|
|
|
|
|
|
|
|
\paragraph{Déclaration des types}
|
|
|
|
|
Les types de bactéries légaux sont déclarés dans une liste d'identifiants. Le
|
|
|
|
|
bloc suivant donne la liste des types impliqués dans le génome:
|
|
|
|
|
\begin{SBGPcode}
|
|
|
|
|
"type" : [
|
|
|
|
|
"QUIESCENT",
|
|
|
|
|
"LEADER",
|
|
|
|
|
"FLESH",
|
|
|
|
|
"SKIN",
|
|
|
|
|
"DEAD"
|
|
|
|
|
]
|
|
|
|
|
\end{SBGPcode}
|
|
|
|
|
|
|
|
|
|
\paragraph{Déclaration du comportement}
|
|
|
|
|
Les comportements spécifiques aux types sont déclarés dans une liste
|
|
|
|
|
associative; une liste d'instructions est donnée pour chaque étiquette
|
|
|
|
|
déclaré dans le bloc type. Par exemple, le code suivant donne le comportement
|
|
|
|
|
d'une bactérie de type \texttt{LEADER}:
|
|
|
|
|
\begin{SBGPcode}
|
|
|
|
|
"behavior" : {
|
|
|
|
|
"LEADER" : [ { "EmitSignal" : ["alpha", "150"] },
|
|
|
|
|
{ "StopDivide" : [] },
|
|
|
|
|
{ "Accumulate" : ["lambda","1"] }
|
|
|
|
|
]
|
|
|
|
|
}
|
|
|
|
|
\end{SBGPcode}
|
|
|
|
|
Une instruction est décrite conformément à la structure suivante:
|
|
|
|
|
\begin{SBGPcode}
|
|
|
|
|
{ "InstructionID" : ["param1", ... ,"paramN"] }
|
|
|
|
|
\end{SBGPcode}
|
|
|
|
|
La valeur du champ \texttt{InstructionID} doit être pris parmi l'ensemble des
|
|
|
|
|
instructions \sbgp{} suivantes:
|
|
|
|
|
\begin{itemize}
|
|
|
|
|
\item \texttt{EmitSignal(s,q)}: dépose une quantité \ç|q| du morphogène \ç|s| à
|
|
|
|
|
la position courante de la bactérie dans l'environnement;
|
|
|
|
|
\item \texttt{AbsorbSignal(s,q)}: consomme une quantité \ç|q| du morphogène
|
|
|
|
|
\ç|s| à la position courante de la bactérie dans l'environnement;
|
|
|
|
|
\item \texttt{Differentiate(A)}: force un changement de type de la bactérie vers
|
|
|
|
|
le type \ç|A| (il doit exister dans la liste des types);
|
|
|
|
|
\item \texttt{Die()}: détruit la bactérie. Elle est en pratique marquée comme
|
|
|
|
|
inactive et réinitialisée;
|
|
|
|
|
\item \texttt{Freeze()}: place le marqueur \ç|immobile| sur une bactérie. Dans cet
|
|
|
|
|
état une bactérie est immobile et ne croît pas;
|
|
|
|
|
\item \texttt{Unfreeze()}: retire le marqueur \ç|immobile|;
|
|
|
|
|
\item \texttt{Divide(r)}: définit le taux de croissance de la bactérie à la
|
|
|
|
|
valeur particulière \ç|r|;
|
|
|
|
|
\item \texttt{StopDivide()}: définit le taux de croissance de la bactérie comme
|
|
|
|
|
nul, l'empêchant ainsi de se diviser;
|
|
|
|
|
\item \texttt{Accumulate(p,q)}: incrémente le compteur de morphogènes \ç|p| avec
|
|
|
|
|
la valeur \ç|q|;
|
|
|
|
|
\item \texttt{Deplete(p,q)}: décrémente le compteur de morphogènes \ç|p| avec la
|
|
|
|
|
valeur \ç|q|.
|
|
|
|
|
\end{itemize}
|
|
|
|
|
|
|
|
|
|
\paragraph{Déclaration des transitions}
|
|
|
|
|
Le bloc transition est une matrice encodant le graphe de différentiation du
|
|
|
|
|
génome. La taille de la matrice dépend du nombre de types. Lorsque qu'une
|
|
|
|
|
transition existe entre deux types, une étiquette est définie dans la case de la
|
|
|
|
|
matrice correspondante, sinon, le mot-clé \texttt{NA} est spécifié. Le code
|
|
|
|
|
\sbgp{} suivant présente le graphe de différenciation d'un cœur homéostatique à
|
|
|
|
|
deux couches: la population croît autour d'une bactérie mère en formant deux
|
|
|
|
|
anneaux concentriques constitués d'une quantité invariante de bactéries.
|
|
|
|
|
\begin{SBGPcode}
|
|
|
|
|
"transition" : [
|
|
|
|
|
["NA","CL","C1" ,"C2" ,"NA" ,"NA" ],
|
|
|
|
|
["NA","NA","NA" ,"NA" ,"NA" ,"NA" ],
|
|
|
|
|
["NA","NA","NA" ,"C12","NA" ,"NA" ],
|
|
|
|
|
["NA","NA","C21","NA" ,"C23","NA" ],
|
|
|
|
|
["NA","NA","NA" ,"NA" ,"NA" ,"C3D"],
|
|
|
|
|
["NA","NA","NA" ,"NA" ,"NA" ,"NA" ]
|
|
|
|
|
],
|
|
|
|
|
\end{SBGPcode}
|
|
|
|
|
|
|
|
|
|
\paragraph{Déclaration des conditions de transition}
|
|
|
|
|
Une condition est une expression booléenne renvoyant \ç|true| ou \ç|false|. La
|
|
|
|
|
valeur du champ \texttt{ConditionID} doit être prise parmi l'ensemble des
|
|
|
|
|
instructions \sbgp{} suivantes:
|
|
|
|
|
\begin{itemize}
|
|
|
|
|
\item \texttt{AND(Cid1,Cid2)}, \texttt{OR(Cid1,Cid2)}: \ç{AND} et \ç{OR} sont les
|
|
|
|
|
opérations classiques de la logique booléenne;
|
|
|
|
|
\item \texttt{EqThreshold(s,q)}: ce prédicat n'est vérifié que si la
|
|
|
|
|
concentration du morphogène \ç|s| est égale à \ç|q|;
|
|
|
|
|
\item \texttt{LessThreshold(s,q)}: ce prédicat n'est vérifié que si la
|
|
|
|
|
concentration du morphogène \ç|s| est inférieure à \ç|q|;
|
|
|
|
|
\item \texttt{GreaterThreshold(s,q)}: ce prédicat n'est vérifié que si la
|
|
|
|
|
concentration du morphogène \ç|s| est supérieure à \ç|q|;
|
|
|
|
|
\item \texttt{LessEqThreshold(s,q)}: ce prédicat n'est vérifié que si la
|
|
|
|
|
concentration du morphogène \ç|s| est inférieure ou égale à \ç|q|;
|
|
|
|
|
\item \texttt{GreaterEqThreshold(s,q)}: ce prédicat n'est vérifié que si la
|
|
|
|
|
concentration du morphogène \ç|s| est supérieure ou égale à \ç|q|;
|
|
|
|
|
\item \texttt{BetweenThreshold(s,q1,q2)}: ce prédicat n'est vérifié que si la
|
|
|
|
|
concentration du morphogène \ç|s| est comprise strictement entre \ç|q1| et
|
|
|
|
|
\ç|q2|;
|
|
|
|
|
\item \texttt{InternalProtEqCond(p,q)}: ce prédicat n'est vérifié que si le
|
|
|
|
|
compteur de morphogènes \ç|p| est égal à la valeur \ç|q|;
|
|
|
|
|
\item \texttt{InternalProtLessCond(p,q)}: ce prédicat n'est vérifié que si le
|
|
|
|
|
compteur de morphogènes \ç|p| est inférieur strictement à la valeur \ç|q|;
|
|
|
|
|
\item \texttt{InternalProtGreatCond(p,q)}: ce prédicat n'est vérifié que si le
|
|
|
|
|
compteur de morphogènes \ç|p| est supérieur strictement à la valeur \ç|q|;
|
|
|
|
|
\item \texttt{InternalProtLessEqCond(p,q)}: ce prédicat n'est vérifié que si le
|
|
|
|
|
compteur de morphogènes \ç|p| est inférieur ou égal à la valeur \ç|q|;
|
|
|
|
|
\item \texttt{InternalProtGreatEqCond(p,q)}: ce prédicat n'est vérifié que si le
|
|
|
|
|
compteur de morphogènes \ç|p| est supérieur ou égal à la valeur \ç|q|;
|
|
|
|
|
\item \texttt{MidPlane(a,b,t)}: ce prédicat n'est vérifié que si la valeur de la
|
|
|
|
|
concentration du morphogène \ç|a| moins la concentration du morphogène \ç|b|
|
|
|
|
|
est comprise entre \ç|-t| et \ç|t|.
|
|
|
|
|
\end{itemize}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
\section{Propagation Parallèle à la Margolus}\label{sec:ppm}
|
|
|
|
|
Nous avons présenté l'architecture de haut niveau de \otb, ainsi que son langage
|
|
|
|
|
de configuration, cette section présente l'algorithme de Propagation Parallèle à
|
|
|
|
|
la Margolus (\ppm). Cette algorithme forme le socle théorique que nous
|
|
|
|
|
implémentons dans les kernels \opencl. Nous commençons par un rappel sur les
|
|
|
|
|
automates cellulaires, les automates à blocs, puis nous présentons l'algorithme
|
|
|
|
|
de bounding-box dynamique et enfin \ppm.
|
|
|
|
|
|
|
|
|
|
\subsection{Automates cellulaires et voisinage de Margolus}
|
|
|
|
|
% Voir peut-être aussi CML (https://en.wikipedia.org/wiki/Coupled_map_lattice)
|
|
|
|
|
Notre travail se situe dans le contexte des automates cellulaires. Un automate
|
|
|
|
|
cellulaire est un modèle de calcul discret, introduit par John Von Neumann et
|
|
|
|
|
Stanislaw Ulam dans les années 1960~\cite{neumann_theory_1966}. C'est un modèle
|
|
|
|
|
de calcul Turing complet qui a d'abord été objet de recherche académique sur les
|
|
|
|
|
processus d'auto réplication, ensuite popularisé par le «Game of Life» de John
|
|
|
|
|
Conway\footnote{lors de sa publication dans les pages du Scientific American en
|
|
|
|
|
octobre 1970} où il est devenu un modèle pour les processus biologiques. Les
|
|
|
|
|
automates cellulaires sont un outil des paradigmes de programmation non
|
|
|
|
|
conventionnels, d'un côté permettant de formaliser les processus biologiques
|
|
|
|
|
observés, et de l'autre de les modéliser et de les simuler.
|
|
|
|
|
|
|
|
|
|
\begin{mpo-definition}[Configuration]
|
|
|
|
|
Soit $\oQ$ un ensemble d'états, $G$ un groupe, $c_\oQ : G \rightarrow \oQ$ est
|
|
|
|
|
une \emph{configuration} et $C_\oQ := \{ c \,|\, c:G \rightarrow \oQ \}$ est
|
|
|
|
|
\emph{l'ensemble de toutes les configurations} $c_\oQ$. Quand le contexte lève
|
|
|
|
|
tout ambigüité, on pourra omettre l'indice $\oQ$.
|
|
|
|
|
\end{mpo-definition}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
\begin{mpo-definition}[Automate cellulaire]\label{def:ca}
|
|
|
|
|
Un automate cellulaire est un tuple $\oA = (M, \oQ, N, f)$ dont:
|
|
|
|
|
\begin{itemize}
|
|
|
|
|
\item $(M,+)$ est un groupe abélien libre appelé \emph{maillage des cellules};
|
|
|
|
|
\item $\oQ$ est \emph{l'ensemble des états}, aussi parfois appelé alphabet,
|
|
|
|
|
\item $N \in M^k$, $k \in \mathbb{N}$ est \emph{l'indice de
|
|
|
|
|
voisinage}, dont les éléments sont uniques deux à deux et $N =
|
|
|
|
|
(n_1,n_2,\ldots,n_k)$;
|
|
|
|
|
\item $f: \oQ^k \rightarrow \oQ$ est la \emph{fonction de transition locale}
|
|
|
|
|
\end{itemize}
|
|
|
|
|
$f$ induit une fonction de transition globale $F$, $\forall c \in C_\oQ$ et $m
|
|
|
|
|
\in M$:
|
|
|
|
|
\[ F(c)(m) := f(c(m+n_1),c(m+n_2),\ldots,c(m+n_k)) \]
|
|
|
|
|
\end{mpo-definition}
|
|
|
|
|
|
|
|
|
|
La mise à jour d'une configuration se fait de manière locale, par l'application
|
|
|
|
|
de $f$ sur chaque cellule en fonction du voisinage, et \emph{synchrone} avec
|
|
|
|
|
des pas de temps discrets. Dans le cas d'un voisinage classique ou de Von
|
|
|
|
|
Neumann, à gauche dans la \textsc{Fig.}~\ref{fig:voisinage-2D}, les voisins directs
|
|
|
|
|
sont pris en compte pour le calcul du nouvel état de chaque cellule. Du point de
|
|
|
|
|
vue de \mgs{}, un automate cellulaire est constitué d'un ensemble $C$ de
|
|
|
|
|
collections topologiques et d'une transformation $T$ jouant le rôle de la
|
|
|
|
|
fonction de transition globale de l'automate. Quelques restrictions s'appliquent
|
|
|
|
|
sur chaque $c_i \in C$ et $T$: $c_i$ doit être une collection newtonienne de
|
|
|
|
|
type \gbf{} et $T$ doit utiliser la stratégie de réécriture
|
|
|
|
|
\texttt{maximal-parallel}, afin que la mise à jour soit synchrone.
|
|
|
|
|
|
|
|
|
|
\begin{figure}[ht]
|
|
|
|
|
\centering
|
|
|
|
|
\includegraphics[page=1,width=.3\textwidth]{figures/ca-neighborhood-2D}
|
|
|
|
|
\includegraphics[page=2,width=.3\textwidth]{figures/ca-neighborhood-2D}
|
|
|
|
|
\includegraphics[page=3,width=.3\textwidth]{figures/ca-neighborhood-2D}
|
|
|
|
|
\caption{Trois exemples de voisinages sur un grille carrée en 2D, à gauche un
|
|
|
|
|
voisinage de Von Neumann, au centre un voisinage hexagonal et à droite un
|
|
|
|
|
voisinage de Moore.}
|
|
|
|
|
\label{fig:voisinage-2D}
|
|
|
|
|
\end{figure}
|
|
|
|
|
|
|
|
|
|
En tant que modèle de calcul, un automate cellulaire fonctionne de manière
|
|
|
|
|
fortement parallèle: la même fonction est appliquée sur chaque cellule de la
|
|
|
|
|
grille, ou autrement dit le même algorithme est appliqué à de multiples données
|
|
|
|
|
ce qui est la définition d'une architecture SIMD. On pourrait donc tirer parti
|
|
|
|
|
d'une architecture fortement parallèle pour implémenter un automate cellulaire.
|
|
|
|
|
Néanmoins, la dépendance entre les données par la relation de voisinage entre
|
|
|
|
|
les cellules pose encore problème. Une solution classique revient à utiliser une
|
|
|
|
|
mémoire intermédiaire (un buffer) depuis lequel on va lire les données et écrire
|
|
|
|
|
les résultat dans un second buffer, cassant ainsi la dépendance en écriture sur
|
|
|
|
|
les cellules concernées. Cependant, il reste une \emph{dépendance en lecture}
|
|
|
|
|
sur les cellules voisines causant des collisions de lecture et pouvant encore
|
|
|
|
|
porter atteinte à l'efficacité d'une implémentation parallèle. Pour résoudre ces
|
|
|
|
|
problèmes, nous nous sommes tournés vers le voisinage de Margolus et de manière
|
|
|
|
|
plus générale, le modèle de calcul des automates à blocs.
|
|
|
|
|
|
|
|
|
|
S'intéressant au développement d'ordinateurs simulant des systèmes physiques,
|
|
|
|
|
Toffoli et Margolus introduisent
|
|
|
|
|
dans~\cite{toffoli_cellular_1987,margolus_physics-like_1984} les automates
|
|
|
|
|
cellulaire à blocs (\emph{block cellular automata}), ou automate à partitions
|
|
|
|
|
(\emph{partitioning automata}), pour modéliser le comportement dynamique de
|
|
|
|
|
l'écoulement d'un fluide en respectant le principe de \emph{réversibilité} des
|
|
|
|
|
lois physiques. En thermodynamique, durant un processus réversible l'entropie
|
|
|
|
|
n'augmente pas et le système est en état d'équilibre thermodynamique. On appelle
|
|
|
|
|
\emph{automate cellulaire réversible} les automates cellulaire dont on retrouve
|
|
|
|
|
la configuration d'origine en «inversant» la flèche du temps. Un automate
|
|
|
|
|
cellulaire dont chaque cellule est mise à jour en inversant sa valeur précédente
|
|
|
|
|
et en ignorant son voisinage est trivialement réversible. Cependant, au delà
|
|
|
|
|
d'une dimension, la réversibilité d'un automate cellulaire est
|
|
|
|
|
indécidable~\cite{kari_reversibility_1994}. L'automate gaz sur réseau (lattice
|
|
|
|
|
gas automaton)~\cite{hardy_time_1973}, la règle
|
|
|
|
|
«Tron»~\cite{toffoli_cellular_1987}, l'ordinateur à boules de billard
|
|
|
|
|
(billiard-ball computer)~\cite{fredkin_conservative_1982} sont des exemples
|
|
|
|
|
d'automates cellulaires réversibles. Toffoli et Margolus montrent également que
|
|
|
|
|
la classe des automates à partitions est équivalente à celles des automates
|
|
|
|
|
cellulaires, et que ces deux modèles peuvent se simuler l'un l'autre.
|
|
|
|
|
|
|
|
|
|
\begin{mpo-definition}[Automate cellulaire à blocs] Un automate cellulaire à
|
|
|
|
|
blocs, aussi appelé automate à partitions, est un tuple
|
|
|
|
|
$B=(M,\oQ,p,\text{\em shift},f)$ avec:
|
|
|
|
|
\begin{itemize}
|
|
|
|
|
% Lattice (order) != Lattice (groups) | Treilli != Réseau
|
|
|
|
|
\item $(M,+)$ le maillage des cellules. C'est le groupe abélien \emph{libre}
|
|
|
|
|
engendré par l'ensemble fini $A = \{g_1,...,g_n\}$;
|
|
|
|
|
\item $\oQ$ un ensemble d'états;
|
|
|
|
|
\item $p : M \rightarrow M$ la fonction de pavage qui pour $\{c_1,...,c_n\}
|
|
|
|
|
\subset \mathbb{Z}^n$ et $\{k_1,...,k_n\} \subset \mathbb{N}_{+}^n$ associe à
|
|
|
|
|
chaque point de $M$ un \emph{bloc}:
|
|
|
|
|
\[
|
|
|
|
|
p(\sum\limits_{i=1}^{n}{c_i\ g_i})
|
|
|
|
|
= \sum\limits_{i=1}^{n}{\left\lfloor \frac{c_i}{k_i} \right\rfloor g_i}
|
|
|
|
|
\]
|
|
|
|
|
La fonction inverse $p^{-1}(m) = \{ m \in M\, |\, p(m) \in M \}$ permet
|
|
|
|
|
d'obtenir l'ensemble des éléments du bloc indicé par $m$.
|
|
|
|
|
\item $\text{\em shift}$ est la liste d'éléments $(m_1,...,m_n)$ de $M$ .
|
|
|
|
|
\item $f : Q^k \rightarrow Q^k$ est la fonction de transition locale, avec $k
|
|
|
|
|
= \prod_{i=1}^{n}{k_i}$.
|
|
|
|
|
\end{itemize}
|
|
|
|
|
La fonction de transition locale $f$ induit une fonction de transition
|
|
|
|
|
globale, dont la définition est décrite par l'algorithme
|
|
|
|
|
\begin{algorithm}
|
|
|
|
|
\ForAll {$s \in \text{shift}$}
|
|
|
|
|
{ \ForAll {$m \in M$} {
|
|
|
|
|
$M \gets f (c_1 (T^s \beta(m)))$ \;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
\end{algorithm}
|
|
|
|
|
en posant:
|
|
|
|
|
\begin{itemize}
|
|
|
|
|
\item $T^s$ l'opérateur de décalage sur les groupes Abéliens, $T^s f(g) =
|
|
|
|
|
f(g+s)$ en prenant un groupe Abélien $G$, $g \in G$ et $f : G \rightarrow
|
|
|
|
|
G$;
|
|
|
|
|
\item $\beta(m) = (p^{-1} \circ p) (m)$ l'ensemble des éléments appartenant au
|
|
|
|
|
bloc de la cellule $m$ et
|
|
|
|
|
\item $c_1(B) : M \rightarrow Q^k $ la configuration d'un ensemble de cellules
|
|
|
|
|
\emph{indexées par leur élément correspondant} dans le groupe. Nous
|
|
|
|
|
n'expliciterons pas la version formelle ici pour ne pas alourdir la
|
|
|
|
|
définition inutilement.
|
|
|
|
|
\end{itemize}
|
|
|
|
|
\end{mpo-definition}
|
|
|
|
|
|
|
|
|
|
Nous avons choisi d'utiliser la structure de groupe abélien libre pour
|
|
|
|
|
représenter un maillage de cellule. C'est également le point de vue utilisé dans
|
|
|
|
|
la définition des \gbf{} à la différence que nous nous restreignons aux groupes
|
|
|
|
|
libres, afin de pouvoir définir un pavage naturel. De ce point du vue, il
|
|
|
|
|
semblerait qu'un automate cellulaire à bloc ne puisse pas avoir de maillage
|
|
|
|
|
hexagonal, avec la présentation de groupe $H = \langle a,b,c \:|\: a + b = c
|
|
|
|
|
\rangle$, car ce n'est pas un groupe libre. Néanmoins, nous pourrons considérer
|
|
|
|
|
qu'un maillage hexagonal est un maillage carré, de présentation $H = \langle a,b
|
|
|
|
|
\rangle$ sur lequel le voisinage entre cellules est spécifique comme présenté
|
|
|
|
|
sur la \textsc{Fig.}~\ref{fig:voisinage-2D} au centre. Par conséquent, c'est la
|
|
|
|
|
fonction de transition locale qui déterminera quel voisinage est utilisé.
|
|
|
|
|
|
|
|
|
|
La fonction $\lfloor x/k \rfloor$ se comporte « naturellement » autour de $0$:
|
|
|
|
|
chaque image par cette fonction possède exactement $k$ préimages. Cette
|
|
|
|
|
caractéristique permet, par exemple, de partitionner $\mathbb{Z}$ en
|
|
|
|
|
sous-ensembles de cardinalité $k$, d'où son usage dans la définition de $p$.
|
|
|
|
|
|
|
|
|
|
Pour la définition de la fonction de pavage, nous avons choisi une approche
|
|
|
|
|
similaire à la définition d'une partition de l'espace passant par les
|
|
|
|
|
$\mathbb{Z}$-modules comme introduit dans~\cite{michel_representations_1996} à
|
|
|
|
|
la section VI.1.1. Notre approche correspond mieux à l'idée intuitive d'une
|
|
|
|
|
sous division de l'espace: à chaque cellule du maillage on fait correspondre une
|
|
|
|
|
cellule du même maillage, ce qui expose immédiatement la structure et la
|
|
|
|
|
régularité du pavage.
|
|
|
|
|
|
|
|
|
|
Le voisinage de Margolus est la règle de partitionnement du maillage d'un
|
|
|
|
|
automate à blocs en une grille composée de blocs de $2$ cellules (ou en carrés
|
|
|
|
|
de $2\times 2$ cellules en deux dimensions, en cubes de $2\times 2\times 2$
|
|
|
|
|
cellules en trois dimension, …) avec un décalage d'une «case» dans toutes les
|
|
|
|
|
directions. C'est donc un cas particulier d'automate cellulaire à blocs, avec
|
|
|
|
|
les restrictions suivantes (en reprenant le contexte de la définition des
|
|
|
|
|
automates à blocs):
|
|
|
|
|
\begin{itemize}
|
|
|
|
|
\item $p : M \rightarrow M$ la fonction de pavage qui pour $\{c_1,...,c_n\}
|
|
|
|
|
\subset \mathbb{Z}^n$ associe à chaque point de $M$ un bloc de côté 2:
|
|
|
|
|
\[
|
|
|
|
|
p(\sum\limits_{i=1}^{n}{c_i\ g_i})
|
|
|
|
|
= \sum\limits_{i=1}^{n}{\left\lfloor \frac{c_i}{2} \right\rfloor g_i}
|
|
|
|
|
\] et
|
|
|
|
|
\item shift est l'élément $\sum\limits_{i=1}^{n}{1\ g_i} \in M$.
|
|
|
|
|
\end{itemize}
|
|
|
|
|
|
|
|
|
|
\begin{figure}[ht]
|
|
|
|
|
\centering
|
|
|
|
|
\includegraphics[page=1,width=.4\textwidth]{figures/ca-neighborhood}
|
|
|
|
|
\hspace{1cm}
|
|
|
|
|
\includegraphics[page=2,width=.4\textwidth]{figures/ca-neighborhood}
|
|
|
|
|
\caption{Voisinage classique (à gauche) d'un automate cellulaire à une
|
|
|
|
|
dimension et voisinage de Margolus (à droite). Pour le voisinage classique,
|
|
|
|
|
chaque ligne correspond à un pas dans la simulation de l'automate, de haut
|
|
|
|
|
en bas. Pour le voisinage de Margolus, un seul pas de simulation est
|
|
|
|
|
présenté, la ligne du milieu est présentée afin de montrer la correspondance
|
|
|
|
|
entre les deux automates.}
|
|
|
|
|
\label{fig:ac-nh}
|
|
|
|
|
\end{figure}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
\subsection{Bounding box et activité}\label{sec:boundingbox}
|
2017-07-08 18:59:57 +02:00
|
|
|
|
Dans OTB, l'environnement dans lequel évoluent les bactéries n'a pas \emph{a
|
2017-07-08 17:42:46 +02:00
|
|
|
|
priori} de taille fixe et subit une expansion ou une contraction en fonction
|
|
|
|
|
de l'espace occupé par les bactéries, ou par leur support. Nous appelons
|
|
|
|
|
\emph{bounding box} la boîte englobante dont l'intérieur forme l'environnement
|
|
|
|
|
dans lequel évoluent les bactéries, ou leur support. Cette bounding box a une
|
|
|
|
|
taille rectangulaire libre. La bounding box est construite \emph{a posteriori}:
|
|
|
|
|
elle est déterminée par la taille de la grille d'automate qu'elle représente. De
|
|
|
|
|
cette manière, il est possible d'accéder rapidement à la taille d'une population
|
|
|
|
|
de bactéries et d'effectuer des calculs de collision entre bounding box et des
|
|
|
|
|
opérations de séparation et de fusion. Ces opérations, bien que planifiées, ne
|
|
|
|
|
sont que partiellement implémentées à l'heure de l'écriture de ce mémoire.
|
|
|
|
|
|
|
|
|
|
\begin{figure}[ht]
|
|
|
|
|
\centering
|
|
|
|
|
\includegraphics[page=1,width=.8\textwidth]{figures/bb-activity}
|
|
|
|
|
\caption{Grille d'un automate cellulaire, ses indicateurs vertical et
|
|
|
|
|
horizontal et sa Bounding Box (en gras)}
|
|
|
|
|
\label{fig:bb-activity}
|
|
|
|
|
\end{figure}
|
|
|
|
|
|
|
|
|
|
Nous utilisons une mesure d'activité spatiale pour déterminer s'il est
|
|
|
|
|
nécessaire d'agrandir ou de diminuer la taille de l'environnement. Chaque
|
|
|
|
|
cellule de l'automate contenant une bactérie est considérée comme active. Si une
|
|
|
|
|
cellule active se trouve à une distance inférieure à $d_c$ d'un des bords, alors
|
|
|
|
|
l'environnement est agrandi. À l'inverse, si la distance la cellule active la
|
|
|
|
|
plus proche d'un bord à ce bord est supérieure à $d_f$ alors, l'environnement
|
|
|
|
|
est rétréci.
|
|
|
|
|
|
|
|
|
|
En pratique, une bounding box est définie par un triplet $(p,w,h)$ où $p=(x,y)$
|
|
|
|
|
est un point dans le plan représentant le coin inférieur gauche de la boîte, $w$
|
|
|
|
|
est sa largeur et $h$ est sa hauteur (Fig.~\ref{fig:bb-activity}). Nous mesurons
|
|
|
|
|
l'occupation pour chaque ligne et chaque colonne avec deux tableaux appelés
|
|
|
|
|
\emph{indicateur}: un pour l'occupation horizontale, l'autre pour l'occupation
|
|
|
|
|
verticale. Ces deux tableaux sont suffisant pour déterminer s'il est nécessaire
|
|
|
|
|
d'agrandir ou de rétrécir l'environnement. L'algorithme suivant est utilisé par
|
|
|
|
|
\otb pour déterminer une nouvelle bounding box optimale, $w,h$ sont la largeur
|
|
|
|
|
et la hauteur respectives de la bounding box de départ, $c_w,c_h$ sont les
|
|
|
|
|
tableaux indicateurs sur la largeur et la hauteur respectivement.
|
|
|
|
|
|
|
|
|
|
La première partie de cet algorithme détermine la position de coupe par rapport à
|
|
|
|
|
chacun des quatre bords nord, sud, est et ouest de la bounding box. Il suffit
|
|
|
|
|
pour cela de déterminer la position du premier élément non nul pour chaque
|
|
|
|
|
extrémité de chaque indicateur, ce qui nous fournit le quadruplet $(\text{posN},
|
|
|
|
|
\text{posS}, \text{posE}, \text{posW})$ de positions de coupe au nord, au sud à
|
|
|
|
|
l'est et à l'ouest respectivement.
|
|
|
|
|
|
|
|
|
|
La seconde partie de cet algorithme détermine la nouvelle dimension de la
|
|
|
|
|
bounding box, en prenant en compte les deux marges notée $d_c$ et $d_f$ et en
|
|
|
|
|
fonction des positions de coupe déterminées auparavant. La fonction
|
|
|
|
|
\texttt{CropBoundingBox()} est chargée de la mise en œuvre du découpage de
|
|
|
|
|
l'ancienne bounding box et en retourne une nouvelle en fonction du quadruplet
|
|
|
|
|
$(\text{n}, \text{s}, \text{e}, \text{w})$ indiquant les corrections de marge à
|
|
|
|
|
chacune des extrémité. Par exemple, $\text{n}=2$ agrandi de 2 unités la taille
|
|
|
|
|
de la bounding box au nord, alors que $\text{e}=-4$ rétrécie de 4 unités la
|
|
|
|
|
taille de la bounding box à l'est. Cette fonction est implémenté dans le module
|
|
|
|
|
de bas niveau \ç|BoundingBox|.
|
|
|
|
|
|
|
|
|
|
\begin{algorithm}[H]
|
|
|
|
|
\SetKwInOut{Input}{input}\SetKwInOut{Output}{output}
|
|
|
|
|
\SetKwData{PosN}{posN}\SetKwData{PosS}{posS}
|
|
|
|
|
\SetKwData{PosE}{posE}\SetKwData{PosW}{posW}
|
|
|
|
|
\SetKwData{OldBB}{oldBB}
|
|
|
|
|
\SetKwFunction{CBB}{cropBoundingBox}
|
|
|
|
|
|
|
|
|
|
\Input{Bounding box actuelle \OldBB et \PosN, \PosS, \PosE, \PosW}%
|
|
|
|
|
\Output{Une nouvelle bounding box ajustée}
|
|
|
|
|
\eIf(\tcp*[f]{Marge nord}){$\PosN < d_c$}{
|
|
|
|
|
$n \gets d_c - \PosN$\;
|
|
|
|
|
}{
|
|
|
|
|
\If{$\PosN > d_f$} {
|
|
|
|
|
$n \gets d_c - \PosN$\;}
|
|
|
|
|
\Else{
|
|
|
|
|
$n \gets 0$\;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
\tcp{Exactement la même opération pour sud, est et ouest}
|
|
|
|
|
|
|
|
|
|
\Return{\CBB{\OldBB, $n$, $s$, $e$, $w$}}
|
|
|
|
|
\caption{Création d'un nouvelle bounding box aux \emph{bonnes} dimensions}
|
|
|
|
|
\end{algorithm}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
\subsection{Propagation Parallèle à la Margolus}
|
|
|
|
|
L'algorithme \ppm est inspiré du voisinage de Margolus, à droite dans la
|
|
|
|
|
\textsc{Fig.}~\ref{fig:ac-nh}, en deux dimensions et l'utilise comme structure de
|
|
|
|
|
données. Il effectue la simulation d'un automate cellulaire à blocs sur une
|
|
|
|
|
machine parallèle d'architecture SIMD, nous l'avons implémenté sous forme d'un
|
|
|
|
|
kernel \opencl. Pour faciliter sa lisibilité, en voici une description un peu
|
|
|
|
|
plus haut niveau que notre implémentation.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
\paragraph{Cellule}%
|
|
|
|
|
Chaque cellule est constituée de quatre emplacements: son propre état et l'état
|
|
|
|
|
de trois de ses voisines comme présenté dans la \textsc{Fig.}~\ref{fig:margolus-grid}.
|
|
|
|
|
Ces quatre emplacements seront notés dans l'algorithme suivant par abus
|
|
|
|
|
de la notation classique de tableau, avec les indices spéciaux 1, 2, 3 et
|
|
|
|
|
4. Ainsi, $m[a1]$ désigne le premier emplacement de la cellule $A$. La
|
|
|
|
|
\textsc{Fig.}~\ref{fig:margolus-grid} (a) donne une représentation visuelle de la
|
|
|
|
|
position des cellules et de leurs emplacements en accord avec l'algorithme.
|
|
|
|
|
|
|
|
|
|
\begin{figure}[ht]
|
|
|
|
|
\centering
|
|
|
|
|
\includegraphics[page=1,width=.24\textwidth]{figures/margolus}\hfill%
|
|
|
|
|
\includegraphics[page=2,width=.24\textwidth]{figures/margolus}\hfill%
|
|
|
|
|
\includegraphics[page=3,width=.24\textwidth]{figures/margolus}\hfill%
|
|
|
|
|
\includegraphics[page=4,width=.24\textwidth]{figures/margolus}
|
|
|
|
|
|
|
|
|
|
\hspace{.11\textwidth}(a)\hfill(b)\hfill(c)\hfill(d)\hspace{.11\textwidth}
|
|
|
|
|
\caption[Quatre configuration successives d'un automate cellulaire en deux
|
|
|
|
|
dimensions.]{\textit{Général.} Quatre configurations successives d'un
|
|
|
|
|
automate cellulaire en deux dimensions dont les cellules sont en gris.%
|
|
|
|
|
\textit{\hspace{1em}(a).} Les coordonnées utilisées dans l'algorithme pour
|
|
|
|
|
une cellule de Margolus.%
|
|
|
|
|
\textit{\hspace{1em}(b).} Les cellules A,B,C et D font partie d'une cellule
|
|
|
|
|
du voisinage de Margolus (en noir, en gras).%
|
|
|
|
|
\textit{\hspace{1em}(c).} Chacune des cellules stocke quatre états: la copie
|
|
|
|
|
de l'état de trois de ses voisines et le sien (en blanc sur fond noir).
|
|
|
|
|
Le positionnement de ces états est présenté par rapport au voisinage de
|
|
|
|
|
Margolus courant.%
|
|
|
|
|
\textit{\hspace{1em}(d).} Après une étape de calcul, les états de A, B, C
|
|
|
|
|
et D sont mis à jour en A', B', C' et D' et le voisinage de Margolus est
|
|
|
|
|
décalé.}
|
|
|
|
|
\label{fig:margolus-grid}
|
|
|
|
|
\end{figure}
|
|
|
|
|
|
|
|
|
|
\paragraph{Algorithme}%
|
|
|
|
|
\ppm prend en entrée un tableau de cellules \ç|cellSpace[w][h]| en deux
|
|
|
|
|
dimensions de largeur \ç|w| et de hauteur \ç|h| et un indicateur \ç|shift|
|
|
|
|
|
déterminant le décalage du voisinage. La fonction d'évolution locale
|
|
|
|
|
\ç|evol(c,n1,n2,n3,n4,n5,n6,n7,n8)| prend en argument l'état courant \ç|c| ainsi
|
|
|
|
|
que l'état des 8 cellules voisines \ç|n1,...,n8|.
|
|
|
|
|
|
|
|
|
|
La fonction de mise à jour est appelée en parallèle sur \emph{le même tableau}
|
|
|
|
|
de cellules et doit donc être paramétrée pour indiquer sur quelle cellule elle
|
|
|
|
|
travaille: c'est le rôle des deux variables spéciales $gc_x$ et $gc_y$ indiquant
|
|
|
|
|
la position globale en abscisse et en ordonnée du bloc courant. C'est donc la
|
|
|
|
|
coordonnée d'une cellule du voisinage de Margolus qui est fournie. Ces deux
|
|
|
|
|
variables sont les paramètres propres à un work-item \opencl, qui permet à
|
|
|
|
|
chaque instance du kernel d'avoir un comportement différent.
|
|
|
|
|
|
|
|
|
|
\begin{algorithm}
|
|
|
|
|
\SetKwInOut{Input}{input}\SetKwInOut{Output}{output}
|
|
|
|
|
\SetKwData{CellSpace}{cellSpace}\SetKwData{Shift}{shift}
|
|
|
|
|
\SetKwData{Slot}{.slot}\SetKwData{Evol}{evol}
|
|
|
|
|
|
|
|
|
|
\Input{Une configuration \CellSpace d'un automate cellulaire en deux
|
|
|
|
|
dimension, un indice de décalage \Shift valant 0 ou 1 et les coordonnées
|
|
|
|
|
globales $(gc_x,gc_y)$ du bloc actuel}%
|
|
|
|
|
\Output{Aucune (le changement est effectué par effet de bord)}
|
|
|
|
|
|
|
|
|
|
$p_x \gets 2 * gc_x + \texttt{shift}$ \tcp*{Coordonnées de la cellule}
|
|
|
|
|
$p_y \gets 2 * gc_y + \texttt{shift}$\;
|
|
|
|
|
$i_x \gets p_x + 1$\;
|
|
|
|
|
$i_y \gets p_y + 1$\;
|
|
|
|
|
|
|
|
|
|
Nouveau tableau local de 2×2 cellules: $m[2][2]$\;
|
|
|
|
|
$m[0][1] \gets \texttt{cellSpace}[N*iy+px]$\;
|
|
|
|
|
$m[1][1] \gets \texttt{cellSpace}[N*iy+ix]$\;
|
|
|
|
|
$m[0][0] \gets \texttt{cellSpace}[N*py+px]$\;
|
|
|
|
|
$m[1][0] \gets \texttt{cellSpace}[N*py+ix]$\;
|
|
|
|
|
|
|
|
|
|
Nouvelle cellule locale: $n$\;
|
|
|
|
|
$n[1] \gets \Evol(m[a3],$\tcp*[f]{Cellule courante $A$}\\
|
|
|
|
|
$\qquad m[a1],m[a2],m[b1],m[b4],m[c1],m[d2],m[d1],m[a4])$
|
|
|
|
|
\;
|
|
|
|
|
|
|
|
|
|
$n[2] \gets \Evol(m[b4],$\tcp*[f]{Cellule courante $B$}\\
|
|
|
|
|
$\qquad m[a2],m[b1],m[b2],m[b3],m[c2],m[c1],m[d2],m[a3])$
|
|
|
|
|
\;
|
|
|
|
|
|
|
|
|
|
$n[3] \gets \Evol(m[c1],$\tcp*[f]{Cellule courante $C$}\\
|
|
|
|
|
$\qquad m[a3],m[b4],m[b3],m[c2],m[c3],m[c4],m[d3],m[d2])$
|
|
|
|
|
\;
|
|
|
|
|
|
|
|
|
|
$n[4] \gets \Evol(m[d2],$\tcp*[f]{Cellule courante $D$}\\
|
|
|
|
|
$\qquad m[a4],m[a3],m[b4],m[c1],m[c4],m[d3],m[d4],m[d1])$
|
|
|
|
|
\;
|
|
|
|
|
|
|
|
|
|
$\CellSpace[N*iy+px] \gets n$\;
|
|
|
|
|
$\CellSpace[N*iy+ix] \gets n$\;
|
|
|
|
|
$\CellSpace[N*py+px] \gets n$\;
|
|
|
|
|
$\CellSpace[N*py+ix] \gets n$\;
|
|
|
|
|
\caption{\ppm}
|
|
|
|
|
\end{algorithm}
|
|
|
|
|
|
|
|
|
|
La cellule localement créée $n$ est au cœur du fonctionnement de \ppm.
|
|
|
|
|
Il pourrait paraître en premier lieu étrange qu'elle soit recopiée à
|
|
|
|
|
l'identique dans les quatre cellules de \ç|cellSpace| constituant l'unique
|
|
|
|
|
cellule de Margolus en cours de mise à jour. Néanmoins, en s'aidant de la
|
|
|
|
|
\textsc{Fig.}~\ref{fig:margolus-grid} et en prenant en compte que le prochain
|
|
|
|
|
décalage de la grille de Margolus se fait sur une cellule en diagonale, une
|
|
|
|
|
symétrie apparaît.
|
|
|
|
|
|
|
|
|
|
La création d'un tableau local $m$ de $2 \times 2$ est en revanche moins
|
|
|
|
|
importante, cependant elle reste utile pour deux raisons: elle améliore sa
|
|
|
|
|
lisibilité de l'algorithme et l'utilisation de variables locales en général nous
|
|
|
|
|
permet de limiter le nombre d'accès à la mémoire globale en faisant un usage
|
|
|
|
|
plus intensif de la mémoire privée (voir le paragraphe Architecture \opencl
|
|
|
|
|
page~\pageref{sec:archi-cl}).
|
|
|
|
|
|
|
|
|
|
L'algorithme \ppm travaille sur un bloc et, dans le voisinage de Margolus,
|
|
|
|
|
chaque bloc est indépendant, ainsi il n'y a pas de problème de concurrence ni à
|
|
|
|
|
l'accès au données ni à l'écriture. Chaque cellule embarque un quart de son
|
|
|
|
|
voisinage et comme un bloc est constitué de quatre cellules, ce bloc contient
|
|
|
|
|
toutes les informations nécessaires pour effectuer une mise à jour localement.
|
|
|
|
|
Ainsi, alors que les algorithmes usuels de simulation d'automates cellulaires
|
|
|
|
|
utilisent deux copies de la configuration actuelle pour éviter les collisions de
|
|
|
|
|
lecture, \ppm n'en a pas besoin.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
% #IloveFloatBarrier
|
|
|
|
|
\FloatBarrier
|
|
|
|
|
\section{Implémentation de \tb{}}\label{sec:implementation}
|
|
|
|
|
Dans cette section nous décrivons les trois modèles (appelés moteurs) qui
|
|
|
|
|
gouvernent le fonctionnement du simulateur: le moteur chimique, le moteur
|
|
|
|
|
physique et le moteur de décision.
|
|
|
|
|
|
|
|
|
|
\subsection{Moteur chimique: réaction et diffusion}
|
|
|
|
|
Dans cette section nous présentons la fonction de transition de l'automate
|
|
|
|
|
cellulaire en charge de la simulation chimique du milieu dans lequel évolueront
|
|
|
|
|
les bactéries. Ce milieu a comme propriété de diffuser plusieurs morphogènes et
|
|
|
|
|
de les faire réagir. L'équation de réaction-diffusion est un modèle mathématique
|
|
|
|
|
qui permet, entre autres, de modéliser l'évolution de la concentration dans
|
|
|
|
|
le temps et dans l'espace d'espèces chimiques diffusant et réagissant entre
|
|
|
|
|
elles. Il a notamment été utilisée par A. Turing~\cite{turing_chemical_1952}
|
|
|
|
|
a qui nous empruntons le terme de \emph{morphogène} pour décrire une espèce
|
|
|
|
|
chimique dans notre automate. Exprimée pour un seul morphogène dans une
|
|
|
|
|
dimension d'espace, l'équation de réaction-diffusion est appelé l'équation de
|
|
|
|
|
Kolmogorov-Petrovsky-Piskounov (KPP)~\cite{kolmogorov_etude_1937}.
|
|
|
|
|
|
|
|
|
|
Nous partirons d'une version généralisée de l'équation KPP en deux dimensions
|
|
|
|
|
d'espace, avec un nombre $n \in \mathbb{R}_+$ de morphogènes:
|
|
|
|
|
\begin{equation}
|
|
|
|
|
\frac{\partial\orr\varphi}{\partial t} =
|
|
|
|
|
\orr{\text{X}}(\orr\varphi) +
|
|
|
|
|
\orr{\text{D}}^{\text{T}} \cdot \left( \frac{\partial^2\orr\varphi}{\partial x^2} +
|
|
|
|
|
\frac{\partial^2\orr\varphi}{\partial y^2} \right)
|
|
|
|
|
\label{eq:reaction-diffusion-2D}
|
|
|
|
|
\end{equation}
|
|
|
|
|
L'équation~\ref{eq:reaction-diffusion-2D} donne la variation des concentrations
|
|
|
|
|
de plusieurs espèces chimiques, ou morphogènes, dénotée $\orr\varphi =
|
|
|
|
|
(\varphi_1,\ldots,\varphi_n)$, au cours du temps et dans un espace à deux
|
|
|
|
|
dimensions où $\orr{\text{D}}^{\text{T}} = (\text{D}_1,\ldots,\text{D}_n)$ sont
|
|
|
|
|
les coefficients de diffusion et $\orr{\text{X}}^{\text{T}} =
|
|
|
|
|
(\text{X}_2,\ldots,\text{X}_n)$ est un champ de vecteur décrivant la cinétique
|
|
|
|
|
locale du système, autrement dit les réactions entre morphogènes.
|
|
|
|
|
|
|
|
|
|
\paragraph{Discrétisation}
|
|
|
|
|
Lors d'une simulation numérique, le temps et l'espace sont discrétisés et il
|
|
|
|
|
existe différentes méthodes pour approcher par des méthodes discrètes la
|
|
|
|
|
solution de l'équation~\ref{eq:reaction-diffusion-2D}. L'implémentation actuelle
|
|
|
|
|
du simulateur utilise la méthode d'Euler, la méthode d'intégration numérique la
|
|
|
|
|
plus simple:
|
|
|
|
|
\begin{align}\label{eq:num-int}
|
|
|
|
|
\displaystyle
|
|
|
|
|
\varphi^{t + \Delta t}_{k,i,j} &= \Delta t\,\text{X}_1(\varphi^t_{1,i,j}, \ldots, \varphi^t_{k,i,j})
|
|
|
|
|
+ \frac{\text{D}_k\Delta t}{(\Delta x)^2}
|
|
|
|
|
(\varphi^t_{k,i-1,j} + \varphi^t_{k,i+1,j} + \varphi^t_{k,i,j-1} + \varphi^t_{k,i,j+1}
|
|
|
|
|
- 4\varphi^t_{k,i,j})
|
|
|
|
|
\end{align}
|
|
|
|
|
où les indices $(i,j)$ dénotent la position sur une grille carrée en 2D.
|
|
|
|
|
Dans~\cite{dilao_validation_1998}, les auteurs fournissent une classe
|
|
|
|
|
de méthodes pour l'intégration numérique d'équations de diffusion et de
|
|
|
|
|
réaction-diffusion approchant la solution exacte de l'équation de diffusion
|
|
|
|
|
continue. En l'absence d'une validation plus poussée de notre outil, nous ne
|
|
|
|
|
pouvons pas encore nous prononcer sur l'impact de l'erreur introduite par la
|
|
|
|
|
discrétisation sur automate. Cependant, d'un point de vue qualitatif, le moteur
|
|
|
|
|
chimique s'est suffisamment bien comporté pour les quelques tests que nous avons
|
|
|
|
|
menés. En choisissant un $\Delta t$ suffisamment petit, en l'occurrence $\Delta
|
|
|
|
|
t = \num{0.01}$, nous avons pu reproduire des réactions chimiques classiques,
|
|
|
|
|
dont une réaction BZ (voir section~\ref{sec:bz}).
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
\paragraph{Fonction de transition}
|
|
|
|
|
\newcommand{\RTable}{\ensuremath{\mathit{RTable}}}
|
|
|
|
|
\newcommand{\RRate}{\ensuremath{\mathit{RRate}}}
|
|
|
|
|
Chaque cellule de l'automate a pour état la concentration de chacun des $n$
|
|
|
|
|
morphogènes de la simulation:
|
|
|
|
|
\[
|
|
|
|
|
(conc_1,conc_2,\ldots,conc_n)
|
|
|
|
|
\]
|
|
|
|
|
Une table des réactions $\RTable[i][j]$ est définie comme un tableau en deux
|
|
|
|
|
dimensions avec selon $i$ les $n$ morphogènes et selon $j$ les $r$ réactions.
|
|
|
|
|
Une liste des taux de réaction $\RRate[j]$ donne le coefficient de vitesse pour
|
|
|
|
|
la réaction $j$. Ces deux valeurs sont définies avant la simulation et sont donc
|
|
|
|
|
accessibles à la fonction de transition locale du moteur chimique. Par exemple,
|
|
|
|
|
dans le cas d'une simulation à trois morphogènes $a,b,c$ où deux réactions $r,s$
|
|
|
|
|
sont possibles
|
|
|
|
|
\[
|
|
|
|
|
\RTable = \left[
|
|
|
|
|
\begin{array}{rrr}
|
|
|
|
|
-1 & -2 & 2 \\
|
|
|
|
|
0 & 2 & -1
|
|
|
|
|
\end{array} \right]
|
|
|
|
|
\qquad
|
|
|
|
|
\RRate = (\alpha, \beta)
|
|
|
|
|
\]
|
|
|
|
|
désigne les réactions
|
|
|
|
|
\[
|
|
|
|
|
a + 2b \xrightarrow{\alpha} 2c
|
|
|
|
|
\qquad\text{et}\qquad
|
|
|
|
|
c \xrightarrow{\beta} 2b
|
|
|
|
|
\]
|
|
|
|
|
|
|
|
|
|
\begin{algorithm}
|
|
|
|
|
\SetKwData{Evol}{evol}
|
|
|
|
|
\SetKw{KwFrom}{from}
|
|
|
|
|
\SetKw{And}{and}
|
|
|
|
|
\SetKwData{NBPC}{$\mathit{nbpc}$}
|
|
|
|
|
\SetKwProg{Fn}{Fonction}{ as}
|
|
|
|
|
|
|
|
|
|
\Fn{\Evol(c: cell, $n_1$: cell, $\ldots$, $n_8$: cell): cell}{
|
|
|
|
|
\For(\tcp*[f]{Diffusion de chacun des morphogènes}){$i$ \KwFrom $0$ \KwTo
|
|
|
|
|
$n-1$}{%
|
|
|
|
|
$ c'[i] \gets c[i] + \Delta t * D[i] * \frac{1}{(\Delta x)^2} * ( n_2[i] +
|
|
|
|
|
n_4[i] + n_6[i] + n_8[i] - 4 c[i] )$\;%
|
|
|
|
|
\For(\tcp*[f]{Résultat des réactions entre morphogènes}){$j$ \KwFrom $0$
|
|
|
|
|
\KwTo $r-1$}{ $c'[i] \gets c'[i] + \Delta t * \RTable[i][j] * \RRate[j]$\;
|
|
|
|
|
} } \Return{$c'$}\; }
|
|
|
|
|
\caption{Fonction de transition locale du moteur chimique}
|
|
|
|
|
\end{algorithm}
|
|
|
|
|
|
|
|
|
|
Dans le cas de la diffusion sans réaction, la diffusion sur
|
|
|
|
|
automate à bloc à voisinage de Margolus a été traité dans la
|
|
|
|
|
littérature~\cite{medvedev_multi-particle_2010} et montre que le processus
|
|
|
|
|
de diffusion est exactement simulé par un automate cellulaire booléen
|
|
|
|
|
bloc synchrone sur voisinage de Margolus.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
\subsection{Moteur physique: collisions}
|
|
|
|
|
Dans cette section, nous présentons la construction de la fonction de transition
|
|
|
|
|
de l'automate cellulaire en charge de la simulation physique des bactéries. Le
|
|
|
|
|
moteur physique représente certains aspects de la mécanique du solide, notamment
|
|
|
|
|
les translations sur le plan, la rotation et la collision entre objets. Nous
|
|
|
|
|
utilisons un modèle de mécanique newtonien avec des simplifications spécifiques
|
|
|
|
|
à l'échelle à laquelle les bactéries évoluent. Le modèle suivant est décrit dans
|
|
|
|
|
un plan vectoriel en deux dimensions.
|
|
|
|
|
|
|
|
|
|
\paragraph{Modèle physique au repos}
|
|
|
|
|
Une bactérie est modélisée par une masse $m$, un centre de masse $p =
|
|
|
|
|
(p_x,p_y)$, une longueur $l$ et un rayon $r$ donnant son épaisseur (voir
|
|
|
|
|
Fig.~\ref{fig:ecoli} droite). Son orientation est représentée de manière
|
|
|
|
|
équivalente, soit par un angle $t$, soit par un vecteur directeur $d =
|
|
|
|
|
(d_x,d_y)$ en prenant $d_x = \mathit{cos}(t)$ et $d_y = \mathit{sin}(t)$. La
|
|
|
|
|
longueur totale d'une bactérie est notée $L$ et sa surface $S$.
|
|
|
|
|
Nous ajoutons deux points $f=(f_x,f_y)$ et $b=(b_x,b_y)$ représentant respectivement l'avant et
|
|
|
|
|
l'arrière de la bactérie
|
|
|
|
|
\begin{align*}
|
|
|
|
|
f_x &= p_x + l \times \mathit{cos}(t) & b_x &= p_x - l \times \mathit{cos}(t)\\
|
|
|
|
|
f_y &= p_y + l \times \mathit{sin}(t) & b_y &= p_y - l \times \mathit{sin}(t)
|
|
|
|
|
\end{align*}
|
|
|
|
|
%
|
|
|
|
|
% Forces
|
|
|
|
|
Du point de vue cinétique, une bactérie possède une vitesse de déplacement de
|
|
|
|
|
norme $v_b$ colinéaire à $\orr{d}$ et une vitesse de rotation de norme
|
|
|
|
|
$\omega_b$ autour de $p$. Elle a également un taux de croissance $g$ faisant
|
|
|
|
|
varier sa masse, sa longueur et sa largeur.
|
|
|
|
|
|
|
|
|
|
La quantité de mouvement, aussi appelé moment linéaire, d'une bactérie est
|
|
|
|
|
$\orr{p} = m \orr{v}_b$ et son moment angulaire, aussi appelé moment cinétique,
|
|
|
|
|
autour de son centre d'inertie est $\orr{L} = I \orr{\omega}_b$ où le moment
|
|
|
|
|
d'inertie $I$ est similaire au moment d'inertie d'une tige de densité de masse
|
|
|
|
|
uniforme, tournant autour de son centre de masse, de la même longueur que la
|
|
|
|
|
bactérie, à savoir:
|
|
|
|
|
\[
|
|
|
|
|
I = \displaystyle\frac{1}{12} \times m(2r+2l)^2 =
|
|
|
|
|
\displaystyle\frac{1}{6} \times m(r+l)^2
|
|
|
|
|
\]
|
|
|
|
|
|
|
|
|
|
Du point de vue dynamique, nous considérons que les bactéries évoluent dans un
|
|
|
|
|
milieu dont la viscosité est très élevée. Au centre de masse de chaque bactérie
|
|
|
|
|
s'applique la somme des forces extérieures d'accélération linéaire $F$ et
|
|
|
|
|
accélération angulaire $T$ transmises lors de collisions avec d'autres objets.
|
|
|
|
|
|
|
|
|
|
% Calcul d'une collision (schéma)
|
|
|
|
|
\begin{figure}[ht]
|
|
|
|
|
\centering
|
|
|
|
|
\includegraphics[page=2,width=.49\textwidth]{figures/collision}\hfill
|
|
|
|
|
\includegraphics[page=3,width=.49\textwidth]{figures/collision}
|
|
|
|
|
\caption{La détection d'une collision a lieu lorsque l'un des pôles d'une
|
|
|
|
|
bactérie est proche du corps d'une autre bactérie (à gauche). Quelques
|
|
|
|
|
vecteurs utilisés dans le calcul de l'impulsion (à droite)}
|
|
|
|
|
\label{fig:collision}
|
|
|
|
|
\end{figure}
|
|
|
|
|
|
|
|
|
|
% Qu'est-ce-qu'une collision
|
|
|
|
|
\paragraph{Collision entre deux bactéries}
|
|
|
|
|
En général, déterminer si deux objets sont en collision, c'est à dire déterminer
|
|
|
|
|
si l'intersection des deux objets est non vide, n'est pas trivial, et ce pour
|
|
|
|
|
deux raisons: les objets ont une forme potentiellement complexe et il peut
|
|
|
|
|
y avoir un grand nombre d'objets. Pour les ceux qui ont une forme complexe,
|
|
|
|
|
un objet de forme proche et plus simple, comme un disque ou un rectangle,
|
|
|
|
|
appelé \emph{bounding box}\footnote{différent de la bounding box que nous avons
|
|
|
|
|
présenté avant, celle-ci est autour d'une unique bactérie, notre bounding
|
|
|
|
|
box est autour d'une population de bactérie. Leurs fonctions sont toutefois
|
|
|
|
|
similaires.} est utilisée pour faciliter le calcul d'intersection. Dans le cas
|
|
|
|
|
où un grand nombre d'objet peuvent entrer en collision, l'espace est divisé en
|
|
|
|
|
petites sections afin que le test de collision n'ait lieu que pour un faible
|
|
|
|
|
nombre d'objets.
|
|
|
|
|
|
|
|
|
|
% Collision de deux bactéries
|
|
|
|
|
Commençons par déterminer la fonction de collision pour deux bactéries. Cette
|
|
|
|
|
fonction prend en entrée deux bactéries et retourne vrai s'il y a collision,
|
|
|
|
|
avec la distance de collision la plus courte, les vecteurs de collision, les
|
|
|
|
|
positions des collisions, ou faux s'il n'y a pas collision. Chaque bactérie est
|
|
|
|
|
déterminée par un quadruplet comprenant le vecteur position du centre de masse,
|
|
|
|
|
le vecteur directeur (unitaire), la longueur et le rayon respectivement $b_1 =
|
|
|
|
|
(\orr{p_1},\orr{d_1},l_1,r_1)$ et $b_2 = (\orr{p_2},\orr{d_2},l_2,r_2)$. À
|
|
|
|
|
partir de ces informations, nous pouvons obtenir les coordonnées des extrémités
|
|
|
|
|
\begin{align*}
|
|
|
|
|
\orr{f_1} &= \orr{p_1} + l_1 \cdot \orr{d_1} & \orr{f_2} &= \orr{p_2} + l_2 \cdot \orr{d_2}\\
|
|
|
|
|
\orr{b_1} &= \orr{p_1} - l_1 \cdot \orr{d_1} & \orr{b_2} &= \orr{p_2} - l_2 \cdot \orr{d_2}
|
|
|
|
|
\end{align*}
|
|
|
|
|
Le critère de collision est simple. Grâce à la forme de la bactérie, il nous
|
|
|
|
|
faut juste vérifier qu'aucun point du segment $[f_1,b_1]$ n'est à une distance
|
|
|
|
|
inférieure ou égale à $d_\mathrm{min} = r_1+r_2$ d'un point du segment
|
|
|
|
|
$[f_2,b_2]$. Aussi, nous commencerons par construire les projections
|
|
|
|
|
orthogonales restreintes à un segment des pôles $\orr{f}^j_i, \orr{b}^j_i$ d'une
|
|
|
|
|
bactérie $i$ sur le corps d'une bactérie $j$.
|
|
|
|
|
\begin{align*}
|
|
|
|
|
\orr{f}^2_1 &= \orr{p_2} +
|
|
|
|
|
\big[ \orr{d_2} + (\orr{f_1} - \orr{p_2}) \big]^{l_2}_{-l_2}
|
|
|
|
|
\cdot{} \orr{d_2} &
|
|
|
|
|
\orr{f}^1_2 &= \orr{p_1} +
|
|
|
|
|
\big[ \orr{d_1} + (\orr{f_2} - \orr{p_1}) \big]^{l_1}_{-l_1}
|
|
|
|
|
\cdot{} \orr{d_1} \\
|
|
|
|
|
\orr{b}^2_1 &= \orr{p_2} +
|
|
|
|
|
\big[ \orr{d_2} + (\orr{b_1} - \orr{p_2}) \big]^{l_2}_{-l_2}
|
|
|
|
|
\cdot{} \orr{d_2} &
|
|
|
|
|
\orr{b}^1_2 &= \orr{p_1} +
|
|
|
|
|
\big[ \orr{d_1} + (\orr{b_2} - \orr{p_1}) \big]^{l_1}_{-l_1}
|
|
|
|
|
\cdot{} \orr{d_1}
|
|
|
|
|
\end{align*}
|
|
|
|
|
Restreindre la projection a un segment reflète le fait qu'une bactérie a une
|
|
|
|
|
longueur \emph{limitée}. Si on omet cette restriction, on obtient les
|
|
|
|
|
projections de la \textsc{Fig.}~\ref{fig:collision}, où la distance la plus courte
|
|
|
|
|
n'est pas nécessairement indicatrice d'une collision. Il nous reste à obtenir
|
|
|
|
|
les 4 vecteurs de collisions
|
|
|
|
|
\begin{align*}
|
|
|
|
|
\orr{n}_{f_{12}} &= \orr{f}^2_1 - \orr{f}_1 & \orr{n}_{f_{21}} &= \orr{f}^1_2 - \orr{f}_2 \\
|
|
|
|
|
\orr{n}_{b_{12}} &= \orr{b}^2_1 - \orr{b}_1 & \orr{n}_{b_{21}} &= \orr{b}^1_2 - \orr{b}_2
|
|
|
|
|
\end{align*}
|
|
|
|
|
dont les normes nous donnent bien la distance entre les corps des bactéries. Si
|
|
|
|
|
$\| \orr{n}_{f_{12}} \| \le d_\mathrm{min}$ ou $\| \orr{n}_{b_{12}} \| \le
|
|
|
|
|
d_\mathrm{min}$ ou $\| \orr{n}_{f_{21}} \| \le d_\mathrm{min}$ ou $\|
|
|
|
|
|
\orr{n}_{b_{21}} \| \le d_\mathrm{min}$, alors il existe au moins une collision
|
|
|
|
|
entre les deux bactéries. Le point d'impact se trouve sur le segment entre
|
|
|
|
|
le pôle de la première bactérie et son projeté sur le corps de la seconde.
|
|
|
|
|
Supposons que la collision ait lieu lorsque les corps des deux bactéries sont au
|
|
|
|
|
contact, alors les points de collisions peuvent être les suivants
|
|
|
|
|
\begin{align*}
|
|
|
|
|
\orr{c}_{f_{12}} &= \displaystyle\frac{r_1 \cdot\orr{f}_1 + r_2 \cdot\orr{f}^2_1}{r_1 + r_2} & \orr{c}_{f_{21}} &= \displaystyle\frac{r_2 \cdot\orr{f}_2 + r_1 \cdot\orr{f}^1_2}{r_1 + r_2} \\
|
|
|
|
|
\orr{c}_{b_{12}} &= \displaystyle\frac{r_1 \cdot\orr{b}_1 + r_2 \cdot\orr{b}^2_1}{r_1 + r_2} & \orr{c}_{b_{21}} &= \displaystyle\frac{r_2 \cdot\orr{b}_2 + r_1 \cdot\orr{b}^1_2}{r_1 + r_2}
|
|
|
|
|
\end{align*}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
\paragraph{Modèle physique post-collision}
|
|
|
|
|
Pour calculer le résultat des échanges de forces lors d'un impact entre une
|
|
|
|
|
bactérie $i$ et une bactérie $j$, il est nécessaire de déterminer le type
|
|
|
|
|
d'impact que nous souhaitons représenter. Dans le cas d'un impact parfaitement
|
|
|
|
|
élastique, toute l'énergie transmise à la bactérie est restituée et l'énergie
|
|
|
|
|
cinétique du système est conservée. Dans le cas d'un impact inélastique, une
|
|
|
|
|
partie de l'énergie est dissipée et seule une partie de l'énergie totale est
|
|
|
|
|
restituée. En une dimension, les vitesses post-collision de deux objets $a$ et
|
|
|
|
|
$b$ sont données par les deux équations suivantes
|
|
|
|
|
\[
|
|
|
|
|
v_a = \displaystyle\frac{Cr\ m_b (u_b - u_a) + m_a u_a + m_b u_b}{m_a + m_b}
|
|
|
|
|
\qquad
|
|
|
|
|
v_b = \displaystyle\frac{Cr\ m_a (u_a - u_b) + m_a u_a + m_b u_b}{m_a + m_b}
|
|
|
|
|
\]
|
|
|
|
|
où
|
|
|
|
|
\begin{itemize}
|
|
|
|
|
\item $Cr \in [0,1]$ est le \emph{coefficient de restitution}, $0$ pour une
|
|
|
|
|
collision parfaitement inélastique et $1$ pour une collision parfaitement
|
|
|
|
|
élastique;
|
|
|
|
|
\item $u_a, u_b$ sont les vitesses avant collision des objets $a, b$
|
|
|
|
|
respectivement;
|
|
|
|
|
\item $m_a, m_b$ sont les masses des objets $a, b$ respectivement.
|
|
|
|
|
\end{itemize}
|
|
|
|
|
|
|
|
|
|
Dans le cas d'une collision en 2D, nous pourrions appliquer ces deux équations
|
|
|
|
|
sur chacune des deux composantes des vecteurs vitesse, mais il nous manquerait
|
|
|
|
|
les informations sur le moment angulaire de chaque bactérie. Nous utilisons un
|
|
|
|
|
modèle un peu différent, ajusté à la collision de corps en 2D dont voici la
|
|
|
|
|
description.
|
|
|
|
|
|
|
|
|
|
\noindent
|
|
|
|
|
Les vecteurs vitesse \emph{au point de collision} pré-collision sont
|
|
|
|
|
\[
|
|
|
|
|
\orr{v}_{ac1} = \orr{v}_1 + \orr{\omega}_1 \wedge \orr{r}_1
|
|
|
|
|
\qquad
|
|
|
|
|
\orr{v}_{ac2} = \orr{v}_2 + \orr{\omega}_2 \wedge \orr{r}_2
|
|
|
|
|
\]
|
|
|
|
|
Notre objectif est de trouver les nouvelles valeurs $\orr{v}'_i$ et
|
|
|
|
|
$\orr{\omega}'_i$ des deux bactéries après la collision. Écrivons d'abord les
|
|
|
|
|
vecteurs vitesse au point de collision post-collision
|
|
|
|
|
\[
|
|
|
|
|
\orr{v}_{pc1} = \orr{v}'_1 + \orr{\omega}'_1 \wedge \orr{r}_1
|
|
|
|
|
\qquad
|
|
|
|
|
\orr{v}_{pc2} = \orr{v}'_2 + \orr{\omega}'_2 \wedge \orr{r}_2
|
|
|
|
|
\]
|
|
|
|
|
Les vitesses relatives au point d'impact $\orr{v}_{ac12}, \orr{v}_{pc12}$
|
|
|
|
|
pré-collision et post-collision respectivement sont données par
|
|
|
|
|
\[
|
|
|
|
|
\orr{v}_{ac12} = \orr{v}_{ac1} - \orr{v}_{ac2}
|
|
|
|
|
\qquad
|
|
|
|
|
\orr{v}_{pc12} = \orr{v}_{pc1} - \orr{v}_{pc2}
|
|
|
|
|
\]
|
|
|
|
|
Dans notre modèle, nous faisons l'hypothèse que la vitesse à laquelle les deux
|
|
|
|
|
bactéries se séparent est proportionnelle à la vitesse à laquelle les deux
|
|
|
|
|
bactéries se rapprochent.
|
|
|
|
|
\begin{equation*}
|
|
|
|
|
\orr{v}_{pc12} \cdot{} \orr{n} = -\mathit{Cr}\ \orr{v}_{ac12} \cdot{} \orr{n}
|
|
|
|
|
\end{equation*}
|
|
|
|
|
Nous retrouvons ici le coefficient de restitution $\mathit{Cr} \in [0,1]$ et
|
|
|
|
|
\orr{n} est le \emph{vecteur normal unitaire} ($\|\orr{n}\| = 1$) au point de
|
|
|
|
|
collision pointant vers l'extérieur de la seconde bactérie.
|
|
|
|
|
|
|
|
|
|
La collision en elle-même est modélisée par une \emph{impulsion}. Pour une
|
|
|
|
|
bactérie quelconque, rencontrer un obstacle équivaut à se voir appliquer une
|
|
|
|
|
force au point de collision, dont la durée d'application est suffisamment courte
|
|
|
|
|
pour qu'elle soit considérée \emph{constante}. Cette application s'effectue
|
|
|
|
|
\emph{sans frottements} ce qui implique qu'elle soit dirigée selon \orr{n}, la
|
|
|
|
|
normale de collision. Une impulsion $\orr{J} = j \cdot \orr{n}$ est
|
|
|
|
|
l'intégration de cette force sur $\Delta_t = t' - t$ le temps d'application
|
|
|
|
|
\[
|
|
|
|
|
\orr{J} = \int^{t'}_t \orr{F} dt
|
|
|
|
|
\]
|
|
|
|
|
Comme d'après la seconde loi de Newton, une force est la dérivée temporelle
|
|
|
|
|
d'une quantité de mouvement et que l'on suppose $\Delta_t$ suffisamment court
|
|
|
|
|
pour que \orr{F} ne varie pas, une impulsion est une variation entre les
|
|
|
|
|
quantités de mouvement entre les temps $t$ et $t'$ et a donc la dimension d'une
|
|
|
|
|
quantité de mouvement. La collision modifie les vitesses des deux bactéries
|
|
|
|
|
selon \orr{n} avec l'intensité $j$. En divisant le tout par la masse, on
|
|
|
|
|
retrouve la dimension d'une vitesse. L'impulsion s'applique selon \orr{n} pour
|
|
|
|
|
la première bactérie et selon $-\orr{n}$ pour la seconde.
|
|
|
|
|
\begin{equation*}
|
|
|
|
|
\orr{v}'_{1} = \orr{v}_{ac1} + j \orr{n} / m_1
|
|
|
|
|
\qquad
|
|
|
|
|
\orr{v}'_{2} = \orr{v}_{ac2} - j \orr{n} / m_2
|
|
|
|
|
\end{equation*}
|
|
|
|
|
Les vitesses angulaires sont aussi modifiées de manière symétrique en prenant en
|
|
|
|
|
compte la distance au centre de rotation des bactéries — si cette distance est
|
|
|
|
|
nulle, la vitesse angulaire est nulle — et en divisant cette fois
|
|
|
|
|
par le moment d'inertie de chacune des bactéries
|
|
|
|
|
\begin{equation*}
|
|
|
|
|
\orr{\omega}'_{1} = \orr{\omega}_{ac1} + (\orr{r}_1 \wedge j \orr{n}) / I_1
|
|
|
|
|
\qquad
|
|
|
|
|
\orr{\omega}'_{2} = \orr{\omega}_{ac2} - (\orr{r}_2 \wedge j \orr{n}) / I_2
|
|
|
|
|
\end{equation*}
|
|
|
|
|
|
|
|
|
|
\noindent
|
|
|
|
|
Après résolution des équations précédentes pour $j$, on obtient
|
|
|
|
|
\begin{equation*}
|
|
|
|
|
j = \displaystyle\frac{-(1 + Cr)\ \orr{v}_{ac12} \cdot{} \orr{n}} { 1/m_1 +
|
|
|
|
|
1/m_2 + (\orr{r}_1 \wedge \orr{n})^2 / I_1 + (\orr{r}_2 \wedge \orr{n})^2
|
|
|
|
|
/ I_2}
|
|
|
|
|
\end{equation*}
|
|
|
|
|
et il est possible de déterminer le quadruplet $(\orr{v}'_1, \orr{\omega}'_1,
|
|
|
|
|
\orr{v}'_2, \orr{\omega}'_2)$ post-collision. Plus généralement, l'impulsion
|
|
|
|
|
résultant d'une collision entre une bactérie $a$ et une bactérie $b$ se notera
|
|
|
|
|
$j_{ab}$.
|
|
|
|
|
|
|
|
|
|
Dans le cas de plusieurs collisions simultanées de la bactérie $1$ avec les
|
|
|
|
|
bactéries $(2,\ldots,N)$, dans la mesure ou chaque bactérie est indépendante,
|
|
|
|
|
les vitesses linéaires et angulaires post-collision de la bactérie $1$ sont
|
|
|
|
|
\begin{equation*}
|
|
|
|
|
\orr{v}'_1 = \orr{v}_{ac1} + \sum^N_{k=2} \frac{j_{1k}\orr{n}}{m_1}
|
|
|
|
|
\qquad
|
|
|
|
|
\orr{\omega}'_1 = \orr{\omega}_{ac1} + \sum^N_{k=2} \frac{\orr{r}_1 \wedge j_{1k}\orr{n}}{I_1}
|
|
|
|
|
\end{equation*}
|
|
|
|
|
l'impulsion étant le seul terme dépendant de la collision, il est différent pour
|
|
|
|
|
chacune des collisions.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
% Les places sont limitées
|
|
|
|
|
\paragraph{Fonction de transition locale}
|
|
|
|
|
La méthode naïve pour détecter les collisions entre un nombre arbitraire de
|
|
|
|
|
bactéries est d'effectuer un test de collision pour chaque paire de bactéries,
|
|
|
|
|
c'est à dire $\binom{n}{2}$ combinaisons, ce qui n'est pas atteignable pour une
|
|
|
|
|
population de l'ordre de \num{E4} individus avec les contraintes que nous nous
|
|
|
|
|
sommes fixées. Pour résoudre ce problème, nous utiliserons le fait que, comme
|
|
|
|
|
nous effectuons une simulation physique, nous partons du principe que tout ce
|
|
|
|
|
qui cause un changement d'état du système a un \emph{effet local} et se
|
|
|
|
|
\emph{propage} de proche en proche. C'est bien le chemin que nous avons emprunté
|
|
|
|
|
en choisissant les automates cellulaires comme support de la simulation. Nous
|
|
|
|
|
devons déterminer comment effectuer notre recherche de collision localement pour
|
|
|
|
|
qu'elle soit correcte à l'échelle de la population. Nous allons donc restreindre
|
|
|
|
|
la recherche de collision à un petit groupe de bactéries, contenu dans une
|
|
|
|
|
cellule de l'automate. Le nombre de bactéries par cellule $\mathit{nbpc}$ dépend
|
|
|
|
|
de plusieurs paramètres:
|
|
|
|
|
\begin{itemize}
|
|
|
|
|
\item l'aire minimum d'une bactérie $S_\mathit{min}$ (dépendant de
|
|
|
|
|
$l_{\mathit{min}}$ et $r_{\mathit{min}}$);
|
|
|
|
|
\item l'aire d'une cellule $C_p$ de diffusion du moteur physique.
|
|
|
|
|
\end{itemize}
|
|
|
|
|
Nous donnons une dimension physique concrète aux cellules car nous allons devoir
|
|
|
|
|
superposer les deux automates cellulaires des moteurs physique et chimiques pour
|
|
|
|
|
savoir où les bactéries déposent et consomment des morphogènes. De plus, nous
|
|
|
|
|
gardons un rapport entier entre les aires des cellules $C_p$ du moteur physique
|
|
|
|
|
et $C_c$ du moteur chimique afin que les deux grilles soient toujours alignées.
|
|
|
|
|
\[
|
|
|
|
|
\mathit{nbpc} = \left\lfloor
|
|
|
|
|
\displaystyle\frac{C_p}{S_\mathit{min}}
|
|
|
|
|
\right\rfloor
|
|
|
|
|
\qquad \text{et} \qquad
|
|
|
|
|
C_p = n_r \times C_c
|
|
|
|
|
\]
|
|
|
|
|
Le rapport entre $C_p$ et $C_c$, noté $n_r$, est un entier.
|
|
|
|
|
|
|
|
|
|
L'espace ainsi segmenté en cellules est une \emph{configuration}. Afin que notre
|
|
|
|
|
automate cellulaire soit complet, il nous reste à spécifier la fonction de
|
|
|
|
|
transition locale à utiliser pour mettre à jour cette configuration.
|
|
|
|
|
|
|
|
|
|
\begin{algorithm}
|
|
|
|
|
\SetKwData{Evol}{evol}
|
|
|
|
|
\SetKwData{GCol}{getCollisions}
|
|
|
|
|
\SetKwData{UpBact}{updateBacteria}
|
|
|
|
|
\SetKw{KwFrom}{from}
|
|
|
|
|
\SetKw{And}{and}
|
|
|
|
|
\SetKwData{NBPC}{$\mathit{nbpc}$}
|
|
|
|
|
\SetKwProg{Fn}{Fonction}{ as}
|
|
|
|
|
|
|
|
|
|
\Fn{\Evol(c: cell, $n_1$: cell, $\ldots$, $n_8$: cell): cell}{
|
|
|
|
|
\For{$i$ \KwFrom $0$ \KwTo $\NBPC - 1$}{
|
|
|
|
|
\tcp{Calcul de collision}
|
|
|
|
|
$v \gets 0$,
|
|
|
|
|
$\omega \gets 0$\;
|
|
|
|
|
\ForAll{$c_n \in \{c,n_1,\ldots,n_8\}$}{
|
|
|
|
|
\For{$j$ \KwFrom $0$ \KwTo $\NBPC - 1$}{
|
|
|
|
|
\If{$c[i] \ne c_n[j]$ \And $\GCol (c[i],c_n[j],\orr{c},\orr{n},\orr{j})$}{
|
|
|
|
|
$v \gets v + \frac{\orr{j}}{c[i].m}$,
|
|
|
|
|
$\omega \gets \omega + \frac{(\orr{c} - c[i].\orr{p}) \wedge \orr{j}}{c[i].I}$\;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
\tcp{Mise à jour de position}
|
|
|
|
|
$\UpBact (v,\omega)$\;
|
|
|
|
|
}
|
|
|
|
|
\Return{$c'$}\;
|
|
|
|
|
}
|
|
|
|
|
\caption{Fonction de transition locale du moteur physique}
|
|
|
|
|
\end{algorithm}
|
|
|
|
|
|
|
|
|
|
La fonction \ç|getCollisions| effectue les calculs de collision présentés
|
|
|
|
|
ci-dessus et retourne \ç|true| si une collision est détectée et \ç|false| sinon.
|
|
|
|
|
Les variables \orr{c}, \orr{n} et \orr{j} sont passées par adresse et sont
|
|
|
|
|
définies seulement dans le cas d'un collision.
|
|
|
|
|
|
|
|
|
|
\FloatBarrier
|
|
|
|
|
\subsection{Moteur de décision: bactéries et morphogènes réunis}
|
|
|
|
|
La coordination entre moteur chimique et moteur physique est le dernier problème
|
|
|
|
|
à résoudre. En effet, pour être complet, les deux parties du simulateur doivent
|
|
|
|
|
communiquer:
|
|
|
|
|
\begin{itemize}
|
|
|
|
|
\item les bactéries peuvent \emph{lire} des valeurs des concentrations en
|
|
|
|
|
morphogène \emph{à leur position} et
|
|
|
|
|
\item les bactéries peuvent \emph{consommer} ou \emph{déposer} des
|
|
|
|
|
morphogènes à leur position.
|
|
|
|
|
\end{itemize}
|
|
|
|
|
Lire, consommer et déposer des morphogène implique que la fonction d'évolution
|
|
|
|
|
des bactéries doit avoir connaissance de la configuration de l'automate chimique
|
|
|
|
|
et doit pouvoir la modifier. Il n'est pas souhaitable que les bactéries écrivent
|
|
|
|
|
directement dans les cellules de la configuration de l'automate chimique car ces
|
|
|
|
|
valeurs dépendent du temps et sont intégrées numériquement. Une meilleure
|
|
|
|
|
solution est de faire déposer par les bactéries une contribution $\epsilon$ qui
|
|
|
|
|
sera ajoutée lors de l'intégration numérique pendant la mise à jour de
|
|
|
|
|
l'automate chimique. Nous reprenons l'équation \ref{eq:num-int} auquel nous
|
|
|
|
|
ajoutons un nouveau terme:
|
|
|
|
|
\begin{align*}
|
|
|
|
|
\displaystyle
|
|
|
|
|
\varphi^{t + \Delta t}_{k,i,j} &= \Delta t\,\text{X}_1(\varphi^t_{1,i,j}, \ldots, \varphi^t_{k,i,j})
|
|
|
|
|
+ \frac{\text{D}_k\Delta t}{(\Delta x)^2}
|
|
|
|
|
(\varphi^t_{k,i-1,j} + \varphi^t_{k,i+1,j} + \varphi^t_{k,i,j-1} + \varphi^t_{k,i,j+1}
|
|
|
|
|
- 4\varphi^t_{k,i,j}) + \Delta t\,\epsilon_{\varphi_k,i,j}
|
|
|
|
|
\end{align*}
|
|
|
|
|
|
|
|
|
|
Ensuite, les deux configurations des automates physique et chimique doivent se
|
|
|
|
|
superposer dans l'espace afin de lier la position d'une bactérie à la
|
|
|
|
|
concentration en morphogènes à cette position. À la position du centre d'une
|
|
|
|
|
bactérie $(p_x,p_y)$ correspond une cellule de la configuration de l'automate
|
|
|
|
|
cellulaire du moteur chimique
|
|
|
|
|
\begin{equation*}
|
|
|
|
|
\left(\frac{p_x}{\Delta x},\frac{p_y}{\Delta x}\right)
|
|
|
|
|
\end{equation*}
|
|
|
|
|
où $\Delta x$ est la taille du côté d'une cellule de cet automate et à condition
|
|
|
|
|
qu'à la position $(0,0)$ corresponde la cellule de coordonnées $(0,0)$.
|
|
|
|
|
|
|
|
|
|
La contrainte suivante concerne la taille des configurations. Nous avons indiqué
|
|
|
|
|
dans la section~\ref{sec:boundingbox} que les dimensions des configurations
|
|
|
|
|
variaient en fonction de leur contenu. Comme une bactérie doit toujours pouvoir
|
|
|
|
|
lire, écrire ou consommer des morphogènes, cela implique que la partie de
|
|
|
|
|
l'espace $S_c$ couvert par la configuration du moteur chimique doit inclure la
|
|
|
|
|
partie de l'espace $S_p$ couvert par la configuration du moteur physique, soit
|
|
|
|
|
$S_p \subset S_c$.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Finalement, lorsque les bactéries ont accès aux concentrations de morphogènes,
|
|
|
|
|
elles peuvent s'en servir pour modifier leur comportement ce qui est l'objet du
|
|
|
|
|
moteur de décision. Chaque bactérie a un état prédéfini en début de simulation
|
|
|
|
|
qui regroupe les différents variables normales et booléennes (dont la valeur par
|
|
|
|
|
défaut est donnée entre parenthèses) suivants
|
|
|
|
|
\begin{itemize}
|
|
|
|
|
\item Division (vrai): si vrai, la bactérie croît et se divise quand sa masse a
|
|
|
|
|
doublé;
|
|
|
|
|
\item Décès (faux): si vrai, la bactérie décide d'entrer en apoptose et
|
|
|
|
|
disparaît de la simulation;
|
|
|
|
|
\item TumbleRun (vrai): si vrai, la bactérie tourne sur elle-même, sinon la
|
|
|
|
|
bactérie se déplace selon une trajectoire rectiligne uniforme vers l'avant;
|
|
|
|
|
\item Production/Consommation du morphogène $\varphi_i$: la bactérie dépose une
|
|
|
|
|
certaine quantité de morphogènes à sa position dans l'environnement. Cette
|
|
|
|
|
quantité est déterminée par le modélisateur en début de simulation.
|
|
|
|
|
\end{itemize}
|
|
|
|
|
Les transitions entre les états sont également donnés en début de simulation
|
|
|
|
|
dans un fichier de description de simulation \sbgp.
|
|
|
|
|
|
|
|
|
|
Le fonctionnement du moteur de décision est donné par la fonction de transition
|
|
|
|
|
décrite dans l'algorithme~\ref{algo:decision}. Cette dernière est appelée sur
|
|
|
|
|
chaque cellule de la configuration de l'automate du moteur physique directement,
|
|
|
|
|
sans passer par \ppm car il n'y a pas conflit en lecture ou en écriture et
|
|
|
|
|
peut être parallélisée naïvement. Cette fonction a de plus à sa disposition
|
|
|
|
|
la configuration de l'automate du moteur chimique $\mathit{H}$ ainsi qu'une
|
|
|
|
|
configuration $\mathit{E}$ des contributions aux concentrations des morphogènes
|
|
|
|
|
de la même taille que $\mathit{H}$. Nous considérerons une simulation où il y
|
|
|
|
|
a $N$ morphogènes. Dans l'algorithme~\ref{algo:decision}, toutes les valeurs
|
|
|
|
|
précédées de \ç|init| sont issues de l'initialisation de la simulation.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
\begin{algorithm}
|
|
|
|
|
\SetKwData{Evol}{evol}
|
|
|
|
|
\SetKw{KwFrom}{from}\SetKw{KwIn}{in}\SetKw{And}{and}\SetKw{KwBreak}{break}
|
|
|
|
|
\SetKwData{NBPC}{$\mathit{nbpc}$}
|
|
|
|
|
\SetKwProg{Fn}{Fonction}{ as}
|
|
|
|
|
|
|
|
|
|
\Fn{\Evol(c: cell, H: configuration, E: configuration): cell}{
|
|
|
|
|
\For{$i$ \KwFrom $0$ \KwTo $\NBPC - 1$}{
|
|
|
|
|
\tcp{Indice de la cellule de $H$ correspondant à la bactérie courante}
|
|
|
|
|
$j \gets projection(H,(c[i].px,c[i].py))$\;
|
|
|
|
|
|
|
|
|
|
\tcp{Mise à jour de la bactérie pour chaque morphogène}
|
|
|
|
|
\For{$k$ \KwFrom $0$ \KwTo $N - 1$}{
|
|
|
|
|
E[i][k] <- E[i][k] + \ç|init.behavior.(c[i].type).EmitSignal[k].value|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
\tcp{Transition vers un nouveau type}
|
|
|
|
|
\For{$t$ \KwIn \ç|init.transisition.(c[i].type)|}{
|
|
|
|
|
\If{\ç|init.cond_transition.t|}{
|
|
|
|
|
$c[i].type \gets t$\;
|
|
|
|
|
\KwBreak\;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
\Return{$c'$}\;
|
|
|
|
|
}
|
|
|
|
|
\caption{\label{algo:decision}Fonction de transition locale du moteur de
|
|
|
|
|
décision}
|
|
|
|
|
\end{algorithm}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
\noindent
|
|
|
|
|
En prenant en compte toutes les contraintes précédentes, l'exécution d'un pas de
|
|
|
|
|
simulation s'effectue de la façon suivante:
|
|
|
|
|
\begin{enumerate}
|
|
|
|
|
\item un pas du moteur physique,
|
|
|
|
|
\item un pas du moteur chimique,
|
|
|
|
|
\item redimensionnement des configurations et
|
|
|
|
|
\item un pas du moteur de décision.
|
|
|
|
|
\end{enumerate}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
\FloatBarrier
|
|
|
|
|
\section{Mise en œuvre}\label{sec:mise-en-oeuvre}
|
|
|
|
|
Dans cette section nous présentons trois exemples de simulation avec \otb. Pour
|
|
|
|
|
chacun de ces exemple nous fournissons le rendu de l'interface graphique et
|
|
|
|
|
le fichier SBGP qui l'a engendré. Ces trois exemples mettent en évidence le
|
|
|
|
|
fonctionnement de chacun des moteurs (chimique, physique et de décision).
|
|
|
|
|
|
|
|
|
|
% Chimique BZ
|
|
|
|
|
\subsection{Une réaction de Belooussov-Jabotinski}
|
|
|
|
|
\label{sec:bz}
|
|
|
|
|
\newcommand{\gfp}{\ensuremath{\mathit{bleu}}}%
|
|
|
|
|
\newcommand{\rfp}{\ensuremath{\mathit{vert}}}%
|
|
|
|
|
Les réactions de Belooussov-Jabotinski (BZ) sont une classe de réactions
|
|
|
|
|
chimiques dans laquelle les concentrations de plusieurs réactants oscillent
|
|
|
|
|
périodiquement jusqu'à épuisement de l'un d'entre eux. Leur importance réside
|
|
|
|
|
dans le fait que l'état d'équilibre n'est pas atteint immédiatement mais après
|
|
|
|
|
une série d'oscillations pouvant prendre plusieurs minutes. Quand elle est
|
|
|
|
|
effectuée dans une boîte de Petri, il est possible d'observer des vagues de
|
|
|
|
|
réactions.
|
|
|
|
|
|
|
|
|
|
Dans le cas de notre moteur chimique, nous pouvons facilement spécifier les
|
|
|
|
|
réactions et les couleurs associés à chacun des morphogènes. Nous construisons
|
|
|
|
|
donc cette réaction avec le minimum de réactifs et de réactions nécessaires,
|
|
|
|
|
soit deux réactifs \gfp{} et \rfp{} et les trois réactions suivantes:
|
|
|
|
|
\begin{align*}
|
|
|
|
|
\gfp + \rfp &\xrightarrow{0.05} 2 \rfp\\
|
|
|
|
|
\gfp &\xrightarrow{0.05} 2 \gfp\\
|
|
|
|
|
\rfp &\xrightarrow{0.05} .\\
|
|
|
|
|
\end{align*}
|
|
|
|
|
|
|
|
|
|
\noindent
|
|
|
|
|
La configuration de la simulation décrite en \sbgp{} est la suivante
|
|
|
|
|
\begin{SBGPcode}
|
|
|
|
|
{
|
|
|
|
|
"signals" : [ ["bleu", 0.0, 1.0], ["vert", 0.0, 1.0] ],
|
|
|
|
|
"reactions" : [ [["bleu","vert"], ["vert","vert"], 0.05],
|
|
|
|
|
[["bleu"], ["bleu","bleu"], 0.05],
|
|
|
|
|
[["vert"], [], 0.05] ],
|
|
|
|
|
"type" : [],
|
|
|
|
|
"behavior" : {},
|
|
|
|
|
"transition" : [],
|
|
|
|
|
"cond_transition" : []
|
|
|
|
|
}
|
|
|
|
|
\end{SBGPcode}
|
|
|
|
|
où les quatre derniers champs sont vides car il n'y a pas de bactéries à
|
|
|
|
|
simuler. Durant la simulation, il est possible d'observer une alternance entre
|
|
|
|
|
les concentrations des deux morphogènes (en vert et en bleu) au cours du temps.
|
|
|
|
|
Comme les morphogènes diffusent, ne s'évaporent pas et que l'environnement
|
|
|
|
|
est ouvert, les concentrations locales baissent et il devient de plus en
|
|
|
|
|
plus difficile de distinguer les deux morphogènes au centre. Par contre, des
|
|
|
|
|
vagues de concentrations alternant bleu puis vert se forment à la périphérie
|
|
|
|
|
conformément aux réactions BZ effectuées en boîte de Petri.
|
|
|
|
|
|
|
|
|
|
% Réaction BZ
|
|
|
|
|
\begin{figure}[ht]
|
|
|
|
|
\centering
|
|
|
|
|
\includegraphics[width=.245\textwidth]{figures/BZ-reaction1}
|
|
|
|
|
\includegraphics[width=.245\textwidth]{figures/BZ-reaction2}
|
|
|
|
|
\includegraphics[width=.245\textwidth]{figures/BZ-reaction3}
|
|
|
|
|
\includegraphics[width=.245\textwidth]{figures/BZ-reaction4}
|
|
|
|
|
\caption{Quatre états d'une simulation de réaction BZ ordonnés en fonction du
|
|
|
|
|
temps de gauche à droite. Il est possible de noter l'alternance entre le
|
|
|
|
|
vert et le bleu au cours du temps}
|
|
|
|
|
\label{fig:reaction-BZ}
|
|
|
|
|
\end{figure}
|
|
|
|
|
|
|
|
|
|
\subsection{Sectorisation d'une population de \ecoli{}}
|
|
|
|
|
Pour la validation du moteur physique, nous avons reproduit une expérience de la
|
|
|
|
|
littérature~\cite{hallatschek_genetic_2007}. Dans cet article, les auteurs
|
|
|
|
|
étudient la ségrégation génomique à la frontière entre deux populations de
|
|
|
|
|
bactéries en croissance.
|
|
|
|
|
|
|
|
|
|
\paragraph{Protocole expérimental} Les auteurs utilisent deux souches de
|
|
|
|
|
bactéries \Ecoli{} de génotypes exactement identique, à l'exception d'une unique
|
|
|
|
|
mutation du même gène promoteur induisant
|
|
|
|
|
\begin{itemize}
|
|
|
|
|
\item la première souche à produire une protéine fluorescente cyan (CFP) et
|
|
|
|
|
\item la seconde souche à produire une protéine fluorescente jaune (YFP).
|
|
|
|
|
\end{itemize}
|
|
|
|
|
On répartit de façon homogène ces deux souches pour obtenir des cultures de
|
|
|
|
|
différentes proportions. Une gouttelette de cette culture est posée au centre
|
|
|
|
|
d'une gélose pour dénombrement dans un milieu contenant un médium de croissance
|
|
|
|
|
enrichi afin d'obtenir une croissance rapide des deux populations. Comme les
|
|
|
|
|
bactéries utilisées sont immobiles, le développement de la population s'effectue
|
|
|
|
|
aux bords. Dans le cas d'un mélange équilibré contenant 50\% de chaque souche,
|
|
|
|
|
il est possible d'observer des secteurs monochromes dans la zone d'expansion de
|
|
|
|
|
la population.
|
|
|
|
|
|
|
|
|
|
D'après les auteurs de~\cite{hallatschek_genetic_2007}, la
|
|
|
|
|
\textsc{Fig.}~\ref{fig:sectorisation} à gauche: « […] is a visible manifestation of
|
|
|
|
|
random genetic drift acting at the leading edge of a range expansion ». La
|
|
|
|
|
dérive génétique (genetic drift) est l'évolution d'une population ou d'une
|
|
|
|
|
espèce causée par des phénomènes aléatoires, impossible à prévoir. Du point de
|
|
|
|
|
vue génétique, c'est la modification de la fréquence d'un allèle, ou d'un
|
|
|
|
|
génotype, au sein d'une population, indépendamment des mutations, de la
|
|
|
|
|
sélection naturelle et des migrations.
|
|
|
|
|
|
|
|
|
|
\paragraph{Simulation avec \otb} Dans notre simulation de cette expérience, nous
|
|
|
|
|
avons utilisé deux états différents ayant le même comportement pour les deux
|
|
|
|
|
souches de bactéries afin de pouvoir colorer les deux sous populations a
|
|
|
|
|
posteriori. Voici le protocole que nous avons suivi:
|
|
|
|
|
\begin{enumerate}
|
|
|
|
|
\item nous avons initialement laissé croître une population initiale issue d'une
|
|
|
|
|
unique bactérie jusqu'à \num{1054} individus, pour obtenir une goutte de
|
|
|
|
|
l'ordre du dixième de millimètre;
|
|
|
|
|
\item nous avons marqué chaque individu par l'état $A$ avec une probabilité de
|
|
|
|
|
50\%, les autres ont été marqué par l'état $B$;
|
|
|
|
|
\item Nous avons repris la croissance de cette population jusqu'à atteindre une
|
|
|
|
|
population de \num{271958} individus (voir Fig.~\ref{fig:sectorisation}) après
|
|
|
|
|
vingt minutes de calcul sur un serveur muni d'une carte de calcul
|
|
|
|
|
Tesla\footnote{NVidia Tesla est une carte de calcul dédié munie de plusieurs
|
|
|
|
|
GPU};
|
|
|
|
|
\item nous avons fait émettre aux individus de type $A$ un morphogène de couleur
|
|
|
|
|
verte et aux individus type $B$ un morphogène de couleur rouge, afin de
|
|
|
|
|
pouvoir observer qualitativement la répartition des bactéries.
|
|
|
|
|
\end{enumerate}
|
|
|
|
|
|
|
|
|
|
Bien qu'idéalement il nous faudrait une population de l'ordre de \num{E6}
|
|
|
|
|
individus pour être dans les mêmes conditions que le protocole expérimental,
|
|
|
|
|
nous avons obtenu un résultat qualitativement très proche des photos présentées
|
|
|
|
|
dans l'article original. Étonnamment, nos bactéries rudimentaires, par les seules
|
|
|
|
|
contraintes mécaniques du moteur physique, se répartissent en secteurs lors de
|
|
|
|
|
la croissance de la population.
|
|
|
|
|
|
|
|
|
|
% Sectorisation
|
|
|
|
|
\begin{figure}[ht]
|
|
|
|
|
\centering
|
|
|
|
|
\includegraphics[height=.4\textwidth]{figures/sectors-original}\hspace{1cm}
|
|
|
|
|
\includegraphics[height=.4\textwidth]{figures/sectors}
|
|
|
|
|
\caption[Deux population de bactéries \ecoli{} croissant librement:
|
|
|
|
|
comparaison avec un résultat de la littérature.] {Deux population de
|
|
|
|
|
bactéries \ecoli{} croissant librement dans un milieu riche en nutriment.
|
|
|
|
|
La figure de droite est issue de la fenêtre de rendu du simulateur \otb.
|
|
|
|
|
La figure de gauche est issue de~\cite{hallatschek_genetic_2007} pour
|
|
|
|
|
comparaison}
|
|
|
|
|
\label{fig:sectorisation}
|
|
|
|
|
\end{figure}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
\FloatBarrier
|
|
|
|
|
% Ensemble Cercles concentriques
|
|
|
|
|
\subsection{Une population stable ?}
|
|
|
|
|
Les bactéries croissent, se divisent et entrent en apoptose. Nous avons tenté
|
|
|
|
|
dans cette simulation d'obtenir une population stable ou au moins croissant
|
|
|
|
|
linéairement. Intuitivement, l'idée que avons suivie est de faire en sorte que
|
|
|
|
|
les bactéries croissent en cercles concentriques autour de la bactérie mère
|
|
|
|
|
initiale. Cette dernière dépose un morphogène, appelé «Vert» dans le modèle,
|
|
|
|
|
et se divise en deux bactéries: une nouvelle bactérie mère et une bactérie
|
|
|
|
|
fille qui change d'état immédiatement. Cette nouvelle bactérie fille dépose
|
|
|
|
|
un morphogène «Rouge» dans l'environnement. L'ensemble des bactéries filles
|
|
|
|
|
forme alors un premier anneau autour de la bactérie mère. Si ces dernières ne
|
|
|
|
|
perçoivent pas un taux de morphogène «Vert» suffisamment grand, signifiant
|
|
|
|
|
qu'elles sont trop éloignées, alors elles changent à nouveau d'état.
|
|
|
|
|
|
|
|
|
|
Voici le comportement que nous avons spécifié en SBGP:
|
|
|
|
|
\begin{SBGPcode}
|
|
|
|
|
{
|
|
|
|
|
"signals" : [ ["Vert", 0.01, 2.5],
|
|
|
|
|
["Rouge", 0.001, 1.5],
|
|
|
|
|
["Bleu", 0.001, 1.5] ],
|
|
|
|
|
"reactions" : [],
|
|
|
|
|
"type" : [ "LEADER",
|
|
|
|
|
"CDAUGHTER",
|
|
|
|
|
"FDAUGHTER",
|
|
|
|
|
"DEAD" ],
|
|
|
|
|
"behavior" : {
|
|
|
|
|
"LEADER" : [ { "Divide" : [] },
|
|
|
|
|
{ "Tumble" : [] },
|
|
|
|
|
{ "EmitSignal" : [ "Vert", 50 ] } ],
|
|
|
|
|
"CDAUGHTER" : [ { "Divide" : 0.005 },
|
|
|
|
|
{ "Tumble" : [] },
|
|
|
|
|
{ "EmitSignal" : [ "Rouge", 50 ] } ],
|
|
|
|
|
"FDAUGHTER" : [ { "Divide" : 0.005 },
|
|
|
|
|
{ "Tumble" : [] },
|
|
|
|
|
{ "EmitSignal" : [ "Bleu", 50 ] } ],
|
|
|
|
|
"DEAD" : [ { "Die" : [] } ]
|
|
|
|
|
},
|
|
|
|
|
"transition" : [
|
|
|
|
|
["NA","NA","NA","NA"],
|
|
|
|
|
["CD","NA","NA","NA"],
|
|
|
|
|
["NA","CF","NA","NA"],
|
|
|
|
|
["NA","NA","CA","NA"]
|
|
|
|
|
],
|
|
|
|
|
"cond_transition" : [
|
|
|
|
|
{"CD" : "IsDaughter()"},
|
|
|
|
|
{"CF" : "LessThreshold(Vert,0.1)"},
|
|
|
|
|
{"CA" : "And(LessThreshold(Rouge,0.1),LessThreshold(Bleu,10.0))"}
|
|
|
|
|
]
|
|
|
|
|
}
|
|
|
|
|
\end{SBGPcode}
|
|
|
|
|
|
|
|
|
|
\noindent
|
|
|
|
|
Les bactéries peuvent être de quatre types:
|
|
|
|
|
\begin{enumerate}
|
|
|
|
|
\item \ç|LEADER| est la première bactérie de la simulation. Elle dépose le
|
|
|
|
|
morphogène vert dans l'environnement;
|
|
|
|
|
\item \ç|CDAUGHTER| sont les bactéries filles directes de la bactérie de type
|
|
|
|
|
\ç|LEADER|. Elles déposent le morphogène \ç|Rouge| dans l'environnement;
|
|
|
|
|
\item \ç|FDAUGHTER| sont les bactéries filles qui sont assez éloignées de la
|
|
|
|
|
bactérie de type \ç|LEADER| d'après la concentration en morphogène \ç|Vert|.
|
|
|
|
|
Elles déposent le morphogène \ç|Bleu| dans l'environnement;
|
|
|
|
|
\item \ç|DEAD| sont les bactéries filles qui se sont trop éloignées de la
|
|
|
|
|
bactérie de type \ç|LEADER| et qui meurent quand les concentrations en
|
|
|
|
|
morphogènes \ç|Vert| et \ç|Bleu| sont trop faibles.
|
|
|
|
|
\end{enumerate}
|
|
|
|
|
|
|
|
|
|
\begin{figure}[ht]
|
|
|
|
|
\centering
|
|
|
|
|
\includegraphics{figures/stablePopulation}
|
|
|
|
|
\caption{Graphique de la simulation « Une population stable? » présentant le
|
|
|
|
|
nombre de bactérie en fonction du temps de simulation. Après une phase de
|
|
|
|
|
croissance linéaire, la population se stabilise autour de \num{6000}
|
|
|
|
|
individus}
|
|
|
|
|
\label{graph:stablePopulation}
|
|
|
|
|
\end{figure}
|
|
|
|
|
|
|
|
|
|
\begin{figure}[ht]
|
|
|
|
|
\centering
|
|
|
|
|
\includegraphics[width=.45\textwidth]{figures/ftl01}\hspace{1em}
|
|
|
|
|
\includegraphics[width=.45\textwidth]{figures/ftl02}\vspace{1em}
|
|
|
|
|
\includegraphics[width=.45\textwidth]{figures/ftl03}\hspace{1em}
|
|
|
|
|
\includegraphics[width=.45\textwidth]{figures/ftl05}
|
|
|
|
|
\caption[Différentes étapes de la simulation «Une population
|
|
|
|
|
stable?».]{Différentes étapes de la simulation « Une population stable? ».
|
|
|
|
|
La bactérie mère (en haut à gauche) se divise une première fois et sa fille
|
|
|
|
|
change d'état (en haut à droite). Après un certain nombre de divisions,
|
|
|
|
|
une des bactérie est suffisamment éloignée de la bactérie mère et change
|
|
|
|
|
d'état (en bas à gauche). Plus tard dans la simulation, les bactéries «
|
|
|
|
|
bleues » trop éloignées de la bactérie mère meurent à la périphérie.}
|
|
|
|
|
\label{fig:stablePopulation}
|
|
|
|
|
\end{figure}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
\FloatBarrier
|
|
|
|
|
\section{Conclusion et perspectives}
|
|
|
|
|
Cette courte section vise à rappeler les principaux résultats obtenus suite à
|
|
|
|
|
nos travaux sur le simulateur de bactéries \otb ainsi que nos futures pistes de
|
|
|
|
|
travail sur le sujet.
|
|
|
|
|
|
|
|
|
|
\subsection{Conclusion}
|
|
|
|
|
% Résumé des épisodes précédents
|
|
|
|
|
Dans ce chapitre nous présentons \otb, un simulateur d'une population de
|
|
|
|
|
bactéries \Ecoli{}. Nous débutons ce chapitre en présentant nos motivations
|
|
|
|
|
pour le développement d'\otb ainsi que les choix techniques que nous avons
|
|
|
|
|
fait: l'utilisation de \ocaml, de \opencl et \opengl. Nous avons ainsi décidé
|
|
|
|
|
de tirer partie du parallélisme présent dans les ordinateurs grand public,
|
|
|
|
|
ce qui nous a amené à développer \ppm, un algorithme inspiré des travaux des
|
|
|
|
|
chapitres précédents (section~\ref{sec:ppm}). \ppm est conçu de sorte que le
|
2017-07-08 18:59:57 +02:00
|
|
|
|
contexte nécessaire à l'exécution de chaque kernel lui soit immédiatement
|
2017-07-08 17:42:46 +02:00
|
|
|
|
disponible. Ainsi le travail de chaque kernel est effectué de manière autonome
|
|
|
|
|
et en parallèle sans accès concurrent à la mémoire. \ppm est utilisé à la fois
|
|
|
|
|
pour l'exécution du moteur chimique et pour l'exécution du moteur physique. Ces
|
|
|
|
|
deux moteurs étant indépendants, la conception de \otb repose sur un dernier
|
|
|
|
|
moteur de décision permettant aux bactéries et à leur support de communiquer par
|
|
|
|
|
le couplage des moteurs chimique et physique. Ces trois moteurs sont présentés
|
|
|
|
|
dans la section~\ref{sec:implementation}. Nous clôturons le chapitre par
|
|
|
|
|
trois simulations permettant de rendre compte du fonctionnement du simulateur
|
|
|
|
|
(section~\ref{sec:mise-en-oeuvre}), montrant le fonctionnement des moteurs
|
|
|
|
|
chimique, physique et de décision.
|
|
|
|
|
|
|
|
|
|
% Résultats importants
|
|
|
|
|
\noindent
|
|
|
|
|
De nos travaux sur \otb nous tirons deux résultats:
|
|
|
|
|
\begin{itemize}
|
|
|
|
|
\item un résultat théorique: l'algorithme \ppm est générique et peut-être
|
|
|
|
|
adapté à d'autres outils travaillant sur les automates cellulaires;
|
|
|
|
|
\item un résultat pratique: le simulateur \otb est un exécutable utilisable
|
|
|
|
|
librement sur différentes plateformes, principalement pour l'étude de la
|
|
|
|
|
morphogénèse dans les populations de \ecoli. Il est modulaire et extensible
|
|
|
|
|
et pourrait donc aisément être adapté à d'autres types de population.
|
|
|
|
|
\end{itemize}
|
|
|
|
|
|
|
|
|
|
\subsection{Perspectives}
|
|
|
|
|
Nos travaux futurs s'articulent autour des grands axes suivants, dont
|
|
|
|
|
l'objectif principal est la pérennisation d'\otb comme outil de simulation:
|
|
|
|
|
|
|
|
|
|
\begin{description}
|
|
|
|
|
|
|
|
|
|
\item[Calibration]
|
|
|
|
|
Nous projetons de comparer les résultats de simulation avec des résultats
|
|
|
|
|
d'expériences \emph{in vivo} connus afin d'étalonner au mieux les moteurs
|
|
|
|
|
physique et chimique. Si cela s'avère nécessaire, nous changerons
|
|
|
|
|
l'algorithme d'intégration numérique pour une version plus précise, au prix
|
|
|
|
|
de la performance. Nous envisageons d'implémenter bien plus d'exemples de
|
|
|
|
|
modèles qu'actuellement. Nous considérons dans ce but l'établissement d'une
|
|
|
|
|
collaboration avec des scientifiques des sciences du vivant s'intéressant
|
|
|
|
|
à la morphogénèse ou plus largement aux dynamiques d'une population de
|
|
|
|
|
bactéries.
|
|
|
|
|
|
|
|
|
|
\item[Performance]
|
|
|
|
|
La performance actuelle du simulateur \otb provient principalement d'une
|
|
|
|
|
planification en amont de sa conception. Il est encore possible d'améliorer
|
|
|
|
|
la vitesse d'exécution du simulateur. Pour cela, il sera nécessaire
|
|
|
|
|
d'effectuer des mesures quantitatives afin d'identifier les parties du
|
|
|
|
|
programme les plus coûteuses en temps de calcul et les optimiser au mieux,
|
|
|
|
|
par rapport à l'environnement dans lequel le simulateur est utilisé et
|
|
|
|
|
en fonction des ressources en espace disponible sur le périphérique de
|
|
|
|
|
calcul. Il pourra ensuite être envisageable de comparer les performances de
|
|
|
|
|
\otb par rapport à d'autres simulateurs de population de bactéries comme
|
|
|
|
|
\gro~\cite{jang_specification_2012}.
|
|
|
|
|
|
|
|
|
|
\item[Interface de sortie]
|
|
|
|
|
L'interface utilisateur de \otb est à ce jour rudimentaire. Pour qu'un plus
|
|
|
|
|
grand nombre d'utilisateurs puissent utiliser le simulateur au quotidien
|
|
|
|
|
il est impératif de lui ajouter quelques fonctionnalités: un meilleur
|
|
|
|
|
contrôle à la souris, l'ajout d'obstacles et de flux dans l'environnement
|
|
|
|
|
afin de tester l'influence de contraintes mécaniques sur une population
|
|
|
|
|
en croissance ou encore présenter plusieurs vues en simultané de la même
|
|
|
|
|
population. Il est envisageable d'ajouter d'autres modes de sortie, comme
|
|
|
|
|
des mesures quantitatives agrégées sous forme de graphes en fonction du
|
|
|
|
|
temps de la simulation comme, par exemple, l'orientation moyenne des
|
|
|
|
|
bactéries, leur nombre, leur taille moyenne, leur volume moyen, etc.
|
2017-07-08 18:46:08 +02:00
|
|
|
|
|
2017-07-08 17:42:46 +02:00
|
|
|
|
\item[Interface d'entrée]
|
|
|
|
|
La description d'une simulation par un fichier \sbgp{} peut encore être
|
|
|
|
|
améliorée. Il est d'abord nécessaire d'optimiser le contenu de ce fichier
|
|
|
|
|
en fonction des informations réellement nécessaire à une simulation \otb
|
|
|
|
|
ce qui sera possible une fois le point «Calibration» effectué et après
|
|
|
|
|
discussion avec les futurs utilisateurs d'\otb. Il est aussi envisageable
|
|
|
|
|
de contrôler \otb à partir d'un programme externe, par exemple une
|
|
|
|
|
interface graphique regroupant les interfaces d'entrée et de sortie pour un
|
|
|
|
|
usage plus intuitif.
|
|
|
|
|
|
|
|
|
|
\item[Formes de bactérie]
|
|
|
|
|
De part sa conception, \otb est modulaire et extensible. Une piste
|
|
|
|
|
de travail futur est l'exploration de la simulation d'autre formes de
|
|
|
|
|
bactéries du genre bacillus (comme \ecoli), diplobacillus (des couples de
|
|
|
|
|
bâtonnets), streptobacillus (des chaînes de bacillus), coccus (des sphères),
|
|
|
|
|
coccobacillus (des ovales), etc. Changer de forme de bactérie implique de
|
|
|
|
|
mettre à jour l'algorithme de collision qui a été développé spécifiquement
|
|
|
|
|
pour les bactéries bacillaires. Ces développements se feront également en
|
|
|
|
|
lien avec le point «Calibration» en fonction des besoins.
|
|
|
|
|
|
|
|
|
|
\item[Grille hexagonale]
|
|
|
|
|
Une propriété des grilles hexagonales est que toutes les cellules ont un
|
|
|
|
|
bord en commun et leur centres sont équidistants (ce qui n'est pas le cas
|
|
|
|
|
sur une grille carrée, les centres des cellules en diagonale sont plus
|
|
|
|
|
éloignés). Nous souhaitons explorer le fonctionnement de \ppm sur ce support
|
|
|
|
|
afin de déterminer s'il est possible d'obtenir une diminution des erreurs
|
|
|
|
|
de la méthode d'intégration actuelle du moteur chimique et du calcul de
|
|
|
|
|
collision du moteur physique.
|
|
|
|
|
|
|
|
|
|
\item[\mgs]
|
|
|
|
|
Dans le point «Interface d'entrée» nous avons indiqué qu'il était
|
|
|
|
|
envisageable qu'un programme externe serve d'interface de contrôle pour
|
|
|
|
|
\otb. \mgs est un bon candidat pour cette tâche. En effet, nous pouvons
|
|
|
|
|
considérer que \otb définit une collection topologique dont les éléments
|
|
|
|
|
sont les bactéries. Cette collection est paramétrée par les réactions
|
|
|
|
|
entre les morphogènes. Chaque élément de cette collection a pour valeur
|
|
|
|
|
la spécification d'un réseau de régulation génétique sous la forme d'un
|
|
|
|
|
automate avec nombre fini d'états.
|
|
|
|
|
|
|
|
|
|
\end{description}
|
|
|
|
|
|