def _build_details_channel(self, chl): sumcls = SummariserLibrary.get_summarisier(chl) if not sumcls: return mrd.Section( 'Summary of channel: %s' % chl.name, mrd.Paragraph('<Summariser Missing for type: %s>' % type(chl))) return mrd.Section('Summary of channel: %s' % chl.name, sumcls.build(chl))
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 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_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 build_mredoc_ouput(trace_comp_res,unexpected_params, config, figures, validators, table_results, missing_parameter_sets, expected_variables, impl_param_filename_dict): print ' -- Producing mredoc output' import mredoc as mrd 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'), ) comparison_graphs = mrd.Section('Trace Comparisons', [build_comp_section(p) for p in figures.keys() ] ) tbl_comp_sections = [] for impl in impl_param_filename_dict: s = build_mredoc_results_table(impl=impl, validators=validators, table_results=table_results, missing_parameter_sets=missing_parameter_sets, expected_variables=expected_variables) tbl_comp_sections.append(s) results_section = mrd.SectionNewPage('%s - %s' % ( config['scenario_short'].capitalize(), config['title'],), mrd.Section('Overview', mrd.Section('Description', mrd.VerbatimBlock(config['description'], caption='Description' ) ), mrd.Section('Implementations', mrd.Paragraph('Tesing against: %s' % ', '.join(impl_param_filename_dict) ) ), mrd.Section('Failures', mrd.Paragraph('TODO!')), mrd.Section('Unexpected Files', mrd.Paragraph('Files:' + ','.join([str(u[1]) for u in unexpected_params]) )), ), mrd.Section('Table Comparisons',*tbl_comp_sections ), comparison_graphs, ) return results_section
def build_simulation(self): from morphforge.management import PluginMgr return mrd.Section( 'Simulation Summary: %s' % self.sim._sim_desc_str(), mrd.TableOfContents(), self.build_simulation_overview(), self.build_simulation_details(), #PluginMgr.summarise_all(), )
def build(cls, obj, result=None): sim_redoc = SimulationMRedoc(obj).mredoc if result is None: return sim_redoc else: return mrd.Section( 'Simulation Results:', mrd.Image(result.fig.fig, auto_adjust=False), sim_redoc, )
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 build_redoc(self, time_data, traces=None, phase_plots=None, params={}, state0In={}, default_state0=None): res = self.__call__(time_data=time_data, params=params, default_state0=default_state0) # What traces do we plot: if traces is False: traces = [] if traces is None: traces = res.keys() # What phase plots shall we draw: if phase_plots is False: phase_plots = [] if phase_plots is None: phase_plots = [] for r in res.keys(): for s in res.keys(): if r != s: phase_plots.append((r, s)) def build_trace_plot(sym): import pylab f = pylab.figure() pylab.plot(res['t'], res[sym]) pylab.xlabel('Time (s)') pylab.ylabel('Symbol: %s') return mredoc.Figure(f) def build_phase_plot(sym1, sym2): import pylab f = pylab.figure() pylab.plot(res[sym1], res[sym2]) pylab.xlabel('Symbol: %s' % sym1) pylab.ylabel('Symbol: %s' % sym2) return mredoc.Figure(f) return mredoc.Section("Simulation Results for: %s" % self.ast.name, [build_trace_plot(tr) for tr in traces] + [build_phase_plot(*tr) for tr in phase_plots])
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 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 test_trace_method_traceout(src_trace, method_name, method_functor): f = QuantitiesFigure(figsize=(6, 4)) f.suptitle('Testing Method: %s' % method_name) ax1 = f.add_subplot(211) ax2 = f.add_subplot(212) ax1.plotTrace(src_trace, label='Original') for (conv_type, conv_functor) in conversions: tr_new = conv_functor(src_trace) if not mf.TraceMethodCtrl.has_method(conv_type, method_name): continue ax2.plotTrace(method_functor(tr_new), label='%s:%s' % (conv_type.__name__, method_name)) ax1.legend() ax2.legend() return mrd.Section('Test: %s' % method_name, mrd.Image(f.fig, auto_adjust=False))
src_files = get_src_9ml_files(args) # Read all the input files: library_manager = NeuroUnitParser.Parse9MLFiles(filenames=src_files) print args.what if not args.what: objs = list(library_manager.objects) else: objs = [ library_manager.get(name) for name in args.what ] summaries = [] for o in objs: print 'Summarising:', repr(o) summaries.append( o.to_redoc() ) summary_obj = mredoc.Section( 'Summary output', *summaries ) fname = os.path.expanduser( '~/Desktop/testout1.pdf') summary_obj.to_pdf(fname) os.system('xdg-open %s' % fname)
def build_population_details(self): return mrd.Section( 'Population Details:', *[ self._build_population_details(pop) for pop in self.sim.neuron_populations ])
def summarise_all(cls): return mrd.Section('Traces', cls.summarise_methods(), cls.summarise_operators(), mrd.Paragraph('asda'))
#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])) for t in tests: tr = TraceStringParser.Parse(t) sects = [] for (method_name, method_functor) in returning_trace_methods: s = test_trace_method_traceout(tr, method_name, method_functor) sects.append(s) #returning_quantities = [ #('mean', lambda tr: tr.mean()), for (method_name, method_functor) in returning_quantities: s = test_trace_method_scalarout(tr, method_name, method_functor) sects.append(s) mrd.Section('Testing: %s' % t, sects).to_pdf('~/Desktop/trace_testing.pdf') #import pylab #pylab.show()
def _build_population_details(self, pop): return mrd.Section('Population: %s' % pop.pop_name, self._build_population_cell_table(pop), *[self.build_neuron_details(nrn) for nrn in pop])
def build_singlecell_details(self): sub_sections = [ self.build_neuron_details(nrn) for nrn in self.sim.cells ] return mrd.Section('Single Cell Details', *sub_sections)
def _build_singlecell_overview_vclamps(self): return mrd.Section( 'Voltage Clamps', self._build_singlecell_overview_stimtable( stims=self.sim.voltage_clamps))
def _build_singlecell_overview_iclamps(self): return mrd.Section( 'Current Clamps', self._build_singlecell_overview_stimtable( stims=self.sim.current_clamps))
def _build_singlecell_overview_cells(self): return mrd.Section('Individual Cells', self._build_cell_table(cell_list=self.sim.cells))
# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT # HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. # ---------------------------------------------------------------------- """ Summarise the cells and channels that are registered to an environment """ import mredoc from morphforge.stdimports import PluginMgr, CellLibrary, ChannelLibrary, MorphologyLibrary import morphforgecontrib.stdimports as mfc from modelling import * fname = '~/Desktop/morphforge_channels.pdf' mredoc.Section('Summary', CellLibrary.summary_table(), ChannelLibrary.summary_table(), MorphologyLibrary.summary_table(), ).to_pdf(fname) print 'Cell & Channel summary stored at: %s'%fname
def build_population_complete_dot(self): fig_count = 0 fig_out = '/tmp/dotimages/' import pydot graph = pydot.Dot('graphname', graph_type='digraph', size='7,7', ratio='compress', compound='true', splines='true', sep='0.3') size = '0.55' fontsize = '6' kwargs_general = { 'fontsize': fontsize, 'fixedsize': 'True', 'width': size, 'height': size, 'fontname': 'Helvetica' } cell_size = '0.15' kwargs_cell = { 'shape': 'circle', 'fillcolor': '#80b3ffff', 'color': '#0066ffff', 'style': 'filled', 'penwidth': '1', 'width': cell_size, 'height': cell_size } kwargs_cc = { 'shape': 'circle', 'style': 'filled', 'width': '0.05', } kwargs_pop = { 'style': 'filled', 'color': 'lightgrey', 'nodesep': '100' } kwargs_synpop = {'shape': 'none', 'fixedsize': 'false'} kwargs_synpop_img = { 'shape': 'square', 'labelloc': 'b', 'scale': 'false', 'fixedsize': 'true', } kwargs_synpop_edge = { 'penwidth': '3', 'color': 'green', 'minlen': '50' } # Map Simulation objects into dot objects: obj2nodedict = {} subgraphs = [] # Populations become subgraphs: for population in self.sim.neuron_populations: n = pydot.Cluster(population.pop_name, label=population.pop_name, **dict(kwargs_general.items() + kwargs_pop.items())) subgraphs.append(n) obj2nodedict[population] = n # Cells into Nodes for cell in self.sim.cells: n = pydot.Node( cell.name, label=cell.name if cell.population is None else '<%d>' % cell.index_in_pop, **dict(kwargs_general.items() + kwargs_cell.items())) obj2nodedict[cell] = n if cell.population: obj2nodedict[cell.population].add_node(n) else: graph.add_node(n) for sg in subgraphs: graph.add_subgraph(sg) del subgraphs # Synapse Populations are turned into a node, with edges from pre and # to the post synaptic population: for synpopindex, synpop in enumerate(self.sim.synapse_populations): synpopcluster = pydot.Cluster('SynpopCluster' + synpop.synapse_pop_name) # Create the connectivity graph: connectivity_graph_figure = build_connectivity_graph(synpop) fname = fig_out + '/synpop%d.png' % synpopindex pylab.savefig(fname, transparent=True, dpi=400, bb_inches='tight') n = pydot.Node(synpop.synapse_pop_name + 'im', label='', image=fname, **dict(kwargs_general.items() + kwargs_synpop_img.items())) synpopcluster.add_node(n) label = '' label += synpop.synapse_pop_name len_prepop = len(synpop.presynaptic_population ) if synpop.presynaptic_population else 1 pc_conn = 100. * len(synpop) / ( len_prepop * len(synpop.postsynaptic_population)) #print pc_conn #pc_conn=50. #label+= '\\nType: %s'% (synpop.type) label += '\\nSynapses: %d (%d%%)' % (len(synpop), pc_conn) #label= synpop.synapse_pop_name n = pydot.Node(synpop.synapse_pop_name + 'cap', label='"%s"' % label, **dict(kwargs_general.items() + kwargs_synpop.items())) synpopcluster.add_node(n) obj2nodedict[synpop] = synpopcluster graph.add_subgraph(synpopcluster) # Connect to pre- and post- synaptic pops: post_pop = synpop.postsynaptic_population e = pydot.Edge( synpopcluster.get_name(), obj2nodedict[post_pop].get_name(), **dict(kwargs_general.items() + kwargs_synpop_edge.items())) graph.add_edge(e) pre_pop = synpop.presynaptic_population if pre_pop is not None: e = pydot.Edge( obj2nodedict[pre_pop].get_name(), synpopcluster.get_name(), **dict(kwargs_general.items() + kwargs_synpop_edge.items())) graph.add_edge(e) else: print 'NONE' for (i, synapse) in enumerate(self.sim.synapses): if synapse.population: continue pre_cell = synapse.get_presynaptic_cell() post_cell = synapse.get_postsynaptic_cell() if not pre_cell: pre_n = pydot.Node(name='SpikeTimes%d' % i, shape='point', color='lightsalmon', style='filled', **kwargs_general) graph.add_node(pre_n) else: pre_n = obj2nodedict[pre_cell] post_n = obj2nodedict[post_cell] syn_name = '%s' % synapse.name e = pydot.Edge(pre_n, post_n, label=syn_name, color='red', **kwargs_general) graph.add_edge(e) stims = {} # Simulations: for cclamp in self.sim.current_clamps: label = '"IClamp: %s\\n %s"' % (cclamp.name, cclamp.location_summary_dot_str) n = pydot.Node(cclamp.name, label=label, **dict(kwargs_general.items() + kwargs_cc.items())) stims[cclamp] = n graph.add_node(n) # Make the edge: cell_node = obj2nodedict[cclamp.cell] e = pydot.Edge(n, cell_node, label='', color='red') # **kwargs) graph.add_edge(e) ## Records: #records = {} #for record in self.sim.recordables: # name = record.name # # label = '"Record: %s\\n %s"' % (name, record.location_summary_dot_str ) # label = '"Record: %s\\n"' % name # , record.location_summary_dot_str ) # n = pydot.Node( # name, # shape='circle', # style='filled', # width='0.05', # fixedsize='True', # label=label, # fontsize=fontsize, # ) # records[record] = n # graph.add_node(n) # # Make the edge: # if isinstance(record, NEURONRecordableOnLocation): # post_node = obj2nodedict[record.cell_location.cell] # e = pydot.Edge(n, post_node, label='', color='green') # graph.add_edge(e) # # cell_node = obj2nodedict[record.cell_location.cell] graph.write_raw('example_cluster2.dot') # Put the stimulations on: #fname = _DotSummaryUtils.save_dot(graph, prog='dot') fname = _DotSummaryUtils.save_dot(graph, format='pdf', prog='fdp') #fname = _DotSummaryUtils.save_dot(graph, prog='osage') #fname = _DotSummaryUtils.save_dot(graph, prog='neato') return mrd.Section('Diagram Overview', mrd.Figure(mrd.Image(fname)))