def setup_ecp(self): self.im_ptr = h.PtrVector(self._nseg) # pointer vector # used for gathering an array of i_membrane values from the pointer vector self.im_ptr.ptr_update_callback(self.set_im_ptr) self.imVec = h.Vector(self._nseg) self.__set_extracell_mechanism()
def __init__(self, ncell, nsec): self.cells = [Cell(i, nsec) for i in range(ncell)] self.update_pointers() # Setup callback to update dipole POINTER for cache_efficiency # The PtrVector is used only to support the callback. self._callback_setup = h.PtrVector(1) self._callback_setup.ptr_update_callback(self.update_pointers)
def setup_xstim(self, set_nrn_mechanism=True): self.ptr2e_extracellular = h.PtrVector(self._nseg) self.ptr2e_extracellular.ptr_update_callback(self.set_ptr2e_extracellular) # Set the e_extracellular mechanism for all sections on this hoc object if set_nrn_mechanism: self.__set_extracell_mechanism()
def __init__(self, node, spike_threshold, dL, calc_ecp=False): super(BioCell, self).__init__(node) # Set up netcon object that can be used to detect and communicate cell spikes. self.set_spike_detector(spike_threshold) self._morph = None self._seg_coords = {} # Determine number of segments and store a list of all sections. self._nseg = 0 self.set_nseg(dL) self._secs = [] self.set_sec_array() self._synapses = [] self._syn_src_gid = [] self._syn_seg_ix = [] self._syn_sec_x = [] if calc_ecp: self.im_ptr = h.PtrVector(self._nseg) # pointer vector self.im_ptr.ptr_update_callback(self.set_im_ptr) # used for gathering an array of i_membrane values from the pointer vector self.imVec = h.Vector(self._nseg)
def setupRecordLFP(): from .. import sim from netpyne.support.recxelectrode import RecXElectrode nsites = len(sim.cfg.recordLFP) saveSteps = int(np.ceil(sim.cfg.duration / sim.cfg.recordStep)) sim.simData['LFP'] = np.zeros((saveSteps, nsites)) if sim.cfg.saveLFPCells: for c in sim.net.cells: sim.simData['LFPCells'][c.gid] = np.zeros((saveSteps, nsites)) if not sim.net.params.defineCellShapes: sim.net.defineCellShapes( ) # convert cell shapes (if not previously done already) sim.net.calcSegCoords() # calculate segment coords for each cell sim.net.recXElectrode = RecXElectrode( sim) # create exctracellular recording electrode if sim.cfg.createNEURONObj: for cell in sim.net.compartCells: nseg = cell._segCoords['p0'].shape[1] sim.net.recXElectrode.calcTransferResistance( cell.gid, cell._segCoords) # transfer resistance for each cell cell.imembPtr = h.PtrVector(nseg) # pointer vector cell.imembPtr.ptr_update_callback( cell.setImembPtr ) # used for gathering an array of i_membrane values from the pointer vector cell.imembVec = h.Vector(nseg) sim.cvode.use_fast_imem(1) # make i_membrane_ a range variable
def setupRecordLFP(): """ Function for/to <short description of `netpyne.sim.setup.setupRecordLFP`> """ from .. import sim from netpyne.support.recxelectrode import RecXElectrode nsites = len(sim.cfg.recordLFP) saveSteps = int(np.ceil(sim.cfg.duration / sim.cfg.recordStep)) sim.simData['LFP'] = np.zeros((saveSteps, nsites)) if sim.cfg.saveLFPCells: if sim.cfg.saveLFPCells == True: cellsRecordLFP = utils.getCellsList(['all']) # record all cells elif isinstance(sim.cfg.saveLFPCells, list): cellsRecordLFP = utils.getCellsList(sim.cfg.saveLFPCells) for c in cellsRecordLFP: sim.simData['LFPCells'][c.gid] = np.zeros((saveSteps, nsites)) if sim.cfg.saveLFPPops: if sim.cfg.saveLFPPops == True: popsRecordLFP = list(sim.net.pops.keys()) # record all pops elif isinstance(sim.cfg.saveLFPPops, list): popsRecordLFP = [ p for p in sim.cfg.saveLFPPops if p in list(sim.net.pops.keys()) ] # only pops that exist sim.net.popForEachGid = {} for pop in popsRecordLFP: sim.net.popForEachGid.update( {gid: pop for gid in sim.net.pops[pop].cellGids}) for pop in popsRecordLFP: sim.simData['LFPPops'][pop] = np.zeros((saveSteps, nsites)) if not sim.net.params.defineCellShapes: sim.net.defineCellShapes( ) # convert cell shapes (if not previously done already) sim.net.calcSegCoords() # calculate segment coords for each cell sim.net.recXElectrode = RecXElectrode.fromConfig( sim.cfg) # create exctracellular recording electrode if sim.cfg.createNEURONObj: for cell in sim.net.compartCells: nseg = cell._segCoords['p0'].shape[1] sim.net.recXElectrode.calcTransferResistance( cell.gid, cell._segCoords) # transfer resistance for each cell cell.imembPtr = h.PtrVector(nseg) # pointer vector cell.imembPtr.ptr_update_callback( cell.setImembPtr ) # used for gathering an array of i_membrane values from the pointer vector cell.imembVec = h.Vector(nseg) sim.cvode.use_fast_imem(True) # make i_membrane_ a range variable sim.cfg.use_fast_imem = True
def LFPinit(self): lsec = getallSections() n = len(lsec) # print('In LFPinit - pc.id = ',self.pc.id(),'len(lsec)=',n) self.imem_ptrvec = h.PtrVector(n) # self.imem_vec = h.Vector(n) for i, s in enumerate(lsec): seg = s(0.5) #for seg in s # so do not need to use segments...? more accurate to use segments and their neighbors self.imem_ptrvec.pset(i, seg._ref_i_membrane_) self.vres = self.transfer_resistance(self.coord) self.lfp_t = h.Vector() self.lfp_v = h.Vector()
def LFPinit(self): lsec = get_all_sections() n_sections = len(lsec) self.imem_ptrvec = h.PtrVector(n_sections) self.imem_vec = h.Vector(n_sections) for i, s in enumerate(lsec): seg = s(0.5) # for seg in s # so do not need to use segments...? # more accurate to use segments and their neighbors self.imem_ptrvec.pset(i, seg._ref_i_membrane_) self.vres = self.transfer_resistance(self.coord, method=self.method) self.lfp_t = h.Vector() self.lfp_v = h.Vector()
def setup(self): size = 0 for sec in self.sl: for seg in sec: size += 1 self.pv = h.PtrVector(size) self.hv = h.Vector(size) self.v = self.hv.as_numpy() self.nodeindices = numpy.empty(size, dtype=int) self.n = numpy.empty(size, dtype=float) self.g = numpy.empty(size, dtype=float) i=0 for sec in self.sl: for seg in sec: self.pv.pset(i, seg._ref_v) self.nodeindices[i] = seg.node_index() i += 1
def _transfer_to_legacy(): global _c_ptr_vector, _c_ptr_vector_storage, _c_ptr_vector_storage_nrn global _last_c_ptr_length size = len(_all_cptrs) if _last_c_ptr_length != size: if size: _c_ptr_vector = h.PtrVector(size) for i, ptr in enumerate(_all_cptrs): _c_ptr_vector.pset(i, ptr) _c_ptr_vector_storage_nrn = h.Vector(size) _c_ptr_vector_storage = _c_ptr_vector_storage_nrn.as_numpy() else: _c_ptr_vector = None _last_c_ptr_length = size if size: _c_ptr_vector_storage[:] = node._get_states()[_all_cindices] _c_ptr_vector.scatter(_c_ptr_vector_storage_nrn)
def _update_node_data(force=False): global last_diam_change_cnt, last_structure_change_cnt, _curr_indices, _curr_scales, _curr_ptrs global _curr_ptr_vector, _curr_ptr_storage, _curr_ptr_storage_nrn if last_diam_change_cnt != _cvode_object.diam_change_count( ) or _cvode_object.structure_change_count( ) != last_structure_change_cnt or force: last_diam_change_cnt = _cvode_object.diam_change_count() last_structure_change_cnt = _cvode_object.structure_change_count() for sr in species._get_all_species().values(): s = sr() if s is not None: s._update_node_data() for sr in species._get_all_species().values(): s = sr() if s is not None: s._update_region_indices() for rptr in _all_reactions: r = rptr() if r is not None: r._update_indices() _curr_indices = [] _curr_scales = [] _curr_ptrs = [] for sr in species._get_all_species().values(): s = sr() if s is not None: s._setup_currents(_curr_indices, _curr_scales, _curr_ptrs) num = len(_curr_ptrs) if num: _curr_ptr_vector = h.PtrVector(num) for i, ptr in enumerate(_curr_ptrs): _curr_ptr_vector.pset(i, ptr) _curr_ptr_storage_nrn = h.Vector(num) _curr_ptr_storage = _curr_ptr_storage_nrn.as_numpy() else: _curr_ptr_vector = None _curr_scales = numpy.array(_curr_scales)
def setupRecordDipole(): """ Function for/to <short description of `netpyne.sim.setup.setupRecordDipole`> """ from .. import sim import lfpykit saveSteps = int(np.ceil(sim.cfg.duration / sim.cfg.recordStep)) sim.simData['dipoleSum'] = np.zeros((saveSteps, 3)) if sim.cfg.saveDipoleCells: if sim.cfg.saveDipoleCells == True: cellsRecordDipole = utils.getCellsList(['all']) # record all cells elif isinstance(sim.cfg.saveDipoleCells, list): cellsRecordDipole = utils.getCellsList(sim.cfg.saveDipoleCells) for c in cellsRecordDipole: sim.simData['dipoleCells'][c.gid] = np.zeros((saveSteps, 3)) if sim.cfg.saveDipolePops: if sim.cfg.saveDipolePops == True: popsRecordDipole = list(sim.net.pops.keys()) # record all pops elif isinstance(sim.cfg.saveDipolePops, list): popsRecordDipole = [ p for p in sim.cfg.saveDipolePops if p in list(sim.net.pops.keys()) ] # only pops that exist sim.net.popForEachGid = {} for pop in popsRecordDipole: sim.net.popForEachGid.update( {gid: pop for gid in sim.net.pops[pop].cellGids}) for pop in popsRecordDipole: sim.simData['dipolePops'][pop] = np.zeros((saveSteps, 3)) if not sim.net.params.defineCellShapes: sim.net.defineCellShapes( ) # convert cell shapes (if not previously done already) sim.net.calcSegCoords() # calculate segment coords for each cell if sim.cfg.createNEURONObj: for cell in sim.net.compartCells: lfpykitCell = lfpykit.CellGeometry( x=np.array([[p0, p1] for p0, p1 in zip( cell._segCoords['p0'][0], cell._segCoords['p1'][0])]), y=np.array([[p0, p1] for p0, p1 in zip( cell._segCoords['p0'][1], cell._segCoords['p1'][1])]), z=np.array([[p0, p1] for p0, p1 in zip( cell._segCoords['p0'][2], cell._segCoords['p1'][2])]), d=np.array([[d0, d1] for d0, d1 in zip( cell._segCoords['d0'], cell._segCoords['d1'])])) cdm = lfpykit.CurrentDipoleMoment(cell=lfpykitCell) cell.M = cdm.get_transformation_matrix() # set up recording of membrane currents (duplicate with setupRecordLFP -- unifiy and avoid calling twice) nseg = cell._segCoords['p0'].shape[1] cell.imembPtr = h.PtrVector(nseg) # pointer vector cell.imembPtr.ptr_update_callback( cell.setImembPtr ) # used for gathering an array of i_membrane values from the pointer vector cell.imembVec = h.Vector(nseg) sim.cvode.use_fast_imem(True) # make i_membrane_ a range variable sim.cfg.use_fast_imem = True
def _build(self, cvode=None, include_celltypes='all'): """Assemble NEURON objects for calculating extracellular potentials. The handler is set up to maintain a vector of membrane currents at at every inner segment of every section of every cell on each CVODE integration step. In addition, it records a time vector of sample times. Parameters ---------- cvode : instance of h.CVode Multi order variable time step integration method. include_celltypes : str String to match against the cell type of each section. Defaults to ``'all'``: calculate extracellular potential generated by all cells. To restrict this to include only pyramidal cells, use ``'Pyr'``. For basket cells, use ``'Basket'``. NB This argument is currently not exposed in the API. """ secs_on_rank = h.allsec() # get all h.Sections known to this MPI rank _validate_type(include_celltypes, str) _check_option('include_celltypes', include_celltypes, ['all', 'Pyr', 'Basket']) if include_celltypes.lower() != 'all': secs_on_rank = [ s for s in secs_on_rank if include_celltypes in s.name() ] segment_counts = [sec.nseg for sec in secs_on_rank] n_total_segments = np.sum(segment_counts) # pointers assigned to _ref_i_membrane_ at each EACH internal segment self._nrn_imem_ptrvec = h.PtrVector(n_total_segments) # placeholder into which pointer values are read on each sim time step self._nrn_imem_vec = h.Vector(n_total_segments) ptr_idx = 0 for sec in secs_on_rank: for seg in sec: # section end points (0, 1) not included # set Nth pointer to the net membrane current at this segment self._nrn_imem_ptrvec.pset(ptr_idx, sec(seg.x)._ref_i_membrane_) ptr_idx += 1 if ptr_idx != n_total_segments: raise RuntimeError(f'Expected {n_total_segments} imem pointers, ' f'got {ptr_idx}.') # transfer resistances for each segment (keep in Neuron Matrix object) self._nrn_r_transfer = h.Matrix(self.n_contacts, n_total_segments) for row, pos in enumerate(self.array.positions): if self.array.method is not None: transfer_resistance = list() for sec in secs_on_rank: this_xfer_r = _transfer_resistance( sec, pos, conductivity=self.array.conductivity, method=self.array.method, min_distance=self.array.min_distance) transfer_resistance.extend(this_xfer_r) self._nrn_r_transfer.setrow(row, h.Vector(transfer_resistance)) else: # for testing, make a matrix of ones self._nrn_r_transfer.setrow(row, h.Vector(n_total_segments, 1.)) # record time for each array self._nrn_times = h.Vector().record(h._ref_t) # contributions of all segments on this rank to total calculated # potential at electrode (_PC.allreduce called in _simulate_dipole) # NB voltages of all contacts are initialised to 0 mV, i.e., the # potential at time 0.0 ms is defined to be zero. self._nrn_voltages = h.Vector(self.n_contacts, 0.) # NB we must make a copy of the function reference, and keep it for # later decoupling using extra_scatter_gather_remove # (instead of a new function reference) self._recording_callback = self._gather_nrn_voltages # Nb extra_scatter_gather is called _after_ the solver takes a step, # so the initial state is not recorded (initialised to zero above) cvode.extra_scatter_gather(0, self._recording_callback)
glu.ijnmda[i] = h.ijk(*locations[i], nz - 1) h.load_file("test1.ses") sl = h.SectionList() hin = h.PlotShape[0] hin.size(0, nx, 0, nx) hin.scale(0, 1) for i in range(nx): for k in range(nz): hin.hinton(glu._ref_glu[i + k * nx * ny], float(i), float(k), .9, .9) #h.flush_list.append(hin) hin.exec_menu("Shape Plot") # plot of glu[i, 0, nz-1] gluline = h.PtrVector(nx) gluline.label("glu[i, 0, nz-1]") for i in range(nx): gluline.pset(i, glu._ref_glu[int(h.ijk(i, 0, nz - 1))]) glulinegraph = h.Graph[2] gluline.plot(glulinegraph) gluline2 = h.PtrVector(nx) gluline2.label("glu[i, 0, 0]") for i in range(nx): gluline2.pset(i, glu._ref_glu[int(h.ijk(i, 0, 0))]) gluline2.plot(glulinegraph) #glulinegraph2.size(0, 30, 0, 3) h.flush_list.append(glulinegraph) h.stdinit()
def __init__(self, tracker_sec, use_fast_imem, lfp_scheme, sigma, electrode_coords, *args): """ Add all segments in given SectionLists as LFP sources, using the given LFP approximation scheme ARGUMENTS --------- @param $o1 : tracking_section <Section> Section where LFP summator object should be inserted. This has no influence on the section and is only necessary because a POINT_PROCESS object needs a container. @param $s2 : use_fast_imem <bool> True if CVode.fast_imem should be used and 'extracellular' mechanism should not be inserted. @param $s3 : lfp_scheme <string> LFP approximation scheme: "PSA", "LSA", or "RC" @param $4 : sigma <float> Conductivity of the extracellular medium. @param $o5 : electrode_coords <Vector> Vector of length 3 containing electrode x,y,z coordinates. @param $o6 - $oN : tracked_seclist <SectionList> SectionLists containing sections whose LFP contributions should be summed. PRECONDITIONS ------------- @pre If the 'use_fast_imem' argument is True, cvode = h.CVode(); cvode.use_fast_imem(True) must be called before calling this function. If not, the variable 'i_membrane_' is not created. PYTHON USAGE ------------ >>> cell = MyCellTemplate() >>> soma = cell.soma # Section >>> dendritic = cell.dendritic # SectionList >>> sigma = 0.3 >>> electrode_coords = h.Vector([10.0, 50.0, 20.0]) >>> tracker = LfpTracker(soma, True, "PSA", sigma, electrode_coords, dendritic) """ self.summator = h.LfpSumStep(tracker_sec(0.5)) self.tracked_seclists = args self.use_fast_imem = use_fast_imem num_tracked_segs = sum( (sec.nseg for sl in self.tracked_seclists for sec in sl)) self.imemb_ptrs = h.PtrVector(num_tracked_segs) self.lfp_imemb_factors = h.calc_lfp_factors(use_fast_imem, lfp_scheme, sigma, electrode_coords, *args).as_numpy() i_seg = 0 for sl in self.tracked_seclists: for sec in sl: for seg in sec: if use_fast_imem: h.setpointer(seg._ref_i_membrane_, 'temp_ptr', self.summator) factor = self.lfp_imemb_factors[i_seg] * 1e2 else: h.setpointer(seg._ref_i_membrane, 'temp_ptr', self.summator) factor = self.lfp_imemb_factors[i_seg] self.imemb_ptrs.pset(i_seg, seg._ref_i_membrane_) self.summator.add_lfp_source(factor) i_seg += 1 self.imemb_ptrs.ptr_update_callback( self.update_imemb_ptrs)
from neuron import h a = h.Vector(5).indgen() b = h.Vector(5).fill(0) pv = h.PtrVector(5) for i in range(len(a)): pv.pset(i, b._ref_x[i]) pv.scatter(a) b.printf() print(pv.label()) pv.label("hello") print(pv.label())