def plot_smoothed(size): trial = cd.shared.trial steps_per_cycle = trial['settings']['steps_per_cycle'] time = trial['times']['cycles'] couplings = trial['couplings']['lengths'] couplings = mstats.values.from_serialized(couplings) couplings = mstats.values.windowed_smooth(couplings, size, 256) values, uncertainties = mstats.values.unzip(couplings) plot = plotting.make_line_data( x=time, y=values, y_unc=uncertainties, color=plotting.get_color(0, 0.8), fill_color=plotting.get_color(0, 0.2) ) coverage = 100 * (2 * size + 1) / steps_per_cycle cd.display.plotly( data=plot['data'], layout=plotting.create_layout( title='Smoothed Coupling Lengths (Cycle Coverage {}%)'.format( coverage ), x_label='Cycle (#)', y_label='Coupling Length (m)' ) ) couplings = trial['couplings']['lengths'] couplings = mstats.values.from_serialized(couplings) couplings = mstats.values.box_smooth(couplings, 2 * size + 1, 256) values, uncertainties = mstats.values.unzip(couplings) plot = plotting.make_line_data( x=time, y=values, y_unc=uncertainties, color=plotting.get_color(1, 0.8), fill_color=plotting.get_color(1, 0.2) ) coverage = 100 * (2 * size + 1) / steps_per_cycle cd.display.plotly( data=plot['data'], layout=plotting.create_layout( title='Box Smoothed Coupling Lengths (Cycle Coverage {}%)'.format( coverage ), x_label='Cycle (#)', y_label='Coupling Length (m)' ) )
def plot_couplings(df_row, trial): """ :param df_row: :param trial: :return: """ data = trial['couplings']['lengths'] median = mstats.ValueUncertainty(**trial['couplings']['value']) couplings = mstats.values.from_serialized( [v['value'] for v in data] ) min_value = mstats.values.minimum(couplings) max_value = mstats.values.maximum(couplings) y, unc = mstats.values.unzip(couplings) plot = plotting.make_line_data( x=[v['time'] for v in data], y=y, y_unc=unc, color=plotting.get_color(int(trial['id'][1]), 0.8), fill_color=plotting.get_color(int(trial['id'][1]), 0.3) ) cd.display.plotly( data=plot['data'], layout=plotting.create_layout( dict( showlegend=False ), title='{} Coupling Length'.format(trial['short_id']), x_label='Cycle (#)', y_label='Coupling Length (m)', y_bounds=[median.value - 0.5, median.value + 0.5] ) ) delta = abs(min_value - max_value) deviation = abs(min_value.value - max_value.value) / delta.uncertainty cd.display.markdown( """ Reference Statistics: * _Minimum:_ __{{ min }} m__ * _Median:_ __{{ median }} m__ * _Max:_ __{{ max }} m__ * _Deviations:_ __{{ deviation }}__ """, min=min_value.html_label, median=median.html_label, max=max_value.html_label, deviation=0.01 * round(100 * deviation) )
def test_get_color(self): """Should return colors with modifications""" color = plotting.get_color(0, 0.5, False) self.assertEqual(len(color), 4) color = plotting.get_color(4) self.assertTrue(color.startswith('rgba(')) color = plotting.get_color(1235, 0.5) self.assertTrue(color.startswith('rgba('))
def plot_couplings(*args, **kwargs): """ :param kwargs: :param args: :return: """ title = kwargs.get('title', 'Coupling Lengths') traces = [] for entry in args: trial = entry['trial'] times = entry.get('times', trial['times']['cycles']) lengths = entry.get('lengths', trial['couplings']['lengths']) index = entry['index'] if 'index' in entry else trial['group_index'] if 'color' in entry: color = entry['color'] elif index is None: color = plotting.get_gray_color(100, 0.8) else: color = plotting.get_color(index, 0.8) if 'fill_color' in entry: fill_color = entry['fill_color'] elif index is None: fill_color = plotting.get_gray_color(100, 0.1) else: fill_color = plotting.get_color(index, 0.1) plot = plotting.make_line_data( x=times, y=[v['value'] for v in lengths], y_unc=[v['uncertainty'] for v in lengths], color=color, fill_color=fill_color, name=entry.get('name', trial['id']) ) traces += plot['data'] layout = dict( showlegend = len(traces) > 0 ) cd.display.plotly( data=traces, layout=plotting.create_layout( layout, title=title, x_label='Cycle (#)', y_label='Coupling Length (m)' ) )
def test_make_line_data(self): """Should make line data according to arguments""" data = plotting.make_line_data(x=[1, 2, 3, 4], y=[1, 2, 3, 4], y_unc=[0.1, 0.1, 0.1, 0.1], name='TEST', color=plotting.get_color(4), fill_color=plotting.get_color(5, 0.2), line_properties={}, marker_properties={}) self.assertIsInstance(data, dict) self.assertIn('data', data) self.assertIn('layout', data)
def plot_groupings(boarding_method, title): group_counts = [1, 2, 3, 4, 5, 6, 8, 10] elapsed = [] elapsed_uncertainties = [] for gc in group_counts: df_slice = df[ (df['boarding_method'] == boarding_method) & (df['group_count'] == gc) ] elapsed.append( np.median(df_slice['elapsed']) ) elapsed_uncertainties.append( np.median(np.abs( df_slice['elapsed'] - elapsed[-1] )) ) if boarding_method == 'r': c = 'rgba(150, 150, 150, 0.8)' fc = 'rgba(150, 150, 150, 0.2)' elif boarding_method == 'b': c = plotting.get_color(0, 0.8) fc = plotting.get_color(0, 0.2) else: c = plotting.get_color(1, 0.8) fc = plotting.get_color(1, 0.2) definition = dict( x=group_counts, y=elapsed, y_unc=elapsed_uncertainties, name=boarding_method.upper(), color=c, fill_color=fc ) plot = plotting.make_line_data(**definition) project.display.plotly( data=plot['data'], layout=plotting.create_layout( plot['layout'], title=title, x_label='Group Count (#)', y_label='Boarding Time (s)', ), scale=0.75 ) return plot['data']
def test_get_color(self): """ :return: """ color = plotting.get_color(0, 0.5, False) self.assertEqual(len(color), 4) color = plotting.get_color(4) self.assertTrue(color.startswith('rgba(')) color = plotting.get_color(1235, 0.5) self.assertTrue(color.startswith('rgba('))
def test_make_line_data(self): """Should make line data according to arguments""" data = plotting.make_line_data( x=[1, 2, 3, 4], y=[1, 2, 3, 4], y_unc=[0.1, 0.1, 0.1, 0.1], name='TEST', color=plotting.get_color(4), fill_color=plotting.get_color(5, 0.2), line_properties={}, marker_properties={} ) self.assertIsInstance(data, dict) self.assertIn('data', data) self.assertIn('layout', data)
def plot_couplings(*args, **kwargs): """ :param kwargs: :param args: :return: """ title = kwargs.get('title', 'Coupling Lengths') traces = [] for entry in args: trial = entry['trial'] times = entry.get('times', trial['times']['cycles']) lengths = entry.get('lengths', trial['couplings']['lengths']) index = entry['index'] if 'index' in entry else trial['group_index'] if 'color' in entry: color = entry['color'] elif index is None: color = plotting.get_gray_color(100, 0.8) else: color = plotting.get_color(index, 0.8) if 'fill_color' in entry: fill_color = entry['fill_color'] elif index is None: fill_color = plotting.get_gray_color(100, 0.1) else: fill_color = plotting.get_color(index, 0.1) plot = plotting.make_line_data( x=times, y=[v['value'] for v in lengths], y_unc=[v['uncertainty'] for v in lengths], color=color, fill_color=fill_color, name=entry.get('name', trial['id'])) traces += plot['data'] layout = dict(showlegend=len(traces) > 0) cd.display.plotly(data=traces, layout=plotting.create_layout( layout, title=title, x_label='Cycle (#)', y_label='Coupling Length (m)'))
def plot_smoothed(size): trial = cd.shared.trial steps_per_cycle = trial['settings']['steps_per_cycle'] time = trial['times']['cycles'] couplings = trial['couplings']['lengths'] couplings = mstats.values.from_serialized(couplings) couplings = mstats.values.windowed_smooth(couplings, size, 256) values, uncertainties = mstats.values.unzip(couplings) plot = plotting.make_line_data(x=time, y=values, y_unc=uncertainties, color=plotting.get_color(0, 0.8), fill_color=plotting.get_color(0, 0.2)) coverage = 100 * (2 * size + 1) / steps_per_cycle cd.display.plotly( data=plot['data'], layout=plotting.create_layout( title='Smoothed Coupling Lengths (Cycle Coverage {}%)'.format( coverage), x_label='Cycle (#)', y_label='Coupling Length (m)')) couplings = trial['couplings']['lengths'] couplings = mstats.values.from_serialized(couplings) couplings = mstats.values.box_smooth(couplings, 2 * size + 1, 256) values, uncertainties = mstats.values.unzip(couplings) plot = plotting.make_line_data(x=time, y=values, y_unc=uncertainties, color=plotting.get_color(1, 0.8), fill_color=plotting.get_color(1, 0.2)) coverage = 100 * (2 * size + 1) / steps_per_cycle cd.display.plotly( data=plot['data'], layout=plotting.create_layout( title='Box Smoothed Coupling Lengths (Cycle Coverage {}%)'.format( coverage), x_label='Cycle (#)', y_label='Coupling Length (m)'))
def plot_couplings(df_row, trial): """ :param df_row: :param trial: :return: """ data = trial['couplings']['lengths'] median = mstats.ValueUncertainty(**trial['couplings']['value']) couplings = mstats.values.from_serialized([v['value'] for v in data]) min_value = mstats.values.minimum(couplings) max_value = mstats.values.maximum(couplings) y, unc = mstats.values.unzip(couplings) plot = plotting.make_line_data( x=[v['time'] for v in data], y=y, y_unc=unc, color=plotting.get_color(int(trial['id'][1]), 0.8), fill_color=plotting.get_color(int(trial['id'][1]), 0.3)) cd.display.plotly(data=plot['data'], layout=plotting.create_layout( dict(showlegend=False), title='{} Coupling Length'.format(trial['short_id']), x_label='Cycle (#)', y_label='Coupling Length (m)', y_bounds=[median.value - 0.5, median.value + 0.5])) delta = abs(min_value - max_value) deviation = abs(min_value.value - max_value.value) / delta.uncertainty cd.display.markdown(""" Reference Statistics: * _Minimum:_ __{{ min }} m__ * _Median:_ __{{ median }} m__ * _Max:_ __{{ max }} m__ * _Deviations:_ __{{ deviation }}__ """, min=min_value.html_label, median=median.html_label, max=max_value.html_label, deviation=0.01 * round(100 * deviation))
def create_density_trace(dist, color_index=0, name=None): x = mstats.distributions.adaptive_range(dist, 5) y = dist.probabilities_at(x) return go.Scatter(x=x, y=y, name=name, fill='tozeroy', mode='lines', line=dict(color=plotting.get_color(color_index)))
def calculate_median(values, uncertainties, color_index=0, plot_name=None): """ :param values: :param uncertainties: :param color_index: :param plot_name: :return: """ try: values = values.values except: pass try: uncertainties = uncertainties.values except: pass measurements = [ (val, unc) for val, unc in zip(values, uncertainties) if not np.isnan(val) and not np.isnan(unc) ] values, uncertainties = zip(*measurements) measurements = mstats.values.join(values, uncertainties) dist = mstats.create_distribution(measurements) pop = mdist.population(dist) median = mstats.ValueUncertainty( mdist.percentile(pop), mdist.weighted_median_average_deviation(pop) ) x = mdist.adaptive_range(dist, 4) y = dist.probabilities_at(x) trace = go.Scatter( x=x, y=y, name=plot_name, fill='tozeroy', mode='lines', line=dict( color=plotting.get_color(color_index) ) ) return dict( measurements=measurements, median=median, trace=trace )
def plot_comparison(data_frame, title, comparison_column, comparison_label): data_frame = data_frame.sort_values(by='trial_label') traces = [] for method in data_frame['boarding_method'].unique(): df_method = data_frame[data_frame['boarding_method'] == method] delays = [] times = [] for delay in sorted(df_method[comparison_column].unique()): x = df_method[df_method[comparison_column] == delay] times.append(np.median(x['elapsed'])) delays.append(delay) if method == 'r': c = 'rgba(204, 204, 204, 0.8)' elif method == 'b': c = plotting.get_color(0, 0.8) else: c = plotting.get_color(1, 0.8) traces.append(go.Scatter( x=times, y=delays, name=method, mode='lines+markers', marker=dict( color=c ) )) project.display.plotly( data=traces, layout=plotting.create_layout( title=title, x_label='Boarding Time (s)', y_label=comparison_label ), scale=0.75 )
def plot_collection( data_frame, title, color_column='boarding_method', color_values=None ): data_frame = data_frame.sort_values(by='trial_label') times = data_frame['elapsed'] labels = data_frame['trial_label'] colors = [] if color_values is None: color_values = dict( r='rgba(204, 204, 204, 0.8)', b=plotting.get_color(0, 0.8), default=plotting.get_color(1, 0.8) ) for index, row in data_frame.iterrows(): method = row[color_column] colors.append( color_values.get(method, color_values.get('default')) ) project.display.plotly( data=go.Bar( y=times, x=labels, marker=dict(color=colors), ), layout=plotting.create_layout( title=title, y_label='Boarding Time (s)', x_label='Trial', y_bounds=[times.min() - 10, times.max() + 10] ), scale=0.75 )
def create_density_trace(dist, color_index=0, name=None): x = mstats.distributions.adaptive_range(dist, 5) y = dist.probabilities_at(x) return go.Scatter( x=x, y=y, name=name, fill='tozeroy', mode='lines', line=dict( color=plotting.get_color(color_index) ) )
def comparison_plot(x_name, y_name, color_name, layout): traces = [] for entry in df[color_name].unique(): sub_df = df[df[color_name] == entry] traces.append( go.Scatter(x=sub_df[x_name], y=sub_df[y_name], text=sub_df.uid, mode='markers', marker={ 'size': 10, 'color': plotting.get_color(len(traces), 0.75) }, name='{} == {}'.format(color_name, entry))) cd.display.plotly(data=traces, layout=layout)
def comparison_plot(x_name, y_name, color_name, layout): traces = [] for entry in df[color_name].unique(): sub_df = df[df[color_name] == entry] traces.append(go.Scatter( x=sub_df[x_name], y=sub_df[y_name], text=sub_df.uid, mode='markers', marker={ 'size': 10, 'color': plotting.get_color(len(traces), 0.75) }, name='{} == {}'.format(color_name, entry) )) cd.display.plotly(data=traces, layout=layout)
def calculate_median(values, uncertainties, color_index=0, plot_name=None): """ :param values: :param uncertainties: :param color_index: :param plot_name: :return: """ try: values = values.values except: pass try: uncertainties = uncertainties.values except: pass measurements = [(val, unc) for val, unc in zip(values, uncertainties) if not np.isnan(val) and not np.isnan(unc)] values, uncertainties = zip(*measurements) measurements = mstats.values.join(values, uncertainties) dist = mstats.create_distribution(measurements) pop = mdist.population(dist) median = mstats.ValueUncertainty( mdist.percentile(pop), mdist.weighted_median_average_deviation(pop)) x = mdist.adaptive_range(dist, 4) y = dist.probabilities_at(x) trace = go.Scatter(x=x, y=y, name=plot_name, fill='tozeroy', mode='lines', line=dict(color=plotting.get_color(color_index))) return dict(measurements=measurements, median=median, trace=trace)
name=cd.shared.trackway_name ) template = """ <div style="margin:0.5em;display:flex;flex-direction:column;"> <div style="width:50px;height:40px;background-color:{color};"> </div> <div style="width:100%;text-align:center">G{index}</div> </div> """ swatches = [] for i in range(8): swatches.append(template.format( index=i, color=plotting.get_color(i) )) cd.display.html( """ <div style="display:flex;align-items:middle;justify-content:center;"> {swatches} </div> """.format( swatches=''.join(swatches) ) ) cd.display.markdown( """ The following table outlines the simulation trials run on the {{ name }}
) traces = [] for i in range(len(columns_progress)): column_progress = columns_progress[i] if i == 0: name = 'Window' elif i == (len(columns_progress) - 1): name = 'Aisle' else: name = 'Middle' traces.append(go.Scatter( x=np.arange(0, len(column_progress), 1), y=column_progress, mode='markers', marker={'color': plotting.get_color(i, 0.7)}, name=name )) cd.display.plotly( data=traces, layout=plotting.create_layout( title='Progress By "Column"', x_label='Time (s)', y_label='Progress (%)' ) )
distribution_trace = go.Scatter( x=dist_data['values']['x'], y=dist_data['values']['y'], name='Distribution', mode='lines', fill='tozeroy' ) segment_trace = go.Scatter( x=dist_data['segment']['x'], y=dist_data['segment']['y'], mode='lines', name='Region', line=go.Line( color=plotting.get_color(1, 1.0), width=4 ) ) gaussian_trace = go.Scatter( x=dist_data['gauss']['x'], y=dist_data['gauss']['y'], mode='lines', name='Region Fit', line=go.Line( color='rgba(0, 0, 0, 0.75)', dash='dash', width=3 ) )
from tracksim import paths from tracksim import reader paths.override('results', '../simulation/results') data = reader.groups() entries = [] for t in data['trials']: parts = t['id'].replace('_', '-').split('-') entries.append(dict( gait_id=parts[0], label='{}-{}'.format(*parts[:2]), rmsd=t['couplings']['rmsd'], swing=t['couplings']['swing'], color=plotting.get_color(int(parts[0][-1])), coupling_length=t['couplings']['value']['value'], uncertainty=t['couplings']['value']['uncertainty'] )) df = pd.DataFrame(entries).sort_values(by=['coupling_length', 'gait_id']) df['order'] = np.arange(0, df.shape[0], 1) cd.shared.df = df cd.display.table(df)
""" ## Maximum Spreads It would be easy to assume that there is a correlation between high width spreads and high length spreads. However, plotting them against each other reveals a very weak correlation. """ ) cd.display.plotly( data=go.Scatter( x=trackways_df['length_spread'], y=trackways_df['width_spread'], mode='markers', marker=dict( color=plotting.get_color(2) ), text=trackways_df['trackway'] ), layout=plotting.create_layout( {'hovermode': 'closest'}, title='Width versus Length Spreads Per Trackway', x_label='Length Spreads (%)', y_label='Width Spreads (%)' ) ) cd.display.markdown( """ Looking at maximum spreads, we get a median value of {{ median }}%, which is larger than either the length or the width values.
import cauldron as cd from cauldron import plotting trials = cd.shared.trials traces = [] for t in trials: values = [x['value'] for x in t['couplings']['lengths']] uncertainties = [x['uncertainty'] for x in t['couplings']['lengths']] plot = plotting.make_line_data( x=t['times']['cycles'], y=values, y_unc=uncertainties, name=t['settings']['id'], color=plotting.get_color(trials.index(t), 0.8), fill_color=plotting.get_color(trials.index(t), 0.2)) traces += plot['data'] cd.display.plotly(data=traces, layout=plotting.create_layout( title='Coupling Length Comparison', x_label='Cycle (#)', y_label='Coupling Length (m)'), scale=0.8)
normalized = [100.0 * (v / median - 1.0) for v in d.measurements] normalized_values += normalized x_values = list(np.arange(1, len(normalized), 1)) y_values, y_uncertainties = mstats.values.unzip(normalized) traces.append(go.Bar( x=x_values, y=y_values, error_y=dict( type='data', array=y_uncertainties, visible=True ), name=key.split('-')[0], marker=dict( color=plotting.get_color(len(traces), 0.5) ) )) d = mstats.create_distribution(normalized_values) mad = mstats.distributions.weighted_median_average_deviation(d, count=2048) result = mstats.ValueUncertainty(0, mad) project.display.text( """ Finally, the overall width and height measurements were analyzed in the same fashion as the above results. The result is that they exhibit the same low and reasonable ±3% variance as the digit length measurements. """ )
def create_scatter( data_frame: pd.DataFrame, value_column: typing.Union[str, list], uncertainty_column: typing.Union[str, list] = None, x_column: typing.Union[str, list] = None, sort_by: typing.Union[str, list] = 'separation' ): """ Create a scatter plot for each row in the specified data frame where the x, y and y uncertainty values are defined by column names or a Series/list where the elements match the order of the entries in the data frame. :param data_frame: :param value_column: :param uncertainty_column: :param x_column: :param sort_by: :return: """ traces = [] data_frame = data_frame.copy() # type: pd.DataFrame ids = data_frame.id.tolist() for index, gait_id in enumerate(sorted(data_frame.gait_id.unique())): df_slice = data_frame[data_frame.gait_id == gait_id] if sort_by: df_slice = df_slice.sort_values(by=sort_by) if isinstance(uncertainty_column, str): uncertainties = df_slice[uncertainty_column] elif uncertainty_column is None: uncertainties = None else: uncertainties = [ uncertainty_column[ids.index(tid)] for tid in df_slice.id ] if isinstance(value_column, str): values = df_slice[value_column] else: values = [ value_column[ids.index(tid)] for tid in df_slice.id ] if x_column is None: x = df_slice.order elif isinstance(x_column, str): x = df_slice[x_column] else: x = [ x_column[ids.index(tid)] for tid in df_slice.id ] if uncertainty_column: error_y = { 'type': 'data', 'visible': True, 'array': uncertainties } else: error_y = { 'visible': False } traces.append(go.Scatter( x=x, y=values, error_y=error_y, mode='markers', marker={ 'size': 6, 'color': plotting.get_color(index) }, text=df_slice.short_id, name=gait_id )) return traces
short_id = '{}-{} ({}%)'.format(gait_id, separation, duty_cycle) t['short_id'] = short_id df.append( dict(id=t['id'], short_id=short_id, duty_cycle=duty_cycle, gait_id=gait_id, gait_index=int(gait_id[1]), gait_name=gait_name, separation=separation, coupling_length=t['couplings']['value']['value'], uncertainty=t['couplings']['value']['uncertainty'], start_time=t['times']['cycles'][0], end_time=t['times']['cycles'][-1], color=plotting.get_color(int(gait_id[1])))) def redundant_filter(row): """ :param row: :return: """ if row.gait_index in [0, 4] and row.duty_cycle > 50: # Remove trots and paces with DC > 50% because they are duplicates return False if row.duty_cycle > 60 and row.gait_index in [1, 2, 5, 6]: # Remove with DC > 0.5 because they are duplicates
short_id = '{}-{} ({}%)'.format(gait_id, separation, duty_cycle) t['short_id'] = short_id df.append(dict( id=t['id'], short_id=short_id, duty_cycle=duty_cycle, gait_id=gait_id, gait_index=int(gait_id[1]), gait_name=gait_name, separation=separation, coupling_length=t['couplings']['value']['value'], uncertainty=t['couplings']['value']['uncertainty'], start_time=t['times']['cycles'][0], end_time=t['times']['cycles'][-1], color=plotting.get_color(int(gait_id[1])) )) def redundant_filter(row): """ :param row: :return: """ if row.gait_index in [0, 4] and row.duty_cycle > 50: # Remove trots and paces with DC > 50% because they are duplicates return False if row.duty_cycle > 60 and row.gait_index in [1, 2, 5, 6]:
import numpy as np import cauldron as cd from cauldron import plotting import pandas as pd from tracksim import paths from tracksim import reader paths.override('results', '../simulation/results') data = reader.groups() entries = [] for t in data['trials']: parts = t['id'].replace('_', '-').split('-') entries.append( dict(gait_id=parts[0], label='{}-{}'.format(*parts[:2]), rmsd=t['couplings']['rmsd'], swing=t['couplings']['swing'], color=plotting.get_color(int(parts[0][-1])), coupling_length=t['couplings']['value']['value'], uncertainty=t['couplings']['value']['uncertainty'])) df = pd.DataFrame(entries).sort_values(by=['coupling_length', 'gait_id']) df['order'] = np.arange(0, df.shape[0], 1) cd.shared.df = df cd.display.table(df)
of different simulation trials. The per-gait color scheme shown below will be used when plotting per-trial results for comparison. """, name=cd.shared.trackway_name) template = """ <div style="margin:0.5em;display:flex;flex-direction:column;"> <div style="width:50px;height:40px;background-color:{color};"> </div> <div style="width:100%;text-align:center">G{index}</div> </div> """ swatches = [] for i in range(8): swatches.append(template.format(index=i, color=plotting.get_color(i))) cd.display.html(""" <div style="display:flex;align-items:middle;justify-content:center;"> {swatches} </div> """.format(swatches=''.join(swatches))) cd.display.markdown(""" The following table outlines the simulation trials run on the {{ name }} trackway. Gaits are uniquely identified in terms of their gait identifier, separation and duty cycle values. The table has been sorted by median coupling lengths for each trial. """, name=cd.shared.trackway_name)
for key in ['Width-Box', 'Height-Box']: d = mstats.create_distribution(measurements=df[key].tolist(), uncertainties=5) median = mstats.distributions.percentile(d) normalized = [100.0 * (v / median - 1.0) for v in d.measurements] normalized_values += normalized x_values = list(np.arange(1, len(normalized), 1)) y_values, y_uncertainties = mstats.values.unzip(normalized) traces.append( go.Bar(x=x_values, y=y_values, error_y=dict(type='data', array=y_uncertainties, visible=True), name=key.split('-')[0], marker=dict(color=plotting.get_color(len(traces), 0.5)))) d = mstats.create_distribution(normalized_values) mad = mstats.distributions.weighted_median_average_deviation(d, count=2048) result = mstats.ValueUncertainty(0, mad) project.display.text(""" Finally, the overall width and height measurements were analyzed in the same fashion as the above results. The result is that they exhibit the same low and reasonable ±3% variance as the digit length measurements. """) project.display.plotly(data=traces, layout=plotting.create_layout( title='Size Measurements Deviations ({}%)'.format( result.html_label.split(' ', 1)[-1]),
from cauldron import plotting trials = cd.shared.trials traces = [] for t in trials: values = [x['value'] for x in t['couplings']['lengths']] uncertainties = [x['uncertainty'] for x in t['couplings']['lengths']] plot = plotting.make_line_data( x=t['times']['cycles'], y=values, y_unc=uncertainties, name=t['settings']['id'], color=plotting.get_color(trials.index(t), 0.8), fill_color=plotting.get_color(trials.index(t), 0.2) ) traces += plot['data'] cd.display.plotly( data=traces, layout=plotting.create_layout( title='Coupling Length Comparison', x_label='Cycle (#)', y_label='Coupling Length (m)' ), scale=0.8 )
import cauldron as cd from cauldron import plotting df = cd.shared.data plot_collection = cd.shared.plot_collection df = df[df.collection == 'twogis'].copy() labels = [] for index, row in df.iterrows(): labels.append('{}G {}'.format(row.group_count, row.trial_label)) df['trial_label'] = labels plot_collection( df[df.collection == 'twogis'], title='Seating & Interchange Delay Trials', color_column='group_count', color_values={ 1: plotting.get_color(0), 2: plotting.get_color(1), 3: plotting.get_color(2), 4: plotting.get_color(3), 5: plotting.get_color(4), 6: plotting.get_color(5), 8: plotting.get_color(6), 10: plotting.get_color(7), 'default': plotting.get_color(8) } )