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

rubin_sim/sim_archive/make_snapshot.py

@@ -0,0 +1,255 @@
+__all__ = [
+    "get_scheduler",
+    "save_scheduler",
+    "add_make_scheduler_snapshot_args",
+    "make_scheduler_snapshot_cli",
+    "get_scheduler_from_config",
+    "get_scheduler_instance_from_repo",
+]
+
+import argparse
+import bz2
+import gzip
+import importlib.util
+import logging
+import lzma
+import pickle
+import sys
+import types
+import typing
+from pathlib import Path
+from tempfile import TemporaryDirectory
+
+import numpy as np
+from git import Repo
+from rubin_scheduler.scheduler.example import example_scheduler
+from rubin_scheduler.scheduler.model_observatory import ModelObservatory
+from rubin_scheduler.scheduler.schedulers.core_scheduler import CoreScheduler
+from rubin_scheduler.scheduler.utils import SchemaConverter
+
+
+def get_scheduler_from_config(config_script_path: str | Path) -> typing.Tuple[int, CoreScheduler]:
+    """Generate a CoreScheduler according to a configuration in a file.
+
+    Parameters
+    ----------
+    config_script_path : `str`
+        The configuration script path
+
+    Returns
+    -------
+    nside : `int`
+        The nside.
+    scheduler : `CoreScheduler`
+        An instance of the Rubin Observatory FBS.
+
+    Raises
+    ------
+    ValueError
+        If the config file is invalid, or has invalid content.
+    """
+
+    # Follow example from official python docs:
+    # https://docs.python.org/3/library/importlib.html#importing-a-source-file-directly
+    # The T&S supplied files have code in a __name__ == 'config' conditional
+    # that we need to be executed, so we *must* name the module "config"
+    config_module_name: str = "config"
+    config_module_spec = importlib.util.spec_from_file_location(config_module_name, config_script_path)
+    if config_module_spec is None or config_module_spec.loader is None:
+        # Make type checking happy
+        raise ValueError(f"Cannot load config file {config_script_path}")
+
+    config_module: types.ModuleType = importlib.util.module_from_spec(config_module_spec)
+    sys.modules[config_module_name] = config_module
+    config_module_spec.loader.exec_module(config_module)
+
+    try:
+        scheduler: CoreScheduler = config_module.scheduler
+        nside: int = scheduler.nside
+    except NameError:
+        nside, scheduler = config_module.get_scheduler()
+        assert isinstance(nside, int)
+        assert isinstance(scheduler, CoreScheduler)
+
+    return nside, scheduler
+
+
+def get_scheduler_instance_from_repo(
+    config_repo: str,
+    config_script: str,
+    config_ref: str = "main",
+) -> CoreScheduler:
+    """Generate a CoreScheduler according to a configuration in git.
+
+    Parameters
+    ----------
+    config_repo : `str`
+        The git repository with the configuration.
+    config_script : `str`
+        The configuration script path (relative to the repository root).
+    config_ref : `str`, optional
+        The branch of the repository to use, by default "main"
+
+    Returns
+    -------
+    scheduler : `CoreScheduler`
+        An instance of the Rubin Observatory FBS.
+
+    Raises
+    ------
+    ValueError
+        If the config file is invalid, or has invalid content.
+    """
+
+    with TemporaryDirectory() as local_config_repo_parent:
+        repo: Repo = Repo.clone_from(config_repo, local_config_repo_parent)
+        repo.git.checkout(config_ref)
+        full_config_script_path: Path = Path(repo.working_dir).joinpath(config_script)
+        scheduler = get_scheduler_from_config(full_config_script_path)[1]
+
+    return scheduler
+
+
+def get_scheduler(
+    config_repo: str | None = None,
+    config_script: str | None = None,
+    config_ref: str = "main",
+    visits_db: str | None = None,
+) -> CoreScheduler:
+    """Generate a CoreScheduler according to a configuration.
+
+    Parameters
+    ----------
+    config_repo : `str`
+        The git repository with the configuration.
+    config_script : `str`
+        The configuration script path (relative to the repository root).
+    config_ref : `str`, optional
+        The branch of the repository to use, by default "main"
+    visits_db : `str` or `None`
+        Database from which to load pre-existing visits
+
+    Returns
+    -------
+    scheduler : `CoreScheduler`
+        An instance of the Rubin Observatory FBS.
+
+    Raises
+    ------
+    ValueError
+        If the config file is invalid, or has invalid content.
+    """
+    if config_repo is not None and len(config_repo) > 0:
+        if config_script is None:
+            raise ValueError("If the config repo is set, the script must be as well.")
+        logging.info(
+            f"Instantiating scheduler form {config_script} on the {config_ref} branch of {config_repo}"
+        )
+        scheduler = get_scheduler_instance_from_repo(
+            config_repo=config_repo, config_script=config_script, config_ref=config_ref
+        )
+    elif config_script is not None:
+        logging.info(f"Reading scheduler from {config_script}")
+        scheduler = get_scheduler_from_config(config_script)[1]
+    else:
+        logging.info("Creating example scheduler")
+        example_scheduler_result = example_scheduler()
+        if isinstance(example_scheduler_result, CoreScheduler):
+            scheduler = example_scheduler_result
+        else:
+            # It might return a observatory, scheduler, observations tuple
+            # instead.
+            scheduler = example_scheduler_result[1]
+
+    if isinstance(visits_db, str) and len(visits_db) > 0:
+        logging.info(f"Adding visits from {visits_db}.")
+        obs: np.recarray = SchemaConverter().opsim2obs(visits_db)
+        if len(obs) > 0:
+            scheduler.add_observations_array(obs)
+        logging.info("Finished adding visits")
+
+    return scheduler
+
+
+def save_scheduler(scheduler: CoreScheduler, file_name: str) -> None:
+    """Save an instances of the scheduler in a pickle file,
+    compressed according to its extension.
+
+    Parameters
+    ----------
+    scheduler : `CoreScheduler`
+        The scheduler to save.
+    file_name : `str`
+        The file in which to save the schedulers.
+    """
+    opener: typing.Callable = open
+
+    if file_name.endswith(".bz2"):
+        opener = bz2.open
+    elif file_name.endswith(".xz"):
+        opener = lzma.open
+    elif file_name.endswith(".gz"):
+        opener = gzip.open
+
+    with opener(file_name, "wb") as pio:
+        pickle.dump(scheduler, pio)
+
+
+def add_make_scheduler_snapshot_args(parser: argparse.ArgumentParser) -> None:
+    """Add arguments needed for saving a scheduler to an argument parser."""
+    parser.add_argument("--scheduler_fname", type=str, help="The file in which to save the scheduler.")
+    parser.add_argument(
+        "--repo", type=str, default=None, help="The repository from which to load the configuration."
+    )
+    parser.add_argument(
+        "--script", type=str, default=None, help="The path to the config script (relative to the repo root)."
+    )
+    parser.add_argument(
+        "--ref",
+        type=str,
+        default="main",
+        help="The git reference (tag/commit/branch) of the repo from which to get the script",
+    )
+    parser.add_argument(
+        "--visits", type=str, default="", help="Opsim database from which to load previous visits."
+    )
+
+
+def make_scheduler_snapshot_cli(cli_args: list = []) -> None:
+    parser = argparse.ArgumentParser(description="Create a scheduler pickle")
+    add_make_scheduler_snapshot_args(parser)
+    args: argparse.Namespace = parser.parse_args() if len(cli_args) == 0 else parser.parse_args(cli_args)
+
+    logging.basicConfig(
+        level=logging.DEBUG,
+        format="%(asctime)s:%(name)s:%(levelname)s:%(message)s",
+        datefmt="%Y-%m-%dT%H:%M:%S",
+    )
+
+    scheduler: CoreScheduler = get_scheduler(args.repo, args.script, args.ref, args.visits)
+
+    save_scheduler(scheduler, args.scheduler_fname)
+
+
+def make_ideal_model_observatory_cli(cli_args: list = []) -> None:
+    parser = argparse.ArgumentParser(description="Create an ideal model observatory pickle")
+    parser.add_argument("scheduler", type=str, help="Scheduler pickle file to read.")
+    parser.add_argument("model_observatory", type=str, help="Model observatory pickle file to write.")
+    args: argparse.Namespace = parser.parse_args() if len(cli_args) == 0 else parser.parse_args(cli_args)
+
+    with open(args.scheduler, "rb") as scheduler_io:
+        scheduler = pickle.load(scheduler_io)
+
+    observatory = ModelObservatory(
+        nside=scheduler.nside,
+        cloud_data="ideal",
+        seeing_data="ideal",
+        downtimes="ideal",
+    )
+
+    with open(args.model_observatory, "wb") as observatory_io:
+        pickle.dump(observatory, observatory_io)
+
+
+if __name__ == "__main__":
+    make_scheduler_snapshot_cli()

