Un flusso di lavoro tipico per simulare i sistemi citoscheletrici

Summary

Questo protocollo dimostra come utilizzare Cytosim, una simulazione di citoscheletro Open Source, per studiare il comportamento di una rete di filamenti collegati da motori molecolari e reticolanti passivi. Viene seguito un flusso di lavoro generico con istruzioni dettagliate per variare il numero di reticolanti e tracciare la contrattilità di rete risultante.

Abstract

Molti sistemi citoscheletrici sono ora sufficientemente noti da consentire la loro precisa modellazione quantitativa. I filamenti di microtubuli e actina sono ben caratterizzati e le proteine associate sono spesso note, così come la loro abbondanza e le interazioni tra questi elementi. Pertanto, le simulazioni al computer possono essere utilizzate per studiare con precisione il comportamento collettivo del sistema, in un modo che è complementare agli esperimenti. Cytosim è una suite di simulazione di citoscheletro open source progettata per gestire grandi sistemi di filamenti flessibili con proteine associate come i motori molecolari. Offre inoltre la possibilità di simulare reticolanti passivi, reticolanti diffusibili, nucleatori, taglierine e versioni discrete dei motori che calpestano solo i siti reticolari non occupati su un filamento. Altri oggetti completano i filamenti offrendo una geometria sferica o più complicata che può essere utilizzata per rappresentare i cromosomi, il nucleo o le vescicole nella cellula.

Cytosim offre semplici strumenti a riga di comando per l'esecuzione di una simulazione e la visualizzazione dei risultati, che sono versatili e non richiedono competenze di programmazione. In questo flusso di lavoro, vengono fornite istruzioni dettagliate per i) installare l'ambiente necessario su un nuovo computer, ii) configurare Cytosim per simulare la contrazione di una rete di actomiosina 2D e iii) produrre una rappresentazione visiva del sistema. Successivamente, il sistema viene sondato variando sistematicamente un parametro chiave: il numero di reticolanti. Infine, la rappresentazione visiva del sistema è completata dalla quantificazione numerica della contrattilità per visualizzare, in un grafico, come la contrattilità dipenda dalla composizione del sistema. Nel complesso, questi diversi passaggi costituiscono un tipico flusso di lavoro che può essere applicato con poche modifiche per affrontare molti altri problemi nel campo del citoscheletro.

Introduction

Il citoscheletro è costituito da filamenti all'interno della cellula e da molecole associate come i motori molecolari, che spesso costituiscono un reticolo dinamico con notevoli proprietà meccaniche. Il citoscheletro esiste in varie configurazioni in diversi tipi di cellule in quasi tutte le forme di vita. Il suo corretto funzionamento è essenziale per processi cellulari fondamentali come la divisione, la motilità e la polarizzazione. Governa anche le interazioni meccaniche cellula-cellula, influenzando così la morfogenesi dei tessuti e degli organismi. Il citoscheletro è alla base di diverse funzioni e si manifesta in molti processi biologici. Ad esempio, la contrazione dei muscoli è legata al colpo di potenza dei motori molecolari della miosina sui filamenti di actina. Un altro esempio è il mantenimento dei neuroni, che si basa sui movimenti dei motori delle chinesine lungo i microtubuli situati all'interno degli assoni di questi neuroni. L'actina e i microtubuli sono due tipi preminenti di filamenti citoscheletrici e senza di essi la vita come la conosciamo sarebbe impossibile.

Il citoscheletro è essenzialmente un sistema biomeccanico, che non può essere ridotto solo alla sua chimica. I microtubuli o filamenti di actina sono costituiti da migliaia di monomeri e si estendono per diversi micrometri. Le conformazioni di questi filamenti nello spazio e le forze che possono trasmettere alla membrana plasmatica, al nucleo o ad altri organelli sono aspetti chiave del loro ruolo nella cellula. Ad esempio, una rete di filamenti di actina e motori della miosina, chiamata corteccia¹ dell'actomiosina, genera forze per sostenere la motilità cellulare e i cambiamenti morfologici nelle cellule animali. Una disposizione molto diversa si osserva nelle cellule vegetali, dove i microtubuli corticali dirigono la deposizione di fibrille di cellulosa, controllando così l'architettura della parete cellulare, che in ultima analisi determina come queste cellule cresceranno in futuro².

Mentre la meccanica gioca chiaramente un ruolo sostanziale nelle operazioni del citoscheletro, la chimica è altrettanto importante. I filamenti crescono attraverso un processo di autoassemblaggio in cui i monomeri trovano il loro sito di aggancio sulla punta del filamento dopo essersi diffusi attraverso il citoplasma³. Su scala molecolare, l'assemblaggio e lo smontaggio sulla punta dei filamenti sono, quindi, determinati dalle affinità molecolari⁴. Allo stesso modo, le proteine del citoscheletro si diffondono e i tassi di legame e dislegame determinano la loro affinità per i filamenti che incontrano. Nel caso dei motori molecolari, i cicli di reazioni chimiche che coinvolgono l'idrolisi dell'ATP sono legati ai movimenti lungo i filamenti e, possibilmente, alle forze che li accompagnano⁵. Sorprendentemente, il citoscheletro offre molte sfide insolite e una grande varietà di processi che coinvolgono componenti simili. È un ricco parco giochi all'interfaccia tra biologia, chimica e fisica.

