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

rubin_sim/selfcal/offsets.py

@@ -0,0 +1,119 @@
+__all__ = ["NoOffset", "OffsetSNR", "BaseOffset"]
+
+import numpy as np
+
+from ..maf.utils.astrometry_utils import m52snr
+
+# from lsst.sims.selfcal.clouds.Arma import ArmaSf, Clouds
+
+
+class BaseOffset:
+    """Base class for how to make offset classes"""
+
+    def __init__(self, **kwargs):
+        self.newkey = "dmag_keyname"
+        pass
+
+    def __call__(self, stars, visit, **kwargs):
+        pass
+
+
+class NoOffset(BaseOffset):
+    def __init__(self):
+        """Make no changes to the mags"""
+        self.newkey = "dmag_zero"
+
+    def __call__(self, stars, visits, **kwargs):
+        dmag = np.zeros(stars.size, dtype=list(zip([self.newkey], [float])))
+        return dmag
+
+
+class OffsetSys(BaseOffset):
+    def __init__(self, error_sys=0.003):
+        """Systematic error floor for photometry"""
+        self.error_sys = error_sys
+        self.newkey = "dmag_sys"
+
+    def __call__(self, stars, visits, **kwargs):
+        nstars = np.size(stars)
+        dmag = np.random.randn(nstars) * self.error_sys
+        return dmag
+
+
+class OffsetClouds(BaseOffset):
+    """Offset based on cloud structure.
+    Not used, as not fully implemented in this version (ArmaSf).
+    """
+
+    def __init__(self, sampling=256, fov=3.5):
+        self.fov = fov
+        self.newkey = "dmag_cloud"
+        # self.SF = ArmaSf()
+        self.SF = None
+        # self.cloud = Clouds()
+        self.cloud = None
+
+    def __call__(self, stars, visits, **kwargs):
+        # XXX-Double check extinction is close to the Opsim transparency
+        extinc_mags = visits["transparency"]
+        if extinc_mags != 0.0:
+            sf_theta, sf_sf = self.SF.CloudSf(500.0, 300.0, 5.0, extinc_mags, 0.55)
+            # Call the Clouds
+            self.cloud.makeCloudImage(sf_theta, sf_sf, extinc_mags, fov=self.fov)
+            # Interpolate clouds to correct position.
+            # Nearest neighbor for speed?
+            nim = self.cloud.cloudimage[0, :].size
+            # calc position in cloud image of each star
+            starx_interp = (np.degrees(stars["x"]) + self.fov / 2.0) * 3600.0 / self.cloud.pixscale
+            stary_interp = (np.degrees(stars["y"]) + self.fov / 2.0) * 3600.0 / self.cloud.pixscale
+
+            # Round off position and make it an int
+            starx_interp = np.round(starx_interp).astype(int)
+            stary_interp = np.round(stary_interp).astype(int)
+
+            # Handle any stars that are out of the field for some reason
+            starx_interp[np.where(starx_interp < 0)] = 0
+            starx_interp[np.where(starx_interp > nim - 1)] = nim - 1
+            stary_interp[np.where(stary_interp < 0)] = 0
+            stary_interp[np.where(stary_interp > nim - 1)] = nim - 1
+
+            dmag = self.cloud.cloudimage[starx_interp, stary_interp]
+        else:
+            dmag = np.zeros(stars.size)
+        return dmag
+
+
+class OffsetSNR(BaseOffset):
+    """Generate offsets based on the 5-sigma limiting depth of an observation
+    and the brightness of the star.
+
+    Note that this takes into account previous offsets that have been applied
+    (so run this after things like vignetting).
+    """
+
+    def __init__(self, lsst_filter="r"):
+        self.lsst_filter = lsst_filter
+        self.newkey = "dmag_snr"
+
+    def calc_mag_errors(self, magnitudes, m5, err_only=False):
+        """ """
+        snr = m52snr(magnitudes, m5)
+        # via good old https://www.eso.org/~ohainaut/ccd/sn.html
+        magnitude_errors = 2.5 * np.log10(1.0 + 1.0 / snr)
+        if err_only:
+            dmag = magnitude_errors
+        else:
+            dmag = np.random.randn(len(magnitudes)) * magnitude_errors
+        return dmag
+
+    def __call__(self, stars, visit, dmags=None):
+        if dmags is None:
+            dmags = {}
+        temp_mag = stars[self.lsst_filter + "mag"].copy()
+        # calc what magnitude the star has when it hits the silicon.
+        # Thus we compute the SNR noise
+        # AFTER things like cloud extinction and vignetting.
+        for key in list(dmags.keys()):
+            temp_mag = temp_mag + dmags[key]
+        dmag = self.calc_mag_errors(temp_mag, visit["fiveSigmaDepth"])
+        return dmag

rubin_sim/selfcal/solver.py

