gammasimtools 0.22.0__py3-none-any.whl → 0.23.0__py3-none-any.whl

simtools/model/model_parameter.py

@@ -13,8 +13,6 @@ from simtools.io import ascii_handler, io_handler
 from simtools.simtel.simtel_config_writer import SimtelConfigWriter
 from simtools.utils import names
 
-__all__ = ["InvalidModelParameterError", "ModelParameter"]
-
 
 class InvalidModelParameterError(Exception):
     """Exception for invalid model parameter."""
@@ -198,6 +196,31 @@ class ModelParameter:
 
         return _parameter
 
+    def _create_quantity_for_value(self, value, unit):
+        """
+        Create an astropy quantity for a single value and unit.
+
+        Parameters
+        ----------
+        value: numeric or str
+            The value to create a quantity for.
+        unit: str or None
+            The unit string or None.
+
+        Returns
+        -------
+        astropy.Quantity or original value
+            Astropy quantity for numeric values with units,
+            original value for non-numeric values.
+        """
+        if not isinstance(value, int | float):
+            return value
+
+        if unit is None or unit == "null":
+            return value * u.dimensionless_unscaled
+
+        return value * u.Unit(unit)
+
     def get_parameter_value_with_unit(self, par_name):
         """
         Get the value of an existing parameter of the model as an Astropy Quantity with its unit.
@@ -226,13 +249,12 @@ class ModelParameter:
             if (isinstance(_value, (int | float))) or (len(_value) > len(_unit)):
                 return _value * u.Unit(_unit[0])
 
-            # entries with 'null' units should be returned as dimensionless
-            _astropy_units = [
-                u.Unit(item) if item != "null" else u.dimensionless_unscaled for item in _unit
+            # Create list of quantities for multiple values with different units
+            return [
+                self._create_quantity_for_value(_value[i], _unit[i] if i < len(_unit) else None)
+                for i in range(len(_value))
             ]
 
-            return [_value[i] * _astropy_units[i] for i in range(len(_value))]
-
         except (KeyError, TypeError, AttributeError) as exc:
             self._logger.debug(
                 f"{exc} encountered for parameter {par_name}, returning only value without units."
@@ -550,6 +572,7 @@ class ModelParameter:
             self.simtel_config_writer = SimtelConfigWriter(
                 site=self.site,
                 telescope_model_name=self.name,
+                telescope_design_model=self.design_model,
                 model_version=self.model_version,
                 label=self.label,
             )

simtools/model/model_utils.py

@@ -8,11 +8,6 @@ from simtools.model.site_model import SiteModel
 from simtools.model.telescope_model import TelescopeModel
 from simtools.utils import names
 
-__all__ = [
-    "compute_telescope_transmission",
-    "is_two_mirror_telescope",
-]
-
 
 def initialize_simulation_models(
     label, db_config, model_version, site, telescope_name, calibration_device_name=None

simtools/model/site_model.py

@@ -9,8 +9,6 @@ from astropy import units as u
 
 from simtools.model.model_parameter import ModelParameter
 
-__all__ = ["SiteModel"]
-
 
 class SiteModel(ModelParameter):
     """

simtools/model/telescope_model.py

@@ -13,8 +13,6 @@ from simtools.model.mirrors import Mirrors
 from simtools.model.model_parameter import InvalidModelParameterError, ModelParameter
 from simtools.utils import names
 
-__all__ = ["TelescopeModel"]
-
 
 class TelescopeModel(ModelParameter):
     """

simtools/production_configuration/calculate_statistical_uncertainties_grid_point.py

@@ -6,8 +6,6 @@ import numpy as np
 from astropy import units as u
 from astropy.io import fits
 
-__all__ = ["StatisticalUncertaintyEvaluator"]
-
 
 class StatisticalUncertaintyEvaluator:
     """

simtools/production_configuration/derive_production_statistics.py

@@ -10,8 +10,6 @@ metrics and the evaluator's results.
 import astropy.units as u
 import numpy as np
 
-__all__ = ["ProductionStatisticsDerivator"]
-
 
 class ProductionStatisticsDerivator:
     """

simtools/production_configuration/interpolation_handler.py

@@ -10,8 +10,6 @@ from simtools.production_configuration.derive_production_statistics import (
     ProductionStatisticsDerivator,
 )
 
-__all__ = ["InterpolationHandler"]
-
 
 class InterpolationHandler:
     """

