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

rubin_sim/maf/run_moving_calc.py

@@ -0,0 +1,239 @@
+__all__ = ("run_moving_calc",)
+
+import argparse
+import os
+
+import numpy as np
+from rubin_scheduler.utils import SURVEY_START_MJD
+
+from rubin_sim.maf.slicers import MoObjSlicer
+
+from . import batches as batches
+from . import db as db
+from . import metricBundles as mmB
+
+
+def run_moving_calc():
+    """Calculate metric values for an input population. Can be used on either
+    a split or complete population. If running on a split population for later
+    re-combining, use the complete set of orbits as the 'orbit_file'. Assumes
+    you have already created the moving object observation files.
+    """
+
+    parser = argparse.ArgumentParser(description="Run moving object metrics for a particular scheduler run.")
+    parser.add_argument("--orbit_file", type=str, help="File containing the moving object orbits.")
+    parser.add_argument(
+        "--objtype",
+        type=str,
+        default="",
+        help="Object type, to set up default characterization/H value parameters "
+        "(if they're not specified by flags) and to label outputs.",
+    )
+    parser.add_argument(
+        "--obs_file",
+        type=str,
+        help="File containing the observations of the moving objects.",
+    )
+    parser.add_argument(
+        "--out_dir",
+        type=str,
+        default=".",
+        help="Output directory for moving object metrics. Default '.'.",
+    )
+    parser.add_argument(
+        "--simulation_db",
+        type=str,
+        default=None,
+        help="Path and filename of opsim output sqlite file, to write config* files to output directory."
+        " Optional: if not provided, files won't have useful names.",
+    )
+    parser.add_argument(
+        "--h_min",
+        type=float,
+        help="Minimum H value. " "If not set, defaults from objtype will be used.",
+    )
+    parser.add_argument(
+        "--h_max",
+        type=float,
+        help="Maximum H value. " "If not set, defaults from objtype will be used.",
+    )
+    parser.add_argument(
+        "--h_step",
+        type=float,
+        help="Stepsizes in H values. " "If not set, defaults from objtype will be used.",
+    )
+    parser.add_argument(
+        "--h_mark",
+        type=float,
+        default=None,
+        help="Add vertical lines at H=h_mark on plots. Default None.",
+    )
+    parser.add_argument(
+        "--characterization",
+        type=str,
+        help="Inner/Outer solar system characterization. " "If unset, defaults from objtype will be used.",
+    )
+    parser.add_argument(
+        "--constraint_info_label",
+        type=str,
+        default="",
+        help="Metadata to add to the output files beyond objtype. Typically translation of "
+        "the sql constraint into something more readable.",
+    )
+    parser.add_argument(
+        "--constraint",
+        type=str,
+        default=None,
+        help="(sql-style) constraint to apply to the solar system observations.",
+    )
+    parser.add_argument(
+        "--albedo",
+        type=float,
+        default=None,
+        help="Albedo value, to add diameters to upper scales on plots. Default None.",
+    )
+
+    parser.add_argument(
+        "--n_years_max",
+        type=int,
+        default=10,
+        help="Maximum number of years out to which to evaluate completeness." "Default 10.",
+    )
+    parser.add_argument(
+        "--start_time",
+        type=float,
+        default=None,
+        help="Time at start of survey (to set time for summary metrics).",
+    )
+    args = parser.parse_args()
+
+    run_name = os.path.split(args.simulation_db)[-1].replace(".db", "")
+
+    if args.orbit_file is None or args.obs_file is None:
+        print("Must specify an orbit_file and an obs_file to calculate the metrics.")
+        exit()
+
+    # Get default H and other values:
+    defaults = batches.ss_population_defaults(args.objtype)
+    h_min = defaults["h_range"][0]
+    h_max = defaults["h_range"][1]
+    h_step = defaults["h_range"][2]
+    h_mark = defaults["h_mark"]
+    characterization = defaults["char"]
+    magtype = defaults["magtype"]
+    # If H info is specified from parser, use that
+    if args.h_min is not None:
+        h_min = args.h_min
+    if args.h_max is not None:
+        h_max = args.h_max
+    if args.h_step is not None:
+        h_step = args.h_step
+    if args.h_mark is not None:
+        h_mark = args.h_mark
+    if args.characterization is not None:
+        characterization = args.characterization
+    Hrange = np.arange(h_min, h_max + h_step, h_step)
+
+    # Default parameters for metric setup.
+    if args.start_time is None:
+        start_time = SURVEY_START_MJD
+    else:
+        start_time = args.start_time
+
+    stepsize = 365 / 2.0
+    times = np.arange(0, args.n_years_max * 365 + stepsize / 2, stepsize)
+    times += start_time
+
+    # Set up results_db.
+    if not (os.path.isdir(args.out_dir)):
+        try:
+            os.makedirs(args.out_dir)
+        except FileExistsError:
+            # This can happen if you are running these in parallel
+            # and two scripts try to make
+            # the same directory.
+            pass
+    results_db = db.ResultsDb(out_dir=args.out_dir)
+
+    colmap = batches.col_map_dict()
+    slicer = MoObjSlicer(h_range=Hrange)
+    slicer.setup_slicer(orbit_file=args.orbit_file, obs_file=args.obs_file)
+    # Run discovery metrics using 'trailing' losses
+    bdictT = batches.quick_discovery_batch(
+        slicer,
+        colmap=colmap,
+        run_name=run_name,
+        objtype=args.objtype,
+        constraint_info_label=args.constraint_info_label,
+        constraint=args.constraint,
+        detection_losses="trailing",
+        albedo=args.albedo,
+        h_mark=h_mark,
+        magtype=magtype,
+    )
+    # Run these discovery metrics
+    print("Calculating quick discovery metrics with simple trailing losses.")
+    bg = mmB.MoMetricBundleGroup(bdictT, out_dir=args.out_dir, results_db=results_db)
+    bg.run_all()
+
+    # Run all discovery metrics using 'detection' losses
+    bdictD = batches.quick_discovery_batch(
+        slicer,
+        colmap=colmap,
+        run_name=run_name,
+        objtype=args.objtype,
+        constraint_info_label=args.constraint_info_label,
+        constraint=args.constraint,
+        detection_losses="detection",
+        albedo=args.albedo,
+        h_mark=h_mark,
+        magtype=magtype,
+    )
+    bdict = batches.discovery_batch(
+        slicer,
+        colmap=colmap,
+        run_name=run_name,
+        objtype=args.objtype,
+        constraint_info_label=args.constraint_info_label,
+        constraint=args.constraint,
+        detection_losses="detection",
+        albedo=args.albedo,
+        h_mark=h_mark,
+        magtype=magtype,
+    )
+    bdictD.update(bdict)
+
+    # Run these discovery metrics
+    print("Calculating full discovery metrics with detection losses.")
+    bg = mmB.MoMetricBundleGroup(bdictD, out_dir=args.out_dir, results_db=results_db)
+    bg.run_all()
+
+    # Run all characterization metrics
+    if characterization.lower() == "inner":
+        bdictC = batches.characterization_inner_batch(
+            slicer,
+            colmap=colmap,
+            run_name=run_name,
+            objtype=args.objtype,
+            albedo=args.albedo,
+            constraint_info_label=args.constraint_info_label,
+            constraint=args.constraint,
+            h_mark=h_mark,
+            magtype=magtype,
+        )
+    elif characterization.lower() == "outer":
+        bdictC = batches.characterization_outer_batch(
+            slicer,
+            colmap=colmap,
+            run_name=run_name,
+            objtype=args.objtype,
+            albedo=args.albedo,
+            constraint_info_label=args.constraint_info_label,
+            constraint=args.constraint,
+            h_mark=h_mark,
+            magtype=magtype,
+        )
+    # Run these characterization metrics
+    print("Calculating characterization metrics.")
+    bg = mmB.MoMetricBundleGroup(bdictC, out_dir=args.out_dir, results_db=results_db)
+    bg.run_all()

