gammasimtools 0.24.0__py3-none-any.whl → 0.26.0__py3-none-any.whl

simtools/model/model_parameter.py

@@ -11,6 +11,7 @@ import simtools.utils.general as gen
 from simtools.data_model import schema
 from simtools.db import db_handler
 from simtools.io import ascii_handler, io_handler
+from simtools.model import legacy_model_parameter
 from simtools.simtel.simtel_config_writer import SimtelConfigWriter
 from simtools.utils import names, value_conversion
 
@@ -28,8 +29,6 @@ class ModelParameter:
 
     Parameters
     ----------
-    db_config:
-        Database configuration dictionary.
     model_version: str
         Version of the model (ex. 5.0.0).
     site: str
@@ -51,7 +50,6 @@ class ModelParameter:
 
     def __init__(
         self,
-        db_config,
         model_version,
         site=None,
         array_element_name=None,
@@ -62,7 +60,9 @@ class ModelParameter:
     ):
         self._logger = logging.getLogger(__name__)
         self.io_handler = io_handler.IOHandler()
-        self.db = db_handler.DatabaseHandler(db_config=db_config)
+        self.db = db_handler.DatabaseHandler()
+        if not self.db.is_configured():
+            raise RuntimeError("Database is not configured.")
 
         self.parameters = {}
         self._simulation_config_parameters = {sw: {} for sw in names.simulation_software()}
@@ -271,7 +271,6 @@ class ModelParameter:
         # Setting file name and the location
         config_file_name = names.simtel_config_file_name(
             self.site,
-            self.model_version,
             telescope_model_name=self.name,
             label=self.label,
         )
@@ -328,35 +327,46 @@ class ModelParameter:
             )
             if self.overwrite_model_parameters:
                 self.overwrite_parameters_from_file(self.overwrite_model_parameters)
-            self._check_model_parameter_software_versions(self.parameters.keys())
+            self._check_model_parameter_versions(self.parameters)
 
         self._load_simulation_software_parameter()
         for software_name, parameters in self._simulation_config_parameters.items():
-            self._check_model_parameter_software_versions(
-                parameters.keys(), software_name=software_name
-            )
+            self._check_model_parameter_versions(parameters, software_name=software_name)
 
-    def _check_model_parameter_software_versions(self, parameter_list, software_name=None):
+    def _check_model_parameter_versions(self, parameters, software_name=None):
         """
-        Ensure that model parameters are compatible with the installed software versions.
+        Ensure parameters follow the latest schema and are compatible with installed software.
 
         Compares software versions listed in schema files with the installed software versions
         (e.g., sim_telarray, CORSIKA).
 
+        For outdated model parameter schemas, legacy update functions are called to update
+        the parameters to the latest schema version.
+
         Parameters
         ----------
-        parameter_list: list
-            List containing model parameter names.
+        parameters: dict
+            Dictionary containing model parameters.
         software_name: str
             Name of the software for which the parameters are checked.
         """
-        for par_name in parameter_list:
+        _legacy_updates = {}
+        for par_name, par_data in parameters.items():
             if par_name in (parameter_schema := names.model_parameters()):
                 schema.validate_deprecation_and_version(
                     data=parameter_schema[par_name],
                     software_name=software_name,
                     ignore_software_version=self.ignore_software_version,
                 )
