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

rubin_sim/maf/maf_contrib/young_stellar_objects_metric.py

@@ -0,0 +1,200 @@
+"""Young Stellar Objects metric.
+Converted from notebook 211116_yso_3D_90b.ipynb.
+Formatted with black."""
+
+__all__ = ("NYoungStarsMetric",)
+
+import healpy as hp
+import numpy as np
+import scipy.integrate as integrate
+
+from rubin_sim.maf.maps import DustMap, DustMap3D, StellarDensityMap
+from rubin_sim.maf.metrics.base_metric import BaseMetric
+from rubin_sim.maf.metrics.crowding_metric import CrowdingM5Metric
+from rubin_sim.phot_utils import DustValues
+
+
+class StarDensity:
+    """integrate from zero to some max distance, then multiply by angular area
+
+    Parameters
+    ----------
+    l : float
+        Galactic longitude, radians
+    b : float
+        Galactic latitude, radians
+    """
+
+    def __init__(self, gall, galb):
+        """Calculate the expected number of stars along a line of site"""
+        self.r_thin = 2.6  # scale length of the thin disk, kpc
+        self.d_gc = 8.178  # Distance to the galactic center, kpc
+        self.h_thin = 0.300  # scale height of the thin disk, kpc
+
+        self.gall = gall
+        self.galb = galb
+
+        self.A = 0.8e8 / (4.0 * np.pi * self.h_thin * self.r_thin**2)
+
+    def __call__(self, r):
+        """
+        Parameters
+        ----------
+        r : float
+            Distance in kpc
+        """
+        r_galac = ((self.d_gc - r * np.cos(self.gall)) ** 2 + (r * np.sin(self.gall)) ** 2) ** 0.5
+
+        exponent = -1.0 * r * np.abs(np.sin(self.galb)) / self.h_thin - r_galac / self.r_thin
+
+        result = self.A * r**2 * np.exp(exponent)
+        return result
+
+
+class NYoungStarsMetric(BaseMetric):
+    """Calculate the distance or number of stars with
+    color uncertainty defined by mags/snrs.
+
+    Parameters
+    ----------
+    metric_name : `str`, opt
+        Default 'young_stars'.
+    m5_col : `str`, opt
+        The default column name for m5 information in the input data.
+        Default fiveSigmaDepth.
+    filter_col : `str`, opt
+        The column name for the filter information. Default filter.
+    mags : `dict`, opt
+        The absolute magnitude of the object in question.
+        Keys of filter name, values in mags.
+        Default is for a 0.3 solar mass star at age = 100 Myr.
+    snrs : `dict`, opt
+        The SNR to demand for each filter.
+    galb_limit : `float`, opt
+        The galactic latitude above which to return zero (degrees).
+        Default 90.
+    badval : `float`, opt
+        The value to return when the metric value cannot be calculated.
+        Default 0.
+    return_distance : `bool`, opt
+        Whether the metric will return the maximum distance that
+        can be reached for each slice_point,
+        or the total number of stars down to mags/snrs.
+    crowding_error : `float`, opt
+        Crowding error that gets passed to CrowdingM5Metric. Default 0.25.
+    use_2D_extinction : `bool`, opt
+        Uses the 2D extinction map instead of the 3D one. Default False.
+    """
+
+    def __init__(
+        self,
+        metric_name="young_stars",
+        m5_col="fiveSigmaDepth",
+        filter_col="band",
+        seeing_col="seeingFwhmGeom",
+        mags={"g": 10.32, "r": 9.28, "i": 7.97},
+        snrs={"g": 5.0, "r": 5.0, "i": 5.0},
+        galb_limit=90.0,
+        badval=0,
+        return_distance=False,
+        crowding_error=0.25,
+        use_2D_extinction=False,
+        **kwargs,
+    ):
+        cols = [m5_col, filter_col, seeing_col]
+        maps = [
+            DustMap3D(),
+            StellarDensityMap(filtername="g"),
+            StellarDensityMap(filtername="r"),
+            StellarDensityMap(filtername="i"),
+        ]
+        self.use_2D_extinction = use_2D_extinction
+        if self.use_2D_extinction:
+            maps[0] = DustMap()
+        # This will give us access to the dust map get_distance_at_dmag routine
+        # but does not require loading another copy of the map
+        self.ebvmap = DustMap3D()
+        self.return_distance = return_distance
+        units = "kpc" if self.return_distance else "N stars"
+        super().__init__(cols, metric_name=metric_name, maps=maps, units=units, badval=badval, **kwargs)
+        # Save R_x values for on-the-fly calculation of dust extinction
+        self.r_x = DustValues().r_x.copy()
+        # set return type
+        self.m5_col = m5_col
+        self.filter_col = filter_col
+        self.galb_limit = np.radians(galb_limit)
+        self.mags = mags
+        self.filters = list(self.mags.keys())
+        self.snrs = snrs
+        self.crowding_error = crowding_error
+        self.m5crowding = {
+            f: CrowdingM5Metric(
+                crowding_error=crowding_error,
+                filtername=f,
+                seeing_col=seeing_col,
+                maps=maps,
+            )
+            for f in self.filters
+        }
+        dust_properties = DustValues()
+        self.ax1 = dust_properties.ax1
+
+    def run(self, data_slice, slice_point=None):
+        # Evaluate area on sky for this slice_point, in radians
+        if "nside" in slice_point:
+            # Best area /pixel calculation, appropriate for healpix slicers
+            sky_area = hp.nside2pixarea(slice_point["nside"], degrees=False)
+        else:
+            # Assume single, approximate, circular FOV
+            sky_area = np.pi * (np.radians(1.75)) ** 2
+
+        # if we are outside the galb_limit, return nothing
+        # Note we could make this a more complicated function that
+        # returns an expected density of star forming regions
+        if np.abs(slice_point["galb"]) > self.galb_limit:
+            return self.badval
+
+        # Compute depth for each filter
+        depths = {}
+        # ignore the divide by zero warnings
+        with np.errstate(divide="ignore"):
+            for filtername in self.filters:
+                in_filt = np.where(data_slice[self.filter_col] == filtername)[0]
+                # Calculate coadded depth per filter
+                depth_m5 = 1.25 * np.log10(np.sum(10.0 ** (0.8 * data_slice[self.m5_col][in_filt])))
+                if self.crowding_error > 0:
+                    depth_crowding = self.m5crowding[filtername].run(data_slice, slice_point)
+                    depths[filtername] = min(depth_m5, depth_crowding)
+                else:
+                    depths[filtername] = depth_m5
+
+        # solve for the distances in each filter where we hit the required SNR
+        distances = []
+        for filtername in self.filters:
+            # Apparent magnitude at the SNR requirement
+            m_app = -2.5 * np.log10(self.snrs[filtername] / 5.0)
+            m_app += depths[filtername]
+            if self.use_2D_extinction:
+                A_x = self.ax1[filtername] * slice_point["ebv"]
+                # Assuming all the dust along the line of sight matters.
+                m_app = m_app - A_x
+                dist = 10.0 * (100 ** ((m_app - self.mags[filtername]) / 5.0)) ** 0.5
+            else:
+                dist = self.ebvmap.distance_at_dmag(
+                    dmag=m_app - self.mags[filtername],
+                    dists=slice_point["ebv3d_dists"],
+                    ebvs=slice_point["ebv3d_ebvs"],
+                    filtername=filtername,
+                )
+            distances.append(dist)
+        # compute the final distance, limited by whichever filter is
+        # most shallow
+        final_distance = np.min(distances, axis=-1) / 1e3  # to kpc
+        if self.return_distance:
+            return final_distance
+        else:
+            # Resorting to numerical integration of ugly function
+            sd = StarDensity(slice_point["gall"], slice_point["galb"])
+            stars_per_sterr, _err = integrate.quad(sd, 0, final_distance)
+            stars_tot = stars_per_sterr * sky_area
+            return stars_tot

