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

rubin_sim/maf/stackers/neo_dist_stacker.py

@@ -0,0 +1,126 @@
+__all__ = ("NEODistStacker",)
+
+import numpy as np
+
+from .base_stacker import BaseStacker
+
+
+class NEODistStacker(BaseStacker):
+    """
+    For each observation, find the max distance to a ~144 km NEO,
+    also stack on the x,y position of the object.
+    """
+
+    cols_added = ["MaxGeoDist", "NEOHelioX", "NEOHelioY"]
+
+    def __init__(
+        self,
+        stepsize=0.001,
+        max_dist=3.0,
+        min_dist=0.3,
+        H=22,
+        elong_col="solarElong",
+        filter_col="filter",
+        sun_az_col="sunAz",
+        az_col="azimuth",
+        m5_col="fiveSigmaDepth",
+    ):
+        """
+        stepsize:  The stepsize to use when solving (in AU)
+        max_dist: How far out to try and measure (in AU)
+        H: Asteroid magnitude
+
+        Adds columns:
+        MaxGeoDist:  Geocentric distance to the NEO
+        NEOHelioX: Heliocentric X (with Earth at x,y,z (0,1,0))
+        NEOHelioY: Heliocentric Y (with Earth at (0,1,0))
+
+        Note that both opsim v3 and v4 report solarElongation in degrees.
+        """
+        self.units = ["AU", "AU", "AU"]
+        # Also grab things needed for the HA stacker
+        self.cols_req = [elong_col, filter_col, sun_az_col, az_col, m5_col]
+
+        self.sun_az_col = sun_az_col
+        self.elong_col = elong_col
+        self.filter_col = filter_col
+        self.az_col = az_col
+        self.m5_col = m5_col
+
+        self.H = H
+        # Magic numbers (Ivezic '15, private comm.)that convert an asteroid
+        # V-band magnitude to LSST filters:
+        # V_5 = m_5 + (adjust value)
+        self.limiting_adjust = {
+            "u": -2.1,
+            "g": -0.5,
+            "r": 0.2,
+            "i": 0.4,
+            "z": 0.6,
+            "y": 0.6,
+        }
+        self.deltas = np.arange(min_dist, max_dist + stepsize, stepsize)
+        self.G = 0.15
+
+        # Magic numbers from  http://adsabs.harvard.edu/abs/2002AJ....124.1776J
+        self.a1 = 3.33
+        self.b1 = 0.63
+        self.a2 = 1.87
+        self.b2 = 1.22
+
+    def _run(self, sim_data, cols_present=False):
+        if cols_present:
+            # This is a pretty rare stacker. Assume we need to rerun
+            pass
+        elong_rad = np.radians(sim_data[self.elong_col])
+        v5 = np.zeros(sim_data.size, dtype=float) + sim_data[self.m5_col]
+        for filter_name in self.limiting_adjust:
+            fmatch = np.where(sim_data[self.filter_col] == filter_name)
+            v5[fmatch] += self.limiting_adjust[filter_name]
+        for i, elong in enumerate(elong_rad):
+            # Law of cosines:
+            # Heliocentric Radius of the object
+            R = np.sqrt(1.0 + self.deltas**2 - 2.0 * self.deltas * np.cos(elong))
+            # Angle between sun and earth as seen by NEO
+            alphas = np.arccos((1.0 - R**2 - self.deltas**2) / (-2.0 * self.deltas * R))
+            ta2 = np.tan(alphas / 2.0)
+            phi1 = np.exp(-self.a1 * ta2**self.b1)
+            phi2 = np.exp(-self.a2 * ta2**self.b2)
+
+            alpha_term = 2.5 * np.log10((1.0 - self.G) * phi1 + self.G * phi2)
+            appmag = self.H + 5.0 * np.log10(R * self.deltas) - alpha_term
+            # There can be some local minima/maxima when solving, so
+            # need to find the *1st* spot where it is too faint, not the
+            # last spot it is bright enough.
+            too_faint = np.where(appmag > v5[i])
+
+            # Check that there is a minimum
+            if np.size(too_faint[0]) == 0:
+                sim_data["MaxGeoDist"][i] = 0
+            else:
+                sim_data["MaxGeoDist"][i] = np.min(self.deltas[too_faint])
+
+        # Make coords in heliocentric
+        interior = np.where(elong_rad <= np.pi / 2.0)
+        outer = np.where(elong_rad > np.pi / 2.0)
+        sim_data["NEOHelioX"][interior] = sim_data["MaxGeoDist"][interior] * np.sin(elong_rad[interior])
+        sim_data["NEOHelioY"][interior] = (
+            -sim_data["MaxGeoDist"][interior] * np.cos(elong_rad[interior]) + 1.0
+        )
+
+        sim_data["NEOHelioX"][outer] = sim_data["MaxGeoDist"][outer] * np.sin(np.pi - elong_rad[outer])
+        sim_data["NEOHelioY"][outer] = sim_data["MaxGeoDist"][outer] * np.cos(np.pi - elong_rad[outer]) + 1.0
+
+        # Flip the X coord if sun az is negative?
+        if sim_data[self.az_col].min() < -np.pi / 2.0:
+            halfval = 180.0
+        else:
+            halfval = np.pi
+        flip = np.where(
+            ((sim_data[self.sun_az_col] > halfval) & (sim_data[self.az_col] > halfval))
+            | ((sim_data[self.sun_az_col] < halfval) & (sim_data[self.az_col] > halfval))
+        )
+
+        sim_data["NEOHelioX"][flip] *= -1.0
+
+        return sim_data

