Ein typischer Arbeitsablauf zur Simulation von Zytoskelettsystemen

Zusammenfassung

Dieses Protokoll zeigt, wie Cytosim, eine Open-Source-Zytoskelett-Simulation, verwendet werden kann, um das Verhalten eines Netzwerks von Filamenten zu untersuchen, die durch molekulare Motoren und passive Vernetzer verbunden sind. Ein generischer Workflow mit Schritt-für-Schritt-Anleitungen wird befolgt, um die Anzahl der Vernetzer zu variieren und die resultierende Netzwerkkontraktilität darzustellen.

Zusammenfassung

Viele Zytoskelettsysteme sind heute ausreichend bekannt, um eine präzise quantitative Modellierung zu ermöglichen. Mikrotubuli- und Aktinfilamente sind gut charakterisiert, und die zugehörigen Proteine sind oft bekannt, ebenso wie ihre Häufigkeit und die Wechselwirkungen zwischen diesen Elementen. So können Computersimulationen verwendet werden, um das kollektive Verhalten des Systems genau und komplementär zu Experimenten zu untersuchen. Cytosim ist eine Open-Source-Simulationssuite für das Zytoskelett, die für den Umgang mit großen Systemen flexibler Filamente mit zugehörigen Proteinen wie molekularen Motoren entwickelt wurde. Es bietet auch die Möglichkeit, passive Vernetzer, diffusionsfähige Vernetzer, Nukleatoren, Cutter und diskrete Versionen der Motoren zu simulieren, die nur auf unbesetzte Gitterstellen auf einem Filament treten. Andere Objekte ergänzen die Filamente, indem sie eine kugelförmige oder kompliziertere Geometrie bieten, die zur Darstellung von Chromosomen, dem Zellkern oder den Vesikeln in der Zelle verwendet werden kann.

Cytosim bietet einfache Befehlszeilenwerkzeuge zum Ausführen einer Simulation und Anzeigen ihrer Ergebnisse, die vielseitig sind und keine Programmierkenntnisse erfordern. In diesem Arbeitsablauf werden Schritt-für-Schritt-Anweisungen gegeben, um i) die erforderliche Umgebung auf einem neuen Computer zu installieren, ii) Cytosim so zu konfigurieren, dass die Kontraktion eines 2D-Aktomyosin-Netzwerks simuliert wird, und iii) eine visuelle Darstellung des Systems zu erstellen. Als nächstes wird das System durch systematische Variation eines Schlüsselparameters getestet: der Anzahl der Vernetzer. Schließlich wird die visuelle Darstellung des Systems durch die numerische Quantifizierung der Kontraktilität ergänzt, um in einem Diagramm zu sehen, wie die Kontraktilität von der Zusammensetzung des Systems abhängt. Insgesamt stellen diese verschiedenen Schritte einen typischen Arbeitsablauf dar, der mit wenigen Modifikationen auf viele andere Probleme im Bereich des Zytoskeletts angewendet werden kann.

Einleitung

Das Zytoskelett besteht aus Filamenten innerhalb der Zelle und zugehörigen Molekülen wie molekularen Motoren, die oft ein dynamisches Geflecht mit bemerkenswerten mechanischen Eigenschaften bilden. Das Zytoskelett existiert in verschiedenen Konfigurationen in verschiedenen Zelltypen bei fast allen Lebensformen. Sein korrektes Funktionieren ist für grundlegende zelluläre Prozesse wie Teilung, Motilität und Polarisation unerlässlich. Es steuert auch die mechanischen Wechselwirkungen von Zelle zu Zelle und beeinflusst so die Morphogenese von Geweben und Organismen. Das Zytoskelett hat mehrere Funktionen und manifestiert sich in vielen biologischen Prozessen. Zum Beispiel ist die Kontraktion der Muskeln mit dem Kraftschlag von Myosin-Molekularmotoren an Aktinfilamenten verbunden. Ein weiteres Beispiel ist die Aufrechterhaltung von Neuronen, die auf den Bewegungen von Kinesinmotoren entlang der Mikrotubuli beruht, die sich in den Axonen dieser Neuronen befinden. Aktin und Mikrotubuli sind zwei herausragende Arten von Zytoskelettfilamenten, und ohne sie wäre das Leben, wie wir es kennen, unmöglich.

Das Zytoskelett ist im Wesentlichen ein biomechanisches System, das sich nicht allein auf seine Chemie reduzieren lässt. Mikrotubuli oder Aktinfilamente sind aus Tausenden von Monomeren aufgebaut und erstrecken sich über mehrere Mikrometer. Die Konformationen dieser Filamente im Raum und die Kräfte, die sie auf die Plasmamembran, den Zellkern oder andere Organellen übertragen können, sind Schlüsselaspekte ihrer Rolle in der Zelle. Zum Beispiel erzeugt ein Netzwerk aus Aktinfilamenten und Myosinmotoren, der sogenannte Aktomyosinkortex¹, Kräfte, um die Zellmotilität und morphologische Veränderungen in tierischen Zellen aufrechtzuerhalten. Eine ganz andere Anordnung ist in Pflanzenzellen zu beobachten, wo kortikale Mikrotubuli die Ablagerung von Zellulosefibrillen steuern und so die Zellwandarchitektur steuern, die letztendlich bestimmt, wie diese Zellen in Zukunft wachsen werden².

Während die Mechanik bei Operationen des Zytoskeletts eine wesentliche Rolle spielt, ist die Chemie ebenso wichtig. Filamente wachsen über einen Selbstorganisationsprozess, bei dem Monomere ihre Andockstelle an der Spitze des Filaments finden, nachdem sie durch das Zytoplasma diffundiert^{sind 3}. Auf molekularer Skala werden der Auf- und Abbau an der Spitze der Filamente also durch die molekularen Affinitäten^{bestimmt 4}. In ähnlicher Weise diffundieren Proteine des Zytoskeletts, und die Bindungs- und Unbindungsraten bestimmen ihre Affinität zu den Filamenten, auf die sie treffen. Im Falle molekularer Motoren sind die Zyklen chemischer Reaktionen, an denen die ATP-Hydrolyse beteiligt ist, mit Bewegungen entlang der Filamente und möglicherweise mit Kräften, die sie begleiten, verbunden⁵. Bemerkenswert ist, dass das Zytoskelett viele ungewöhnliche Herausforderungen und eine große Vielfalt an Prozessen mit ähnlichen Komponenten bietet. Es ist ein reichhaltiger Spielplatz an der Schnittstelle zwischen Biologie, Chemie und Physik.

