Um fluxo de trabalho típico para simular sistemas de citoesqueleto

Resumo

Este protocolo demonstra como usar o Cytosim, uma simulação de citoesqueleto Open Source, para investigar o comportamento de uma rede de filamentos conectados por motores moleculares e reticuladores passivos. Um fluxo de trabalho genérico com instruções passo a passo é seguido para variar o número de reticuladores e traçar a contratilidade da rede resultante.

Resumo

Muitos sistemas do citoesqueleto são agora suficientemente conhecidos para permitir sua modelagem quantitativa precisa. Os microtúbulos e os filamentos de actina são bem caracterizados, e as proteínas associadas são frequentemente conhecidas, bem como sua abundância e as interações entre esses elementos. Assim, simulações computacionais podem ser usadas para investigar o comportamento coletivo do sistema com precisão, de forma complementar aos experimentos. O Cytosim é um conjunto de simulação de citoesqueleto de código aberto projetado para lidar com grandes sistemas de filamentos flexíveis com proteínas associadas, como motores moleculares. Também oferece a possibilidade de simular reticuladores passivos, reticuladores difusíveis, nucleadores, cortadores e versões discretas dos motores que pisam apenas em locais de treliça desocupados em um filamento. Outros objetos complementam os filamentos, oferecendo geometria esférica ou mais complicada que pode ser usada para representar cromossomos, núcleo ou vesículas na célula.

O Cytosim oferece ferramentas simples de linha de comando para executar uma simulação e exibir seus resultados, que são versáteis e não requerem habilidades de programação. Neste fluxo de trabalho, são dadas instruções passo a passo para i) instalar o ambiente necessário em um novo computador, ii) configurar o Cytosim para simular a contração de uma rede de actomiosina 2D e iii) produzir uma representação visual do sistema. Em seguida, o sistema é testado variando sistematicamente um parâmetro-chave: o número de reticuladores. Por fim, a representação visual do sistema é complementada pela quantificação numérica da contratilidade para visualizar, em um gráfico, como a contratilidade depende da composição do sistema. No geral, essas diferentes etapas constituem um fluxo de trabalho típico que pode ser aplicado com poucas modificações para resolver muitos outros problemas no campo do citoesqueleto.

Introdução

O citoesqueleto consiste em filamentos dentro da célula e moléculas associadas, como motores moleculares, que muitas vezes constituem uma malha dinâmica com propriedades mecânicas notáveis. O citoesqueleto existe em várias configurações em diferentes tipos de células em quase todas as formas de vida. Seu correto funcionamento é essencial para processos celulares fundamentais, como divisão, motilidade e polarização. Também governa as interações mecânicas célula a célula, influenciando assim a morfogênese de tecidos e organismos. O citoesqueleto está subjacente a várias funções e se manifesta em muitos processos biológicos. Por exemplo, a contração dos músculos está ligada ao golpe de força dos motores moleculares da miosina nos filamentos de actina. Outro exemplo é a manutenção dos neurônios, que depende dos movimentos dos motores da cinesina ao longo dos microtúbulos localizados dentro dos axônios desses neurônios. Actina e microtúbulos são dois tipos proeminentes de filamentos do citoesqueleto e, sem eles, a vida como a conhecemos seria impossível.

O citoesqueleto é essencialmente um sistema biomecânico, que não pode ser reduzido apenas à sua química. Os microtúbulos ou filamentos de actina são construídos a partir de milhares de monômeros e se estendem por vários micrômetros. As conformações desses filamentos no espaço e as forças que eles podem transmitir à membrana plasmática, ao núcleo ou a outras organelas são aspectos-chave de seu papel na célula. Por exemplo, uma rede de filamentos de actina e motores de miosina, chamada córtex de actomiosina¹, gera forças para sustentar a motilidade celular e as mudanças morfológicas nas células animais. Um arranjo muito diferente é visto nas células vegetais, onde os microtúbulos corticais direcionam a deposição de fibrilas de celulose, controlando assim a arquitetura da parede celular, que determina como essas células crescerão no futuro².

Embora a mecânica claramente desempenhe um papel substancial nas operações do citoesqueleto, a química é igualmente importante. Os filamentos crescem por meio de um processo de automontagem pelo qual os monômeros encontram seu local de encaixe na ponta do filamento após a difusão pelo citoplasma³. Na escala molecular, a montagem e desmontagem na ponta dos filamentos são, portanto, determinadas por afinidades moleculares⁴. Da mesma forma, as proteínas do citoesqueleto se difundem e as taxas de ligação e desligação determinam sua afinidade pelos filamentos que encontram. No caso dos motores moleculares, os ciclos de reações químicas envolvendo hidrólise de ATP estão ligados a movimentos ao longo dos filamentos e, possivelmente, a forças que os acompanham⁵. Notavelmente, o citoesqueleto oferece muitos desafios incomuns e uma grande variedade de processos envolvendo componentes semelhantes. É um rico playground na interface entre biologia, química e física.