rubin_sim/maf/stackers/sdss_stackers.py

@@ -0,0 +1,30 @@
+__all__ = ("SdssRADecStacker",)
+
+
+import numpy as np
+
+from .base_stacker import BaseStacker
+from .coord_stackers import wrap_ra
+
+
+class SdssRADecStacker(BaseStacker):
+    """convert the p1,p2,p3... columns to radians and wrap them"""
+
+    cols_added = ["RA1", "Dec1", "RA2", "Dec2", "RA3", "Dec3", "RA4", "Dec4"]
+
+    def __init__(self, pcols=["p1", "p2", "p3", "p4", "p5", "p6", "p7", "p8"]):
+        """The p1,p2 columns represent the corners of chips.
+        Could generalize this a bit."""
+        self.units = ["rad"] * 8
+        self.cols_req = pcols
+
+    def _run(self, sim_data, cols_present=False):
+        if cols_present:
+            # Assume this is unusual enough to run that you really mean it.
+            pass
+        for pcol, newcol in zip(self.cols_req, self.cols_added):
+            if newcol[0:2] == "RA":
+                sim_data[newcol] = wrap_ra(np.radians(sim_data[pcol]))
+            else:
+                sim_data[newcol] = np.radians(sim_data[pcol])
+        return sim_data

rubin_sim/maf/stackers/sn_stacker.py

