Typowy przepływ pracy symulujący układy cytoszkieletu

Summary

Ten protokół pokazuje, jak używać Cytosim, symulacji cytoszkieletu Open Source, do badania zachowania sieci włókien połączonych silnikami molekularnymi i pasywnymi siecierami. Postępuje ogólny przepływ pracy z instrukcjami krok po kroku, aby zmienić liczbę urządzeń sieciujących i wykreślić wynikową kurczliwość sieci.

Abstract

Wiele systemów cytoszkieletu jest teraz wystarczająco dobrze znanych, aby umożliwić ich precyzyjne modelowanie ilościowe. Włókna mikrotubul i aktyny są dobrze scharakteryzowane, a związane z nimi białka są często znane, a także ich obfitość i interakcje między tymi pierwiastkami. W ten sposób symulacje komputerowe mogą być wykorzystywane do precyzyjnego badania zbiorowego zachowania systemu, w sposób uzupełniający do eksperymentów. Cytosim to pakiet symulacyjny cytoszkieletu typu open source, przeznaczony do obsługi dużych systemów elastycznych włókien z powiązanymi białkami, takimi jak silniki molekularne. Oferuje również możliwość symulacji pasywnych środków sieciujących, dyfuzyjnych środków sieciujących, nukleatorów, obcinaczy i dyskretnych wersji silników, które nadepną tylko na niezajęte miejsca sieciowe na żarniku. Inne obiekty uzupełniają włókna, oferując sferyczną lub bardziej skomplikowaną geometrię, którą można wykorzystać do reprezentowania chromosomów, jądra lub pęcherzyków w komórce.

Cytosim oferuje proste narzędzia wiersza poleceń do przeprowadzania symulacji i wyświetlania jej wyników, które są wszechstronne i nie wymagają umiejętności programowania. W tym przepływie pracy podane są instrukcje krok po kroku, aby i) zainstalować niezbędne środowisko na nowym komputerze, ii) skonfigurować Cytosim do symulacji skurczu sieci 2D aktomiozyny oraz iii) stworzyć wizualną reprezentację systemu. Następnie system jest badany poprzez systematyczną zmianę kluczowego parametru: liczby osób sieciujących. Wreszcie, wizualna reprezentacja systemu jest uzupełniona numeryczną kwantyfikacją kurczliwości, aby zobaczyć na wykresie, w jaki sposób kurczliwość zależy od składu systemu. Ogólnie rzecz biorąc, te różne kroki stanowią typowy przepływ pracy, który można zastosować z niewielkimi modyfikacjami w celu rozwiązania wielu innych problemów w dziedzinie cytoszkieletu.

Introduction

Cytoszkielet składa się z włókien wewnątrz komórki i powiązanych z nimi cząsteczek, takich jak silniki molekularne, które często tworzą dynamiczną siatkę o niezwykłych właściwościach mechanicznych. Cytoszkielet występuje w różnych konfiguracjach w różnych typach komórek w prawie wszystkich formach życia. Jego prawidłowe funkcjonowanie jest niezbędne dla podstawowych procesów komórkowych, takich jak podział, ruchliwość i polaryzacja. Reguluje również interakcje mechaniczne między komórkami, wpływając w ten sposób na morfogenezę tkanek i organizmów. Cytoszkielet pełni kilka funkcji i przejawia się w wielu procesach biologicznych. Na przykład skurcz mięśni jest związany z udarem mocy silników molekularnych miozyny na włóknach aktynowych. Innym przykładem jest utrzymanie neuronów, które opiera się na ruchach silników kinezynowych wzdłuż mikrotubul znajdujących się wewnątrz aksonów tych neuronów. Aktyna i mikrotubule to dwa dominujące typy włókien cytoszkieletu, bez których życie, jakie znamy, byłoby niemożliwe.

Cytoszkielet jest zasadniczo systemem biomechanicznym, którego nie można sprowadzić wyłącznie do jego chemii. Mikrotubule lub filamenty aktynowe są zbudowane z tysięcy monomerów i rozciągają się na kilka mikrometrów. Konformacje tych włókien w przestrzeni i siły, które mogą przenosić na błonę plazmatyczną, jądro lub inne organelle, są kluczowymi aspektami ich roli w komórce. Na przykład sieć filamentów aktynowych i silników miozyny, zwana korą aktomiozyny¹, generuje siły podtrzymujące ruchliwość komórek i zmiany morfologiczne w komórkach zwierzęcych. Zupełnie inny układ obserwuje się w komórkach roślinnych, gdzie mikrotubule korowe kierują odkładaniem włókien celulozowych, kontrolując w ten sposób architekturę ściany komórkowej, która ostatecznie decyduje o tym, jak te komórki będą rosły w przyszłości².

Podczas gdy mechanika wyraźnie odgrywa znaczącą rolę w operacjach cytoszkieletu, chemia jest równie ważna. Włókna rosną w procesie samoorganizacji, w którym monomery znajdują swoje miejsce dokowania na końcu włókna po dyfuzji przez cytoplazmę³. W skali molekularnej montaż i demontaż na końcu włókien jest zatem określany przez powinowactwo molekularne⁴. Podobnie, białka cytoszkieletu dyfundują, a szybkość wiązania i rozwiązywania określa ich powinowactwo do napotkanych włókien. W przypadku silników molekularnych cykle reakcji chemicznych obejmujących hydrolizę ATP są związane z ruchami wzdłuż włókien i, być może, siłami, które im towarzyszą⁵. Co ciekawe, cytoszkielet oferuje wiele nietypowych wyzwań i dużą różnorodność procesów obejmujących podobne komponenty. Jest to bogaty plac zabaw na styku biologii, chemii i fizyki.

