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

rubin_sim/phot_utils/spectral_resampling.py

@@ -0,0 +1,161 @@
+__all__ = ("spectres",)
+
+import warnings
+
+import numpy as np
+
+# Taken from https://github.com/ACCarnall/SpectRes
+# (which is under GPL 3), cite https://arxiv.org/abs/1705.05165
+
+
+def make_bins(wavs):
+    """Given a series of wavelength points, find the edges and widths
+    of corresponding wavelength bins."""
+    edges = np.zeros(wavs.shape[0] + 1)
+    widths = np.zeros(wavs.shape[0])
+    edges[0] = wavs[0] - (wavs[1] - wavs[0]) / 2
+    widths[-1] = wavs[-1] - wavs[-2]
+    edges[-1] = wavs[-1] + (wavs[-1] - wavs[-2]) / 2
+    edges[1:-1] = (wavs[1:] + wavs[:-1]) / 2
+    widths[:-1] = edges[1:-1] - edges[:-2]
+
+    return edges, widths
+
+
+def spectres(new_wavs, spec_wavs, spec_fluxes, spec_errs=None, fill=0, verbose=True):
+    """
+    Function for resampling spectra (and optionally associated
+    uncertainties) onto a new wavelength basis.
+
+    If performance is an issue, https://github.com/ACCarnall/SpectRes
+    includes a version that is wrapped in numba and should be much faster.
+
+    Parameters
+    ----------
+
+    new_wavs : numpy.ndarray
+        Array containing the new wavelength sampling desired for the
+        spectrum or spectra.
+
+    spec_wavs : numpy.ndarray
+        1D array containing the current wavelength sampling of the
+        spectrum or spectra.
+
+    spec_fluxes : numpy.ndarray
+        Array containing spectral fluxes at the wavelengths specified in
+        spec_wavs, last dimension must correspond to the shape of
+        spec_wavs. Extra dimensions before this may be used to include
+        multiple spectra.
+
+    spec_errs : numpy.ndarray (optional)
+        Array of the same shape as spec_fluxes containing uncertainties
+        associated with each spectral flux value.
+
+    fill : float (optional)
+        Where new_wavs extends outside the wavelength range in spec_wavs
+        this value will be used as a filler in new_fluxes and new_errs.
+
+    verbose : bool (optional)
+        Setting verbose to False will suppress the default warning about
+        new_wavs extending outside spec_wavs and "fill" being used.
+
+    Returns
+    -------
+
+    new_fluxes : numpy.ndarray
+        Array of resampled flux values, last dimension is the same
+        length as new_wavs, other dimensions are the same as
+        spec_fluxes.
+
+    new_errs : numpy.ndarray
+        Array of uncertainties associated with fluxes in new_fluxes.
+        Only returned if spec_errs was specified.
+    """
+
+    # Rename the input variables for clarity within the function.
+    old_wavs = spec_wavs
+    old_fluxes = spec_fluxes
+    old_errs = spec_errs
+
+    # Make arrays of edge positions and widths for the old and new bins
+
+    old_edges, old_widths = make_bins(old_wavs)
+    new_edges, new_widths = make_bins(new_wavs)
+
+    # Generate output arrays to be populated
+    new_fluxes = np.zeros(old_fluxes[..., 0].shape + new_wavs.shape)
+
+    if old_errs is not None:
+        if old_errs.shape != old_fluxes.shape:
+            raise ValueError("If specified, spec_errs must be the same shape " "as spec_fluxes.")
+        else:
+            new_errs = np.copy(new_fluxes)
+
+    start = 0
+    stop = 0
+
+    # Calculate new flux and uncertainty values, looping over new bins
+    for j in range(new_wavs.shape[0]):
+
+        # Add filler values if new_wavs extends outside of spec_wavs
+        if (new_edges[j] < old_edges[0]) or (new_edges[j + 1] > old_edges[-1]):
+            new_fluxes[..., j] = fill
+
+            if spec_errs is not None:
+                new_errs[..., j] = fill
+
+            if (j == 0 or j == new_wavs.shape[0] - 1) and verbose:
+                warnings.warn(
+                    "Spectres: new_wavs contains values outside the range "
+                    "in spec_wavs, new_fluxes and new_errs will be filled "
+                    "with the value set in the 'fill' keyword argument "
+                    "(by default 0).",
+                    category=RuntimeWarning,
+                )
+            continue
+
+        # Find first old bin which is partially covered by the new bin
+        while old_edges[start + 1] <= new_edges[j]:
+            start += 1
+
+        # Find last old bin which is partially covered by the new bin
+        while old_edges[stop + 1] < new_edges[j + 1]:
+            stop += 1
+
+        # If new bin is fully inside an old bin start and stop are equal
+        if stop == start:
+            new_fluxes[..., j] = old_fluxes[..., start]
+            if old_errs is not None:
+                new_errs[..., j] = old_errs[..., start]
+
+        # Otherwise multiply the first and last old bin widths by P_ij
+        else:
+            start_factor = (old_edges[start + 1] - new_edges[j]) / (old_edges[start + 1] - old_edges[start])
+
+            end_factor = (new_edges[j + 1] - old_edges[stop]) / (old_edges[stop + 1] - old_edges[stop])
+
+            old_widths[start] *= start_factor
+            old_widths[stop] *= end_factor
+
+            # Populate new_fluxes spectrum and uncertainty arrays
+            f_widths = old_widths[start : stop + 1] * old_fluxes[..., start : stop + 1]
+            new_fluxes[..., j] = np.sum(f_widths, axis=-1)
+            new_fluxes[..., j] /= np.sum(old_widths[start : stop + 1])
+
+            if old_errs is not None:
+                e_wid = old_widths[start : stop + 1] * old_errs[..., start : stop + 1]
+
+                new_errs[..., j] = np.sqrt(np.sum(e_wid**2, axis=-1))
+                new_errs[..., j] /= np.sum(old_widths[start : stop + 1])
+
+            # Put back the old bin widths to their initial values
+            old_widths[start] /= start_factor
+            old_widths[stop] /= end_factor
+
+    # If errors were supplied return both new_fluxes and new_errs.
+    if old_errs is not None:
+        return new_fluxes, new_errs
+
+    # Otherwise just return the new_fluxes spectrum array
+    else:
+        return new_fluxes

