Un flux de travail typique pour simuler des systèmes cytosquelettiques

Résumé

Ce protocole montre comment utiliser Cytosim, une simulation de cytosquelette Open Source, pour étudier le comportement d’un réseau de filaments connectés par des moteurs moléculaires et des réticulants passifs. Un flux de travail générique avec des instructions étape par étape est suivi pour faire varier le nombre d’agents de réticulation et tracer la contractilité du réseau qui en résulte.

Résumé

De nombreux systèmes cytosquelettiques sont aujourd’hui suffisamment bien connus pour permettre une modélisation quantitative précise. Les filaments des microtubules et de l’actine sont bien caractérisés, et les protéines associées sont souvent connues, ainsi que leur abondance et les interactions entre ces éléments. Ainsi, les simulations informatiques peuvent être utilisées pour étudier le comportement collectif du système avec précision, d’une manière complémentaire aux expériences. Cytosim est une suite de simulation de cytosquelette Open Source conçue pour gérer de grands systèmes de filaments flexibles avec des protéines associées telles que des moteurs moléculaires. Il offre également la possibilité de simuler des réticulants passifs, des réticulants diffusibles, des nucléateurs, des cutters et des versions discrètes des moteurs qui ne marchent que sur des sites de réseau inoccupés sur un filament. D’autres objets complètent les filaments en offrant une géométrie sphérique ou plus compliquée qui peut être utilisée pour représenter les chromosomes, le noyau ou les vésicules de la cellule.

Cytosim offre des outils simples en ligne de commande pour exécuter une simulation et afficher ses résultats, qui sont polyvalents et ne nécessitent pas de compétences en programmation. Dans ce flux de travail, des instructions étape par étape sont données pour i) installer l’environnement nécessaire sur un nouvel ordinateur, ii) configurer Cytosim pour simuler la contraction d’un réseau d’actomyosine 2D, et iii) produire une représentation visuelle du système. Ensuite, le système est sondé en faisant systématiquement varier un paramètre clé : le nombre de réticulants. Enfin, la représentation visuelle du système est complétée par la quantification numérique de la contractilité pour voir, dans un graphique, comment la contractilité dépend de la composition du système. Dans l’ensemble, ces différentes étapes constituent un flux de travail typique qui peut être appliqué avec peu de modifications pour s’attaquer à de nombreux autres problèmes dans le domaine du cytosquelette.

Introduction

Le cytosquelette est constitué de filaments à l’intérieur de la cellule et de molécules associées telles que les moteurs moléculaires, qui constituent souvent un maillage dynamique aux propriétés mécaniques remarquables. Le cytosquelette existe dans diverses configurations dans différents types de cellules chez presque toutes les formes de vie. Son bon fonctionnement est essentiel pour les processus cellulaires fondamentaux tels que la division, la motilité et la polarisation. Il régit également les interactions mécaniques de cellule à cellule, influençant ainsi la morphogenèse des tissus et des organismes. Le cytosquelette sous-tend plusieurs fonctions et se manifeste dans de nombreux processus biologiques. Par exemple, la contraction des muscles est liée à la course de puissance des moteurs moléculaires de la myosine sur les filaments d’actine. Un autre exemple est le maintien des neurones, qui repose sur les mouvements des moteurs de kinésine le long des microtubules situés à l’intérieur des axones de ces neurones. L’actine et les microtubules sont deux types prééminents de filaments cytosquelettiques, et sans eux, la vie telle que nous la connaissons serait impossible.

Le cytosquelette est essentiellement un système biomécanique, qui ne peut être réduit à sa seule chimie. Les microtubules ou filaments d’actine sont constitués de milliers de monomères et s’étendent sur plusieurs micromètres. Les conformations de ces filaments dans l’espace et les forces qu’ils peuvent transmettre à la membrane plasmique, au noyau ou à d’autres organites sont des aspects clés de leur rôle dans la cellule. Par exemple, un réseau de filaments d’actine et de moteurs de myosine, appelé cortex d’actomyosine¹, génère des forces pour soutenir la motilité cellulaire et les changements morphologiques dans les cellules animales. Un arrangement très différent est observé dans les cellules végétales, où les microtubules corticaux dirigent le dépôt des fibrilles de cellulose, contrôlant ainsi l’architecture de la paroi cellulaire, qui détermine finalement comment ces cellules se développeront à l’avenir².

Alors que la mécanique joue clairement un rôle important dans les opérations du cytosquelette, la chimie est tout aussi importante. Les filaments se développent via un processus d’auto-assemblage par lequel les monomères trouvent leur site d’amarrage à l’extrémité du filament après avoir diffusé à travers le cytoplasme³. À l’échelle moléculaire, l’assemblage et le désassemblage à l’extrémité des filaments sont donc déterminés par les affinités moléculaires⁴. De même, les protéines du cytosquelette diffusent, et les taux de liaison et de déliaison déterminent leur affinité pour les filaments qu’elles rencontrent. Dans le cas des moteurs moléculaires, les cycles de réactions chimiques impliquant l’hydrolyse de l’ATP sont liés aux mouvements le long des filaments et, éventuellement, aux forces qui les accompagnent⁵. Remarquablement, le cytosquelette présente de nombreux défis inhabituels et une grande variété de processus impliquant des composants similaires. C’est un terrain de jeu riche à l’interface entre la biologie, la chimie et la physique.