Systemy cytoszkieletowe są podatne na modelowanie matematyczne. W rzeczywistości, dzięki doskonałym badaniom przeprowadzonym w ostatnich dziesięcioleciach, główne składniki molekularne są najprawdopodobniej już zidentyfikowane, co ilustruje endocytoza⁶. W organizmach modelowych, takich jak drożdże, znane są właściwości tych pierwiastków, a także skład układowy niektórych z ich procesów. Na przykład, struktura i właściwości materiałowe mikrotubul⁷, a także ich liczba i średnie długości na różnych etapach wrzeciona mitotycznego, zostały opisane⁸. Liczba kinezyn, które łączą mikrotubule w spójną strukturę mechaniczną, jest często znana⁹. Prędkości wielu silników zostały zmierzone in vitro¹⁰. Ponadto eksperymentatorzy mogą obserwować i określać ilościowo te układy in vivo w warunkach typu dzikiego lub zmutowanego. Połączenie teorii z eksperymentami in vivo i in vitro umożliwia naukowcom sprawdzenie, czy obecna wiedza na temat układu cytoszkieletu jest wystarczająca, aby wyjaśnić jego obserwowane zachowanie. Wykorzystanie narzędzi matematycznych i obliczeniowych pozwala nam również na wnioskowanie o tym, jak komponenty działają kolektywnie na podstawie założeń wynikających z obserwacji w skali molekularnej, zwykle w uproszczonych sytuacjach (np. eksperymenty z pojedynczymi cząsteczkami).

Rolę teorii można zilustrować na praktycznym przykładzie: biciu rzęsek. To dudnienie jest spowodowane ruchem silników dyneiny wzdłuż mikrotubul w rzęskach. Można zapytać, od czego zależy prędkość silnika dyneinowego w tym układzie. Jedną z możliwych odpowiedzi jest to, że maksymalna prędkość jest ograniczona przez wymóg utrzymania określonego wzorca dudnienia. Byłoby to zrozumiałe, gdyby bicie odbywało się w ramach doboru naturalnego. W takim przypadku, gdyby silniki poruszały się szybciej, proces straciłby swoje pożądane właściwości - rzęski nie biłyby tak wydajnie, a nawet całkowicie by zawiodły. Chociaż jest to możliwe, drugą alternatywą jest to, że jakiś wewnętrzny czynnik może ograniczać prędkość dyneiny.

Na przykład, komórka może nie mieć wystarczającej ilości ATP, aby przyspieszyć działanie dyneiny, lub ruchy białka wymagane do aktywności dyneiny po prostu nie mogą być przyspieszone. W takim przypadku, gdyby silniki mogły być szybsze pomimo fizycznych ograniczeń, bicie uległoby poprawie. Trzecią możliwością jest oczywiście to, że zmiana prędkości nie wpływa znacząco na proces, co może być korzystne dla organizmu, zapewniając pewną "odporność" na niekontrolowane czynniki. Spośród tych trzech możliwości można zidentyfikować właściwą, obliczając wzór dudnienia na podstawie właściwości dyneiny. Rzeczywiście, odpowiedni model matematyczny powinien przewidywać, w jaki sposób na wzorzec dudnienia wpływa zmienna prędkość dyneiny i nie podlega ograniczeniom, które istnieją w świecie fizycznym. Oczywiście poprawność modelu musi zostać zweryfikowana, ale nawet "niepoprawne" modele mogą generować ciekawe pomysły.

Model może przybrać formę struktury analitycznej lub być symulacją numeryczną systemu. Tak czy inaczej, luka między skalą molekularną a skalą funkcjonalną pozostaje przeszkodą, a opracowanie tych modeli nie jest prostym zadaniem, ponieważ kilka procesów mechanicznych i chemicznych musi zostać zintegrowanych z równaniami opisującymi system biologiczny. Teoria występuje w różnych formach, oferując różne kompromisy między prostotą a realizmem. Zwiększanie stopnia szczegółowości modelu nie zawsze jest korzystne, ponieważ może ograniczyć naszą zdolność do rozwiązywania równań lub, innymi słowy, do wyprowadzania przewidywań teorii. Ten sam kompromis istnieje w przypadku symulacji. Modelarze będą musieli wybrać składniki systemu, które mają być brane pod uwagę, ignorując pewne aspekty. Te kluczowe decyzje będą w dużym stopniu zależały od celu badania. W dzisiejszych czasach niezwykłe ulepszenia w sprzęcie komputerowym umożliwiają symulację wielu układów cytoszkieletu z wystarczającą ilością szczegółów w wystarczająco długim czasie, aby przeanalizować ich zachowanie. To często generuje nieoczekiwane pomysły i nowatorskie kierunki badań. Na przykład symulacje podobne do tych, które zostaną użyte w tym protokole, doprowadziły do obliczenia na odwrocie koperty, które może przewidzieć kurczliwość sieci na podstawie jej składu¹¹.

Metody numeryczne są wszechobecne w naukach inżynieryjnych i fizycznych, a ich zastosowanie w biologii rośnie. Obecnie praktycznie wszystkie nasze technologiczne whatchamacallit (zegarki, telefony, samochody i komputery) zostały po raz pierwszy wymyślone na komputerze i istnieje potężne oprogramowanie, które to robi. Biorąc pod uwagę dobrze scharakteryzowany układ cytoszkieletu i zakładając, że został określony odpowiedni poziom opisu, kilka kwestii musi zostać jeszcze rozwiązanych, zanim będzie można go zasymulować. W przypadku najprostszych problemów najwłaściwszą drogą działania może być napisanie symulacji "kodując od zera", innymi słowy, zaczynając od generycznego języka programowania lub platformy matematycznej, takiej jak MATLAB. Ma to tę zaletę, że autor kodu będzie miał dogłębną wiedzę na temat tego, co zostało zaimplementowane i dokładnie wie, jak działa oprogramowanie. Ta droga nie jest jednak pozbawiona ryzyka i nierzadko można być świadkiem, jak doktoranci spędzają większość swojego czasu pracy na pisaniu kodu, a nie na zajmowaniu się pytaniami naukowymi.

Alternatywą jest korzystanie z oprogramowania wymyślonego przez innych, ale to również nie jest pozbawione ryzyka; każdy duży kod źródłowy ma tendencję do spontanicznego nabywania cech nieprzeniknionej czarnej skrzynki, pomimo najbardziej godnych podziwu wysiłków ich autorów, aby temu zapobiec. Korzystanie z czarnych skrzynek z pewnością nie jest marzeniem naukowca. Duży kod źródłowy może również stać się obciążeniem i szybsze może być rozpoczęcie od zera niż modyfikowanie istniejącej bazy kodu, aby robiła coś innego. Aby załagodzić ten problem, zawsze można zaprosić do pomocy autorów oprogramowania, ale to może nie wystarczyć. Często istnieje różnica w kulturze naukowej między autorami oprogramowania a osobami, które chciałyby z niego korzystać, co oznacza, że wiele ukrytych założeń wymaga wyjaśnienia. Dzięki temu, że kod stanie się Open Source, oczekuje się, że więcej osób będzie zaangażowanych w rozwój oprogramowania i utrzymanie jego dokumentacji, poprawiając tym samym jego jakość. Wszystko to są ważne kwestie, które należy odpowiednio rozważyć przed dokonaniem jakiejkolwiek inwestycji. Niemniej jednak jedynym sposobem na postęp w dłuższej perspektywie jest promowanie solidnych rozwiązań programistycznych, używanych i utrzymywanych przez szeroką społeczność o wspólnych zainteresowaniach naukowych.

