Préparation

Veuillez vous référer à l'article séparé pour l'installation.

Essayez d'utiliser E-Cell 4 sous Windows 7 ou Mac OS X

Cet article est une édition avancée. Il est supposé que vous comprenez les éditions débutante et intermédiaire.

De plus, cet article suppose l'utilisation d'IPython Notebook.

Comment utiliser

Je pense que ce n'est plus "facile" à utiliser, mais j'aimerais expliquer un peu plus les fonctionnalités avancées à la fin.

Modélisation basée sur des règles

Donner une structure aux espèces moléculaires

Les noms d'espèces moléculaires précédents n'étaient que des symboles.

Par exemple, lorsque l'on considère la réaction A> B '', dans de nombreux cas, l'espèce A devient l'espèce moléculaire B en raison d'un état de modification ou d'un changement structurel, et c'est la même molécule que la molécule. C'est possible. Cependant, dans le cas des espèces moléculaires A et B, la relation entre les espèces moléculaires n'est pas claire. Permettez-moi de donner un autre exemple. Dans la réaction A + A> B```, l'espèce moléculaire B est probablement On peut s'attendre à ce que la molécule A soit un dimère à deux liaisons, mais il n'est pas connu du nom B, et même si le nom "B" est changé en "A2", l'ordinateur ne peut pas le juger.

Pour résoudre ces problèmes, donner une structure aux espèces moléculaires est la première étape de la modélisation basée sur des règles. Ci-dessous, expérimentons la modélisation basée sur des règles en utilisant E-Cell 4.

with reaction_rules():
    X(s=u) > X(s=p) | 1  # corresponding to 'A > B | 1'

Dans E-Cell 4, la structure de l'espèce moléculaire est déterminée à l'aide de parenthèses et de nombres égaux.Dans l'exemple ci-dessus, X (s = u) et X (s = p) '' Chacun représente un nom d'espèce moléculaire. Ici, l'espèce moléculaire X (s = u) '' signifie que la modification 'de la molécule' X 'est dans l'état' u '. De même, l'espèce moléculaire' X (s = p) est que la modification 'de la molécule'X' est l'état'p '. Ainsi, dans cette réaction, la molécule'X' est l'état de la modification 'to'u'. Signifie changer de «p». C'est la structure de l'espèce moléculaire.

Utilisons World pour confirmer cela.

from ecell4 import *

w = gillespie.GillespieWorld(Real3(1, 1, 1))
w.add_molecules(Species('X(s=u)'), 60)
w.add_molecules(Species('X(s=p)'), 120)

print(w.num_molecules(Species('X(s=u)')))  # will print 60
print(w.num_molecules(Species('X(s=p)')))  # will print 120

Le nombre est compté en ajoutant respectivement 60 et 120 espèces moléculaires. Même si le style d'écriture de l'espèce moléculaire est modifié, le nombre ajouté peut être obtenu comme d'habitude. Alors, que se passe-t-il si ce qui suit est fait?

print(w.num_molecules(Species('X')))  # will print 180

J'ai compté le nombre d'espèces moléculaires «X», mais nous n'avons ajouté aucune des espèces moléculaires «X». Néanmoins, nous en avons obtenu 180. Cela s'appelle «X». En effet, toutes les molécules nommées "X" sont comptées quel que soit l'état modifié, pas l'espèce moléculaire nommée. Les deux premières espèces moléculaires ajoutées sont toutes deux nommées "X", seul l'état modifié est différent. Par conséquent, les deux sont vrais en comptant «X».

Au fait, si vous voulez ne compter que les espèces moléculaires nommées'X ', utilisez `` num_molecules_exact```. Cette fois, il n'y a pas de telles espèces moléculaires, vous devriez donc obtenir 0.

Considérons ensuite la liaison: les espèces moléculaires représentant le complexe dans lequel la molécule «X» et la molécule «Y» sont liées peuvent s'écrire comme suit.

with reaction_rules():
    X(b1) + Y(b2) > X(b1^1).Y(b2^1) | 1

Regardez le côté droit de cette réaction. Vous pouvez voir que "X" et "Y" sont reliés par des points "." De cette façon, le complexe exprime plusieurs espèces moléculaires reliées par des points. ..

À propos, X (b1 ^ 1) .Y (b2 ^ 1) '' représente une espèce moléculaire dans son ensemble, mais certaines d'entre elles sont'X (b1 ^ 1) 'et'Y (b2 ^ 1). Vous pouvez voir qu'il contient deux éléments appelés ')'. Dans E-Cell 4, ceux-ci sont appelés espèces moléculaires unitaires Unité Espèce. X (b1 ^ 1) .Y (b2 ^ 1) est deux C'est une espèce moléculaire qui comprend une espèce moléculaire unitaire.Bien sûr, si c'est `` X (p = u) '', elle est constituée d'une espèce moléculaire unitaire.