rubin_sim/maf/run_moving_fractions.py

@@ -0,0 +1,128 @@
+__all__ = ("run_moving_fractions",)
+
+import argparse
+import glob
+import os
+
+import numpy as np
+from rubin_scheduler.utils import SURVEY_START_MJD
+
+from . import batches as batches
+from . import db as db
+from . import metricBundles as mmB
+
+
+def run_moving_fractions():
+    """Calculate completeness and fractions for moving object metrics."""
+    parser = argparse.ArgumentParser(description="Run moving object metrics for a particular opsim run.")
+    parser.add_argument(
+        "--work_dir",
+        type=str,
+        default=".",
+        help="Output (and input) directory for moving object metrics. Default '.'.",
+    )
+    parser.add_argument(
+        "--metadata",
+        type=str,
+        default=None,
+        help="Select only files matching this metadata string. Default None (all files).",
+    )
+    parser.add_argument(
+        "--h_mark",
+        type=float,
+        default=None,
+        help="H value at which to calculate cumulative/differential completeness, etc."
+        "Default (None) will be set to plot_dict value or median of H range.",
+    )
+    parser.add_argument(
+        "--n_years_max",
+        type=int,
+        default=10,
+        help="Maximum number of years out to which to evaluate completeness." "Default 10.",
+    )
+    parser.add_argument(
+        "--start_time",
+        type=float,
+        default=None,
+        help="Time at start of survey (to set time for summary metrics).",
+    )
+    args = parser.parse_args()
+
+    # Default parameters for metric setup.
+    if args.start_time is None:
+        start_time = SURVEY_START_MJD
+    else:
+        start_time = args.start_time
+    stepsize = 365 / 6.0
+    times = np.arange(0, args.n_years_max * 365 + stepsize / 2, stepsize)
+    times += start_time
+
+    # Create a results Db.
+    results_db = db.ResultsDb(out_dir=args.work_dir)
+
+    # Just read in all metrics in the (joint or single) directory,
+    # then run completeness and fraction
+    # summaries, using the methods in the batches.
+    if args.metadata is None:
+        matchstring = os.path.join(args.work_dir, "*MOOB.npz")
+    else:
+        matchstring = os.path.join(args.work_dir, f"*{args.metadata}*MOOB.npz")
+    metricfiles = glob.glob(matchstring)
+    metric_names = []
+    for m in metricfiles:
+        mname = os.path.split(m)[-1].replace("_MOOB.npz", "")
+        metric_names.append(mname)
+
+    bdict = {}
+    for mName, mFile in zip(metric_names, metricfiles):
+        bdict[mName] = mmB.create_empty_mo_metric_bundle()
+        bdict[mName].read(mFile)
+
+    first = bdict[metric_names[0]]
+    figroot = f"{first.run_name}"
+    # adding args.metadata to the figroot means that we can narrow
+    # down *which* subset of files to work on
+    # this lets us add different h_mark values to the output plots,
+    # if desired (leaving None/default is ok)
+    if args.metadata != ".":
+        figroot += f"_{args.metadata}"
+
+    # Calculate completeness. This utility writes these to disk.
+    bdict_completeness = batches.run_completeness_summary(
+        bdict, args.h_mark, times, args.work_dir, results_db
+    )
+
+    # Plot some of the completeness results.
+    batches.plot_completeness(
+        bdict_completeness,
+        figroot=figroot,
+        results_db=results_db,
+        out_dir=args.work_dir,
+    )
+
+    # Calculate fractions of population for characterization.
+    # This utility writes these to disk.
+    bdict_fractions = batches.run_fraction_summary(bdict, args.h_mark, args.work_dir, results_db)
+    # Plot the fractions for colors and lightcurves.
+    batches.plot_fractions(bdict_fractions, figroot=figroot, results_db=results_db, out_dir=args.work_dir)
+
+    # Plot nObs and arcLength.
+    for k in bdict:
+        if "NObs" in k:
+            batches.plot_single(bdict[k], results_db=results_db, out_dir=args.work_dir)
+        if "ObsArc" in k:
+            batches.plot_single(bdict[k], results_db=results_db, out_dir=args.work_dir)
+
+    # Plot the number of chances of discovery metric -
+    # this is different than completeness
+    # As it plots the metric value directly
+    for k in bdict:
+        if "DiscoveryNChances" in k and "3_pairs_in_15_nights_detection_loss" in k:
+            batches.plot_single(bdict[k], results_db=results_db, out_dir=args.work_dir)
+        if "MagicDiscovery" in k:
+            batches.plot_single(bdict[k], results_db=results_db, out_dir=args.work_dir)
+        if "HighVelocity" in k:
+            batches.plot_single(bdict[k], results_db=results_db, out_dir=args.work_dir)
+
+    # Plot likelihood of detecting activity.
+    batches.plot_activity(bdict, figroot=figroot, results_db=results_db, out_dir=args.work_dir)