Chociaż ten protokół korzysta z Cytosim, istnieją inne narzędzia Open Source, które mogą symulować ten sam system, na przykład AFINES¹², MEDYAN¹³, CyLaKS¹⁴, aLENS¹⁵ i AKYT¹⁶, by wymienić tylko kilka. Niestety, porównywanie tych projektów wykracza poza ramy artykułu. Tutaj podane są instrukcje krok po kroku, aby symulować kurczliwą sieć 2D aktomiozyny. Ten system jest prosty i wykorzystuje lepiej ugruntowane możliwości Cytosim. Cytosim jest zbudowany wokół wieloplatformowego silnika rdzeniowego, który może uruchamiać symulacje w 2D lub 3D. Posiada modułową bazę kodu, dzięki czemu można go łatwo dostosować do wykonywania określonych zadań. Cytosim jest równie stabilny i wydajny w 3D i był z powodzeniem stosowany w przeszłości do badania różnych problemów związanych z mikrotubulami i filamentami aktyny: asocjacja dwóch astry mikrotubul¹⁷, ruch jąder w komórkach^18,19, endocytoza⁶, cytokineza²⁰, tworzenie wrzeciona mitottycznego²¹, ruchy wrzeciona mitotycznego²², przechwytywanie chromosomów²³, kurczenie się sieci aktomiozyny^11,24, oraz mechanika pierścienia mikrotubul w płytkach krwi²⁵, a także zdolności opracowane dla tych projektów zostały zachowane w kodzie. Opisany tutaj przepływ pracy można dostosować do wielu innych problemów. Korzysta z wiersza poleceń systemu Unix, który może być nieznany niektórym czytelnikom. Korzystanie z wiersza poleceń jest jednak najbardziej przenośnym i wygodnym sposobem automatyzacji procesu uruchamiania symulacji. Zintegrowane graficzne interfejsy użytkownika mają na celu zapewnienie łatwego, intuicyjnego dostępu do oprogramowania, ale często odbywa się to kosztem ogólności. Celem tego artykułu jest zilustrowanie podejścia, które można łatwo zmodyfikować lub dostosować do innych problemów. Znajdują się tam uwagi wyjaśniające znaczenie poleceń.

Aby symulować sieć aktomiozyny, włókna są modelowane jako linie zorientowane i reprezentowane przez wierzchołki rozmieszczone wzdłuż ich długości (Rysunek 1). Jest to pośredni poziom opisu, powszechny w fizyce polimerów, który ignoruje prawdziwą naturę 3D włókien, ale pozwala na obliczenie wygięcia. Włókna mogą rosnąć i kurczyć się na swoich końcach, zgodnie z różnymi modelami, które obejmują zarówno fenomenologię aktyny, jak i mikrotubul. W komórkach włókna są zorganizowane przede wszystkim poprzez interakcje, które ograniczają ich ruch, na przykład przyczepienie się do innych włókien lub po prostu uwięzienie w komórce. W Cytosimie wszystkie takie interakcje są linearyzowane i łączone w dużą matrix²⁶. Równania opisujące ruch wszystkich wierzchołków włókien wywodzą się z tej macierzy, przyjmując lepki ośrodek i losowe zmienne składniki reprezentujące ruch Browna. Równania te są rozwiązywane numerycznie, aby uzyskać ruch włókien wraz ze wszystkimi działającymi na nie siłami w sposób spójny i wydajny²⁶. Na ten mechaniczny silnik nałożony jest silnik stochastyczny, który symuluje dyskretne zdarzenia, takie jak przyłączanie i odłączanie silników molekularnych lub dynamika składania włókien. Podsumowując, Cytosim wykorzystuje najpierw symulowaną dynamikę do obliczenia mechaniki sieci włókien, połączonych w dowolny sposób, a po drugie, metody stochastyczne do symulacji wiązania, rozwiązywania i dyfuzji białek, które łączą lub wpływają na włókna.

Przedstawiony tutaj przepływ pracy był często stosowany do początkowego zbadania systemu za pomocą Cytosim. Krytycznym krokiem dla wielu potencjalnych użytkowników będzie prawdopodobnie instalacja komponentów oprogramowania. Dystrybucja oprogramowania jako kodu źródłowego spełnia imperatywy Otwartej Nauki, ale jest podatna na błędy, ponieważ twórcy oprogramowania mają dostęp tylko do ograniczonej puli architektury w celu przetestowania programu. Kompilacja może zakończyć się niepowodzeniem, ponieważ systemy operacyjne różnią się. Podane tutaj instrukcje prawdopodobnie staną się nieaktualne wraz z ewolucją systemów komputerowych i kodów źródłowych. Dlatego niezbędne jest okresowe sprawdzanie najnowszych instrukcji online. W przypadku problemów zdecydowanie zaleca się, aby użytkownicy zgłaszali się z powrotem, publikując posty na odpowiednim kanale opinii (obecnie strona główna Cytosim na Gitlab), aby pomóc rozwiązać problem.

Protocol

UWAGA: Protokół składa się z następujących kroków: przygotowanie platformy dla Windows 10, MacOS i Linux; instalacja Cytosim; konfiguracja symulacji i uruchomienia testowego oraz wyświetlania graficznego; wiele przebiegów, zmieniając parametr: liczbę sieciujących w sieci; generowanie wykresu, aby zobaczyć, jak liczba sieciujących wpływa na kurczliwość; przebiegi równoległe; oraz losowe próbkowanie. Cały tekst następujący po ">" to polecenia, które należy wprowadzić dosłownie w oknie terminala. ">" reprezentuje monit terminala i nie może być dołączony, ale wszystkie inne znaki są ważne.

