def prepare_epth_ob(params):
print "Creating ORN parameters...."
OrnParamClass = CreateOrnParameters.CreateOrnParameters(params)
ok = OrnParamClass.create_single_odorant_patterns()
# EPTH -> OB connections are not affected by the pattern
#print "Creating connections: orn -> mit"
ConnectionClass = CreateObConnections.CreateObConnections(params)
ConnectionClass.connect_orn_mit()
ConnectionClass.connect_orn_pg()
ConnectionClass.connect_pg_mit_serial()
ConnectionClass.connect_pg_mit_reciprocal()
ConnectionClass.connect_mt_gran_local()
ConnectionClass.connect_mt_gran_global()
def set_orn_params(self):
# class to write parameters into file
OrnParamClass = CreateOrnParameters.CreateOrnParameters(self.params)
OrnParamClass.param_list = ["gna", "gk", "gkcag", "gcal", "gleak_orn", "tau_cadec"]
# define parameters:
OrnParamClass.set_oor_value_for_conc_sweep()
OrnParamClass.current_param_values = np.zeros((self.params["n_orn_x"], len(OrnParamClass.param_list)))
# OrnParamClass.current_param_values[col][2]
# corresponds to the "gkcag" values for all ORNs in this type (i.e. giving one of the n_gor response curves)
self.gor_values = OrnParamClass.gor_values # set based on self.params['gor_min, gor_max, gor_exp']
self.gkcag_values = linear_transformation(self.gor_values, self.gkcag_min, self.gkcag_max)
self.gcal_values = linear_transformation(self.gor_values, self.gcal_min, self.gcal_max)
self.gleak_values = linear_transformation(self.gor_values, self.gleak_min, self.gleak_max)
testparams = np.ones((self.params['n_gor'], 6))
testparams[:, 0] *= 0.5 # g_na
testparams[:, 1] *= 0.05 # g_k
testparams[:, 2] = self.gkcag_values
testparams[:, 3] = self.gcal_values
testparams[:, 4] = self.gleak_values
testparams[:, 5] *= 1000 # tau_ca_decay
for i_ in xrange(n_test_curves):
for param in xrange(len(OrnParamClass.param_list)):
OrnParamClass.current_param_values[i_][param] = testparams[i_, param]
# now overwrite gleak values according to the corresponding function
param_fn = params['orn_params_fn_base'] + '%d.dat' % self.sim_cnt
OrnParamClass.write_current_param_values_to_file(param_fn)
log_file = open("%s/params_handtuning_%d.txt" % (params['params_folder'], self.sim_cnt), 'w')
for i in xrange(params["n_gor"]):
line = "%.1e\t%.1e\t%.1e\t%.1e\t%.1e\t%.1e\t%.1e\n" % ( \
OrnParamClass.gor_values[i],\
OrnParamClass.current_param_values[i][0],\
OrnParamClass.current_param_values[i][1],\
OrnParamClass.current_param_values[i][2],\
OrnParamClass.current_param_values[i][3],\
OrnParamClass.current_param_values[i][4],\
OrnParamClass.current_param_values[i][5])
log_file.write(line)
log_file.flush()
"""
import simulation_parameters
import os
import time
import MergeSpikefiles
import SetOfCurvesPlotter
import CreateOrnParameters
param_tool = simulation_parameters.parameter_storage()
params = param_tool.params
param_tool.hoc_export()
prepare = True
if prepare:
OrnParamClass = CreateOrnParameters.CreateOrnParameters(params)
OrnParamClass.create_params_for_response_curve()
t1 = time.time()
sim_cnt = 0
pn = sim_cnt
param_file_orns = params['orn_params_fn_base'] + '%d.dat' % pn
assert os.path.exists(
param_file_orns
), 'File does not exist: %s\nPlease run prepare_epth_response_curve.py before!' % param_file_orns
if params['with_artificial_orns']:
neuron_command = "mpirun -np %d $(which nrniv) -mpi -nobanner -nogui \
-c \"x=%d\" -c \"strdef param_file\" -c \"sprint(param_file, \\\"%s\\\")\" start_file_artificial_orn_spikes.hoc > delme%d" \
% (params['n_proc'], pn, params['hoc_file'], pn)
default_folder = os.path.abspath(sys.argv[1]) + '/' # this should include all the data ready to run a full system
print 'Taking data from:', default_folder
srcs = []
srcs.append('%sParameters/' % default_folder)
srcs.append('%sConnections/' % default_folder)
for src in srcs:
cmd = 'cp -r %s %s' % (src, params['folder_name'])
print cmd
os.system(cmd)
param_tool.write_parameters_to_file(params["info_file"])
param_tool.write_parameters_to_file() #
param_tool.hoc_export() #
default_activation_matrix_fn = default_folder + 'Parameters/activation_matrix.dat'
OrnParamClass = CreateOrnParameters.CreateOrnParameters(params) # patterns for ORN activation must be recreated to add noise
default_activation_matrix = '%sParameters/activation_matrix.dat' % default_folder
ok = OrnParamClass.create_single_odorant_patterns(given_activation_matrix=default_activation_matrix)
for fn in params['all_connection_fns']:
assert os.path.exists(fn), 'Required dile does not exist: %s' % fn
for fn in [params['pyr_params_file'], params['readout_params_file']]:
assert os.path.exists(fn), 'Required dile does not exist: %s' % fn
for pn in xrange(params['n_patterns']):
fn = params['orn_params_fn_base'] + '%d.dat' % pn
assert os.path.exists(fn)
print 'Ready - Go!\t', params['folder_name']
import CreateOrnParameters t1 = time.time() # ------------ I N I T ----------------------------- # The simulation_parameters module defines a class for simulation parameter storage #param_tool = network_parameters_BGL.simulation_parameters_BGL() param_tool = simulation_parameters.parameter_storage() # params is the dictionary with all parameters params = param_tool.params param_tool.write_parameters_to_file(params["info_file"]) # human readable param_tool.write_parameters_to_file() # param_tool.hoc_export( ) # write the simulation parameters to a NEURON executable file #param_tool.print_cell_gids() OrnParam = CreateOrnParameters.CreateOrnParameters(params) OrnParam.create_params_for_response_curve() # EPTH -> OB connections are not affected by the pattern #print "Creating connections: orn -> mit" ConnectionClass = CreateObConnections.CreateObConnections(params) ConnectionClass.connect_orn_mit() ConnectionClass.connect_orn_pg() ConnectionClass.connect_pg_mit_serial() ConnectionClass.connect_pg_mit_reciprocal() ConnectionClass.connect_mt_gran_local() ConnectionClass.connect_mt_gran_global() print "Creating ORN parameters...." print "Folder name:", params['folder_name'] t2 = time.time()