def get_interped_y(label, data, x, x_to): run_y = lfu.grab_mobj_by_name(label, data) run_interped = lgeo.scalars( label = 'interpolated best result - ' + label, scalars = lm.linear_interpolation( x.scalars, run_y.scalars, x_to.scalars, 'linear')) return run_interped
def show_plot_lines(self, *args, **kwargs): #interpolate y so that it covers domain x def fill_via_interpolation(x, y): print 'interpolation for incorrectly '+\ 'structured data is not supported' def plot_(x, y, label, col): if not x.size == y.size: x, y = fill_via_interpolation(x, y) try: line = matplotlib.lines.Line2D( #x, y, color = self.colors.pop()) x, y, color = self.colors[col]) except IndexError: print 'too many lines!'; return except: pdb.set_trace() line.set_label(label) ax.add_line(line) self.resolve_x_domain() ax = self.add_plot() ax.grid(True) if type(self._data_.data[0]) is types.ListType: self._data_.data = lfu.flatten(self._data_.data) x_ax = lfu.grab_mobj_by_name(self.x_ax_title, self._data_.data) y_axes = [dater for dater in self._data_.data if dater.label in self._plot_targets_ and not dater.label is x_ax.label] #in self._plot_targets_] if not y_axes: print 'incorrect plot targets...reconciling...' y_axes = [dater for dater in self._data_.data] self.colors = [self.colormap(i) for i in np.linspace( 0, 0.9, min([self.max_line_count, len(y_axes)]))] x = np.array(x_ax.scalars) ys = [np.array(y_ax.scalars) for y_ax in y_axes if hasattr(y_ax, 'scalars')] [plot_(x, y, label, col_dex) for x, y, label, col_dex in zip([x]*len(ys), ys, [dater.label for dater in y_axes], range(len(ys)))] ax.axis([x.min(), x.max(), min([y.min() for y in ys]), max([y.max() for y in ys])]) ax.legend() #pylab.gca().set_xscale('log',basex=2) #ax.set_yscale('log') if self.x_log: ax.set_xscale('log') if self.y_log: ax.set_yscale('log') self.canvas.draw()
def make_surface(self, x_ax = '', y_ax = '', surf_target = ''): data = self.data_scalars daters = [dater.label for dater in data] are_ax = [label in self.axis_labels for label in daters] axes = [copy(dater) for dater, is_ax in zip(data, are_ax) if is_ax] ax_labs = [ax.label for ax in axes] if not (x_ax in ax_labs and y_ax in ax_labs and not x_ax == y_ax and surf_target in self.surf_targets): print 'chosen axes do not correspond to surface' print 'axes:\n', ax_labs, '\nsurfaces:\n', self.surf_targets return False surf = lfu.grab_mobj_by_name(surf_target, data) x_ax_dex = ax_labs.index(x_ax) y_ax_dex = ax_labs.index(y_ax) ax_slices = copy(self.axis_defaults) ax_slices[x_ax_dex] = None ax_slices[y_ax_dex] = None reduced = (axes, surf) in_slices = [] for ax_dex, ax in enumerate(axes): if ax_slices[ax_dex] is None: in_slices.append([True for val in ax.scalars]) else: in_slices.append([(val == ax_slices[ax_dex]) for val in ax.scalars]) in_every_slice = [(False not in row) for row in zip(*in_slices)] sub_surf = scalars_from_labels([surf_target])[0] sub_surf.scalars = [sur for sur, in_ in zip(surf.scalars, in_every_slice) if in_] sub_axes = scalars_from_labels(self.axis_labels) for sub_ax, ax in zip(sub_axes, axes): sub_ax.scalars = lfu.uniqfy([val for val, in_ in zip(ax.scalars, in_every_slice) if in_]) self.reduced = (sub_axes, sub_surf) return True
def postproc(self, *args, **kwargs): #pool should invariably be a list of # lists of data objects for each trajectory #a method must always be provided by a superclass # a pool and a p_space are optional, default # is to use the ensemble self.determine_regime(args[0]) pool = [] sources = self.get_source_reference(1, *args, **kwargs) from_always = self.parent.parent._children_[0].data for inp in self.input_regime: inpmobj = lfu.grab_mobj_by_name(inp, from_always) lfu.zip_list(pool, [inpmobj.data.data]) for src in sources: lfu.zip_list(pool, src.data) if self.regime == 'all trajectories': self.handle_all_trajectories(kwargs['method'], pool) elif self.regime == 'manual grouping': self.handle_manual_grouping(kwargs['method'], pool) elif self.regime == 'per trajectory': self.handle_per_trajectory(kwargs['method'], pool)
def postproc(self, *args, **kwargs): #pool should invariably be a list of # lists of data objects for each trajectory #a method must always be provided by a superclass # a pool and a p_space are optional, default # is to use the ensemble self.determine_regime(args[0]) pool = [] sources = self.get_source_reference(1, *args, **kwargs) from_always = self.parent.parent._children_[0].data for inp in self.input_regime: inpmobj = lfu.grab_mobj_by_name(inp, from_always) lfu.zip_list(pool, [inpmobj.data.data]) for src in sources: lfu.zip_list(pool, src.data) if self.regime == 'all trajectories': self.handle_all_trajectories(kwargs['method'], pool) elif self.regime == 'manual grouping': self.handle_manual_grouping(kwargs['method'], pool) elif self.regime == 'per trajectory': self.handle_per_trajectory(kwargs['method'], pool)
def finalize(self, *args, **kwargs): def get_interped_y(label, data, x, x_to): run_y = lfu.grab_mobj_by_name(label, data) run_interped = lgeo.scalars( label = 'interpolated best result - ' + label, scalars = lm.linear_interpolation( x.scalars, run_y.scalars, x_to.scalars, 'linear')) return run_interped self.best_fits = [(met.best_measure, met.data[0].scalars[met.best_measure]) for met in self.metrics] self.handle_fitting_key() self.parameter_space.set_current_position( self.p_sp_trajectory[self.best_fits[ self.prime_metric][0]]) best_run_data = lis.run_system(self.ensemble) best_run_data = [lgeo.scalars(label = lab, scalars = dat) for lab, dat in zip(self.run_targets, best_run_data)] best_run_data_x = lfu.grab_mobj_by_name( self.data_to_fit_to[0].label, best_run_data) best_run_data_ys = [get_interped_y( lab, best_run_data, best_run_data_x, self.data_to_fit_to[0]) for lab in lfu.grab_mobj_names(self.data_to_fit_to[1:])] print 'fit routine:', self.label, 'best fit:', self.best_fits print '\tran using regime:', self.regime best_data = self.data_to_fit_to + best_run_data_ys lgd.quick_plot_display(best_data[0], best_data[1:], delay = 5) self.ensemble.data_pool.pool_names =\ [dat.label for dat in best_data] self.ensemble.data_pool.batch_pool.append(best_data) if self.regime.startswith('coarse'): self.impose_coarse_result_to_p_space() self.ensemble.cartographer_plan.parameter_space.\ set_current_position(self.p_sp_trajectory[ self.best_fits[self.prime_metric][0]])
def show_plot_surface(self, *args, **kwargs): self.resolve_x_domain() self.resolve_y_domain() self.resolve_surf_target() self.figure.clf() ax = Axes3D(self.figure) self.newest_ax = ax ax.cla() ax.grid(False) #color = (0.1843, 0.3098, 0.3098) #ax.set_axis_bgcolor(color) try: surf_vector_dex = [hasattr(dater, 'reduced') for dater in self._data_.data].index(True) except ValueError: print 'no surface_vector found!'; return surf_vect = self._data_.data[surf_vector_dex] made_surf = surf_vect.make_surface( x_ax = self.x_ax_title, y_ax = self.y_ax_title, surf_target = self.surf_target) if not made_surf: print 'surface was not resolved' return ax.set_xlabel(self.x_ax_title, fontsize = 18) ax.set_ylabel(self.y_ax_title, fontsize = 18) ax.set_zlabel(self.surf_target, fontsize = 18) self.title = self.surf_target ax.set_title(self.title) x_ax = lfu.grab_mobj_by_name(self.x_ax_title, surf_vect.axis_values) y_ax = lfu.grab_mobj_by_name(self.y_ax_title, surf_vect.axis_values) x = np.array(x_ax.scalars, dtype = float) y = np.array(y_ax.scalars, dtype = float) try: surf = np.array(surf_vect.reduced[1].scalars, dtype = float).reshape(len(x), len(y)) except ValueError: print 'not organized properly to colorplot...' return surf = surf.transpose() x_min, x_max = x.min(), x.max() y_min, y_max = y.min(), y.max() z_min, z_max = surf.min(), surf.max() x, y = np.meshgrid(x, y) ax.set_zlim(z_min, z_max) ax.axis([x_min, x_max, y_min, y_max]) surf = ax.plot_surface(x, y, surf, cmap = plt.get_cmap('jet'), #surf = ax.plot_surface(x, y, surf, cmap = plt.cm.gist_heat, shade = True, rstride = 1, cstride = 1, linewidth = 0, antialiased = False, zorder = 1.0) #ax.zaxis.set_major_locator(LinearLocator(10)) #ax.zaxis.set_major_formatter(FormatStrFormatter('%.02f')) self.figure.colorbar(surf, shrink = 0.75) #ax.set_axisbelow() self.canvas.draw()
def show_plot_color(self, *args, **kwargs): self.resolve_x_domain() self.resolve_y_domain() self.resolve_surf_target() ax = self.add_plot() try: surf_vector_dex = [hasattr(dater, 'reduced') for dater in self._data_.data].index(True) except ValueError: print 'no surface_vector found!'; return surf_vect = self._data_.data[surf_vector_dex] made_surf = surf_vect.make_surface( x_ax = self.x_ax_title, y_ax = self.y_ax_title, surf_target = self.surf_target) if not made_surf: print 'surface was not resolved' return self.title = self.surf_target ax.set_title(self.title) x_ax = lfu.grab_mobj_by_name(self.x_ax_title, surf_vect.axis_values) y_ax = lfu.grab_mobj_by_name(self.y_ax_title, surf_vect.axis_values) x = np.array(x_ax.scalars, dtype = float) y = np.array(y_ax.scalars, dtype = float) try: surf = np.array(surf_vect.reduced[1].scalars, dtype = float).reshape(len(x), len(y)) except ValueError: print 'not organized properly to colorplot...' return surf = surf.transpose() x_min, x_max = x.min(), x.max() y_min, y_max = y.min(), y.max() z_min, z_max = surf.min(), surf.max() #plt.xscale('log') #plt.yscale('log') delx = [x[i+1] - x[i] for i in range(len(x) - 1)] dely = [y[i+1] - y[i] for i in range(len(y) - 1)] xdels = lfu.uniqfy(delx) ydels = lfu.uniqfy(dely) if len(xdels) == 1 and len(ydels) == 1: pc_mesh = ax.imshow(surf, interpolation = 'bicubic', cmap = plt.get_cmap('jet'), vmin = z_min, vmax = z_max, #cmap = 'autumn', vmin = z_min, vmax = z_max, origin = 'lower', extent = (x_min, x_max, y_min, y_max)) #Acceptable interpolations are 'none', 'nearest', 'bilinear', #'bicubic', 'spline16', 'spline36', 'hanning', 'hamming', #'hermite', 'kaiser', 'quadric', 'catrom', 'gaussian', #'bessel', 'mitchell', 'sinc', 'lanczos' else: print 'axes values are not evenly spaced; plot will be boxy' pc_mesh = ax.pcolormesh(x, y, surf, cmap = plt.get_cmap('jet'), #pc_mesh = ax.pcolormesh(x, y, surf, cmap = 'autumn', shading = 'gouraud', vmin = z_min, vmax = z_max) ax.axis([x.min(), x.max(), y.min(), y.max()]) ax.grid(True) self.figure.colorbar(pc_mesh) self.canvas.draw()