Esempio n. 1
0
def multisplit_distrib(model):
  enter = h.startsw()
  cxlist = determine_multisplit_complexity(model)
  #start over
  destroy_model(model)
  # but we still have model.mconnections and model.rank_gconnections
  # from the round-robin distribution perspective.
  # we will need to tell the ranks  where to distribute that information

  cxlist = load_bal(cxlist, nhost) #cxlist is the list of (cx,(gid,piece)) we want on this process
  # the new distribution of mitrals and granules
  model.gids = set([item[1][0] for item in cxlist])
  model.mitral_gids = set([gid for gid in model.gids if gid < params.gid_granule_begin])
  model.granule_gids = model.gids - model.mitral_gids
  # for splitting need gid:[pieceindices]
  gid2pieces = {}
  for item in cxlist:
    gid = item[1][0]
    piece = item[1][1]
    if not gid2pieces.has_key(gid):
      gid2pieces.update({gid:[]})
    gid2pieces[gid].append(piece)

  # get the correct mconnections and gconnections
  # Round-robin ranks that presently have the connection info for the gids
  rr = {}
  for gid in model.gids:
    r = gid%nhost
    if not rr.has_key(r):
      rr.update({r:[]})
    rr[r].append(gid);
  rr = all2all(rr)
  # rr is now the ranks for where to send the synapse information
  # all the gids in rr were 'owned' by the round-robin distribution
  # may wish to revisit so that only synapse info for relevant pieces is
  # scattered.
  
  mc = model.mconnections
  gc = model.rank_gconnections
  # construct a ggid2connection dict
  ggid2connection = {}
  for r in gc:
    for ci in gc[r]:
      ggid = ci[3]
      if not ggid2connection.has_key(ggid):
        ggid2connection.update({ggid:[]})
      ggid2connection[ggid].append(ci)
  for r in rr:
    gids = rr[r]
    mgci = []
    rr[r] = mgci
    for gid in gids:
      if mc.has_key(gid):
        mgci.append(mc[gid])
      else:
        mgci.append(ggid2connection[gid])
  mgci = all2all(rr)
  # mgci contains all the connection info needed by the balanced distribution
        
  # create mitrals and granules, split and register and create synapses
  nmc.dc.mk_mitrals(model) # whole cells 
  nmc.build_granules(model)
  for gid in gid2pieces:
    if gid < params.Nmitral:
      split.splitmitral(gid, model.mitrals[gid], gid2pieces[gid])
  pc.multisplit()
  nmc.register_mitrals(model)
  nmc.register_granules(model)
  # build_synapses() ... use mgci to build explicitly
  model.mgrss = {}
  for r in mgci:
    for cil in mgci[r]:
      for ci in cil:
        if not model.mgrss.has_key(mgrs.mgrs_gid(ci[0], ci[3], ci[6])):
          rsyn = mgrs.mk_mgrs(*ci[0:7])
          if rsyn:
            model.mgrss.update({rsyn.md_gid : rsyn})
  nmultiple = int(pc.allreduce(mgrs.multiple_cnt(), 1))
  if rank == 0:
    print 'nmultiple = ', nmultiple
  detectors = h.List("AmpaNmda")
  util.elapsed('%d ampanmda for reciprocalsynapses constructed'%int(pc.allreduce(detectors.count(),1)))
  detectors = h.List("FastInhib")
  util.elapsed('%d fi for reciprocalsynapses constructed'%int(pc.allreduce(detectors.count(),1)))
  detectors = h.List("ThreshDetect")
  util.elapsed('%d ThreshDetect for reciprocalsynapses constructed'%int(pc.allreduce(detectors.count(),1)))
  if rank == 0: print 'multisplit_distrib time ', h.startsw() - enter