I sistemi citoscheletrici sono suscettibili di modellazione matematica. Infatti, grazie alle eccellenti ricerche condotte negli ultimi decenni, i principali costituenti molecolari sono molto probabilmente già identificati, come illustrato con l'endocitosi⁶. Negli organismi modello, come il lievito, le proprietà di questi elementi sono note, così come la composizione del sistema per alcuni dei loro processi. Ad esempio, sono state descritte la struttura e le proprietà del materiale dei microtubuli⁷, così come il loro numero e la lunghezza media nei vari stadi del fuso mitotico⁸. Il numero di chinesine che collegano i microtubuli in una struttura meccanica coerente è spesso noto⁹. Le velocità di molti motori sono state misurate in vitro¹⁰. Inoltre, gli sperimentatori possono osservare e quantificare questi sistemi in vivo in condizioni wild-type o mutate. La combinazione della teoria con gli esperimenti in vivo e in vitro consente ai ricercatori di verificare se le attuali conoscenze su un sistema citoscheletrico sono sufficienti per spiegare il suo comportamento osservato. L'uso di strumenti matematici e computazionali ci permette anche di fare inferenze su come i componenti lavorano collettivamente sulla base di ipotesi derivate da osservazioni su scala molecolare, di solito in situazioni semplificate (ad esempio, esperimenti su singole molecole).

Il ruolo della teoria può essere illustrato con un esempio pratico: il battito delle ciglia. Questo battito è dovuto al movimento dei motori della dineina lungo i microtubuli delle ciglia. Ci si potrebbe chiedere cosa determini la velocità del motore dynein in questo sistema. Una possibile risposta è che la velocità massima è limitata dalla necessità di mantenere un certo schema di battitura. Questo sarebbe comprensibile se il battito fosse sotto la selezione naturale. In tal caso, se i motori si muovessero più velocemente, il processo perderebbe le qualità desiderate: le ciglia non batterebbero in modo altrettanto efficiente o addirittura fallirebbero del tutto. Sebbene ciò sia possibile, una seconda alternativa è che qualche fattore intrinseco possa limitare la velocità della dineina.

Ad esempio, la cellula potrebbe non avere abbastanza ATP per rendere la dineina più veloce, o i movimenti delle proteine necessari per l'attività della dineina potrebbero non essere accelerati. In tal caso, se i motori potessero essere resi più veloci nonostante i limiti fisici, la battitura sarebbe migliorata. Una terza possibilità, naturalmente, è che la modifica della velocità non influisca in modo significativo sul processo, il che potrebbe essere vantaggioso per l'organismo fornendo una certa "robustezza" contro fattori incontrollabili. Tra queste tre possibilità, si può identificare quella corretta calcolando il modello di battitura dalle proprietà della dineina. Infatti, un modello matematico adatto dovrebbe prevedere come il modello di battitura sia influenzato dalla variazione della velocità della dineina e non sia soggetto ai limiti che esistono nel mondo fisico. Naturalmente la validità del modello deve essere verificata, ma anche modelli "scorretti" possono generare spunti interessanti.

Il modello può assumere la forma di un quadro analitico o di essere una simulazione numerica del sistema. In entrambi i casi, il divario tra la scala molecolare e la scala funzionale rimane un ostacolo, e lo sviluppo di questi modelli non è un compito semplice, poiché diversi processi meccanici e chimici devono essere integrati nelle equazioni che descrivono il sistema biologico. La teoria si presenta in varie forme, offrendo diversi compromessi tra semplicità e realismo. Aumentare il grado di dettaglio in un modello non è sempre vantaggioso in quanto può limitare la nostra capacità di risolvere le equazioni o, in altre parole, di derivare le previsioni della teoria. Lo stesso compromesso esiste per le simulazioni. I modellisti dovranno selezionare gli ingredienti del sistema da considerare ignorando alcuni aspetti. Queste decisioni chiave dipenderanno fortemente dall'obiettivo dello studio. Al giorno d'oggi, gli straordinari miglioramenti nell'hardware dei computer rendono possibile simulare molti sistemi citoscheletrici con dettagli sufficienti per un tempo sufficiente per analizzarne il comportamento. Questo spesso genera idee inaspettate e nuove direzioni nella ricerca. Ad esempio, simulazioni simili a quelle che verranno utilizzate in questo protocollo hanno portato a un calcolo back-of-the-envelope in grado di prevedere la contrattilità di una rete in base alla sua composizione¹¹.

I metodi numerici sono onnipresenti nell'ingegneria e nelle scienze fisiche e il loro uso in biologia è in crescita. Oggi, praticamente tutto il nostro software tecnologico (orologi, telefoni, automobili e computer) è stato concepito per la prima volta su un computer, ed esistono potenti software per farlo. Dato un sistema citoscheletrico ben caratterizzato e supponendo che sia stato determinato un livello appropriato di descrizione, devono ancora essere risolti diversi problemi prima che possa essere simulato. Per i problemi più semplici, la strada d'azione più appropriata potrebbe essere quella di scrivere una simulazione "codificando da zero", in altre parole, partendo da un linguaggio di programmazione generico o da una piattaforma matematica come MATLAB. Questo ha il vantaggio che l'autore del codice avrà una conoscenza intima di ciò che è stato implementato e sa esattamente come funziona il software. Questo percorso non è, tuttavia, privo di rischi e non è raro assistere a dottorandi che trascorrono la maggior parte del loro tempo lavorativo a scrivere codice piuttosto che affrontare questioni scientifiche.

