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

rubin_sim/maf/utils/sn_utils.py

@@ -0,0 +1,369 @@
+import matplotlib.pyplot as plt
+import numpy as np
+import numpy.lib.recfunctions as rf
+from scipy import interpolate
+
+
+class Lims:
+    """class to handle light curve of SN
+
+    Parameters
+    -------------
+    Li_files : `str`
+       light curve reference file
+    mag_to_flux_files : `str`
+       files of magnitude to flux
+    band : `str`
+        band considered
+    SNR : `float`
+        Signal-To-Noise Ratio cut
+    mag_range : `float`, `float`, optional
+        mag range considered
+        Default : (23., 27.5)
+    dt_range : `float`, `float`, optional
+        difference time range considered (cadence)
+        Default : (0.5, 25.)
+    """
+
+    def __init__(
+        self,
+        li_files,
+        mag_to_flux_files,
+        band,
+        SNR,
+        mag_range=(23.0, 27.5),
+        dt_range=(0.5, 25.0),
+    ):
+        self.band = band
+        self.SNR = SNR
+        self.lims = []
+        self.mag_to_flux = []
+        self.mag_range = mag_range
+        self.dt_range = dt_range
+
+        for val in li_files:
+            self.lims.append(self.get_lims(self.band, np.load(val), SNR))
+        for val in mag_to_flux_files:
+            self.mag_to_flux.append(np.load(val))
+        self.interp()
+
+    def get_lims(self, band, tab, SNR):
+        """
+        Estimations of the limits
+
+        Parameters
+        -------------
+        band : `str`
+          band to consider
+        tab : `np.ndarray`, (N,)
+          table of data
+        SNR : `float`
+           Signal-to-Noise Ratio cut
+
+        Returns
+        ---------
+        lims : `dict`
+            dict of limits with redshift and band as keys.
+
+        """
+
+        lims = {}
+
+        for z in np.unique(tab["z"]):
+            idx = (tab["z"] == z) & (tab["band"] == "LSST::" + band)
+            idx &= tab["flux_e"] > 0.0
+            sel = tab[idx]
+
+            if len(sel) > 0:
+                li2 = np.sqrt(np.sum(sel["flux_e"] ** 2))
+                lim = 5.0 * li2 / SNR
+                if z not in lims.keys():
+                    lims[z] = {}
+                lims[z][band] = lim
+
+        return lims
+
+    def mesh(self, mag_to_flux):
+        """Mesh grid to estimate five-sigma depth values (m5) from mags input.
+
+        Parameters
+        -----------
+        mag_to_flux : `np.ndarray`, (N,2)
+            magnitude to flux values
+
+        Returns
+        -------
+        m5, Dt, metric : `np.ndarray`, np.ndarray`, `np.ndarray`
+            m5 values, time difference dt (cadence),
+            metric=sqrt(dt)*f5 where f5 is the 5-sigma flux
+
+        """
+        dt = np.linspace(self.dt_range[0], self.dt_range[1], 100)
+        m5 = np.linspace(self.mag_range[0], self.mag_range[1], 50)
+        ida = mag_to_flux["band"] == self.band
+        fa = interpolate.interp1d(mag_to_flux[ida]["m5"], mag_to_flux[ida]["flux_e"])
+        f5 = fa(m5)
+        f5, DT = np.meshgrid(f5, dt)
+        m5, DT = np.meshgrid(m5, dt)
+        metric = np.sqrt(DT) * f5
+
+        return m5, DT, metric
+
+    def interp(self):
+        """Estimate a grid of interpolated values in the plane
+        (m5, cadence, metric).
+        """
+
+        m5_all = []
+        dt_all = []
+        metric_all = []
+
+        for val in self.mag_to_flux:
+            m5, DT, metric = self.mesh(val)
+            m5_all.append(m5)
+            dt_all.append(DT)
+            metric_all.append(metric)
+
+        sorted_keys = []
+        for i in range(len(self.lims)):
+            sorted_keys.append(np.sort([k for k in self.lims[i].keys()])[::-1])
+        figa, axa = plt.subplots()
+
+        for kk, lim in enumerate(self.lims):
+            ll = [lim[zz][self.band] for zz in sorted_keys[kk]]
+            cs = axa.contour(m5_all[kk], dt_all[kk], metric_all[kk], ll)
+
+            points_values = None
+            for io, col in enumerate(cs.collections):
+                # Update in matplotlib changed get_segments to get_paths
+                if hasattr(col, "get_segments"):
+                    segments = col.get_segments()
+                else:
+                    segments = col.get_paths()
+                if segments:
+                    segments = segments[0]
+                    if hasattr(segments, "vertices"):
+                        segments = segments.vertices
+                    myarray = segments
+                    res = np.array(myarray[:, 0], dtype=[("m5", "f8")])
+                    res = rf.append_fields(res, "cadence", myarray[:, 1])
+                    res = rf.append_fields(res, "z", [sorted_keys[kk][io]] * len(res))
+                    if points_values is None:
+                        points_values = res
+                    else:
+                        points_values = np.concatenate((points_values, res))
+            self.points_ref = points_values
+
+        plt.close(figa)  # do not display
+
+    def interp_griddata(self, data):
+        """Estimate metric interpolation for data (m5,cadence)
+
+        Parameters
+        ----------
+        data : `np.ndarray`
+            data where interpolation has to be done (m5,cadence)
+
+        Returns
+        --------
+        res : `np.ndarray`
+            griddata interpolation (m5,cadence,metric)
+        """
+
+        ref_points = self.points_ref
+        res = interpolate.griddata(
+            (ref_points["m5"], ref_points["cadence"]),
+            ref_points["z"],
+            (data["m5_mean"], data["cadence_mean"]),
+            method="cubic",
+        )
+        return res
+
+
+class GenerateFakeObservations:
+    """Class to generate Fake observations
+
+    Parameters
+    -----------
+    config: yaml-like
+       configuration file (parameter choice: filter, cadence, m5,Nseasons, ..)
+    list : `str`, optional
+        Name of the columns used.
+        Default : 'observationStartMJD', 'fieldRA', 'fieldDec','filter',
+        'fiveSigmaDepth', 'visitExposureTime','numExposures',
+        'visitTime','season'
+
+    Returns
+    ---------
+    observations : `np.ndarray`, (N, M)
+        recordarray of observations with the fields:
+        MJD, Ra, Dec, band,m5,Nexp, ExpTime, Season
+    """
+
+    def __init__(
+        self,
+        config,
+        mjd_col="observationStartMJD",
+        ra_col="fieldRA",
+        dec_col="fieldDec",
+        filter_col="filter",
+        m5_col="fiveSigmaDepth",
+        exptime_col="visitExposureTime",
+        nexp_col="numExposures",
+        season_col="season",
+    ):
+        self.mjd_col = mjd_col
+        self.m5_col = m5_col
+        self.filter_col = filter_col
+        self.ra_col = ra_col
+        self.dec_col = dec_col
+        self.exptime_col = exptime_col
+        self.season_col = season_col
+        self.nexp_col = nexp_col
+
+        # now make fake obs
+        self.make_fake(config)
+
+    def make_fake(self, config):
+        """Generate Fake observations
+
+        Parameters
+        -----------
+        config: yaml-like
+            configuration file (parameter choice: filter,
+            cadence, m5,Nseasons, ...)
+        """
+        bands = config["bands"]
+        cadence = dict(zip(bands, config["Cadence"]))
+        shift_days = dict(zip(bands, [config["shift_days"] * io for io in range(len(bands))]))
+        m5 = dict(zip(bands, config["m5"]))
+        nvisits = dict(zip(bands, config["nvisits"]))
+        exposure__time = dict(zip(bands, config["exposure__time"]))
+
+        ra = config["ra"]
+        dec = config["dec"]
+        rtot = []
+        # for season in range(1, config['nseasons']+1):
+        for il, season in enumerate(config["seasons"]):
+            # mjd_min = config['MJD_min'] + float(season-1)*inter_season_gap
+            mjd_min = config["MJD_min"][il]
+            mjd_max = mjd_min + config["season_length"]
+
+            for i, band in enumerate(bands):
+                mjd = np.arange(mjd_min, mjd_max + cadence[band], cadence[band])
+                mjd += shift_days[band]
+                m5_coadded = self.m5_coadd(m5[band], nvisits[band], exposure__time[band])
+                myarr = np.array(mjd, dtype=[(self.mjd_col, "f8")])
+                myarr = rf.append_fields(
+                    myarr,
+                    [self.ra_col, self.dec_col, self.filter_col],
+                    [[ra] * len(myarr), [dec] * len(myarr), [band] * len(myarr)],
+                )
+                myarr = rf.append_fields(
+                    myarr,
+                    [self.m5_col, self.nexp_col, self.exptime_col, self.season_col],
+                    [
+                        [m5_coadded] * len(myarr),
+                        [nvisits[band]] * len(myarr),
+                        [nvisits[band] * exposure__time[band]] * len(myarr),
+                        [season] * len(myarr),
+                    ],
+                )
+                rtot.append(myarr)
+
+        res = np.copy(np.concatenate(rtot))
+        res.sort(order=self.mjd_col)
+
+        self.observations = res
+
+    def m5_coadd(self, m5, nvisits, tvisit):
+        """Coadded m5 estimation
+
+        Parameters
+        ----------
+        m5 : `list` [`float`]
+           list of five-sigma depth values
+        nvisits : `list` [`float`]
+            list of the number of visits
+        tvisit : `list` [`float`]
+           list of the visit times
+
+        Returns
+        ---------
+        m5_coadd : `list` [`float`]
+            list of m5 coadded values
+        """
+        m5_coadd = m5 + 1.25 * np.log10(float(nvisits) * tvisit / 30.0)
+        return m5_coadd
+
+
+class ReferenceData:
+    """class to handle light curve of SN
+
+    Parameters
+    ------------
+    Li_files : `str`
+        light curve reference file
+    mag_to_flux_files : `str`
+        files of magnitude to flux
+    band : `str`
+        band considered
+    z : `float`
+        redshift considered
+    """
+
+    def __init__(self, li_files, mag_to_flux_files, band, z):
+        self.band = band
+        self.z = z
+        self.fluxes = []
+        self.mag_to_flux = []
+
+        for val in li_files:
+            self.fluxes.append(self.interp_fluxes(self.band, np.load(val), self.z))
+        for val in mag_to_flux_files:
+            self.mag_to_flux.append(self.interp_mag(self.band, np.load(val)))
+
+    def interp_fluxes(self, band, tab, z):
+        """Flux interpolator
+
+        Parameters
+        ---------------
+        band : `str`
+            band considered
+        tab : `np.ndarray`
+            reference data with (at least) fields z,band,time,DayMax
+        z : `float`
+            redshift considered
+
+        Returns
+        --------
+        fluxes : `list` [`float`]
+            list (float) of interpolated fluxes (in e/sec)
+        """
+        idx = (np.abs(tab["z"] - z) < 1.0e-5) & (tab["band"] == "LSST::" + band)
+        sel = tab[idx]
+        selc = np.copy(sel)
+        difftime = sel["time"] - sel["DayMax"]
+        selc = rf.append_fields(selc, "deltaT", difftime)
+        return interpolate.interp1d(selc["deltaT"], selc["flux_e"], bounds_error=False, fill_value=0.0)
+
+    def interp_mag(self, band, tab):
+        """magnitude (m5) to flux (e/sec) interpolator
+
+        Parameters
+        ---------------
+        band : `str`
+            band considered
+        tab : `np.ndarray`
+            reference data with (at least) fields band,m5,flux_e,
+        z : `float`
+            redshift considered
+
+        Returns
+        --------
+        mags : `list` [`float`]
+            list (float) of interpolated magnitudes (in e/sec)
+        """
+        idx = tab["band"] == band
+        sel = tab[idx]
+        return interpolate.interp1d(sel["m5"], sel["flux_e"], bounds_error=False, fill_value=0.0)

