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

rubin_sim/maf/metrics/periodic_detect_metric.py

@@ -0,0 +1,133 @@
+__all__ = ("PeriodicDetectMetric",)
+
+import numpy as np
+import scipy
+
+from rubin_sim.maf.utils import m52snr, stellar_mags
+
+from .base_metric import BaseMetric
+
+
+class PeriodicDetectMetric(BaseMetric):
+    """Determine if we would be able to classify an object as
+    periodic/non-uniform, using an F-test.
+
+    The idea here is that if a periodic source is aliased, it will be
+    indistinguishable from a constant source,
+    so we can find a best-fit constant, and if the reduced chi-squared is ~1,
+    we know we are aliased.
+
+    Parameters
+    ----------
+    mjd_col : `str`, opt
+        Name of the MJD column in the observations.
+    periods : `float` or `np.ndarray`, (N,), opt
+        The period of the star (days).
+        Can be a single value, or an array.
+        If an array, amplitude and starMag should be arrays of equal length.
+    amplitudes : `float`, opt
+        The amplitude of the stellar variability, (mags).
+    m5_col : `str`, opt
+        The name of the m5 limiting magnitude column in the observations.
+    metric_name : `str`, opt
+        The name for the metric.
+    starMags : `float`, opt
+        The mean magnitude of the star in r (mags).
+    sig_level : `float`, opt
+        The value to use to compare to the p-value when deciding
+        if we can reject the null hypothesis.
+    sed_template : `str`, opt
+        The stellar SED template to use to generate realistic colors
+        (default is an F star, so RR Lyrae-like)
+
+    Returns
+    -------
+    flag : `int`
+        Returns 1 if we would detect star is variable,
+        0 if it is well-fit by a constant value.
+        If using arrays to test multiple period-amplitude-mag combinations,
+        will be the sum of the number of detected stars.
+    """
+
+    def __init__(
+        self,
+        mjd_col="observationStartMJD",
+        periods=2.0,
+        amplitudes=0.1,
+        m5_col="fiveSigmaDepth",
+        metric_name="PeriodicDetectMetric",
+        filter_col="band",
+        star_mags=20,
+        sig_level=0.05,
+        sed_template="F",
+        **kwargs,
+    ):
+        self.mjd_col = mjd_col
+        self.m5_col = m5_col
+        self.filter_col = filter_col
+        if np.size(periods) == 1:
+            self.periods = [periods]
+            # Using the same magnitude for all filters.
+            # Could expand to fit the mean in each filter.
+            self.star_mags = [star_mags]
+            self.amplitudes = [amplitudes]
+        else:
+            self.periods = periods
+            self.star_mags = star_mags
+            self.amplitudes = amplitudes
+        self.sig_level = sig_level
+        self.sed_template = sed_template
+
+        super(PeriodicDetectMetric, self).__init__(
+            [mjd_col, m5_col, filter_col],
+            metric_name=metric_name,
+            units="N Detected (0, %i)" % np.size(periods),
+            **kwargs,
+        )
+
+    def run(self, data_slice, slice_point=None):
+        result = 0
+        n_pts = np.size(data_slice[self.mjd_col])
+        n_filt = np.size(np.unique(data_slice[self.filter_col]))
+
+        # If we had a correct model with phase, amplitude, period, mean_mags,
+        # then chi_squared/DoF would be ~1 with 3+n_filt free parameters.
+        # The mean is one free parameter
+        p1 = n_filt
+        p2 = 3.0 + n_filt
+        chi_sq_2 = 1.0 * (n_pts - p2)
+
+        u_filters = np.unique(data_slice[self.filter_col])
+
+        if n_pts > p2:
+            for period, starMag, amplitude in zip(self.periods, self.star_mags, self.amplitudes):
+                chi_sq_1 = 0
+                mags = stellar_mags(self.sed_template, rmag=starMag)
+                for filtername in u_filters:
+                    in_filt = np.where(data_slice[self.filter_col] == filtername)[0]
+                    lc = (
+                        amplitude * np.sin(data_slice[self.mjd_col][in_filt] * (np.pi * 2) / period)
+                        + mags[filtername]
+                    )
+                    snr = m52snr(lc, data_slice[self.m5_col][in_filt])
+                    delta_m = 2.5 * np.log10(1.0 + 1.0 / snr)
+                    weights = 1.0 / (delta_m**2)
+                    weighted_mean = np.sum(weights * lc) / np.sum(weights)
+                    chi_sq_1 += np.sum(((lc - weighted_mean) ** 2 / delta_m**2))
+                # Yes, I'm fitting magnitudes rather than flux.
+                # At least I feel kinda bad about it.
+                # F-test for nested models Regression problems:
+                # https://en.wikipedia.org/wiki/F-test
+                f_numerator = (chi_sq_1 - chi_sq_2) / (p2 - p1)
+                f_denom = 1.0
+                # This is just reduced chi-squared for the more
+                # complicated model, so should be 1.
+                f_val = f_numerator / f_denom
+                # Has DoF (p2-p1, n-p2)
+                # https://stackoverflow.com/questions/21494141/how-do-i-do-a-f-test-in-python/21503346
+                p_value = scipy.stats.f.sf(f_val, p2 - p1, n_pts - p2)
+                if np.isfinite(p_value):
+                    if p_value < self.sig_level:
+                        result += 1
+
+        return result

