def go(self):
"""
Start the simulation once it's been intialized
"""
cells = [self.target_cell]
self.params.set_bioparameter("unphysiological_offset_current", "0.25nA", "Testing IClamp", "0")
self.params.set_bioparameter("unphysiological_offset_current_del", "0 ms", "Testing IClamp", "0")
self.params.set_bioparameter("unphysiological_offset_current_dur", "%f ms"%self.sim_time, "Testing IClamp", "0")
generate(self.reference,
self.params,
cells=cells,
cells_to_stimulate=cells,
duration=self.sim_time,
dt=self.dt,
vmin=-72 if self.params.level=='A' else -52,
vmax=-48 if self.params.level=='A' else -28,
validate=(self.params.level!='B'),
verbose=False)
self.lems_file = "LEMS_%s.xml"%(self.reference)
print("Running a simulation of %s ms with timestep %s ms"%(self.sim_time, self.dt))
self.go_already = True
results = pynml.run_lems_with_jneuroml(self.lems_file, nogui=True, load_saved_data=True, plot=False, verbose=False)
self.rec_t = results['t']
res_template = '%s/0/generic_iaf_cell/v'
if self.params.level == 'C' or self.params.level == 'D':
res_template = '%s[0]/v'
self.rec_v = results[res_template%self.target_cell]
def setUpClass(cls):
# read data from spread sheet
cls.cell_names, cls.conns = SpreadsheetDataReader.readDataFromSpreadsheet("../../../../")
print (str(len(cls.cell_names))+' unique cell names in CElegensNeuronTables')
# generate all nml files once
for index in cls.conns:
origin = index.pre_cell
target = index.post_cell
fn = origin+"_"+target
fnswap = target+"_"+origin
if fn not in cls.checked_files:
if fnswap not in cls.checked_files:
# generate xml and nml file
cells_to_plot = "["+origin+","+target+"]"
cells_to_stimulate = "["+origin+"]"
generate(fn, params, cells=cells_to_plot, cells_to_stimulate=cells_to_stimulate, duration=500, validate=False, test=True)
cls.checked_files.append(fn)
cls.counter += 1
print "Total files generated %i"%cls.counter
def setup(parameter_set,
generate=False,
duration=1080, #Match time run in Figure 1C of Kato et. al, Cell 2015 http://dx.doi.org/10.1016/j.cell.2015.09.034
dt=0.1,
target_directory='examples',
include_muscles = True):
exec('from parameters_%s import ParameterisedModel'%parameter_set)
params = ParameterisedModel()
# Match the labelled cells in Figure 1C of Kato et. al, Cell 2015 http://dx.doi.org/10.1016/j.cell.2015.09.034
cells_to_stimulate = ["AVAR", "AVAL", "RIMR", "RIML", "AVER", "VA01", "SABVL", "OLQVL", "DB01", "VB01", "DB02", "RMER", "RMEL", "RID", "AVBR", "RIBL", "VB02", "RMED", "RMEV", "AVBL", "SMDVL", "SMDVR", "RIVL", "RIVR", "OLQVR", "OLQDL", "AIBL", "AIBR", "OLQDR", "RIFR", "SMBDR"]
# Plot some directly stimulated & some not stimulated
cells_to_plot = ["AVAR", "AVAL", "RIMR", "RIML", "AVER", "VA01", "SABVL", "OLQVL", "DB01", "VB01", "DB02", "RMER", "RMEL", "RID", "AVBR", "RIBL", "VB02", "RMED", "RMEV", "AVBL", "SMDVL", "SMDVR", "RIVL", "RIVR", "OLQVR", "OLQDL", "AIBL", "AIBR", "OLQDR", "RIFR", "SMBDR"]
reference = "c302_%s_Kato"%parameter_set
cell_names, conns = c302.get_cell_names_and_connection()
if generate:
c302.generate(reference,
params,
cells_to_plot=cells_to_plot,
cells_to_stimulate=cells_to_stimulate,
include_muscles = include_muscles,
duration=duration,
dt=dt,
vmin=-72 if parameter_set=='A' else -52,
vmax=-48 if parameter_set=='A' else -28,
validate=(parameter_set!='B'),
target_directory=target_directory)
return cell_names, cells_to_stimulate, params, include_muscles
def setup(parameter_set,
generate=False,
duration=500,
dt=0.01,
target_directory='examples',
data_reader="SpreadsheetDataReader",
param_overrides={},
verbose=True):
exec('from parameters_%s import ParameterisedModel'%parameter_set)
params = ParameterisedModel()
cells = ["M1","M2L","M2R","M3L","M3R","M4","M5","I1L","I1R","I2L","I2R","I3","I4","I5","I6","MI","NSML","NSMR","MCL","MCR"]
cells_to_stimulate = ["M1","M3R","M4","M5","I1L","I4","I5","I6","MCL","MCR"]
reference = "c302_%s_Pharyngeal"%parameter_set
if generate:
c302.generate(reference,
params,
cells=cells,
cells_to_stimulate=cells_to_stimulate,
duration=duration,
dt=dt,
target_directory=target_directory,
param_overrides=param_overrides,
verbose=verbose)
return cells, cells_to_stimulate, params, []
def setup(parameter_set,
generate=False,
duration=500,
dt=0.01,
target_directory='examples'):
exec('from parameters_%s import ParameterisedModel'%parameter_set)
params = ParameterisedModel()
cells = ["M1","M2L","M2R","M3L","M3R","M4","M5","I1L","I1R","I2L","I2R","I3","I4","I5","I6","MI","NSML","NSMR","MCL","MCR"]
cells_to_stimulate = ["M1","M3R","M4","M5","I1L","I4","I5","I6","MCL","MCR"]
reference = "c302_%s_Pharyngeal"%parameter_set
if generate:
c302.generate(reference,
params,
cells=cells,
cells_to_stimulate=cells_to_stimulate,
duration=duration,
dt=dt,
validate=(parameter_set!='B'),
target_directory=target_directory)
return cells, cells_to_stimulate, params, False
def setup(parameter_set,
generate=False,
duration=500,
dt=0.01,
target_directory='examples',
data_reader="SpreadsheetDataReader"):
exec('from parameters_%s import ParameterisedModel'%parameter_set)
params = ParameterisedModel()
cells = ["M1","M2L","M2R","M3L","M3R","M4","M5","I1L","I1R","I2L","I2R","I3","I4","I5","I6","MI","NSML","NSMR","MCL","MCR"]
cells_to_stimulate = ["M1","M3R","M4","M5","I1L","I4","I5","I6","MCL","MCR"]
reference = "c302_%s_Pharyngeal"%parameter_set
if generate:
c302.generate(reference,
params,
cells=cells,
cells_to_stimulate=cells_to_stimulate,
duration=duration,
dt=dt,
validate=(parameter_set!='B'),
target_directory=target_directory)
return cells, cells_to_stimulate, params, False
def setup(parameter_set, generate=False):
exec('from parameters_%s import ParameterisedModel'%parameter_set)
params = ParameterisedModel()
exc_pre = "URYDL"
exc_post = "SMDDR"
inh_pre = "VD12"
inh_post = "VB11"
gap_1 = "AIZL"
gap_2 = "ASHL"
cells = [exc_pre, exc_post, inh_pre, inh_post]
cells_to_stimulate = [exc_pre, inh_pre]
if parameter_set=='B':
cells.append(gap_1)
cells.append(gap_2)
cells_to_stimulate.append(gap_1)
reference = "c302_%s_Syns"%parameter_set
if generate:
c302.generate(reference,
params,
cells=cells,
cells_to_stimulate=cells_to_stimulate,
duration=500,
dt=0.1,
validate=(parameter_set!='B'),
target_directory='examples')
return cells, cells_to_stimulate, params
def setup(parameter_set,
generate=False,
duration=1000,
dt=0.1,
target_directory='examples'):
exec('from parameters_%s import ParameterisedModel'%parameter_set)
params = ParameterisedModel()
params.set_bioparameter("unphysiological_offset_current", "5pA", "Testing IClamp", "0")
params.set_bioparameter("unphysiological_offset_current_del", "100 ms", "Testing IClamp", "0")
params.set_bioparameter("unphysiological_offset_current_dur", "800 ms", "Testing IClamp", "0")
my_cell = "ADAL"
cells = [my_cell]
cells_to_stimulate = [my_cell]
reference = "c302_%s_IClamp"%parameter_set
if generate:
c302.generate(reference,
params,
cells=cells,
cells_to_stimulate=cells_to_stimulate,
duration=duration,
dt=dt,
validate=('B' not in parameter_set),
target_directory=target_directory)
return cells, cells_to_stimulate, params, False
def setup(parameter_set,
generate=False,
duration=500,
dt=0.1,
target_directory='examples',
include_muscles = True):
exec('from parameters_%s import ParameterisedModel'%parameter_set)
params = ParameterisedModel()
# Some random set of neurons
cells_to_stimulate = ["ADAL", "ADAR", "M1","M2L","M3L","M3R","M4","I1R","I2L","I5","I6","MI","NSMR","MCL","ASEL", "AVEL", "AWAR", "DB1", "DVC", "RIAR", "RMDDL"]
# Plot some directly stimulated & some not stimulated
cells_to_plot = ["ADAL", "ADAR", "PVDR", "BDUR","I1R","I2L"]
reference = "c302_%s_Full"%parameter_set
cell_names, conns = c302.get_cell_names_and_connection()
if generate:
c302.generate(reference,
params,
cells_to_plot=cells_to_plot,
cells_to_stimulate=cells_to_stimulate,
include_muscles = include_muscles,
duration=duration,
dt=dt,
vmin=-72 if parameter_set=='A' else -52,
vmax=-48 if parameter_set=='A' else -28,
validate=(parameter_set!='B'),
target_directory=target_directory)
return cell_names, cells_to_stimulate, params, include_muscles
def setUpClass(cls):
# read data from spread sheet
cls.cell_names, cls.conns = SpreadsheetDataReader.readDataFromSpreadsheet("../../../../")
print (str(len(cls.cell_names))+' unique cell names in CElegensNeuronTables')
# generate all nml files once
for index in cls.conns:
origin = index.pre_cell
target = index.post_cell
fn = origin+"_"+target
fnswap = target+"_"+origin
if fn not in cls.checked_files:
if fnswap not in cls.checked_files:
# generate xml and nml file
cells_to_plot = "["+origin+","+target+"]"
cells_to_stimulate = "["+origin+"]"
generate(fn, params, cells=cells_to_plot, cells_to_stimulate=cells_to_stimulate, duration=500, validate=False, test=True)
cls.checked_files.append(fn)
cls.counter += 1
print "Total files generated %i"%cls.counter
def setup(parameter_set, generate=False):
exec('from parameters_%s import ParameterisedModel' % parameter_set)
params = ParameterisedModel()
exc_pre = "URYDL"
exc_post = "SMDDR"
inh_pre = "VD12"
inh_post = "VB11"
gap_1 = "AIZL"
gap_2 = "ASHL"
cells = [exc_pre, exc_post, inh_pre, inh_post]
cells_to_stimulate = [exc_pre, inh_pre]
if parameter_set == 'B':
cells.append(gap_1)
cells.append(gap_2)
cells_to_stimulate.append(gap_1)
reference = "c302_%s_Syns" % parameter_set
if generate:
c302.generate(reference,
params,
cells=cells,
cells_to_stimulate=cells_to_stimulate,
duration=500,
dt=0.1,
validate=(parameter_set != 'B'),
target_directory='examples')
return cells, cells_to_stimulate, params, False
def setup(parameter_set, generate=False):
exec('from parameters_%s import ParameterisedModel' % parameter_set)
params = ParameterisedModel()
params.set_bioparameter("unphysiological_offset_current", "0.35nA",
"Testing IClamp", "0")
params.set_bioparameter("unphysiological_offset_current_del", "5 ms",
"Testing IClamp", "0")
params.set_bioparameter("unphysiological_offset_current_dur", "1000 ms",
"Testing IClamp", "0")
params.add_bioparameter("chem_exc_syn_gbase", "5 nS", "BlindGuess", "0.1")
params.add_bioparameter("chem_exc_syn_decay", "5 ms", "BlindGuess", "0.1")
params.add_bioparameter("chem_inh_syn_gbase", "5 nS", "BlindGuess", "0.1")
params.add_bioparameter("chem_inh_syn_decay", "20 ms", "BlindGuess", "0.1")
params.add_bioparameter("elec_syn_gbase", "0.2 nS", "BlindGuess", "0.1")
# Any neurons connected to muscles
cells = [
'DB1', 'DB2', 'DB3', 'DB4', 'DB5', 'DB6', 'DB7', 'VB1', 'VB10', 'VB11',
'VB2', 'VB3', 'VB4', 'VB5', 'VB6', 'VB7', 'VB8', 'VB9'
]
cells += ['AVBL', 'PVCL']
#cells=None # implies all cells...
cells_to_stimulate = ['PVCL', 'AVBL']
# Plot some directly stimulated & some not stimulated
cells_to_plot = [
'AVBL', 'PVCL', 'PVCR', 'DB1', 'DB2', 'DB4', 'DB4', 'VB1', 'VB2',
'VB3', 'VB4'
]
reference = "c302_%s_Oscillator" % parameter_set
include_muscles = True
#include_muscles = False
if generate:
c302.generate(reference,
params,
cells=cells,
cells_to_plot=cells_to_plot,
cells_to_stimulate=cells_to_stimulate,
include_muscles=include_muscles,
duration=600,
dt=0.1,
validate=(parameter_set != 'B'),
target_directory='examples')
return cells, cells_to_stimulate, params, include_muscles
def setup(
parameter_set,
generate=False,
duration=1080, #Match time run in Figure 1C of Kato et. al, Cell 2015 http://dx.doi.org/10.1016/j.cell.2015.09.034
dt=0.1,
target_directory='examples',
muscles_to_include=None,
data_reader="SpreadsheetDataReader",
param_overrides={},
config_param_overrides={},
verbose=True):
exec('from parameters_%s import ParameterisedModel' % parameter_set)
params = ParameterisedModel()
# Match the labelled cells in Figure 1C of Kato et. al, Cell 2015 http://dx.doi.org/10.1016/j.cell.2015.09.034
cells_to_stimulate = [
"AVAR", "AVAL", "RIMR", "RIML", "AVER", "VA01", "SABVL", "OLQVL",
"DB01", "VB01", "DB02", "RMER", "RMEL", "RID", "AVBR", "RIBL", "VB02",
"RMED", "RMEV", "AVBL", "SMDVL", "SMDVR", "RIVL", "RIVR", "OLQVR",
"OLQDL", "AIBL", "AIBR", "OLQDR", "RIFR", "SMBDR"
]
# Plot some directly stimulated & some not stimulated
cells_to_plot = [
"AVAR", "AVAL", "RIMR", "RIML", "AVER", "VA01", "SABVL", "OLQVL",
"DB01", "VB01", "DB02", "RMER", "RMEL", "RID", "AVBR", "RIBL", "VB02",
"RMED", "RMEV", "AVBL", "SMDVL", "SMDVR", "RIVL", "RIVR", "OLQVR",
"OLQDL", "AIBL", "AIBR", "OLQDR", "RIFR", "SMBDR"
]
reference = "c302_%s_Kato" % parameter_set
cell_names, conns = c302.get_cell_names_and_connection()
if generate:
c302.generate(reference,
params,
cells_to_plot=cells_to_plot,
cells_to_stimulate=cells_to_stimulate,
muscles_to_include=muscles_to_include,
duration=duration,
dt=dt,
vmin=-72 if parameter_set == 'A' else -52,
vmax=-48 if parameter_set == 'A' else -28,
target_directory=target_directory,
param_overrides=param_overrides,
verbose=verbose,
data_reader=data_reader)
return cell_names, cells_to_stimulate, params, muscles_to_include
def setup(parameter_set, generate=False):
exec('from parameters_%s import ParameterisedModel'%parameter_set)
params = ParameterisedModel()
cells = ['RIAL', 'RIAR', 'SMDVL', 'SMDVR', 'SMDDL', 'SMDDR', 'AIYL', 'AIYR', 'AWCL', 'AWCR']
#cells = None
cells_to_stimulate = []
reference = "c302_%s_AWC"%parameter_set
target_directory='examples'
if generate:
nml_doc = c302.generate(reference,
params,
cells=cells,
cells_to_stimulate=cells_to_stimulate,
duration=800,
dt=0.1,
validate=(parameter_set!='B'),
target_directory = target_directory)
stim_amplitude = "0.6nA"
c302.add_new_input(nml_doc, "AWCL", "100ms", "100ms", stim_amplitude, params)
c302.add_new_input(nml_doc, "AWCR", "500ms", "100ms", stim_amplitude, params)
nml_file = target_directory+'/'+reference+'.nml'
writers.NeuroMLWriter.write(nml_doc, nml_file) # Write over network file written above...
print("(Re)written network file to: "+nml_file)
return cells, cells_to_stimulate, params, False
def setup(parameter_set,
generate=False,
duration=2000,
dt=0.05,
target_directory='examples',
data_reader="SpreadsheetDataReader",
param_overrides={},
verbose=True):
exec('from parameters_%s import ParameterisedModel' % parameter_set)
params = ParameterisedModel()
my_cells = []
muscles_to_include = ['MDR01']
cells = my_cells
cells_total = my_cells + muscles_to_include
reference = "c302_%s_IClampMuscle" % parameter_set
nml_doc = None
if generate:
nml_doc = c302.generate(reference,
params,
cells=cells,
cells_to_stimulate=muscles_to_include,
muscles_to_include=muscles_to_include,
duration=duration,
dt=dt,
target_directory=target_directory,
param_overrides=param_overrides,
verbose=verbose,
data_reader=data_reader)
return cells, cells_total, params, muscles_to_include, nml_doc
def setup(parameter_set, generate=False):
exec('from parameters_%s import ParameterisedModel'%parameter_set)
params = ParameterisedModel()
params.set_bioparameter("unphysiological_offset_current", "0.35nA", "Testing IClamp", "0")
params.set_bioparameter("unphysiological_offset_current_del", "5 ms", "Testing IClamp", "0")
params.set_bioparameter("unphysiological_offset_current_dur", "1000 ms", "Testing IClamp", "0")
params.add_bioparameter("chem_exc_syn_gbase", "5 nS", "BlindGuess", "0.1")
params.add_bioparameter("chem_exc_syn_decay", "5 ms", "BlindGuess", "0.1")
params.add_bioparameter("chem_inh_syn_gbase", "5 nS", "BlindGuess", "0.1")
params.add_bioparameter("chem_inh_syn_decay", "20 ms", "BlindGuess", "0.1")
params.add_bioparameter("elec_syn_gbase", "0.2 nS", "BlindGuess", "0.1")
# Any neurons connected to muscles
cells = ['DB1', 'DB2', 'DB3', 'DB4', 'DB5', 'DB6', 'DB7',
'VB1', 'VB10', 'VB11', 'VB2', 'VB3', 'VB4', 'VB5', 'VB6', 'VB7', 'VB8', 'VB9']
cells+=['AVBL','PVCL']
#cells=None # implies all cells...
cells_to_stimulate = ['PVCL', 'AVBL']
# Plot some directly stimulated & some not stimulated
cells_to_plot = ['AVBL','PVCL', 'PVCR', 'DB1','DB2', 'DB4','DB4','VB1','VB2', 'VB3', 'VB4']
reference = "c302_%s_Oscillator"%parameter_set
include_muscles = True
#include_muscles = False
if generate:
c302.generate(reference,
params,
cells=cells,
cells_to_plot=cells_to_plot,
cells_to_stimulate=cells_to_stimulate,
include_muscles = include_muscles,
duration=600,
dt=0.1,
validate=(parameter_set!='B'),
target_directory='examples')
return cells, cells_to_stimulate, params, include_muscles
def setup(parameter_set,
generate=False,
duration=500,
dt=0.05,
target_directory='examples',
data_reader="SpreadsheetDataReader",
param_overrides={},
verbose=True):
exec('from parameters_%s import ParameterisedModel' % parameter_set)
params = ParameterisedModel()
stim_amplitudes = ["3pA", "5pA"]
duration = (len(stim_amplitudes)) * 1000
params.set_bioparameter("unphysiological_offset_current_del", "50 ms",
"Testing IClamp", "0")
exc_pre = "URYDL"
exc_post = "SMDDR"
inh_pre = "VD12"
inh_post = "VB11"
gap_1 = "AIZL"
gap_2 = "ASHL"
cells = [exc_pre, exc_post, inh_pre, inh_post]
cells_to_stimulate_extra = [exc_pre, inh_pre]
if parameter_set != 'A':
cells.append(gap_1)
cells.append(gap_2)
cells_to_stimulate_extra.append(gap_1)
reference = "c302_%s_Syns" % parameter_set
if generate:
nml_doc = c302.generate(reference,
params,
cells=cells,
cells_to_stimulate=[],
duration=duration,
dt=dt,
target_directory=target_directory,
param_overrides=param_overrides,
verbose=verbose)
for i in range(len(stim_amplitudes)):
start = "%sms" % (i * 1000 + 100)
for c in cells_to_stimulate_extra:
c302.add_new_input(nml_doc, c, start, "800ms", stim_amplitudes[i],
params)
nml_file = target_directory + '/' + reference + '.nml'
writers.NeuroMLWriter.write(
nml_doc, nml_file) # Write over network file written above...
print("(Re)written network file to: " + nml_file)
return cells, cells_to_stimulate_extra, params, []
def go(self):
"""
Start the simulation once it's been intialized
"""
nml_doc = c302.generate(self.reference,
self.params,
cells=self.cells,
cells_to_stimulate=self.cells_to_stimulate,
include_muscles = self.include_muscles,
duration=self.sim_time,
dt=self.dt,
validate=(self.params.level!='B'),
verbose=False,
target_directory = self.generate_dir)
self.lems_file ="LEMS_%s.xml"%(self.reference)
print("Running a simulation of %s ms with timestep %s ms: %s"%(self.sim_time, self.dt, self.lems_file))
self.already_run = True
start = time.time()
if self.simulator == 'jNeuroML':
results = pynml.run_lems_with_jneuroml(self.lems_file,
nogui=True,
load_saved_data=True,
plot=False,
exec_in_dir = self.generate_dir,
verbose=False)
elif self.simulator == 'jNeuroML_NEURON':
results = pynml.run_lems_with_jneuroml_neuron(self.lems_file,
nogui=True,
load_saved_data=True,
plot=False,
exec_in_dir = self.generate_dir,
verbose=False)
else:
print('Unsupported simulator: %s'%self.simulator)
exit()
secs = time.time()-start
print("Ran simulation in %s in %f seconds (%f mins)\n\n"%(self.simulator, secs, secs/60.0))
self.t = [t*1000 for t in results['t']]
res_template = '%s/0/generic_iaf_cell/v'
if self.params.level == 'B' or self.params.level == 'C' or self.params.level == 'D':
res_template = '%s[0]/v'
self.volts = {}
if self.cells is None:
self.cells = []
for pop in nml_doc.networks[0].populations:
self.cells.append(pop.id)
for cell in self.cells:
self.volts[res_template%cell] = [v*1000 for v in results[res_template%cell]]
def setUpClass(cls):
# generate files from pairs in CElegensNeuronTables
cls.cell_names, cls.conns = SpreadsheetDataReader.readDataFromSpreadsheet("../../../../")
print (str(len(cls.cell_names))+' unique cell names in CElegensNeuronTables')
for index in cls.conns:
origin = index.pre_cell
target = index.post_cell
fn = origin+"_"+target
fnswap = target+"_"+origin
if fn not in cls.checked_files:
if fnswap not in cls.checked_files:
# generate xml and nml file
cells_to_plot = "["+origin+","+target+"]"
cells_to_stimulate = "["+origin+"]"
generate(fn, params, cells=cells_to_plot, cells_to_stimulate=cells_to_stimulate, duration=500, test=True)
cls.checked_files.append(fn)
cls.counter += 1
# generate files from pairs not present in CElegensNeuronTables but in NeuronConnect.xls
cls.neuron_cell_names, cls.neuron_conns = SpreadsheetDataReader.readDataFromSpreadsheet("../../../../", neuron_connect=True)
print (str(len(cls.neuron_cell_names))+' unique cell names in NeuronConnectFormatted')
for index in cls.neuron_conns:
origin = index.pre_cell
target = index.post_cell
fn = origin+"_"+target
fnswap = target+"_"+origin
if fn not in cls.checked_files:
if fnswap not in cls.checked_files:
# generate xml and nml file
cells_to_plot = "["+origin+","+target+"]"
cells_to_stimulate = "["+origin+"]"
generate(fn, params, cells=cells_to_plot, cells_to_stimulate=cells_to_stimulate, duration=500, test=True)
cls.checked_files.append(fn)
cls.counter += 1
print ("Total files generated %i"%cls.counter)
def setup(parameter_set,
generate=False,
duration=None,
dt=0.05,
target_directory='examples',
data_reader="SpreadsheetDataReader",
param_overrides={},
config_param_overrides={},
verbose=True):
reference = "c302_%s_IClamp" % parameter_set
c302.print_("Setting up %s" % reference)
exec('from c302.parameters_%s import ParameterisedModel' % parameter_set,
globals())
params = ParameterisedModel()
stim_amplitudes = ["1pA", "2pA", "3pA", "4pA", "5pA", "6pA"]
if duration == None:
duration = (len(stim_amplitudes)) * 1000
my_cells = ["ADAL", "PVCL"]
muscles_to_include = ['MDR01']
cells = my_cells
cells_total = my_cells + muscles_to_include
nml_doc = None
if generate:
c302.print_("Generating %s" % reference)
nml_doc = c302.generate(reference,
params,
cells=cells,
cells_to_stimulate=[],
muscles_to_include=muscles_to_include,
duration=duration,
dt=dt,
target_directory=target_directory,
param_overrides=param_overrides,
verbose=verbose,
data_reader=data_reader)
for i in range(len(stim_amplitudes)):
start = "%sms" % (i * 1000 + 100)
for c in cells_total:
c302.add_new_input(nml_doc, c, start, "800ms",
stim_amplitudes[i], params)
nml_file = target_directory + '/' + reference + '.net.nml'
writers.NeuroMLWriter.write(
nml_doc, nml_file) # Write over network file written above...
c302.print_("(Re)written network file to: " + nml_file)
return cells, cells_total, params, muscles_to_include, nml_doc
def setup(parameter_set,
generate=False,
duration=3000,
dt=0.05,
target_directory='examples',
data_reader="SpreadsheetDataReader",
param_overrides={},
config_param_overrides={},
verbose=True):
exec('from parameters_%s import ParameterisedModel' % parameter_set)
params = ParameterisedModel()
stim_amplitudes = ["1pA", "2pA", "3pA", "4pA", "10pA", "15pA"]
duration = (len(stim_amplitudes)) * 1000
cells = ['VB1']
muscles_to_include = ['MVL07']
cells_total = list(cells + muscles_to_include)
reference = "c302_%s_NMJ" % parameter_set
conn_polarity_override = None
if config_param_overrides.has_key('conn_polarity_override'):
conn_polarity_override = config_param_overrides[
'conn_polarity_override']
nml_doc = None
if generate:
nml_doc = c302.generate(reference,
params,
data_reader=data_reader,
cells=cells,
cells_to_stimulate=[],
muscles_to_include=muscles_to_include,
duration=duration,
dt=dt,
target_directory=target_directory,
param_overrides=param_overrides,
conn_polarity_override=conn_polarity_override,
verbose=verbose)
for i in range(len(stim_amplitudes)):
start = "%sms" % (i * 1000 + 100)
for c in cells:
c302.add_new_input(nml_doc, c, start, "800ms", stim_amplitudes[i],
params)
nml_file = target_directory + '/' + reference + '.nml'
writers.NeuroMLWriter.write(
nml_doc, nml_file) # Write over network file written above...
print("(Re)written network file to: " + nml_file)
return cells, cells_total, params, muscles_to_include, nml_doc
def setup(parameter_set,
generate=False,
duration=2500,
dt=0.05,
target_directory='examples',
data_reader="SpreadsheetDataReader",
param_overrides={},
config_param_overrides={},
verbose=True):
exec('from parameters_%s import ParameterisedModel' % parameter_set,
globals())
params = ParameterisedModel()
cells = ["RMGR", "ASHR", "ASKR", "AWBR", "IL2R", "RMHR", "URXR"]
cells_to_stimulate = []
reference = "c302_%s_Social" % parameter_set
nml_doc = None
if generate:
nml_doc = c302.generate(reference,
params,
cells=cells,
cells_to_stimulate=cells_to_stimulate,
duration=duration,
dt=dt,
target_directory=target_directory,
param_overrides=param_overrides,
verbose=verbose,
data_reader=data_reader)
stim_amplitude = "5pA"
c302.add_new_input(nml_doc, "RMGR", "100ms", "200ms", stim_amplitude,
params)
c302.add_new_input(nml_doc, "ASHR", "400ms", "200ms", stim_amplitude,
params)
c302.add_new_input(nml_doc, "ASKR", "700ms", "200ms", stim_amplitude,
params)
c302.add_new_input(nml_doc, "AWBR", "1000ms", "200ms", stim_amplitude,
params)
c302.add_new_input(nml_doc, "IL2R", "1300ms", "200ms", stim_amplitude,
params)
c302.add_new_input(nml_doc, "RMHR", "1600ms", "200ms", stim_amplitude,
params)
c302.add_new_input(nml_doc, "URXR", "1900ms", "200ms", stim_amplitude,
params)
nml_file = target_directory + '/' + reference + '.net.nml'
writers.NeuroMLWriter.write(
nml_doc, nml_file) # Write over network file written above...
c302.print_("(Re)written network file to: " + nml_file)
return cells, cells_to_stimulate, params, [], nml_doc
def setup(parameter_set,
generate=False,
duration=3000,
dt=0.05,
target_directory='examples',
data_reader="SpreadsheetDataReader",
param_overrides={},
config_param_overrides={},
verbose=True):
exec('from parameters_%s import ParameterisedModel'%parameter_set)
params = ParameterisedModel()
stim_amplitudes = ["1pA","2pA","3pA","4pA","10pA","15pA"]
duration = (len(stim_amplitudes))*1000
cells = ['VB1']
muscles_to_include = ['MVL07']
cells_total = list(cells + muscles_to_include)
reference = "c302_%s_NMJ"%parameter_set
conn_polarity_override = None
if config_param_overrides.has_key('conn_polarity_override'):
conn_polarity_override = config_param_overrides['conn_polarity_override']
nml_doc = None
if generate:
nml_doc = c302.generate(reference,
params,
data_reader=data_reader,
cells=cells,
cells_to_stimulate=[],
muscles_to_include = muscles_to_include,
duration=duration,
dt=dt,
target_directory=target_directory,
param_overrides=param_overrides,
conn_polarity_override=conn_polarity_override,
verbose=verbose)
for i in range(len(stim_amplitudes)):
start = "%sms"%(i*1000 + 100)
for c in cells:
c302.add_new_input(nml_doc, c, start, "800ms", stim_amplitudes[i], params)
nml_file = target_directory+'/'+reference+'.net.nml'
writers.NeuroMLWriter.write(nml_doc, nml_file) # Write over network file written above...
print("(Re)written network file to: "+nml_file)
return cells, cells_total, params, muscles_to_include, nml_doc
def setup(parameter_set,
generate=False,
duration=1000,
dt=0.05,
target_directory='examples',
include_muscles=True):
exec('from parameters_%s import ParameterisedModel' % parameter_set)
params = ParameterisedModel()
# Some random set of neurons
cells_to_stimulate = [
"ADAL", "ADAR", "M1", "M2L", "M3L", "M3R", "M4", "I1R", "I2L", "I5",
"I6", "MI", "NSMR", "MCL", "ASEL", "AVEL", "AWAR", "DB1", "DVC",
"RIAR", "RMDDL"
]
cells_to_stimulate = ['PVCL', 'PVCR']
# Plot some directly stimulated & some not stimulated
cells_to_plot = ["ADAL", "ADAR", "PVDR", "BDUR", "I1R", "I2L"]
cells_to_plot = [
'AVBL', 'AVBR', 'PVCL', 'PVCR', 'DB1', 'DB2', 'VB1', 'VB2', 'DD1',
'DD2', 'VD1', 'VD2'
]
reference = "c302_%s_Full" % parameter_set
cell_names, conns = c302.get_cell_names_and_connection()
if generate:
c302.generate(reference,
params,
cells_to_plot=cells_to_plot,
cells_to_stimulate=cells_to_stimulate,
include_muscles=include_muscles,
duration=duration,
dt=dt,
vmin=-72 if parameter_set == 'A' else -52,
vmax=-48 if parameter_set == 'A' else -28,
validate=(parameter_set != 'B'),
target_directory=target_directory)
return cell_names, cells_to_stimulate, params, include_muscles
def setup(parameter_set,
generate=False,
duration=1000,
dt=0.05,
target_directory='examples',
data_reader="SpreadsheetDataReader",
param_overrides={},
verbose=True):
exec('from c302.parameters_%s import ParameterisedModel'%parameter_set, globals())
params = ParameterisedModel()
my_cells = ['RIAL', 'SMDDL','SMDVL']
muscles_to_include = []
cells = my_cells
cells_total = my_cells + muscles_to_include
reference = "c302_%s_RIA"%parameter_set
nml_doc = None
if generate:
nml_doc = c302.generate(reference,
params,
cells=cells,
cells_to_stimulate=muscles_to_include,
muscles_to_include = muscles_to_include,
duration=duration,
dt=dt,
target_directory=target_directory,
param_overrides=param_overrides,
verbose=verbose,
data_reader=data_reader)
start1 = '100ms'
dur1 = '100ms'
stim_amplitude1 = '4pA'
start2 = '400ms'
dur2 = '100ms'
stim_amplitude2 = '4pA'
c302.add_new_input(nml_doc, 'SMDDL', start1, dur1, stim_amplitude1, params)
c302.add_new_input(nml_doc, 'SMDVL', start2, dur2, stim_amplitude2, params)
nml_file = target_directory+'/'+reference+'.net.nml'
writers.NeuroMLWriter.write(nml_doc, nml_file) # Write over network file written above...
c302.print_("(Re)written network file to: "+nml_file)
return cells, cells_total, params, muscles_to_include, nml_doc
def setup(
parameter_set,
generate=False,
duration=1000,
dt=0.05,
target_directory='examples',
muscles_to_include=None, # None => All!
data_reader="SpreadsheetDataReader",
param_overrides={},
config_param_overrides={},
verbose=True):
exec('from parameters_%s import ParameterisedModel' % parameter_set,
globals())
params = ParameterisedModel()
# Some random set of neurons
cells_to_stimulate = [
"ADAL", "ADAR", "M1", "M2L", "M3L", "M3R", "M4", "I1R", "I2L", "I5",
"I6", "MI", "NSMR", "MCL", "ASEL", "AVEL", "AWAR", "DB1", "DVC",
"RIAR", "RMDDL"
]
cells_to_stimulate = ['PVCL', 'PVCR']
cells_to_stimulate = ['PLML', 'PLMR']
#cells_to_stimulate = ['AVBL','AVBR']
# Plot some directly stimulated & some not stimulated
cells_to_plot = ["ADAL", "ADAR", "PVDR", "BDUR", "I1R", "I2L"]
cells_to_plot = [
'AVBL', 'AVBR', 'PVCL', 'PVCR', 'DB1', 'DB2', 'VB1', 'VB2', 'DD1',
'DD2', 'VD1', 'VD2'
]
reference = "c302_%s_Full" % parameter_set
cell_names, conns = c302.get_cell_names_and_connection()
nml_doc = None
if generate:
nml_doc = c302.generate(reference,
params,
cells_to_plot=cells_to_plot,
cells_to_stimulate=cells_to_stimulate,
muscles_to_include=muscles_to_include,
duration=duration,
dt=dt,
vmin=-72 if parameter_set == 'A' else -52,
vmax=-48 if parameter_set == 'A' else -28,
target_directory=target_directory,
param_overrides=param_overrides,
verbose=verbose,
data_reader=data_reader)
return cell_names, cells_to_stimulate, params, muscles_to_include, nml_doc
def setup(parameter_set,
generate=False,
duration=500,
dt=0.05,
target_directory='examples',
data_reader="SpreadsheetDataReader"):
exec('from parameters_%s import ParameterisedModel'%parameter_set)
params = ParameterisedModel()
params.set_bioparameter("unphysiological_offset_current_del", "50 ms", "Testing IClamp", "0")
exc_pre = "URYDL"
exc_post = "SMDDR"
inh_pre = "VD12"
inh_post = "VB11"
gap_1 = "AIZL"
gap_2 = "ASHL"
cells = [exc_pre, exc_post, inh_pre, inh_post]
cells_to_stimulate = [exc_pre, inh_pre]
if parameter_set!='A':
cells.append(gap_1)
cells.append(gap_2)
cells_to_stimulate.append(gap_1)
reference = "c302_%s_Syns"%parameter_set
if generate:
c302.generate(reference,
params,
cells=cells,
cells_to_stimulate=cells_to_stimulate,
duration=duration,
dt=dt,
validate=(parameter_set!='B'),
target_directory=target_directory)
return cells, cells_to_stimulate, params, False
def setup(parameter_set,
generate=False,
duration=2500,
dt=0.1,
target_directory='examples'):
exec('from parameters_%s import ParameterisedModel' % parameter_set)
params = ParameterisedModel()
cells = ["RMGR", "ASHR", "ASKR", "AWBR", "IL2R", "RMHR", "URXR"]
cells_to_stimulate = []
reference = "c302_%s_Social" % parameter_set
target_directory = 'examples'
if generate:
nml_doc = c302.generate(reference,
params,
cells=cells,
cells_to_stimulate=cells_to_stimulate,
duration=duration,
dt=dt,
validate=(parameter_set != 'B'),
target_directory=target_directory)
stim_amplitude = "5pA"
c302.add_new_input(nml_doc, "RMGR", "100ms", "200ms", stim_amplitude,
params)
c302.add_new_input(nml_doc, "ASHR", "400ms", "200ms", stim_amplitude,
params)
c302.add_new_input(nml_doc, "ASKR", "700ms", "200ms", stim_amplitude,
params)
c302.add_new_input(nml_doc, "AWBR", "1000ms", "200ms", stim_amplitude,
params)
c302.add_new_input(nml_doc, "IL2R", "1300ms", "200ms", stim_amplitude,
params)
c302.add_new_input(nml_doc, "RMHR", "1600ms", "200ms", stim_amplitude,
params)
c302.add_new_input(nml_doc, "URXR", "1900ms", "200ms", stim_amplitude,
params)
nml_file = target_directory + '/' + reference + '.nml'
writers.NeuroMLWriter.write(
nml_doc, nml_file) # Write over network file written above...
print("(Re)written network file to: " + nml_file)
return cells, cells_to_stimulate, params, False
def setup(parameter_set,
generate=False,
duration=1000,
dt=0.05,
target_directory='examples',
data_reader="SpreadsheetDataReader"):
exec('from parameters_%s import ParameterisedModel'%parameter_set)
params = ParameterisedModel()
params.set_bioparameter("unphysiological_offset_current", "5pA", "Testing IClamp", "0")
params.set_bioparameter("unphysiological_offset_current_del", "100 ms", "Testing IClamp", "0")
params.set_bioparameter("unphysiological_offset_current_dur", "800 ms", "Testing IClamp", "0")
my_cells = ["ADAL","PVCL","MDR1"]
my_cells = ["ADAL","PVCL"]
include_muscles = False
cells = my_cells
cells_to_stimulate = my_cells
reference = "c302_%s_IClamp"%parameter_set
if generate:
c302.generate(reference,
params,
cells=cells,
cells_to_stimulate=cells_to_stimulate,
include_muscles = include_muscles,
duration=duration,
dt=dt,
validate=('B' not in parameter_set),
target_directory=target_directory)
return cells, cells_to_stimulate, params, include_muscles
def setup(parameter_set,
generate=False,
duration=3000,
dt=0.05,
target_directory='examples',
data_reader="SpreadsheetDataReader",
param_overrides={},
config_param_overrides={},
verbose=True):
exec('from c302.parameters_%s import ParameterisedModel' % parameter_set,
globals())
params = ParameterisedModel()
params.set_bioparameter("unphysiological_offset_current", "15pA",
"Testing IClamp", "0")
params.set_bioparameter("unphysiological_offset_current_del", "1 ms",
"Testing IClamp", "0")
params.set_bioparameter("unphysiological_offset_current_dur", "20 ms",
"Testing IClamp", "0")
duration = 300
my_cells = ["AVKR"]
my_cells = ["RMHR"]
muscles_to_include = None
cells = my_cells
reference = "c302_%s_TargetMuscle" % parameter_set
nml_doc = None
if generate:
nml_doc = c302.generate(reference,
params,
cells=cells,
cells_to_stimulate=cells,
muscles_to_include=muscles_to_include,
duration=duration,
dt=dt,
target_directory=target_directory,
param_overrides=param_overrides,
verbose=verbose,
data_reader=data_reader,
print_connections=True)
return cells, cells, params, muscles_to_include, nml_doc
def setup(parameter_set,
generate=False,
duration=2500,
dt=0.05,
target_directory='examples',
data_reader="SpreadsheetDataReader",
param_overrides={},
config_param_overrides={},
verbose=True):
exec('from parameters_%s import ParameterisedModel'%parameter_set, globals())
params = ParameterisedModel()
cells = ["RMGR","ASHR","ASKR","AWBR","IL2R","RMHR","URXR"]
cells_to_stimulate = []
reference = "c302_%s_Social"%parameter_set
nml_doc = None
if generate:
nml_doc = c302.generate(reference,
params,
cells=cells,
cells_to_stimulate=cells_to_stimulate,
duration=duration,
dt=dt,
target_directory=target_directory,
param_overrides=param_overrides,
verbose=verbose,
data_reader=data_reader)
stim_amplitude = "5pA"
c302.add_new_input(nml_doc, "RMGR", "100ms", "200ms", stim_amplitude, params)
c302.add_new_input(nml_doc, "ASHR", "400ms", "200ms", stim_amplitude, params)
c302.add_new_input(nml_doc, "ASKR", "700ms", "200ms", stim_amplitude, params)
c302.add_new_input(nml_doc, "AWBR", "1000ms", "200ms", stim_amplitude, params)
c302.add_new_input(nml_doc, "IL2R", "1300ms", "200ms", stim_amplitude, params)
c302.add_new_input(nml_doc, "RMHR", "1600ms", "200ms", stim_amplitude, params)
c302.add_new_input(nml_doc, "URXR", "1900ms", "200ms", stim_amplitude, params)
nml_file = target_directory+'/'+reference+'.net.nml'
writers.NeuroMLWriter.write(nml_doc, nml_file) # Write over network file written above...
print("(Re)written network file to: "+nml_file)
return cells, cells_to_stimulate, params, [], nml_doc
def setup(parameter_set,
generate=False,
duration=3000,
dt=0.05,
target_directory='examples',
data_reader="SpreadsheetDataReader",
param_overrides={},
config_param_overrides={},
verbose=True):
exec('from parameters_%s import ParameterisedModel'%parameter_set, globals())
params = ParameterisedModel()
params.set_bioparameter("unphysiological_offset_current", "15pA", "Testing IClamp", "0")
params.set_bioparameter("unphysiological_offset_current_del", "1 ms", "Testing IClamp", "0")
params.set_bioparameter("unphysiological_offset_current_dur", "20 ms", "Testing IClamp", "0")
duration = 300
my_cells = ["AVKR"]
my_cells = ["RMHR"]
muscles_to_include = None
cells = my_cells
reference = "c302_%s_TargetMuscle"%parameter_set
nml_doc = None
if generate:
nml_doc = c302.generate(reference,
params,
cells=cells,
cells_to_stimulate=cells,
muscles_to_include = muscles_to_include,
duration=duration,
dt=dt,
target_directory=target_directory,
param_overrides=param_overrides,
verbose=verbose,
data_reader=data_reader,
print_connections=True)
return cells, cells, params, muscles_to_include, nml_doc
def setup(parameter_set,
generate=False,
duration=1000,
dt=0.05,
target_directory='examples',
muscles_to_include = None, # None => All!
data_reader="SpreadsheetDataReader",
param_overrides={},
config_param_overrides={},
verbose=True):
exec('from parameters_%s import ParameterisedModel'%parameter_set, globals())
params = ParameterisedModel()
# Some random set of neurons
cells_to_stimulate = ["ADAL", "ADAR", "M1","M2L","M3L","M3R","M4","I1R","I2L","I5","I6","MI","NSMR","MCL","ASEL", "AVEL", "AWAR", "DB1", "DVC", "RIAR", "RMDDL"]
cells_to_stimulate = ['PVCL','PVCR']
cells_to_stimulate = ['PLML','PLMR']
#cells_to_stimulate = ['AVBL','AVBR']
# Plot some directly stimulated & some not stimulated
cells_to_plot = ["ADAL", "ADAR", "PVDR", "BDUR","I1R","I2L"]
cells_to_plot = ['AVBL','AVBR','PVCL', 'PVCR', 'DB1','DB2','VB1','VB2','DD1','DD2','VD1','VD2']
reference = "c302_%s_Full"%parameter_set
cell_names, conns = c302.get_cell_names_and_connection()
nml_doc = None
if generate:
nml_doc = c302.generate(reference,
params,
cells_to_plot=cells_to_plot,
cells_to_stimulate=cells_to_stimulate,
muscles_to_include = muscles_to_include,
duration=duration,
dt=dt,
vmin=-72 if parameter_set=='A' else -52,
vmax=-48 if parameter_set=='A' else -28,
target_directory=target_directory,
param_overrides=param_overrides,
verbose=verbose,
data_reader=data_reader)
return cell_names, cells_to_stimulate, params, muscles_to_include, nml_doc
def setup(parameter_set,
generate=False,
duration=2500,
dt=0.1,
target_directory='examples'):
exec('from parameters_%s import ParameterisedModel'%parameter_set)
params = ParameterisedModel()
cells = ["RMGR","ASHR","ASKR","AWBR","IL2R","RMHR","URXR"]
cells_to_stimulate = []
reference = "c302_%s_Social"%parameter_set
target_directory='examples'
if generate:
nml_doc = c302.generate(reference,
params,
cells=cells,
cells_to_stimulate=cells_to_stimulate,
duration=duration,
dt=dt,
validate=(parameter_set!='B'),
target_directory=target_directory)
stim_amplitude = "5pA"
c302.add_new_input(nml_doc, "RMGR", "100ms", "200ms", stim_amplitude, params)
c302.add_new_input(nml_doc, "ASHR", "400ms", "200ms", stim_amplitude, params)
c302.add_new_input(nml_doc, "ASKR", "700ms", "200ms", stim_amplitude, params)
c302.add_new_input(nml_doc, "AWBR", "1000ms", "200ms", stim_amplitude, params)
c302.add_new_input(nml_doc, "IL2R", "1300ms", "200ms", stim_amplitude, params)
c302.add_new_input(nml_doc, "RMHR", "1600ms", "200ms", stim_amplitude, params)
c302.add_new_input(nml_doc, "URXR", "1900ms", "200ms", stim_amplitude, params)
nml_file = target_directory+'/'+reference+'.nml'
writers.NeuroMLWriter.write(nml_doc, nml_file) # Write over network file written above...
print("(Re)written network file to: "+nml_file)
return cells, cells_to_stimulate, params, False
def setup(parameter_set,
generate=False,
target_directory='examples',
data_reader="SpreadsheetDataReader"):
exec('from parameters_%s import ParameterisedModel' % parameter_set,
globals())
params = ParameterisedModel()
cells = [
'RIAL', 'RIAR', 'SMDBL', 'SMDVR', 'SMDDL', 'SMDDR', 'AIYL', 'AIYR',
'AWCL', 'AWCR'
]
cells_to_stimulate = []
reference = "c302_%s_AWCMike" % parameter_set
nml_doc = None
if generate:
nml_doc = c302.generate(reference,
params,
cells=cells,
cells_to_stimulate=cells_to_stimulate,
duration=800,
dt=0.1,
target_directory=target_directory)
stim_amplitude = "0.6nA" #this is WAY too high to prevent unstable outputs, but fun to watch
c302.add_new_input(nml_doc, "AWCL", "100ms", "100ms", stim_amplitude,
params)
c302.add_new_input(nml_doc, "AWCR", "500ms", "100ms", stim_amplitude,
params)
nml_file = target_directory + '/' + reference + '.net.nml'
writers.NeuroMLWriter.write(nml_doc, nml_file)
print("(Re)written network file to: " + nml_file)
return cells, cells_to_stimulate, params, [], nml_doc
def setup(parameter_set,
generate=False,
duration=2000,
dt=0.05,
target_directory='examples',
data_reader="SpreadsheetDataReader",
param_overrides={},
verbose=True):
exec('from parameters_%s import ParameterisedModel'%parameter_set, globals())
params = ParameterisedModel()
my_cells = []
muscles_to_include = ['MDR01']
cells = my_cells
cells_total = my_cells + muscles_to_include
reference = "c302_%s_IClampMuscle"%parameter_set
nml_doc = None
if generate:
nml_doc = c302.generate(reference,
params,
cells=cells,
cells_to_stimulate=muscles_to_include,
muscles_to_include = muscles_to_include,
duration=duration,
dt=dt,
target_directory=target_directory,
param_overrides=param_overrides,
verbose=verbose,
data_reader=data_reader)
return cells, cells_total, params, muscles_to_include, nml_doc
def setup(parameter_set,
generate=False,
duration=500,
dt=0.01,
target_directory='examples',
data_reader="SpreadsheetDataReader",
param_overrides={},
config_param_overrides={},
verbose=True):
exec('from parameters_%s import ParameterisedModel'%parameter_set, globals())
params = ParameterisedModel()
params.set_bioparameter("unphysiological_offset_current", "2.2pA", "Testing Pharyngeal", "0")
params.set_bioparameter("unphysiological_offset_current_del", "50ms", "Testing Pharyngeal", "0")
params.set_bioparameter("unphysiological_offset_current_dur", "200ms", "Testing Pharyngeal", "0")
cells = ["M1","M2L","M2R","M3L","M3R","M4","M5","I1L","I1R","I2L","I2R","I3","I4","I5","I6","MI","NSML","NSMR","MCL","MCR"]
cells_to_stimulate = ["M1","M3R","M4","M5","I1L","I4","I5","I6","MCL","MCR"]
reference = "c302_%s_Pharyngeal"%parameter_set
nml_doc = None
if generate:
nml_doc = c302.generate(reference,
params,
cells=cells,
cells_to_stimulate=cells_to_stimulate,
duration=duration,
dt=dt,
target_directory=target_directory,
param_overrides=param_overrides,
verbose=verbose,
data_reader=data_reader)
return cells, cells_to_stimulate, params, [], nml_doc
def go(self):
"""
Start the simulation once it's been intialized
"""
nml_doc = c302.generate(self.reference,
self.params,
cells=self.cells,
cells_to_stimulate=self.cells_to_stimulate,
duration=self.sim_time,
dt=self.dt,
validate=(self.params.level!='B'),
verbose=False)
self.lems_file = "LEMS_%s.xml"%(self.reference)
print("Running a simulation of %s ms with timestep %s ms"%(self.sim_time, self.dt))
self.go_already = True
results = pynml.run_lems_with_jneuroml(self.lems_file, nogui=True, load_saved_data=True, plot=False, verbose=False)
#results = pynml.run_lems_with_jneuroml_neuron(self.lems_file, nogui=True, load_saved_data=True, plot=False)
self.t = [t*1000 for t in results['t']]
res_template = '%s/0/generic_iaf_cell/v'
if self.params.level == 'B' or self.params.level == 'C' or self.params.level == 'D':
res_template = '%s[0]/v'
self.volts = {}
if self.cells is None:
self.cells = []
for pop in nml_doc.networks[0].populations:
self.cells.append(pop.id)
for cell in self.cells:
self.volts[res_template%cell] = [v*1000 for v in results[res_template%cell]]
from c302 import generate
import parameters_A as params
if __name__ == '__main__':
# Some random set of neurons
cells_to_stimulate = ["ADAL", "ADAR", "M1","M2L","M3L","M3R","M4","I1R","I2L","I5","I6","MI","NSMR","MCL","ASEL", "AVEL", "AWAR", "DB1", "DVC", "RIAR", "RMDDL"]
# Plot some directly stimulated & some not stimulated
cells_to_plot = ["ADAL", "ADAR", "PVDR", "BDUR","I1R","I2L"]
generate("c302_A", params, cells_to_plot=cells_to_plot, cells_to_stimulate=cells_to_stimulate, duration=500, dt=0.1, vmin=-72, vmax=-48)
def setup(parameter_set,
generate=False,
duration=6000,
dt=0.05,
target_directory='examples',
data_reader="UpdatedSpreadsheetDataReader2",
param_overrides={},
verbose=True,
config_param_overrides={}):
exec ('from parameters_%s import ParameterisedModel' % parameter_set, globals())
params = ParameterisedModel()
#'''
VA_motors = ["VA%s" % c for c in range_incl(1, 12)]
VB_motors = ["VB%s" % c for c in range_incl(1, 11)]
DA_motors = ["DA%s" % c for c in range_incl(1, 9)]
DB_motors = ["DB%s" % c for c in range_incl(1, 7)]
DD_motors = ["DD%s" % c for c in range_incl(1, 6)]
VD_motors = ["VD%s" % c for c in range_incl(1, 13)]
AS_motors = ["AS%s" % c for c in range_incl(1, 11)]
#'''
motors = list(VA_motors + VB_motors + AS_motors + DA_motors + DB_motors + VD_motors + DD_motors)
inters = ['AVBL', 'AVBR', 'AVAL', 'AVAR']
cells = list(motors + inters)
muscles_to_include = []
cells_to_stimulate = []
cells_to_plot = cells
reference = "c302_%s_BW" % parameter_set
conns_to_include = [
]
conns_to_exclude = [
'VB2-VB4_GJ',
'VB4-VB2_GJ',
#########################################
# Remove unwanted interneuron connections
#########################################
# Disconnect the AVA and AVB interneurons
r'^AVB.-AVA.$',
r'^AVA.-AVB.$',
r'^AVB.-AVA._GJ$',
r'^AVA.-AVB._GJ$',
# Disconnect chemical stimulation from AVA and AVB
r'^AVB.-.A\d+$',
r'^AVB.-.B\d+$',
r'^AVB.-.D\d+$',
r'^AVB.-AS\d+$',
r'^AVA.-.A\d+$',
r'^AVA.-.B\d+$',
r'^AVA.-.D\d+$',
r'^AVA.-AS\d+$',
# Disconnect AVA and AVB gap junctions not pressent.
r'^AVB.-.A\d+_GJ$',
r'^AVB.-AS\d+_GJ$',
r'^AVB.-.D\d+_GJ$',
r'^AVA.-.B\d+_GJ$',
r'^AVA.-AS\d+_GJ$',
r'^AVA.-.D\d+_GJ$',
# Disconnect feedback GJ into AVA and AVB.
r'^..\d+-AV.._GJ$',
#########################################################
# Remove connections not present in Haspel and O'Donovan
#########################################################
#'''
r'^AS\d+-.B\d+$',
r'^AS\d+-VA\d+$',
r'^AS\d+-DD\d+$',
r'^AS\d+-..\d+_GJ$',
r'^..\d+-AS\d+_GJ$',
r'^DA\d+-AS\d+$',
r'^DA\d+-DD\d+$',
r'^DA\d+-VB\d+$',
r'^DA\d+-VA\d+$',
r'^DA\d+-AS\d+$',
r'^DA\d+-.B\d+_GJ$',
r'^DA\d+-.D\d+_GJ$',
r'^.B\d+-DA\d+_GJ$',
r'^.D\d+-DA\d+_GJ$',
r'^DB\d+-.A\d+$',
r'^DB\d+-VB\d+$',
r'^DB\d+-.A\d+_GJ$',
r'^DB\d+-.D\d+_GJ$',
r'^DB\d+-VB\d+_GJ$',
r'^.A\d+-DB\d+_GJ$',
r'^.D\d+-DB\d+_GJ$',
r'^VB\d+-DB\d+_GJ$',
r'^DD\d+-..\d+$',
r'^DD\d+-VD\d+_GJ$',
r'^DD\d+-.B\d+_GJ$',
r'^DD\d+-.A\d+_GJ$',
r'^VD\d+-DD\d+_GJ$',
r'^.B\d+-DD\d+_GJ$',
r'^.A\d+-DD\d+_GJ$',
r'^VD\d+-D.\d+$',
r'^VD\d+-AS\d+$',
r'^VD\d+-VB\d+_GJ$',
r'^VB\d+-VD\d+_GJ$',
r'^VB\d+-DB\d+$',
r'^VB\d+-.A\d+$',
r'^VB\d+-AS\d+$',
r'^VB\d+-VD\d+$',
r'^VB\d+-VA\d+_GJ$',
r'^VA\d+-VB\d+_GJ$',
r'^VA\d+-.B\d+$',
r'^VA\d+-DA\d+$',
r'^VA\d+-AS\d+$',
###############################################
# Remove connections going forward in DA and VA
###############################################
#Forward connections in DA-VA
'DA3-DA4',
'DA2-DA3',
'VA2-VA3',
'VA3-VA4',
'VA5-VA6',
'DA9-VA12',
'VA12-DA8',
'VA12-DA9',
'VA1-DA2',
#'''
]
conn_polarity_override = {
#Inhibitory in Olivares
r'^AS\d+-VD\d+$': 'inh',
r'^DB\d+-AS\d+$': 'inh',
r'^DB\d+-VD\d+$': 'inh',
r'^VD\d+-VA\d+$': 'inh',
r'^VA\d+-VD\d+$': 'inh',
#Excitatory in Olivares
r'^VD\d+-VB\d+$': 'exc',
#Inhibitory in LUNG
#r'^DB\d+-DD\d+$': 'inh',
#r'^VB\d+-VD\d+$': 'inh',
#Inhibitory for DD
r'^DA\d+-DD\d+$': 'inh',
r'^AS\d+-DD\d+$': 'inh',
r'^DB\d+-VD\d+$': 'inh',
}
conn_polarity_override = {
#### NEW CIRCUIT ####
r'^VA\d+-VD\d+$': 'inh',
r'^DA\d+-DD\d+$': 'inh',
r'^AS\d+-DD\d+$': 'inh',
r'^DB\d+-DD\d+$': 'inh',
r'^AS\d+-VD\d+$': 'inh',
#VD-DD and VD-VB are already inhibitory
}
conn_number_override = {
'^.+-.+$': 1,
}
#*********
# INPUTS
#*********
input_list = []
sine_input_list = []
ramp_input_list = []
#*************************
# Interneuron STIMULATION
#*************************
#'''
input_list.append(('AVAL', '0ms', '4000ms', '15pA'))
input_list.append(('AVAR', '0ms', '4000ms', '15pA'))
#'''
#*************************
# DB1 and VB1 STIMULATION
#*************************
# Sinusoidal Input
#'''
#sine_input_list.append(('DB1', '0ms', '15000ms', '1.5pA', '800ms')) #AMP: 2pA seems to overstimulate
#sine_input_list.append(('VB1', '0ms', '15000ms', '1.5pA', '800ms'))
sine_input_list.append(('DA9', '0ms', '15000ms', '1.5pA', '800ms'))
sine_input_list.append(('VA12', '0ms', '15000ms', '-1.5pA', '800ms'))
config_param_overrides['input'] = input_list
param_overrides = {
'mirrored_elec_conn_params': {
#Connections to DB1 and VB1 have a HIGHER conductance
r'^AVB._to_.B1_GJ$_elec_syn_gbase': '0.005 nS',
#Connections to rest of DB and VB have a LOWER conductance
r'^AVB._to_.B[2-9]\_GJ$_elec_syn_gbase': '0.001 nS',
r'^AVB._to_.B[1-9][0-9]\_GJ$_elec_syn_gbase': '0.001 nS',
#Connections to DA9 and VA12 have a HIGHER conductance
r'^AVA._to_DA9_GJ$_elec_syn_gbase': '0.005 nS',
r'^AVA._to_VA12_GJ$_elec_syn_gbase': '0.005 nS',
#Connections to rest of DA and VA have LOWER conductance
r'^AVA._to_DA[1-8]\_GJ$_elec_syn_gbase': '0.001 nS',
r'^AVA._to_VA[1-9][0-1]?\_GJ$_elec_syn_gbase': '0.001 nS',
r'^.B\d+_to_.B\d+\_GJ$_elec_syn_gbase': '0.001 nS',
r'^.A\d+_to_.A\d+\_GJ$_elec_syn_gbase': '0.001 nS',
r'^.D\d+_to_.D\d+\_GJ$_elec_syn_gbase': '0.001 nS',
r'^AS\d+_to_AS\d+\_GJ$_elec_syn_gbase': '0.001 nS',
r'^VA\d+_to_DA\d+\_GJ$_elec_syn_gbase': '0.001 nS',
r'^VA\d+_to_VD\d+\_GJ$_elec_syn_gbase': '0.001 nS',
},
'initial_memb_pot': '-50 mV',
##### Adjustments ######
r'^DA\d+_to_DB\d+$_exc_syn_conductance': '0.2 nS',
r'^DB\d+_to_VD\d+$_exc_syn_conductance': '0.2 nS',
#*********************************
# Connections between units (chemical)
#*********************************
#r'^VD\d+_to_VB\d+$_inh_syn_conductance': '0.2 nS',
#r'^DA\d+_to_VD\d+$_exc_syn_conductance': '0.2 nS',
#Connect synaptically VB1 to VB2 and so on
r'^VB\d+_to_VB\d+$_exc_syn_conductance': '30 nS',
r'^VB\d+_to_VB\d+$_exc_syn_ar': '0.19 per_s',
r'^VB\d+_to_VB\d+$_exc_syn_ad': '73 per_s',
r'^VB\d+_to_VB\d+$_exc_syn_beta': '2.81 per_mV',
r'^VB\d+_to_VB\d+$_exc_syn_vth': '-22 mV',
r'^VB\d+_to_VB\d+$_exc_syn_erev': '10 mV',
#Connect synaptically DB1 to DB2 and so on
r'^DB\d+_to_DB\d+$_exc_syn_conductance': '30 nS',
r'^DB\d+_to_DB\d+$_exc_syn_ar': '0.08 per_s',
r'^DB\d+_to_DB\d+$_exc_syn_ad': '18 per_s',
r'^DB\d+_to_DB\d+$_exc_syn_beta': '0.21 per_mV',
r'^DB\d+_to_DB\d+$_exc_syn_vth': '-10 mV',
r'^DB\d+_to_DB\d+$_exc_syn_erev': '10 mV',
#'''
#Connect synaptically VA1 to VA2 and so on
r'^VA\d+_to_VA\d+$_exc_syn_conductance': '30 nS',
r'^VA\d+_to_VA\d+$_exc_syn_ar': '0.19 per_s',
r'^VA\d+_to_VA\d+$_exc_syn_ad': '73 per_s',
r'^VA\d+_to_VA\d+$_exc_syn_beta': '2.81 per_mV',
r'^VA\d+_to_VA\d+$_exc_syn_vth': '-22 mV',
r'^VA\d+_to_VA\d+$_exc_syn_erev': '10 mV',
#Connect synaptically DB1 to DB2 and so on
r'^DA\d+_to_DA\d+$_exc_syn_conductance': '30 nS',
r'^DA\d+_to_DA\d+$_exc_syn_ar': '0.08 per_s',
r'^DA\d+_to_DA\d+$_exc_syn_ad': '18 per_s',
r'^DA\d+_to_DA\d+$_exc_syn_beta': '0.21 per_mV',
r'^DA\d+_to_DA\d+$_exc_syn_vth': '-10 mV',
r'^DA\d+_to_DA\d+$_exc_syn_erev': '10 mV',
#'''
'AVBR_to_MVL16_exc_syn_conductance': '0 nS',
'ca_conc_decay_time_muscle': '60.8 ms',
'ca_conc_rho_muscle': '0.002338919 mol_per_m_per_A_per_s',
}
nml_doc = None
if generate:
nml_doc = c302.generate(reference,
params,
cells=cells,
cells_to_plot=cells_to_plot,
cells_to_stimulate=cells_to_stimulate,
conns_to_include=conns_to_include,
conns_to_exclude=conns_to_exclude,
conn_polarity_override=conn_polarity_override,
conn_number_override=conn_number_override,
muscles_to_include=muscles_to_include,
duration=duration,
dt=dt,
target_directory=target_directory,
data_reader=data_reader,
param_overrides=param_overrides,
verbose=verbose)
#if config_param_overrides.has_key('input'):
# input_list = config_param_overrides['input']
for stim_input in input_list:
cell, start, dur, current = stim_input
c302.add_new_input(nml_doc, cell, start, dur, current, params)
for sine_stim_input in sine_input_list:
cell, delay, dur, amp, period = sine_stim_input
c302.add_new_sinusoidal_input(nml_doc, cell, delay, dur, amp, period, params)
for ramp_stim_input in ramp_input_list:
cell, delay, dur, start_amp, finish_amp, base_amp = ramp_stim_input
c302.add_new_ramp_input(nml_doc, cell, delay, dur, start_amp, finish_amp, base_amp, params)
#c302.add_new_input(nml_doc, cell='VB1', delay="1200ms", duration="1000ms", amplitude="1pA", params=params)
#c302.add_new_input(nml_doc, cell='VB1', delay="0ms", duration="2000ms", amplitude="1.5pA", params=params)
nml_file = target_directory + '/' + reference + '.net.nml'
writers.NeuroMLWriter.write(nml_doc, nml_file) # Write over network file written above...
c302.print_("(Re)written network file to: " + nml_file)
return cells, cells_to_stimulate, params, muscles_to_include, nml_doc
def setup(parameter_set,
generate=False,
duration=1000,
dt=0.05,
target_directory='examples'):
exec('from parameters_%s import ParameterisedModel'%parameter_set)
params = ParameterisedModel()
#params.set_bioparameter("unphysiological_offset_current", "4.3pA", "Testing IClamp", "0")
params.set_bioparameter("unphysiological_offset_current_del", "5 ms", "Testing IClamp", "0")
params.set_bioparameter("unphysiological_offset_current_dur", "10000 ms", "Testing IClamp", "0")
#params.add_bioparameter("exc_syn_conductance", ".20 nS", "BlindGuess", "0.1")
params.add_bioparameter("chem_exc_syn_decay", "5 ms", "BlindGuess", "0.1")
#params.add_bioparameter("inh_syn_conductance", ".35 nS", "BlindGuess", "0.1")
params.add_bioparameter("chem_inh_syn_decay", "200 ms", "BlindGuess", "0.1")
#params.add_bioparameter("elec_syn_gbase", "0.001 nS", "BlindGuess", "0.1")
# Any neurons connected to muscles
cells = ['AS1', 'AS10', 'AS11', 'AS2', 'AS3', 'AS4', 'AS5', 'AS6', 'AS7', 'AS8', 'AS9',
'AVFL', 'AVFR', 'AVKR', 'AVL',
'CEPVL', 'CEPVR',
'DA1', 'DA2', 'DA3', 'DA4', 'DA5', 'DA6', 'DA7', 'DA8', 'DA9',
'DB1', 'DB2', 'DB3', 'DB4', 'DB5', 'DB6', 'DB7',
'DD1', 'DD2', 'DD3', 'DD4', 'DD5', 'DD6',
'DVB',
'HSNL', 'HSNR',
'IL1DL', 'IL1DR', 'IL1L', 'IL1R', 'IL1VL', 'IL1VR',
'PDA', 'PDB',
'PVNL', 'PVNR',
'RID', 'RIML', 'RIMR', 'RIVL', 'RIVR',
'RMDDL', 'RMDDR', 'RMDL', 'RMDR', 'RMDVL', 'RMDVR', 'RMED', 'RMEL', 'RMER', 'RMEV', 'RMFL', 'RMGL', 'RMGR', 'RMHL', 'RMHR',
'SMBDL', 'SMBDR', 'SMBVL', 'SMBVR', 'SMDDL', 'SMDDR', 'SMDVL', 'SMDVR',
'URADL', 'URADR', 'URAVL', 'URAVR',
'VA1', 'VA10', 'VA11', 'VA12', 'VA2', 'VA3', 'VA4', 'VA5', 'VA6', 'VA7', 'VA8', 'VA9',
'VB1', 'VB10', 'VB11', 'VB2', 'VB3', 'VB4', 'VB5', 'VB6', 'VB7', 'VB8', 'VB9',
'VC1', 'VC2', 'VC3', 'VC4', 'VC5', 'VC6',
'VD1', 'VD10', 'VD11', 'VD12', 'VD13', 'VD2', 'VD3', 'VD4', 'VD5', 'VD6', 'VD7', 'VD8', 'VD9']
cells+=['AVAL', 'AVAR', 'AVBL', 'AVBR','AVDL', 'AVDR', 'PVCL', 'PVCR']
#cells=None # implies all cells...
## Some random set of neurons
#probability = 0.1
cells_to_stimulate = []
'''
for cell in cells:
#if random.random()<probability:
# cells_to_stimulate.append(cell)
if cell.startswith("xxVB") or cell.startswith("DB"):
cells_to_stimulate.append(cell)'''
#cells_to_stimulate = ['DB1', 'VB1']
cells_to_stimulate = ['PVCL', 'AVBL']
cells_to_stimulate.extend(['DB1', 'VB1'])
cells_to_stimulate = ['PVCL','PVCR']
# Plot some directly stimulated & some not stimulated
cells_to_plot = ['AS1', 'AS10', 'AVFL', 'DA1','DB1','DB4','DB7','IL1DL','RID', 'RIML','SMBDL', 'SMBDR', 'VB1', 'VB5', 'VB10','VC1', 'VC2']
cells_to_plot = ['AVBL','AVBR','PVCL', 'PVCR', 'DB1','DB2','VB1','VB2','DD1','DD2','VD1','VD2']
reference = "c302_%s_Muscles"%parameter_set
include_muscles = True
if generate:
c302.generate(reference,
params,
cells=cells,
cells_to_plot=cells_to_plot,
cells_to_stimulate=cells_to_stimulate,
include_muscles = include_muscles,
duration=duration,
dt=dt,
validate=(parameter_set!='B'),
target_directory=target_directory)
return cells, cells_to_stimulate, params, include_muscles
from c302 import generate
import parameters_A as params
if __name__ == '__main__':
pharyngeal_cells = ["M1","M2L","M2R","M3L","M3R","M4","M5","I1L","I1R","I2L","I2R","I3","I4","I5","I6","MI","NSML","NSMR","MCL","MCR"]
cells_to_stimulate = ["M1","M3R","M4","M5","I1L","I4","I5","I6","MCL","MCR"]
generate("c302_A_Pharyngeal", params, cells=pharyngeal_cells, cells_to_stimulate=cells_to_stimulate, duration=500, dt=0.025, vmin=-72, vmax=-48)
from c302 import generate
import sys
if __name__ == '__main__':
parameter_set = sys.argv[1] if len(sys.argv)==2 else 'A'
exec('from parameters_%s import ParameterisedModel'%parameter_set)
params = ParameterisedModel()
# Some random set of neurons
cells_to_stimulate = ["ADAL", "ADAR", "M1","M2L","M3L","M3R","M4","I1R","I2L","I5","I6","MI","NSMR","MCL","ASEL", "AVEL", "AWAR", "DB1", "DVC", "RIAR", "RMDDL"]
# Plot some directly stimulated & some not stimulated
cells_to_plot = ["ADAL", "ADAR", "PVDR", "BDUR","I1R","I2L"]
reference = "c302_%s_Full"%parameter_set
generate(reference,
params,
cells_to_plot=cells_to_plot,
cells_to_stimulate=cells_to_stimulate,
duration=500,
dt=0.1,
vmin=-72 if parameter_set=='A' else -52,
vmax=-48 if parameter_set=='A' else -28,
validate=(parameter_set!='B'),
target_directory='examples')
def setup(parameter_set,
generate=False,
duration=1000,
dt=0.05,
target_directory='examples',
data_reader="SpreadsheetDataReader"):
exec('from parameters_%s import ParameterisedModel'%parameter_set)
params = ParameterisedModel()
#params.set_bioparameter("unphysiological_offset_current", "5pA", "Testing IClamp", "0")
params.set_bioparameter("unphysiological_offset_current_del", "5 ms", "Testing IClamp", "0")
params.set_bioparameter("unphysiological_offset_current_dur", "1000 ms", "Testing IClamp", "0")
#params.add_bioparameter("chem_exc_syn_gbase", ".02 nS", "BlindGuess", "0.1")
params.add_bioparameter("chem_exc_syn_decay", "5 ms", "BlindGuess", "0.1")
#params.add_bioparameter("chem_inh_syn_gbase", ".02 nS", "BlindGuess", "0.1")
params.add_bioparameter("chem_inh_syn_decay", "30 ms", "BlindGuess", "0.1")
params.add_bioparameter("inh_syn_erev", "-90 mV", "BlindGuess", "0.1")
#params.add_bioparameter("elec_syn_gbase", "0.001 nS", "BlindGuess", "0.1")
# Any neurons connected to muscles
cells = ['DB1', 'DB2', 'DB3', 'DB4', 'DB5', 'DB6', 'DB7',
'DD1', 'DD2', 'DD3', 'DD4', 'DD5', 'DD6',
'VB1', 'VB10', 'VB11', 'VB2', 'VB3', 'VB4', 'VB5', 'VB6', 'VB7', 'VB8', 'VB9',
'VD1', 'VD10', 'VD11', 'VD2', 'VD3', 'VD4', 'VD5', 'VD6', 'VD7', 'VD8', 'VD9']
cells = ['DB3', 'VB3', 'DD3', 'VD3', 'DB4', 'VB4', 'DD4', 'VD4']
cells = ['DB2', 'VB2', 'DD2', 'VD2', 'DB3', 'VB3', 'DD3', 'VD3']
#cells = ['DB3', 'VB3', 'DB4', 'VB4']
#cells+=['AVBL','PVCL','AVBR','PVCR']
#cells+=[]
cells+=['PVCL', 'PVCR','AVBL','AVBR']
#cells+=['AVBL','AVBR']
#cells=None # implies all cells...
cells_to_stimulate = ['PVCL','PVCR']
#cells_to_stimulate = ['AVBL','AVBR']
#cells_to_stimulate = ['AVBL']
# Plot some directly stimulated & some not stimulated
# cells_to_plot = ['AVBL','PVCL', 'PVCR', 'DB1','DB2','DB3', 'DB4','DD1','DD2','DD3', 'DD4','DB4','VB1','VB2', 'VB3', 'VB4','VD1','VD2', 'VD3', 'VD4']
cells_to_plot = cells
reference = "c302_%s_Oscillator"%parameter_set
include_muscles = True
include_muscles = False
if generate:
c302.generate(reference,
params,
cells=cells,
cells_to_plot=cells_to_plot,
cells_to_stimulate=cells_to_stimulate,
include_muscles = include_muscles,
duration=duration,
dt=dt,
validate=(parameter_set!='B'),
target_directory=target_directory)
return cells, cells_to_stimulate, params, include_muscles
parameter_set = sys.argv[1] if len(sys.argv)==2 else 'A'
exec('from parameters_%s import ParameterisedModel'%parameter_set)
params = ParameterisedModel()
cells = ["URYDL", "SMDDR", "ADAL", "RIML", "IL2VL", "RIPL"]
cells_to_stimulate = []
reference = "c302_%s_MultiSyns"%parameter_set
target_directory='examples'
nml_doc = generate(reference,
params,
cells=cells,
cells_to_stimulate=cells_to_stimulate,
duration=1000,
dt=0.1,
validate=(parameter_set!='B'),
target_directory=target_directory)
stim_amplitude = "0.35nA"
add_new_input(nml_doc, "URYDL", "100ms", "200ms", stim_amplitude, params)
add_new_input(nml_doc, "ADAL", "400ms", "200ms", stim_amplitude, params)
add_new_input(nml_doc, "IL2VL", "700ms", "200ms", stim_amplitude, params)
nml_file = target_directory+'/'+reference+'.nml'
writers.NeuroMLWriter.write(nml_doc, nml_file) # Write over network file written above...
print("(Re)written network file to: "+nml_file)
def setup(parameter_set,
generate=False,
duration=1000,
dt=0.05,
target_directory='examples'):
exec('from parameters_%s import ParameterisedModel' % parameter_set)
params = ParameterisedModel()
#params.set_bioparameter("unphysiological_offset_current", "4.3pA", "Testing IClamp", "0")
params.set_bioparameter("unphysiological_offset_current_del", "5 ms",
"Testing IClamp", "0")
params.set_bioparameter("unphysiological_offset_current_dur", "10000 ms",
"Testing IClamp", "0")
#params.add_bioparameter("exc_syn_conductance", ".20 nS", "BlindGuess", "0.1")
params.add_bioparameter("chem_exc_syn_decay", "5 ms", "BlindGuess", "0.1")
#params.add_bioparameter("inh_syn_conductance", ".35 nS", "BlindGuess", "0.1")
params.add_bioparameter("chem_inh_syn_decay", "200 ms", "BlindGuess",
"0.1")
#params.add_bioparameter("elec_syn_gbase", "0.001 nS", "BlindGuess", "0.1")
# Any neurons connected to muscles
cells = [
'AS1', 'AS10', 'AS11', 'AS2', 'AS3', 'AS4', 'AS5', 'AS6', 'AS7', 'AS8',
'AS9', 'AVFL', 'AVFR', 'AVKR', 'AVL', 'CEPVL', 'CEPVR', 'DA1', 'DA2',
'DA3', 'DA4', 'DA5', 'DA6', 'DA7', 'DA8', 'DA9', 'DB1', 'DB2', 'DB3',
'DB4', 'DB5', 'DB6', 'DB7', 'DD1', 'DD2', 'DD3', 'DD4', 'DD5', 'DD6',
'DVB', 'HSNL', 'HSNR', 'IL1DL', 'IL1DR', 'IL1L', 'IL1R', 'IL1VL',
'IL1VR', 'PDA', 'PDB', 'PVNL', 'PVNR', 'RID', 'RIML', 'RIMR', 'RIVL',
'RIVR', 'RMDDL', 'RMDDR', 'RMDL', 'RMDR', 'RMDVL', 'RMDVR', 'RMED',
'RMEL', 'RMER', 'RMEV', 'RMFL', 'RMGL', 'RMGR', 'RMHL', 'RMHR',
'SMBDL', 'SMBDR', 'SMBVL', 'SMBVR', 'SMDDL', 'SMDDR', 'SMDVL', 'SMDVR',
'URADL', 'URADR', 'URAVL', 'URAVR', 'VA1', 'VA10', 'VA11', 'VA12',
'VA2', 'VA3', 'VA4', 'VA5', 'VA6', 'VA7', 'VA8', 'VA9', 'VB1', 'VB10',
'VB11', 'VB2', 'VB3', 'VB4', 'VB5', 'VB6', 'VB7', 'VB8', 'VB9', 'VC1',
'VC2', 'VC3', 'VC4', 'VC5', 'VC6', 'VD1', 'VD10', 'VD11', 'VD12',
'VD13', 'VD2', 'VD3', 'VD4', 'VD5', 'VD6', 'VD7', 'VD8', 'VD9'
]
cells += ['AVAL', 'AVAR', 'AVBL', 'AVBR', 'AVDL', 'AVDR', 'PVCL', 'PVCR']
#cells=None # implies all cells...
## Some random set of neurons
#probability = 0.1
cells_to_stimulate = []
'''
for cell in cells:
#if random.random()<probability:
# cells_to_stimulate.append(cell)
if cell.startswith("xxVB") or cell.startswith("DB"):
cells_to_stimulate.append(cell)'''
#cells_to_stimulate = ['DB1', 'VB1']
cells_to_stimulate = ['PVCL', 'AVBL']
cells_to_stimulate.extend(['DB1', 'VB1'])
cells_to_stimulate = ['PVCL', 'PVCR']
# Plot some directly stimulated & some not stimulated
cells_to_plot = [
'AS1', 'AS10', 'AVFL', 'DA1', 'DB1', 'DB4', 'DB7', 'IL1DL', 'RID',
'RIML', 'SMBDL', 'SMBDR', 'VB1', 'VB5', 'VB10', 'VC1', 'VC2'
]
cells_to_plot = [
'AVBL', 'AVBR', 'PVCL', 'PVCR', 'DB1', 'DB2', 'VB1', 'VB2', 'DD1',
'DD2', 'VD1', 'VD2'
]
reference = "c302_%s_Muscles" % parameter_set
include_muscles = True
if generate:
c302.generate(reference,
params,
cells=cells,
cells_to_plot=cells_to_plot,
cells_to_stimulate=cells_to_stimulate,
include_muscles=include_muscles,
duration=duration,
dt=dt,
validate=(parameter_set != 'B'),
target_directory=target_directory)
return cells, cells_to_stimulate, params, include_muscles
from c302 import generate
import parameters_A as params
if __name__ == '__main__':
# Some random set of neurons
cells_to_stimulate = [
"ADAL", "ADAR", "M1", "M2L", "M3L", "M3R", "M4", "I1R", "I2L", "I5",
"I6", "MI", "NSMR", "MCL", "ASEL", "AVEL", "AWAR", "DB1", "DVC",
"RIAR", "RMDDL"
]
# Plot some directly stimulated & some not stimulated
cells_to_plot = ["ADAL", "ADAR", "PVDR", "BDUR", "I1R", "I2L"]
generate("c302_A",
params,
cells_to_plot=cells_to_plot,
cells_to_stimulate=cells_to_stimulate,
duration=500,
dt=0.1,
vmin=-72,
vmax=-48)
parameter_set = sys.argv[1] if len(sys.argv) == 2 else 'A'
exec('from parameters_%s import ParameterisedModel' % parameter_set)
params = ParameterisedModel()
cells = ["URYDL", "SMDDR", "ADAL", "RIML", "IL2VL", "RIPL"]
cells_to_stimulate = []
reference = "c302_%s_MultiSyns" % parameter_set
target_directory = 'examples'
nml_doc = generate(reference,
params,
cells=cells,
cells_to_stimulate=cells_to_stimulate,
duration=1000,
dt=0.1,
target_directory=target_directory,
verbose=verbose)
stim_amplitude = "0.35nA"
add_new_input(nml_doc, "URYDL", "100ms", "200ms", stim_amplitude, params)
add_new_input(nml_doc, "ADAL", "400ms", "200ms", stim_amplitude, params)
add_new_input(nml_doc, "IL2VL", "700ms", "200ms", stim_amplitude, params)
nml_file = target_directory + '/' + reference + '.nml'
writers.NeuroMLWriter.write(
nml_doc, nml_file) # Write over network file written above...
print("(Re)written network file to: " + nml_file)
# Some random set of neurons
probability = 0.1
cells_to_stimulate = []
for cell in cells:
#if random.random()<probability:
# cells_to_stimulate.append(cell)
if cell.startswith("xxVB") or cell.startswith("DB"):
cells_to_stimulate.append(cell)
#cells_to_stimulate = ['DB1', 'VB1']
cells_to_stimulate = ['PVCL', 'PVCR', 'VB1', 'VB2', 'VB3']
# Plot some directly stimulated & some not stimulated
cells_to_plot = ['AS1', 'AS10', 'AVFL', 'DA1','DB1','DB4','DB7','IL1DL','RID', 'RIML','SMBDL', 'SMBDR', 'VB1', 'VB5', 'VB10','VC1', 'VC2']
cells_to_plot = ['AVBL', 'AVBR','PVCL', 'PVCR', 'DB1','DB2','VB1','VB2','DD1','DD2','VD1','VD2']
reference = "c302_%s_Muscles"%parameter_set
generate(reference,
params,
cells=cells,
cells_to_plot=cells_to_plot,
cells_to_stimulate=cells_to_stimulate,
include_muscles = True,
duration=500,
dt=0.1,
vmin=-52,
vmax=-28,
validate=(parameter_set!='B'),
target_directory='examples')
def setup(parameter_set,
generate=False,
duration=2000,
dt=0.05,
target_directory='examples',
data_reader="SpreadsheetDataReader",
param_overrides={},
verbose=True,
config_param_overrides={}):
exec('from parameters_%s import ParameterisedModel' % parameter_set,
globals())
params = ParameterisedModel()
params.set_bioparameter("unphysiological_offset_current", "0pA",
"Testing TapWithdrawal", "0")
params.set_bioparameter("unphysiological_offset_current_del", "0 ms",
"Testing TapWithdrawal", "0")
params.set_bioparameter("unphysiological_offset_current_dur", "2000 ms",
"Testing TapWithdrawal", "0")
VA_motors = ["VA%s" % c for c in range_incl(1, 12)]
VB_motors = ["VB%s" % c for c in range_incl(1, 11)]
DA_motors = ["DA%s" % c for c in range_incl(1, 9)]
DB_motors = ["DB%s" % c for c in range_incl(1, 7)]
DD_motors = ["DD%s" % c for c in range_incl(1, 6)]
VD_motors = ["VD%s" % c for c in range_incl(1, 13)]
AS_motors = ["AS%s" % c for c in range_incl(1, 11)]
cells = list(['AVBL', 'AVBR'] + DB_motors + VD_motors + VB_motors +
DD_motors)
muscles_to_include = True
cells_to_stimulate = []
cells_to_plot = list(cells)
reference = "c302_%s_FW" % parameter_set
conns_to_include = []
conns_to_exclude = [
'VB2-VB4_GJ',
'VB4-VB2_GJ',
]
conn_polarity_override = {
r'^DB\d+-DD\d+$': 'inh',
r'^VB\d+-VD\d+$': 'inh',
}
conn_number_override = {
'^.+-.+$': 1,
}
input_list = []
'''dur = '250ms'
amp = '3pA'
for muscle_num in range(24):
mdlx = 'MDL0%s' % (muscle_num + 1)
mdrx = 'MDR0%s' % (muscle_num + 1)
#mvlx = 'MVL0%s' % (muscle_num + 1)
#mvrx = 'MVR0%s' % (muscle_num + 1)
if muscle_num >= 9:
mdlx = 'MDL%s' % (muscle_num + 1)
mdrx = 'MDR%s' % (muscle_num + 1)
#mvlx = 'MVL%s' % (muscle_num + 1)
#mvrx = 'MVR%s' % (muscle_num + 1)
startd = '%sms' % (muscle_num * 10)
#startv = '%sms' % ((stim_num * 800 + 400) + muscle_num * 30)
input_list.append((mdlx, startd, dur, amp))
input_list.append((mdrx, startd, dur, amp))'''
input_list.append(('MVR10', '0ms', '150ms', '1pA'))
input_list.append(('MVR11', '0ms', '150ms', '2pA'))
input_list.append(('MVR12', '0ms', '150ms', '3pA'))
input_list.append(('MVR13', '0ms', '150ms', '3pA'))
input_list.append(('MVR14', '0ms', '150ms', '2pA'))
input_list.append(('MVR15', '0ms', '150ms', '1pA'))
input_list.append(('MVL10', '0ms', '150ms', '1pA'))
input_list.append(('MVL11', '0ms', '150ms', '2pA'))
input_list.append(('MVL12', '0ms', '150ms', '3pA'))
input_list.append(('MVL13', '0ms', '150ms', '3pA'))
input_list.append(('MVL14', '0ms', '150ms', '2pA'))
input_list.append(('MVL15', '0ms', '150ms', '1pA'))
input_list.append(('MDL21', '0ms', '250ms', '3pA'))
input_list.append(('MDL22', '0ms', '250ms', '3pA'))
input_list.append(('MDR21', '0ms', '250ms', '3pA'))
input_list.append(('MDR22', '0ms', '250ms', '3pA'))
amp = '4pA'
dur = '250ms'
for stim_num in range(15):
for muscle_num in range(7):
mdlx = 'MDL0%s' % (muscle_num + 1)
mdrx = 'MDR0%s' % (muscle_num + 1)
mvlx = 'MVL0%s' % (muscle_num + 1)
mvrx = 'MVR0%s' % (muscle_num + 1)
if muscle_num >= 9:
mdlx = 'MDL%s' % (muscle_num + 1)
mdrx = 'MDR%s' % (muscle_num + 1)
mvlx = 'MVL%s' % (muscle_num + 1)
mvrx = 'MVR%s' % (muscle_num + 1)
startd = '%sms' % (stim_num * 800 + muscle_num * 30)
startv = '%sms' % ((stim_num * 800 + 400) + muscle_num * 30)
input_list.append((mdlx, startd, dur, amp))
input_list.append((mdrx, startd, dur, amp))
if muscle_num != 6:
input_list.append((mvlx, startv, dur, amp))
input_list.append((mvrx, startv, dur, amp))
d_v_delay = 400
start = 190
motor_dur = '250ms'
input_list.append(('AVBL', '0ms', '%sms' % duration, '15pA'))
input_list.append(('AVBR', '0ms', '%sms' % duration, '15pA'))
input_list.append(('DB1', '%sms' % (start), motor_dur, '3pA'))
input_list.append(('VB1', '%sms' % (start + d_v_delay), motor_dur, '3pA'))
i = start + 2 * d_v_delay
j = start + 3 * d_v_delay
for pulse_num in range(1, 15):
input_list.append(('DB1', '%sms' % i, motor_dur, '3pA'))
input_list.append(('VB1', '%sms' % j, motor_dur, '3pA'))
i += d_v_delay * 2
j += d_v_delay * 2
#input_list = []
#input_list.append(('AVBL', '0ms', '1900ms', '15pA'))
#input_list.append(('AVBR', '0ms', '1900ms', '15pA'))
config_param_overrides['input'] = input_list
param_overrides = {
'mirrored_elec_conn_params': {
r'^AVB._to_DB\d+\_GJ$_elec_syn_gbase': '0.001 nS',
r'^AVB._to_VB\d+\_GJ$_elec_syn_gbase': '0.001 nS',
r'^DB\d+_to_DB\d+\_GJ$_elec_syn_gbase': '0.001 nS',
#'^DB\d+_to_DB\d+\_GJ$_elec_syn_p_gbase': '0.08 nS',
#'^DB\d+_to_DB\d+\_GJ$_elec_syn_sigma': '0.2 per_mV',
#'^DB\d+_to_DB\d+\_GJ$_elec_syn_mu': '-20 mV',
r'^VB\d+_to_VB\d+\_GJ$_elec_syn_gbase': '0.001 nS',
#'^VB\d+_to_VB\d+\_GJ$_elec_syn_p_gbase': '0.1 nS',
#'^VB\d+_to_VB\d+\_GJ$_elec_syn_sigma': '0.3 per_mV',
#'^VB\d+_to_VB\d+\_GJ$_elec_syn_mu': '-30 mV',
#'VB2_to_VB4_elec_syn_gbase': '0 nS',
r'^DB\d+_to_VB\d+\_GJ$_elec_syn_gbase': '0 nS',
r'^DB\d+_to_DD\d+\_GJ$_elec_syn_gbase': '0 nS',
r'^VB\d+_to_VD\d+\_GJ$_elec_syn_gbase': '0 nS',
#'^VD\d+_to_DD\d+\_GJ$_elec_syn_gbase': '0 nS',
'DD1_to_MVL08_elec_syn_gbase': '0 nS',
'VD2_to_MDL09_elec_syn_gbase': '0 nS',
},
r'^VB\d+_to_VB\d+$_exc_syn_conductance': '18 nS',
r'^VB\d+_to_VB\d+$_exc_syn_ar': '0.19 per_s',
r'^VB\d+_to_VB\d+$_exc_syn_ad': '73 per_s',
r'^VB\d+_to_VB\d+$_exc_syn_beta': '2.81 per_mV',
r'^VB\d+_to_VB\d+$_exc_syn_vth': '-22 mV',
r'^VB\d+_to_VB\d+$_exc_syn_erev': '10 mV',
r'^DB\d+_to_DB\d+$_exc_syn_conductance': '20 nS',
r'^DB\d+_to_DB\d+$_exc_syn_ar': '0.08 per_s',
r'^DB\d+_to_DB\d+$_exc_syn_ad': '18 per_s',
r'^DB\d+_to_DB\d+$_exc_syn_beta': '0.21 per_mV',
r'^DB\d+_to_DB\d+$_exc_syn_vth': '-10 mV',
r'^DB\d+_to_DB\d+$_exc_syn_erev': '10 mV',
'initial_memb_pot': '-50 mV',
'AVBR_to_DB4_exc_syn_conductance': '0 nS',
#'VB4_to_VB5_exc_syn_conductance': '0 nS',
'AVBL_to_VB2_exc_syn_conductance': '0 nS',
'AVBR_to_VD3_exc_syn_conductance': '0 nS',
#'^DB\d+_to_DD\d+$_exc_syn_conductance': '0 nS',
#'^DD\d+_to_DB\d+$_inh_syn_conductance': '0 nS',
#'^VB\d+_to_VD\d+$_exc_syn_conductance': '0 nS',
#'^VD\d+_to_VB\d+$_inh_syn_conductance': '0 nS',
'DD1_to_VB2_inh_syn_conductance': '0 nS',
'neuron_to_muscle_exc_syn_conductance': '0.5 nS',
r'^DB\d+_to_MDL\d+$_exc_syn_conductance': '0.4 nS',
r'^DB\d+_to_MDR\d+$_exc_syn_conductance': '0.4 nS',
r'^VB\d+_to_MVL\d+$_exc_syn_conductance': '0.6 nS',
r'^VB\d+_to_MVR\d+$_exc_syn_conductance': '0.6 nS',
'neuron_to_muscle_exc_syn_vth': '37 mV',
'neuron_to_muscle_inh_syn_conductance': '0.6 nS',
'neuron_to_neuron_inh_syn_conductance': '0.2 nS',
#'DB2_to_MDL11_exc_syn_conductance': '1 nS',
'AVBR_to_MVL16_exc_syn_conductance': '0 nS',
'ca_conc_decay_time_muscle': '60.8 ms',
'ca_conc_rho_muscle': '0.002338919 mol_per_m_per_A_per_s',
}
nml_doc = None
if generate:
nml_doc = c302.generate(reference,
params,
cells=cells,
cells_to_plot=cells_to_plot,
cells_to_stimulate=cells_to_stimulate,
conns_to_include=conns_to_include,
conns_to_exclude=conns_to_exclude,
conn_polarity_override=conn_polarity_override,
conn_number_override=conn_number_override,
muscles_to_include=muscles_to_include,
duration=duration,
dt=dt,
target_directory=target_directory,
data_reader=data_reader,
param_overrides=param_overrides,
verbose=verbose)
#if config_param_overrides.has_key('input'):
# input_list = config_param_overrides['input']
for stim_input in input_list:
cell, start, dur, current = stim_input
c302.add_new_input(nml_doc, cell, start, dur, current, params)
nml_file = target_directory + '/' + reference + '.net.nml'
writers.NeuroMLWriter.write(
nml_doc, nml_file) # Write over network file written above...
print("(Re)written network file to: " + nml_file)
return cells, cells_to_stimulate, params, muscles_to_include, nml_doc
exec('from parameters_%s import ParameterisedModel'%parameter_set)
params = ParameterisedModel()
cells = ["RMGR","ASHR","ASKR","AWBR","IL2R","RMHR","URXR"]
cells_to_stimulate = []
reference = "c302_%s_Social"%parameter_set
target_directory='examples'
nml_doc = generate(reference,
params,
cells=cells,
cells_to_stimulate=cells_to_stimulate,
duration=2500,
dt=0.1,
vmin=-72 if parameter_set=='A' else -52,
vmax=-48 if parameter_set=='A' else -28,
validate=(parameter_set!='B'),
target_directory=target_directory)
stim_amplitude = "0.35nA"
add_new_input(nml_doc, "RMGR", "100ms", "200ms", stim_amplitude, params)
add_new_input(nml_doc, "ASHR", "400ms", "200ms", stim_amplitude, params)
add_new_input(nml_doc, "ASKR", "700ms", "200ms", stim_amplitude, params)
add_new_input(nml_doc, "AWBR", "1000ms", "200ms", stim_amplitude, params)
add_new_input(nml_doc, "IL2R", "1300ms", "200ms", stim_amplitude, params)
add_new_input(nml_doc, "RMHR", "1600ms", "200ms", stim_amplitude, params)
add_new_input(nml_doc, "URXR", "1900ms", "200ms", stim_amplitude, params)
def setup(parameter_set,
generate=False,
duration=2000,
dt=0.05,
target_directory='../../../examples',
data_reader="SpreadsheetDataReader",
param_overrides={},
verbose=True,
config_param_overrides={}):
exec ('from parameters_%s import ParameterisedModel' % parameter_set)
params = ParameterisedModel()
params.set_bioparameter("unphysiological_offset_current", "0pA", "Testing TapWithdrawal", "0")
params.set_bioparameter("unphysiological_offset_current_del", "0 ms", "Testing TapWithdrawal", "0")
params.set_bioparameter("unphysiological_offset_current_dur", "2000 ms", "Testing TapWithdrawal", "0")
VA_motors = ["VA%s" % c for c in range_incl(1, 12)]
VB_motors = ["VB%s" % c for c in range_incl(1, 11)]
DA_motors = ["DA%s" % c for c in range_incl(1, 9)]
DB_motors = ["DB%s" % c for c in range_incl(1, 7)]
DD_motors = ["DD%s" % c for c in range_incl(1, 6)]
VD_motors = ["VD%s" % c for c in range_incl(1, 13)]
AS_motors = ["AS%s" % c for c in range_incl(1, 11)]
cells = list(['AVAL', 'AVAR'] + VA_motors + DA_motors + VD_motors + DD_motors)
muscles_to_include = True
cells_to_stimulate = []
cells_to_plot = list(cells)
reference = "c302_%s_AVA_VA_DA_VD_DD" % parameter_set
conns_to_include = [
]
conn_polarity_override = {}
if config_param_overrides.has_key('conn_polarity_override'):
conn_polarity_override.update(config_param_overrides['conn_polarity_override'])
conn_number_override = {}
if config_param_overrides.has_key('conn_number_override'):
conn_number_override.update(config_param_overrides['conn_number_override'])
nml_doc = None
if generate:
nml_doc = c302.generate(reference,
params,
cells=cells,
cells_to_plot=cells_to_plot,
cells_to_stimulate=cells_to_stimulate,
conns_to_include=conns_to_include,
conn_polarity_override=conn_polarity_override,
conn_number_override=conn_number_override,
muscles_to_include=muscles_to_include,
duration=duration,
dt=dt,
target_directory=target_directory,
data_reader=data_reader,
param_overrides=param_overrides,
verbose=verbose)
end = int(duration) - 500
#for vb in VB_motors:
# c302.add_new_sinusoidal_input(nml_doc, cell=vb, delay="0ms", duration="1000ms", amplitude="3pA",
# period="700ms", params=params)
#for db in DB_motors:
# c302.add_new_sinusoidal_input(nml_doc, cell=db, delay="0ms", duration="1000ms", amplitude="3pA",
# period="700ms", params=params)
c302.add_new_input(nml_doc, "AVAL", "50ms", "%sms"%end, "15pA", params)
c302.add_new_input(nml_doc, "AVAR", "50ms", "%sms"%end, "15pA", params)
nml_file = target_directory + '/' + reference + '.net.nml'
writers.NeuroMLWriter.write(nml_doc, nml_file) # Write over network file written above...
print("(Re)written network file to: " + nml_file)
return cells, cells_to_stimulate, params, muscles_to_include, nml_doc
def setup(parameter_set,
generate=False,
duration=2000,
dt=0.05,
target_directory='examples',
data_reader="SpreadsheetDataReader",
param_overrides={},
verbose=True,
config_param_overrides={}):
exec('from parameters_%s import ParameterisedModel' % parameter_set)
params = ParameterisedModel()
params.set_bioparameter("unphysiological_offset_current", "0pA",
"Testing TapWithdrawal", "0")
params.set_bioparameter("unphysiological_offset_current_del", "0 ms",
"Testing TapWithdrawal", "0")
params.set_bioparameter("unphysiological_offset_current_dur", "2000 ms",
"Testing TapWithdrawal", "0")
VA_motors = ["VA%s" % c for c in range_incl(1, 12)]
VB_motors = ["VB%s" % c for c in range_incl(1, 11)]
DA_motors = ["DA%s" % c for c in range_incl(1, 9)]
DB_motors = ["DB%s" % c for c in range_incl(1, 7)]
DD_motors = ["DD%s" % c for c in range_incl(1, 6)]
VD_motors = ["VD%s" % c for c in range_incl(1, 13)]
AS_motors = ["AS%s" % c for c in range_incl(1, 11)]
#cells = list(['AVBL', 'AVBR'] + DB_motors + VD_motors + VB_motors + DD_motors + VA_motors + DA_motors + AS_motors)
#cells = list(['AVBL', 'AVBR', 'AVAL', 'AVAR'] + DB_motors + VD_motors + VB_motors + DD_motors + AS_motors + VA_motors + DA_motors)
#cells = list(['AVBL', 'AVBR'] + ['DB2', 'DB5', 'DB6'])
cells = list(['AVBL', 'AVBR'] + DB_motors)
muscles_to_include = True
cells_to_stimulate = []
cells_to_plot = list(cells)
reference = "c302_%s_AVB_DB" % parameter_set
conns_to_include = []
if config_param_overrides.has_key('conns_to_include'):
conns_to_include = config_param_overrides['conns_to_include']
conn_polarity_override = {}
if config_param_overrides.has_key('conn_polarity_override'):
conn_polarity_override.update(
config_param_overrides['conn_polarity_override'])
conn_number_override = {}
if config_param_overrides.has_key('conn_number_override'):
conn_number_override.update(
config_param_overrides['conn_number_override'])
nml_doc = None
if generate:
nml_doc = c302.generate(reference,
params,
cells=cells,
cells_to_plot=cells_to_plot,
cells_to_stimulate=cells_to_stimulate,
conns_to_include=conns_to_include,
conn_polarity_override=conn_polarity_override,
conn_number_override=conn_number_override,
muscles_to_include=muscles_to_include,
duration=duration,
dt=dt,
target_directory=target_directory,
data_reader=data_reader,
param_overrides=param_overrides,
verbose=verbose)
end = int(duration) - 100
#for db in DB_motors:
# c302.add_new_sinusoidal_input(nml_doc, cell=db, delay="0ms", duration="1000ms", amplitude="3pA",
# period="700ms", params=params)
c302.add_new_input(nml_doc, "AVBL", "50ms", "%sms" % end, "15pA",
params)
c302.add_new_input(nml_doc, "AVBR", "50ms", "%sms" % end, "15pA",
params)
#c302.add_new_input(nml_doc, "AVBL", "50ms", "850ms", "15pA", params)
#c302.add_new_input(nml_doc, "AVBR", "50ms", "850ms", "15pA", params)
nml_file = target_directory + '/' + reference + '.nml'
writers.NeuroMLWriter.write(
nml_doc, nml_file) # Write over network file written above...
print("(Re)written network file to: " + nml_file)
return cells, cells_to_stimulate, params, muscles_to_include, nml_doc
def setup(parameter_set,
generate=False,
duration=1000,
dt=0.05,
target_directory='examples',
data_reader="SpreadsheetDataReader",
param_overrides={},
config_param_overrides={},
verbose=True):
exec ('from parameters_%s import ParameterisedModel' % parameter_set)
params = ParameterisedModel()
params.set_bioparameter("unphysiological_offset_current", "0pA", "Testing TapWithdrawal", "0")
params.set_bioparameter("unphysiological_offset_current_del", "0 ms", "Testing TapWithdrawal", "0")
params.set_bioparameter("unphysiological_offset_current_dur", "2000 ms", "Testing TapWithdrawal", "0")
VA_motors = ["VA%s" % c for c in range_incl(1, 12)]
VB_motors = ["VB%s" % c for c in range_incl(1, 11)]
DA_motors = ["DA%s" % c for c in range_incl(1, 9)]
DB_motors = ["DB%s" % c for c in range_incl(1, 7)]
DD_motors = ["DD%s" % c for c in range_incl(1, 6)]
VD_motors = ["VD%s" % c for c in range_incl(1, 13)]
AS_motors = ["AS%s" % c for c in range_incl(1, 11)]
cells = list(VB_motors + DB_motors + DD_motors + VD_motors + AS_motors + VA_motors + DA_motors)
#cells = ['VB1', 'VB2', 'DB1', 'DB2', 'DD1', 'DD2', 'VD1', 'VD2', 'AS1', 'AS2']
# cells += ['AVAL']
# cells += ['DB6']
muscles_to_include = True
muscles_to_include = ['MVL07', 'MVL08', 'MVL09', 'MVR07', 'MVR08', 'MVR09', 'MDL07', 'MDL08', 'MDL09', 'MDR07', 'MDR08', 'MDR09']
cells_to_stimulate = []
#cells_to_stimulate = ['VA1']
cells_to_plot = list(VB_motors + DB_motors)
cells_to_plot = ['VB1', 'VB2', 'DB1', 'DB2', 'DD1', 'DD2', 'VD1', 'VD2', 'AS1', 'AS2']
reference = "c302_%s_SinusoidalInputTest" % parameter_set
conns_to_include = [
]
conn_polarity_override = {
}
conn_number_override = {
}
nml_doc = None
if generate:
nml_doc = c302.generate(reference,
params,
cells=cells,
cells_to_plot=cells_to_plot,
cells_to_stimulate=cells_to_stimulate,
conns_to_include=conns_to_include,
conn_polarity_override=conn_polarity_override,
conn_number_override=conn_number_override,
muscles_to_include=muscles_to_include,
duration=duration,
dt=dt,
target_directory=target_directory,
data_reader=data_reader,
param_overrides=param_overrides,
verbose=verbose)
#for b_type in [b for b in cells if b.startswith("VB") or b.startswith("DB")]:
# c302.add_new_sinusoidal_input(nml_doc, cell=b_type, delay="0ms", duration="1000ms", amplitude="6pA",
# period="150ms", params=params)
c302.add_new_sinusoidal_input(nml_doc, cell="VB1", delay="0ms", duration="1000ms", amplitude="3pA", period="150ms", params=params)
#for vb in VB_motors:
# c302.add_new_sinusoidal_input(nml_doc, cell=vb, delay="0ms", duration="1000ms", amplitude="3pA",
# period="150ms", params=params)
#for db in DB_motors:
# c302.add_new_sinusoidal_input(nml_doc, cell=db, delay="0ms", duration="1000ms", amplitude="3pA",
# period="150ms", params=params)
nml_file = target_directory + '/' + reference + '.net.nml'
writers.NeuroMLWriter.write(nml_doc, nml_file) # Write over network file written above...
print("(Re)written network file to: " + nml_file)
return cells, cells_to_stimulate, params, muscles_to_include, nml_doc
def setup(parameter_set,
generate=False,
duration=1000,
dt=0.05,
target_directory='examples',
data_reader="SpreadsheetDataReader",
param_overrides={},
config_param_overrides={},
verbose=True):
exec('from c302.parameters_%s import ParameterisedModel' % parameter_set,
globals())
params = ParameterisedModel()
params.set_bioparameter("unphysiological_offset_current", "1.5pA",
"Testing Osc", "0")
params.set_bioparameter("unphysiological_offset_current_del", "500 ms",
"Testing Osc", "0")
params.set_bioparameter("unphysiological_offset_current_dur", "1200 ms",
"Testing Osc", "0")
#params.set_bioparameter("initial_memb_pot", "-62 mV", "Testing Osc", "0")
#params.set_bioparameter("chem_exc_syn_gbase", ".2 nS", "BlindGuess", "0.1")
#params.set_bioparameter("chem_exc_syn_decay", "5 ms", "BlindGuess", "0.1")
#params.set_bioparameter("chem_inh_syn_gbase", ".2 nS", "BlindGuess", "0.1")
#params.set_bioparameter("chem_inh_syn_decay", "30 ms", "BlindGuess", "0.1")
#params.set_bioparameter("inh_syn_erev", "-90 mV", "BlindGuess", "0.1")
params.set_bioparameter("neuron_to_neuron_elec_syn_gbase", "0.0001 nS",
"BlindGuess", "0.1")
# Any neurons connected to muscles
cells = [
'DB1', 'DB2', 'DB3', 'DB4', 'DB5', 'DB6', 'DB7', 'DD1', 'DD2', 'DD3',
'DD4', 'DD5', 'DD6', 'VB1', 'VB2', 'VB3', 'VB4', 'VB5', 'VB6', 'VB7',
'VB8', 'VB9', 'VB10', 'VB11', 'VD1', 'VD2', 'VD3', 'VD4', 'VD5', 'VD6',
'VD7', 'VD8', 'VD9', 'VD10', 'VD11', 'VD12', 'VD13'
]
cells += ['DA1', 'DA2', 'DA3', 'DA4', 'DA5', 'DA6', 'DA7', 'DA8', 'DA9']
cells += [
'VA1', 'VA2', 'VA3', 'VA4', 'VA5', 'VA6', 'VA7', 'VA8', 'VA9', 'VA10',
'VA11', 'VA12'
]
#cells = ['DB2', 'VB2', 'DD2', 'VD2', 'DB3', 'VB3', 'DD3', 'VD3', 'DB4', 'VB4', 'DD4', 'VD4']
#cells = ['DB3', 'VB3', 'DD3', 'VD3']
#cells += ['DA2', 'VA2','DA3','VA3']
#cells = ['DB3', 'VB3', 'DB4', 'VB4']
#cells+=['AVBL','PVCL','AVBR','PVCR']
#cells+=[]
cells += ['PVCL', 'PVCR', 'AVBL', 'AVBR']
#cells+=['AVAL','AVAR']
#cells+=['AVBL','AVBR']
#cells=None # implies all cells...
#cells = ['AVBR', 'VB2', 'VD3', 'DB3', 'DD2']
#cells = ['VB2', 'VD3']
#cells_to_stimulate = ['PVCL','PVCR']
#cells_to_stimulate = ['PLML','PLMR']
cells_to_stimulate = ['AVBR']
cells_to_stimulate = ['VB1', 'VB2']
#cells_to_stimulate = ['AVAL']
# Plot some directly stimulated & some not stimulated
# cells_to_plot = ['AVBL','PVCL', 'PVCR', 'DB1','DB2','DB3', 'DB4','DD1','DD2','DD3', 'DD4','DB4','VB1','VB2', 'VB3', 'VB4','VD1','VD2', 'VD3', 'VD4']
cells_to_plot = cells
reference = "c302_%s_OscillatorM" % parameter_set
muscles_to_include = None # i.e. all
muscles_to_include = []
nml_doc = None
if generate:
nml_doc = c302.generate(reference,
params,
cells=cells,
cells_to_plot=cells_to_plot,
cells_to_stimulate=cells_to_stimulate,
muscles_to_include=muscles_to_include,
duration=duration,
dt=dt,
target_directory=target_directory,
param_overrides=param_overrides,
verbose=verbose,
data_reader=data_reader)
return cells, cells_to_stimulate, params, muscles_to_include, nml_doc
def setup(parameter_set,
generate=False,
duration=2000,
dt=0.05,
target_directory='examples',
data_reader="UpdatedSpreadsheetDataReader",
param_overrides={},
verbose=True,
config_param_overrides={}):
exec('from parameters_%s import ParameterisedModel' % parameter_set)
params = ParameterisedModel()
params.set_bioparameter("unphysiological_offset_current", "0pA",
"Testing TapWithdrawal", "0")
params.set_bioparameter("unphysiological_offset_current_del", "0 ms",
"Testing TapWithdrawal", "0")
params.set_bioparameter("unphysiological_offset_current_dur", "2000 ms",
"Testing TapWithdrawal", "0")
VA_motors = ["VA%s" % c for c in range_incl(1, 12)]
VB_motors = ["VB%s" % c for c in range_incl(1, 11)]
DA_motors = ["DA%s" % c for c in range_incl(1, 9)]
DB_motors = ["DB%s" % c for c in range_incl(1, 7)]
DD_motors = ["DD%s" % c for c in range_incl(1, 6)]
VD_motors = ["VD%s" % c for c in range_incl(1, 13)]
AS_motors = ["AS%s" % c for c in range_incl(1, 11)]
cells = list(['AVBL', 'AVBR'] + VB_motors + DB_motors + VD_motors +
DD_motors)
muscles_to_include = False
if config_param_overrides.has_key('muscles_to_include'):
muscles_to_include = config_param_overrides['muscles_to_include']
cells_to_stimulate = []
cells_to_plot = list(cells)
reference = "c302_%s_AVB_VB_DB_VD_DD" % parameter_set
conns_to_include = []
if config_param_overrides.has_key('conns_to_include'):
conns_to_include = config_param_overrides['conns_to_include']
conns_to_exclude = []
if config_param_overrides.has_key('conns_to_exclude'):
conns_to_exclude = config_param_overrides['conns_to_exclude']
conn_polarity_override = {}
if config_param_overrides.has_key('conn_polarity_override'):
conn_polarity_override.update(
config_param_overrides['conn_polarity_override'])
conn_number_override = {}
if config_param_overrides.has_key('conn_number_override'):
conn_number_override.update(
config_param_overrides['conn_number_override'])
end = '%sms' % (int(duration) - 100)
input_list = [
('AVBL', '0ms', end, '15pA'),
('AVBR', '0ms', end, '15pA'),
]
if config_param_overrides.has_key('input'):
input_list = config_param_overrides['input']
nml_doc = None
if generate:
nml_doc = c302.generate(reference,
params,
cells=cells,
cells_to_plot=cells_to_plot,
cells_to_stimulate=cells_to_stimulate,
conns_to_include=conns_to_include,
conns_to_exclude=conns_to_exclude,
conn_polarity_override=conn_polarity_override,
conn_number_override=conn_number_override,
muscles_to_include=muscles_to_include,
duration=duration,
dt=dt,
target_directory=target_directory,
data_reader=data_reader,
param_overrides=param_overrides,
verbose=verbose)
if config_param_overrides.has_key('input'):
input_list = config_param_overrides['input']
for stim_input in input_list:
cell, start, dur, current = stim_input
c302.add_new_input(nml_doc, cell, start, dur, current, params)
nml_file = target_directory + '/' + reference + '.net.nml'
writers.NeuroMLWriter.write(
nml_doc, nml_file) # Write over network file written above...
print("(Re)written network file to: " + nml_file)
return cells, cells_to_stimulate, params, muscles_to_include, nml_doc
