gammasimtools 0.25.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()}
@@ -327,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_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"),

simtools/ray_tracing/psf_parameter_optimisation.py

@@ -861,7 +861,6 @@ def _run_ray_tracing_simulation(tel_model, site_model, args_dict, pars):
     ray = RayTracing(
         telescope_model=tel_model,
         site_model=site_model,
-        simtel_path=args_dict["simtel_path"],
         zenith_angle=args_dict["zenith"] * u.deg,
         source_distance=args_dict["src_distance"] * u.km,
         off_axis_angle=[0.0] * u.deg,

simtools/ray_tracing/ray_tracing.py

@@ -5,7 +5,6 @@ import logging
 import shutil
 from copy import copy
 from math import pi, tan
-from pathlib import Path
 
 import astropy.io.ascii
 import astropy.units as u
@@ -33,8 +32,6 @@ class RayTracing:
         telescope model
     site_model: SiteModel
         site model
-    simtel_path: str (or Path)
-        Location of sim_telarray installation.
     label: str
         label used for output file naming.
     zenith_angle: astropy.units.Quantity
@@ -64,7 +61,6 @@ class RayTracing:
         self,
         telescope_model,
         site_model,
-        simtel_path,
         label=None,
         zenith_angle=20.0 * u.deg,
         off_axis_angle=[0.0] * u.deg,
@@ -78,7 +74,6 @@ class RayTracing:
         self._logger = logging.getLogger(__name__)
         self._logger.debug(f"Initializing RayTracing class {single_mirror_mode}")
 
-        self.simtel_path = Path(simtel_path)
         self._io_handler = io_handler.IOHandler()
 
         self.telescope_model, self.site_model = telescope_model, site_model
@@ -212,7 +207,6 @@ class RayTracing:
                     f"Simulating RayTracing for off_axis={this_off_axis}, mirror={mirror_number}"
                 )
                 simtel = SimulatorRayTracing(
-                    simtel_path=self.simtel_path,
                     telescope_model=self.telescope_model,
                     site_model=self.site_model,
                     test=test,
@@ -408,11 +402,7 @@ class RayTracing:
         PSFImage
             PSF image object.
         """
-        image = PSFImage(
-            focal_length=focal_length,
-            containment_fraction=containment_fraction,
-            simtel_path=self.simtel_path,
-        )
+        image = PSFImage(focal_length=focal_length, containment_fraction=containment_fraction)
         image.process_photon_list(photons_file, use_rx)
         self._psf_images[this_off_axis] = copy(image)
         return image
@@ -623,10 +613,11 @@ class RayTracing:
         -------
         List of PSFImages
         """
-        images = []
-        for this_off_axis in self.off_axis_angle:
-            if self._psf_images and this_off_axis in self._psf_images:
-                images.append(self._psf_images[this_off_axis])
+        images = [
+            self._psf_images[this_off_axis]
+            for this_off_axis in self.off_axis_angle
+            if self._psf_images and this_off_axis in self._psf_images
+        ]
         if len(images) == 0:
             self._logger.warning("No image found")
             return None

simtools/reporting/docs_auto_report_generator.py

@@ -16,11 +16,10 @@ logger = logging.getLogger()
 class ReportGenerator:
     """Automate report generation."""
 
-    def __init__(self, db_config, args, output_path):
+    def __init__(self, args, output_path):
         """Initialise class."""
         self._logger = logging.getLogger(__name__)
-        self.db = db_handler.DatabaseHandler(db_config=db_config)
-        self.db_config = db_config
+        self.db = db_handler.DatabaseHandler()
         self.args = args
         self.output_path = output_path
 
@@ -99,7 +98,7 @@ class ReportGenerator:
         )
 
         output_path = Path(self.output_path) / str(model_version)
-        ReadParameters(self.db_config, self.args, output_path).produce_array_element_report()
+        ReadParameters(self.args, output_path).produce_array_element_report()
 
         logger.info(
             f"Markdown report generated for {site} "
@@ -167,9 +166,7 @@ class ReportGenerator:
                 }
             )
 
-            ReadParameters(
-                self.db_config, self.args, self.output_path
-            ).produce_model_parameter_reports()
+            ReadParameters(self.args, self.output_path).produce_model_parameter_reports()
 
             logger.info(
                 f"Markdown report generated for {site} Telescope {telescope}: {self.output_path}"
@@ -211,7 +208,7 @@ class ReportGenerator:
         )
 
         output_path = Path(self.output_path) / str(model_version)
-        ReadParameters(self.db_config, self.args, output_path).produce_observatory_report()
+        ReadParameters(self.args, output_path).produce_observatory_report()
 
         logger.info(f"Observatory report generated for {site} (v{model_version}): {output_path}")
 
@@ -237,9 +234,7 @@ class ReportGenerator:
             self.args.update({"model_version": version})
             output_path = Path(self.output_path) / str(version)
 
-            ReadParameters(
-                self.db_config, self.args, output_path
-            ).produce_simulation_configuration_report()
+            ReadParameters(self.args, output_path).produce_simulation_configuration_report()
 
             logger.info(f"Configuration reports for (v{version}) produced: {output_path}")
 
@@ -262,7 +257,7 @@ class ReportGenerator:
             output_path = Path(self.output_path) / str(version)
 
             try:
-                ReadParameters(self.db_config, self.args, output_path).produce_calibration_reports()
+                ReadParameters(self.args, output_path).produce_calibration_reports()
                 logger.info(f"Calibration reports for (v{version}) produced: {output_path}")
             except ValueError as err:
                 # Some model versions do not have calibration_devices in the DB;
@@ -305,7 +300,7 @@ class ReportGenerator:
 
                 # Generate parameter comparison reports for calibration devices
                 ReadParameters(
-                    self.db_config, version_args, self.output_path
+                    version_args, self.output_path
                 ).generate_model_parameter_reports_for_devices(array_elements)
 
                 logger.info(