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

rubin_sim/maf/maf_contrib/calculate_lsst_field_visibility_astropy.py

@@ -0,0 +1,170 @@
+"""
+Created on Tue Sep 18 13:35:41 2018
+
+@author: rstreet
+"""
+
+__all__ = ("calculate_lsst_field_visibility", "calculate_lsst_field_visibility_fast")
+
+
+import astropy.units as u
+import numpy as np
+from astropy.coordinates import AltAz, EarthLocation, SkyCoord, get_sun
+from astropy.time import Time, TimeDelta
+from rubin_scheduler.utils import Site, approx_ra_dec2_alt_az
+
+
+def calculate_lsst_field_visibility(
+    ra, dec, start_date, end_date, min_alt=30.0, sun_alt_limit=18.0, sample_rate=0.0007, verbose=False
+):
+    """Method to calculate the visibility of a given RA and Dec from LSST
+    over the course of a year
+
+    Adapted from an example in the Astropy docs.
+
+    Parameters
+    ----------
+    ra : `float`
+        RA in decimal degrees.
+    dec : `float`
+        Declination in decimal degrees
+    start_date : `astropy.time.Time`
+        Start date for calculations
+    end_date : `astropy.time.Time`
+        End date for calculations
+    min_alt : `float`, optional
+        Minimal altitude for field
+    sun_alt_limit : `float`, optional
+        Maximum sun altitude to consider for visibility
+    sample_rate : `float`, optional
+        Time spacing between visibility tests (days)
+    verbose : `bool`, optional
+        Output extra information, including debugging
+    """
+    field = SkyCoord(ra, dec, frame="icrs", unit=(u.deg, u.deg))
+
+    lsst_site = Site("LSST")
+    lsst = EarthLocation(
+        lat=lsst_site.latitude * u.deg,
+        lon=lsst_site.longitude * u.deg,
+        height=lsst_site.height * u.m,
+    )
+
+    total_time_visible = 0.0
+
+    dates = np.arange(start_date, end_date, TimeDelta(1, format="jd", scale="tai"))
+
+    target_alts = []
+    hrs_visible_per_night = []
+    hrs_per_night = []
+
+    for d in dates:
+        intervals = np.arange(0.0, 1.0, sample_rate)
+
+        dt = TimeDelta(intervals, format="jd", scale="tai")
+
+        ts = d + dt
+
+        frame = AltAz(obstime=ts, location=lsst)
+
+        altaz = field.transform_to(frame)
+
+        alts = np.array((altaz.alt * u.deg).value)
+
+        idx = np.where(alts >= min_alt)[0]
+
+        sun_altaz = get_sun(ts).transform_to(frame)
+
+        sun_alts = np.array((sun_altaz.alt * u.deg).value)
+
+        jdx = np.where(sun_alts < sun_alt_limit)[0]
+        # Hours available in the sun
+        hrs_per_night.append(sample_rate * len(sun_alts[jdx]) * 24.0)
+        # The indexes where sun down and target above min_alt
+        idx = list(set(idx).intersection(set(jdx)))
+        # The highest altitude for the target, when the sun is down
+        target_alts.append(alts[jdx].max())
+
+        if len(idx) > 0:
+            ts_vis = ts[idx]
+
+            tvis = sample_rate * len(ts_vis)
+
+            total_time_visible += tvis
+
+            if verbose:
+                print("Target visible from LSST for " + str(round(tvis * 24.0, 2)) + "hrs on " + d.isot)
+            # Hours of visibility of the target on this night
+            hrs_visible_per_night.append((tvis * 24.0))
+
+        else:
+            # target_alts.append(-1e5)
+            hrs_visible_per_night.append(0.0)
+
+            if verbose:
+                print("Target not visible from LSST on " + d.isot)
+
+    return np.array(total_time_visible), np.array(hrs_visible_per_night)
+
+
+def calculate_lsst_field_visibility_fast(
+    ra,
+    dec,
+    start_date,
+    end_date,
+    min_alt=30.0,
+    sun_alt_limit=18.0,
+    sample_rate=0.0007,
+):
+    """Method to calculate the visibility of a given RA and Dec from LSST
+    over the course of a year
+
+    Skips astropy calculation of alt/az which is slow and uses
+    approximate transform from rubin_scheduler.
+
+    Parameters
+    ----------
+    ra : `float`
+        RA in decimal degrees.
+    dec : `float`
+        Declination in decimal degrees
+    start_date : `astropy.time.Time`
+        Start date for calculations
+    end_date : `astropy.time.Time`
+        End date for calculations
+    min_alt : `float`, optional
+        Minimal altitude for field
+    sun_alt_limit : `float`, optional
+        Maximum sun altitude to consider for visibility
+    cadence : `float`, optional
+        Time spacing between visibility tests (days)
+
+    Returns
+    -------
+    tvisible : `float`
+        Total time target is visible (days)
+    dates_visible : `np.ndarray`, (N,)
+        Dates that target is above min_alt and sun is below sun_alt_limit,
+        within start_date to end_date.
+    """
+    lsst_site = Site("LSST")
+
+    dates = np.arange(start_date.mjd, end_date.mjd + sample_rate / 2.0, sample_rate)
+
+    alts, _ = approx_ra_dec2_alt_az(ra, dec, lsst_site.latitude, lsst_site.longitude, dates)
+    # where is the target above the minimum altitude
+    target_high = np.where(alts >= min_alt)[0]
+
+    # when is the sun above the sun_alt_limit
+    dates = dates[target_high]
+    sun_locs = get_sun(Time(dates, format="mjd", scale="utc"))
+    sun_alts, _ = approx_ra_dec2_alt_az(
+        sun_locs.ra.deg, sun_locs.dec.deg, lsst_site.latitude, lsst_site.longitude, dates
+    )
+    sun_low = np.where(sun_alts <= sun_alt_limit)[0]
+
+    dates = dates[sun_low]
+    # total amount of time target is visible, in days
+    tvisible = len(dates) * sample_rate
+
+    return tvisible, dates

