def __init__(self, **kwargs): """ Parameters ---------- base : float, optional The base of the logarithm. Default is ``10``. linthresh : float, optional Defines the range ``(-linthresh, linthresh)``, within which the plot is linear. This avoids having the plot go to infinity around zero. Defaults to 2. linscale : float, optional This allows the linear range ``(-linthresh, linthresh)`` to be stretched relative to the logarithmic range. Its value is the number of decades to use for each half of the linear range. For example, when `linscale` is ``1`` (the default), the space used for the positive and negative halves of the linear range will be equal to one decade in the logarithmic range. subs : sequence of int, optional Default *minor* tick locations are on these multiples of each power of the base. For example, ``subs=(1, 2, 5)`` draws ticks on 1, 2, 5, 10, 20, 50, 100, 200, 500, etc. The default is ``subs=numpy.arange(1, 10)``. basex, basey, linthreshx, linthreshy, linscalex, linscaley, \ subsx, subsy Aliases for the above keywords. These used to be conditional on the *name* of the axis. """ keys = ('base', 'linthresh', 'linscale', 'subs') super().__init__(**_parse_logscale_args(*keys, **kwargs)) transform = self.get_transform() self._default_major_locator = mticker.SymmetricalLogLocator(transform) self._default_minor_locator = mticker.SymmetricalLogLocator( transform, self.subs) # noqa: E501
def plot(df, title, equation = 1): """ Plot x1 vs x2 with contour lines. Input df: dataframe with values to be plotted title: chart title equation: 1: f(x1, x2) = x1^2 + 2.x2^2 - 2.x1.x2 - 2.x2 2: f(x1, x2) = r1(x)**2 + r2(x)**2 (method Levenberg-Marquardt) 3: f(x1, x2) = (x1 - 2)^4 + (x1 - 2.x2)^2 """ fig, ax = plt.subplots() # Compute contour lines delta_x1 = (1.5*max(df.x1) - min(df.x1)) / 1000 delta_x2 = (1.5*max(df.x2) - min(df.x2)) / 1000 d1 = (max(df.x1) - min(df.x1)) * 0.1 d2 = (max(df.x2) - min(df.x2)) * 0.1 x_1 = np.arange(min(df.x1) - d1, max(df.x1) + d1, delta_x1) x_2 = np.arange(min(df.x2) - d2, max(df.x2) + d2, delta_x2) x_1, x_2 = np.meshgrid(x_1, x_2) if equation == 1: f = x_1**2 + 2*x_2**2 - 2*x_1*x_2 - 2*x_2 CS = ax.contour(x_1, x_2, f, locator = ticker.SymmetricalLogLocator(linthresh=1, base=10)) locator = ticker.AutoLocator() elif equation == 3: f = (x_1 - 2)**4 + (x_1 - 2*x_2)**2 locator = ticker.SymmetricalLogLocator(linthresh=0.1, base=2) else: print ("Only equations 1 and 3 are supported.") #return # Plot contour lines and labels CS = ax.contour(x_1, x_2, f, locator = locator) ax.clabel(CS, inline=1, fontsize=10) # Points x1 = df.x1 x2 = df.x2 ax.plot(x1, x2) ax.plot(x1, x2, 'ro') # Lables and title ax.set_title(title) ax.set_xlabel('x1') ax.set_ylabel('x2') plt.show() return
def make_symlog(ax, featbin, linthresh=2e-3, lim=1e-1): """ Converts the y axis to a symlog scale with custom ticks, usually for the mcbin-plot from above """ ax.set_yscale('symlog', linthreshy=linthresh) ax.set_ylim([-lim, lim]) ticks = np.concatenate([np.arange(-linthresh, linthresh, 1e-3) ]) #, np.arange(lintresh, 1e-2, 9)]) s = ax.yaxis._scale ax.yaxis.set_minor_locator( ticker.SymmetricalLogLocator(s, subs=[ 1., 2., 3., 4., 5., 6., 7., 8., 9., -2., -3., -4., -5., -6., -7., -8., -9. ])) ticks = np.concatenate( [ticks, ax.yaxis.get_minor_locator().tick_values(-.1, .1)]) ax.yaxis.set_minor_locator(ticker.FixedLocator(ticks)) xlim = (featbin.low, featbin.high) ax.fill_between(xlim, -linthresh, linthresh, alpha=0.2, facecolor='darkgrey') ax.set_xlim(xlim)
def set_normalization(self, vmin, vmax, norm='linear'): if np.isclose(vmin, vmax): vmin, vmax = 1e-3, 1e+3 if (norm.lower() == 'linear'): self.norm = colors.Normalize(vmin=vmin, vmax=vmax) elif (norm.lower() == 'logarithmic'): self.norm = colors.LogNorm(vmin=vmin, vmax=vmax) else: self.norm = colors.SymLogNorm(linthresh=0.1, linscale=0.9, base=10, vmin=vmin, vmax=vmax) self.s.set_norm(self.norm) if self.s.colorbar is not None: orientation = self.s.colorbar.orientation self.remove_colorbar() self.create_colorbar(orientation, norm) if (norm.lower() == 'symlog'): self.cb.locator = ticker.SymmetricalLogLocator(linthresh=0.1, base=10) self.cb.update_ticks()
def _ticker(self): ''' Return the sequence of ticks (colorbar data locations), ticklabels (strings), and the corresponding offset string. ''' locator = self.locator formatter = self.formatter if locator is None: if self.boundaries is None: if isinstance(self.norm, colors.NoNorm): nv = len(self._values) base = 1 + int(nv / 10) locator = ticker.IndexLocator(base=base, offset=0) elif isinstance(self.norm, colors.BoundaryNorm): b = self.norm.boundaries locator = ticker.FixedLocator(b, nbins=10) elif isinstance(self.norm, colors.LogNorm): locator = ticker.LogLocator(subs='all') elif isinstance(self.norm, colors.SymLogNorm): # The subs setting here should be replaced # by logic in the locator. locator = ticker.SymmetricalLogLocator( subs=np.arange(1, 10), linthresh=self.norm.linthresh, base=10) else: if mpl.rcParams['_internal.classic_mode']: locator = ticker.MaxNLocator() else: locator = ticker.AutoLocator() else: b = self._boundaries[self._inside] locator = ticker.FixedLocator(b, nbins=10) if isinstance(self.norm, colors.NoNorm) and self.boundaries is None: intv = self._values[0], self._values[-1] else: intv = self.vmin, self.vmax locator.create_dummy_axis(minpos=intv[0]) formatter.create_dummy_axis(minpos=intv[0]) locator.set_view_interval(*intv) locator.set_data_interval(*intv) formatter.set_view_interval(*intv) formatter.set_data_interval(*intv) b = np.array(locator()) if isinstance(locator, ticker.LogLocator): eps = 1e-10 b = b[(b <= intv[1] * (1 + eps)) & (b >= intv[0] * (1 - eps))] else: eps = (intv[1] - intv[0]) * 1e-10 b = b[(b <= intv[1] + eps) & (b >= intv[0] - eps)] self._tick_data_values = b ticks = self._locate(b) formatter.set_locs(b) ticklabels = [formatter(t, i) for i, t in enumerate(b)] offset_string = formatter.get_offset() return ticks, ticklabels, offset_string
def test_set_params(self): """ Create symmetrical log locator with default subs =[1.0] numticks = 15, and change it to something else. See if change was successful. Should not exception. """ sym = mticker.SymmetricalLogLocator(base=10, linthresh=1) sym.set_params(subs=[2.0], numticks=8) assert sym._subs == [2.0] assert sym.numticks == 8
def test_SymmetricalLogLocator_set_params(): """ Create symmetrical log locator with default subs =[1.0] numticks = 15, and change it to something else. See if change was successful. Should not exception. """ # since we only test for the params change. I will pass empty transform sym = mticker.SymmetricalLogLocator(None) sym.set_params(subs=[2.0], numticks=8) assert sym._subs == [2.0] assert sym.numticks == 8
def _clear(self): self._raw.set_major_locator(ticker.AutoLocator()) self._raw.set_minor_locator(ticker.NullLocator()) if self._scale == Scale.Log: self._raw.set_major_locator(ticker.LogLocator()) self._raw.set_minor_locator(ticker.LogLocator(subs="auto")) elif self._scale == Scale.Logit: self._raw.set_major_locator(ticker.LogitLocator()) elif self._scale == Scale.SymmetricLog: self._raw.set_major_locator(ticker.SymmetricalLogLocator())
def plot_function(): """ Create a plot of the function f(x1, x2) with contour lines. """ # Compute contour lines x_1 = np.arange(-10, 10, 0.5) x_2 = np.arange(-10, 10, 0.5) x_1, x_2 = np.meshgrid(x_1, x_2) for equation in [1, 3]: fig, ax = plt.subplots() # f(x) = x_1^2 + 2.x_2^2 - 2.x_1.x_2 - 2.x_2" if equation == 1: title = "F(x1, x2) Contour Map" f = x_1**2 + 2 * x_2**2 - 2 * x_1 * x_2 - 2 * x_2 locator = ticker.AutoLocator() # Example 8.8.7 from "Nonlinear Programming" # f(x) = (x_1 - 2)^4 + (x_1 - 2.x_2)^2" else: title = "Example 8.8.7 Contour Map" f = (x_1 - 2)**4 + (x_1 - 2 * x_2)**2 locator = ticker.SymmetricalLogLocator(linthresh=0.1, base=2) # Plot contour lines CS1 = ax.contourf(x_1, x_2, f, locator=locator, cmap=plt.get_cmap("plasma")) CS2 = ax.contour(x_1, x_2, f, locator=locator, colors='white', linewidths=(0.5, )) # Color bar fig.colorbar(CS1, shrink=0.9) # Lables and title ax.set_title(title) ax.set_xlabel('x1') ax.set_ylabel('x2') plt.show() return
def direct_plot(fig, ax, data, params, direction, depth=None, cax=None, time_coords=False, fontsize=None, mccomas=False, titlesize=25, labelsize=20, ticklabelsize=15, cbtitle='', skip_labeling=False, **kwargs): X, Y, dslice = plot_setup(ax, data, params, direction, depth, time_coords, fontsize=fontsize, mccomas=mccomas, titlesize=titlesize, labelsize=labelsize, ticklabelsize=ticklabelsize, skip_labeling=skip_labeling) mappable = ax.pcolormesh(X,Y,dslice.transpose(), **kwargs) fmt = plticker.FuncFormatter(scientific_format(digits=1)) if cax != 'None': if cax == None: if 'SymLogNorm' in repr(kwargs['norm']): cb = fig.colorbar(mappable, ax=ax, shrink=0.7, ticks=plticker.SymmetricalLogLocator(linthresh=0.01, base=10)) elif 'LogNorm' in repr(kwargs['norm']): cb = fig.colorbar(mappable, ax=ax, shrink=0.7, ticks=plticker.LogLocator()) else: cb = fig.colorbar(mappable, ax=ax, shrink=0.7, format=fmt) else: cb = fig.colorbar(mappable, cax=cax, format=fmt) cb.ax.set_title(cbtitle, fontsize=ticklabelsize) return mappable, X, Y, dslice
def minorticks_on(ax=None, which="both"): """Same as ax.minorticks_on, but takes a `which` parameter specifying `x`, `y` or `both`.""" if ax == None: ax = plt.gca() if which == "both": axes = [ax.xaxis, ax.yaxis] elif which == "x": axes = [ax.xaxis] elif which == "y": axes = [ax.yaxis] for ax in axes: scale = ax.get_scale() if scale == 'log': s = ax._scale ax.set_minor_locator(mticker.LogLocator(s.base, s.subs)) elif scale == 'symlog': s = ax._scale ax.set_minor_locator( mticker.SymmetricalLogLocator(s._transform, s.subs)) else: ax.set_minor_locator(mticker.AutoMinorLocator())
def fixedPotential_cBar(myFig,fraction="5%"): """ This function fixes the colorbar of the potential colormap """ ## I create another axis object for the colorbar ## in order to use later tbe plt.tight_layout() function divider = make_axes_locatable(plt.gca()) cax = divider.append_axes("right", fraction, pad="3%") cbar = myFig.colorbar(pColorMap, cax=cax) cbar.ax.set_ylabel('Potential (Volts)', fontsize=14) ## NOTE: the fact that symmetric log-scale colorbar tick labels ## near zero don't appear correctly is a known pyplot issue ## see: https://matplotlib.org/users/colormapnorms.html ## here the large threshold partially alleviates the problem ## but still we will do some modifications (remove minor ticks, fix v==0 tick) ## fixing the ticks of the colorbar loc = ticker.SymmetricalLogLocator(linthresh=1E8,base=10) cbar.ax.yaxis.set_major_locator(loc) cbar.set_ticks(cbar.ax.yaxis.get_major_locator().tick_values(potential.min(), potential.max())) return
def plot(self, matrix, RHSvector, log='auto'): import tempfile import os if "print" in os.environ['FIPY_DISPLAY_MATRIX'].lower().split(): print("-"*75) print(self.title) print("-"*75) print("L:") print(matrix) print("b:", RHSvector) (f, mtxName) = tempfile.mkstemp(suffix='.mtx') matrix.exportMmf(mtxName) mtx = mmio.mmread(mtxName) os.remove(mtxName) pyplot.ion() c = mtx.tocoo() y = c.row x = c.col z = c.data N = matrix._shape[0] b = RHSvector if numerix.shape(b) == (): b = numerix.zeros((N,), 'l') if len(z) == 0: y = numerix.zeros((1,), 'l') x = numerix.zeros((1,), 'l') z = numerix.zeros((1,), 'l') def signed_to_logs(v): return (numerix.where(v > 0, numerix.log10(v), numerix.nan), numerix.where(v < 0, numerix.log10(-v), numerix.nan)) def logs_to_signed(v, plus, minus): v = numerix.where(v > 0, plus, -minus) v = numerix.where(numerix.isnan(v), 0., v) return v zPlus, zMinus = signed_to_logs(z) bPlus, bMinus = signed_to_logs(b) logs = (zPlus, zMinus, bPlus, bMinus) log = ((log == True) or (log == 'auto' and (numerix.nanmax(numerix.concatenate(logs)) - numerix.nanmin(numerix.concatenate(logs)) > 2))) if log: zMin = numerix.nanmin(numerix.concatenate(logs)) zMax = numerix.nanmax(numerix.concatenate(logs)) zMin -= 0.5 numdec = numerix.floor(zMax) - numerix.ceil(zMin) if numdec < 0: zMax += 0.5 for v in logs: v -= zMin zRange = zMax - zMin if zRange == 0: zRange = numerix.nanmax(zPlus) + 1 z = logs_to_signed(z, zPlus, zMinus) b = logs_to_signed(b, bPlus, bMinus) fmt = None loc = ticker.SymmetricalLogLocator(linthresh=1, base=10) else: zRange = max(abs(numerix.concatenate((z, b)))) if zRange == 0: zRange = 1 fmt = None loc = None pyplot.ioff() fig = pyplot.figure(self.id) fig.clf() usetex = rcParams['text.usetex'] rcParams['text.usetex'] = False cmap = cm.RdBu norm = Normalize(vmin=-zRange, vmax=zRange) x0 = self.margin L_ax = fig.add_axes([x0 / self.aspect, self.margin, self.L_width / self.aspect, self.L_width]) L_ax.text(0.5, -0.1, "L", transform=L_ax.transAxes, horizontalalignment='center', verticalalignment='baseline') x0 += self.L_width + self.buffer c_ax = fig.add_axes([x0 / self.aspect, self.margin, self.c_width / self.aspect, self.L_width]) x0 += self.c_width + self.buffer b_ax = fig.add_axes([x0 / self.aspect, self.margin, self.b_width / self.aspect, self.L_width], sharey=L_ax) b_ax.text(0.5, -0.1, "b", transform=b_ax.transAxes, horizontalalignment='center', verticalalignment='baseline') def scatterRectangles(x, y, z, norm=None, cmap=None): patches = [Rectangle(numerix.array([X - 0.5, Y - 0.5]), 1., 1., edgecolor='none') for X, Y in zip(x, y)] collection = PatchCollection(patches, norm=norm, cmap=cmap, edgecolors='none') collection.set_array(z) return collection L_ax.add_collection(scatterRectangles(x=x, y=y, z=z, norm=norm, cmap=cmap)) b_ax.add_collection(scatterRectangles(x=numerix.zeros((N,), 'l'), y=numerix.arange(N), z=b, norm=norm, cmap=cmap)) ColorbarBase(ax=c_ax, cmap=cmap, norm=norm, orientation='vertical', format=fmt, ticks=loc) pyplot.setp((b_ax.get_xticklabels(), b_ax.get_yticklabels(), b_ax.get_xticklines(), b_ax.get_yticklines()), visible=False) L_ax.set_xlim(xmin=-0.5, xmax=N-0.5) L_ax.set_ylim(ymax=-0.5, ymin=N-0.5) b_ax.set_xlim(xmin=-0.5, xmax=0.5) b_ax.set_ylim(ymax=-0.5, ymin=N-0.5) fig.suptitle(self.title, x=0.5, y=0.95, fontsize=14) pyplot.draw() rcParams['text.usetex'] = usetex
def FormatAxis(self, ax2fmt, scale): if ax2fmt == 'x': setScale = self.ax.set_xscale curAxis = self.ax.xaxis curData = self.xData elif ax2fmt == 'y': setScale = self.ax.set_yscale curAxis = self.ax.yaxis curData = self.yData setScale(scale) if scale == 'linear': self.ax.ticklabel_format(style='sci', axis=ax2fmt, scilimits=(0, 0), useMathText=True) curAxis.set_minor_locator(tck.AutoMinorLocator()) self.ax.relim() self.ax.autoscale(True, ax2fmt, None) elif scale == 'log': curAxis.set_minor_locator(tck.LogLocator(subs=numpy.arange(2, 10))) logFmt = tck.LogFormatterSciNotation(base=10, labelOnlyBase=False, minor_thresholds=(4, 1)) curAxis.set_minor_formatter(logFmt) self.ax.relim() self.ax.autoscale(True, ax2fmt, None) elif scale == 'symlog': axMin = min(abs(curData[curData != 0])) axMax = max(abs(curData)) axRange = numpy.log10(axMax / axMin) if ax2fmt == 'x': setScale('symlog', basex=10, subsx=numpy.arange(2, 10), linthreshx=axMin * 10**(axRange / 2)) elif ax2fmt == 'y': setScale('symlog', basey=10, subsy=numpy.arange(2, 10), linthreshy=axMin * 10**(axRange / 2)) # Thomas Duvernay, 06/01/19 # There seems to be a bug with the labelling of the 0 tick # when a 'symlog' is used as an axis scale. It looks like # it is considered as a minor tick. symLogLoc = tck.SymmetricalLogLocator(subs=numpy.arange(2, 10), linthresh=axMin * 10**(axRange / 2), base=10) curAxis.set_minor_locator(symLogLoc) logFmt = tck.LogFormatterSciNotation(base=10, labelOnlyBase=False, minor_thresholds=(4, 1), linthresh=axMin * 10**(axRange / 2)) curAxis.set_minor_formatter(logFmt) self.ax.set_xlabel(self.xCombo.get_child().get_text(), fontweight='bold', fontsize=20) self.ax.set_ylabel(self.yCombo.get_child().get_text(), fontweight='bold', fontsize=20) self.ax.tick_params(which='major', length=7, labelsize=16, width=2) self.ax.tick_params(which='minor', length=4, labelsize=10, width=2, colors='xkcd:scarlet', labelrotation=45) self.ax.xaxis.get_offset_text().set(fontsize=13, fontweight='bold', color='xkcd:black') self.ax.yaxis.get_offset_text().set(fontsize=13, fontweight='bold', color='xkcd:black') self.fig.set_tight_layout(True)
def plot_heatmap(data, name, signals=None, ticks="both", minimum="auto", xlabel=None, title=None): if ticks == "both": ticks = "xy" fig, (ax, cbar_ax) = plt.subplots( 2, gridspec_kw=dict( left=0.2, right=0.95, top=0.86, bottom=0.1, hspace=0.05, height_ratios=(0.9, 0.05), ), figsize=(MARGIN_LENGTH, 1.15 * MARGIN_LENGTH), ) if data.max().max() - data.min().min() > 20: norm = colors.SymLogNorm(linthresh=0.001, base=10) locator = ticker.SymmetricalLogLocator(linthresh=0.0011, base=10) locator.set_params(numticks=5) else: norm = colors.Normalize() locator = ticker.LinearLocator(numticks=5) # if minimum == "auto": # _min = data.min().min() # data_min = np.sign(_min) * 10 ** min(10, floor(log10(np.abs(_min)))) # else: # data_min = minimum # data_max = 10 ** max(1, ceil(log10(data.max().max()))) # _ticks = [data_min, 0, data_max] # norm.autoscale(_ticks) sns.heatmap( data, ax=ax, annot=False, linewidths=1, cbar=True, cbar_ax=cbar_ax, cbar_kws={ "orientation": "horizontal", "ticks": locator }, square=True, norm=norm, cmap=CMAP_DIV, ) if xlabel is not None: ax.set_xlabel(xlabel) ax.xaxis.set_label_position('top') if title is not None: ax.set_title(title) ax.tick_params( bottom=False, left=False, labelbottom=False, labeltop="x" not in ticks, labelleft="y" not in ticks, ) plt.setp(ax.get_yticklabels(), rotation=0, ha="right", rotation_mode="default") if signals is not None: N = len(signals) pos_tick = np.linspace(0, 1, 2 * N + 1)[1::2] size = 1 / N * 0.9 if 'vocals' in signals: size *= 1.4 for i in range(N): if "x" in ticks: add_plot_tick(ax, signals[i], pos=pos_tick[i], where="x", size=size) if "y" in ticks: add_plot_tick(ax, signals[i], pos=pos_tick[-i - 1], where="y", size=size) savefig(name + "_hm", eps=True)
def _set_ticker(self, a): try: if not isiterable(self.ticks): if self.scale == 'linear': a.set_major_locator(mticker.AutoLocator()) elif self.scale == 'log': a.set_major_locator(mticker.LogLocator(self.base)) elif self.scale == 'symlog': from matplotlib.scale import SymmetricalLogScale if isMPL33: scale = SymmetricalLogScale( a, base=self.base, linthresh=self.symloglin, linscale=self.symloglinscale) else: scale = SymmetricalLogScale( a, basex=self.base, linthreshx=self.symloglin, linscalex=self.symloglinscale) a.set_major_locator( mticker.SymmetricalLogLocator(scale.get_transform())) # scale.set_default_locators_and_formatters(a) else: a.set_major_locator(mticker.AutoLocator()) #a.get_axes().locator_params(self.name[0], nbins = 10) if self.ticks is not None: value = self.ticks else: #figpage = a.get_axes().figobj.get_figpage() figpage = a.axes.figobj.get_figpage() if self.name[0] == 'x': value = figpage.getp('nticks')[0] elif self.name[0] == 'y': value = figpage.getp('nticks')[1] elif self.name[0] == 'z': value = figpage.getp('nticks')[2] else: pass try: # this works onlyfor MaxNLocator #a.get_axes().locator_params(self.name[0], nbins = value) a.axes.locator_params(self.name[0], nbins=value) except BaseException: # for Symlog and LogLocator a.get_major_locator().numticks = value else: a.set_ticks(self.ticks) if self.format == 'default': if self.scale == 'linear': a.set_major_formatter(mticker.ScalarFormatter()) elif self.scale == 'log': a.set_major_formatter( mticker.LogFormatterMathtext(self.base)) elif self.scale == 'symlog': a.set_major_formatter( mticker.LogFormatterMathtext(self.base)) else: a.set_major_formatter(mticker.ScalarFormatter()) elif self.format == 'scalar': a.set_major_formatter(mticker.ScalarFormatter()) elif self.format == 'scalar(mathtext)': a.set_major_formatter( mticker.ScalarFormatter(useOffset=True, useMathText=True)) a.get_major_formatter().get_offset() elif self.format == 'log': a.set_major_formatter(mticker.LogFormatter(self.base)) elif self.format == 'log(mathtext)': a.set_major_formatter(mticker.LogFormatterMathtext(self.base)) elif self.format == 'log(exp)': a.set_major_formatter(mticker.LogFormatterExponent(self.base)) elif self.format == 'none': a.set_major_formatter(mticker.NullFormatter()) else: a.set_major_formatter(mticker.FormatStrFormatter(self.format)) except BaseException: import traceback traceback.print_exc()
barlinecols[0].set_linestyle(ls[ibranch]) barlinecols[1].set_linestyle(ls[ibranch]) for cap in capsstuff: cap.set_markeredgewidth(2) ax.set_yscale('symlog', linthreshy=lintreshy) ax.set_xscale('symlog', linthreshx=lintreshx) ax.set_ylim([-5e-1, 5e-1]) ticks = np.concatenate([np.arange(-lintreshy, lintreshy, 1e-3) ]) #, np.arange(lintresh, 1e-2, 9)]) s = ax.yaxis._scale ax.yaxis.set_minor_locator( ticker.SymmetricalLogLocator(s, subs=[ 1., 2., 3., 4., 5., 6., 7., 8., 9., -2., -3., -4., -5., -6., -7., -8., -9. ])) ticks = np.concatenate( [ticks, ax.yaxis.get_minor_locator().tick_values(-.1, .1)]) ax.yaxis.set_minor_locator(ticker.FixedLocator(ticks)) ax.set_xlim([-5e-1, 5e-1]) ticks = np.concatenate([np.arange(-lintreshx, lintreshx, 1e-4) ]) #, np.arange(lintresh, 1e-2, 9)]) s = ax.xaxis._scale ax.xaxis.set_minor_locator( ticker.SymmetricalLogLocator(s, subs=[ 1., 2., 3., 4., 5., 6., 7., 8., 9., -2., -3., -4., -5., -6., -7.,
# Plotting settings # Note:Many things are commented out as I was experimenting with the type of display # ============================================================================= fig = plt.figure(figsize=(10, 10)) gs = gridspec.GridSpec(nrows=2, ncols=2) cmap = plt.cm.RdBu_r # ============================================================================= # Contour plot of Bx # ============================================================================= ax0 = fig.add_subplot(gs[0, 0]) norm=colors.SymLogNorm(linthresh=0.000001,linscale=1, vmin=Bx.min(), vmax=Bx.max()) #cs1 = ax0.contourf(x, y, Bx, norm=colors.SymLogNorm(linthresh=0.1,linscale=1, vmin=Bx.min(), vmax=Bx.max()),cmap='RdBu') #cs1 = ax0.contourf(x, y, Bx, norm=MidpointNormalize(midpoint=0.,vmin=Bx.min(), vmax=Bx.max()),cmap='RdBu_r') cs1 = ax0.contourf(x, y, Bx,locator=ticker.SymmetricalLogLocator(base=10, linthresh=0.000001),norm=norm,cmap='RdBu_r') #cs1 = ax0.contourf(x, y, Bx,norm=colors.SymLogNorm(linthresh=0.1,linscale=0.1,vmin=Bx.min(), vmax=Bx.max()),cmap='RdBu_r') ax0.set_title("Bx") #ax0.set_xlabel("x ({})".format(units[unit_size])) #ax0.set_ylabel("y ({})".format(units[unit_size])) ax0.set_xlabel(r'$x$ (m)') ax0.set_ylabel(r'$y$ (m)') ax0.set_xlim(-XMAX/2, XMAX/2) ax0.set_ylim(-YMAX/2, YMAX/2) #ax0.ticklabel_format(axis='both',style='sci',scilimits=(0,0),useMathText=True) cbar1=fig.colorbar(cs1,ax=ax0) cbar1.set_label('Log(Bx)',rotation=270) ax0.add_patch(Rectangle((-XM_Max,-YM_Max),length_mag,width_mag, color='k', zorder=100)) # ============================================================================= # Contour plot of By
fig = plt.figure(figsize=(11, 7)) gs = gridspec.GridSpec(nrows=2, ncols=3) cmap = plt.cm.RdBu_r # ============================================================================= # Contour plot of Bx # ============================================================================= ax0 = fig.add_subplot(gs[0, 0]) norm = colors.SymLogNorm(linthresh=0.000001, linscale=1, vmin=-0.1, vmax=0.1) #cs1 = ax0.contourf(x, y, Bx, norm=colors.SymLogNorm(linthresh=0.1,linscale=1, vmin=Bx.min(), vmax=Bx.max()),cmap='RdBu') #cs1 = ax0.contourf(x, y, Bx, norm=MidpointNormalize(midpoint=0.,vmin=Bx.min(), vmax=Bx.max()),cmap='RdBu_r') cs1 = ax0.contourf(x2, y2, Bx, locator=ticker.SymmetricalLogLocator(base=10, linthresh=0.000001), norm=norm, cmap='RdBu_r') #cs1 = ax0.contourf(x, y, Bx,norm=colors.SymLogNorm(linthresh=0.1,linscale=0.1,vmin=Bx.min(), vmax=Bx.max()),cmap='RdBu_r') ax0.set_title("Bx") #ax0.set_xlabel("x ({})".format(units[unit_size])) #ax0.set_ylabel("y ({})".format(units[unit_size])) ax0.set_xlabel(r'x ($\mu$m)') ax0.set_ylabel(r'y ($\mu$m)') ax0.set_xlim(-50, 50) ax0.set_ylim(-50, 50) #ax0.ticklabel_format(axis='both',style='sci',scilimits=(0,0),useMathText=True) cbar1 = fig.colorbar(cs1, ax=ax0, extend='both') cbar1.set_label('Log(Bx)', rotation=270) ax0.add_patch(Rectangle((-5, -5), 10, 10, color='k', zorder=100)) ax0.add_patch(Circle((12.6, 11), radius=1, color='g', zorder=100))
axt = axs[dpoolind].twiny() axt.set_xlim(1e6*xcpdps_b_avg_pol_diag[sampling]['lags'].min(), 1e6*xcpdps_b_avg_pol_diag[sampling]['lags'].max()) axs[dpoolind].axhline(y=0, xmin=0, xmax=1, ls='-', lw=1, color='black') minvals = NP.asarray(minvals) maxvals = NP.asarray(maxvals) minabsvals = NP.asarray(minabsvals) maxabsvals = NP.asarray(maxabsvals) axs[dpoolind].set_xlim(0.99*xcpdps_b_avg_pol_diag[sampling]['kprll'][zind,:].min(), 1.01*xcpdps_b_avg_pol_diag[sampling]['kprll'][zind,:].max()) if NP.min(minvals) < 0.0: axs[dpoolind].set_ylim(1.5*NP.min(minvals), 2*NP.max(maxabsvals)) else: axs[dpoolind].set_ylim(0.5*NP.min(minvals), 2*NP.max(maxabsvals)) axs[dpoolind].set_yscale('symlog', linthreshy=10**NP.floor(NP.log10(NP.min(minabsvals[minabsvals > 0.0])))) tickloc = PLTick.SymmetricalLogLocator(linthresh=10**NP.floor(NP.log10(NP.min(minabsvals[minabsvals > 0.0]))), base=100.0) axs[dpoolind].yaxis.set_major_locator(tickloc) axs[dpoolind].grid(color='0.9', which='both', linestyle=':', lw=1) fig.subplots_adjust(top=0.85) fig.subplots_adjust(bottom=0.16) fig.subplots_adjust(left=0.22) fig.subplots_adjust(right=0.98) big_ax = fig.add_subplot(111) big_ax.set_facecolor('none') # matplotlib.__version__ >= 2.0.0 # big_ax.set_axis_bgcolor('none') # matplotlib.__version__ < 2.0.0 big_ax.tick_params(labelcolor='none', top=False, bottom=False, left=False, right=False) big_ax.set_xticks([]) big_ax.set_yticks([]) big_ax.set_xlabel(r'$\kappa_\parallel$'+' [pseudo '+r'$h$'+' Mpc'+r'$^{-1}$'+']', fontsize=12, weight='medium', labelpad=20)
def ee(args): sns.set_theme(context='notebook', style='whitegrid') exps = expman.gather(args.run).filter(args.filter) mask_metrics = exps.collect('test_pred/mask_metrics.csv').groupby( 'exp_id')[['dice', 'iou']].max() flops_nparams = exps.collect('flops_nparams.csv') data = pd.merge(mask_metrics, flops_nparams, on='exp_id') data['dice'] *= 100 named_data = data.rename( { 'nparams': '# Params', 'dice': 'mean Dice Coeff. (%)', 'conv_type': '$t$ (Conv. Type)', 'grow_factor': r'$\gamma$', 'num_filters': '$k$ (# Filters)', 'flops': 'FLOPs', 'num_stages': '$s$ (# Stages)', }, axis=1).replace({ 'bn-conv': 'conv-bn', 'sep-bn-conv': 'sep-conv-bn' }) g = sns.relplot(data=named_data, x='FLOPs', y='mean Dice Coeff. (%)', hue='$t$ (Conv. Type)', hue_order=['conv', 'conv-bn', 'sep-conv', 'sep-conv-bn'], col='$s$ (# Stages)', style='$k$ (# Filters)', markers=True, markersize=9, kind='line', dashes=True, facet_kws=dict(despine=False, legend_out=False), legend=True, height=3.8, aspect=1.3, markeredgecolor='white') b_formatter = ticker.FuncFormatter( lambda x, pos: '{:.2f}'.format(x / 10**9) + 'B') h, l = g.axes.flatten()[0].get_legend_handles_labels() for hi in h: hi.set_markeredgecolor('white') g.axes.flatten()[0].legend_.remove() g.fig.legend(h, l, ncol=2, bbox_to_anchor=(0.53, 0.53), fancybox=False, columnspacing=0, framealpha=1, handlelength=1.2) for ax in g.axes.flatten(): ax.yaxis.set_minor_locator(ticker.AutoMinorLocator()) ax.set_ylim(bottom=40, top=90) ax.set_xscale('symlog') ax.set_xlim(left=0.04 * 10**9, right=2 * 10**9) ax.xaxis.set_minor_locator( ticker.SymmetricalLogLocator(base=10, linthresh=2, subs=[1.5, 2, 3, 4, 5, 6, 8])) ax.xaxis.set_minor_formatter(b_formatter) ax.grid(which='minor', linestyle='--', color='#eeeeee') ax.xaxis.set_major_formatter(b_formatter) ax.tick_params(axis="x", which="both", rotation=90) plt.savefig(args.output, bbox_inches='tight')
def add_major_minor_ticks(ax, x_minor_per_major=3, y_minor_per_major=3, labelsize="small", basex=10, basey=10, linthreshx=2, linthreshy=2): """Utility function to make plots look like NCL plots by adding minor and major tick lines. Args: ax (:class:`matplotlib.axes._subplots.AxesSubplot` or :class:`cartopy.mpl.geoaxes.GeoAxesSubplot`): Current axes to the current figure x_minor_per_major (:class:`int`): Number of minor ticks between adjacent major ticks on x-axis y_minor_per_major (:class:`int`): Number of minor ticks between adjacent major ticks on y-axis labelsize (:class:`str`): Optional text size passed to tick_params. A default value of "small" is used if nothing is set. basex (:class:`int`): If the xaxis scale is logarithmic, this is the base for the logarithm. Default is base 10. basey (:class:`int`): If the yaxis scale is logarithmic, this is the base for the logarithm. Default is base 10. linthreshx (:class:`int`): An argument passed to SymmetricalLogLocator if the xaxis scale is `symlog`. Defines the range (-x, x), within which the plot is linear. This avoids having the plot go to infinity around zero. Defaults to 2. linthreshy (:class:`int`): An argument passed to SymmetricalLogLocator if the yaxis scale is `symlog`. Defines the range (-x, x), within which the plot is linear. This avoids having the plot go to infinity around zero. Defaults to 2. """ import matplotlib.ticker as tic ax.tick_params(labelsize=labelsize) ax.minorticks_on() if ax.xaxis.get_scale() == 'log': ax.xaxis.set_minor_locator( tic.LogLocator(base=basex, subs=np.linspace(0, basex, x_minor_per_major + 1))) elif ax.xaxis.get_scale() == 'symlog': ax.xaxis.set_minor_locator( tic.SymmetricalLogLocator(base=basex, subs=np.linspace(0, basex, x_minor_per_major + 1), linthresh=linthreshx)) else: ax.xaxis.set_minor_locator(tic.AutoMinorLocator(n=x_minor_per_major)) if ax.yaxis.get_scale() == 'log': ax.yaxis.set_minor_locator( tic.LogLocator(base=basey, subs=np.linspace(0, basey, y_minor_per_major + 1))) elif ax.yaxis.get_scale() == 'symlog': ax.yaxis.set_minor_locator( tic.SymmetricalLogLocator(base=basey, subs=np.linspace(0, basey, y_minor_per_major + 1), linthresh=linthreshy)) else: ax.yaxis.set_minor_locator(tic.AutoMinorLocator(n=y_minor_per_major)) # length and width are in points and may need to change depending on figure size etc. ax.tick_params( "both", length=8, width=0.9, which="major", bottom=True, top=True, left=True, right=True, ) ax.tick_params( "both", length=4, width=0.4, which="minor", bottom=True, top=True, left=True, right=True, )