gammasimtools 0.14.0__py3-none-any.whl → 0.16.0__py3-none-any.whl

simtools/model/model_parameter.py

@@ -24,7 +24,8 @@ class ModelParameter:
     """
     Base class for simulation model parameters.
 
-    Provides methods to read and manipulate parameters from DB.
+    Provides methods to read and manipulate parameters from DB and to write
+    sim_telarray configuration files.
 
     Parameters
     ----------
@@ -64,7 +65,7 @@ class ModelParameter:
         )
 
         self._parameters = {}
-        self._simulation_config_parameters = {"corsika": {}, "simtel": {}}
+        self._simulation_config_parameters = {sw: {} for sw in names.simulation_software()}
         self.collection = collection
         self.label = label
         self.model_version = model_version
@@ -86,6 +87,34 @@ class ModelParameter:
         self._is_config_file_up_to_date = False
         self._is_exported_model_files_up_to_date = False
 
+    @property
+    def model_version(self):
+        """Model version."""
+        return self._model_version
+
+    @model_version.setter
+    def model_version(self, model_version):
+        """
+        Set model version.
+
+        Parameters
+        ----------
+        model_version: str or list
+            Model version (e.g., "6.0.0").
+            If a list is passed, it must contain exactly one element,
+            and only that element will be used.
+
+        Raises
+        ------
+        ValueError
+            If more than one model version is passed.
+        """
+        if isinstance(model_version, list):
+            raise ValueError(
+                f"Only one model version can be passed to {self.__class__.__name__}, not a list."
+            )
+        self._model_version = model_version
+
     @property
     def parameters(self):
         """
@@ -279,7 +308,7 @@ class ModelParameter:
             return
 
         self._config_file_directory = self.io_handler.get_output_directory(
-            label=self.label, sub_dir="model"
+            label=self.label, sub_dir=f"model/{self.model_version}"
         )
 
         # Setting file name and the location
@@ -322,32 +351,19 @@ class ModelParameter:
                         simulation_software=simulation_software,
                     )
                 )
-            except ValueError as exc:
-                self._logger.warning(
-                    f"No {simulation_software} parameters found for "
-                    f"{self.site}, {self.name} (model version {self.model_version}). "
-                    f" (Query {exc})"
-                )
+            except ValueError:
+                pass
 
     def _load_parameters_from_db(self):
         """Read parameters from DB and store them in _parameters."""
         if self.db is None:
             return
 
-        if self.name:
+        if self.name or self.site:
             self._parameters = self.db.get_model_parameters(
                 self.site, self.name, self.collection, self.model_version
             )
 
-        if self.site:
-            self._parameters.update(
-                self.db.get_model_parameters(
-                    self.site,
-                    None,
-                    "sites",
-                    self.model_version,
-                )
-            )
         self._load_simulation_software_parameter()
 
     @property