+                _latest_schema_version = parameter_schema[par_name]["schema_version"]
+                if par_data["model_parameter_schema_version"] != _latest_schema_version:
+                    _legacy_updates.update(
+                        legacy_model_parameter.update_parameter(
+                            par_name, parameters, _latest_schema_version
+                        )
+                    )
+
+        legacy_model_parameter.apply_legacy_updates_to_parameters(parameters, _legacy_updates)
 
     def overwrite_model_parameter(self, par_name, value, parameter_version=None):
         """

simtools/model/model_repository.py

@@ -361,7 +361,7 @@ def _get_changes_to_production(
         _version_changes, base_model_version = _get_changes_to_production(
             _changes_dict, simulation_models_path, update_type="full_update"
         )
-        changes = _update_two_levels_in_changes_dict(changes, _version_changes)
+        changes = _update_two_levels_in_changes_dict(_version_changes, changes)
         # stop iterative loop after reaching first full version of production tables
         if _changes_dict.get("model_update", "full_update") == "full_update":
             break
@@ -461,7 +461,7 @@ def _create_new_model_parameter_entry(telescope, param, param_data, simulation_m
 
     param_dir = telescope_dir / param
     try:
-        latest_file = _get_latest_model_parameter_file(param_dir, param)
+        latest_file = _get_latest_model_parameter_file(param_dir, param, param_data["version"])
     except FileNotFoundError:
         latest_file = None
 
@@ -484,10 +484,11 @@ def _create_new_model_parameter_entry(telescope, param, param_data, simulation_m
         output_path=param_dir,
         unit=param_data.get("unit"),
         meta_parameter=param_data.get("meta_parameter", False),
+        model_parameter_schema_version=param_data.get("model_parameter_schema_version", None),
     )
 
 
-def _get_latest_model_parameter_file(directory, parameter):
+def _get_latest_model_parameter_file(directory, parameter, max_version):
     """
     Get the latest model parameter JSON file for a parameter in the given directory.
 
@@ -499,11 +500,14 @@ def _get_latest_model_parameter_file(directory, parameter):
         Path to the directory containing parameter JSON files.
     parameter: str
         Name of the parameter to find.
+    max_version: str
+        Maximum version to consider (inclusive). Files with versions greater than
+        this will be excluded.
 
     Returns
     -------
     str
-        Path to the latest JSON file for the parameter.
+        Path to the latest JSON file for the parameter with version <= max_version.
 
     Raises
     ------
@@ -521,7 +525,16 @@ def _get_latest_model_parameter_file(directory, parameter):
         # version is part after first '-'
         return parse_version(path.stem.split("-", 1)[1])
 
-    latest_file = max(files, key=extract_version)
+    max_ver = parse_version(max_version)
+    filtered_files = [f for f in files if extract_version(f) <= max_ver]
+
+    if not filtered_files:
+        raise FileNotFoundError(
+            f"No JSON files found for parameter '{parameter}' with version <= {max_version} "
+            f"in directory '{directory}'."
+        )
+
+    latest_file = max(filtered_files, key=extract_version)
     return str(latest_file)
 
 

simtools/model/model_utils.py

@@ -10,7 +10,7 @@ from simtools.utils import names
 
 
 def initialize_simulation_models(
-    label, db_config, model_version, site, telescope_name, calibration_device_name=None
+    label, model_version, site, telescope_name, calibration_device_name=None
 ):
     """
     Initialize simulation models for a single telescope, site, and calibration device model.
@@ -19,8 +19,6 @@ def initialize_simulation_models(
     ----------
     label: str
         Label for the simulation.
-    db_config: dict
-        Database configuration.
     model_version: str
         Version of the simulation model
     site: str
@@ -38,21 +36,18 @@ def initialize_simulation_models(
     tel_model = TelescopeModel(
         site=site,
         telescope_name=telescope_name,
-        db_config=db_config,
         model_version=model_version,
         label=label,
     )
     site_model = SiteModel(
         site=site,
         model_version=model_version,
-        db_config=db_config,
         label=label,
     )
     if calibration_device_name is not None:
         calibration_model = CalibrationModel(
             site=site,
             calibration_device_model_name=calibration_device_name,
-            db_config=db_config,
             model_version=model_version,
             label=label,
         )

simtools/model/site_model.py

@@ -26,8 +26,6 @@ class SiteModel(ModelParameter):
     ----------
     site: str
         Site name (e.g., South or North).
-    db_config: dict
-        Database configuration.
     model_version: str or list
         Model version or list of model versions (in which case only the first one is used).
     label: str, optional
@@ -41,7 +39,6 @@ class SiteModel(ModelParameter):
     def __init__(
         self,
         site,
-        db_config,
         model_version,
         label=None,
         overwrite_model_parameters=None,
@@ -52,7 +49,6 @@ class SiteModel(ModelParameter):
         self._logger.debug("Init SiteModel for site %s", site)
         super().__init__(
             site=site,
-            db_config=db_config,
             model_version=model_version,
             label=label,
             collection="sites",

simtools/model/telescope_model.py

@@ -26,8 +26,6 @@ class TelescopeModel(ModelParameter):
         Site name (e.g., South or North).
     telescope_name: str
         Telescope name (ex. LSTN-01, LSTN-design, ...).
-    db_config: dict
-        Database configuration.
     model_version: str
         Model version.
     label: str, optional
@@ -42,7 +40,6 @@ class TelescopeModel(ModelParameter):
         self,
         site,
         telescope_name,
-        db_config,
         model_version,
         label=None,
         overwrite_model_parameters=None,
@@ -52,7 +49,6 @@ class TelescopeModel(ModelParameter):
         super().__init__(
             site=site,
             array_element_name=telescope_name,
-            db_config=db_config,
             model_version=model_version,
             label=label,
             overwrite_model_parameters=overwrite_model_parameters,
@@ -326,13 +322,12 @@ class TelescopeModel(ModelParameter):
         average_curve: astropy.table.Table
             Instance of astropy.table.Table with the averaged curve.
         """