@@ -0,0 +1,152 @@
+__all__ = ("CoaddStacker",)
+
+import numpy as np
+
+from rubin_sim.maf.stackers import BaseStacker
+
+
+class CoaddStacker(BaseStacker):
+    """Stacker to estimate m5 "coadded" per band and par night
+
+    Parameters
+    ----------
+    mjd_col : `str`, optional
+        Name of the MJD column
+    ra_col : `str`, optional
+        Name of the RA column
+    dec_col : `str`, optional
+        Name of the Dec column
+    m5_col : `str`, optional
+        Name of the m5 column
+    filter_col : `str`, optional
+        Name of the filter column
+    night_col : `str`, optional
+        Name of the night column
+    num_exposures_col : `str`, optional
+        Name of the number of exposures per visit column
+    visit_time_col : `str`, optional
+        Name of the total visit time column
+    visit_exposure_time_col : `str`, optional
+        Name of the on-sky exposure time column
+    """
+
+    cols_added = ["coadd"]
+
+    def __init__(
+        self,
+        mjd_col="observationStartMJD",
+        ra_col="fieldRA",
+        dec_col="fieldDec",
+        m5_col="fiveSigmaDepth",
+        filter_col="band",
+        night_col="night",
+        num_exposures_col="numExposures",
+        visit_time_col="visitTime",
+        visit_exposure_time_col="visitExposureTime",
+    ):
+        self.cols_req = [
+            mjd_col,
+            ra_col,
+            dec_col,
+            m5_col,
+            filter_col,
+            night_col,
+            num_exposures_col,
+            visit_time_col,
+            visit_exposure_time_col,
+        ]
+        self.ra_col = ra_col
+        self.dec_col = dec_col
+        self.night_col = night_col
+        self.filter_col = filter_col
+        self.m5_col = m5_col
+        self.num_exposures_col = num_exposures_col
+        self.visit_time_col = visit_time_col
+        self.visit_exposure_time_col = visit_exposure_time_col
+
+        self.units = ["int"]
+
+    def _run(self, sim_data, cols_present=False):
+        if cols_present:
+            # Column already present in data; assume it is correct
+            # and does not need recalculating.
+            return sim_data
+        self.dtype = sim_data.dtype
+        r = []
+        for ra, dec, band in np.unique(sim_data[[self.ra_col, self.dec_col, self.filter_col]]):
+            idx = np.abs(sim_data[self.ra_col] - ra) < 1.0e-5
+            idx &= np.abs(sim_data[self.dec_col] - dec) < 1.0e-5
+            idx &= sim_data[self.filter_col] == band
+
+            sel = sim_data[idx]
+            for night in np.unique(sel[self.night_col]):
+                idxb = sel[self.night_col] == night
+                r.append(tuple(self.fill(sel[idxb])))
+
+        myarray = np.array(r, dtype=self.dtype)
+        return myarray
+
+    def fill(self, tab):
+        """Estimation of new fields (m5 "coadded" values, ...)
+
+        Parameters
+        ---------------
+        tab : array of (initial) data
+
+
+        Returns
+        -----------
+        tuple with modified field values:
+         - m5Col: "coadded" m5
+        - numExposuresCol: sum of  numExposuresCol
+        - visitTimeCol: sum of visitTimeCol
+        - visitExposureTimeCol: sum of visitExposureTimeCol
+        - all other input fields except band (Ra, Dec, night) : median(field)
+        """
+
+        r = []
+
+        for colname in self.dtype.names:
+            if colname not in [
+                self.m5_col,
+                self.num_exposures_col,
+                self.visit_time_col,
+                self.visit_exposure_time_col,
+                self.filter_col,
+            ]:
+                if colname == "coadd":
+                    r.append(1)
+                else:
+                    if tab[colname].dtype == "object":
+                        r.append(tab[colname][0])
+                    else:
+                        r.append(np.median(tab[colname]))
+            if colname == self.m5_col:
+                r.append(self.m5_coadd(tab[self.m5_col]))
+            if colname in [
+                self.num_exposures_col,
+                self.visit_time_col,
+                self.visit_exposure_time_col,
+            ]:
+                r.append(np.sum(tab[colname]))
+            if colname == self.filter_col:
+                r.append(np.unique(tab[self.filter_col])[0])
+
+        return r
+
+    def m5_coadd(self, m5):
+        """Estimation of "coadded" m5 values based on:
+        flux_5sigma = 10**(-0.4*m5)
+        sigmas = flux_5sigma/5.
+        sigma_tot = 1./sqrt(np.sum(1/sigmas**2))
+        flux_tot = 5.*sigma_tot
+
+        Parameters
+        ---------------
+        m5 : set of m5 (five-sigma depths) values
+
+        Returns
+        -----------
+        "coadded" m5 value
+        """
+        return 1.25 * np.log10(np.sum(10.0 ** (0.8 * m5)))

rubin_sim/maf/stackers/teff_stacker.py