simtools/ray_tracing/psf_analysis.py

@@ -19,8 +19,6 @@ import numpy as np
 
 from simtools.utils.general import collect_kwargs, set_default_kwargs
 
-__all__ = ["PSFImage"]
-
 
 class PSFImage:
     """

simtools/ray_tracing/ray_tracing.py

@@ -20,8 +20,6 @@ from simtools.simtel.simulator_ray_tracing import SimulatorRayTracing
 from simtools.utils import names
 from simtools.visualization import visualize
 
-__all__ = ["RayTracing"]
-
 INVALID_KEY_TO_PLOT = "Invalid key to plot"
 
 

simtools/reporting/docs_auto_report_generator.py

@@ -175,6 +175,10 @@ class ReportGenerator:
                 f"Markdown report generated for {site} Telescope {telescope}: {self.output_path}"
             )
 
+        # Also generate calibration device parameter comparison reports when using --all_telescopes
+        if self.args.get("all_telescopes"):
+            self._generate_calibration_device_parameter_reports()
+
     def _generate_observatory_report_combinations(self) -> Generator[tuple[str, str], None, None]:
         """Generate combinations of sites and model versions for observatory reports.
 
@@ -215,3 +219,107 @@ class ReportGenerator:
         """Generate all observatory reports based on which --all_* flags are passed."""
         for params in self._generate_observatory_report_combinations():
             self._generate_single_observatory_report(*params)
+
+    def auto_generate_simulation_configuration_reports(self):
+        """Generate simulation configuration reports for one or all model versions.
+
+        If --all_model_versions is set, produce reports for every model version in
+        the DB; otherwise produce reports only for the configured model_version.
+        """
+        model_versions = (
+            self.db.get_model_versions()
+            if self.args.get("all_model_versions")
+            else [self.args["model_version"]]
+        )
+
+        for version in model_versions:
+            # update args and create a per-version output directory
+            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()
+
+            logger.info(f"Configuration reports for (v{version}) produced: {output_path}")
+
+    def auto_generate_calibration_reports(self):
+        """Generate calibration reports for one or all model versions.
+
+        Mirrors the pattern used by other auto_generate_* methods: if
+        --all_model_versions is set, produce reports for every model version in
+        the DB; otherwise produce reports only for the configured model_version.
+        """
+        model_versions = (
+            self.db.get_model_versions()
+            if self.args.get("all_model_versions")
+            else [self.args["model_version"]]
+        )
+
+        for version in model_versions:
+            # update args and create a per-version output directory
+            self.args.update({"model_version": version})
+            output_path = Path(self.output_path) / str(version)
+
+            try:
+                ReadParameters(self.db_config, 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;
+                msg = str(err)
+                if "calibration_devices" in msg and "zero results" in msg:
+                    logger.info(
+                        f"Skipping model version {version}: no calibration devices defined ({msg})"
+                    )
+                    continue
+                # re-raise unexpected ValueErrors
+                raise
+
+    def _generate_calibration_device_parameter_reports(self):
+        """Generate parameter comparison reports for calibration devices for all model versions."""
+        # Get all model versions since no specific version is provided when using --all_telescopes
+        model_versions = self.db.get_model_versions()
+
+        for version in model_versions:
+            self._process_calibration_devices_for_version(version)
+
+    def _process_calibration_devices_for_version(self, version):
+        """Process calibration devices for a specific model version."""
+        try:
+            # Get all calibration devices for this version
+            calibration_array_elements = self.db.get_array_elements(
+                version, collection="calibration_devices"
+            )
+            array_elements = calibration_array_elements.copy()
+
+            # Add design models
+            for element in calibration_array_elements:
+                design_model = self.db.get_design_model(version, element, "calibration_devices")
+                if design_model and design_model not in array_elements:
+                    array_elements.append(design_model)
+
+            if array_elements:
+                # Create a copy of args with the current version for this iteration
+                version_args = self.args.copy()
+                version_args["model_version"] = version
+
+                # Generate parameter comparison reports for calibration devices
+                ReadParameters(
+                    self.db_config, version_args, self.output_path
+                ).generate_model_parameter_reports_for_devices(array_elements)
+
+                logger.info(
+                    "Calibration device parameter reports generated for"
+                    f" v{version}: {self.output_path}"
+                )
+
+        except ValueError as err:
+            # Some model versions may not have calibration_devices
+            msg = str(err)
+            if "calibration_devices" in msg and "zero results" in msg:
+                logger.info(
+                    f"Skipping model version {version}: no calibration devices defined ({msg})"
+                )
+                return
+            # re-raise unexpected ValueErrors
+            raise

simtools/reporting/docs_read_parameters.py

@@ -896,9 +896,6 @@ class ReadParameters:
                 output_filename, calibration_device, data, design_model
             )
 
