Source code for blenderneuron.nrn.neuronnode

from neuron import h
from blenderneuron.commnode import CommNode
from blenderneuron.nrn.neuronrootgroup import NeuronRootGroup
from collections import OrderedDict
import re, math
from hashlib import sha1

    import xmlrpclib
    import xmlrpc.client as xmlrpclib

[docs]class NeuronNode(CommNode): # Match Cell[n].section[y] pattern e.g. MC1[0].soma section_rx = re.compile('(.+?])\.?(.*)') def __init__(self, server_end=None, *args, **kwargs): self.roots = None self.section_index = None self.synapse_sets = {} # 'set_name': [(netcon, syn, head, neck)] self.parallel_ctx = None self.mpimap = None self.mpirank = None def init(): h.load_file('stdrun.hoc') self.server.register_function(self.get_roots) self.server.register_function(self.set_sim_params) self.server.register_function(self.get_sim_params) self.server.register_function(self.initialize_groups) self.server.register_function(self.update_groups) self.server.register_function(self.create_synapses) if server_end is None: server_end = "NEURON" super(NeuronNode, self).__init__(server_end, on_server_setup=init, *args, **kwargs)
[docs] def init_mpi(self, parallel_ctx, mpimap): self.parallel_ctx = parallel_ctx self.mpimap = mpimap self.mpirank = self.current_gid = 0
[docs] def get_roots(self): self.roots = h.SectionList() self.roots.allroots() self.roots = list(self.roots) self.update_section_index() return [ { "index": i, "name": } for i, sec in enumerate(self.roots) ]
[docs] def update_section_index(self): all_sec = h.allsec() self.section_index = { sec for sec in all_sec}
[docs] def initialize_groups(self, blender_groups, send_back=True): self.groups = OrderedDict() if self.section_index is None: self.update_section_index() for blender_group in blender_groups: name = blender_group["name"] nrn_group = NeuronRootGroup() nrn_group.from_skeletal_blender_group(blender_group, node=self) self.groups[name] = nrn_group if send_back: return self.get_group_dicts()
[docs] def get_group_dicts(self, compressed=True): if any([g.record_activity for g in self.groups.values()]): result = [group.to_dict(include_activity=group.record_activity, include_root_children=True, include_coords_and_radii=True) for group in self.groups.values()] if compressed: return self.compress(result) else: return result
[docs] def update_groups(self, blender_groups): for blender_group in blender_groups: name = blender_group["name"] if name not in self.groups: self.initialize_groups(blender_groups, send_back=False) nrn_group = self.groups[name] nrn_group.from_updated_blender_group(blender_group)
[docs] def set_sim_params(self, params): h.tstop = params["tstop"] h.dt = params["dt"] h.cvode.atol(params["atol"]) h.celsius = params["celsius"] h.cvode_active(int(params["cvode"]))
[docs] def get_sim_params(self): params = {} params["t"] = h.t params["tstop"] = h.tstop params["dt"] = h.dt params["atol"] = h.cvode.atol() params["celsius"] = h.celsius params["cvode"] = str(h.cvode_active()) return params
[docs] @staticmethod def clamp_section_x(x_in): """ When placing synapses, avoid using 0 and 1 section locations, esp. if extracellular potentials will be computed. See the warning comment in: mechanisms/mech.html?highlight=i_membrane#mech-extracellular :param x_in: 0-1 section location :return: section location constrained to 0.001-0.999 """ return min(max(x_in, 0.001), 0.999)
[docs] def rank_section_name(self, single_rank_name): if self.mpimap is not None: cell_name, section_name = self.section_rx.match(single_rank_name).groups() entry = self.mpimap[cell_name] # If cell is not on this rank, return None if self.mpirank != entry['rank']: return None # Otherwise get its multi-rank section name mpi_cell_name = entry['name'] mpi_name = mpi_cell_name if section_name != '': mpi_name += '.' + section_name return mpi_name else: return single_rank_name
[docs] def segment_gid(self, sec_name, seg_id, has_spine): """ One one gid can be associated with a segment. If more than one gid is assigned to a seg, only the last gid will send events to the post- synapse. However, if the segment index can be computed from section.x location, locations that refer to the same segment e.g. section(0.49) and section(0.51) when nseg=3, can be identified. This method generates a unique gid for each segment based on the section name and segment index. Where section(0) -> seg_id=0 and section(1) -> seg_id=nseg-1 If a spine was added, its assumed that the pre-syn location is at the head of the spine. :param sec_name: :param seg_id: :param has_spine: :return: """ # Generate a segment address e.g. MyCell[2].soma[1] from soma(0.5) with nseg=3 seg_address = sec_name + ('[%s]' % seg_id) if has_spine: seg_address += '.spine_head' # Compute the SHA1 9-digit hash of the address # 9 digits is the largest safe number that is accepted by pc.set_gid2node # In practice, this will be unique for each segment # And same on each machine and version of python (unlike hash()) gid = int(sha1(seg_address.encode('utf-8')).hexdigest(), 16) % (10 ** 9) return gid
[docs] def create_synapses(self, syn_set): set_name = syn_set['name'] syn_entries = syn_set['entries'] synapses = self.synapse_sets[set_name] = [] for entry in syn_entries: rank_source_section = self.rank_section_name(entry['source_section']) rank_dest_section = self.rank_section_name(entry['dest_section']) source_on_rank = rank_source_section is not None dest_on_rank = rank_dest_section is not None if dest_on_rank: dest_sec = self.section_index[rank_dest_section] dest_x = self.clamp_section_x(entry['dest_x']) else: dest_sec = None dest_x = 0 if source_on_rank: source_sec = self.section_index[rank_source_section] source_x = self.clamp_section_x(entry['source_x']) else: source_sec = None source_x = 0 # At first, assume no spines neck = None head = None # Unless indicated otherwise if source_on_rank and entry['create_spine']: prefix = set_name+"_"+entry['prefix']+"["+str(len(synapses))+"]" # Create the spine head head = h.Section(name=prefix + ".head") # basic passive params head.insert('pas') # Add the 3D coords self.add_spine_pt3d(head, entry['head_start'], entry['head_diameter']) self.add_spine_pt3d(head, entry['head_end'], entry['head_diameter']) # Create the head (if there is enough room) if entry['neck_start'] is not None: neck = h.Section(name=prefix+".neck") neck.insert('pas') self.add_spine_pt3d(neck, entry['neck_start'], entry['neck_diameter']) self.add_spine_pt3d(neck, entry['neck_end'], entry['neck_diameter']) # Connect the spine together to the source section neck.connect(source_sec(source_x), 0) head.connect(neck) else: # If there is no neck, connect the head to section directly head.connect(source_sec(source_x), 0) # Point process should now be placed on the spine head source_sec = head source_x = 0.5 source_gid = self.segment_gid(entry['source_section'], entry['source_seg_i'], entry['create_spine']) netcon, syn = self.create_netcon_syn( entry['dest_syn'], dest_sec, dest_x, entry['dest_syn_params'], source_sec, source_x, entry['threshold'], entry['delay'], entry['weight'], source_on_rank, dest_on_rank, source_gid ) # If reciprocal, create a NetCon+Syn going in the opposite direction if entry['is_reciprocal']: dest_gid = self.segment_gid(entry['dest_section'], entry['dest_seg_i'], False) netcon_recip, syn_recip = self.create_netcon_syn( entry['source_syn'], source_sec, source_x, entry['source_syn_params'], dest_sec, dest_x, entry['threshold'], entry['delay'], entry['weight'], dest_on_rank, source_on_rank, dest_gid ) else: netcon_recip, syn_recip = None, None # Keep references to the synapse parts synapses.append((netcon, syn, neck, head, netcon_recip, syn_recip))
[docs] def create_netcon_syn(self, syn_class_name, syn_sec, syn_sec_x, syn_params, source_sec, source_x, threshold, delay, weight, source_on_rank, syn_on_rank, source_gid): netcon, syn = None, None if syn_on_rank: # Create synapse point process # e.g. syn = h.ExpSyn(dend(0.5)) syn_class = getattr(h, syn_class_name) syn = syn_class(syn_sec(syn_sec_x)) if syn_params != '': syn_params = eval(syn_params) for key in syn_params.keys(): setattr(syn, key, syn_params[key]) # If both source and syn on rank, no rank span -> classic NetCon if syn_on_rank and source_on_rank: netcon = h.NetCon( source_sec(source_x)._ref_v, syn, threshold, delay, weight, sec=source_sec ) # Connection spans ranks elif source_on_rank or syn_on_rank: if source_on_rank: # Assign a gid to a given segment only once if self.parallel_ctx.gid_exists(source_gid) == 0: self.assign_gid_to_source_seg( source_sec, source_x, threshold, source_gid ) else: # syn_on_rank netcon = self.parallel_ctx.gid_connect(source_gid, syn) netcon.delay = delay netcon.weight[0] = weight return netcon, syn
[docs] def assign_gid_to_source_seg(self, pre_sec, pre_sec_x, threshold, gid): # Assign the gid the current rank self.parallel_ctx.set_gid2node(gid, self.mpirank) # Create the dummy connection from source segment nc = h.NetCon(pre_sec(pre_sec_x)._ref_v, None, sec=pre_sec) nc.threshold = threshold # Assign the gid to the source segment (through the dummy netcon) self.parallel_ctx.cell(gid, nc)
[docs] @staticmethod def add_spine_pt3d(sec, xyz, diam): h.pt3dadd(xyz[0], xyz[1], xyz[2], diam, sec=sec)