@@ -0,0 +1,154 @@
+__all__ = ["TEFF_FIDUCIAL_DEPTH", "TEFF_FIDUCIAL_EXPTIME", "TeffStacker", "compute_teff"]
+
+from collections import defaultdict
+
+import numpy as np
+
+from .base_stacker import BaseStacker
+
+# From reference von Karman 500nm zenith seeing of 0.69"
+# median zenith dark seeing from sims_skybrightness_pre
+# airmass = 1
+# 2 "snaps" of 15 seconds each
+# m5_flat_sed sysEngVals from rubin_sim
+#   commit 6d03bd49550972e48648503ed60784a4e6775b82 (2021-05-18)
+# These include constants from:
+#   https://github.com/lsst-pst/syseng_throughputs/blob/master/notebooks/generate_sims_values.ipynb
+#   commit 7abb90951fcbc70d9c4d0c805c55a67224f9069f (2021-05-05)
+# See https://github.com/lsst-sims/smtn-002/blob/master/notebooks/teff_fiducial.ipynb
+
+# If we do not recognize the filter, return a nan. The np.array(np.nan).item
+# is a hack to define a function that retruns a nan without defining a useless
+# new function or violating the style guide by using a lambda function.
+TEFF_FIDUCIAL_DEPTH = defaultdict(
+    np.array(np.nan).item,
+    {
+        "u": 23.71,
+        "g": 24.67,
+        "r": 24.24,
+        "i": 23.82,
+        "z": 23.21,
+        "y": 22.40,
+    }.items(),
+)
+
+TEFF_FIDUCIAL_EXPTIME = 30.0
+
+
+def compute_teff(m5_depth, filter_name, exptime=None, fiducial_depth=None, teff_base=None, normed=False):
+    """Compute the effective exposure time for a limiting magnitude.
+
+    Parameters
+    ----------
+    m5_depth : `float` or `numpy.ndarray`, (N,)
+        The five sigma point source limiting magintude.
+    filter_name : `str` or `numpy.ndarray`, (N,)
+        The name of the filter.
+    exptime : `float` or `numpy.ndarray`, (N,)
+        The expsore time (seconds), defaults to TEFF_FIDUCIAL_EXPTIME.
+    fiducial_depth: `dict` [`str`, `float`]
+        A mapping of filter to fiducial depth.
+        Defaults to TEFF_FIDUCIAL_DEPTH.
+    teff_base : `float`
+        The exposure time (in seconds) corresponding to the exposure depth.
+    normed : `bool`
+        Normalize against the exposure time, such that a value of 1 corresponds
+        to the exposure having been taken at fiducial conditions. Defaults
+        to False.
+
+    Returns
+    -------
+    t_eff : `float`
+        Effective expsore time, in seconds (if normed is False) or unitless
+        (if normed is true).
+    """
+    if fiducial_depth is None:
+        fiducial_depth = TEFF_FIDUCIAL_DEPTH
+
+    if teff_base is None:
+        teff_base = TEFF_FIDUCIAL_EXPTIME
+
+    if exptime is None:
+        exptime = TEFF_FIDUCIAL_EXPTIME
+
+    try:
+        fiducial_m5_depth = fiducial_depth[filter_name]
+    except TypeError:
+        # If filter_name is not one value, but an iterable, map it according
+        # to fiducial_depth.
+        if len(filter_name) != len(m5_depth):
+            raise ValueError()
+
+        fiducial_m5_depth = np.array([fiducial_depth[b] for b in filter_name])
+
+    t_eff = teff_base * 10.0 ** (0.8 * (m5_depth - fiducial_m5_depth))
+
+    if normed:
+        tau = t_eff / exptime
+        return tau
+    else:
+        return t_eff
+
+
+class TeffStacker(BaseStacker):
+    """Add t_eff column corresponding to fiveSigmaDepth.
+
+    Parameters
+    ----------
+    m5_col : `str` ('fiveSigmaDepth')
+        Colum name for the five sigma limiting depth per pointing.
+        Defaults to "fiveSigmaDepth".
+    filter_col : `str`
+        Defaults to "filter"
+    exptime_col : `str`
+        The column with the exposure time, defaults to
+        "visitExposureTime"
+    fiducial_depth: `dict` [`str`, `float`]
+        A mapping of filter to fiducial depth.
+        Defaults to TEFF_FIDUCIAL_DEPTH.
+    fiducial_exptime : `float`
+        The exposure time (in seconds) corresponding to the exposure depth.
+    normed : `bool`
+        Normalize to exporuse time.
+    """
+
+    cols_added = ["t_eff"]
+
+    def __init__(
+        self,
+        m5_col="fiveSigmaDepth",
+        filter_col="band",
+        exptime_col="visitExposureTime",
+        fiducial_depth=None,
+        fiducial_exptime=None,
+        normed=False,
+        **kwargs,
+    ):
+        self.m5_col = m5_col
+        self.filter_col = filter_col
+        self.exptime_col = exptime_col
+        self.normed = normed
+        self.fiducial_depth = TEFF_FIDUCIAL_DEPTH if fiducial_depth is None else fiducial_depth
+        self.fiducial_exptime = TEFF_FIDUCIAL_EXPTIME if fiducial_exptime is None else fiducial_exptime
+        self.cols_req = [self.m5_col, self.filter_col, self.exptime_col]
+        if self.normed and self.exptime_col not in self.cols_req:
+            self.cols_req.append(self.exptime_col)
+
+        self.units = "" if self.normed else "seconds"
+
+    def _run(self, sim_data, cols_present=False):
+        if cols_present:
+            # Column already present in data; assume it is correct and does not
+            # need recalculating.
+            return sim_data
+
+        sim_data["t_eff"] = compute_teff(
+            sim_data[self.m5_col],
+            sim_data[self.filter_col],
+            sim_data[self.exptime_col],
+            self.fiducial_depth,
+            self.fiducial_exptime,
+            normed=self.normed,
+        )
+
+        return sim_data