rubin_sim/maf/maf_contrib/depth_limited_num_gal_metric.py

@@ -0,0 +1,109 @@
+import numpy as np
+
+import rubin_sim.maf.metrics as metrics
+from rubin_sim.maf.maf_contrib.lss_obs_strategy.galaxy_counts_metric_extended import (
+    GalaxyCountsMetricExtended as GalaxyCountsMetric,
+)
+
+
+class DepthLimitedNumGalMetric(metrics.BaseMetric):
+    """This metric calculates the number of galaxies while accounting for the
+    extragalactic footprint.
+
+    Parameters
+    ----------
+    m5_col : `str`, optional
+        Name of column for depth in the data. Default: 'fiveSigmaDepth'
+    filter_col : `str`, optional
+        Name of column for filter in the data. Default: 'filter'
+    maps : `list` [`str`], optional
+        List of map names. Default: ['DustMap']
+    nside : `int`, optional
+        HEALpix resolution parameter. Default: 256.
+        This should match slicer nside.
+    filter_band : `str`, optional
+        Filter to use to calculate galaxy counts.
+        Any one of 'u', 'g', 'r', 'i', 'z', 'y'. Default: 'i'
+    redshiftBin: `str`, optional
+        options include '0.<z<0.15', '0.15<z<0.37', '0.37<z<0.66, '0.66<z<1.0',
+        '1.0<z<1.5', '1.5<z<2.0', '2.0<z<2.5', '2.5<z<3.0','3.0<z<3.5',
+        '3.5<z<4.0', 'all' for no redshift restriction
+        (so consider 0.<z<4.0)
+        Default: 'all'
+    nfilters_needed : `int`, optional
+        Number of filters in which to require coverage. Default: 6
+    lim_mag_i_ptsrc : `float`, optional
+        Point-source limiting mag for the i-band coadded dust-corrected depth.
+        Default: 26.0
+    lim_ebv : `float`, optional
+        Limiting EBV value. Default: 0.2
+
+    Returns
+    -------
+    ngal : `float`
+        Number of galaxies in healpix if the slice_point passes the
+        extragalactic cuts; otherwise self.badval
+    """
+
+    def __init__(
+        self,
+        m5_col="fiveSigmaDepth",
+        filter_col="band",
+        nside=128,
+        filter_band="i",
+        redshift_bin="all",
+        nfilters_needed=6,
+        lim_mag_i_ptsrc=26.0,
+        lim_ebv=0.2,
+        metric_name="DepthLimitedNumGalaxiesMetric",
+        units="Galaxy Counts",
+        **kwargs,
+    ):
+        self.m5_col = m5_col
+        self.filter_col = filter_col
+        self.filter_band = filter_band
+        # set up the extended source limiting mag
+        # galaxies are x2 as seeing: seeing is generally 0.7arcsec
+        # and a typical galaxies is 1arcsec
+        # => for extended source limiting mag of x, we'd need x + 0.7
+        # as the point-source limiting mag;
+        # 0.7 comes from $\sqrt{1/2}$;
+        # basically have x2 difference in magnitudes between
+        # point source and extended source.
+        lim_mag_i_extsrc = lim_mag_i_ptsrc - 0.7
+        # set up the metric for galaxy counts
+        self.galmetric = GalaxyCountsMetric(
+            m5_col=self.m5_col,
+            nside=nside,
+            upper_mag_limit=lim_mag_i_extsrc,
+            include_dust_extinction=True,
+            filter_band=self.filter_band,
+            redshift_bin=redshift_bin,
+            cfht_ls_counts=False,
+            normalized_mock_catalog_counts=True,
+        )
+        # set up the metric for extragalactic footprint
+        self.eg_metric = metrics.ExgalM5WithCuts(
+            m5_col=self.m5_col,
+            filter_col=self.filter_col,
+            lsst_filter=self.filter_band,
+            n_filters=nfilters_needed,
+            extinction_cut=lim_ebv,
+            depth_cut=lim_mag_i_ptsrc,
+        )
+        maps = self.eg_metric.maps + self.galmetric.maps
+        maps = set(maps)
+        super().__init__(
+            col=[self.m5_col, self.filter_col], maps=maps, metric_name=metric_name, units=units, **kwargs
+        )
+
+    def run(self, data_slice, slice_point=None):
+        # see if this slice_point is in the extragalactic footprint
+        pass_egcuts = self.eg_metric.run(data_slice, slice_point=slice_point)
+
+        if pass_egcuts == self.badval:  # failed dust/depth cuts
+            return self.badval
+
+        # Otherwise, find the galaxy counts
+        in_filt = np.where(data_slice[self.filter_col] == self.filter_band)[0]
+        return self.galmetric.run(data_slice[in_filt], slice_point=slice_point)