L'alternativa è utilizzare software concepiti da altri, ma anche questo non è privo di rischi; Qualsiasi codice sorgente di grandi dimensioni tende ad acquisire spontaneamente i tratti di una scatola nera impenetrabile, nonostante gli sforzi più ammirevoli dei suoi autori per impedirlo. L'uso delle scatole nere non è sicuramente il sogno di uno scienziato. Un codice sorgente di grandi dimensioni può anche diventare un problema e potrebbe essere più veloce iniziare da zero piuttosto che modificare una base di codice esistente per fargli fare qualcosa di diverso. Per mitigare questo problema, si può sempre invitare gli autori del software ad aiutare, ma questo potrebbe non essere sufficiente. Spesso c'è una differenza di cultura scientifica tra gli autori del software e le persone che vorrebbero usarlo, il che significa che molte ipotesi implicite devono essere chiarite. Rendendo il codice Open Source, ci si aspetta che più persone saranno coinvolte nello sviluppo del software e nel mantenimento della sua documentazione, migliorandone così la qualità. Tutte queste sono questioni importanti che devono essere prese in debita considerazione prima di effettuare qualsiasi investimento. Tuttavia, l'unico modo per progredire a lungo termine è promuovere soluzioni software solide, utilizzate e mantenute da un'ampia comunità con interessi scientifici comuni.

Sebbene questo protocollo utilizzi Cytosim, esistono altri strumenti Open Source che potrebbero essere in grado di simulare lo stesso sistema, ad esempio AFINES¹², MEDYAN¹³, CyLaKS¹⁴, aLENS¹⁵ e AKYT¹⁶, solo per citarne alcuni. Sfortunatamente, il confronto tra questi progetti va oltre lo scopo dell'articolo. Qui, vengono fornite istruzioni dettagliate per simulare una rete di actomiosina 2D contrattile. Questo sistema è semplice e sfrutta le capacità più consolidate di Cytosim. Cytosim è costruito attorno a un motore di base multipiattaforma in grado di eseguire simulazioni in 2D o 3D. Ha una base di codice modulare, che lo rende facilmente personalizzabile per eseguire attività particolari. La citosima è altrettanto stabile ed efficiente in 3D ed è stata utilizzata con successo in passato per studiare diversi problemi che coinvolgono i microtubuli e i filamenti di actina: l'associazione di due astri di microtubuli¹⁷, il movimento dei nuclei nelle cellule^18,19, l'endocitosi⁶, la citocinesi²⁰, la formazione del fuso mitotico²¹, i movimenti del fuso mitotico²², La cattura dei cromosomi²³, la contrazione delle reti di actomiosina^11,24 e la meccanica dell'anello dei microtubuli nelle piastrine^{del sangue 25} e le capacità sviluppate per questi progetti sono state mantenute nel codice. Il flusso di lavoro qui descritto può essere adattato a molti altri problemi. Utilizza la riga di comando Unix, che potrebbe non essere familiare ad alcuni lettori. L'utilizzo della riga di comando è, tuttavia, il modo più portatile e conveniente per automatizzare il processo di esecuzione delle simulazioni. Le interfacce utente grafiche integrate mirano a offrire un accesso facile e intuitivo a un software, ma questo spesso va a scapito della generalità. L'obiettivo di questo articolo è quello di illustrare un approccio che può essere facilmente modificato o adattato ad altri problemi. Vengono fornite note per spiegare il significato dei comandi.

Per simulare una rete di actomiosina, i filamenti sono modellati come linee orientate e rappresentati da vertici distribuiti lungo la loro lunghezza (Figura 1). Questo è un livello intermedio di descrizione, comune nella fisica dei polimeri, che ignora la vera natura 3D dei filamenti ma consente di calcolare la flessione. I filamenti possono crescere e restringersi alle loro estremità, seguendo diversi modelli che coprono sia la fenomenologia dell'actina che quella dei microtubuli. Nelle cellule, i filamenti sono organizzati principalmente attraverso interazioni che ne limitano il movimento, ad esempio l'attaccamento ad altri filamenti o semplicemente il confinamento all'interno della cellula. In Cytosim, tutte queste interazioni sono linearizzate e combinate in una grande matrice²⁶. Le equazioni che descrivono il moto di tutti i vertici del filamento sono derivate da questa matrice, assumendo un mezzo viscoso e termini fluttuanti casuali che rappresentano il moto browniano. Queste equazioni vengono risolte numericamente per ottenere il moto dei filamenti insieme a tutte le forze che agiscono su di essi in modo autoconsistente ed efficiente²⁶. Sovrapposto a questo motore meccanico, c'è un motore stocastico che simula eventi discreti, come gli attacchi e i distacchi di motori molecolari o la dinamica di assemblaggio dei filamenti. In sintesi, Cytosim utilizza in primo luogo la dinamica simulata per calcolare la meccanica di una rete di filamenti, collegati in modo arbitrario, e, in secondo luogo, metodi stocastici per simulare il legame, il distacco e la diffusione delle proteine che collegano o influenzano i filamenti.

Il flusso di lavoro qui illustrato è stato seguito frequentemente per esplorare inizialmente un sistema utilizzando Cytosim. Il passaggio critico per molti potenziali utenti è probabilmente l'installazione dei componenti software. La distribuzione del software come codice sorgente soddisfa gli imperativi della Scienza Aperta, ma è soggetta a errori poiché gli sviluppatori del software hanno accesso solo a un pool limitato di architetture per testare il programma. La compilazione potrebbe non riuscire in quanto i sistemi operativi differiscono. È probabile che le istruzioni fornite qui diventino obsolete con l'evoluzione dei sistemi informatici e dei codici sorgente. Pertanto, è essenziale controllare periodicamente le ultime istruzioni online. In caso di problemi, si consiglia vivamente agli utenti di segnalare pubblicando un post sul canale di feedback pertinente (attualmente la homepage di Cytosim su Gitlab) per aiutare a risolvere il problema.

Protocol

NOTA: Il protocollo è costituito dai seguenti passaggi: preparazione della piattaforma per Windows 10, MacOS e Linux; l'installazione di Cytosim; configurazione della simulazione e del test di esecuzione e della visualizzazione grafica; più esecuzioni, variando un parametro: il numero di reticolanti nella rete; generare un grafico per visualizzare come la contrattilità è influenzata dal numero di reticolanti; corse parallele; e campionamento casuale. Tutto il testo che segue un ">" sono comandi che devono essere inseriti letteralmente nella finestra del terminale. Il ">" rappresenta il prompt del terminale e non deve essere incluso, ma tutti gli altri caratteri sono importanti.

