def _generate_projections(net_id, gather_subprojections): txt = "" proj_tpl = """ %(pre)s & %(post)s & %(target)s & %(synapse)s & %(description)s \\\\ \\hline """ if gather_subprojections: projections = [] for proj in Global._network[net_id]['projections']: for existing_proj in projections: if proj.pre.name == existing_proj.pre.name and proj.post.name == existing_proj.post.name and proj.target == existing_proj.target : # TODO break else: projections.append(proj) else: projections = Global._network[net_id]['projections'] for proj in projections: # Find a name for the synapse if proj.synapse_type.name in Synapse._default_names.values(): # name not set synapse_name = "Synapse " + str(proj.synapse_type._rk_synapses_type) else: synapse_name = proj.synapse_type.name txt += proj_tpl % { 'pre': LatexParser.pop_name(proj.pre.name), 'post': LatexParser.pop_name(proj.post.name), 'target': LatexParser._format_list(proj.target, ' / '), 'synapse': synapse_name, 'description': proj.connector_description} return connectivity_template % {'projections_description': txt}
def _generate_population_parameters(net_id): txt = "" pop_tpl = """ %(name)s & $%(param)s$ & %(value)s \\\\ \\hline """ for rk, pop in enumerate(Global._network[net_id]['populations']): parameters = "" for idx, param in enumerate(pop.parameters): val = pop.init[param] if isinstance(val, (list, np.ndarray)): val = "$[" + str(np.array(val).min()) + ", " + str( np.array(val).max()) + "]$" parameters += pop_tpl % { 'name': LatexParser.pop_name(pop.name) if idx == 0 else "", 'param': LatexParser._latexify_name(param, []), 'value': val } txt += popparameters_template % { 'parameters': parameters, 'firstpopulation': "\hdr{3}{H}{Population parameters}\\\\ \\hline" if rk == 0 else "" } return txt
def _generate_projection_parameters(net_id, gather_subprojections): txt = "" proj_tpl = """ %(name)s & $%(param)s$ & %(value)s \\\\ \\hline """ if gather_subprojections: projections = [] for proj in Global._network[net_id]['projections']: for existing_proj in projections: if proj.pre.name == existing_proj.pre.name and proj.post.name == existing_proj.post.name and proj.target == existing_proj.target: # TODO break else: projections.append(proj) else: projections = Global._network[net_id]['projections'] first = True for rk, proj in enumerate(projections): parameters = "" for idx, param in enumerate(proj.parameters): if param == 'w': continue if idx == 0: proj_name = "%(pre)s $\\rightarrow$ %(post)s with target %(target)s" % { 'pre': LatexParser.pop_name(proj.pre.name), 'post': LatexParser.pop_name(proj.post.name), 'target': LatexParser._format_list(proj.target, ' / ') } else: proj_name = "" val = proj.init[param] if isinstance(val, (list, np.ndarray)): val = "$[" + str(np.min(val)) + ", " + str(np.max(val)) + "]$" parameters += proj_tpl % { 'name': proj_name, 'param': LatexParser._latexify_name(param, []), 'value': val } if parameters != "": txt += projparameters_template % { 'parameters': parameters, 'firstprojection': "\hdr{3}{H}{Projection parameters}\\\\ \\hline" if first else "" } first = False return txt
def _process_variables(variables, neuron=True): eqs = "" for var in variables: # Min value if 'min' in var['bounds'].keys(): min_val = ", minimum: " + str(var['bounds']['min']) else: min_val ="" # Max value if 'max' in var['bounds'].keys(): max_val = ", maximum: " + str(var['bounds']['max']) else: max_val ="" # Method if var['ode']: method = ", " + find_method(var) + " numerical method" else: method = "" eqs += """ * Variable %(name)s : %(locality)s, initial value: %(init)s%(min)s%(max)s%(method)s $$ %(code)s $$ """ % { 'name': "$" + LatexParser._latexify_name(var['name'], []) + "$", 'code': var['latex'], 'locality': _adapt_locality_neuron(var['locality']) if neuron else _adapt_locality_synapse(var['locality']), 'init': var['init'], 'min': min_val, 'max': max_val, 'method': method} return eqs
def _generate_populations(net_id): def format_size(pop): size = str(pop.size) if pop.dimension >1: size += ' (' for d in range(pop.dimension): size += str(pop.geometry[d]) + '*' size = size.rsplit('*', 1)[0] + ')' return size txt = "" pop_tpl = """ %(pop_name)s & %(neuron_type)s & $N_{\\text{%(pop_name)s}}$ = %(size)s \\\\ \\hline """ for pop in Global._network[net_id]['populations']: # Find a name for the neuron if pop.neuron_type.name in Neuron._default_names.values(): # name not set neuron_name = "Neuron " + str(pop.neuron_type._rk_neurons_type) else: neuron_name = pop.neuron_type.name txt += pop_tpl % { 'pop_name': LatexParser.pop_name(pop.name), 'neuron_type': neuron_name, 'size': format_size(pop)} return populations_template % {'populations_description': txt}
def _generate_functions(net_id): functions = "" if len(Global._objects['functions']) == 0: return functions for name, func in Global._objects['functions']: functions += LatexParser._process_functions(func) + "\n" return functions_template % {'parameters': functions, 'firstfunction': "\hdr{1}{G}{Functions}\\\\ \\hline"}
def _generate_summary(net_id): "part A" population_names = str(len(Global._network[net_id]['populations'])) + ': ' connectivity = "" neuron_models = "" synapse_models = "" # List the names of all populations for pop in Global._network[net_id]['populations']: # population name population_names += LatexParser.pop_name(pop.name) + ", " population_names = population_names[:-2] # suppress the last , # List all BOLD recordings measurements = "" # List all neuron types neuron_model_names = [] for neur in Global._objects['neurons']: # bold models sorted in measurements if isinstance(neur, BoldModel): if neur._model_instantiated: measurements += neur.name + ', ' # neuron model else: neuron_model_names.append(neur.name) for neur in list(set(neuron_model_names)): neuron_models += neur + ', ' # suppress the last , measurements = measurements[:-2] neuron_models = neuron_models[:-2] list_connectivity = [] list_synapse_models = [] for proj in Global._network[net_id]['projections']: list_connectivity.append(proj.connector_name) if not proj.synapse_type.name in list(Synapse._default_names.values()) + ['-']: list_synapse_models.append(proj.synapse_type.name) for con in list(set(list_connectivity)): connectivity += con + ', ' for syn in list(set(list_synapse_models)): synapse_models += syn + ', ' connectivity = connectivity[:-2] synapse_models = synapse_models[:-2] # suppress the last , # Write the summary txt = summary_template % { 'population_names' : population_names, 'connectivity' : connectivity, 'neuron_models' : neuron_models, 'synapse_models' : synapse_models, 'measurements': measurements } return txt
def _generate_projection_parameters(net_id, gather_subprojections): txt = "" proj_tpl = """ %(name)s & $%(param)s$ & %(value)s \\\\ \\hline """ if gather_subprojections: projections = [] for proj in Global._network[net_id]['projections']: for existing_proj in projections: if proj.pre.name == existing_proj.pre.name and proj.post.name == existing_proj.post.name and proj.target == existing_proj.target : # TODO break else: projections.append(proj) else: projections = Global._network[net_id]['projections'] first = True for rk, proj in enumerate(projections): parameters = "" for idx, param in enumerate(proj.parameters): if param == 'w': continue if idx == 0: proj_name = "%(pre)s $\\rightarrow$ %(post)s with target %(target)s" % { 'pre': LatexParser.pop_name(proj.pre.name), 'post': LatexParser.pop_name(proj.post.name), 'target': LatexParser._format_list(proj.target, ' / ')} else: proj_name = "" val = proj.init[param] if isinstance(val, (list, np.ndarray)): val = "$[" + str(np.min(val)) + ", " + str(np.max(val)) + "]$" parameters += proj_tpl % {'name': proj_name, 'param': LatexParser._latexify_name(param, []), 'value': val} if parameters != "": txt += projparameters_template % {'parameters': parameters, 'firstprojection': "\hdr{3}{H}{Projection parameters}\\\\ \\hline" if first else ""} first = False return txt
def _generate_constants(net_id): cst_tpl = """ & $%(param)s$ & %(value)s \\\\ \\hline """ parameters = "" if len(Global._objects['constants']) == 0: return "" for constant in Global._objects['constants']: parameters += cst_tpl % {'param': LatexParser._latexify_name(constant.name, []), 'value': constant.value} txt = constants_template % {'parameters': parameters} return txt
def _generate_population_parameters(net_id): txt = "" pop_tpl = """ %(name)s & $%(param)s$ & %(value)s \\\\ \\hline """ for rk, pop in enumerate(Global._network[net_id]['populations']): parameters = "" for idx, param in enumerate(pop.parameters): val = pop.init[param] if isinstance(val, (list, np.ndarray)): val = "$[" + str(np.array(val).min()) + ", " + str(np.array(val).max()) + "]$" parameters += pop_tpl % {'name': LatexParser.pop_name(pop.name) if idx==0 else "", 'param': LatexParser._latexify_name(param, []), 'value': val} txt += popparameters_template % {'parameters': parameters, 'firstpopulation': "\hdr{3}{H}{Population parameters}\\\\ \\hline" if rk==0 else ""} return txt
def _generate_summary(net_id): "part A" population_names = str(len(Global._network[net_id]['populations'])) + ': ' connectivity = "" neuron_models = "" synapse_models = "" # List the names of all populations for pop in Global._network[net_id]['populations']: # population name population_names += LatexParser.pop_name(pop.name) + ", " population_names = population_names[:-2] # suppress the last , # List all neuron types neuron_model_names = [] for neur in Global._objects['neurons']: neuron_model_names.append(neur.name) for neur in list(set(neuron_model_names)): neuron_models += neur + ', ' neuron_models = neuron_models[:-2] # suppress the last , list_connectivity = [] list_synapse_models = [] for proj in Global._network[net_id]['projections']: list_connectivity.append(proj.connector_name) if not proj.synapse_type.name in list(Synapse._default_names.values()) + ['-']: list_synapse_models.append(proj.synapse_type.name) for con in list(set(list_connectivity)): connectivity += con + ', ' for syn in list(set(list_synapse_models)): synapse_models += syn + ', ' connectivity = connectivity[:-2] synapse_models = synapse_models[:-2] # suppress the last , # Write the summary txt = summary_template % { 'population_names' : population_names, 'connectivity' : connectivity, 'neuron_models' : neuron_models, 'synapse_models' : synapse_models } return txt
def _generate_parameters(net_id, gather_subprojections): txt = """ # Parameters """ # Constants if len(Global._objects['constants']) > 0: txt += """ ## Constants """ constants_list = [ ["$" + LatexParser._latexify_name(constant.name, []) + "$", constant.value] for constant in Global._objects['constants']] constants_headers = ["Name", "Value"] txt += _make_table(constants_headers, constants_list) # Population parameters txt += """ ## Population parameters """ parameters_list = [] for rk, pop in enumerate(Global._network[net_id]['populations']): neuron_name = "Neuron " + str(pop.neuron_type._rk_neurons_type) if pop.neuron_type.name in Neuron._default_names.values() \ else pop.neuron_type.name for idx, param in enumerate(pop.parameters): val = pop.init[param] if isinstance(val, (list, np.ndarray)): val = "$[" + str(np.array(val).min()) + ", " + str(np.array(val).max()) + "]$" parameters_list.append( [ LatexParser.pop_name(pop.name) if idx==0 else "", neuron_name if idx==0 else "", "$" + LatexParser._latexify_name(param, []) + "$", val ] ) population_headers = ["Population", "Neuron type", "Name", "Value"] txt += _make_table(population_headers, parameters_list) # Projection parameters txt += """ ## Projection parameters """ if gather_subprojections: projections = [] for proj in Global._network[net_id]['projections']: for existing_proj in projections: if proj.pre.name == existing_proj.pre.name and proj.post.name == existing_proj.post.name \ and proj.target == existing_proj.target : # TODO break else: projections.append(proj) else: projections = Global._network[net_id]['projections'] parameters_list = [] for rk, proj in enumerate(projections): for idx, param in enumerate(proj.parameters): if param == 'w': continue if idx == 0: proj_name = "%(pre)s $\\rightarrow$ %(post)s with target %(target)s" % { 'pre': LatexParser.pop_name(proj.pre.name), 'post': LatexParser.pop_name(proj.post.name), 'target': LatexParser._format_list(proj.target, ' / ')} else: proj_name = "" synapse_name = "Synapse " + str(proj.synapse_type._rk_synapses_type) if proj.synapse_type.name in Synapse._default_names.values() \ else proj.synapse_type.name val = proj.init[param] if isinstance(val, (list, np.ndarray)): val = "$[" + str(np.array(val).min()) + ", " + str(np.array(val).max()) + "]$" parameters_list.append( [ proj_name, synapse_name if idx == 0 else "", "$" + LatexParser._latexify_name(param, []) + "$", val ] ) projection_headers = ["Projection", "Synapse type", "Name", "Value"] txt += _make_table(projection_headers, parameters_list) return txt
def _generate_summary(net_id): txt = """ # Structure of the network """ # General information backend = 'default' if Global.config['paradigm'] == 'cuda': backend = "CUDA" elif Global.config['paradigm'] == "openmp" and Global.config['num_threads'] > 1: backend = "OpenMP" txt +=""" * ANNarchy %(version)s using the %(backend)s backend. * Numerical step size: %(dt)s ms. """ % {'version': ANNarchy.__release__, 'backend': backend, 'dt': Global.config['dt']} # Populations if len(Global._network[net_id]['populations']) > 0: headers = ["Population", "Size", "Neuron type"] populations = [] for pop in Global._network[net_id]['populations']: # Find a name for the neuron neuron_name = "Neuron " + str(pop.neuron_type._rk_neurons_type) if pop.neuron_type.name in Neuron._default_names.values() \ else pop.neuron_type.name populations.append([ pop.name, pop.geometry if len(pop.geometry)>1 else pop.size, neuron_name]) txt += """ ## Populations """ txt += _make_table(headers, populations) # Projections if len(Global._network[net_id]['projections']) > 0 : headers = ["Source", "Destination", "Target", "Synapse type", "Pattern"] projections = [] for proj in Global._network[net_id]['projections']: # Find a name for the synapse synapse_name = "Synapse " + str(proj.synapse_type._rk_synapses_type) if proj.synapse_type.name in Synapse._default_names.values() \ else proj.synapse_type.name projections.append([ proj.pre.name, proj.post.name, LatexParser._format_list(proj.target, ' / '), synapse_name, proj.connector_description ]) txt += """ ## Projections """ txt += _make_table(headers, projections) # Monitors if len(Global._network[net_id]['monitors']) > 0: headers = ["Object", "Variables", "Period"] monitors = [] for monitor in Global._network[net_id]['monitors']: monitors.append([ monitor.object.name + (" (subset)" if isinstance(monitor.object, PopulationView) else ""), LatexParser._format_list(monitor.variables, ', '), monitor.period ]) txt += """ ## Monitors """ txt += _make_table(headers, monitors) # Functions if len(Global._objects['functions']) > 0 : txt += """## Functions """ for name, func in Global._objects['functions']: txt += LatexParser._process_functions(func, begin="$$", end="$$\n\n") return txt
def _generate_synapse_models(net_id): txt = """ # Synapse models """ for idx, synapse in enumerate(Global._objects['synapses']): # Do not document default synapses if synapse.name == "-": continue # Find a name for the synapse synapse_name = "Synapse " + str(synapse._rk_synapses_type) if synapse.name in Synapse._default_names.values() else synapse.name # Description description = synapse.short_description if description == None: description = "Spiking synapse." if synapse.type == 'spike' else 'Rate-coded synapse' # Parameters parameters = extract_parameters(synapse.parameters, synapse.extra_values) parameters_list = [ ["$" + LatexParser._latexify_name(param['name'], []) + "$", param['init'], _adapt_locality_synapse(param['locality']), param['ctype']] for param in parameters] parameters_headers = ["Name", "Default value", "Locality", "Type"] parameters_table = _make_table(parameters_headers, parameters_list) if len(parameters) == 0: parameters_table = "$$\\varnothing$$" # Generate the code for the equations psp, variables, pre_desc, post_desc = LatexParser._process_synapse_equations(synapse) eqs = _process_variables(variables, neuron = False) # PSP if synapse.type == "rate": psp = """ **Weighted sum:** $$%(transmission)s$$ """ % {'transmission': psp} elif synapse.type == "spike" and psp != "": psp = """ **Continuous transmission:** $$%(transmission)s$$ """ % {'transmission': psp} else: psp = "" # Pre- and post-events if synapse.type == "spike": if len(pre_desc) > 0: eqs += """ **Pre-synaptic event at $t_\\text{pre} + d$:** """ for pre in pre_desc: eqs += "$$"+pre+"$$\n" if len(post_desc) > 0: eqs += """ **Post-synaptic event at $t_\\text{post}$:** """ for post in post_desc: eqs += "$$"+post+"$$\n" # Finalize the template txt += synapse_tpl % { 'name': synapse_name, 'description': description, 'psp': psp, 'parameters': parameters_table, 'eqs': eqs} return txt
def _generate_synapse_models(net_id): firstsynapse = "" synapses = "" firstsynapse = "\\hdr{2}{E}{Synapse Models}\\\\ \\hline" synapse_tpl = """ \\noindent \\begin{tabularx}{\\linewidth}{|p{0.15\\linewidth}|X|}\\hline %(firstsynapse)s \\textbf{Name} & %(name)s \\\\ \\hline \\textbf{Type} & %(description)s\\\\ \\hline %(psp)s %(variables)s %(preevent)s %(postevent)s %(functions)s \\end{tabularx} \\vspace{2ex} """ for idx, synapse in enumerate(Global._objects['synapses']): # Do not document default synapses if synapse.name == "-": continue # Find a name for the synapse if synapse.name in Synapse._default_names.values(): # name not set synapse_name = "Synapse " + str(synapse._rk_synapses_type) else: synapse_name = synapse.name # Generate the code for the equations psp, variables, pre_desc, post_desc = LatexParser._process_synapse_equations(synapse) eqs = "" for var in variables: eqs += """ \\begin{dmath*} %(eq)s \\end{dmath*} """ % {'eq': var['latex']} variables_eqs = """ %(eqs)s \\\\ \\hline """ % {'eqs': eqs} # Synaptic variables variables = """ \\textbf{Equations} & %(variables)s \\\\ \\hline""" % {'variables':eqs} if eqs != "" else "" # PSP if psp != "": psp_code = """ \\textbf{PSP} & \\begin{dmath*} %(psp)s \\end{dmath*} \\\\ \\hline""" % {'psp': psp} else: psp_code = "" # Spiking neurons have extra fields for the event-driven if synapse.type == 'spike': if len(pre_desc) > 0: txt_pre = "" for l in pre_desc: txt_pre += """ \\begin{dmath*} %(eq)s \\end{dmath*} """ % {'eq': l} preevent = """ \\textbf{Pre-synaptic event} & %(preevent)s \\\\ \\hline """ % {'preevent': txt_pre} else: preevent = "" if len(post_desc) > 0: txt_post = "" for l in post_desc: txt_post += """ \\begin{dmath*} %(eq)s \\end{dmath*} """ % {'eq': l} postevent = """ \\textbf{Post-synaptic event} & %(postevent)s \\\\ \\hline """ % {'postevent': txt_post} else: postevent = "" else: preevent = "" postevent = "" # Possible functions functions = "" if not synapse.functions == None: functions = """ \\textbf{Functions} & %(functions)s \\\\ \\hline """ % {'functions': LatexParser._process_functions(synapse.functions)} # Build the dictionary desc = { 'name': synapse_name, 'description': synapse.short_description, 'firstsynapse': firstsynapse if idx == 0 else "", 'variables': variables, 'psp': psp_code, 'preevent': preevent, 'postevent': postevent, 'functions': functions } # Generate the code synapses += synapse_tpl % desc return synapses
def _generate_neuron_models(net_id): neurons = "" firstneuron = "\\hdr{2}{D}{Neuron Models}\\\\ \\hline" neuron_tpl = """ \\noindent \\begin{tabularx}{\\linewidth}{|p{0.15\\linewidth}|X|}\\hline %(firstneuron)s \\textbf{Name} & %(name)s \\\\ \\hline \\textbf{Type} & %(description)s\\\\ \\hline \\textbf{%(equation_type)s} & %(variables)s %(spike)s %(functions)s \\end{tabularx} \\vspace{2ex} """ for idx, neuron in enumerate(Global._objects['neurons']): # Name if neuron.name in Neuron._default_names.values(): # name not set neuron_name = "Neuron " + str(neuron._rk_neurons_type) else: neuron_name = neuron.name # Generate the code for the equations variables, spike_condition, spike_reset = LatexParser._process_neuron_equations(neuron) eqs = "" for var in variables: eqs += """ \\begin{dmath*} %(eq)s \\end{dmath*} """ % {'eq': var['latex']} variables_eqs = """ %(eqs)s \\\\ \\hline """ % {'eqs': eqs} # Spiking neurons have an extra field for the spike condition spike_extra = "" if neuron.type == 'spike': spike_code = "If $" + spike_condition + "$ or $t \leq t^* + t_{\\text{refractory}}$:" # Reset spike_code += """ \\begin{enumerate} \\item Emit a spike at time $t^*$""" for var in spike_reset: spike_code += """ \\item $""" + var + "$" spike_code += """ \\end{enumerate}""" spike_extra = """ \\textbf{Spiking} & %(spike)s \\\\ \\hline """ % {'spike': spike_code} # Possible function functions = "" if not neuron.functions == None: functions = """ \\textbf{Functions} & %(functions)s \\\\ \\hline """ % {'functions': LatexParser._process_functions(neuron.functions)} # Build the dictionary desc = { 'name': neuron_name, 'description': neuron.short_description, 'firstneuron': firstneuron if idx ==0 else "", 'variables': variables_eqs, 'spike': spike_extra, 'functions': functions, 'equation_type': "Subthreshold dynamics" if neuron.type == 'spike' else 'Equations' } # Generate the code depending on the neuron position neurons += neuron_tpl % desc return neurons
def _generate_neuron_models(net_id): txt = """ # Neuron models """ for idx, neuron in enumerate(Global._objects['neurons']): # Name if neuron.name in Neuron._default_names.values(): # name not set neuron_name = "Neuron " + str(neuron._rk_neurons_type) else: neuron_name = neuron.name # Description description = neuron.short_description if description == None: description = "Spiking neuron." if neuron.type == 'spike' else 'Rate-coded neuron' # Parameters parameters = extract_parameters(neuron.parameters, neuron.extra_values) parameters_list = [ ["$" + LatexParser._latexify_name(param['name'], []) + "$", param['init'], _adapt_locality_neuron(param['locality']), param['ctype']] for param in parameters] parameters_headers = ["Name", "Default value", "Locality", "Type"] parameters_table = _make_table(parameters_headers, parameters_list) if len(parameters) == 0: parameters_table = "$$\\varnothing$$" # Generate the code for the equations variables, spike_condition, spike_reset = LatexParser._process_neuron_equations(neuron) eqs = _process_variables(variables, neuron=True) # Spiking neurons if neuron.type == 'spike': reset_txt = "* Emit a spike a time $t$.\n" for r in spike_reset: reset_txt += "* $" + r + "$\n" eqs += """ **Spike emission:** if $%(condition)s$ : %(reset)s """ % {'condition': spike_condition, 'reset': reset_txt} # Possible function if not neuron.functions == None: eqs += """ **Functions** %(functions)s """ % {'functions': LatexParser._process_functions(neuron.functions, begin="$$", end="$$\n\n")} # Finalize the template txt += neuron_tpl % { 'name': neuron_name, 'description': description, 'parameters': parameters_table, 'eqs': eqs} return txt
def _generate_neuron_models(net_id): neurons = "" firstneuron = "\\hdr{2}{D}{Neuron Models}\\\\ \\hline" neuron_tpl = """ \\noindent \\begin{tabularx}{\\linewidth}{|p{0.15\\linewidth}|X|}\\hline %(firstneuron)s \\textbf{Name} & %(name)s \\\\ \\hline \\textbf{Type} & %(description)s\\\\ \\hline \\textbf{%(equation_type)s} & %(variables)s %(spike)s %(functions)s \\end{tabularx} \\vspace{2ex} """ first_neuron = True for neuron in Global._objects['neurons']: # skip bold models if isinstance(neuron, BoldModel): continue # Name if neuron.name in Neuron._default_names.values(): # name not set neuron_name = "Neuron " + str(neuron._rk_neurons_type) else: neuron_name = neuron.name # Generate the code for the equations variables, spike_condition, spike_reset = LatexParser._process_neuron_equations(neuron) eqs = "" for var in variables: eqs += """ \\begin{dmath*} %(eq)s \\end{dmath*} """ % {'eq': var['latex']} variables_eqs = """ %(eqs)s \\\\ \\hline """ % {'eqs': eqs} # Spiking neurons have an extra field for the spike condition spike_extra = "" if neuron.type == 'spike': spike_code = "If $" + spike_condition + "$ or $t \leq t^* + t_{\\text{refractory}}$:" # Reset spike_code += """ \\begin{enumerate} \\item Emit a spike at time $t^*$""" for var in spike_reset: spike_code += """ \\item $""" + var + "$" spike_code += """ \\end{enumerate}""" spike_extra = """ \\textbf{Spiking} & %(spike)s \\\\ \\hline """ % {'spike': spike_code} # Possible function functions = "" if not neuron.functions == None: functions = """ \\textbf{Functions} & %(functions)s \\\\ \\hline """ % {'functions': LatexParser._process_functions(neuron.functions)} # Build the dictionary desc = { 'name': neuron_name, 'description': neuron.short_description, 'firstneuron': firstneuron if first_neuron else "", 'variables': variables_eqs, 'spike': spike_extra, 'functions': functions, 'equation_type': "Subthreshold dynamics" if neuron.type == 'spike' else 'Equations' } # Generate the code depending on the neuron position neurons += neuron_tpl % desc # first_neuron = False, to prevent multiple header first_neuron = False return neurons
def _generate_measurements(net_id): measurements = "" header = "\\hdr{2}{D}{Bold Measurement Models}\\\\ \\hline" measurements_template = """ \\noindent \\begin{tabularx}{\\linewidth}{|p{0.15\\linewidth}|X|}\\hline %(header)s \\textbf{Name} & %(name)s \\\\ \\hline \\textbf{Type} & %(description)s\\\\ \\hline \\textbf{%(equation_type)s} & %(variables)s \\end{tabularx} \\vspace{2ex} """ first_define = True for neuron in Global._objects['neurons']: # skip non-bold models if not isinstance(neuron, BoldModel): continue # the model is not used if not neuron._model_instantiated: continue # Name if neuron.name in Neuron._default_names.values(): # name not set neuron_name = "Neuron " + str(neuron._rk_neurons_type) else: neuron_name = neuron.name # Generate the code for the equations variables, _, _ = LatexParser._process_neuron_equations(neuron) eqs = "" for var in variables: eqs += """ \\begin{dmath*} %(eq)s \\end{dmath*} """ % {'eq': var['latex']} variables_eqs = """ %(eqs)s \\\\ \\hline """ % {'eqs': eqs} # Build the dictionary desc = { 'name': neuron_name, 'description': neuron.short_description, 'header': header if first_define else "", 'variables': variables_eqs, 'equation_type': "Equations" } # Generate the code depending on the neuron position measurements += measurements_template % desc # first_define disable to prevent multiple table header first_define = False # no models were processed if len(measurements) == 0: measurements = """ \\noindent \\begin{tabularx}{\\linewidth}{|l|X|}\\hline \\hdr{2}{H}{Measurement}\\\\ \\hline \\textbf{Type} & \\textbf{Description} \\\\ \\hline --- \\\\ \\hline \\end{tabularx} """ return measurements