rubin_sim/maf/metrics/phase_gap_metric.py

@@ -0,0 +1,172 @@
+__all__ = ("PhaseGapMetric", "PeriodicQualityMetric")
+
+import numpy as np
+
+from rubin_sim.maf.utils import m52snr
+
+from .base_metric import BaseMetric
+
+
+class PhaseGapMetric(BaseMetric):
+    """Measure the maximum gap in phase coverage for
+    observations of periodic variables.
+
+    Parameters
+    ----------
+    col : `str`, optional
+        Name of the column to use for the observation times (MJD)
+    n_periods : `int`, optional
+        Number of periods to test
+    period_min : `float`, optional
+        Minimum period to test, in days.
+    period_max : `float`, optional
+        Maximum period to test, in days
+    n_visits_min : `int`, optional
+        Minimum number of visits necessary before looking for the phase gap.
+
+    Returns
+    -------
+    metric_value : `dict` {`periods`: `float`, `maxGaps` : `float`}
+        Calculates a dictionary of max gap in phase coverage for each period.
+    """
+
+    def __init__(
+        self,
+        col="observationStartMJD",
+        n_periods=5,
+        period_min=3.0,
+        period_max=35.0,
+        n_visits_min=3,
+        metric_name="Phase Gap",
+        **kwargs,
+    ):
+        self.period_min = period_min
+        self.period_max = period_max
+        self.n_periods = n_periods
+        self.n_visits_min = n_visits_min
+        super(PhaseGapMetric, self).__init__(col, metric_name=metric_name, units="Fraction, 0-1", **kwargs)
+
+    def run(self, data_slice, slice_point=None):
+        if len(data_slice) < self.n_visits_min:
+            return self.badval
+        # Create 'nPeriods' evenly spaced periods within range of min to max.
+        step = (self.period_max - self.period_min) / self.n_periods
+        if step == 0:
+            periods = np.array([self.period_min])
+        else:
+            periods = np.arange(self.n_periods)
+            periods = periods / np.max(periods) * (self.period_max - self.period_min) + self.period_min
+        max_gap = np.zeros(self.n_periods, float)
+
+        for i, period in enumerate(periods):
+            # For each period, calculate the phases.
+            phases = (data_slice[self.colname] % period) / period
+            phases = np.sort(phases)
+            # Find the largest gap in coverage.
+            gaps = np.diff(phases)
+            start_to_end = np.array([1.0 - phases[-1] + phases[0]], float)
+            gaps = np.concatenate([gaps, start_to_end])
+            max_gap[i] = np.max(gaps)
+
+        return {"periods": periods, "maxGaps": max_gap}
+
+    def reduce_mean_gap(self, metric_val):
+        """
+        At each slice_point, return the mean gap value.
+        """
+        return np.mean(metric_val["maxGaps"])
+
+    def reduce_median_gap(self, metric_val):
+        """
+        At each slice_point, return the median gap value.
+        """
+        return np.median(metric_val["maxGaps"])
+
+    def reduce_worst_period(self, metric_val):
+        """
+        At each slice_point, return the period with the largest phase gap.
+        """
+        worst_p = metric_val["periods"][np.where(metric_val["maxGaps"] == metric_val["maxGaps"].max())]
+        return worst_p
+
+    def reduce_largest_gap(self, metric_val):
+        """
+        At each slice_point, return the largest phase gap value.
+        """
+        return np.max(metric_val["maxGaps"])
+
+
+#  To fit a periodic source well, you need to cover the full phase,
+#  and fit the amplitude.
+class PeriodicQualityMetric(BaseMetric):
+    """Evaluate phase coverage over a given period.
+
+    Parameters
+    ----------
+    mjd_col : `str`, opt
+        Name of the MJD column in the observations.
+    period : `float`, opt
+        Period to check.
+    m5_col : `str`, opt
+        Name of the m5 column in the observations.
+    metric_name : `str`, opt
+        Name of the metric.
+    star_mag : `float`, opt
+        Magnitude of the star to simulate coverage for.
+
+    Returns
+    -------
+    value : `float`
+        Value representing phase_coverage * amplitude_snr.
+        Ranges from 0 (poor) to 1.
+    """
+
+    def __init__(
+        self,
+        mjd_col="observationStartMJD",
+        period=2.0,
+        m5_col="fiveSigmaDepth",
+        metric_name="PhaseCoverageMetric",
+        star_mag=20,
+        **kwargs,
+    ):
+        self.mjd_col = mjd_col
+        self.m5_col = m5_col
+        self.period = period
+        self.star_mag = star_mag
+        super(PeriodicQualityMetric, self).__init__(
+            [mjd_col, m5_col], metric_name=metric_name, units="Fraction, 0-1", **kwargs
+        )
+
+    def _calc_phase(self, data_slice):
+        """1 is perfectly balanced phase coverage,
+        0 is no effective coverage.
+        """
+        angles = data_slice[self.mjd_col] % self.period
+        angles = angles / self.period * 2.0 * np.pi
+        x = np.cos(angles)
+        y = np.sin(angles)
+
+        snr = m52snr(self.star_mag, data_slice[self.m5_col])
+        x_ave = np.average(x, weights=snr)
+        y_ave = np.average(y, weights=snr)
+
+        vector_off = np.sqrt(x_ave**2 + y_ave**2)
+        return 1.0 - vector_off
+
+    def _calc_amp(self, data_slice):
+        """Fractional SNR on the amplitude,
+        testing for a variety of possible phases.
+        """
+        phases = np.arange(0, np.pi, np.pi / 8.0)
+        snr = m52snr(self.star_mag, data_slice[self.m5_col])
+        amp_snrs = np.sin(data_slice[self.mjd_col] / self.period * 2 * np.pi + phases[:, np.newaxis]) * snr
+        amp_snr = np.min(np.sqrt(np.sum(amp_snrs**2, axis=1)))
+
+        max_snr = np.sqrt(np.sum(snr**2))
+        return amp_snr / max_snr
+
+    def run(self, data_slice, slice_point=None):
+        amplitude_fraction = self._calc_amp(data_slice)
+        phase_fraction = self._calc_phase(data_slice)
+        return amplitude_fraction * phase_fraction

