Un flujo de trabajo típico para simular sistemas de citoesqueletos

Resumen

Este protocolo demuestra cómo utilizar Cytosim, una simulación de citoesqueleto de código abierto, para investigar el comportamiento de una red de filamentos conectados por motores moleculares y reticulantes pasivos. Se sigue un flujo de trabajo genérico con instrucciones paso a paso para variar el número de reticulantes y trazar la contractilidad de la red resultante.

Resumen

Muchos sistemas del citoesqueleto son ahora lo suficientemente conocidos como para permitir su modelado cuantitativo preciso. Los filamentos de microtúbulos y actina están bien caracterizados, y a menudo se conocen las proteínas asociadas, así como su abundancia y las interacciones entre estos elementos. Por lo tanto, las simulaciones por computadora se pueden utilizar para investigar el comportamiento colectivo del sistema con precisión, de una manera complementaria a los experimentos. Cytosim es una suite de simulación de citoesqueletos de código abierto diseñada para manejar grandes sistemas de filamentos flexibles con proteínas asociadas, como motores moleculares. También ofrece la posibilidad de simular reticulantes pasivos, reticulantes difusibles, nucleadores, cortadores y versiones discretas de los motores que solo pisan sitios de celosía desocupados en un filamento. Otros objetos complementan los filamentos ofreciendo una geometría esférica o más complicada que se puede utilizar para representar los cromosomas, el núcleo o las vesículas de la célula.

Cytosim ofrece herramientas sencillas de línea de comandos para ejecutar una simulación y mostrar sus resultados, que son versátiles y no requieren conocimientos de programación. En este flujo de trabajo, se dan instrucciones paso a paso para i) instalar el entorno necesario en una computadora nueva, ii) configurar Cytosim para simular la contracción de una red 2D de actomiosina, y iii) producir una representación visual del sistema. A continuación, se sondea el sistema variando sistemáticamente un parámetro clave: el número de reticulantes. Finalmente, la representación visual del sistema se complementa con la cuantificación numérica de la contractilidad para visualizar, en un gráfico, cómo la contractilidad depende de la composición del sistema. En general, estos diferentes pasos constituyen un flujo de trabajo típico que se puede aplicar con pocas modificaciones para abordar muchos otros problemas en el campo del citoesqueleto.

Introducción

El citoesqueleto está formado por filamentos dentro de la célula y moléculas asociadas, como motores moleculares, que a menudo constituyen una malla dinámica con notables propiedades mecánicas. El citoesqueleto existe en varias configuraciones en diferentes tipos de células en casi todas las formas de vida. Su correcto funcionamiento es esencial para procesos celulares fundamentales como la división, la motilidad y la polarización. También gobierna las interacciones mecánicas de célula a célula, influyendo así en la morfogénesis de tejidos y organismos. El citoesqueleto subyace a varias funciones y se manifiesta en muchos procesos biológicos. Por ejemplo, la contracción de los músculos está relacionada con la potencia de los motores moleculares de miosina en los filamentos de actina. Otro ejemplo es el mantenimiento de las neuronas, que se basa en los movimientos de los motores de quinesina a lo largo de los microtúbulos ubicados dentro de los axones de estas neuronas. La actina y los microtúbulos son dos tipos preeminentes de filamentos del citoesqueleto, y sin ellos, la vida tal como la conocemos sería imposible.

El citoesqueleto es esencialmente un sistema biomecánico, que no puede reducirse únicamente a su química. Los microtúbulos o filamentos de actina se construyen a partir de miles de monómeros y se extienden a lo largo de varios micrómetros. Las conformaciones de estos filamentos en el espacio y las fuerzas que pueden transmitir a la membrana plasmática, al núcleo o a otros orgánulos son aspectos clave de su papel en la célula. Por ejemplo, una red de filamentos de actina y motores de miosina, llamada corteza de actomiosina¹, genera fuerzas para mantener la motilidad celular y los cambios morfológicos en las células animales. Una disposición muy diferente se observa en las células vegetales, donde los microtúbulos corticales dirigen la deposición de fibrillas de celulosa, controlando así la arquitectura de la pared celular, que en última instancia determina cómo crecerán estas células en el futuro².

Si bien la mecánica juega claramente un papel importante en las operaciones del citoesqueleto, la química es igualmente importante. Los filamentos crecen a través de un proceso de autoensamblaje en el que los monómeros encuentran su sitio de acoplamiento en la punta del filamento después de difundirse a través del citoplasma³. A escala molecular, el ensamblaje y desensamblaje en la punta de los filamentos están, por lo tanto, determinados por las afinidades moleculares⁴. Del mismo modo, las proteínas del citoesqueleto se difunden y las tasas de unión y desunión determinan su afinidad por los filamentos que encuentran. En el caso de los motores moleculares, los ciclos de reacciones químicas que involucran hidrólisis de ATP están ligados a los movimientos a lo largo de los filamentos y, posiblemente, a las fuerzas que los acompañan⁵. Sorprendentemente, el citoesqueleto ofrece muchos desafíos inusuales y una gran variedad de procesos que involucran componentes similares. Es un rico patio de recreo en la interfaz entre la biología, la química y la física.