rubin_sim/maf/maf_night_report.py

@@ -0,0 +1,200 @@
+from . import db as db
+from . import metricBundles as metricBundles
+from . import metrics as metrics
+from . import plots as plots
+from . import slicers as slicers
+from .batches import col_map_dict
+
+__all__ = ("make_bundle_list", "maf_night_report")
+
+import argparse
+
+import matplotlib
+
+# Set matplotlib backend (to create plots where DISPLAY is not set).
+matplotlib.use("Agg")
+
+
+def make_bundle_list(
+    db_file,
+    night=1,
+    nside=64,
+    latCol="fieldDec",
+    lonCol="fieldRA",
+    notes=True,
+    colmap=None,
+):
+    """
+    Make a bundleList of things to run
+    """
+
+    if colmap is None:
+        colmap = col_map_dict("opsimV4")
+
+    mjdCol = "observationStartMJD"
+    altCol = "altitude"
+    azCol = "azimuth"
+    # Construct sql queries for each filter and all filters
+    filters = ["u", "g", "r", "i", "z", "y"]
+    sqls = ["night=%i and filter='%s'" % (night, f) for f in filters]
+    sqls.append("night=%i" % night)
+
+    bundleList = []
+    plotFuncs_lam = [plots.LambertSkyMap()]
+
+    # Hourglass
+    hourslicer = slicers.HourglassSlicer()
+    display_dict = {"group": "Hourglass"}
+    md = ""
+    sql = "night=%i" % night
+    metric = metrics.HourglassMetric(
+        night_col=colmap["night"], mjd_col=colmap["mjd"], metric_name="Hourglass"
+    )
+    bundle = metricBundles.MetricBundle(
+        metric, hourslicer, constraint=sql, info_label=md, display_dict=display_dict
+    )
+    bundleList.append(bundle)
+
+    reg_slicer = slicers.HealpixSlicer(nside=nside, lon_col=lonCol, lat_col=latCol, lat_lon_deg=True)
+    altaz_slicer = slicers.HealpixSlicer(
+        nside=nside, lat_col=altCol, lat_lon_deg=True, lon_col=azCol, use_cache=False
+    )
+
+    unislicer = slicers.UniSlicer()
+    for sql in sqls:
+        # Number of exposures
+        metric = metrics.CountMetric(mjdCol, metric_name="N visits")
+        bundle = metricBundles.MetricBundle(metric, reg_slicer, sql)
+        bundleList.append(bundle)
+        metric = metrics.CountMetric(mjdCol, metric_name="N visits alt az")
+        bundle = metricBundles.MetricBundle(metric, altaz_slicer, sql, plot_funcs=plotFuncs_lam)
+        bundleList.append(bundle)
+
+        metric = metrics.MeanMetric(mjdCol, metric_name="Mean Visit Time")
+        bundle = metricBundles.MetricBundle(metric, reg_slicer, sql)
+        bundleList.append(bundle)
+        metric = metrics.MeanMetric(mjdCol, metric_name="Mean Visit Time alt az")
+        bundle = metricBundles.MetricBundle(metric, altaz_slicer, sql, plot_funcs=plotFuncs_lam)
+        bundleList.append(bundle)
+
+        metric = metrics.CountMetric(mjdCol, metric_name="N_visits")
+        bundle = metricBundles.MetricBundle(metric, unislicer, sql)
+        bundleList.append(bundle)
+
+        # Need pairs in window to get a map of how well it gathered SS pairs.
+
+    # Moon phase.
+
+    metric = metrics.NChangesMetric(col="filter", metric_name="Filter Changes")
+    bundle = metricBundles.MetricBundle(metric, unislicer, "night=%i" % night)
+    bundleList.append(bundle)
+
+    metric = metrics.BruteOSFMetric()
+    bundle = metricBundles.MetricBundle(metric, unislicer, "night=%i" % night)
+    bundleList.append(bundle)
+
+    metric = metrics.MeanMetric("slewTime")
+    bundle = metricBundles.MetricBundle(metric, unislicer, "night=%i" % night)
+    bundleList.append(bundle)
+
+    metric = metrics.MinMetric("slewTime")
+    bundle = metricBundles.MetricBundle(metric, unislicer, "night=%i" % night)
+    bundleList.append(bundle)
+
+    metric = metrics.MaxMetric("slewTime")
+    bundle = metricBundles.MetricBundle(metric, unislicer, "night=%i" % night)
+    bundleList.append(bundle)
+
+    # Make plots of the solar system pairs that were taken in the night
+    metric = metrics.PairMetric(mjd_col=mjdCol)
+    sql = "night=%i and (filter ='r' or filter='g' or filter='i')" % night
+    bundle = metricBundles.MetricBundle(metric, reg_slicer, sql)
+    bundleList.append(bundle)
+
+    metric = metrics.PairMetric(mjd_col=mjdCol, metric_name="z Pairs")
+    sql = "night=%i and filter='z'" % night
+    bundle = metricBundles.MetricBundle(metric, reg_slicer, sql)
+    bundleList.append(bundle)
+
+    # Plot up each visit
+    metric = metrics.NightPointingMetric(mjd_col=mjdCol)
+    slicer = slicers.UniSlicer()
+    sql = "night=%i" % night
+    plot_funcs = [plots.NightPointingPlotter()]
+    bundle = metricBundles.MetricBundle(metric, slicer, sql, plot_funcs=plot_funcs)
+    bundleList.append(bundle)
+
+    # stats from the note column
+    if notes:
+        display_dict = {"group": "Basic Stats", "subgroup": "Percent stats"}
+        metric = metrics.StringCountMetric(col="scheduler_note", percent=True, metric_name="Percents")
+        bundle = metricBundles.MetricBundle(metric, unislicer, sql, display_dict=display_dict)
+        bundleList.append(bundle)
+        display_dict["subgroup"] = "Count Stats"
+        metric = metrics.StringCountMetric(col="scheduler_note", metric_name="Counts")
+        bundle = metricBundles.MetricBundle(metric, unislicer, sql, display_dict=display_dict)
+        bundleList.append(bundle)
+
+    return metricBundles.make_bundles_dict_from_list(bundleList)
+
+
+def maf_night_report():
+    """Generate a report on a single night."""
+
+    parser = argparse.ArgumentParser(description="Python script to generate a report on a single night.")
+    parser.add_argument(
+        "db_file",
+        type=str,
+        default=None,
+        help="full file path to the simulation sqlite file",
+    )
+    parser.add_argument(
+        "--out_dir",
+        type=str,
+        default="night_report",
+        help="Output directory for MAF outputs." + ' Default "Out"',
+    )
+    parser.add_argument(
+        "--nside",
+        type=int,
+        default=64,
+        help="Resolution to run Healpix grid at (must be 2^x). Default 64.",
+    )
+    parser.add_argument(
+        "--lon_col",
+        type=str,
+        default="fieldRA",
+        help="Column to use for RA values (can be a stacker dither column)." + " Default=fieldRA.",
+    )
+    parser.add_argument(
+        "--lat_col",
+        type=str,
+        default="fieldDec",
+        help="Column to use for Dec values (can be a stacker dither column)." + " Default=fieldDec.",
+    )
+    parser.add_argument("--night", type=int, default=1)
+    parser.add_argument("--run_name", type=str, default="run_name")
+
+    parser.set_defaults()
+    args, extras = parser.parse_known_args()
+
+    bundle_dict = make_bundle_list(
+        args.db_file,
+        nside=args.nside,
+        lonCol=args.lon_col,
+        latCol=args.lat_col,
+        night=args.night,
+    )
+
+    for key in bundle_dict:
+        bundle_dict[key].set_run_name(args.run_name)
+
+    # Set up / connect to results_db.
+    results_db = db.ResultsDb(out_dir=args.out_dir)
+
+    # Set up metricBundleGroup.
+    group = metricBundles.MetricBundleGroup(
+        bundle_dict, args.db_file, out_dir=args.out_dir, results_db=results_db
+    )
+    group.run_all()
+    group.plot_all()