Zytoskelettsysteme sind für mathematische Modellierungen zugänglich. Dank der exzellenten Forschung der letzten Jahrzehnte sind die wichtigsten molekularen Bestandteile höchstwahrscheinlich bereits identifiziert, wie die Endozytose⁶ zeigt. In Modellorganismen wie der Hefe sind die Eigenschaften dieser Elemente sowie die Systemzusammensetzung für einige ihrer Prozesse bekannt. So sind beispielsweise die Struktur und die Materialeigenschaften von Mikrotubuli⁷ sowie ihre Anzahl und durchschnittliche Länge in verschiedenen Stadien der mitotischen Spindel beschrieben^{worden 8}. Die Anzahl der Kinesine, die Mikrotubuli zu einer kohärenten mechanischen Struktur verbinden, ist oft bekannt⁹. Die Drehzahlen vieler Motoren wurden in vitro^{gemessen 10}. Darüber hinaus können Experimentatoren diese Systeme in vivo unter Wildtyp- oder mutierten Bedingungen beobachten und quantifizieren. Die Kombination von Theorie mit In-vivo- und In-vitro-Experimenten ermöglicht es den Forschern zu testen, ob das derzeitige Wissen über ein Zytoskelettsystem ausreicht, um sein beobachtetes Verhalten zu erklären. Die Verwendung mathematischer und rechnerischer Werkzeuge ermöglicht es uns auch, Rückschlüsse darauf zu ziehen, wie Komponenten kollektiv funktionieren, und zwar auf der Grundlage von Annahmen, die aus Beobachtungen auf molekularer Ebene abgeleitet wurden, in der Regel in vereinfachten Situationen (z. B. Einzelmolekülexperimenten).

Die Rolle der Theorie lässt sich anhand eines praktischen Beispiels verdeutlichen: dem Schlagen von Zilien. Diese Schwebung ist auf die Bewegung von Dyneinmotoren entlang der Mikrotubuli in den Zilien zurückzuführen. Man kann sich fragen, was die Drehzahl des Dynein-Motors in diesem System bestimmt. Eine mögliche Antwort ist, dass die maximale Geschwindigkeit durch die Anforderung begrenzt wird, ein bestimmtes Schwebungsmuster beizubehalten. Dies wäre verständlich, wenn die Prügelei unter natürlicher Selektion erfolgte. In diesem Fall, wenn sich die Motoren schneller bewegen, würde der Prozess seine gewünschten Eigenschaften verlieren - die Zilien würden nicht mehr so effizient schlagen oder sogar ganz ausfallen. Obwohl dies möglich ist, besteht eine zweite Alternative darin, dass ein intrinsischer Faktor die Geschwindigkeit von Dynein begrenzen könnte.

Zum Beispiel kann es sein, dass die Zelle nicht genug ATP hat, um Dynein schneller zu machen, oder die Proteinbewegungen, die für die Aktivität von Dynein erforderlich sind, konnten einfach nicht beschleunigt werden. In diesem Fall würde sich die Schwebung verbessern, wenn die Motoren trotz der physikalischen Grenzen schneller gemacht werden könnten. Eine dritte Möglichkeit besteht natürlich darin, dass die Änderung der Geschwindigkeit den Prozess nicht wesentlich beeinflusst, was für den Organismus von Vorteil sein könnte, indem es eine gewisse "Robustheit" gegenüber unkontrollierbaren Faktoren bietet. Unter diesen drei Möglichkeiten kann man die richtige identifizieren, indem man das Schwebungsmuster aus den Eigenschaften von Dynein berechnet. In der Tat sollte ein geeignetes mathematisches Modell vorhersagen, wie das Schwebungsmuster durch die Variation der Dynein-Geschwindigkeit beeinflusst wird und nicht den Grenzen unterliegt, die in der physikalischen Welt existieren. Natürlich muss die Gültigkeit des Modells überprüft werden, aber auch "falsche" Modelle können interessante Ideen hervorbringen.

Das Modell kann in Form eines analytischen Rahmens oder einer numerischen Simulation des Systems vorliegen. In jedem Fall bleibt die Lücke zwischen der molekularen und der funktionalen Skala ein Hindernis, und die Entwicklung dieser Modelle ist keine einfache Aufgabe, da mehrere mechanische und chemische Prozesse in die Gleichungen zur Beschreibung des biologischen Systems integriert werden müssen. Theorie gibt es in verschiedenen Formen, die unterschiedliche Kompromisse zwischen Einfachheit und Realismus bieten. Den Detaillierungsgrad in einem Modell zu erhöhen ist nicht immer vorteilhaft, da dies unsere Fähigkeit einschränken kann, die Gleichungen zu lösen oder, mit anderen Worten, die Vorhersagen der Theorie abzuleiten. Der gleiche Kompromiss gilt für Simulationen. Die Modellierer müssen die Bestandteile des Systems auswählen, die berücksichtigt werden sollen, wobei bestimmte Aspekte ignoriert werden. Diese Schlüsselentscheidungen werden stark vom Ziel der Studie abhängen. Heutzutage ermöglichen die außergewöhnlichen Verbesserungen in der Computerhardware die Simulation vieler Zytoskelettsysteme mit genügend Details über einen ausreichenden Zeitraum, um ihr Verhalten zu analysieren. Dies führt oft zu unerwarteten Ideen und neuen Richtungen in der Forschung. Zum Beispiel führten Simulationen, die denen ähneln, die in diesem Protokoll verwendet werden, zu einer Berechnung auf der Rückseite der Hüllkurve, die die Kontraktilität eines Netzwerks auf der Grundlage seiner Zusammensetzung^{vorhersagen kann 11}.

Numerische Methoden sind in den Ingenieur- und Physikwissenschaften allgegenwärtig, und ihre Anwendung in der Biologie nimmt zu. Heutzutage wurden praktisch alle unsere technologischen Dinge (Uhren, Telefone, Autos und Computer) zuerst auf einem Computer konzipiert, und es gibt leistungsstarke Software, um dies zu tun. Bei einem gut charakterisierten Zytoskelettsystem und unter der Annahme, dass ein angemessener Beschreibungsgrad bestimmt wurde, müssen noch einige Fragen gelöst werden, bevor es simuliert werden kann. Für die einfachsten Probleme könnte der geeignetste Weg darin bestehen, eine Simulation "durch Codierung von Grund auf" zu schreiben, mit anderen Worten, beginnend mit einer generischen Programmiersprache oder einer mathematischen Plattform wie MATLAB. Dies hat den Vorteil, dass der Autor des Codes eine genaue Kenntnis dessen hat, was implementiert wurde, und genau weiß, wie die Software funktioniert. Dieser Weg ist jedoch nicht ohne Risiken, und es ist nicht ungewöhnlich, dass Doktoranden den größten Teil ihrer Arbeitszeit damit verbringen, Code zu schreiben, anstatt sich mit wissenschaftlichen Fragestellungen zu befassen.