rubin_sim/maf/utils/stellar_mags.py

@@ -0,0 +1,197 @@
+__all__ = ("stellar_mags",)
+
+import numpy as np
+
+
+def calc_wd_colors():
+    """
+    Calculate a few example WD colors. Values to go in stellar_mags().
+    Here in case values need to be regenerated
+    (different stars, bandpasses change, etc.)
+    """
+
+    try:
+        import os
+
+        from lsst.utils import getPackageDir
+
+        from rubin_sim.photUtils import Bandpass, Sed
+    except ImportError:
+        "Need to setup sims_photUtils to generate WD magnitudes."
+
+    names = ["HeWD_25200_80", "WD_11000_85", "WD_3000_85"]
+    fns = [
+        "bergeron_He_24000_80.dat_25200.gz",
+        "bergeron_10500_85.dat_11000.gz",
+        "bergeron_2750_85.dat_3000.gz",
+    ]
+    wd_dir = os.path.join(getPackageDir("sims_sed_library"), "starSED/wDs/")
+    files = [os.path.join(wd_dir, filename) for filename in fns]
+
+    # Read in the LSST bandpasses
+    bp_names = ["u", "g", "r", "i", "z", "y"]
+    bps = []
+    through_path = os.path.join(getPackageDir("throughputs"), "baseline")
+    for key in bp_names:
+        bp = np.loadtxt(
+            os.path.join(through_path, "filter_" + key + ".dat"),
+            dtype=list(zip(["wave", "trans"], [float] * 2)),
+        )
+        temp_b = Bandpass()
+        temp_b.setBandpass(bp["wave"], bp["trans"])
+        bps.append(temp_b)
+
+    # Read in the SEDs and compute mags
+    mags = []
+    for filename in files:
+        star = Sed()
+        star.readSED_flambda(filename)
+        single_mags = [star.calcMag(band) for band in bps]
+        mags.append([single_mags[i - 1] - single_mags[i] for i in range(1, 6)])
+
+    for maglist, fn, name in zip(mags, fns, names):
+        format = (name, fn) + tuple(maglist)
+        print("['%s', '%s', %f, %f, %f, %f, %f]" % format)
+
+
+def stellar_mags(stellar_type, rmag=19.0):
+    """
+    Calculates the expected magnitudes in LSST filters for a
+    typical star of the given spectral type.
+
+    Based on mapping of Kuruz models to spectral types here:
+    http://www.stsci.edu/hst/observatory/crds/k93models.html
+
+
+    Parameters
+    ----------
+    stellar_type : str
+        Spectral type of a star (O,B,A,F,G,K,M), or for white dwarf colors,
+        one of 'HeWD_25200_80, 'WD_11000_85', 'WD_3000_85'
+    rmag : float
+        The expected r-band magnitude of the star.
+
+    Returns
+    -------
+    dict of floats
+        The expected magnitudes in LSST filters.
+    """
+
+    # If this is the first time running the function, set up the data array
+    if not hasattr(stellar_mags, "data"):
+        names = ["stellar_type", "Model Name", "u-g", "g-r", "r-i", "i-z", "z-y"]
+        types = [("U", 20), ("U", 35), float, float, float, float, float]
+        data = np.rec.fromrecords(
+            [
+                (
+                    "O",
+                    "kp00_50000[g50]",
+                    -0.4835688497,
+                    -0.5201721327,
+                    -0.3991733698,
+                    -0.3106800468,
+                    -0.2072290744,
+                ),
+                (
+                    "B",
+                    "kp00_30000[g40]",
+                    -0.3457202828,
+                    -0.4834762052,
+                    -0.3812792176,
+                    -0.2906072887,
+                    -0.1927230035,
+                ),
+                (
+                    "A",
+                    "kp00_9500[g40]",
+                    0.8823182684,
+                    -0.237288029,
+                    -0.2280783991,
+                    -0.1587960264,
+                    -0.03043824335,
+                ),
+                (
+                    "F",
+                    "kp00_7250[g45]",
+                    0.9140316091,
+                    0.1254277486,
+                    -0.03419150003,
+                    -0.0802010739,
+                    -0.03802756413,
+                ),
+                (
+                    "G",
+                    "kp00_6000[g45]",
+                    1.198219095,
+                    0.3915608688,
+                    0.09129426676,
+                    0.002604263747,
+                    -0.004659443668,
+                ),
+                (
+                    "K",
+                    "kp00_5250[g45]",
+                    1.716635024,
+                    0.6081567546,
+                    0.1796910856,
+                    0.06492278686,
+                    0.0425155827,
+                ),
+                (
+                    "M",
+                    "kp00_3750[g45]",
+                    2.747842719,
+                    1.287599638,
+                    0.5375622482,
+                    0.4313486709,
+                    0.219308065,
+                ),
+                (
+                    "HeWD_25200_80",
+                    "bergeron_He_24000_80.dat_25200.gz",
+                    -0.218959,
+                    -0.388374,
+                    -0.326946,
+                    -0.253573,
+                    -0.239460,
+                ),
+                (
+                    "WD_11000_85",
+                    "bergeron_10500_85.dat_11000.gz",
+                    0.286146,
+                    -0.109115,
+                    -0.178500,
+                    -0.185833,
+                    -0.186913,
+                ),
+                (
+                    "WD_3000_85",
+                    "bergeron_2750_85.dat_3000.gz",
+                    3.170620,
+                    1.400062,
+                    0.167195,
+                    0.127024,
+                    -0.378069,
+                ),
+            ],
+            dtype=list(zip(names, types)),
+        )
+        # Switch to a dict for faster look-up
+        stellar_mags.data = {}
+        for row in data:
+            stellar_mags.data["%s" % row["stellar_type"]] = row
+
+    results = {}
+    # good = np.where(stellar_mags.data['stellar_type'] == stellar_type)
+    if stellar_type not in stellar_mags.data:
+        message = "Received stellar_type %s" % stellar_type
+        message += " but expected one of %s" % ", ".join(stellar_mags.data.keys())
+        raise ValueError(message)
+
+    results["r"] = rmag
+    results["i"] = rmag - stellar_mags.data[stellar_type]["r-i"]
+    results["z"] = results["i"] - stellar_mags.data[stellar_type]["i-z"]
+    results["y"] = results["z"] - stellar_mags.data[stellar_type]["z-y"]
+    results["g"] = stellar_mags.data[stellar_type]["g-r"] + results["r"]
+    results["u"] = stellar_mags.data[stellar_type]["u-g"] + results["g"]
+    return results

rubin_sim/maf/web/__init__.py

@@ -0,0 +1,2 @@
+from .maf_run_results import *
+from .maf_tracking import *