Os sistemas do citoesqueleto são passíveis de modelagem matemática. De fato, graças a excelentes pesquisas feitas nas últimas décadas, os principais constituintes moleculares provavelmente já estão identificados, conforme ilustrado com a endocitose⁶. Em organismos modelo, como leveduras, as propriedades desses elementos são conhecidas, bem como a composição do sistema para alguns de seus processos. Por exemplo, a estrutura e as propriedades do material dos microtúbulos⁷, bem como seu número e comprimentos médios em vários estágios do fuso mitótico, foram descritos⁸. O número de cinesinas que conectam os microtúbulos em uma estrutura mecânica coerente é frequentemente conhecido⁹. As velocidades de muitos motores foram medidas in vitro¹⁰. Além disso, os experimentalistas podem observar e quantificar esses sistemas in vivo sob condições de tipo selvagem ou mutantes. A combinação da teoria com experimentos in vivo e in vitro permite que os pesquisadores testem se o conhecimento atual sobre um sistema citoesquelético é suficiente para explicar seu comportamento observado. O uso de ferramentas matemáticas e computacionais também nos permite fazer inferências de como os componentes funcionam coletivamente com base em suposições derivadas de observações em escala molecular, geralmente em situações simplificadas (por exemplo, experimentos de molécula única).

O papel da teoria pode ser ilustrado usando um exemplo prático: o batimento dos cílios. Esse batimento é devido ao movimento dos motores de dineína ao longo dos microtúbulos nos cílios. Pode-se perguntar o que determina a velocidade do motor de dineína neste sistema. Uma resposta possível é que a velocidade máxima é limitada pela exigência de manter um certo padrão de batimento. Isso seria compreensível se o espancamento estivesse sob seleção natural. Nesse caso, se os motores se movessem mais rápido, o processo perderia as qualidades desejadas - os cílios não bateriam com tanta eficiência ou até mesmo falhariam completamente. Embora isso seja possível, uma segunda alternativa é que algum fator intrínseco possa limitar a velocidade da dineína.

Por exemplo, a célula pode não ter ATP suficiente para tornar a dineína mais rápida, ou os movimentos proteicos necessários para a atividade da dineína simplesmente não puderam ser acelerados. Nesse caso, se os motores pudessem ser feitos mais rápidos, apesar dos limites físicos, a batida seria melhorada. Uma terceira possibilidade, é claro, é que alterar a velocidade não afeta significativamente o processo, o que pode ser vantajoso para o organismo, fornecendo alguma "robustez" contra fatores incontroláveis. Entre essas três possibilidades, pode-se identificar a correta calculando o padrão de batimento a partir das propriedades da dineína. De fato, um modelo matemático adequado deve prever como o padrão de batimento é afetado pela variação da velocidade da dineína e não está sujeito aos limites que existem no mundo físico. Naturalmente, a validade do modelo deve ser verificada, mas mesmo modelos "incorretos" podem gerar ideias interessantes.

O modelo pode assumir a forma de uma estrutura analítica ou ser uma simulação numérica do sistema. De qualquer forma, a lacuna entre a escala molecular e a escala funcional continua sendo um obstáculo, e o desenvolvimento desses modelos não é uma tarefa simples, uma vez que vários processos mecânicos e químicos precisam ser integrados às equações que descrevem o sistema biológico. A teoria vem em várias formas, oferecendo diferentes compensações entre simplicidade e realismo. Aumentar o grau de detalhes em um modelo nem sempre é vantajoso, pois pode limitar nossa capacidade de resolver as equações ou, em outras palavras, derivar as previsões da teoria. A mesma compensação existe para simulações. Os modeladores terão que selecionar os ingredientes do sistema a serem considerados, ignorando certos aspectos. Essas decisões-chave dependerão fortemente do objetivo do estudo. Hoje em dia, as melhorias extraordinárias no hardware do computador tornam possível simular muitos sistemas do citoesqueleto com detalhes suficientes em um tempo suficiente para analisar seu comportamento. Isso geralmente gera ideias inesperadas e novas direções na pesquisa. Por exemplo, simulações semelhantes às que serão usadas neste protocolo levaram a um cálculo de back-of-the-envelope que pode prever a contratilidade de uma rede com base em sua composição¹¹.

Os métodos numéricos são onipresentes na engenharia e nas ciências físicas, e seu uso na biologia está crescendo. Hoje, praticamente todo o nosso whatchamacallit tecnológico (relógios, telefones, carros e computadores) foi concebido pela primeira vez em um computador, e existem softwares poderosos para fazer isso. Dado um sistema citoesquelético bem caracterizado e assumindo que um nível apropriado de descrição foi determinado, vários problemas ainda devem ser resolvidos antes que ele possa ser simulado. Para os problemas mais simples, a rota de ação mais apropriada pode ser escrever uma simulação "codificando do zero", ou seja, começando com uma linguagem de programação genérica ou uma plataforma matemática como o MATLAB. Isso tem a vantagem de que o autor do código terá um conhecimento íntimo do que foi implementado e saberá exatamente como o software funciona. Esse caminho, no entanto, não é isento de riscos, e não é incomum testemunhar estudantes de doutorado gastando a maior parte de seu tempo de trabalho escrevendo código em vez de abordar questões científicas.

A alternativa é usar software concebido por outros, mas isso também não é isento de riscos; Qualquer código-fonte grande tende a adquirir espontaneamente as características de uma caixa preta impenetrável, apesar dos esforços mais admiráveis de seus autores para evitá-lo. Usar caixas pretas certamente não é o sonho de um cientista. Um código-fonte grande também pode se tornar um passivo, e pode ser mais rápido começar do zero do que modificar uma base de código existente para fazê-la fazer algo diferente. Para mitigar esse problema, pode-se sempre convidar os autores do software para ajudar, mas isso pode não ser suficiente. Frequentemente, há uma diferença de cultura científica entre os autores do software e as pessoas que gostariam de usá-lo, o que significa que muitas suposições implícitas precisam ser esclarecidas. Ao tornar o código Open Source, espera-se que mais pessoas se envolvam no desenvolvimento do software e mantenham sua documentação, melhorando assim sua qualidade. Todas essas são questões importantes que devem ser devidamente consideradas antes de qualquer investimento ser feito. No entanto, a única maneira de progredir a longo prazo é promover soluções de software sólidas, usadas e mantidas por uma ampla comunidade com interesses científicos comuns.

