gammasimtools 0.15.0__py3-none-any.whl → 0.17.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_repository.py

@@ -0,0 +1,134 @@
+"""Utilities for managing the simulation models repository.
+
+Simulation model parameters and production tables are managed through
+a gitlab repository ('SimulationModels'). This module provides service
+functions to interact with and verify the repository.
+"""
+
+import logging
+from pathlib import Path
+
+from simtools.utils import general as gen
+from simtools.utils import names
+
+_logger = logging.getLogger(__name__)
+
+
+def verify_simulation_model_production_tables(simulation_models_path):
+    """
+    Verify the simulation model production tables in the specified path.
+
+    Checks that all model parameters defined in the production tables are
+    present in the simulation models repository.
+
+    Parameters
+    ----------
+    simulation_models_path : str
+        Path to the simulation models repository.
+
+    Returns
+    -------
+    bool
+        True if all parameters found, False if any missing.
+    """
+    productions_path = Path(simulation_models_path) / "simulation-models" / "productions"
+    production_files = list(productions_path.rglob("*.json"))
+
+    _logger.info(
+        f"Verifying {len(production_files)} simulation model production "
+        f"tables in {simulation_models_path}"
+    )
+
+    missing_files = []
+    total_checked = 0
+
+    for production_file in production_files:
+        file_missing, file_checked = _verify_model_parameters_for_production(
+            simulation_models_path, production_file
+        )
+        missing_files.extend(file_missing)
+        total_checked += file_checked
+
+    _logger.info(f"Checked {total_checked} parameters, {len(missing_files)} missing")
+
+    if missing_files:
+        for missing_file in missing_files:
+            _logger.error(f"Missing: {missing_file}")
+        return False
+
+    _logger.info("Verification passed: All parameters found")
+    return True
+
+
+def _verify_model_parameters_for_production(simulation_models_path, production_file):
+    """
+    Verify that model parameters defined in the production tables exist.
+
+    Parameters
+    ----------
+    simulation_models_path : str
+        Path to the simulation models repository.
+    production_file : Path
+        Path to the production file.
+
+    Returns
+    -------
+    tuple
+        (missing_files_list, total_checked_count)
+    """
+    production_table = gen.collect_data_from_file(production_file)
+    missing_files = []
+    total_checked = 0
+
+    parameters = production_table.get("parameters", {})
+    for array_element, par_dict in parameters.items():
+        if isinstance(par_dict, dict):
+            for param_name, param_version in par_dict.items():
+                total_checked += 1
+                parameter_file = _get_model_parameter_file_path(
+                    simulation_models_path, array_element, param_name, param_version
+                )
+                if parameter_file and not parameter_file.exists():
+                    missing_files.append(str(parameter_file))
+
+    return missing_files, total_checked
+
+
+def _get_model_parameter_file_path(
+    simulation_models_path, array_element, parameter_name, parameter_version
+):
+    """
+    Get the file path for a model parameter.
+
+    Take into account path structure based on collections and array elements.
+
+    Parameters
+    ----------
+    simulation_models_path : str
+        Path to the simulation models repository.
+    array_element : str
+        Name of the array element (e.g., 'telescope').
+    parameter_name : str
+        Name of the parameter.
+    parameter_version : str
+        Version of the parameter.
+
+    Returns
+    -------
+    Path
+        The file path to the model parameter JSON file.
+    """
+    collection = names.get_collection_name_from_parameter_name(parameter_name)
+    return (
+        Path(simulation_models_path)
+        / "simulation-models"
+        / "model_parameters"
+        / (
+            collection
+            if collection in ("configuration_sim_telarray", "configuration_corsika")
+            else ""
+        )
+        / (array_element if collection != "configuration_corsika" else "")
+        / parameter_name
+        / f"{parameter_name}-{parameter_version}.json"
+    )

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: