gammasimtools 0.9.0__py3-none-any.whl → 0.11.0__py3-none-any.whl

simtools/utils/value_conversion.py

@@ -87,7 +87,7 @@ def get_value_unit_type(value, unit_str=None):
     return base_value, _unit_as_string(base_unit), base_type
 
 
-def split_value_and_unit(value):
+def split_value_and_unit(value, is_integer=False):
     """
     Split a value into its value and unit.
 
@@ -98,6 +98,8 @@ def split_value_and_unit(value):
     ----------
     value: str, int, float, bool, u.Quantity
         Value to be parsed.
+    is_integer: bool
+        Flag to indicate if the value is an integer.
 
     Returns
     -------
@@ -105,40 +107,42 @@ def split_value_and_unit(value):
         Value and units as (value, unit), or lists of values and unites
     """
     if isinstance(value, u.Quantity):
-        return _split_value_is_quantity(value)
+        return _split_value_is_quantity(value, is_integer)
     if isinstance(value, str):
-        return _split_value_is_string(value)
+        return _split_value_is_string(value, is_integer)
     if isinstance(value, list | np.ndarray):
-        return _split_value_is_list(value)
+        return _split_value_is_list(value, is_integer)
     return value, None
 
 
-def _split_value_is_quantity(value):
+def _split_value_is_quantity(value, is_integer=False):
     """Split value and unit for an astropy Quantity."""
-    if isinstance(value.value, list | np.ndarray):  # type [100.0, 200] * u.m,
-        return list(value.value), [str(value.unit)] * len(value)
-    return value.value, str(value.unit)
+    if isinstance(value.value, list | np.ndarray):  # type [100.0, 200] * u.m
+        return [int(v) if is_integer else v for v in value.value], [str(value.unit)] * len(value)
+    return int(value.value) if is_integer else value.value, str(value.unit)
 
 
-def _split_value_is_string(value):
+def _split_value_is_string(value, is_integer=False):
     """Split vale and unit for a string."""
     if value.isdigit():  # single integer value
         return int(value), None
     try:  # single value with/without unit
-        return u.Quantity(value).value, str(u.Quantity(value).unit)
+        return int(u.Quantity(value).value) if is_integer else u.Quantity(value).value, str(
+            u.Quantity(value).unit
+        )
     except ValueError:
-        return _split_value_is_list(gen.convert_string_to_list(value))
+        return _split_value_is_list(gen.convert_string_to_list(value), is_integer)
     except TypeError:  # string value (not numerical)
         return value, None
 
 
-def _split_value_is_list(value):
+def _split_value_is_list(value, is_integer=False):
     """Split value and unit for a list."""
     value_list = []
     unit_list = []
     for item in value:
         _value, _unit = split_value_and_unit(item)
-        value_list.append(_value)
+        value_list.append(int(_value) if is_integer else _value)
         if isinstance(_unit, str):
             unit_list.append(_unit)
         else:

simtools/version.py

@@ -9,11 +9,11 @@ try:
         from ._dev_version import version
     except ImportError:
         from ._version import version
-except Exception:
+except Exception:  # pylint: disable=broad-except
     import warnings
 
     warnings.warn("Could not determine simtools version; this indicates a broken installation.")
     del warnings
-    version = "0.0.0"
+    version = "0.0.0"  # pylint: disable=invalid-name
 
 __version__ = version

simtools/visualization/legend_handlers.py