Embora este protocolo use o Cytosim, existem outras ferramentas de código aberto que podem simular o mesmo sistema, por exemplo, AFINES¹², MEDYAN¹³, CyLaKS¹⁴, aLENS¹⁵ e AKYT¹⁶, para citar alguns. Infelizmente, comparar esses projetos está além do escopo do artigo. Aqui, instruções passo a passo são fornecidas para simular uma rede de actomiosina 2D contrátil. Este sistema é simples e faz uso das capacidades mais bem estabelecidas do Cytosim. O Cytosim é construído em torno de um mecanismo central multiplataforma que pode executar simulações em 2D ou 3D. Possui uma base de código modular, tornando-o facilmente personalizável para executar tarefas específicas. O citosim é igualmente estável e eficiente em 3D e foi usado com sucesso no passado para investigar diversos problemas envolvendo microtúbulos e filamentos de actina: a associação de dois ásteres de microtúbulos¹⁷, o movimento dos núcleos nas células^18,19, endocitose⁶, citocinese²⁰, a formação do fuso mitótico²¹, os movimentos do fuso mitótico²², A captura dos cromossomos²³, a contração das redes de actomiosina^11,24 e a mecânica do anel de microtúbulos nas plaquetas sanguíneas²⁵ e as capacidades desenvolvidas para esses projetos foram mantidas no código. O fluxo de trabalho descrito aqui pode ser adaptado a muitos outros problemas. Ele faz uso da linha de comando Unix, que pode não ser familiar para alguns leitores. Usar a linha de comando é, no entanto, a maneira mais portátil e conveniente de automatizar o processo de execução de simulações. As interfaces gráficas de usuário integradas visam oferecer acesso fácil e intuitivo a um software, mas isso geralmente ocorre às custas da generalidade. O objetivo deste artigo é ilustrar uma abordagem que pode ser facilmente modificada ou adaptada a outros problemas. São fornecidas notas para explicar o significado dos comandos.

Para simular uma rede de actomiosina, os filamentos são modelados como linhas orientadas e representados por vértices distribuídos ao longo de seu comprimento (Figura 1). Este é um nível intermediário de descrição, comum na física de polímeros, que ignora a natureza 3D genuína dos filamentos, mas permite que a curvatura seja calculada. Os filamentos podem crescer e encolher em suas extremidades, seguindo diferentes modelos que cobrem a fenomenologia da actina e dos microtúbulos. Nas células, os filamentos são organizados principalmente por meio de interações que restringem seu movimento, por exemplo, a ligação a outros filamentos ou simplesmente o confinamento dentro da célula. No Cytosim, todas essas interações são linearizadas e combinadas em uma grande matriz²⁶. As equações que descrevem o movimento de todos os vértices do filamento são derivadas dessa matriz, assumindo um meio viscoso e termos flutuantes aleatórios que representam o movimento browniano. Essas equações são resolvidas numericamente para obter o movimento dos filamentos juntamente com todas as forças que atuam sobre eles de maneira autoconsistente e eficiente²⁶. Sobreposto a este motor mecânico, existe um motor estocástico que simula eventos discretos, como as fixações e desprendimentos de motores moleculares ou a dinâmica de montagem de filamentos. Em resumo, o Cytosim primeiro usa dinâmica simulada para calcular a mecânica de uma rede de filamentos, conectados de qualquer maneira arbitrária e, segundo, métodos estocásticos para simular a ligação, desligação e difusão de proteínas que conectam ou afetam os filamentos.

O fluxo de trabalho ilustrado aqui foi frequentemente seguido para explorar inicialmente um sistema usando o Cytosim. A etapa crítica para muitos usuários em potencial provavelmente será a instalação dos componentes de software. Distribuir o software como código-fonte cumpre os imperativos da Ciência Aberta, mas é propenso a erros, pois os desenvolvedores do software têm acesso apenas a um conjunto limitado de arquitetura para testar o programa. A compilação pode falhar à medida que os sistemas operacionais diferem. As instruções fornecidas aqui provavelmente se tornarão obsoletas à medida que os sistemas de computador e os códigos-fonte evoluem. Assim, é essencial verificar periodicamente as instruções mais recentes online. Em caso de problemas, é altamente recomendável que os usuários relatem postando no canal de feedback relevante (atualmente a página inicial do Cytosim no Gitlab) para ajudar a corrigir o problema.

Protocolo

NOTA: O protocolo consiste nestas etapas: preparação da plataforma para Windows 10, MacOS e Linux; a instalação do Cytosim; configuração da simulação e do ensaio e da visualização gráfica; várias execuções, variando um parâmetro: o número de reticuladores na rede; gerar um gráfico para ver como a contratilidade é afetada pelo número de reticuladores; corridas paralelas; e amostragem aleatória. Todo o texto após um ">" são comandos que devem ser inseridos literalmente na janela do terminal. O ">" representa o prompt do terminal e não deve ser incluído, mas todos os outros caracteres são importantes.

1. Preparação da plataforma

