rubin-sim 2.6.1.dev2__py3-none-any.whl

rubin_sim/maf/plots/hourglass_plotters.py

@@ -0,0 +1,120 @@
+__all__ = ("HourglassPlot",)
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+from .plot_handler import BasePlotter
+
+
+class HourglassPlot(BasePlotter):
+    def __init__(self):
+        self.plot_type = "Hourglass"
+        self.object_plotter = True
+        self.default_plot_dict = {
+            "title": None,
+            "xlabel": "Night - min(Night)",
+            "ylabel": "Hours from local midnight",
+            "figsize": None,
+        }
+        self.filter2color = {
+            "u": "purple",
+            "g": "blue",
+            "r": "green",
+            "i": "cyan",
+            "z": "orange",
+            "y": "red",
+        }
+
+    def __call__(self, metric_value, slicer, user_plot_dict, fig=None):
+        """
+        Generate the hourglass plot
+        """
+        if slicer.slicer_name != "HourglassSlicer":
+            raise ValueError("HourglassPlot is for use with hourglass slicers")
+
+        plot_dict = {}
+        plot_dict.update(self.default_plot_dict)
+        plot_dict.update(user_plot_dict)
+
+        if fig is None:
+            fig = plt.figure(figsize=plot_dict["figsize"])
+        ax = fig.add_subplot(111)
+        pernight = metric_value[0]["pernight"]
+        perfilter = metric_value[0]["perfilter"]
+
+        y = (perfilter["mjd"] - perfilter["midnight"]) * 24.0
+        dmin = np.floor(np.min(perfilter["mjd"]))
+        for i in np.arange(0, perfilter.size, 2):
+            ax.plot(
+                [perfilter["mjd"][i] - dmin, perfilter["mjd"][i + 1] - dmin],
+                [y[i], y[i + 1]],
+                self.filter2color[perfilter["filter"][i]],
+            )
+        for i, key in enumerate(["u", "g", "r", "i", "z", "y"]):
+            ax.text(
+                1.05,
+                0.9 - i * 0.07,
+                key,
+                color=self.filter2color[key],
+                transform=ax.transAxes,
+            )
+        # ax.plot(pernight['mjd'] - dmin,
+        # (pernight['twi6_rise'] - pernight['midnight']) * 24.,
+        #        'blue', label=r'6$^\circ$ twilight')
+        # ax.plot(pernight['mjd'] - dmin,
+        # (pernight['twi6_set'] - pernight['midnight']) * 24.,
+        #        'blue')
+        ax.plot(
+            pernight["mjd"] - dmin,
+            (pernight["twi12_rise"] - pernight["midnight"]) * 24.0,
+            "yellow",
+            label=r"12$^\circ$ twilight",
+        )
+        ax.plot(
+            pernight["mjd"] - dmin,
+            (pernight["twi12_set"] - pernight["midnight"]) * 24.0,
+            "yellow",
+        )
+        ax.plot(
+            pernight["mjd"] - dmin,
+            (pernight["twi18_rise"] - pernight["midnight"]) * 24.0,
+            "red",
+            label=r"18$^\circ$ twilight",
+        )
+        ax.plot(
+            pernight["mjd"] - dmin,
+            (pernight["twi18_set"] - pernight["midnight"]) * 24.0,
+            "red",
+        )
+        ax.plot(
+            pernight["mjd"] - dmin,
+            pernight["moonPer"] / 100.0 - 7,
+            "black",
+            label="Moon",
+        )
+        ax.set_xlabel(plot_dict["xlabel"])
+        ax.set_ylabel(plot_dict["ylabel"])
+        ax.set_title(plot_dict["title"])
+
+        # draw things in with lines if we are only plotting one night
+        if len(pernight["mjd"]) == 1:
+            ax.axhline(
+                (pernight["twi6_rise"] - pernight["midnight"]) * 24.0,
+                color="blue",
+                label=r"6$^\circ$ twilight",
+            )
+            ax.axhline((pernight["twi6_set"] - pernight["midnight"]) * 24.0, color="blue")
+            ax.axhline(
+                (pernight["twi12_rise"] - pernight["midnight"]) * 24.0,
+                color="yellow",
+                label=r"12$^\circ$ twilight",
+            )
+            ax.axhline((pernight["twi12_set"] - pernight["midnight"]) * 24.0, color="yellow")
+            ax.axhline(
+                (pernight["twi18_rise"] - pernight["midnight"]) * 24.0,
+                color="red",
+                label=r"18$^\circ$ twilight",
+            )
+            ax.axhline((pernight["twi18_set"] - pernight["midnight"]) * 24.0, color="red")
+
+        return fig

