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 __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