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

rubin_sim/maf/stackers/get_col_info.py

@@ -0,0 +1,104 @@
+__all__ = ("ColInfo",)
+
+
+from .base_stacker import BaseStacker
+
+
+class ColInfo:
+    """Holds the units and source (stacker or database) locations
+    for data columns.
+
+    The stacker classes which will generate stacker columns are tracked here,
+    as well as some default units for common opsim columns.
+
+    See ColInfo.unit_dict for the unit information of database columns.
+    """
+
+    def __init__(self):
+        self.default_data_source = None
+        self.default_unit = ""
+        self.unit_dict = {
+            "filter": "filter",
+            "seqnNum": "#",
+            "expMJD": "MJD",
+            "observationStartMJD": "MJD",
+            "observationStartLST": "deg",
+            "visitExposureTime": "s",
+            "slewTime": "s",
+            "slewDist": "rad",
+            "rotSkyPos": "deg",
+            "rotTelPos": "deg",
+            "rawSeeing": "arcsec",
+            "finSeeing": "arcsec",
+            "FWHMeff": "arcsec",
+            "FWHMgeom": "arcsec",
+            "seeingFwhmEff": "arcsec",
+            "seeingFwhmGeom": "arcsec",
+            "seeingFwhm500": "arcsec",
+            "seeing": "arcsec",
+            "airmass": "X",
+            "night": "days",
+            "moonRA": "rad",
+            "moonDec": "rad",
+            "moonAlt": "rad",
+            "dist2Moon": "rad",
+            "filtSkyBrightness": "mag/sq arcsec",
+            "skyBrightness": "mag/sq arcsec",
+            "fiveSigmaDepth": "mag",
+            "solarElong": "degrees",
+        }
+        # Go through the available stackers and add any units,
+        # and identify their source methods.
+        self.source_dict = {}
+        for stacker_class in BaseStacker.registry.values():
+            stacker = stacker_class()
+            for col, units in zip(stacker.cols_added, stacker.units):
+                self.source_dict[col] = stacker_class
+                self.unit_dict[col] = units
+        # Note that a 'unique' list of methods should be built from the
+        # resulting returned methods, at whatever point the derived data
+        # columns will be calculated.
+
+    def get_units(self, col_name):
+        """Return the appropriate units for col_name.
+
+        If no units have been defined for a given column,
+        return the default units ('').
+
+        Parameters
+        ----------
+        col_name : `str`
+            The name of the column
+
+        Returns
+        -------
+        units : `str`
+        """
+        if col_name is None or col_name not in self.unit_dict:
+            return self.default_unit
+        else:
+            return self.unit_dict[col_name]
+
+    def get_data_source(self, col_name):
+        """Identify the appropriate source for a given column.
+
+        For values which are calculated via a stacker, the returned
+        value is the stacker class.
+        For values which do not have a recorded source or are known to
+        be coming from the database, the result is
+        self.default_data_source (None), which will be assumed to be
+        queryable from the database.
+
+        Parameters
+        ----------
+        col_name : `str`
+            The name of the column.
+
+        Returns
+        -------
+        data_source : `rubin_sim.maf.stacker` or None
+        """
+        if col_name in self.source_dict:
+            return self.source_dict[col_name]
+        else:
+            return self.default_data_source

rubin_sim/maf/stackers/label_stackers.py

