gammasimtools 0.25.0__py3-none-any.whl → 0.27.0__py3-none-any.whl

simtools/model/array_model.py

@@ -1,4 +1,4 @@
-"""Definition of the ArrayModel class."""
+"""Array model represents an observatory consisting of site, telescopes, and further devices."""
 
 import logging
 from pathlib import Path
@@ -9,9 +9,10 @@ from astropy.table import QTable
 from simtools.data_model import data_reader, schema
 from simtools.io import io_handler
 from simtools.model.calibration_model import CalibrationModel
+from simtools.model.model_utils import read_overwrite_model_parameter_dict
 from simtools.model.site_model import SiteModel
 from simtools.model.telescope_model import TelescopeModel
-from simtools.simtel.simtel_config_writer import SimtelConfigWriter
+from simtools.simtel import simtel_config_writer, simtel_seeds
 from simtools.utils import general, names
 
 
@@ -21,8 +22,6 @@ class ArrayModel:
 
     Parameters
     ----------
-    db_config: dict
-        Database configuration.
     model_version: str
         Model version.
     label: str, optional
@@ -36,28 +35,22 @@ class ArrayModel:
         the array element positions).
     calibration_device_types: List[str], optional
         List of calibration device types (e.g., 'flat_fielding') attached to each telescope.
-    simtel_path: str, Path, optional
-        Path to the sim_telarray installation directory.
     overwrite_model_parameters: str, optional
         File name to overwrite model parameters from DB with provided values.
     """
 
     def __init__(
         self,
-        db_config,
         model_version,
         label=None,
         site=None,
         layout_name=None,
         array_elements=None,
         calibration_device_types=None,
-        simtel_path=None,
         overwrite_model_parameters=None,
     ):
         """Initialize ArrayModel."""
         self._logger = logging.getLogger(__name__)
-        self._logger.debug("Init ArrayModel")
-        self.db_config = db_config
         self.model_version = model_version
         self.label = label
         self.layout_name = (
@@ -69,7 +62,9 @@ class ArrayModel:
         self._config_file_directory = None
         self.io_handler = io_handler.IOHandler()
 
-        self.overwrite_model_parameters = overwrite_model_parameters
+        self.overwrite_model_parameter_dict = read_overwrite_model_parameter_dict(
+            overwrite_model_parameters
+        )
 
         self.array_elements, self.site_model, self.telescope_models, self.calibration_models = (
             self._initialize(site, array_elements, calibration_device_types)
@@ -77,8 +72,7 @@ class ArrayModel:
 
         self._telescope_model_files_exported = False
         self._array_model_file_exported = False
-        self._sim_telarray_seeds = None
-        self.simtel_path = simtel_path
+        self.sim_telarray_seed = None
 
     def _initialize(self, site, array_elements_config, calibration_device_types):
         """
@@ -105,10 +99,9 @@ class ArrayModel:
         self._logger.debug(f"Getting site parameters from DB ({site})")
         site_model = SiteModel(
             site=names.validate_site_name(site),
-            db_config=self.db_config,
             model_version=self.model_version,
             label=self.label,
-            overwrite_model_parameters=self.overwrite_model_parameters,
+            overwrite_model_parameter_dict=self.overwrite_model_parameter_dict,
         )
 
         # Case 1: array_elements is a file name
@@ -136,41 +129,6 @@ class ArrayModel:
 
         return array_elements, site_model, telescope_models, calibration_models
 