Les systèmes cytosquelettiques se prêtent à la modélisation mathématique. En fait, grâce à l’excellence des recherches effectuées au cours des dernières décennies, les principaux constituants moléculaires sont probablement déjà identifiés, comme l’illustre l’endocytose⁶. Chez les organismes modèles, tels que la levure, les propriétés de ces éléments sont connues, ainsi que la composition du système pour certains de leurs processus. Par exemple, la structure et les propriétés matérielles des microtubules⁷, ainsi que leur nombre et leur longueur moyenne à différents stades du fuseau mitose, ont été décrits⁸. Le nombre de kinésines qui relient les microtubules en une structure mécanique cohérente est souvent connu⁹. Les vitesses de nombreux moteurs ont été mesurées in vitro¹⁰. De plus, les expérimentateurs peuvent observer et quantifier ces systèmes in vivo dans des conditions de type sauvage ou mutées. La combinaison de la théorie avec des expériences in vivo et in vitro permet aux chercheurs de tester si les connaissances actuelles sur un système cytosquelettique sont suffisantes pour expliquer son comportement observé. L’utilisation d’outils mathématiques et informatiques nous permet également de faire des inférences sur la façon dont les composants fonctionnent collectivement sur la base d’hypothèses dérivées d’observations à l’échelle moléculaire, généralement dans des situations simplifiées (par exemple, des expériences sur une seule molécule).

Le rôle de la théorie peut être illustré à l’aide d’un exemple pratique : le battement des cils. Ce battement est dû au mouvement des moteurs dynéins le long des microtubules dans les cils. On peut se demander ce qui détermine la vitesse du moteur dynéin dans ce système. Une réponse possible est que la vitesse maximale est limitée par la nécessité de maintenir un certain schéma de battement. Cela serait compréhensible si la raclée était sous la sélection naturelle. Dans ce cas, si les moteurs se déplaçaient plus rapidement, le processus perdrait ses qualités souhaitées - les cils ne battraient pas aussi efficacement ou même échoueraient complètement. Bien que cela soit possible, une deuxième alternative est qu’un facteur intrinsèque pourrait limiter la vitesse de la dynein.

Par exemple, la cellule peut ne pas avoir assez d’ATP pour accélérer la dynéine, ou les mouvements des protéines nécessaires à l’activité de la dynéine ne peuvent tout simplement pas être accélérés. Dans ce cas, si les moteurs pouvaient être rendus plus rapides malgré les limites physiques, le battement serait amélioré. Une troisième possibilité, bien sûr, est que la modification de la vitesse n’affecte pas le processus de manière significative, ce qui pourrait être avantageux pour l’organisme en fournissant une certaine « robustesse » contre les facteurs incontrôlables. Parmi ces trois possibilités, on peut identifier la bonne en calculant le modèle de battement à partir des propriétés de la dynéine. En effet, un modèle mathématique approprié devrait prédire comment le modèle de battement est affecté par la variation de la vitesse de la dynéine et n’est pas soumis aux limites qui existent dans le monde physique. Naturellement, la validité du modèle doit être vérifiée, mais même des modèles « incorrects » peuvent générer des idées intéressantes.

Le modèle peut prendre la forme d’un cadre analytique ou être une simulation numérique du système. Quoi qu’il en soit, l’écart entre l’échelle moléculaire et l’échelle fonctionnelle reste un obstacle, et le développement de ces modèles n’est pas une tâche simple, car plusieurs processus mécaniques et chimiques doivent être intégrés dans les équations décrivant le système biologique. La théorie se présente sous diverses formes, offrant différents compromis entre simplicité et réalisme. L’augmentation du degré de détail d’un modèle n’est pas toujours avantageuse car elle peut limiter notre capacité à résoudre les équations ou, en d’autres termes, à dériver les prédictions de la théorie. Le même compromis existe pour les simulations. Les modélistes devront sélectionner les ingrédients du système à prendre en compte tout en ignorant certains aspects. Ces décisions clés dépendront fortement de l’objectif de l’étude. De nos jours, les améliorations extraordinaires du matériel informatique permettent de simuler de nombreux systèmes cytosquelettiques avec suffisamment de détails sur un temps suffisant pour analyser leur comportement. Cela génère souvent des idées inattendues et de nouvelles orientations dans la recherche. Par exemple, des simulations similaires à celles qui seront utilisées dans ce protocole ont conduit à un calcul à l’arrière de l’enveloppe qui permet de prédire la contractilité d’un réseau en fonction de sa composition¹¹.

Les méthodes numériques sont omniprésentes dans l’ingénierie et les sciences physiques, et leur utilisation en biologie augmente. Aujourd’hui, pratiquement tous nos whatchamacallit technologiques (montres, téléphones, voitures et ordinateurs) ont d’abord été conçus sur un ordinateur, et des logiciels puissants existent pour le faire. Étant donné un système cytosquelettique bien caractérisé et en supposant qu’un niveau de description approprié a été déterminé, plusieurs problèmes doivent encore être résolus avant qu’il puisse être simulé. Pour les problèmes les plus simples, la voie d’action la plus appropriée pourrait être d’écrire une simulation « en codant à partir de zéro », c’est-à-dire en commençant par un langage de programmation générique ou une plateforme mathématique telle que MATLAB. Cela présente l’avantage que l’auteur du code aura une connaissance intime de ce qui a été mis en œuvre et saura exactement comment fonctionne le logiciel. Cette voie n’est cependant pas sans risque, et il n’est pas rare de voir des doctorants passer l’essentiel de leur temps de travail à écrire du code plutôt qu’à aborder des questions scientifiques.

L’alternative est d’utiliser des logiciels conçus par d’autres, mais ce n’est pas non plus sans risques ; Tout code source volumineux a tendance à acquérir spontanément les caractéristiques d’une boîte noire impénétrable, malgré les efforts les plus admirables de leurs auteurs pour l’empêcher. Utiliser des boîtes noires n’est sûrement pas le rêve d’un scientifique. Un code source volumineux peut également devenir un handicap, et il peut être plus rapide de repartir de zéro que de modifier une base de code existante pour lui faire faire quelque chose de différent. Pour atténuer ce problème, on peut toujours inviter les auteurs du logiciel à aider, mais cela peut ne pas être suffisant. Souvent, il y a une différence de culture scientifique entre les auteurs du logiciel et les personnes qui aimeraient l’utiliser, ce qui signifie que de nombreuses hypothèses implicites doivent être clarifiées. En rendant le code Open Source, on s’attend à ce que davantage de personnes soient impliquées dans le développement du logiciel et la maintenance de sa documentation, améliorant ainsi sa qualité. Toutes ces questions sont importantes qui doivent être dûment prises en compte avant tout investissement. Néanmoins, la seule façon de progresser à long terme est de promouvoir des solutions logicielles solides, utilisées et maintenues par une large communauté ayant des intérêts scientifiques communs.