rubin_sim/maf/make_fbs_tracking_db.py

@@ -0,0 +1,90 @@
+__all__ = ("make_fbs_tracking_db",)
+
+import argparse
+import os
+import sqlite3
+
+import pandas as pd
+
+from rubin_sim.maf.db import ResultsDb, TrackingDb, VersionRow
+
+
+def make_fbs_tracking_db():
+    """Make a database to track lots of opsim outputs,
+    adding in comments and identifiers based on the metric subsets.
+    """
+    parser = argparse.ArgumentParser(
+        description="Create a tracking database for many opsim maf outputs,"
+        "with comments and dates. "
+        "Assumes metrics are in a subdirectory called 'maf'."
+    )
+    parser.add_argument(
+        "--opsim_list",
+        type=str,
+        default="opsim_list",
+        help="File containing a list of all of the opsim runs to add.",
+    )
+    args = parser.parse_args()
+
+    batches = {
+        "glance": "Quick Look Metrics",
+        "meta": "General Info Metrics",
+        "sci": "Science Metrics",
+        "ss": "Solar System Metrics",
+        "ddf": "Deep Drilling Metrics",
+    }
+
+    tracking_db = TrackingDb()
+    print(f"Tracking database in directory {tracking_db.tracking_db_dir}")
+
+    with open(args.opsim_list, "r") as runlist:
+        for run in runlist:
+            db_file = run.replace("\n", "")
+            vals = db_file.split("/")
+            family = vals[-2]
+            db_name = vals[-1]
+            run_name = db_name.replace(".db", "")
+            run_version = run_name.split("_10yrs")[0].split("_v")[-1]
+            run_group = family
+
+            # Try to build a comment on the run based on the run_name
+            run_comment = run_version + " "
+            run_comment += db_name.split("_v")[0].replace("_", " ")
+
+            print(run_name, db_file)
+            conn = sqlite3.connect(db_file)
+            query = "select Value from info where Parameter == 'Date, ymd'"
+            result = pd.read_sql(query, conn)
+            sched_date = result.iloc[0, 0]
+            query = "select Value from info where Parameter like 'rubin_%.__version__'"
+            result = pd.read_sql(query, conn)
+            sched_version = result.iloc[0, 0]
+
+            # Look for metrics in any of the above sets
+            for k in batches:
+                maf_dir = os.path.join("maf", run_name + "_" + k)
+                maf_comment = batches[k]
+                # Get maf run date and version
+                if os.path.isfile(os.path.join(maf_dir, "resultsDb_sqlite.db")):
+                    resdb = ResultsDb(maf_dir)
+                    resdb.open()
+                    query = resdb.session.query(VersionRow).all()
+                    for v in query:
+                        maf_version = v.version
+                        maf_date = v.run_date
+                    resdb.close()
+
+                    maf_dir = os.path.relpath(maf_dir, start=os.path.dirname(tracking_db.tracking_db_dir))
+                    runId = tracking_db.add_run(
+                        run_group=run_group,
+                        run_name=run_name,
+                        run_comment=run_comment,
+                        run_version=sched_version,
+                        run_date=sched_date,
+                        maf_comment=maf_comment,
+                        maf_version=maf_version,
+                        maf_date=maf_date,
+                        maf_dir=maf_dir,
+                        db_file=db_file,
+                    )
+                    print("Used MAF RunID %d" % (runId))

