gammasimtools 0.19.0__py3-none-any.whl → 0.21.0__py3-none-any.whl

simtools/simtel/simtel_io_event_reader.py

@@ -9,7 +9,7 @@ from astropy.coordinates import angular_separation
 
 from simtools.corsika.primary_particle import PrimaryParticle
 from simtools.io import table_handler
-from simtools.utils.geometry import transform_ground_to_shower_coordinates
+from simtools.utils.geometry import solid_angle, transform_ground_to_shower_coordinates
 
 
 @dataclass
@@ -28,6 +28,7 @@ class ShowerEventData:
     x_core_shower: list[np.float64] = field(default_factory=list)
     y_core_shower: list[np.float64] = field(default_factory=list)
     core_distance_shower: list[np.float64] = field(default_factory=list)
+    angular_distance: list[float] = field(default_factory=list)
 
 
 @dataclass
@@ -52,6 +53,7 @@ class SimtelIOEventDataReader:
         self.telescope_list = telescope_list
 
         self.data_sets = self.read_table_list(event_data_file)
+        self.reduced_file_info = None
 
     def read_table_list(self, event_data_file):
         """
@@ -78,7 +80,14 @@ class SimtelIOEventDataReader:
         )
 
         data_sets = []
-        for i in range(len(dataset_dict["SHOWERS"])):
+        try:
+            sorted_indices = sorted(
+                range(len(dataset_dict["SHOWERS"])),
+                key=lambda i: int(dataset_dict["SHOWERS"][i].split("_")[-1]),
+            )
+        except (ValueError, AttributeError):
+            sorted_indices = [0]  # Handle the case where the key is only "SHOWERS"
+        for i in sorted_indices:
             data_sets.append(
                 {
                     "SHOWERS": dataset_dict["SHOWERS"][i],
@@ -122,6 +131,16 @@ class SimtelIOEventDataReader:
         shower_data.core_distance_shower = np.hypot(
             shower_data.x_core_shower, shower_data.y_core_shower
         )
+        shower_data.angular_distance = (
+            angular_separation(
+                shower_data.shower_azimuth * u.deg,
+                shower_data.shower_altitude * u.deg,
+                self.reduced_file_info["azimuth"],
+                (90.0 * u.deg - self.reduced_file_info["zenith"]),
+            )
+            .to(u.deg)
+            .value
+        )
 
         return shower_data
 
@@ -238,6 +257,9 @@ class SimtelIOEventDataReader:
             event_data_file,
             table_names=[get_name(k) for k in ("SHOWERS", "TRIGGERS", "FILE_INFO")],
         )
+        self.reduced_file_info = self.get_reduced_simulation_file_info(
+            tables[get_name("FILE_INFO")]
+        )
 
         shower_data = self._table_to_shower_data(tables[get_name("SHOWERS")])
         triggered_data = self._table_to_triggered_data(tables[get_name("TRIGGERS")])
@@ -355,4 +377,31 @@ class SimtelIOEventDataReader:
                 value = value * simulation_file_info[key].unit
             reduced_info[key] = value
 
+        reduced_info["solid_angle"] = solid_angle(
+            angle_min=reduced_info.get("viewcone_min", 0.0 * u.rad),
+            angle_max=reduced_info.get("viewcone_max", 0.0 * u.rad),
+        )
+        reduced_info["scatter_area"] = self.scatter_area(
+            core_scatter_min=reduced_info.get("core_scatter_min", 0.0 * u.m),
+            core_scatter_max=reduced_info.get("core_scatter_max", 0.0 * u.m),
+        )
+
         return reduced_info
+
+    def scatter_area(self, core_scatter_min, core_scatter_max):
+        """
+        Calculate the scatter area of the core.
+
+        Parameters
+        ----------
+        core_scatter_min : astropy.units.Quantity
+            Minimum core scatter radius.
+        core_scatter_max : astropy.units.Quantity
+            Maximum core scatter radius.
+
+        Returns
+        -------
+        astropy.units.Quantity
+            Scatter area.
+        """
+        return np.pi * (core_scatter_max**2 - core_scatter_min**2)

simtools/simtel/simtel_io_event_writer.py

@@ -20,6 +20,7 @@ from simtools.corsika.primary_particle import PrimaryParticle
 from simtools.simtel.simtel_io_file_info import get_corsika_run_header
 from simtools.simtel.simtel_io_metadata import (
     get_sim_telarray_telescope_id_to_telescope_name_mapping,
+    read_sim_telarray_metadata,
 )
 from simtools.utils.geometry import calculate_circular_mean
 from simtools.utils.names import get_common_identifier_from_array_element_name
@@ -175,7 +176,7 @@ class SimtelIOEventDataWriter:
                 "core_scatter_max": run_info["core_range"][1],
                 "zenith": 90.0 - np.degrees(run_info["direction"][1]),
                 "azimuth": np.degrees(run_info["direction"][0]),
-                "nsb_level": self._get_preliminary_nsb_level(str(file)),
+                "nsb_level": self.get_nsb_level_from_sim_telarray_metadata(file),
             }
         )
 
@@ -300,14 +301,33 @@ class SimtelIOEventDataWriter:
             self.telescope_id_to_name.get(tel_id, f"Unknown_{tel_id}") for tel_id in telescope_ids
         ]
 
-    def _get_preliminary_nsb_level(self, file):
+    def get_nsb_level_from_sim_telarray_metadata(self, file):
         """