rubin_sim/sim_archive/prenight.py

@@ -0,0 +1,216 @@
+"""Tools for running the set of simulations used for a pre-night briefing."""
+
+__all__ = ["AnomalousOverheadFunc", "run_prenight_sim_cli"]
+
+import argparse
+import logging
+import pickle
+import warnings
+from datetime import date
+from pathlib import Path
+
+import numpy as np
+from matplotlib.pylab import Generator
+from rubin_scheduler.scheduler import sim_runner
+from rubin_scheduler.site_models import Almanac
+
+from rubin_sim.sim_archive import make_sim_data_dir
+
+from .util import dayobs_to_date
+
+LOGGER = logging.getLogger(__name__)
+
+
+class AnomalousOverheadFunc:
+    """Callable to return random overhead.
+
+    Parameters
+    ----------
+    seed : `int`
+        Random number seed.
+    slew_scale : `float`
+        The scale for the scatter in the slew offest (seconds).
+    visit_scale : `float`, optional
+        The scale for the scatter in the visit overhead offset (seconds).
+        Defaults to 0.0.
+    slew_loc : `float`, optional
+        The location of the scatter in the slew offest (seconds).
+        Defaults to 0.0.
+    visit_loc : `float`, optional
+        The location of the scatter in the visit offset (seconds).
+        Defaults to 0.0.
+    """
+
+    def __init__(
+        self,
+        seed: int,
+        slew_scale: float,
+        visit_scale: float = 0.0,
+        slew_loc: float = 0.0,
+        visit_loc: float = 0.0,
+    ) -> None:
+        self.rng: Generator = np.random.default_rng(seed)
+        self.visit_loc: float = visit_loc
+        self.visit_scale: float = visit_scale
+        self.slew_loc: float = slew_loc
+        self.slew_scale: float = slew_scale
+
+    def __call__(self, visittime: float, slewtime: float) -> float:
+        """Return a randomized offset for the visit overhead.
+
+        Parameters
+        ----------
+        visittime : `float`
+            The visit time (seconds).
+        slewtime : `float`
+            The slew time (seconds).
+
+        Returns
+        -------
+        offset: `float`
+            Random offset (seconds).
+        """
+
+        slew_overhead: float = slewtime * self.rng.normal(self.slew_loc, self.slew_scale)
+
+        # Slew might be faster that expected, but it will never take negative
+        # time.
+        if (slewtime + slew_overhead) < 0:
+            slew_overhead = 0.0
+
+        visit_overhead: float = visittime * self.rng.normal(self.slew_loc, self.slew_scale)
+        # There might be anomalous overhead that makes visits take longer,
+        # but faster is unlikely.
+        if visit_overhead < 0:
+            visit_overhead = 0.0
+
+        return slew_overhead + visit_overhead
+
+
+def compute_sim_start_and_end(day_obs: int, sim_nights: int, delay: float = 0) -> tuple[float, float]:
+    """Compute simulation start and end time for a prenight simulation.
+
+    Parameters
+    ----------
+    day_obs: `int`
+        The starting dayobs as YYYYMMDD.
+    sim_nights: `int`
+        The number of nights to simulate
+    delay: `float`
+        A delayed start, in minutes.
+
+    Return
+    ------
+    sim_start_mjd, sim_duration : `tuple`
+        The starting MJD and simulation duration in days.
+    """
+    # Find the start of observing for the specified day_obs.
+    # Almanac.get_sunset_info does not use day_obs, so
+    # translate to DJD, Dublin Julian Date.
+    # Like plain Julian Date, DJD rolls over at the
+    # same time as day_obs, but unlike JD, the year
+    # of the epoch works with python's datetime.date.
+    # Note that MJD - DJD = 15019.5
+    # and has epoch 1899-12-31T12:00:00.
+    sunsets = Almanac().sunsets
+    djd_mjd_offset = 15019.5
+    djd0 = date(1899, 12, 31)
+
+    night0_djd = int(np.floor(sunsets["sunset"][0] - djd_mjd_offset))
+    day_obs_date = dayobs_to_date(day_obs)
+    day_obs_djd = (day_obs_date - djd0).days
+    day_obs_start_night = day_obs_djd - night0_djd
+    sim_start_mjd = sunsets["sun_n12_setting"][day_obs_start_night] + delay / (24 * 60.0)
+    day_obs_end_night = day_obs_start_night + sim_nights - 1
+    sim_end_mjd = sunsets["sunrise"][day_obs_end_night]
+    sim_duration = sim_end_mjd - sim_start_mjd
+    assert np.ceil(sim_duration) == sim_nights
+    return sim_start_mjd, sim_duration
+
+
+def run_prenight_sim_cli(cli_args: list = []) -> int:
+    parser = argparse.ArgumentParser(description="Run an SV simulation.")
+    parser.add_argument("scheduler", type=str, help="scheduler pickle file.")
+    parser.add_argument("observatory", type=str, help="model observatory pickle file.")
+    parser.add_argument("day_obs", type=int, help="start day obs.")
+    parser.add_argument("sim_nights", type=int, help="number of nights to run.")
+    parser.add_argument("--keep_rewards", action="store_true", help="Compute rewards data.")
+    parser.add_argument("--telescope", type=str, default="simonyi", help="The telescope simulated.")
+    parser.add_argument("--label", type=str, default="", help="The tags on the simulation.")
+    parser.add_argument("--delay", type=float, default=0.0, help="Minutes after nominal to start.")
+    parser.add_argument("--anom_overhead_scale", type=float, default=0.0, help="scale of scatter in the slew")
+    parser.add_argument(
+        "--anom_overhead_seed",
+        type=int,
+        default=1,
+        help="random number seed for anomalous scatter in overhead",
+    )
+    parser.add_argument("--tags", type=str, default=[], nargs="*", help="The tags on the simulation.")
+    parser.add_argument("--results", type=str, default="", help="Results directory.")
+    args = parser.parse_args() if len(cli_args) == 0 else parser.parse_args(cli_args)
+    day_obs = args.day_obs
+    sim_nights = args.sim_nights
+    keep_rewards = args.keep_rewards
+    tags = args.tags
+    label = args.label
+    telescope = args.telescope
+    delay = args.delay
+    anom_overhead_scale = args.anom_overhead_scale
+    anom_overhead_seed = args.anom_overhead_seed
+    results_dir = args.results if len(args.results) > 0 else None
+
+    with open(args.scheduler, "rb") as scheduler_io:
+        scheduler = pickle.load(scheduler_io)
+
+    with open(args.observatory, "rb") as observatory_io:
+        observatory = pickle.load(observatory_io)
+
+    if anom_overhead_scale > 0:
+        anomalous_overhead_func = AnomalousOverheadFunc(anom_overhead_seed, anom_overhead_scale)
+    else:
+        anomalous_overhead_func = None
+
+    if keep_rewards:
+        scheduler.keep_rewards = keep_rewards
+
+    sim_start_mjd, sim_duration = compute_sim_start_and_end(day_obs, sim_nights, delay)
+    observatory.mjd = sim_start_mjd
+
+    LOGGER.info("Starting simulation")
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore", RuntimeWarning)
+        results = sim_runner(
+            observatory,
+            scheduler,
+            sim_start_mjd=sim_start_mjd,
+            sim_duration=sim_duration,
+            record_rewards=keep_rewards,
+            verbose=True,
+            anomalous_overhead_func=anomalous_overhead_func,
+        )
+    observatory, scheduler, obs = results[:3]
+    rewards, obs_rewards = (None, None) if len(results) < 5 else results[3:5]
+    LOGGER.info("Simulation complete.")
+
+    LOGGER.info("Writing simulation results")
+    data_path = make_sim_data_dir(
+        obs,
+        rewards,
+        obs_rewards,
+        in_files={"scheduler": args.scheduler, "observatory": args.observatory},
+        tags=tags,
+        label=label,
+        opsim_metadata={"telescope": telescope},
+        data_path=results_dir,
+    )
+    output_dirname: str = "Unknown"
+    if isinstance(data_path, Path):
+        assert isinstance(data_path, Path)
+        output_dirname = data_path.name
+    else:
+        assert isinstance(data_path, str)
+        output_dirname = data_path
+
+    LOGGER.info(f"Wrote results in directory: {output_dirname}")
+
+    return 0

