gammasimtools 0.19.0__py3-none-any.whl → 0.20.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/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.