-        Return preliminary NSB level from file name.
+        Return NSB level from sim_telarray metadata.
 
-        Hardwired values are used for "dark", "half", and "full" NSB levels
-        (actual values are made up for this example). Will be replaced with
-        reading of sim_telarray metadata entry for NSB level (to be implemented,
-        see issue #1572).
+        Falls back to preliminary NSB level if not found.
+
+        Parameters
+        ----------
+        file : Path
+            Path to the sim_telarray file.
+
+        Returns
+        -------
+        float
+            NSB level.
+        """
+        metadata, _ = read_sim_telarray_metadata(file)
+        nsb_integrated_flux = metadata.get("nsb_integrated_flux")
+        return nsb_integrated_flux or self._get_nsb_level_from_file_name(str(file))
+
+    def _get_nsb_level_from_file_name(self, file):
+        """
+        Return NSB level from file name.
+
+        Hardwired values are used for "dark", "half", and "full" NSB levels.
+        Allows to read legacy sim_telarray files without 'nsb_integrated_flux'
+        metadata field.
 
         Parameters
         ----------
@@ -319,15 +339,15 @@ class SimtelIOEventDataWriter:
         float
             NSB level extracted from file name.
         """
-        nsb_levels = {"dark": 1.0, "half": 2.0, "full": 5.0}
+        nsb_levels = {"dark": 0.24, "half": 0.835, "full": 1.2}
 
         for key, value in nsb_levels.items():
             try:
                 if key in file.lower():
-                    self._logger.warning(f"NSB level set to hardwired value of {value}")
+                    self._logger.warning(f"NSB level set to hardwired value of {value} for {file}")
                     return value
             except AttributeError as exc:
                 raise AttributeError("Invalid file name.") from exc
 
-        self._logger.warning("No NSB level found in file name, defaulting to 1.0")
-        return 1.0
+        self._logger.warning(f"No NSB level found in {file}, defaulting to None")
+        return None

simtools/simtel/simtel_io_metadata.py

@@ -78,7 +78,7 @@ def _decode_dictionary(meta, encoding="utf8"):
         return {k.decode(encoding, errors="ignore"): v.decode(encoding) for k, v in meta.items()}
     except UnicodeDecodeError as e:
         _logger.warning(
-            f"Failed to decode metadata with encoding {encoding}: {e}. "
+            f"Unable to decode metadata with encoding {encoding}: {e}. "
             "Falling back to 'utf-8' with errors='ignore'."
         )
         return {safe_decode(k, encoding): safe_decode(v, encoding) for k, v in meta.items()}

simtools/simtel/simtel_table_reader.py

@@ -229,8 +229,8 @@ def _data_columns_pulse_shape(n_columns):
     return _columns, "Pulse shape"
 
 
-def _data_columns_nsb_reference_spectrum():
-    """Column description for parameter nsb_reference_spectrum."""
+def _data_columns_nsb_spectrum():
+    """Column description for parameters describing the nsb spectrum."""
     return (
         [
             {"name": "wavelength", "description": "Wavelength", "unit": "nm"},
@@ -240,7 +240,7 @@ def _data_columns_nsb_reference_spectrum():
                 "unit": "1.e9 / (nm s m^2 sr)",
             },
         ],
-        "NSB reference spectrum",
+        "NSB spectrum",
     )
 
 

simtools/simulator.py

@@ -19,6 +19,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",
@@ -163,10 +164,6 @@ 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

simtools/telescope_trigger_rates.py

@@ -0,0 +1,119 @@
+"""Trigger rate calculation for telescopes and arrays of telescopes."""
+
+import logging
+
+import numpy as np
+from astropy import units as u
+from ctao_cr_spectra.definitions import IRFDOC_PROTON_SPECTRUM
+
+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.visualization import plot_simtel_event_histograms
+
+_logger = logging.getLogger(__name__)
+
+
+def telescope_trigger_rates(args_dict, db_config):
+    """
+    Calculate trigger rates for single telescopes or arrays of telescopes.
+
+    Main function to read event data, fill histograms, and derive trigger rates.
+
+
+    """
+    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"])[
+            "telescope_configs"
+        ]
+
+    for array_name, telescope_ids in telescope_configs.items():
+        _logger.info(
+            f"Processing file: {args_dict['event_data_file']} with telescope config: {array_name}"
+        )
+        histograms = SimtelIOEventHistograms(
+            args_dict["event_data_file"], array_name=array_name, telescope_list=telescope_ids
+        )
+        histograms.fill()
+
+        _calculate_trigger_rates(histograms, array_name)
+
+        if args_dict["plot_histograms"]:
+            plot_simtel_event_histograms.plot(
+                histograms.histograms,
+                output_path=io_handler.IOHandler().get_output_directory(),
+                array_name=array_name,
+            )
+
+
+def _calculate_trigger_rates(histograms, array_name):
+    """
+    Calculate trigger rates from the filled histograms.
+
+    Missing
+
+    - custom definition of energy spectra
+
+    """
+    efficiency = histograms.histograms.get("energy_eff", {}).get("histogram")
+    energy_axis = histograms.histograms.get("energy_eff", {}).get("bin_edges")
+
+    cr_spectrum = get_cosmic_ray_spectrum()
+    _logger.info(f"Cosmic ray spectrum: {cr_spectrum}")
+    e_min = energy_axis[:-1] * u.TeV
+    e_max = energy_axis[1:] * u.TeV
+    cr_rates = (
+        np.array(
+            [
+                cr_spectrum.integrate_energy(e1, e2).decompose(bases=[u.s, u.cm, u.sr]).value
+                for e1, e2 in zip(e_min, e_max)
+            ]
+        )
+        * histograms.file_info["scatter_area"].to("cm2").value
+        * histograms.file_info["solid_angle"].to("sr").value
+        * u.Hz
+    )
+    trigger_rates = efficiency * cr_rates
+    trigger_rate = np.sum(trigger_rates, axis=0)
+
+    _logger.info(f"Scatter area from MC: {histograms.file_info['scatter_area'].to('m2')}")
+    _logger.info(f"Solid angle from MC: {histograms.file_info['solid_angle']}")
+    _logger.info(f"Trigger rate for {array_name} array: {trigger_rate.to('Hz')}")
+
+    histograms.histograms["cr_rates_mc"] = histograms.get_histogram_definition(
+        histogram=cr_rates.value,
+        bin_edges=energy_axis,
+        title="Cosmic Ray Rates (MC)",
+        axis_titles=["Energy (TeV)", "Cosmic Ray Rate (Hz)"],
+        plot_scales={"x": "log", "y": "log"},
+    )
+    histograms.histograms["trigger_rates"] = histograms.get_histogram_definition(
+        histogram=trigger_rates.value,
+        bin_edges=energy_axis,
+        title="Trigger Rates (MC)",
+        axis_titles=["Energy (TeV)", "Trigger Rate (Hz)"],
+        plot_scales={"x": "log", "y": "log"},
+    )
+
+    return cr_rates, trigger_rates, trigger_rate
+
+
+def get_cosmic_ray_spectrum():
+    """
+    Return the cosmic ray spectrum.
+
+    To be extended in future to read a larger variety of spectra.
+
+    Returns
+    -------
+    astropy.units.Quantity
+        Cosmic ray spectrum.
+    """
+    return IRFDOC_PROTON_SPECTRUM

simtools/testing/log_inspector.py

@@ -15,6 +15,8 @@ ERROR_PATTERNS = [
     re.compile(r"segmentation fault", re.IGNORECASE),
 ]
 
+IGNORE_PATTERNS = [re.compile(r"Falling back to 'utf-8' with errors='ignore'", re.IGNORECASE)]
+
 
 def inspect(log_text):
     """
@@ -34,17 +36,17 @@ def inspect(log_text):
         True if no errors or warnings are found, False otherwise.
     """
     log_text = log_text if isinstance(log_text, list) else [log_text]
-    issues = []
-    for txt in log_text:
-        for lineno, line in enumerate(txt.splitlines(), 1):
-            # Skip lines containing "INFO::"
-            if "INFO::" in line:
-                continue
-            for pattern in ERROR_PATTERNS:
-                if pattern.search(line):
-                    issues.append((lineno, line))
-                    break
+
+    issues = [
+        (lineno, line)
+        for txt in log_text
+        for lineno, line in enumerate(txt.splitlines(), 1)
+        if "INFO::" not in line
+        and any(p.search(line) for p in ERROR_PATTERNS)
+        and not any(p.search(line) for p in IGNORE_PATTERNS)
+    ]
 
     for lineno, line in issues:
         _logger.error(f"Error or warning found in log at line {lineno}: {line.strip()}")
-    return len(issues) == 0
+
+    return not issues

simtools/utils/geometry.py

@@ -182,6 +182,26 @@ def calculate_circular_mean(angles):
     return np.arctan2(sin_sum, cos_sum)
 
 
+@u.quantity_input(angle_max=u.rad, angle_min=u.rad)
+def solid_angle(angle_max, angle_min=0 * u.rad):
+    """
+    Calculate the solid angle subtended by a given range of angles.
+
+    Parameters
+    ----------
+    angle_max: astropy.units.Quantity
+        The maximum angle for which to calculate the solid angle.
+    angle_min: astropy.units.Quantity
+        The minimum angle for which to calculate the solid angle (default is 0 rad).
+
+    Returns
+    -------
+    astropy.units.Quantity
+        The solid angle subtended by the given range of angles (in steradians).
+    """
+    return 2 * np.pi * (np.cos(angle_min.to("rad")) - np.cos(angle_max.to("rad"))) * u.sr
+
+
 def transform_ground_to_shower_coordinates(x_ground, y_ground, z_ground, azimuth, altitude):
     """
     Transform ground to shower coordinates.

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,90 @@ 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

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