def plot_time_param(
time_list, param_list, x_label=None, y_label=None, x_rotation=False
):
"""
Plots a parameter against time.
`Quantity` type is supported.
Parameters
----------
time_list: Time
list of times
param_list : ndarray or list
list of parameter values on the y axis
x_label : str
X axis label
y_label : str
Y axis label
x_rotation : bool
True rotates the X axis labels by 90 deg (useful for ISOT dates)
"""
quantity_support()
time_support(format="isot")
fig1, ax1 = plt.subplots(figsize=(12, 8), dpi=100)
# default with grid
format_axis_with_grid(ax1, x_label, y_label, x_rotation)
# plot the data and show the plot
ax1.plot(time_list, param_list)
plt.show()
def plot_time_trajectories(self, plot="xyz"): # coveralls: ignore
r"""
Draws position history versus time.
Parameters
----------
plot : str (optional)
Enable plotting of position component x, y, z for each of these
letters included in `plot`.
"""
from astropy.visualization import quantity_support
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
quantity_support()
fig, ax = plt.subplots()
for p_index in range(self.N):
r = self.position_history[:, p_index]
x, y, z = r.T
if "x" in plot:
ax.plot(self.t, x, label=f"x_{p_index}")
if "y" in plot:
ax.plot(self.t, y, label=f"y_{p_index}")
if "z" in plot:
ax.plot(self.t, z, label=f"z_{p_index}")
ax.set_title(self.name)
ax.legend(loc='best')
ax.grid()
plt.show()
def plot_time_trajectories(self, plot="xyz"): # coveralls: ignore
r"""
Draws position history versus time.
Parameters
----------
plot : str (optional)
Enable plotting of position component x, y, z for each of these
letters included in `plot`.
"""
from astropy.visualization import quantity_support
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
quantity_support()
fig, ax = plt.subplots()
for p_index in range(self.N):
r = self.position_history[:, p_index]
x, y, z = r.T
if "x" in plot:
ax.plot(self.t, x, label=f"x_{p_index}")
if "y" in plot:
ax.plot(self.t, y, label=f"y_{p_index}")
if "z" in plot:
ax.plot(self.t, z, label=f"z_{p_index}")
ax.set_title(self.name)
ax.legend(loc='best')
ax.grid()
plt.show()
def __init__(self):
os.chdir(os.path.dirname(__file__))
quantity_support()
app = QApplication([])
gallery = Frame()
gallery.show()
app.exec_()
def plot_orbit(orbiter: spice.Trajectory, spacecraft: Union[int, str] = 2, planets: Optional[List[str]] = None):
"""
:param orbiter: generated by kernel_loader
:param spacecraft: 1 or 2 for Helios 1 or 2
:param planets: list of planets orbits to be plotted
:return:
"""
quantity_support()
times_float = [(t - orbiter.times[0]).total_seconds() for t in orbiter.times]
fig = plt.figure()
circle = plt.Circle((0, 0), 0.004, color='r')
ax = fig.add_subplot(111)
ax.scatter(orbiter.x, orbiter.y, s=3, c=times_float)
radius = np.sqrt(orbiter.x ** 2 + orbiter.y ** 2 + orbiter.z ** 2)
for n in range(len(radius)):
if 0.1 * u.au < radius[n] < 0.2 * u.au:
ax.scatter(orbiter.x[n], orbiter.y[n], s=3, c='k')
ax.scatter(orbiter.x[0], orbiter.y[0], s=5, c='b')
ax.scatter(orbiter.x[10], orbiter.y[10], s=5, c='r')
if planets is not None:
for planet in planets:
orbiter_planet = get_planet_orbit(planet)
ax.scatter(orbiter_planet.x, orbiter_planet.y, s=3, c='k')
ax.set_xlim(-1, 1)
ax.set_ylim(-1, 1)
ax.set_title(str(spacecraft) + ' orbit between ' + str(orbiter.times[0]) + ' and ' + str(orbiter.times[-1]))
fig = plt.gcf()
ax = fig.gca()
ax.add_artist(circle)
plt.show()
def init():
matplotlib.rcParams.update({
'image.origin': 'lower',
'image.interpolation': 'nearest',
'image.cmap': 'Greys_r'
})
from astropy.visualization import quantity_support
quantity_support()
def plot_period(orbiter, spacecraft: Union[int, str] = 2):
"""
:param orbiter: generated by kernel_loader
:param spacecraft: 1 or 2 for Helios 1 or 2
:return:
"""
quantity_support()
fig = plt.figure()
sun_distance = np.sqrt(orbiter.x ** 2 + orbiter.y ** 2 + orbiter.z ** 2)
plt.plot(orbiter.times, sun_distance, label='Helios' + str(spacecraft) + ' orbit')
plt.title(
'Orbit of Helios ' + str(spacecraft) + ' between ' + str(orbiter.times[0]) + ' and ' + str(orbiter.times[-1]))
plt.legend()
plt.show()
def plot_photometry(self, ax=None, **kwargs):
"""
Plots available photometry (mag v lambda_eff).
:param ax: matplotlib ax object to plot with. A new object is generated if none is provided.
:param kwargs:
:return: matplotlib ax object containing plot info
"""
if ax is None:
fig, ax = plt.subplots()
if "ls" not in kwargs:
kwargs["ls"] = ""
if "marker" not in kwargs:
kwargs["marker"] = "x"
if "ecolor" not in kwargs:
kwargs["ecolor"] = "black"
self.estimate_galactic_extinction()
self.photometry_to_table(fmts=["ascii.ecsv", "ascii.csv"], best=False)
self.photometry_to_table(
output=self.build_photometry_table_path().replace(".ecsv", "_best.ecsv"),
fmts=["ascii.ecsv", "ascii.csv"], best=True)
with quantity_support():
plot_limit = (-999 * units.mag == self.photometry_tbl["mag_sep_err"])
plot_mag = np.invert(plot_limit)
print(plot_limit)
print(plot_mag)
print(self.photometry_tbl["mag_sep"][plot_mag])
ax.errorbar(
self.photometry_tbl["lambda_eff"][plot_mag],
self.photometry_tbl["mag_sep"][plot_mag],
yerr=self.photometry_tbl["mag_sep_err"][plot_mag],
label="Magnitude",
**kwargs,
)
ax.scatter(
self.photometry_tbl["lambda_eff"][plot_limit],
self.photometry_tbl["mag_sep"][plot_limit],
label="Magnitude upper limit",
marker="v",
)
ax.scatter(
self.photometry_tbl["lambda_eff"][plot_mag],
self.photometry_tbl["mag_sep_ext_corrected"][plot_mag],
color="orange",
label="Corrected for Galactic extinction"
)
ax.scatter(
self.photometry_tbl["lambda_eff"][plot_limit],
self.photometry_tbl["mag_sep_ext_corrected"][plot_limit],
label="Magnitude upper limit",
marker="v",
)
ax.set_ylabel("Apparent magnitude")
ax.set_xlabel("$\lambda_\mathrm{eff}$ (\AA)")
ax.invert_yaxis()
return ax
def plot_energy(self, ax=None, **kwargs):
"""Plot counts as a function of energy.
Parameters
----------
ax : `~matplotlib.axes.Axes` or None
Axes
**kwargs : dict
Keyword arguments passed to `~matplotlib.pyplot.hist`
Returns
-------
ax : `~matplotlib.axes.Axes` or None
Axes
"""
import matplotlib.pyplot as plt
ax = plt.gca() if ax is None else ax
energy_axis = self._default_plot_energy_axis
kwargs.setdefault("log", True)
kwargs.setdefault("histtype", "step")
kwargs.setdefault("bins", energy_axis.edges)
with quantity_support():
ax.hist(self.energy, **kwargs)
energy_axis.format_plot_xaxis(ax=ax)
ax.set_ylabel("Counts")
ax.set_yscale("log")
return ax
def plot(self, ax=None, add_cbar=True, **kwargs):
"""Plot effective area image."""
import matplotlib.pyplot as plt
ax = plt.gca() if ax is None else ax
energy = self.axes["energy_true"]
offset = self.axes["offset"]
aeff = self.evaluate(offset=offset.center,
energy_true=energy.center[:, np.newaxis])
vmin, vmax = np.nanmin(aeff.value), np.nanmax(aeff.value)
kwargs.setdefault("cmap", "GnBu")
kwargs.setdefault("edgecolors", "face")
kwargs.setdefault("vmin", vmin)
kwargs.setdefault("vmax", vmax)
with quantity_support():
caxes = ax.pcolormesh(energy.edges, offset.edges, aeff.value.T,
**kwargs)
energy.format_plot_xaxis(ax=ax)
offset.format_plot_yaxis(ax=ax)
if add_cbar:
label = f"Effective Area [{aeff.unit}]"
ax.figure.colorbar(caxes, ax=ax, label=label)
return ax
def plot_spectrum(self, ax=None, **kwargs):
"""Plot angle integrated background rate versus energy.
Parameters
----------
ax : `~matplotlib.axes.Axes`, optional
Axis
**kwargs : dict
Keyword arguments forwarded to `~matplotib.pyplot.plot`
Returns
-------
ax : `~matplotlib.axes.Axes`
Axis
"""
import matplotlib.pyplot as plt
ax = plt.gca() if ax is None else ax
offset_axis = self.axes["offset"]
energy_axis = self.axes["energy"]
bkg = self.integral(offset=offset_axis.bounds[1], axis_name="offset")
with quantity_support():
ax.plot(energy_axis.center, bkg, label="integrated spectrum", **kwargs)
energy_axis.format_plot_xaxis(ax=ax)
ax.set_yscale("log")
ax.set_ylabel(f"Background rate ({ax.yaxis.units})")
ax.legend(loc="best")
return ax
def plot(self, ax=None, add_cbar=True, **kwargs):
"""Plot energy offset dependence of the background model."""
import matplotlib.pyplot as plt
from matplotlib.colors import LogNorm
ax = plt.gca() if ax is None else ax
energy_axis, offset_axis = self.axes["energy"], self.axes["offset"]
data = self.quantity.value
kwargs.setdefault("cmap", "GnBu")
kwargs.setdefault("edgecolors", "face")
kwargs.setdefault("norm", LogNorm())
with quantity_support():
caxes = ax.pcolormesh(
energy_axis.edges, offset_axis.edges, data.T, **kwargs
)
energy_axis.format_plot_xaxis(ax=ax)
offset_axis.format_plot_yaxis(ax=ax)
if add_cbar:
label = f"Background rate ({self.unit})"
ax.figure.colorbar(caxes, ax=ax, label=label)
def peek(self):
"""
Draw a quick matplotlib plot of the array
"""
from matplotlib import pyplot as plt
from astropy.visualization import quantity_support
types = {str(tel) for tel in self.tels.values()}
tab = self.to_table()
plt.figure(figsize=(8, 8))
with quantity_support():
for teltype in types:
tels = tab[tab['tel_description'] == teltype]['tel_id']
sub = self.select_subarray(teltype, tels)
tel_coords = sub.tel_coords
radius = np.array([np.sqrt(tel.optics.mirror_area / np.pi).value
for tel in sub.tels.values()])
plt.scatter(tel_coords.x, tel_coords.y, s=radius * 8, alpha=0.5,
label=teltype)
plt.legend(loc='best')
plt.title(self.name)
plt.tight_layout()
def plot_bias(self, ax=None, **kwargs):
"""Plot reconstruction bias.
See `~gammapy.irf.EnergyDispersion.get_bias` method.
Parameters
----------
ax : `~matplotlib.axes.Axes`, optional
Plot axis
**kwargs : dict
Kwyrow
Returns
-------
ax : `~matplotlib.axes.Axes`, optional
Plot axis
"""
import matplotlib.pyplot as plt
ax = plt.gca() if ax is None else ax
energy = self.axes["energy_true"].center
bias = self.get_bias(energy)
with quantity_support():
ax.plot(energy, bias, **kwargs)
ax.set_xlabel(f"$E_\\mathrm{{True}}$ [{ax.yaxis.units}]")
ax.set_ylabel(
"($E_\\mathrm{{Reco}} - E_\\mathrm{{True}}) / E_\\mathrm{{True}}$"
)
ax.set_xscale("log")
return ax
def plot(self, ax=None, **kwargs):
"""
Plot the stellar spectrum.
Parameters
----------
ax : `~matplotlib.axes.Axes`
Matplotlib axis object
kwargs : dict
Dictionary passed to the `~matplotlib.pyplot.plot` command
Returns
-------
ax : `~matplotlib.axes.Axes`
Updated axis object
"""
import matplotlib.pyplot as plt
from astropy.visualization import quantity_support
if ax is None:
ax = plt.gca()
with quantity_support():
ax.plot(self.wavelength, self.spectral_flux_density, **kwargs)
return ax
def extrapolate_electron_current(probe_characteristic, fit,
bimaxwellian=False, visualize=False):
r"""Extrapolate the electron current from the Maxwellian electron
temperature obtained in the exponential growth region.
Parameters
----------
probe_characteristic : ~plasmapy.diagnostics.langmuir.Characteristic
The probe characteristic that is being analyzed.
fit : ndarray
Polynomial fit coefficients returned by the electron temperature fit.
bimaxwellian : bool, optional
If True the electron current is extrapolated assuming bi-Maxwellian
electron populations, as opposed to Maxwellian. Default is False.
visualize : bool, optional
If True a plot of the extracted electron current is shown. Default is
False.
Returns
-------
electron_current : ~plasmapy.diagnostics.langmuir.Characteristic
The extrapolated electron current characteristic.
Notes
-----
Assuming the electron population is fully Maxwellian the pure electron
current is extrapolated from the fit of the exponential region for the
entire bias range.
"""
probe_characteristic.check_validity()
if bimaxwellian:
fit_func = _fit_func_double_lin_inverse
else:
fit_func = _fit_func_lin_inverse
electron_current = np.exp(fit_func(probe_characteristic.bias.to(u.V).value,
*fit))*u.A
electron_current[electron_current >
np.max(probe_characteristic.current)] = np.NaN
electron_characteristic = Characteristic(probe_characteristic.bias,
electron_current)
if visualize: # coverage: ignore
with quantity_support():
plt.figure()
plt.scatter(probe_characteristic.bias,
probe_characteristic.current.to(u.mA), marker='.',
c='k')
plt.plot(electron_characteristic.bias,
electron_characteristic.current.to(u.mA))
return electron_characteristic
def peek(self):
"""
Draw a quick matplotlib plot of the array
"""
from matplotlib import pyplot as plt
from astropy.visualization import quantity_support
types = {str(tel) for tel in self.tels.values()}
tab = self.to_table()
plt.figure(figsize=(8, 8))
with quantity_support():
for teltype in types:
tels = tab[tab['tel_description'] == teltype]['tel_id']
sub = self.select_subarray(teltype, tels)
radius = np.array([
np.sqrt(tel.optics.mirror_area / np.pi).value
for tel in sub.tels.values()
])
plt.scatter(sub.pos_x,
sub.pos_y,
s=radius * 8,
alpha=0.5,
label=teltype)
plt.legend(loc='best')
plt.title(self.name)
plt.tight_layout()
def peek(self):
"""
Draw a quick matplotlib plot of the array
"""
from matplotlib import pyplot as plt
from astropy.visualization import quantity_support
types = set(self.tels.values())
tab = self.to_table()
plt.figure(figsize=(8, 8))
with quantity_support():
for tel_type in types:
tels = tab[tab["tel_description"] == str(tel_type)]["tel_id"]
sub = self.select_subarray(tel_type, tels)
tel_coords = sub.tel_coords
radius = np.array(
[
np.sqrt(tel.optics.mirror_area / np.pi).value
for tel in sub.tels.values()
]
)
plt.scatter(
tel_coords.x, tel_coords.y, s=radius * 8, alpha=0.5, label=tel_type
)
plt.legend(loc="best")
plt.title(self.name)
plt.tight_layout()
def moon_dist_plot(vis,
grb,
times,
radec,
site="None",
ax=None,
alpha=1,
color="purple"):
if (ax == None): fig, ax = plt.subplots(figsize=(21, 5))
dist = radec.separation(grb.radec)
with quantity_support():
ax.plot(times.datetime,
dist,
color=color,
alpha=alpha,
label="Moon distance")
ax.axhline(y=vis.moon_mindist,
color=color,
ls=":",
alpha=alpha,
label="Min. distance")
ax.set_ylabel("Dist.")
ax.legend()
return ax
def dotheplot(openloop, closedloop, **kwargs):
date = kwargs.pop('date', closedloop.date)
ext = kwargs.pop('extension', extension)
kind = kwargs.setdefault('kind', default_kind)
index = kwargs.get('index', None)
subdir = kwargs.pop('subdir', False)
path = kwargs.pop('path', None)
with quantity_support():
figure = f(openloop, closedloop, **kwargs)
parts = ["{date:%Y-%m-%d}","C{closedloop.n:04d}","O{openloop.n:04d}","{kind:s}", "{key:s}", "{index:s}"]
if keyarg:
if keyargtransform:
kpart = keyargtransform(kwargs.get(keyarg, ""))
else:
kpart = str(kwargs.get(keyarg, ""))
parts.append(kpart)
basename = "{0}.{{ext:s}}".format("-".join(parts))
if path is None:
path = pjoin("{date:%Y-%m-%d}", "C{closedloop.n:04d}-O{openloop.n:04d}", "{kind:s}")
if subdir:
path = pjoin(path, subdir)
path = pjoin(path, basename)
name = path.format(date=date, closedloop=closedloop, openloop=openloop,
kind=kind, key=key, index=index_label(index), ext=ext)
name = name.replace(":", "-")
if not os.path.isdir(os.path.dirname(name)):
os.makedirs(os.path.dirname(name))
click.echo("--> Saving {0} for {1} to '{2}'".format(key, kind, name))
figure.savefig(name)
plt.close(figure)
def plot_at_energy(
self, energy=None, add_cbar=True, ncols=3, figsize=None, **kwargs
):
"""Plot the background rate in Field of view coordinates at a given energy.
Parameters
----------
energy : `~astropy.units.Quantity`
list of Energy
ax: `~matplotlib.axes.Axes`, optional
Axis
add_cbar : bool
Add color bar?
ncols : int
Number of columns to plot
**kwargs : dict
Keyword arguments passed to `~matplotlib.pyplot.pcolormesh`.
"""
import matplotlib.pyplot as plt
n = len(energy)
cols = min(ncols, n)
rows = 1 + (n - 1) // cols
width = 12
if figsize is None:
figsize = (width, width * rows / cols)
fig, axes = plt.subplots(
ncols=cols,
nrows=rows,
figsize=figsize,
gridspec_kw={"hspace": 0.2, "wspace": 0.3},
)
x = self.axes["fov_lat"].edges
y = self.axes["fov_lon"].edges
X, Y = np.meshgrid(x, y)
for i, ee in enumerate(energy):
if len(energy) == 1:
ax = axes
else:
ax = axes.flat[i]
bkg = self.evaluate(energy=ee)
with quantity_support():
caxes = ax.pcolormesh(X, Y, bkg.squeeze(), **kwargs)
self.axes["fov_lat"].format_plot_xaxis(ax)
self.axes["fov_lon"].format_plot_yaxis(ax)
ax.set_title(str(ee))
if add_cbar:
label = f"Background [{bkg.unit}]"
ax.figure.colorbar(caxes, ax=ax, label=label)
row, col = np.unravel_index(i, shape=(rows, cols))
if col > 0:
ax.set_ylabel("")
if row < rows - 1:
ax.set_xlabel("")
def extrapolate_ion_current_OML(probe_characteristic, fit,
visualize=False):
r"""Extrapolate the ion current from the ion density obtained with the
OML method.
Parameters
----------
probe_characteristic : ~plasmapy.diagnostics.langmuir.Characteristic
The probe characteristic that is being analyzed.
fit : ndarray
Fit coefficients returned by the OML method.
visualize : bool, optional
If True a plot of the extracted electron current is shown. Default is
False.
Returns
-------
ion_section : ~plasmapy.diagnostics.langmuir.Characteristic
The exponential electron current growth section.
Notes
-----
The exponential section of the probe characteristic should be a straight
line if the plasma electrons are fully Maxwellian. The slope is then
inversely proportional to the electron temperature.
"""
if not isinstance(probe_characteristic, Characteristic):
raise TypeError(f"For 'probe_characteristic' expected type "
f"{Characteristic.__module__ + '.' + Characteristic.__qualname__} "
f"and got {type(probe_characteristic)}")
slope = fit[0] * u.mA**2 / u.V
offset = fit[1] * u.mA**2
ion_current = -np.sqrt(np.clip(slope * probe_characteristic.bias + offset,
0.0, None))
ion_characteristic = Characteristic(probe_characteristic.bias, ion_current)
if visualize: # coverage: ignore
try:
import matplotlib.pyplot as plt
except (ImportError, ModuleNotFoundError) as e:
from plasmapy.optional_deps import mpl_import_error
raise mpl_import_error from e
with quantity_support():
plt.figure()
plt.scatter(probe_characteristic.bias,
probe_characteristic.current.to(u.mA), marker='.',
c='k')
plt.plot(probe_characteristic.bias,
ion_characteristic.current.to(u.mA), c='y')
return ion_characteristic
def plot(self): # coverage: ignore
r"""Plot the characteristic in matplotlib."""
with quantity_support():
plt.figure()
plt.scatter(self.bias.to(u.V), self.current.to(u.mA),
marker='.', color='k')
plt.title("Probe characteristic")
def plot_residuals(self, ax=None, method="diff", **kwargs):
"""Plot flux point residuals.
Parameters
----------
ax : `~matplotlib.axes.Axes`
Axes to plot on.
method : {"diff", "diff/model"}
Normalization used to compute the residuals, see `FluxPointsDataset.residuals`.
**kwargs : dict
Keyword arguments passed to `~matplotlib.axes.Axes.errorbar`.
Returns
-------
ax : `~matplotlib.axes.Axes`
Axes object.
"""
import matplotlib.pyplot as plt
ax = ax or plt.gca()
fp = self.data
residuals = self.residuals(method)
xerr = self.data.energy_axis.as_plot_xerr
yerr = fp._plot_get_flux_err(sed_type="dnde")
if method == "diff/model":
model = self.flux_pred()
yerr = (yerr[0].quantity[:, 0, 0] / model), (
yerr[1].quantity[:, 0, 0] / model
)
elif method == "diff":
yerr = yerr[0].quantity[:, 0, 0], yerr[1].quantity[:, 0, 0]
else:
raise ValueError('Invalid method, choose between "diff" and "diff/model"')
kwargs.setdefault("color", kwargs.pop("c", "black"))
kwargs.setdefault("marker", "+")
kwargs.setdefault("linestyle", kwargs.pop("ls", "none"))
with quantity_support():
ax.errorbar(fp.energy_ref, residuals, xerr=xerr, yerr=yerr, **kwargs)
ax.axhline(0, color=kwargs["color"], lw=0.5)
# format axes
ax.set_xlabel(f"Energy [{self._energy_unit}]")
ax.set_xscale("log")
label = self._residuals_labels[method]
ax.set_ylabel(f"Residuals\n {label}")
ymin = np.nanmin(residuals - yerr[0])
ymax = np.nanmax(residuals + yerr[1])
ymax = max(abs(ymin), ymax)
ax.set_ylim(-1.05 * ymax, 1.05 * ymax)
return ax
def plot_trajectories(self): # coveralls: ignore
r"""Draws trajectory history."""
from astropy.visualization import quantity_support
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
quantity_support()
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
for p_index in range(self.N):
r = self.position_history[:, p_index]
x, y, z = r.T
ax.plot(x, y, z)
ax.set_title(self.name)
ax.set_xlabel("$x$ position")
ax.set_ylabel("$y$ position")
ax.set_zlabel("$z$ position")
plt.show()
def plot_trajectories(self): # coveralls: ignore
r"""Draws trajectory history."""
from astropy.visualization import quantity_support
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
quantity_support()
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
for p_index in range(self.N):
r = self.position_history[:, p_index]
x, y, z = r.T
ax.plot(x, y, z)
ax.set_title(self.name)
ax.set_xlabel("$x$ position")
ax.set_ylabel("$y$ position")
ax.set_zlabel("$z$ position")
plt.show()
def preview_spectrum(HDU):
"""Preview a 1D spectrum"""
from astropy.visualization import quantity_support
with quantity_support():
fig, ax = plt.subplots(1,1)
wave = wavelength(HDU)
ax.plot(wave, HDU.data)
ax.set_xlabel("Wavelength ({0:latex})".format(wave.unit))
ax.set_ylabel("Flux")
return fig
def plot_containment_radius(self,
ax=None,
fraction=0.68,
add_cbar=True,
**kwargs):
"""Plot containment image with energy and theta axes.
Parameters
----------
ax : `~matplotlib.pyplot.Axes`
Axes to plot on.
fraction : float
Containment fraction between 0 and 1.
add_cbar : bool
Add a colorbar
**kwargs : dict
Keyword arguments passed to `~matplotlib.pyplot.pcolormesh`
Returns
-------
ax : `~matplotlib.pyplot.Axes`
Axes to plot on.
"""
import matplotlib.pyplot as plt
ax = plt.gca() if ax is None else ax
energy = self.axes["energy_true"]
offset = self.axes["offset"]
# Set up and compute data
containment = self.containment_radius(
energy_true=energy.center[:, np.newaxis],
offset=offset.center,
fraction=fraction,
)
# plotting defaults
kwargs.setdefault("cmap", "GnBu")
kwargs.setdefault("vmin", np.nanmin(containment.value))
kwargs.setdefault("vmax", np.nanmax(containment.value))
# Plotting
with quantity_support():
caxes = ax.pcolormesh(energy.edges, offset.edges,
containment.value.T, **kwargs)
energy.format_plot_xaxis(ax=ax)
offset.format_plot_yaxis(ax=ax)
if add_cbar:
label = f"Containment radius R{100 * fraction:.0f} ({containment.unit})"
ax.figure.colorbar(caxes, ax=ax, label=label)
return ax
def plot_runtimes(cases, title, logscale_plot=True):
"""Plots the runtimes."""
quantity_support()
time_support()
fig, ax = plt.subplots()
# ax.grid()
# ax.xaxis.set_major_formatter(FormatStrFormatter("% 3.3f"))
# ax.yaxis.set_major_formatter(FormatStrFormatter("% 3.3f"))
plt.title(f"Runtime Analysis\n({title})")
ax.set_ylabel("Runtime (s)")
if logscale_plot:
ax.set_yscale("log")
fig.set_size_inches(8, 6)
# generate data lists
names = [case for case in cases]
def plot(self): # coverage: ignore
r"""Plot the characteristic in matplotlib."""
try:
import matplotlib.pyplot as plt
except (ImportError, ModuleNotFoundError) as e:
from plasmapy.optional_deps import mpl_import_error
raise mpl_import_error from e
with quantity_support():
plt.figure()
plt.scatter(self.bias.to(u.V), self.current.to(u.mA), marker=".", color="k")
plt.title("Probe characteristic")
def plot_sun_moon(self):
plt.style.use(astropy_mpl_style)
quantity_support()
# Create Sun Moon Plot
sunaltazs_viewing_date = get_sun(self.midnight).transform_to(
self.sun_moon_viewing_frame)
moon_data = get_moon(self.sun_moon_viewing_times)
moonaltazs = moon_data.transform_to(self.sun_moon_viewing_frame)
plt.plot(self.sun_moon_delta_midnight,
moonaltazs.alt,
color=[0.75] * 3,
ls='--',
label='Moon')
plt.plot(self.sun_moon_delta_midnight,
sunaltazs_viewing_date.alt,
color='r',
label='Sun')
plt.fill_between(self.sun_moon_delta_midnight,
0 * u.deg,
90 * u.deg,
sunaltazs_viewing_date.alt < -0 * u.deg,
color='0.5',
zorder=0)
plt.fill_between(self.sun_moon_delta_midnight,
0 * u.deg,
90 * u.deg,
sunaltazs_viewing_date.alt < -18 * u.deg,
color='k',
zorder=0)
plt.legend(loc='upper left')
plt.xlim(-12 * u.hour, 12 * u.hour)
plt.xticks((np.arange(13) * 2 - 12) * u.hour)
plt.ylim(0 * u.deg, 90 * u.deg)
plt.xlabel('Hours from EDT Midnight on {0}'.format(self.date))
plt.ylabel('Altitude [deg]')
plt.title('Sun and Moon plot for {0}'.format(self.site_name))
plt.savefig(self.plot_file_name)
self.get_sunset(sunaltazs_viewing_date)
def test_terminal_velocity():
data = pandas.read_csv("vel_vs_r.dat", names = ["radius", "velocity"], sep=r"\s+")
data_radius = data['radius'].values * u.um
data_velocity = data['velocity'].values * u.m / u.s
my_velocity = spherical_terminal_velocity(data_radius)
if True:
with visualization.quantity_support():
plt.plot(data_radius, data_velocity, label="Dane źródłowe")
plt.plot(data_radius, my_velocity, label="Obliczone")
plt.legend()
plt.savefig("terminal_velocity.png")
plt.show()
assert u.allclose(data_velocity, my_velocity, rtol=4e-3)
def plot_bias(self, ax=None, offset=None, add_cbar=False, **kwargs):
"""Plot migration as a function of true energy for a given offset.
Parameters
----------
ax : `~matplotlib.axes.Axes`, optional
Axis
offset : `~astropy.coordinates.Angle`, optional
Offset
add_cbar : bool
Add a colorbar to the plot.
kwargs : dict
Keyword arguments passed to `~matplotlib.pyplot.pcolormesh`.
Returns
-------
ax : `~matplotlib.axes.Axes`
Axis
"""
import matplotlib.pyplot as plt
from matplotlib.colors import PowerNorm
kwargs.setdefault("cmap", "GnBu")
kwargs.setdefault("norm", PowerNorm(gamma=0.5))
ax = plt.gca() if ax is None else ax
if offset is None:
offset = Angle(1, "deg")
energy_true = self.axes["energy_true"]
migra = self.axes["migra"]
z = self.evaluate(
offset=offset,
energy_true=energy_true.center.reshape(1, -1, 1),
migra=migra.center.reshape(1, 1, -1),
).value[0]
with quantity_support():
caxes = ax.pcolormesh(energy_true.edges, migra.edges, z.T,
**kwargs)
energy_true.format_plot_xaxis(ax=ax)
migra.format_plot_yaxis(ax=ax)
if add_cbar:
label = "Probability density (A.U.)"
ax.figure.colorbar(caxes, ax=ax, label=label)
return ax
def plot(self, ax=None, **kwargs):
"""Plot region map.
Parameters
----------
ax : `~matplotlib.pyplot.Axis`
Axis used for plotting
**kwargs : dict
Keyword arguments passed to `~matplotlib.pyplot.errorbar`
Returns
-------
ax : `~matplotlib.pyplot.Axis`
Axis used for plotting
"""
import matplotlib.pyplot as plt
ax = ax or plt.gca()
if self.data.squeeze().ndim > 1:
raise TypeError(
"Use `.plot_interactive()` if more the one extra axis is present."
)
try:
axis = self.geom.axes["energy"]
except KeyError:
axis = self.geom.axes["energy_true"]
kwargs.setdefault("fmt", ".")
kwargs.setdefault("capsize", 2)
kwargs.setdefault("lw", 1)
with quantity_support():
xerr = (axis.center - axis.edges[:-1],
axis.edges[1:] - axis.center)
ax.errorbar(axis.center,
self.quantity.squeeze(),
xerr=xerr,
**kwargs)
if axis.interp == "log":
ax.set_xscale("log")
ax.set_xlabel(axis.name.capitalize() + f" [{axis.unit}]")
if not self.unit.is_unity():
ax.set_ylabel(f"Data [{self.unit}]")
ax.set_yscale("log")
return ax
import pandas as pd
from astropy.visualization import quantity_support
from matplotlib import pyplot as plt
from scipy.optimize import curve_fit
from pocs.utils import error
from .conversions import cr2_to_fits
from .conversions import make_pretty_image
from .io import crop_data
from .io import read_exif
from .metadata import get_wcsinfo
quantity_support()
def process_cr2(cr2_fname, fits_headers={}, solve=True, make_pretty=False, verbose=False, **kwargs):
assert os.path.exists(cr2_fname), warnings.warn("File must exist: {}".format(cr2_fname))
processed_info = {}
try:
if verbose:
print("Processing image")
if make_pretty:
# If we have the object name, pass it to pretty image
if 'title' in fits_headers:
kwargs['title'] = "{}".format(fits_headers.get('title'))
def imshow(
self,
data=None,
save=False,
ax=None,
interpolation="none",
extra_title=None,
show_resonances="some",
set_extent=True,
equalized=False,
rmin=None,
rmax=None,
savepath=".",
**kwargs,
):
"""Powerful default display.
show_resonances can be True, a list, 'all', or 'some'
"""
if data is None:
data = self.img
if self.resonance_axis is not None:
logger.debug("removing resonance_axis")
self.resonance_axis.remove()
if equalized:
data = np.nan_to_num(data)
data[data < 0] = 0
data = exposure.equalize_hist(data)
self.plotted_data = data
extent_val = self.extent if set_extent else None
min_, max_ = self.plot_limits
self.min_ = min_
self.max_ = max_
if ax is None:
if not _SEABORN_INSTALLED:
fig, ax = plt.subplots(figsize=calc_4_3(8))
else:
fig, ax = plt.subplots()
else:
fig = ax.get_figure()
with quantity_support():
im = ax.imshow(
data,
extent=extent_val,
cmap="gray",
vmin=min_,
vmax=max_,
interpolation=interpolation,
origin="lower",
aspect="auto",
**kwargs,
)
if any([rmin is not None, rmax is not None]):
ax.set_ylim(rmin, rmax)
self.mpl_im = im
ax.set_xlabel("Longitude [deg]")
ax.set_ylabel("Radius [Mm]")
ax.ticklabel_format(useOffset=False)
# ax.grid('on')
title = self.plot_title
if extra_title:
title += ", " + extra_title
ax.set_title(title, fontsize=12)
if show_resonances:
self.set_resonance_axis(ax, show_resonances, rmin, rmax)
if save:
savename = self.plotfname
if extra_title:
savename = savename[:-4] + "_" + extra_title + ".png"
p = Path(savename)
fullpath = Path(savepath) / p.name
fig.savefig(fullpath, dpi=150)
logging.info("Created %s", fullpath)
self.im = im
return im
def ellipse(major, minor, n):
"""Return ellipse edge"""
a = major/2
b = minor/2
t = np.linspace(0, 2*np.pi, n)
return a*np.cos(t), b*np.sin(t)
data = DataFile('touchdown_data.h5')
xunits = imp.ft
yunits = imp.ft
npoints = 1000
fig, ax = plt.subplots()
with quantity_support():
ax.plot(data['miss_x'], data['miss_y'], '.',
xunits=xunits, yunits=yunits, label='simulation data')
x, y = ellipse(8*imp.mile, 6*imp.mile, npoints)
ax.plot(x, y, label='accuracy requirement')
x, y = ellipse(20*imp.mile, 7*imp.mile, npoints)
ax.plot(x, y, label='keepout zone')
ax.set_xlabel('X Miss Distance ({})'.format(ax.xaxis.units))
ax.set_ylabel('Y Miss Distance ({})'.format(ax.yaxis.units))
ax.grid(True)
ax.axis('equal')
ax.legend()