@@ -0,0 +1,143 @@
+__all__ = ("LsqrSolver",)
+
+import numpy as np
+from scipy.sparse import coo_matrix
+from scipy.sparse.linalg import lsqr
+
+# Modified from /astro/store/scratch/tmp/yoachim/Research/LSST/Parallel_Solver
+# and then from https://github.com/lsst-sims/legacy_sims_selfcal
+
+
+class LsqrSolver:
+    """
+    Class to solve self-calibration
+
+    Parameters
+    ----------
+    observations : `np.array`
+        A numpy array of the observations.
+        Should have columns id, patch_id, observed_mag, mag_uncert.
+    atol : `float`
+        Tolerance passed to lsqr.
+    btol : `float`
+        Tolerance passed to lsqr.
+    iter_lim : `int`
+        Iteration limit passed to lsqr.
+    show : `bool`
+        Should the lsqr solver print some iteration logs (False).
+    """
+
+    def __init__(
+        self,
+        observations,
+        atol=1e-8,
+        btol=1e-8,
+        iter_lim=None,
+        show=False,
+    ):
+        self.atol = atol
+        self.btol = btol
+        self.iter_lim = iter_lim
+        self.observations = observations
+        self.show = show
+
+    def run(self):
+        """clean data, solve matrix, write solution out."""
+        self.clean_data()
+        self.solve_matrix()
+
+    def clean_data(self):
+        """
+        Remove observations that can't contribute to a solution.
+        Index remaining stars and patches so they are continuous.
+        """
+        n_start = 1.0
+        n_end = 0.0
+        while n_start != n_end:
+            n_start = self.observations.size
+            self.observations.sort(order="id")
+            # Remove observations if the star was only observed once
+            good = np.where(
+                (self.observations["id"] - np.roll(self.observations["id"], 1))
+                * (self.observations["id"] - np.roll(self.observations["id"], -1))
+                == 0
+            )
+            self.observations = self.observations[good]
+
+            # Remove patches with only one star
+            self.observations.sort(order="patch_id")
+
+            good = np.where(
+                (self.observations["patch_id"] - np.roll(self.observations["patch_id"], 1))
+                * (self.observations["patch_id"] - np.roll(self.observations["patch_id"], -1))
+                == 0
+            )
+            self.observations = self.observations[good]
+            n_end = self.observations.size
+
+        self.observations.sort(order="patch_id")
+
+        self.patches = np.unique(self.observations["patch_id"])
+        n_patches = np.size(self.patches)
+        self.n_patches = n_patches
+        self.n_patches = n_patches
+        patches_index = np.arange(n_patches)
+        left = np.searchsorted(self.observations["patch_id"], self.patches)
+        right = np.searchsorted(self.observations["patch_id"], self.patches, side="right")
+        for i in range(np.size(left)):
+            self.observations["patch_id"][left[i] : right[i]] = patches_index[i]
+
+        # Convert id to continuous running index to keep matrix
+        # as small as possible
+        self.observations.sort(order="id")
+
+        self.stars = np.unique(self.observations["id"])
+        n_stars = np.size(self.stars)
+        self.n_stars = np.size(self.stars)
+        stars_index = np.arange(1, n_stars + 1)
+        left = np.searchsorted(self.observations["id"], self.stars)
+        right = np.searchsorted(self.observations["id"], self.stars, side="right")
+        for i in range(np.size(left)):
+            self.observations["id"][left[i] : right[i]] = stars_index[i]
+
+    def solve_matrix(self):
+        n_obs = np.size(self.observations)
+        # construct sparse matrix
+        # A = lil_matrix((nPatches+nStars,np.size(observations['patch_id'])))
+        row = np.arange(n_obs)
+        row = np.append(row, row)
+        col = np.append(
+            self.observations["patch_id"],
+            self.observations["id"] + np.max(self.observations["patch_id"]),
+        )
+        # data = np.append(np.ones(nObs),1./observations['mag_uncert'])
+        data = 1.0 / self.observations["mag_uncert"]
+        data = np.append(data, data)
+        # maybe do this in place earlier?
+        # then just delete parts of observations earlier to save total memory
+        b = self.observations["observed_mag"] / self.observations["mag_uncert"]
+
+        # blast away data now that we have the matrix constructed
+        del self.observations
+
+        A = coo_matrix((data, (row, col)), shape=(n_obs, self.n_patches + self.n_stars))
+        A = A.tocsr()
+        # solve Ax = b
+        self.solution = lsqr(A, b, show=self.show, atol=self.atol, btol=self.btol, iter_lim=self.iter_lim)
+
+    def return_solution(self):
+        """
+        Returns
+        -------
+        patches, stars: `np.array`, `np.array`
+            Two arrays containing patch zeropoints and star best-fit mags.
+        """
+        patches = np.empty(self.patches.size, dtype=list(zip(["patch_id", "zp"], [int, float])))
+        patches["patch_id"] = self.patches
+        patches["zp"] = self.solution[0][0 : self.n_patches]
+
+        stars = np.empty(self.stars.size, dtype=list(zip(["id", "fit_mag"], [int, float])))
+        stars["id"] = self.stars  # should match the input ID.
+        stars["fit_mag"] = self.solution[0][self.n_patches :]
+
+        return patches, stars