rubin_sim/maf/metrics/qso_number_counts_metric.py

@@ -0,0 +1,138 @@
+__all__ = ("QSONumberCountsMetric",)
+
+import os
+
+import healpy as hp
+import numpy as np
+from rubin_scheduler.data import get_data_dir
+from scipy import interpolate
+
+from .base_metric import BaseMetric
+from .exgal_m5 import ExgalM5
+
+
+class QSONumberCountsMetric(BaseMetric):
+    """Calculate the number of quasars expected with SNR>=5
+    according to the Shen et al. (2020) QLF - model A in the redshift
+    range zmin < z < zmax.
+
+    The 5 sigma depths are obtained using the ExgalM5 metric.
+    Only quasars fainter than the saturation magnitude are counted.
+
+    By default, zmin is 0.3 and zmax is the minimum between 6.7 and the
+    redshift at which the Lyman break matches the effective wavelength
+    of the band. For bands izy, zmax is 6.7. This default choice is to
+    match Table 10.2 for i-band quasar counts in the LSST Science book.
+    """
+
+    def __init__(
+        self,
+        lsst_filter,
+        m5_col="fiveSigmaDepth",
+        units="mag",
+        extinction_cut=1.0,
+        filter_col="band",
+        metric_name="QSONumberCountsMetric",
+        qlf_module="Shen20",
+        qlf_model="A",
+        sed_model="Richards06",
+        zmin=0.3,
+        zmax=None,
+        **kwargs,
+    ):
+        # Declare the effective wavelengths.
+        self.effwavelen = {
+            "u": 367.0,
+            "g": 482.5,
+            "r": 622.2,
+            "i": 754.5,
+            "z": 869.1,
+            "y": 971.0,
+        }
+
+        # Dust Extinction limit.
+        # Regions with larger extinction and dropped from the counting.
+        self.extinction_cut = extinction_cut
+
+        # Save the filter information.
+        self.filter_col = filter_col
+        self.lsst_filter = lsst_filter
+
+        # Save zmin and zmax, or set zmax to the default value.
+        # The default zmax is the lower number between 6.7 and the
+        # redshift at which the Lyman break (91.2nm) hits the
+        # effective wavelength of the filter.
+        # Note that this means that for i, z and y,
+        # the default value for zmax is 6.7
+        self.zmin = zmin
+        if zmax is None:
+            zmax = np.min([6.7, self.effwavelen[self.lsst_filter] / 91.2 - 1.0])
+        self.zmax = zmax
+
+        # This calculation uses the ExgalM5 metric. So declare that here.
+        self.exgal_m5 = ExgalM5(m5_col=m5_col, units=units, filter_col=filter_col)
+
+        # Save the input parameters that relate to the QLF model.
+        self.qlf_module = qlf_module
+        self.qlf_model = qlf_model
+        self.sed_model = sed_model
+
+        # Read the long tables, which the number of quasars expected
+        # for a given band, qlf_module and qlf_model in a range of
+        # redshifts and magnitudes.
+        table_name = "Long_Table.LSST{0}.{1}.{2}.{3}.txt".format(
+            self.lsst_filter, self.qlf_module, self.qlf_model, self.sed_model
+        )
+        data_dir = os.path.join(get_data_dir(), "maf", "quasarNumberCounts")
+        filename = os.path.join(data_dir, table_name)
+        with open(filename, "r") as f:
+            mags = np.array([float(x) for x in f.readline().split()])
+            zs = np.array([float(x) for x in f.readline().split()])
+        mz_data = np.loadtxt(filename, skiprows=2)
+
+        # Make the long table cumulative.
+        c_mz_data = np.zeros((mz_data.shape[0] + 1, mz_data.shape[1] + 1))
+        c_mz_data[1:, 1:] = mz_data
+        c_mz_data = np.cumsum(c_mz_data, axis=0)
+        c_mz_data = np.cumsum(c_mz_data, axis=1)
+
+        # Create a 2D interpolation object for the long table.
+        # self.nqso_cumulative = interpolate.interp2d(zs[:-1], mags[:-1],
+        # #c_mz_data[:-1, :-1], kind="cubic")
+        self.nqso_cumulative_aux = interpolate.RectBivariateSpline(
+            zs[:-1], mags[:-1], c_mz_data[:-1, :-1].T, kx=3, ky=3
+        )
+
+        self.nqso_cumulative = lambda z_new, m_new: self.nqso_cumulative_aux(z_new, m_new).T[0]
+
+        super().__init__(
+            col=[m5_col, filter_col, "saturation_mag"],
+            metric_name=metric_name,
+            maps=self.exgal_m5.maps,
+            units=units,
+            **kwargs,
+        )
+
+    def run(self, data_slice, slice_point=None):
+        # exclude areas with high extinction
+        if slice_point["ebv"] > self.extinction_cut:
+            return self.badval
+
+        # For the data_slice, get the 5 sigma limiting magnitude.
+        d_s = data_slice[data_slice[self.filter_col] == self.lsst_filter]
+        mlim5 = self.exgal_m5.run(d_s, slice_point)
+
+        # Get the slicer pixel area.
+        nside = slice_point["nside"]
+        pix_area = hp.nside2pixarea(nside, degrees=True)
+
+        # tranform that limiting magnitude into an expected number of quasars.
+        # If there is more than one, take the faintest.
+        m_bright = np.max(d_s["saturation_mag"])
+        n11 = self.nqso_cumulative(self.zmin, m_bright)
+        n12 = self.nqso_cumulative(self.zmin, mlim5)
+        n21 = self.nqso_cumulative(self.zmax, m_bright)
+        n22 = self.nqso_cumulative(self.zmax, mlim5)
+
+        nqso = (n22 - n21 - n12 + n11) * pix_area
+        return nqso