rubin_sim/satellite_constellations/__init__.py

@@ -0,0 +1,3 @@
+from .basis_function import *
+from .model_observatory import *
+from .sat_utils import *

rubin_sim/satellite_constellations/basis_function.py

@@ -0,0 +1,40 @@
+__all__ = ("SatelliteAvoidBasisFunction",)
+
+import healpy as hp
+import numpy as np
+import rubin_scheduler.scheduler.basis_functions as bf
+
+
+class SatelliteAvoidBasisFunction(bf.BaseBasisFunction):
+    """Uses satellite position information from the Conditions object
+    and then avoids streaks.
+
+    Parameters
+    ----------
+    forecast_time : `float`
+        The time ahead to forecast satellite streaks (minutes).
+    smooth_fwhm : `float`
+        The smoothing full width half max to use (degrees)
+    """
+
+    def __init__(self, nside=32, forecast_time=90.0, smooth_fwhm=3.5):
+        super().__init__(nside=nside)
+        self.forecast_time = forecast_time / 60.0 / 24  # To days
+        self.smooth_fwhm = np.radians(smooth_fwhm)
+
+    def _calc_value(self, conditions, indx=None):
+        result = 0
+        # find the indices that are relevant
+        indx_min = np.min(np.searchsorted(conditions.satellite_mjds, conditions.mjd))
+        indx_max = np.max(np.searchsorted(conditions.satellite_mjds, conditions.mjd + self.forecast_time))
+
+        if indx_max > indx_min:
+            result = np.sum(conditions.satellite_maps[indx_min:indx_max], axis=0)
+            result = hp.smoothing(result, fwhm=self.smooth_fwhm)
+            result = hp.ud_grade(result, self.nside)
+            result[np.where(result < 0)] = 0
+            # Make it negative, so positive weights will result
+            # in avoiding satellites
+            result *= -1
+
+        return result

rubin_sim/satellite_constellations/model_observatory.py