Los sistemas citoesqueléticos son susceptibles de modelado matemático. De hecho, gracias a la excelente investigación realizada en las últimas décadas, lo más probable es que los principales constituyentes moleculares ya estén identificados, como se ilustra con la endocitosis⁶. En los organismos modelo, como las levaduras, se conocen las propiedades de estos elementos, así como la composición del sistema para algunos de sus procesos. Por ejemplo, se han descrito la estructura y las propiedades del material^de los microtúbulos 7, así como su número y longitudes medias en varias etapas del huso mitótico⁸. A menudo se conoce el número de quinesinas que conectan los microtúbulos en una estructura mecánica coherente⁹. Las velocidades de muchos motores se han medido in vitro¹⁰. Además, los experimentalistas pueden observar y cuantificar estos sistemas in vivo en condiciones de tipo salvaje o mutadas. La combinación de la teoría junto con experimentos in vivo e in vitro permite a los investigadores probar si el conocimiento actual sobre un sistema citoesquelético es suficiente para explicar su comportamiento observado. El uso de herramientas matemáticas y computacionales también nos permite hacer inferencias de cómo los componentes trabajan colectivamente sobre la base de suposiciones derivadas de observaciones a escala molecular, generalmente en situaciones simplificadas (por ejemplo, experimentos de una sola molécula).

El papel de la teoría se puede ilustrar con un ejemplo práctico: el latido de los cilios. Este golpeteo se debe al movimiento de los motores de dineína a lo largo de los microtúbulos de los cilios. Uno puede preguntarse qué determina la velocidad del motor de dineína en este sistema. Una posible respuesta es que la velocidad máxima está limitada por el requisito de mantener un cierto patrón de golpes. Esto sería comprensible si la paliza se produjera bajo la selección natural. En ese caso, si los motores se movieran más rápido, entonces el proceso perdería sus cualidades deseadas: los cilios no latirían tan eficientemente o incluso fallarían por completo. Aunque esto es posible, una segunda alternativa es que algún factor intrínseco podría limitar la velocidad de la dineína.

Por ejemplo, es posible que la célula no tenga suficiente ATP para producir dineína más rápido, o que los movimientos de las proteínas necesarios para la actividad de la dineína simplemente no se puedan acelerar. En ese caso, si los motores pudieran ser más rápidos a pesar de los límites físicos, el golpeteo mejoraría. Una tercera posibilidad, por supuesto, es que cambiar la velocidad no afecte significativamente al proceso, lo que podría ser ventajoso para el organismo al proporcionar cierta "robustez" contra factores incontrolables. Entre estas tres posibilidades, se puede identificar la correcta calculando el patrón de batido a partir de las propiedades de la dineína. De hecho, un modelo matemático adecuado debería predecir cómo el patrón de batido se ve afectado por la variación de la velocidad de la dineína y no está sujeto a los límites que existen en el mundo físico. Naturalmente, se debe verificar la validez del modelo, pero incluso los modelos "incorrectos" pueden generar ideas interesantes.

El modelo puede tomar la forma de un marco analítico o ser una simulación numérica del sistema. De cualquier manera, la brecha entre la escala molecular y la escala funcional sigue siendo un obstáculo, y el desarrollo de estos modelos no es una tarea sencilla, ya que varios procesos mecánicos y químicos deben integrarse en las ecuaciones que describen el sistema biológico. La teoría se presenta en varias formas, ofreciendo diferentes compensaciones entre la simplicidad y el realismo. Aumentar el grado de detalle en un modelo no siempre es ventajoso, ya que puede limitar nuestra capacidad para resolver las ecuaciones o, en otras palabras, para derivar las predicciones de la teoría. La misma compensación existe para las simulaciones. Los modeladores tendrán que seleccionar los ingredientes del sistema a tener en cuenta ignorando ciertos aspectos. Estas decisiones clave dependerán en gran medida del objetivo del estudio. Hoy en día, las extraordinarias mejoras en el hardware informático permiten simular muchos sistemas de citoesqueletos con suficientes detalles durante un tiempo suficiente para analizar su comportamiento. Esto a menudo generará ideas inesperadas y direcciones novedosas en la investigación. Por ejemplo, simulaciones similares a las que se utilizarán en este protocolo condujeron a un cálculo que puede predecir la contractilidad de una red en función de su composición¹¹.

Los métodos numéricos son omnipresentes en la ingeniería y las ciencias físicas, y su uso en biología está creciendo. Hoy en día, prácticamente todos nuestros whatchamacallit tecnológicos (relojes, teléfonos, automóviles y computadoras) se han concebido por primera vez en una computadora, y existe un poderoso software para hacer esto. Dado un sistema de citoesqueletos bien caracterizado y suponiendo que se haya determinado un nivel apropiado de descripción, aún deben resolverse varios problemas antes de que pueda simularse. Para los problemas más simples, la ruta de acción más apropiada podría ser escribir una simulación "codificando desde cero", es decir, partiendo de un lenguaje de programación genérico o de una plataforma matemática como MATLAB. Esto tiene la ventaja de que el autor del código tendrá un conocimiento íntimo de lo que se ha implementado y sabe exactamente cómo funciona el software. Sin embargo, esta ruta no está exenta de riesgos, y no es raro ver a los estudiantes de doctorado pasar la mayor parte de su tiempo de trabajo escribiendo código en lugar de abordar cuestiones científicas.

La alternativa es utilizar software concebido por otros, pero esto tampoco está exento de riesgos; Cualquier código fuente de gran tamaño tiende a adquirir espontáneamente los rasgos de una caja negra impenetrable, a pesar de los esfuerzos más admirables de sus autores por evitarlo. El uso de cajas negras seguramente no es el sueño de un científico. Un código fuente grande también puede convertirse en una responsabilidad, y puede ser más rápido comenzar desde cero que modificar una base de código existente para que haga algo diferente. Para mitigar este problema, siempre se puede invitar a los autores del software a ayudar, pero esto puede no ser suficiente. Con frecuencia, hay una diferencia de cultura científica entre los autores del software y las personas que quisieran usarlo, lo que significa que muchos supuestos implícitos deben aclararse. Al hacer que el código sea de código abierto, se espera que más personas se involucren en el desarrollo del software y en mantener su documentación, mejorando así su calidad. Todos estos son temas importantes que deben ser considerados adecuadamente antes de realizar cualquier inversión. Sin embargo, la única forma de progresar a largo plazo es promover soluciones de software sólidas, utilizadas y mantenidas por una amplia comunidad con intereses científicos comunes.

