gammasimtools 0.10.0__py3-none-any.whl → 0.12.0__py3-none-any.whl

simtools/dependencies.py

@@ -0,0 +1,112 @@
+"""
+Simtools dependencies version management.
+
+This modules provides two main functionalities:
+
+- retrieve the versions of simtools dependencies (e.g., databases, sim_telarray, CORSIKA)
+- provide space for future implementations of version management
+
+"""
+
+import logging
+import os
+import re
+import subprocess
+from pathlib import Path
+
+import simtools.utils.general as gen
+from simtools.db.db_handler import DatabaseHandler
+
+_logger = logging.getLogger(__name__)
+
+
+def get_version_string(db_config=None):
+    """Print the versions of the dependencies."""
+    return (
+        f"Database version: {get_database_version(db_config)}\n"
+        f"sim_telarray version: {get_sim_telarray_version()}\n"
+        f"CORSIKA version: {get_corsika_version()}\n"
+    )
+
+
+def get_database_version(db_config):
+    """
+    Get the version of the simulation model data base used.
+
+    Parameters
+    ----------
+    db_config : dict
+        Dictionary containing the database configuration.
+
+    Returns
+    -------
+    str
+        Version of the simulation model data base used.
+
+    """
+    if db_config is None:
+        return None
+    db = DatabaseHandler(db_config)
+    return db.mongo_db_config.get("db_simulation_model")
+
+
+def get_sim_telarray_version():
+    """
+    Get the version of the sim_telarray package using 'sim_telarray --version'.
+
+    Returns
+    -------
+    str
+        Version of the sim_telarray package.
+    """
+    sim_telarray_path = os.getenv("SIMTOOLS_SIMTEL_PATH")
+    if sim_telarray_path is None:
+        _logger.warning("Environment variable SIMTOOLS_SIMTEL_PATH is not set.")
+        return None
+    sim_telarray_path = Path(sim_telarray_path) / "sim_telarray" / "bin" / "sim_telarray"
+
+    # expect stdout with e.g. a line 'Release: 2024.271.0 from 2024-09-27'
+    result = subprocess.run(
+        [sim_telarray_path, "--version"],
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    match = re.search(r"^Release:\s+(.+)", result.stdout, re.MULTILINE)
+
+    if match:
+        return match.group(1).split()[0]
+    raise ValueError(f"sim_telarray release not found in {result.stdout}")
+
+
+def get_corsika_version():
+    """
+    Get the version of the corsika package.
+
+    Returns
+    -------
+    str
+        Version of the corsika package.
+    """
+    try:
+        build_opts = get_build_options()
+    except (FileNotFoundError, TypeError):
+        _logger.warning("CORSIKA version not implemented yet.")
+        return None
+    return build_opts.get("corsika_version")
+
+
+def get_build_options():
+    """
+    Return CORSIKA / sim_telarray build options.
+
+    Expects a build_opts.yml file in the sim_telarray directory.
+    """
+    try:
+        return gen.collect_data_from_file(
+            Path(os.getenv("SIMTOOLS_SIMTEL_PATH")) / "build_opts.yml"
+        )
+    except FileNotFoundError as exc:
+        raise FileNotFoundError("No build_opts.yml file found.") from exc
+    except TypeError as exc:
+        raise TypeError("SIMTOOLS_SIMTEL_PATH not defined.") from exc

simtools/layout/array_layout.py

@@ -445,9 +445,11 @@ class ArrayLayout:
             )
             try:
                 tel_model = self._get_telescope_model(telescope_name)
-            except ValueError:
+            except ValueError:  # telescope not found in the database revert to design model
                 tel_model = self._get_telescope_model(
-                    names.get_array_element_type_from_name(telescope_name) + "-design",
+                    names.array_element_design_types(
+                        names.get_array_element_type_from_name(telescope_name)
+                    )[0]
                 )
 
             for para in ("telescope_axis_height", "telescope_sphere_radius"):
@@ -716,8 +718,7 @@ class ArrayLayout:
                     set(_telescope_list_from_name + _telescope_list_from_type)
                 )
             self._logger.info(
-                f"Selected {len(self._telescope_list)} telescopes"
-                f" (from originally {_n_telescopes})"
+                f"Selected {len(self._telescope_list)} telescopes (from originally {_n_telescopes})"
             )
         except TypeError:
             self._logger.info("No asset list provided, keeping all telescopes")

simtools/model/model_parameter.py

@@ -76,6 +76,9 @@ class ModelParameter:
             if array_element_name is not None
             else None
         )
+        self.design_model = self.db.get_design_model(
+            self.model_version, self.name, collection="telescopes"
+        )
         self._config_file_directory = None
         self._config_file_path = None
         self._load_parameters_from_db()
