def plot2d(metaAry, size = (10, 7.5), dpi = 75, fontsize = 15, cmap = None, \
nticks = 5, aspect_ratio = 1.0, corient = 'vertical', cformat = None,
vmin = None, vmax = None):
"""
metaArray function to do a simple 2D plot.
cmap Colour map, default is pyplot.cm.spectral
nticks Number of ticks in the colour bar
aspect_ratio Aspect ratio of the plot {float|'ij'|'xy'}
float: Fixed aspect ratio by the given number
'ij': Same aspect ratio as ij space
'xy': Same aspect ratio as xy space
corient Colorbar orientation ('vertical'|'horizontal')
cformat Colorbar format [ None | format string | Formatter object ]
vmin Minimum value for the colour scale
vmax Maximum value for the coloir scale
"""
if cmap is None:
cmap = cm.spectral
if corient is not 'horizontalt':
corient = 'vertical'
axis = metaAry['range']
data = metaAry.data
x0 = axis['begin'][0]
x1 = axis['end'][0]
y0 = axis['begin'][1]
y1 = axis['end'][1]
if vmin is None:
v0 = metaAry.data.min()
else:
v0 = vmin
if vmax is None:
v1 = metaAry.data.max()
else:
v1 = vmax
xunit = axis['unit'][0]
yunit = axis['unit'][1]
vunit = metaAry['unit']
# Apply unit prefix if unit is defined
xunit, x0, x1, xscale = prettyunit(xunit, x0, x1)
yunit, y0, y1, yscale = prettyunit(yunit, y0, y1)
vunit, v0, v1, vscale = prettyunit(vunit, v0, v1)
if vscale != 1:
data = data.copy() * vscale
xlabl = lbl_repr(axis['label'][0], xunit)
ylabl = lbl_repr(axis['label'][1], yunit)
vlabl = lbl_repr(metaAry['label'], vunit)
ticks = linspace(v0, v1, nticks)
ticks_lbl = []
for i in range(nticks):
ticks_lbl.append("%(val)0.4g" % {'val':ticks[i]})
# Aspect ration of the plot
if aspect_ratio == 'ij':
ratio = data.shape
ratio = float(ratio[1]) / ratio[0]
elif aspect_ratio == 'xy':
ratio = float(y1 - y0) / float(x1 - x0)
else:
try:
ratio = float(aspect_ratio)
except:
print "*** Warning! Unrecognisable aspect ratio spec. Using the default instead."
ratio = 1.0
ratio /= float(y1 - y0) / float(x1 - x0)
ratio = abs(ratio)
# Make plot with vertical (default) colorbar
fig = figure(figsize=size, dpi = dpi)
ax = fig.add_subplot(111)
extent = (x0, x1, y0, y1)
cax = ax.imshow(data.transpose()[::-1], cmap=cmap, extent=extent, interpolation = 'bicubic', vmin = v0, vmax = v1, aspect=ratio)
cbar = fig.colorbar(cax, ticks=ticks, orientation=corient, format=cformat)
# ax.set_size(fontsize)
ax.set_xlabel(xlabl, fontsize=fontsize) # Label font size
ax.set_ylabel(ylabl, fontsize=fontsize)
rcParams.update({'font.size': fontsize}) # Value font size
# Add colorbar, make sure to specify tick locations to match desired ticklabels
cbar.ax.set_yticklabels(ticks_lbl)
cbar.set_label(vlabl, fontsize=fontsize)
if fontsize is not None:
ax.set_title(metaAry['name'], fontsize=int(fontsize*1.3))
else:
ax.set_title(metaAry['name'])
return fig, ax
def plotcomplexpolar(metaAry, size = (10, 7.5), dpi = 75, grid = True, legend = 0, fontsize = 15):
"""
metaArray function to do a simple 1D plot of complex array as magnitude and phase angle.
legend:
'best' 0
'upper right' 1
'upper left' 2
'lower left' 3
'lower right' 4
'right' 5
'center left' 6
'center right' 7
'lower center' 8
'upper center' 9
'center' 10
"""
if legend is None:
legend = 0
axis = metaAry['range']
mag = abs(metaAry.data)
pha = angle(metaAry.data, deg=True)
# Load the plotting ranges and units
x0 = axis['begin'][0]
x1 = axis['end'][0]
my0 = min(mag)
my1 = max(mag)
py0 = min(pha)
py1 = max(pha)
xunit = axis['unit'][0]
myunit = metaAry['unit']
pyunit = 'Degree'
# Leave 10% margin in the y axis
mmean = average((my0, my1))
mreach = abs(my0-my1) / 2 / 0.9
my0 = sign(my0-mmean) * mreach + mmean
my1 = sign(my1-mmean) * mreach + mmean
pmean = average((py0, py1))
preach = abs(py0-py1) / 2 / 0.9
py0 = sign(py0-pmean) * preach + pmean
py1 = sign(py1-pmean) * preach + pmean
# Apply unit prefix if unit is defined
xunit, x0, x1, xscale = prettyunit(xunit, x0, x1)
myunit, my0, my1, myscale = prettyunit(myunit, my0, my1)
pyunit, py0, py1, pyscale = prettyunit(pyunit, py0, py1)
if myscale != 1:
mag = mag * myscale
if pyscale != 1:
pha = pha.copy() * pyscale
xlabl = lbl_repr(axis['label'][0], xunit)
mylabl = lbl_repr(metaAry['label'], myunit, "Magnitude")
pylabl = lbl_repr(metaAry['label'], pyunit, "Phase angle")
title = metaAry['name']
fig = figure(figsize=size, dpi = dpi)
host = SubplotHost(fig, 111)
fig.add_subplot(host)
par = host.twinx()
if axis['log'][0] is False:
x = linspace(x0, x1, len(metaAry))
else:
raise NotImplemented, "Log axis is not yet implemented."
host.plot(x, mag, 'b-', label=lbl_repr(axis['label'][0], '', "Magnitude"))
par.plot(x, pha, 'r--', label=lbl_repr(axis['label'][0], '', "Phase"))
host.grid(grid)
host.set_xlabel(xlabl, fontsize=fontsize)
host.set_ylabel(mylabl, fontsize=fontsize)
par.set_ylabel(pylabl, fontsize=fontsize)
host.set_xlim([x0, x1])
host.set_ylim([my0, my1])
par.set_ylim([py0, py1])
if fontsize is not None:
host.set_title(title, fontsize=int(fontsize*1.3))
else:
host.set_title(title)
if legend >= 0:
host.legend(loc=legend)
return fig, host, par
def plot1d(metaAry, size = (10, 7.5), dpi = 75, grid = True, legend = None, fontsize = 15,\
fig = None, ax = None, label = None):
"""
metaArray function to do a simple 1D plot.
legend:
'best' 0
'upper right' 1
'upper left' 2
'lower left' 3
'lower right' 4
'right' 5
'center left' 6
'center right' 7
'lower center' 8
'upper center' 9
'center' 10
label Label for the legend display, default to metaAry['range']['label'][0]
"""
if metaAry.dtype is dtype('complex'):
return plotcomplex(metaAry, size = size, dpi = dpi, grid = grid, legend = legend, fontsize = fontsize)
if legend is None:
legend = -1
axis = metaAry['range']
data = metaAry.data
# Load the plotting ranges and units
x0 = axis['begin'][0]
x1 = axis['end'][0]
y0 = min(metaAry.data)
y1 = max(metaAry.data)
xunit = axis['unit'][0]
yunit = metaAry['unit']
# Leave 10% margin in the y axis
mean = average((y0, y1))
reach = abs(y0-y1) / 2 / 0.9
y0 = sign(y0-mean) * reach + mean
y1 = sign(y1-mean) * reach + mean
# Apply unit prefix if unit is defined
xunit, x0, x1, xscale = prettyunit(xunit, x0, x1)
yunit, y0, y1, yscale = prettyunit(yunit, y0, y1)
if yscale != 1:
data = data.copy() * yscale
xlabl = lbl_repr(axis['label'][0], xunit)
ylabl = lbl_repr(metaAry['label'], yunit)
title = metaAry['name']
# check if object is 1D metaArray object
if fig is None:
fig = figure(figsize=size, dpi = dpi)
if ax is None:
ax = fig.add_subplot(111)
else:
x00, x01 = ax.get_xlim()
y00, y01 = ax.get_ylim()
x0 = min((x0, x00))
y0 = min((y0, y00))
x1 = max((x1, x01))
y1 = max((y1, y01))
if axis['log'][0] is False:
x = linspace(x0, x1, len(metaAry))
else:
raise NotImplemented
if label is None:
label = axis['label'][0]
ax.plot(x, data, label=label)
ax.grid(grid)
ax.set_xlabel(xlabl, fontsize=fontsize)
ax.set_ylabel(ylabl, fontsize=fontsize)
ax.set_xlim([x0, x1])
ax.set_ylim([y0, y1])
if fontsize is not None:
ax.set_title(title, fontsize=int(fontsize*1.3))
else:
ax.set_title(title)
if legend >= 0:
ax.legend(loc=legend)
return fig, ax
def plotcomplex(metaAry, size = (10, 7.5), dpi = 75, grid = True, legend = 0, fontsize = 15):
"""
metaArray function to do a simple 1D plot of complex array as real and imaginary parts.
legend:
'best' 0
'upper right' 1
'upper left' 2
'lower left' 3
'lower right' 4
'right' 5
'center left' 6
'center right' 7
'lower center' 8
'upper center' 9
'center' 10
"""
if legend is None:
legend = 0
axis = metaAry['range']
rdata = metaAry.data.real
idata = metaAry.data.imag
# Load the plotting ranges and units
x0 = axis['begin'][0]
x1 = axis['end'][0]
ry0 = min(rdata)
ry1 = max(rdata)
iy0 = min(idata)
iy1 = max(idata)
xunit = axis['unit'][0]
ryunit = metaAry['unit']
iyunit = metaAry['unit']
# Leave 10% margin in the y axis
rmean = average((ry0, ry1))
rreach = abs(ry0-ry1) / 2 / 0.9
ry0 = sign(ry0-rmean) * rreach + rmean
ry1 = sign(ry1-rmean) * rreach + rmean
imean = average((iy0, iy1))
ireach = abs(iy0-iy1) / 2 / 0.9
iy0 = sign(iy0-imean) * ireach + imean
iy1 = sign(iy1-imean) * ireach + imean
# Apply unit prefix if unit is defined
xunit, x0, x1, xscale = prettyunit(xunit, x0, x1)
ryunit, ry0, ry1, ryscale = prettyunit(ryunit, ry0, ry1)
iyunit, iy0, iy1, iyscale = prettyunit(iyunit, iy0, iy1)
if ryscale != 1:
rdata = rdata.copy() * ryscale
if iyscale != 1:
idata = idata.copy() * iyscale
xlabl = lbl_repr(axis['label'][0], xunit)
rylabl = lbl_repr(metaAry['label'], ryunit, "Real part")
iylabl = lbl_repr(metaAry['label'], iyunit, "Imaginary part")
title = metaAry['name']
fig = figure(figsize=size, dpi = dpi)
host = SubplotHost(fig, 111)
fig.add_subplot(host)
par = host.twinx()
if axis['log'][0] is False:
x = linspace(x0, x1, len(metaAry))
else:
raise NotImplemented, "Log axis is not yet implemented."
host.plot(x, rdata, 'b-', label=lbl_repr(axis['label'][0], '', "Real"))
par.plot(x, idata, 'r--', label=lbl_repr(axis['label'][0], '', "Imaginary"))
host.grid(grid)
host.set_xlabel(xlabl, fontsize=fontsize)
host.set_ylabel(rylabl, fontsize=fontsize)
par.set_ylabel(iylabl, fontsize=fontsize)
host.set_xlim([x0, x1])
host.set_ylim([ry0, ry1])
par.set_ylim([iy0, iy1])
if fontsize is not None:
host.set_title(title, fontsize=int(fontsize*1.3))
else:
host.set_title(title)
if legend >= 0:
host.legend(loc=legend)
return fig, host, par
def multiplot(metaArylst, size = (10, 7.5), dpi = 75, grid = True, \
legend = 0, fontsize = 15, mode='inc', \
unitChk = True, title = False, group_y = True, \
fig = None, ax = None):
"""
metaArray function to put the specified list of metaArrays in to a 1D plot.
metaArylst [metAry1, metAry2, ... metAryN] List of 1-D metaAry
size Plot size, default to (10, 7.5)
dpi Dot Per Inch for raster graphics
grid Display grid
fontsize Norminal font size
mode ['inc'|'exc']
unitChk Whether to check if all metArys has the same x-axis unit
title Whether to generate figure title, if title is string, use it as is.
group_y Identical metArys['unit'] are default to use the same y-axis scale
legend:
'best' 0
'upper right' 1
'upper left' 2
'lower left' 3
'lower right' 4
'right' 5
'center left' 6
'center right' 7
'lower center' 8
'upper center' 9
'center' 10
mode:
'inc' Inclusive, plot all data (x-axis) ranges
'exc' Exclusive, plot only common (x-axis) ranges to all data
label Label for the legend display, default to metaAry['range']['label'][0]
"""
if legend is None: legend = -1
# First pass, work out the overall axis range
xunit = metaArylst[0].get_range(0, 'unit')
x0 = metaArylst[0].get_range(0, 'begin')
x1 = metaArylst[0].get_range(0, 'end')
# unitChk Make sure they have identical x-units:
if unitChk:
for metAry in metaArylst:
if metAry.get_range(0, 'unit') != xunit:
raise UnitError, "Axis unit description do no match (" + str(metAry['name']) + ")"
# Identify the x ranges
if mode is 'inc':
for metAry in metaArylst:
if metAry.get_range(0, 'begin') < x0: x0 = metAry.get_range(0, 'begin')
if metAry.get_range(0, 'end') > x1: x1 = metAry.get_range(0, 'end')
else:
for metAry in metaArylst:
if metAry.get_range(0, 'begin') > x0: x0 = metAry.get_range(0, 'begin')
if metAry.get_range(0, 'end') < x1: x1 = metAry.get_range(0, 'end')
# Define the x-axis
# x0
# x1
# xunit
# xscale
# xlabl
xunit, x0_scl, x1_scl, xscale = prettyunit(xunit, x0, x1)
xlabl = lbl_repr(axis['label'][0], xunit)
# Check how many y-axies are necessary
y_lst = {}
for idx in range(len(metaArylst)):
metAry = metaArylst[idx]
yunit = metAry['unit']
if group_y:
if y_lst.has_key(yunit):
if y_lst[yunit]['y0'] > metAry.data.min():
y_lst[yunit]['y0'] = metAry.data.min()
if y_lst[yunit]['y1'] < metAry.data.max():
y_lst[yunit]['y1'] = metAry.data.max()
else:
y_lst[yunit] = {}
y_lst[yunit]['y0'] = metAry.data.min()
y_lst[yunit]['y1'] = metAry.data.max()
y_lst[yunit]['yunit'] = yunit
y_lst[yunit]['ylabl'] = metaAry['label']
else:
idx_str = str(idx)
y_lst[idx_str] = {}
y_lst[idx_str]['y0'] = metAry.data.min()
y_lst[idx_str]['y1'] = metAry.data.max()
y_lst[idx_str]['yunit'] = yunit
y_lst[idx_str]['ylabl'] = metaAry['label']
# Per y-axis defnitions
# y0
# y1
# yunit
# yscale
# ylabl
for ykey in y_lst.keys():
y0 = y_lst[ykey]['y0']
y1 = y_lst[ykey]['y1']
yunit = y_lst[ykey]['yunit']
ylabl = y_lst[ykey]['ylabl']
# Leave 10% margin in the y axis
ymean = average((y0, y1))
yreach = abs(y0-y1) / 2 / 0.9
y0 = sign(y0-mean) * reach + mean
y1 = sign(y1-mean) * reach + mean
y0, y1 = scale_check(y0, y1)
# Apply unit prefix if unit is defined
yunit, y0, y1, yscale = prettyunit(yunit, y0, y1)
# Update the label
ylabl = lbl_repr(ylabl, yunit)
y_lst[ykey]['y0'] = y0
y_lst[ykey]['y1'] = y1
y_lst[ykey]['yunit'] = yunit
y_lst[ykey]['yscale'] = yscale
y_lst[ykey]['ylabl'] = ylabl
#Generate the fig
if fig is None:
fig = figure(figsize=size, dpi = dpi)
fig.subplots_adjust(right=0.75)
if ax is None:
ax0 = fig.add_subplot(111)
else:
ax0 = ax
# Generate the ax
ykeys = y_lst.keys()
ykey = ykeys[0]
y_lst[ykey]['ax'] = ax0
for ykey in ykeys[1:]:
y_lst[ykey]['ax'] = ax0.twinx()
for ykey in ykeys[2:]:
ax = y_lst[ykey]['ax']
# Offset the right spine of par2. The ticks and label have already been
# placed on the right by twinx above.
ax.spines["right"].set_position(("axes", 1.2))
# Having been created by twinx, par2 has its frame off, so the line of its
# detached spine is invisible. First, activate the frame but make the patch
# and spines invisible.
make_patch_spines_invisible(ax)
# Second, show the right spine.
ax.spines["right"].set_visible(True)
# Plot each metaArray in the list
line_lst = []
for idx in range(len(metaArylst)):
# x0, x1
# xunit, xscale, xlabl, x0_scl, x1_scl
if mode is 'inc':
metAry = metaArylst[idx]
else: # Exclusive mode
metAry = metaArylst[idx][float(x0):float(x1)]
if group_y:
ykey = metAry['unit']
else:
ykey = str(idx)
# y0, y1, yscale, yunit, ylabl, ax
yscale = y_lst[ykey]['yscale']
ax = y_lst[ykey]['ax']
# Obtain the scaled data pair
x_axis = metaAry.get_axis() * xscale
data_val = metaAry.data * yscale
pax, = ax.plot(x_axis, data_val, label=metAry['name'])
line_lst.append(pax)
# Set plot limits
# x0, x1
# xunit, xscale, xlabl
# ax0
ax0.set_xlim([x0_scl, x1_scl])
ax0.set_xlabel(xlabl, fontsize=fontsize)
ax0.grid(grid)
ax_lst = []
for ykey in y_lst.keys():
y0 = y_lst[ykey]['y0']
y1 = y_lst[ykey]['y1']
ylabl = y_lst[ykey]['ylabl']
ax = y_lst[ykey]['ax']
ax.set_ylim([y0, y1])
ax.set_ylabel(ylabl, fontsize=fontsize)
ax_lst.append(ax)
if legend >= 0:
ax0.legend(line_lst, [l.get_label() for l in line_lst])
ax0.legend(loc=legend)
# Define the title
if isinstance(title, str):
# Use the title string as is
if fontsize is not None:
ax0.set_title(title, fontsize=int(fontsize*1.3))
else:
ax0.set_title(title)
elif title:
t_lst = []
for metAry in metaArylst:
t_lst.append(metAry['name'])
title = 'Comparison between ' + ' & '.join(t_lst)
return fig, ax_lst
def plot2d(metaAry, size = (10, 7.5), dpi = 75, fontsize = 15, cmap = None, \
nticks = 5, aspect_ratio = 1.0, corient = 'vertical', cformat = None,
vmin = None, vmax = None, interpolation = 'sinc'):
"""
metaArray function to do a simple 2D plot.
size Plot size, default to (10, 7.5)
dpi Dot Per Inch for raster graphics
fontsize Norminal font size
cmap Colour map, default is pyplot.cm.spectral
nticks Number of ticks in the colour bar
aspect_ratio Aspect ratio of the plot {float|'ij'|'xy'}
float: Fixed aspect ratio by the given number
'ij': Same aspect ratio as ij space
'xy': Same aspect ratio as xy space
corient Colorbar orientation ('vertical'|'horizontal')
cformat Colorbar format [ None | format string | Formatter object ]
vmin Minimum value for the colour scale
vmax Maximum value for the coloir scale
interpolation Colour interpolation methods
[None, 'none', 'nearest', 'bilinear', 'bicubic',
'spline16', 'spline36', 'hanning', 'hamming', 'hermite',
'kaiser', 'quadric', 'catrom', 'gaussian', 'bessel',
'mitchell', 'sinc', 'lanczos']
"""
if cmap is None:
cmap = cm.spectral
if corient is not 'horizontal':
corient = 'vertical'
axis = metaAry['range']
data = metaAry.data
x0 = axis['begin'][0]
x1 = axis['end'][0]
y0 = axis['begin'][1]
y1 = axis['end'][1]
# Try to work out the aspect ratio and plot size before scailing the axis
# Aspect ratio of the plot
if aspect_ratio == 'ij':
ratio = data.shape
ratio = float(ratio[1]) / ratio[0]
elif aspect_ratio == 'xy':
ratio = float(y1 - y0) / (float(x1 - x0))
else:
try:
ratio = float(aspect_ratio)
except:
print "*** Warning! Unrecognisable aspect ratio spec. Using the default instead."
ratio = 1.0
## Make plot with vertical (default) colorbar
#if size == 'default':
## Default size aspect ratio is 4:3, and size to be (10, 7.5)
## Adjust size according to image aspect ratio
#if corient == 'vertical':
#size_ratio = ratio * 0.75
#size = (10, 10 * size_ratio)
#else:
#size_ratio = ratio / 0.75
#size = (7.5 / size_ratio, 7.5)
##diagonal = 12.5**2
##size_x = (diagonal / (1 + size_ratio**2))**0.5
##size_y = (diagonal / size_x**2)**0.5
##size = (size_x, size_y)
# Try to work out the colour scale
if vmin is None:
v0 = metaAry.data.min()
else:
v0 = vmin
if vmax is None:
v1 = metaAry.data.max()
else:
v1 = vmax
# In case the values are all the same
v0, v1 = scale_check(v0, v1)
xunit = axis['unit'][0]
yunit = axis['unit'][1]
vunit = metaAry['unit']
# Apply unit prefix if unit is defined
xunit, x0, x1, xscale = prettyunit(xunit, x0, x1)
yunit, y0, y1, yscale = prettyunit(yunit, y0, y1)
vunit, v0, v1, vscale = prettyunit(vunit, v0, v1)
if vscale != 1:
data = data.copy() * vscale
xlabl = lbl_repr(axis['label'][0], xunit)
ylabl = lbl_repr(axis['label'][1], yunit)
vlabl = lbl_repr(metaAry['label'], vunit)
ticks = linspace(v0, v1, nticks)
ticks_lbl = []
# Matplotlib inshow data in transposed from metaArray convension
# And it adjust the aspect ratio based on the prefix corrected number
ratio /= float(y1 - y0) / float(x1 - x0)
ratio = abs(ratio) # This is the number fed to matplotlib
for i in range(nticks):
ticks_lbl.append("%(val)0.4g" % {'val':ticks[i]})
fig = figure(figsize=size, dpi = dpi)
ax = fig.add_subplot(111)
extent = (x0, x1, y0, y1)
cax = ax.imshow(data.transpose()[::-1], cmap=cmap, extent=extent, interpolation = interpolation, vmin = v0, vmax = v1, aspect=ratio)
cbar = fig.colorbar(cax, ticks=ticks, orientation=corient, format=cformat)
# ax.set_size(fontsize)
ax.set_xlabel(xlabl, fontsize=fontsize) # Label font size
ax.set_ylabel(ylabl, fontsize=fontsize)
rcParams.update({'font.size': fontsize}) # Value font size
# Add colorbar, make sure to specify tick locations to match desired ticklabels
cbar.ax.set_yticklabels(ticks_lbl)
cbar.set_label(vlabl, fontsize=fontsize)
if fontsize is not None:
ax.set_title(metaAry['name'], fontsize=int(fontsize*1.3))
else:
ax.set_title(metaAry['name'])
# fig.tight_layout()
return fig, ax
def plotcomplexpolar(metaAry, axis = -1, size = (10, 7.5), dpi = 75, \
grid = True, legend = 0, fontsize = 14, linewidth = 2.0, \
log_mag=False, mag_label=None, mag_unit=None, \
pha_label=None, pha_unit=None, degree=False):
"""
metaArray function to do a simple 1D plot of complex array (metaAry[axis]) as magnitude and phase angle.
legend:
'best' 0
'upper right' 1
'upper left' 2
'lower left' 3
'lower right' 4
'right' 5
'center left' 6
'center right' 7
'lower center' 8
'upper center' 9
'center' 10
"""
assert type(axis) is int, "Axis is not an integer: %r" % axis
fontsize = float(fontsize)
if legend is None:
legend = 0
if mag_label is None:
mag_label = "Magnitude"
if pha_label is None:
pha_label = "Phase"
mag = abs(metaAry.data)
pha = angle(metaAry.data)
# Load the plotting ranges and units
x0 = metaAry.get_range(axis, 'begin')
x1 = metaAry.get_range(axis, 'end')
my0 = min(mag)
my1 = max(mag)
py0 = floor(4 * min(pha) / pi) # Round to the nearest pi/4
py1 = ceil(4 * max(pha) / pi)
pticks = arange(py0, py1+1) # Ticks in pi/4 interval
xunit = metaAry.get_range(axis, 'unit')
if mag_unit == None:
myunit = metaAry['unit']
else:
myunit = str(mag_unit)
if pha_unit == None:
if degree == True:
pyunit = 'Deg.'
else:
pyunit = 'Rad.'
else:
pyunit = pha_unit
# Leave 10% margin in the y axis
if log_mag == True:
my0 = log10(my0)
my1 = log10(my1)
mmean = average((my0, my1))
mreach = abs(my0-my1) / 2 / 0.9
my0 = sign(my0-mmean) * mreach + mmean
my1 = sign(my1-mmean) * mreach + mmean
if log_mag == True:
my0 = 10**my0
my1 = 10**my1
pmean = average((py0, py1))
preach = abs(py0-py1) / 2 / 0.9
py0 = sign(py0-pmean) * preach + pmean
py1 = sign(py1-pmean) * preach + pmean
my0, my1 = scale_check(my0, my1)
py0, py1 = scale_check(py0, py1)
# Apply unit prefix if unit is defined
xunit, x0, x1, xscale = prettyunit(xunit, x0, x1)
myunit, my0, my1, myscale = prettyunit(myunit, my0, my1)
pyunit, py0, py1, pyscale = prettyunit(pyunit, py0, py1)
x = metaAry.get_axis(axis=axis)
if xscale != 1:
x *= xscale
if myscale != 1:
mag *= myscale
if pyscale != 1:
pha *= pyscale
xlabl = lbl_repr(metaAry.get_range(axis, 'label'), xunit)
mylabl = lbl_repr(metaAry['label'], myunit, mag_label)
pylabl = lbl_repr(metaAry['label'], pyunit, pha_label)
title = metaAry['name']
# Done the preparation, do the actual plotting
fig, ax1 = plt.subplots(figsize=size, dpi=dpi)
ax2 = ax1.twinx()
ax1.grid(True, which="both", ls="--", color='g')
######
ax1.plot(x, mag, 'b-', linewidth=linewidth, label=mag_label)
if degree == True:
ax2.plot(x, pha * 180 / pi, 'r--', linewidth=linewidth, label=pha_label)
else:
ax2.plot(x, pha, 'r--', linewidth=linewidth, label=pha_label)
######
ax1.set_ylabel(mylabl, color='b', fontsize=fontsize)
for tl in ax1.get_yticklabels():
tl.set_color('b')
tl.set_fontsize(fontsize)
if log_mag == True:
ax1.set_yscale('log', nonposy='clip')
ax1.set_ylim([my0, my1])
######
ax2.set_ylabel(pylabl, color='r', fontsize=fontsize)
if degree == True:
py0 *= 45
py1 *= 45
ax2.set_ylim([py0, py1])
ax2.set_yticks(pticks*45)
else:
py0 = py0 * pi / 4
py1 = py1 * pi / 4
ax2.set_ylim([py0, py1])
ax2.set_yticks(pticks * pi / 4)
pticks_lbl = []
for pt in pticks:
if abs(pt) == 1:
val = r'\pi/4'
elif abs(pt) == 2:
val = r'\pi/2'
elif abs(pt) == 3:
val = r'3\pi/4'
elif abs(pt) == 4:
val = r'\pi'
if abs(pt) == 0:
val = '0'
elif sign(pt) == -1:
val = '-' + val
pticks_lbl.append('$' + val + '$')
ax2.set_yticklabels(pticks_lbl)
for tl in ax2.get_yticklabels():
tl.set_color('r')
tl.set_fontsize(fontsize)
######
ax1.set_title(title, fontsize=fontsize*1.3)
if metaAry.get_range(axis, 'log') == True:
ax1.set_xscale("log", nonposx='clip')
ax2.set_xscale("log", nonposx='clip')
for tl in ax1.get_xticklabels():
tl.set_fontsize(fontsize)
ax1.set_xlabel(xlabl, fontsize=fontsize)
ax1.set_xlim([x0, x1])
if legend >= 0:
lns1, lbl1 = ax1.get_legend_handles_labels()
lns2, lbl2 = ax2.get_legend_handles_labels()
ax1.legend(lns1 + lns2, lbl1 + lbl2, loc=legend)
######
## fig = figure(figsize=size, dpi = dpi)
## host = SubplotHost(fig, 111)
#fig.add_subplot(host)
#par = host.twinx()
#host.plot(x, mag, 'b-', label=mag_label)
#par.plot(x, pha, 'r--', label=pha_label)
#host.grid(grid, which="both", color='g')
#host.set_xlabel(xlabl)
#host.set_ylabel(mylabl, color='b')
#par.set_ylabel(pylabl, color='r')
#if log_mag == True:
#host.set_yscale('log', nonposy='clip')
#host.set_xlim([x0, x1])
#host.set_ylim([my0, my1])
#par.set_ylim([py0, py1])
#for tl in host.get_xticklabels():
#tl.set_fontsize(fontsize)
#for tl in host.get_yticklabels():
#tl.set_color('b')
#tl.set_fontsize(fontsize)
#for tl in par.get_yticklabels():
#tl.set_color('r')
#tl.set_fontsize(fontsize)
## host.set_title(title, fontsize=int(fontsize*1.3))
#host.set_title(title, fontsize=fontsize)
#if legend >= 0:
#host.legend(loc=legend)
return fig, ax1, ax2