Bien que ce protocole utilise Cytosim, il existe d’autres outils Open Source qui pourraient être en mesure de simuler le même système, par exemple, AFINES¹², MEDYAN¹³, CyLaKS¹⁴, aLENS¹⁵ et AKYT¹⁶, pour n’en nommer que quelques-uns. Malheureusement, comparer ces projets dépasse le cadre de l’article. Ici, des instructions étape par étape sont données pour simuler un réseau d’actomyosine 2D contractile. Ce système est simple et utilise les capacités mieux établies de Cytosim. Cytosim est construit autour d’un moteur central multiplateforme qui peut exécuter des simulations en 2D ou en 3D. Il dispose d’une base de code modulaire, ce qui le rend facilement personnalisable pour effectuer des tâches particulières. Le cytosme est tout aussi stable et efficace en 3D et a été utilisé avec succès dans le passé pour étudier divers problèmes impliquant des microtubules et des filaments d’actine : l’association de deux asters de microtubules¹⁷, le mouvement des noyaux dans les cellules^18,19, l’endocytose⁶, la cytokinèse²⁰, la formation du fuseau mitotique²¹, les mouvements du fuseau mitotique²², La capture des chromosomes²³, la contraction des réseaux d’actomyosine^11,24 et la mécanique de l’anneau des microtubules dans les plaquettes sanguines²⁵, ainsi que les capacités développées pour ces projets ont été maintenues dans le code. Le flux de travail décrit ici peut être adapté à de nombreux autres problèmes. Il utilise la ligne de commande Unix, qui peut ne pas être familière à certains lecteurs. L’utilisation de la ligne de commande est toutefois le moyen le plus portable et le plus pratique d’automatiser le processus d’exécution des simulations. Les interfaces utilisateur graphiques intégrées visent à offrir un accès facile et intuitif à un logiciel, mais cela se fait souvent au détriment de la généralité. L’objectif de cet article est d’illustrer une approche qui peut facilement être modifiée ou adaptée à d’autres problématiques. Des notes sont fournies pour expliquer la signification des commandes.

Pour simuler un réseau d’actomyosine, les filaments sont modélisés comme des lignes orientées et représentés par des sommets répartis sur leur longueur (Figure 1). Il s’agit d’un niveau de description intermédiaire, courant en physique des polymères, qui ignore la nature 3D authentique des filaments mais permet de calculer la flexion. Les filaments peuvent croître et rétrécir à leurs extrémités, selon différents modèles qui couvrent à la fois la phénoménologie de l’actine et des microtubules. Dans les cellules, les filaments sont organisés principalement par des interactions qui limitent leur mouvement, par exemple, l’attachement à d’autres filaments ou simplement le confinement à l’intérieur de la cellule. Dans Cytosim, toutes ces interactions sont linéarisées et combinées dans une grande matrice²⁶. Les équations décrivant le mouvement de tous les sommets des filaments sont dérivées de cette matrice, en supposant un milieu visqueux et des termes fluctuants aléatoires représentant le mouvement brownien. Ces équations sont résolues numériquement pour obtenir le mouvement des filaments ainsi que toutes les forces agissant sur eux de manière cohérente et efficace²⁶. À ce moteur mécanique se superpose un moteur stochastique qui simule des événements discrets, tels que les attaches et les détachements de moteurs moléculaires ou la dynamique d’assemblage de filaments. En résumé, Cytosim utilise d’abord la dynamique simulée pour calculer la mécanique d’un réseau de filaments, connectés de manière arbitraire, et, deuxièmement, des méthodes stochastiques pour simuler la liaison, la déliaison et la diffusion des protéines qui connectent ou affectent les filaments.

Le flux de travail illustré ici a été fréquemment suivi pour explorer initialement un système utilisant Cytosim. L’étape critique pour de nombreux utilisateurs potentiels est probablement l’installation des composants logiciels. La distribution du logiciel en tant que code source répond aux impératifs de la science ouverte, mais elle est sujette à des erreurs puisque les développeurs du logiciel n’ont accès qu’à un nombre limité d’architectures pour tester le programme. La compilation peut échouer en raison de la différence entre les systèmes d’exploitation. Les instructions fournies ici sont susceptibles de devenir obsolètes à mesure que les systèmes informatiques et les codes sources évoluent. Il est donc essentiel de vérifier périodiquement les dernières instructions en ligne. En cas de problème, il est fortement encouragé que les utilisateurs nous fassent part de leurs commentaires en postant sur le canal de commentaires approprié (actuellement la page d’accueil de Cytosim sur Gitlab) pour aider à résoudre le problème.

Access restricted. Please log in or start a trial to view this content.

Protocole

REMARQUE : Le protocole se compose des étapes suivantes : préparation de la plate-forme pour Windows 10, MacOS et Linux ; l’installation de Cytosim ; configuration de la simulation et de l’essai et de l’affichage graphique ; plusieurs passages, en faisant varier un paramètre : le nombre de réticulants dans le réseau ; la génération d’un graphique pour voir comment la contractilité est affectée par le nombre de réticulants ; courses parallèles ; et l’échantillonnage aléatoire. Tout le texte suivant un « > » sont des commandes qui doivent être saisies mot à mot dans la fenêtre du terminal. Le « > » représente l’invite du terminal et ne doit pas être inclus, mais tous les autres caractères sont importants.

1. Préparation de la plateforme