@@ -239,6 +242,22 @@ class ModelParameter:
             self._logger.debug(f"Parameter {par_name} does not have a file associated with it.")
         return False
 
+    def get_parameter_version(self, par_name):
+        """
+        Get version for a given parameter used in the model.
+
+        Parameters
+        ----------
+        par_name: str
+            Name of the parameter.
+
+        Returns
+        -------
+        str
+            parameter version used in the model (eg. '1.0.0')
+        """
+        return self._get_parameter_dict(par_name)["parameter_version"]
+
     def print_parameters(self):
         """Print parameters and their values for debugging purposes."""
         for par in self._parameters:
@@ -281,6 +300,21 @@ class ModelParameter:
         """
         return self._simulation_config_parameters.get(simulation_software)
 
+    def has_parameter(self, par_name):
+        """Check if a parameter exists in the model.
+
+        Parameters
+        ----------
+        par_name : str
+            Name of the parameter.
+
+        Returns
+        -------
+        bool
+            True if parameter exists in the model.
+        """
+        return par_name in self._parameters
+
     def _load_simulation_software_parameter(self):
         """Read simulation software parameters from DB."""
         for simulation_software in self._simulation_config_parameters:
@@ -409,8 +443,7 @@ class ModelParameter:
             )
 
         self._logger.debug(
-            f"Changing parameter {par_name} "
-            f"from {self.get_parameter_value(par_name)} to {value}"
+            f"Changing parameter {par_name} from {self.get_parameter_value(par_name)} to {value}"
         )
         self._parameters[par_name]["value"] = value
 

simtools/production_configuration/calculate_statistical_errors_grid_point.py

@@ -81,8 +81,7 @@ class StatisticalErrorEvaluator:
         unique_zeniths = 90 * u.deg - np.unique(events_data["PNT_ALT"]) * u.deg
         if len(unique_azimuths) > 1 or len(unique_zeniths) > 1:
             msg = (
-                f"Multiple values found for azimuth ({unique_azimuths}) "
-                f"zenith ({unique_zeniths})."
+                f"Multiple values found for azimuth ({unique_azimuths}) zenith ({unique_zeniths})."
             )
             self._logger.error(msg)
             raise ValueError(msg)
@@ -326,15 +325,15 @@ class StatisticalErrorEvaluator:
     def calculate_metrics(self):
         """Calculate all defined metrics as specified in self.metrics and store results."""
         if "uncertainty_effective_area" in self.metrics:
-
             self.uncertainty_effective_area = self.calculate_uncertainty_effective_area()
             if self.uncertainty_effective_area:
                 energy_range = self.metrics.get("uncertainty_effective_area", {}).get(
                     "energy_range"
                 )
-                min_energy, max_energy = energy_range["value"][0] * u.Unit(
-                    energy_range["unit"]
-                ), energy_range["value"][1] * u.Unit(energy_range["unit"])
+                min_energy, max_energy = (
+                    energy_range["value"][0] * u.Unit(energy_range["unit"]),
+                    energy_range["value"][1] * u.Unit(energy_range["unit"]),
+                )
 
                 valid_errors = [
                     error

simtools/production_configuration/event_scaler.py

@@ -19,21 +19,18 @@ class EventScaler:
     Supports scaling both the entire dataset and specific grid points like energy values.
     """
 
-    def __init__(self, evaluator, science_case: str, metrics: dict):
+    def __init__(self, evaluator, metrics: dict):
         """
-        Initialize the EventScaler with the evaluator, science case, and metrics.
+        Initialize the EventScaler with the evaluator and metrics.
 
         Parameters
         ----------
         evaluator : StatisticalErrorEvaluator
             The evaluator responsible for calculating metrics and handling event data.
-        science_case : str
-            The science case used to adjust the uncertainty factor.
         metrics : dict
             Dictionary containing metrics, including target error for effective area.
         """
         self.evaluator = evaluator
-        self.science_case = science_case
         self.metrics = metrics
 
     def scale_events(self, return_sum: bool = True) -> u.Quantity:
@@ -77,20 +74,7 @@ class EventScaler:
             "value"
         ]
 