rubin_sim/selfcal/star_tools.py

@@ -0,0 +1,42 @@
+__all__ = ("stars_project", "assign_patches")
+
+import numpy as np
+from rubin_scheduler.utils import gnomonic_project_toxy
+
+
+def stars_project(stars, visit):
+    """
+    Project the stars to x,y plane for a given visit.
+    """
+    xtemp, ytemp = gnomonic_project_toxy(
+        np.radians(stars["ra"]),
+        np.radians(stars["decl"]),
+        np.radians(visit["ra"]),
+        np.radians(visit["dec"]),
+    )
+    # Rotate the field using the visit rotSkyPos.
+    # Hope I got that sign right...
+    sin_rot = np.sin(np.radians(visit["rotSkyPos"]))
+    cos_rot = np.cos(np.radians(visit["rotSkyPos"]))
+    stars["x"] = cos_rot * xtemp + sin_rot * ytemp
+    stars["y"] = -1.0 * sin_rot * xtemp + cos_rot * ytemp
+
+    stars["radius"] = (stars["x"] ** 2 + stars["y"] ** 2) ** 0.5
+    return stars
+
+
+def assign_patches(stars, visit, n_patches=16, radius_fov=1.8):
+    """
+    Assign PatchIDs to everything.
+    Assume that stars have already been projected to x,y
+    """
+    maxx, maxy = gnomonic_project_toxy(0.0, np.radians(radius_fov), 0.0, 0.0)
+    nsides = n_patches**0.5
+
+    # This should move all coords to  0 < x < nsides-1
+    px = np.floor((stars["x"] + maxy) / (2.0 * maxy) * nsides)
+    py = np.floor((stars["y"] + maxy) / (2.0 * maxy) * nsides)
+
+    stars["sub_patch"] = px + py * nsides
+    stars["patch_id"] = stars["sub_patch"] + visit["observationId"] * n_patches
+    return stars

rubin_sim/sim_archive/__init__.py

@@ -0,0 +1,14 @@
+import importlib.util
+import logging
+
+from .make_snapshot import *
+
+HAVE_LSST_RESOURCES = importlib.util.find_spec("lsst") and importlib.util.find_spec("lsst.resources")
+if HAVE_LSST_RESOURCES:
+    from .sim_archive import *  # isort:skip
+    from .prenight import *
+    from .prenightindex import *
+    from .vseqarchive import *
+    from .vseqmetadata import *
+else:
+    logging.error("rubin_sim.sim_archive requires lsst.resources.")

rubin_sim/sim_archive/conda_packages.py

@@ -0,0 +1,65 @@
+import json
+import os
+import re
+import sys
+from functools import lru_cache
+
+__all__ = [
+    "get_conda_packages",
+]
+
+
+@lru_cache(maxsize=1)
+def get_conda_packages() -> dict[str, str]:
+    """Get products and their versions from the conda environment.
+
+    Returns
+    -------
+    packages : `dict`
+        Keys (type `str`) are product names; values (type `str`) are their
+        versions.
+
+    Notes
+    -----
+    Returns empty result if a conda environment is not in use or can not
+    be queried.
+    """
+    if "CONDA_PREFIX" not in os.environ:
+        return {}
+
+    # conda list is very slow. Ten times faster to scan the directory
+    # directly. This will only find conda packages and not pip installed
+    # packages.
+    meta_path = os.path.join(os.environ["CONDA_PREFIX"], "conda-meta")
+
+    try:
+        filenames = os.scandir(path=meta_path)
+    except FileNotFoundError:
+        return {}
+
+    packages = {}
+    for filename in filenames:
+        if not filename.name.endswith(".json"):
+            continue
+        with open(filename) as f:
+            try:
+                data = json.load(f)
+            except ValueError:
+                continue
+            try:
+                packages[data["name"]] = data["version"]
+            except KeyError:
+                continue
+
+    packages = dict(sorted(packages.items()))
+
+    # Try to work out the conda environment name and include it as a fake
+    # package. The "obvious" way of running "conda info --json" does give
+    # access to the active_prefix but takes about 2 seconds to run.
+    # As a compromise look for the env name in the path to the python
+    # executable
+    match = re.search(r"/envs/(.*?)/bin/", sys.executable)
+    if match:
+        packages["conda_env"] = match.group(1)
+
+    return packages