Een typische workflow om cytoskeletsystemen te simuleren

Samenvatting

Dit protocol laat zien hoe Cytosim, een Open Source cytoskeletsimulatie, kan worden gebruikt om het gedrag te onderzoeken van een netwerk van filamenten verbonden door moleculaire motoren en passieve crosslinkers. Een generieke workflow met stapsgewijze instructies wordt gevolgd om het aantal crosslinkers te variëren en de resulterende netwerkcontractiliteit in kaart te brengen.

Samenvatting

Veel cytoskeletale systemen zijn nu voldoende bekend om hun nauwkeurige kwantitatieve modellering mogelijk te maken. Microtubuli- en actinefilamenten zijn goed gekarakteriseerd en de bijbehorende eiwitten zijn vaak bekend, evenals hun overvloed en de interacties tussen deze elementen. Computersimulaties kunnen dus worden gebruikt om het collectieve gedrag van het systeem nauwkeurig te onderzoeken, op een manier die complementair is aan experimenten. Cytosim is een Open Source cytoskelet simulatiesuite die is ontworpen om grote systemen van flexibele filamenten met bijbehorende eiwitten zoals moleculaire motoren te verwerken. Het biedt ook de mogelijkheid om passieve crosslinkers, diffusibele crosslinkers, nucleators, cutters en discrete versies van de motoren te simuleren die alleen op onbezette roosterplaatsen op een filament stappen. Andere objecten vullen de filamenten aan door sferische of meer gecompliceerde geometrie te bieden die kan worden gebruikt om chromosomen, de kern of blaasjes in de cel weer te geven.

Cytosim biedt eenvoudige opdrachtregeltools voor het uitvoeren van een simulatie en het weergeven van de resultaten, die veelzijdig zijn en geen programmeervaardigheden vereisen. In deze workflow worden stap-voor-stap instructies gegeven om i) de benodigde omgeving op een nieuwe computer te installeren, ii) Cytosim te configureren om de samentrekking van een 2D-actomyosinenetwerk te simuleren, en iii) een visuele weergave van het systeem te produceren. Vervolgens wordt het systeem onderzocht door systematisch een sleutelparameter te variëren: het aantal crosslinkers. Ten slotte wordt de visuele weergave van het systeem aangevuld met de numerieke kwantificering van contractiliteit om in een grafiek te zien hoe contractiliteit afhangt van de samenstelling van het systeem. Over het algemeen vormen deze verschillende stappen een typische workflow die met weinig aanpassingen kan worden toegepast om vele andere problemen op het gebied van het cytoskelet aan te pakken.

Inleiding

Het cytoskelet bestaat uit filamenten in de cel en bijbehorende moleculen zoals moleculaire motoren, die vaak een dynamisch netwerk vormen met opmerkelijke mechanische eigenschappen. Het cytoskelet bestaat in verschillende configuraties in verschillende celtypen in bijna alle levensvormen. De juiste werking ervan is essentieel voor fundamentele cellulaire processen zoals deling, beweeglijkheid en polarisatie. Het regelt ook de mechanische interacties van cel tot cel, waardoor de morfogenese van weefsels en organismen wordt beïnvloed. Het cytoskelet heeft verschillende functies en manifesteert zich in veel biologische processen. De samentrekking van spieren is bijvoorbeeld gekoppeld aan de arbeidsslag van moleculaire myosinemotoren op actinefilamenten. Een ander voorbeeld is het onderhoud van neuronen, dat afhankelijk is van de bewegingen van kinesinemotoren langs microtubuli die zich in de axonen van deze neuronen bevinden. Actine en microtubuli zijn twee vooraanstaande soorten cytoskeletfilamenten, en zonder hen zou het leven zoals we dat kennen onmogelijk zijn.

Het cytoskelet is in wezen een biomechanisch systeem, dat niet alleen kan worden teruggebracht tot zijn chemie. Microtubuli of actinefilamenten zijn opgebouwd uit duizenden monomeren en strekken zich uit over enkele micrometers. De conformaties van deze filamenten in de ruimte en de krachten die ze kunnen overbrengen op het plasmamembraan, de kern of andere organellen zijn belangrijke aspecten van hun rol in de cel. Een netwerk van actinefilamenten en myosinemotoren, de actomyosinecortex¹ genaamd, genereert bijvoorbeeld krachten om de celmotiliteit en morfologische veranderingen in dierlijke cellen in stand te houden. Een heel andere rangschikking is te zien in plantencellen, waar corticale microtubuli de afzetting van cellulosefibrillen sturen, waardoor de celwandarchitectuur wordt gecontroleerd, die uiteindelijk bepaalt hoe deze cellen in de toekomst zullen groeien².

Hoewel mechanica duidelijk een substantiële rol speelt bij cytoskeletale operaties, is chemie net zo belangrijk. Filamenten groeien via een zelfassemblageproces waarbij monomeren hun aanmeerplaats vinden aan het uiteinde van het filament nadat ze door het cytoplasma zijn diffunderen³. Op moleculaire schaal worden assemblage en demontage aan het uiteinde van de filamenten dus bepaald door moleculaire affiniteiten⁴. Op dezelfde manier diffunderen eiwitten van het cytoskelet, en bindings- en ontbindingssnelheden bepalen hun affiniteit voor de filamenten die ze tegenkomen. In het geval van moleculaire motoren zijn cycli van chemische reacties waarbij ATP-hydrolyse betrokken is, gekoppeld aan bewegingen langs de filamenten en mogelijk de krachten die daarmee gepaard gaan⁵. Opmerkelijk is dat het cytoskelet veel ongebruikelijke uitdagingen biedt en een grote verscheidenheid aan processen met vergelijkbare componenten. Het is een rijke speeltuin op het snijvlak van biologie, scheikunde en natuurkunde.