1. Przygotowanie platformy

UWAGA: W zależności od systemu operacyjnego (MacOS, Windows 10 lub Linux), wykonaj krok 1.1, krok 1.2 lub krok 1.3.

1. Przygotowanie (MacOS)
   1. Zainstaluj narzędzia wiersza poleceń Xcode, otwierając terminal (w Aplikacjach/Narzędziach) i wprowadź:
      Gt; xcode-select --install
   2. Aby wyświetlić lub edytować kod Cytosim, zainstaluj Xcode ze sklepu Apple App Store (https://apps.apple.com/us/app/Xcode/id497799835?mt=12).
      UWAGA: Wbudowany edytor Xcode jest idealnie odpowiedni. Inne edytory zorientowane na kod również by działały, na przykład TextMate. Aby korzystać z TextMate, pobierz i postępuj zgodnie z instrukcjami z https://macromates.com.
2. Przygotowanie (Windows)
   UWAGA: W przypadku systemu Windows 10 lub nowszego Cytosim może działać przy użyciu "Podsystemu Windows dla systemu Linux" (WSL), jak opisano poniżej. Alternatywą dla starszej wersji jest Cygwin, ale instrukcje nie są tutaj podane.
   1. Zaktualizuj system operacyjny komputera, aby spełniał wymagania programu WSL 2: Windows 10 w wersji 1903 lub nowszej, z kompilacją 18362 lub nowszą, dla systemów x64 i wersją 2004 lub nowszą, z kompilacją 19041 lub nowszą, dla systemów ARM64. Aby zapoznać się z kolejnymi aktualizacjami wersji, sprawdź https://docs.microsoft.com/en-us/windows/release-health/release-information.
   2. Wpisz Włączanie i wyłączanie funkcji systemu Windows w polu wyszukiwania na pasku zadań. Ręcznie włącz () Virtual Machine Platform i () Podsystem Windows dla systemu Linux. Kliknij OK i uruchom ponownie system Windows.
   3. Przejdź do Windows Microsoft Store i wyszukaj Ubuntu. Pobierz i zainstaluj aktualną wersję (Ubuntu 20.04 LTS od 03.2022)
   4. Kliknij Uruchom, aby uruchomić terminal Ubuntu. Jeśli zostaniesz poproszony o pobranie najnowszego jądra WSL2 Linux, postępuj zgodnie z instrukcjami, które zostaną dostarczone. Zainstaluj aktualizację i ponownie uruchom Ubuntu.
   5. Postępuj zgodnie z instrukcjami terminala, aby wprowadzić nową nazwę użytkownika systemu UNIX i ustawić hasło. Po skonfigurowaniu konta użytkownika uruchom Ubuntu z pola wyszukiwania na pasku zadań systemu Windows. Otwórz katalog domowy (aka "."), z okna poleceń:
      > explorer.exe .
   6. Zainstaluj serwer X-Window zgodny z WSL, na przykład Xming: https://sourceforge.net/projects/xming/
   7. Uruchom serwer X-Window, Xming, klikając dwukrotnie ikonę Xming; wybierz Wiele okien. Następnie otwórz terminal Ubuntu i wykonaj krok 1.3 (Linux).
3. Przygotowanie (Linux)
   UWAGA: Te instrukcje są odpowiednie dla dystrybucji Linuksa, które używają menedżera pakietów APT. Te polecenia muszą zostać zmodyfikowane dla dystrybucji, takich jak Red Hat Linux, które używają innego menedżera pakietów. W takim przypadku postępuj zgodnie z instrukcjami dystrybucji Linuksa, aby zainstalować te same pakiety.
   1. Zaktualizuj system Linux:
      > sudo apt-get update
      > sudo apt-get upgrade
   2. Zainstaluj kompilator C++ i make (https://www.gnu.org/software/make) GNU:
      > sudo apt-get install build-essential
   3. Zainstaluj biblioteki BLAS/LAPACK (http://www.netlib.org/lapack):
      > sudo apt-get install libblas-dev liblapack-dev
   4. Zainstaluj bibliotekę programisty OpenGL i pliki nagłówkowe (https://www.mesa3d.org):
      > sudo apt-get install mesa-common-dev
   5. Zainstaluj bibliotekę GLEW (http://glew.sourceforge.net):
      > sudo apt-get install libglew-dev
   6. Zainstaluj bibliotekę freeGLUT (http://freeglut.sourceforge.net):
      > sudo apt-get install freeglut3-dev
   7. Zainstaluj system kontroli wersji GIT (https://git-scm.com):
      > sudo apt-get install git
   8. Zainstaluj programy testowe X11 (np. xeyes, xclock, xcalc):
      > sudo apt-get install x11-apps
   9. Dostosuj zmienną środowiskową DISPLAY:
      > export DISPLAY=:0
      1. Spróbuj otworzyć okno X11:
         > XEYES
      2. Jeśli to zadziała, przejdź do kroku 2. Jeśli błąd nie powiedzie się, aby otworzyć wyświetlacz, spróbuj użyć innej wartości DISPLAY.
      3. Znajdź adres IP komputera WSL2:
         > cat /etc/resolv.conf
      4. Jeśli pojawi się numer IP, np. "serwer nazw 10.16.0.7", użyj tego numeru IP zamiast X.X.X.X poniżej:
         > export DISPLAY= X.X.X.X:0
         > XEYES
      5. Jeśli to zadziała, przejdź do kroku 2. Jeśli "play" nie "otworzy wyświetlacza", spróbuj uruchomić go z poziomu okna "xterm":
         > sudo apt install xterm
         > xterm -display :0
      6. W nowym oknie, które zostanie otwarte, wpisz:
         > XEYES

2. Instalacja Cytosim

UWAGA: Te kroki są podobne dla każdego systemu operacyjnego: MacOS, WSL i Linux. W poniższej sekcji polecenia będą wydawane w terminalu, a "bieżący katalog roboczy" powinien być ustawiony na katalog, w którym symulacja została skompilowana. Ten katalog będzie określany jako katalog podstawowy. Alternatywnie wszystko można zrobić w osobnym katalogu, jeśli pliki są kopiowane w razie potrzeby. Jeśli nie jesteś zaznajomiony z wierszem poleceń, rozważ skorzystanie z samouczka, na przykład https://www.learnenough.com/command-line-tutorial lub https://learnpythonthehardway.org/book/appendixa.html.

1. Pobierz kod źródłowy Cytosism:
   > git klon https://gitlab.com/f-nedelec/cytosim.git cytosim
   UWAGA: Konto Gitlab nie jest konieczne do pobrania kodu. Powinno to utworzyć nowy podkatalog "cytosim" w bieżącym katalogu.
2. Kompilacja:
   > cd cytosim
   > marki >
   1. Sprawdź, czy w podkatalogu "bin" zostały utworzone trzy pliki, uruchamiając polecenie:
      > ls pojemnik
   2. Jeśli krok 2.2.1 się nie powiedzie, wypróbuj tę alternatywną metodę kompilacji, instalując cmake(https://cmake.org):
      > mkdir b
      > cd b
      > cmake ..
      > make
      > cd ..
3. Sprawdź pliki wykonywalne:
   > informacje o pojemniku/karcie SIM
   > informacje o koszu/odtwarzaniu >
   1. Sprawdź, czy oba pliki wykonywalne zostały skompilowane w celu przeprowadzenia symulacji 2D. Poszukaj następujących danych wyjściowych powyższych zapytań "info":
      Wymiar: 2 Okresowy: 1 Precyzja: 8 bajtów
   2. Jeśli tak nie jest, i tylko wtedy, zmodyfikuj plik "src/math/dim.h" (otwórz, edytuj, aby zmienić DIM na 2, zapisz) i ponownie skompiluj Cytosim:
      > make clean
      > marki
4. Uruchomienie testowe
   1. Skopiuj trzy pliki wykonywalne:
      > cp bin/sim sim
      > kosz CP/Play Play
      > CP BINK/raport raportu
   2. Utwórz nowy katalog:
      > mkdir run
   3. Skopiuj i zmień nazwę standardowego pliku konfiguracyjnego:
      > cp cym/fiber.cym uruchom/config.cym
   4. Rozpocznij symulację:
      > cd run
      > .. /Sim
   5. Wizualizacja wyników symulacji:
      > .. /grać
      1. Naciśnij spację, aby animować. Naciśnij h, aby uzyskać pomoc dotyczącą skrótów klawiaturowych.
      2. Aby wyjść z programu, w systemie MacOS spróbuj -Q lub CTRL-Q lub wybierz z menu opcję Zakończ. W ostateczności wpisz CTRL-C w oknie terminala, z którego uruchomiono "play".
   6. Uruchom w trybie na żywo:
      > .. /Graj na żywo

3. Konfiguracja symulacji

1. Zainstaluj edytor tekstu zorientowany na kod (np. TextMate, SublimeText), jeśli nie jest jeszcze dostępny.
   Otwórz edytor i otwórz plik "config.cym", znajdujący się w katalogu "uruchom" utworzonym w kroku 2.4.2. Zapoznaj się z różnymi sekcjami pliku konfiguracyjnego, który jest kopią pliku "fiber.cym" (plik uzupełniający 1).
   UWAGA: Cytosim zwykle odczytuje tylko jeden plik konfiguracyjny kończący się na ".cym". Wszystkie modyfikacje zostaną wprowadzone w tym miejscu w "config.cym". Tabela uzupełniająca S1 zawiera listę parametrów.
2. Zmodyfikuj symulację, wprowadzając następujące zmiany w "config.cym":
   Promień=5 → Promień=3
   Nowy 1 filament → nowy 100 filament
3. Zapisz plik bez zmiany jego nazwy lub lokalizacji (zastąp "config.cym"). Przełącz się do okna terminalu i sprawdź, czy symulacja została zmodyfikowana zgodnie z oczekiwaniami za pomocą:
   > .. /Graj na żywo
   UWAGA: Promień okręgu jest określony w mikrometrach (μm), podobnie jak wszystkie odległości w Cytosim. Cytozym jest zgodny z systemem jednostek dostosowanych do skali komórki, pochodzących z mikrometrów, pikonewtonów i sekund.
4. W akapicie "ustaw filament światłowodowy" wprowadź następujące zmiany:
   sztywność = 20 → sztywność = 0.1 < br / > Segmentacja = 0,5 → Segmentacja = 0,2
   confine=wewnątrz, 200, komórka → confine= wewnątrz, 10, komórka
   W akapicie "nowy filament" zmień:
   Długość=12 → Długość=2
   Skróć czas symulacji, zmieniając
   Uruchom system 5000 → uruchom 1000 System
   UWAGA: Spowoduje to dostosowanie właściwości filamentu. Paragraf "set" określa trwałe właściwości filamentów, podczas gdy parametry w "new" są zwykle warunkami początkowymi. Sztywność zginania jest określona w pN μm². Segmentacja to przybliżona odległość między wierzchołkami opisującymi włókna w mikrometrach (μm). Należy go zmniejszyć, jeśli filamenty są bardziej elastyczne. Ostatnia zmiana zmniejsza sztywność (pN/μm) potencjału uwięzienia związanego z krawędziami "komórki". Długość zadeklarowana w "nowym" ustępie (2 μm) jest początkową długością włókien, a ponieważ w tym modelu włókna nie są dynamiczne, ich długości nie ulegną zmianie. Zaleca się podpisanie pliku konfiguracyjnego poprzez edycję pierwszego wiersza:
   % Twoje imię i nazwisko, data, miejsce
   1. Sprawdź poprawność pliku konfiguracyjnego (powtórz krok 3.3).
5. Tworzenie łączników pasywnych.
   1. Dodaj nowy akapit do "config.cym", przed wierszami z poleceniem "new" i "run", aby zdefiniować aktywność molekularną z powinowactwem do filamentów:
      zestaw segregatora ręcznego {
      binding_rate = 10
      binding_range = 0.01
      unbinding_rate = 0.2
      }
   2. Aby zdefiniować jednostki dwufunkcyjne, dodaj kolejny akapit tuż poniżej:
      set couple crosslinker {
      ręka1 = spoiwo
      ręka2 = spoiwo
      sztywność = 100
      dyfuzja = 10
      }
   3. Dodaj "nowe" polecenie po poprzednich akapitach i przed poleceniem "uruchom":
      Nowy 1000 Crosslinker
      UWAGA: W cytosimie szybkości są określone w jednostkach s⁻¹, a zakres w mikrometrach (μm). Sztywność określa się w jednostkach pikonewtonów na mikrometr (pN/μm), a współczynnik dyfuzji w mikrometrach do kwadratu na sekundę (μm²/s). Kolejność poleceń w pliku konfiguracyjnym jest ważna, a te akapity muszą pojawiać się przed każdym poleceniem "uruchom", w przeciwnym razie nie będą skuteczne. Aby dowiedzieć się więcej o obiektach Cytosim, postępuj zgodnie z samouczkiem w "tuto_introduction.md", który znajduje się w podfolderze "doc" katalogu podstawowego: doc/tutorials/.
6. Twórz silniki dwufunkcyjne.
   1. Dodaj nowy akapit do "config.cym", przed wierszami z poleceniem "new" i "run":
      ustaw silnik ręczny {
      binding_rate = 10
      binding_range = 0.01
      unbinding_rate = 0.2
      aktywność = move
      unloaded_speed = 1
      stall_force = 3
      }
   2. Dodaj kolejny akapit, po poprzednim:
      set para złożona {
      ręka1 = silnik
      Ręka2 = Silnik
      sztywność = 100
      dyfuzja = 10
      }
   3. Dodaj "nowe" polecenie po poprzednich akapitach i przed poleceniem "uruchom":
      Nowość 200 Complex
      UWAGA: "aktywność = ruch" określa silnik, który porusza się w sposób ciągły nad filamentem. Silnik jest zgodny z liniową krzywą siła-prędkość (Rysunek 1) charakteryzującą się prędkością bez obciążenia (μm/s) i siłą przeciągnięcia (piconewton). W każdym kroku czasowym, τ, porusza się o odległość, v × τ. Użycie "aktywność = brak" określiłoby cząsteczkę, która się nie porusza, a ponieważ jest to domyślna aktywność, można po prostu całkowicie pominąć "aktywność". Możliwe są inne czynności, na przykład "aktywność = chodzenie" określałoby silnik z dyskretnymi krokami wzdłuż filamentu. "unloaded_speed" jest dodatnie dla silnika ukierunkowanego na dodatni koniec. Określenie wartości ujemnej spowodowałoby, że silnik przesunąłby się w kierunku końców ujemnych. Jest to bardziej szczegółowo wyjaśnione w pierwszym samouczku Cytosim (patrz link w kroku 3.5.2).
7. Zapisz plik.
   Sprawdź symulację:
   > .. /Graj na żywo
   Uruchom symulację:
   > .. /sim
   Wizualizacja wyników:
   > .. /play
   Skopiuj ostateczny plik konfiguracyjny do katalogu podstawowego:
   > cp config.cym .. /config.cym
   UWAGA: Twój końcowy plik powinien być podobny do Pliku Uzupełniającego 2 ("jove.cym"). Zwróć uwagę, ile czasu zajęło obliczenie tej symulacji. W kolejnych sekcjach czas ten zostanie pomnożony przez liczbę symulacji wykonanych w celu wygenerowania wykresu, na którym parametr jest zmienny.

4. Zamiatanie parametrów

UWAGA: W tej sekcji liczba crosslinkerów w sieci jest systematycznie zmieniana.

1. Importowanie skryptów języka Python.
   1. Utwórz podkatalog "byn" w katalogu podstawowym:
      > mkdir byn
   2. Skopiuj trzy skrypty ze standardowego rozkładu cytozym:
      > cp python/run/preconfig.py byn/preconfig
      > cp python/look/scan.py byn/.
      > cp python/look/make_page.py byn/.
      UWAGA: Ze względów bezpieczeństwa kopie tych plików są dostarczane jako >Plik uzupełniający 3, Plik uzupełniający 4 i Plik uzupełniający 5 z tym artykułem.
2. Spraw, aby pliki były wykonywalne:
   > chmod +x byn/preconfig
   > chmod +x byn/scan.py
   > chmod +x byn/make_page.py >
   1. Sprawdź, czy skrypty są wykonywane poprawnie:
      > byn/preconfig help
      > byn/scan.py help
      > byn/make_page.py help
      UWAGA: Powinno to wydrukować opis tego, jak można użyć każdego polecenia. Możliwe jest zmodyfikowanie zmiennej PATH, aby wywoływać skrypty w prostszy sposób; Patrz https://en.wikipedia.org/wiki/PATH_(zmienna).
   2. Rozwiązywanie problemów
      1. Jeśli błąd to "nie znaleziono polecenia", sprawdź określoną ścieżkę, która powinna odpowiadać lokalizacji pliku. Jeśli występuje inny typ błędu, ponieważ system operacyjny nie zapewnia python2, edytuj trzy pliki .py i zmodyfikuj shebang, który jest pierwszym wierszem każdego pliku (po prostu dodaj "3"):
         #!/usr/bin/env python → #!/usr/bin/env python3
3. Skopiuj plik konfiguracyjny, aby przekształcić go w "szablon" (plik uzupełniający 6):
   > cp config.cym config.cym.tpl
4. Edytuj plik konfiguracyjny szablonu. W edytorze kodu otwórz plik "config.cym.tpl", znajdujący się w katalogu podstawowym. Zmień jeden wiersz, aby wprowadzić zmienny element tekstowy:
   Nowy 1000 Crosslinker → nowy [[range(0,4000,100)]] Crosslinker
   UWAGA: Preconfig rozpozna kod zawarty w podwójnych nawiasach kwadratowych i zastąpi go wartością uzyskaną przez wykonanie tego kodu w Pythonie. W Pythonie "range(X,Y,S)" określa liczby całkowite od X do Y, z przyrostem S; W tym przypadku [0, 100, 200, 300, ... 4000]. Intencją jest zmiana liczby linkerów dodawanych do symulacji.
5. Wygeneruj pliki konfiguracyjne z szablonu:
   > byn/preconfig runi/config.cym config.cym.tpl
   UWAGA: Powinno to utworzyć 40 plików, po jednym dla każdej wartości określonej w "range(0,4000,100)". Nazwy plików, które mają być wygenerowane przez Preconfig, są określone przez "runi/config.cym". Za pomocą tego konkretnego kodu Preconfig wygeneruje "run0000/config.cym", "run0001/config.cym" itp. W rzeczywistości sprawi, że katalogi będą "run0000", "run0001" itp., i utworzy plik "config.cym" w każdym z nich. Sprawdź pomoc Preconfig, aby uzyskać więcej informacji (uruchom "byn/preconfig help"). W przypadku błędu sprawdź, czy polecenie zostało dokładnie wpisane. Liczy się każda postać.
6. Uruchom wszystkie symulacje sekwencyjnie:
   > byn/scan.py '.. /sim' biegnij????
   UWAGA: Program "scan.py" wykona polecenie podane w cudzysłowie z podanej listy katalogów. W tym przypadku ta lista katalogów jest określona przez "uruchom???? ". Znak zapytania to dzika karta, która pasuje do dowolnego znaku. Stąd "uciekać???? " pasuje do dowolnej nazwy rozpoczynającej się od "run" i następującej po niej dokładnie czterech znaków. Alternatywnie można użyć "run*", aby wygenerować tę samą listę, ponieważ "*" pasuje do dowolnego ciągu.
   1. W przypadku problemów wykonaj to polecenie z nowego okna terminala, aby kolejno uruchomić "sim" we wszystkich katalogach utworzonych w kroku 4.5. Poczekaj około 30 minut na zakończenie procesu, ale zależy to w dużej mierze od pojemności komputera. Zmniejsz ilość obliczeń wymaganych przez edycję "config.cym":
      Uruchom system 1000 → uruchom system 500
7. Wizualizacja niektórych symulacji:
   > ./play run0010
   > ./play run0020
powiedział:
8. Generuj obrazy dla wszystkich symulacji:
   > byn/scan.py '.. /play rozmiar obrazu=256 klatek=10' biegu????
9. Wygeneruj stronę podsumowania HTML:
   > byn/make_page.py tile=5 run????
   1. Otwórz "page.html" w przeglądarce internetowej.

5. Tworzenie wykresu

UWAGA: W tej sekcji wykres jest tworzony na podstawie wyników przemiatania parametrów.

1. Sprawdź plik wykonywalny raportu:
   > cd run
   > .. /raport sieć:rozmiar
   UWAGA: Dla każdej klatki na trajektorii zostanie wydrukowane kilka komentarzy i dwie liczby odpowiadające "polimerowi" i "powierzchni". Używana będzie tylko "powierzchnia" sieci (ostatnia kolumna).
   1. W szczególności ogranicz informacje do jednej ramki za pomocą:
      > .. /report network:rozmiar ramki=10
   2. Usuń komentarze, aby ułatwić przetwarzanie danych wyjściowych:
      > .. /report network:rozmiar ramki=10 gadatliwy=0
   3. Na koniec przekieruj dane wyjściowe do pliku za pomocą narzędzia potoku systemu Unix (">"):
      > .. /report network:rozmiar ramki=10 gadatliwy=0 > net.txt
   4. Wydrukuj zawartość pliku do terminala w celu weryfikacji:
      > kot net.txt
      UWAGA: Powinno to wydrukować dwie liczby. Druga to powierzchnia pokryta przez sieć w 10. klatce. Aby wykonać tę samą operację we wszystkich katalogach "uruchom", zmień katalog:
      > cd ..
2. Wygeneruj raport w każdym podkatalogu symulacji:
   > byn/scan.py '.. /report network:size frame=10 verbose=0 > net.txt' run????
   UWAGA: Ponownie, scan.py wykona cytowane polecenie we wszystkich katalogach określonych przez "uruchom???? ". Polecenie jest ostatnim, które zostało wypróbowane w kroku 5.1. Spowoduje to wygenerowanie pliku "net.txt" w każdym katalogu (spróbuj "ls run???? ").
3. Sprawdź te liczby:
   > byn/scan.py "cat net.txt" bieg????
   1. Dodaj opcję "+", aby połączyć nazwę katalogu i dane wyjściowe polecenia:
      > byn/scan.py + 'cat net.txt' run????
4. Zbierz te liczby do pliku:
   > byn/scan.py + "cat net.txt" biegnij???? > results.txt
5. Wyczyść plik "results.txt", usuwając powtarzający się tekst, który nie jest numeryczny. Otwórz ciąg "result.txt" w edytorze kodu i użyj polecenia "zastąp tekst", aby usunąć wszystkie ciągi "uruchom". Usuń tylko trzy litery i zachowaj cyfry; "run0000" powinno stać się "0000".
   UWAGA: Powinno to pozostawić plik z samymi liczbami uporządkowanymi w trzech kolumnach.
6. Wygeneruj wykres kurczliwości na podstawie danych w "result.txt". Użyj dowolnej metody, aby wygenerować wykres, używając kolumny 1 dla X i kolumny 3 dla Y. Oznacz oś X jako liczbę środków sieciujących/100. Oznacz oś Y jako powierzchnię (mikrometr^2).
7. Przechowuj wszystkie symulacje w osobnym katalogu:
   > mkdir save1
   > Uruchom MV???? zapisz1

6. Alternatywna metoda tworzenia wykresu

1. Dodaj polecenie report na końcu "config.cym.tpl" w nowym wierszu po zamykającym "}" polecenia uruchamiania:
   raport sieć:rozmiar net.txt { verbose = 0 }
2. Generuj pliki konfiguracyjne:
   > byn/preconfig runi/config.cym config.cym.tpl
3. Uruchom wszystkie symulacje przy użyciu równoległych wątków:
   > byn/scan.py '.. /sim' biegnij???? njobs=4
   1. Dostosuj liczbę zadań (njobs=4) w zależności od pojemności komputera. Monitoruj użycie zasobów procesora, na przykład przez aplikację Monitor aktywności w systemie MacOS.
4. Zbierz dane:
   > byn/scan.py + "cat net.txt" biegnij???? > results.txt
5. Zrób wykres, tak jak w krokach 5.5 i 5.6.
6. Przechowuj wszystkie poprzednie uruchomienia w osobnym katalogu:
   > mkdir save2
   > Uruchom MV???? zapisz2

7. Ulepszony wykres przy użyciu losowego próbkowania

UWAGA: Zmienna jest tutaj próbkowana za pomocą funkcji generatora z modułu "random" Pythona.

1. W edytorze kodu otwórz plik konfiguracyjny szablonu "config.cym.tpl", znajdujący się w katalogu podstawowym. Dodaj dwie linie, tuż przed "nowym środkiem sieciującym":
   [[num = int(random.uniform(0,4000))]]
   %[[liczba]] xlinkers
   Zmień również polecenie "new", aby używało tej zmiennej:
   nowy [[range(0,4000,100)]] sieciujący → nowy [[liczba]] sieciujący
   UWAGA: Pierwszy wiersz tworzy zmienną losową "num". Drugi wiersz drukuje wartość parametru. Znak "%" jest ważny, ponieważ poinstruuje Cytosima, aby pominął linię. Wkrótce "xlinkers" będzie służył jako rozpoznawalny znacznik i musi pojawić się tylko raz w każdym pliku.
   1. Na samym końcu pliku "config.cym.tpl" upewnij się, że znajduje się instrukcja raportu:
      raport sieć:rozmiar net.txt { verbose = 0 }
2. Generuj pliki konfiguracyjne:
   > byn/preconfig runi/config.cym 42 config.cym.tpl
   UWAGA: Powinno to wygenerować 42 pliki. Liczba ta może zostać zwiększona, jeśli komputer jest wystarczająco szybki. Wartości wygenerowane losowo można zobaczyć za pomocą uniksowego narzędzia "grep" do wyszukiwania plików:
   > uruchomione są xlinkery grep???? /config.cym
3. Uruchom wszystkie symulacje równolegle:
   > byn/scan.py '.. /sim' biegnij???? njobs=4
   UWAGA: Dostosuj liczbę zadań do pojemności komputera. Aby uzyskać najlepsze wyniki, zmienna "njobs" powinna być równa liczbie rdzeni komputera.
4. Zbierz dane za pomocą jednego polecenia:
   > byn/scan.py + 'grep xlinkers config.cym; Wybieg dla kotów net.txt???? > results.txt
   UWAGA: Opcja "+" scan.py połączy wszystkie dane wyjściowe polecenia w jednym wierszu. W tym przypadku polecenie składa się w rzeczywistości z dwóch poleceń oddzielonych półkolumną ("; "). Zbieranie danych zawsze można zautomatyzować za pomocą skryptu w języku Python.
5. Wyczyść plik. Otwórz "result.txt" w edytorze kodu. Aby upewnić się, że wszystkie dane odpowiadające jednej symulacji są zawarte w jednym wierszu, usuń wszystkie wystąpienia ciągu "xlinkers" i usuń znaki "%" na początku każdego wiersza. Na koniec zapisz "result.txt", które powinny być starannie zorganizowane w trzech kolumnach wartości liczbowych.
6. Utwórz wykres, aby wykreślić dane, powtarzając krok 5.6, ale oznacz oś X jako liczbę środków sieciujących
7. Zapisz zestaw danych w nowym podkatalogu:
   >mkdir set1
   > Uruchom MV???? set1/.
   > mv results.txt set1/.
8. Oblicz inny zestaw danych, powtarzając kroki 7.2–7.6, a następnie powtórz krok 7.8, zastępując ciąg "set1" ciągiem "set2" we wszystkich trzech poleceniach.
9. Zrób połączoną działkę.
   1. Połącz dwa pliki danych:
      > zestaw dla kotów?/results.txt > results.txt
      UWAGA: Nowy "result.txt" powinien być większy.
   2. Wykreśl dane, aby utworzyć wykres łączony, zgodnie z opisem w kroku 7.7.

8. W pełni zautomatyzowany potok

UWAGA: W tej części wszystkie operacje wymagające ręcznej interwencji są zastępowane poleceniami. Po wykonaniu tej czynności możliwe będzie napisanie pojedynczego skryptu, który automatycznie wykona wszystkie kroki. Ten skrypt można uruchomić na komputerze zdalnym, takim jak farma obliczeniowa.

1. Użyj uniksowego polecenia "sed", aby "wyczyścić" plik results.txt, zastępując krok 7.6.
   1. Usuń znak "%" na początku wierszy:
      > sed -e 's/%//g' results.txt > tmp.txt
   2. Usuń "xlinkers":
      > sed -e 's/xlinkers//g' tmp.txt > results.txt
2. Napisz skrypt, aby wywołać kolejno wszystkie polecenia w odpowiedniej kolejności.
   1. Używaj różnych języków: bash lub Python.
   2. Utwórz plik "pipeline.bash" i skopiuj wszystkie polecenia potrzebne do uruchomienia potoku.
   3. Wykonaj skrypt:
      > bash potok.bash
3. Użyj automatycznego skryptu kreślenia.
   UWAGA: Korzystne może być usunięcie wszystkich ręcznych interwencji. Istnieje wiele narzędzi do generowania wykresu PDF bezpośrednio z pliku danych, na przykład gnuplot (http://www.gnuplot.info), PyX (https://pyx-project.org) lub Seplot (https://pypi.org/project/seplot/).

Results

W sekcji 2, udana kompilacja Cytosim za pomocą "make" powinna spowodować wyświetlenie sim, play i report w podkatalogu "bin". Dane wyjściowe kroku 2.3 ("informacje o karcie SIM") powinny wskazywać między innymi "Wymiar: 2". W sekcji 3 plik konfiguracyjny powinien być podobny do jove.cym, dostarczony jako plik uzupełniający 1. W sekcji 4 magowieuzyskani w kroku 4.8 z symulacji powinni być podobni do tego pokazanego na Rysunek 2. Strona podsum...

Discussion

Metoda opisana w tym artykule opiera się na trzech małych i niezależnych programach w Pythonie, które były używane na różne sposoby w całym opisanym protokole. Pierwsza prekonfiguracja skryptu to wszechstronne narzędzie, które może zastąpić potrzebę pisania niestandardowych skryptów Pythona²⁷. Służy do generowania wielu plików konfiguracyjnych z jednego pliku szablonu, określając, który parametr powinien być zmieniany i w jaki sposób. Aby zmienić wiele parametrów, można po prostu dodać wi...

Materials

List of materials used in this article

Name	Company	Catalog Number	Comments
Plik konfiguracyjny szablonu	config.cym.tpl
na komputerze			MacOS, Windows 10 lub Linux
https://gitlab.com/f-nedelec/cytosim.git jove.cym			Cytosim
make_page.py			skrypt Pythona; https://github.com/nedelec/make_page.py
preconfig			Skrypt Pythona; https://github.com/nedelec/preconfig
scan.py			skrypt Pythona; https://github.com/nedelec/scan.py