def test_prd_pacement():
sim = S.Simulation(low=[-10, -10, -10], high=[10, 10, 10], quit_at_end=1)
sim.setRandomSeed(10)
blue = sim.addSpecies(name="blue", color="blue", difc=1, display_size=0.3)
red = sim.addSpecies(name="red", color="red", difc=0, display_size=0.3)
sim.addMolecules(blue, number=100, lowpos=[-5, -5, -5], highpos=[5, 5, 5])
sim.addMolecules(red, number=1, pos=[0, 0, 0])
s1 = sim.addSurface(
"membrane",
panels=[
sim.addSphere(center=[0, 0, 0], radius=10, slices=10, stacks=10)
],
)
s1.setStyle("both", drawmode="edge", color="green")
s1.setAction(face="both", species=[blue, red], action="reflect")
stick = sim.addReaction(name="stick",
subs=[blue, red],
prds=[red, red],
rate=20)
stick.productPlacement(method="bounce", param=0.6)
sim.addOutputData("data")
sim.addCommand("molcount data", "E")
# sim.setGraphics('opengl_good', 1)
sim.run(stop=100, dt=0.1)
d = sim.getOutputData("data")
d = np.array(d)
assert (d[:, 1] + d[:, 2] == 101).all()
y = d.std(axis=0)
ym = d.mean(axis=0)
assert np.allclose(ym, [50, 20.75524, 80.24475], atol=1e-3, rtol=1e-3), ym
assert np.allclose(y, [28.89636655, 20.5, 20.5], atol=1e-1, rtol=1e-1), y
print(d)
def test_data():
s = smoldyn.Simulation(low=[0, 0, 0], high=[100, 100, 100])
s.seed = 100
R = s.addSpecies("R", difc=1, color="red")
B = s.addSpecies("B", difc=1, color="blue")
s.addReaction("r1", subs=[R], prds=[], rate=0.1)
R.addToSolution(400)
B.addToSolution(1, pos=[50, 50, 50])
s.addOutputData("mydata")
s.addCommand("molcount mydata", "E")
# s.setGraphics( "opengl" )
s.run(stop=10, dt=0.01)
print(s.stop, s.dt)
data = s.getOutputData("mydata", 0)
assert len(data) == 1001, len(data)
assert len(data[0]) == 3, len(data[0])
assert data[0] == [0.0, 400.0, 1.0], data[0]
assert is_close(data[-1], [10.0, 142.0, 1.0]), data[-1]
for row in data:
assert row
print(row)
def test_connect():
global a, avals
s = smoldyn.Simulation(low=(0, 0), high=(10, 10))
a = s.addSpecies("a", color="black", difc=0.1)
s.connect(new_dif, update_difc, step=10, args=[1, 1])
s.run(100, dt=1)
for a, b in zip(avals[1:], expected_a[1:]):
print("test_connect", a, b)
assert math.isclose(a[1], b[1], rel_tol=1e-6,
abs_tol=1e-6), (a[1], b[1])
def test_connect_2():
global spb, bvals
s1 = smoldyn.Simulation(low=(0, 0), high=(10, 10))
spb = s1.addSpecies("b", color="blue", difc=1)
s1.connect(new_dif_2, "spb.difc", step=1, args=[1, 1])
s1.run(stop=100, dt=10)
assert len(bvals) == len(expected_b)
for _x, _y in zip(bvals, expected_b):
print("test_connect_2", _x, _y)
assert tuple_isclose(_x, _y), (_x, _y)
def test_connect_1():
global spa, avals
s = smoldyn.Simulation(low=(0, 0), high=(10, 10))
spa = s.addSpecies("a", color="black", difc=0.1)
s.connect(new_dif_1, "spa.difc", step=10, args=[1, 1])
s.run(200, dt=1)
assert len(avals) == len(expected_a)
for _x, _y in zip(avals, expected_a):
print("test_connect_1", _x, _y)
assert tuple_isclose(_x, _y), (_x, _y)
def test_getters():
s = smoldyn.Simulation(low=[0, 0], high=[100, 100], types="r")
A = s.addSpecies("A",
color={"all": "red"},
difc={"all": 1},
display_size=dict(all=1))
B = s.addSpecies("B",
color={"all": "green"},
difc={"all": 1},
display_size=dict(all=1))
C = s.addSpecies("C",
color={"all": "blue"},
difc={"all": 1},
display_size=dict(all=1))
p1 = smoldyn.Rectangle(corner=(0, 0), dimensions=[100], axis="+x")
p2 = smoldyn.Rectangle(corner=(100, 0), dimensions=[100], axis="-x")
p3 = smoldyn.Rectangle(corner=(0, 0), dimensions=[100], axis="+y")
p4 = smoldyn.Rectangle(corner=(0, 100), dimensions=[100], axis="-y")
walls = s.addSurface("walls", panels=[p1, p2, p3, p4])
walls.setAction("both", [A, B, C], "reflect")
r1 = smoldyn.Rectangle(corner=[49, 30],
dimensions=[20],
axis="+x",
name="r1")
t1 = smoldyn.Triangle(vertices=[[49, 50], [29, 70]], name="t1")
left = s.addSurface(name="left", panels=[r1, t1])
r1.neighbor = t1
t1.neighbor = r1
left.setAction("both", [A, B, C], "reflect")
left.addMolecules((A, "up"), 20)
r1 = smoldyn.Rectangle(corner=[50, 30],
dimensions=[20],
axis="+x",
name="r1")
t1 = smoldyn.Triangle(vertices=[[50, 30], [70, 10]], name="t1")
right = s.addSurface(name="right", panels=[r1, t1])
r1.neighbor = t1
t1.neighbor = r1
right.setAction("both", [A, B, C], "reflect")
right.addMolecules((B, "up"), 20)
rxn1 = s.addReaction(
name="rxn1",
subs=[(A, "up"), (B, "up")],
prds=[(A, "up"), (C, "bsoln")],
binding_radius=2,
)
rxn1.setIntersurface([1, 1])
s.addGraphics("opengl_good")
s = s.run(1000, dt=0.1)
def build_model():
"""
Size of bouton: 1 cubic µm
diameter of Synaptic Vesicle (SV): 40 nm
Diff of SV: 0.024 um^2/s (2400 nm^2/s)
1px = 1nm throughout.
"""
global r1_, bouton_
s = smoldyn.Simulation(low=[-500, -500], high=[1500, 1500])
# a molecule that self-generate
sv = s.addSpecies("SV",
difc=dict(all=2400, front=10),
color="blue",
display_size=10)
sv.addToSolution(100, lowpos=(0, 0), highpos=(1000, 1000))
s.addReaction("svgen", [sv], [sv, sv], rate=1e-6)
svFused = s.addSpecies("VSOpen", color="blue", display_size=10)
# intermediate speficies with a lifetime.
B = s.addSpecies("B", color="red", difc=10000, display_size=2)
decay = s.addReaction("decay", subs=[B], prds=[], rate=math.log(2) / 20e-3)
# A very non-interesting surface.
path = s.addPath2D((1000, 0), (1000, 1000), (0, 1000), (0, 0))
bouton_ = s.addSurface("bouton", panels=path.panels)
bouton_.setStyle("both", color="blue")
# try to add all actions.
bouton_.setAction("both", [sv], "reflect")
bouton_.setAction("both", [sv], "trans")
bouton_.setAction("back", [sv], "absorb")
bouton_.setAction("back", [sv], "jump")
bouton_.setAction("back", [sv], "port")
# NOTE: action 'mult', 'no' and 'none' causes error here.
# this is the bottom surface of bouton. This is sticky for synaptic
# vesciles
rect1 = smoldyn.Rectangle(corner=(0, 0), dimensions=[1000], axis="+y")
bottom = s.addSurface("boutonBottom", panels=[rect1])
bottom.setStyle("both", color="red")
bottom.setAction("back", B, "reflect")
bottom.setAction("back", B, "trans")
bottom.setAction("back", B, "absorb")
bottom.setAction("back", B, "jump")
bottom.setAction("back", B, "port")
return s
def __init__(self, parameters=None):
super().__init__(parameters)
self.dt = self.parameters['dt']
# initialize the simulation
if self.parameters['file']:
self.simulation = sm.Simulation.fromFile(self.parameters['file'], "q")
else:
self.simulation = sm.Simulation(
low=self.parameters['low'],
high=self.parameters['high'],
types=self.parameters['boundary'],
setFlags="q"
)
# set output type
self.simulation.addOutputData('counts')
self.simulation.addCommand(cmd='molcount counts', cmd_type='E')
# get the species names
species_count = self.simulation.count()['species']
self.species = []
for index in range(species_count):
species_name = self.simulation.getSpeciesName(index)
self.species.append(species_name)
# make the species
species = {}
for name, config in self.parameters['species'].items():
species[name] = self.simulation.addSpecies(name, **config)
self.species.append(name)
# make the reactions
for rxn_name, config in self.parameters['reactions'].items():
substrate_names = config.pop('subs')
product_names = config.pop('prds')
substrates = [species[name] for name in substrate_names]
products = [species[name] for name in product_names]
self.simulation.addReaction(
rxn_name,
subs=substrates,
prds=products,
**config)
if self.parameters['animate']:
self.simulation.addGraphics('opengl')
def test_data_output():
s = sm.Simulation(low=[0, 0, 0], high=[100, 100, 100], boundary_type="ppp")
s.addBox(size=10)
# declaration of species A, B, and C with attributes.
a = s.addSpecies("A", state="soln", difc=1, color="red", mol_list="Alist")
b = s.addSpecies("B",
state="soln",
color="green",
difc=1,
mol_list="Blist")
c = s.addSpecies("C",
state="soln",
difc=1.0,
color="blue",
mol_list="Clist")
s.addMolecules(a, 1000)
s.addMolecules(b, 1000)
s.addBidirectionalReaction("r1", subs=[c], prds=(a, b), kf=0.1, kb=100)
# FIXME: Prints only upto 10 (2 iterations rather than 100)
s.setOutputFile("box.dat")
# s.setGraphics("opengl")
c = s.addCommand("molcount box.dat", "i", on=0, off=100, step=10)
s.run(100, dt=0.1, overwrite=True)
print("Simulation over")
# Now read the box.dat and verify the results.
# On OSX, it may not work. Homebrew python is a shell script which chdir to
# script dir before running it. I.e., box.dat would not be found easily.
if not os.path.exists('box.dat'):
quit(0)
data = np.loadtxt("box.dat")
assert data.shape == (11, 4), data.shape
expected = [50.036, 590.727, 590.727, 409.272]
print(data.mean(axis=0), expected)
assert np.isclose(data.mean(axis=0), expected, atol=1e-1,
rtol=1e-1).all(), data.mean(axis=0)
quit(0)
def sim2():
sim = smoldyn.Simulation(low=[0, 0, 0], high=[100, 100, 100])
# Set it after Simulation object is created.
sim.seed = 0
spRed = sim.addSpecies("red", color="red", difc=3, display_size=3)
spRed.addToSolution(20, highpos=[10, 50, 50])
spGreen = sim.addSpecies("green", color="green", difc=1, display_size=3)
sim.addMolecules(spGreen, 20, highpos=[10, 50, 50])
# Add Surfaces
r1 = sim.addRectangle(corner=[100, 0, 0], dimensions=[100, 100], axis="-x")
r2 = sim.addRectangle(corner=[0, 0, 0], dimensions=[100, 100], axis="+y")
r3 = sim.addRectangle(corner=[0, 100, 0], dimensions=[100, 100], axis="-y")
r4 = sim.addRectangle(corner=[0, 0, 0], dimensions=[100, 100], axis="+z")
r5 = sim.addRectangle(corner=[0, 0, 100], dimensions=[100, 100], axis="-z")
s1 = sim.addSurface("walls", panels=[r1, r2, r3, r4, r5])
# s1.both.setStyle(drawmode='edge')
s1.setStyle("both", drawmode="edge")
s1.setAction("both", [spRed, spGreen], "reflect")
# portsurf
rr = sim.addRectangle(corner=[0, 0, 0], dimensions=[100, 100], axis="+x")
portSurf = sim.addSurface("portsurf", panels=[rr])
portSurf.setStyle("front", drawmode="face", color="gray")
portSurf.setStyle("back", drawmode="face", color=[0.2, 0, 0, 1])
portSurf.setAction("front", [spRed, spGreen], "port")
portSurf.setAction("back", [spRed, spGreen], "reflect")
# Ports
sim.addPort(name="testport", surface=portSurf, panel="front")
# sim.setGraphics("opengl", 20)
sim.addOutputData("data2")
sim.addCommand("molcount data2", 'E')
return sim
def test_simptr_simobj():
s1 = smoldyn.Simulation([0, 0], [10, 10])
assert s1
assert s1.getSimPtr()
assert s1.simptr == s1.getSimPtr()
assert s1.simptr.dt == 0.0, "dt should be initialized to 0"
modelfile = sdir / "min.txt"
s2 = smoldyn.Simulation.fromFile(modelfile, "") # type: Simulation
assert s2
assert s2.getSimPtr() and s2.getSimPtr() == s2.simptr
assert s2.start == 0.0
assert s2.stop == 500
assert s2.dt == 0.002
s2.addOutputData('moments')
s2.addCommand("molmoments MinD_ATP(front) moments", "N", step=10)
s2.run(stop=100, dt=1)
data = s2.getOutputData("moments")
assert len(data) == 11, len(data)
for row in data:
print(row)
def test_getter():
s = smoldyn.Simulation(low=[0, 0],
high=[10, 10],
types="p",
output_files=["bistableout.txt"])
# species X A B A2 B2
X = s.addSpecies("X", difc=0, color="green", display_size=3)
A = s.addSpecies("A", difc=1, color="red", display_size=3)
B = s.addSpecies("B", difc=1, color="blue", display_size=3)
A2 = s.addSpecies("A2", difc=1, color="red", display_size=5)
B2 = s.addSpecies("B2", difc=1, color="blue", display_size=5)
# mol 1 X 5 5
X.addToSolution(1, pos=[5, 5])
express = s.addReaction("express", subs=[X], prds=[X, A, B], rate=1)
Adimer = s.addBidirectionalReaction("Adimer",
subs=[A, A],
prds=[A2],
kf=1,
kb=1)
Bdimer = s.addBidirectionalReaction("Bdimer",
subs=[B, B],
prds=[B2],
kf=1,
kb=1)
AxB = s.addReaction("AxB", subs=[A2, B], prds=[A2], rate=1)
BxA = s.addReaction("BxA", subs=[B2, A], prds=[B2], rate=1)
Adegrade = s.addReaction("Adegrade", subs=[A], prds=[], rate=0.01)
Bdegrade = s.addReaction("Bdegrade", subs=[B], prds=[], rate=0.01)
s.addCommand("molcountheader bistableout.txt", cmd_type="B")
s.addCommand("molcount bistableout.txt", cmd_type="N", step=10)
s.setGraphics("opengl")
d = s.count()
print(d)
def sim1():
s = smoldyn.Simulation(low=[0, 0], high=[100, 100])
red = s.addSpecies("red",
color="red",
difc=dict(all=3, front=0),
display_size=5)
yellow = s.addSpecies("yellow",
color="black",
difc=dict(soln=3, back=1),
display_size=5)
blue = s.addSpecies("blue", color="blue", difc=3, display_size=5)
red.addToSolution(100)
yellow.addToSolution(50, pos=(50, 50))
blue.addToSolution(50, pos=(20, 20))
# Construct a closed path in 2D.
p = s.addPath2D((0, 0), (100, 0), (100, 100), (0, 100), closed=True)
walls = s.addSurface("walls", panels=p.panels)
walls.setAction("both", [red, yellow, blue], "reflect")
walls.setStyle("both", color="black")
sph = s.addSphere(center=(50, 50), radius=20, slices=20)
surf = s.addSurface("stick", panels=[sph])
surf.setRate(red, "fsoln", "front", rate=10, revrate=1)
surf.setRate(yellow, "bsoln", "back", rate=10, revrate=1)
surf.setRate(blue, "fsoln", "bsoln", rate=10, revrate=1)
surf.setStyle("front", color=(1, 0.7, 0))
surf.setStyle("back", color=(0.6, 0, 0.6))
surf.addMolecules((red, "front"), 100)
# FIXME: Concurrent simulation doesn't work when graphics is enabled.
# s.setGraphics("opengl")
s.addCommand("killmolinsphere red all", "b")
s.addOutputData("data1")
s.addCommand("molcount data1", 'E')
return s
import smoldyn
import smoldyn._smoldyn as S
import numpy
import matplotlib.pyplot as plt
s = smoldyn.Simulation(low=[-10, -10, -10], high=[10, 10, 10])
target = s.addSpecies("target",
color=dict(all="red"),
display_size={"all": 10})
protein = s.addSpecies("protein",
color="black",
display_size=3,
difc=dict(all=1))
counter = s.addSpecies("counter", color="white", display_size=0)
sph1 = smoldyn.Sphere(center=[0, 0, 0], radius=10, slices=20, stacks=20)
membrane = s.addSurface(name="membrane", panels=[sph1])
membrane.setStyle("both", color="blue", drawmode="edge")
#membrane.setRate(protein, "bsoln", "back", rate=1, revrate=0.1)
r1 = s.addReaction("r1",
subs=[(target, "up"), (protein, "bsoln")],
prds=[(target, "up"), counter],
rate=6)
r2 = s.addReaction("r2",
subs=[(target, "up"), (protein, "back")],
prds=[(target, "up"), counter],
rate=12)
#s.setGraphics("opengl", frame_thickness=0, text_display=["time",protein,(protein,"back"), counter])
s.addOutputData("output")
# Demonstration of absorbing, periodic, and reflective boundaries
import smoldyn
import smoldyn._smoldyn as S
# dim 2
# low_wall x 0 a
# high_wall x 100 r
# boundaries y 0 100 p
s = smoldyn.Simulation(low=[0, 0], high=[100, 100], types=["ar", "p"])
# species red green
# difc red 3
# difc green 3
# color red red
# color green green
red = s.addSpecies("red", color="red", difc=3)
green = s.addSpecies("green", color="green", difc=3)
S.Simulation.readConfigString(s, "drift", "red 0.2 0")
S.Simulation.setFlags(s, "q")
# mol 300 red u u
# mol 30 green 50 5
red.addToSolution(300)
green.addToSolution(30, pos=[50, 5])
S.Simulation.runCommand(s, "molcount stdout")
# time_start 0
# time_stop 200
# time_step 0.01
import smoldyn
s = smoldyn.Simulation(low=[-1000, -1000, -10000],
high=[1000, 1000, 10000],
output_files=["cylinder.txt"])
d1 = s.addDisk(name="d1",
center=[50, 25, 8500],
radius=850,
slices=12,
vector=[0, 0, -1])
test = s.addSurface("test", panels=[d1])
# Simulation file for Lotka-Voltera reaction
import smoldyn
from pathlib import Path
scriptdir = Path(__file__).parent
s = smoldyn.Simulation([-100, -100, -10], [100, 100, 10], boundary_type="p")
rabbit = s.addSpecies("rabbit", color="red", display_size=2, mol_list="rlist", difc=100)
fox = s.addSpecies("fox", color="blue", display_size=3, mol_list="flist", difc=100)
s.addMoleculePerBox(1)
r1 = s.addReaction("r1", subs=[rabbit], prds=[rabbit, rabbit], rate=10)
r2 = s.addReaction("r2", subs=[rabbit, fox], prds=[fox, fox], rate=8000)
r3 = s.addReaction("r3", subs=[fox], prds=[], rate=10)
rabbit.addToSolution(1000)
fox.addToSolution(1000)
#s.setTiff("OpenGl")
#s.setGraphics("opengl", iter=5, text_display=["time", "rabbit", "fox"])
# NOTE: Can not set the absolute path. Its always relative to the current
# working directory.
datafile = "lotvoltout.txt"
s.setOutputFile(datafile)
s.addCommand(f"molcount {datafile}", "i", on=0, off=20, step=0.01)
s.addCommand("molcount stdout", "i", on=0, off=20, step=0.1)
s = s.run(5, dt=0.001, overwrite=True)
# make sure that datafile is generated.
# Bistable reaction system
__author__ = "Dilawar Singh"
__email__ = "*****@*****.**"
import smoldyn
s = smoldyn.Simulation(low=[0, 0],
high=[10, 10],
types="p",
output_files=["bistableout.txt"])
# species X A B A2 B2
X = s.addSpecies("X", difc=0, color="green", display_size=3)
A = s.addSpecies("A", difc=1, color="red", display_size=3)
B = s.addSpecies("B", difc=1, color="blue", display_size=3)
A2 = s.addSpecies("A2", difc=1, color="red", display_size=5)
B2 = s.addSpecies("B2", difc=1, color="blue", display_size=5)
# mol 1 X 5 5
X.addToSolution(1, pos=[5, 5])
express = s.addReaction("express", subs=[X], prds=[X, A, B], rate=1)
Adimer = s.addBidirectionalReaction("Adimer",
subs=[A, A],
prds=[A2],
kf=1,
kb=1)
Bdimer = s.addBidirectionalReaction("Bdimer",
subs=[B, B],
prds=[B2],
kf=1,
def build_model_smoldyn():
"""
Size of bouton: 1 cubic µm
diameter of Synaptic Vesicle (SV): 40 nm
Diff of SV: 0.024 um^2/s (2400 nm^2/s)
1px = 1nm throughout.
"""
global r1_, bouton_
s = smoldyn.Simulation(low=[-500, -500], high=[1500, 1500])
sv = s.addSpecies("SV",
difc=dict(all=2400, front=10),
color="blue",
display_size=10)
sv.addToSolution(100, lowpos=(0, 0), highpos=(1000, 1000))
# add a reaction with generates the sv at a fixed rate. Its better to
# split so location of the new sv is inside the box.
s.addReaction("svgen", [sv], [sv, sv], rate=1e-6)
# fused vesicle.
svFused = s.addSpecies("VSOpen", color="blue", display_size=10)
# neutotransmitter. The concentration has the half-life of 2ms (PMID:
# 19844813), that is, rate is 0.693/2e-3, k ~ 346 per sec
trans = s.addSpecies("trans", color="red", difc=10000, display_size=2)
decay = s.addReaction("decay",
subs=[trans],
prds=[],
rate=math.log(2) / 20e-3)
# BOUTON
path = s.addPath2D((1000, 0), (1000, 1000), (0, 1000), (0, 0))
bouton_ = s.addSurface("bouton", panels=path.panels)
bouton_.setStyle('both', color="blue")
bouton_.setAction('both', [sv], "reflect")
# this is the bottom surface of bouton. This is sticky for synaptic
# vesciles
rect1 = smoldyn.Rectangle(corner=(0, 0), dimensions=[1000], axis="+y")
bottom = s.addSurface("boutonBottom", panels=[rect1])
bottom.setStyle('both', color="red")
bottom.setAction('back', trans,
"reflect") # but it reflect neurotranmitter
# SV stick to bottom of the bouton and also detach back with a smaller
# rate.
bottom.setRate(sv, "fsoln", "front", rate=10, revrate=0.001)
# They move to outside of bouton, this value is dependant on the membrane
# potential
bottom.setRate(sv, "front", "bsoln", rate=10, new_species=svFused)
# Open vesicle turns into 1000 to 2000 or neurotransmitters.
r1_ = s.addReaction("open2trans",
subs=[svFused],
prds=[trans] * 200,
rate=100.0)
s.connect(generate_spike, update_kf, step=20)
s.addGraphics("opengl", iter=10, text_display="time")
print('[INFO] Starting simulation ...')
s.run(stop=20, dt=0.001)
print("Done")
def test_get_err():
print('Testing test_get_err')
s = smoldyn.Simulation(low=(0, 0), high=(1, 1))
a = smoldyn.getError()
print(a)
# -*- coding: utf-8 -*-
# Dilawar Singh <*****@*****.**>, 2020-04-29
# Python implementation of box.txt
import smoldyn as sm
s = sm.Simulation(low=[0, 0, 0], high=[100, 100, 100], boundary_type="ppp")
s.addBox(size=10)
# declaration of species A, B, and C with attributes.
a = s.addSpecies("A", state="soln", difc=1, color="red", mol_list="Alist")
b = s.addSpecies("B", state="soln", color="green", difc=1, mol_list="Blist")
c = s.addSpecies("C", state="soln", difc=1.0, color="blue", mol_list="Clist")
s.addMolecules(a, 1000)
s.addMolecules(b, 1000)
s.addBidirectionalReaction("r1", subs=[c], prds=(a, b), kf=0.1, kb=100)
# FIXME: Prints only upto 10 (2 iterations rather than 100)
s.setOutputFile("box.dat", True)
c = s.addCommand("molcount box.dat", cmd_type="i", on=0, off=100, step=10)
s.run(100, dt=1, log_level=1)
def test_newcursim():
print("test_newcursim")
s = smoldyn.Simulation(low=(0, 0), high=(1, 1))
cs = s.simptr
assert cs != None
print(cs)
# Zeroth order reactions
import smoldyn
s = smoldyn.Simulation(low=[0, 0, 0], high=(10, 10, 10), boundary_type="r")
red = s.addSpecies("red", difc=1, color=[1, 0, 0])
green = s.addSpecies("green", difc=1, color=[0, 1, 0])
blue = s.addSpecies("blue", difc=1, color=[0, 0, 1])
slow = s.addReaction("slow", [], [red], rate=0.001)
med = s.addReaction("med", [], [green], rate=0.01)
fast = s.addReaction("fast", [], [blue], rate=0.1)
s.setGraphics("opengl")
s.setOutputFile("zeroreactout.txt")
s.addCommand("molcount zeroreactout.txt", "e")
s = s.run(stop=10, dt=0.01, overwrite=True)
# Periodic boundaries with surfaces
import smoldyn
s = smoldyn.Simulation(low=[0, 0], high=[100, 100])
A = s.addSpecies("A", difc=1, color="red")
B = s.addSpecies("B", difc=1, color="green")
C = s.addSpecies("C", difc=1, color="blue")
A.addToSolution(200, pos=[10, 50])
B.addToSolution(200, pos=[90, 50])
s1 = s.addSphere(center=[50, 50], radius=20, slices=50)
ball = s.addSurface("ball", panels=[s1])
ball.setAction('both', [A, B, C], "reflect")
ball.setStyle('both', color=[0, 0.5, 0], thickness=1)
r1 = smoldyn.Rectangle(corner=[0, 0], dimensions=[100], axis="+0", name="r1")
r2 = smoldyn.Rectangle(corner=[100, 0], dimensions=[100], axis="-0", name="r2")
r3 = smoldyn.Rectangle(corner=[0, 0], dimensions=[100], axis="+1", name="r3")
r4 = smoldyn.Rectangle(corner=[0, 100], dimensions=[100], axis="-1", name="r4")
sides = s.addSurface("sides", panels=[r1, r2, r3, r4])
# sides.front.setAction([A, B, C], "jump")
# sides.back.setAction([A, B, C], "reflect")
sides.setAction('front', [A, B, C], 'jump')
sides.setAction('back', [A, B, C], 'reflect')
sides.setStyle('front', color=[0.2, 0, 0])
global r1_, bouton_, bottom_
kf = max(0.0, val) * 1e3 * 1e3
r1_.setRate(kf)
bottom_.setRate(sv, "fsoln", "front", rate=(10 + kf), revrate=0.0)
c = min(kf / 300, 1)
bouton_.setStyle('both', color=[c, c, c])
"""
Size of bouton: 1 cubic µm
diameter of Synaptic Vesicle (SV): 40 nm
Diff of SV: 0.024 µm^2/s (2400 nm^2/s)
1px = 1nm throughout.
"""
s = smoldyn.Simulation(low=[-500, -500], high=[1500, 1500])
sv = s.addSpecies(
"SV",
difc=dict(all=5000, front=100),
color=dict(fsoln="blue", front="gray"),
display_size=6,
)
sv.addToSolution(100, pos=(500, 500))
# fused vesicle.
svFused = s.addSpecies("VSOpen", color="red", display_size=10)
s.addReaction("prod", subs=[sv], prds=[sv, sv], rate=1e-2)
# neutotransmitter. The concentration has the half-life of 2ms (PMID:
# 19844813), that is, rate is 0.693/2e-3, k ~ 346 per sec
trans = s.addSpecies("trans", color="red", difc=10000, display_size=2)
The model was published in Andrews (2012) Methods for Molecular Biology, 804:519.
It executes a Michaelis-Menten reaction within and on the surface of a 2D circle.
"""
__author__ = "Dilawar Singh"
__email__ = "*****@*****.**"
import smoldyn
# Model parameters
K_FWD = 0.001 # substrate-enzyme association reaction rate
K_BACK = 1 # complex dissociation reaction rate
K_PROD = 1 # complex reaction rate to product
# Simulation starts with declaring a Simulation object with the system boundaries.
s = smoldyn.Simulation(low=[-1, -1], high=[1, 1])
# Molecular species and their properties
# Species: S=substrate, E=enzyme, ES=complex, P=product
# Type `help(smoldyn.Species)` in Python console to see all parameters.
S = s.addSpecies("S",
difc=3,
color=dict(all="green"),
display_size=dict(all=0.02))
E = s.addSpecies("E", color=dict(all="darkred"), display_size=dict(all=0.03))
P = s.addSpecies("P",
difc=3,
color=dict(all="darkblue"),
display_size=dict(all=0.02))
ES = s.addSpecies("ES", color=dict(all="orange"), display_size=dict(all=0.03))
spRed.addToSolution(20, highpos=[10,50,50])
spGreen = S.Species('green', color='green', difc=1, display_size=3)
spGreen.addToSolution(10)
# Add Surfaces
r1 = S.Rectangle(corner=[100,0,0], dimensions=[100,100], axis='-x')
r2 = S.Rectangle(corner=[0,0,0], dimensions=[100,100], axis='+y')
r3 = S.Rectangle(corner=[0,100,0], dimensions=[100,100], axis='-y')
r4 = S.Rectangle(corner=[0,0,0], dimensions=[100,100], axis='+z')
r5 = S.Rectangle(corner=[0,0,100], dimensions=[100,100], axis='-z')
s1 = S.Surface('walls', panels=[r1,r2,r3,r4,r5])
#s1.both.setStyle(drawmode='edge')
s1.setStyle('both', drawmode='edge')
s1.both.addAction('all', 'reflect')
# portsurf
rr = S.Rectangle(corner=[0,0,0], dimensions=[100,100], axis='+x')
portSurf = S.Surface('portsurf', panels=[rr])
portSurf.front.setStyle(drawmode='face', color='gray')
portSurf.back.setStyle(drawmode='face', color=[0.2,0,0,1])
portSurf.front.addAction('all', 'port')
portSurf.back.addAction('all', 'reflect')
# Ports
testport = S.Port('testport', surface=portSurf, panel='front')
s = S.Simulation(step=0.01, stop=100)
s.setGraphics('opengl', 20)
s.run()
"""
2Dreact.txt in Python
"""
__author__ = "Dilawar Singh"
__email__ = "*****@*****.**"
import smoldyn
s = smoldyn.Simulation(
low=[-5, -5, -5], high=[5, 5, 5], output_files=["2Dreactout.txt"]
)
red = s.addSpecies("red", difc=dict(all=0.1), color=dict(all="red"))
green = s.addSpecies("green", difc=dict(all=0.1), color=dict(all="green"))
blue = s.addSpecies("blue", difc=dict(all=0.1), color=dict(all="blue"))
h1 = s.addHemisphere(
name="h1", center=[-3, 0, 0], radius=2, vector=[1, 0, 0], slices=10, stacks=5
)
h2 = s.addHemisphere(
center=[3, 0, 0], radius=2, vector=[-1, 0, 0], slices=10, stacks=5, name="h2"
)
c1 = s.addCylinder(
start=[-3, 0, 0], end=[3, 0, 0], radius=2, slices=10, stacks=5, name="c1"
)
ecoli = s.addSurface("ecoli", panels=[h1, h2, c1])
ecoli.setStyle("both", drawmode="edge", color="black")
# h1.neighbor = c1
# h2.neighbor = c1
# c1.neighbors = [h1, h2]
__author__ = "Dilawar Singh"
__email__ = "*****@*****.**"
import smoldyn
s = smoldyn.Simulation(low=(0, 0, 0),
high=(100, 100, 100),
types=["r", "r", "r"])
red = s.addSpecies("red", difc=3, color="red")
s.addMolecules(red, 100) # or, red.addToSolution(100)
s.addMolecules(red, 30,
highpos=(20, 30,
20)) # red.addToSolution(30, highpos=[20, 30, 20])
green = s.addSpecies("green", difc=1, color="green")
s.addMolecules(green, 30)
s.setGraphics("opengl", 10)
s = s.run(100, 0.01, quit_at_end=True)
__author__ = "Dilawar Singh"
__email__ = "*****@*****.**"
import smoldyn as S
S.setBoundaries(low=(0, 0, 0), high=(100, 100, 100), types=['r', 'r', 'r'])
red = S.Species('red', difc=3)
red.addToSolution(100)
red.addToSolution(30, highpos=[20, 30, 20])
green = S.Species('green', difc=1)
green.addToSolution(30)
s = S.Simulation(100, 0.01)
s.setGraphics('opengl', 10)
s.run()