-    @property
-    def sim_telarray_seeds(self):
-        """
-        Return sim_telarray seeds.
-
-        Returns
-        -------
-        dict
-            Dictionary with sim_telarray seeds.
-        """
-        return self._sim_telarray_seeds
-
-    @sim_telarray_seeds.setter
-    def sim_telarray_seeds(self, value):
-        """
-        Set sim_telarray seeds.
-
-        Parameters
-        ----------
-        value: dict
-            Dictionary with sim_telarray seeds.
-        """
-        if isinstance(value, dict):
-            required_keys = {
-                "seed",
-                "random_instrument_instances",
-                "seed_file_name",
-            }
-            if not required_keys.issubset(value):
-                raise ValueError(
-                    "sim_telarray_seeds dictionary must contain the following keys: "
-                    f"{required_keys}"
-                )
-        self._sim_telarray_seeds = value
-
     @property
     def config_file_path(self):
         """
@@ -250,9 +208,8 @@ class ArrayModel:
                 site=site_model.site,
                 telescope_name=element_name,
                 model_version=self.model_version,
-                db_config=self.db_config,
                 label=self.label,
-                overwrite_model_parameters=self.overwrite_model_parameters,
+                overwrite_model_parameter_dict=self.overwrite_model_parameter_dict,
             )
             calibration_models[element_name] = self._build_calibration_models(
                 telescope_models[element_name],
@@ -282,10 +239,9 @@ class ArrayModel:
             calibration_models[device_name] = CalibrationModel(
                 site=site_model.site,
                 calibration_device_model_name=device_name,
-                db_config=self.db_config,
                 model_version=self.model_version,
                 label=self.label,
-                overwrite_model_parameters=self.overwrite_model_parameters,
+                overwrite_model_parameter_dict=self.overwrite_model_parameter_dict,
             )
         return calibration_models
 
@@ -300,7 +256,6 @@ class ArrayModel:
         for tel_model in self.telescope_models.values():
             name = tel_model.name
             if name not in exported_models:
-                self._logger.debug(f"Exporting configuration file for telescope {name}")
                 tel_model.write_sim_telarray_config_file(
                     additional_models=self.calibration_models.get(tel_model.name)
                 )
@@ -317,12 +272,11 @@ class ArrayModel:
         self.site_model.export_model_files()
 
         self._logger.info(f"Writing array configuration file into {self.config_file_path}")
-        simtel_writer = SimtelConfigWriter(
+        simtel_writer = simtel_config_writer.SimtelConfigWriter(
             site=self.site_model.site,
             layout_name=self.layout_name,
             model_version=self.model_version,
             label=self.label,
-            simtel_path=self.simtel_path,
         )
         simtel_writer.write_array_config_file(
             config_file_path=self.config_file_path,
@@ -543,10 +497,16 @@ class ArrayModel:
         dict
             Dictionary with additional metadata.
         """
-        metadata = {}
-        if self.sim_telarray_seeds is not None:
-            metadata.update(self.sim_telarray_seeds)
-
-        metadata["nsb_integrated_flux"] = self.site_model.get_nsb_integrated_flux()
+        return {
+            "nsb_integrated_flux": self.site_model.get_nsb_integrated_flux(),
+        }
 
-        return metadata
+    def initialize_seeds(self, zenith_angle=None, azimuth_angle=None):
+        """Initialize sim_telarray seeds for instrument and shower simulations."""
+        self.sim_telarray_seed = simtel_seeds.SimtelSeeds(
+            output_path=self.get_config_directory(),
+            site=self.site_model.site,
+            model_version=self.model_version,
+            zenith_angle=zenith_angle,
+            azimuth_angle=azimuth_angle,
+        )

simtools/model/calibration_model.py

@@ -17,34 +17,30 @@ class CalibrationModel(ModelParameter):
         Site name (e.g., South or North).
     calibration_device_model_name: str
         Calibration device model name (ex. ILLS-01, ILLN-01, ...).
-    db_config: dict
-        Database configuration.
     model_version: str
         Model version.
     label: str, optional
         Instance label. Important for output file naming.