@@ -0,0 +1,114 @@
+__all__ = ("WFDlabelStacker",)
+
+import healpy as hp
+import numpy as np
+
+from .base_stacker import BaseStacker
+
+
+class WFDlabelStacker(BaseStacker):
+    """Add an 'areaId' column to flag whether a visit was
+    inside the 'footprint'.
+
+    Parameters
+    ----------
+    footprint : `np.NDarray`, optional
+        The healpix map indicating the desired footprint region.
+        If this is not defined (default None),
+        then the entire sky is used as the footprint.
+    fp_threshold : `float`, optional
+        The threshold for the fraction of the visit area which
+        falls within the footprint in order
+        to be counted as 'in' the footprint. Default 0.4.
+    areaIdName : `str`, optional
+        Value to place in the areaId column for visits which match this area.
+    ra_col : `str`, optional
+        The name of the RA column. Default fieldRA.
+    dec_col : `str`, optional
+        The name of the Dec column. Default fieldDec.
+    note_col : `str`, optional
+        The name of the 'note' (scheduler_note) column in the database.
+        This is used to identify visits
+        which were part of a DD sequence.
+    exclude_dd : `bool`, optional
+        Exclude (True) or include (False) visits which are part of a
+        DD sequence within this 'area'.
+
+    Notes
+    -----
+    This stacker adds an areaId column in the opsim database,
+    to be labelled with 'areaIdName' if the visit falls within the
+    healpix footprint map and (optionally) is not tagged as a DD visit.
+    If it falls outside the footprint, the visit is tagged as "NULL".
+    If it was part of a DD sequence, the visit is tagged with an
+    ID which is unique to that DD field, if 'exclude_dd' is True.
+    Generally this would be likely to be used to tag visits as
+    belonging to WFD - but not necessarily!
+    Any healpix footprint is valid.
+    """
+
+    cols_added = ["area_id"]
+
+    def __init__(
+        self,
+        footprint=None,
+        fp_threshold=0.4,
+        area_id_name="WFD",
+        ra_col="fieldRA",
+        dec_col="fieldDec",
+        note_col="scheduler_note",
+        exclude_dd=True,
+    ):
+        self.ra_col = ra_col
+        self.dec_col = dec_col
+        self.note_col = note_col
+        self.cols_req = [self.ra_col, self.dec_col, self.note_col]
+        self.cols_added_dtypes = [(str, 15)]
+        self.units = [""]
+        self.fp_threshold = fp_threshold
+        self.area_id_name = area_id_name
+        self.exclude_dd = exclude_dd
+        if footprint is None:
+            # If footprint was not defined,
+            # just set it to cover the entire sky, at nside=64
+            footprint = np.ones(hp.nside2npix(64))
+        self.footprint = footprint
+        self.nside = hp.npix2nside(len(self.footprint))
+
+    def define_ddname(self, note):
+        field = note.replace("u,", "")
+        field = field.split(",")[0].replace(",", "")
+        return field
+
+    def _run(self, sim_data, cols_present=False):
+        # Even if cols_present is true, recalculate.
+        # Set up DD names.
+        d = set()
+        for p in np.unique(sim_data[self.note_col]):
+            if p.startswith("DD"):
+                d.add(self.define_ddname(p))
+        # Identify Healpixels associated with each visit.
+        vec = hp.dir2vec(sim_data[self.ra_col], sim_data[self.dec_col], lonlat=True)
+        vec = vec.swapaxes(0, 1)
+        radius = np.radians(1.75)  # fov radius
+        area_id = np.zeros(len(sim_data), self.cols_added_dtypes[0])
+        for i, (v, note) in enumerate(zip(vec, sim_data[self.note_col])):
+            # Identify the healpixels which would be inside this pointing
+            pointing_healpix = hp.query_disc(self.nside, v, radius, inclusive=False)
+            # The wfd_footprint consists of values of 0/1
+            # if out/in WFD footprint
+            hp_in_fp = self.footprint[pointing_healpix].sum()
+            # So in_fp= the number of healpixels which were in
+            # the specified footprint
+            # .. in the # in / total # > limit (0.4)
+            # then "yes" it's in the footprint
+            in_fp = hp_in_fp / len(pointing_healpix)
+            if note.startswith("DD") and self.exclude_dd:
+                area_id[i] = self.define_ddname(note)
+            else:
+                if in_fp >= self.fp_threshold:
+                    area_id[i] = self.area_id_name
+                else:
+                    area_id[i] = "NULL"
+        sim_data["area_id"] = area_id
+        return sim_data

rubin_sim/maf/stackers/m5_optimal_stacker.py