Pour en revenir à l'histoire, les espèces moléculaires unitaires de X (b1 ^ 1) .Y (b2 ^ 1) '' sont modifiées respectivement par b1 '' et `` b2 ''. Les points de connexion entre les espèces sont déterminés. «X» et «Y» sont reliés par les modifications respectives «b1» et «b2». Le nombre après le symbole «^» est un nombre indiquant la correspondance des points de connexion. Oui. Cela peut être n'importe quel nombre supérieur à 0, tant qu'il correspond. De plus, cette fois, j'ai donné aux modificateurs des noms différents tels que «b1» et «b2», mais ils peuvent être identiques.

Modifié avec X (b1) '' sur le côté gauche Le fait que ni l'état du nombre égal ni la connexion par '^' ne soient écrits dans 'b1' signifie que le point de connexion 'b1' n'est connecté à personne. Pour clarifier: X (b1) `` signifie 'X' qui n'est lié à personne par la modification 'b1'.

Maintenant que nous avons expliqué la représentation du complexe, essayons-la de la même manière que précédemment.

w.add_molecules(Species('X(b1)'), 10)
w.add_molecules(Species('Y(b2)'), 20)
w.add_molecules(Species('X(b1^1).Y(b2^1)'), 30)

print(w.num_molecules(Species('X')))  # will print 40
print(w.num_molecules(Species('Y')))  # will print 50
print(w.num_molecules(Species('X.Y')))  # will print 30

Dernier point mais non le moindre, dans le cas d'une espèce moléculaire qui a à la fois un site de liaison et un site de modification, X (a, b = c) '' peut être écrit, mais X (b = c, a) '' Il ne peut pas être écrit comme `. Même s'il y a plusieurs parties, il doit être écrit comme` X (a, b, c, d = e, f = g) `. Cependant, l'ordre est changé `` X (c, a, b, f = g, d = e) '' peut être utilisé avec la même signification qu'auparavant.

Règle de réaction

Dans l'exemple précédent, il est devenu possible de compter le nombre de molécules en donnant une structure à l'espèce moléculaire Par exemple, l'espèce moléculaire «X» donnée lors du comptage ne signifie pas une espèce moléculaire spécifique, mais compte. C'est une sorte de modèle qui détermine les conditions spécifiques des espèces moléculaires qui devraient être, c'est-à-dire celles qui incluent X dans les espèces moléculaires unitaires. La modélisation basée sur des règles consiste à utiliser ces modèles pour décrire les réactions. L'étape suivante.

Prenons un exemple simple constitué d'une unité moléculaire d'espèce X.

Par exemple, l'espèce moléculaire unitaire X a trois sites de phosphorylation, «s1», «s2» et «3», chacun d'eux pouvant prendre indépendamment l'un ou l'autre des deux états «u» ou «p». À ce stade, le nombre d'états que peut prendre l'espèce moléculaire unitaire X est de 2 ^ 3 = 8 $.

Maintenant, comment écrire une telle réaction de phosphorylation de la molécule X? En fait, c'est comme suit.

with reaction_rules():
    X(s1=u, s2=u, s3=u) > X(s1=p, s2=u, s3=u) | 1
    X(s1=u, s2=p, s3=u) > X(s1=p, s2=p, s3=u) | 1
    X(s1=u, s2=u, s3=p) > X(s1=p, s2=u, s3=p) | 1
    X(s1=u, s2=p, s3=p) > X(s1=p, s2=p, s3=p) | 1
    X(s1=u, s2=u, s3=u) > X(s1=u, s2=p, s3=u) | 2
    X(s1=p, s2=u, s3=u) > X(s1=p, s2=p, s3=u) | 2
    X(s1=u, s2=u, s3=p) > X(s1=u, s2=p, s3=p) | 2
    X(s1=p, s2=u, s3=p) > X(s1=p, s2=p, s3=p) | 2
    X(s1=u, s2=u, s3=u) > X(s1=u, s2=u, s3=p) | 3
    X(s1=u, s2=p, s3=u) > X(s1=u, s2=p, s3=p) | 3
    X(s1=p, s2=u, s3=u) > X(s1=p, s2=u, s3=p) | 3
    X(s1=p, s2=p, s3=u) > X(s1=p, s2=p, s3=p) | 3