-        return (
-            current_max_error / target_max_error
-        ) ** 2 * self._apply_science_case_scaling_factor()
-
-    def _apply_science_case_scaling_factor(self) -> float:
-        """
-        Apply the uncertainty factor based on the science case.
-
-        Returns
-        -------
-        float
-            The final scaling factor after applying uncertainty.
-        """
-        return 1 if self.science_case == "science case 1" else 1.0
+        return (current_max_error / target_max_error) ** 2
 
     def _number_of_simulated_events(self) -> u.Quantity:
         """

simtools/production_configuration/generate_simulation_config.py

@@ -16,10 +16,6 @@ class SimulationConfig:
     ----------
     grid_point : dict
         Dictionary representing a grid point with azimuth, elevation, and night sky background.
-    ctao_data_level : str
-        The data level (e.g., 'A', 'B', 'C') for the simulation configuration.
-    science_case : str
-        The science case for the simulation configuration.
     file_path : str
         Path to the DL2 MC event file for statistical uncertainty evaluation.
     file_type : str
@@ -31,26 +27,22 @@ class SimulationConfig:
     def __init__(
         self,
         grid_point: dict[str, float],
-        ctao_data_level: str,
-        science_case: str,
         file_path: str,
         file_type: str,
         metrics: dict[str, float] | None = None,
     ):
         """Initialize the simulation configuration for a grid point."""
         self.grid_point = grid_point
-        self.ctao_data_level = ctao_data_level
-        self.science_case = science_case
         self.file_path = file_path
         self.file_type = file_type
         self.metrics = metrics or {}
         self.evaluator = StatisticalErrorEvaluator(file_path, file_type, metrics)
-        self.event_scaler = EventScaler(self.evaluator, science_case, self.metrics)
+        self.event_scaler = EventScaler(self.evaluator, self.metrics)
         self.simulation_params = {}
 
     def configure_simulation(self) -> dict[str, float]:
         """
-        Configure the simulation parameters for the grid point, data level, and science case.
+        Configure the simulation parameters for the grid point.
 
         Returns
         -------
@@ -80,7 +72,7 @@ class SimulationConfig:
 
     def _calculate_core_scatter_area(self) -> float:
         """
-        Calculate the core scatter area based on the grid point and data level.
+        Calculate the core scatter area based on the grid point.
 
         Returns
         -------
@@ -93,7 +85,7 @@ class SimulationConfig:
 
     def _calculate_viewcone(self) -> float:
         """
-        Calculate the viewcone based on the grid point conditions and data level.
+        Calculate the viewcone based on the grid point conditions.
 
         Returns
         -------

simtools/production_configuration/interpolation_handler.py

@@ -12,13 +12,10 @@ __all__ = ["InterpolationHandler"]
 class InterpolationHandler:
     """Handle interpolation between multiple StatisticalErrorEvaluator instances."""
 
-    def __init__(self, evaluators, science_case: str, metrics: dict):
+    def __init__(self, evaluators, metrics: dict):
         self.evaluators = evaluators
-        self.science_case = science_case
         self.metrics = metrics
-        self.event_scalers = [
-            EventScaler(e, self.science_case, self.metrics) for e in self.evaluators
-        ]
+        self.event_scalers = [EventScaler(e, self.metrics) for e in self.evaluators]
 
         self.azimuths = [e.grid_point[1].to(u.deg).value for e in self.evaluators]
         self.zeniths = [e.grid_point[2].to(u.deg).value for e in self.evaluators]

simtools/production_configuration/limits_calculation.py