rubin_sim/maf/run_moving_join.py

@@ -0,0 +1,103 @@
+from . import batches as batches
+
+__all__ = ("run_moving_join",)
+
+import argparse
+import glob
+import os
+
+import matplotlib
+import numpy as np
+
+matplotlib.use("Agg")
+
+
+def run_moving_join():
+    """Join split metric outputs into a single metric output file."""
+    parser = argparse.ArgumentParser(
+        description="Join moving object metrics (from splits) for a particular "
+        "scheduler run.  Assumes split metric files are in "
+        "<orbitRoot_split> subdirectories of base_dir. "
+    )
+    parser.add_argument("--orbit_file", type=str, help="File containing the moving object orbits.")
+    parser.add_argument(
+        "--base_dir",
+        type=str,
+        default=".",
+        help="Root directory containing split (or single) metric outputs.",
+    )
+    parser.add_argument(
+        "--out_dir",
+        type=str,
+        default=None,
+        help="Output directory for moving object metrics. Default [orbitRoot]",
+    )
+    args = parser.parse_args()
+
+    if args.orbit_file is None:
+        print("Must specify an orbit_file")
+        exit()
+
+    # Outputs from the metrics are generally like so:
+    #  <base_dir>/<splitDir>/<metricFileName>
+    # - base_dir tends to be <opsimName_orbitRoot> (
+    # but is set by user when starting to generate obs.)
+    # - splitDir tends to be <orbitRoot_split#>
+    # (and is set by observation generation script)
+    # - metricFile is <opsimName_metricName_metadata
+    # (NEO/L7/etc + metadata from metric script)_MOOB.npz
+    #  (the metricFileName is set by the metric generation script
+    #  - run_moving_calc.py).
+    #  (note that split# does not show up in the metricFileName,
+    #  and is not used in run_moving_calc.py).
+    #  ... this lets run_moving_calc.py easily run in parallel on
+    #  multiple splits.
+
+    # Assume splits = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+    splits = np.arange(0, 10, 1)
+    orbit_root = args.orbit_file.replace(".txt", "").replace(".des", "").replace(".s3m", "")
+
+    if args.out_dir is not None:
+        out_dir = args.out_dir
+    else:
+        out_dir = f"{orbit_root}"
+
+    # Scan first splitDir for all metric files.
+    tempdir = os.path.join(args.base_dir, f"{orbit_root}_{splits[0]}")
+    print(f"# Joining files from {orbit_root}_[0-9]; will use {tempdir} to find metric names.")
+
+    metricfiles = glob.glob(os.path.join(tempdir, "*MOOB.npz"))
+    # Identify metric names that we want to join.
+    metricNames = []
+    for m in metricfiles:
+        mname = os.path.split(m)[-1]
+        # Hack out raw Discovery outputs.
+        # We don't want to join the raw discovery files.
+        # This is a hack because currently we're just pulling out
+        # _Time and _N_Chances to join but there are other options.
+        if "Discovery" in mname:
+            if "DiscoveryTime" in mname:
+                metricNames.append(mname)
+            elif "DiscoveryNChances" in mname:
+                metricNames.append(mname)
+            elif "Magic" in mname:
+                metricNames.append(mname)
+            elif "HighVelocity" in mname:
+                metricNames.append(mname)
+            else:
+                pass
+        else:
+            metricNames.append(mname)
+
+    if len(metricNames) == 0:
+        print(f"Could not read any metric files from {tempdir}")
+        exit()
+
+    # Create the output directory.
+    if not (os.path.isdir(out_dir)):
+        os.makedirs(out_dir)
+
+    # Read and combine the metric files.
+    for m in metricNames:
+        b = batches.read_and_combine(orbit_root, args.base_dir, splits, m)
+        b.write(out_dir=out_dir)