rubin_sim/maf/maf_contrib/example_new_metrics.py

@@ -0,0 +1,40 @@
+# Example of a new metric added to the repo.
+# ljones@astro.washington.edu
+
+__all__ = ("NightsWithNFiltersMetric",)
+
+import numpy as np
+
+from rubin_sim.maf.metrics import BaseMetric
+
+
+class NightsWithNFiltersMetric(BaseMetric):
+    """Count how many times more than NFilters are used within the same night,
+    for this set of visits.
+
+    Parameters
+    ----------
+    n_filters : `int`, optional
+        How many filters to look for, within the same night.
+    """
+
+    def __init__(self, night_col="night", filter_col="filter", n_filters=3, **kwargs):
+        """
+        night_col = the name of the column defining the night
+        filter_col = the name of the column defining the filter
+        n_filters = the minimum desired set of filters used in these visits
+        """
+        self.night_col = night_col
+        self.filter_col = filter_col
+        self.n_filters = n_filters
+        super(NightsWithNFiltersMetric, self).__init__(col=[self.night_col, self.filter_col], **kwargs)
+
+    def run(self, data_slice, slice_point=None):
+        count = 0
+        unique_nights = np.unique(data_slice[self.night_col])
+        for n in unique_nights:
+            condition = data_slice[self.night_col] == n
+            unique_filters = np.unique(data_slice[self.filter_col][condition])
+            if len(unique_filters) > self.n_filters:
+                count += 1
+        return count