-        # produce parameter comparison reports (site-independent)
-        self._generate_model_parameter_reports_for_devices(array_elements)
-
     def _collect_calibration_array_elements(self):
         """Return a list of calibration devices including their design models."""
         calibration_array_elements = self.db.get_array_elements(
@@ -954,11 +951,8 @@ class ReadParameters:
 
                 self._write_to_file(display_group, file)
 
-    def _generate_model_parameter_reports_for_devices(self, array_elements):
+    def generate_model_parameter_reports_for_devices(self, array_elements):
         """Create model-parameter comparison reports for calibration devices."""
-        new_output_path = Path(self.output_path).parent.parent / "parameters"
-        new_output_path.mkdir(parents=True, exist_ok=True)
-        self.output_path = new_output_path
         for calibration_device in array_elements:
             device_sites = names.get_site_from_array_element_name(calibration_device)
             # parameters are site independent so just take the first site to read from db

simtools/runners/corsika_runner.py

@@ -7,8 +7,6 @@ from pathlib import Path
 from simtools.io import io_handler
 from simtools.runners.runner_services import RunnerServices
 
-__all__ = ["CorsikaRunner", "MissingRequiredEntryInCorsikaConfigError"]
-
 
 class MissingRequiredEntryInCorsikaConfigError(Exception):
     """Exception for missing required entry in corsika config."""

simtools/runners/corsika_simtel_runner.py

@@ -8,8 +8,6 @@ import simtools.utils.general as gen
 from simtools.runners.corsika_runner import CorsikaRunner
 from simtools.simtel.simulator_array import SimulatorArray
 
-__all__ = ["CorsikaSimtelRunner"]
-
 
 class CorsikaSimtelRunner:
     """

simtools/runners/simtel_runner.py

@@ -8,8 +8,6 @@ from pathlib import Path
 import simtools.utils.general as gen
 from simtools.runners.runner_services import RunnerServices
 
-__all__ = ["InvalidOutputFileError", "SimtelExecutionError", "SimtelRunner"]
-
 
 class SimtelExecutionError(Exception):
     """Exception for sim_telarray execution error."""

simtools/schemas/model_parameters/transit_time_random.schema.yml

@@ -0,0 +1,29 @@
+%YAML 1.2
+---
+title: Schema for transit_time_random model parameter
+schema_version: 0.1.0
+meta_schema: simpipe-schema
+meta_schema_url: https://raw.githubusercontent.com/gammasim/simtools/main/src/simtools/schemas/model_parameter_and_data_schema.metaschema.yml
+meta_schema_version: 0.1.0
+name: transit_time_random
+description: Event-wise and pixel-wise random fluctuations in the signal transit time.
+data:
+  - type: float64
+    unit: ns
+    default: 0.
+    allowed_range:
+      min: 0.0
+instrument:
+  class: Camera
+activity:
+  setting:
+    - SetParameterFromExternal
+  validation:
+    - ValidateParameterByExpert
+    - ValidateCameraTimeResponse
+source:
+  - Initial instrument setup
+simulation_software:
+  - name: sim_telarray
+  - name: simtools
+    version: ">=0.22.0"

simtools/simtel/simtel_config_reader.py

@@ -10,8 +10,6 @@ import numpy as np
 from simtools.io import ascii_handler
 from simtools.utils import names
 
-__all__ = ["SimtelConfigReader"]
-
 
 def get_list_of_simtel_parameters(simtel_config_file):
     """

simtools/simtel/simtel_config_writer.py

@@ -13,8 +13,6 @@ import simtools.version
 from simtools.io import ascii_handler
 from simtools.utils import names
 
-__all__ = ["SimtelConfigWriter"]
-
 
 def sim_telarray_random_seeds(seed, number):
     """
@@ -67,6 +65,7 @@ class SimtelConfigWriter:
         model_version,
         layout_name=None,
         telescope_model_name=None,
+        telescope_design_model=None,
         label=None,
         simtel_path=None,
     ):
@@ -79,9 +78,12 @@ class SimtelConfigWriter:
         self._label = label
         self._layout_name = layout_name
         self._telescope_model_name = telescope_model_name
+        self._telescope_design_model = telescope_design_model
         self._simtel_path = simtel_path
 
-    def write_telescope_config_file(self, config_file_path, parameters, telescope_name=None):
+    def write_telescope_config_file(
+        self, config_file_path, parameters, telescope_name=None, telescope_design_model=None
+    ):
         """
         Write the sim_telarray config file for a single telescope.
 
@@ -93,22 +95,30 @@ class SimtelConfigWriter:
             Model parameters
         telescope_name: str
             Name of the telescope (use self._telescope_model_name if None)
+        telescope_design_model: str
+            Telescope design model.
         """
         self._logger.debug(f"Writing telescope config file {config_file_path}")
 
         simtel_par = self._get_parameters_for_sim_telarray(parameters, config_file_path)
+        telescope_name = telescope_name or self._telescope_model_name
+        _telescope_design_model = telescope_design_model or self._telescope_design_model
 
         with open(config_file_path, "w", encoding="utf-8") as file:
             self._write_header(file, "TELESCOPE CONFIGURATION FILE")
 
-            telescope_name = telescope_name or self._telescope_model_name
             file.write("#ifdef TELESCOPE\n")
             file.write(f"   echo Configuration for {telescope_name} - TELESCOPE $(TELESCOPE)\n")
             file.write("#endif\n\n")
 
             for simtel_name, simtel_value in simtel_par.items():
                 file.write(f"{simtel_name} = {self._get_value_string_for_simtel(simtel_value)}\n")
-            for meta in self._get_sim_telarray_metadata("telescope", parameters, telescope_name):
+            for meta in self._get_sim_telarray_metadata(
+                "telescope",
+                parameters,
+                telescope_name,
+                telescope_design_model=_telescope_design_model,
+            ):
                 file.write(f"{meta}\n")
 
     def _get_parameters_for_sim_telarray(self, parameters, config_file_path):
@@ -211,12 +221,17 @@ class SimtelConfigWriter:
         value = "none" if value is None else value  # simtel requires 'none'
         if isinstance(value, bool):
             value = 1 if value else 0
-        elif isinstance(value, (list, np.ndarray)):  # noqa: UP038
+        elif isinstance(value, (list, np.ndarray)):
             value = gen.convert_list_to_string(value, shorten_list=True)
         return value
 
     def _get_sim_telarray_metadata(
-        self, config_type, model_parameters, telescope_model_name, additional_metadata=None
+        self,
+        config_type,
+        model_parameters,
+        telescope_model_name,
+        additional_metadata=None,
+        telescope_design_model=None,
     ):
         """
         Return sim_telarray metadata.
@@ -231,6 +246,8 @@ class SimtelConfigWriter:
             Name of the telescope model
         additional_metadata: dict
             Dictionary with additional metadata to include using 'set'.
+        telescope_design_model: str
+            Name of the telescope design model.
 
         Returns
         -------
@@ -241,14 +258,15 @@ class SimtelConfigWriter:
             f"config_release = {self._model_version} with simtools v{simtools.version.__version__}",
             f"config_version = {self._model_version}",
         ]
