def scalar_bistable(rxdstr):
if rxdstr == 'rxd':
from neuron import rxd
else:
from neuron import crxd as rxd
h.load_file('stdrun.hoc')
s = h.Section(name='s')
s.nseg = 101
cyt = rxd.Region(h.allsec())
c = rxd.Species(cyt,
name='c',
initial=lambda node: 1 if 0.4 < node.x < 0.6 else 0,
d=1)
r = rxd.Rate(c, -c * (1 - c) * (0.3 - c))
h.finitialize()
h.run()
#check the results
result = h.Vector(c.nodes.concentration)
cmpV = h.Vector(scalar_bistable_data[rxdstr])
cmpV.sub(result)
cmpV.abs()
if cmpV.sum() < 1e-6:
sys.exit(0)
sys.exit(-1)
def do_sim(simulation, sim_control=None):
"""setup a simulation"""
global na, cell
# hide the simulation control panel, if there was one
if sim_control:
sim_control.unmap()
cell = FleidervishNeuron()
# add sodium diffusion everywhere
allsec = rxd.Region(h.allsec(), nrn_region='i')
na = rxd.Species(allsec, d=0.6, name='na', charge=1)
# create a current clamp and add it to the cell
cell.ic = h.IClamp(cell.soma(0.5))
cell.ic.dur = 3 # ms
cell.ic.amp = 1.5 # nA
# setup graphs needed by both simulations
concentration_graph = h.Graph(False)
concentration_graph.size(0, 3000, 4, 4.4)
voltage_graph = h.Graph(False)
voltage_graph.size(0, 3000, -90, 60)
h.graphList[0].append(voltage_graph)
h.graphList[1].append(concentration_graph)
# pop up the run control
h.nrncontrolmenu()
# call the funciton which actually sets up the specific simulation
simulation(cell, voltage_graph, concentration_graph)
def load(self, secs, dx_3d_size, rxds=None):
"""
Must be called after all secs are set.
:param secs:
List of sections (real HOC objects)
:param dx_3d_size:
If 3D geometry is True, define the size of the single compartment size.
:param rxds:
dictionary which contains previously added RxDTool objects
"""
self.cyt = rxd.Region(secs=secs, nrn_region='i', dx=dx_3d_size)
# 1/nM = 1 × 1/10^-9M = 10^3/10^3 × 1/10^-9M = 1000/(10^3×10^-9M) = 1000/10^-6M = 1000/uM
# Ca2+
self.ca = rxd.Species(regions=self.cyt,
initial=75 * nM,
name='ca',
charge=2,
d=174.3 / sec)
# Calbindin buffer
self.calbindin = rxd.Species(regions=self.cyt,
initial=159982 * nM,
name='calbindin',
charge=0,
d=9.3 / sec)
self.calbindin_ca = rxd.Species(regions=self.cyt,
initial=18 * nM,
name='calbindin_ca',
charge=0,
d=9.3 / sec)
self.calbindin_ca_reaction = rxd.Reaction(self.ca + self.calbindin,
self.calbindin_ca,
0.028e-3 / (nM * ms),
19.6 / (nM * ms))
# Calmodulin buffer
self.calmodulin = rxd.Species(regions=self.cyt,
initial=12600 * nM,
name='calmodulin',
charge=0,
d=4 / sec)
self.calmodulin_ca2 = rxd.Species(regions=self.cyt,
initial=200 * nM,
name='calmodulin_ca2',
charge=0,
d=4 / sec)
self.calmodulin_ca4 = rxd.Species(regions=self.cyt,
initial=3 * nM,
name='calmodulin_ca4',
charge=0,
d=4 / sec)
self.calmodulin_ca2_reaction = rxd.Reaction(
2 * self.ca + self.calmodulin, self.calmodulin_ca2,
6e-6 / (nM * ms), 9.1e-3 / (nM * ms))
self.calmodulin_ca4_reaction = rxd.Reaction(
2 * self.ca + self.calmodulin_ca2, self.calmodulin_ca4,
0.1e-3 / (nM * ms), 1000e-3 / (nM * ms))
def basicRxD3D():
from neuron import h, rxd
s = h.Section(name='s')
s.L = s.diam = 1
cyt = rxd.Region([s])
ca = rxd.Species(cyt)
rxd.set_solve_type(dimension=3)
h.finitialize(-65)
h.fadvance()
return 1
lncrec, ltimevec, lidvec = [], [], [] # spike recorders
lX, lY, lZ, lctyID = [0], [0], [0], [
E2
] # E2 pyramidal cell - nothing particular about the E2
timevec, idvec = h.Vector(), h.Vector()
ncrec = h.NetCon(ce[-1].soma(0.5)._ref_v, None, sec=ce[-1].soma)
ncrec.record(timevec, idvec, 0)
ncrec.threshold = 0 # 10 mV is default, lower it
ltimevec.append(timevec)
lidvec.append(idvec)
lncrec.append(ncrec) # record the spikes at soma
rxd.options.use_reaction_contribution_to_jacobian = False # faster (checked a few days before 10/16/13)
fc, fe = 0.83, 0.17 # cytoplasmic, er volume fractions
cyt = rxd.Region(rxdsec,
nrn_region='i',
geometry=rxd.FractionalVolume(fc, surface_fraction=1))
er = rxd.Region(rxdsec, geometry=rxd.FractionalVolume(fe))
cyt_er_membrane = rxd.Region(rxdsec, geometry=rxd.ScalableBorder(1))
caDiff = 0.233
ca = rxd.Species([cyt, er],
d=caDiff,
name='ca',
charge=2,
initial=dconf['cacytinit'])
caexinit = dconf['caexinit']
caextrude = rxd.Rate(ca, (caexinit - ca[cyt]) / taurcada,
regions=cyt,
membrane_flux=False)
ip3 = rxd.Species(cyt, d=0.283, name='ip3', initial=0.0)
# nai = 10 nao = 147
# ki = 125 ko = 2.9
# In[6]:
def concentration(i, o):
return lambda nd: i if isinstance(nd, rxd.node.Node1D) else o
# In[7]:
# REGIONS------------------------------------------------------------------------------------------------------------------------
# intracellular/extracellular regions
cyt = rxd.Region(soma, name="cyt", nrn_region="i")
mem = rxd.Region(soma, name="cell_mem", geometry=rxd.membrane())
gcyt = rxd.Region(glia, name="cyt", nrn_region="i")
gmem = rxd.Region(glia, name="cell_mem", geometry=rxd.membrane())
dx = vo**(1.0 / 3.0)
ecs = rxd.Extracellular(-2 * dx,
-2 * dx,
-2 * dx,
2 * dx,
2 * dx,
2 * dx,
dx=dx)
# ecs = rxd.Extracellular(-100, -100, -100, 100, 100, 100, dx=33)
# SPECIES/PARAMETERS------------------------------------------------------------------------------------------------------------------------
# intracellular/extracellular species (Na+, K+, Cl-)
from neuron import h, rxd
h.load_file("stdrun.hoc")
sec = h.Section(name="sec")
sec.L = 10
sec.nseg = 11
sec.diam = 5
rxd.set_solve_type(dimension=3)
cyt = rxd.Region(h.allsec(), name="cyt", nrn_region="i")
ip3 = rxd.Species(cyt,
name="ip3",
initial=lambda nd: 1000 if nd.segment == sec(0.3) else 0)
def callbackfun():
return 1000
for nd in ip3.nodes(sec(0.1)):
nd.include_flux(1000)
for nd in ip3.nodes(sec(0.5)):
nd.include_flux(callbackfun)
for nd in ip3.nodes(sec(0.9)):
nd.include_flux(sec(0.3)._ref_ip3i)
h.finitialize(-70)
h.continuerun(10)
import numpy
gip3r = 12040
gserca = 0.3913
gleak = 6.020
kserca = 0.1
kip3 = 0.15
kact = 0.4
ip3rtau = 2000.0
#These parameters where missing in the tutorial so arbitrary values were chosen
#any resemblance to experimental values is purely coincidental.
fc = 0.7
fe = 0.3
caCYT_init = 0.1
cyt = rxd.Region(h.allsec(),
name='cyt',
nrn_region='i',
geometry=rxd.FractionalVolume(fc, surface_fraction=1))
er = rxd.Region(h.allsec(), name='er', geometry=rxd.FractionalVolume(fe / 2.))
cyt_er_membrane = rxd.Region(h.allsec(),
name='mem',
geometry=rxd.ScalableBorder(
1, on_cell_surface=False))
ca = rxd.Species([cyt, er], d=caDiff, name="ca", charge=2, initial=caCYT_init)
ip3 = rxd.Species(cyt, d=ip3Diff, name="ip3", initial=ip3_init)
ip3r_gate_state = rxd.Species(cyt_er_membrane, name="gate", initial=0.8)
h_gate = ip3r_gate_state[cyt_er_membrane]
minf = ip3[cyt] * 1000. * ca[cyt] / (ip3[cyt] + kip3) / (1000. * ca[cyt] +
gserca = 0.3913
gleak = 6.020
kserca = 0.1
kip3 = 0.15
kact = 0.4
ip3rtau = 2000.0
# These parameters where missing in the tutorial so arbitrary values were chosen
# any resemblance to experimental values is purely coincidental.
fc = 0.7
fe = 0.3
caCYT_init = 0.1
cyt = rxd.Region(
h.allsec(),
name="cyt",
nrn_region="i",
geometry=rxd.FractionalVolume(fc, surface_fraction=1),
)
er = rxd.Region(h.allsec(), name="er", geometry=rxd.FractionalVolume(fe / 2.0))
cyt_er_membrane = rxd.Region(h.allsec(),
name="mem",
geometry=rxd.DistributedBoundary(1))
ca = rxd.Species([cyt, er], d=caDiff, name="ca", charge=2, initial=caCYT_init)
ip3 = rxd.Species(cyt, d=ip3Diff, name="ip3", initial=ip3_init)
ip3r_gate_state = rxd.Species(cyt_er_membrane, name="gate", initial=0.8)
h_gate = ip3r_gate_state[cyt_er_membrane]
minf = ip3[cyt] * 1000.0 * ca[cyt] / (ip3[cyt] + kip3) / (1000.0 * ca[cyt] +
#cp model_nrn_altered_template.py model_nrn_testPKA.py
#Based on Model C in https://www.ncbi.nlm.nih.gov/pmc/articles/PMC2719611/
from neuron import h, rxd
from pylab import *
from matplotlib import pyplot
import scipy.io
import time
import re
import mytools
h.load_file('stdrun.hoc')
dend = h.Section(name='dend')
dend.L = 1
dend.diam = 0.79788
cyt = rxd.Region([dend], name='cyt', nrn_region='i')
mesh_input_file = open('mesh_general.out', 'r')
mesh_firstline = mesh_input_file.readline()
mesh_secondline = mesh_input_file.readline()
mesh_values = mesh_secondline.split()
my_volume = float(mesh_values[-2]) * 1e-15 #litres
mesh_input_file.close()
Duration = 3000
tolerance = 1e-6
cAMP_input_onset = 800
cAMP_input_N = 100
cAMP_input_freq = 100
cAMP_input_dur = 0.005
cAMP_input_flux = 600.0
import matplotlib.pyplot as plt
from neuron import h, rxd
from neuron.units import mV, ms
h.load_file('stdrun.hoc')
soma = h.Section(name='soma')
soma.diam = soma.L = 10
ecs = rxd.Extracellular(-20, -20, -20, 20, 20, 20, dx=10)
cyt = rxd.Region([soma], name='cyt', nrn_region='i')
mem = rxd.Region([soma], name='mem', geometry=rxd.membrane())
ca = rxd.Species([cyt, ecs],
d=1, # with single section and nseg=1 only affects extracellular
name='ca',
charge=2,
initial=lambda node: 1e-3 if node.region==cyt else 0)
e = 1.60217662e-19
scale = 1e-14 / e
# rate constant is in terms of molecules/um2 ms
ca_pump = rxd.MultiCompartmentReaction(ca[cyt], ca[ecs], ca[cyt] * scale,
custom_dynamics=True,
membrane_flux=True,
membrane=mem)
t = h.Vector().record(h._ref_t)
ca_vec = h.Vector().record(soma(0.5)._ref_cai)
ca_vec2 = h.Vector().record(ca[ecs].node_by_location(5, 0, 0)._ref_value)
v = h.Vector().record(soma(0.5)._ref_v)
# nai = 10 nao = 147
# ki = 125 ko = 2.9
# In[6]:
def concentration(i, o):
return lambda nd: i if isinstance(nd, rxd.node.Node1D) else o
# In[7]:
#REGIONS------------------------------------------------------------------------------------------------------------------------
#intracellular/extracellular regions
cyt = rxd.Region(soma, name='cyt', nrn_region='i')
mem = rxd.Region(soma, name='cell_mem', geometry=rxd.membrane())
gcyt = rxd.Region(glia, name='cyt', nrn_region='i')
gmem = rxd.Region(glia, name='cell_mem', geometry=rxd.membrane())
dx = vo**(1.0 / 3.0)
ecs = rxd.Extracellular(-2 * dx,
-2 * dx,
-2 * dx,
2 * dx,
2 * dx,
2 * dx,
dx=dx)
#ecs = rxd.Extracellular(-100, -100, -100, 100, 100, 100, dx=33)
#SPECIES/PARAMETERS------------------------------------------------------------------------------------------------------------------------
#intracellular/extracellular species (Na+, K+, Cl-)
results["species"] = set(my_species)
results["name"] = sec.hname()
results["hoc_internal_name"] = sec.hoc_internal_name()
results["cell"] = sec.cell()
# all_active_reactions = [r() for r in rxd_module._all_reactions if r() is not None]
return results
if __name__ == "__main__":
from pprint import pprint
from neuron import h, rxd
soma = h.Section(name="soma")
soma.insert("hh")
soma.insert("pas")
soma.nseg = 3
iclamp = h.IClamp(soma(0.3))
gaba = h.ExpSyn(soma(0.7))
dend = h.Section(name="dend")
dend.connect(soma)
cyt = rxd.Region([dend], name="cyt", nrn_region="i")
er = rxd.Region([dend], name="er")
na = rxd.Species(cyt, name="na", charge=1)
ca = rxd.Species([cyt, er], name="ca", charge=2)
h.finitialize(-65)
pprint(psection(soma))
print("\n")
pprint(psection(dend))
import matplotlib.pyplot as plt
from neuron import h, rxd
from neuron.units import mV, ms
h.load_file('stdrun.hoc')
soma = h.Section(name='soma')
soma.diam = soma.L = 10
# the geometry of the ecs doesn't matter in the constant case
ecs = rxd.Region([soma], name='ecs', nrn_region='o', geometry=rxd.Shell(1, 2))
cyt = rxd.Region([soma], name='cyt', nrn_region='i')
mem = rxd.Region([soma], name='mem', geometry=rxd.membrane())
cao = rxd.Parameter(ecs, charge=2)
ca = rxd.Species(
[cyt],
d=1, # with single section and nseg=1 only affects extracellular
name='ca',
charge=2,
initial=lambda node: 1e-3 if node.region == cyt else 0)
e = 1.60217662e-19
scale = 1e-14 / e
# rate constant is in terms of molecules/um2 ms
ca_pump = rxd.MultiCompartmentReaction(ca[cyt],
cao[ecs],
ca[cyt] * scale,
custom_dynamics=True,
membrane_flux=True,
from neuron import h, rxd
h.load_file("stdrun.hoc")
cell = h.Section(name="cell")
r = rxd.Region([cell])
Ca = rxd.Species(r, name="ca", charge=2, initial=60e-3)
reaction_decay = rxd.Reaction(Ca, 0 * Ca, 1e-8)
tvec = h.Vector().record(h._ref_t)
cavec = h.Vector().record(Ca.nodes[0]._ref_concentration)
h.finitialize(-70)
h.continuerun(10)
if __name__ == "__main__":
from matplotlib import pyplot
pyplot.plot(tvec, cavec)
pyplot.show()
cell_1 = Cell()
cell_2 = Cell()
ecs = rxd.Extracellular(-55,
-55,
-55,
55,
55,
55,
dx=10,
volume_fraction=0.2,
tortuosity=1.6)
soma_cell_1 = rxd.Region([cell_1.soma],
nrn_region="i",
geometry=rxd.Shell(0.8, 1))
soma_cell_2 = rxd.Region([cell_2.soma],
nrn_region="i",
geometry=rxd.Shell(0.8, 1))
species_x = rxd.Species(
[ecs, soma_cell_1, soma_cell_2],
name="species_x",
d=1,
charge=1,
initial=1,
ecs_boundary_conditions=0,
)
Species_y = rxd.Species(
[soma_cell_1, ecs],
name="species_y",
name=key,
initial=kwargs[key],
atolscale=1 * nM)
def recorder(ptr):
"""return a vector that records the pointer"""
vec = h.Vector()
vec.record(ptr)
return vec
rxd.set_solve_type(dimension=3)
cell = h.Section(name="cell")
cell.diam = cell.L = 5
r = rxd.Region(h.allsec())
rxd.nthread(4)
declare_parameters(
vsP=1.1 * nM / hour,
vmP=1.0 * nM / hour,
KmP=0.2 * nM,
KIP=1.0 * nM,
ksP=0.9 / hour,
vdP=2.2 * nM / hour,
KdP=0.2 * nM,
vsT=1.0 * nM / hour,
vmT=0.7 * nM / hour,
KmT=0.2 * nM,
KIT=1.0 * nM,
ksT=0.9 / hour,
#!/usr/bin/env python
# coding: utf-8
# In[1]:
from neuron import h, rxd
from matplotlib import pyplot
h.load_file('stdrun.hoc')
# In[2]:
axon = h.Section(name='s1')
axon_terminal = h.Section(name='s')
axon.connect(axon_terminal)
axon_terminal_region = rxd.Region([axon_terminal], nrn_region='i')
synaptic_cleft = rxd.Region([axon_terminal], nrn_region='o')
terminal_membrane = rxd.Region(h.allsec(), geometry=rxd.DistributedBoundary(1))
# In[3]:
VA = rxd.Species([axon_terminal_region], name="VA", initial=10, charge=1)
T = rxd.Species([synaptic_cleft], name="T", initial=10, charge=1)
# In[4]:
# if you comment the exocytosis line below, the error will go away
exocytosis = rxd.MultiCompartmentReaction(VA[axon_terminal_region],
T[synaptic_cleft],
500,
0,
from neuron import h, rxd
from matplotlib import pyplot
h.load_file('stdrun.hoc')
from neuron.units import mM, ms
sim_time = 100
axon_terminal = h.Section(name="axon_terminal")
#synaptic_cleft = rxd.Region([axon_terminal], nrn_region='o')
axon_terminal_region = rxd.Region([axon_terminal], nrn_region='i')
ca_intra = rxd.Species(axon_terminal_region,
name="ca",
charge=2,
d=0,
initial=5e-4,
atolscale=1e-6)
F = rxd.Species(axon_terminal_region, name="F", initial=0.001)
FA = rxd.Species(axon_terminal_region, name="FA", initial=0)
kb = rxd.Parameter(axon_terminal_region, name="kb", value=1e16 / (mM**4 * ms))
ku = rxd.Parameter(axon_terminal_region, name="ku", value=0.1 / ms)
myreaction = rxd.Reaction(F + 4 * ca_intra, FA, kb,
ku) #, regions=axon_terminal_region)
tvec = h.Vector().record(h._ref_t)
Fvec = h.Vector().record(F.nodes._ref_concentration)
FAvec = h.Vector().record(FA.nodes._ref_concentration)
h.finitialize(-65)
h.continuerun(10)
from neuron import h, rxd, gui from neuron.rxd import initializer h.CVode().active(1) rxdsec = [h.Section(), h.Section()] cyt = rxd.Region(rxdsec) er = rxd.Region(rxdsec) ca = rxd.Species([cyt, er]) caextrude = rxd.Rate(ca, 1) # test for forced initialization before model fully described initializer._do_init() ip3 = rxd.Species(cyt) h.tstop = 1000 h.run()
gip3r = 12040
gserca = 0.3913
gleak = 6.020
kserca = 0.1
kip3 = 0.15
kact = 0.4
ip3rtau = 2000.0
#These parameters where missing in the tutorial so arbitrary values were chosen
#any resemblance to experimental values is purely coincidental.
fc = 0.7
fe = 0.3
caCYT_init = 0.1
cyt = rxd.Region(h.allsec(),
name='cyt',
nrn_region='i',
geometry=rxd.FractionalVolume(fc, surface_fraction=1))
er = rxd.Region(h.allsec(), name='er', geometry=rxd.FractionalVolume(fe / 2.))
cyt_er_membrane = rxd.Region(h.allsec(),
name='mem',
geometry=rxd.DistributedBoundary(1))
ca = rxd.Species([cyt, er], d=caDiff, name="ca", charge=2, initial=caCYT_init)
ip3 = rxd.Species(cyt, d=ip3Diff, name="ip3", initial=ip3_init)
ip3r_gate_state = rxd.Species(cyt_er_membrane, name="gate", initial=0.8)
h_gate = ip3r_gate_state[cyt_er_membrane]
minf = ip3[cyt] * 1000. * ca[cyt] / (ip3[cyt] + kip3) / (1000. * ca[cyt] +
kact)
def __init__(self, x, y, z, rec=False):
self.x = x
self.y = y
self.z = z
self.soma = h.Section(name="soma", cell=self)
# add 3D points to locate the neuron in the ECS
self.soma.pt3dadd(x, y, z + somaR, 2.0 * somaR)
self.soma.pt3dadd(x, y, z - somaR, 2.0 * somaR)
# Where? -- define the intracellular space and membrane
self.cyt = rxd.Region(self.soma, name="cyt", nrn_region="i")
self.mem = rxd.Region(self.soma, name="mem", geometry=rxd.membrane())
cell = [self.cyt, self.mem]
# Who? -- the relevant ions and gates
self.k = rxd.Species(cell, name="k", d=2.62, charge=1, initial=125)
self.na = rxd.Species(cell, name="na", d=1.78, charge=1, initial=10)
self.n = rxd.State(cell, name="n", initial=0.25512)
self.ki, self.nai = self.k[self.cyt], self.na[self.cyt]
# What? -- gating variables and ion currents
self.n_gate = rxd.Rate(self.n, phin * (ninf - self.n) / taun)
# Nernst potentials
ena = 1e3 * h.R * (h.celsius + 273.15) * log(
nao / self.nai) / h.FARADAY
ek = 1e3 * h.R * (h.celsius + 273.15) * log(ko / self.ki) / h.FARADAY
# Persistent Na current
self.nap_current = rxd.MultiCompartmentReaction(
self.nai,
nao,
gnap * nap_minf * nap_hinf * (v - ena),
mass_action=False,
membrane=self.mem,
membrane_flux=True,
)
# Na current
self.na_current = rxd.MultiCompartmentReaction(
self.nai,
nao,
gna * minf**3 * (1.0 - self.n) * (v - ena),
mass_action=False,
membrane=self.mem,
membrane_flux=True,
)
# K current
self.k_current = rxd.MultiCompartmentReaction(
self.ki,
ko,
gk * self.n**4 * (v - ek),
mass_action=False,
membrane=self.mem,
membrane_flux=True,
)
# K leak
self.k_leak = rxd.MultiCompartmentReaction(
self.ki,
ko,
gl * (v - ek),
mass_action=False,
membrane=self.mem,
membrane_flux=True,
)
# passive leak
self.soma.insert("pas")
self.soma(0.5).pas.g = pas_gl
self.soma(0.5).pas.e = pas_el
if rec: # record membrane potential (shown in figure 1C)
self.somaV = h.Vector()
self.somaV.record(self.soma(0.5)._ref_v, rec)
except ImportError as e:
print("[INFO ] Failed to import neuron. Quitting ...")
quit()
import numpy
from matplotlib import pyplot
import time
# needed for standard run system
h.load_file('stdrun.hoc')
dend = h.Section()
dend.nseg = 501
# WHERE the dynamics will take place
where = rxd.Region(h.allsec())
# WHO the actors are
u = rxd.Species(where, d=1, initial=0)
# HOW they act
bistable_reaction = rxd.Rate(u, -u * (1 - u) * (0.3 - u))
# initial conditions
h.finitialize()
for node in u.nodes:
if node.x < .2: node.concentration = 1
def plot_it(color='k'):
y = u.nodes.concentration
def wave_search(size, size_segments, time_period, times, au, Du):
# needed for standard run system
h.load_file('stdrun.hoc')
global dend
dend = h.Section()
dend.L = size
dend.nseg = size_segments
# WHERE the dynamics will take place
where = rxd.Region(h.allsec())
# WHO the actors are
global u
global z
global v
u = rxd.Species(where, d=Du, initial=0.5) # activator
z = rxd.Species(where, d=20, initial=0.5) # inhibitor
v = rxd.Species(where, d=0, initial=(1 / dend.L) * 30) # modulator
# HOW they act
a = au
b = -0.4
c = 0.6
d = -0.8
u0 = 0.5
z0 = 0.5
av = 5.0
kz = 0.001
bistable_reaction1 = rxd.Rate(u, (a * (u - u0) + b * (z - z0) - av *
(u - u0)**3) * (v**-2))
bistable_reaction2 = rxd.Rate(z, (c * (u - u0) + d * (z - z0)) * (v**-2))
# initial conditions
h.finitialize()
for node in u.nodes:
if node.x < .2: node.concentration = 0.6
if node.x > .8: node.concentration = 0.6
for node in z.nodes:
if node.x < .2: node.concentration = 0.6
if node.x > .8: node.concentration = 0.6
# Setting up time frame
global u_timespace
T_d = times
T = time_period
u_timespace = []
for i in np.arange(0, T_d):
h.continuerun(i * T)
u_timespace.append(u.nodes.concentration)
# activator FFT source files
u_fft_y = u.nodes.concentration
u_fft_y = u_fft_y - np.mean(u_fft_y)
u_fft_x = u.nodes.x
global u_fft_x_norm
u_fft_x_norm = dend.L * np.array(u_fft_x)
# inhibitor FFT source files
z_fft_y = z.nodes.concentration
z_fft_y = z_fft_y - np.mean(z_fft_y)
z_fft_x = z.nodes.x
z_fft_x_norm = dend.L * np.array(u_fft_x)
# activator FFT
Y1 = np.fft.fft(u_fft_y)
N = len(Y1) / 2 + 1
dt = dend.L / dend.nseg
fa = 1.0 / dt
X = np.linspace(0, fa / 2, N, endpoint=True)
# inhibitor FFT
Y2 = np.fft.fft(z_fft_y)
X2 = np.linspace(0, fa / 2, N, endpoint=True)
#
# if ((np.amax(Y1) - np.amin(Y1) < .01) or (np.amax(Y2) - np.amin(Y2) < .01)):
# return 0
if (len(X) == len(2.0 * np.abs(Y1[:N] / N))):
u_maxx = (np.argmax(2.0 * np.abs(Y1[:N] / N)))
wavelen = np.around(1 / X[u_maxx])
plot_it(time_period, times, u_timespace)
plt.savefig('results/plots/{0}_{1}_{2}_{3}_{4}_{5}.png'.format(
size, size_segments, time_period, times, au, Du))
return wavelen
from neuron import h, rxd
from neuron.units import mV, ms
h.load_file("stdrun.hoc")
soma = h.Section(name="soma")
soma.diam = soma.L = 10
# the geometry of the ecs doesn't matter in the constant case
ecs = rxd.Region([soma], name="ecs", nrn_region="o", geometry=rxd.Shell(1, 2))
cyt = rxd.Region([soma], name="cyt", nrn_region="i")
mem = rxd.Region([soma], name="mem", geometry=rxd.membrane())
cao = rxd.Parameter(ecs, charge=2)
ca = rxd.Species(
[cyt],
d=1, # with single section and nseg=1 only affects extracellular
name="ca",
charge=2,
initial=lambda node: 1e-3 if node.region == cyt else 0,
)
e = 1.60217662e-19
scale = 1e-14 / e
# rate constant is in terms of molecules/um2 ms
ca_pump = rxd.MultiCompartmentReaction(
ca[cyt],
cao[ecs],
ca[cyt] * scale,
gserca = 0.3913
gleak = 6.020
kserca = 0.1
kip3 = 0.15
kact = 0.4
ip3rtau = 2000.0
# These parameters where missing in the tutorial so arbitrary values were chosen
# any resemblance to experimental values is purely coincidental.
fc = 0.7
fe = 0.3
caCYT_init = 0.1
cyt = rxd.Region(
h.allsec(),
name="cyt",
nrn_region="i",
geometry=rxd.FractionalVolume(fc, surface_fraction=1),
)
er = rxd.Region(h.allsec(), name="er", geometry=rxd.FractionalVolume(fe / 2.0))
cyt_er_membrane = rxd.Region(h.allsec(),
name="mem",
geometry=rxd.ScalableBorder(
1, on_cell_surface=False))
ca = rxd.Species([cyt, er], d=caDiff, name="ca", charge=2, initial=caCYT_init)
ip3 = rxd.Species(cyt, d=ip3Diff, name="ip3", initial=ip3_init)
ip3r_gate_state = rxd.Species(cyt_er_membrane, name="gate", initial=0.8)
h_gate = ip3r_gate_state[cyt_er_membrane]
#ip3Diff = 0
cac_init = 1.e-4
ip3_init = 0.1
gip3r = 12040
gserca = 0.3913
gleak = 6.020
kserca = 0.1
kip3 = 0.15
kact = 0.4
ip3rtau = 2000
h.CVode().active(1)
h.cvode.atol(1e-10)
# define the regions for the rxd
cyt = rxd.Region(h.allsec(),
nrn_region='i',
geometry=rxd.FractionalVolume(fc, surface_fraction=1))
er = rxd.Region(h.allsec(), geometry=rxd.FractionalVolume(fe))
cyt_er_membrane = rxd.Region(h.allsec(), geometry=rxd.FixedPerimeter(1))
# the species and other states
ca = rxd.Species([cyt, er], d=caDiff, name='ca', charge=2, initial=cac_init)
ip3 = rxd.Species(cyt, d=ip3Diff, initial=ip3_init)
ip3r_gate_state = rxd.State(cyt_er_membrane, initial=0.8)
h_gate = ip3r_gate_state[cyt_er_membrane]
# pumps and channels between ER and Cytosol
serca = rxd.MultiCompartmentReaction(ca[cyt] > ca[er],
gserca / ((kserca /
(1000. * ca[cyt]))**2 + 1),
gserca = 0.3913
gleak = 6.020
kserca = 0.1
kip3 = 0.15
kact = 0.4
sec = h.Section(name='sec')
sec.L = 101
sec.diam = 1
# By chunking the neuron into a large number of segments
# we increase the resolution of the output at the expense of processing power.
sec.nseg = 101
# Where
cyt = rxd.Region(h.allsec(),
nrn_region='i',
geometry=rxd.FractionalVolume(0.8, surface_fraction=1))
er = rxd.Region(h.allsec(), geometry=rxd.FractionalVolume(0.2))
cyt_er_membrane = rxd.Region(h.allsec(), geometry=rxd.DistributedBoundary(1))
# What
ca = rxd.Species(regions=[cyt, er],
d=0.08,
name='ca',
charge=2,
initial=1e-4,
atolscale=1e-6)
ip3 = rxd.Species(regions=cyt, d=1.41, initial=0.1)
# What: ??
ip3r_gate_stage = rxd.State(cyt_er_membrane, initial=0.8)