rubin_sim/maf/utils/__init__.py

@@ -0,0 +1,6 @@
+from .astrometry_utils import *
+from .get_date_version import *
+from .maf_utils import *
+from .opsim_utils import *
+from .output_utils import *
+from .stellar_mags import *

rubin_sim/maf/utils/astrometry_utils.py

@@ -0,0 +1,93 @@
+__all__ = ("sigma_slope", "m52snr", "astrom_precision")
+
+import numpy as np
+
+"""Some simple functions that are useful for astrometry calculations. """
+
+
+def sigma_slope(x, sigma_y):
+    """
+    Calculate the uncertainty in fitting a line, as
+    given by the spread in x values and the uncertainties
+    in the y values.
+
+    Parameters
+    ----------
+    x : numpy.ndarray
+        The x values of the data
+    sigma_y : numpy.ndarray
+        The uncertainty in the y values
+
+    Returns
+    -------
+    float
+        The uncertainty in the line fit
+    """
+    w = 1.0 / sigma_y**2
+    denom = np.sum(w) * np.sum(w * x**2) - np.sum(w * x) ** 2
+    if denom <= 0:
+        return np.nan
+    else:
+        result = np.sqrt(np.sum(w) / denom)
+        return result
+
+
+def m52snr(m, m5, gamma=0.04):
+    """
+    Calculate the SNR for a star of magnitude m in an
+    observation with 5-sigma limiting magnitude depth m5.
+    Assumes gaussian distribution of photons and might not be
+    strictly due in bluer filters. See table 2 and equation 5
+    in astroph/0805.2366.
+
+    Parameters
+    ----------
+    m : `float` or `np.ndarray` (N,)
+        The magnitude of the star
+    m5 : `float` or `np.ndarray` (N,)
+        The m5 limiting magnitude of the observation
+    gamma : `float` or None
+        The 'gamma' value used when calculating photometric or
+        astrometric errors and weighting SNR accordingly.
+        See equation 5 of the LSST Overview paper.
+        Use "None" to discount the gamma factor completely
+        and use standard 5*10^(0.4 * (m5-m)).
+
+    Returns
+    -------
+    snr : `float` or `np.ndarray` (N,)
+        The SNR
+    """
+    # gamma varies per band, but is fairly close to 0.04
+
+    if gamma is None:
+        snr = 5.0 * 10.0 ** (-0.4 * (m - m5))
+    else:
+        xval = np.power(10, 0.4 * (m - m5))
+        snr = 1 / np.sqrt((0.04 - gamma) * xval + gamma * xval * xval)
+    return snr
+
+
+def astrom_precision(fwhm, snr, systematic_floor=0.00):
+    """
+    Calculate the approximate precision of astrometric measurements,
+    given a particular seeing and SNR value.
+
+    Parameters
+    ----------
+    fwhm : `float` or `np.ndarray` (N,)
+        The seeing (FWHMgeom) of the observation.
+    snr : float` or `np.ndarray` (N,)
+        The SNR of the object.
+    systematic_floor : `float`
+        Systematic noise floor for astrometric error, in arcseconds.
+        Default here is 0, for backwards compatibility.
+        General Rubin use should be 0.01.
+
+    Returns
+    -------
+    astrom_err : `float` or `numpy.ndarray` (N,)
+        The astrometric precision, in arcseconds.
+    """
+    astrom_err = np.sqrt((fwhm / snr) ** 2 + systematic_floor**2)
+    return astrom_err

