def select(self, gid):
from params import granule_priden2_len as l, granule_diam as diam
pos, u, proj = gpo(gid)
r = params.ranstream(gid, 0)
r.uniform(-params.grid_dim * .5, params.grid_dim * .5)
pos2 = []
for i in range(3):
d = r.repick()
pos[i] += d # perturb
pos2.append(proj[i] + u[i] * l + d)
# draw priden actor
src = tvtk.LineSource(point1=tuple(pos), point2=tuple(pos2))
mapper = tvtk.PolyDataMapper(input=src.output)
priden_actor = tvtk.Actor(mapper=mapper)
priden_actor.property.color = self.sel_color
if not self.priden_visible:
priden_actor.property.opacity = 0.
# draw soma actor
src = tvtk.SphereSource(center=tuple(pos), radius=diam * .5 * self.sel_factor)
mapper = tvtk.PolyDataMapper(input=src.output)
soma_actor = tvtk.Actor(mapper=mapper)
soma_actor.property.color = self.sel_color
fig.scene.add_actor(priden_actor)
fig.scene.add_actor(soma_actor)
self.sel_actor.append((priden_actor, soma_actor))
def __init__(self, odorname, start, dur, conc):
''' Specifies the odor for an OdorStim. Note that the OdorStim is
activated with setup which can only be called after the mitrals
dict exists (usually from determine_connections.py).
'''
self.odorname = odorname
self.start = start
self.dur = dur
self.conc = conc
self.verbose = True
self.next_invl = 0
if params.glomerular_layer == 0:
self.w_odor = odors.odors[odorname].getORNs(conc) # odor vector
elif params.glomerular_layer == 1:
self.w_odor = odors.odors[odorname].afterPG_1(conc) # odor vector
elif params.glomerular_layer == 2:
self.w_odor = odors.odors[odorname].afterPG_2(conc) # odor vector
# set up the netcons to simulate the ORNs
self.netcons = {}
self.rng_act = params.ranstream(0, params.stream_orn_act)
self.rng_act.uniform(params.sniff_invl_min, params.sniff_invl_max)
model = getmodel()
for gid, cell in model.mitrals.items():
if h.section_exists("tuftden", 0, cell):
for i in range(int(cell.ornsyn.count())):
self.netcons[(gid, i)] = h.NetCon(None, cell.ornsyn.o(i))
self.fih = h.FInitializeHandler(0, (self.init_ev, (start,)))
def drawgranules(gids, gcolor, *arg):
from params import granule_diam as diam
x = []
y = []
z = []
if self.colors:
s = []
if self.colors and not not_in_weights:
gids = gids.intersection(self.colors.keys())
for gid in gids:
if self.projected:
if scale_mode == 'scalar':
u, p = gpo(gid)[-2:]
if self.colors:
try:
s.append(self.colors[gid] / 20 * 20 * 0.9 + 10)
except KeyError:
continue
dep = -(100 - s[-1]) / 20 * params.grid_dim # depth from colors
p = [ dep * u[0] + p[0], dep * u[1] + p[1], dep * u[2] + p[2]]
diam = 0.42
elif scale_mode == 'none':
p = gpo(gid)[2]
else:
p = gpo(gid)[0]
if self.colors and not (self.projected and scale_mode == 'scalar'):
try:
color = self.colors[gid]
except KeyError:
color = 0
if gthreshold:
if color >= gthreshold:
s.append(1)
else:
s.append(0)
else:
s.append(color)
r = params.ranstream(gid, 0)
r.uniform(-params.grid_dim * .5, params.grid_dim * .5)
x.append(p[0] + r.repick())
y.append(p[1] + r.repick())
z.append(p[2] + r.repick())
#print 'drawn mitral:',len(x)
if self.colors:
if self.vmin != None and self.vmax != None:
return points3d(x, y, z, s, scale_factor=diam, vmin=self.vmin, vmax=self.vmax, scale_mode=scale_mode, colormap=gpalette)
return points3d(x, y, z, s, scale_factor=diam, scale_mode=scale_mode,colormap=gpalette)
return points3d(x, y, z, scale_factor=diam, color=gcolor,colormap=gpalette)
def mkgranule(gid):
def randomize_diam(r):
from math import log
rn = r.normal(params.granule_rn_mean, params.granule_rn_std**2)
while rn < (params.granule_rn_mean - 3*params.granule_rn_std) or \
rn > (params.granule_rn_mean + 3*params.granule_rn_std):
rn = r.repick()
flag = g.setRN(rn)
while not flag:
rn = r.repick()
flag = g.setRN(rn)
g.memb()
g = h.Granule()
r = params.ranstream(gid, params.stream_granule_diam)
randomize_diam(r)
if gcissup(gid):
g.sup_deep_flag(1)
else:
g.sup_deep_flag(0)
return g
def gen_soma_pos(cfg, rng_sm, glompos, gid):
upbnd = Ellipsoid(params.bulbCenter, cfg.somaAxisUp)
dwbnd = Ellipsoid(params.bulbCenter, cfg.somaAxisDw)
if ismitral(gid):
import mcgrow
ncell_per_glom = params.Nmitral_per_glom
else:
import mtgrow
ncell_per_glom = params.Nmtufted_per_glom
glpj_up = upbnd.project(glompos)
somapos = glpj_up
base_phi, base_theta = upbnd.toElliptical(glompos)[1:]
base_phi = pi / 2 - base_phi
base_theta = pi / 2 - base_theta
radius = rng_sm.uniform(cfg.GLOM_DIST, cfg.GLOM_DIST)
phi = (gid%ncell_per_glom)*2*pi/ncell_per_glom + \
params.ranstream(mgid2glom(gid), stream_soma).uniform(0, 2*pi)
theta = pi / 2
absphi, abstheta = convert_direction(phi, theta, base_phi, base_theta)
p = Spherical.xyz(radius, absphi, abstheta, glpj_up)
p_up = upbnd.project(p)
p_dw = dwbnd.project(p)
x = rng_sm.uniform(0, 1)
somapos = [
x * (p_up[0] - p_dw[0]) + p_dw[0], x * (p_up[1] - p_dw[1]) + p_dw[1],
x * (p_up[2] - p_dw[2]) + p_dw[2]
]
return somapos #, base_phi, base_theta
def show(self):
if self.actor1:
self.actor1.remove()
from granules import granule_position_orientation as gpo
from params import granule_diam as diam
x = []
y = []
z = []
s = []
for gid in self.gran:
p = gpo(gid)[0]
s.append(self.colors[gid])
r = params.ranstream(gid, 0)
r.uniform(-params.grid_dim * .5, params.grid_dim * .5)
x.append(p[0] + r.repick())
y.append(p[1] + r.repick())
z.append(p[2] + r.repick())
self.actor1 = points3d(x,
y,
z,
s,
scale_factor=diam,
scale_mode='none',
vmin=0,
vmax=100)
def mk_mconnection_info(model):
r = {}
GL_to_GCs = {}
to_conn = []
cilist = []
# initialization
for gid in model.mitrals.keys(): #+model.mtufted.keys():
r[gid] = params.ranstream(gid, params.stream_latdendconnect) # init rng
glomid = mgid2glom(gid) #params.cellid2glomid(gid) # init GCs connected to GL
if glomid not in GL_to_GCs:
GL_to_GCs[glomid] = set()
# lateral dendrites positions
for cellid, cell in model.mitrals.items(): #+model.mtufted.values():
to_conn += latconn.lateral_connections(cellid, cell)
ntot_conn = pc.allreduce(len(to_conn),1) # all connections
# connect to granule cells
it = 0
while pc.allreduce(len(to_conn), 2) > 0:
connect2gc(to_conn, r, GL_to_GCs)
# good connect vs to redo and update GL_to_GCs
_cilist, to_conn1 = detect_intraglom_conn(to_conn, GL_to_GCs)
#_cilist, to_conn2 = detect_over_connected_gc(_cilist)
#to_conn = to_conn1 + to_conn2
to_conn = to_conn1
cilist += _cilist
it += 1
ntot_conn = pc.allreduce(len(cilist),1)/ntot_conn
# fill the model data
MCconn = 0
mTCconn = 0
for ci in cilist:
#if params.gid_is_mitral(ci[0]):
conns = model.mconnections
MCconn += 1
#elif params.gid_is_mtufted(ci[0]):
# conns = model.mt_connections
# mTCconn += 1
if ci[0] not in conns:
conns[ci[0]] = []
conns[ci[0]].append(ci)
util.elapsed('Mitral %d and mTufted %d cells connection infos. generated (it=%d,err=%.3g%%)'%(int(pc.allreduce(MCconn,1)),\
int(pc.allreduce(mTCconn,1)),\
int(pc.allreduce(it,2)),\
(1-ntot_conn)*100))
def __init__(self, od, start, dur, rel_conc=1.):
''' Specifies the odor for an OdorStim. Note that the OdorStim is
activated with setup which can only be called after the mitrals
dict exists (usually from determine_connections.py).
'''
# set odor weights
if type(od) == str:
self.odor = odors[od]
else:
self.odor = od
self.rel_conc = rel_conc
self.verbose = True
self.tstop = start + dur
mitrals = getmodel().mitrals
self.netcons = {}
self.rng_act = params.ranstream(0, params.stream_ods_act)
self.rng_act.uniform(params.ods_freql, params.ods_freqh)
for gid in mitrals:
m = mitrals[gid]
# in case of multisplit
if not h.section_exists("tuftden", 0, m):
continue
iglom = mgid2glom(gid)
w = self.odor.glom_weights[iglom]
for i in range(int(m.synls.count())):
nc = h.NetCon(None, m.synls.o(i))
# rng for weights
rw = params.ranstream(gid, params.stream_ods_w + i)
nc.weight[0] = w * self.rel_conc * rw.uniform(
params.ods_wl, params.ods_wh)
self.netcons.update({(gid, i): (nc, rw)})
self.fih = h.FInitializeHandler(0, (self.init_ev, (start, )))
def __init__(self, od, start, dur, rel_conc=1.0):
""" Specifies the odor for an OdorStim. Note that the OdorStim is
activated with setup which can only be called after the mitrals
dict exists (usually from determine_connections.py).
"""
# set odor weights
if type(od) == str:
self.odor = odors[od]
else:
self.odor = od
self.rel_conc = rel_conc
self.verbose = True
self.tstop = start + dur
mitrals = getmodel().mitrals
self.netcons = {}
self.rng_act = params.ranstream(0, params.stream_ods_act)
self.rng_act.uniform(params.ods_freql, params.ods_freqh)
for gid in mitrals:
m = mitrals[gid]
# in case of multisplit
if not h.section_exists("tuftden", 0, m):
continue
iglom = mgid2glom(gid)
w = self.odor.glom_weights[iglom]
for i in range(int(m.synls.count())):
nc = h.NetCon(None, m.synls.o(i))
# rng for weights
rw = params.ranstream(gid, params.stream_ods_w + i)
nc.weight[0] = w * self.rel_conc * rw.uniform(params.ods_wl, params.ods_wh)
self.netcons.update({(gid, i): (nc, rw)})
self.fih = h.FInitializeHandler(0, (self.init_ev, (start,)))
def show(self):
if self.actor1:
self.actor1.remove()
from granules import granule_position_orientation as gpo
from params import granule_diam as diam
x = []
y = []
z = []
s = []
for gid in self.gran:
p = gpo(gid)[0]
s.append(self.colors[gid])
r = params.ranstream(gid, 0)
r.uniform(-params.grid_dim * .5, params.grid_dim * .5)
x.append(p[0] + r.repick())
y.append(p[1] + r.repick())
z.append(p[2] + r.repick())
self.actor1 = points3d(x, y, z, s, scale_factor=diam, scale_mode='none', vmin=0, vmax=100)
def __init__(self, gid, spine):
self.rng = params.ranstream(gid, params.stream_dsac)
self.rng.negexp(1)
self.spine = spine
self.gaba = h.FastInhib(self.spine.neck(0.5))
self.gaba.training = 0
self.gaba.gmax = params.dsac_gmax
self.stim = h.NetStim(0.5)
self.stim.start = 0
self.stim.number = 1e+9
self.stim.noise = 1.0
self.stim.interval = 1.0 / (17.0 / 1000)
self.stim.noiseFromRandom(self.rng)
self.nc = h.NetCon(self.stim, self.gaba)
self.nc.delay = 1
self.nc.weight[0] = 1
self.nc.weight[1] = 50
def init():
from math import exp
# it fix the granule cells type
up = misc.Ellipsoid(params.bulbCenter, params.granAxisUp)
dw = misc.Ellipsoid(params.bulbCenter, params.granAxisDw)
for p, ggid in granules.pos2ggid.items():
rng_type = params.ranstream(ggid, params.stream_granule_type)
if rng_type.uniform(0, 1) < params.gc_type3_prob:
# if False:
gtype = 1
else:
prob = (dw.normalRadius(p) - 1) / (dw.normalRadius(up.project(p)) -
1)
#if rng_type.uniform(0, 1) > prob:
if prob <= 0.5:
# if not gc_is_superficial(ggid):
gtype = 0 # right type for mitral only
else:
gtype = 2 # right type for mid. tufted only
pos2type.update({p: gtype})
# initialize the voxel grid to connect segment to granule cells
d = params.gran_voxel
ndepth = int(round(params.gran_connect_radius / d))
old_moves = set([(0, 0, 0)])
for idepth in range(ndepth):
new_moves = set()
for m in old_moves:
for dx in range(-d, d + 1, d):
for dy in range(-d, d + 1, d):
for dz in range(-d, d + 1, d):
p = (m[0] + dx, m[1] + dy, m[2] + dz)
new_moves.add(p)
_gran_voxel.add(p)
old_moves = new_moves
def __init__(self, mgid, blanesgid, w=None):
self.mgid = mgid
self.blanes_gid = blanesgid
self.blanes_cell = getmodel().blanes[blanesgid]
rng = params.ranstream(blanesgid,
params.stream_blanes + gidfunc.mgid2glom(mgid))
ibranch = int(rng.discunif(0, self.blanes_cell.nden0 - 1))
idend = int(rng.discunif(0, self.blanes_cell.nden1 - 1))
x = rng.uniform(0, 1)
self.syn = h.Exp2Syn(self.blanes_cell.dend[ibranch][idend](x))
self.syn.e = 0
self.syn.tau1 = 1
self.syn.tau2 = 250
self.nc = pc.gid_connect(mgid, self.syn)
if w:
self.nc.weight[0] = w
else:
self.nc.weight[0] = params.mt2bc_exc_gmax
self.nc.delay = 1
self.gid = gidfunc.mbs_gid(mgid, blanesgid)
def __init__(self, blanesgid, ggid, w=1):
self.ggid = ggid
self.blanes_gid = blanesgid
self.granule_cell = getmodel().granules[ggid]
rng = params.ranstream(blanesgid,
params.stream_blanes + params.Nmtufted + ggid)
L = self.granule_cell.priden2[0].L * rng.uniform(0, 1)
if L <= self.granule_cell.priden2[0].L:
sec = self.granule_cell.priden2[0]
x = L / self.granule_cell.priden2[0].L
self.syn = h.Exp2Syn(sec(x))
self.syn.e = -80
self.syn.tau1 = 1
self.syn.tau2 = 15
self.nc = pc.gid_connect(self.blanes_gid, self.syn)
self.nc.weight[0] = w * params.bc2gc_inh_gmax
self.nc.delay = 1
self.gid = gidfunc.bc2gc_gid(blanesgid, ggid)
def init():
data = {}
for uid in range(nhost):
data.update({ uid:(getmodel().mitrals.keys()) })
data = a2a.all2all(data)
mgids = []
for _mgids in data.values(): mgids += _mgids
mgids = set(mgids)
# initialize source
for mgid in getmodel().mitrals.keys():
mpriden = split.mpriden(mgid)
if not mpriden:
continue
rgj = params.ranstream(mgid, params.stream_gap_junction)
mpriden.push()
secref = h.SectionRef()
h.pop_section()
h.mk_gj_src(pc, mgid, secref)
glomid = mgid2glom(mgid)
sistergids = []
# no longer all to all, only a chain
if not (ismtufted(mgid) and (mgid - nmi) % nmt == (nmt - 1)):
if ismitral(mgid) and mgid % nmxg == (nmxg - 1):
sistergids += [glomid * nmt + nmi]
else:
sistergids += [mgid + 1]
if not (ismitral(mgid) and mgid % nmxg == 0):
if ismtufted(mgid) and (mgid - nmi) % nmt == 0:
sistergids += [(glomid + 1) * nmxg - 1]
else:
sistergids += [mgid - 1]
sistergids = mgids.intersection(range(glomid * nmxg, glomid * nmxg + nmxg) + range(glomid * nmt + nmi, glomid * nmt + nmt + nmi)).difference([ mgid ])
for sistermgid in sistergids:
gap = h.Gap(mpriden(0.99))
if ismitral(mgid) and ismitral(sistermgid):
gap.g = rgj.uniform(gj_min_g1, gj_max_g1)
elif ismtufted(mgid) and ismtufted(sistermgid):
gap.g = rgj.uniform(gj_min_g3, gj_max_g3)
else:
gap.g = rgj.uniform(gj_min_g2, gj_max_g2)
getmodel().gj[(mgid, sistermgid)] = gap
pc.barrier()
# initialize targets
for key, gap in getmodel().gj.items():
mgid, sistermgid = key
pc.target_var(gap, gap._ref_vgap, sistermgid)
util.elapsed('Gap junctions built')
def __init__(self, odorname, start, dur, conc):
''' Specifies the odor for an OdorStim. Note that the OdorStim is
activated with setup which can only be called after the mitrals
dict exists (usually from determine_connections.py).
'''
if rank == 0:
print("OdorStim %s start=%g dur=%g conc=%g" %
(odorname, start, dur, conc))
self.odorname = odorname
self.start = start
self.dur = dur
self.conc = conc
self.verbose = True
self.next_invl = 0
if params.glomerular_layer == 0:
self.w_odor = odors.odors[odorname].getORNs(conc) # odor vector
elif params.glomerular_layer == 1:
self.w_odor = odors.odors[odorname].afterPG_1(conc) # odor vector
elif params.glomerular_layer == 2:
self.w_odor = odors.odors[odorname].afterPG_2(conc) # odor vector
# set up the netcons to stimulate the ORNs
self.netcons = {}
if not use_OdorStimHelper:
self.rng_act = params.ranstream(0, params.stream_orn_act)
self.rng_act.uniform(params.sniff_invl_min, params.sniff_invl_max)
model = getmodel()
self.src = None
if use_OdorStimHelper or allow_prcellstate_debug:
src = h.OdorStimHelper()
src.start = start
src.dur = dur
src.invl_min = params.sniff_invl_min
src.invl_max = params.sniff_invl_max
src.noiseFromRandom123(0, params.stream_orn_act, 0)
self.src = src
for gid, cell in model.mitrals.items():
peak = self.w_odor[mgid2glom(gid)]
if gidfunc.ismitral(gid):
g_e_baseline = params.orn_g_mc_baseline
std_e = params.orn_g_mc_std
g_e_max = params.orn_g_mc_max
else:
g_e_baseline = params.orn_g_mt_baseline
std_e = params.orn_g_mt_std
g_e_max = params.orn_g_mt_max
if h.section_exists("tuftden", 0, cell):
for i in range(int(cell.ornsyn.count())):
nc = h.NetCon(self.src, cell.ornsyn.o(i))
self.netcons[(gid, i)] = nc
# NetCon weights are peak, base, gemax, stde
nc.weight[0] = peak
nc.weight[1] = g_e_baseline
nc.weight[2] = g_e_max
nc.weight[3] = std_e
nc.delay = 0.0
if use_OdorStimHelper:
pass
else:
self.fih = h.FInitializeHandler(0, (self.init_ev, (start, )))
def initGrow(cfg, mid):
nrn = Neuron()
extrLs = []
r = [
ranstream(mid, stream_dend), \
ranstream(mid, stream_apic), \
ranstream(mid, stream_tuft) ]
glomPos = glomCoord[mgid2glom(mid)]
somaPos = mk_soma(cfg, ranstream(mid, stream_soma), mid,
nrn) # initialize the
mk_apic(cfg, somaPos, nrn)
somaLvl = Ellipsoid(bulbCenter, cfg.somaAxisDw)
phi_base, theta_base = somaLvl.toElliptical(somaPos)[1:]
theta_base = pi / 2 - theta_base
phi_base = pi / 2 - phi_base
extr = Extreme()
extr.cfg = cfg
extr.r = r
extr.nrn = nrn
extr.glomPos = glomPos
extr.sec = nrn.apic[0]
extr.phi, extr.theta = Spherical.to(glomPos, somaPos)[1:]
extr.phi, extr.theta = convert_direction(extr.phi, extr.theta, phi_base,
theta_base, True)
extr.extr_type = Extreme.APICAL
extr.limit = cfg.APIC_LEN_MAX
extr.basePhi = phi_base
extr.baseTheta = theta_base
extrLs.append(extr)
rd = r[Extreme.DENDRITE]
#if ismitral(mid):
DENDRITES = int(
rd.negexp(cfg.N_MEAN_DEND - cfg.N_MIN_DEND)) + cfg.N_MIN_DEND
while DENDRITES > cfg.N_MAX_DEND:
DENDRITES = int(rd.repick()) + cfg.N_MIN_DEND
#else:
#DENDRITES = int(rd.negexp(cfg.N_MEAN_DEND))
#while DENDRITES < cfg.N_MIN_DEND or DENDRITES > cfg.N_MAX_DEND:
# DENDRITES = int(rd.repick())
if ismitral(mid):
ncell_per_glom = params.Nmitral_per_glom
cell_index = (mid - params.gid_mitral_begin) % ncell_per_glom
elif ismtufted(mid):
ncell_per_glom = params.Nmtufted_per_glom
cell_index = (mid - params.gid_mtufted_begin) % ncell_per_glom
phi_phase = 2 * pi / cfg.N_MEAN_DEND / ncell_per_glom * cell_index
for i in range(DENDRITES):
sec, extr = mkDendrite(cfg, r, nrn, 0, nrn.soma[0])
sec.points = [
somaPos + [rd.uniform(cfg.diam_min_dend, cfg.diam_min_dend)]
]
nrn.dend.append(sec)
extr.phi = 2 * pi / DENDRITES * i + phi_phase
extr.theta = cfg.init_theta
extr.basePhi = phi_base
extr.baseTheta = theta_base
extrLs.append(extr)
return nrn, extrLs