@@ -446,37 +462,66 @@ class ModelParameter:
         file_path: str
             Path of the file to be added to the config file directory.
         """
-        if self._added_parameter_files is None:
-            self._added_parameter_files = []
+        self._added_parameter_files = self._added_parameter_files or []
         self._added_parameter_files.append(par_name)
         shutil.copy(file_path, self.config_file_directory)
 
-    def export_model_files(self):
-        """Export the model files into the config file directory."""
+    def export_model_files(self, destination_path=None, update_if_necessary=False):
+        """
+        Export the model files into the config file directory.
+
+        Parameters
+        ----------
+        destination_path: str
+            Path to the directory where the model files should be exported.
+            If None, the config file directory is used.
+        update_if_necessary: bool
+            If True, the model files are only exported if they are not up to date.
+        """
+        if self._is_exported_model_files_up_to_date and update_if_necessary:
+            self._logger.debug(
+                f"Model files for {self.name} are already exported to {self.config_file_directory}"
+            )
+            return
         # Removing parameter files added manually (which are not in DB)
         pars_from_db = copy(self.parameters)
         if self._added_parameter_files is not None:
             for par in self._added_parameter_files:
                 pars_from_db.pop(par)
 
-        self.db.export_model_files(parameters=pars_from_db, dest=self.config_file_directory)
+        self.db.export_model_files(
+            parameters=pars_from_db,
+            dest=destination_path or self.config_file_directory,
+        )
         self._is_exported_model_files_up_to_date = True
 
-    def export_config_file(self):
-        """Export the config file used by sim_telarray."""
-        if not self._is_exported_model_files_up_to_date:
-            self.export_model_files()
+    def write_sim_telarray_config_file(self, additional_model=None):
+        """
+        Write the sim_telarray configuration file.
+
+        Parameters
+        ----------
+        additional_model: TelescopeModel or SiteModel
+            Model object for additional parameter to be written to the config file.
+        """
+        self.parameters.update(self._simulation_config_parameters.get("sim_telarray", {}))
+        self.export_model_files(update_if_necessary=True)
+
+        if additional_model:
+            self.parameters.update(additional_model.parameters)
+            additional_model.export_model_files(
+                self.config_file_directory, update_if_necessary=True
+            )
 
         self._load_simtel_config_writer()
         self.simtel_config_writer.write_telescope_config_file(
             config_file_path=self.config_file_path,
             parameters=self.parameters,
-            config_parameters=self._simulation_config_parameters["simtel"],
         )
 
     @property
     def config_file_directory(self):
-        """Directory for configure files. Configure, if necessary."""
+        """Directory for configuration files. Configure if not yet set."""
         if self._config_file_directory is None:
             self._set_config_file_directory_and_name()
         return self._config_file_directory
@@ -488,26 +533,6 @@ class ModelParameter:
             self._set_config_file_directory_and_name()
         return self._config_file_path
 
-    def get_config_file(self, no_export=False):
-        """
-        Get the path of the config file for sim_telarray.
-
-        The config file is produced if the file is not up to date.
-
-        Parameters
-        ----------
-        no_export: bool
-            Turn it on if you do not want the file to be exported.
-
-        Returns
-        -------
-        Path
-            Path of the exported config file for sim_telarray.
-        """
-        if not self._is_config_file_up_to_date and not no_export:
-            self.export_config_file()
-        return self.config_file_path
-
     def _load_simtel_config_writer(self):
         """Load the SimtelConfigWriter object."""
         if self.simtel_config_writer is None:
@@ -535,7 +560,7 @@ class ModelParameter:
         self.db.export_model_files(
             parameters={
                 "nsb_spectrum_at_2200m": {
-                    "value": self._simulation_config_parameters["simtel"][
+                    "value": self._simulation_config_parameters["sim_telarray"][
                         "correct_nsb_spectrum_to_telescope_altitude"
                     ]["value"],
                     "file": True,

simtools/model/model_utils.py

@@ -1,8 +1,10 @@
 #!/usr/bin/python3
-"""Helper functions calculations related to model parameters."""
+"""Helper functions related to model parameters."""
 
 import math
 
+from simtools.model.site_model import SiteModel
+from simtools.model.telescope_model import TelescopeModel
 from simtools.utils import names
 
 __all__ = [
@@ -11,6 +13,46 @@ __all__ = [
 ]
 
 
+def initialize_simulation_models(label, db_config, site, telescope_name, model_version):
+    """
+    Initialize simulation models for a single telescope and site model.
+
+    Parameters
+    ----------
+    label: str
+        Label for the simulation.
+    db_config: dict
+        Database configuration.
+    site: str
+        Name of the site.
+    telescope_name: str
+        Name of the telescope.
+    model_version: str
+        Version of the simulation model
+
+    Returns
+    -------
+    Tuple
+        Tuple containing the telescope model and site model.
+    """
+    tel_model = TelescopeModel(
+        site=site,
+        telescope_name=telescope_name,
+        mongo_db_config=db_config,
+        model_version=model_version,
+        label=label,
+    )
+    site_model = SiteModel(
+        site=site,
+        model_version=model_version,
+        mongo_db_config=db_config,
+        label=label,
+    )
+    for model in tel_model, site_model:
+        model.export_model_files()
+    return tel_model, site_model
+
+
 def compute_telescope_transmission(pars: list[float], off_axis: float) -> float:
     """
     Compute telescope transmission (0 < T < 1) for a given off-axis angle.