rubin_sim/maf/utils/generate_fov_map.py

@@ -0,0 +1,58 @@
+import numpy as np
+from rubin_scheduler.utils import gnomonic_project_tosky
+
+# Use the main stack to make a rough array.
+# This code needs an update to work without lsst.sims.
+
+if __name__ == "__main__":
+    import lsst.sims.utils as simsUtils
+    from lsst.obs.lsst import LsstCamMapper
+    from lsst.sims.coordUtils import _chipNameFromRaDec
+
+    mapper = LsstCamMapper()
+    camera = mapper.camera
+    epoch = 2000.0
+
+    ra = 0.0
+    dec = 0.0
+    rot_sky_pos = 0.0
+    mjd = 5300.0
+
+    obs_metadata = simsUtils.ObservationMetaData(
+        pointing_ra=np.degrees(ra),
+        pointing_dec=np.degrees(dec),
+        rot_sky_pos=np.degrees(rot_sky_pos),
+        mjd=mjd,
+    )
+
+    nside = int(1000)
+    # 60k pixels, from 0 to 3.5 degrees
+    x_one = np.linspace(-1.75, 1.75, int(nside))
+
+    # make 2-d x,y arrays
+    x_two = np.broadcast_to(x_one, (nside, nside))
+    y_two = np.broadcast_to(x_one, (nside, nside)).T
+
+    result = np.ones((nside, nside), dtype=bool)
+    ra_two, dec_two = gnomonic_project_tosky(np.radians(x_two), np.radians(y_two), ra, dec)
+    chip_names = _chipNameFromRaDec(
+        ra_two.ravel(),
+        dec_two.ravel(),
+        epoch=epoch,
+        camera=camera,
+        obs_metadata=obs_metadata,
+    )
+
+    chip_names = chip_names.reshape(nside, nside)
+    wavefront_names = [
+        name
+        for name in np.unique(chip_names[np.where(chip_names is not None)])
+        if ("SW" in name) | ("R44" in name) | ("R00" in name) | ("R04" in name) | ("R40" in name)
+    ]
+    # If it's on a waverfront sensor, that's false
+    for name in wavefront_names:
+        result[np.where(chip_names == name)] = False
+    # No chipname, that's a false
+    result[np.where(chip_names is None)] = False
+
+    np.savez("fov_map.npz", x=x_one, image=result)

rubin_sim/maf/utils/get_date_version.py

@@ -0,0 +1,28 @@
+__all__ = ("get_date_version",)
+
+import time
+from importlib import metadata
+
+
+def get_date_version():
+    """
+    Get today's date and a dictionary with the MAF version information.
+    This is written into configuration output files, to help track MAF runs.
+
+    Returns
+    -------
+    str, dict
+        String with today's date, Dictionary with version information.
+    """
+
+    version = metadata.version("rubin_sim")
+    # today_date = time.strftime("%x")
+    today_date = "-".join([time.strftime(x) for x in ["%Y", "%m", "%d"]])
+    version_info = {
+        "__version__": version,
+        "__repo_version__": None,
+        "__fingerprint__": None,
+        "__dependency_versions__": None,
+    }
+
+    return today_date, version_info