Esempio n. 2
0
def multisplit_distrib(model):
    enter = h.startsw()

    cxlist = determine_multisplit_complexity(model)

    #start over
    destroy_model(model)

    # fake cell to solve problem with gap junctions
    #  init_fake_cell()

    # but we still have model.mconnections and model.rank_gconnections
    # from the round-robin distribution perspective.
    # we will need to tell the ranks  where to distribute that information

    cxlist = load_bal(
        cxlist,
        nhost)  #cxlist is the list of (cx,(gid,piece)) we want on this process
    # the new distribution of mitrals and granules
    model.gids = set([item[1][0] for item in cxlist])
    model.mitral_gids = set(
        [gid for gid in model.gids if ismitral(gid) or ismtufted(gid)])
    model.granule_gids = set([gid for gid in model.gids if isgranule(gid)])
    model.blanes_gids = set([gid for gid in model.gids if isblanes(gid)])

    # for splitting need gid:[pieceindices]
    gid2pieces = {}
    for item in cxlist:
        gid = item[1][0]
        piece = item[1][1]
        if not gid2pieces.has_key(gid):
            gid2pieces[gid] = []
        gid2pieces[gid].append(piece)

    # get the correct mconnections and gconnections
    # Round-robin ranks that presently have the connection info for the gids
    rr = {}
    for gid in model.gids:
        r = gid % nhost
        if not rr.has_key(r):
            rr[r] = []
        rr[r].append(gid)
    rr = all2all(rr)
    # rr is now the ranks for where to send the synapse information
    # all the gids in rr were 'owned' by the round-robin distribution
    # may wish to revisit so that only synapse info for relevant pieces is
    # scattered.

    mc = model.mconnections
    gc = model.rank_gconnections

    # construct a ggid2connection dict
    ggid2connection = {}
    for r in gc:
        for ci in gc[r]:
            ggid = ci[3]
            if not ggid2connection.has_key(ggid):
                ggid2connection[ggid] = []
            ggid2connection[ggid].append(ci)

    for r in rr:
        gids = rr[r]
        mgci = []
        rr[r] = mgci
        for gid in gids:

            if mc.has_key(gid):
                mgci.append(mc[gid])
            elif gidfunc.isgranule(gid):
                mgci.append(ggid2connection[gid])
    mgci = all2all(rr)

    # mgci contains all the connection info needed by the balanced distribution

    # create mitrals and granules, split and register and create synapses
    nmc.dc.mk_mitrals(model)  # whole cells
    nmc.build_granules(model)
    nmc.build_blanes(model)

    for gid in gid2pieces:
        if ismitral(gid) or ismtufted(gid):
            split.splitmitral(gid, model.mitrals[gid], gid2pieces[gid])

    pc.multisplit()

    nmc.register_mitrals(model)
    nmc.register_granules(model)
    nmc.register_blanes(model)

    # build_synapses() ... use mgci to build explicitly
    model.mgrss = {}
    for r in mgci:
        for cil in mgci[r]:
            for ci in cil:
                if not model.mgrss.has_key(mgrs.mgrs_gid(ci[0], ci[3], ci[6])):
                    rsyn = mgrs.mk_mgrs(*ci[0:7])
                    if rsyn:
                        model.mgrss[rsyn.md_gid] = rsyn
    nmultiple = int(pc.allreduce(mgrs.multiple_cnt(), 1))

    # it is faster if generated again
    blanes.mk_gl2b_connections()
    # excitatory
    for mgid, blanes_gid, w in model.mt2blanes_connections:
        syn = blanes.mt2blanes(mgid, blanes_gid, w)
        model.mt2blanes[syn.gid] = syn

    blanes.mk_b2g_connections()
    # inhibitory synapses from blanes to gc
    for ggid, blanes_gid, w in model.blanes2gc_connections:
        syn = blanes.blanes2granule(blanes_gid, ggid, w)
        model.blanes2gc[syn.gid] = syn

    if rank == 0:
        print 'nmultiple = ', nmultiple
    detectors = h.List("AmpaNmda")
    util.elapsed('%d ampanmda for reciprocalsynapses constructed' %
                 int(pc.allreduce(detectors.count(), 1)))
    detectors = h.List("FastInhib")
    util.elapsed('%d fi for reciprocalsynapses constructed' %
                 int(pc.allreduce(detectors.count(), 1)))
    detectors = h.List("ThreshDetect")
    util.elapsed('%d ThreshDetect for reciprocalsynapses constructed' %
                 int(pc.allreduce(detectors.count(), 1)))
    util.elapsed('%d mt to bc' % int(pc.allreduce(len(model.mt2blanes), 1)))
    util.elapsed('%d bc to gc' % int(pc.allreduce(len(model.blanes2gc), 1)))

    if rank == 0: print 'multisplit_distrib time ', h.startsw() - enter
    return None


def multiple_cnt():
    cnt = 0
    for mgrs in getmodel().mgrss.values():
        if mgrs.slot > 0:
            if mgrs.gd: cnt += 1
            if mgrs.md: cnt += 1
    return cnt


if __name__ == "__main__":
    import mkmitral, split
    h.load_file("granule.hoc")

    m = mkmitral.mkmitral(1)
    pieces = split.secden_indices_connected_to_soma(m)
    pieces.append(-1)
    split.splitmitral(1, m, pieces)
    pc.set_gid2node(1, pc.id())
    pc.cell(1, h.NetCon(m.soma(.5)._ref_v, None, sec=m.soma))

    g = h.Granule()
    pc.set_gid2node(10000, pc.id())
    pc.cell(10000, h.NetCon(g.soma(.5)._ref_v, None, sec=g.soma))

    mgrs = MGRS(1, 0, .8, 10000, 0, .1)
    mgrs.pr()
    mgrs2 = MGRS(1, 0, .8, 10000, 0, .1)