simtools/model/site_model.py

@@ -19,8 +19,8 @@ class SiteModel(ModelParameter):
         Site name (e.g., South or North).
     mongo_db_config: dict
         MongoDB configuration.
-    model_version: str
-        Model version.
+    model_version: str or list
+        Model version or list of model versions (in which case only the first one is used).
     label: str, optional
         Instance label. Important for output file naming.
     """
@@ -41,6 +41,7 @@ class SiteModel(ModelParameter):
             model_version=model_version,
             db=None,
             label=label,
+            collection="sites",
         )
 
     def get_reference_point(self) -> dict:

simtools/model/telescope_model.py

@@ -220,8 +220,8 @@ class TelescopeModel(ModelParameter):
         """
         try:
             file_name = self.get_parameter_value(par)
-        except KeyError:
-            logging.error(f"Parameter {par} does not exist")
+        except InvalidModelParameterError:
+            logging.warning(f"Parameter {par} does not exist")
             return False
 
         file = self.config_file_directory.joinpath(file_name)
@@ -269,11 +269,11 @@ class TelescopeModel(ModelParameter):
             self.config_file_directory.joinpath(self.get_parameter_value("optics_properties"))
         )
         if not np.isclose(ray_tracing_data["Off-axis angle"][0], 0):
-            self._logger.error(
+            msg = (
                 f"No value for the on-axis effective optical area exists."
                 f" The minimum off-axis angle is {ray_tracing_data['Off-axis angle'][0]}"
             )
-            raise ValueError
+            raise ValueError(msg)
         return ray_tracing_data["eff_area"][0]
 
     def read_incidence_angle_distribution(self, incidence_angle_dist_file: str) -> Table:

simtools/production_configuration/calculate_statistical_errors_grid_point.py

@@ -17,8 +17,6 @@ class StatisticalErrorEvaluator:
     ----------
     file_path : str
         Path to the DL2 MC event file.
-    file_type : str
-        Type of the file, either 'point-like' or 'cone'.
     metrics : dict, optional
         Dictionary of metrics to evaluate. Default is None.
     grid_point : tuple, optional
@@ -28,13 +26,11 @@ class StatisticalErrorEvaluator:
     def __init__(
         self,
         file_path: str,
-        file_type: str,
         metrics: dict[str, float],
         grid_point: tuple[float, float, float, float, float] | None = None,
     ):
         """Init the evaluator with a DL2 MC event file, its type, and metrics to calculate."""
         self._logger = logging.getLogger(__name__)
-        self.file_type = file_type
         self.metrics = metrics
         self.grid_point = grid_point
 

simtools/production_configuration/{event_scaler.py → derive_production_statistics.py}

@@ -1,27 +1,29 @@
 """
-Calculate the scaled number of events based on metrics.
+Calculate the event production statistics based on metrics.
 
-Module for scaling events based on statistical error metrics. Contains the `EventScaler` class,
-which scales the number of events for both the entire dataset and specific grid points.
-Scaling factors are calculated using error metrics and the evaluator's results.
+Module for calculating the production event statistics based on statistical error metrics.
+Contains the `ProductionStatisticsDerivator` class, which derives the number of events for
+both the entire dataset and specific grid points. Event statistic is calculated using error
+metrics and the evaluator's results.
 """
 
 import astropy.units as u
 import numpy as np
 
-__all__ = ["EventScaler"]
+__all__ = ["ProductionStatisticsDerivator"]
 
 
-class EventScaler:
+class ProductionStatisticsDerivator:
     """
-    Scales the number of events based on statistical error metrics.
+    Derives the production statistics based on statistical error metrics.
 
-    Supports scaling both the entire dataset and specific grid points like energy values.
+    Supports deriving statistics for both the entire dataset and
+    specific grid points like energy values.
     """
 
     def __init__(self, evaluator, metrics: dict):
         """
-        Initialize the EventScaler with the evaluator and metrics.
+        Initialize the ProductionStatisticsDerivator with the evaluator and metrics.
 
         Parameters
         ----------
@@ -33,22 +35,24 @@ class EventScaler:
         self.evaluator = evaluator
         self.metrics = metrics
 
-    def scale_events(self, return_sum: bool = True) -> u.Quantity:
+    def derive_statistics(self, return_sum: bool = True) -> u.Quantity:
         """
-        Calculate the scaled number of events based on statistical error metrics.
+        Derive the production statistics based on statistical error metrics.
 
         Parameters
         ----------
         return_sum : bool, optional
-            If True, returns the sum of scaled events for the entire set of MC events. If False,
-            returns the scaled events for each grid point along the energy axis. Default is True.
+            If True, returns the sum of production statistics for the entire set of MC events.
+            If False, returns the production statistics for each grid point along the energy axis.
+            Default is True.
 
         Returns
         -------
         u.Quantity
-            If 'return_sum' is True, returns the total scaled number of events as a u.Quantity.
-            If 'return_sum' is False, returns an array of scaled events along the energy axis as
-            a u.Quantity.
+            If 'return_sum' is True, returns the total
+            derived production statistics as a u.Quantity.
+            If 'return_sum' is False, returns an array of production statistics along the energy
+            axis as a u.Quantity.
         """
         scaling_factor = self._compute_scaling_factor()
 
@@ -87,12 +91,12 @@ class EventScaler:
         """
         return self.evaluator.data.get("simulated_event_histogram")
 
-    def calculate_scaled_events_at_grid_point(
+    def calculate_production_statistics_at_grid_point(
         self,
         grid_point: tuple,
     ) -> u.Quantity:
         """
-        Calculate the scaled number of events for a specific energy grid point.
+        Derive the production statistics for a specific energy grid point.
 
         Parameters
         ----------
@@ -102,7 +106,7 @@ class EventScaler:
         Returns
         -------
         float
-            The scaled number of events at the specified grid point (energy).
+            The derived production statistics at the specified grid point (energy).
         """
         energy = grid_point[0]
         bin_edges = self.evaluator.create_bin_edges()
@@ -113,7 +117,7 @@ class EventScaler:
         simulated_event_histogram = self.evaluator.data.get("simulated_event_histogram", [])
 
         if bin_idx < 0 or bin_idx >= len(simulated_event_histogram):
-            raise ValueError(f"Energy {energy} is outside the range of the simulated events data.")
+            raise ValueError(f"Energy {energy} is outside therange of the simulated events data.")
 
         base_events = self._number_of_simulated_events()
         base_event_at_energy = base_events[bin_idx]

simtools/production_configuration/derive_production_statistics_handler.py

@@ -0,0 +1,119 @@
+"""
+Module to run the StatisticalErrorEvaluator and interpolate results.
+
+This module provides the `ProductionStatisticsHandler` class, which manages the workflow for
+derivation of required number of events for a simulation production using pre-defined metrics.
+
+The module includes functionality to:
+- Initialize evaluators for statistical error calculations based on input parameters.
+- Perform interpolation using the initialized evaluators to estimate production statistics at a
+query point.
+- Write the results of the interpolation to an output file.
+"""
+
+import itertools
+import json
+import logging
+from pathlib import Path
+
+import astropy.units as u
+import numpy as np
+
+from simtools.production_configuration.calculate_statistical_errors_grid_point import (
+    StatisticalErrorEvaluator,
+)
+from simtools.production_configuration.interpolation_handler import InterpolationHandler
+from simtools.utils.general import collect_data_from_file
+
+
+class ProductionStatisticsHandler:
+    """
+    Handles the workflow for deriving production statistics.
+
+    This class manages the evaluation of statistical uncertainties from DL2 MC event files
+    and performs interpolation to estimate the required number of events for a simulation
+    production at a specified query point.
+    """
+
+    def __init__(self, args_dict):
+        """
+        Initialize the manager with the provided arguments.
+
+        Parameters
+        ----------
+        args_dict : dict
+            Dictionary of command-line arguments.
+        """
+        self.args = args_dict
+        self.logger = logging.getLogger(__name__)
+        self.output_path = Path(self.args.get("output_path", "."))
+        self.output_filepath = self.output_path.joinpath(f"{self.args['output_file']}")
+        self.metrics = collect_data_from_file(self.args["metrics_file"])
+        self.evaluator_instances = []
+
+    def initialize_evaluators(self):
+        """Initialize StatisticalErrorEvaluator instances for the given zeniths and offsets."""
+        if not (self.args["base_path"] and self.args["zeniths"] and self.args["camera_offsets"]):
+            self.logger.warning("No files read")
+            self.logger.warning(f"Base Path: {self.args['base_path']}")
+            self.logger.warning(f"Zeniths: {self.args['zeniths']}")
+            self.logger.warning(f"Camera offsets: {self.args['camera_offsets']}")
+            return
+
+        for zenith, offset in itertools.product(self.args["zeniths"], self.args["camera_offsets"]):
+            file_name = self.args["file_name_template"].format(zenith=int(zenith))
+            file_path = Path(self.args["base_path"]).joinpath(file_name)
+
+            if not file_path.exists():
+                self.logger.warning(f"File not found: {file_path}. Skipping.")
+                continue
+
+            evaluator = StatisticalErrorEvaluator(
+                file_path,
+                metrics=self.metrics,
+                grid_point=(None, None, zenith, None, offset * u.deg),
+            )
+            evaluator.calculate_metrics()
+            self.evaluator_instances.append(evaluator)
+
+    def perform_interpolation(self):
+        """Perform interpolation for the query point."""
+        if not self.evaluator_instances:
+            self.logger.error("No evaluators initialized. Cannot perform interpolation.")
+            return None
+
+        interpolation_handler = InterpolationHandler(self.evaluator_instances, metrics=self.metrics)
+        query_point = self.args.get("query_point")
+        if not query_point or len(query_point) != 5:
+            raise ValueError(
+                "Invalid query point format. "
+                f"Expected 5 values, got {len(query_point) if query_point else 'None'}."
+            )
+        query_points = np.array([self.args["query_point"]])
+        return interpolation_handler.interpolate(query_points)
+
+    def write_output(self, production_statistics):
+        """Write the derived event statistics to a file."""
+        output_data = {
+            "query_point": self.args["query_point"],
+            "production_statistics": production_statistics.tolist(),
+        }
+        self.output_filepath.parent.mkdir(parents=True, exist_ok=True)
+        with open(self.output_filepath, "w", encoding="utf-8") as f:
+            json.dump(output_data, f, indent=4)
+        self.logger.info(f"Output saved to {self.output_filepath}")
+        self.logger.info(
+            f"production statistics for grid point "
+            f"{self.args['query_point']}: {production_statistics}"
+        )
+
+    def run(self):
+        """Run the scaling and interpolation workflow."""
+        self.logger.info(f"Zeniths: {self.args['zeniths']}")
+        self.logger.info(f"Camera offsets: {self.args['camera_offsets']}")
+        self.logger.info(f"Query Point: {self.args['query_point']}")
+        self.logger.info(f"Metrics File: {self.args['metrics_file']}")
+
+        self.initialize_evaluators()
+        production_statistics = self.perform_interpolation()
+        self.write_output(production_statistics)