def set_model(self, model):
model.set_all_repulsive()
model.set_default_surface_size(self.world.world_size)
for st in model.species_types:
if st["surface"] == "":
st["surface"] = self.model.default_surface.name
try:
self.world.get_species(st.id)
except:
self.world.add_species(_gfrd.SpeciesInfo(st.id,
float(st["D"]),
float(st["radius"]),
st["surface"]))
# else: keep particle data for this species.
for surface in itertools.chain(model.surface_list.itervalues(), [model.default_surface]):
_surface_class = self.surface_conv_map.get(type(surface))
if _surface_class is None:
raise NotImplementedError("Unsupported surface type: %s" % surface)
_surface = _surface_class(surface.name, surface.shape)
self.world.add_surface(_surface)
self.network_rules = _gfrd.NetworkRulesWrapper(model.network_rules)
self.model = model
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)
gfrdbase.throw_in_particles(w, A, N)
print 'stir'
t = 0
stir_time = T * .1
while 1:
s.step()
next_time = s.get_next_time()
if next_time > stir_time:
s.stop(stir_time)
break
print 'reset'
s.reset()
print 'run'
run_time = T
start = time.time()
while s.t < run_time:
s.step()
end = time.time()
timing = end - start
steps = s.step_counter
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
def setUp(self):
self.m = _gfrd.Model()
self.s1 = self.m.new_species_type()
self.s1['radius'] = '0.1'
self.s1['D'] = '0.2'
self.s2 = self.m.new_species_type()
self.s2['radius'] = '0.3'
self.s2['D'] = '0.4'
self.nr = _gfrd.NetworkRulesWrapper(self.m.network_rules)
def setUp(self):
self.m = model.ParticleModel(1e-5)
self.S = model.Species('S', 2e-11, 5e-8)
self.A = model.Species('A', 0, 1e-8)
self.B = model.Species('B', 2e-11, 5e-9)
self.m.add_species_type(self.S)
self.m.add_species_type(self.A)
self.m.add_species_type(self.B)
self.m.set_all_repulsive()
self.w = gfrdbase.create_world(self.m, 10)
self.nrw = _gfrd.NetworkRulesWrapper(self.m.network_rules)
self.s = bd.BDSimulator(self.w, myrandom.rng, self.nrw)
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 = EGFRDSimulator(w, myrandom.rng, nrw)
place_particle(w, A, [0, 0, 0])
place_particle(w, B,
[(float(A['radius']) + float(B['radius'])) + 1e-23, 0, 0])
end_time = T
s.step()
while 1:
next_time = s.get_next_time()
if next_time > end_time:
s.stop(end_time)
break
s.step()
if len(s.world.get_particle_ids(C.id)) != 0:
return 0, s.t
distance = w.distance(s.get_position(A.id), s.get_position(B.id))
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 get_reaction_rules(model_or_simulator):
"""Return three lists with all the reaction rules defined in the
ParticleModel or EGFRDSimulator.
The three lists are:
- reaction rules of only one reactant.
- reaction rules between two reactants with a reaction rate
larger than 0.
- repulsive reaction rules between two reactants with a
reaction rate equal to 0.
Arguments:
- model_or_simulator
a ParticleModel or EGFRDSimulator.
"""
if isinstance(model_or_simulator, EGFRDSimulator):
model = model_or_simulator.world.model
else:
model = model_or_simulator
# Return 3 lists with different types of reaction rules.
reaction_rules_1 = []
reaction_rules_2 = []
repulsive_rules = []
# Wrap the network_rules first, the iterator over the products
# of the unwrapped one fails when there are no products.
network_rules = _gfrd.NetworkRulesWrapper(model.network_rules)
for index_of_si1, si1 in enumerate(model.species_types):
rri_vector = network_rules.query_reaction_rule(si1)
for rr_info in rri_vector:
reaction_rules_1.append(rr_info)
for si2 in list(model.species_types)[index_of_si1:]:
rri_vector = network_rules.query_reaction_rule(si1, si2)
for rr_info in rri_vector:
if rr_info.k > 0:
reaction_rules_2.append(rr_info)
else:
repulsive_rules.append(rr_info)
return reaction_rules_1, reaction_rules_2, repulsive_rules
def create_network_rules_wrapper(model):
return _gfrd.NetworkRulesWrapper(model.network_rules)
S2 = m.new_species_type()
S2['D'] = '.01'
S2['radius'] = '.01'
S2['surface'] = 'default'
colors = {
S0.id: (1., 0., 0.),
S1.id: (0., 1., 0.),
S2.id: (1., 1., 0.),
}
rr = _gfrd.ReactionRule((S0, S1), (S2, ))
rr['k'] = '.01'
m.network_rules.add_reaction_rule(rr)
nrw = _gfrd.NetworkRulesWrapper(m.network_rules)
class MyParticleContainer(_gfrd._ParticleContainer):
def __init__(self, world_size):
_gfrd._ParticleContainer.__init__(self)
self.particles = {}
self.surfaces = {}
self.species = {}
self.pidgen = _gfrd.ParticleIDGenerator(0)
self.world_size = world_size
def add_surface(self, surface):
self.surfaces[surface.id] = surface
def add_species(self, species):