rubin_sim/maf/run_selfcal_metric.py

@@ -0,0 +1,92 @@
+from .db import ResultsDb
+from .maf_contrib import PhotometricSelfCalUniformityMetric
+from .metric_bundles import MetricBundle, MetricBundleGroup
+from .metrics import IdentityMetric
+from .plots import HealpixHistogram, HealpixSkyMap, PlotHandler
+from .slicers import HealpixSlicer, UniSlicer
+
+__all__ = ("run_selfcal_metric",)
+
+import argparse
+import os
+import shutil
+
+import healpy as hp
+import matplotlib
+import numpy as np
+
+matplotlib.use("Agg")
+
+
+def run_selfcal_metric():
+    """
+    Run the self-calibration metric on one database.
+    """
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--db", type=str, default=None)
+    parser.add_argument(
+        "--no_clobber",
+        dest="no_clobber",
+        default=False,
+        action="store_true",
+        help="Do not remove existing directory outputs",
+    )
+    parser.add_argument("--filter", type=str, default="r")
+
+    args = parser.parse_args()
+
+    opsdb = args.db
+    sim_name = os.path.basename(opsdb).replace(".db", "")
+
+    out_dir = sim_name + "_selfcal"
+    if not args.no_clobber:
+        if os.path.isdir(out_dir):
+            shutil.rmtree(out_dir)
+
+    # Set up the metric bundle.
+    map_nside = 128
+    selfcal_metric = PhotometricSelfCalUniformityMetric(
+        nside_residual=map_nside, filter_name=args.filter, metric_name="selfcal_uniformity-%s" % args.filter
+    )
+    slicer = UniSlicer()
+    # Exclude DDF visits
+    sql = "scheduler_note not like '%DD%'"
+    # And run on only year 1 (?)
+    sql += " and night < 366"
+    sql += " and filter='%s'" % args.filter
+
+    bundle = MetricBundle(
+        selfcal_metric, slicer, sql, run_name=sim_name, info_label="year 1 no-DD %s" % args.filter
+    )
+
+    # Set up the resultsDB
+    results_db = ResultsDb(out_dir=out_dir)
+    # Go and run it
+    group = MetricBundleGroup(
+        {"selfcal": bundle}, opsdb, out_dir=out_dir, results_db=results_db, save_early=True
+    )
+    group.run_all(clear_memory=False, plot_now=True)
+
+    # Make plots of the residuals map
+    map_bundle = MetricBundle(
+        IdentityMetric(metric_name="PhotoCal Uniformity %s" % args.filter),
+        HealpixSlicer(map_nside),
+        sql,
+        run_name=sim_name,
+        info_label="year 1 no-DD",
+    )
+    tmp_vals = bundle.metric_values[0]["uniformity_map"]
+    tmp_vals = np.where(tmp_vals == hp.UNSEEN, map_bundle.slicer.badval, tmp_vals)
+    map_bundle.metric_values = np.ma.MaskedArray(
+        data=tmp_vals,
+        mask=np.zeros(map_bundle.slicer.shape, "bool"),
+        fill_value=map_bundle.slicer.badval,
+    )
+    map_bundle.write(out_dir=out_dir, results_db=results_db)
+
+    ph = PlotHandler(results_db=results_db, out_dir=out_dir)
+    ph.set_metric_bundles([map_bundle])
+    _ = ph.plot(HealpixSkyMap(), plot_dicts={"color_min": -0.02, "color_max": 0.02})
+    _ = ph.plot(HealpixHistogram(), plot_dicts={"percentile_clip": 99})
+
+    results_db.close()