@@ -0,0 +1,202 @@
+"""Calculate the thresholds for energy, radial distance, and viewcone."""
+
+import astropy.units as u
+import numpy as np
+
+
+class LimitCalculator:
+    """
+    Compute thresholds/limits for energy, radial distance, and viewcone.
+
+    Histograms are generated with simtools-generate-simtel-array-histograms with --hdf5 flag.
+
+    Event data is read from the generated HDF5 file from the following tables:
+    - angle_to_observing_position__triggered_showers_ for the viewcone limit.
+    - event_weight__ra3d__log10_e__ for the energy and radial distance limit.
+
+
+    Parameters
+    ----------
+    event_data_file : list of astropy.table.Table
+        The list of tables containing the event data.
+    """
+
+    def __init__(self, event_data_file_tables):
+        """
+        Initialize the LimitCalculator with the given event data file.
+
+        Parameters
+        ----------
+        event_data_file : list of astropy.table.Table
+            The list of tables containing the event data.
+        """
+        self.angle_to_observing_position__triggered_showers_ = None
+        self.event_weight__ra3d__log10_e__ = None
+
+        for table in event_data_file_tables:
+            if (
+                "Title" in table.meta
+                and table.meta["Title"] == "angle_to_observing_position__triggered_showers_"
+            ):
+                self.angle_to_observing_position__triggered_showers_ = table
+            elif "Title" in table.meta and table.meta["Title"] == "event_weight__ra3d__log10_e__":
+                self.event_weight__ra3d__log10_e__ = table
+
+    def _compute_limits(
+        self, event_weight_array, bin_edges, loss_fraction, axis=0, limit_type="lower"
+    ):
+        """
+        Compute the limits based on the loss fraction.
+
+        Parameters
+        ----------
+        event_weight_array : np.ndarray
+            Array of event weights.
+        bin_edges : np.ndarray
+            Array of bin edges.
+        loss_fraction : float
+            Fraction of events to be lost.
+        axis : int, optional
+            Axis along which to sum the event weights. Default is 0.
+        limit_type : str, optional
+            Type of limit ('lower' or 'upper'). Default is 'lower'.
+
+        Returns
+        -------
+        int
+            Bin index where the threshold is reached.
+        float
+            Bin edge value corresponding to the threshold.
+        """
+        projection = np.sum(event_weight_array, axis=axis)
+        bin_edge_value = None
+        cumulative_sum = None
+        if limit_type == "upper":
+            cumulative_sum = np.cumsum(projection)
+
+        elif limit_type == "lower":
+            cumulative_sum = np.cumsum(projection[::-1])
+
+        total_events = np.sum(projection)
+        threshold = (1 - loss_fraction) * total_events
+        bin_index = np.searchsorted(cumulative_sum, threshold)
+        if limit_type == "upper":
+            bin_edge_value = bin_edges[bin_index]
+        elif limit_type == "lower":
+            bin_edge_value = bin_edges[-bin_index]
+        return bin_index, bin_edge_value
+
+    def get_bin_edges_and_units(self, table, axis="x"):
+        """
+        Extract bin edges and units from the table metadata.
+
+        Parameters
+        ----------
+        table : astropy.table.Table
+            Table containing the event data.
+
+        Returns
+        -------
+        tuple
+            Tuple containing the bin edges and their units.
+        """
+        bin_edges = table.meta[f"{axis}_bin_edges"]
+        try:
+            bin_edges_unit = table.meta[f"{axis}_bin_edges_unit"]
+        except KeyError:
+            bin_edges_unit = ""
+        return bin_edges, bin_edges_unit
+
+    def compute_lower_energy_limit(self, loss_fraction):
+        """
+        Compute the lower energy limit in TeV based on the event loss fraction.
+
+        Parameters
+        ----------
+        loss_fraction : float
+            Fraction of events to be lost.
+
+        Returns
+        -------
+        astropy.units.Quantity
+            Lower energy limit.
+        """
+        event_weight_array = np.column_stack(
+            [
+                self.event_weight__ra3d__log10_e__[name]
+                for name in self.event_weight__ra3d__log10_e__.dtype.names
+            ]
+        )
+        bin_edges, bin_edges_unit = self.get_bin_edges_and_units(
+            self.event_weight__ra3d__log10_e__, axis="y"
+        )
+        if bin_edges_unit == "":
+            bin_edges_unit = "TeV"
+        _, lower_bin_edge_value = self._compute_limits(
+            event_weight_array, bin_edges, loss_fraction, axis=0, limit_type="lower"
+        )
+        return (10**lower_bin_edge_value) * u.Unit(bin_edges_unit)
+
+    def compute_upper_radial_distance(self, loss_fraction):
+        """
+        Compute the upper radial distance based on the event loss fraction.
+
+        Parameters
+        ----------
+        loss_fraction : float
+            Fraction of events to be lost.
+
+        Returns
+        -------
+        astropy.units.Quantity
+            Upper radial distance in m.
+        """
+        event_weight_array = np.column_stack(
+            [
+                self.event_weight__ra3d__log10_e__[name]
+                for name in self.event_weight__ra3d__log10_e__.dtype.names
+            ]
+        )
+        bin_edges, bin_edges_unit = self.get_bin_edges_and_units(
+            self.event_weight__ra3d__log10_e__, axis="x"
+        )
+        if bin_edges_unit == "":
+            bin_edges_unit = "m"
+        _, upper_bin_edge_value = self._compute_limits(
+            event_weight_array, bin_edges, loss_fraction, axis=1, limit_type="upper"
+        )
+        return upper_bin_edge_value * u.Unit(bin_edges_unit)
+
+    def compute_viewcone(self, loss_fraction):
+        """
+        Compute the viewcone based on the event loss fraction.
+
+        Parameters
+        ----------
+        loss_fraction : float
+            Fraction of events to be lost.
+
+        Returns
+        -------
+        astropy.units.Quantity
+            Viewcone radius in degrees.
+        """
+        angle_to_observing_position__triggered_showers = np.column_stack(
+            [
+                self.angle_to_observing_position__triggered_showers_[name]
+                for name in self.angle_to_observing_position__triggered_showers_.dtype.names
+            ]
+        )
+        bin_edges, bin_edges_unit = self.get_bin_edges_and_units(
+            self.angle_to_observing_position__triggered_showers_, axis="x"
+        )
+        if bin_edges_unit == "":
+            bin_edges_unit = "deg"
+        _, upper_bin_edge_value = self._compute_limits(
+            angle_to_observing_position__triggered_showers,
+            bin_edges,
+            loss_fraction,
+            axis=0,
+            limit_type="upper",
+        )
+        return upper_bin_edge_value * u.Unit(bin_edges_unit)