def run_single(T, V, N, R, D):
L = numpy.power(V, 1.0/3.0) # cuboid side length
# matrix_size = 3 # min matrix size
matrix_size = max(3, int(min(numpy.power(N, 1.0 / 3.0), L / (2 * R))))
m = model.ParticleModel(L)
A = model.Species('A', D, R)
m.add_species_type(A)
m.set_all_repulsive()
w = gfrdbase.create_world(m, matrix_size)
gfrdbase.throw_in_particles(w, A, N)
nrw = gfrdbase.create_network_rules_wrapper(m)
sim = _gfrd._EGFRDSimulator(w, nrw, myrandom.rng)
stirTime = T*0.01
t = 0.0
gc.disable
while (sim.step(stirTime)):
pass
print "Now running",int(N),"molecules for",T,"s"
endTime = stirTime+T
start = time.time()
while (sim.step(endTime)):
pass
print "time",sim.t,endTime
end = time.time()
gc.collect()
gc.enable()
duration = end-start
print duration,"s"
return duration
def singlerun(T, S):
m = model.ParticleModel(1e-3)
A = model.Species('A', 1e-12, 5e-9)
m.add_species_type(A)
w = gfrdbase.create_world(m, 3)
nrw = gfrdbase.create_network_rules_wrapper(m)
# s = EGFRDSimulator(w, myrandom.rng, nrw)
# s.set_user_max_shell_size(S)
s = _gfrd._EGFRDSimulator(w, nrw, myrandom.rng, 1, 1e-5, S)
particleA = gfrdbase.place_particle(w, A, [0, 0, 0])
end_time = T
s.step()
while 1:
next_time = s.t + s.dt
if next_time > end_time:
# s.stop(end_time)
s.step(end_time)
break
s.step()
pos = w.get_particle(iter(w.get_particle_ids(A.id)).next())[1].position
distance = w.distance([0,0,0], pos)
return distance, s.t
def singlerun(T, S):
m = model.ParticleModel(1e-3)
A = model.Species('A', 1e-12, 5e-9)
m.add_species_type(A)
w = gfrdbase.create_world(m, 3)
nrw = gfrdbase.create_network_rules_wrapper(m)
# s = EGFRDSimulator(w, myrandom.rng, nrw)
# s.set_user_max_shell_size(S)
s = _gfrd._EGFRDSimulator(w, nrw, myrandom.rng, 1, 1e-5, S)
particleA = gfrdbase.place_particle(w, A, [0, 0, 0])
end_time = T
s.step()
while 1:
next_time = s.t + s.dt
if next_time > end_time:
# s.stop(end_time)
s.step(end_time)
break
s.step()
pos = w.get_particle(iter(w.get_particle_ids(A.id)).next())[1].position
distance = w.distance([0, 0, 0], pos)
return distance, s.t
def singlerun(T):
sigma = 5e-9
r0 = sigma
D = 1e-12
D_tot = D * 2
kf = 100 * sigma * D_tot
m = model.ParticleModel(1e-3)
A = model.Species('A', D, sigma / 2)
m.add_species_type(A)
B = model.Species('B', D, sigma / 2)
m.add_species_type(B)
C = model.Species('C', D, sigma / 2)
m.add_species_type(C)
r1 = model.create_binding_reaction_rule(A, B, C, kf)
m.network_rules.add_reaction_rule(r1)
w = gfrdbase.create_world(m, 3)
nrw = gfrdbase.create_network_rules_wrapper(m)
s = _gfrd._EGFRDSimulator(w, nrw, myrandom.rng)
class check_reactions:
def __init__(self):
self.reactions = []
def __call__(self, ri):
self.reactions.append(ri)
cr = check_reactions()
s.reaction_recorder = cr
pid1 = gfrdbase.place_particle(w, A, [0, 0, 0])[0]
pid2 = gfrdbase.place_particle(
w, B, [float(A['radius']) + float(B['radius']) + 1e-23, 0, 0])[0]
end_time = T
while s.step(end_time):
if len(cr.reactions) != 0:
cr.reactions = []
return 0, s.t
p1 = s.world.get_particle(pid1)[1]
p2 = s.world.get_particle(pid2)[1]
distance = w.distance(p1.position, p2.position)
return distance, s.t
def singlerun(T):
sigma = 5e-9
r0 = sigma
D = 1e-12
D_tot = D * 2
tau = sigma * sigma / D_tot
kf = 100 * sigma * D_tot
koff = 0.1 / tau
m = model.ParticleModel(1e-3)
A = model.Species('A', D, sigma/2)
B = model.Species('B', D, sigma/2)
C = model.Species('C', D, sigma/2)
m.add_species_type(A)
m.add_species_type(B)
m.add_species_type(C)
r1 = model.create_binding_reaction_rule(A, B, C, kf)
m.network_rules.add_reaction_rule(r1)
r2 = model.create_unbinding_reaction_rule(C, A, B, koff)
m.network_rules.add_reaction_rule(r2)
w = gfrdbase.create_world(m, 3)
nrw = _gfrd.NetworkRulesWrapper(m.network_rules)
s = _gfrd._EGFRDSimulator(w, nrw, myrandom.rng)
place_particle(w, A, [0,0,0])
place_particle(w, B,
[(float(A['radius']) + float(B['radius']))+1e-23,
0,0])
end_time = T
while s.step(end_time):
pass
if len(s.world.get_particle_ids(C.id)) != 0:
return 0, s.t
pid1 = list(s.world.get_particle_ids(A.id))[0]
pid2 = list(s.world.get_particle_ids(B.id))[0]
p1 = s.world.get_particle(pid1)[1]
p2 = s.world.get_particle(pid2)[1]
distance = w.distance(p1.position, p2.position)
return distance, s.t
def singlerun(T):
sigma = 5e-9
r0 = sigma
D = 1e-12
D_tot = D * 2
kf = 100 * sigma * D_tot
m = model.ParticleModel(1e-3)
A = model.Species('A', D, sigma/2)
m.add_species_type(A)
B = model.Species('B', D, sigma/2)
m.add_species_type(B)
C = model.Species('C', D, sigma/2)
m.add_species_type(C)
r1 = model.create_binding_reaction_rule(A, B, C, kf)
m.network_rules.add_reaction_rule(r1)
w = gfrdbase.create_world(m, 3)
nrw = gfrdbase.create_network_rules_wrapper(m)
s = _gfrd._EGFRDSimulator(w, nrw, myrandom.rng)
class check_reactions:
def __init__(self):
self.reactions = []
def __call__(self, ri):
self.reactions.append(ri)
cr = check_reactions()
s.reaction_recorder = cr
pid1 = gfrdbase.place_particle(w, A, [0,0,0])[0]
pid2 = gfrdbase.place_particle(w, B, [float(A['radius']) +
float(B['radius'])+1e-23,0,0])[0]
end_time = T
while s.step(end_time):
if len(cr.reactions) != 0:
cr.reactions = []
return 0, s.t
p1 = s.world.get_particle(pid1)[1]
p2 = s.world.get_particle(pid2)[1]
distance = w.distance(p1.position, p2.position)
return distance, s.t
def singlerun(T):
sigma = 5e-9
r0 = sigma
D = 1e-12
D_tot = D * 2
tau = sigma * sigma / D_tot
kf = 100 * sigma * D_tot
koff = 0.1 / tau
m = model.ParticleModel(1e-3)
A = model.Species('A', D, sigma / 2)
B = model.Species('B', D, sigma / 2)
C = model.Species('C', D, sigma / 2)
m.add_species_type(A)
m.add_species_type(B)
m.add_species_type(C)
r1 = model.create_binding_reaction_rule(A, B, C, kf)
m.network_rules.add_reaction_rule(r1)
r2 = model.create_unbinding_reaction_rule(C, A, B, koff)
m.network_rules.add_reaction_rule(r2)
w = gfrdbase.create_world(m, 3)
nrw = _gfrd.NetworkRulesWrapper(m.network_rules)
s = _gfrd._EGFRDSimulator(w, nrw, myrandom.rng)
place_particle(w, A, [0, 0, 0])
place_particle(w, B,
[(float(A['radius']) + float(B['radius'])) + 1e-23, 0, 0])
end_time = T
while s.step(end_time):
pass
if len(s.world.get_particle_ids(C.id)) != 0:
return 0, s.t
pid1 = list(s.world.get_particle_ids(A.id))[0]
pid2 = list(s.world.get_particle_ids(B.id))[0]
p1 = s.world.get_particle(pid1)[1]
p2 = s.world.get_particle(pid2)[1]
distance = w.distance(p1.position, p2.position)
return distance, s.t
def run_single(T, V, N):
print 'T =', T, '; V= ', V, '; N=', N
# disable gc
import gc
gc.disable()
L = math.pow(V * 1e-3, 1.0 / 3.0)
matrix_size = max(3, int((3 * N) ** (1.0/3.0)))
print 'matrix_size=', matrix_size
D = 1e-12
m = model.ParticleModel(L)
A = model.Species('A', D, 2.5e-9)
m.add_species_type(A)
m.set_all_repulsive()
w = gfrdbase.create_world(m, matrix_size)
nrw = _gfrd.NetworkRulesWrapper(m.network_rules)
#s = EGFRDSimulator(w, myrandom.rng, nrw)
myrandom.seed(3964642685656813207)
s = _gfrd._EGFRDSimulator(w, nrw, myrandom.rng)
#s.paranoiac = True
gfrdbase.throw_in_particles(w, A, N)
print 'stir'
stir_time = T * .1
while 1:
s.step()
next_time = s.t + s.dt
if next_time > stir_time:
s.step(stir_time)
break
stir_steps = s.num_steps
#print 'reset'
#s.reset()
print 'run'
run_time = T + stir_time
start = time.time()
while s.t < run_time:
s.step()
end = time.time()
timing = end - start
steps = s.num_steps - stir_steps
stepspersec = float(steps) / timing
print 'steps (total)= ', steps
print 'steps/sec= ', stepspersec, ', steps/N= ', float(steps) / N
print 'TIMING:\n', timing, '\n'
gc.collect()
gc.enable()
return end - start, steps, stepspersec
m.add_species_type(ES)
m.add_species_type(P)
fwd = model.create_binding_reaction_rule(E, S, ES, 0.01e-18)
back = model.create_unbinding_reaction_rule(ES, E, S, 0.1)
prod = model.create_unbinding_reaction_rule(ES, E, P, 0.1)
m.network_rules.add_reaction_rule(fwd)
m.network_rules.add_reaction_rule(back)
m.network_rules.add_reaction_rule(prod)
m.set_all_repulsive()
w = gfrdbase.create_world(m, matrix_size)
gfrdbase.throw_in_particles(w, E, nE)
gfrdbase.throw_in_particles(w, S, nS)
nrw = gfrdbase.create_network_rules_wrapper(m)
sim = _gfrd._EGFRDSimulator(w, nrw, myrandom.rng)
start = time.time()
t = 0
f = open('egfrd_small_r.csv','w')
while (sim.step(T)):
t = t+1e-2
while (sim.step(t)): pass
f.write(str(sim.t)+','+str(len(w.get_particle_ids(E)))+','+str(len(w.get_particle_ids(S)))+','+str(len(w.get_particle_ids(ES)))+','+str(len(w.get_particle_ids(P)))+'\n')
f.flush()
print "time",sim.t,T
end = time.time()
duration = end-start
print duration,"s"
def run_single(T, V, N):
print 'T =', T, '; V= ', V, '; N=', N
# disable gc
import gc
gc.disable()
L = math.pow(V * 1e-3, 1.0 / 3.0)
matrix_size = max(3, int((3 * N)**(1.0 / 3.0)))
print 'matrix_size=', matrix_size
D = 1e-12
m = model.ParticleModel(L)
A = model.Species('A', D, 2.5e-9)
m.add_species_type(A)
m.set_all_repulsive()
w = gfrdbase.create_world(m, matrix_size)
nrw = _gfrd.NetworkRulesWrapper(m.network_rules)
#s = EGFRDSimulator(w, myrandom.rng, nrw)
myrandom.seed(3964642685656813207)
s = _gfrd._EGFRDSimulator(w, nrw, myrandom.rng)
#s.paranoiac = True
gfrdbase.throw_in_particles(w, A, N)
print 'stir'
stir_time = T * .1
while 1:
s.step()
next_time = s.t + s.dt
if next_time > stir_time:
s.step(stir_time)
break
stir_steps = s.num_steps
#print 'reset'
#s.reset()
print 'run'
run_time = T + stir_time
start = time.time()
while s.t < run_time:
s.step()
end = time.time()
timing = end - start
steps = s.num_steps - stir_steps
stepspersec = float(steps) / timing
print 'steps (total)= ', steps
print 'steps/sec= ', stepspersec, ', steps/N= ', float(steps) / N
print 'TIMING:\n', timing, '\n'
gc.collect()
gc.enable()
return end - start, steps, stepspersec
# ".*", _gfrd.PythonLoggerFactory())
m = model.ParticleModel(L)
S = model.Species('S', 1.5e-12, 5e-9)
P = model.Species('P', 1e-12, 7e-9)
m.add_species_type(S)
m.add_species_type(P)
r1 = model.create_binding_reaction_rule(S, S, P, 1e7 / N_A)
r2 = model.create_unbinding_reaction_rule(P, S, S, 1e3)
m.network_rules.add_reaction_rule(r1)
m.network_rules.add_reaction_rule(r2)
m.set_all_repulsive()
world = create_world(m, int((N * 6)**(1. / 3.)))
nrw = _gfrd.NetworkRulesWrapper(m.network_rules)
s = _gfrd._EGFRDSimulator(world, nrw, myrandom.rng)
s.paranoiac = True
#s = BDSimulator(world. myrandom.rng, nrw)
throw_in_particles(s.world, S, N / 2)
throw_in_particles(s.world, P, N / 2)
#l = Logger('dimer')
l = None
interrupter = None
if l is not None:
interrupter = FixedIntervalInterrupter(s, 1e-7, l.log)
import myrandom
myrandom.seed(0)
# ".*", _gfrd.PythonLoggerFactory())
m = model.ParticleModel(L)
S = model.Species('S', 1.5e-12, 5e-9)
P = model.Species('P', 1e-12, 7e-9)
m.add_species_type(S)
m.add_species_type(P)
r1 = model.create_binding_reaction_rule(S, S, P, 1e7 / N_A)
r2 = model.create_unbinding_reaction_rule(P, S, S, 1e3)
m.network_rules.add_reaction_rule(r1)
m.network_rules.add_reaction_rule(r2)
m.set_all_repulsive()
world = create_world(m, int((N * 6) ** (1. / 3.)))
nrw = _gfrd.NetworkRulesWrapper(m.network_rules)
s = _gfrd._EGFRDSimulator(world, nrw, myrandom.rng)
s.paranoiac = True
#s = BDSimulator(world. myrandom.rng, nrw)
throw_in_particles(s.world, S, N / 2)
throw_in_particles(s.world, P, N / 2)
#l = Logger('dimer')
l = None
interrupter = None
if l is not None:
interrupter = FixedIntervalInterrupter(s, 1e-7, l.log)
import myrandom
