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

rubin_sim/maf/plots/neo_distance_plotter.py

@@ -0,0 +1,140 @@
+__all__ = ("NeoDistancePlotter",)
+
+import copy
+
+import matplotlib.pyplot as plt
+import numpy as np
+from matplotlib import colormaps
+from matplotlib.patches import Ellipse
+
+from .plot_handler import BasePlotter
+
+
+class NeoDistancePlotter(BasePlotter):
+    """
+    Special plotter to calculate and plot the maximum distance an H=22 NEO
+    could be observable to, in any particular opsim observation.
+
+    Parameters
+    ----------
+    step : `float`, optional
+        Step size to use for radial bins. Default is 0.01 AU.
+    eclip_max, eclip_min : `float`, `float`, optional
+        Range of ecliptic latitude values to include when creating the plot.
+    """
+
+    def __init__(self, step=0.01, eclip_max=10.0, eclip_min=-10.0):
+        self.plot_type = "neoxyPlotter"
+        self.object_plotter = True
+
+        self.default_plot_dict = {
+            "title": None,
+            "xlabel": "X (AU)",
+            "ylabel": "Y (AU)",
+            "x_min": -1.5,
+            "x_max": 1.5,
+            "y_min": -0.25,
+            "y_max": 2.5,
+            "units": "Count",
+            "figsize": None,
+        }
+        self.filter2color = {
+            "u": "purple",
+            "g": "blue",
+            "r": "green",
+            "i": "cyan",
+            "z": "orange",
+            "y": "red",
+        }
+        self.filter_col_name = "filter"
+        self.step = step
+        self.eclip_max = np.radians(eclip_max)
+        self.eclip_min = np.radians(eclip_min)
+
+    def __call__(self, metric_value, 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.
+        """
+        in_plane = np.where(
+            (metric_value[0]["eclipLat"] >= self.eclip_min) & (metric_value[0]["eclipLat"] <= self.eclip_max)
+        )
+
+        plot_dict = {}
+        plot_dict.update(self.default_plot_dict)
+        plot_dict.update(user_plot_dict)
+
+        if fig is None:
+            fig = plt.figure(plot_dict["figsize"])
+        ax = fig.add_subplot(111)
+
+        planet_props = {"Earth": 1.0, "Venus": 0.72, "Mars": 1.52, "Mercury": 0.39}
+
+        planets = []
+        for prop in planet_props:
+            planets.append(Ellipse((0, 0), planet_props[prop] * 2, planet_props[prop] * 2, fill=False))
+
+        for planet in planets:
+            ax.add_artist(planet)
+
+        # Let's make a 2-d histogram in polar coords,
+        # then convert and display in cartisian
+
+        r_step = self.step
+        rvec = np.arange(0, plot_dict["x_max"] + r_step, r_step)
+        theta_step = np.radians(3.5)
+        thetavec = np.arange(0, 2 * np.pi + theta_step, theta_step) - np.pi
+
+        # array to hold histogram values
+        H = np.zeros((thetavec.size, rvec.size), dtype=float)
+
+        rgrid, thetagrid = np.meshgrid(rvec, thetavec)
+
+        xgrid = rgrid * np.cos(thetagrid)
+        ygrid = rgrid * np.sin(thetagrid)
+
+        for dist, x, y in zip(
+            metric_value[0]["MaxGeoDist"][in_plane],
+            metric_value[0]["NEOHelioX"][in_plane],
+            metric_value[0]["NEOHelioY"][in_plane],
+        ):
+            theta = np.arctan2(y - 1.0, x)
+            diff = np.abs(thetavec - theta)
+            theta_to_use = thetavec[np.where(diff == diff.min())]
+            # This is a slow where-clause, should be possible to speed it up
+            # using
+            # np.searchsorted+clever slicing or hist2d to build up the map.
+            good = np.where((thetagrid == theta_to_use) & (rgrid <= dist))
+            H[good] += 1
+
+        # Set the under value to white
+        my_cmap = copy.copy(colormaps["jet"])
+        my_cmap.set_under("w")
+        blah = ax.pcolormesh(xgrid, ygrid + 1, H, cmap=my_cmap, vmin=0.001, shading="auto")
+        cb = plt.colorbar(blah, ax=ax)
+        cb.set_label(plot_dict["units"])
+
+        ax.set_xlabel(plot_dict["xlabel"])
+        ax.set_ylabel(plot_dict["ylabel"])
+        ax.set_title(plot_dict["title"])
+        ax.set_ylim([plot_dict["y_min"], plot_dict["y_max"]])
+        ax.set_xlim([plot_dict["x_min"], plot_dict["x_max"]])
+
+        ax.plot([0], [1], marker="o", color="b")
+        ax.plot([0], [0], marker="o", color="y")
+
+        return fig

rubin_sim/maf/plots/night_pointing_plotter.py

@@ -0,0 +1,96 @@
+__all__ = ("NightPointingPlotter",)
+
+import warnings
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+from .plot_handler import BasePlotter
+
+
+class NightPointingPlotter(BasePlotter):
+    def __init__(self, mjd_col="observationStartMJD", alt_col="alt", az_col="az"):
+        # Just call it Hourglass so it gets treated the same way
+        self.plot_type = "Hourglass"
+        self.mjd_col = mjd_col
+        self.alt_col = alt_col
+        self.az_col = az_col
+        self.object_plotter = True
+        self.default_plot_dict = {
+            "title": None,
+            "xlabel": "MJD",
+            "ylabels": ["Alt", "Az"],
+            "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):
+        if fig is not None:
+            warnings.warn("Always expect to create a new plot in " "NightPointingPlotter.")
+        fig, (ax1, ax2) = plt.subplots(2, sharex=True)
+
+        mv = metric_value[0]
+
+        u_filters = np.unique(mv["data_slice"]["filter"])
+        for filt in u_filters:
+            good = np.where(mv["data_slice"]["filter"] == filt)
+            ax1.plot(
+                mv["data_slice"][self.mjd_col][good],
+                mv["data_slice"][self.alt_col][good],
+                "o",
+                color=self.filter2color[filt],
+                markersize=5,
+                alpha=0.5,
+            )
+            ax2.plot(
+                mv["data_slice"][self.mjd_col][good],
+                mv["data_slice"][self.az_col][good],
+                "o",
+                color=self.filter2color[filt],
+                markersize=5,
+                alpha=0.5,
+            )
+
+        good = np.where(np.degrees(mv["moon_alts"]) > -10.0)
+        ax1.plot(
+            mv["mjds"][good],
+            np.degrees(mv["moon_alts"][good]),
+            "ko",
+            markersize=3,
+            alpha=0.1,
+        )
+        ax2.plot(
+            mv["mjds"][good],
+            np.degrees(mv["moon_azs"][good]),
+            "ko",
+            markersize=3,
+            alpha=0.1,
+        )
+        ax2.set_xlabel("MJD")
+        ax1.set_ylabel("Altitude (deg)")
+        ax2.set_ylabel("Azimuth (deg)")
+
+        good = np.where(np.degrees(mv["sun_alts"]) > -20.0)
+        ax1.plot(mv["mjds"][good], np.degrees(mv["sun_alts"][good]), "yo", markersize=3)
+        ax2.plot(mv["mjds"][good], np.degrees(mv["sun_azs"][good]), "yo", markersize=3)
+
+        ax1.set_ylim([-20.0, 90.0])
+        ax2.set_ylim([0.0, 360.0])
+
+        for i, key in enumerate(["u", "g", "r", "i", "z", "y"]):
+            ax1.text(
+                1.05,
+                0.9 - i * 0.07,
+                key,
+                color=self.filter2color[key],
+                transform=ax1.transAxes,
+            )
+
+        return fig

rubin_sim/maf/plots/oned_plotters.py

@@ -0,0 +1,114 @@
+__all__ = ("OneDBinnedData",)
+
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+from rubin_sim.maf.utils import percentile_clipping
+
+from .plot_handler import BasePlotter
+
+
+class OneDBinnedData(BasePlotter):
+    """Plot data from a OneDSlicer."""
+
+    def __init__(self):
+        self.plot_type = "BinnedData"
+        self.object_plotter = False
+        self.default_plot_dict = {
+            "title": None,
+            "label": None,
+            "xlabel": None,
+            "ylabel": None,
+            "filled_data": False,
+            "alpha": 0.5,
+            "linestyle": "-",
+            "linewidth": 1,
+            "log_scale": False,
+            "percentile_clip": None,
+            "x_min": None,
+            "x_max": None,
+            "y_min": None,
+            "y_max": None,
+            "fontsize": None,
+            "figsize": None,
+            "grid": True,
+        }
+
+    def __call__(self, metric_values, slicer, user_plot_dict, fig=None):
+        """
+        Plot a set of oneD binned metric data.
+        """
+        if slicer.slicer_name != "OneDSlicer":
+            raise ValueError("OneDBinnedData plotter is for use with OneDSlicer")
+        if "bins" not in slicer.slice_points:
+            err_message = 'OneDSlicer must contain "bins" in slice_points metadata.'
+            err_message += " SlicePoints only contains keys %s." % (slicer.slice_points.keys())
+            raise ValueError(err_message)
+        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"])
+        # Plot the histogrammed data.
+        leftedge = slicer.slice_points["bins"][:-1]
+        width = np.diff(slicer.slice_points["bins"])
+        if plot_dict["filled_data"]:
+            x = np.ravel(list(zip(leftedge, leftedge + width)))
+            y = np.ravel(list(zip(metric_values.filled(), metric_values.filled())))
+        else:
+            good = np.where(~metric_values.mask)
+            x = np.ravel(list(zip(leftedge[good], leftedge[good] + width[good])))
+            y = np.ravel(list(zip(metric_values[good], metric_values[good])))
+        if plot_dict["log_scale"]:
+            plt.semilogy(
+                x,
+                y,
+                label=plot_dict["label"],
+                color=plot_dict["color"],
+                linestyle=plot_dict["linestyle"],
+                linewidth=plot_dict["linewidth"],
+                alpha=plot_dict["alpha"],
+            )
+        else:
+            plt.plot(
+                x,
+                y,
+                label=plot_dict["label"],
+                color=plot_dict["color"],
+                linestyle=plot_dict["linestyle"],
+                linewidth=plot_dict["linewidth"],
+                alpha=plot_dict["alpha"],
+            )
+        if "ylabel" in plot_dict:
+            plt.ylabel(plot_dict["ylabel"], fontsize=plot_dict["fontsize"])
+        if "xlabel" in plot_dict:
+            plt.xlabel(plot_dict["xlabel"], fontsize=plot_dict["fontsize"])
+        # Set y limits (either from values in args,
+        # percentile_clipping or compressed data values).
+        if plot_dict["percentile_clip"] is not None:
+            y_min, y_max = percentile_clipping(
+                metric_values.compressed(), percentile=plot_dict["percentile_clip"]
+            )
+            if plot_dict["y_min"] is None:
+                plot_dict["y_min"] = y_min
+            if plot_dict["y_max"] is None:
+                plot_dict["y_max"] = y_max
+
+        if plot_dict["grid"]:
+            plt.grid(plot_dict["grid"], alpha=0.3)
+
+        if plot_dict["y_min"] is None and metric_values.filled().min() == 0:
+            plot_dict["y_min"] = 0
+
+        # Set y and x limits, if provided.
+        if plot_dict["y_min"] is not None:
+            plt.ylim(bottom=plot_dict["y_min"])
+        if plot_dict["y_max"] is not None:
+            plt.ylim(top=plot_dict["y_max"])
+        if plot_dict["x_min"] is not None:
+            plt.xlim(left=plot_dict["x_min"])
+        if plot_dict["x_max"] is not None:
+            plt.xlim(right=plot_dict["x_max"])
+        plt.title(plot_dict["title"])
+        return fig

rubin_sim/maf/plots/perceptual_rainbow.py

@@ -0,0 +1,30 @@
+__all__ = ("make_pr_cmap",)
+
+from matplotlib.colors import LinearSegmentedColormap
+
+
+def make_pr_cmap():
+    colors = [
+        [135, 59, 97],
+        [143, 64, 127],
+        [143, 72, 157],
+        [135, 85, 185],
+        [121, 102, 207],
+        [103, 123, 220],
+        [84, 146, 223],
+        [69, 170, 215],
+        [59, 192, 197],
+        [60, 210, 172],
+        [71, 223, 145],
+        [93, 229, 120],
+        [124, 231, 103],
+        [161, 227, 95],
+        [198, 220, 100],
+        [233, 213, 117],
+    ]
+    mpl_colors = []
+    for color in colors:
+        mpl_colors.append(tuple([x / 255.0 for x in color]))
+    # Set up the colormap
+    cmap = LinearSegmentedColormap.from_list("perceptual_rainbow", mpl_colors)
+    return cmap