@@ -0,0 +1,126 @@
+__all__ = ("M5OptimalStacker", "generate_sky_slopes")
+
+import numpy as np
+from rubin_scheduler.utils import Site
+
+from .base_stacker import BaseStacker
+
+
+def generate_sky_slopes():
+    """Fit a line to how the sky brightness changes with airmass."""
+    import healpy as hp
+
+    import rubin_sim.skybrightness as sb
+
+    sm = sb.SkyModel(mags=True, moon=False, twilight=False, zodiacal=False)
+    mjd = 57000
+    nside = 32
+    airmass_limit = 2.0
+    dec, ra = hp.pix2ang(nside, np.arange(hp.nside2npix(nside)))
+    dec = np.pi / 2 - dec
+    sm.set_ra_dec_mjd(ra, dec, mjd)
+    mags = sm.return_mags()
+    filters = mags.dtype.names
+    filter_slopes = {}
+    for filter_name in filters:
+        good = np.where((~np.isnan(mags[filter_name])) & (sm.airmass < airmass_limit))
+        pf = np.polyfit(sm.airmass[good], mags[filter_name][good], 1)
+        filter_slopes[filter_name] = pf[0]
+    print(filter_slopes)
+
+
+class M5OptimalStacker(BaseStacker):
+    """Make a new m5 column as if observations were taken on the meridian.
+    If the moon is up, assume sky brightness stays the same.
+
+    Assumes seeing scales as airmass^0.6. Uses linear fits for sky
+    and airmass relation.
+
+    Parameters
+    ----------
+    airmass_col : `str`
+        Column name for the airmass per pointing.
+    dec_col : `str`
+        Column name for the pointing declination.
+    sky_bright_col : `str`
+        Column name for the sky brighntess per pointing.
+    filter_col : `str`
+        Column name for the filter name.
+    m5_col : `str`
+        Colum name for the five sigma limiting depth per pointing.
+    moon_alt_col : `str`
+        Column name for the moon altitude per pointing.
+    sun_alt_col : `str`
+        Column name for the sun altitude column.
+    site : `str`
+        Name of the site.
+    """
+
+    cols_added = ["m5_optimal"]
+
+    def __init__(
+        self,
+        airmass_col="airmass",
+        dec_col="fieldDec",
+        sky_bright_col="skyBrightness",
+        seeing_col="seeingFwhmEff",
+        m5_col="fiveSigmaDepth",
+        filter_col="filter",
+        moon_alt_col="moonAlt",
+        sun_alt_col="sunAlt",
+        site="LSST",
+    ):
+        self.site = Site(site)
+        self.units = ["mags"]
+        self.airmass_col = airmass_col
+        self.dec_col = dec_col
+        self.sky_bright_col = sky_bright_col
+        self.seeing_col = seeing_col
+        self.filter_col = filter_col
+        self.moon_alt_col = moon_alt_col
+        self.sun_alt_col = sun_alt_col
+        self.m5_col = m5_col
+        self.cols_req = [
+            airmass_col,
+            dec_col,
+            sky_bright_col,
+            seeing_col,
+            filter_col,
+            moon_alt_col,
+            sun_alt_col,
+        ]
+        self.cols_req = list(set(self.cols_req))
+
+    def _run(self, sim_data, cols_present=False):
+        # k_atm values from rubin_sim.operations gen_output.py
+        k_atm = {"u": 0.50, "g": 0.21, "r": 0.13, "i": 0.10, "z": 0.07, "y": 0.18}
+        # Linear fits to sky brightness change,
+        # no moon, twilight, or zodiacal components
+        # Use generate_sky_slopes to regenerate if needed.
+        sky_slopes = {
+            "g": -0.52611780327408397,
+            "i": -0.67898669252082422,
+            "r": -0.61378749766766827,
+            "u": -0.27840980367303503,
+            "y": -0.69635091524779691,
+            "z": -0.69652846002009128,
+        }
+        min_z_possible = np.abs(np.radians(sim_data[self.dec_col]) - self.site.latitude_rad)
+        min_airmass_possible = 1.0 / np.cos(min_z_possible)
+        for filter_name in np.unique(sim_data[self.filter_col]):
+            delta_sky = sky_slopes[filter_name] * (sim_data[self.airmass_col] - min_airmass_possible)
+            delta_sky[
+                np.where((sim_data[self.moon_alt_col] > 0) | (sim_data[self.sun_alt_col] > np.radians(-18.0)))
+            ] = 0
+            # Using Approximation that FWHM~X^0.6.
+            # So seeing term in m5 of: 0.25 * log (7.0/FWHMeff )
+            # Goes to 0.15 log(FWHM_min / FWHM_eff) in the difference
+            m5_optimal = (
+                sim_data[self.m5_col]
+                - 0.5 * delta_sky
+                - 0.15 * np.log10(min_airmass_possible / sim_data[self.airmass_col])
+                - k_atm[filter_name] * (min_airmass_possible - sim_data[self.airmass_col])
+            )
+            good = np.where(sim_data[self.filter_col] == filter_name)
+            sim_data["m5_optimal"][good] = m5_optimal[good]
+        return sim_data