Die Alternative besteht darin, Software zu verwenden, die von anderen konzipiert wurde, aber auch das ist nicht ohne Risiken; Jeder große Quellcode neigt dazu, spontan die Züge einer undurchdringlichen Blackbox anzunehmen, trotz der bewundernswertesten Bemühungen seiner Autoren, dies zu verhindern. Die Verwendung von Black Boxes ist sicherlich nicht der Traum eines Wissenschaftlers. Ein großer Quellcode kann auch zu einer Belastung werden, und es kann schneller sein, bei Null anzufangen, als eine vorhandene Codebasis zu ändern, damit sie etwas anderes tut. Um dieses Problem zu entschärfen, kann man immer die Autoren der Software um Hilfe bitten, aber das reicht möglicherweise nicht aus. Häufig gibt es einen Unterschied in der Wissenschaftskultur zwischen den Autoren der Software und den Menschen, die sie nutzen möchten, was bedeutet, dass viele implizite Annahmen geklärt werden müssen. Durch die Open-Source-Veröffentlichung des Codes wird erwartet, dass mehr Personen in die Entwicklung der Software und die Pflege ihrer Dokumentation einbezogen werden, um so ihre Qualität zu verbessern. All dies sind wichtige Aspekte, die vor jeder Investition angemessen berücksichtigt werden müssen. Der einzige Weg, um langfristig voranzukommen, besteht jedoch darin, solide Softwarelösungen zu fördern, die von einer breiten Gemeinschaft mit gemeinsamen wissenschaftlichen Interessen genutzt und gepflegt werden.

Obwohl dieses Protokoll Cytosim verwendet, gibt es andere Open-Source-Tools, die in der Lage sein könnten, dasselbe System zu simulieren, z. B. AFINES¹², MEDYAN¹³, CyLaKS¹⁴, aLENS¹⁵ und AKYT¹⁶, um nur einige zu nennen. Leider würde der Vergleich dieser Projekte den Rahmen des Artikels sprengen. Hier wird eine Schritt-für-Schritt-Anleitung gegeben, um ein kontraktiles 2D-Aktomyosin-Netzwerk zu simulieren. Dieses System ist einfach und nutzt die besser etablierten Fähigkeiten von Cytosim. Cytosim basiert auf einer plattformübergreifenden Kern-Engine, die Simulationen in 2D oder 3D ausführen kann. Es verfügt über eine modulare Codebasis, die es leicht anpassbar macht, um bestimmte Aufgaben auszuführen. Cytosim ist in 3D gleichermaßen stabil und effizient und wurde in der Vergangenheit erfolgreich eingesetzt, um verschiedene Probleme mit Mikrotubuli und Aktinfilamenten zu untersuchen: die Assoziation von zwei Astern von Mikrotubuli¹⁷, die Bewegung von Zellkernen in den Zellen^18,19, die Endozytose⁶, die Zytokinese²⁰, die Bildung der mitotischen Spindel²¹, die Bewegungen der mitotischen Spindel²², Die Erfassung der Chromosomen²³, die Kontraktion der Aktomyosin-Netzwerke^11,24 und die Mechanik des Mikrotubuli-Rings in den Blutplättchen²⁵ sowie die für diese Projekte entwickelten Kapazitäten wurden im Code beibehalten. Der hier beschriebene Workflow kann auf viele weitere Problemstellungen angepasst werden. Es verwendet die Unix-Befehlszeile, die einigen Lesern möglicherweise nicht vertraut ist. Die Verwendung der Befehlszeile ist jedoch die portabelste und bequemste Methode, um den Prozess der Ausführung von Simulationen zu automatisieren. Integrierte grafische Benutzeroberflächen zielen darauf ab, einen einfachen, intuitiven Zugang zu einer Software zu bieten, was jedoch oft auf Kosten der Allgemeinheit geht. Das Ziel dieses Artikels ist es, einen Ansatz zu veranschaulichen, der leicht modifiziert oder an andere Probleme angepasst werden kann. Es werden Hinweise gegeben, um die Bedeutung der Befehle zu erklären.

Um ein Aktomyosin-Netzwerk zu simulieren, werden Filamente als orientierte Linien modelliert und durch Eckpunkte dargestellt, die über ihre Länge verteilt sind (Abbildung 1). Dabei handelt es sich um eine in der Polymerphysik übliche mittlere Beschreibungsebene, die die echte 3D-Natur der Filamente ignoriert, aber die Berechnung der Biegung ermöglicht. Filamente können an ihren Enden wachsen und schrumpfen, wobei sie verschiedenen Modellen folgen, die sowohl die Aktin- als auch die Mikrotubuli-Phänomenologie abdecken. In Zellen werden Filamente hauptsächlich durch Wechselwirkungen organisiert, die ihre Bewegung einschränken, z. B. die Anheftung an andere Filamente oder einfach die Gefangenschaft innerhalb der Zelle. In Cytosim sind alle diese Wechselwirkungen linearisiert und in einer großen Matrix²⁶ kombiniert. Die Gleichungen, die die Bewegung aller Filamentvertices beschreiben, werden aus dieser Matrix abgeleitet, wobei ein viskoses Medium und zufällig fluktuierende Terme angenommen werden, die die Brownsche Bewegung darstellen. Diese Gleichungen werden numerisch gelöst, um die Bewegung der Filamente zusammen mit allen auf sie wirkenden Kräften in einer selbstkonsistenten und effizienten Weise zu erhalten²⁶. Über diesem mechanischen Motor befindet sich ein stochastischer Motor, der diskrete Ereignisse simuliert, wie z. B. das Anheften und Ablösen von molekularen Motoren oder die Assemblierungsdynamik von Filamenten. Zusammenfassend lässt sich sagen, dass Cytosim erstens simulierte Dynamik verwendet, um die Mechanik eines Netzwerks von Filamenten zu berechnen, die auf beliebige Weise miteinander verbunden sind, und zweitens stochastische Methoden, um das Binden, Entbinden und Diffundieren von Proteinen zu simulieren, die die Filamente verbinden oder beeinflussen.

Der hier dargestellte Workflow wurde häufig befolgt, um zunächst ein System mit Cytosim zu untersuchen. Der kritische Schritt für viele potenzielle Nutzer dürfte die Installation der Softwarekomponenten sein. Die Distribution der Software als Quellcode erfüllt zwar die Gebote von Open Science, ist aber fehleranfällig, da die Entwickler der Software nur auf einen begrenzten Pool an Architektur zugreifen können, um das Programm zu testen. Die Kompilierung kann fehlschlagen, wenn sich die Betriebssysteme unterscheiden. Die hier bereitgestellten Anweisungen werden wahrscheinlich veraltet sein, wenn sich Computersysteme und Quellcodes weiterentwickeln. Daher ist es wichtig, die neuesten Anweisungen regelmäßig online zu überprüfen. Im Falle von Problemen wird dringend empfohlen, dass Benutzer sich melden, indem sie auf dem entsprechenden Feedback-Kanal (derzeit die Homepage von Cytosim auf Gitlab) posten, um das Problem zu beheben.

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

Protokoll