rubin_sim/sim_archive/prenightindex.py

@@ -0,0 +1,229 @@
+__all__ = ["get_prenight_index", "select_latest_prenight_sim"]
+
+import logging
+import os
+from datetime import date
+
+import pandas as pd
+from lsst.resources import ResourcePath
+
+if "PRENIGHT_INDEX_URL" in os.environ:
+    PRENIGHT_INDEX_URL = os.environ["PRENIGHT_INDEX_URL"]
+else:
+    from rubin_sim.sim_archive.vseqarchive import PRENIGHT_INDEX_URL
+
+from rubin_sim.sim_archive.vseqmetadata import VisitSequenceArchiveMetadata
+
+from .util import dayobs_to_date
+
+MAX_AGE = 365
+LOGGER = logging.getLogger(__name__)
+
+
+def get_prenight_index_from_database(
+    day_obs: str | int | date,
+    telescope: str = "simonyi",
+    schema: str | None = None,
+    host: str | None = None,
+    user: str | None = None,
+    database: str | None = None,
+) -> pd.DataFrame:
+    """
+    Retrieve the pre‑night observation index for a given night from the
+    LSST SIM Archive.
+
+    Parameters
+    ----------
+    day_obs : `str` or `int` or `date`
+        The night for which to fetch the index.  Accepts a date string,
+        YYYYMMDD encoded into an integer, or a :class:`datetime.date`
+    telescope : `str`, optional
+        Telescope name (default ``"simonyi"``).  Passed directly to
+        :class:`~rubin_sim.sim_archive.vseqmetadata.VisitSequenceArchiveMetadata`.
+    schema : `str` or `None`, optional
+        Optional database schema name.
+    host : `str` or `None`, optional
+        Database host address.
+    user : `str` or `None`, optional
+        Database user name.
+    database : `str` or `None`, optional
+        Database name.
+
+    Returns
+    -------
+    prenights: `pandas.DataFrame`
+        A DataFrame indexed by ``visitseq_uuid`` containing all pre‑night
+        entries for the requested night.  Columns mirror those returned
+        by the underlying `sims_on_nights` call.
+
+    Notes
+    -----
+    * The function uses a hard‑coded maximum simulation age of
+      :data:`MAX_AGE` (365 days) to limit the search.
+    * If any of ``host``, ``user`` or ``database`` are supplied, they
+      override the defaults in the ``metadata_dsn`` dictionary passed to
+      :class:`~rubin_sim.sim_archive.vseqmetadata.VisitSequenceArchiveMetadata`.
+    """
+
+    day_obs_date = dayobs_to_date(day_obs)
+    assert isinstance(day_obs_date, date)
+
+    metadata_dsn = {}
+    if host is not None:
+        metadata_dsn["host"] = host
+    if user is not None:
+        metadata_dsn["user"] = user
+    if database is not None:
+        metadata_dsn["database"] = database
+
+    visit_seq_archive_metadata = VisitSequenceArchiveMetadata(metadata_dsn, schema)
+    prenights = visit_seq_archive_metadata.sims_on_nights(
+        day_obs_date, day_obs_date, tags=["prenight"], telescope=telescope, max_simulation_age=MAX_AGE
+    ).set_index("visitseq_uuid")
+    LOGGER.info(f"Got metadata on {len(prenights)} simulations from database")
+    return prenights
+
+
+def get_prenight_index_from_bucket(
+    day_obs: str | int | date,
+    telescope: str = "simonyi",
+    prenight_index_path: str | ResourcePath = PRENIGHT_INDEX_URL,
+) -> pd.DataFrame:
+    """
+    Load the pre‑night observation index for a given night from a remote
+    bucket.
+
+    Parameters
+    ----------
+    day_obs : `str` or `int` or `date`
+        The night for which to fetch the index.  Accepts a date string,
+        YYYYMMDD encoded into an integer, a ``datetime.date``
+    telescope : `str`, optional
+        Telescope name (default ``"simonyi"``).
+    prenight_index_path : `str` or `ResourcePath`, optional
+        The root path where the pre‑night index
+        JSON files are stored.  It can be a string URL or a
+        ``ResourcePath`` instance.
+
+    Returns
+    -------
+    prenights : `pandas.DataFrame`
+        A DataFrame indexed by the JSON key (``visitseq_uuid``) containing
+        all pre‑night entries for the requested night.  The columns match
+        those stored in the JSON file.
+    """
+    day_obs_date = dayobs_to_date(day_obs)
+    assert isinstance(day_obs_date, date)
+
+    prenight_index_path = ResourcePath(prenight_index_path, forceDirectory=True)
+    assert isinstance(prenight_index_path, ResourcePath)
+
+    year = day_obs_date.year
+    month = day_obs_date.month
+    isodate = day_obs_date.isoformat()
+
+    prenight_index_resource_path = (
+        prenight_index_path.join(telescope)
+        .join(str(year))
+        .join(str(month))
+        .join(f"{telescope}_prenights_for_{isodate}.json")
+    )
+    with prenight_index_resource_path.as_local() as local_resource_path:
+        prenights = pd.read_json(local_resource_path.ospath, orient="index")
+
+    return prenights
+
+
+def get_prenight_index(
+    day_obs: str | int | date,
+    telescope: str = "simonyi",
+    schema: str | None = None,
+    host: str | None = None,
+    user: str | None = None,
+    database: str | None = None,
+    prenight_index_path: str | ResourcePath | None = None,
+) -> pd.DataFrame:
+    """Retrieve the pre‑night observation index for a given night.
+
+    Parameters
+    ----------
+    day_obs : `str` or `int` or `date`
+        Night for which to fetch the index.
+    telescope : `str`
+        Telescope name (default ``simonyi``).
+    schema : `str` or `None`, optional
+        Optional database schema name.
+    host : `str` or `None`, optional
+        Database host address.
+    user : `str` or `None`, optional
+        Database user name.
+    database : `str` or `None`, optional
+        Database name.
+    prenight_index_path :  `str` or `ResourcePath`, optional
+        Root path to the bucket files (used only if the database call fails).
+
+    Returns
+    -------
+    prenights: `pd.DataFrame`
+        Pre‑night index indexed by ``visitseq_uuid``.
+    """
+    try:
+        # Try the database first
+        prenights = get_prenight_index_from_database(day_obs, telescope, schema, host, user, database)
+    except Exception:
+        # Fall back to the bucket
+        LOGGER.info("Database not accessible, falling back on the index in the S3 bucket.")
+        if prenight_index_path is None:
+            prenight_index_path = PRENIGHT_INDEX_URL
+        try:
+            prenights = get_prenight_index_from_bucket(day_obs, telescope, prenight_index_path)
+        except FileNotFoundError:
+            prenights = pd.DataFrame()
+
+    return prenights
+
+
+def select_latest_prenight_sim(
+    prenights: pd.DataFrame,
+    tags: tuple[str, ...] = ("ideal", "nominal"),
+    max_simulation_age: int = 2,
+) -> dict | None:
+    """Select the best prenight simulation from a DataFrame.
+
+    Parameters
+    ----------
+    prenights: `pd.DataFrame`
+        The table of prenights from which to select.
+    tags : `tuple` [`str`]
+        A tuple of tags to filter simulations by.
+        Defaults to ``('ideal', 'nominal')``.
+    max_simulation_age : `int`
+        The maximum age of simulations to consider, in days.
+        Simulations older than ``max_simulation_age`` will not be considered.
+        Defaults to 2.
+
+    Returns
+    -------
+    best_sim : `dict` or `None`
+        A dictionary with metadata for the simulation.
+    """
+    best_sim = None
+    for _, sim in prenights.reset_index().iterrows():
+        if not set(tags).issubset(sim["tags"]):
+            continue
+        if best_sim is not None:
+            if sim["creation_time"] < best_sim["creation_time"]:
+                continue
+
+        age = (pd.Timestamp.now(tz="UTC") - sim["creation_time"]).days
+        if age > max_simulation_age:
+            continue
+
+        best_sim = sim
+
+    if best_sim is not None:
+        LOGGER.info(f"Most recent simulation meeting requested criteria is {best_sim['visitseq_url']}.")
+    else:
+        LOGGER.debug("No simulations met the requested criteria.")
+
+    return best_sim