-    overwrite_model_parameters: str, optional
-        File name to overwrite model parameters from DB with provided values.
+    overwrite_model_parameter_dict: dict, optional
+        Dictionary to overwrite model parameters from DB with provided values.
     """
 
     def __init__(
         self,
         site,
         calibration_device_model_name,
-        db_config,
         model_version,
         label=None,
-        overwrite_model_parameters=None,
+        overwrite_model_parameter_dict=None,
     ):
         """Initialize CalibrationModel."""
         super().__init__(
             site=site,
             array_element_name=calibration_device_model_name,
             collection="calibration_devices",
-            db_config=db_config,
             model_version=model_version,
             label=label,
-            overwrite_model_parameters=overwrite_model_parameters,
+            overwrite_model_parameter_dict=overwrite_model_parameter_dict,
         )
 
         self._logger = logging.getLogger(__name__)

simtools/model/legacy_model_parameter.py

@@ -0,0 +1,134 @@
+#!/usr/bin/python3
+"""
+Handling of legacy model parameters for backward compatibility.
+
+Collects routines to convert legacy model parameters to more recent
+formats. This is a fine-tuned process and requires to hard wire the
+changes. All code related to legacy model parameters should go into
+this module.
+
+"""
+
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+UPDATE_HANDLERS = {}
+
+
+def register_update(name):
+    """Register update handler for legacy model parameter."""
+
+    def deco(func):
+        UPDATE_HANDLERS[name] = func
+        return func
+
+    return deco
+
+
+def apply_legacy_updates_to_parameters(parameters, legacy_updates):
+    """Apply legacy updates to model parameters.
+
+    Modifies the parameters dictionary in-place.
+
+    Parameters
+    ----------
+    parameters: dict
+        Dictionary of model parameters (all parameters).
+    legacy_updates: dict
+        Dictionary of legacy updates to apply.
+    """
+    for par_name, legacy_data in legacy_updates.items():
+        if legacy_data is None or par_name not in parameters:
+            continue
+        for key in parameters[par_name].keys():
+            if key in legacy_data:
+                parameters[par_name][key] = legacy_data[key]
+        if legacy_data.get("remove_parameter", False):
+            parameters.pop(par_name)
+
+
+def update_parameter(par_name, parameters, schema_version):
+    """Update legacy model parameters to recent formats.
+
+    Parameters
+    ----------
+    par_name: str
+        Model parameter name.
+    parameters: dict
+        Dictionary of model parameters (all parameters).
+    schema_version: str
+        Target schema version.
+
+    Returns
+    -------
+    dict
+        Updated model parameter.
+    """
+    handler = UPDATE_HANDLERS.get(par_name)
+    if handler is None:
+        raise ValueError(_get_unsupported_update_message(parameters[par_name], schema_version))
+    return handler(parameters, schema_version)
+
+
+@register_update("dsum_threshold")
+def _update_dsum_threshold(parameters, schema_version):
+    """Update legacy dsum_threshold parameter."""
+    para_data = parameters["dsum_threshold"]
+    if para_data["model_parameter_schema_version"] == "0.1.0" and schema_version == "0.2.0":
+        logger.info(
+            "Updating legacy model parameter dsum_threshold from schema version "
+            f"{para_data['model_parameter_schema_version']} to {schema_version}"
+        )
+        return {
+            para_data["parameter"]: {
+                "value": int(para_data["value"]),
+                "model_parameter_schema_version": schema_version,
+            }
+        }
+    raise ValueError(_get_unsupported_update_message(para_data, schema_version))
+
+
+@register_update("corsika_starting_grammage")
+def _update_corsika_starting_grammage(parameters, schema_version):
+    """Update legacy corsika_starting_grammage parameter (dummy function until model is updated)."""
+    logger.debug(f"No fix applied to corsika_starting_grammage to schema version {schema_version}")
+    return {
+        parameters["corsika_starting_grammage"]["parameter"]: None,
+    }
+
+
+@register_update("flasher_pulse_shape")
+def _update_flasher_pulse_shape(parameters, schema_version):
+    """Update legacy flasher_pulse_shape parameter."""
+    para_data = parameters["flasher_pulse_shape"]
+    if para_data["model_parameter_schema_version"] == "0.1.0" and schema_version == "0.2.0":
+        logger.info(
+            f"Updating legacy model parameter flasher_pulse_shape from schema version "
+            f"{para_data['model_parameter_schema_version']} to {schema_version}"
+        )
+        return {
+            para_data["parameter"]: {
+                "value": [
+                    para_data["value"],
+                    parameters.get("flasher_pulse_width", {}).get("value", 0.0),
+                    parameters.get("flasher_pulse_exp_decay", {}).get("value", 0.0),
+                ],
+                "model_parameter_schema_version": schema_version,
+                "unit": [None, "ns", "ns"],
+                "type": ["string", "float64", "float64"],
+            },
+            "flasher_pulse_width": {"remove_parameter": True},
+            "flasher_pulse_exp_decay": {"remove_parameter": True},
+        }
+
+    raise ValueError(_get_unsupported_update_message(para_data, schema_version))
+
+
+def _get_unsupported_update_message(para_data, schema_version):
+    """Get unsupported update message."""
+    return (
+        f"Unsupported update for legacy parameter {para_data['parameter']}: "
+        f"{para_data['model_parameter_schema_version']} to {schema_version}"
+    )