def load_hoc_model(self, model_dir, hoc_file): """Load an hoc files. It compiles the mod before loading the hoc.""" try: os.path.isfile(os.path.join (model_dir, hoc_file)) except IOError: logger.error("Not existing file: %s" %e.value) old_dir = os.path.abspath(os.getcwd()) logger.info("Path changed to %s" %(os.path.abspath(model_dir))) if model_dir != '' : os.chdir(model_dir) try: # Add all mod files into current directory self.find_mod_files() # If windows if os.name == 'nt': self.windows_compile_mod_files('.') from neuron import h h.nrn_load_dll('./nrnmech.dll') else: # Anything else. call(['nrnivmodl']) import neuron neuron.load_mechanisms('.') # Auto loading. Not needed anymore. from neuron import gui # to not freeze neuron gui from neuron import h logger.info("Loading model in %s from %s"%(model_dir, hoc_file)) h.load_file(hoc_file) except Exception as e: logger.warning("Error running model: " + e.message) logger.info("Path changed back to %s" %old_dir) os.chdir(old_dir) return True
def return_cell(self): self.model_path = join(root_path+'TC_neuron') neuron.load_mechanisms(self.model_path) cell_parameters = { 'morphology': join(self.model_path, 'soma.hoc'), 'passive':False, 'v_init' : -60, 'extracellular':False, 'nsegs_method': 'none', # 'timeres_NEURON':0.1, # 'timeres_python':0.1, 'dt' : 0.1, 'tstop':2000, 'tstart':0, 'templatefile': join(self.model_path, 'TC_GH2.hoc'), 'templatename':'sTC', 'templateargs':None, 'delete_sections':False } cell = LFPy.TemplateCell(**cell_parameters) return cell
def test(verbosity=2): ''' Run tests for the LFPy module implemented using the unittest module. Note: if the NEURON extension file LFPy/sinsyn.mod could not be compiled using the neuron-provided nrnivmodl script (linux/OSX) upon installation of LFPy, tests will fail. Consider reinstalling LFPy e.g., issuing :: pip install LFPy --upgrade or :: cd /path/to/LFPy/sources python setup.py install Arguments: :: verbosity : int unittest.TextTestRunner verbosity level ''' #load sinusoid synapse currrent mechanism neuron.load_mechanisms(LFPy.__path__[0]) #check if sinsyn.mod is compiled, if it isn't, some tests will fail if not hasattr(neuron.h, 'SinSyn'): warn( 'tests will fail because the sinsyn.mod mechanism is not compiled') #load and execute testing suite suite = unittest.TestLoader().loadTestsFromTestCase(testLFPy) unittest.TextTestRunner(verbosity=verbosity).run(suite)
def test(verbosity=2): ''' Run tests for the LFPy module implemented using the unittest module. Note: if the NEURON extension file LFPy/sinsyn.mod could not be compiled using the neuron-provided nrnivmodl script (linux/OSX) upon installation of LFPy, tests will fail. Consider reinstalling LFPy e.g., issuing :: pip install LFPy --upgrade or :: cd /path/to/LFPy/sources python setup.py install Arguments: :: verbosity : int unittest.TextTestRunner verbosity level ''' #load sinusoid synapse currrent mechanism neuron.load_mechanisms(LFPy.__path__[0]) #check if sinsyn.mod is compiled, if it isn't, some tests will fail if not hasattr(neuron.h, 'SinSyn'): warn('tests will fail because the sinsyn.mod mechanism is not compiled') #load and execute testing suite suite = unittest.TestLoader().loadTestsFromTestCase(testLFPy) unittest.TextTestRunner(verbosity=verbosity).run(suite)
def run_extracted_model(self, mod): model_dir = mod.get_dir() if os.path.exists(os.path.join (model_dir, 'mosinit.hoc')): old_dir = os.path.abspath(os.getcwd()) logger.info("Path changed to %s" %(os.path.abspath(model_dir))) os.chdir(model_dir) try: # If windows if os.name == 'nt': self.windows_compile_mod_files('.') from neuron import h h.nrn_load_dll('./nrnmech.dll') else: # Anything else. call(['nrnivmodl']) import neuron neuron.load_mechanisms('./') from neuron import gui # to not freeze neuron gui from neuron import h logger.info("Loading model in %s" %model_dir) h.load_file('mosinit.hoc') except Exception as e: logger.warning("Error running model: "+e.message) logger.info("Path changed back to %s" %old_dir) os.chdir(old_dir) else: response = """We didn't find any mosinit.hoc . Unfortunately we can't automatically run the model. Check the README, maybe there is an hint.""" logging.warning(response) path_info = "You can find the extracted model in %s" %model_dir mod.browse() logging.info(path_info)
def load_neuron_modules(mechanisms_dir, templates_dir, default_templates=True): """ :param mechanisms_dir: :param templates_dir: :param default_templates: """ h.load_file('stdgui.hoc') bionet_dir = os.path.dirname(__file__) h.load_file(os.path.join(bionet_dir, 'import3d.hoc').replace( "\\", "/")) # customized import3d.hoc to supress warnings h.load_file( os.path.join(bionet_dir, 'default_templates', 'advance.hoc').replace("\\", "/")) if isinstance(mechanisms_dir, list): for mdir in mechanisms_dir: neuron.load_mechanisms(str(mdir)) elif mechanisms_dir is not None: neuron.load_mechanisms(str(mechanisms_dir)) if default_templates: load_templates(os.path.join(bionet_dir, 'default_templates')) if templates_dir: load_templates(templates_dir)
def return_cell(): neuron.load_mechanisms("HallermannEtAl2012") # Define cell parameters cell_parameters = { # various cell parameters, 'morphology' : 'unmyelinated_axon_Hallermann.hoc', # Mainen&Sejnowski, 1996 'v_init' : -80., # initial crossmembrane potential 'passive' : False, # switch off passive mechs 'nsegs_method' : 'lambda_f', 'lambda_f' : 1000., 'dt' : 2.**-7, # [ms] dt's should be in powers of 2 'tstart' : -200., # start time of simulation, recorders start at t=0 'tstop' : 2., # stop simulation at 2 ms. } cell = LFPy.Cell(**cell_parameters) cell.set_pos(x=-np.max(cell.xmid) / 2, z=2.5) # To induce a spike: synapseParameters = { 'idx' : 0, # insert synapse on index "0", the soma 'e' : 0., # reversal potential of synapse 'syntype' : 'Exp2Syn', # conductance based double-exponential synapse 'tau1' : 0.1, # Time constant, decay 'tau2' : 0.1, # Time constant, decay 'weight' : 0.004, # Synaptic weight 'record_current' : False, # Will enable synapse current recording } # attach synapse with parameters and input time synapse = LFPy.Synapse(cell, **synapseParameters) synapse.set_spike_times(np.array([0.1])) cell.simulate(rec_vmem=True, rec_imem=True) return cell
def _compile_nmodl(nineml_component, weight_variables, hierarchical_mode=None): # weight variables should really be within component """ Generate NMODL code for the 9ML component, run "nrnivmodl" and then load the mechanisms into NEURON. """ if not os.path.exists(NMODL_DIR): os.makedirs(NMODL_DIR) cwd = os.getcwd() os.chdir(NMODL_DIR) xml_file = "%s.xml" % nineml_component.name logger.debug("Writing NineML component to %s" % xml_file) nineml_component.write(xml_file) from nineml2nmodl import write_nmodl, write_nmodldirect mod_filename = nineml_component.name + ".mod" write_nmodldirect(component=nineml_component, mod_filename=mod_filename, weight_variables=weight_variables) #write_nmodl(xml_file, weight_variables) # weight variables should really come from xml file print "Running 'nrnivmodl' from %s"%NMODL_DIR import nineml2nmodl nineml2nmodl.call_nrnivmodl() os.chdir(cwd) neuron.load_mechanisms(NMODL_DIR)
def return_cell(self): self.model_path = join(root_path+'cortex_neurons') neuron.load_mechanisms(self.model_path) cell_parameters = { 'morphology': join(self.model_path, 'soma.hoc'), 'passive':False, 'v_init' : -70, 'extracellular':False, 'nsegs_method': 'lambda_f', 'lambda_f': 50, #'timeres_NEURON':0.1, #'timeres_python':0.1, 'dt' : 0.1, 'tstop':2000, 'tstart':0, 'templatefile': join(self.model_path, 'sPY_template'), 'templatename':'sPY', 'templateargs':None, 'custom_fun': None, 'delete_sections':False } cell = LFPy.TemplateCell(**cell_parameters) cell.set_rotation(x=-1.57, y=0.0, z=0.0) return cell
def _compile_nmodl(nineml_component, weight_variables, hierarchical_mode=None ): # weight variables should really be within component """ Generate NMODL code for the 9ML component, run "nrnivmodl" and then load the mechanisms into NEURON. """ wdir = os.path.join(NMODL_DIR, nineml_component.name) if not os.path.exists(wdir): os.makedirs(wdir) cwd = os.getcwd() os.chdir(wdir) xml_file = "%s.xml" % nineml_component.name logger.debug("Writing NineML component to %s" % xml_file) nineml_component.write(xml_file) mod_filename = nineml_component.name + ".mod" write_nmodldirect(component=nineml_component, mod_filename=mod_filename, weight_variables=weight_variables) #write_nmodl(xml_file, weight_variables) # weight variables should really come from xml file print("Running 'nrnivmodl' from %s" % wdir) import nineml2nmodl call_nrnivmodl() os.chdir(cwd) neuron.load_mechanisms(wdir)
def __init__(self, model_path, special_path, base=os.getcwd()): self.base_directory = base os.chdir(self.base_directory) print('*********** NEURON ' + neuron.__version__ + ' LOADED ***********') self.special = None if special_path == 'None' else special_path self.model = model_path self.model_dir = ('/').join(self.model.rsplit('/')[0:-1]) if self.special: neuron.load_mechanisms(self.special) self.hoc_obj = first_hoc_cls.__new__(first_hoc_cls) self.hoc_obj.__dict__.update(first_hoc_dict) self.hoc_obj.load_file(1, str(self.model)) self.hoc_obj.load_file("stdrun.hoc") self.vec = self.hoc_obj.Vector() self.stimulus = None self.record = [] self.spike_times = None self.sections = {} for n in self.hoc_obj.allsec(): self.sections[str(self.hoc_obj.secname(sec=n))] = n self.channels = {} for sec in self.hoc_obj.allsec(): for seg in sec: for mech in seg: self.channels[str(mech.name())] = mech
def load_hoc_model(self, model_dir, hoc_file): """Load an hoc files. It compiles the mod before loading the hoc.""" try: os.path.isfile(os.path.join(model_dir, hoc_file)) except IOError: logger.error("Not existing file: %s" % e.value) old_dir = os.path.abspath(os.getcwd()) logger.info("Path changed to %s" % (os.path.abspath(model_dir))) if model_dir != '': os.chdir(model_dir) try: # Add all mod files into current directory self.find_mod_files() # If windows if os.name == 'nt': self.windows_compile_mod_files('.') from neuron import h h.nrn_load_dll('./nrnmech.dll') else: # Anything else. call(['nrnivmodl']) import neuron neuron.load_mechanisms( '.') # Auto loading. Not needed anymore. from neuron import gui # to not freeze neuron gui from neuron import h logger.info("Loading model in %s from %s" % (model_dir, hoc_file)) h.load_file(hoc_file) except Exception as e: logger.warning("Error running model: " + e.message) logger.info("Path changed back to %s" % old_dir) os.chdir(old_dir) return True
def importNet(self, configFile, replaceAxon=True, setdLNseg=True): self.configFile = configFile self.replaceAxon = replaceAxon self.setdLNseg = setdLNseg # read config files filename = os.path.abspath(configFile) rootFolder = os.path.dirname(configFile) self.config = load_json(filename) self.substitutes = { '../': '%s/../' % rootFolder, './': '%s/' % rootFolder, '.': '%s/' % rootFolder, '${configdir}': '%s' % rootFolder } if 'network' in self.config: self.network_config = load_json(self.subs(self.config['network'])) else: self.network_config = self.config if 'simulation' in self.config: self.simulation_config = load_json( self.subs(self.config['simulation'])) else: self.simulation_config = None for m in self.network_config['manifest']: path = self.subs(self.network_config['manifest'][m]) self.substitutes[m] = path for m in self.simulation_config['manifest']: path = self.subs(self.simulation_config['manifest'][m]) self.substitutes[m] = path # create and initialize sim object sim.initialize() # create netpyne simConfig self.createSimulationConfig() # add compiled mod folder modFolder = self.subs( self.network_config['components']['mechanisms_dir']) + '/modfiles' neuron.load_mechanisms(str(modFolder)) # create pops self.createPops() # create stimulation (before createCells since spkTimes added to pops) self.createStims() # create cells self.createCells() # create connections self.createConns()
def load_mechanisms_from_neuron_model(cell_name): neuron_model = '/home/baran/Desktop/neuron_models/' + cell_name cwd = os.getcwd() mechanisms_folder = neuron_model + '/mechanisms' os.chdir(mechanisms_folder) os.system('nrnivmodl') #Compiling mechanisms os.chdir(cwd) neuron.load_mechanisms(mechanisms_folder)
def set_parameters(morphology, X, Y, Z, sigma=0.3, cell_model=None): """set cell, synapse and electrode parameters""" model_folder = join("cell_models", "EyalEtAl2018") morph_path = join(model_folder, "Morphs", morphology) if cell_model == None: cell_parameters = { 'v_init': -70, 'morphology': morph_path, 'passive_parameters': {'g_pas' : 1./30000, 'e_pas' : -70}, # S/cm^2, mV 'Ra' : 150, # Ω cm 'cm' : 1, # µF/cm^2 'nsegs_method': "lambda_f", "lambda_f": 100, 'dt': 2**-4, # [ms] Should be a power of 2 'tstart': -10, # [ms] Simulation start time 'tstop': 100, # [ms] Simulation end time "pt3d": True, 'passive': True } else: mod_folder = join(model_folder, 'ActiveMechanisms') model_path = join(model_folder, "ActiveModels", cell_model + '_mod') neuron.load_mechanisms(mod_folder) cell_parameters = { 'morphology': morph_path, 'templatefile': model_path + '.hoc', 'templatename': cell_model, 'templateargs': morph_path, 'v_init': -86, 'passive': False, 'dt': 2**-4, # [ms] Should be a power of 2 'tstart': -200, # [ms] Simulation start time 'tstop': 100, # [ms] Simulation end time "pt3d": True, 'nsegs_method': "lambda_f", "lambda_f": 100, } synapse_parameters = {'e': 0., # reversal potential # 'tau': 5., # synapse time constant (first fig version) 'weight': 0.002, # 0.001, # synapse weight 'record_current': True, # record synapse current # parameters not included in first version of fig 'syntype': 'Exp2Syn', 'tau1': 1., #Time constant, rise 'tau2': 3., #Time constant, decay } grid_electrode_parameters = {'sigma': sigma, 'x': X.flatten(), 'y': Y.flatten(), 'z': Z.flatten() } return cell_parameters, synapse_parameters, grid_electrode_parameters
def load_neuron_modules(conf, **cm): h.load_file('stdgui.hoc') bionet_dir = os.path.dirname(__file__) h.load_file(bionet_dir+'/import3d.hoc') # loads hoc files from package directory ./import3d. It is used because read_swc.hoc is modified to suppress some warnings. h.load_file(bionet_dir+'/advance.hoc') neuron.load_mechanisms(str(conf["components"]["mechanisms_dir"])) load_templates(conf["components"]["templates_dir"])
def run_sim(): # Folder that contains x86_64 folder NETPYNE_WORKDIR_PATH = "../../../" neuron.load_mechanisms(NETPYNE_WORKDIR_PATH) netParams = sim.loadNetParams("./netParams.json", None, False) simConfig = sim.loadSimCfg("./simConfig.json", None, False) sim.createSimulate(netParams, simConfig) sim.saveData()
def compile_neuron_mod_dir(pkg_dir): try: print('Compiling {}'.format(pkg_dir)) os.system('nrnivmodl {}'.format(pkg_dir)) from neuron import load_mechanisms load_mechanisms(pkg_dir) print(' Compilation of support folder mod files successful') except Exception as err: print(' Error compiling support folder mod files') print(err) return
def run(): # Folder that contains x86_64 folder NETPYNE_WORKDIR_PATH = "../../../" neuron.load_mechanisms(NETPYNE_WORKDIR_PATH) # read cfg and netParams from command line arguments if available; otherwise use default simConfig, netParams = sim.readCmdLineArgs(simConfigDefault="cfg.py", netParamsDefault="netParams.py") # Create network and run simulation sim.createSimulate(netParams=netParams, simConfig=simConfig) sim.saveData()
def importCellsFromNet(netParams, fileName, labelList, condsList, cellNamesList, importSynMechs): """ importCellsFromNet Import cell from HOC template or python file into framework format (dict of sections, with geom, topol, mechs, syns) """ h.initnrn() if fileName.endswith('.hoc') or fileName.endswith('.tem'): print('Importing from .hoc network not yet supported') return # h.load_file(fileName) # for cellName in cellNames: # cell = getattr(h, cellName) # create cell using template, passing dict with args # secDic, secListDic, synMechs = getCellParams(cell) elif fileName.endswith('.py'): origDir = os.getcwd() filePath, fileNameOnly = os.path.split( fileName) # split path from filename if filePath not in sys.path: # add to path if not there (need to import module) sys.path.insert(0, filePath) removeFilePath = True else: removeFilePath = False moduleName = fileNameOnly.split('.py')[ 0] # remove .py to obtain module name os.chdir(filePath) print('\nRunning network in %s to import cells into NetPyNE ...\n' % (fileName)) from neuron import load_mechanisms load_mechanisms(filePath) tempModule = importlib.import_module(moduleName) modulePointer = tempModule if removeFilePath: sys.path.remove(filePath) else: print("File name should be either .hoc or .py file") return for label, conds, cellName in zip(labelList, condsList, cellNamesList): print('\nImporting %s from %s ...' % (cellName, fileName)) exec('cell = tempModule' + '.' + cellName) #cell = getattr(modulePointer, cellName) # get cell object varList = mechVarList() origGlob = getGlobals( list(varList['mechs'].keys()) + list(varList['pointps'].keys())) secs, secLists, synMechs = getCellParams(cell, varList, origGlob) cellRule = {'conds': conds, 'secs': secs, 'secLists': secLists} netParams.addCellParams(label, cellRule) if importSynMechs: for synMech in synMechs: netParams.addSynMechParams(synMech.pop('label'), synMech)
def return_cell(synaptic_y_pos=900, conductance_type='active', weight=0.001, input_spike_train=np.array([10.])): """ Runs a NEURON simulation and returns an LFPy cell object for a single synaptic input. :param synaptic_y_pos: position along the apical dendrite where the synapse is inserted. :param conductance_type: Either 'active' or 'passive'. If 'active' all original ion-channels are included, if 'passive' they are all removed, yielding a passive cell model. :param weight: Strength of synaptic input. :param input_spike_train: Numpy array containing synaptic spike times :return: cell object where cell.imem gives transmembrane currents, cell.vmem gives membrane potentials. See LFPy documentation for more details and examples. """ nrn('forall delete_section()') model_path = join('hay_model') neuron.load_mechanisms(join(model_path, 'mod')) cell_parameters = { 'morphology': join(model_path, 'cell1.hoc'), 'v_init': -65, 'passive': False, 'nsegs_method': 'lambda_f', 'lambda_f': 100, 'timeres_NEURON': 2**-3, # Should be a power of 2 'timeres_python': 2**-3, 'tstartms': -200, 'tstopms': 200, 'custom_code': [join(model_path, 'custom_codes.hoc')], 'custom_fun': [active_declarations], 'custom_fun_args': [{'conductance_type': conductance_type}], } cell = LFPy.Cell(**cell_parameters) synapse_parameters = { # 'idx': cell.get_closest_idx(x=0., y=synaptic_y_pos, z=0.), 'e': 0., 'syntype': 'ExpSyn', 'tau': 10., 'weight': 0.004, #weight, 'record_current': True, } # synapse = LFPy.Synapse(cell, **synapse_parameters) # synapse.set_spike_times(input_spike_train) n = 0 ypos = np.linspace(400,900,5) while n < len(ypos): synapse_parameters['idx'] = cell.get_closest_idx(x=0., y=ypos[n], z=0.) synapse = LFPy.Synapse(cell,**synapse_parameters) synapse.set_spike_times(input_spike_train) print 'Synapse ', n, ' inserted!' n += 1 cell.simulate(rec_imem=True, rec_vmem=True) return cell
def compile_and_load_mods(mod_folders): if isinstance(mod_folders, str): mod_folders = mod_folders.split(" ") mod_folders = [m for m in mod_folders if m not in mods_loaded] if len(mod_folders) > 0: comp = CompileMOD() targ_path = os.path.join(os.getcwd(), "compiled", "mods%s" % len(mods_loaded)) comp.compile(source_paths=mod_folders, target_path=targ_path) neuron.load_mechanisms(targ_path) mods_loaded.extend(mod_folders)
def compileModMechFiles(self, compileMod, modFolder): #Create Symbolic link if compileMod: modPath = os.path.join(str(modFolder), "x86_64") subprocess.call(["rm", "-r", modPath]) os.chdir(modFolder) subprocess.call(["nrnivmodl"]) # Load mechanism if mod path is passed if modFolder: neuron.load_mechanisms(str(modFolder))
def test_ca_initiation(): timeres = 2**-2 cut_off = 0 tstopms = 6000 tstartms = -cut_off model_path = join('lfpy_version') neuron.load_mechanisms('mod') cell_params = { 'morphology': join(model_path, 'morphologies', 'cell1.hoc'), #'rm' : 30000, # membrane resistance #'cm' : 1.0, # membrane capacitance #'Ra' : 100, # axial resistance 'v_init': -60, # initial crossmembrane potential 'passive': False, # switch on passive mechs 'nsegs_method': 'lambda_f', # method for setting number of segments, 'lambda_f': 100, # segments are isopotential at this frequency 'timeres_NEURON': timeres, # dt of LFP and NEURON simulation. 'timeres_python': 1, 'tstartms': tstartms, # start time, recorders start at t=0 'tstopms': tstopms, 'custom_code': [join(model_path, 'custom_codes.hoc')], 'custom_fun': [active_declarations], # will execute this function 'custom_fun_args': [{'conductance_type': 'active', 'hold_potential': -60}], } cell = LFPy.Cell(**cell_params) cell.simulate(rec_vmem=True, rec_imem=True) plt.subplots_adjust(wspace=0.6, hspace=0.6) plt.subplot(231, title='Membrane potential soma') plt.plot(cell.tvec, cell.vmem[0, :]) plt.ylim([-61.5, -59.8]) plt.subplot(232, title='Calcium current soma') plt.plot(cell.tvec, cell.rec_variables['ica'][0, :]) plt.ylim([0, -0.000008]) plt.subplot(233, title='Calcium concentration soma') plt.plot(cell.tvec, cell.rec_variables['cai'][0, :]) plt.ylim([0, 0.00015]) apic_idx = cell.get_closest_idx(x=0, y=0, z=1000) plt.subplot(234, title='Membrane potential apic') plt.plot(cell.tvec, cell.vmem[apic_idx, :]) plt.ylim([-61.5, -59.8]) plt.subplot(235, title='Calcium current apic') plt.plot(cell.tvec, cell.rec_variables['ica'][apic_idx, :]) plt.ylim([0, -0.000008]) plt.subplot(236, title='Calcium concentration apic') plt.plot(cell.tvec, cell.rec_variables['cai'][apic_idx, :]) plt.ylim([0, 0.00015]) # plt.savefig('ca_initiation_init.png') plt.show()
def test_tut4(self): print("------------------------------------") print("Tutorial 4 Instantiation:") print("------------------------------------") modelpath = os.path.join(self.path, 'tut4') subprocess.call(["rm", "-r", os.path.join(modelpath, "x86_64")]) owd = os.getcwd() os.chdir(modelpath) p = subprocess.check_output(["nrnivmodl"]) os.chdir(owd) neuron.load_mechanisms(modelpath) from netpyne_ui.examples.tut4.tut4 import netParams, simConfig self.getGeppettoModel(netParams, simConfig)
def neuron(self): """Return neuron module""" if self.disable_banner and not self.banner_disabled: NrnSimulator._nrn_disable_banner() self.banner_disabled = True import neuron # NOQA if self.mechanisms_directory is not None: neuron.load_mechanisms(self.mechanisms_directory, warn_if_already_loaded=False) return neuron
def example_white_noise(synaptic_y_pos=0, conductance_type='active', weight=0.001): """ Runs a NEURON simulation and returns an LFPy cell object for a single synaptic input. :param synaptic_y_pos: position along the apical dendrite where the synapse is inserted. :param conductance_type: Either 'active' or 'passive'. If 'active' all original ion-channels are included, if 'passive' they are all removed, yielding a passive cell model. :param weight: Strength of synaptic input. :param input_spike_train: Numpy array containing synaptic spike times :return: cell object where cell.imem gives transmembrane currents, cell.vmem gives membrane potentials. See LFPy documentation for more details and examples. """ # Making cell model_path = join('hay_model') neuron.load_mechanisms(join(model_path, 'mod')) # Repeat same stimuli and save only the last repeats = 2 sim_time = 1000 cell_parameters = { 'morphology': join(model_path, 'cell1.hoc'), 'v_init': -65, 'passive': False, 'nsegs_method': 'lambda_f', 'lambda_f': 100, 'timeres_NEURON': 2**-3, # Should be a power of 2 'timeres_python': 2**-3, 'tstartms': 0, 'tstopms': sim_time * repeats, 'custom_code': [join(model_path, 'custom_codes.hoc')], 'custom_fun': [active_declarations], 'custom_fun_args': [{ 'conductance_type': conductance_type }], } cell = LFPy.Cell(**cell_parameters) input_idx = cell.get_closest_idx(x=0., y=synaptic_y_pos, z=0.) cell, synapse, noiseVec = make_white_noise(cell, weight, input_idx) cell.simulate(rec_imem=True, rec_vmem=True) if not repeats is None: cut_off_idx = (len(cell.tvec) - 1) / repeats cell.tvec = cell.tvec[-cut_off_idx:] - cell.tvec[-cut_off_idx] cell.imem = cell.imem[:, -cut_off_idx:] cell.vmem = cell.vmem[:, -cut_off_idx:] plot_electrode_signal(cell, input_idx, True)
def neuron_import(request): """Provides an instance of neuron h and rxd for tests""" # to use NEURON with MPI, mpi4py must be imported first. if request.config.getoption("--mpi"): from mpi4py import MPI # noqa: F401 # we may not be not running in the test path so we have to load the mechanisms import neuron neuron.load_mechanisms(osp.abspath(osp.dirname(__file__))) from neuron import h, rxd return h, rxd
def setUpClass(cls): HERE = os.path.dirname(os.path.realpath(__file__)) ROOT = os.path.dirname(HERE) cls.path = NETPYNE_WORKDIR_PATH modelpath = os.path.join(NETPYNE_WORKDIR_PATH, 'mod') subprocess.call(["rm", "-r", os.path.join(modelpath, "x86_64")]) owd = os.getcwd() os.chdir(modelpath) p = subprocess.check_output(["nrnivmodl"]) os.chdir(owd) try: neuron.load_mechanisms(modelpath) except: logging.error("Error loading mechanisms", exc_info=True)
def __init__(self, component, parameters, initial_values, expected_spike_times, run_time): configure(1e-6) self.component = component build_dir = write_and_compile_nmodl(component) load_mechanisms(build_dir) self.name = component.name self.section = h.Section() self.cell = getattr(h, self.name)(0.5, sec=self.section) for param, value in parameters.items(): setattr(self.cell, param, value) self.initial_values = initial_values initializer.register(self) self.setup_recording() self.expected_spike_times = numpy.array(expected_spike_times) self.run_time = run_time
def compileModMechFiles(compileMod, modFolder): # Create Symbolic link if compileMod: modPath = os.path.join(str(modFolder), "x86_64") if os.path.exists(modPath): shutil.rmtree(modPath) os.chdir(modFolder) subprocess.call(["nrnivmodl"]) os.chdir('..') try: neuron.load_mechanisms(str(modFolder)) except: raise
def load_neuron_modules(mechanisms_dir, templates_dir, default_templates=True): """ :param mechanisms_dir: :param templates_dir: :param default_templates: """ h.load_file('stdgui.hoc') bionet_dir = os.path.dirname(__file__) # h.load_file(os.path.join(bionet_dir, 'import3d.hoc')) # customized import3d.hoc to supress warnings # h.load_file('import3d.hoc') h.load_file(os.path.join(bionet_dir,'default_templates', 'advance.hoc')) if mechanisms_dir is not None: neuron.load_mechanisms(str(mechanisms_dir))
def create_functional_network(cellParamName, nwParamName): ''' Public interface: used for creating fixed functional connectivity. cellParamName - parameter file of postsynaptic neuron nwParamName - parameter file of anatomical network ''' preParam = build_parameters(cellParamName) neuronParam = preParam.neuron nwParam = build_parameters(nwParamName) for mech in nwParam.NMODL_mechanisms.values(): neuron.load_mechanisms(mech) parser = cell_parser.CellParser(neuronParam.filename) parser.spatialgraph_to_cell() nwMap = NetworkMapper(parser.cell, nwParam) nwMap.create_functional_realization()
def test_M1detailed(self): print("------------------------------------") print("M1 detailed Instantiation:") print("------------------------------------") modelpath = os.path.join(self.path, 'M1detailed') modpath = os.path.join(modelpath, 'mod') subprocess.call(["rm", "-r", os.path.join(modpath, "x86_64")]) owd = os.getcwd() os.chdir(modpath) p = subprocess.check_output(["nrnivmodl"]) neuron.load_mechanisms(modpath) os.chdir(modelpath) from netpyne_ui.examples.M1detailed.init import netParams, cfg self.getGeppettoModel(netParams, cfg) os.chdir(owd)
def __init__(self, biochemical_filename, big_spine, dt, hoc_path="hoc", mod_path="mod", msn=True, spines_dist=None): """Load and initiate all the hoc and mod file. Can load the model of the neuron or otherwise can just expose general method""" # Mod file are always in a mod directory if not os.path.exists(mod_path) : print "ERROR mod path %s doesn't exist" %os.path.realpath(mod_path) sys.exit(1) neuron.load_mechanisms(mod_path) if not os.path.exists(hoc_path): print "ERROR hoc path %s doesn't exist" %os.path.realpath(hoc_path) sys.exit(1) # Hoc file assumes all the file are launched from a top directory head, tail = os.path.split(os.path.realpath(hoc_path)) preface_pos = head h('strdef preface, dirstr') # preface and dirstr used in each hoc preface_string = "preface = \"" + preface_pos + "\"" h(preface_string) if msn: # Loading the MSN model h.load_file(os.path.join(hoc_path, "nacb_main.hoc")) self._set_geometry() self.biochemical_filename = biochemical_filename # Adding the spines self.distribute_spines(spines_dist, big_spine) h.load_file("stdrun.hoc") h.v_init = -87.75 #Setting the vinit self.dt = h.dt = dt #setting internally and externally
def nrnivmodl(directory='.', suppress=False): """ Should avoid using relative paths as neuron will complain on running neuron.load_mechanisms twice on the same directory path. E.g. : Don't do this. os.chdir(mech_1) LFPy_util.other.nrnivmodl(".") os.chdir(mech_2) LFPy_util.other.nrnivmodl(".") Do this. LFPy_util.other.nrnivmodl(mech_1) LFPy_util.other.nrnivmodl(mech_2) """ tmp = os.getcwd() with suppress_stdout_stderr(suppress): os.chdir(directory) devnull = open(os.devnull, 'w') if suppress else None subprocess.call(['nrnivmodl'], stdout=devnull, shell=True) neuron.load_mechanisms(directory) os.chdir(tmp)
def initRegionIndices(self, marksFile): nrn.load_mechanisms(os.path.join(self.packagePrefix, 'etc')) for sec in self.allsec.values(): sec.insert('regionInd') marksFle = open(marksFile, 'r') #skip commented lines tempStr = '#' startChar = tempStr[0] while (startChar == '#') or (startChar == '\n'): tempStr = marksFle.readline() startChar = tempStr[0] tempStr = tempStr.rstrip('\n') marksFle.close() tempWords = tempStr.split('\t') branchPointMark = tempWords[0] regionMarks = tempWords[1:len(self.subTreesLabels) + 1] self.regionMarkSecs = [0] * len(self.subTreesLabels) regionMarksDone = 0 for secName, sec in self.allsec.iteritems(): secName = sec.name() if secName == branchPointMark: self.branchPointSec = sec elif (secName in regionMarks) and (regionMarksDone < len(self.subTreesLabels)): self.regionMarkSecs[regionMarks.index(secName)] = sec regionMarksDone += 1 for secInd in range(len(self.regionMarkSecs)): regionMarkSectionPtr = self.getPtr(self.regionMarkSecs[secInd]) self.setRegionIndex(secInd + 1, regionMarkSectionPtr) #include the demarkating section in the active zone. regionMarkSectionPtr.sec().regionInd.index = 0
def importCellsFromNet (netParams, fileName, labelList, condsList, cellNamesList, importSynMechs): h.initnrn() ''' Import cell from HOC template or python file into framework format (dict of sections, with geom, topol, mechs, syns)''' if fileName.endswith('.hoc'): print 'Importing from .hoc network not yet supported' return # h.load_file(fileName) # for cellName in cellNames: # cell = getattr(h, cellName) # create cell using template, passing dict with args # secDic, secListDic, synMechs = getCellParams(cell) elif fileName.endswith('.py'): origDir = os.getcwd() filePath,fileNameOnly = os.path.split(fileName) # split path from filename if filePath not in sys.path: # add to path if not there (need to import module) sys.path.insert(0, filePath) moduleName = fileNameOnly.split('.py')[0] # remove .py to obtain module name os.chdir(filePath) print '\nRunning network in %s to import cells into NetPyNE ...\n'%(fileName) from neuron import load_mechanisms load_mechanisms(filePath) exec('import ' + moduleName + ' as tempModule') in globals(), locals() # import module dynamically modulePointer = tempModule sys.path.remove(filePath) else: print "File name should be either .hoc or .py file" return for label, conds, cellName in zip(labelList, condsList, cellNamesList): print '\nImporting %s from %s ...'%(cellName, fileName) exec('cell = tempModule' + '.' + cellName) #cell = getattr(modulePointer, cellName) # get cell object secs, secLists, synMechs = getCellParams(cell) cellRule = {'conds': conds, 'secs': secs, 'secLists': secLists} netParams.addCellParams(label, cellRule) if importSynMechs: for synMech in synMechs: netParams.addSynMechParams(synMech.pop('label'), synMech)
def load_libraries(cls, _, install_dir): load_mechanisms(os.path.dirname(install_dir))
os.path.join(NMODL, '.'))) os.chdir(NMODL) if "win32" in sys.platform: warn("no autompile of NMODL (.mod) files on Windows. " + "Run mknrndll from NEURON bash in the folder %s and rerun example script" % NMODL) else: os.system('nrnivmodl') os.chdir(CWD) COMM.Barrier() if "win32" in sys.platform: if not NMODL in neuron.nrn_dll_loaded: neuron.h.nrn_load_dll(NMODL+"/nrnmech.dll") neuron.nrn_dll_loaded.append(NMODL) else: neuron.load_mechanisms(NMODL) os.chdir(CWD) FIGS = 'hoc_combos_syn.1_0_10.allfigures' if not os.path.isdir(FIGS): os.mkdir(FIGS) #load the LFPy SinSyn mechanism for stimulus if "win32" in sys.platform: pth = os.path.join(LFPy.__path__[0], "test").replace(os.sep, posixpath.sep) if not pth in neuron.nrn_dll_loaded: neuron.h.nrn_load_dll(pth + "/nrnmech.dll") neuron.nrn_dll_loaded.append(pth) else:
for s in string: for ss in s.split(':'): savefolder += ss + '_' savefolder += uuid.uuid4().hex os.mkdir(savefolder) os.system("cp %s '%s'" % (__file__, savefolder + '/.')) else: savefolder = None savefolder = COMM.bcast(savefolder, root=0) ##### load NMODL mechanisms #################################################### #neuron.h.load_file('stdlib.hoc') #neuron.h.load_file('nrngui.hoc') neuron.load_mechanisms("modfiles") ################################################################################ # PARAMETERS ################################################################################ tstart = 0 tend = 60000 dt = 0.05 #set up base parameter file for the LFPy.Cell or LFPy.TemplateCell class, #without specifying cell model. cellParameters = { 'v_init' : -65, 'passive' : False,
################# Initialization of MPI stuff ################################## COMM = MPI.COMM_WORLD SIZE = COMM.Get_size() RANK = COMM.Get_rank() #if True, execute full model. If False, do only the plotting. Simulation results #must exist. properrun = True #check if mod file for synapse model specified in alphaisyn.mod is loaded if not hasattr(neuron.h, 'AlphaISyn'): if RANK == 0: os.system('nrnivmodl') COMM.Barrier() neuron.load_mechanisms('.') ################################################################################ ## PARAMETERS ################################################################################ #Set up parameters using the NeuroTools.parameters.ParameterSet class. #Access parameters defined in example script implementing the network using #pynest, brunel_alpha_nest.py, adapted from the NEST v2.4.1 release. This will #not execute the network model, but see below. import brunel_alpha_nest as BN #set up file destinations differentiating between certain output
myzip.close() #compile mod files every time, because of incompatibility with Hay2011 files: if "win32" in sys.platform: pth = "cells" warn("no autompile of NMODL (.mod) files on Windows. " + "Run mknrndll from NEURON bash in the folder cells and rerun example script") if not pth in neuron.nrn_dll_loaded: neuron.h.nrn_load_dll(pth+"/nrnmech.dll") neuron.nrn_dll_loaded.append(pth) else: os.system(''' cd cells nrnivmodl ''') neuron.load_mechanisms('cells') ################################################################################ # Define parameters, using dictionaries # It is possible to set a few more parameters for each class or functions, but # we chose to show only the most important ones here. ################################################################################ #define cell parameters used as input to cell-class cellParameters = { 'morphology' : 'morphologies/L5_Mainen96_wAxon_LFPy.hoc', 'cm' : 1.0, # membrane capacitance 'Ra' : 150, # axial resistance 'v_init' : -65, # initial crossmembrane potential 'passive' : True, # turn on passive mechanism 'passive_parameters' : {'g_pas' : 1./30000, 'e_pas' : -65}, # passive params
os.chdir(PSET.NMODL) # patch faulty ProbGABAAB_EMS.mod file (otherwise stochastic inhibitory synapses will stay closed except at first activation) diff = '''319c319 < urand = scop_random(1) --- > value = scop_random(1) ''' f = open('ProbGABAAB_EMS.patch', 'w') f.writelines(diff) f.close() os.system('patch ProbGABAAB_EMS.mod ProbGABAAB_EMS.patch') os.system('nrnivmodl') os.chdir(PSET.CWD) COMM.Barrier() neuron.load_mechanisms(PSET.NMODL) os.chdir(PSET.CWD) # Fill in dictionary of population-specific cell parameters for NRN in PSET.populationParameters['me_type']: os.chdir(os.path.join(PSET.CWD, PSET.CELLPATH, NRN)) #get the template name f = open("template.hoc", 'r') templatename = get_templatename(f) f.close() #get biophys template name f = open("biophysics.hoc", 'r') biophysics = get_templatename(f)
def runsimulation(legtext,amp1,dur1,start1): def recvolt(seg): rec_v=neuron.h.Vector() rec_v.record(seg._ref_v) return rec_v def rectime(seg): rec_t=neuron.h.Vector() rec_t.record(seg._ref_t) return rec_t def setstim(seg,amp,duration,start,segdist): stim=neuron.h.IClamp(seg(segdist)) stim.delay=start stim.dur=duration stim.amp=amp return stim load_mechanisms("/home/ben/boxing_bk/neuron_model/downloaded_models/Figure5/") #neuron.h.create soma cell1=cell(maxNa,maxK,maxLeak,NaRev,KRev,LeakRev) rec_v_cell1=recvolt(cell1.soma(0.5)) ###SPECIFY THE VALUES OF THE SECTION TO BE RECORDED## #record time from NEURON (neuron.h._ref_t) rec_t=neuron.h.Vector() rec_t.record(neuron.h._ref_t) #record voltage from center of the soma #for i in dends: cell1_stim=setstim(cell1.soma,amp1,dur1,start1,0.5) '''ATTRIBUTES OF ELECTRODE amp: Amplitude of the injected current delay: Time of activation in ms dur: Duration of the stimulation ''' #initialize the value of the voltage neuron.h.finitialize(-65) #set time of the simulation tstop=300 #create ndendrites ndend=1 dends=range(ndend) #Run the simulation neuron.run(tstop) #PLOT THE RESULT time=rec_t.as_numpy() cell1_volt=rec_v_cell1.as_numpy() plt.plot(time,cell1_volt,color=colors[cellnum],linewidth=3.0) legendlist.append(legtext) plt.legend(legendlist) global cellnum if cellnum==4: cellnum=0 else: cellnum=cellnum+1 #plt.plot(time,cell2_volt,color='k',linewidth=3.0) plt.xlabel("Time (ms)") plt.ylabel("Voltage (mV)") #plt.axis(xmin=210,xmax=216,\ #ymin=min(cell1_volt)-5,ymax=max(cell1_volt)+5) plt.show()
myzip.close() #compile mod files every time, because of incompatibility with Mainen96 files: if "win32" in sys.platform: pth = "L5bPCmodelsEH/mod/" warn("no autompile of NMODL (.mod) files on Windows.\n" + "Run mknrndll from NEURON bash in the folder L5bPCmodelsEH/mod and rerun example script") if not pth in neuron.nrn_dll_loaded: neuron.h.nrn_load_dll(pth+"nrnmech.dll") neuron.nrn_dll_loaded.append(pth) else: os.system(''' cd L5bPCmodelsEH/mod/ nrnivmodl ''') neuron.load_mechanisms('L5bPCmodelsEH/mod/') ################################################################################ # Simulation parameters ################################################################################ ##define cell parameters used as input to cell-class cellParameters = { 'morphology' : 'L5bPCmodelsEH/morphologies/cell1.asc', 'templatefile' : ['L5bPCmodelsEH/models/L5PCbiophys3.hoc', 'L5bPCmodelsEH/models/L5PCtemplate.hoc'], 'templatename' : 'L5PCtemplate', 'templateargs' : 'L5bPCmodelsEH/morphologies/cell1.asc', 'passive' : False,
else: raise Exception("synapse type does not have an attribute '%s'" % name) return property(_get, _set) setattr(Connection, 'U', generate_synapse_property('U')) setattr(Connection, 'tau_rec', generate_synapse_property('tau_rec')) setattr(Connection, 'tau_facil', generate_synapse_property('tau_facil')) setattr(Connection, 'u0', generate_synapse_property('u0')) def generate_stdp_property(name): def _get(self): return getattr(self.weight_adjuster, name) def _set(self, val): setattr(self.weight_adjuster, name, val) return property(_get, _set) setattr(Connection, 'w_max', generate_stdp_property('wmax')) setattr(Connection, 'w_min', generate_stdp_property('wmin')) setattr(Connection, 'A_plus', generate_stdp_property('aLTP')) setattr(Connection, 'A_minus', generate_stdp_property('aLTD')) setattr(Connection, 'tau_plus', generate_stdp_property('tauLTP')) setattr(Connection, 'tau_minus', generate_stdp_property('tauLTD')) # --- Initialization, and module attributes ------------------------------------ mech_path = os.path.join(pyNN_path[0], 'neuron', 'nmodl') load_mechanisms(mech_path) # maintains a list of mechanisms that have already been imported state = _State() # a Singleton, so only a single instance ever exists del _State initializer = _Initializer() del _Initializer
#unzip: myzip = zipfile.ZipFile('L5bPCmodelsEH.zip', 'r') myzip.extractall('.') myzip.close() #compile NMODL language files os.system(''' cd L5bPCmodelsEH/mod/ nrnivmodl cd - ''') COMM.Barrier() ##### load NEURON mechanisms from Hay et al. 2011 ############################## neuron.load_mechanisms("L5bPCmodelsEH/mod") ################################################################################ # PARAMETERS ################################################################################ #set up base parameter file for the LFPy.Cell or LFPy.TemplateCell class, #without specifying cell model. cellParameters = { 'v_init' : -80, 'passive' : False, 'nsegs_method' : None, 'timeres_NEURON' : 2**-5, 'timeres_python' : 2**-5, 'tstartms' : 0.,
# ###################################################################################### # MODIFIED HISTORY # 2015.04.30 This code is eddited for al_V2 from neuron import h import neuron as nrn import os.path import numpy as np import csv import operator import random import swc nrn.load_mechanisms("./mod") h.load_file("../input/swc/CellSwc_Ver2.hoc") def CalcDistance(cmpt1, cmpt2): #cmpt means compartment cmpt1.push() sr1 = h.SectionRef(sec=cmpt1) x1 = h.x3d(0.5) y1 = h.y3d(0.5) z1 = h.z3d(0.5) h.pop_section() cmpt2.push() sr2 = h.SectionRef(sec=cmpt2) x2 = h.x3d(0.5) y2 = h.y3d(0.5)
def load_libraries(self, name, url): install_dir = self.get_install_dir(name, url) load_mechanisms(os.path.dirname(install_dir))
import os import posixpath import unittest import numpy as np import LFPy import neuron # for nosetests to run load mechanisms if "win32" in sys.platform: pth = os.path.join(LFPy.__path__[0], 'test', 'nrnmech.dll') pth = pth.replace(os.sep, posixpath.sep) if not pth in neuron.nrn_dll_loaded: neuron.h.nrn_load_dll(pth) neuron.nrn_dll_loaded.append(pth) else: neuron.load_mechanisms(os.path.join(LFPy.__path__[0], 'test')) class testPointProcess(unittest.TestCase): """ test class LFPy.PointProcess """ def test_PointProcess_00(self): cell = LFPy.Cell(morphology=os.path.join(LFPy.__path__[0], 'test', 'ball_and_sticks.hoc')) pp = LFPy.PointProcess(cell=cell, idx=0) self.assertTrue(np.alltrue(np.array([pp.x, pp.y, pp.z])==cell.somapos)) self.assertEqual(pp.idx, 0) class testSynapse(unittest.TestCase): """
stim.delay=delay stim.dur=dur stim.amp=amp return stim def recvolt(seg): rec_v=neuron.h.Vector() rec_v.record(seg._ref_v) return rec_v def rectime(seg): rec_t=neuron.h.Vector() rec_t.record(seg._ref_t) return rec_t load_mechanisms('/home/ben/Desktop/5ht3a_project/neuron_model/downloaded_neuron_models/Hipp_paper_code/') h.xopen('/home/ben/Desktop/5ht3a_project/neuron_model/downloaded_neuron_models/Hipp_paper_code/basket_cell17S.hoc') h.xopen('/home/ben/Desktop/5ht3a_project/neuron_model/downloaded_neuron_models/Hipp_paper_code/pyramidal_cell_14Vb.hoc') h.xopen('/home/ben/Desktop/5ht3a_project/neuron_model/downloaded_neuron_models/Hipp_paper_code/olm_cell2.hoc') pyrstren=np.arange(.005,.01,.001) pvstren=np.arange(0,0.3,.05) olmexcstren=np.arange(.05,.055,.001) olmstren=np.arange(.04,.05,.002) olmcombs=itertools.product(olmexcstren,olmstren) pvpyrcombs=itertools.product(pyrstren,pvstren)
''' import os from os.path import join import sys from glob import glob import numpy as np import matplotlib matplotlib.use('Agg') import pylab as plt import neuron import LFPy neuron.h.load_file("stdrun.hoc") neuron.h.load_file("import3d.hoc") neuron.load_mechanisms('mods') def get_templatename(f): ''' Assess from hoc file the templatename being specified within Arguments --------- f : file, mode 'r' Returns ------- templatename : str '''