@@ -71,6 +71,7 @@ class TelescopeHandler:
     def __init__(self, radius=None):
         self.colors_dict = {
             "LSTN": "darkorange",
+            "MSTx": "dodgerblue",
             "MSTN": "dodgerblue",
             "LSTS": "darkorange",
             "MSTS": "dodgerblue",
@@ -84,6 +85,7 @@ class TelescopeHandler:
         # hardwired values; this is for plotting purposes only
         self.radius_dict = {
             "LSTN": 12.5,
+            "MSTx": 9.15,
             "MSTN": 9.15,
             "LSTS": 12.5,
             "MSTS": 9.15,

simtools/applications/db_add_model_parameters_from_repository_to_db.py

@@ -1,176 +0,0 @@
-#!/usr/bin/python3
-r"""
-    Add parameters found in a model parameter repository to a new database.
-
-    Generates a new database with all required collections.
-    Follows the structure of the CTAO gitlab model parameters repository.
-    file as input.
-
-    This is an application for experts and should not be used by the general user.
-
-    Command line arguments
-
-    input_path (str, required)
-        Path of local copy of model parameter repository.
-    db_name (str, required)
-        Name of new DB to be created.
-    type (str, optional)
-        Type of data to be uploaded to the DB. Options are: model_parameters
-
-    Examples
-    --------
-    Upload model data repository to the DB:
-
-    .. code-block:: console
-
-        simtools-db-add_model-parameters-from-repository-to-db \
-            --input_path /path/to/repository \
-            --db_name new_db_name \
-            --type model_parameters
-"""
-
-import logging
-from pathlib import Path
-
-import simtools.utils.general as gen
-from simtools.configuration import configurator
-from simtools.db import db_handler
-from simtools.utils import names
-
-
-def _parse(label=None, description=None):
-    """
-    Parse command line configuration.
-
-    Parameters
-    ----------
-    label : str
-        Label describing application.
-    description : str
-        Description of application.
-
-    Returns
-    -------
-    CommandLineParser
-        Command line parser object.
-    """
-    config = configurator.Configurator(label=label, description=description)
-    config.parser.add_argument(
-        "--input_path",
-        help="Path to model parameter repository.",
-        type=Path,
-        required=True,
-    )
-    config.parser.add_argument(
-        "--db_name",
-        help="Name of the new model parameter database to be created.",
-        type=str.strip,
-        required=True,
-    )
-    config.parser.add_argument(
-        "--type",
-        help="Type of data to be uploaded to the database.",
-        type=str,
-        required=False,
-        default="model_parameters",
-        choices=["model_parameters"],
-    )
-
-    args_dict, db_config = config.initialize(
-        output=True, require_command_line=True, db_config=True, simulation_model="version"
-    )
-    db_config["db_simulation_model"] = args_dict["db_name"]  # overwrite explicitly DB configuration
-    return args_dict, db_config
-
-
-def add_values_from_json_to_db(file, collection, db, db_name, file_prefix, logger):
-    """
-    Upload data from json files to db.
-
-    Parameters
-    ----------
-    file : list
-        Json file to be uploaded to the DB.
-    collection : str
-        The DB collection to which to add the file.
-    db : DatabaseHandler
-        Database handler object.
-    db_name : str
-        Name of the database to be created.
-    file_prefix : str
-        Path to location of all additional files to be uploaded.
-    logger : logging.Logger
-        Logger object.
-    """
-    par_dict = gen.collect_data_from_file(file_name=file)
-    logger.info(
-        f"Adding the following parameter to the DB: {par_dict['parameter']} "
-        f"(collection {collection} in database {db_name})"
-    )
-    db.add_new_parameter(
-        db_name=db_name,
-        par_dict=par_dict,
-        collection_name=collection,
-        file_prefix=file_prefix,
-    )
-
-
-def _add_model_parameters_to_db(args_dict, db, logger):
-    """
-    Add model parameters to the DB.
-
-    Parameters
-    ----------
-    args_dict : dict
-        Command line arguments.
-    db : DatabaseHandler
-        Database handler object.
-    logger : logging.Logger
-        Logger object.
-
-    """
-    input_path = Path(args_dict["input_path"])
-    array_elements = [d for d in input_path.iterdir() if d.is_dir()]
-    for element in array_elements:
-        try:
-            collection = names.get_collection_name_from_array_element_name(element.name)
-        except ValueError:
-            if element.name.startswith("OBS"):
-                collection = "sites"
-            elif element.name in {"configuration_sim_telarray", "configuration_corsika"}:
-                collection = element.name
-            elif element.name == "Files":
-                logger.info("Files are uploaded with the corresponding model parameters")
-                continue
-        logger.info(f"Reading model parameters for {element.name} into collection {collection}")
-        files_to_insert = list(Path(element).rglob("*json"))
-        for file in files_to_insert:
-            if collection == "files":
-                logger.info("Not yet implemented files")
-            else:
-                add_values_from_json_to_db(
-                    file=file,
-                    collection=collection,
-                    db=db,
-                    db_name=args_dict["db_name"],
-                    file_prefix=input_path / "Files",
-                    logger=logger,
-                )
-
-
-def main():
-    """Application main."""
-    label = Path(__file__).stem
-    args_dict, db_config = _parse(
-        label, description="Add or update a model parameter database to the DB"
-    )
-    logger = logging.getLogger()
-    logger.setLevel(gen.get_log_level_from_user(args_dict["log_level"]))
-
-    db = db_handler.DatabaseHandler(mongo_db_config=db_config)
-
-    _add_model_parameters_to_db(args_dict, db, logger)
-
-
-if __name__ == "__main__":
-    main()

simtools/db/db_array_elements.py

@@ -1,130 +0,0 @@
-"""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)]
-    )