Aunque este protocolo utiliza Cytosim, existen otras herramientas de código abierto que podrían ser capaces de simular el mismo sistema, por ejemplo, AFINES¹², MEDYAN¹³, CyLaKS¹⁴, aLENS¹⁵ y AKYT¹⁶, por nombrar algunas. Desafortunadamente, la comparación de estos proyectos está más allá del alcance del artículo. Aquí, se dan instrucciones paso a paso para simular una red de actomiosina 2D contráctil. Este sistema es simple y hace uso de las capacidades mejor establecidas de Cytosim. Cytosim se basa en un motor central multiplataforma que puede ejecutar simulaciones en 2D o 3D. Tiene una base de código modular, lo que lo hace fácilmente personalizable para realizar tareas particulares. Cytosim es igualmente estable y eficiente en 3D y se ha utilizado con éxito en el pasado para investigar diversos problemas relacionados con los microtúbulos y los filamentos de actina: la asociación de dos ásteres de microtúbulos¹⁷, el movimiento de los núcleos en las células^18,19, la endocitosis⁶, la citocinesis²⁰, la formación del huso mitótico²¹, los movimientos del huso mitótico²², La captura de los cromosomas²³, la contracción de las redes de actomiosinas^11,24 y la mecánica del anillo de microtúbulos en las plaquetas de la sangre²⁵, y las capacidades desarrolladas para estos proyectos se han mantenido en el código. El flujo de trabajo descrito aquí se puede adaptar a muchos otros problemas. Hace uso de la línea de comandos de Unix, que puede ser desconocida para algunos lectores. Sin embargo, el uso de la línea de comandos es la forma más portátil y conveniente de automatizar el proceso de ejecución de simulaciones. Las interfaces gráficas de usuario integradas tienen como objetivo ofrecer un acceso fácil e intuitivo a un software, pero esto a menudo se produce a expensas de la generalidad. El objetivo de este artículo es ilustrar un enfoque que puede ser fácilmente modificado o adaptado a otros problemas. Se proporcionan notas para explicar el significado de los comandos.

Para simular una red de actomiosina, los filamentos se modelan como líneas orientadas y se representan mediante vértices distribuidos a lo largo de su longitud (Figura 1). Este es un nivel intermedio de descripción, común en la física de polímeros, que ignora la naturaleza 3D genuina de los filamentos, pero permite calcular la flexión. Los filamentos pueden crecer y encogerse en sus extremos, siguiendo diferentes modelos que abarcan tanto la fenomenología de la actina como la de los microtúbulos. En las células, los filamentos se organizan principalmente a través de interacciones que restringen su movimiento, por ejemplo, la unión a otros filamentos o simplemente el confinamiento dentro de la célula. En Cytosim, todas estas interacciones están linealizadas y combinadas en una gran matriz²⁶. Las ecuaciones que describen el movimiento de todos los vértices del filamento se derivan de esta matriz, asumiendo un medio viscoso y términos fluctuantes aleatorios que representan el movimiento browniano. Estas ecuaciones se resuelven numéricamente para obtener el movimiento de los filamentos junto con todas las fuerzas que actúan sobre ellos de forma autoconsistente y eficiente²⁶. Superpuesto a este motor mecánico, existe un motor estocástico que simula eventos discretos, como las uniones y desconexiones de motores moleculares o la dinámica de ensamblaje de filamentos. En resumen, Cytosim utiliza en primer lugar la dinámica simulada para calcular la mecánica de una red de filamentos, conectados de forma arbitraria y, en segundo lugar, métodos estocásticos para simular la unión, desunión y difusión de las proteínas que conectan o afectan a los filamentos.

El flujo de trabajo que se ilustra aquí se siguió con frecuencia para explorar inicialmente un sistema que utilizaba Cytosim. Es probable que el paso crítico para muchos usuarios potenciales sea la instalación de los componentes de software. La distribución del software como código fuente cumple con los imperativos de la Ciencia Abierta, pero es propensa a errores ya que los desarrolladores del software solo tienen acceso a un conjunto limitado de arquitectura para probar el programa. Es posible que se produzca un error en la compilación ya que los sistemas operativos difieren. Es probable que las instrucciones proporcionadas aquí se vuelvan obsoletas a medida que evolucionen los sistemas informáticos y los códigos fuente. Por lo tanto, es esencial verificar periódicamente las últimas instrucciones en línea. En caso de problemas, se recomienda encarecidamente a los usuarios que informen publicando en el canal de comentarios correspondiente (actualmente la página de inicio de Cytosim en Gitlab) para ayudar a solucionar el problema.

Protocolo

NOTA: El protocolo consta de estos pasos: preparación de la plataforma para Windows 10, MacOS y Linux; la instalación de Cytosim; configuración de la simulación y la ejecución de la prueba y de la visualización gráfica; múltiples corridas, variando un parámetro: el número de reticulantes en la red; generar un gráfico para ver cómo la contractilidad se ve afectada por el número de reticulantes; corridas paralelas; y muestreo aleatorio. Todo el texto que sigue a un ">" son comandos que deben introducirse literalmente en la ventana del terminal. El ">" representa el símbolo del sistema del terminal y no debe incluirse, pero todos los demás caracteres son importantes.

