def summary_table(cls, ):
summary_data = []
for ((modelsrc, celltype), functor) in sorted(cls._cells.iteritems()):
summary_data.append((modelsrc, celltype)) # , functor.__file__)
summary_table = mredoc.VerticalColTable(('Model', 'CellType'),
summary_data)
return mredoc.Section('Cell Library Summary', summary_table)
def summarise_operators(cls):
all_types = cls._get_all_operator_types()
trace_types = cls._trace_types
summary_matrix = empty_str_matrix(N=len(all_types) + 1,
M=len(all_types) + 1)
for (i, tp1) in enumerate(all_types):
summary_matrix[0][i + 1] = tp1.__name__
summary_matrix[i + 1][0] = tp1.__name__
for (j, tp2) in enumerate(all_types):
# Neither of the operand is a trace_type:
if tp1 not in trace_types and tp2 not in trace_types:
summary_matrix[i + 1][j + 1] = '==='
continue
for (op, sym) in operators:
if (op, tp1, tp2) in TraceOperatorCtrl.trace_operators_all:
summary_matrix[i + 1][j + 1] += sym
return mrd.Section(
'TraceOperators',
mrd.VerticalColTable(summary_matrix[0],
summary_matrix[1:],
caption='Operators'))
def _build_singlecell_overview_stimtable(self, stims):
data = [(
stim.name,
stim.location_summary_str,
stim.get_summary_description(),
) for stim in stims]
tbl = mrd.VerticalColTable('Name|Location|Description', data)
return tbl
def build_comp_section(param):
fig = figures[param]
trcs = sorted( trace_comp_res[param] )
comp_tbl_header, comp_tbl_data= zip( *[ ('%s.max_ptp' %c, trace_comp_res[param][c].max_ptp) for c in trcs])
return mrd.Section('Parameters: %s' % str(param),
mrd.VerticalColTable(comp_tbl_header, [comp_tbl_data] ),
mrd.Figure( mrd.Image(fig, auto_adjust=False), caption='Comparison'),
)
def _create_neuron_details_2b_pta(self, nrn):
passives = nrn.biophysics.get_applied_passives()
return mrd.VerticalColTable('PassiveProp|Priority|Targetter|Value', [(
pta.passiveproperty,
pta.targetter.get_priority(),
pta.targetter.get_description(),
str(pta.value),
) for pta in passives],
caption='%s:Passive Properties' % nrn.name)
def _create_neuron_details_2_mta(self, nrn):
mechs = nrn.biophysics.get_applied_mtas()
return mrd.VerticalColTable('Mechanism|Priority|Targetter|Applicator',
[(
'%s ' % (mta.mechanism.name, ),
mta.targetter.get_priority(),
mta.targetter.get_description(),
mta.applicator.get_description(),
) for mta in mechs],
caption='%s:Channels' % nrn.name)
def build_population_overview(self):
if not self.sim.neuron_populations:
return None
table = mrd.VerticalColTable(
"Population | Size | Type "
"", [(pop.pop_name, len(pop), ",".join(pop.cell_types))
for pop in self.sim.neuron_populations])
table2 = mrd.VerticalColTable(
"Population | Size | Type "
"", [(pop.synapse_pop_name, len(pop), ",".join(pop.synapse_types))
for pop in self.sim.synapse_populations])
return mrd.Section(
"Population Overview",
table,
table2,
#self.build_population_overview_dot(),
self.build_population_complete_dot())
def summarise_channels(cls):
mech_types = cls.get_all_chls()
col1 = ['Channel Name'] + [mech.__name__ for mech in mech_types]
cols = [[env._env_name] +
[to_symbol(mech, env.channels) for mech in mech_types]
for env in cls._environments]
col_ = ['Summary'] + [
to_symbol(mech, SummariserLibrary.summarisers)
for mech in mech_types
]
cols = [col1] + cols + [col_]
rows = zip(*cols)
return mrd.Section('Channels', mrd.VerticalColTable(rows[0], rows[1:]))
def summarise_postsynapticmechs(cls):
mech_types = cls.get_all_postsynmechs()
col1 = ['PostSynMech'] + [mech.__name__ for mech in mech_types]
cols = [[env._env_name] + [
to_symbol(mech, env.postsynapticmechanisms) for mech in mech_types
] for env in cls._environments]
col_ = ['Summary'] + [
to_symbol(mech, SummariserLibrary.summarisers)
for mech in mech_types
]
cols = [col1] + cols + [col_]
rows = zip(*cols)
return mrd.Section('Postsynaptic Mechanisms',
mrd.VerticalColTable(rows[0], rows[1:]))
def summarise_methods(cls):
trace_types = cls._trace_types
method_names = cls._get_all_trace_method_names()
def get_argments(method, trace_type):
if not TraceMethodCtrl.has_method(trace_type, method):
return None
functor = TraceMethodCtrl.get_method(trace_type, method)
(args, varargs, varkw, defaults) = inspect.getargspec(functor)
return inspect.formatargspec(args=args[1:],
varargs=varargs,
varkw=varkw,
defaults=defaults)
def get_argments_TraceFixedDT(method):
return str(get_argments(method, TraceFixedDT))
def get_docstring(method):
trace_type = TraceFixedDT
if not TraceMethodCtrl.has_method(trace_type, method):
return '<None>'
func = TraceMethodCtrl.get_method(trace_type, method)
return inspect.getdoc(func)
def _support_for_method(trace_type, method_name):
if (trace_type, method_name) in TraceMethodCtrl.registered_methods:
return 'X'
if method_name in TraceMethodCtrl.fallback_to_fixedtrace_methods:
return '<via fixed>'
arguments = [
get_argments_TraceFixedDT(method_name)
for method_name in method_names
]
docstrings = [
get_docstring(method_name) for method_name in method_names
]
col1 = [''] + method_names
col2 = [[trace_type.__name__] + [
_support_for_method(trace_type, method_name)
for method_name in method_names
] for trace_type in trace_types]
col_args = ['args'] + arguments
col_docstrings = ['docstring'] + docstrings
cols = [col1] + col2 + [col_args] + [col_docstrings]
rows = zip(*cols)
tbl = mrd.VerticalColTable(rows[0], rows[1:], caption='Operators')
return mrd.Section('TraceMethods', tbl)
def _create_neuron_details_1_morphology(self, nrn):
morph = nrn.morphology
section_indexer = SectionIndexerDF(morph)
section_table = mrd.VerticalColTable(
'ID|Tags|Lateral Surface Area (um2)|Region|nseg|L|diam (prox/dist)',
[(section_indexer[sec], sec.idtag, '%.0f' % sec.area,
(sec.region.name if sec.region else ''),
nrn.cell_segmenter.get_num_segments(sec), sec.length,
'%.1f/%.1f' % (sec.p_r * 2., sec.d_r * 2.)) for sec in morph],
caption='%s:Morphology (Sections)' % nrn.name)
region_table = mrd.VerticalColTable(
'Region|Surface Area|\#Sections',
[(rgn.name, rgn.surface_area, len(rgn))
for rgn in nrn.morphology.regions],
caption='%s:Morphology (Regions)' % nrn.name)
from morphforge.morphology.ui import MatPlotLibViewer
fig = MatPlotLibViewer(nrn.morphology, fig_kwargs={
'figsize': (7, 7)
}).fig
return mrd.HierachyScope(section_table, region_table, mrd.Image(fig),
'tada')
def check_scenarios(**kwargs):
import waf_util
scen_filenames = waf_util.get_all_scenarios()
# Run the individual comparisons, and produce a section for
# each:
all_summary_results = []
results_sections = []
for tgt_scen in waf_util.get_target_scenarios():
tgt_scen_fname = scen_filenames[tgt_scen]
results_section, summary_results = check_scenario( tgt_scen_fname, **kwargs )
results_sections.append(results_section)
all_summary_results.extend(summary_results)
sim_details = mrd.Section('Simulation Details', *results_sections)
# Produce an overall results table
print 'Summary Results'
for sum_res in all_summary_results:
print sum_res
sims = sorted( set( [ res.sim_name for res in all_summary_results] ) )
scens = sorted( set( [ res.scen_name for res in all_summary_results]) )
sim_scen_lut = dict([ ((res.sim_name, res.scen_name),res) for res in all_summary_results])
def table_entry(scen,sim):
key = (sim, scen)
res = sim_scen_lut.get(key , None)
#assert res is not None
if res is None:
return ":warning:[None Found]"
prefix = ':success:' if not res.nmissing and not res.nfails else ''
if res.nmissing:
prefix = ':warning:'
if res.nfails:
prefix = ':err:'
return prefix + res.summary_str()
return str(res)
header = [''] + sims
res = [ ]
for scen in scens:
res.append( [scen] + [ table_entry(scen,sim) for sim in sims ] )
overview_table = mrd.VerticalColTable( header, res)
sim_overview = mrd.Section('Results Overview', overview_table )
return (sim_details,sim_overview)
def test_trace_method_scalarout(src_trace, method_name, method_functor):
res = []
for (conv_type, conv_functor) in conversions:
tr_new = conv_functor(src_trace)
if not mf.TraceMethodCtrl.has_method(conv_type, method_name):
res.append([conv_type.__name__, '--'])
continue
else:
res_new = method_functor(tr_new)
res.append([conv_type.__name__, str(res_new)])
#ax2.plotTrace(method_functor(tr_new), label='%s:%s' % (conv_type.__name__, method_name) )
print res
(header, data) = zip(*res)
print 'header', header
print 'data', data
return mrd.Section('Tesing Method: %s' % method_name,
mrd.VerticalColTable(header, [data]))
def build_mredoc_results_table(impl, validators, table_results, missing_parameter_sets, expected_variables):
import mredoc as mrd
output_cols = set(itertools.chain(*[[v.test_expr for v in V] for V in validators.values()]))
input_cols = sorted(expected_variables)
output_cols = sorted(output_cols)
tbl_res = []
for param in sorted(validators.keys()):
in_vals = [ str(getattr(param,c)) for c in input_cols]
out_vals = []
for output_col_index, output_col in enumerate(output_cols):
key = (impl, param, output_col)
if key in table_results:
R = table_results[key]
prefix = ''
if table_results[key][0]:
prefix=':success:'
res = 'OK %f (%s [eps:%s])' % ( R[2],R[3].expected_value, R[3].eps )
else:
prefix=':err:'
res = '***ERROR %f (%s [eps:%s]) ***' % ( R[2],R[3].expected_value, R[3].eps )
else:
prefix = ''
if (impl,param) in missing_parameter_sets:
prefix=':warning:'
res = ' *** MISSING! *** '
else:
res = '-'
out_vals.append(prefix + str(res))
tbl_res.append(in_vals+out_vals)
headers = input_cols + output_cols
res_tbl = mrd.VerticalColTable( headers, tbl_res,caption='Results for: %s' % impl,)
return res_tbl
def _build_cell_table(cls, cell_list):
table = mrd.VerticalColTable(
'Name|Type|SA(um2)|\#sections/segments|Regions(SA(um2):nseg)|\#Pre/Post-Synapse|\#GapJunctions|Chls',
[(
cell.name,
cell.cell_type_str,
"%.0f" % (cell.morphology.surface_area),
"%d:%d" %
(len(cell.morphology), cell.segmenter.get_num_segment_total()),
" ".join([
"%s(%d:%d)" % (rgn.name, rgn.surface_area,
cell.segmenter.get_num_segment_region(rgn))
for rgn in cell.morphology.regions
]),
"%d %d" % (len(cell.presynaptic_connections),
len(cell.postsynaptic_connections)),
"%d" % len(cell.electrical_connections),
" ".join([chl.name for chl in cell.biophysics.get_channels()]),
) for cell in cell_list])
return table
def _create_neuron_details_4_stimulation(self, nrn):
return mrd.VerticalColTable('Type|Distance From Soma', [],
caption='%s:Stimulation' % nrn.name)
def _create_neuron_details_3b_postsynapses(self, nrn):
return mrd.VerticalColTable('Type|Distance From Soma', [],
caption='%s:Postsynaptic Connections' %
nrn.name)
def _create_neuron_details_3c_gapjunctions(self, nrn):
return mrd.VerticalColTable('Type|Distance From Soma', [],
caption='%s:Gap Junctions' % nrn.name)