rubin_sim/maf/scimaf_dir.py

@@ -0,0 +1,87 @@
+from . import batches as batches
+from . import db as db
+from . import metricBundles as mmB
+
+__all__ = ("scimaf_dir",)
+
+import argparse
+import glob
+import os
+import shutil
+import sqlite3
+import warnings
+
+import matplotlib
+import pandas as pd
+
+matplotlib.use("Agg")
+
+
+def scimaf_dir():
+    """Run the science batch on all .db files in a directory."""
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--db", type=str, default=None)
+    parser.add_argument(
+        "--no_clobber",
+        dest="no_clobber",
+        action="store_true",
+        default=False,
+        help="Do not remove existing directory outputs",
+    )
+    parser.set_defaults(no_long_micro=False)
+    parser.add_argument("--limited", dest="limited", action="store_true")
+    parser.set_defaults(limited=False)
+    args = parser.parse_args()
+
+    if args.db is None:
+        db_files = glob.glob("*.db")
+        db_files = [filename for filename in db_files if "trackingDb" not in filename]
+    else:
+        db_files = [args.db]
+    run_names = [os.path.basename(name).replace(".db", "") for name in db_files]
+
+    for filename, name in zip(db_files, run_names):
+        out_dir = name + "_sci"
+
+        # Grab the starting date for the Presto KNe metric
+        try:
+            con = sqlite3.connect(filename)
+            mjd0_df = pd.read_sql("select min(observationStartMJD) from observations;", con)
+            con.close()
+            mjd0 = mjd0_df.values.min()
+        # If this fails for any reason (aka schema change)
+        except:  # noqa E722
+            warnings.warn("Could not find survey start date for Presto KNe, setting mjd0=None.")
+            mjd0 = None
+        # Clobber output directory if it exists
+        if not args.no_clobber:
+            if os.path.isdir(out_dir):
+                shutil.rmtree(out_dir)
+        results_db = db.ResultsDb(out_dir=out_dir)
+        # Set up the metricBundles
+        if args.limited:
+            bdict = batches.radar_limited(
+                runName=name,
+                mjd0=mjd0,
+            )
+        else:
+            bdict = batches.science_radar_batch(
+                runName=name,
+                mjd0=mjd0,
+            )
+        # Run them, including generating plots
+        group = mmB.MetricBundleGroup(
+            bdict, filename, out_dir=out_dir, results_db=results_db, save_early=False
+        )
+        group.run_all(clear_memory=True, plot_now=True)
+        results_db.close()
+        db.add_run_to_database(
+            out_dir,
+            "trackingDb_sqlite.db",
+            run_group=None,
+            run_name=name,
+            run_comment=None,
+            maf_comment="ScienceRadar",
+            db_file=name + ".db",
+        )