def __init__(self, **kwargs):
kwargs = basic.dict_set_default(kwargs, **default_dataset_attrs)
super().__init__(**kwargs)
self.database = kwargs.pop('database', 'Madrigal')
self.facility = kwargs.pop('facility', 'DMSP')
self.instrument = kwargs.pop('instrument', 'SSIES&SSM')
self.product = kwargs.pop('product', 's1')
self.allow_download = kwargs.pop('allow_download', False)
self.force_download = kwargs.pop('force_download', False)
self.add_AACGM = kwargs.pop('add_AACGM', False)
self.add_APEX = kwargs.pop('add_APEX', False)
self.calib_orbit = kwargs.pop('calib_orbit', False)
self.replace_orbit = kwargs.pop('replace_orbit', False)
self.sat_id = kwargs.pop('sat_id', None)
self.metadata = None
allow_load = kwargs.pop('allow_load', False)
# self.config(**kwargs)
if self.loader is None:
self.loader = default_Loader
if self.downloader is None:
self.downloader = default_Downloader
self._validate_attrs()
if allow_load:
self.load_data()
def overlay_bar(self, *args, ax=None, **kwargs):
var = args[0]
il = None
data = self._retrieve_data_1d(var)
x = data['x'].flatten()
height = data['y'].flatten()
bar_config = basic.dict_set_default(kwargs,
**var.visual.plot_config.bar)
color_by_value = bar_config.pop('color_by_value', False)
colormap = bar_config.pop('colormap', 'viridis')
vmin = bar_config.pop('vmin', np.nanmin(height))
vmax = bar_config.pop('vmax', np.nanmax(height))
if color_by_value:
if isinstance(colormap, str):
colormap = mpl.cm.get_cmap(colormap)
norm = mpl_colors.Normalize(vmin=vmin, vmax=vmax)
colors = colormap(norm(height))
bar_config.update(color=colors)
# plot_config = basic.dict_set_default(plot_config, **self._default_plot_config)
ib = ax.bar(x, height, **bar_config)
return [ib]
def __init__(self, **kwargs):
kwargs = basic.dict_set_default(kwargs, **default_dataset_attrs)
super().__init__(**kwargs)
self.database = kwargs.pop('database', 'SuperDARN')
self.facility = kwargs.pop('facility', 'SuperDARN')
self.product = kwargs.pop('product', 'POTMAP')
self.allow_download = kwargs.pop('allow_download', False)
self.pole = kwargs.pop('pole', 'N')
self.load_append_support_data = kwargs.pop('append_support_data', True)
self.metadata = None
allow_load = kwargs.pop('allow_load', False)
# self.config(**kwargs)
if self.loader is None:
self.loader = default_Loader
if self.downloader is None:
self.downloader = None
self._validate_attrs()
if allow_load:
self.load_data()
def __init__(self, **kwargs):
kwargs = basic.dict_set_default(kwargs, **default_dataset_attrs)
super().__init__(**kwargs)
self.database = kwargs.pop('database', 'TUD')
self.facility = kwargs.pop('facility', 'GRACE')
self.instrument = kwargs.pop('instrument', 'ACC')
self.product = kwargs.pop('product', 'WND-ACC')
self.product_version = kwargs.pop('product_version', 'v01')
self.local_latest_version = ''
self.allow_download = kwargs.pop('allow_download', False)
self.force_download = kwargs.pop('force_download', False)
self.add_AACGM = kwargs.pop('add_AACGM', False)
self.add_APEX = kwargs.pop('add_APEX', False)
self._data_root_dir = self.data_root_dir # Record the initial root dir
self.sat_id = kwargs.pop('sat_id', 'A')
self.metadata = None
allow_load = kwargs.pop('allow_load', False)
# self.config(**kwargs)
if self.loader is None:
self.loader = default_Loader
if self.downloader is None:
self.downloader = default_Downloader
self._validate_attrs()
if allow_load:
self.load_data()
def __init__(self, **kwargs):
kwargs = basic.dict_set_default(kwargs, **default_dataset_attrs)
super().__init__(**kwargs)
self.database = cdaweb_database
self.facility = kwargs.pop('facility', '')
self.omni_type = kwargs.pop('omni_type', 'omni2')
self.omni_res = kwargs.pop('omni_res', '1min')
self.data_file_type = kwargs.pop('data_file_type', '')
self.allow_download = kwargs.pop('allow_download', True)
self.metadata = None
allow_load = kwargs.pop('allow_load', False)
# self.config(**kwargs)
if self.loader is None:
self.loader = default_Loader
if self.downloader is None:
self.downloader = default_Downloader
self._set_default_variables(
default_variable_names,
configured_variables=var_config.configured_variables)
self._validate_attrs()
if allow_load:
self.load_data()
def load_cdf_data(self):
"""
load the data from the cdf file
:return:
"""
cdf_file = cdflib.CDF(self.file_path)
cdf_info = cdf_file.cdf_info()
variables = cdf_info['zVariables']
if dict(self.variable_name_dict):
new_dict = {vn: vn for vn in variables}
self.variable_name_dict = pybasic.dict_set_default(
self.variable_name_dict, **new_dict)
for var_name, cdf_var_name in self.variable_name_dict.items():
if var_name == 'CDF_EPOCH':
epochs = cdf_file.varget(variable=cdf_var_name)
epochs = cdflib.cdfepoch.unixtime(epochs)
dts = [
datetime.timedelta(seconds=epoch) +
datetime.datetime(1970, 1, 1, 0, 0, 0) for epoch in epochs
]
self.variables['SC_DATETIME'] = np.array(dts).reshape(
(len(dts), 1))
continue
var = cdf_file.varget(variable=cdf_var_name)
var = np.array(var)
vshape = var.shape
if len(vshape) == 1:
var = var.reshape(vshape[0], 1)
self.variables[var_name] = var
def __init__(self, **kwargs):
kwargs = basic.dict_set_default(kwargs, **default_dataset_attrs)
super().__init__(**kwargs)
self.database = kwargs.pop('database', 'JHUAPL')
self.facility = kwargs.pop('facility', 'DMSP')
self.instrument = kwargs.pop('instrument', 'SSUSI')
self.product = kwargs.pop('product', 'SDR-DISK')
self.allow_download = kwargs.pop('allow_download', True)
self.sat_id = kwargs.pop('sat_id', '')
self.orbit_id = kwargs.pop('orbit_id', None)
self.pole = kwargs.pop('pole', '')
self.pp_type = kwargs.pop('pp_type', '')
self.metadata = None
allow_load = kwargs.pop('allow_load', False)
# self.config(**kwargs)
if self.loader is None:
self.loader = default_Loader
if self.downloader is None:
self.downloader = default_Downloader
self._validate_attrs()
if allow_load:
self.load_data()
def overlay_sites(self, site_ids=None, coords=None, cs=None, **kwargs):
kwargs = pybasic.dict_set_default(kwargs, color='k', linestyle='', markersize=5, marker='.')
cs_new = self.cs_transform(cs_fr=cs, coords=coords)
isc = self().plot(cs_new['lon'], cs_new['lat'], transform=ccrs.PlateCarree(), **kwargs)
return isc
def __init__(self, **kwargs):
kwargs = basic.dict_set_default(kwargs, **default_dataset_attrs)
super().__init__(**kwargs)
self.database = kwargs.pop('database', '')
self.product = kwargs.pop('product', '')
self.allow_download = kwargs.pop('allow_download', True)
self.metadata = None
allow_load = kwargs.pop('allow_load', False)
# self.config(**kwargs)
if self.loader is None:
self.loader = default_Loader
if self.downloader is None:
self.downloader = default_Downloader
self._set_default_variables(
default_variable_names,
configured_variables=var_config.configured_variables
)
self._validate_attrs()
if allow_load:
self.load_data()
def overlay_line(self, var, ax=None, errorbar='off', **kwargs):
"""
Overlay a line plot in the axes.
:param var: A GeospaceLab Variable object
:param ax: The axes to plot.
:param errorbar: If 'on', show errorbar.
:param kwargs: Other keyword arguments forwarded to ax.plot() or ax.errorbar()
:return:
"""
il = None
data = self._retrieve_data_1d(var)
x = data['x']
y = data['y']
y_err = data['y_err']
plot_config = basic.dict_set_default(kwargs,
**var.visual.plot_config.line)
plot_config = basic.dict_set_default(plot_config,
**self._default_plot_config)
if self.axes_overview[ax]['twinx'] in ['on', 'self']:
var.visual.axis[1].label = '@v.label'
label = var.get_visual_axis_attr(axis=2, attr_name='label')
plot_config = basic.dict_set_default(plot_config, label=label)
if errorbar == 'off':
il = ax.plot(x, y, **kwargs)
elif errorbar == 'on':
errorbar_config = dict(plot_config)
errorbar_config.update(var.visual.plot_config.errorbar)
il = ax.errorbar(x.flatten(),
y.flatten(),
yerr=y_err.flatten(),
**errorbar_config)
if type(il) is not list:
il = [il]
self.axes_overview[ax]['lines'].extend(il)
if self.axes_overview[ax]['legend'] is None:
self.axes_overview[ax]['legend'] = 'on'
elif self.axes_overview[ax]['legend'] == 'off':
var.visual.axis[1].label = '@v.label'
return il
def _check_legend(self, ax):
ax_ov = self.axes_overview[ax]
var_for_config = ax_ov['variables'][0]
legend_config = var_for_config.visual.plot_config.legend
# get color
legend_config = basic.dict_set_default(legend_config,
**self._default_legend_config)
if len(ax_ov['lines']) == 1 and ax_ov['lines'][0]._label == '_line0':
return
ax.legend(handles=ax_ov['lines'], **legend_config)
def overlay_cross_track_vector(
self, vector, unit_vector, sc_ut=None, sc_coords=None, cs=None, *,
unit_vector_scale=0.1, vector_unit='',
color='r', alpha=0.5, quiverkey_config={},
**kwargs):
cs_new = self.cs_transform(cs_fr=cs, coords=sc_coords, ut=sc_ut)
if self.pole == 'N':
ind_lat = np.where(cs_new['lat'] > self.boundary_lat)[0]
else:
ind_lat = np.where(cs_new['lat'] < self.boundary_lat)[0]
lat_in = cs_new['lat'][ind_lat]
lon_in = cs_new['lon'][ind_lat]
dts_in = sc_ut[ind_lat]
vector = vector[ind_lat]
data = self.projection.transform_points(ccrs.PlateCarree(), lon_in, lat_in)
xdata = np.float32(data[:, 0])
ydata = np.float32(data[:, 1])
slope = mathtool.calc_curve_tangent_slope(xdata, ydata, degree=3)
width = np.float32(self._extent[1] - self._extent[0])
vector = vector / unit_vector * width * unit_vector_scale
sign = np.sign(xdata[1] - xdata[0])
xq = xdata
yq = ydata
uq1 = - sign * vector * np.sin(slope)
vq1 = sign * vector * np.cos(slope)
iq = self.major_ax.quiver(
xq, yq, uq1, vq1,
units='xy', angles='xy', scale=1., scale_units='xy',
width=0.001 * (self._extent[1] - self._extent[0]),
headlength=0, headaxislength=0, pivot='tail', color=color, alpha=alpha, **kwargs
)
# Add quiverkey
quiverkey_config = pybasic.dict_set_default(
quiverkey_config, X=0.9, Y=0.95, U=width*unit_vector_scale,
linewidth=0.01 * (self._extent[1] - self._extent[0]), label=str(unit_vector) + ' ' + vector_unit, color=color,
)
X = quiverkey_config.pop('X')
Y = quiverkey_config.pop('Y')
U = quiverkey_config.pop('U')
label = quiverkey_config.pop('label')
iqk = self.major_ax.quiverkey(
iq, X, Y, U, label, **kwargs
)
return iq
def set_layout(self, num_rows=None, num_cols=None, **kwargs):
"""
Set the layout of the dashboard in a canvas using matplotlib GridSpec.
:param num_rows: The number of rows of the grid.
:type num_rows: int.
:param num_cols: The number of columns of the grid.
:type num_cols: int.
:param kwargs: Optional keyword arguments used in **matplotlib GridSpec**.
"""
kwargs = pybasic.dict_set_default(kwargs,
**self._default_layout_config)
self.gs = self.figure.add_gridspec(num_rows, num_cols)
self.gs.update(**kwargs)
def __init__(self, **kwargs):
kwargs = basic.dict_set_default(kwargs, **default_dataset_attrs)
super().__init__(**kwargs)
self.database = kwargs.pop('database', '')
self.facility = kwargs.pop('facility', '')
self.site = kwargs.pop('site', MillstoneHillSite('MillstoneHill'))
self.antenna = kwargs.pop('antenna', '')
self.experiment = kwargs.pop('experiment', '')
self.exp_name_pattern = kwargs.pop('exp_name_pattern', '')
self.exp_check = kwargs.pop('exp_check', False)
self.pulse_code = kwargs.pop('pulse_code', '')
self.pulse_length = kwargs.pop('pulse_length', '')
self.data_file_type = kwargs.pop('data_file_type', '')
self.affiliation = kwargs.pop('affiliation', '')
self.allow_download = kwargs.pop('allow_download', True)
self.beam_location = kwargs.pop('beam_location', True)
self.metadata = None
allow_load = kwargs.pop('allow_load', True)
self.status_control = kwargs.pop('status_control', False)
self.residual_control = kwargs.pop('residual_control', False)
# self.config(**kwargs)
if self.loader is None:
self.loader = default_Loader
if self.downloader is None:
self.downloader = default_Downloader
self._set_default_variables(
default_variable_names,
configured_variables=var_config.configured_variables)
self._validate_attrs()
if allow_load:
self.load_data()
def __init__(self, **kwargs):
kwargs = basic.dict_set_default(kwargs, **default_dataset_attrs)
super().__init__(**kwargs)
self.database = kwargs.pop('database', 'ESA/EarthOnline')
self.facility = kwargs.pop('facility', 'SWARM')
self.instrument = kwargs.pop('instrument', 'EFI-LP')
self.product = kwargs.pop('product', 'HM02')
self.product_version = kwargs.pop('product_version', '')
self.local_latest_version = ''
self.allow_download = kwargs.pop('allow_download', False)
self.force_download = kwargs.pop('force_download', False)
self.quality_control = kwargs.pop('quality_control', False)
self.calib_control = kwargs.pop('calib_control', False)
self.add_AACGM = kwargs.pop('add_AACGM', False)
self.add_APEX = kwargs.pop('add_AACGM', False)
self._data_root_dir_init = copy.deepcopy(
self.data_root_dir) # Record the initial root dir
self.sat_id = kwargs.pop('sat_id', 'A')
self.metadata = None
allow_load = kwargs.pop('allow_load', False)
# self.config(**kwargs)
if self.loader is None:
self.loader = default_Loader
if self.downloader is None:
self.downloader = default_Downloader
self._validate_attrs()
if allow_load:
self.load_data()
def overlay_gridlines(self,
lat_res=None, lon_res=None,
lat_label_separator=None, lon_label_separator=None,
lat_label_format=None, lon_label_format=None,
lat_label=True, lat_label_clock=6.5, lat_label_config={},
lon_label=True, lon_label_config={},
gridlines_config={}):
default_gridlines_label_config = {
'lon-fixed': {
'lat_res': 10.,
'lon_res': 30.,
'lat_label_separator': 0,
'lon_label_separator': 0,
'lat_label_format': '%d%D%N',
'lon_label_format': '%d%D%E',
},
'mlon-fixed': {
'lat_res': 10.,
'lon_res': 30.,
'lat_label_separator': 0,
'lon_label_separator': 0,
'lat_label_format': '%d%D%N',
'lon_label_format': '%d%D%E',
},
'lst-fixed': {
'lat_res': 10.,
'lon_res': 15.,
'lat_label_separator': 0,
'lon_label_separator': 2,
'lat_label_format': '%d%D%N',
'lon_label_format': '%02d LT',
},
'mlt-fixed': {
'lat_res': 10.,
'lon_res': 15.,
'lat_label_separator': 0,
'lon_label_separator': 2,
'lat_label_format': '%d%D%N',
'lon_label_format': '%02d MLT',
},
}
def label_formatter(value, fmt=''):
ms = re.findall(r"(%[0-9]*[a-zA-Z])", fmt)
fmt_new = copy.deepcopy(fmt)
patterns = []
if "%N" in ms:
if value > 0:
lb_ns = 'N'
elif value < 0:
lb_ns = 'S'
else:
lb_ns = ''
value = np.abs(value)
if "%E" in ms:
mod_value = np.mod(value - 180, 360) - 180.
if mod_value == 0 or mod_value == 180:
lb_ew = ''
elif mod_value < 0:
lb_ew = 'W'
else:
lb_ew = 'E'
value = np.abs(mod_value)
for ind_m, m in enumerate(ms):
if m == "%N":
fmt_new = fmt_new.replace(m, '{}')
patterns.append(lb_ns)
elif m == "%E":
fmt_new = fmt_new.replace(m, '{}')
patterns.append(lb_ew)
elif m == "%D":
continue
else:
if 'd' in m:
value = int(value)
fmt_new = fmt_new.replace(m, '{:' + m[1:] + '}')
patterns.append(value)
string_new = fmt_new.format(*patterns)
if "%D" in string_new:
splits = string_new.split("%D")
string_new = splits[0] + r'$^{\circ}$' + splits[1]
return string_new
default_label_config = default_gridlines_label_config[self.style]
if lat_res is None:
lat_res = default_label_config['lat_res']
if lon_res is None:
lon_res = default_label_config['lon_res']
if lat_label_separator is None:
lat_label_separator = default_label_config['lat_label_separator']
if lon_label_separator is None:
lon_label_separator = default_label_config['lon_label_separator']
if lat_label_format is None:
lat_label_format = default_label_config['lat_label_format']
if lon_label_format is None:
lon_label_format = default_label_config['lon_label_format']
# xlocator
if self.style == 'lst-fixed':
lon_shift = (self.ut - datetime.datetime(
self.ut.year, self.ut.month, self.ut.day, self.ut.hour
)).total_seconds() / 86400. * 360
else:
lon_shift = 0
num_lons = 360. // lon_res + 1.
lons = np.linspace(-180., 180., int(num_lons)) - lon_shift
xlocator = mticker.FixedLocator(lons)
# ylocator
lat_fr = np.abs(self.boundary_lat) + np.mod(90 - np.abs(self.boundary_lat), lat_res)
lat_to = 90.
# num_lats = (lat_to - lat_fr) / lat_res + 1.
lats = np.arange(lat_fr, lat_to, lat_res) * np.sign(self.lat_c)
ylocator = mticker.FixedLocator(lats)
pybasic.dict_set_default(gridlines_config, color='#331900', linewidth=0.5, linestyle=':',
draw_labels=False)
gl = self().gridlines(crs=ccrs.PlateCarree(), **gridlines_config)
gl.xlocator = xlocator
gl.ylocator = ylocator
if lat_label:
pybasic.dict_set_default(lat_label_config, fontsize=plt.rcParams['font.size'] - 2, fontweight='roman',
ha='center', va='center',
family='fantasy', alpha=0.9
)
if self.pole == 'S':
clock = lat_label_clock / 12 * 360
rotation = 180 - clock
if self.mirror_south:
clock = - clock
rotation = 180 + clock
else:
clock = np.mod(180. - lat_label_clock / 12 * 360, 360)
rotation = clock
label_lon = self.lon_c + clock
for ind, lat in enumerate(lats):
if np.mod(ind, lat_label_separator+1) != 0:
continue
# if lat > 0:
# label = r'' + '{:d}'.format(int(lat)) + r'$^{\circ}$N'
# elif lat < 0:
# label = r'' + '{:d}'.format(int(-lat)) + r'$^{\circ}$S'
# else:
# label = r'' + '{:d}'.format(int(0)) + r'$^{\circ}$S'
label = label_formatter(lat, fmt=lat_label_format)
self().text(
label_lon, lat, label, transform=ccrs.PlateCarree(),
rotation=rotation,
**lat_label_config
)
if lon_label:
pybasic.dict_set_default(
lon_label_config,
va='center', ha='center',
family='fantasy', fontweight='ultralight')
lb_lons = np.arange(0, 360., lon_res)
if self.pole == 'S':
lon_shift_south = 180.
else:
lon_shift_south = 0
if self.style == 'lon-fixed' or self.style == 'mlon-fixed':
lb_lons_loc = lb_lons
elif self.style == 'lst-fixed':
lb_lons_loc = np.mod(self.lon_c + (lb_lons - self.lst_c / 24 * 360) + lon_shift_south, 360)
elif self.style == 'mlt-fixed':
lb_lons_loc = lb_lons
if self.boundary_style == 'circle':
lb_lats = np.empty_like(lb_lons)
lb_lats[:] = self.boundary_lat
data = self.projection.transform_points(ccrs.PlateCarree(), lb_lons_loc, lb_lats)
xdata = data[:, 0]
ydata = data[:, 1]
scale = (self._extent[1] - self._extent[0]) * 0.03
xdata = xdata + scale * np.sin((lb_lons_loc - self.lon_c) * np.pi / 180.)
ydata = ydata - np.sign(self.lat_c) * scale * np.cos((lb_lons_loc - self.lon_c) * np.pi / 180.)
for ind, lb_lon in enumerate(lb_lons):
if np.mod(ind, lon_label_separator+1) != 0:
continue
x = xdata[ind]
y = ydata[ind]
# if self.style in ['lon-fixed', 'mlon-fixed']:
# lb_lon = np.mod(lb_lon + 180, 360) - 180
# if lb_lon == 0 or np.abs(lb_lon) == 180.:
# label = r'' + '{:d}'.format(int(np.abs(lb_lon))) + r'$^{\circ}$'
# if lb_lon < 0:
# label = r'' + '{:d}'.format(int(-lb_lon)) + r'$^{\circ}$W'
# else:
# label = r'' + '{:d}'.format(int(lb_lon)) + r'$^{\circ}$E'
# elif self.style == 'mlt-fixed':
# label = '{:d}'.format(int(lb_lon / 15)) + ' MLT'
# elif self.style == 'lst-fixed':
# label = '{:d}'.format(int(lb_lon / 15)) + ' LT'
if self.style in ['lon-fixed', 'mlon-fixed']:
lb_value = lb_lon
elif self.style in ['lst-fixed', 'mlt-fixed']:
lb_value = lb_lon / 15
label = label_formatter(lb_value, fmt=lon_label_format)
if self.pole == 'S':
rotation = self.lon_c - lb_lons_loc[ind]
if self.mirror_south:
rotation = -self.lon_c + lb_lons_loc[ind]
else:
rotation = (lb_lons_loc[ind] - self.lon_c) + 180
self().text(
x, y, label,
rotation=rotation,
**lon_label_config,
)
def add_colorbar(self,
im,
ax=None,
cax=None,
cax_position=None,
cax_scale=None,
cax_label=None,
cax_ticks=None,
cax_tick_labels=None,
cax_label_config=None,
cax_tick_label_step=1,
**kwargs):
"""
Add a colorbar appended to the parent ax.
:param im: the mappable
:param cax: If None, create a colorbar axes using the default settings, see also matplotlib.colorbar.Colorbar.
:type cax: axes instance or {None, 'new'}
:param ax: The appended ax instance.
:type ax: matplotlib.pyplot.Axes isntance.
:param cax_position: If not None, set the colorbar ax position at [x, y, width, height], which are normalized to the main ax coordinates.
:type cax_position: 4-tuple, default: [1.02, 0.01, 0.025, 0.85].
:param cax_label_config: Optional keyword arguments for setting the colorbar label.
:param kwargs: Other optional keyword arguments forwarded to matplotlib.colorbar.Colorbar.
:return: The colarbar instance
"""
if cax_label_config is None:
cax_label_config = {}
if cax == 'new':
if cax_position is None:
cax_position = [1.02, 0.01, 0.025, 0.85]
pos_ax = ax.get_position()
# convert from Axes coordinates to Figure coordinates
pos_cax = [
pos_ax.x0 + (pos_ax.x1 - pos_ax.x0) * cax_position[0],
pos_ax.y0 + (pos_ax.y1 - pos_ax.y0) * cax_position[1],
(pos_ax.x1 - pos_ax.x0) * cax_position[2],
(pos_ax.y1 - pos_ax.y0) * cax_position[3],
]
cax = self.add_axes(pos_cax)
cax_label_config = {
'rotation': 270,
'va': 'bottom',
'size': 'medium'
}
icb = self.figure.colorbar(im, cax=cax, **kwargs)
self.sca(ax)
# set colorbar label
cax_label_config = pybasic.dict_set_default(cax_label_config,
rotation=270,
va='bottom',
size='small')
if cax_label is not None:
icb.set_label(cax_label, **cax_label_config)
ylim = cax.get_ylim()
# set cticks
if cax_ticks is not None:
icb.ax.yaxis.set_ticks(cax_ticks)
if cax_tick_labels is not None:
icb.ax.yaxis.set_ticklabels(cax_tick_labels)
else:
if cax_scale == 'log':
num_major_ticks = int(np.ceil(np.diff(np.log10(ylim)))) * 2
cax.yaxis.set_major_locator(
mpl.ticker.LogLocator(base=10.0, numticks=num_major_ticks))
n = cax_tick_label_step
[
l.set_visible(False)
for (i, l) in enumerate(cax.yaxis.get_ticklabels())
if i % n != 0
]
# [l.set_ha('right') for (i, l) in enumerate(cax.yaxis.get_ticklabels()) if i % n != 0]
minorlocator = mpl.ticker.LogLocator(base=10.0,
subs=(0.1, 0.2, 0.3, 0.4,
0.5, 0.6, 0.7, 0.8,
0.9),
numticks=12)
cax.yaxis.set_minor_locator(minorlocator)
cax.yaxis.set_minor_formatter(mpl.ticker.NullFormatter())
cax.yaxis.set_tick_params(labelsize='x-small')
