def _connect(self,targetsId,cellType,netconList): """ Connect this object to target cells. Keyword arguments: targetsId -- List with the id of the target cells. cellType -- String defining the cell type. netconList -- List in which we append the created netCon Neuron objects. """ delay=1 # delay of the connection if cellType in self._nn.get_afferents_names(): weight = AfferentFiber.get_ees_weight() elif cellType in self._nn.get_real_motoneurons_names(): weight = Motoneuron.get_ees_weight() elif cellType in self._nn.get_intf_motoneurons_names(): weight = IntFireMn.get_ees_weight() else: raise Exception("undefined celltype for EES...intfireMn still to be implemented") for targetId in targetsId: # check whether this id is associated with a cell in this host. if not self._pc.gid_exists(targetId): continue if cellType in self._nn.get_real_motoneurons_names(): cell = self._pc.gid2cell(targetId) target = cell.create_synapse('ees') else: target = self._pc.gid2cell(targetId) # create the connections nc = self._pc.gid_connect(self._eesId,target) nc.weight[0] = weight nc.delay = delay nc.active(False) netconList.append(nc)
def __init__(self,parallelContext,neuralNetwork,amplitude,frequency,pulsesNumber=100000,species="rat",stim_start=5): """ Object initialization. Keyword arguments: parallelContext -- Neuron parallelContext object. neuralNetwork -- NeuralNetwork instance to connect to this object. amplitude -- Aplitude of stimulation. It could either be an integer value between _minCur and _maxCur or a list containing the percentages of recruited primary afferents, secondary afferents and motoneurons. frequency -- Stimulation frequency in Hz; it has to be lower than the maximum stimulation frequency imposed by the AfferentFiber model. pulsesNumber -- number of pulses to send (default 100000). species -- rat or human (it loads different recruitment curves) """ self._pc = parallelContext self._nn = neuralNetwork self._species = species # Lets assign an Id to the stim object (high value to be sure is not already take from some cell) self._eesId = 1000000 # Initialize a dictionary to contain all the connections between this object and the stimulated cells self._connections = {} self._maxFrequency = AfferentFiber.get_max_ees_frequency() self._current = None self._percIf= None self._percIIf= None self._percMn = None # Create the netStim Object in the first process if rank==0: # Tell this host it has this cellId self._pc.set_gid2node(self._eesId, rank) # Create the stim objetc self._stim = h.NetStim() self._stim.number = pulsesNumber self._stim.start = stim_start #lets give few ms for init purposes self._stim.noise = 0 self._pulses = h.Vector() # Associate the cell with this host and id # the nc is also necessary to use this cell as a source for all other hosts nc = h.NetCon(self._stim,None) self._pc.cell(self._eesId, nc) # Record the stimulation pulses nc.record(self._pulses) # Load the recruitment data self._load_rec_data() # lets define which type of cells are recruited by the stimulation self._recruitedCells = sum([self._nn.get_afferents_names(),self._nn.get_motoneurons_names()],[]) # Connect the stimulation to all muscles of the neural network self._connect_to_network() # Set stimulation parameters self.set_amplitude(amplitude) self.set_frequency(frequency)
def _connect_ees_to_fibers(self): """ Connect fibers ojects to ees objects to make the stimulation activate these fibers. """ for i in range(len(self._eesFrequencies)): for j in range(len(self._fiberDelays)): for k in range(len(self._fiberFiringRates)): self._netconList[i][j].append( h.NetCon(self._eesList[i], self._fiberList[i][j][k].cell)) self._netconList[i][j][k].delay = 1 self._netconList[i][j][k].weight[ 0] = AfferentFiber.get_ees_weight()
def _create_fibers(self): """ Create the fibers with the defined different delays. """ for i in range(len(self._eesFrequencies)): for j in range(len(self._fiberDelays)): for k in range(len(self._fiberFiringRates)): self._fiberList[i][j].append( AfferentFiber(self._fiberDelays[j])) if self._segmentToRecord is None: self._fiberList[i][j][k].set_firing_rate( self._fiberFiringRates[k]) if self._segmentToRecord is not None: self._fiberList[i][j][k].set_firing_rate( self._fiberFiringRates[k], False) self._fiberList[i][j][k].set_recording( True, self._segmentToRecord)
def __init__(self, parallelContext, eesFrequencies, fiberDelays, fiberFiringRates, segmentToRecord=None, tstop=5000): """ Object initialization. Keyword arguments: parallelContext -- Neuron parallelContext object. eesFrequencies -- List of stimulation frequencies to test. fiberDelays -- List of fiber delays to test. fiberFiringRates -- List of fiber firing rates to test. segmentToRecord -- Segment to record in case of a real afferent fiber model (default = None). tstop -- Time in ms at wich the simulation will stop (default = 500). """ Simulation.__init__(self, parallelContext) if rank == 1: print "\nMPI execution: the different processes have different stimulation starting time." print "The final result is the mean results between each process\n" # Variables initializations self._eesFrequencies = eesFrequencies self._fiberDelays = fiberDelays self._fiberFiringRates = fiberFiringRates self._segmentToRecord = segmentToRecord self._init_lists() self._results = np.zeros([ len(self._eesFrequencies), len(self._fiberDelays), len(self._fiberFiringRates) ]) self._create_fibers() self._create_ees_objects() self._connect_ees_to_fibers() self._set_tstop(tstop) self._set_integration_step(AfferentFiber.get_update_period())
def __init__(self, parallelContext, neuralNetwork, afferentInput=None, eesObject=None, eesModulation=None, tStop=100): """ Object initialization. Keyword arguments: parallelContext -- Neuron parallelContext object. neuralNetwork -- NeuralNetwork object. afferentInput -- Dictionary of lists for each type of fiber containing the fibers firing rate over time and the dt at wich the firing rate is updated. If no afferent input is desired, use None (default = None). eesObject -- EES object connected to the NeuralNetwork, mandatory for eesModulation (Default = None). eesModulation -- possible dictionary with the following strucuture: {'modulation': dictionary containing a signal of 0 and 1s used to activate/inactivate the stimulation for every muscle that we want to modulate (the dictionary keys have to be the muscle names used in the neural network structure), 'dt': modulation dt}. If no modulation of the EES is intended use None (default = None). tStop -- Time in ms at wich the simulation will stop (default = 100). In case the time is set to -1 the neuralNetwork will be integrated for all the duration of the afferentInput. """ Simulation.__init__(self, parallelContext) if rank == 1: print "\nMPI execution: the cells are divided in the different hosts\n" self._nn = neuralNetwork self._Iaf = self._nn.get_primary_afferents_names( )[0] if self._nn.get_primary_afferents_names() else [] self._IIf = self._nn.get_secondary_afferents_names( )[0] if self._nn.get_secondary_afferents_names() else [] self._Mn = self._nn.get_motoneurons_names( ) if self._nn.get_motoneurons_names() else [] self._set_integration_step(AfferentFiber.get_update_period()) # Initialization of the afferent modulation if afferentInput == None: self._afferentModulation = False self._afferentInput = None if tStop > 0: self._set_tstop(tStop) else: raise (Exception( "If no afferents input are provided tStop has to be greater than 0." )) else: self._afferentModulation = True self._afferentInput = afferentInput[0] self._dtUpdateAfferent = afferentInput[1] self._init_afferents_fr() key = [] key.append(self._afferentInput.keys()[0]) key.append(self._afferentInput[key[0]].keys()[0]) self._inputDuration = len( self._afferentInput[key[0]][key[1]]) * self._dtUpdateAfferent if tStop == -1 or tStop >= self._inputDuration: self._set_tstop(self._inputDuration - self._dtUpdateAfferent) else: self._set_tstop(tStop) self._ees = eesObject # Initialization of the binary stim modulation if eesModulation == None or eesObject == None: self._eesBinaryModulation = False self._eesProportionalModulation = False self._eesParam = { 'state': None, 'amp': None, 'modulation': None, 'dt': None } elif eesModulation['type'] == "binary": self._eesBinaryModulation = True self._eesProportionalModulation = False current, percIf, percIIf, percMn = self._ees.get_amplitude() self._eesParam = { 'state': {}, 'modulation': eesModulation['modulation'], 'dt': eesModulation['dt'] } self._eesParam['amp'] = [percIf, percIIf, percMn] for muscle in eesModulation['modulation']: self._eesParam['state'][muscle] = 1 elif eesModulation['type'] == "proportional": self._eesBinaryModulation = False self._eesProportionalModulation = True self._eesParam = { 'modulation': eesModulation['modulation'], 'dt': eesModulation['dt'] } current, percIf, percIIf, percMn = self._ees.get_amplitude() self._eesParam['maxAmp'] = np.array([percIf, percIIf, percMn]) #Initialization of the result dictionaries self._meanFr = None self._estimatedEMG = None self._nSpikes = None self._nActiveCells = None
def _create_cell_population(self, cellId, muscle, muscAfferentDelay, cellClass, cellName, cellNumber, neuronParam=None): """ Create cells populations. """ for n in range(int(cellNumber)): # Lets divide equally the cells between the different hosts if n % sizeComm == rank: # Assign a cellId to the new cell self.cellsId[muscle][cellName].append(cellId) # Tell this host it has this cellId self._pc.set_gid2node(cellId, rank) # Create the cell if cellClass == "IntFireMn": #List containing all integrate and fire motoneurons names if not cellName in self._intMotoneuronsNames: self._intMotoneuronsNames.append(cellName) self.cells[muscle][cellName].append(IntFireMn()) elif cellClass == "Motoneuron": #List containing all realistic motoneurons names if not cellName in self._realMotoneuronsNames: self._realMotoneuronsNames.append(cellName) # durg - parameter specific to the Mn drug = False if neuronParam == "drug": drug = True self.cells[muscle][cellName].append(Motoneuron(drug)) elif cellClass == "AfferentFiber": #Lists containing all primary or secondary afferent fibers names if "II" in cellName: if not cellName in self._secondaryAfferentsNames: self._secondaryAfferentsNames.append(cellName) else: if not cellName in self._primaryAfferentsNames: self._primaryAfferentsNames.append(cellName) # delay - parameter specific for the Afferent fibers if neuronParam is not None: delay = int(neuronParam) elif muscAfferentDelay is not None: delay = int(muscAfferentDelay) else: raise Exception( "Please specify the afferent fiber delay") self.cells[muscle][cellName].append(AfferentFiber(delay)) elif cellClass == "IntFire": #List containing all interneurons names if not cellName in self._interNeuronsNames: self._interNeuronsNames.append(cellName) self.cells[muscle][cellName].append(IntFire()) else: raise Exception( "Unkown cell in the netowrk instructions.... (" + str(cellClass) + ")") # Associate the cell with this host and id, the nc is also necessary to use this cell as a source for all other hosts nc = self.cells[muscle][cellName][-1].connect_to_target(None) self._pc.cell(cellId, nc) # Record cells APs if (cellClass == "Motoneuron" or cellClass == "IntFireMn") and self.recordMotoneurons: self.actionPotentials[muscle][cellName].append(h.Vector()) nc.record(self.actionPotentials[muscle][cellName][-1]) elif cellClass == "AfferentFiber" and self.recordAfferents: self.actionPotentials[muscle][cellName].append(h.Vector()) nc.record(self.actionPotentials[muscle][cellName][-1]) elif cellClass == "IntFire" and self.recordIntFire: self.actionPotentials[muscle][cellName].append(h.Vector()) nc.record(self.actionPotentials[muscle][cellName][-1]) cellId += 1 return cellId