Il n'est pas facile de comprendre ce que cela signifie et de l'écrire sans erreur, la raison pour laquelle c'est gênant comme ça est que chaque réaction de phosphorylation n'est pas indépendante et qu'un site de phosphorylation est considéré. Parce que tous les autres états doivent être comptés.

Par conséquent, considérons le modèle des espèces moléculaires. Lorsque nous nous concentrons sur le site de phosphorylation '1', la réaction de phosphorylation est que l'état '1' de la molécule X passe de 'u' à 'p'. Autrement dit, Il suffit de prendre une molécule qui correspond au modèle de la molécule X où l'état de «1» est «u» et de changer l'état en «p».

with reaction_rules():
    X(s1=u) > X(s1=p) | 1
    X(s2=u) > X(s2=p) | 2
    X(s3=u) > X(s3=p) | 3

Ce ne sont pas des réactions qui ont des espèces moléculaires spécifiques individuelles à gauche et à droite, mais sont appelées règles de réaction parce qu'elles donnent un modèle d'espèces moléculaires.Pour utiliser ce modèle, les réactions sont différentes du passé. Vous devez indiquer qu'il s'agit d'un modèle par la loi.

De plus, comme la règle de réaction n'est qu'une règle basée sur le modèle, il n'est pas possible de savoir quel type d'espèce moléculaire existe réellement. Dans l'exemple ci-dessus, l'espèce moléculaire «X (s1 = u)» apparaît sur le côté gauche. Rappelez-vous que la première chose que j'ai envisagée était une espèce moléculaire avec trois modifications, telles que «X (s1 = u, s2 = u, s3 = u)». vouloir.

Dans le modèle basé sur des règles, en donnant une espèce moléculaire qui devient une graine de graine, toutes les espèces moléculaires possibles sont générées à la manière d'un ver en appliquant à plusieurs reprises la règle de réaction. Pensez-y comme une espèce moléculaire à ajouter.

m = get_model(seeds=(Species('X(s1=u, s2=u, s3=u)'),))
print(len(m.species_attributes()))  # will print 8
print(len(m.reaction_rules()))  # will print 12

A partir de l'espèce «X (s1 = u, s2 = u, s3 = u)» donnée ici, on peut voir que 8 espèces moléculaires et 12 réactions peuvent être obtenues à volonté.

Enfin, calculons à l'aide de ce modèle.

y = run_simulation(
    numpy.linspace(0, 5, 100),
    {'X(s1=u,s2=u,s3=u)': 120},
    model=m,
    species_list=('X', 'X(s1=p)', 'X(s2=p)', 'X(s3=p)'))

Les espèces moléculaires à enregistrer sont déterminées en spécifiant "liste_espèces". En fait, si vous regardez uniquement les états de phosphorylation des "1", "s2" et "3" modifiés, vous pouvez voir qu'ils augmentent des constantes de taux spécifiées. Bien entendu, la quantité totale de molécules «X» est constante.

Caractère générique

Maintenant que vous connaissez l'utilisation de base, il reste une chose à retenir: le joker, représenté par le symbole '\ _' dans E-Cell 4.

La première et la plus importante utilisation est la liaison. Par exemple, si l'espèce moléculaire «A» a un site de liaison «b» et que vous souhaitez connaître le nombre de A qui ne sont liés à personne, «A (b) Alors, comment exprimer A, qui est lié à quelqu'un?

with reaction_rules():
    A(b) + B(b) > A(b^1).B(b^1) | 1
    A(b^_, s=u) > A(b^_, s=p) | 2

m = get_model(seeds=(Species('A(b, s=u)'),))

Remarquez la deuxième loi de réaction: c'est ce que «« A (b ^ _, s = u) »« est écrit ». C'est un joker, c'est quoi. La deuxième loi de réaction modifie la modification «de» à «p», ce qui signifie que cette réaction ne se produit que lorsque A est lié à quelqu'un. Oui.

Si c'est A qui est simplement combiné avec quelqu'un, écrivez ```A (b ^ _) `` `.

Ce joker peut bien sûr être utilisé aussi bien pour la qualification que pour la jointure.Un exemple simple est ```A (s = _) `` `, ce qui signifie que la qualification 'peut être dans n'importe quel état. Je ne pense pas qu'il soit nécessaire d'écrire si ça va, mais je garantis que A a la qualification.

Une autre chose importante est quand il est utilisé pour le nom de l'espèce moléculaire unitaire.Si vous écrivez _ (s = u), il a un modifié ', et toute molécule dans l'état'u' Essayons.