Esempio n. 4
0
  return None
    
def multiple_cnt():
  cnt = 0;
  for mgrs in getmodel().mgrss.values():
    if mgrs.slot > 0:
      if mgrs.gd: cnt += 1
      if mgrs.md: cnt += 1
  return cnt

if __name__ == "__main__":
  import mkmitral, split
  h.load_file("granule.hoc")

  m = mkmitral.mkmitral(1)
  pieces = split.secden_indices_connected_to_soma(m)
  pieces.append(-1)
  split.splitmitral(1, m, pieces)
  pc.set_gid2node(1, pc.id())
  pc.cell(1, h.NetCon(m.soma(.5)._ref_v, None, sec=m.soma))

  g = h.Granule()
  pc.set_gid2node(10000, pc.id())
  pc.cell(10000, h.NetCon(g.soma(.5)._ref_v, None, sec=g.soma))

  mgrs = MGRS(1, 0, .8, 10000, 0, .1)
  mgrs.pr()
  mgrs2 = MGRS(1, 0, .8, 10000, 0, .1)


Esempio n. 5
0
def multisplit_distrib(model):
    enter = h.startsw()
    cxlist = determine_multisplit_complexity(model)
    #start over
    destroy_model(model)
    # but we still have model.mconnections and model.rank_gconnections
    # from the round-robin distribution perspective.
    # we will need to tell the ranks  where to distribute that information

    cxlist = load_bal(
        cxlist,
        nhost)  #cxlist is the list of (cx,(gid,piece)) we want on this process
    # the new distribution of mitrals and granules
    model.gids = set([item[1][0] for item in cxlist])
    model.mitral_gids = set(
        [gid for gid in model.gids if gid < params.gid_granule_begin])
    model.granule_gids = model.gids - model.mitral_gids
    # for splitting need gid:[pieceindices]
    gid2pieces = {}
    for item in cxlist:
        gid = item[1][0]
        piece = item[1][1]
        if not gid2pieces.has_key(gid):
            gid2pieces.update({gid: []})
        gid2pieces[gid].append(piece)

    # get the correct mconnections and gconnections
    # Round-robin ranks that presently have the connection info for the gids
    rr = {}
    for gid in model.gids:
        r = gid % nhost
        if not rr.has_key(r):
            rr.update({r: []})
        rr[r].append(gid)
    rr = all2all(rr)
    # rr is now the ranks for where to send the synapse information
    # all the gids in rr were 'owned' by the round-robin distribution
    # may wish to revisit so that only synapse info for relevant pieces is
    # scattered.

    mc = model.mconnections
    gc = model.rank_gconnections
    # construct a ggid2connection dict
    ggid2connection = {}
    for r in gc:
        for ci in gc[r]:
            ggid = ci[3]
            if not ggid2connection.has_key(ggid):
                ggid2connection.update({ggid: []})
            ggid2connection[ggid].append(ci)
    for r in rr:
        gids = rr[r]
        mgci = []
        rr[r] = mgci
        for gid in gids:
            if mc.has_key(gid):
                mgci.append(mc[gid])
            else:
                mgci.append(ggid2connection[gid])
    mgci = all2all(rr)
    # mgci contains all the connection info needed by the balanced distribution

    # create mitrals and granules, split and register and create synapses
    nmc.dc.mk_mitrals(model)  # whole cells
    nmc.build_granules(model)
    for gid in gid2pieces:
        if gid < params.Nmitral:
            split.splitmitral(gid, model.mitrals[gid], gid2pieces[gid])
    pc.multisplit()
    nmc.register_mitrals(model)
    nmc.register_granules(model)
    # build_synapses() ... use mgci to build explicitly
    model.mgrss = {}
    for r in mgci:
        for cil in mgci[r]:
            for ci in cil:
                if not model.mgrss.has_key(mgrs.mgrs_gid(ci[0], ci[3], ci[6])):
                    rsyn = mgrs.mk_mgrs(*ci[0:7])
                    if rsyn:
                        model.mgrss.update({rsyn.md_gid: rsyn})
    nmultiple = int(pc.allreduce(mgrs.multiple_cnt(), 1))
    if rank == 0:
        print 'nmultiple = ', nmultiple
    detectors = h.List("AmpaNmda")
    util.elapsed('%d ampanmda for reciprocalsynapses constructed' %
                 int(pc.allreduce(detectors.count(), 1)))
    detectors = h.List("FastInhib")
    util.elapsed('%d fi for reciprocalsynapses constructed' %
                 int(pc.allreduce(detectors.count(), 1)))
    detectors = h.List("ThreshDetect")
    util.elapsed('%d ThreshDetect for reciprocalsynapses constructed' %
                 int(pc.allreduce(detectors.count(), 1)))
    if rank == 0: print 'multisplit_distrib time ', h.startsw() - enter