Cytoskeletale systemen zijn vatbaar voor wiskundige modellering. Dankzij uitstekend onderzoek dat in de afgelopen decennia is gedaan, zijn de belangrijkste moleculaire bestanddelen hoogstwaarschijnlijk al geïdentificeerd, zoals geïllustreerd met endocytose⁶. In modelorganismen, zoals gist, zijn de eigenschappen van deze elementen bekend, evenals de systeemsamenstelling voor sommige van hun processen. Zo zijn bijvoorbeeld de structuur en materiaaleigenschappen van microtubuli⁷, evenals hun aantal en gemiddelde lengte in verschillende stadia van de mitotische spoel, beschreven⁸. Het aantal kinesines dat microtubuli verbindt tot een coherente mechanische structuur is vaak bekend⁹. De toerentallen van veel motoren zijn gemeten in vitro¹⁰. Bovendien kunnen experimentalisten deze systemen in vivo observeren en kwantificeren onder wildtype of gemuteerde omstandigheden. Door theorie te combineren met in vivo en in vitro experimenten kunnen onderzoekers testen of de huidige kennis over een cytoskelet voldoende is om het waargenomen gedrag te verklaren. Het gebruik van wiskundige en computationele hulpmiddelen stelt ons ook in staat om conclusies te trekken over hoe componenten samenwerken op basis van aannames die zijn afgeleid van waarnemingen op moleculaire schaal, meestal in vereenvoudigde situaties (bijv. experimenten met één molecuul).

De rol van de theorie kan worden geïllustreerd aan de hand van een praktisch voorbeeld: het slaan van trilharen. Dit kloppen is te wijten aan de beweging van dyneïnemotoren langs microtubuli in de trilharen. Men kan zich afvragen wat de snelheid van de dyneïnemotor in dit systeem bepaalt. Een mogelijk antwoord is dat de maximale snelheid wordt beperkt door de eis om een bepaald slagpatroon aan te houden. Dit zou begrijpelijk zijn als het pak slaag onder natuurlijke selectie was. In dat geval, als motoren sneller zouden bewegen, zou het proces zijn gewenste eigenschappen verliezen - de trilharen zouden niet zo efficiënt kloppen of zelfs helemaal falen. Hoewel dit mogelijk is, is een tweede alternatief dat een intrinsieke factor de snelheid van dyneïne zou kunnen beperken.

Het kan bijvoorbeeld zijn dat de cel niet genoeg ATP heeft om dyneïne sneller te maken, of dat de eiwitbewegingen die nodig zijn voor de activiteit van dyneïne gewoon niet kunnen worden versneld. In dat geval, als de motoren ondanks de fysieke limieten sneller zouden kunnen worden gemaakt, zou de slagkracht worden verbeterd. Een derde mogelijkheid is natuurlijk dat het veranderen van de snelheid geen significante invloed heeft op het proces, wat voordelig kan zijn voor het organisme door enige "robuustheid" te bieden tegen oncontroleerbare factoren. Van deze drie mogelijkheden kan men de juiste identificeren door het kloppatroon te berekenen op basis van de eigenschappen van dyneïne. Een geschikt wiskundig model zou inderdaad moeten voorspellen hoe het slagpatroon wordt beïnvloed door variërende dyneïnesnelheid en niet onderhevig is aan de limieten die in de fysieke wereld bestaan. Natuurlijk moet de geldigheid van het model worden geverifieerd, maar zelfs "onjuiste" modellen kunnen interessante ideeën opleveren.

Het model kan de vorm aannemen van een analytisch raamwerk of een numerieke simulatie van het systeem zijn. Hoe dan ook, de kloof tussen de moleculaire schaal en de functionele schaal blijft een obstakel, en het ontwikkelen van deze modellen is geen eenvoudige taak, aangezien verschillende mechanische en chemische processen moeten worden geïntegreerd in de vergelijkingen die het biologische systeem beschrijven. Theorie is er in verschillende vormen en biedt verschillende afwegingen tussen eenvoud en realisme. Het verhogen van de mate van details in een model is niet altijd voordelig, omdat het ons vermogen kan beperken om de vergelijkingen op te lossen of, met andere woorden, om de voorspellingen van de theorie af te leiden. Dezelfde afweging bestaat voor simulaties. De modelbouwers zullen de ingrediënten van het systeem moeten selecteren waarmee rekening moet worden gehouden, terwijl ze bepaalde aspecten negeren. Deze belangrijke beslissingen zullen sterk afhangen van het doel van het onderzoek. Tegenwoordig maken de buitengewone verbeteringen in computerhardware het mogelijk om veel cytoskeletale systemen te simuleren met voldoende details gedurende een voldoende lange tijd om hun gedrag te analyseren. Dit zal vaak onverwachte ideeën en nieuwe richtingen in het onderzoek opleveren. Simulaties die vergelijkbaar zijn met de simulaties die in dit protocol zullen worden gebruikt, hebben bijvoorbeeld geleid tot een back-of-the-envelope-berekening die de contractiliteit van een netwerk kan voorspellen op basis van de samenstelling¹¹.