`wildcard1.py`


from ecell4 import *

with reaction_rules():
    _(s=u) > _(s=p) | 1

m = get_model(seeds=(
    Species('A(s=u)'), Species('B(s=u)'), Species('C(b^1,s=u).C(b^1,s=u)')))

y = run_simulation(
    numpy.linspace(0, 5, 100),
    {'A(s=u)': 30, 'B(s=u)': 40, 'C(b^1,s=u).C(b^1,s=u)': 60},
    model=m,
    species_list=('A(s=u)', 'B(s=u)', 'C(s=u)', '_(s=u)'))

On peut voir que le nom de l'espèce moléculaire unitaire s'applique à «A», «B» et «C». Si un complexe se forme, il s'applique également à chacun d'eux. Bien sûr, il peut également être utilisé avec Observer et num_molecules.

Les caractères génériques peuvent également être utilisés pour déterminer les attributs d'une espèce moléculaire.

with species_attributes():
    _ | {'D': '1', 'radius': '0.005'}

Vous pouvez spécifier les attributs de tous les types moléculaires à l'aide de caractères génériques sans spécifier les mêmes attributs pour chaque type moléculaire. Si vous souhaitez ajouter une exception, spécifiez-la avant cela.

Faire une vidéo

Je pourrais utiliser `` viz.plot_world '' pour visualiser facilement l'état du monde. Voici comment faire une vidéo. Il y a plusieurs façons de faire une vidéo, mais cette fois Utilisons ParaView.

Download | ParaView

Tout d'abord, téléchargez ParaView à partir du site ci-dessus et installez-le. Ci-dessous, ParaView-4.3.1-Windows-32bit.exe est utilisé.

Enregistrer la position des particules

Tout d'abord, enregistrez les données pour la visualisation. Observer peut également être utilisé pour cela.

Cette fois, utilisons le modèle suivant.

from ecell4 import *

with species_attributes():
    A | {'D': '1', 'location': 'C'}
    B | {'D': '1', 'location': 'N'}
    N | {'location': 'C'}

with reaction_rules():
    A + N > B | 1e-4
    B + C > A | 1e-4

m = get_model()

w = lattice.LatticeWorld(Real3(1, 1, 1), 0.005)
w.bind_to(m)
w.add_structure(Species('C'), Sphere(Real3(0.5, 0.5, 0.5), 0.441))
w.add_structure(Species('N'), Sphere(Real3(0.5, 0.5, 0.5), 0.350))
w.add_molecules(Species('A'), 720)

Nous pensons à un modèle dans lequel des sphères imbriquées sont créées comme une structure et circulent de l'extérieur vers l'intérieur. La sphère interne N est placée de manière à chevaucher la sphère externe C.

Pour effectuer le calcul pour la seconde suivante, sélectionnez les types moléculaires «A» et «B» toutes les 0,01 seconde et enregistrez leurs positions au format CSV. Cependant, la procédure est essentiellement la même qu'avant.

sim = lattice.LatticeSimulator(w)
obs1 = NumberObserver(('A', 'B'))
obs2 = FixedIntervalCSVObserver(0.01, 'sample%03d.csv', ('A', 'B'))
sim.run(1, (obs1, obs2))

Cette fois, nous utilisons deux observateurs en même temps. Parmi ceux-ci, nous utilisons FixedIntervalCSVObserver '' pour l'enregistrement au format CSV. Les arguments sont la durée d'enregistrement, le nom du fichier et la liste des espèces moléculaires. Vous pouvez inclure le numéro de fichier dans le nom du fichier en utilisant ``% 03d```.

Faire ce qui précède devrait vous donner «exemple000.csv» à «échantillon100.csv». Enregistrez le fichier à l'emplacement où vous avez exécuté Python ou, si vous utilisez IPython Notebook, sous le répertoire où vous avez démarré IPython Notebook côté serveur. Devrait être fait.

Visualisation avec ParaView

Pour l'explication de ParaView lui-même, reportez-vous directement au site suivant, mais ici je n'expliquerai que la visualisation du résultat de E-Cell 4.

Tout d'abord, sélectionnez les données au format CSV enregistrées avec `` Fichier-> Ouvrir ''. Les fichiers de numéro de série enregistrés sont affichés ensemble comme indiqué dans la figure ci-dessous. Après le chargement, cliquez sur le bouton Appliquer dans Propriétés en bas à gauche. Appuyez sur pour terminer le chargement.

Après lecture, visualisez les données avec Pipeline. Commencez par convertir du tableau CSV en coordonnées. Sélectionnez `` Filtres-> Alphabétique-> Tableau en points ''. En bas à gauche, X, Y, Z Après avoir sélectionné x, y, z comme Colonne, appuyez sur le bouton Appliquer.

Enfin, sélectionnez Filtres-> Commun-> Glyphe ''. Comme précédemment, changez Type de glyphe '' de Propriétés '' à SphèreRéglez Mode échelle '' sur scalaire '' Je pense qu'une valeur numérique sera définie, mais ignorez-la et entrez 4 '' cette fois et appuyez sur le bouton Appliquer.

Ensuite, l'élément "Coloration" sera ajouté à la précédente Propriétés```, alors sélectionnez sid. Vous devriez pouvoir visualiser comme ci-dessous. Si vous ne voyez rien, le navigateur de pipelines en haut à gauche Assurez-vous que le globe oculaire à gauche de Glyph1``` est actif dans`.