1. Preparazione della piattaforma

NOTA: A seconda del sistema operativo (MacOS, Windows 10 o Linux), seguire i passaggi 1.1, 1.2 o 1.3.

1. Preparazione (MacOS)
   1. Installa gli strumenti da riga di comando Xcode aprendo il Terminale (in Applicazioni/Utility) e inserisci:
      Gt; xcode-select --install
   2. Per visualizzare o modificare il codice di Cytosim, installa Xcode dall'App Store di Apple (https://apps.apple.com/us/app/Xcode/id497799835?mt=12).
      NOTA: L'editor integrato di Xcode è perfettamente adatto. Funzionerebbero anche altri editor orientati al codice, ad esempio TextMate. Per utilizzare TextMate, scaricare e seguire le istruzioni riportate in https://macromates.com.
2. Preparazione (Windows)
   NOTA: per Windows 10 o versioni successive, Cytosim può essere eseguito utilizzando il "Windows Subsystem for Linux" (WSL), come descritto di seguito. Un'alternativa per una versione precedente è Cygwin, ma le istruzioni non sono fornite qui.
   1. Aggiornare il sistema operativo del computer in modo che soddisfi i requisiti per WSL 2: Windows 10 versione 1903 o successiva, con build 18362 o successiva, per i sistemi x64 e versione 2004 o successiva, con build 19041 o successiva, per i sistemi ARM64. Per gli aggiornamenti successivi della versione, controllare https://docs.microsoft.com/en-us/windows/release-health/release-information.
   2. Digita Attiva e disattiva le funzionalità di Windows nella casella di ricerca della barra delle applicazioni. Abilitare manualmente () la piattaforma della macchina virtuale e il sottosistema Windows () per Linux. Fare clic su OK e riavviare Windows.
   3. Vai su Windows Microsoft Store e cerca Ubuntu. Scarica e installa la versione attuale (Ubuntu 20.04 LTS a partire dal 03.2022)
   4. Fare clic su Avvia per avviare il terminale Ubuntu. Se viene chiesto di scaricare l'ultimo kernel Linux WSL2, procedere seguendo le istruzioni che verranno fornite. Installa l'aggiornamento e riavvia Ubuntu.
   5. Segui le istruzioni del terminale per inserire un nuovo nome utente UNIX e impostare una password. Una volta configurato l'account utente, avvia Ubuntu dalla casella di ricerca della barra delle applicazioni di Windows. Apri la home directory (nota anche come "."), dalla finestra di comando:
      > explorer.exe .
   6. Installare un server X-Window compatibile con WSL, ad esempio Xming: https://sourceforge.net/projects/xming/
   7. Avviare il server X-Window, Xming facendo doppio clic sull'icona Xming; selezionare Più finestre. Successivamente, apri il terminale Ubuntu e segui il passaggio 1.3 (Linux).