REMARQUE : selon le système d’exploitation (MacOS, Windows 10 ou Linux), suivez l’étape 1.1, l’étape 1.2 ou l’étape 1.3.

1. Préparation (MacOS)
   1. Installez les outils de ligne de commande Xcode en ouvrant le terminal (dans Applications/Utilitaires), puis entrez :
      Gt; xcode-select --install
   2. Pour afficher ou modifier le code de Cytosim, installez Xcode depuis l’App Store d’Apple (https://apps.apple.com/us/app/Xcode/id497799835?mt=12).
      REMARQUE : L’éditeur intégré de Xcode est parfaitement adapté. D’autres éditeurs orientés code fonctionneraient également, par exemple, TextMate. Pour utiliser TextMate, téléchargez et suivez les instructions de https://macromates.com.
2. Préparation (Windows)
   REMARQUE : pour Windows 10 ou version ultérieure, Cytosim peut s’exécuter à l’aide du « sous-système Windows pour Linux » (WSL), comme décrit ci-dessous. Une alternative pour une version plus ancienne est Cygwin, mais les instructions ne sont pas fournies ici.
   1. Mettez à jour le système d’exploitation de l’ordinateur pour répondre aux exigences de WSL 2 : Windows 10 version 1903 ou ultérieure, avec Build 18362 ou ultérieure, pour les systèmes x64 et version 2004 ou ultérieure, avec Build 19041 ou ultérieure, pour les systèmes ARM64. Pour les mises à jour de version ultérieures, consultez https://docs.microsoft.com/en-us/windows/release-health/release-information.
   2. Tapez Activer et désactiver les fonctionnalités Windows dans la zone de recherche de la barre des tâches. Activez manuellement () la plate-forme de machine virtuelle et () le sous-système Windows pour Linux. Cliquez sur OK et redémarrez Windows.
   3. Allez sur Windows Microsoft Store et recherchez Ubuntu. Téléchargez et installez la version actuelle (Ubuntu 20.04 LTS à partir du 03.2022)
   4. Cliquez sur Lancer pour démarrer le terminal Ubuntu. Si vous êtes invité à télécharger la dernière version du noyau Linux WSL2, suivez les instructions qui vous seront fournies. Installez la mise à jour et relancez Ubuntu.
   5. Suivez les instructions du terminal pour entrer un nouveau nom d’utilisateur UNIX et définir un mot de passe. Une fois le compte utilisateur configuré, lancez Ubuntu à partir de la zone de recherche de la barre des tâches Windows. Ouvrez le répertoire personnel (alias « . »), à partir de la fenêtre de commande :
      > explorer.exe .
   6. Installez un serveur X-Window compatible WSL, par exemple, Xming : https://sourceforge.net/projects/xming/
   7. Démarrez le serveur X-Window, Xming en double-cliquant sur l’icône Xming ; sélectionnez Plusieurs fenêtres. Ensuite, ouvrez le terminal Ubuntu et suivez l’étape 1.3 (Linux).
3. Préparation (Linux)
   REMARQUE : Ces instructions sont appropriées pour les distributions Linux qui utilisent le gestionnaire de paquets APT. Ces commandes doivent être modifiées pour les distributions telles que Red Hat Linux qui utilisent un gestionnaire de paquets différent. Dans ce cas, suivez les instructions de la distribution Linux pour installer les mêmes paquets.
   1. Mettez à jour le système Linux :
      > sudo apt-get update
      > sudo apt-get upgrade
   2. Installez un compilateur C++ et le make (https://www.gnu.org/software/make) de GNU :
      > sudo apt-get install build-essential
   3. Installez les bibliothèques BLAS/LAPACK (http://www.netlib.org/lapack) :
      > sudo apt-get install libblas-dev liblapack-dev
   4. Installez la bibliothèque de développement OpenGL et les fichiers d’en-tête (https://www.mesa3d.org) :
      > sudo apt-get install mesa-common-dev
   5. Installez la bibliothèque GLEW (http://glew.sourceforge.net) :
      > sudo apt-get install libglew-dev
   6. Installez la bibliothèque freeGLUT (http://freeglut.sourceforge.net) :
      > sudo apt-get install freeglut3-dev
   7. Installez le système de contrôle de version GIT (https://git-scm.com) :
      > sudo apt-get install git
   8. Installez les programmes de test X11 (par exemple, xeyes, xclock, xcalc) :
      > sudo apt-get install x11-apps
   9. Ajustez la variable d’environnement DISPLAY :
      > export DISPLAY= :0
      1. Essayez d’ouvrir une fenêtre X11 :
         > xeyes
      2. Si cela fonctionne, passez à l’étape 2. Si l’erreur n’a pas réussi à ouvrir l’affichage, essayez une autre valeur DISPLAY.
      3. Trouvez l’adresse IP de la machine WSL2 :
         > chat /etc/resolv.conf
      4. Si le numéro IP apparaît, par exemple, « serveur de noms 10.16.0.7 », utilisez ce numéro IP au lieu de X.X.X.X ci-dessous :
         > export display= X.X.X.X :0
         > xeyes
      5. Si cela fonctionne, passez à l’étape 2. Si « play » ne parvient pas à « ouvrir l’affichage », essayez de l’exécuter à partir d’une fenêtre « xterm » :
         > sudo apt install xterm
         > xterm -affichage :0
      6. Dans la nouvelle fenêtre qui s’ouvre, tapez :
         > xeyes

2. Installation de Cytosim

REMARQUE : ces étapes sont similaires pour tous les systèmes d’exploitation : MacOS, WSL et Linux. Dans la section suivante, les commandes seront émises dans le terminal, et le « répertoire de travail actuel » doit être défini dans le répertoire dans lequel la simulation a été compilée. Ce répertoire sera désigné comme étant le répertoire de base. Alternativement, tout peut être fait dans un répertoire séparé si les fichiers sont copiés si nécessaire. Si vous n’êtes pas familier avec la ligne de commande, envisagez de suivre un tutoriel, par exemple, https://www.learnenough.com/command-line-tutorial ou https://learnpythonthehardway.org/book/appendixa.html.

1. Télécharger le code source de Cytosim :
   > clone git https://gitlab.com/f-nedelec/cytosim.git cytosim
   REMARQUE : Un compte Gitlab n’est pas nécessaire pour télécharger le code. Cela devrait créer un nouveau sous-répertoire « cytosim » dans le répertoire courant.
2. Compiler:
   > cytosme cd
   > faire
   1. Vérifiez que trois fichiers sont créés dans un sous-directeur « bin » en exécutant :
      > bac LS
   2. Si l’étape 2.2.1 échoue, essayez cette méthode alternative pour compiler en installant cmake (https://cmake.org) :
      > mkdir b
      > cd b
      > cmake ..
      > faire
      > cd ..
3. Vérifier les exécutables :
   > d’informations sur la corbeille/sim
   > informations sur la corbeille et le jeu
   1. Vérifiez que les deux exécutables ont été compilés pour effectuer des simulations 2D. Recherchez le résultat suivant des requêtes « info » ci-dessus :
      Dimension : 2 Périodique : 1 Précision : 8 octets
   2. Si ce n’est pas le cas, et seulement alors, modifiez le fichier « src/math/dim.h » (ouvrir, modifier pour changer DIM en 2, enregistrer) et recompiler Cytosim :
      > rendre propre
      > faire
4. Série d’essai
   1. Copiez trois exécutables :
      > cp bin/sim sim
      > cp bin/play play
      > rapport BIN/RAPPORT CP
   2. Créez un nouveau répertoire :
      > mkdir run
   3. Copiez et renommez le fichier de configuration standard :
      > cp cym/fiber.cym run/config.cym
   4. Démarrez la simulation :
      > CD
      > .. /Sim
   5. Visualisez les résultats de la simulation :
      > .. /jouer
      1. Appuyez sur la barre d’espace pour animer. Appuyez sur h pour obtenir de l’aide sur les raccourcis clavier.
      2. Pour quitter le programme, sous MacOS, essayez -Q ou CTRL-Q, ou sélectionnez Quitter dans le menu. En dernier recours, entrez CTRL-C dans la fenêtre du terminal à partir de laquelle « play » a été lancé.
   6. Exécuter en mode direct :
      > .. /play live

3. Configuration de la simulation

1. Installez un éditeur de texte orienté code (par exemple, TextMate, SublimeText) s’il n’est pas déjà disponible.
   Ouvrez l’éditeur et ouvrez le fichier « config.cym », situé dans le répertoire « run » créé à l’étape 2.4.2. Familiarisez-vous avec les différentes sections du fichier de configuration, qui est une copie de « fiber.cym » (Supplementary File 1).
   REMARQUE : Cytosim ne lit généralement qu’un seul fichier de configuration se terminant par « .cym ». Toutes les modifications seront apportées ici à « config.cym ». Voir le tableau supplémentaire S1 pour une liste des paramètres.
2. Modifiez la simulation en apportant les modifications suivantes à « config.cym » :
   rayon = 5 → rayon = 3
   Nouveau 1 filament → nouveau 100 filament
3. Enregistrez le fichier sans changer son nom ou son emplacement (écrasez « config.cym »). Basculez dans la fenêtre du terminal, et vérifiez que la simulation est modifiée comme prévu avec :
   > .. /play live
   REMARQUE : Le rayon du cercle est spécifié en micromètres (μm), comme toutes les distances dans Cytosim. Le cytosme suit un système d’unités adapté à l’échelle de la cellule, dérivé des micromètres, des piconewtons et des secondes.
4. Dans le paragraphe « fixer le filament de fibre », apportez les modifications suivantes :
   rigidité=20 → rigidité=0,1
   Segmentation = 0,5 → Segmentation = 0,2
   confine=intérieur, 200, cellule → confine= intérieur, 10, cellule
   Dans le paragraphe « nouveau filament », modifier :
   longueur=12 → longueur=2
   Réduisez le temps à simuler en modifiant :
   Système Run 5000 → système Run 1000
   REMARQUE : Cela ajuste les propriétés du filament. Le paragraphe « set » définit les propriétés persistantes des filaments, tandis que les paramètres dans « new » sont généralement des conditions initiales. La rigidité à la flexion est spécifiée en pN μm². La segmentation est la distance approximative entre les sommets décrivant les filaments en micromètres (μm). Il doit être réduit si les filaments sont rendus plus flexibles. Le dernier changement réduit la rigidité (pN/μm) du potentiel de confinement associé aux bords des « cellules ». La longueur déclarée dans le « nouveau » paragraphe (2 μm) est la longueur initiale des filaments, et comme dans ce modèle les filaments ne sont pas dynamiques, leurs longueurs ne changeront pas. Il est recommandé de signer le fichier de configuration, en éditant la première ligne :
   % Votre nom, date, lieu
   1. Vérifiez la validité du fichier de configuration (répétez l’étape 3.3).
5. Créez des connecteurs passifs.
   1. Ajouter un nouveau paragraphe à « config.cym », avant les lignes avec les commandes « new » et « run », pour définir une activité moléculaire avec affinité avec les filaments :
      set relieur à main {
      binding_rate = 10
      binding_range = 0,01
      unbinding_rate = 0,2
      }
   2. Pour définir des entités bifonctionnelles, ajoutez un autre paragraphe juste en dessous :
      set couple crosslinker {
      hand1 = relieur
      hand2 = relieur
      rigidité = 100
      diffusion = 10
      }
   3. Ajoutez une commande « new » après les paragraphes précédents et avant la commande « run » :
      NOUVEAU 1000 Réticulant
      REMARQUE : Dans Cytosim, les débits sont exprimés en unités de s⁻¹ et la plage en micromètres (μm). La rigidité est exprimée en piconewtons par micromètre (pN/μm) et le coefficient de diffusion en micromètres carrés par seconde (μm²/s). L’ordre des commandes dans le fichier de configuration est important, et ces paragraphes doivent apparaître avant toute commande « run », sinon ils ne seront pas efficaces. Pour en savoir plus sur les objets de Cytosim, suivez le tutoriel dans « tuto_introduction.md », qui se trouve dans un sous-dossier « doc » du répertoire de base : doc/tutorials/.
6. Créez des moteurs bifonctionnels.
   1. Ajoutez un nouveau paragraphe à « config.cym », avant les lignes avec les commandes « new » et « run » :
      régler le moteur manuel {
      binding_rate = 10
      binding_range = 0,01
      unbinding_rate = 0,2
      activité = bouger
      unloaded_speed = 1
      stall_force = 3
      }
   2. Ajouter un autre paragraphe, après le précédent :
      ensemble couple complexe {
      hand1 = moteur
      hand2 = moteur
      rigidité = 100
      diffusion = 10
      ​}
   3. Ajoutez une commande « new » après les paragraphes précédents et avant la commande « run » :
      Nouveau complexe 200
      REMARQUE : L’option « activité = mouvement » spécifie un moteur qui se déplace continuellement sur le filament. Le moteur obéit à une courbe linéaire force-vitesse (Figure 1) caractérisée par la vitesse à vide (μm/s) et la force de décrochage (piconewton). À chaque pas de temps, τ, il se déplace d’une distance, v × τ. L’utilisation de « activité = aucune » spécifierait une molécule qui ne bouge pas, et comme il s’agit de l’activité par défaut, on pourrait simplement omettre « activité » complètement. D’autres activités sont possibles, par exemple, « activité = marche » spécifierait un moteur avec des pas discrets le long du filament. Le « unloaded_speed » est positif pour un moteur dirigé haut de gamme. Spécifier une valeur négative ferait bouger le moteur vers les extrémités négatives. Ceci est expliqué plus en détail dans le premier tutoriel de Cytosim (voir lien à l’étape 3.5.2).
7. Enregistrez le fichier.
   Vérifiez la simulation :
   > .. /play live
   Exécutez la simulation :
   > .. /Sim
   Visualisez les résultats :
   > .. /jouer
   Copiez le fichier de configuration final dans le répertoire de base :
   > cp config.cym .. /config.cym
   REMARQUE : Votre fichier final doit être similaire au Fichier supplémentaire 2 (« jove.cym »). Notez le temps nécessaire pour calculer cette simulation. Dans les sections suivantes, ce temps sera multiplié par le nombre de simulations effectuées pour générer un graphique où un paramètre est varié.

4. Balayage des paramètres

REMARQUE : Dans cette section, le nombre de réticulants dans le réseau est systématiquement modifié.

1. Importez des scripts Python.
   1. Créez un sous-répertoire « byn », à l’intérieur du répertoire de base :
      > mkdir byn
   2. Copiez trois scripts de la distribution Cytosim standard :
      > cp python/run/preconfig.py byn/preconfig
      > cp python/look/scan.py byn/.
      > cp python/look/make_page.py byn/.
      REMARQUE : Pour des raisons de sécurité, des copies de ces fichiers sont fournies en tant que Fichier supplémentaire 3, Fichier supplémentaire 4 et Fichier supplémentaire 5 avec cet article.
2. Rendez les fichiers exécutables :
   > chmod +x byn/preconfig
   > chmod +x byn/scan.py
   > chmod +x byn/make_page.py
   1. Vérifiez que les scripts s’exécutent correctement :
      > l’aide de byn/preconfig
      > aide byn/scan.py
      > byn/make_page.py help
      REMARQUE : Cela devrait afficher une description de la façon dont chaque commande peut être utilisée. Il est possible de modifier la variable PATH pour appeler les scripts plus simplement ; Voir https://en.wikipedia.org/wiki/PATH_(variable).
   2. Dépannage
      1. Si l’erreur est « commande introuvable », vérifiez le chemin spécifié, qui doit correspondre à l’emplacement du fichier. S’il y a un autre type d’erreur parce que l’OS ne fournit pas python2, éditez les trois fichiers .py et modifiez le shebang, qui est la première ligne de chaque fichier (il suffit d’ajouter « 3 ») :
         # !/usr/bin/env python → # !/usr/bin/env python3
3. Copiez le fichier de configuration pour en faire un « modèle » (Fichier Supplémentaire 6) :
   > cp config.cym config.cym.tpl
4. Modifiez le fichier de configuration du modèle. Dans l’éditeur de code, ouvrez le fichier « config.cym.tpl », situé dans le répertoire de base. Modifiez une ligne pour introduire un élément de texte variable :
   nouveau 1000 réticulant → nouveau [[range(0,4000,100)]] réticulant
   REMARQUE : Preconfig reconnaîtra le code contenu dans les doubles crochets et le remplacera par une valeur obtenue en exécutant ce code en Python. En Python, « range(X,Y,S) » spécifie les entiers de X à Y, avec un incrément de S ; Dans ce cas [0, 100, 200, 300, ... 4000]. L’objectif est de modifier le nombre de réticulants ajoutés à la simulation.
5. Générez des fichiers de configuration à partir du modèle :
   > byn/preconfig run %04i/config.cym config.cym.tpl
   REMARQUE : Cela devrait créer 40 fichiers, un pour chaque valeur spécifiée dans « range(0,4000,100) ». Les noms des fichiers à générer par Preconfig sont spécifiés par « run %04i/config.cym ». Avec ce code spécifique, Preconfig va générer « run0000/config.cym », « run0001/config.cym », etc. Il va en fait créer les répertoires « run0000 », « run0001 », etc., et créer un fichier « config.cym » dans chacun d’eux. Consultez l’aide de Preconfig pour plus de détails (exécutez « byn/preconfig help »). En cas d’erreur, vérifiez que la commande est bien tapée. Chaque caractère compte.
6. Exécutez toutes les simulations de manière séquentielle :
   > byn/scan.py '.. /sim' exécuter ????
   REMARQUE : Le programme « scan.py » exécutera la commande citée dans la liste des répertoires fournis. Dans ce cas, cette liste de répertoires est spécifiée par « run ???? ». Le point d’interrogation est un caractère générique qui correspond à n’importe quel caractère. Par conséquent, « run ???? » correspond à n’importe quel nom commençant par « run » et suivi d’exactement quatre caractères. Alternativement, on pourrait utiliser « run* » pour générer la même liste, puisque « * » correspond à n’importe quelle chaîne.
   1. En cas de problème, exécutez cette commande à partir d’une nouvelle fenêtre de terminal pour exécuter « sim » séquentiellement dans tous les répertoires créés à l’étape 4.5. Attendez environ 30 minutes pour que le processus se termine, mais cela dépend beaucoup des capacités de l’ordinateur. Réduire la quantité de calcul demandée en éditant « config.cym » :
      Système Run 1000 → système Run 500
7. Visualisez quelques simulations :
   > ./play run0010
   > ./play run0020
8. Générer des images pour toutes les simulations :
   > byn/scan.py '.. /play image size=256 frame=10' run ????
9. Générez une page de résumé HTML :
   > tuile byn/make_page.py = 5 run ????
   1. Ouvrez « page.html » dans un navigateur Web.

5. Réalisation d’un graphique

REMARQUE : Dans cette section, un graphique est réalisé à partir des résultats du balayage des paramètres.

1. Vérifiez l’exécutable du rapport :
   > CD
   > .. /report network :taille
   REMARQUE : Pour chaque image de la trajectoire, cela affichera des commentaires et deux chiffres, correspondant à « polymère » et « surface ». Seule la « surface » du réseau (dernière colonne) sera utilisée.
   1. Limitez spécifiquement les informations à un seul cadre en utilisant :
      > .. /réseau de rapport :taille cadre=10
   2. Supprimez les commentaires pour faciliter le traitement de la sortie :
      > .. /report network :size frame=10 verbose=0
   3. Enfin, redirigez la sortie vers un fichier à l’aide de la fonction de pipe Unix (« > ») :
      > .. /report network :size frame=10 verbose=0 > net.txt
   4. Imprimez le contenu du fichier sur le terminal pour vérification :
      > chat net.txt
      REMARQUE : Cela devrait imprimer deux chiffres. La seconde est la surface couverte par le réseau dans la 10ème image. Pour exécuter la même opération dans tous les répertoires « run », changez de répertoire :
      > cd ..
2. Générez un rapport dans chaque sous-répertoire de simulation :
   > byn/scan.py '.. /report network :size frame=10 verbose=0 > net.txt' run ????
   REMARQUE : Encore une fois, scan.py exécuterez la commande citée dans tous les répertoires spécifiés par « run ???? ». La commande est la dernière essayée à l’étape 5.1. Cela générera un fichier « net.txt » dans chaque répertoire (essayez « ls run ???? »).
3. Examinez ces chiffres :
   > la série « Cat net.txt byn/scan.py ????
   1. Ajoutez l’option « + » pour concaténer le nom du répertoire et la sortie de la commande :
      > byn/scan.py + 'cat net.txt' run ????
4. Rassemblez ces numéros dans un fichier :
   > byn/scan.py + 'cat net.txt' run ???? > results.txt
5. Nettoyez le fichier « results.txt » en supprimant le texte répété qui n’est pas numérique. Ouvrez « result.txt » dans l’éditeur de code et utilisez « remplacer le texte » pour supprimer toutes les chaînes « run ». Supprimez seulement trois lettres et conservez les chiffres ; « run0000 » devrait devenir « 0000 ».
   REMARQUE : Cela devrait laisser un fichier avec seulement des numéros organisés en trois colonnes.
6. Générez un tracé de contractilité à partir des données dans « result.txt ». Utilisez n’importe quelle méthode pour générer un graphique à l’aide de la colonne 1 pour X et de la colonne 3 pour Y. Indiquez sur l’axe des X le nombre d’agents de réticulation/100. Étiquetez l’axe Y comme surface (micromètre^2).
7. Stockez toutes les simulations dans un répertoire séparé :
   > mkdir save1
   > mv run ???? sauvegarde1

6. Méthode alternative pour faire un graphique

1. Ajoutez une commande report à la fin de « config.cym.tpl » sur une nouvelle ligne après le « } » de fermeture de la commande run :
   réseau de rapport :taille net.txt { détaillé = 0 }
2. Générez des fichiers de configuration :
   > byn/preconfig run %04i/config.cym config.cym.tpl
3. Exécutez toutes les simulations à l’aide de threads parallèles :
   > byn/scan.py '.. /sim' exécuter ???? njobs=4
   1. Ajustez le nombre de tâches (njobs=4), en fonction de la capacité de l’ordinateur. Surveillez l’utilisation des ressources du processeur, par exemple, par l’application Moniteur d’activité sur MacOS.
4. Collecter les données :
   > byn/scan.py + 'cat net.txt' run ???? > results.txt
5. Faites un graphique, comme aux étapes 5.5 et 5.6.
6. Stockez toutes les exécutions précédentes dans un répertoire séparé :
   > mkdir save2
   > mv run ???? sauvegarde2

7. Graphique amélioré à l’aide d’un échantillonnage aléatoire

REMARQUE : Une variable est échantillonnée ici à l’aide d’une fonction génératrice du module « random » de Python.

1. Dans l’éditeur de code, ouvrez le fichier de configuration du modèle « config.cym.tpl », situé dans le répertoire de base. Ajoutez deux lignes, juste avant le « nouveau réticulateur » :
   [[num = int(random.uniform(0,4000))]]
   %[[num]] xlinkers
   Modifiez également la commande « new » pour utiliser cette variable :
   nouveau [[range(0,4000,100)]] réticulant → nouveau [[num]] réticulant
   REMARQUE : La première ligne crée une variable aléatoire « num ». La deuxième ligne imprime la valeur du paramètre. Le caractère « % » est important car il indiquera à Cytosim de sauter la ligne. Bientôt, « xlinkers » servira de balise reconnaissable, et il ne devra apparaître qu’une seule fois dans chaque fichier.
   1. À la toute fin de « config.cym.tpl », assurez-vous qu’il y a une instruction de rapport :
      réseau de rapport :taille net.txt { détaillé = 0 }
2. Générez des fichiers de configuration :
   > byn/preconfig run %04i/config.cym 42 config.cym.tpl
   REMARQUE : Cela devrait générer 42 fichiers. Ce nombre peut être augmenté si l’ordinateur est suffisamment rapide. Les valeurs générées aléatoirement peuvent être vues en utilisant l’outil Unix « grep » pour rechercher des fichiers :
   > les xlinkers grep s’exécutent ???? /config.cym
3. Exécutez toutes les simulations en parallèle :
   > byn/scan.py '.. /sim' exécuter ???? njobs=4
   REMARQUE : Ajustez le nombre de tâches à la capacité de l’ordinateur. Pour de meilleurs résultats, la variable « njobs » doit être égale au nombre de cœurs de l’ordinateur.
4. Collectez les données à l’aide d’une seule commande :
   > byn/scan.py + 'grep xlinkers config.cym ; le parcours du chat net.txt ???? > results.txt
   REMARQUE : L’option « + » de scan.py concaténera toute la sortie de la commande sur une seule ligne. Dans ce cas, la commande est en fait composée de deux commandes séparées par une demi-colonne (« ; »). La collecte de données peut toujours être automatisée avec un script Python.
5. Nettoyez le fichier. Ouvrez « result.txt » dans l’éditeur de code. Pour vous assurer que toutes les données correspondant à une simulation sont contenues sur une seule ligne, supprimez toutes les occurrences de la chaîne « xlinkers » et supprimez les caractères « % » au début de chaque ligne. Enfin, enregistrez « result.txt », qui doit être soigneusement organisé en trois colonnes de valeurs numériques.
6. Faites un graphique pour tracer les données en répétant l’étape 5.6, mais étiquetez l’axe X comme nombre de réticulants
7. Enregistrez le jeu de données dans un nouveau sous-répertoire :
   >mkdir set1
   > mv run ???? ensemble1/.
   > mv results.txt set1/.
8. Calculez un autre jeu de données en répétant les étapes 7.2 à 7.6, puis répétez l’étape 7.8, en remplaçant « set1 » par « set2 » dans les trois commandes.
9. Faites un graphique combiné.
   1. Concaténez les deux fichiers de données :
      > ensemble pour chat ?/results.txt > results.txt
      REMARQUE : Le nouveau « result.txt » doit être plus grand.
   2. Tracez les données pour créer un graphique combiné, comme décrit à l’étape 7.7.

8. Pipeline entièrement automatisé

REMARQUE : Dans cette partie, toutes les opérations nécessitant une intervention manuelle sont remplacées par des commandes. Lorsque cela est fait, il sera possible d’écrire un seul script qui effectue toutes les étapes automatiquement. Ce script peut être exécuté sur un ordinateur distant tel qu’une batterie de serveurs de calcul.

1. Utilisez la commande Unix « sed » pour « nettoyer » le fichier results.txt, en remplaçant l’étape 7.6.
   1. Supprimez le « % » au début des lignes :
      > sed -e 's/ %//g' results.txt > tmp.txt
   2. Supprimer les « xlinkers » :
      > sed -e 's/xlinkers//g' tmp.txt > results.txt
2. Écrivez un script pour appeler toutes les commandes successivement dans le bon ordre.
   1. Utilisez différents langages : bash ou Python.
   2. Créez un fichier « pipeline.bash » et copiez toutes les commandes nécessaires à l’exécution du pipeline.
   3. Exécutez le script :
      > bash pipeline.bash
3. Utilisez un script de traçage automatisé.
   REMARQUE : Il peut être avantageux de supprimer toute intervention manuelle. De nombreux outils existent pour générer un tracé PDF directement à partir d’un fichier de données, par exemple, gnuplot (http://www.gnuplot.info), PyX (https://pyx-project.org), ou Seplot (https://pypi.org/project/seplot/).

Access restricted. Please log in or start a trial to view this content.

Résultats

Dans la section 2, une compilation réussie de Cytosim à l’aide de « make » devrait produire sim, play et report dans le sous-répertoire « bin ». Le résultat de l’étape 2.3 (« sim info ») doit indiquer « Dimension : 2 » entre autres. Dans la section 3, le fichier de configuration doit être similaire à jove.cym, fourni en tant que fichier supplémentaire 1. Dans la section 4, lesimages obtenues à l’étape 4.8 ...

Access restricted. Please log in or start a trial to view this content.

Discussion

La méthode décrite dans cet article s’appuie sur trois petits programmes Python indépendants, qui ont été utilisés de diverses manières tout au long du protocole décrit. Le premier script preconfig est un outil polyvalent qui peut remplacer le besoin d’écrire des scripts Python personnalisés²⁷. Il est utilisé pour générer plusieurs fichiers de configuration à partir d’un seul fichier de modèle, en spécifiant quel paramètre doit êtr...

Access restricted. Please log in or start a trial to view this content.

matériels

Name	Company	Catalog Number	Comments
A personal computer			MacOS, Windows 10 or Linux
config.cym.tpl			template configuration file; https://gitlab.com/f-nedelec/cytosim.git
jove.cym			Cytosim configuration file
make_page.py			Python script; https://github.com/nedelec/make_page.py
preconfig			Python script; https://github.com/nedelec/preconfig
scan.py			Python script; https://github.com/nedelec/scan.py