rubin_sim/maf/metrics/scaling_metrics.py

@@ -0,0 +1,148 @@
+__all__ = ("NgalScaleMetric", "NlcPointsMetric")
+
+import healpy as hp
+import numpy as np
+
+from rubin_sim.maf.maps import TrilegalDensityMap
+from rubin_sim.phot_utils import DustValues
+
+from .base_metric import BaseMetric
+
+
+class NgalScaleMetric(BaseMetric):
+    """Approximate number of galaxies, scaled by median seeing.
+
+    Parameters
+    ----------
+    a_max : `float`
+        The maximum dust extinction to allow. Anything with higher dust
+        extinction is considered to have zero usable galaxies.
+    m5min : `float`
+        The minimum coadded 5-sigma depth to allow. Anything less is
+        considered to have zero usable galaxies.
+    filter : `str`
+        The filter to use. Any visits in other filters are ignored.
+    """
+
+    def __init__(
+        self,
+        seeing_col="seeingFwhmEff",
+        m5_col="fiveSigmaDepth",
+        metric_name="NgalScale",
+        filtername="i",
+        a_max=0.2,
+        m5min=26.0,
+        filter_col="band",
+        **kwargs,
+    ):
+        maps = ["DustMap"]
+        units = "N gals"
+        self.seeing_col = seeing_col
+        self.m5_col = m5_col
+        self.filtername = filtername
+        self.filter_col = filter_col
+        self.a_max = a_max
+        self.m5min = m5min
+
+        super().__init__(
+            col=[self.m5_col, self.filter_col, self.seeing_col],
+            maps=maps,
+            units=units,
+            metric_name=metric_name,
+            **kwargs,
+        )
+        dust_properties = DustValues()
+        self.ax1 = dust_properties.ax1
+
+    def run(self, data_slice, slice_point):
+        # I'm a little confused why there's a dust cut and an M5 cut,
+        # but whatever
+        a_x = self.ax1[data_slice[self.filter_col][0]] * slice_point["ebv"]
+        if a_x > self.a_max:
+            return 0
+
+        in_filt = np.where(data_slice[self.filter_col] == self.filtername)
+        coadd_m5 = 1.25 * np.log10(np.sum(10.0 ** (0.8 * data_slice[self.m5_col][in_filt])))
+        if coadd_m5 < self.m5min:
+            return 0
+
+        theta = np.median(data_slice[self.seeing_col])
+        # N gals per arcmin2
+        ngal_per_arcmin2 = 57 * (0.75 / theta) ** 1.5
+
+        area = hp.nside2pixarea(slice_point["nside"], degrees=True) * 3600.0
+
+        ngal = ngal_per_arcmin2 * area
+        return ngal
+
+
+class NlcPointsMetric(BaseMetric):
+    """Number of points in stellar light curves
+
+    Parameters
+    ----------
+    ndpmin : `int`
+        The number of points to demand on a lightcurve in a single
+        filter to have that light curve qualify.
+    mags : `float`
+        The magnitude of our fiducial object (maybe make it a dict in the
+        future to support arbitrary colors).
+    maps : `list` [`~rubin_sim.maf.map`] or None
+        List of stellar density maps to use.
+        Default of None loads Trilegal maps.
+    nside : `int`
+        The nside is needed to make sure the loaded maps
+        match the slicer nside.
+    """
+
+    def __init__(
+        self,
+        ndpmin=10,
+        mags=21.0,
+        m5_col="fiveSigmaDepth",
+        filter_col="band",
+        metric_name="NlcPoints",
+        maps=None,
+        nside=128,
+        **kwargs,
+    ):
+        units = "N LC points"
+        self.ndpmin = ndpmin
+        self.mags = mags
+        self.m5_col = m5_col
+        self.filter_col = filter_col
+        self.nside = nside
+        if maps is None:
+            maps = [TrilegalDensityMap(filtername=fn, nside=nside) for fn in "ugrizy"]
+        super().__init__(
+            col=[self.m5_col, self.filter_col],
+            maps=maps,
+            units=units,
+            metric_name=metric_name,
+            **kwargs,
+        )
+
+    def run(self, data_slice, slice_point):
+        if self.nside != slice_point["nside"]:
+            raise ValueError("nside of metric does not match slicer")
+        pix_area = hp.nside2pixarea(slice_point["nside"], degrees=True)
+
+        nlcpoints = 0
+        # Let's do it per filter
+        for filtername in np.unique(data_slice[self.filter_col]):
+            in_filt = np.where(
+                (data_slice[self.filter_col] == filtername) & (data_slice[self.m5_col] > self.mags)
+            )[0]
+            n_obs = np.size(in_filt)
+            if n_obs > self.ndpmin:
+                nstars = (
+                    np.interp(
+                        self.mags,
+                        slice_point[f"starMapBins_{filtername}"][1:],
+                        slice_point[f"starLumFunc_{filtername}"],
+                    )
+                    * pix_area
+                )
+                nlcpoints += n_obs * nstars
+
+        return nlcpoints