HINWEIS: Das Protokoll besteht aus den folgenden Schritten: Plattformvorbereitung für Windows 10, MacOS und Linux; die Installation von Cytosim; Konfiguration des Simulations- und Testlaufs und der grafischen Darstellung; mehrere Durchläufe, bei denen ein Parameter variiert wird: die Anzahl der Vernetzer im Netzwerk; Generieren eines Diagramms, um zu sehen, wie die Kontraktilität von der Anzahl der Vernetzer beeinflusst wird; parallele Läufe; und Zufallsstichproben. Alle Texte, die auf ein ">" folgen, sind Befehle, die wörtlich im Terminalfenster eingegeben werden müssen. Das ">" stellt die Eingabeaufforderung des Terminals dar und darf nicht enthalten sein, aber alle anderen Zeichen sind wichtig.

1. Vorbereitung der Plattform

HINWEIS: Führen Sie je nach Betriebssystem (MacOS, Windows 10 oder Linux) Schritt 1.1, Schritt 1.2 oder Schritt 1.3 aus.

1. Vorbereitung (MacOS)
   1. Installieren Sie die Xcode-Befehlszeilentools , indem Sie das Terminal (unter Anwendungen/Dienstprogramme) öffnen und Folgendes eingeben:
      Gt; xcode-select --install
   2. Um den Code von Cytosim anzuzeigen oder zu bearbeiten, installieren Sie Xcode aus dem Apple App Store (https://apps.apple.com/us/app/Xcode/id497799835?mt=12).
      HINWEIS: Der integrierte Editor von Xcode ist perfekt geeignet. Andere codeorientierte Editoren würden auch funktionieren, z. B. TextMate. Um TextMate zu verwenden, laden Sie es herunter und befolgen Sie die Anweisungen von https://macromates.com.
2. Vorbereitung (Windows)
   HINWEIS: Für Windows 10 oder höher kann Cytosim mit dem "Windows-Subsystem für Linux" (WSL) ausgeführt werden, wie unten beschrieben. Eine Alternative für eine ältere Version ist Cygwin, aber eine Anleitung wird hier nicht bereitgestellt.
   1. Aktualisieren Sie das Computerbetriebssystem, um die Anforderungen für WSL 2 zu erfüllen: Windows 10 Version 1903 oder höher, mit Build 18362 oder höher, für x64-Systeme und Version 2004 oder höher, mit Build 19041 oder höher, für ARM64-Systeme. Informationen zu nachfolgenden Versionsupdates finden Sie unter https://docs.microsoft.com/en-us/windows/release-health/release-information.
   2. Geben Sie Windows-Funktionen ein- und ausschalten in das Suchfeld der Taskleiste ein. Aktivieren Sie () die Plattform für virtuelle Maschinen und () das Windows-Subsystem für Linux manuell. Klicken Sie auf OK und starten Sie Windows neu .
   3. Gehen Sie zum Windows Microsoft Store und suchen Sie nach Ubuntu. Laden Sie das aktuelle Release herunter und installieren Sie es (Ubuntu 20.04 LTS vom 03.2022)
   4. Klicken Sie auf Starten , um das Ubuntu-Terminal zu starten. Wenn Sie aufgefordert werden, den neuesten WSL2-Linux-Kernel herunterzuladen, befolgen Sie die Anweisungen, die bereitgestellt werden. Installieren Sie das Update und starten Sie Ubuntu neu.
   5. Befolgen Sie die Anweisungen zum Terminal, um einen neuen UNIX-Benutzernamen einzugeben und ein Kennwort festzulegen. Sobald das Benutzerkonto eingerichtet ist, starten Sie Ubuntu über das Suchfeld in der Windows-Taskleiste. Öffnen Sie das Home-Verzeichnis (auch bekannt als ".") aus dem Befehlsfenster:
      > explorer.exe .
   6. Installieren Sie einen WSL-kompatiblen X-Window-Server, z. B. Xming: https://sourceforge.net/projects/xming/
   7. Starten Sie den X-Window-Server Xming durch Doppelklick auf das Xming-Symbol. Wählen Sie Mehrere Fenster aus. Öffnen Sie anschließend das Ubuntu-Terminal und folgen Sie Schritt 1.3 (Linux).
3. Vorbereitung (Linux)
   HINWEIS: Diese Anweisungen gelten für Linux-Distributionen, die den APT-Paketmanager verwenden. Diese Befehle müssen für Distributionen wie Red Hat Linux geändert werden, die einen anderen Paketmanager verwenden. Befolgen Sie in diesem Fall die Anweisungen der Linux-Distribution, um dieselben Pakete zu installieren.
   1. Aktualisieren Sie das Linux-System:
      > sudo apt-get update
      > sudo apt-get upgrade
   2. Installieren Sie einen C++-Compiler und GNUs make (https://www.gnu.org/software/make):
      > sudo apt-get install build-essential
   3. Installieren Sie BLAS/LAPACK-Bibliotheken (http://www.netlib.org/lapack):
      > sudo apt-get install libblas-dev liblapack-dev
   4. Installieren Sie die OpenGL-Entwicklerbibliothek und die Header-Dateien (https://www.mesa3d.org):
      > sudo apt-get install mesa-common-dev
   5. Installieren Sie die GLEW-Bibliothek (http://glew.sourceforge.net):
      > sudo apt-get install libglew-dev
   6. Installieren Sie die freeGLUT-Bibliothek (http://freeglut.sourceforge.net):
      > sudo apt-get install freeglut3-dev
   7. Installieren Sie das GIT-Versionskontrollsystem (https://git-scm.com):
      > sudo apt-get install git
   8. Installieren Sie die X11-Testprogramme (z.B. xeyes, xclock, xcalc):
      > sudo apt-get install x11-apps
   9. Passen Sie die Umgebungsvariable DISPLAY an:
      > Export DISPLAY=:0
      1. Versuchen Sie, ein X11-Fenster zu öffnen:
         > xeyes
      2. Wenn dies funktioniert, fahren Sie mit Schritt 2 fort. Wenn der Fehler beim Öffnen der Anzeige auftritt, versuchen Sie es mit einem anderen DISPLAY-Wert.
      3. Suchen Sie die IP-Adresse des WSL2-Computers:
         > Katze /etc/resolv.conf
      4. Wenn die IP-Nummer angezeigt wird, z.B. "nameserver 10.16.0.7", verwenden Sie diese IP-Nummer anstelle von X.X.X.X unten:
         > export DISPLAY= X.X.X.X:0
         > xeyes
      5. Wenn dies funktioniert, fahren Sie mit Schritt 2 fort. Wenn "play" nicht in der Lage ist, "die Anzeige zu öffnen", versuchen Sie, es aus einem "xterm"-Fenster heraus auszuführen:
         > sudo apt install xterm
         > xterm -display :0
      6. Geben Sie im neuen Fenster, das sich öffnet, Folgendes ein:
         > xeyes

2. Installation von Cytosim

HINWEIS: Diese Schritte sind für alle Betriebssysteme ähnlich: MacOS, WSL und Linux. Im folgenden Abschnitt werden Befehle im Terminal ausgegeben, und das "aktuelle Arbeitsverzeichnis" sollte auf das Verzeichnis gesetzt werden, in dem die Simulation kompiliert wurde. Dieses Verzeichnis wird als Basisverzeichnis bezeichnet. Alternativ kann alles in einem separaten Verzeichnis erledigt werden, wenn Dateien nach Bedarf kopiert werden. Wenn Sie mit der Befehlszeile nicht vertraut sind, sollten Sie ein Tutorial befolgen, z. B. https://www.learnenough.com/command-line-tutorial oder https://learnpythonthehardway.org/book/appendixa.html.

1. Laden Sie den Quellcode von Cytosim herunter:
   > git clone https://gitlab.com/f-nedelec/cytosim.git cytosim
   HINWEIS: Ein Gitlab-Konto ist nicht erforderlich, um den Code herunterzuladen. Dadurch sollte ein neues Unterverzeichnis "cytosim" im aktuellen Verzeichnis erstellt werden.
2. Kompilieren:
   > cd cytosim
   > machen
   1. Überprüfen Sie, ob drei Dateien in einem Subdirector-"bin" erstellt werden, indem Sie Folgendes ausführen:
      > ls bin
   2. Wenn Schritt 2.2.1 fehlschlägt, versuchen Sie diese alternative Methode zum Kompilieren, indem Sie cmake (https://cmake.org) installieren:
      > mkdir b
      > cd b
      > cmake ..
      > machen
      > cd ..
3. Überprüfen Sie die ausführbaren Dateien:
   > bin/sim-Informationen
   > Bin/Play-Info
   1. Stellen Sie sicher, dass beide ausführbaren Dateien kompiliert wurden, um 2D-Simulationen durchzuführen. Suchen Sie nach der folgenden Ausgabe der obigen "info"-Abfragen:
      Dimension: 2 Periodisch: 1 Genauigkeit: 8 Bytes
   2. Wenn dies nicht der Fall ist, und nur dann, ändern Sie die Datei "src/math/dim.h" (öffnen, bearbeiten, um DIM auf 2 zu ändern, speichern) und kompilieren Sie Cytosim neu:
      > sauber machen
      > machen
4. Testlauf
   1. Kopieren Sie drei ausführbare Dateien:
      > CP Bin/SIM SIM
      > CP Bin/Play Play
      > CP Bin/Report Report
   2. Erstellen Sie ein neues Verzeichnis:
      > mkdir ausführen
   3. Kopieren Sie die Standardkonfigurationsdatei, und benennen Sie sie um:
      > cp cym/fiber.cym run/config.cym
   4. Starten Sie die Simulation:
      > CD-Lauf
      > .. /sim
   5. Visualisieren Sie die Ergebnisse der Simulation:
      > .. /spielen
      1. Drücken Sie die Leertaste, um zu animieren. Drücken Sie h , um Hilfe zu Tastenkombinationen zu erhalten.
      2. Um das Programm zu beenden, versuchen Sie unter MacOS -Q oder STRG-Q oder wählen Sie Beenden aus dem Menü. Als letzten Ausweg geben Sie STRG-C in das Terminalfenster ein, von dem aus "Play" gestartet wurde.
   6. Im Live-Modus ausführen:
      > .. /live spielen

3. Konfiguration der Simulation

1. Installieren Sie einen codeorientierten Texteditor (z. B. TextMate, SublimeText), falls noch nicht verfügbar.
   Öffnen Sie den Editor und öffnen Sie die Datei "config.cym", die sich im Verzeichnis "run" befindet, das Sie in Schritt 2.4.2 erstellt haben. Machen Sie sich mit den verschiedenen Abschnitten der Konfigurationsdatei vertraut, die eine Kopie von "fiber.cym" (Ergänzungsdatei 1) ist.
   HINWEIS: Cytosim liest in der Regel nur eine Konfigurationsdatei, die auf ".cym" endet. Alle Änderungen werden hier in der "config.cym" vorgenommen. Eine Liste der Parameter finden Sie in der ergänzenden Tabelle S1 .
2. Ändern Sie die Simulation, indem Sie die folgenden Änderungen an "config.cym" vornehmen:
   Radius=5 → Radius=3
   neu 1 Filament → neu 100 Filament
3. Speichern Sie die Datei, ohne ihren Namen oder Speicherort zu ändern ("config.cym" überschreiben). Wechseln Sie zum Terminalfenster, und überprüfen Sie, ob die Simulation wie erwartet geändert wurde:
   > .. /live spielen
   HINWEIS: Der Radius des Kreises wird in Mikrometern (μm) angegeben, ebenso wie alle Abstände in Cytosim. Cytosim folgt einem System von Einheiten, die an die Größe der Zelle angepasst sind und aus Mikrometern, Piconewtonen und Sekunden abgeleitet werden.
4. Nehmen Sie im Abschnitt "Faserfilament einstellen" folgende Änderungen vor:
   Steifigkeit=20 → Steifigkeit=0,1
   Segmentierung= 0,5 → Segmentierung=0,2
   confine=innen, 200, Zelle → confine= innen, 10, Zelle
   Im Absatz "neues Filament" wird Folgendes geändert:
   Länge=12 → Länge=2
   Reduzieren Sie die zu simulierende Zeit, indem Sie Folgendes ändern:
   Run 5000 System → Run 1000 System
   HINWEIS: Dadurch werden die Eigenschaften des Filaments angepasst. Der Absatz "set" definiert persistente Eigenschaften der Filamente, während Parameter in "new" in der Regel Anfangsbedingungen sind. Die Biegesteifigkeit wird in pN^{μm 2} angegeben. Die Segmentierung ist der ungefähre Abstand zwischen den Eckpunkten, die die Filamente in Mikrometern (μm) beschreiben. Sie muss reduziert werden, wenn die Filamente flexibler gemacht werden. Die letzte Änderung verringert die Steifigkeit (pN/μm) des Einschlusspotentials, das mit den "Zell"-Kanten verbunden ist. Die im "neuen" Absatz angegebene Länge (2 μm) ist die Anfangslänge der Filamente, und da die Filamente in diesem Modell nicht dynamisch sind, ändern sich ihre Längen nicht. Es wird empfohlen, die Konfigurationsdatei zu signieren, indem Sie die erste Zeile bearbeiten:
   % Ihr Name, Datum, Ort
   1. Überprüfen Sie die Gültigkeit der Konfigurationsdatei (wiederholen Sie Schritt 3.3).
5. Erstellen Sie passive Konnektoren.
   1. Fügen Sie "config.cym" vor den Zeilen mit den Befehlen "new" und "run" einen neuen Absatz hinzu, um eine molekulare Aktivität mit Affinität zu den Filamenten zu definieren:
      Set Handbinder {
      binding_rate = 10
      binding_range = 0,01
      unbinding_rate = 0,2
      }
   2. Um bifunktionale Entitäten zu definieren, fügen Sie einen weiteren Absatz direkt darunter hinzu:
      set couple crosslinker {
      Hand1 = Ordner
      Hand2 = Ordner
      Steifigkeit = 100
      Diffusion = 10
      }
   3. Fügen Sie nach den vorherigen Absätzen und vor dem Befehl "run" einen "new"-Befehl hinzu:
      Neuer 1000 Vernetzer
      HINWEIS: In Cytosim werden die Raten in Einheiten von ^s-1 und der Bereich in Mikrometern (μm) angegeben. Die Steifigkeit wird in Einheiten von Piconewton pro Mikrometer (pN/μm) und der Diffusionskoeffizient in Mikrometern zum Quadrat pro Sekunde (μm²/s) angegeben. Die Reihenfolge der Befehle in der Konfigurationsdatei ist wichtig, und diese Absätze müssen vor jedem "Run"-Befehl stehen, da sie sonst nicht wirksam sind. Um mehr über die Objekte von Cytosim zu erfahren, folgen Sie dem Tutorial in "tuto_introduction.md", das sich in einem Unterordner "doc" des Basisverzeichnisses befindet: doc/tutorials/.
6. Entwickeln Sie bifunktionale Motoren.
   1. Fügen Sie einen neuen Absatz zu "config.cym" hinzu, vor den Zeilen mit den Befehlen "new" und "run":
      set Handmotor {
      binding_rate = 10
      binding_range = 0,01
      unbinding_rate = 0,2
      Aktivität = Verschieben
      unloaded_speed = 1
      stall_force = 3
      }
   2. Fügen Sie einen weiteren Absatz hinzu, der auf den vorherigen folgt:
      set couple complex {
      Hand1 = Motor
      Hand2 = Motor
      Steifigkeit = 100
      Diffusion = 10
      ​}
   3. Fügen Sie nach den vorherigen Absätzen und vor dem Befehl "run" einen "new"-Befehl hinzu:
      Neuer Komplex 200
      HINWEIS: Das "activity = move" gibt einen Motor an, der sich kontinuierlich über das Filament bewegt. Der Motor gehorcht einer linearen Kraft-Geschwindigkeits-Kurve (Abbildung 1), die durch die unbelastete Geschwindigkeit (μm/s) und die Stillstandskraft (piconewton) gekennzeichnet ist. Bei jedem Zeitschritt τ bewegt er sich um eine Entfernung, v × τ. Die Verwendung von "activity = none" würde ein Molekül angeben, das sich nicht bewegt, und da dies die Standardaktivität ist, könnte man "activity" einfach ganz weglassen. Andere Aktivitäten sind möglich, z.B. würde "Aktivität = Gehen" einen Motor mit diskreten Schritten entlang des Filaments spezifizieren. Das "unloaded_speed" ist positiv für einen plus-end-gerichteten Motor. Wenn Sie einen negativen Wert angeben, bewegt sich der Motor in Richtung der Minus-Enden. Dies wird im ersten Tutorial von Cytosim näher erläutert (siehe Link in Schritt 3.5.2).
7. Speichern Sie die Datei.
   Überprüfen Sie die Simulation:
   > .. /live spielen
   Führen Sie die Simulation aus:
   > .. /sim
   Visualisieren Sie die Ergebnisse:
   > .. /spielen
   Kopieren Sie die endgültige Konfigurationsdatei in das Basisverzeichnis:
   > cp config.cym .. /config.cym
   HINWEIS: Ihre endgültige Datei sollte ähnlich wie die Ergänzungsdatei 2 ("jove.cym") aussehen. Beachten Sie, wie viel Zeit für die Berechnung dieser Simulation benötigt wurde. In den folgenden Abschnitten wird diese Zeit mit der Anzahl der Simulationen multipliziert, die durchgeführt wurden, um ein Diagramm zu generieren, in dem ein Parameter variiert wird.

4. Parameter-Sweep

HINWEIS: In diesem Abschnitt wird die Anzahl der Vernetzer im Netzwerk systematisch variiert.

1. Importieren Sie Python-Skripte.
   1. Erstellen Sie ein Unterverzeichnis "byn" innerhalb des Basisverzeichnisses:
      > mkdir byn
   2. Kopieren Sie drei Skripte aus der Standard-Cytosim-Distribution:
      > cp python/run/preconfig.py byn/preconfig
      > cp python/look/scan.py byn/.
      > cp python/look/make_page.py byn/.
      HINWEIS: Aus Sicherheitsgründen werden Kopien dieser Dateien als Zusatzdatei 3, Zusatzdatei 4 und Zusatzdatei 5 mit diesem Artikel bereitgestellt.
2. Machen Sie die Dateien ausführbar:
   > chmod +x byn/preconfig
   > chmod +x byn/scan.py
   > chmod +x byn/make_page.py
   1. Überprüfen Sie, ob die Skripts korrekt ausgeführt werden:
      > byn/preconfig Hilfe
      > byn/scan.py Hilfe
      > byn/make_page.py Hilfe
      HINWEIS: Dies sollte eine Beschreibung ausgeben, wie jeder Befehl verwendet werden kann. Es ist möglich, die Variable PATH zu ändern, um die Skripte einfacher aufzurufen. Siehe https://en.wikipedia.org/wiki/PATH_(Variable).
   2. Fehlerbehebung
      1. Wenn der Fehler "Befehl nicht gefunden" lautet, überprüfen Sie den angegebenen Pfad, der dem Speicherort der Datei entsprechen sollte. Wenn es eine andere Art von Fehler gibt, weil das Betriebssystem python2 nicht bereitstellt, bearbeiten Sie die drei .py Dateien und ändern Sie den Shebang, der die erste Zeile jeder Datei ist (fügen Sie einfach "3" hinzu):
         #!/usr/bin/env python → #!/usr/bin/env python3
3. Kopieren Sie die Konfigurationsdatei, um sie zu einer "Vorlage" zu machen (Ergänzungsdatei 6):
   > cp config.cym config.cym.tpl
4. Bearbeiten Sie die Vorlagenkonfigurationsdatei. Öffnen Sie im Code-Editor die Datei "config.cym.tpl", die sich im Basisverzeichnis befindet. Ändern Sie eine Zeile, um ein variables Textelement einzuführen:
   Neu 1000 Vernetzer → Neu [[Bereich(0,4000,100)]] Vernetzer
   HINWEIS: Preconfig erkennt den Code, der in den doppelten eckigen Klammern enthalten ist, und ersetzt ihn durch einen Wert, der durch Ausführen dieses Codes in Python erhalten wurde. In Python gibt "range(X,Y,S)" ganze Zahlen von X bis Y mit einem Inkrement von S an; In diesem Fall [0, 100, 200, 300, ... 4000]. Die Absicht besteht darin, die Anzahl der Crosslinker zu ändern, die der Simulation hinzugefügt wurden.
5. Generieren Sie Konfigurationsdateien aus der Vorlage:
   > byn/preconfig run%04i/config.cym config.cym.tpl
   HINWEIS: Es sollten 40 Dateien erstellt werden, eine für jeden Wert, der in "range(0,4000,100)" angegeben ist. Die Namen der Dateien, die von Preconfig erzeugt werden sollen, werden mit "run%04i/config.cym" angegeben. Mit diesem speziellen Code generiert Preconfig "run0000/config.cym", "run0001/config.cym" usw. Es werden tatsächlich die Verzeichnisse "run0000", "run0001" usw. erstellt und in jedem von ihnen eine Datei "config.cym" erstellt. Weitere Informationen finden Sie in der Hilfe von Preconfig (führen Sie "byn/preconfig help" aus). Überprüfen Sie im Fehlerfall, ob der Befehl genau eingegeben wurde. Jeder Charakter zählt.
6. Führen Sie alle Simulationen nacheinander aus:
   > byn/scan.py '.. /sim' ausführen????
   HINWEIS: Das Programm "scan.py" führt den Befehl in Anführungszeichen in der Liste der bereitgestellten Verzeichnisse aus. In diesem Fall wird diese Liste von Verzeichnissen durch "run????" angegeben. Das Fragezeichen ist ein Platzhalter, der auf ein beliebiges Zeichen passt. Daher entspricht "run????" jedem Namen, der mit "run" beginnt und von genau vier Zeichen gefolgt wird. Alternativ könnte man "run*" verwenden, um die gleiche Liste zu erzeugen, da "*" auf jede Zeichenkette passt.
   1. Bei Problemen führen Sie diesen Befehl aus einem neuen Terminalfenster aus, um "sim" nacheinander in alle in Schritt 4.5 erstellten Verzeichnisse auszuführen. Warten Sie ca. 30 Minuten, bis der Vorgang abgeschlossen ist, aber dies hängt sehr stark von den Kapazitäten des Computers ab. Reduzieren Sie die Menge der angeforderten Berechnungen, indem Sie "config.cym" bearbeiten:
      Run 1000 System → Run 500 System
7. Visualisieren Sie einige Simulationen:
   > ./play run0010
   > ./play run0020
8. Generieren Sie Bilder für alle Simulationen:
   > byn/scan.py '.. /Bildgröße abspielen=256 frame=10' Lauf????
9. Generieren Sie eine HTML-Zusammenfassungsseite:
   > byn/make_page.py tile=5 ausführen????
   1. Öffnen Sie "page.html" in einem Webbrowser.

5. Erstellen eines Diagramms

HINWEIS: In diesem Abschnitt wird ein Diagramm aus den Ergebnissen des Parameters sweep erstellt.

1. Überprüfen Sie die ausführbare Datei des Berichts :
   > CD-Lauf
   > .. /report network:size
   HINWEIS: Für jedes Bild in der Trajektorie werden einige Kommentare und zwei Zahlen gedruckt, die "Polymer" und "Oberfläche" entsprechen. Es wird nur die "Oberfläche" des Netzwerks (letzte Spalte) verwendet.
   1. Beschränken Sie die Informationen speziell auf einen Frame mit:
      > .. /report network:size frame=10
   2. Entfernen Sie Kommentare, um die Verarbeitung der Ausgabe zu erleichtern:
      > .. /report network:size frame=10 ausführlich=0
   3. Leiten Sie schließlich die Ausgabe mithilfe der Unix-Pipe-Funktion (">") in eine Datei um:
      > .. /report network:size frame=10 ausführlich=0 > net.txt
   4. Drucken Sie den Inhalt der Datei zur Überprüfung in das Terminal:
      > Katze net.txt
      HINWEIS: Es sollten zwei Zahlen gedruckt werden. Die zweite ist die Fläche, die im 10. Frame vom Netzwerk bedeckt wird. Um die gleiche Operation in allen "run"-Verzeichnissen auszuführen, wechseln Sie das Verzeichnis:
      > cd ..
2. Generieren Sie einen Bericht in jedem Simulationsunterverzeichnis:
   > byn/scan.py '.. /report network:size frame=10 ausführlich=0 > net.txt' ausführen????
   HINWEIS: Auch hier führt scan.py den Befehl in Anführungszeichen in allen Verzeichnissen aus, die mit "run????" angegeben sind. Der Befehl ist der letzte, der in Schritt 5.1 versucht wurde. Dadurch wird in jedem Verzeichnis eine Datei "net.txt" erzeugt (versuchen Sie es mit "ls run????").
3. Untersuchen Sie diese Zahlen:
   > Byn/scan.py 'Katze net.txt'-Lauf????
   1. Fügen Sie die Option "+" hinzu, um den Namen des Verzeichnisses und die Ausgabe des Befehls zu verketten:
      > byn/scan.py + 'Katze net.txt' laufen????
4. Sammeln Sie diese Zahlen in einer Datei:
   > byn/scan.py + 'Katze net.txt' laufen???? > results.txt
5. Bereinigen Sie die Datei "results.txt", indem Sie den wiederholten Text löschen, der nicht numerisch ist. Öffnen Sie "result.txt" im Code-Editor, und verwenden Sie "text ersetzen", um alle "run"-Zeichenfolgen zu entfernen. Entfernen Sie nur drei Buchstaben und behalten Sie die Zahlen; "run0000" sollte zu "0000" werden.
   HINWEIS: Dadurch sollte eine Datei mit nur Zahlen übrig bleiben, die in drei Spalten organisiert sind.
6. Generieren Sie ein Kontraktilitätsdiagramm aus den Daten in "result.txt". Verwenden Sie eine beliebige Methode, um ein Diagramm mit Spalte 1 für X und Spalte 3 für Y zu erstellen. Beschriften Sie die X-Achse als Anzahl der Quervernetzer/100. Beschriften Sie die Y-Achse als Fläche (Mikrometer^2).
7. Speichern Sie alle Simulationen in einem separaten Verzeichnis:
   > mkdir speichern1
   > MV-Lauf???? speichern1

6. Alternative Methode zum Erstellen eines Diagramms

1. Fügen Sie am Ende von "config.cym.tpl" in einer neuen Zeile nach dem schließenden "}" des Ausführungsbefehls einen Report-Befehl hinzu:
   report network:size net.txt { verbose = 0 }
2. Generieren Sie Konfigurationsdateien:
   > byn/preconfig run%04i/config.cym config.cym.tpl
3. Führen Sie alle Simulationen mit parallelen Threads aus:
   > byn/scan.py '.. /sim' ausführen???? njobs=4
   1. Passen Sie die Anzahl der Aufträge (njobs=4) je nach Kapazität des Computers an. Überwachen Sie die Auslastung der CPU-Ressourcen, z. B. durch die Aktivitätsmonitor-App unter MacOS.
4. Sammeln Sie die Daten:
   > byn/scan.py + 'Katze net.txt' laufen???? > results.txt
5. Erstellen Sie einen Plot, wie in den Schritten 5.5 und 5.6.
6. Speichern Sie alle vorherigen Ausführungen in einem separaten Verzeichnis:
   > mkdir save2
   > MV-Lauf???? Speichern2

7. Verbessertes Diagramm mit Zufallsstichproben

HINWEIS: Hier wird eine Variable mit einer Generatorfunktion aus dem "random"-Modul von Python abgetastet.

1. Öffnen Sie im Code-Editor die Vorlagenkonfigurationsdatei "config.cym.tpl", die sich im Basisverzeichnis befindet. Fügen Sie zwei Zeilen direkt vor dem "neuen Crosslinker" hinzu:
   [[num = int(zufällig.uniform(0,4000))]]
   %[[num]] Xlinker
   Ändern Sie auch den Befehl "new", um diese Variable zu verwenden:
   Neuer [[Range(0,4000,100)]] Verlinker → Neuer [[NUM]] Verlinker
   HINWEIS: Die erste Zeile erzeugt eine Zufallsvariable "num". In der zweiten Zeile wird der Parameterwert ausgegeben. Das Zeichen "%" ist wichtig, da es Cytosim anweist, die Zeile zu überspringen. Bald wird "xlinkers" als erkennbares Tag dienen, und es muss nur einmal in jeder Datei vorkommen.
   1. Stellen Sie ganz am Ende von "config.cym.tpl" sicher, dass es eine Berichtsanweisung gibt:
      report network:size net.txt { verbose = 0 }
2. Generieren Sie Konfigurationsdateien:
   > byn/preconfig run%04i/config.cym 42 config.cym.tpl
   HINWEIS: Dadurch sollten 42 Dateien generiert werden. Diese Zahl kann erhöht werden, wenn der Computer schnell genug ist. Die zufällig generierten Werte können mit dem Unix-Tool "grep" zur Suche nach Dateien eingesehen werden:
   > grep xlinkers laufen???? /config.cym
3. Führen Sie alle Simulationen parallel aus:
   > byn/scan.py '.. /sim' ausführen???? njobs=4
   HINWEIS: Passen Sie die Anzahl der Aufträge an die Kapazität des Computers an. Um die besten Ergebnisse zu erzielen, sollte die Variable "njobs" gleich der Anzahl der Kerne des Computers gesetzt werden.
4. Erfassen Sie die Daten mit einem einzigen Befehl:
   > byn/scan.py + 'grep xlinkers config.cym; Cat net.txt' Run???? > results.txt
   HINWEIS: Die Option "+" von scan.py verkettet die gesamte Ausgabe des Befehls in einer einzigen Zeile. In diesem Fall besteht der Befehl tatsächlich aus zwei Befehlen, die durch eine halbe Spalte (";") getrennt sind. Die Datenerfassung kann jederzeit mit einem Python-Skript automatisiert werden.
5. Bereinigen Sie die Datei. Öffnen Sie "result.txt" im Code-Editor. Um sicherzustellen, dass alle Daten, die einer Simulation entsprechen, in einer Zeile enthalten sind, löschen Sie alle Vorkommen der Zeichenfolge "xlinkers" und entfernen Sie die "%"-Zeichen am Anfang jeder Zeile. Speichern Sie abschließend "result.txt", das übersichtlich in drei Spalten mit numerischen Werten organisiert sein sollte.
6. Erstellen Sie ein Diagramm, um die Daten darzustellen, indem Sie Schritt 5.6 wiederholen, aber beschriften Sie die X-Achse als Anzahl der Quervernetzer
7. Speichern Sie das Dataset in einem neuen Unterverzeichnis:
   >mkdir set1
   > MV-Lauf???? set1/.
   > MV results.txt Set1/.
8. Berechnen Sie ein weiteres Dataset, indem Sie die Schritte 7.2 bis 7.6 wiederholen, und wiederholen Sie dann Schritt 7.8, indem Sie in allen drei Befehlen "set1" durch "set2" ersetzen.
9. Erstellen Sie einen kombinierten Plot.
   1. Verketten Sie die beiden Datendateien:
      > Katzen-Set?/results.txt > results.txt
      HINWEIS: Das neue "result.txt" sollte größer sein.
   2. Zeichnen Sie die Daten, um ein kombiniertes Diagramm zu erstellen, wie in Schritt 7.7 beschrieben.

8. Vollautomatische Rohrleitung

HINWEIS: In diesem Teil werden alle Vorgänge, die einen manuellen Eingriff erfordern, durch Befehle ersetzt. Wenn dies erledigt ist, wird es möglich sein, ein einzelnes Skript zu schreiben, das alle Schritte automatisch ausführt. Dieses Skript kann auf einem Remotecomputer, z. B. einer Computefarm, ausgeführt werden.

1. Verwenden Sie den Unix-Befehl "sed", um die results.txt Datei zu "säubern", und ersetzen Sie Schritt 7.6.
   1. Entfernen Sie das "%" am Anfang von Zeilen:
      > sed -e 's/%//g' results.txt > tmp.txt
   2. "xlinkers" entfernen:
      > sed -e 's/xlinkers//g' tmp.txt > results.txt
2. Schreiben Sie ein Skript, um alle Befehle nacheinander in der richtigen Reihenfolge aufzurufen.
   1. Verwenden Sie verschiedene Sprachen: bash oder Python.
   2. Erstellen Sie die Datei "pipeline.bash", und kopieren Sie alle Befehle, die zum Ausführen der Pipeline erforderlich sind.
   3. Führen Sie das Skript aus:
      > bash pipeline.bash
3. Verwenden Sie ein automatisiertes Plotskript.
   HINWEIS: Es kann von Vorteil sein, alle manuellen Eingriffe zu entfernen. Es gibt viele Werkzeuge, um einen PDF-Plot direkt aus einer Datendatei zu generieren, z. B. gnuplot (http://www.gnuplot.info), PyX (https://pyx-project.org) oder Seplot (https://pypi.org/project/seplot/).

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

Ergebnisse

In Abschnitt 2 sollte die erfolgreiche Kompilierung von Cytosim mit »make« im Unterverzeichnis »bin« zu sim, play und report führen. Die Ausgabe von Schritt 2.3 ("sim-Info") sollte unter anderem "Dimension: 2" anzeigen. In Abschnitt 3 sollte die Konfigurationsdatei ähnlich wie jove.cym aussehen, die als Ergänzungsdatei 1 bereitgestellt wird. In Abschnitt 4 sollten diein Schritt 4.8 aus Simulationen ermittelten Werte ähnlich wie i...

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

Diskussion

Die in diesem Artikel skizzierte Methode stützt sich auf drei kleine und unabhängige Python-Programme, die im gesamten beschriebenen Protokoll auf unterschiedliche Weise verwendet wurden. Das erste Skript preconfig ist ein vielseitiges Werkzeug, das das Schreiben von benutzerdefinierten Python-Skripten ersetzen kann²⁷. Es wird verwendet, um mehrere Konfigurationsdateien aus einer einzigen Vorlagendatei zu generieren, wobei angegeben wird, welcher Parame...

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

Materialien

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