rubin_sim/maf/stackers/mo_phase.py

@@ -0,0 +1,265 @@
+"""Phase functions for moving objects.
+
+Adapted from code written by Michael Kelley - mkelley @ github
+(https://github.com/lsst-sssc/lsstcomet/blob/master/lsstcomet/phase.py)
+[the HalleyMarcus phase curve is entirely from Michael Kelley's code]
+"""
+
+__all__ = ("phase__halley_marcus", "phase__log_linear", "phase_hg")
+
+import numpy as np
+from scipy.interpolate import splev, splrep
+
+_halley_marcus_phase_curve = splrep(
+    np.arange(181),
+    np.array(
+        [
+            1.0000e00,
+            9.5960e-01,
+            9.2170e-01,
+            8.8590e-01,
+            8.5220e-01,
+            8.2050e-01,
+            7.9060e-01,
+            7.6240e-01,
+            7.3580e-01,
+            7.1070e-01,
+            6.8710e-01,
+            6.6470e-01,
+            6.4360e-01,
+            6.2370e-01,
+            6.0490e-01,
+            5.8720e-01,
+            5.7040e-01,
+            5.5460e-01,
+            5.3960e-01,
+            5.2550e-01,
+            5.1220e-01,
+            4.9960e-01,
+            4.8770e-01,
+            4.7650e-01,
+            4.6590e-01,
+            4.5590e-01,
+            4.4650e-01,
+            4.3770e-01,
+            4.2930e-01,
+            4.2150e-01,
+            4.1420e-01,
+            4.0730e-01,
+            4.0090e-01,
+            3.9490e-01,
+            3.8930e-01,
+            3.8400e-01,
+            3.7920e-01,
+            3.7470e-01,
+            3.7060e-01,
+            3.6680e-01,
+            3.6340e-01,
+            3.6030e-01,
+            3.5750e-01,
+            3.5400e-01,
+            3.5090e-01,
+            3.4820e-01,
+            3.4580e-01,
+            3.4380e-01,
+            3.4210e-01,
+            3.4070e-01,
+            3.3970e-01,
+            3.3890e-01,
+            3.3850e-01,
+            3.3830e-01,
+            3.3850e-01,
+            3.3890e-01,
+            3.3960e-01,
+            3.4050e-01,
+            3.4180e-01,
+            3.4320e-01,
+            3.4500e-01,
+            3.4700e-01,
+            3.4930e-01,
+            3.5180e-01,
+            3.5460e-01,
+            3.5760e-01,
+            3.6090e-01,
+            3.6450e-01,
+            3.6830e-01,
+            3.7240e-01,
+            3.7680e-01,
+            3.8150e-01,
+            3.8650e-01,
+            3.9170e-01,
+            3.9730e-01,
+            4.0320e-01,
+            4.0940e-01,
+            4.1590e-01,
+            4.2280e-01,
+            4.3000e-01,
+            4.3760e-01,
+            4.4560e-01,
+            4.5400e-01,
+            4.6270e-01,
+            4.7200e-01,
+            4.8160e-01,
+            4.9180e-01,
+            5.0240e-01,
+            5.1360e-01,
+            5.2530e-01,
+            5.3750e-01,
+            5.5040e-01,
+            5.6380e-01,
+            5.7800e-01,
+            5.9280e-01,
+            6.0840e-01,
+            6.2470e-01,
+            6.4190e-01,
+            6.5990e-01,
+            6.7880e-01,
+            6.9870e-01,
+            7.1960e-01,
+            7.4160e-01,
+            7.6480e-01,
+            7.8920e-01,
+            8.1490e-01,
+            8.4200e-01,
+            8.7060e-01,
+            9.0080e-01,
+            9.3270e-01,
+            9.6640e-01,
+            1.0021e00,
+            1.0399e00,
+            1.0799e00,
+            1.1223e00,
+            1.1673e00,
+            1.2151e00,
+            1.2659e00,
+            1.3200e00,
+            1.3776e00,
+            1.4389e00,
+            1.5045e00,
+            1.5744e00,
+            1.6493e00,
+            1.7294e00,
+            1.8153e00,
+            1.9075e00,
+            2.0066e00,
+            2.1132e00,
+            2.2281e00,
+            2.3521e00,
+            2.4861e00,
+            2.6312e00,
+            2.7884e00,
+            2.9592e00,
+            3.1450e00,
+            3.3474e00,
+            3.5685e00,
+            3.8104e00,
+            4.0755e00,
+            4.3669e00,
+            4.6877e00,
+            5.0418e00,
+            5.4336e00,
+            5.8682e00,
+            6.3518e00,
+            6.8912e00,
+            7.4948e00,
+            8.1724e00,
+            8.9355e00,
+            9.7981e00,
+            1.0777e01,
+            1.1891e01,
+            1.3166e01,
+            1.4631e01,
+            1.6322e01,
+            1.8283e01,
+            2.0570e01,
+            2.3252e01,
+            2.6418e01,
+            3.0177e01,
+            3.4672e01,
+            4.0086e01,
+            4.6659e01,
+            5.4704e01,
+            6.4637e01,
+            7.7015e01,
+            9.2587e01,
+            1.1237e02,
+            1.3775e02,
+            1.7060e02,
+            2.1348e02,
+            2.6973e02,
+            3.4359e02,
+            4.3989e02,
+            5.6292e02,
+            7.1363e02,
+            8.8448e02,
+            1.0533e03,
+            1.1822e03,
+            1.2312e03,
+        ]
+    ),
+)
+
+
+def phase__halley_marcus(phase):
+    """Halley-Marcus composite dust phase function.
+    This is appropriate for use when calculating the brightness of
+    cometary coma.
+
+    Parameters
+    ----------
+    phase : float or array
+        Phase angle (degrees).
+
+    Returns
+    -------
+    phi : float or array
+        Phase function evaluated at ``phase``.
+
+    """
+    return splev(phase, _halley_marcus_phase_curve)
+
+
+def phase__log_linear(phase, slope=0.04):
+    """A logLinear phase function, roughly appropriate for cometary nuclei.
+    An H-G phase function is likely a better approximation.
+
+    Parameters
+    ----------
+    phase : float or array
+        Phase angle (degrees)
+    slope : float, optional
+        The slope for the phase function. Default 0.04.
+
+    Returns
+    -------
+    phi : float or array
+        Phase function evaluated at phase
+    """
+    return 10 ** (-0.4 * slope * phase)
+
+
+def phase_hg(phase, G=0.15):
+    """The Bowell et al 1989 (Asteroids II) HG phase curve.
+    https://ui.adsabs.harvard.edu/abs/1989aste.conf..524B/abstract
+
+    Parameters
+    ----------
+    phase : float or array
+        Phase angle (degrees)
+    G : float, optional
+        The G value for the formula. Default 0.15.
+
+    Returns
+    -------
+    phi : float or array
+        Phase function evaluated at phase
+    """
+    # see Muinonen et al 2010, eqn 6
+    # (http://dx.doi.org/10.1016/j.icarus.2010.04.003)
+    phi1 = np.exp(-3.33 * np.power(np.tan(np.radians(phase) / 2), 0.63))
+    phi2 = np.exp(-1.87 * np.power(np.tan(np.radians(phase) / 2), 1.22))
+    return (1 - G) * phi1 + G * phi2
+
+
+def phase_hg12(phase, g12=0.1):
+    pass