+        telescope_design_model = telescope_design_model or "design_model_not_set"
         if config_type == "telescope":
             meta_parameters.extend(
                 [
-                    f"camera_config_name = {telescope_model_name}",
-                    "camera_config_variant = ",
+                    f"camera_config_name = {telescope_design_model}",
+                    f"camera_config_variant = {telescope_model_name}",
                     f"camera_config_version = {self._model_version}",
-                    f"optics_config_name = {telescope_model_name}",
-                    "optics_config_variant = ",
+                    f"optics_config_name = {telescope_design_model}",
+                    f"optics_config_variant = {telescope_model_name}",
                     f"optics_config_version = {self._model_version}",
                 ]
             )
@@ -521,7 +539,7 @@ class SimtelConfigWriter:
             if simtel_name is not None:
                 file.write(f"{self.TAB}{simtel_name} = {value}\n")
         for meta in self._get_sim_telarray_metadata(
-            "site", site_parameters, self._telescope_model_name, additional_metadata
+            "site", site_parameters, None, additional_metadata
         ):
             file.write(f"{self.TAB}{meta}\n")
         file.write("\n")
@@ -588,7 +606,7 @@ class SimtelConfigWriter:
             trigger_lines[tel_type] += ", ".join(map(str, tel_list))
             width = trigger_dict["width"]["value"] * u.Unit(trigger_dict["width"]["unit"]).to("ns")
             trigger_lines[tel_type] += f" width {width}"