1. Preparación de la plataforma

NOTA: Según el sistema operativo (MacOS, Windows 10 o Linux), siga los pasos 1.1, 1.2 o 1.3.

1. Preparación (MacOS)
   1. Instale las herramientas de línea de comandos de Xcode abriendo el Terminal (en Aplicaciones/Utilidades) y escriba:
      Gt; xcode-select --install
   2. Para ver o editar el código de Cytosim, instale Xcode desde la App Store de Apple (https://apps.apple.com/us/app/Xcode/id497799835?mt=12).
      NOTA: El editor integrado de Xcode es perfectamente adecuado. Otros editores orientados al código también funcionarían, por ejemplo, TextMate. Para usar TextMate, descargue y siga las instrucciones de https://macromates.com.
2. Preparación (Windows)
   NOTA: Para Windows 10 o superior, Cytosim puede ejecutarse mediante el "Subsistema de Windows para Linux" (WSL), como se describe a continuación. Una alternativa para una versión anterior es Cygwin, pero las instrucciones no se proporcionan aquí.
   1. Actualice el sistema operativo del equipo para que cumpla los requisitos de WSL 2: Windows 10 versión 1903 o superior, con Build 18362 o superior, para sistemas x64 y versión 2004 o superior, con Build 19041 o superior, para sistemas ARM64. Para obtener actualizaciones de versiones posteriores, consulte https://docs.microsoft.com/en-us/windows/release-health/release-information.
   2. Escriba Activar y desactivar características de Windows en el cuadro de búsqueda de la barra de tareas. Habilite manualmente () la plataforma de máquina virtual y el subsistema de Windows () para Linux. Haga clic en Aceptar y reinicie Windows.
   3. Ve a Windows Microsoft Store y busca Ubuntu. Descargue e instale la versión actual (Ubuntu 20.04 LTS a partir del 03.2022)
   4. Haga clic en Iniciar para iniciar el terminal de Ubuntu. Si se le pide que descargue el kernel de Linux WSL2 más reciente, siga las instrucciones que se proporcionarán. Instale la actualización y reinicie Ubuntu.
   5. Siga las instrucciones del terminal para Introduzca un nuevo nombre de usuario de UNIX y establezca una contraseña. Una vez configurada la cuenta de usuario, inicie Ubuntu desde el cuadro de búsqueda de la barra de tareas de Windows. Abra el directorio de inicio (también conocido como "."), desde la ventana de comandos:
      > explorer.exe .
   6. Instale un servidor X-Window compatible con WSL, por ejemplo, Xming: https://sourceforge.net/projects/xming/
   7. Inicie el servidor X-Window, Xming , haciendo doble clic en el icono Xming; seleccione Varias ventanas. A continuación, abra el terminal de Ubuntu y siga el paso 1.3 (Linux).
3. Preparación (Linux)
   NOTA: Estas instrucciones son apropiadas para las distribuciones de Linux que utilizan el gestor de paquetes APT. Estos comandos deben modificarse para distribuciones como Red Hat Linux que utilizan un administrador de paquetes diferente. En este caso, siga las instrucciones de la distribución de Linux para instalar los mismos paquetes.
   1. Actualizar el sistema Linux:
      > sudo apt-get update
      > sudo apt-get upgrade
   2. Instale un compilador de C++ y haga (https://www.gnu.org/software/make) de GNU):
      > sudo apt-get install build-essential
   3. Instalar bibliotecas BLAS/LAPACK (http://www.netlib.org/lapack):
      > sudo apt-get install libblas-dev liblapack-dev
   4. Instale la biblioteca de desarrollador de OpenGL y los archivos de encabezado (https://www.mesa3d.org):
      > sudo apt-get install mesa-common-dev
   5. Instale la biblioteca GLEW (http://glew.sourceforge.net):
      > sudo apt-get install libglew-dev
   6. Instale la biblioteca freeGLUT (http://freeglut.sourceforge.net):
      > sudo apt-get install freeglut3-dev
   7. Instale el sistema de control de versiones GIT (https://git-scm.com):
      > sudo apt-get install git
   8. Instale los programas de prueba X11 (por ejemplo, xeyes, xclock, xcalc):
      > sudo apt-get install x11-apps
   9. Ajuste la variable de entorno DISPLAY:
      > exportar DISPLAY=:0
      1. Intente abrir una ventana X11:
         > xeyes
      2. Si esto funciona, continúe con el paso 2. Si el error no puede abrir la pantalla, pruebe con un valor DISPLAY diferente.
      3. Busque la dirección IP de la máquina WSL2:
         > cat /etc/resolv.conf
      4. Si aparece el número de IP, por ejemplo, "servidor de nombres 10.16.0.7", utilice este número de IP en lugar de X.X.X.X a continuación:
         > exportar PANTALLA= X.X.X.X:0
         > xeyes
      5. Si esto funciona, continúe con el paso 2. Si "play" no puede "abrir la pantalla", intente ejecutarlo desde una ventana "xterm":
         > sudo apt install xterm
         > xterm -display :0
      6. En la nueva ventana que se abre, escriba:
         > xeyes

2. Instalación de Cytosim

NOTA: Estos pasos son similares para cualquier sistema operativo: MacOS, WSL y Linux. En la siguiente sección, se emitirán comandos en el terminal, y el "directorio de trabajo actual" debe establecerse en el directorio en el que se compiló la simulación. Este directorio se denominará directorio base. Alternativamente, todo se puede hacer en un directorio separado si los archivos se copian según sea necesario. Si no está familiarizado con la línea de comandos, considere seguir un tutorial, por ejemplo, https://www.learnenough.com/command-line-tutorial o https://learnpythonthehardway.org/book/appendixa.html.

1. Descargar el código fuente de Cytosim:
   > clon de git https://gitlab.com/f-nedelec/cytosim.git citosim
   NOTA: No es necesaria una cuenta de Gitlab para descargar el código. Esto debería crear un nuevo subdirectorio "cytosim" en el directorio actual.
2. Compilar:
   > cd Cytosim
   > hacer
   1. Compruebe que se crean tres archivos en un "bin" de subdirector ejecutando:
      > Papelera LS
   2. Si el paso 2.2.1 falla, pruebe este método alternativo para compilar instalando cmake (https://cmake.org):
      > mkdir b
      > CD B
      > cmake ..
      > hacer
      > cd..
3. Comprobar ejecutables:
   > información de la papelera/SIM
   > información de la papelera/juego
   1. Verifique que ambos ejecutables se hayan compilado para realizar simulaciones 2D. Busque el siguiente resultado de las consultas de "información" anteriores:
      Dimensión: 2 Periódico: 1 Precisión: 8 bytes
   2. Si este no es el caso, y solo entonces, modifique el archivo "src/math/dim.h" (abrir, editar para cambiar DIM a 2, guardar) y recompilar Cytosim:
      > hacer limpio
      > hacer
4. Ejecución de prueba
   1. Copie tres ejecutables:
      > CP Bin/Sim Sim
      > CP Bin/Play Play
      > CP Bin/Informe Informe
   2. Cree un nuevo directorio:
      > mkdir run
   3. Copie y cambie el nombre del archivo de configuración estándar:
      > cp cym/fiber.cym run/config.cym
   4. Inicie la simulación:
      > Ejecución de CD
      > .. /Sim
   5. Visualice los resultados de la simulación:
      > .. /jugar
      1. Presione la barra espaciadora para animar. Presione h para obtener ayuda sobre los atajos de teclado.
      2. Para salir del programa, en MacOS pruebe -Q o CTRL-Q, o seleccione Salir en el menú. Como último recurso, ingrese CTRL-C en la ventana del terminal desde la que se inició "jugar".
   6. Ejecutar en modo en vivo:
      > .. /Jugar en vivo

3. Configuración de la simulación

1. Instale un editor de texto orientado al código (por ejemplo, TextMate, SublimeText) si aún no está disponible.
   Abra el editor y abra el archivo "config.cym", ubicado en el directorio "run" creado en el paso 2.4.2. Familiarícese con las diferentes secciones del archivo de configuración, que es una copia de "fiber.cym" (Archivo complementario 1).
   NOTA: Por lo general, Cytosim solo lee un archivo de configuración que termina en ".cym". Todas las modificaciones se realizarán aquí en "config.cym". Consulte la Tabla complementaria S1 para obtener una lista de parámetros.
2. Modifique la simulación realizando los siguientes cambios en "config.cym":
   radio=5 → radio=3
   Nuevo 1 filamento → nuevo filamento 100
3. Guarde el archivo sin cambiar su nombre o ubicación (sobrescriba "config.cym"). Cambie a la ventana de terminal y compruebe que la simulación se modifica según lo esperado con:
   > .. /Jugar en vivo
   NOTA: El radio del círculo se especifica en micrómetros (μm), al igual que todas las distancias en Cytosim. Cytosim sigue un sistema de unidades adaptadas a la escala de la célula, derivadas de micrómetros, piconewtons y segundos.
4. En el párrafo "establecer filamento de fibra", realice los siguientes cambios:
   rigidez=20 → rigidez=0.1
   segmentación= 0.5 → segmentación=0.2
   confine=dentro, 200, celda → confina= dentro, 10, celda
   En el párrafo "nuevo filamento", modifique:
   longitud=12 → longitud=2
   Reduzca el tiempo a simular cambiando:
   Ejecutar el sistema 5000 → ejecutar el sistema 1000
   NOTA: Esto ajusta las propiedades del filamento. El párrafo "conjunto" define las propiedades persistentes de los filamentos, mientras que los parámetros en "nuevo" suelen ser condiciones iniciales. La rigidez a la flexión se especifica en pN μm². La segmentación es la distancia aproximada entre los vértices que describe los filamentos en micrómetros (μm). Es necesario reducirlo si los filamentos se hacen más flexibles. El último cambio reduce la rigidez (pN/μm) del potencial de confinamiento asociado con los bordes de la "celda". La longitud declarada en el "nuevo" párrafo (2 μm) es la longitud inicial de los filamentos, y dado que en este modelo los filamentos no son dinámicos, sus longitudes no cambiarán. Se recomienda firmar el fichero de configuración, editando la primera línea:
   % Tu nombre, fecha, lugar
   1. Compruebe la validez del archivo de configuración (repita el paso 3.3).
5. Cree conectores pasivos.
   1. Agregue un nuevo párrafo a "config.cym", antes de las líneas con el comando "new" y "run", para definir una actividad molecular con afinidad a los filamentos:
      set carpeta de mano {
      binding_rate = 10
      binding_range = 0,01
      unbinding_rate = 0,2
      }
   2. Para definir entidades bifuncionales, agregue otro párrafo justo debajo:
      set par crosslinker {
      mano1 = encuadernación
      mano2 = aglutinante
      Rigidez = 100
      difusión = 10
      }
   3. Agregue un comando "nuevo" después de los párrafos anteriores y antes del comando "ejecutar":
      Nuevo reticulante 1000
      NOTA: En Cytosim, las tasas se especifican en unidades de ^s-1 y el rango en micrómetros (μm). La rigidez se especifica en unidades de piconewtons por micrómetro (pN/μm) y el coeficiente de difusión en micrómetros al cuadrado por segundo (μm²/s). El orden de los comandos en el archivo de configuración es importante, y estos párrafos deben aparecer antes de cualquier comando de "ejecución", de lo contrario no serán efectivos. Para obtener más información sobre los objetos de Cytosim, siga el tutorial en "tuto_introduction.md", que se encuentra en una subcarpeta "doc" del directorio base: doc/tutorials/.
6. Cree motores bifuncionales.
   1. Agregue un nuevo párrafo a "config.cym", antes de las líneas con el comando "new" y "run":
      Configurar motor manual {
      binding_rate = 10
      binding_range = 0,01
      unbinding_rate = 0,2
      actividad = mover
      unloaded_speed = 1
      stall_force = 3
      }
   2. Añádase otro párrafo, después del anterior:
      conjunto de par complejo {
      mano1 = motor
      mano2 = motor
      Rigidez = 100
      difusión = 10
      ​}
   3. Agregue un comando "nuevo" después de los párrafos anteriores y antes del comando "ejecutar":
      Nuevo Complejo 200
      NOTA: La "actividad = mover" especifica un motor que se mueve continuamente sobre el filamento. El motor obedece a una curva lineal de fuerza-velocidad (Figura 1) caracterizada por la velocidad en descarga (μm/s) y la fuerza de parada (piconewton). En cada paso de tiempo, τ, se mueve a una distancia, v × τ. El uso de "actividad = ninguna" especificaría una molécula que no se mueve, y dado que esta es la actividad predeterminada, simplemente se podría omitir "actividad" por completo. Otras actividades son posibles, por ejemplo, "actividad = caminar" especificaría un motor con pasos discretos a lo largo del filamento. El "unloaded_speed" es positivo para un motor dirigido en el extremo positivo. Especificar un valor negativo haría que el motor se moviera hacia los extremos negativos. Esto se explica con más detalle en el primer tutorial de Cytosim (ver enlace en el paso 3.5.2).
7. Guarde el archivo.
   Compruebe la simulación:
   > .. /Jugar en vivo
   Ejecute la simulación:
   > .. /Sim
   Visualiza los resultados:
   > .. /jugar
   Copie el archivo de configuración final en el directorio base:
   > cp config.cym .. /config.cym
   NOTA: Su archivo final debe ser similar al Archivo Complementario 2 ("jove.cym"). Observe cuánto tiempo se necesitó para calcular esta simulación. En los siguientes apartados, este tiempo se multiplicará por el número de simulaciones realizadas para generar un gráfico donde se varía un parámetro.

4. Barrido de parámetros

NOTA: En esta sección, el número de reticuladores en la red varía sistemáticamente.

1. Importar scripts de Python.
   1. Cree un subdirectorio "byn", dentro del directorio base:
      > mkdir byn
   2. Copie tres scripts de la distribución estándar de Cytosim:
      > cp python/run/preconfig.py byn/preconfig
      > cp python/look/scan.py byn/.
      > cp python/look/make_page.py byn/.
      NOTA: Por seguridad, se proporcionan copias de estos archivos como Archivo Suplementario 3, Archivo Suplementario 4 y Archivo Suplementario 5 con este artículo.
2. Hacer que los archivos sean ejecutables:
   > chmod +x byn/preconfig
   > chmod +x byn/scan.py
   > chmod +x byn/make_page.py
   1. Compruebe que los scripts se ejecutan correctamente:
      > Ayuda de byn/preconfig
      > ayuda de byn/scan.py
      > ayuda de byn/make_page.py
      NOTA: Esto debería imprimir una descripción de cómo se puede usar cada comando. Es posible modificar la variable PATH para llamar a los scripts de forma más sencilla; Véase https://en.wikipedia.org/wiki/PATH_(variable).
   2. Solución de problemas
      1. Si el error es "comando no encontrado", verifique la ruta especificada, que debe corresponder a la ubicación del archivo. Si hay otro tipo de error porque el sistema operativo no proporciona python2, edite los tres archivos .py y modifique el shebang, que es la primera línea de cada archivo (simplemente agregue "3"):
         #!/usr/bin/env python → #!/usr/bin/env python3
3. Copie el archivo de configuración para convertirlo en una "plantilla" (Archivo complementario 6):
   > cp config.cym config.cym.tpl
4. Edite el archivo de configuración de la plantilla. En el editor de código, abra el archivo "config.cym.tpl", ubicado en el directorio base. Cambie una línea para introducir un elemento de texto variable:
   Nuevo reticulante 1000 → nuevo reticulante [[range(0,4000,100)]]
   NOTA: Preconfig reconocerá el código contenido en los corchetes dobles y lo reemplazará con un valor obtenido al ejecutar este código en Python. En Python "range(X,Y,S)" especifica enteros de X a Y, con un incremento de S; En este caso [0, 100, 200, 300, ... 4000]. La intención es cambiar el número de reticulantes agregados a la simulación.
5. Genere archivos de configuración a partir de la plantilla:
   > byn/preconfig runi/config.cym config.cym.tpl
   NOTA: Esto debería crear 40 archivos, uno para cada valor especificado en "range(0,4000,100)". Los nombres de los archivos que se generarán mediante Preconfig se especifican mediante "runi/config.cym". Con este código específico, Preconfig generará "run0000/config.cym", "run0001/config.cym", etc. De hecho, creará los directorios "run0000", "run0001", etc., y creará un archivo "config.cym" en cada uno de ellos. Consulte la ayuda de Preconfig para obtener más detalles (ejecute "byn/preconfig help"). En caso de error, compruebe que el comando esté escrito exactamente. Cada carácter cuenta.
6. Ejecute todas las simulaciones secuencialmente:
   > byn/scan.py '.. Carrera /sim'????
   NOTA: El programa "scan.py" ejecutará el comando citado en la lista de directorios proporcionada. En este caso, esta lista de directorios se especifica mediante "run????". El signo de interrogación es un comodín que coincide con cualquier carácter. Por lo tanto, "run????" coincide con cualquier nombre que comience con "run" y seguido exactamente por cuatro caracteres. Alternativamente, se puede usar "run*" para generar la misma lista, ya que "*" coincide con cualquier cadena.
   1. En caso de problemas, ejecute este comando desde una nueva ventana de terminal para ejecutar "sim" secuencialmente en todos los directorios creados en el paso 4.5. Espere aproximadamente 30 minutos para que se complete el proceso, pero esto depende en gran medida de las capacidades de la computadora. Reduzca la cantidad de cálculo solicitada editando "config.cym":
      Ejecutar el sistema 1000 → ejecutar el sistema 500
7. Visualice algunas simulaciones:
   > ./play run0010
   > ./play run0020
8. Genere imágenes para todas las simulaciones:
   > byn/scan.py '.. /play tamaño de la imagen = 256 fotograma = 10' carrera????
9. Genere una página de resumen HTML:
   > byn/make_page.py tile=5 ejecutar????
   1. Abra "page.html" en un navegador web.

5. Hacer un gráfico

NOTA: En esta sección, se realiza un gráfico a partir de los resultados del barrido de parámetros.

1. Compruebe el ejecutable del informe :
   > Ejecución de CD
   > .. /red de informes:tamaño
   NOTA: Para cada fotograma de la trayectoria, se imprimirán algunos comentarios y dos números, correspondientes a "polímero" y "superficie". Solo se utilizará la "superficie" de la red (última columna).
   1. Restrinja específicamente la información a un fotograma mediante:
      > .. /red de informes:tamaño del marco=10
   2. Elimine los comentarios para que la salida sea más fácil de procesar:
      > .. /red de informes:tamaño del marco=10 detallado=0
   3. Por último, redirija la salida a un archivo utilizando la función de tubería de Unix (">"):
      > .. /report network:tamaño frame=10 verbose=0 > net.txt
   4. Imprima el contenido del archivo en el terminal para su verificación:
      > gato net.txt
      NOTA: Esto debería imprimir dos números. La segunda es la superficie cubierta por la red en el 10º cuadro. Para ejecutar la misma operación en todos los directorios "run", cambie el directorio:
      > cd..
2. Genere un informe en cada subdirectorio de simulación:
   > byn/scan.py '.. /report network:size frame=10 verbose=0 > net.txt' run????
   NOTA: De nuevo, scan.py ejecutará el comando citado en todos los directorios especificados por "run????". El comando es el último que se intentó en el paso 5.1. Esto generará un archivo "net.txt" en cada directorio (pruebe "ls run????").
3. Examina estos números:
   > byn/scan.py 'cat net.txt'????
   1. Agregue la opción "+" para concatenar el nombre del directorio y la salida del comando:
      > byn/scan.py + carrera 'cat net.txt'????
4. Reúna estos números en un archivo:
   > byn/scan.py + carrera 'cat net.txt'???? > results.txt
5. Limpie el archivo "results.txt" eliminando el texto repetido que no sea numérico. Abra "result.txt" en el editor de código y use "reemplazar texto" para eliminar todas las cadenas de "ejecución". Elimine solo tres letras y conserve los números; "run0000" debe convertirse en "0000".
   NOTA: Esto debería dejar un archivo con solo números organizados en tres columnas.
6. Genere un gráfico de contractilidad a partir de los datos de "result.txt". Utilice cualquier método para generar una gráfica utilizando la columna 1 para X y la columna 3 para Y. Etiquete el eje X como número de reticulantes/100. Etiquete el eje Y como superficie (micrómetro^2).
7. Almacene todas las simulaciones en un directorio separado:
   > mkdir save1
   > carrera de MV???? Guardar1

6. Método alternativo para hacer un gráfico

1. Agregue un comando de informe al final de "config.cym.tpl" en una nueva línea después del cierre "}" del comando de ejecución:
   Report network:Tamaño net.txt { detallado = 0 }
2. Generar archivos de configuración:
   > byn/preconfig runi/config.cym config.cym.tpl
3. Ejecute todas las simulaciones utilizando subprocesos paralelos:
   > byn/scan.py '.. Carrera /sim'???? njobs=4
   1. Ajuste el número de trabajos (njobs=4), en función de la capacidad del equipo. Supervise el uso de los recursos de la CPU, por ejemplo, mediante la aplicación Monitor de actividad en MacOS.
4. Recopilar los datos:
   > byn/scan.py + carrera 'cat net.txt'???? > results.txt
5. Haga un gráfico, igual que en los pasos 5.5 y 5.6.
6. Almacene todas las ejecuciones anteriores en un directorio separado:
   > mkdir save2
   > carrera de MV???? Guardar2

7. Gráfico mejorado utilizando muestreo aleatorio

NOTA: Aquí se muestrea una variable utilizando una función generadora del módulo "aleatorio" de Python.

1. En el editor de código, abra el archivo de configuración de la plantilla "config.cym.tpl", ubicado en el directorio base. Agregue dos líneas, justo antes del "nuevo reticulante":
   [[num = int(random.uniform(0,4000))]]
   %[[num]] xlinkers
   Cambie también el comando "new" para usar esta variable:
   Nuevo reticulante [[range(0,4000,100)]] → nuevo reticulante [[num]]
   NOTA: La primera línea crea una variable aleatoria "num". La segunda línea imprime el valor del parámetro. El carácter "%" es importante, ya que le indicará a Cytosim que se salte la línea. Pronto "xlinkers" servirá como una etiqueta reconocible, y debe aparecer solo una vez en cada archivo.
   1. Al final de "config.cym.tpl", asegúrese de que haya una instrucción de informe:
      Report network:Tamaño net.txt { detallado = 0 }
2. Generar archivos de configuración:
   > byn/preconfig runi/config.cym 42 config.cym.tpl
   NOTA: Esto debería generar 42 archivos. Este número se puede aumentar si la computadora es lo suficientemente rápida. Los valores generados aleatoriamente se pueden ver utilizando la herramienta Unix "grep" para buscar archivos:
   > se ejecutan los grep xlinkers???? /config.cym
3. Ejecute todas las simulaciones en paralelo:
   > byn/scan.py '.. Carrera /sim'???? njobs=4
   NOTA: Ajuste el número de trabajos a la capacidad del equipo. Para obtener los mejores resultados, la variable "njobs" debe establecerse igual al número de núcleos de la computadora.
4. Recopile los datos con un solo comando:
   > byn/scan.py + 'grep xlinkers config.cym; Carrera de net.txt gatos???? > results.txt
   NOTA: La opción "+" de scan.py concatenará toda la salida del comando en una sola línea. En este caso, el comando se compone en realidad de dos comandos separados por una semicolumna (";"). La recopilación de datos siempre se puede automatizar con un script de Python.
5. Limpia el archivo. Abra "result.txt" en el editor de código. Para asegurarse de que todos los datos correspondientes a una simulación estén contenidos en una línea, elimine todas las apariciones de la cadena "xlinkers" y elimine los caracteres "%" al principio de cada línea. Por último, guarde "result.txt", que debe estar perfectamente organizado en tres columnas de valores numéricos.
6. Haga un gráfico para representar los datos repitiendo el paso 5.6, pero etiquete el eje X como número de reticulantes
7. Guarde el conjunto de datos en un nuevo subdirectorio:
   >mkdir set1
   > carrera de MV???? conjunto1/.
   > mv results.txt set1/.
8. Calcule otro conjunto de datos repitiendo los pasos 7.2 a 7.6 y, a continuación, repita el paso 7.8, reemplazando "set1" por "set2" en los tres comandos.
9. Haz una parcela combinada.
   1. Concatene los dos archivos de datos:
      > conjunto de gatos?/results.txt > results.txt
      NOTA: El nuevo "result.txt" debe ser más grande.
   2. Traza los datos para hacer un gráfico combinado, como se describe en el paso 7.7.

8. Canalización totalmente automatizada

NOTA: En esta parte, todas las operaciones que requieren intervención manual se reemplazan por comandos. Una vez hecho esto, será posible escribir un único script que realice todos los pasos automáticamente. Este script se puede ejecutar en un equipo remoto, como una granja de servidores de proceso.

1. Utilice el comando "sed" de Unix para "limpiar" el archivo results.txt, reemplazando el paso 7.6.
   1. Elimine el "%" al principio de las líneas:
      > sed -e 's/%//g' results.txt > tmp.txt
   2. Eliminar "xlinkers":
      > sed -e 's/xlinkers//g' tmp.txt > results.txt
2. Escriba un script para llamar a todos los comandos sucesivamente en el orden correcto.
   1. Utiliza diferentes lenguajes: bash o Python.
   2. Cree un archivo "pipeline.bash" y copie todos los comandos necesarios para ejecutar la tubería.
   3. Ejecute el script:
      > bash pipeline.bash
3. Utilice un script de trazado automatizado.
   NOTA: Puede ser ventajoso eliminar toda intervención manual. Existen muchas herramientas para generar un gráfico PDF directamente a partir de un archivo de datos, por ejemplo, gnuplot (http://www.gnuplot.info), PyX (https://pyx-project.org) o Seplot (https://pypi.org/project/seplot/).

Resultados

En la sección 2, la compilación exitosa de Cytosim usando "make" debería producir sim, play e report en el subdirectorio "bin". La salida del paso 2.3 ("sim info") debe indicar, entre otras cosas, "Dimensión: 2". En la sección 3, el fichero de configuración debe ser similar a jove.cym, proporcionado como Fichero Complementario 1. En la sección 4, losmagos obtenidos en el paso 4.8 a partir de simulaciones deben ser similares al que se muestra en la Fi...

Discusión

El método descrito en este artículo se basa en tres programas Python pequeños e independientes, que se utilizaron de diversas maneras en todo el protocolo descrito. La primera preconfiguración de script es una herramienta versátil que puede reemplazar la necesidad de escribir scripts de Python personalizados²⁷. Se utiliza para generar múltiples archivos de configuración a partir de un solo archivo de plantilla, especificando qué parámetro se debe variar y cómo se debe variar. Para variar ...

Materiales

Lista de materiales utilizados en este artículo

Nombre	Empresa	Número de catálogo	Comentarios
de plantilla config.cym.tpl
computadora			MacOS, Windows 10 o Linux
configuración jove.cym
make_page.py			script de Python;
https://github.com/nedelec/make_page.py preconfiguración			Script de Python; https://github.com/nedelec/preconfig
scan.py			script de Python; https://github.com/nedelec/scan.py