rubin_sim/maf/maps/__init__.py

@@ -0,0 +1,8 @@
+from .base_map import *
+from .dust_map import *
+from .dust_map_3d import *
+from .ebv_3d_hp import *
+from .gal_coords_map import *
+from .galactic_plane_priority_maps import *
+from .stellar_density_map import *
+from .trilegal_map import *

rubin_sim/maf/maps/base_map.py

@@ -0,0 +1,72 @@
+__all__ = ("MapsRegistry", "BaseMap")
+
+import inspect
+
+
+class MapsRegistry(type):
+    """
+    Meta class for Maps, to build a registry of maps classes.
+    """
+
+    def __init__(cls, name, bases, dict):
+        super(MapsRegistry, cls).__init__(name, bases, dict)
+        if not hasattr(cls, "registry"):
+            cls.registry = {}
+        modname = inspect.getmodule(cls).__name__
+        if modname.startswith("rubin_sim.maf.maps"):
+            modname = ""
+        else:
+            if len(modname.split(".")) > 1:
+                modname = ".".join(modname.split(".")[:-1]) + "."
+            else:
+                modname = modname + "."
+        mapsname = modname + name
+        if mapsname in cls.registry:
+            raise Exception("Redefining maps %s! (there are >1 maps with the same name)" % (mapsname))
+        if mapsname != "BaseMaps":
+            cls.registry[mapsname] = cls
+
+    def get_class(cls, mapsname):
+        return cls.registry[mapsname]
+
+    def help(cls, doc=False):
+        for mapsname in sorted(cls.registry):
+            if not doc:
+                print(mapsname)
+            if doc:
+                print("---- ", mapsname, " ----")
+                print(cls.registry[mapsname].__doc__)
+                maps = cls.registry[mapsname]()
+                print(" added to slice_point: ", ",".join(maps.keynames))
+
+
+class BaseMap(metaclass=MapsRegistry):
+    """Base for maps classes."""
+
+    def __init__(self, **kwargs):
+        self.keynames = ["newkey"]
+
+    def __eq__(self, othermap):
+        return self.keynames == othermap.keynames
+
+    def __ne__(self, othermap):
+        return self.keynames != othermap.keynames
+
+    def __lt__(self, othermap):
+        return self.keynames < othermap.keynames
+
+    def __gt__(self, othermap):
+        return self.keynames > othermap.keynames
+
+    def __le__(self, othermap):
+        return self.keynames <= othermap.keynames
+
+    def __ge__(self, othermap):
+        return self.keynames >= othermap.keynames
+
+    def run(self, slice_points):
+        """Given slice_points (dict containing metadata about each slice_point,
+        including ra/dec), adds additional metadata at each slice_point
+        and returns updated dict.
+        """
+        raise NotImplementedError("This must be defined in subclass")