rubin_sim/maf/plots/mo_plotters.py

@@ -0,0 +1,358 @@
+__all__ = ("MetricVsH", "MetricVsOrbit", "MetricVsOrbitPoints")
+
+
+import matplotlib.cm as cm
+import matplotlib.pyplot as plt
+import numpy as np
+
+from .plot_handler import BasePlotter
+
+# mag_sun = -27.1
+# apparent r band magnitude of the sun.
+# this sets the band for the magnitude limit.
+# see http://www.ucolick.org/~cnaw/sun.html for apparent mags in other bands.
+mag_sun = -26.74
+# apparent V band magnitude of the Sun (our H mags translate to V band)
+km_per_au = 1.496e8
+m_per_km = 1000
+
+
+class MetricVsH(BasePlotter):
+    """
+    Plot metric values versus H.
+    Marginalize over metric values in each H bin using 'np_reduce'.
+    """
+
+    def __init__(self):
+        self.plot_type = "MetricVsH"
+        self.object_plotter = False
+        self.default_plot_dict = {
+            "title": None,
+            "xlabel": "H (mag)",
+            "ylabel": None,
+            "label": None,
+            "np_reduce": None,
+            "nbins": None,
+            "albedo": None,
+            "Hmark": None,
+            "HmarkLinestyle": ":",
+            "figsize": None,
+        }
+        self.min_hrange = 1.0
+
+    def __call__(self, metric_value, slicer, user_plot_dict, fig=None):
+        if "linestyle" not in user_plot_dict:
+            user_plot_dict["linestyle"] = "-"
+        plot_dict = {}
+        plot_dict.update(self.default_plot_dict)
+        plot_dict.update(user_plot_dict)
+        hvals = slicer.slice_points["H"]
+        reduce_func = plot_dict["np_reduce"]
+        if reduce_func is None:
+            reduce_func = np.mean
+        if hvals.shape[0] == 1:
+            # We have a simple set of values to plot against H.
+            # This may be due to running a summary metric,
+            # such as completeness.
+            m_vals = metric_value[0].filled()
+        elif len(hvals) == slicer.shape[1]:
+            # Using cloned H distribution.
+            # Apply 'np_reduce' method directly to metric values,
+            # and plot at matching H values.
+            m_vals = reduce_func(metric_value.filled(), axis=0)
+        else:
+            # Probably each object has its own H value.
+            hrange = hvals.max() - hvals.min()
+            min_h = hvals.min()
+            if hrange < self.min_hrange:
+                hrange = self.min_hrange
+                min_h = hvals.min() - hrange / 2.0
+            nbins = plot_dict["nbins"]
+            if nbins is None:
+                nbins = 30
+            stepsize = hrange / float(nbins)
+            bins = np.arange(min_h, min_h + hrange + stepsize / 2.0, stepsize)
+            # In each bin of H, calculate the 'np_reduce' value of the
+            # corresponding metric_values.
+            inds = np.digitize(hvals, bins)
+            inds = inds - 1
+            m_vals = np.zeros(len(bins), float)
+            for i in range(len(bins)):
+                match = metric_value[inds == i]
+                if len(match) == 0:
+                    m_vals[i] = slicer.badval
+                else:
+                    m_vals[i] = reduce_func(match.filled())
+            hvals = bins
+        # Plot the values.
+        if fig is None:
+            fig = plt.figure(figsize=plot_dict["figsize"])
+        ax = plt.gca()
+        ax.plot(
+            hvals,
+            m_vals,
+            color=plot_dict["color"],
+            linestyle=plot_dict["linestyle"],
+            label=plot_dict["label"],
+        )
+        if "x_min" in plot_dict:
+            ax.set_xlim(left=plot_dict["x_min"])
+        if "x_max" in plot_dict:
+            ax.set_xlim(right=plot_dict["x_max"])
+        if "y_min" in plot_dict:
+            ax.set_ylim(bottom=plot_dict["y_min"])
+        if "y_max" in plot_dict:
+            ax.set_ylim(top=plot_dict["y_max"])
+        # Convert hvals to diameter, using 'albedo' - add these upper xticks
+        albedo = plot_dict["albedo"]
+        y = 1.0
+        if albedo is not None:
+            ax2 = ax.twiny()
+            hmin, hmax = ax.get_xlim()
+            dmax = 2.0 * np.sqrt(10 ** ((mag_sun - hmin - 2.5 * np.log10(albedo)) / 2.5))
+            dmin = 2.0 * np.sqrt(10 ** ((mag_sun - hmax - 2.5 * np.log10(albedo)) / 2.5))
+            dmax = dmax * km_per_au * m_per_km
+            dmin = dmin * km_per_au * m_per_km
+            ax2.set_xlim(dmax, dmin)
+            ax2.set_xscale("log")
+            dmid = (dmax - dmin) / 2 + dmin
+            dmid = np.power(10, round(np.log10(dmid)))
+            dmin = np.power(10, round(np.log10(dmin)))
+            dmax = np.power(10, round(np.log10(dmax)))
+            dticks = np.array([dmin, dmid, dmax])
+            ax2.set_xticks(dticks)
+            ax2.set_xlabel("D (m)", labelpad=-5, horizontalalignment="right")
+            ax2.grid(False)
+            plt.sca(ax)
+            y = 1.1
+        plt.grid(True)
+        if plot_dict["Hmark"] is not None:
+            plt.axvline(
+                x=plot_dict["Hmark"],
+                color="r",
+                linestyle=plot_dict["HmarkLinestyle"],
+                alpha=0.3,
+            )
+        plt.title(plot_dict["title"], y=y)
+        plt.xlabel(plot_dict["xlabel"])
+        plt.ylabel(plot_dict["ylabel"])
+        plt.tight_layout()
+        return fig
+
+
+class MetricVsOrbit(BasePlotter):
+    """
+    Plot metric values (at a particular H value) vs. orbital parameters.
+    Marginalize over metric values in each orbital bin using 'np_reduce'.
+    """
+
+    def __init__(self, xaxis="q", yaxis="e"):
+        self.plot_type = "MetricVsOrbit_%s%s" % (xaxis, yaxis)
+        self.object_plotter = False
+        self.default_plot_dict = {
+            "title": None,
+            "xlabel": xaxis,
+            "ylabel": yaxis,
+            "xaxis": xaxis,
+            "yaxis": yaxis,
+            "label": None,
+            "cmap": cm.viridis,
+            "np_reduce": None,
+            "nxbins": None,
+            "nybins": None,
+            "levels": None,
+            "h_val": None,
+            "Hwidth": None,
+            "figsize": None,
+        }
+
+    def __call__(self, metric_value, slicer, user_plot_dict, fig=None):
+        plot_dict = {}
+        plot_dict.update(self.default_plot_dict)
+        plot_dict.update(user_plot_dict)
+        if fig is None:
+            fig = plt.figure(figsize=plot_dict["figsize"])
+        xvals = slicer.slice_points["orbits"][plot_dict["xaxis"]]
+        yvals = slicer.slice_points["orbits"][plot_dict["yaxis"]]
+        # Set x/y bins.
+        nxbins = plot_dict["nxbins"]
+        nybins = plot_dict["nybins"]
+        if nxbins is None:
+            nxbins = 100
+        if nybins is None:
+            nybins = 100
+        if "xbins" in plot_dict:
+            xbins = plot_dict["xbins"]
+        else:
+            xbinsize = (xvals.max() - xvals.min()) / float(nxbins)
+            xbins = np.arange(xvals.min(), xvals.max() + xbinsize / 2.0, xbinsize)
+        if "ybins" in plot_dict:
+            ybins = plot_dict["ybins"]
+        else:
+            ybinsize = (yvals.max() - yvals.min()) / float(nybins)
+            ybins = np.arange(yvals.min(), yvals.max() + ybinsize / 2.0, ybinsize)
+        nxbins = len(xbins)
+        nybins = len(ybins)
+        # Identify the relevant metric_values for the Hvalue we want to plot.
+        hvals = slicer.slice_points["H"]
+        hwidth = plot_dict["hwidth"]
+        if hwidth is None:
+            hwidth = 1.0
+        if len(hvals) == slicer.shape[1]:
+            if plot_dict["hval"] is None:
+                hidx = int(len(hvals) / 2)
+                hval = hvals[hidx]
+            else:
+                hval = plot_dict["hval"]
+                hidx = np.where(np.abs(hvals - hval) == np.abs(hvals - hval).min())[0]
+                hidx = hidx[0]
+        else:
+            if plot_dict["hval"] is None:
+                hval = np.median(hvals)
+                hidx = np.where(np.abs(hvals - hval) <= hwidth / 2.0)[0]
+            else:
+                hval = plot_dict["hvals"]
+                hidx = np.where(np.abs(hvals - hval) <= hwidth / 2.0)[0]
+        if len(hvals) == slicer.shape[1]:
+            m_vals = np.swapaxes(metric_value, 1, 0)[hidx].filled()
+        else:
+            m_vals = metric_value[hidx].filled()
+        # Calculate the np_reduce'd metric values at each x/y bin.
+        if "color_min" in plot_dict:
+            badval = plot_dict["color_min"] - 1
+        else:
+            badval = slicer.badval
+        binvals = np.zeros((nybins, nxbins), dtype="float") + badval
+        xidxs = np.digitize(xvals, xbins) - 1
+        yidxs = np.digitize(yvals, ybins) - 1
+        reduce_func = plot_dict["np_reduce"]
+        if reduce_func is None:
+            reduce_func = np.mean
+        for iy in range(nybins):
+            ymatch = np.where(yidxs == iy)[0]
+            for ix in range(nxbins):
+                xmatch = np.where(xidxs[ymatch] == ix)[0]
+                match_vals = m_vals[ymatch][xmatch]
+                if len(match_vals) > 0:
+                    binvals[iy][ix] = reduce_func(match_vals)
+        xi, yi = np.meshgrid(xbins, ybins)
+        if "color_min" in plot_dict:
+            v_min = plot_dict["color_min"]
+        else:
+            v_min = binvals.min()
+        if "color_max" in plot_dict:
+            v_max = plot_dict["color_max"]
+        else:
+            v_max = binvals.max()
+        nlevels = plot_dict["levels"]
+        if nlevels is None:
+            nlevels = 200
+        levels = np.arange(v_min, v_max, (v_max - v_min) / float(nlevels))
+        plt.contourf(xi, yi, binvals, levels, extend="max", zorder=0, cmap=plot_dict["cmap"])
+        cbar = plt.colorbar()
+        label = plot_dict["label"]
+        if label is None:
+            label = ""
+        cbar.set_label(label + " @ H=%.1f" % (hval))
+        plt.title(plot_dict["title"])
+        plt.xlabel(plot_dict["xlabel"])
+        plt.ylabel(plot_dict["ylabel"])
+        return fig
+
+
+class MetricVsOrbitPoints(BasePlotter):
+    """
+    Plot metric values (at a particular H value) as function
+    of orbital parameters, using points for each metric value.
+    """
+
+    def __init__(self, xaxis="q", yaxis="e"):
+        self.plot_type = "MetricVsOrbit"
+        self.object_plotter = False
+        self.default_plot_dict = {
+            "title": None,
+            "xlabel": xaxis,
+            "ylabel": yaxis,
+            "label": None,
+            "cmap": cm.viridis,
+            "xaxis": xaxis,
+            "yaxis": yaxis,
+            "h_val": None,
+            "Hwidth": None,
+            "foregroundPoints": True,
+            "backgroundPoints": False,
+            "figsize": None,
+        }
+
+    def __call__(self, metric_value, slicer, user_plot_dict, fig=None):
+        plot_dict = {}
+        plot_dict.update(self.default_plot_dict)
+        plot_dict.update(user_plot_dict)
+        if fig is None:
+            fig = plt.figure(figsize=plot_dict["figsize"])
+        xvals = slicer.slice_points["orbits"][plot_dict["xaxis"]]
+        yvals = slicer.slice_points["orbits"][plot_dict["yaxis"]]
+        # Identify the relevant metric_values for the Hvalue we want to plot.
+        hvals = slicer.slice_points["H"]
+        hwidth = plot_dict["hwidth"]
+        if hwidth is None:
+            hwidth = 1.0
+        if len(hvals) == slicer.shape[1]:
+            if plot_dict["hval"] is None:
+                hidx = int(len(hvals) / 2)
+                hval = hvals[hidx]
+            else:
+                hval = plot_dict["hval"]
+                hidx = np.where(np.abs(hvals - hval) == np.abs(hvals - hval).min())[0]
+                hidx = hidx[0]
+        else:
+            if plot_dict["hval"] is None:
+                hval = np.median(hvals)
+                hidx = np.where(np.abs(hvals - hval) <= hwidth / 2.0)[0]
+            else:
+                hval = plot_dict["hvals"]
+                hidx = np.where(np.abs(hvals - hval) <= hwidth / 2.0)[0]
+        if len(hvals) == slicer.shape[1]:
+            m_vals = np.swapaxes(metric_value, 1, 0)[hidx]
+        else:
+            m_vals = metric_value[hidx]
+        if "color_min" in plot_dict:
+            v_min = plot_dict["color_min"]
+        else:
+            v_min = m_vals.min()
+        if "color_max" in plot_dict:
+            v_max = plot_dict["color_max"]
+        else:
+            v_max = m_vals.max()
+        if plot_dict["backgroundPoints"]:
+            # This isn't quite right for the condition .. but will do for now.
+            condition = np.where(m_vals == 0)
+            plt.plot(
+                xvals[condition],
+                yvals[condition],
+                "r.",
+                markersize=4,
+                alpha=0.5,
+                zorder=3,
+            )
+        if plot_dict["foregroundPoints"]:
+            plt.scatter(
+                xvals,
+                yvals,
+                c=m_vals,
+                vmin=v_min,
+                vmax=v_max,
+                cmap=plot_dict["cmap"],
+                s=15,
+                alpha=0.8,
+                zorder=0,
+            )
+            cbar = plt.colorbar()
+            label = plot_dict["label"]
+            if label is None:
+                label = ""
+        cbar.set_label(label + " @ H=%.1f" % (hval))
+        plt.title(plot_dict["title"])
+        plt.xlabel(plot_dict["xlabel"])
+        plt.ylabel(plot_dict["ylabel"])
+        return fig