rubin_sim/maf/maf_contrib/filter_pair_t_gaps_metric.py

@@ -0,0 +1,208 @@
+__all__ = ("FilterPairTGapsMetric",)
+
+import numpy as np
+
+from ..metrics.base_metric import BaseMetric
+
+
+class FilterPairTGapsMetric(BaseMetric):
+    """Figure of merit to measure the coverage the time gaps in same
+    and different filter pairs;
+
+    FoM is defined as sum of Nv / standard deviation after a clip;
+
+    Parameters
+    ----------
+    fltpairs : `list` [`str`], optional
+        List of filter pair sets to search for.
+    mag_lim : `list` [`float`]
+        FiveSigmaDepth threshold each filter,
+        default {'u':18, 'g':18, 'r':18, 'i':18, 'z':18, 'y':18}
+    bins_same : `np.ndarray`, (N,)
+        Bins to get histogram for same-filter pair.
+    bins_diff : `np.ndarray`, (N,)
+        Bins to get histogram for diff-filter pair.
+    nv_clip : `int`, optional
+        Number of visits of pairs to clip, std is calculated below nv_clip.
+    allgaps : `bool``, optional
+        All possible pairs if True, else consider only nearest
+
+    Returns
+    -------
+    result : `float`
+        sum of fom for all filterpairs,
+    """
+
+    def __init__(
+        self,
+        mjd_col="observationStartMJD",
+        filter_col="filter",
+        m5_col="fiveSigmaDepth",
+        fltpairs=[
+            "uu",
+            "ug",
+            "ur",
+            "ui",
+            "uz",
+            "uy",
+            "gg",
+            "gr",
+            "gi",
+            "gz",
+            "gy",
+            "rr",
+            "ri",
+            "rz",
+            "ry",
+            "ii",
+            "iz",
+            "iy",
+            "zz",
+            "zy",
+            "yy",
+        ],
+        mag_lim={"u": 18, "g": 18, "r": 18, "i": 18, "z": 18, "y": 18},
+        bins_same=np.logspace(np.log10(5 / 60 / 60 / 24), np.log10(3650), 50),
+        bins_diff=np.logspace(np.log10(5 / 60 / 60 / 24), np.log10(2), 50),
+        nv_clip={
+            "uu": 30,
+            "ug": 30,
+            "ur": 30,
+            "ui": 30,
+            "uz": 30,
+            "uy": 30,
+            "gg": 69,
+            "gr": 30,
+            "gi": 30,
+            "gz": 30,
+            "gy": 30,
+            "rr": 344,
+            "ri": 30,
+            "rz": 30,
+            "ry": 30,
+            "ii": 355,
+            "iz": 30,
+            "iy": 30,
+            "zz": 282,
+            "zy": 30,
+            "yy": 288,
+        },
+        allgaps=True,
+        **kwargs,
+    ):
+        self.mjd_col = mjd_col
+        self.filter_col = filter_col
+        self.m5_col = m5_col
+        self.fltpairs = fltpairs
+        self.mag_lim = mag_lim
+        self.bins_same = bins_same
+        self.bins_diff = bins_diff
+
+        self.allgaps = allgaps
+
+        # number of visits to clip, default from 1/10th of baseline_v2.0 WFD
+        self.nv_clip = nv_clip
+
+        super().__init__(col=[self.mjd_col, self.filter_col, self.m5_col], **kwargs)
+
+    def _get_d_t(self, data_slice, f0, f1):
+        # select
+        idx0 = (data_slice[self.filter_col] == f0) & (data_slice[self.m5_col] > self.mag_lim[f0])
+        idx1 = (data_slice[self.filter_col] == f1) & (data_slice[self.m5_col] > self.mag_lim[f1])
+
+        time_col0 = data_slice[self.mjd_col][idx0]
+        time_col1 = data_slice[self.mjd_col][idx1]
+
+        # time_col0 = time_col0.reshape((len(time_col0), 1))
+        # time_col1 = time_col1.reshape((len(time_col1), 1))
+
+        # calculate time gaps matrix
+        # diffmat = np.subtract(time_col0, time_col1.T)
+
+        if self.allgaps:
+            # collect all time gaps
+            if f0 == f1:
+                time_col0 = time_col0.reshape((len(time_col0), 1))
+                time_col1 = time_col1.reshape((len(time_col1), 1))
+
+                diffmat = np.subtract(time_col0, time_col1.T)
+                diffmat = np.abs(diffmat)
+                # get only triangle part
+                dt_tri = np.tril(diffmat, -1)
+                d_t = dt_tri[dt_tri != 0]  # flatten lower triangle
+            else:
+                # d_t = diffmat.flatten()
+                dtmax = np.max(self.bins_diff)
+                # time gaps window for measure color
+                d_t = []
+                for time_col in time_col0:
+                    time_col_in_window = time_col1[
+                        (time_col1 >= (time_col - dtmax)) & (time_col1 <= (time_col + dtmax))
+                    ]
+
+                    d_t.append(np.abs(time_col_in_window - time_col))
+
+                d_t = np.concatenate(d_t) if len(d_t) > 0 else np.array(d_t)
+        else:
+            # collect only nearest
+            if f0 == f1:
+                # get diagonal ones nearest nonzero, offset=1
+                # d_t = np.diagonal(diffmat, offset=1)
+                d_t = np.diff(time_col0)
+            else:
+                time_col0 = data_slice[self.mjd_col][idx0]
+                time_col1 = data_slice[self.mjd_col][idx1]
+
+                time_col0 = time_col0.reshape((len(time_col0), 1))
+                time_col1 = time_col1.reshape((len(time_col1), 1))
+
+                # calculate time gaps matrix
+                diffmat = np.subtract(time_col0, time_col1.T)
+                # get tgaps both left and right
+                # keep only negative ones
+                masked_ar = np.ma.masked_where(
+                    diffmat >= 0,
+                    diffmat,
+                )
+                left_ar = np.max(masked_ar, axis=1)
+                d_t_left = -left_ar.data[~left_ar.mask]
+
+                # keep only positive ones
+                masked_ar = np.ma.masked_where(diffmat <= 0, diffmat)
+                right_ar = np.min(masked_ar, axis=1)
+                d_t_right = right_ar.data[~right_ar.mask]
+
+                d_t = np.concatenate([d_t_left.flatten(), d_t_right.flatten()])
+
+        return d_t
+
+    def run(self, data_slice, slice_point=None):
+        # sort the data_slice in order of time.
+        data_slice.sort(order=self.mjd_col)
+
+        fom_dic = {}
+        d_t_dic = {}
+        for fltpair in self.fltpairs:
+            d_t = self._get_d_t(data_slice, fltpair[0], fltpair[1])
+            # calculate FoM
+            # cut out at average
+            # std below
+            # FOM = Nv / std
+
+            if fltpair[0] == fltpair[1]:
+                bins = self.bins_same
+            else:
+                bins = self.bins_diff
+                d_t_dic[fltpair] = d_t
+
+            hist, _ = np.histogram(d_t, bins=bins)
+
+            if np.any(hist):
+                hist_clip = np.clip(hist, a_min=0, a_max=self.nv_clip[fltpair])
+                fom = hist.sum() / hist_clip.std()
+            else:
+                fom = np.nan
+            fom_dic[fltpair] = fom
+            # print( fltpair, fom)
+
+        return np.nansum(list(fom_dic.values()))