-        weights = []
-        for angle_now in curves["Angle"]:
-            weights.append(
-                incidence_angle_dist["Fraction"][
-                    np.nanargmin(np.abs(angle_now - incidence_angle_dist["Incidence angle"].value))
-                ]
-            )
+        weights = [
+            incidence_angle_dist["Fraction"][
+                np.nanargmin(np.abs(angle_now - incidence_angle_dist["Incidence angle"].value))
+            ]
+            for angle_now in curves["Angle"]
+        ]
 
         return Table(
             [curves["Wavelength"], np.average(curves["z"], weights=weights, axis=0)],

simtools/production_configuration/derive_corsika_limits.py

@@ -10,13 +10,13 @@ from astropy.table import Column, Table
 from simtools.data_model.metadata_collector import MetadataCollector
 from simtools.io import ascii_handler, io_handler
 from simtools.layout.array_layout_utils import get_array_elements_from_db_for_layouts
-from simtools.simtel.simtel_io_event_histograms import SimtelIOEventHistograms
+from simtools.sim_events.histograms import EventDataHistograms
 from simtools.visualization import plot_simtel_event_histograms
 
 _logger = logging.getLogger(__name__)
 
 
-def generate_corsika_limits_grid(args_dict, db_config=None):
+def generate_corsika_limits_grid(args_dict):
     """
     Generate CORSIKA limits.
 
@@ -24,15 +24,12 @@ def generate_corsika_limits_grid(args_dict, db_config=None):
     ----------
     args_dict : dict
         Dictionary containing command line arguments.
-    db_config : dict, optional
-        Database configuration dictionary.
     """
     if args_dict.get("array_layout_name"):
         telescope_configs = get_array_elements_from_db_for_layouts(
             args_dict["array_layout_name"],
             args_dict.get("site"),
             args_dict.get("model_version"),
-            db_config,
         )
     else:
         telescope_configs = ascii_handler.collect_data_from_file(args_dict["telescope_ids"])[
@@ -81,9 +78,7 @@ def _process_file(file_path, array_name, telescope_ids, loss_fraction, plot_hist
     dict
         Dictionary containing the computed limits and metadata.
     """
-    histograms = SimtelIOEventHistograms(
-        file_path, array_name=array_name, telescope_list=telescope_ids
-    )
+    histograms = EventDataHistograms(file_path, array_name=array_name, telescope_list=telescope_ids)
     histograms.fill()
 
     limits = {
@@ -257,7 +252,7 @@ def compute_lower_energy_limit(histograms, loss_fraction):
 
     Parameters
     ----------
-    histograms : SimtelIOEventHistograms
+    histograms : EventDataHistograms
         Histograms.
     loss_fraction : float
         Fraction of events to be lost.
@@ -299,7 +294,7 @@ def compute_upper_radius_limit(histograms, loss_fraction):
 
     Parameters
     ----------
-    histograms : SimtelIOEventHistograms
+    histograms : EventDataHistograms
         Histograms.
     loss_fraction : float
         Fraction of events to be lost.
@@ -337,7 +332,7 @@ def compute_viewcone(histograms, loss_fraction):
 
     Parameters
     ----------
-    histograms : SimtelIOEventHistograms
+    histograms : EventDataHistograms
         Histograms.
     loss_fraction : float
         Fraction of events to be lost.

simtools/production_configuration/interpolation_handler.py

@@ -214,17 +214,15 @@ class InterpolationHandler:
         np.ndarray
             Reduced production grid points.
         """
-        production_grid_points = []
-
-        for point in self.grid_points_production:
-            production_grid_points.append(
-                [
-                    point["azimuth"]["value"],
-                    point["zenith_angle"]["value"],
-                    point["nsb"]["value"],
-                    point["offset"]["value"],
-                ]
-            )
+        production_grid_points = [
+            [
+                point["azimuth"]["value"],
+                point["zenith_angle"]["value"],
+                point["nsb"]["value"],
+                point["offset"]["value"],
+            ]
+            for point in self.grid_points_production
+        ]
 
         production_grid_points = np.array(production_grid_points)
 
@@ -280,11 +278,13 @@ class InterpolationHandler:
         reduced_production_grid_points = self._prepare_production_grid_points()
         energy_grid = self.energy_grids[0] if self.energy_grids else []
 
-        energy_query_grid = []
-        for energy in energy_grid:
-            for grid_point in reduced_production_grid_points:
-                energy_query_grid.append(np.hstack([energy.to(u.TeV).value, grid_point]))
-
+        energy_query_grid = [
+            [
+                np.hstack([energy.to(u.TeV).value, grid_point])
+                for energy in energy_grid
+                for grid_point in reduced_production_grid_points
+            ]
+        ]
         energy_query_grid = np.array(energy_query_grid)
 
         self._logger.debug(f"Grid points with energy shape: {grid_points_energy.shape}")

simtools/ray_tracing/incident_angles.py

@@ -15,6 +15,7 @@ from pathlib import Path
 import astropy.units as u
 from astropy.table import QTable
 
+from simtools import settings
 from simtools.data_model.metadata_collector import MetadataCollector
 from simtools.model.model_utils import initialize_simulation_models
 
@@ -24,10 +25,6 @@ class IncidentAnglesCalculator:
 
     Parameters
     ----------
-    simtel_path : str or pathlib.Path
-        Path to the sim_telarray installation directory (containing ``sim_telarray/bin``).
-    db_config : dict
-        Database configuration passed to ``initialize_simulation_models``.
     config_data : dict
         Simulation configuration (e.g. ``site``, ``telescope``, ``model_version``,
         ``off_axis_angle``, ``source_distance``, ``number_of_photons``).
@@ -48,15 +45,12 @@ class IncidentAnglesCalculator:
 
     def __init__(
         self,
-        simtel_path,
-        db_config,
         config_data,
         output_dir,
         label=None,
     ):
         self.logger = logging.getLogger(__name__)
 
-        self._simtel_path = Path(simtel_path)
         self.config_data = config_data
         self.output_dir = Path(output_dir)
         self.label = label or f"incident_angles_{config_data['telescope']}"
@@ -82,7 +76,6 @@ class IncidentAnglesCalculator:
         )
         self.telescope_model, self.site_model, _ = initialize_simulation_models(
             label=self.label,
-            db_config=db_config,
             site=config_data["site"],
             telescope_name=config_data["telescope"],
             model_version=config_data["model_version"],
@@ -216,8 +209,6 @@ class IncidentAnglesCalculator:
             Path to the generated shell script.
         """
         script_path = self.scripts_dir / f"run_incident_angles_{self._label_suffix()}.sh"
-        simtel_bin = self._simtel_path / "sim_telarray/bin/sim_telarray_debug_trace"
-        corsika_dummy = self._simtel_path / "sim_telarray/run9991.corsika.gz"
 
         theta = self.ZENITH_ANGLE_DEG
         off = float(self.config_data["off_axis_angle"].to_value(u.deg))
@@ -258,7 +249,10 @@ class IncidentAnglesCalculator:
             cfg("camera_filter", "none"),
         ]
 
-        command = f"{simtel_bin} {' '.join(opts)} {corsika_dummy}"
+        command = (
+            f"{settings.config.sim_telarray_exe_debug_trace} {' '.join(opts)} "
+            f"{settings.config.corsika_dummy_file}"
+        )
         with script_path.open("w", encoding="utf-8") as sh:
             sh.write("#!/usr/bin/env bash\n\n")
             sh.write("set -e\nset -o pipefail\n\n")

simtools/ray_tracing/mirror_panel_psf.py

@@ -28,17 +28,15 @@ class MirrorPanelPSF:
         Application label.
     args_dict: dict
         Dictionary with input arguments.
-    db_config:
-        Dictionary with database configuration.
     """
 
-    def __init__(self, label, args_dict, db_config):
+    def __init__(self, label, args_dict):
         """Initialize the MirrorPanelPSF class."""
         self._logger = logging.getLogger(__name__)
         self._logger.debug("Initializing MirrorPanelPSF")
 
         self.args_dict = args_dict
-        self.telescope_model, self.site_model = self._define_telescope_model(label, db_config)
+        self.telescope_model, self.site_model = self._define_telescope_model(label)
 
         if self.args_dict["test"]:
             self.args_dict["number_of_mirrors_to_test"] = 2
@@ -56,7 +54,7 @@ class MirrorPanelPSF:
         self.results_mean = []
         self.results_sig = []
 
-    def _define_telescope_model(self, label, db_config):
+    def _define_telescope_model(self, label):
         """
         Define telescope model.
 
@@ -72,7 +70,6 @@ class MirrorPanelPSF:
         """
         tel_model, site_model, _ = initialize_simulation_models(
             label=label,
-            db_config=db_config,
             site=self.args_dict["site"],
             telescope_name=self.args_dict["telescope"],
             model_version=self.args_dict["model_version"],
@@ -225,7 +222,6 @@ class MirrorPanelPSF:
         ray = RayTracing(
             telescope_model=self.telescope_model,
             site_model=self.site_model,
-            simtel_path=self.args_dict.get("simtel_path", None),
             single_mirror_mode=True,
             mirror_numbers=(
                 list(range(1, self.args_dict["number_of_mirrors_to_test"] + 1))

simtools/ray_tracing/psf_analysis.py

@@ -17,6 +17,7 @@ import astropy.units as u
 import matplotlib.pyplot as plt
 import numpy as np
 
+from simtools import settings
 from simtools.utils.general import collect_kwargs, set_default_kwargs
 
 
@@ -36,8 +37,6 @@ class PSFImage:
         Scatter area of all photons in cm^2. If not given, effective area cannot be computed.
     containment_fraction: float
         Containment fraction for PSF calculation.
-    simtel_path: str
-        Path to sim_telarray installation.
     """
 
     __PSF_RADIUS = "Radius [cm]"
@@ -48,11 +47,9 @@ class PSFImage:
         focal_length=None,
         total_scattered_area=None,
         containment_fraction=None,
-        simtel_path=None,
     ):
         """Initialize PSFImage class."""
         self._logger = logging.getLogger(__name__)
-        self.simtel_path = simtel_path
 
         self._total_photons = None
         self._number_of_detected_photons = None
@@ -97,20 +94,23 @@ class PSFImage:
             Name of sim_telarray file with photon list.
         """
         try:
-            rx_output = subprocess.Popen(  # pylint: disable=consider-using-with
+            with subprocess.Popen(
                 shlex.split(
-                    f"{self.simtel_path}/sim_telarray/bin/rx -f {self._containment_fraction:.2f} -v"
+                    f"{settings.config.sim_telarray_path}/bin/rx "
+                    f"-f {self._containment_fraction:.2f} -v"
                 ),
                 stdin=subprocess.PIPE,
                 stdout=subprocess.PIPE,
-            )
-            with gzip.open(photon_file, "rb") as _stdin:
-                with rx_output.stdin:
-                    shutil.copyfileobj(_stdin, rx_output.stdin)
-                    try:
-                        rx_output = rx_output.communicate()[0].splitlines()[-1:][0].split()
-                    except IndexError as e:
-                        raise IndexError(f"Unexpected output format from rx: {rx_output}") from e
+            ) as rx_process:
+                with gzip.open(photon_file, "rb") as _stdin:
+                    with rx_process.stdin:
+                        shutil.copyfileobj(_stdin, rx_process.stdin)
+                        try:
+                            rx_output = rx_process.communicate()[0].splitlines()[-1:][0].split()
+                        except IndexError as e:
+                            raise IndexError(
+                                f"Unexpected output format from rx: {rx_process}"
+                            ) from e
         except FileNotFoundError as e:
             raise FileNotFoundError(f"Photon list file not found: {photon_file}") from e
 
@@ -384,7 +384,6 @@ class PSFImage:
                 if radius is not found (found_radius is False)
             """
             r0, r1 = rad_min, rad_min + dr
-            s0, s1 = 0, 0
             found_radius = False
             while not found_radius:
                 s0, s1 = self._sum_photons_in_radius(r0), self._sum_photons_in_radius(r1)
@@ -497,10 +496,10 @@ class PSFImage:
             radius_all = radius.to(u.cm).value if isinstance(radius, u.Quantity) else radius
         else:
             radius_all = list(np.linspace(0, 1.6 * self.get_psf(0.8), 30))
-
-        intensity = []
-        for rad in radius_all:
-            intensity.append(self._sum_photons_in_radius(rad) / self._number_of_detected_photons)
+        intensity = [
+            self._sum_photons_in_radius(rad) / self._number_of_detected_photons
+            for rad in radius_all
+        ]
         d_type = {
             "names": (self.__PSF_RADIUS, self.__PSF_CUMULATIVE),
             "formats": ("f8", "f8"),
@@ -516,18 +515,21 @@ class PSFImage:
 
         Parameters
         ----------
+        file_name: str
+            Name of the file to save the plot to.
+        d80: float
+            d80 value to be marked in the plot (in cm).
         **kwargs:
-            image_* for the histogram plot and psf_* for the psf circle.
+            Customization of line plot (e.g., color, linestyle, linewidth).
         """
         data = self.get_cumulative_data()
-        ax = plt.gca()
-        plt.tight_layout(pad=1.5)
+        fig, ax = plt.subplots(constrained_layout=True)
         ax.set_xlabel("Radius (cm)")
         ax.set_ylabel("Contained light %")
-        plt.plot(data[self.__PSF_RADIUS], data[self.__PSF_CUMULATIVE], **kwargs)
-        plt.axvline(x=self.get_psf(0.8) / 2, color="b", linestyle="--", linewidth=1)
+        ax.plot(data[self.__PSF_RADIUS], data[self.__PSF_CUMULATIVE], **kwargs)
+        ax.axvline(x=self.get_psf(0.8) / 2, color="b", linestyle="--", linewidth=1)
         if d80 is not None:
-            plt.axvline(x=d80 / 2.0, color="r", linestyle="--", linewidth=1)
+            ax.axvline(x=d80 / 2.0, color="r", linestyle="--", linewidth=1)
         if file_name is not None:
-            plt.savefig(file_name)
-            plt.close()
+            fig.savefig(file_name)
+            plt.close(fig)