rubin_sim/maf/plots/nd_plotters.py

@@ -0,0 +1,220 @@
+__all__ = ("TwoDSubsetData", "OneDSubsetData")
+
+
+import matplotlib.pyplot as plt
+import numpy as np
+from matplotlib import colors
+
+from .perceptual_rainbow import make_pr_cmap
+from .plot_handler import BasePlotter
+
+perceptual_rainbow = make_pr_cmap()
+
+
+class TwoDSubsetData(BasePlotter):
+    """
+    Plot 2 axes from the slicer.sliceColList, identified by
+    plot_dict['xaxis']/['yaxis'], given the metric_values at all
+    slicepoints [sums over non-visible axes].
+    """
+
+    def __init__(self):
+        self.plot_type = "2DBinnedData"
+        self.object_plotter = False
+        self.default_plot_dict = {
+            "title": None,
+            "xlabel": None,
+            "ylable": None,
+            "units": None,
+            "log_scale": False,
+            "clims": None,
+            "cmap": perceptual_rainbow,
+            "cbar_format": None,
+            "figsize": None,
+        }
+
+    def __call__(self, metric_values, slicer, user_plot_dict, fig=None):
+        """
+        Parameters
+        ----------
+        metric_value : `numpy.ma.MaskedArray`
+            The metric values from the bundle.
+        slicer : `rubin_sim.maf.slicers.TwoDSlicer`
+            The slicer.
+        user_plot_dict: `dict`
+            Dictionary of plot parameters set by user
+            (overrides default values).
+        fig : `matplotlib.figure.Figure`
+            Matplotlib figure number to use. Default = None, starts new figure.
+
+        Returns
+        -------
+        fig : `matplotlib.figure.Figure`
+           Figure with the plot.
+        """
+        if slicer.slicer_name != "NDSlicer":
+            raise ValueError("TwoDSubsetData plots ndSlicer metric values")
+        plot_dict = {}
+        plot_dict.update(self.default_plot_dict)
+        plot_dict.update(user_plot_dict)
+        if "xaxis" not in plot_dict or "yaxis" not in plot_dict:
+            raise ValueError("xaxis and yaxis must be specified in plot_dict")
+        xaxis = plot_dict["xaxis"]
+        yaxis = plot_dict["yaxis"]
+
+        if fig is None:
+            fig = plt.figure(figsize=plot_dict["figsize"])
+        # Reshape the metric data so we can isolate the values to plot
+        # (just new view of data, not copy).
+        newshape = []
+        for b in slicer.bins:
+            newshape.append(len(b) - 1)
+        newshape.reverse()
+        md = metric_values.reshape(newshape)
+        # Sum over other dimensions.
+        # Note that masked values are not included in sum.
+        sumaxes = list(range(slicer.nD))
+        sumaxes.remove(xaxis)
+        sumaxes.remove(yaxis)
+        sumaxes = tuple(sumaxes)
+        md = md.sum(sumaxes)
+        # Plot the histogrammed data.
+        # Plot data.
+        x, y = np.meshgrid(slicer.bins[xaxis][:-1], slicer.bins[yaxis][:-1])
+        if plot_dict["log_scale"]:
+            norm = colors.LogNorm()
+        else:
+            norm = None
+        if plot_dict["clims"] is None:
+            im = plt.contourf(x, y, md, 250, norm=norm, extend="both", cmap=plot_dict["cmap"])
+        else:
+            im = plt.contourf(
+                x,
+                y,
+                md,
+                250,
+                norm=norm,
+                extend="both",
+                cmap=plot_dict["cmap"],
+                vmin=plot_dict["clims"][0],
+                vmax=plot_dict["clims"][1],
+            )
+        xlabel = plot_dict["xlabel"]
+        if xlabel is None:
+            xlabel = slicer.sliceColList[xaxis]
+        plt.xlabel(xlabel)
+        ylabel = plot_dict["ylabel"]
+        if ylabel is None:
+            ylabel = slicer.sliceColList[yaxis]
+        plt.ylabel(ylabel)
+        cb = plt.colorbar(
+            im,
+            aspect=25,
+            extend="both",
+            orientation="horizontal",
+            format=plot_dict["cbar_format"],
+        )
+        cb.set_label(plot_dict["units"])
+        plt.title(plot_dict["title"])
+        return fig
+
+
+class OneDSubsetData(BasePlotter):
+    """
+    Plot a single axes from the sliceColList, identified by plot_dict['axis'],
+    given the metric_values at all slicepoints [sums over non-visible axes].
+    """
+
+    def __init__(self):
+        self.plot_type = "1DBinnedData"
+        self.object_plotter = False
+        self.default_plot_dict = {
+            "title": None,
+            "xlabel": None,
+            "ylabel": None,
+            "label": None,
+            "units": None,
+            "log_scale": False,
+            "histRange": None,
+            "filled": False,
+            "alpha": 0.5,
+            "cmap": perceptual_rainbow,
+            "cbar_format": None,
+            "figsize": None,
+        }
+
+    def __call__(self, metric_values, slicer, user_plot_dict, fig=None):
+        """
+        Parameters
+        ----------
+        metric_value : `numpy.ma.MaskedArray`
+            The metric values from the bundle.
+        slicer : `rubin_sim.maf.slicers.TwoDSlicer`
+            The slicer.
+        user_plot_dict: `dict`
+            Dictionary of plot parameters set by user
+            (overrides default values).
+        fig : `matplotlib.figure.Figure`
+            Matplotlib figure number to use. Default = None, starts new figure.
+
+        Returns
+        -------
+        fig : `matplotlib.figure.Figure`
+           Figure with the plot.
+        """
+        if slicer.slicer_name != "NDSlicer":
+            raise ValueError("TwoDSubsetData plots ndSlicer metric values")
+
+        plot_dict = {}
+        plot_dict.update(self.default_plot_dict)
+        plot_dict.update(user_plot_dict)
+        if "axis" not in plot_dict:
+            raise ValueError("axis for 1-d plot must be specified in plot_dict")
+
+        if fig is None:
+            fig = plt.Figure(figsize=plot_dict["figsize"])
+        # Reshape the metric data so we can isolate the values to plot
+        # (just new view of data, not copy).
+        axis = plot_dict["axis"]
+        newshape = []
+        for b in slicer.bins:
+            newshape.append(len(b) - 1)
+        newshape.reverse()
+        md = metric_values.reshape(newshape)
+        # Sum over other dimensions.
+        # Note that masked values are not included in sum.
+        sumaxes = list(range(slicer.nD))
+        sumaxes.remove(axis)
+        sumaxes = tuple(sumaxes)
+        md = md.sum(sumaxes)
+        # Plot the histogrammed data.
+        leftedge = slicer.bins[axis][:-1]
+        width = np.diff(slicer.bins[axis])
+        if plot_dict["filled"]:
+            plt.bar(
+                leftedge,
+                md,
+                width,
+                label=plot_dict["label"],
+                linewidth=0,
+                alpha=plot_dict["alpha"],
+                log=plot_dict["log_scale"],
+            )
+        else:
+            x = np.ravel(list(zip(leftedge, leftedge + width)))
+            y = np.ravel(list(zip(md, md)))
+            if plot_dict["log_scale"]:
+                plt.semilogy(x, y, label=plot_dict["label"])
+            else:
+                plt.plot(x, y, label=plot_dict["label"])
+        plt.ylabel(plot_dict["ylabel"])
+        xlabel = plot_dict["xlabel"]
+        if xlabel is None:
+            xlabel = slicer.sliceColName[axis]
+            if plot_dict["units"] is not None:
+                xlabel += " (" + plot_dict["units"] + ")"
+        plt.xlabel(xlabel)
+        if plot_dict["histRange"] is not None:
+            plt.xlim(plot_dict["histRange"])
+        plt.title(plot_dict["title"])
+        return fig