@@ -0,0 +1,157 @@
+__all__ = ("ModelObservatory",)
+
+import numpy as np
+from rubin_scheduler.scheduler.model_observatory import ModelObservatory as oMO
+from rubin_scheduler.site_models import Almanac
+from rubin_scheduler.utils import SURVEY_START_MJD, _healbin
+
+# Take the model observatory from the scheduler and
+# subclass to expand to include satellite constellations
+
+
+class ModelObservatory(oMO):
+    """A class to generate a realistic telemetry stream for the scheduler
+
+    Parameters
+    ----------
+    nside : `int`
+        The healpix nside resolution
+    mjd_start : `float`
+        The MJD to start the observatory up at.
+        Uses util to lookup default if None.
+    alt_min : `float`
+        The minimum altitude to compute models at (degrees).
+    lax_dome : `bool`
+        Passed to observatory model. If true, allows dome creep.
+    cloud_limit : `float`
+        The limit to stop taking observations if the cloud model
+        returns something equal or higher
+    sim_to_o : `sim_targetoO`
+        If one would like to inject simulated ToOs into the telemetry stream.
+    seeing_db : `str`
+        If one would like to use an alternate seeing database,
+        filename of sqlite file
+    park_after : `float`
+        Park the telescope after a gap longer than park_after (minutes)
+    init_load_length : `int`
+        The length of pre-scheduled sky brighntess to load initially (days).
+    alt_limit : `float`
+        Altitude limit for considering satellite streaks (degrees).
+    satellite_dt : `float`
+        The time step to use for computing satellite positions (seconds).
+    sat_nside : `int`
+        The HEALpix nside to use for satellite streak maps.
+    constellation : `rubin_sim.satellite_constellations.Constellation`
+        The satellite constellation to use.
+    """
+
+    def __init__(
+        self,
+        nside=None,
+        mjd_start=SURVEY_START_MJD,
+        seed=42,
+        alt_min=5.0,
+        lax_dome=True,
+        cloud_limit=0.3,
+        sim_to_o=None,
+        seeing_db=None,
+        park_after=10.0,
+        init_load_length=10,
+        sat_nside=64,
+        satellite_dt=10.0,
+        constellation=None,
+        alt_limit=20.0,
+    ):
+        # Add in the new satellite information
+        self.alt_limit = np.radians(alt_limit)
+        self.satelite_dt = satellite_dt / 3600.0 / 24.0  # Seconds to days
+        self.sat_nside = sat_nside
+        self.constellation = constellation
+
+        # Need to do a little fiddle with the MJD since
+        # self.mjd needs self.night set now.
+        self.mjd_start = mjd_start
+
+        self.almanac = Almanac(mjd_start=self.mjd_start)
+        self.night = -1
+
+        # Run the rest of the regular __init__ steps
+        super().__init__(
+            nside=None,
+            mjd_start=self.mjd_start,
+            seed=seed,
+            alt_min=alt_min,
+            lax_dome=lax_dome,
+            cloud_limit=cloud_limit,
+            sim_to_o=sim_to_o,
+            seeing_db=seeing_db,
+            park_after=park_after,
+            init_load_length=init_load_length,
+        )
+
+    def return_conditions(self):
+        """
+        Returns
+        -------
+        conditions: `rubin_sim.scheduler.features.conditions`
+            Current conditions as simulated by the ModelObservatory.
+        """
+
+        # Spot to put in satellite streak prediction maps
+        self.conditions.satellite_mjds = self.sat_mjds
+        self.conditions.satellite_maps = self.satellite_maps
+
+        # Run the regular return conditions
+        super().return_conditions()
+        # I guess running super() means return statement gets skipped?
+        return self.conditions
+
+    @property
+    def mjd(self):
+        return self._mjd
+
+    @mjd.setter
+    def mjd(self, value):
+        self._mjd = value
+        self.almanac_indx = self.almanac.mjd_indx(value)
+        # Update night if needed
+        if self.almanac.sunsets["night"][self.almanac_indx] != self.night:
+            self.night = self.almanac.sunsets["night"][self.almanac_indx]
+            # Update the satellite prediction map for the night
+            self._update_satellite_maps()
+
+    def _update_satellite_maps(self):
+        """Make the satellite prediction maps for the night.
+
+        Will set self.sat_mjds and self.satellite_maps that can then
+        be attached to a conditions object in self.return_conditions
+        """
+        sunset = self.almanac.sunsets["sun_n12_setting"][self.almanac_indx]
+        sunrise = self.almanac.sunsets["sun_n12_rising"][self.almanac_indx]
+
+        self.sat_mjds = np.arange(sunset, sunrise, self.satelite_dt)
+
+        # Compute RA and decs for when sun is down
+        ras, decs, alts, illums = self.constellation.paths_array(self.sat_mjds)
+
+        below_limit = np.where(alts < self.alt_limit)
+
+        weights = np.zeros(ras.shape, dtype=int)
+        weights[illums] = 1
+        weights[below_limit] = 0
+
+        satellite_maps = []
+        for i, mjd in enumerate(self.sat_mjds):
+            spot_map = _healbin(
+                ras[:, i][illums[:, i]],
+                decs[:, i][illums[:, i]],
+                weights[:, i][illums[:, i]],
+                self.sat_nside,
+                reduce_func=np.sum,
+                dtype=int,
+                fill_val=0,
+            )
+
+            satellite_maps.append(spot_map)
+
+        self.satellite_maps = np.vstack(satellite_maps)