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

simtools/simtel/simulator_ray_tracing.py

@@ -61,7 +61,7 @@ class SimulatorRayTracing(SimtelRunner):
         self.label = label if label is not None else self.telescope_model.label
 
         self.io_handler = io_handler.IOHandler()
-        self._base_directory = self.io_handler.get_output_directory(self.label, "ray_tracing")
+        self._base_directory = self.io_handler.get_output_directory()
 
         self.config = (
             self._config_to_namedtuple(config_data)
@@ -146,7 +146,7 @@ class SimulatorRayTracing(SimtelRunner):
 
         The run_number and input_file parameters are not relevant for the ray tracing simulation.
         """
-        self.telescope_model.write_sim_telarray_config_file(additional_model=self.site_model)
+        self.telescope_model.write_sim_telarray_config_file(additional_models=self.site_model)
 
         if self.config.single_mirror_mode:
             # Note: no mirror length defined for dual-mirror telescopes

simtools/simulator.py

@@ -8,6 +8,7 @@ from collections import defaultdict
 from pathlib import Path
 
 import numpy as np
+from astropy import units as u
 
 import simtools.utils.general as gen
 from simtools.corsika.corsika_config import CorsikaConfig
@@ -19,6 +20,7 @@ from simtools.runners.corsika_simtel_runner import CorsikaSimtelRunner
 from simtools.simtel.simtel_io_event_writer import SimtelIOEventDataWriter
 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",
@@ -67,8 +69,8 @@ class Simulator:
         self.db_config = db_config
 
         self.simulation_software = self.args_dict.get("simulation_software", "corsika_sim_telarray")
-        self.run_mode = self.args_dict.get("run_mode")
         self.logger.debug(f"Init Simulator {self.simulation_software}")
+        self.run_mode = args_dict.get("run_mode", None)
 
         self.io_handler = io_handler.IOHandler()
 
@@ -140,6 +142,9 @@ class Simulator:
                     "seed_file_name": self.sim_telarray_seeds["seed_file_name"],
                 },
                 simtel_path=self.args_dict.get("simtel_path", None),
+                calibration_device_types=self._get_calibration_device_types(
+                    self.args_dict.get("run_mode")
+                ),
             )
             for version in versions
         ]
@@ -163,14 +168,10 @@ class Simulator:
         if seed:
             return int(seed.split(",")[0].strip())
 
-        def semver_to_int(version: str):
-            major, minor, patch = map(int, version.split("."))
-            return major * 10000 + minor * 100 + patch
-
         seed = semver_to_int(model_version) * 10000000
         seed = seed + 1000000 if self.args_dict.get("site") != "North" else seed + 2000000
-        seed = seed + (int)(self.args_dict["zenith_angle"].value) * 1000
-        return seed + (int)(self.args_dict["azimuth_angle"].value)
+        seed = seed + (int)(self.args_dict.get("zenith_angle", 0.0 * u.deg).value) * 1000
+        return seed + (int)(self.args_dict.get("azimuth_angle", 0.0 * u.deg).value)
 
     def _initialize_run_list(self):
         """
@@ -260,7 +261,7 @@ class Simulator:
                     label=self.label,
                     args_dict=self.args_dict,
                     db_config=self.db_config,
-                    dummy_simulations=self._is_calibration_run(),
+                    dummy_simulations=self._is_calibration_run(self.run_mode),
                 )
             )
         return (
@@ -299,8 +300,9 @@ class Simulator:
             runner_args["sim_telarray_seeds"] = self.sim_telarray_seeds
         if runner_class is CorsikaSimtelRunner:
             runner_args["sequential"] = self.args_dict.get("sequential", False)
-            if self._is_calibration_run():
-                runner_args["calibration_runner_args"] = self.args_dict
+            runner_args["calibration_config"] = (
+                self.args_dict if self._is_calibration_run(self.run_mode) else None
+            )
 
         return runner_class(**runner_args)
 
@@ -586,9 +588,7 @@ class Simulator:
     def save_file_lists(self):
         """Save files lists for output and log files."""
         for file_type in ["simtel_output", "log", "corsika_log", "hist"]:
-            file_name = self.io_handler.get_output_directory(label=self.label).joinpath(
-                f"{file_type}_files.txt"
-            )
+            file_name = self.io_handler.get_output_directory().joinpath(f"{file_type}_files.txt")
             file_list = self.get_file_list(file_type=file_type)
             if all(element is not None for element in file_list) and len(file_list) > 0:
                 self.logger.info(f"Saving list of {file_type} files to {file_name}")
@@ -649,9 +649,7 @@ class Simulator:
         directory_for_grid_upload = (
             Path(directory_for_grid_upload)
             if directory_for_grid_upload
-            else self.io_handler.get_output_directory(label=self.label).joinpath(
-                "directory_for_grid_upload"
-            )
+            else self.io_handler.get_output_directory().joinpath("directory_for_grid_upload")
         )
         directory_for_grid_upload.mkdir(parents=True, exist_ok=True)
 
@@ -752,13 +750,43 @@ class Simulator:
 
             corsika_log_files.append(str(new_log))
 
-    def _is_calibration_run(self):
+    @staticmethod
+    def _is_calibration_run(run_mode):
         """
         Check if this simulation is a calibration run.
 
+        Parameters
+        ----------
+        run_mode: str
+            Run mode of the simulation.
+
         Returns
         -------
         bool
             True if it is a calibration run, False otherwise.
         """
-        return self.run_mode in ["pedestals", "dark_pedestals", "nsb_only_pedestals", "flasher"]
+        return run_mode in [
+            "pedestals",
+            "dark_pedestals",
+            "nsb_only_pedestals",
+            "direct_injection",
+        ]
+
+    @staticmethod
+    def _get_calibration_device_types(run_mode):
+        """
+        Get the list of calibration device types based on the run mode.
+
+        Parameters
+        ----------
+        run_mode: str
+            Run mode of the simulation.
+
+        Returns
+        -------
+        list
+            List of calibration device types.
+        """
+        if run_mode == "direct_injection":
+            return ["flat_fielding"]
+        return []

simtools/testing/configuration.py

@@ -184,14 +184,16 @@ def _prepare_test_options(config, output_path, model_version=None):
 
     tmp_config_file = output_path / "tmp_config.yml"
     config_file_model_version = config.get("model_version")
+    if isinstance(config_file_model_version, list):
+        config_file_model_version = [str(item) for item in config_file_model_version]
+    elif config_file_model_version is not None:
+        config_file_model_version = str(config_file_model_version)
     if model_version and "model_version" in config:
         config.update({"model_version": model_version})
 
     for key in ["output_path", "data_directory", "pack_for_grid_register"]:
         if key in config:
             config[key] = str(Path(output_path).joinpath(config[key]))
-            if key == "output_path":
-                config["use_plain_output_path"] = True
 
     _logger.info(f"Writing config file: {tmp_config_file}")
     ascii_handler.write_data_to_file(data=config, output_file=tmp_config_file, sort_keys=False)

simtools/testing/sim_telarray_metadata.py

@@ -35,19 +35,19 @@ def assert_sim_telarray_metadata(file, array_model):
     if sim_telarray_seed_mismatch:
         site_parameter_mismatch.append(sim_telarray_seed_mismatch)
 
-    if len(telescope_meta) != len(array_model.telescope_model):
+    if len(telescope_meta) != len(array_model.telescope_models):
         raise ValueError(
             f"Number of telescopes in sim_telarray file ({len(telescope_meta)}) does not match "
-            f"number of telescopes in array model ({len(array_model.telescope_model)})"
+            f"number of telescopes in array model ({len(array_model.telescope_models)})"
         )
 
-    for telescope_name in array_model.telescope_model.keys():
+    for telescope_name in array_model.telescope_models.keys():
         if not get_sim_telarray_telescope_id(telescope_name, file):
             raise ValueError(f"Telescope {telescope_name} not found in sim_telarray file metadata")
 
     telescope_parameter_mismatch = [
         _assert_model_parameters(telescope_meta[i], model)
-        for i, model in enumerate(array_model.telescope_model.values(), start=1)
+        for i, model in enumerate(array_model.telescope_models.values(), start=1)
     ]
 
     # ensure printout of all mismatches, not only those found first

simtools/utils/geometry.py

@@ -1,6 +1,7 @@
 """A collection of functions related to geometrical transformations."""
 
 import logging
+import math
 
 import astropy.units as u
 import numpy as np
@@ -236,3 +237,36 @@ def transform_ground_to_shower_coordinates(x_ground, y_ground, z_ground, azimuth
     z_s = -sz * x + cz * z
 
     return x_s, y_s, z_s
+
+
+def fiducial_radius_from_shape(width, shape):
+    """
+    Calculate minimum radius including different geometrical shapes.
+
+    Assumes definition of shapes as in 'camera_body_shape' model parameter:
+
+    - circle: shape = 0, width is diameter
+    - hexagon: shape = 1 or 3, width is flat-to-flat distance
+    - square: shape = 2, width is side length
+
+    Parameters
+    ----------
+    width : float
+        Characteristic width
+    shape : int
+        Geometrical shape parameter
+
+    Returns
+    -------
+    float
+        Minimum fiducial radius
+    """
+    if shape == 0:
+        return width / 2.0
+    if shape == 2:
+        return width / math.sqrt(2.0)
+    if shape in (1, 3):
+        return width / math.sqrt(3.0)
+    raise ValueError(
+        f"Unknown shape value {shape}. Valid values are: 0 (circle), 1 or 3 (hexagon), 2 (square)."
+    )

simtools/version.py

@@ -4,6 +4,8 @@
 # which is adapted from https://github.com/astropy/astropy/blob/master/astropy/version.py
 # see https://github.com/astropy/astropy/pull/10774 for a discussion on why this needed.
 
+from packaging.version import InvalidVersion, Version
+
 try:
     try:
         from ._dev_version import version
@@ -17,3 +19,112 @@ except Exception:  # pylint: disable=broad-except
     version = "0.0.0"  # pylint: disable=invalid-name
 
 __version__ = version
+
+
+def resolve_version_to_latest_patch(partial_version, available_versions):
+    """
+    Resolve a partial version (major.minor) to the latest patch version.
+
+    Given a partial version string (e.g., "6.0") and a list of available versions,
+    finds the latest patch version that matches the major.minor pattern.
+
+    Parameters
+    ----------
+    partial_version : str
+        Partial version string in format "major.minor" (e.g., "6.0", "5.2")
+    available_versions : list of str
+        List of available semantic versions (e.g., ["5.0.0", "5.0.1", "6.0.0", "6.0.2"])
+
+    Returns
+    -------
+    str
+        Latest patch version matching the partial version pattern
+
+    Raises
+    ------
+    ValueError
+        If partial_version is not in major.minor format
+    ValueError
+        If no matching versions are found
+
+    Examples
+    --------
+    >>> versions = ["5.0.0", "5.0.1", "6.0.0", "6.0.2", "6.1.0"]
+    >>> resolve_version_to_latest_patch("6.0", versions)
+    '6.0.2'
+    >>> resolve_version_to_latest_patch("5.0", versions)
+    '5.0.1'
+    >>> resolve_version_to_latest_patch("5.0.1", versions)
+    '5.0.1'
+    """
+    try:
+        pv = Version(partial_version)
+    except InvalidVersion as exc:
+        raise ValueError(f"Invalid version string: {partial_version}") from exc
+
+    if pv.release and len(pv.release) >= 3:
+        return str(pv)
+
+    if len(pv.release) != 2:
+        raise ValueError(f"Partial version must be major.minor, got: {partial_version}")
+
+    major, minor = pv.release
+
+    candidates = [
+        v for v in available_versions if Version(v).major == major and Version(v).minor == minor
+    ]
+
+    if not candidates:
+        raise ValueError(
+            f"No versions found matching '{partial_version}.x' "
+            f"in available versions: {sorted(available_versions)}"
+        )
+
+    return str(max(map(Version, candidates)))
+
+
+def semver_to_int(version_string):
+    """
+    Convert a semantic version string to an integer.
+
+    Parameters
+    ----------
+    version_string : str
+        Semantic version string (e.g., "6.0.2")
+
+    Returns
+    -------
+    int
+        Integer representation of the version (e.g., 60002 for "6.0.2")
+
+    """
+    try:
+        v = Version(version_string)
+    except InvalidVersion as exc:
+        raise ValueError(f"Invalid version: {version_string}") from exc
+
+    release = v.release + (0,) * (3 - len(v.release))
+    major, minor, patch = release[:3]
+    return major * 10000 + minor * 100 + patch
+
+
+def sort_versions(version_list, reverse=False):
+    """
+    Sort a list of semantic version strings.
+
+    Parameters
+    ----------
+    version_list : list of str
+        List of semantic version strings (e.g., ["5.0.0", "6.0.2", "5.1.0"])
+    reverse : bool, optional
+        Sort in descending order if True (default False)
+
+    Returns
+    -------
+    list of str
+        Sorted list of version strings.
+    """
+    try:
+        return [str(v) for v in sorted(map(Version, version_list), reverse=reverse)]
+    except InvalidVersion as exc:
+        raise ValueError(f"Invalid version in list: {version_list}") from exc

simtools/{corsika/corsika_histograms_visualize.py → visualization/plot_corsika_histograms.py}

@@ -1,6 +1,7 @@
 """Visualize Cherenkov photon distributions from CORSIKA."""
 
 import logging
+import re
 from pathlib import Path
 
 import matplotlib.pyplot as plt
@@ -569,3 +570,111 @@ def save_figs_to_pdf(figs, pdf_file_name):
         plt.tight_layout()
         pdf_pages.savefig(fig)
     pdf_pages.close()
+
+
+def build_all_photon_figures(histograms_instance, test: bool = False):
+    """Return list of all photon histogram figures for the given instance.
+
+    When test is True, only generate the first two figure groups to reduce runtime.
+    """
+    plot_function_names = sorted(
+        [
+            name
+            for name, obj in globals().items()
+            if name.startswith("plot_")
+            and "event_header_distribution" not in name
+            and callable(obj)
+        ]
+    )
+    if test:
+        plot_function_names = plot_function_names[:2]
+
+    figure_list = []
+    module_obj = globals()
+    for fn_name in plot_function_names:
+        plot_fn = module_obj[fn_name]
+        figs = plot_fn(histograms_instance)
+        for fig in figs:
+            figure_list.append(fig)
+    return np.array(figure_list).flatten()
+
+
+def export_all_photon_figures_pdf(histograms_instance, test: bool = False):
+    """Build and save all photon histogram figures into a single PDF.
+
+    The PDF name is derived from the HDF5 file name core and written under output_path.
+    """
+    figs = build_all_photon_figures(histograms_instance, test=test)
+    core_name = re.sub(r"\.hdf5$", "", Path(histograms_instance.hdf5_file_name).name)
+    output_file_name = Path(histograms_instance.output_path).joinpath(f"{core_name}.pdf")
+    save_figs_to_pdf(figs, output_file_name)
+    return output_file_name
+
+
+def derive_event_1d_histograms(
+    histograms_instance,
+    event_1d_header_keys,
+    pdf: bool,
+    hdf5: bool,
+    overwrite: bool = False,
+):
+    """Create 1D event header histograms; optionally save to PDF and/or HDF5."""
+    figure_list = []
+    for key in event_1d_header_keys:
+        if pdf:
+            fig = plot_1d_event_header_distribution(histograms_instance, key)
+            figure_list.append(fig)
+        if hdf5:
+            histograms_instance.export_event_header_1d_histogram(
+                key, bins=50, hist_range=None, overwrite=overwrite
+            )
+    if pdf:
+        figs_array = np.array(figure_list).flatten()
+        pdf_name = Path(histograms_instance.output_path).joinpath(
+            f"{Path(histograms_instance.hdf5_file_name).name}_event_1d_histograms.pdf"
+        )
+        save_figs_to_pdf(figs_array, pdf_name)
+        return pdf_name
+    return None
+
+
+def derive_event_2d_histograms(
+    histograms_instance,
+    event_2d_header_keys,
+    pdf: bool,
+    hdf5: bool,
+    overwrite: bool = False,
+):
+    """Create 2D event header histograms in pairs; optionally save PDF and/or HDF5.
+
+    If an odd number of keys is provided, the last one is ignored (with a warning).
+    """
+    if len(event_2d_header_keys) % 2 == 1:
+        _logger.warning(
+            "An odd number of keys was passed to generate 2D histograms.\n"
+            "The last key is being ignored."
+        )
+
+    figure_list = []
+    for i, _ in enumerate(event_2d_header_keys[::2]):
+        if pdf:
+            fig = plot_2d_event_header_distribution(
+                histograms_instance, event_2d_header_keys[i], event_2d_header_keys[i + 1]
+            )
+            figure_list.append(fig)
+        if hdf5:
+            histograms_instance.export_event_header_2d_histogram(
+                event_2d_header_keys[i],
+                event_2d_header_keys[i + 1],
+                bins=50,
+                hist_range=None,
+                overwrite=overwrite,
+            )
+    if pdf:
+        figs_array = np.array(figure_list).flatten()
+        pdf_name = Path(histograms_instance.output_path).joinpath(
+            f"{Path(histograms_instance.hdf5_file_name).name}_event_2d_histograms.pdf"
+        )
+        save_figs_to_pdf(figs_array, pdf_name)
+        return pdf_name
+    return None