rubin_sim/maf/metrics/schedview_metrics.py

@@ -0,0 +1,39 @@
+"""Metrics for scheduler monitoring and progress."""
+
+__all__ = ["AgeMetric"]
+
+import numpy as np
+
+from .base_metric import BaseMetric
+
+
+class AgeMetric(BaseMetric):
+    def __init__(
+        self, mjd, mjd_col="observationStartMJD", long_limit=30, metric_name="age", mask_val=np.nan, **kwargs
+    ):
+        """Metric that shows the time since the previous visit in each slice,
+        as of a given time
+
+        Parameters
+        ----------
+        mjd : `float`
+            Reference time for the age.
+        mjd_col : `str`
+            Column with the time of visit, by default "observationStartMJD"
+        long_limit : `int`
+            The age past which to mask values, by default 30
+        metric_name : `str`
+            The metric name, by default 'age'
+        mask_val : `object`
+            Name for masked values, by default np.nan
+        """
+        self.mjd = mjd
+        self.mjd_col = mjd_col
+        self.long_limit = long_limit
+        super().__init__(col=[self.mjd_col], metric_name=metric_name, mask_val=mask_val, **kwargs)
+
+    def run(self, data_slice, slice_point=None):
+        age = self.mjd - np.max(data_slice[self.mjd_col])
+        if age > self.long_limit:
+            age = self.mask_val
+        return age