Après cela, appuyez sur le bouton Lire '' ci-dessus.Si vous pouvez voir comment la couleur rouge augmente correctement, vous avez terminé.Vous pouvez enregistrer la vidéo à partir de Fichier-> Enregistrer l'animation ... doit.

Autres conseils

Utilisation de l'usine

Je vais vous expliquer comment écrire pour faciliter la commutation des modules d'E-Cell 4. Si vous n'êtes pas doué en programmation, vous pouvez l'ignorer.

Vous avez peut-être remarqué que la différence dans l'utilisation de différents modules d'ode, gillespie, meso et lattice apparaît presque uniquement lors de la création de World. Cependant, en réalité, le nom de Simulator est également différent, et lors de la création de World, 2 Il peut y avoir un deuxième argument ou non. Pour résoudre ces problèmes, chaque module fournit une classe de commodité appelée Factory.

f = ode.ODEFactory()
# f = gillespie.GillespieFactory()
# f = meso.MesoscopicFactory(Integer3(4, 4, 4))
# f = lattice.LatticeFactory(0.005)

w = f.create_world(Real3(1, 1, 1))  # XXX: Factory
w.bind_to(m)
w.add_molecules(Species('C'), 60)
sim = f.create_simulator(w)  # XXX: Factory
obs = FixedIntervalNumberObserver(0.1, ('A', 'B', 'C'))
sim.run(10, obs)

En faisant cela, le module peut être commuté en commutant l'usine. De plus, faisons de cela une fonction afin qu'il puisse être facilement comparé.

`comparison.py`


from ecell4 import *

def run(m, f):
    w = f.create_world(Real3(1, 1, 1))  # XXX: Factory
    w.bind_to(m)
    w.add_molecules(Species('C'), 60)
    sim = f.create_simulator(w)  # XXX: Factory
    obs = FixedIntervalNumberObserver(0.1, ('A', 'B', 'C'))
    sim.run(10, obs)
    return obs

with species_attributes():
    A | B | C | {'D': '1'}

with reaction_rules():
    A + B == C | (0.01, 0.3)

m = get_model()
obs1 = run(m, lattice.LatticeFactory(0.005))
obs2 = run(m, ode.ODEFactory())

viz.plot_number_observer(obs1, '-', obs2, '--')

Bien sûr, toutes les fonctions World ne peuvent pas être utilisées en commun, mais l'utilisation de Factory facilite la séparation de l'algorithme du problème.

Des exercices

Pratique des espèces moléculaires dans la modélisation basée sur des règles Comment exprimer un dimère composé de deux molécules X. Essayez également de manipuler lors du comptage du nombre de X.
Pratique des règles de réaction dans la modélisation basée sur des règles Lorsqu'il existe deux types d'espèces moléculaires unitaires «X» et «Y» et que les réactions suivantes sont établies indépendamment, combien d'espèces moléculaires existe-t-il?

Les X forment un dimère.

X et Y se combinent.

Y a un site de modification et prend l'un des deux états.

Cependant, faites attention à la symétrie.

Pratiquez l'enregistrement de la position de la molécule. Cette fois, je l'ai enregistrée dans un fichier au format CSV avec `` FixedIntervalCSVObserver '', mais quand je l'ai ouvert avec un éditeur de texte ou un logiciel de calcul de table, ce qui était réellement écrit Vérifions s'il y en a.
Entraînez-vous à la visualisation avec ParaView ParaView peut changer son apparence de différentes manières en fonction des paramètres, alors créez votre propre vidéo.

[PYTHON] E-Cell 4 Advanced Edition facile à utiliser