-            if trigger_dict.get("hard_stereo"):
+            if trigger_dict.get("hard_stereo", {}).get("value"):
                 trigger_lines[tel_type] += " hardstereo"
             if all(trigger_dict["min_separation"][key] is not None for key in ["value", "unit"]):
                 min_sep = trigger_dict["min_separation"]["value"] * u.Unit(

simtools/simtel/simtel_io_metadata.py

@@ -105,8 +105,8 @@ def get_sim_telarray_telescope_id(telescope_name, file):
     _, telescope_meta = read_sim_telarray_metadata(file)
     telescope_name_to_sim_telarray_id = {}
     for tel_id in telescope_meta.keys():
-        _optics_name = telescope_meta[tel_id].get("optics_config_name", None)
-        _camera_name = telescope_meta[tel_id].get("camera_config_name", None)
+        _optics_name = telescope_meta[tel_id].get("optics_config_variant", None)
+        _camera_name = telescope_meta[tel_id].get("camera_config_variant", None)
         if _optics_name == _camera_name and _optics_name == telescope_name:
             telescope_name_to_sim_telarray_id[telescope_name] = tel_id
 
@@ -132,7 +132,7 @@ def get_sim_telarray_telescope_id_to_telescope_name_mapping(file):
     for i, (tel_id, meta) in enumerate(telescope_meta.items()):
         try:
             telescope_name = names.validate_array_element_name(
-                meta.get("optics_config_name", f"Unknown-{tel_id}")
+                meta.get("optics_config_variant", f"Unknown-{tel_id}")
             )
         except ValueError:
             telescope_name = _guess_telescope_name_for_legacy_files(i, file)

simtools/simtel/simulator_array.py

@@ -6,8 +6,6 @@ from simtools.io import io_handler
 from simtools.runners.simtel_runner import InvalidOutputFileError, SimtelRunner
 from simtools.utils.general import clear_default_sim_telarray_cfg_directories
 
-__all__ = ["SimulatorArray"]
-
 
 class SimulatorArray(SimtelRunner):
     """
@@ -73,41 +71,33 @@ class SimulatorArray(SimtelRunner):
         command = self._common_run_command(run_number, weak_pointing)
 
         if self.calibration_config:
-            command += self._make_run_command_for_calibration_simulations(input_file)
+            command += self._make_run_command_for_calibration_simulations()
         else:
-            command += self._make_run_command_for_shower_simulations(input_file)
+            command += self._make_run_command_for_shower_simulations()
+
+        # "-C show=all" should be the last option
+        command += super().get_config_option("show", "all")
+        command += f" {input_file} | gzip > {self._log_file} 2>&1 || exit"
 
         return clear_default_sim_telarray_cfg_directories(command)
 
-    def _make_run_command_for_shower_simulations(self, input_file=None):
+    def _make_run_command_for_shower_simulations(self):
         """
         Build and return the command to run sim_telarray shower simulations.
 
-        Parameters
-        ----------
-        input_file: str
-            Full path of the input CORSIKA file
-        run_number: int (optional)
-            run number
-        weak_pointing: bool (optional)
-            Specify weak pointing option for sim_telarray.
-
         Returns
         -------
         str
             Command to run sim_telarray.
         """
-        command = f" {input_file}"
-        command += f" | gzip > {self._log_file} 2>&1 || exit"
-        command += super().get_config_option(
+        return super().get_config_option(
             "power_law",
             SimulatorArray.get_power_law_for_sim_telarray_histograms(
                 self.corsika_config.primary_particle
             ),
         )
-        return command
 
-    def _make_run_command_for_calibration_simulations(self, input_file=None):
+    def _make_run_command_for_calibration_simulations(self):
         """Build sim_telarray command for calibration simulations."""
         cfg = self.calibration_config
         altitude = self.corsika_config.array_model.site_model.get_parameter_value_with_unit(
@@ -133,7 +123,6 @@ class SimulatorArray(SimtelRunner):
             n_events = cfg.get("number_of_flasher_events", cfg["number_of_events"])
             command += super().get_config_option("laser_events", n_events)
 
-        command += f" {input_file} | gzip > {self._log_file} 2>&1 || exit"
         return command
 
     def _common_run_command(self, run_number, weak_pointing=None):
@@ -162,7 +151,6 @@ class SimulatorArray(SimtelRunner):
             )
         elif self.sim_telarray_seeds and self.sim_telarray_seeds.get("seed"):
             command += super().get_config_option("random_seed", self.sim_telarray_seeds["seed"])
-        command += super().get_config_option("show", "all")
         command += super().get_config_option("output_file", output_file)
 
         return command

simtools/simtel/simulator_camera_efficiency.py

@@ -7,8 +7,6 @@ from simtools.io import ascii_handler
 from simtools.runners.simtel_runner import SimtelRunner
 from simtools.utils import general
 
-__all__ = ["SimulatorCameraEfficiency"]
-
 
 class SimulatorCameraEfficiency(SimtelRunner):
     """

simtools/simtel/simulator_light_emission.py

@@ -15,8 +15,6 @@ from simtools.runners.simtel_runner import SimtelRunner
 from simtools.utils.general import clear_default_sim_telarray_cfg_directories
 from simtools.utils.geometry import fiducial_radius_from_shape
 
-__all__ = ["SimulatorLightEmission"]
-
 
 class SimulatorLightEmission(SimtelRunner):
     """
@@ -41,7 +39,7 @@ class SimulatorLightEmission(SimtelRunner):
             simtel_path=light_emission_config.get("simtel_path"), label=label, corsika_config=None
         )
 
-        self.output_directory = self.io_handler.get_output_directory(label)
+        self.output_directory = self.io_handler.get_output_directory()
 
         self.telescope_model, self.site_model, self.calibration_model = (
             initialize_simulation_models(

simtools/simtel/simulator_ray_tracing.py

@@ -10,8 +10,6 @@ from simtools.runners.simtel_runner import SimtelRunner
 from simtools.utils import names
 from simtools.utils.general import clear_default_sim_telarray_cfg_directories
 
-__all__ = ["SimulatorRayTracing"]
-
 # pylint: disable=no-member
 # The line above is needed because there are members which are created
 # by adding them to the __dict__ of the class rather than directly.

simtools/simulator.py

@@ -22,11 +22,6 @@ from simtools.simtel.simulator_array import SimulatorArray
 from simtools.testing.sim_telarray_metadata import assert_sim_telarray_metadata
 from simtools.version import semver_to_int
 
-__all__ = [
-    "InvalidRunsToSimulateError",
-    "Simulator",
-]
-
 
 class InvalidRunsToSimulateError(Exception):
     """Exception for invalid runs to simulate."""

simtools/testing/assertions.py

@@ -62,9 +62,9 @@ def assert_n_showers_and_energy_range(file):
 
     simulated_energies = []
     simulation_config = {}
-    with SimTelFile(file) as f:
+    with SimTelFile(file, skip_non_triggered=False) as f:
         simulation_config = f.mc_run_headers[0]
-        for event in f.iter_mc_events():
+        for event in f:
             simulated_energies.append(event["mc_shower"]["energy"])
 
     # The relative tolerance is set to 1% because ~0.5% shower simulations do not