Numerieke methoden zijn alomtegenwoordig in de technische en natuurwetenschappen, en het gebruik ervan in de biologie neemt toe. Tegenwoordig is vrijwel al onze technologische whatchamacallit (horloges, telefoons, auto's en computers) voor het eerst bedacht op een computer, en er bestaat krachtige software om dit te doen. Gegeven een goed gekarakteriseerd cytoskeletaal systeem en ervan uitgaande dat een geschikt beschrijvingsniveau is bepaald, moeten er nog verschillende problemen worden opgelost voordat het kan worden gesimuleerd. Voor de eenvoudigste problemen is de meest geschikte manier van handelen misschien om een simulatie te schrijven "door helemaal opnieuw te coderen", met andere woorden, te beginnen met een generieke programmeertaal of een wiskundig platform zoals MATLAB. Dit heeft als voordeel dat de auteur van de code een grondige kennis heeft van wat er is geïmplementeerd en precies weet hoe de software werkt. Deze route is echter niet zonder risico, en het is niet ongebruikelijk om te zien dat promovendi het grootste deel van hun werktijd besteden aan het schrijven van code in plaats van aan het beantwoorden van wetenschappelijke vragen.

Het alternatief is om software te gebruiken die door anderen is bedacht, maar ook dit is niet zonder risico's; Elke grote broncode heeft de neiging om spontaan de eigenschappen van een ondoordringbare zwarte doos te verwerven, ondanks de meest bewonderenswaardige inspanningen van hun auteurs om dit te voorkomen. Het gebruik van zwarte dozen is zeker niet de droom van een wetenschapper. Een grote broncode kan ook een verplichting worden, en het kan sneller zijn om helemaal opnieuw te beginnen dan om een bestaande codebasis aan te passen om deze iets anders te laten doen. Om dit probleem te verhelpen, kan men altijd de auteurs van de software uitnodigen om te helpen, maar dit is misschien niet voldoende. Vaak is er een verschil in wetenschappelijke cultuur tussen de auteurs van de software en de mensen die het willen gebruiken, wat betekent dat veel impliciete aannames moeten worden opgehelderd. Door de code Open Source te maken, wordt verwacht dat er meer mensen betrokken zullen zijn bij de ontwikkeling van de software en het onderhouden van de documentatie, waardoor de kwaliteit ervan verbetert. Dit zijn allemaal belangrijke zaken die goed in overweging moeten worden genomen voordat er een investering wordt gedaan. Desalniettemin is de enige manier om op de lange termijn vooruitgang te boeken het promoten van solide softwareoplossingen, die worden gebruikt en onderhouden door een brede gemeenschap met gemeenschappelijke wetenschappelijke interesses.

Hoewel dit protocol gebruikmaakt van Cytosim, zijn er andere Open Source-tools die mogelijk hetzelfde systeem kunnen simuleren, bijvoorbeeld AFINES¹², MEDYAN¹³, CyLaKS¹⁴, aLENS¹⁵ en AKYT¹⁶, om er maar een paar te noemen. Helaas valt het vergelijken van deze projecten buiten het bestek van het artikel. Hier worden stapsgewijze instructies gegeven om een contractiel 2D-actomyosinenetwerk te simuleren. Dit systeem is eenvoudig en maakt gebruik van de beter ingeburgerde capaciteiten van Cytosim. Cytosim is gebouwd rond een platformonafhankelijke kernengine die simulaties in 2D of 3D kan uitvoeren. Het heeft een modulaire codebasis, waardoor het gemakkelijk kan worden aangepast om bepaalde taken uit te voeren. Cytosim is even stabiel en efficiënt in 3D en is in het verleden met succes gebruikt om diverse problemen met microtubuli en actinefilamenten te onderzoeken: de associatie van twee asters van microtubuli¹⁷, de beweging van kernen in de cellen^18,19, endocytose⁶, cytokinese²⁰, de vorming van de mitotische spoel²¹, de bewegingen van de mitotische spoel²², De vangst van chromosomen²³, de samentrekking van actomyosinenetwerken^11,24 en de mechanica van de microtubuli-ring in bloedplaatjes²⁵, en de capaciteiten die voor deze projecten zijn ontwikkeld, zijn in de code gehandhaafd. De hier beschreven workflow kan worden aangepast aan vele andere problemen. Het maakt gebruik van de Unix-commandoregel, die voor sommige lezers misschien onbekend is. Het gebruik van de opdrachtregel is echter de meest draagbare en handige manier om het proces van het uitvoeren van simulaties te automatiseren. Geïntegreerde grafische gebruikersinterfaces zijn bedoeld om gemakkelijke, intuïtieve toegang tot software te bieden, maar dit gaat vaak ten koste van de algemeenheid. Het doel van dit artikel is om een aanpak te illustreren die gemakkelijk kan worden aangepast of aangepast aan andere problemen. Er worden aantekeningen gegeven om de betekenis van de commando's uit te leggen.

Om een actomyosinenetwerk te simuleren, worden filamenten gemodelleerd als georiënteerde lijnen en weergegeven door hoekpunten die over hun lengte zijn verdeeld (Figuur 1). Dit is een tussenliggend beschrijvingsniveau, gebruikelijk in de polymeerfysica, dat de echte 3D-aard van de filamenten negeert, maar het mogelijk maakt om de buiging te berekenen. Filamenten kunnen aan hun uiteinden groeien en krimpen, volgens verschillende modellen die zowel actine- als microtubuli-fenomenologie omvatten. In cellen worden filamenten voornamelijk georganiseerd door interacties die hun beweging beperken, bijvoorbeeld de aanhechting aan andere filamenten of gewoon opsluiting in de cel. In Cytosim worden al dergelijke interacties gelineariseerd en gecombineerd in een grote matrix²⁶. De vergelijkingen die de beweging van alle hoekpunten van filamenten beschrijven, zijn afgeleid van deze matrix, uitgaande van een stroperig medium en willekeurig fluctuerende termen die de Brownse beweging vertegenwoordigen. Deze vergelijkingen worden numeriek opgelost om de beweging van de filamenten samen met alle krachten die erop inwerken op een zelfconsistente en efficiënte manier te verkrijgen²⁶. Bovenop deze mechanische motor is er een stochastische motor die discrete gebeurtenissen simuleert, zoals de aanhechtingen en onthechtingen van moleculaire motoren of de assemblagedynamiek van filamenten. Samenvattend gebruikt Cytosim ten eerste gesimuleerde dynamica om de mechanica te berekenen van een netwerk van filamenten, op een willekeurige manier verbonden, en ten tweede stochastische methoden om het binden, ontbinden en diffuseren van eiwitten die de filamenten verbinden of beïnvloeden te simuleren.

De hier geïllustreerde workflow werd vaak gevolgd om in eerste instantie een systeem te verkennen met behulp van Cytosim. De cruciale stap voor veel potentiële gebruikers is waarschijnlijk de installatie van de softwarecomponenten. Het distribueren van de software als broncode voldoet aan de eisen van Open Science, maar is vatbaar voor fouten omdat de ontwikkelaars van de software slechts toegang hebben tot een beperkte pool van architectuur om het programma te testen. Compilatie kan mislukken omdat besturingssystemen verschillen. De instructies die hier worden gegeven, zullen waarschijnlijk achterhaald raken naarmate computersystemen en broncodes evolueren. Het is dus essentieel om regelmatig de nieuwste instructies online te controleren. In geval van problemen wordt het ten zeerste aangemoedigd dat gebruikers verslag uitbrengen door een bericht te plaatsen op het relevante feedbackkanaal (momenteel de startpagina van Cytosim op Gitlab) om het probleem op te lossen.

Protocol

OPMERKING: Het protocol bestaat uit de volgende stappen: platformvoorbereiding voor Windows 10, MacOS en Linux; de installatie van Cytosim; configuratie van de simulatie en testrun en de grafische weergave; meerdere runs, variërend van een parameter: het aantal crosslinkers in het netwerk; het genereren van een grafiek om te zien hoe contractiliteit wordt beïnvloed door het aantal crosslinkers; parallelle runs; en willekeurige steekproeven. Alle tekst die volgt op een ">" zijn commando's die letterlijk in het terminalvenster moeten worden ingevoerd. De ">" staat voor de terminalprompt en mag niet worden opgenomen, maar alle andere tekens zijn belangrijk.

1. Voorbereiding van het platform

OPMERKING: Afhankelijk van het besturingssysteem (MacOS, Windows 10 of Linux) volgt u stap 1.1, stap 1.2 of stap 1.3.

1. Voorbereiding (MacOS)
   1. Installeer Xcode Command Line Tools door de Terminal te openen (in Toepassingen/Hulpprogramma's) en voer het volgende in:
      Gt; xcode-select --installeren
   2. Om de code van Cytosim te bekijken of te bewerken, installeert u Xcode vanuit de Apple App Store (https://apps.apple.com/us/app/Xcode/id497799835?mt=12).
      OPMERKING: De ingebouwde editor van Xcode is perfect geschikt. Andere code-georiënteerde editors zouden ook werken, bijvoorbeeld TextMate. Om TextMate te gebruiken, downloadt en volgt u de instructies van https://macromates.com.
2. Voorbereiding (Windows)
   OPMERKING: Voor Windows 10 of hoger kan Cytosim worden uitgevoerd met behulp van het "Windows-subsysteem voor Linux" (WSL), zoals hieronder beschreven. Een alternatief voor een oudere versie is Cygwin, maar instructies worden hier niet gegeven.
   1. Werk het besturingssysteem van de computer bij om te voldoen aan de vereisten voor WSL 2: Windows 10 versie 1903 of hoger, met build 18362 of hoger, voor x64-systemen en versie 2004 of hoger, met build 19041 of hoger, voor ARM64-systemen. Kijk op https://docs.microsoft.com/en-us/windows/release-health/release-information voor volgende versie-updates.
   2. Typ Windows-functies in- en uitschakelen in het zoekvak van de taakbalk. Schakel handmatig () Virtual Machine Platform en () Windows-subsysteem voor Linux in. Klik op OK en start Windows opnieuw op .
   3. Ga naar Windows Microsoft Store en zoek naar Ubuntu. Download en installeer de huidige release (Ubuntu 20.04 LTS vanaf 03.2022)
   4. Klik op Starten om de Ubuntu-terminal te starten. Als u wordt gevraagd om de nieuwste WSL2 Linux-kernel te downloaden, gaat u verder met het volgen van de instructies die worden verstrekt. Installeer de update en start Ubuntu opnieuw.
   5. Volg de instructies van de terminal om een nieuwe UNIX-gebruikersnaam in te voeren en een wachtwoord in te stellen. Zodra het gebruikersaccount is ingesteld, start u Ubuntu vanuit het zoekvak van de Windows-taakbalk. Open de thuismap (ook wel ".") genoemd vanuit het opdrachtvenster:
      > explorer.exe .
   6. Installeer een WSL-compatibele X-Window-server, bijvoorbeeld Xming: https://sourceforge.net/projects/xming/
   7. Start de X-Window server, Xming door te dubbelklikken op het Xming icoon; selecteer Meerdere vensters. Open hierna de Ubuntu-terminal en volg stap 1.3 (Linux).
3. Voorbereiding (Linux)
   OPMERKING: Deze instructies zijn geschikt voor Linux-distributies die de APT-pakketbeheerder gebruiken. Deze commando's moeten worden aangepast voor distributies zoals Red Hat Linux die een andere pakketbeheerder gebruiken. Volg in dit geval de instructies van de Linux-distributie om dezelfde pakketten te installeren.
   1. Werk het Linux-systeem bij:
      > sudo apt-get update
      > sudo apt-get upgrade
   2. Installeer een C++ compiler en GNU's maken (https://www.gnu.org/software/make):
      > sudo apt-get install build-essential
   3. BLAS/LAPACK-bibliotheken installeren (http://www.netlib.org/lapack):
      > sudo apt-get install libblas-dev liblapack-dev
   4. Installeer de OpenGL-ontwikkelaarsbibliotheek en headerbestanden (https://www.mesa3d.org):
      > sudo apt-get install mesa-common-dev
   5. Installeer de GLEW-bibliotheek (http://glew.sourceforge.net):
      > sudo apt-get install libglew-dev
   6. Installeer de freeGLUT-bibliotheek (http://freeglut.sourceforge.net):
      > sudo apt-get installeren freeglut3-dev
   7. Installeer het GIT-versiebeheersysteem (https://git-scm.com):
      > sudo apt-get install git
   8. Installeer de X11 testprogramma's (bijv. xeyes, xclock, xcalc):
      > sudo apt-get installeren x11-apps
   9. Pas de omgevingsvariabele DISPLAY aan:
      > exporteren DISPLAY=:0
      1. Probeer een X11-venster te openen:
         > xeyes
      2. Als dit werkt, ga dan verder met stap 2. Als de fout niet lukt om het scherm te openen, probeer dan een andere DISPLAY-waarde.
      3. Zoek het IP-adres van de WSL2-machine:
         > kat /etc/resolv.conf
      4. Als het IP-nummer verschijnt, bijvoorbeeld "nameserver 10.16.0.7", gebruik dan dit IP-nummer in plaats van X.X.X.X hieronder:
         > EXPORTEREN DISPLAY= X.X.X.X:0
         > xeyes
      5. Als dit werkt, ga dan verder met stap 2. Als "play" er niet in slaagt om het scherm te openen, probeer het dan uit te voeren vanuit een "xterm"-venster:
         > sudo apt installeren xterm
         > xterm -weergave :0
      6. Typ in het nieuwe venster dat wordt geopend:
         > xeyes

2. Installatie van Cytosim

OPMERKING: Deze stappen zijn vergelijkbaar voor elk besturingssysteem: MacOS, WSL en Linux. In de volgende sectie worden opdrachten gegeven in de terminal en moet de "huidige werkmap" worden ingesteld op de map waarin de simulatie is gecompileerd. Deze map wordt de basismap genoemd. Als alternatief kan alles in een aparte map worden gedaan als de bestanden naar behoefte worden gekopieerd. Als u niet bekend bent met de opdrachtregel, kunt u overwegen een tutorial te volgen, bijvoorbeeld https://www.learnenough.com/command-line-tutorial of https://learnpythonthehardway.org/book/appendixa.html.

1. Download de broncode van Cytosim:
   > git kloon https://gitlab.com/f-nedelec/cytosim.git cytosim
   LET OP: Een Gitlab-account is niet nodig om de code te downloaden. Dit zou een nieuwe subdirectory "cytosim" moeten aanmaken in de huidige directory.
2. Compileren:
   > CD cytosim
   > maken
   1. Controleer of er drie bestanden zijn gemaakt in een subdirector "bin" door het volgende uit te voeren:
      > ls prullenbak
   2. Als stap 2.2.1 mislukt, probeer dan deze alternatieve methode om te compileren door cmake (https://cmake.org) te installeren:
      > mkdir b
      > cd b
      > cmake ..
      > maken
      > cd ..
3. Uitvoerbare bestanden controleren:
   > prullenbak/sim-info
   > informatie over prullenbak/afspelen
   1. Controleer of beide uitvoerbare bestanden zijn gecompileerd om 2D-simulaties uit te voeren. Zoek naar de volgende uitvoer van de "info"-query's hierboven:
      Afmeting: 2 Periodiek: 1 Precisie: 8 bytes
   2. Als dit niet het geval is, en alleen dan, wijzig dan het bestand "src/math/dim.h" (openen, bewerken om DIM te wijzigen in 2, opslaan) en compileer Cytosim opnieuw:
      > schoon maken
      > maken
4. Proefdraaien
   1. Kopieer drie uitvoerbare bestanden:
      > cp bin/sim sim
      > cp bin/play afspelen
      > cp bin/rapport rapport
   2. Maak een nieuwe map:
      > mkdir rennen
   3. Kopieer en hernoem het standaardconfiguratiebestand:
      > cp cym/fiber.cym uitvoeren/config.cym
   4. Start de simulatie:
      > cd-run
      > .. /Sim
   5. Visualiseer de resultaten van de simulatie:
      > .. /spelen
      1. Druk op de spatiebalk om te animeren. Druk op h voor hulp bij sneltoetsen.
      2. Om het programma af te sluiten, probeer op MacOS -Q of CTRL-Q, of selecteer Afsluiten in het menu. Voer als laatste redmiddel CTRL-C in het terminalvenster in van waaruit het "afspelen" is gestart.
   6. Uitvoeren in live-modus:
      > .. /Speel live

3. Configuratie van de simulatie

1. Installeer een code-georiënteerde teksteditor (bijv. TextMate, SublimeText) als deze nog niet beschikbaar is.
   Open de editor en open het bestand "config.cym", dat zich in de map "run" bevindt die in stap 2.4.2 is gemaakt. Raak vertrouwd met de verschillende secties van het configuratiebestand, dat een kopie is van "fiber.cym" (aanvullend bestand 1).
   OPMERKING: Cytosim leest meestal slechts één configuratiebestand dat eindigt op ".cym". Alle wijzigingen worden hier doorgevoerd in "config.cym". Zie aanvullende tabel S1 voor een lijst met parameters.
2. Wijzig de simulatie door de volgende wijzigingen aan te brengen in "config.cym":
   straal=5 → straal=3
   nieuw 1 filament → nieuw 100 filament
3. Sla het bestand op zonder de naam of locatie te wijzigen (overschrijf "config.cym"). Schakel over naar het terminalvenster en controleer of de simulatie is aangepast zoals verwacht met:
   > .. /Speel live
   OPMERKING: De straal van de cirkel wordt gespecificeerd in micrometers (μm), net als alle afstanden in Cytosim. Cytosim volgt een systeem van eenheden die zijn aangepast aan de schaal van de cel, afgeleid van micrometers, piconewtons en seconden.
4. Breng in de paragraaf "stel vezelfilament" de volgende wijzigingen aan:
   stijfheid = 20 → stijfheid = 0,1
   segmentatie= 0,5 → segmentatie=0,2
   confine=binnen, 200, cel → confine= binnen, 10, cel
   Wijzig in de paragraaf "nieuw filament":
   lengte=12 → lengte=2
   Verkort de tijd die moet worden gesimuleerd door het volgende te wijzigen:
   Run 5000 systeem → Run 1000 systeem
   OPMERKING: Hiermee worden de eigenschappen van het filament aangepast. De paragraaf "set" definieert de persistente eigenschappen van de filamenten, terwijl parameters in "nieuw" meestal beginvoorwaarden zijn. De buigstijfheid wordt gespecificeerd in pN μm². De segmentatie is de geschatte afstand tussen de hoekpunten die de filamenten in micrometers (μm) beschrijven. Het moet worden verminderd als filamenten flexibeler worden gemaakt. De laatste verandering vermindert de stijfheid (pN/μm) van het opsluitingspotentiaal dat verband houdt met de "cel"-randen. De lengte die in de "nieuwe" alinea wordt aangegeven (2 μm) is de initiële lengte van de filamenten, en aangezien de filamenten in dit model niet dynamisch zijn, zal hun lengte niet veranderen. Het wordt aanbevolen om het configuratiebestand te ondertekenen door de eerste regel te bewerken:
   % Uw naam, datum, plaats
   1. Controleer de geldigheid van het configuratiebestand (herhaal stap 3.3).
5. Maak passieve connectoren.
   1. Voeg een nieuwe alinea toe aan "config.cym", vóór de regels met de commando's "new" en "run", om een moleculaire activiteit te definiëren met affiniteit voor de filamenten:
      Set handbinder {
      binding_rate = 10
      binding_range = 0,01
      unbinding_rate = 0,2
      }
   2. Om bifunctionele entiteiten te definiëren, voegt u hieronder nog een alinea toe:
      set paar crosslinker {
      hand1 = bindmiddel
      hand2 = bindmiddel
      stijfheid = 100
      Diffusie = 10
      }
   3. Voeg een "new" commando toe na de vorige alinea's en voor het "run" commando:
      Nieuwe 1000 crosslinker
      OPMERKING: In Cytosim worden de snelheden gespecificeerd in eenheden van ^s-1 en het bereik in micrometers (μm). De stijfheid wordt gespecificeerd in eenheden van piconewton per micrometer (pN/μm) en de diffusiecoëfficiënt in micrometers in het kwadraat per seconde (μm²/s). De volgorde van de opdrachten in het configuratiebestand is belangrijk en deze alinea's moeten vóór elke "run"-opdracht verschijnen, anders zijn ze niet effectief. Om meer te weten te komen over de objecten van Cytosim, volgt u de tutorial in "tuto_introduction.md", die zich in een submap "doc" van de basismap bevindt: doc/tutorials/.
6. Creëer bifunctionele motoren.
   1. Voeg een nieuwe alinea toe aan "config.cym", voor de regels met de opdracht "new" en "run":
      set handmotor {
      binding_rate = 10
      binding_range = 0,01
      unbinding_rate = 0,2
      activiteit = bewegen
      unloaded_speed = 1
      stall_force = 3
      }
   2. Voeg nog een alinea toe, na de vorige:
      Set paar complex {
      hand1 = motor
      hand2 = motor
      stijfheid = 100
      Diffusie = 10
      ​}
   3. Voeg een "new" commando toe na de vorige alinea's en voor het "run" commando:
      Nieuw 200 complex
      OPMERKING: De "activiteit = beweging" specificeert een motor die continu over het filament beweegt. De motor gehoorzaamt aan een lineaire kracht-snelheidscurve (Figuur 1) die wordt gekenmerkt door de onbelaste snelheid (μm/s) en de overtrekkracht (piconewton). Bij elke tijdstap, τ, beweegt het met een afstand, v × τ. Het gebruik van "activiteit = geen" zou een molecuul specificeren dat niet beweegt, en aangezien dit de standaardactiviteit is, zou men "activiteit" gewoon helemaal kunnen weglaten. Andere activiteiten zijn mogelijk, bijvoorbeeld, "activiteit = lopen" zou een motor specificeren met discrete stappen langs het filament. De "unloaded_speed" is positief voor een plus-end gerichte motor. Het opgeven van een negatieve waarde zou de motor naar de min-uiteinden doen bewegen. Dit wordt verder uitgelegd in de eerste tutorial van Cytosim (zie link in stap 3.5.2).
7. Sla het bestand op.
   Bekijk de simulatie:
   > .. /Speel live
   Voer de simulatie uit:
   > .. /Sim
   Visualiseer de resultaten:
   > .. /spelen
   Kopieer het definitieve configuratiebestand naar de basismap:
   > cp config.cym .. /config.cym
   OPMERKING: Je uiteindelijke bestand moet gelijk zijn aan Aanvullend Bestand 2 ("jove.cym"). Merk op hoeveel tijd er nodig was om deze simulatie te berekenen. In de volgende paragrafen wordt deze tijd vermenigvuldigd met het aantal simulaties dat is gemaakt om een grafiek te genereren waarin een parameter wordt gevarieerd.

4. Parameter opruimen

OPMERKING: In dit hoofdstuk wordt het aantal crosslinkers in het netwerk systematisch gevarieerd.

1. Python-scripts importeren.
   1. Maak een subdirectory "byn", in de basisdirectory:
      > mkdir byn
   2. Kopieer drie scripts uit de standaard Cytosim-verdeling:
      > cp python/run/preconfig.py byn/preconfig
      > cp python/look/scan.py byn/.
      > cp python/look/make_page.py byn/.
      OPMERKING: Voor de veiligheid worden kopieën van deze bestanden bij dit artikel geleverd als aanvullend bestand 3, aanvullend bestand 4 en aanvullend bestand 5 .
2. Maak de bestanden uitvoerbaar:
   > chmod +x byn/preconfig
   > Chmod +x byn/scan.py
   > chmod +x byn/make_page.py
   1. Controleer of de scripts correct worden uitgevoerd:
      > byn/preconfig hulp
      > byn/scan.py hulp
      > byn/make_page.py hulp
      OPMERKING: Dit zou een beschrijving moeten weergeven van hoe elk commando kan worden gebruikt. Het is mogelijk om de PATH-variabele aan te passen om de scripts eenvoudiger aan te roepen; Zie https://en.wikipedia.org/wiki/PATH_(variabele).
   2. Probleemoplossing
      1. Als de fout "opdracht niet gevonden" is, controleert u het opgegeven pad, dat moet overeenkomen met de locatie van het bestand. Als er een ander type fout is omdat het besturingssysteem geen python2 biedt, bewerk dan de drie .py bestanden en wijzig de shebang, die de eerste regel van elk bestand is (voeg gewoon "3" toe):
         #!/usr/bin/env python → #!/usr/bin/env python3
3. Kopieer het configuratiebestand om er een "sjabloon" van te maken (aanvullend bestand 6):
   > cp config.cym config.cym.tpl
4. Bewerk het sjabloonconfiguratiebestand. Open in de code-editor het bestand "config.cym.tpl", dat zich in de basismap bevindt. Wijzig één regel om een variabel tekstelement in te voegen:
   nieuwe 1000 crosslinker → nieuwe [[bereik(0,4000,100)]] crosslinker
   OPMERKING: Preconfig herkent de code tussen de dubbele haken en vervangt deze door een waarde die wordt verkregen door deze code in Python uit te voeren. In Python specificeert "range(X,Y,S)" gehele getallen van X tot Y, met een toename van S; In dit geval [0, 100, 200, 300, ... 4000]. De bedoeling is om het aantal crosslinkers dat aan de simulatie wordt toegevoegd te wijzigen.
5. Genereer configuratiebestanden op basis van de sjabloon:
   > byn/preconfig run%04i/config.cym config.cym.tpl
   OPMERKING: Dit zou 40 bestanden moeten maken, één voor elke waarde die is gespecificeerd in "bereik(0,4000,100)". De namen van de bestanden die door Preconfig moeten worden gegenereerd, worden gespecificeerd door "run%04i/config.cym". Met deze specifieke code genereert Preconfig "run0000/config.cym", "run0001/config.cym", enz. Het zal de mappen "run0000", "run0001", enz. maken en in elk van hen een bestand "config.cym" maken. Raadpleeg de help van Preconfig voor meer details (voer "byn/preconfig help" uit). Controleer in geval van een fout of de opdracht precies is getypt. Elk personage telt.
6. Voer alle simulaties opeenvolgend uit:
   > byn/scan.py '.. /sim' uitvoeren????
   OPMERKING: Het programma "scan.py" voert de opdracht uit die wordt vermeld in de lijst met meegeleverde mappen. In dit geval wordt deze lijst met mappen gespecificeerd met "run????". Het vraagteken is een joker die overeenkomt met een bepaald personage. Daarom komt "run????" overeen met elke naam die begint met "run" en gevolgd door precies vier tekens. Als alternatief zou men "run*" kunnen gebruiken om dezelfde lijst te genereren, aangezien "*" overeenkomt met elke string.
   1. In geval van problemen, voert u deze opdracht uit vanuit een nieuw terminalvenster om "sim" achtereenvolgens uit te voeren in alle mappen die in stap 4.5 zijn gemaakt. Wacht ongeveer 30 minuten totdat het proces is voltooid, maar dit hangt sterk af van de computercapaciteit. Verminder de hoeveelheid berekening die nodig is door "config.cym" te bewerken:
      Run 1000-systeem → Run 500-systeem
7. Visualiseer enkele simulaties:
   > ./speel run0010
   > ./speel run0020
8. Genereer afbeeldingen voor alle simulaties:
   > byn/scan.py '.. /play afbeelding grootte=256 frame=10' run????
9. Een HTML-overzichtspagina genereren:
   > byn/make_page.py tile=5 run????
   1. Open "page.html" in een webbrowser.

5. Een grafiek maken

OPMERKING: In deze sectie wordt een plot gemaakt van de resultaten van de parameter sweep.

1. Controleer het uitvoerbare bestand :
   > cd-run
   > .. /report netwerk:size
   OPMERKING: Voor elk frame in het traject worden enkele opmerkingen en twee nummers afgedrukt, die overeenkomen met "polymeer" en "oppervlak". Alleen het netwerk "oppervlak" (laatste kolom) wordt gebruikt.
   1. Beperk de informatie specifiek tot één frame met behulp van:
      > .. /report netwerk:size frame=10
   2. Verwijder opmerkingen om de uitvoer gemakkelijker te verwerken:
      > .. /report netwerk:size frame=10 breedsprakig=0
   3. Leid ten slotte de uitvoer om naar een bestand met behulp van de Unix-pipe-faciliteit (">"):
      > .. /report netwerk:size frame=10 breedsprakig=0 > net.txt
   4. Druk de inhoud van het bestand af naar de terminal voor verificatie:
      > kat net.txt
      OPMERKING: Dit zou twee getallen moeten afdrukken. De tweede is het oppervlak dat door het netwerk wordt bedekt in het 10e frame. Om dezelfde bewerking uit te voeren in alle "run"-mappen, wijzigt u de map:
      > cd ..
2. Genereer een rapport in elke simulatiesubdirectory:
   > byn/scan.py '.. /report network:size frame=10 verbose=0 > net.txt' run????
   OPMERKING: Nogmaals, scan.py zal de geciteerde opdracht uitvoeren in alle mappen die zijn gespecificeerd door "run????". De opdracht is de laatste die in stap 5.1 is geprobeerd. Dit genereert een bestand "net.txt" in elke map (probeer "ls run????").
3. Onderzoek deze cijfers:
   > byn/scan.py 'cat net.txt'-run????
   1. Voeg de optie "+" toe om de naam van de map en de uitvoer van de opdracht samen te voegen:
      > byn/scan.py + 'cat net.txt' run????
4. Verzamel deze nummers in een bestand:
   > byn/scan.py + 'cat net.txt' run???? > results.txt
5. Reinig het bestand "results.txt" door de herhaalde tekst te verwijderen die niet numeriek is. Open "result.txt" in de code-editor en gebruik de "replace text" om alle "run"-strings te verwijderen. Verwijder slechts drie letters en behoud de cijfers; "run0000" moet "0000" worden.
   OPMERKING: Dit zou een bestand moeten achterlaten met alleen nummers die in drie kolommen zijn georganiseerd.
6. Genereer een contractiliteitsplot op basis van de gegevens in "result.txt". Gebruik een willekeurige methode om een plot te genereren met kolom 1 voor X en kolom 3 voor Y. Label de X-as als het aantal crosslinkers/100. Label de Y-as als oppervlak (micrometer^2).
7. Sla alle simulaties op in een aparte map:
   > mkdir bespaar1
   > mv lopen???? Bespaar 1

6. Alternatieve methode voor het maken van een grafiek

1. Voeg een rapportopdracht toe aan het einde van "config.cym.tpl" op een nieuwe regel na het sluiten van de "}" van de opdracht uitvoeren:
   Rapport Network:Size net.txt { uitgebreid = 0 }
2. Configuratiebestanden genereren:
   > byn/preconfig run%04i/config.cym config.cym.tpl
3. Voer alle simulaties uit met behulp van parallelle threads:
   > byn/scan.py '.. /sim' uitvoeren???? njobs=4
   1. Pas het aantal taken aan (njobs=4), afhankelijk van de capaciteit van de computer. Bewaak het gebruik van de CPU-bronnen, bijvoorbeeld door de Activity Monitor-app op MacOS.
4. Verzamel de gegevens:
   > byn/scan.py + 'cat net.txt' run???? > results.txt
5. Maak een tekening, hetzelfde als in stap 5.5 en 5.6.
6. Sla alle voorgaande uitvoeringen op in een aparte map:
   > mkdir save2
   > mv lopen???? Bespaar 2

7. Verbeterde plot met behulp van willekeurige steekproeven

OPMERKING: Een variabele wordt hier gesampled met behulp van een generatorfunctie uit de "willekeurige" module van Python.

1. Open in de code-editor het sjabloonconfiguratiebestand "config.cym.tpl", dat zich in de basismap bevindt. Voeg twee regels toe, net voor de "nieuwe crosslinker":
   [[num = int(willekeurig.uniform(0,4000))]]
   %[[num]] xlinkers
   Verander ook de opdracht "nieuw" om deze variabele te gebruiken:
   nieuwe [[range(0,4000,100)]] crosslinker → nieuwe [[num]] crosslinker
   OPMERKING: De eerste regel maakt een willekeurige variabele "num". Op de tweede regel wordt de parameterwaarde afgedrukt. Het teken "%" is belangrijk omdat het Cytosim instrueert om de regel over te slaan. Binnenkort zal "xlinkers" dienen als een herkenbare tag, en het hoeft slechts één keer in elk bestand te voorkomen.
   1. Zorg ervoor dat er helemaal aan het einde van "config.cym.tpl" een rapportinstructie is:
      Rapport Network:Size net.txt { uitgebreid = 0 }
2. Configuratiebestanden genereren:
   > byn/preconfig run%04i/config.cym 42 config.cym.tpl
   OPMERKING: Dit zou 42 bestanden moeten opleveren. Dit aantal kan worden verhoogd als de computer snel genoeg is. De willekeurig gegenereerde waarden kunnen worden bekeken door de Unix-tool "grep" te gebruiken om bestanden te doorzoeken:
   > grep xlinkers draaien???? /config.cym
3. Voer alle simulaties parallel uit:
   > byn/scan.py '.. /sim' uitvoeren???? njobs=4
   OPMERKING: Pas het aantal taken aan de capaciteit van de computer aan. Voor de beste resultaten moet de variabele "njobs" gelijk worden gesteld aan het aantal cores van de computer.
4. Verzamel de gegevens met behulp van een enkele opdracht:
   > byn/scan.py + 'grep xlinkers config.cym; Kat net.txt rennen???? > results.txt
   OPMERKING: De optie "+" van scan.py voegt alle uitvoer van de opdracht samen tot één regel. In dit geval bestaat het commando eigenlijk uit twee commando's die worden gescheiden door een halve kolom (";"). Het verzamelen van gegevens kan altijd worden geautomatiseerd met een Python-script.
5. Schoon het bestand op. Open "result.txt" in de code-editor. Om ervoor te zorgen dat alle gegevens die overeenkomen met één simulatie op één regel staan, verwijdert u alle exemplaren van de tekenreeks "xlinkers" en verwijdert u de "%"-tekens aan het begin van elke regel. Sla ten slotte "result.txt" op, die netjes moet worden georganiseerd in drie kolommen met numerieke waarden.
6. Maak een grafiek om de gegevens uit te zetten door stap 5.6 te herhalen, maar label de X-as als het aantal crosslinkers
7. Sla de dataset op in een nieuwe submap:
   >mkdir set1
   > mv lopen???? set1/.
   > mv results.txt set1/.
8. Bereken een andere gegevensset door de stappen 7.2-7.6 te herhalen en herhaal vervolgens stap 7.8, waarbij u "set1" vervangt door "set2" in alle drie de opdrachten.
9. Maak een gecombineerd perceel.
   1. Voeg de twee gegevensbestanden samen:
      > kattenset?/results.txt > results.txt
      OPMERKING: De nieuwe "result.txt" moet groter zijn.
   2. Plot gegevens om een gecombineerde grafiek te maken, zoals beschreven in stap 7.7.

8. Volledig geautomatiseerde pijplijn

OPMERKING: In dit deel worden alle handelingen die handmatige tussenkomst vereisen, vervangen door commando's. Wanneer dit is gebeurd, is het mogelijk om een enkel script te schrijven dat alle stappen automatisch uitvoert. Dit script kan worden uitgevoerd op een externe computer, zoals een compute farm.

1. Gebruik het Unix "sed" commando om het results.txt bestand "op te schonen", ter vervanging van stap 7.6.
   1. Verwijder de "%" aan het begin van de regels:
      > sed -e 's/%//g' results.txt > tmp.txt
   2. Verwijder "xlinkers":
      > sed -e 's/xlinkers//g' tmp.txt > results.txt
2. Schrijf een script om alle commando's achtereenvolgens in de juiste volgorde aan te roepen.
   1. Gebruik verschillende talen: bash of Python.
   2. Maak een bestand "pipeline.bash" en kopieer alle opdrachten die nodig zijn om de pipeline uit te voeren.
   3. Voer het script uit:
      > bash pipeline.bash
3. Gebruik een geautomatiseerd plotscript.
   OPMERKING: Het kan voordelig zijn om alle handmatige interventie te verwijderen. Er bestaan veel tools om een PDF-plot rechtstreeks uit een gegevensbestand te genereren, bijvoorbeeld gnuplot (http://www.gnuplot.info), PyX (https://pyx-project.org) of Seplot (https://pypi.org/project/seplot/).

Resultaten

In sectie 2 zou een succesvolle compilatie van Cytosim met behulp van "make" sim, play en report moeten opleveren in de subdirectory "bin". De uitvoer van stap 2.3 ("sim info") moet onder andere "Dimensie: 2" aangeven. In sectie 3 moet het configuratiebestand vergelijkbaar zijn met jove.cym, geleverd als aanvullend bestand 1. In sectie 4 moeten demagiërs die in stap 4.8 uit simulaties zijn verkregen, vergelijkbaar zijn met die in

Discussie

De methode die in dit artikel wordt beschreven, is gebaseerd op drie kleine en onafhankelijke Python-programma's, die op verschillende manieren werden gebruikt in het beschreven protocol. De eerste script-preconfig is een veelzijdige tool die de noodzaak voor het schrijven van aangepaste Python-scripts²⁷ kan vervangen. Het wordt gebruikt om meerdere configuratiebestanden te genereren uit een enkel sjabloonbestand, waarbij wordt gespecificeerd welke parame...

Materialen

Lijst van materialen gebruikt in dit artikel

Naam	Bedrijf	Catalogusnummer	Opmerkingen
Een personal computer			MacOS, Windows 10 of Linux
config.cym.tpl			sjabloon configuratiebestand; https://gitlab.com/f-nedelec/cytosim.git
jove.cym			Cytosim configuratiebestand
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