NOTA: Dependendo do sistema operacional (MacOS, Windows 10 ou Linux), siga a etapa 1.1, a etapa 1.2 ou a etapa 1.3.

1. Preparação (MacOS)
   1. Instale as Ferramentas de Linha de Comando do Xcode abrindo o Terminal (em Aplicativos/Utilitários) e digite:
      Gt; xcode-select --install
   2. Para visualizar ou editar o código do Cytosim, instale o Xcode na Apple App Store (https://apps.apple.com/us/app/Xcode/id497799835?mt=12).
      NOTA: O editor integrado do Xcode é perfeitamente adequado. Outros editores orientados a código também funcionariam, por exemplo, TextMate. Para usar o TextMate, baixe e siga as instruções do https://macromates.com.
2. Preparação (Windows)
   NOTA: Para Windows 10 ou superior, o Cytosim pode ser executado usando o "Windows Subsystem for Linux" (WSL), conforme descrito abaixo. Uma alternativa para uma versão mais antiga é o Cygwin, mas as instruções não são fornecidas aqui.
   1. Atualize o sistema operacional do computador para atender aos requisitos do WSL 2: Windows 10 versão 1903 ou superior, com Build 18362 ou superior, para sistemas x64 e versão 2004 ou superior, com Build 19041 ou superior, para sistemas ARM64. Para atualizações de versão subsequentes, verifique https://docs.microsoft.com/en-us/windows/release-health/release-information.
   2. Digite Ativar e desativar recursos do Windows na caixa de pesquisa da barra de tarefas. Habilite manualmente () Plataforma de Máquina Virtual e () Subsistema Windows para Linux. Clique em OK e reinicie o Windows.
   3. Vá para a Windows Microsoft Store e procure por Ubuntu. Baixe e instale a versão atual (Ubuntu 20.04 LTS a partir de 03.2022)
   4. Clique em Iniciar para iniciar o Terminal Ubuntu. Se for solicitado a baixar o kernel Linux WSL2 mais recente, siga as instruções que serão fornecidas. Instale a atualização e reinicie o Ubuntu.
   5. Siga as instruções do terminal para Digite o novo nome de usuário do UNIX e defina uma senha. Depois que a conta de usuário estiver configurada, inicie o Ubuntu na caixa de pesquisa da barra de tarefas do Windows. Abra o diretório inicial (também conhecido como "."), na janela de comando:
      > explorer.exe .
   6. Instale um servidor X-Window compatível com WSL, por exemplo, Xming: https://sourceforge.net/projects/xming/
   7. Inicie o servidor X-Window, Xming clicando duas vezes no ícone Xming; selecione Várias janelas. A seguir, abra o terminal do Ubuntu e siga a etapa 1.3 (Linux).
3. Preparação (Linux)
   NOTA: Estas instruções são apropriadas para distribuições Linux que usam o gerenciador de pacotes APT. Esses comandos devem ser modificados para distribuições como o Red Hat Linux que usam um gerenciador de pacotes diferente. Nesse caso, siga as instruções da distribuição Linux para instalar os mesmos pacotes.
   1. Atualize o sistema Linux:
      > atualização do sudo apt-get
      > sudo apt-get upgrade
   2. Instale um compilador C++ e o make do GNU (https://www.gnu.org/software/make):
      > sudo apt-get install build-essential
   3. Instale as bibliotecas BLAS/LAPACK (http://www.netlib.org/lapack):
      > sudo apt-get install libblas-dev liblapack-dev
   4. Instale a biblioteca do desenvolvedor OpenGL e os arquivos de cabeçalho (https://www.mesa3d.org):
      > sudo apt-get install mesa-common-dev
   5. Instale a biblioteca GLEW (http://glew.sourceforge.net):
      > sudo apt-get install libglew-dev
   6. Instale a biblioteca freeGLUT (http://freeglut.sourceforge.net):
      > sudo apt-get instalar freeglut3-dev
   7. Instale o sistema de controle de versão GIT (https://git-scm.com):
      > sudo apt-get install git
   8. Instale os programas de teste X11 (por exemplo, xeyes, xclock, xcalc):
      > sudo apt-get install x11-apps
   9. Ajuste a variável de ambiente DISPLAY:
      > export DISPLAY=:0
      1. Tente abrir uma janela X11:
         > xeyes
      2. Se isso funcionar, vá para a etapa 2. Se o erro não for ao abrir a tela, tente um valor DISPLAY diferente.
      3. Localize o endereço IP do computador WSL2:
         > cat /etc/resolv.conf
      4. Se o número IP aparecer, por exemplo, "servidor de nomes 10.16.0.7", use este número IP em vez de X.X.X.X abaixo:
         > exibição de exportação = XXX: 0
         > xeyes
      5. Se isso funcionar, vá para a etapa 2. Se "play" falhar em "abrir a tela", tente executá-lo de dentro de uma janela "xterm":
         > sudo apt instalar xterm
         > xterm -display :0
      6. Na nova janela que se abre, digite:
         > xeyes

2. Instalação do Cytosim

NOTA: Essas etapas são semelhantes para qualquer sistema operacional: MacOS, WSL e Linux. Na seção a seguir, os comandos serão emitidos no terminal e o "diretório de trabalho atual" deve ser definido como o diretório no qual a simulação foi compilada. Este diretório será referido como sendo o diretório base. Como alternativa, tudo pode ser feito em um diretório separado se os arquivos forem copiados conforme necessário. Se não estiver familiarizado com a linha de comando, considere seguir um tutorial, por exemplo, https://www.learnenough.com/command-line-tutorial ou https://learnpythonthehardway.org/book/appendixa.html.

1. Baixe o código-fonte do Cytosim:
   > clone git https://gitlab.com/f-nedelec/cytosim.git citosim
   NOTA: Não é necessária uma conta Gitlab para baixar o código. Isso deve criar um novo subdiretório "cytosim" no diretório atual.
2. Compilar:
   > cd citosim
   > fazer
   1. Verifique se três arquivos são criados em um subdiretório "bin" executando:
      > ls bin
   2. Se a etapa 2.2.1 falhar, tente este método alternativo para compilar instalando o cmake (https://cmake.org):
      > mkdir b
      > tempo de recarga
      > cmake ..
      > fazer
      > cd ..
3. Verifique os executáveis:
   > informações do bin/sim
   > informações de lixeira/reprodução
   1. Verifique se ambos os executáveis foram compilados para executar simulações 2D. Procure a seguinte saída das consultas "info" acima:
      Dimensão: 2 Periódico: 1 Precisão: 8 bytes
   2. Se este não for o caso, e só então, modifique o arquivo "src/math/dim.h" (abra, edite para alterar o DIM para 2, salve) e recompile o Cytosim:
      > limpar
      > fazer
4. Execução de teste
   1. Copie três executáveis:
      > cp bin/sim sim
      > cp bin/play play
      > relatório de compartimento/relatório de cp
   2. Crie um novo diretório:
      > mkdir corra
   3. Copie e renomeie o arquivo de configuração padrão:
      > cp cym/fiber.cym run/config.cym
   4. Inicie a simulação:
      > corrida de cd
      > .. /sim
   5. Visualize os resultados da simulação:
      > .. /brincar
      1. Pressione a barra de espaço para animar. Pressione h para obter ajuda sobre atalhos de teclado.
      2. Para sair do programa, no MacOS, tente -Q ou CTRL-Q ou selecione Sair no menu. Como último recurso, digite CTRL-C na janela do terminal a partir da qual "play" foi iniciado.
   6. Executar no modo ao vivo:
      > .. /jogar ao vivo

3. Configuração da simulação

1. Instale um editor de texto orientado a código (por exemplo, TextMate, SublimeText) se ainda não estiver disponível.
   Abra o editor e abra o arquivo "config.cym", localizado no diretório "run" criado na etapa 2.4.2. Familiarize-se com as diferentes seções do arquivo de configuração, que é uma cópia de "fiber.cym" (Arquivo Suplementar 1).
   NOTA: O Cytosim geralmente lê apenas um arquivo de configuração que termina com ".cym". Todas as modificações serão feitas aqui em "config.cym". Consulte a Tabela Suplementar S1 para obter uma lista de parâmetros.
2. Modifique a simulação fazendo as seguintes alterações em "config.cym":
   raio = 5 → raio = 3
   Novo 1 filamento → novo 100 filamento
3. Salve o arquivo sem alterar seu nome ou localização (substitua "config.cym"). Alterne para a janela Terminal e verifique se a simulação foi modificada conforme o esperado com:
   > .. /jogar ao vivo
   NOTA: O raio do círculo é especificado em micrômetros (μm), assim como todas as distâncias no Cytosim. O citosim segue um sistema de unidades adaptadas à escala da célula, derivadas de micrômetros, piconewtons e segundos.
4. No parágrafo "definir filamento de fibra", faça as seguintes alterações:
   rigidez = 20 → rigidez = 0,1
   segmentação = 0,5 → segmentação = 0,2
   confine=inside, 200, cell → confine= inside, 10, cell
   No parágrafo "novo filamento", altere:
   comprimento = 12 → comprimento = 2
   Reduza o tempo a ser simulado alterando:
   executar sistema 5000 → executar sistema 1000
   NOTA: Isso ajusta as propriedades do filamento. O parágrafo "set" define propriedades persistentes dos filamentos, enquanto os parâmetros em "new" são geralmente condições iniciais. A rigidez à flexão é especificada em pN μm². A segmentação é a distância aproximada entre os vértices que descrevem os filamentos em micrômetros (μm). Ele precisa ser reduzido se os filamentos forem mais flexíveis. A última mudança reduz a rigidez (pN/μm) do potencial de confinamento associado às bordas da "célula". O comprimento declarado no "novo" parágrafo (2 μm) é o comprimento inicial dos filamentos, e como neste modelo os filamentos não são dinâmicos, seus comprimentos não mudarão. Recomenda-se assinar o arquivo de configuração, editando a primeira linha:
   % Seu nome, data, local
   1. Verifique a validade do arquivo de configuração (repita a etapa 3.3).
5. Crie conectores passivos.
   1. Adicione um novo parágrafo a "config.cym", antes das linhas com o comando "new" e "run", para definir uma atividade molecular com afinidade com os filamentos:
      definir encadernador de mão {
      binding_rate = 10
      binding_range = 0,01
      unbinding_rate = 0,2
      }
   2. Para definir entidades bifuncionais, adicione outro parágrafo logo abaixo:
      conjunto de reticulador de casal {
      hand1 = fichário
      hand2 = fichário
      rigidez = 100
      difusão = 10
      }
   3. Adicione um comando "novo" após os parágrafos anteriores e antes do comando "executar":
      novo reticulador 1000
      NOTA: No Cytosim, as taxas são especificadas em unidades de s⁻¹ e a faixa em micrômetros (μm). A rigidez é especificada em unidades de piconewtons por micrômetro (pN/μm) e o coeficiente de difusão em micrômetros ao quadrado por segundo (μm²/s). A ordem dos comandos no arquivo de configuração é importante, e esses parágrafos devem aparecer antes de qualquer comando "executar", caso contrário, eles não serão eficazes. Para saber mais sobre os objetos do Cytosim, siga o tutorial em "tuto_introduction.md", que está em uma subpasta "doc" do diretório base: doc/tutorials/.
6. Crie motores bifuncionais.
   1. Adicione um novo parágrafo a "config.cym", antes das linhas com o comando "new" e "run":
      ajuste o motor da mão {
      binding_rate = 10
      binding_range = 0,01
      unbinding_rate = 0,2
      atividade = mover
      unloaded_speed = 1
      stall_force = 3
      }
   2. Adicione outro parágrafo, após o anterior:
      conjunto de casal complexo {
      hand1 = motor
      hand2 = motor
      rigidez = 100
      difusão = 10
      ​}
   3. Adicione um comando "novo" após os parágrafos anteriores e antes do comando "executar":
      Novo Complexo 200
      NOTA: A "atividade = movimento" especifica um motor que se move continuamente sobre o filamento. O motor obedece a uma curva linear de força-velocidade (Figura 1) caracterizada pela velocidade de descarga (μm/s) e pela força de estol (piconewton). A cada passo de tempo, τ, ele se move por uma distância, v × τ. Usar "atividade = nenhuma" especificaria uma molécula que não se move e, como essa é a atividade padrão, pode-se simplesmente omitir "atividade" completamente. Outras atividades são possíveis, por exemplo, "atividade = caminhada" especificaria um motor com passos discretos ao longo do filamento. O "unloaded_speed" é positivo para um motor direcionado de ponta positiva. Especificar um valor negativo faria com que o motor se movesse em direção às extremidades negativas. Isso é explicado com mais detalhes no primeiro tutorial do Cytosim (veja o link na etapa 3.5.2).
7. Salve o arquivo.
   Confira a simulação:
   > .. /jogar ao vivo
   Execute a simulação:
   > .. /sim
   Visualize os resultados:
   > .. /brincar
   Copie o arquivo de configuração final para o diretório base:
   > cp config.cym .. /config.cym
   NOTA: Seu arquivo final deve ser semelhante ao Arquivo Suplementar 2 ("jove.cym"). Observe quanto tempo foi necessário para calcular essa simulação. Nas seções seguintes, esse tempo será multiplicado pelo número de simulações feitas para gerar um gráfico onde um parâmetro é variado.

4. Varredura de parâmetro

NOTA: Nesta seção, o número de reticuladores na rede é sistematicamente variado.

1. Importe scripts Python.
   1. Crie um subdiretório "byn", dentro do diretório base:
      > mkdir tchau
   2. Copie três scripts da distribuição padrão do Cytosim:
      > cp python/run/preconfig.py byn/preconfig
      > cp python/look/scan.py byn/.
      > cp python/look/make_page.py byn/.
      NOTA: Por segurança, cópias desses arquivos são fornecidas como Arquivo Suplementar 3, Arquivo Suplementar 4 e Arquivo Suplementar 5 com este artigo.
2. Torne os arquivos executáveis:
   > chmod +x byn/preconfig
   > chmod +x byn/scan.py
   > chmod +x byn/make_page.py
   1. Verifique se os scripts são executados corretamente:
      > ajuda byn/preconfig
      > byn/scan.py ajuda
      > byn/make_page.py ajuda
      NOTA: Isso deve imprimir uma descrição de como cada comando pode ser usado. É possível modificar a variável PATH para chamar os scripts de forma mais simples; consulte https://en.wikipedia.org/wiki/PATH_(variável).
   2. Solucionando problemas
      1. Se o erro for "comando não encontrado", verifique o caminho especificado, que deve corresponder à localização do arquivo. Se houver outro tipo de erro porque o sistema operacional não fornece python2, edite os três arquivos .py e modifique o shebang, que é a primeira linha de cada arquivo (basta adicionar "3"):
         #!/usr/bin/env python → #!/usr/bin/env python3
3. Copie o arquivo de configuração para torná-lo um "modelo" (Arquivo Suplementar 6):
   > cp config.cym config.cym.tpl
4. Edite o arquivo de configuração do modelo. No editor de código, abra o arquivo "config.cym.tpl", localizado no diretório base. Altere uma linha para introduzir um elemento de texto variável:
   novo reticulador 1000 → novo reticulador [[range(0,4000,100)]]
   NOTA: O Preconfig reconhecerá o código contido nos colchetes duplos e o substituirá por um valor obtido executando este código em Python. Em Python, "range(X,Y,S)" especifica números inteiros de X a Y, com um incremento de S; neste caso [0, 100, 200, 300, ... 4000]. A intenção é alterar o número de reticuladores adicionados à simulação.
5. Gere arquivos de configuração a partir do modelo:
   > byn/preconfig runi/config.cym config.cym.tpl
   NOTA: Isso deve criar 40 arquivos, um para cada valor especificado em "range(0,4000,100)". Os nomes dos arquivos a serem gerados pelo Preconfig são especificados por "runi/config.cym". Com este código específico, o Preconfig irá gerar "run0000/config.cym", "run0001/config.cym", etc. Na verdade, ele fará com que os diretórios "run0000", "run0001", etc., e crie um arquivo "config.cym" em cada um deles. Verifique a ajuda do Preconfig para obter mais detalhes (execute "byn/preconfig help"). Em caso de erro, verifique se o comando foi digitado exatamente. Cada personagem conta.
6. Execute todas as simulações sequencialmente:
   > byn/scan.py '.. /sim' executar????
   NOTA: O programa "scan.py" executará o comando citado na lista de diretórios fornecida. Nesse caso, essa lista de diretórios é especificada por "run????". O ponto de interrogação é um curinga que corresponde a qualquer caractere. Portanto, "run????" corresponde a qualquer nome que comece com "run" e seja seguido por exatamente quatro caracteres. Alternativamente, pode-se usar "run*" para gerar a mesma lista, já que "*" corresponde a qualquer string.
   1. Em caso de problemas, execute este comando a partir de uma nova janela de terminal para executar "sim" sequencialmente em todos os diretórios criados no passo 4.5. Aguarde aproximadamente 30 minutos para que o processo seja concluído, mas isso depende muito das capacidades do computador. Reduza a quantidade de cálculo solicitada editando "config.cym":
      executar o sistema 1000 → executar o sistema 500
7. Visualize algumas simulações:
   > ./play run0010
   > ./play run0020
8. Gere imagens para todas as simulações:
   > byn/scan.py '.. /play image size=256 frame=10' run????
9. Gere uma página de resumo HTML:
   > byn/make_page.py tile=5 executar????
   1. Abra "page.html" em um navegador da web.

5. Fazendo um gráfico

NOTA: Nesta seção, um gráfico é feito a partir dos resultados da varredura de parâmetro.

1. Verifique o executável do relatório :
   > corrida de cd
   > .. /relatório rede:tamanho
   NOTA: Para cada quadro na trajetória, isso imprimirá alguns comentários e dois números, correspondentes a "polímero" e "superfície". Somente a "superfície" da rede (última coluna) será usada.
   1. Restrinja especificamente as informações a um quadro usando:
      > .. /report network:tamanho quadro=10
   2. Remova os comentários para facilitar o processamento da saída:
      > .. /report network:tamanho quadro=10 verbose=0
   3. Finalmente, redirecione a saída para um arquivo usando o recurso de pipe Unix (">"):
      > .. /report network:size frame=10 verbose=0 > net.txt
   4. Imprima o conteúdo do arquivo no terminal para verificação:
      > gato net.txt
      NOTA: Isso deve imprimir dois números. O segundo é a superfície coberta pela rede no 10º quadro. Para executar a mesma operação em todos os diretórios "run", altere o diretório:
      > cd ..
2. Gere um relatório em cada subdiretório de simulação:
   > byn/scan.py '.. /report network:size frame=10 verbose=0 > net.txt' run????
   NOTA: Novamente, scan.py executará o comando entre aspas em todos os diretórios especificados por "run????". O comando é o último tentado na etapa 5.1. Isso gerará um arquivo "net.txt" em cada diretório (tente "ls run????").
3. Examine estes números:
   > byn / scan.py corrida 'cat net.txt'????
   1. Adicione a opção "+" para concatenar o nome do diretório e a saída do comando:
      > byn/scan.py + 'cat net.txt'????
4. Colete estes números em um arquivo:
   > byn/scan.py + 'cat net.txt'???? > results.txt
5. Limpe o arquivo "results.txt" excluindo o texto repetido que não é numérico. Abra "result.txt" no editor de código e use o "texto de substituição" para remover todas as strings de "execução". Remova apenas três letras e mantenha os números; "run0000" deve se tornar "0000".
   NOTA: Isso deve deixar um arquivo com apenas números organizados em três colunas.
6. Gere um gráfico de contratilidade a partir dos dados em "result.txt". Use qualquer método para gerar um gráfico usando a coluna 1 para X e a coluna 3 para Y. Rotule o eixo X como número de reticuladores/100. Rotule o eixo Y como superfície (micrômetro^2).
7. Armazene todas as simulações em um diretório separado:
   > mkdir salvar1
   > corrida MV???? Salvar 1

6. Método alternativo para fazer um gráfico

1. Adicione um comando report no final de "config.cym.tpl" em uma nova linha após o fechamento "}" do comando run:
   rede de relatório: tamanho net.txt { verbose = 0 }
2. Gerar arquivos de configuração:
   > byn/preconfig runi/config.cym config.cym.tpl
3. Execute todas as simulações usando threads paralelos:
   > byn/scan.py '.. /sim' executar???? njobs=4
   1. Ajuste o número de trabalhos (njobs=4), dependendo da capacidade do computador. Monitore o uso dos recursos da CPU, por exemplo, pelo aplicativo Monitor de Atividade no MacOS.
4. Colete os dados:
   > byn/scan.py + 'cat net.txt'???? > results.txt
5. Faça um gráfico, igual aos passos 5.5 e 5.6.
6. Armazene todas as execuções anteriores em um diretório separado:
   > mkdir save2
   > corrida MV???? salvar 2

7. Gráfico aprimorado usando amostragem aleatória

NOTA: Uma variável é amostrada aqui usando uma função geradora do módulo "random" do Python.

1. No editor de código, abra o arquivo de configuração do modelo "config.cym.tpl", localizado no diretório base. Adicione duas linhas, logo antes do "novo reticulador":
   [[num = int(random.uniform(0,4000))]]
   %[[num]] xlinkers
   Altere também o comando "novo" para usar esta variável:
   novo reticulador [[range(0,4000,100)]] → novo reticulador [[num]]
   NOTA: A primeira linha cria uma variável aleatória "num". A segunda linha imprime o valor do parâmetro. O caractere "%" é importante, pois instruirá o Cytosim a pular a fila. Em breve, "xlinkers" servirá como uma tag reconhecível e deve aparecer apenas uma vez em cada arquivo.
   1. No final de "config.cym.tpl", certifique-se de que haja uma instrução de relatório:
      rede de relatório: tamanho net.txt { verbose = 0 }
2. Gerar arquivos de configuração:
   > byn/preconfig runi/config.cym 42 config.cym.tpl
   NOTA: Isso deve gerar 42 arquivos. Esse número pode ser aumentado se o computador for rápido o suficiente. Os valores gerados aleatoriamente podem ser vistos usando a ferramenta Unix "grep" para pesquisar arquivos:
   > grep xlinkers executados???? /config.cym
3. Execute todas as simulações em paralelo:
   > byn/scan.py '.. /sim' executar???? njobs=4
   NOTA: Ajuste o número de trabalhos de acordo com a capacidade do computador. Para obter os melhores resultados, a variável "njobs" deve ser definida como igual ao número de núcleos do computador.
4. Colete os dados usando um único comando:
   > byn/scan.py + 'grep xlinkers config.cym; Cat net.txt' Run???? > results.txt
   NOTA: A opção "+" do scan.py concatenará toda a saída do comando em uma única linha. Nesse caso, o comando é composto por dois comandos separados por uma semicoluna (";"). A coleta de dados sempre pode ser automatizada com um script Python.
5. Limpe o arquivo. Abra "result.txt" no editor de código. Para garantir que todos os dados correspondentes a uma simulação estejam contidos em uma linha, exclua todas as ocorrências da cadeia de caracteres "xlinkers" e remova os caracteres "%" no início de cada linha. Por fim, salve "result.txt", que deve ser organizado em três colunas de valores numéricos.
6. Faça um gráfico para plotar os dados repetindo a etapa 5.6, mas rotule o eixo X como número de reticuladores
7. Salve o conjunto de dados em um novo subdiretório:
   >mkdir set1
   > corrida MV???? set1/.
   > MV results.txt set1/.
8. Calcule outro conjunto de dados repetindo as etapas 7.2 a 7.6 e, em seguida, repita a etapa 7.8, substituindo "set1" por "set2" em todos os três comandos.
9. Faça um gráfico combinado.
   1. Concatene os dois arquivos de dados:
      > conjunto de gatos?/results.txt > results.txt
      NOTA: O novo "result.txt" deve ser maior.
   2. Plote os dados para fazer um gráfico combinado, conforme descrito na etapa 7.7.

8. Pipeline totalmente automatizado

NOTA: Nesta parte, todas as operações que requerem intervenção manual são substituídas por comandos. Quando isso for feito, será possível escrever um único script que executa todas as etapas automaticamente. Esse script pode ser executado em um computador remoto, como um farm de computação.

1. Use o comando "sed" do Unix para "limpar" o arquivo results.txt, substituindo a etapa 7.6.
   1. Remova o "%" no início das linhas:
      > sed -e 's/%//g' results.txt > tmp.txt
   2. Remova "xlinkers":
      > sed -e 's/xlinkers//g' tmp.txt > results.txt
2. Escreva um script para chamar todos os comandos sucessivamente na ordem correta.
   1. Use linguagens diferentes: bash ou Python.
   2. Crie um arquivo "pipeline.bash" e copie todos os comandos necessários para executar o pipeline.
   3. Execute o script:
      > bash pipeline.bash
3. Use um script de plotagem automatizado.
   NOTA: Pode ser vantajoso remover todas as intervenções manuais. Existem muitas ferramentas para gerar um gráfico PDF diretamente de um arquivo de dados, por exemplo, gnuplot (http://www.gnuplot.info), PyX (https://pyx-project.org) ou Seplot (https://pypi.org/project/seplot/).

Resultados

Na seção 2, a compilação bem-sucedida do Cytosim usando "make" deve produzir sim, play e report no subdiretório "bin". A saída da etapa 2.3 ("sim info") deve indicar "Dimensão: 2" entre outras coisas. Na seção 3, o arquivo de configuração deve ser semelhante ao jove.cym, fornecido como Arquivo Suplementar 1. Na seção 4, osrecursos obtidos na etapa 4.8 a partir de simulações devem ser semelhantes aos mostrados na Figura 2. A página de resumo ...

Discussão

O método descrito neste artigo se baseia em três programas Python pequenos e independentes, que foram usados de diversas maneiras em todo o protocolo descrito. A primeira preconfiguração de script é uma ferramenta versátil que pode substituir a necessidade de escrever scripts Python personalizados²⁷. Ele é usado para gerar vários arquivos de configuração a partir de um único arquivo de modelo, especificando qual parâmetro deve ser variado e como deve ser variado. Para variar vários parâme...

Materiais

Lista de materiais utilizados neste artigo

Nome	Empresa	Número de catálogo	Comentários
arquivo de configuração	de modelo config.cym.tpl
MacOS, Windows 10 ou Linux	computador
do Cytosim jove.cym
make_page.py			script Python; https://github.com/nedelec/make_page.py
preconfig			Script Python; https://github.com/nedelec/preconfig
scan.py			script Python; https://github.com/nedelec/scan.py