gammasimtools 0.6.1__py3-none-any.whl → 0.8.2__py3-none-any.whl

simtools/db/db_array_elements.py

@@ -0,0 +1,130 @@
+"""Retrieval of array elements from the database."""
+
+from functools import lru_cache
+
+from pymongo import ASCENDING
+
+from simtools.utils import names
+
+
+@lru_cache
+def get_array_elements(db_collection, model_version):
+    """
+    Get all array element names and their design model for a given DB collection.
+
+    Uses the 'design_model' parameter to determine the design model of the array element.
+    Assumes that a design model is defined for every array element.
+
+    Parameters
+    ----------
+    db_collection:
+        pymongo.collection.Collection
+    model_version: str
+       Model version.
+
+    Returns
+    -------
+    dict
+        Dict with array element names found and their design model
+
+    Raises
+    ------
+    ValueError
+        If query for collection name not implemented.
+    KeyError
+        If array element entry in the database is incomplete.
+
+    """
+    query = {"version": model_version}
+    results = db_collection.find(query, {"instrument": 1, "value": 1, "parameter": 1}).sort(
+        "instrument", ASCENDING
+    )
+
+    _all_available_array_elements = {}
+    for doc in results:
+        try:
+            if doc["parameter"] == "design_model":
+                _all_available_array_elements[doc["instrument"]] = doc["value"]
+        except KeyError as exc:
+            raise KeyError(f"Incomplete array element entry in the database: {doc}.") from exc
+
+    if len(_all_available_array_elements) == 0:
+        raise ValueError(f"No array elements found in DB collection {db_collection}.")
+
+    return _all_available_array_elements
+
+
+def get_array_element_list_for_db_query(array_element_name, db, model_version, collection):
+    """
+    Get array element name and design model for querying the database.
+
+    Return a list of array element names to be used for querying the database for a given array
+    element. This is in most cases the array element itself and its design model.
+    In cases of no design model available, the design model of the array element is returned.
+
+    Parameters
+    ----------
+    array_element_name: str
+        Name of the array element model (e.g. MSTN-01).
+    db: DBHandler
+        Instance of the database handler
+    model_version: str
+        Model version.
+    collection: str
+        DB collection to get the array elements from (e.g., telescopes, calibration_devices)
+
+    Returns
+    -------
+    list
+        List of array element model names as used in the DB.
+
+    """
+    try:
+        _available_array_elements = get_array_elements(
+            db.get_collection(db_name=None, collection_name=collection),
+            db.model_version(model_version),
+        )
+    except ValueError:
+        return [names.get_array_element_type_from_name(array_element_name) + "-design"]
+    try:
+        return [_available_array_elements[array_element_name], array_element_name]
+    except KeyError:
+        pass
+
+    if array_element_name in _available_array_elements.values():
+        return [array_element_name]
+
+    raise ValueError(f"Array element {array_element_name} not found in DB.")
+
+
+def get_array_elements_of_type(array_element_type, db, model_version, collection):
+    """
+    Get all array elements of a certain type in the specified collection in the DB.
+
+    Return e.g. for array_element_type='MSTS' all MSTS array elements found in the collection.
+
+    Parameters
+    ----------
+    array_element_type : str
+        Type of the array element (e.g. LSTN, MSTS)
+    model_version : str
+        Which version to get the array elements of
+    collection : str
+        Which collection to get the array elements from:
+        i.e. telescopes, calibration_devices
+    db_name : str
+        Database name
+
+    Returns
+    -------
+    list
+        Sorted list of all array element names found in collection
+
+    """
+    _available_array_elements = get_array_elements(
+        db.get_collection(db_name=None, collection_name=collection),
+        db.model_version(model_version),
+    )
+    return sorted(
+        [entry for entry in _available_array_elements if entry.startswith(array_element_type)]
+    )

simtools/db/db_from_repo_handler.py

@@ -0,0 +1,106 @@
+"""
+Module to mimic DB interaction for simulation model DB development.
+
+Read simulation model values from files in simulation model repository.
+
+"""
+
+import logging
+
+import simtools.utils.general as gen
+from simtools.utils import names
+
+logger = logging.getLogger(__name__)
+
+
+def update_model_parameters_from_repo(
+    parameters,
+    site,
+    array_element_name,
+    parameter_collection,
+    model_version,
+    db_simulation_model_url,
+):
+    """
+    Update model parameters with values from a repository.
+
+    Existing entries will be updated, new entries will be added.
+
+    Parameters
+    ----------
+    parameters: dict
+        Existing dictionary with parameters to be updated.
+    site: str
+        Observatory site (e.g., South or North)
+    array_element_name: str
+        Array element name (e.g., MSTN-01, MSTN-design)
+    parameter_collection: str
+        Collection of parameters to be queried (e.g., telescope or site)
+    model_version: str
+        Model version to use.
+    db_simulation_model_url: str
+        URL to the simulation model repository.
+
+    Returns
+    -------
+    dict
+        Updated dictionary with parameters.
+
+    """
+    logger.info(
+        "Updating model parameters from repository for site: %s, array element: %s",
+        site,
+        array_element_name,
+    )
+
+    if db_simulation_model_url is None:
+        logger.debug(f"No repository specified, skipping {parameter_collection} parameter updates")
+        return parameters
+
+    if parameter_collection in ["telescopes", "calibration"]:
+        _file_path = gen.join_url_or_path(
+            db_simulation_model_url,
+            "model_versions",
+            model_version,
+            array_element_name,
+        )
+        # use design array element model in case there is no model defined for this array element ID
+        _design_model = names.get_array_element_type_from_name(array_element_name) + "-design"
+        if _design_model == array_element_name:
+            _design_model = None
+    elif parameter_collection == "site":
+        _file_path = gen.join_url_or_path(
+            db_simulation_model_url,
+            "model_versions",
+            model_version,
+            "OBS-" + site,
+        )
+        _design_model = None
+    else:
+        raise ValueError(f"Unknown parameter collection {parameter_collection}")
+
+    for key in parameters:
+        _tmp_par = {}
+        _parameter_file = gen.join_url_or_path(_file_path, f"{key}.json")
+        try:
+            _tmp_par = gen.collect_data_from_file(file_name=_parameter_file)
+        except (FileNotFoundError, gen.InvalidConfigDataError):
+            # use design array element model in case there is no model defined for this
+            #  array element ID. Accept errors, as not all parameters are defined in the repository
+            try:
+                _file_path = gen.join_url_or_path(
+                    db_simulation_model_url,
+                    "model_versions",
+                    model_version,
+                    _design_model,
+                )
+                _tmp_par = gen.collect_data_from_file(
+                    file_name=gen.join_url_or_path(_file_path, f"{key}.json")
+                )
+            except (FileNotFoundError, TypeError, gen.InvalidConfigDataError):
+                pass
+        if _tmp_par.get("version") == model_version:
+            parameters[key] = _tmp_par
+
+    # return all entries which are not None
+    return {key: value for key, value in parameters.items() if value is not None}