3. Preparazione (Linux)
   NOTA: Queste istruzioni sono appropriate per le distribuzioni Linux che utilizzano il gestore di pacchetti APT. Questi comandi devono essere modificati per le distribuzioni come Red Hat Linux che utilizzano un gestore di pacchetti diverso. In questo caso, segui le istruzioni della distribuzione Linux per installare gli stessi pacchetti.
   1. Aggiorna il sistema Linux:
      > sudo apt-get update
      > sudo apt-get upgrade
   2. Installa un compilatore C++ e make (https://www.gnu.org/software/make) di GNU:
      > sudo apt-get install build-essential
   3. Installare le librerie BLAS/LAPACK (http://www.netlib.org/lapack):
      > sudo apt-get install libblas-dev liblapack-dev
   4. Installa la libreria per sviluppatori OpenGL e i file di intestazione (https://www.mesa3d.org):
      > sudo apt-get install mesa-common-dev
   5. Installare la libreria GLEW (http://glew.sourceforge.net):
      > sudo apt-get install libglew-dev
   6. Installa la libreria freeGLUT (http://freeglut.sourceforge.net):
      > sudo apt-get install freeglut3-dev
   7. Installare il sistema di controllo della versione GIT (https://git-scm.com):
      > sudo apt-get install git
   8. Installare i programmi di test X11 (ad esempio, xeyes, xclock, xcalc):
      > sudo apt-get install x11-apps
   9. Regolare la variabile ambiente DISPLAY:
      > esportazione DISPLAY=:0
      1. Prova ad aprire una finestra X11:
         > xeyes
      2. Se funziona, procedi al passaggio 2. Se l'errore non riesce ad aprire il display, provare un valore DISPLAY diverso.
      3. Trova l'indirizzo IP della macchina WSL2:
         > cat /etc/resolv.conf
      4. Se viene visualizzato il numero IP, ad esempio "nameserver 10.16.0.7", utilizzare questo numero IP invece di X.X.X.X di seguito:
         > esportazione DISPLAY= X.X.X.X:0
         > xeyes
      5. Se funziona, procedi al passaggio 2. Se "play" non riesce ad "aprire il display", prova ad eseguirlo da una finestra "xterm":
         > sudo apt install xterm
         > xterm -visualizzazione :0
      6. Nella nuova finestra che si apre, digita:
         > xeyes

2. Installazione di Cytosim

NOTA: questi passaggi sono simili per qualsiasi sistema operativo: MacOS, WSL e Linux. Nella sezione seguente, verranno emessi comandi nel terminale e la "directory di lavoro corrente" dovrebbe essere impostata sulla directory in cui è stata compilata la simulazione. Questa directory verrà indicata come directory di base. In alternativa, tutto può essere fatto in una directory separata se i file vengono copiati secondo necessità. Se non hai familiarità con la riga di comando, prendi in considerazione la possibilità di seguire un tutorial, ad esempio https://www.learnenough.com/command-line-tutorial o https://learnpythonthehardway.org/book/appendixa.html.

1. Scarica il codice sorgente di Cytosim:
   > clone git https://gitlab.com/f-nedelec/cytosim.git citosimo
   NOTA: Non è necessario un account Gitlab per scaricare il codice. Questo dovrebbe creare una nuova sottodirectory "cytosim" nella directory corrente.
2. Compilare:
   > citosimo cd
   > fare
   1. Verificare che tre file siano stati creati in un "bin" del subdirector eseguendo:
      > cestino LS
   2. Se il passaggio 2.2.1 non riesce, provare questo metodo alternativo per la compilazione installando cmake (https://cmake.org):
      > mkdir b
      > cd b
      > cmake ..
      > fare
      > cd ..
3. Controlla gli eseguibili:
   > informazioni sul cestino/sim
   > cestino/informazioni sul gioco
   1. Verificare che entrambi i file eseguibili siano stati compilati per eseguire simulazioni 2D. Cerca il seguente output delle query "info" sopra:
      Dimensione: 2 Periodico: 1 Precisione: 8 byte
   2. Se questo non è il caso, e solo allora, modifica il file "src/math/dim.h" (apri, modifica per cambiare DIM a 2, salva) e ricompila Cytosim:
      > fare pulito
      > fare
4. Prova di funzionamento
   1. Copia tre file eseguibili:
      > cp bin/sim sim
      > cp bin/play play
      > rapporto c/report cp
   2. Creare una nuova directory:
      > esecuzione mkdir
   3. Copiare e rinominare il file di configurazione standard:
      > cp cym/fiber.cym esegui/config.cym
   4. Inizia la simulazione:
      > CD
      > .. /Sim
   5. Visualizza i risultati della simulazione:
      > .. /giocare
      1. Premi la barra spaziatrice per animare. Premere h per assistenza sulle scorciatoie da tastiera.
      2. Per uscire dal programma, su MacOS prova -Q o CTRL-Q o seleziona Esci dal menu. Come ultima risorsa, inserisci CTRL-C nella finestra del terminale da cui è stato avviato "play".
   6. Esegui in modalità live:
      > .. /suona dal vivo

3. Configurazione della simulazione

1. Installa un editor di testo orientato al codice (ad esempio, TextMate, SublimeText) se non è già disponibile.
   Aprire l'editor e aprire il file "config.cym", che si trova nella directory "run" creata nel passaggio 2.4.2. Acquisire familiarità con le diverse sezioni del file di configurazione, che è una copia di "fiber.cym" (File supplementare 1).
   NOTA: Cytosim di solito legge solo un file di configurazione che termina con ".cym". Tutte le modifiche verranno apportate qui a "config.cym". Vedere la Tabella supplementare S1 per un elenco di parametri.
2. Modificare la simulazione apportando le seguenti modifiche a "config.cym":
   raggio=5 → raggio=3
   nuovo filamento 1 → nuovo filamento 100
3. Salvare il file senza modificarne il nome o la posizione (sovrascrivere "config.cym"). Passa alla finestra del terminale e verifica che la simulazione sia modificata come previsto con:
   > .. /suona dal vivo
   NOTA: Il raggio del cerchio è specificato in micrometri (μm), così come tutte le distanze in Cytosim. La citosima segue un sistema di unità adattate alla scala della cellula, derivate da micrometri, piconewton e secondi.
4. Nel paragrafo "set filamento in fibra", apportare le seguenti modifiche:
   rigidità=20 → rigidità=0,1
   segmentazione= 0,5 → segmentazione=0,2
   confine=interno, 200, cella → confine= interno, 10, cella
   Nel paragrafo "nuovo filamento", cambiare:
   lunghezza=12 → lunghezza=2
   Riduci il tempo da simulare modificando:
   Sistema Run 5000 → sistema Run 1000
   NOTA: Questo regola le proprietà del filamento. Il paragrafo "set" definisce le proprietà persistenti dei filamenti, mentre i parametri in "new" sono solitamente le condizioni iniziali. La rigidità alla flessione è specificata in pN μm². La segmentazione è la distanza approssimativa tra i vertici che descrive i filamenti in micrometri (μm). Deve essere ridotto se i filamenti sono resi più flessibili. L'ultima modifica riduce la rigidità (pN/μm) del potenziale di confinamento associato ai bordi della "cella". La lunghezza dichiarata nel "nuovo" paragrafo (2 μm) è la lunghezza iniziale dei filamenti, e poiché in questo modello i filamenti non sono dinamici, le loro lunghezze non cambieranno. Si consiglia di firmare il file di configurazione, modificando la prima riga:
   % Il tuo nome, data, luogo
   1. Verificare la validità del file di configurazione (ripetere il passaggio 3.3).
5. Crea connettori passivi.
   1. Aggiungi un nuovo paragrafo a "config.cym", prima delle righe con i comandi "new" e "run", per definire un'attività molecolare con affinità ai filamenti:
      set raccoglitore manuale {
      binding_rate = 10
      binding_range = 0,01
      unbinding_rate = 0,2
      }
   2. Per definire le entità bifunzionali, aggiungere un altro paragrafo appena sotto:
      set coppia reticolante {
      mano1 = raccoglitore
      mano2 = raccoglitore
      rigidità = 100
      diffusione = 10
      }
   3. Aggiungi un comando "nuovo" dopo i paragrafi precedenti e prima del comando "esegui":
      Nuovo reticolante 1000
      NOTA: In Cytosim, le velocità sono specificate in unità di s⁻¹ e l'intervallo in micrometri (μm). La rigidezza è specificata in unità di piconewton per micrometro (pN/μm) e il coefficiente di diffusione in micrometri al quadrato al secondo (μm²/s). L'ordine dei comandi nel file di configurazione è importante e questi paragrafi devono apparire prima di qualsiasi comando "esegui", altrimenti non saranno efficaci. Per saperne di più sugli oggetti di Cytosim, segui il tutorial in "tuto_introduction.md", che si trova in una sottocartella "doc" della directory di base: doc/tutorials/.
6. Crea motori bifunzionali.
   1. Aggiungere un nuovo paragrafo a "config.cym", prima delle righe con i comandi "new" e "run":
      impostare il motore manuale {
      binding_rate = 10
      binding_range = 0,01
      unbinding_rate = 0,2
      attività = spostamento
      unloaded_speed = 1
      stall_force = 3
      }
   2. Aggiungi un altro paragrafo, dopo il precedente:
      insieme coppia complesso {
      mano1 = motore
      mano2 = motore
      rigidità = 100
      diffusione = 10
      ​}
   3. Aggiungi un comando "nuovo" dopo i paragrafi precedenti e prima del comando "esegui":
      Nuovo complesso 200
      NOTA: Il "activity = move" specifica un motore che si muove continuamente sul filamento. Il motore obbedisce a una curva lineare forza-velocità (Figura 1) caratterizzata dalla velocità a vuoto (μm/s) e dalla forza di stallo (piconewton). Ad ogni passo temporale, τ, si muove di una distanza, v × τ. L'uso di "activity = none" specificherebbe una molecola che non si muove, e poiché questa è l'attività predefinita, si potrebbe semplicemente omettere del tutto "activity". Altre attività sono possibili, ad esempio, "attività = camminata" specificherebbe un motore con passi discreti lungo il filamento. Il "unloaded_speed" è positivo per un motore diretto con estremità positiva. Specificando un valore negativo, il motore si muoverebbe verso le estremità negative. Questo è ulteriormente spiegato nel primo tutorial di Cytosim (vedere il link al passaggio 3.5.2).
7. Salva il file.
   Controlla la simulazione:
   > .. /suona dal vivo
   Esegui la simulazione:
   > .. /Sim
   Visualizza i risultati:
   > .. /giocare
   Copiare il file di configurazione finale nella directory di base:
   > cp config.cym .. /config.cym
   NOTA: Il file finale dovrebbe essere simile al file supplementare 2 ("jove.cym"). Si noti quanto tempo è stato necessario per calcolare questa simulazione. Nelle sezioni seguenti, questo tempo verrà moltiplicato per il numero di simulazioni effettuate per generare un grafico in cui viene variato un parametro.

4. Sweep dei parametri

NOTA: In questa sezione, il numero di reticolanti nella rete viene sistematicamente variato.

1. Importa script Python.
   1. Creare una sottodirectory "byn", all'interno della directory di base:
      > mkdir byn
   2. Copiare tre script dalla distribuzione standard di Cytosim:
      > cp python/run/preconfig.py byn/preconfig
      > cp python/look/scan.py byn/.
      > cp python/look/make_page.py byn/.
      NOTA: Per motivi di sicurezza, le copie di questi file vengono fornite come File supplementare 3, File supplementare 4 e File supplementare 5 con questo articolo.
2. Rendi i file eseguibili:
   > chmod +x byn/preconfig
   > chmod +x byn/scan.py
   > chmod +x byn/make_page.py
   1. Verificare che gli script vengano eseguiti correttamente:
      > byn/preconfig help
      > byn/scan.py aiuto
      > byn/make_page.py aiuto
      NOTA: Questo dovrebbe stampare una descrizione di come ogni comando può essere utilizzato. È possibile modificare la variabile PATH per chiamare gli script in modo più semplice; Vedere https://en.wikipedia.org/wiki/PATH_(variabile).
   2. Risoluzione dei problemi
      1. Se l'errore è "comando non trovato", controlla il percorso specificato, che dovrebbe corrispondere alla posizione del file. Se c'è un altro tipo di errore perché il sistema operativo non fornisce python2, modifica i tre file .py e modifica lo shebang, che è la prima riga di ogni file (basta aggiungere "3"):
         #!/usr/bin/env python → #!/usr/bin/env python3
3. Copiare il file di configurazione per renderlo un "modello" (File supplementare 6):
   > cp config.cym config.cym.tpl
4. Modificare il file di configurazione del modello. Nell'editor di codice, aprire il file "config.cym.tpl", che si trova nella directory di base. Modificare una riga per introdurre un elemento di testo variabile:
   Nuovo crosslinker 1000 → nuovo crosslinker [[range(0,4000,100)]]
   NOTA: Preconfig riconoscerà il codice contenuto nelle doppie parentesi e lo sostituirà con un valore ottenuto eseguendo questo codice in Python. In Python "range(X,Y,S)" specifica numeri interi da X a Y, con un incremento di S; In questo caso [0, 100, 200, 300, ... L'intento è quello di modificare il numero di reticolanti aggiunti alla simulazione.
5. Genera i file di configurazione dal modello:
   > byn/preconfig eseguii/config.cym config.cym.tpl
   NOTA: Questo dovrebbe creare 40 file, uno per ogni valore specificato in "range(0,4000,100)". I nomi dei file che devono essere generati da Preconfig sono specificati da "runi/config.cym". Con questo codice specifico, Preconfig genererà "run0000/config.cym", "run0001/config.cym", ecc. In realtà creerà le directory "run0000", "run0001", ecc., e creerà un file "config.cym" in ciascuna di esse. Controlla la guida di Preconfig per maggiori dettagli (esegui "byn/preconfig help"). In caso di errore, verificare che il comando sia digitato esattamente. Ogni carattere conta.
6. Esegui tutte le simulazioni in sequenza:
   > byn/scan.py '.. /sim' eseguire????
   NOTA: Il programma "scan.py" eseguirà il comando citato nell'elenco delle directory fornito. In questo caso, questo elenco di directory è specificato da "run????". Il punto interrogativo è un carattere jolly che corrisponde a qualsiasi carattere. Pertanto, "run????" corrisponde a qualsiasi nome che inizia con "run" e seguito esattamente da quattro caratteri. In alternativa, si potrebbe usare "run*" per generare lo stesso elenco, poiché "*" corrisponde a qualsiasi stringa.
   1. In caso di problemi, eseguire questo comando da una nuova finestra di terminale per eseguire "sim" in sequenza in tutte le directory create nel passaggio 4.5. Attendi circa 30 minuti per il completamento del processo, ma questo dipende molto dalle capacità del computer. Riduci la quantità di calcolo richiesta modificando "config.cym":
      Sistema Run 1000 → sistema Run 500
7. Visualizza alcune simulazioni:
   > ./play run0010
   > ./play run0020
8. Genera immagini per tutte le simulazioni:
   > byn/scan.py '.. /play dimensione immagine=256 frame=10' di esecuzione????
9. Genera una pagina di riepilogo HTML:
   > byn/make_page.py piastrella = 5 esegui????
   1. Apri "page.html" in un browser web.

5. Fare un grafico

NOTA: In questa sezione, viene creato un grafico dai risultati del parametro sweep.

1. Controllare l'eseguibile del rapporto :
   > CD
   > .. /report rete:dimensione
   NOTA: Per ogni fotogramma della traiettoria, verranno stampati alcuni commenti e due numeri, corrispondenti a "polimero" e "superficie". Verrà utilizzata solo la "superficie" di rete (ultima colonna).
   1. Limita in modo specifico le informazioni a un fotogramma utilizzando:
      > .. /report rete:dimensione frame=10
   2. Rimuovi i commenti per semplificare l'elaborazione dell'output:
      > .. /report network:dimensione frame=10 verbose=0
   3. Infine, reindirizzare l'output a un file utilizzando la funzione pipe Unix (">"):
      > .. /report network:dimensione frame=10 verbose=0 > net.txt
   4. Stampa il contenuto del file sul terminale per la verifica:
      > gatto net.txt
      NOTA: Questo dovrebbe stampare due numeri. Il secondo è la superficie coperta dalla rete nel 10° fotogramma. Per eseguire la stessa operazione in tutte le directory "run", cambia directory:
      > cd ..
2. Generare un report in ogni sottodirectory di simulazione:
   > byn/scan.py '.. /report network:size frame=10 verbose=0 > net.txt' run????
   NOTA: Ancora una volta, scan.py eseguirà il comando tra virgolette in tutte le directory specificate da "run????". Il comando è l'ultimo provato nel passaggio 5.1. Questo genererà un file "net.txt" in ogni directory (prova "ls run????").
3. Esamina questi numeri:
   > byn/scan.py corsa "cat net.txt????
   1. Aggiungere l'opzione "+" per concatenare il nome della directory e l'output del comando:
      > byn/scan.py + corsa 'cat net.txt'????
4. Raccogli questi numeri in un file:
   > byn/scan.py + corsa 'cat net.txt'???? > results.txt
5. Pulisci il file "results.txt" eliminando il testo ripetuto che non è numerico. Aprire "result.txt" nell'editor di codice e utilizzare "sostituisci testo" per rimuovere tutte le stringhe "esegui". Rimuovi solo tre lettere e conserva i numeri; "run0000" dovrebbe diventare "0000".
   NOTA: Questo dovrebbe lasciare un file con solo numeri organizzati in tre colonne.
6. Genera un grafico di contrattilità dai dati in "result.txt". Utilizzare qualsiasi metodo per generare un grafico utilizzando la colonna 1 per X e la colonna 3 per Y. Etichettare l'asse X come numero di reticolanti/100. Etichettare l'asse Y come superficie (micrometro^2).
7. Memorizza tutte le simulazioni in una directory separata:
   > mkdir salva1
   > corsa mv???? salvare1

6. Metodo alternativo per creare un grafico

1. Aggiungere un comando report alla fine di "config.cym.tpl" su una nuova riga dopo la chiusura "}" del comando run:
   rapporto rete:dimensione net.txt { verboso = 0 }
2. Genera i file di configurazione:
   > byn/preconfig eseguii/config.cym config.cym.tpl
3. Eseguire tutte le simulazioni utilizzando thread paralleli:
   > byn/scan.py '.. /sim' eseguire???? njobs=4
   1. Regolare il numero di lavori (njobs=4), a seconda della capacità del computer. Monitora l'utilizzo delle risorse della CPU, ad esempio, da parte dell'app Activity Monitor su MacOS.
4. Raccogli i dati:
   > byn/scan.py + corsa 'cat net.txt'???? > results.txt
5. Crea un grafico, come nei passaggi 5.5 e 5.6.
6. Memorizza tutte le esecuzioni precedenti in una directory separata:
   > mkdir salva2
   > corsa mv???? salva2

7. Grafico migliorato utilizzando il campionamento casuale

NOTA: Una variabile viene campionata qui utilizzando una funzione generatore dal modulo "casuale" di Python.

1. Nell'editor di codice, aprire il file di configurazione del modello "config.cym.tpl", che si trova nella directory di base. Aggiungi due righe, appena prima del "nuovo reticolante":
   [[num = int(casuale.uniforme(0,4000))]]
   %[[num]] xlinkers
   Cambia anche il comando "new" per utilizzare questa variabile:
   Nuovo crosslinker [[range(0,4000,100)]] → nuovo crosslinker [[num]]
   NOTA: La prima riga crea una variabile casuale "num". La seconda riga stampa il valore del parametro. Il carattere "%" è importante poiché indicherà a Cytosim di saltare la fila. Presto "xlinkers" servirà come tag riconoscibile e dovrà apparire solo una volta in ogni file.
   1. Alla fine di "config.cym.tpl", assicurarsi che ci sia un'istruzione di rapporto:
      rapporto rete:dimensione net.txt { verboso = 0 }
2. Genera i file di configurazione:
   > byn/preconfig eseguii/config.cym 42 config.cym.tpl
   NOTA: Questo dovrebbe generare 42 file. Questo numero può essere aumentato se il computer è abbastanza veloce. I valori generati casualmente possono essere visualizzati utilizzando lo strumento Unix "grep" per cercare i file:
   > grep xlinkers eseguono???? /config.cym
3. Eseguire tutte le simulazioni in parallelo:
   > byn/scan.py '.. /sim' eseguire???? njobs=4
   NOTA: Regolare il numero di lavori in base alla capacità del computer. Per ottenere i migliori risultati, la variabile "njobs" deve essere impostata su un valore uguale al numero di core del computer.
4. Raccogli i dati utilizzando un unico comando:
   > byn/scan.py + 'grep xlinkers config.cym; Il recinto del gatto net.txt???? > results.txt
   NOTA: L'opzione "+" di scan.py concatena tutto l'output del comando in una singola riga. In questo caso, il comando è in realtà composto da due comandi separati da una semicolonna (";"). La raccolta dei dati può sempre essere automatizzata con uno script Python.
5. Pulisci il file. Aprire "result.txt" nell'editor di codice. Per assicurarsi che tutti i dati corrispondenti a una simulazione siano contenuti in una riga, eliminare tutte le occorrenze della stringa "xlinkers" e rimuovere i caratteri "%" all'inizio di ogni riga. Infine, salva "result.txt", che dovrebbe essere organizzato ordinatamente in tre colonne di valori numerici.
6. Crea un grafico per tracciare i dati ripetendo il passaggio 5.6, ma etichetta l'asse X come numero di reticolanti
7. Salvare il set di dati in una nuova sottodirectory:
   >mkdir set1
   > corsa mv???? set1/.
   > mv results.txt set1/.
8. Calcolare un altro set di dati ripetendo i passaggi 7.2-7.6 e quindi ripetere il passaggio 7.8, sostituendo "set1" con "set2" in tutti e tre i comandi.
9. Crea un grafico combinato.
   1. Concatenare i due file di dati:
      > set per gatti?/results.txt > results.txt
      NOTA: Il nuovo "result.txt" dovrebbe essere più grande.
   2. Tracciare i dati per creare un grafico combinato, come descritto nel passaggio 7.7.

8. Pipeline completamente automatizzata

NOTA: In questa parte, tutte le operazioni che richiedono un intervento manuale sono sostituite da comandi. Fatto ciò, sarà possibile scrivere un unico script che esegua automaticamente tutti i passaggi. Questo script può essere eseguito in un computer remoto, ad esempio una farm di calcolo.

1. Utilizzare il comando Unix "sed" per "pulire" il file results.txt, sostituendo il passaggio 7.6.
   1. Rimuovi il "%" all'inizio delle righe:
      > sed -e 's/%//g' results.txt > tmp.txt
   2. Rimuovere "xlinkers":
      > sed -e 's/xlinkers//g' tmp.txt > results.txt
2. Scrivi uno script per chiamare tutti i comandi in successione nell'ordine corretto.
   1. Usa linguaggi diversi: bash o Python.
   2. Creare un file "pipeline.bash" e copiare tutti i comandi necessari per eseguire la pipeline.
   3. Eseguire lo script:
      > bash pipeline.bash
3. Utilizzare uno script di stampa automatizzato.
   NOTA: Può essere vantaggioso rimuovere tutti gli interventi manuali. Esistono molti strumenti per generare un grafico PDF direttamente da un file di dati, ad esempio gnuplot (http://www.gnuplot.info), PyX (https://pyx-project.org) o Seplot (https://pypi.org/project/seplot/).

Results

Nella sezione 2, la compilazione riuscita di Cytosim utilizzando "make" dovrebbe produrre sim, play e report nella sottodirectory "bin". L'output del passaggio 2.3 ("sim info") dovrebbe indicare, tra le altre cose, "Dimensione: 2". Nella sezione 3, il file di configurazione dovrebbe essere simile a jove.cym, fornito come File supplementare 1. Nella sezione 4, ivalori ottenuti nel passaggio 4.8 dalle simulazioni dovrebbero essere simili a quelli mostrati nella

Discussion

Il metodo descritto in questo articolo si basa su tre piccoli programmi Python indipendenti, che sono stati utilizzati in modi diversi in tutto il protocollo descritto. Il primo script preconfig è uno strumento versatile che può sostituire la necessità di scrivere script Python personalizzati²⁷. Viene utilizzato per generare più file di configurazione da un singolo file di modello, specificando quale parametro deve essere variato e come deve essere variato. Per variare più parametri, è su...

Materials

List of materials used in this article

Name	Company	Catalog Number	Comments
Un personal computer			MacOS, Windows 10 o Linux
file di configurazione	del modello config.cym.tpl
file di configurazione	jove.cym
make_page.py			script Python; https://github.com/nedelec/make_page.py
preconfigurazione			Script Python; https://github.com/nedelec/preconfig
scan.py			script Python; https://github.com/nedelec/scan.py