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

simtools/simtel/simtel_io_event_reader.py

@@ -5,11 +5,11 @@ from dataclasses import dataclass, field
 
 import astropy.units as u
 import numpy as np
-from astropy.coordinates import AltAz, angular_separation
-from ctapipe.coordinates import GroundFrame, TiltedGroundFrame
+from astropy.coordinates import angular_separation
 
 from simtools.corsika.primary_particle import PrimaryParticle
-from simtools.io_operations import io_table_handler
+from simtools.io import table_handler
+from simtools.utils.geometry import transform_ground_to_shower_coordinates
 
 
 @dataclass
@@ -71,7 +71,7 @@ class SimtelIOEventDataReader:
         list
             List of dictionaries containing the data from the tables.
         """
-        dataset_dict = io_table_handler.read_table_list(
+        dataset_dict = table_handler.read_table_list(
             event_data_file,
             ["SHOWERS", "TRIGGERS", "FILE_INFO"],
             include_indexed_tables=True,
@@ -110,16 +110,17 @@ class SimtelIOEventDataReader:
             if table[col].unit:
                 setattr(shower_data, f"{col}_unit", table[col].unit)
 
-        shower_data.x_core_shower, shower_data.y_core_shower = (
-            self._transform_to_shower_coordinates(
+        shower_data.x_core_shower, shower_data.y_core_shower, _ = (
+            transform_ground_to_shower_coordinates(
                 shower_data.x_core,
                 shower_data.y_core,
+                0.0,
                 shower_data.shower_azimuth,
                 shower_data.shower_altitude,
             )
         )
-        shower_data.core_distance_shower = np.sqrt(
-            shower_data.x_core_shower**2 + shower_data.y_core_shower**2
+        shower_data.core_distance_shower = np.hypot(
+            shower_data.x_core_shower, shower_data.y_core_shower
         )
 
         return shower_data
@@ -144,7 +145,7 @@ class SimtelIOEventDataReader:
         for col in table.colnames:
             if col == "telescope_list":
                 arrays = [
-                    np.array(list(map(int, tel_list.split(","))), dtype=np.int16)
+                    np.array(list(map(str, tel_list.split(","))), dtype=np.str_)
                     for tel_list in table[col]
                 ]
                 triggered_data.telescope_list = arrays
@@ -191,7 +192,7 @@ class SimtelIOEventDataReader:
                 & (shower_data.event_id == tr_event_id)
                 & (shower_data.file_id == tr_file_id)
             )
-            matched_idx = np.where(mask)[0]
+            matched_idx = np.nonzero(mask)[0]
             if len(matched_idx) == 1:
                 matched_indices.append(matched_idx[0])
             else:
@@ -233,7 +234,7 @@ class SimtelIOEventDataReader:
         def get_name(key):
             return table_name_map.get(key, key)
 
-        tables = io_table_handler.read_tables(
+        tables = table_handler.read_tables(
             event_data_file,
             table_names=[get_name(k) for k in ("SHOWERS", "TRIGGERS", "FILE_INFO")],
         )
@@ -249,10 +250,10 @@ class SimtelIOEventDataReader:
 
         triggered_data.angular_distance = (
             angular_separation(
-                triggered_shower.shower_azimuth * u.rad,
-                triggered_shower.shower_altitude * u.rad,
-                triggered_data.array_azimuth * u.rad,
-                triggered_data.array_altitude * u.rad,
+                triggered_shower.shower_azimuth * u.deg,
+                triggered_shower.shower_altitude * u.deg,
+                triggered_data.array_azimuth * u.deg,
+                triggered_data.array_altitude * u.deg,
             )
             .to(u.deg)
             .value
@@ -298,34 +299,6 @@ class SimtelIOEventDataReader:
 
         return filtered_triggered_data, filtered_triggered_shower_data
 
-    def _transform_to_shower_coordinates(self, x_core, y_core, shower_azimuth, shower_altitude):
-        """
-        Transform core positions from ground coordinates to shower coordinates.
-
-        Parameters
-        ----------
-        x_core : np.ndarray
-            Core x positions in ground coordinates.
-        y_core : np.ndarray
-            Core y positions in ground coordinates.
-        shower_azimuth : np.ndarray
-            Shower azimuth angles.
-        shower_altitude : np.ndarray
-            Shower altitude angles.
-
-        Returns
-        -------
-        tuple
-            Core positions in shower coordinates (x, y).
-        """
-        ground = GroundFrame(x=x_core * u.m, y=y_core * u.m, z=np.zeros_like(x_core) * u.m)
-        shower_frame = ground.transform_to(
-            TiltedGroundFrame(
-                pointing_direction=AltAz(az=shower_azimuth * u.rad, alt=shower_altitude * u.rad)
-            )
-        )
-        return shower_frame.x.value, shower_frame.y.value
-
     def get_reduced_simulation_file_info(self, simulation_file_info):
         """
         Return reduced simulation file info assuming single-valued parameters.

simtools/simtel/simtel_io_event_writer.py

@@ -18,7 +18,11 @@ from eventio.simtel import (
 
 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,
+)
 from simtools.utils.geometry import calculate_circular_mean
+from simtools.utils.names import get_common_identifier_from_array_element_name
 
 
 @dataclass
@@ -32,8 +36,8 @@ class TableSchemas:
         "simulated_energy": (np.float64, u.TeV),
         "x_core": (np.float64, u.m),
         "y_core": (np.float64, u.m),
-        "shower_azimuth": (np.float64, u.rad),
-        "shower_altitude": (np.float64, u.rad),
+        "shower_azimuth": (np.float64, u.deg),
+        "shower_altitude": (np.float64, u.deg),
         "area_weight": (np.float64, None),
     }
 
@@ -41,9 +45,10 @@ class TableSchemas:
         "shower_id": (np.uint32, None),
         "event_id": (np.uint32, None),
         "file_id": (np.uint32, None),
-        "array_altitude": (np.float64, u.rad),
-        "array_azimuth": (np.float64, u.rad),
+        "array_altitude": (np.float64, u.deg),
+        "array_azimuth": (np.float64, u.deg),
         "telescope_list": (str, None),  # Store as comma-separated string
+        "telescope_list_common_id": (str, None),  # Store as comma-separated string
     }
 
     file_info_schema = {
@@ -93,6 +98,7 @@ class SimtelIOEventDataWriter:
         self.shower_data = []
         self.trigger_data = []
         self.file_info = []
+        self.telescope_id_to_name = {}
 
     def process_files(self):
         """
@@ -152,6 +158,7 @@ class SimtelIOEventDataWriter:
     def _process_file_info(self, file_id, file):
         """Process file information and append to file info list."""
         run_info = get_corsika_run_header(file)
+        self.telescope_id_to_name = get_sim_telarray_telescope_id_to_telescope_name_mapping(file)
         particle = PrimaryParticle(
             particle_id_type="eventio_id", particle_id=run_info.get("primary_id", 1)
         )
@@ -189,8 +196,8 @@ class SimtelIOEventDataWriter:
                 "simulated_energy": shower["energy"],
                 "x_core": None,  # filled in _process_mc_event
                 "y_core": None,  # filled in _process_mc_event
-                "shower_azimuth": shower["azimuth"],
-                "shower_altitude": shower["altitude"],
+                "shower_azimuth": np.degrees(shower["azimuth"]),
+                "shower_altitude": np.degrees(shower["altitude"]),
                 "area_weight": None,  # filled in _process_mc_event
             }
             for _ in range(self.n_use)
@@ -240,13 +247,18 @@ class SimtelIOEventDataWriter:
                 tracking_position = obj.parse()
                 tracking_positions.append(
                     {
-                        "altitude": tracking_position["altitude_raw"],
-                        "azimuth": tracking_position["azimuth_raw"],
+                        "altitude": np.degrees(tracking_position["altitude_raw"]),
+                        "azimuth": np.degrees(tracking_position["azimuth_raw"]),
                     }
                 )
 
         if len(telescopes) > 0 and tracking_positions:
-            self._fill_array_event(telescopes, tracking_positions, eventio_object.event_id, file_id)
+            self._fill_array_event(
+                self._map_telescope_names(telescopes),
+                tracking_positions,
+                eventio_object.event_id,
+                file_id,
+            )
 
     def _fill_array_event(self, telescopes, tracking_positions, event_id, file_id):
         """Add array event triggered events with tracking positions."""
@@ -259,11 +271,35 @@ class SimtelIOEventDataWriter:
                 "event_id": event_id,
                 "file_id": file_id,
                 "array_altitude": float(np.mean(altitudes)),
-                "array_azimuth": float(calculate_circular_mean(azimuths)),
+                "array_azimuth": float(np.degrees(calculate_circular_mean(np.deg2rad(azimuths)))),
                 "telescope_list": ",".join(map(str, telescopes)),
+                "telescope_list_common_id": ",".join(
+                    [
+                        str(get_common_identifier_from_array_element_name(tel, 0))
+                        for tel in telescopes
+                    ]
+                ),
             }
         )
 
+    def _map_telescope_names(self, telescope_ids):
+        """
+        Map sim_telarray telescopes IDs to CTAO array element names.
+
+        Parameters
+        ----------
+        telescope_ids : list
+            List of telescope IDs.
+
+        Returns
+        -------
+        list
+            List of telescope names corresponding to the IDs.
+        """
+        return [
+            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):
         """
         Return preliminary NSB level from file name.

simtools/simtel/simtel_io_histogram.py

@@ -177,7 +177,7 @@ class SimtelIOHistogram:
         histograms = {hist["id"]: hist for hist in self.histogram if hist["id"] in {1, 2}}
         if 1 in histograms and 2 in histograms:
             return histograms[1], histograms[2]
-        self._logger.error("Histograms ids not found. Please check your files.")
+        self._logger.error("Histograms ids not found. Please check files.")
         raise HistogramIdNotFoundError
 
     def _set_view_cone(self, view_cone):
@@ -560,6 +560,8 @@ class SimtelIOHistogram:
             self.energy_range[0],
             self.energy_range[1],
         )
+        if first_estimate == 0:
+            return 0.0 * u.s
         if stacked_num_simulated_events is None:
             _simulated_events, _ = self.total_number_of_events
             return (_simulated_events / first_estimate) * u.s

simtools/simtel/simtel_io_histograms.py

@@ -9,7 +9,7 @@ from eventio import EventIOFile, Histograms
 from eventio.search_utils import yield_toplevel_of_type
 
 from simtools import version
-from simtools.io_operations.hdf5_handler import fill_hdf5_table
+from simtools.io.hdf5_handler import fill_hdf5_table
 from simtools.simtel.simtel_io_histogram import (
     HistogramIdNotFoundError,
     InconsistentHistogramFormatError,
@@ -159,7 +159,7 @@ class SimtelIOHistograms:
         if sim_hist is None or trig_hist is None:
             msg = (
                 "Simulated and triggered histograms were not found in the stacked histograms."
-                " Please check your sim_telarray files!"
+                " Please check sim_telarray files!"
             )
             self._logger.error(msg)
             raise HistogramIdNotFoundError
@@ -285,7 +285,11 @@ class SimtelIOHistograms:
                 f"Estimated equivalent observation time corresponding to the number of "
                 f"events simulated: {obs_time.value} s"
             )
-            sim_event_rate = _simulated_events / obs_time
+            if obs_time != 0:
+                sim_event_rate = _simulated_events / obs_time
+            else:
+                sim_event_rate = 0.0 * obs_time.unit
+                logging.warning("Observation time is zero, cannot calculate event rate.")
             sim_event_rates.append(sim_event_rate)
             logging.info(f"Simulated event rate: {sim_event_rate.value:.4e} Hz")
 

simtools/simtel/simtel_io_metadata.py

@@ -2,11 +2,15 @@
 """Read metadata from sim_telarray files."""
 
 import logging
+import re
 from functools import cache
 
 from eventio import EventIOFile
+from eventio.iact import InputCard
 from eventio.simtel import HistoryMeta
 
+from simtools.utils import names
+
 _logger = logging.getLogger(__name__)
 
 
@@ -56,9 +60,12 @@ def read_sim_telarray_metadata(file, encoding="utf8"):
         return {k: v.strip() if isinstance(v, str) else v for k, v in meta.items()}
 
     # keys to lower case and strip leading '*', trailing spaces
-    return clean_meta(global_meta), {
-        tel_id: clean_meta(meta) for tel_id, meta in telescope_meta.items()
-    }
+    try:
+        return clean_meta(global_meta), {
+            tel_id: clean_meta(meta) for tel_id, meta in telescope_meta.items()
+        }
+    except AttributeError as e:
+        raise AttributeError(f"Error reading metadata from file {file}: {e}") from e
 
 
 def _decode_dictionary(meta, encoding="utf8"):
@@ -104,3 +111,92 @@ def get_sim_telarray_telescope_id(telescope_name, file):
             telescope_name_to_sim_telarray_id[telescope_name] = tel_id
 
     return telescope_name_to_sim_telarray_id.get(telescope_name, None)
+
+
+def get_sim_telarray_telescope_id_to_telescope_name_mapping(file):
+    """
+    Return a mapping of telescope IDs to telescope names from a sim_telarray file.
+
+    Parameters
+    ----------
+    file: str
+        Path to the sim_telarray file.
+
+    Returns
+    -------
+    dict
+        Dictionary mapping telescope IDs to telescope names.
+    """
+    _, telescope_meta = read_sim_telarray_metadata(file)
+    telescope_map = {}
+    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}")
+            )
+        except ValueError:
+            telescope_name = _guess_telescope_name_for_legacy_files(i, file)
+        if telescope_name is not None:
+            telescope_map[tel_id] = telescope_name
+
+    return telescope_map
+
+
+def _guess_telescope_name_for_legacy_files(tel_counter, file):
+    """
+    Guess telescope names for legacy prod6 sim_telarray files with incomplete metadata.
+
+    Parameters
+    ----------
+    tel_counter: int
+        Telescope counter, used to index into the telescope list.
+    file: str, Path
+        Path to the sim_telarray file.
+
+    Returns
+    -------
+    str, None
+        Guessed telescope name or None if not found.
+    """
+    telescope_list = _get_telescope_list_from_input_card(file)
+    try:
+        return names.validate_array_element_name(telescope_list[tel_counter])
+    except (IndexError, ValueError):
+        pass
+    return None
+
+
+@cache
+def _get_telescope_list_from_input_card(file):
+    r"""
+    Return telescope list from CORSIKA input card.
+
+    Note hardwired regex pattern with telescope naming convention.
+    This function is intended for legacy files generated for prod6,
+    where metadata is incomplete.
+
+    Expected format in input card:
+
+    .. code-block:: console
+        TELESCOPE    -70.91E2     -52.35E2 45.00E2  12.50E2  # (ID=1)  LSTN   01   2B5\n
+
+    Parameters
+    ----------
+    file: str, Path
+        Path to the sim_telarray file.
+
+    Returns
+    -------
+    list
+        List of telescope names as found in CORSIKA input card.
+    """
+    with EventIOFile(file) as f:
+        for o in f:
+            if isinstance(o, InputCard):
+                input_card = o.parse().decode("utf-8")
+                regex = (
+                    r"TELESCOPE\s+[-\d.E]+\s+[-\d.E]+\s+[-\d.E]+\s+[-\d.E]+\s+"
+                    r"# \(ID=\d+\)\s+(LST[N|S]|MST[N|S]|S[S|C]TS)\s+([^\s]+)"
+                )
+                return [f"{m[0]}-{m[1]}" for m in re.findall(regex, input_card)]
+    return []

simtools/simtel/simtel_table_reader.py

@@ -6,9 +6,10 @@ import re
 from pathlib import Path
 
 import astropy.units as u
+import numpy as np
 from astropy.table import Table
 
-from simtools.utils import general as gen
+from simtools.io import ascii_handler
 
 logger = logging.getLogger(__name__)
 
@@ -132,11 +133,6 @@ def _data_columns_camera_filter():
     )
 
 
-def _data_columns_lightguide_efficiency_vs_wavelength():
-    """Column description for parameter lightguide_efficiency_vs_wavelength."""
-    return _data_columns_lightguide_efficiency_vs_incidence_angle()
-
-
 def _data_columns_lightguide_efficiency_vs_incidence_angle():
     """Column description for (parameter lightguide_efficiency_vs_incidence_angle."""
     return (
@@ -201,6 +197,16 @@ def _data_columns_mirror_reflectivity(n_columns, n_dim):
     return _columns, "Mirror reflectivity"
 
 
+def _data_columns_secondary_mirror_reflectivity():
+    """Column description for secondary mirror reflectivity."""
+    columns = [
+        {"name": "wavelength", "description": "Wavelength", "unit": "nm"},
+        {"name": "reflectivity", "description": "Reflectivity", "unit": None},
+    ]
+
+    return columns, "Secondary mirror reflectivity vs wavelength"
+
+
 def _data_columns_pulse_shape(n_columns):
     """Column description for parameters discriminator_pulse_shape, fadc_pulse_shape."""
     _columns = [
@@ -259,6 +265,8 @@ def read_simtel_table(parameter_name, file_path):
 
     if parameter_name == "atmospheric_transmission":
         return _read_simtel_data_for_atmospheric_transmission(file_path)
+    if parameter_name == "lightguide_efficiency_vs_wavelength":
+        return _read_simtel_data_for_lightguide_efficiency(file_path)
 
     rows, meta_from_simtel, n_columns, n_dim = _read_simtel_data(file_path)
     columns_info, description = _data_columns(parameter_name, n_columns, n_dim)
@@ -291,6 +299,17 @@ def _adjust_columns_length(rows, n_columns):
     return [row[:n_columns] + [0.0] * max(0, n_columns - len(row)) for row in rows]
 
 
+def _process_line_parts(parts):
+    """Convert parts to floats, skipping non-float entries."""
+    row = []
+    for p in parts:
+        try:
+            row.append(float(p))
+        except ValueError:
+            logger.debug(f"Skipping non-float part: {p}")
+    return row
+
+
 def _read_simtel_data(file_path):
     """
     Read data, comments, and (if available) axis definition from sim_telarray table.
@@ -311,7 +330,7 @@ def _read_simtel_data(file_path):
     n_dim_axis = None
     r_pol_axis = None
 
-    lines = gen.read_file_encoded_in_utf_or_latin(file_path)
+    lines = ascii_handler.read_file_encoded_in_utf_or_latin(file_path)
 
     for line in lines:
         stripped = line.strip()
@@ -326,12 +345,75 @@ def _read_simtel_data(file_path):
         elif stripped:  # Data
             data_lines.append(stripped.split("%%%")[0].split("#")[0].strip())  # Remove comments
 
-    rows = [[float(part) for part in line.split()] for line in data_lines]
+    rows = [_process_line_parts(line.split()) for line in data_lines]
     n_columns = max(len(row) for row in rows) if rows else 0
 
     return rows, "\n".join(meta_lines), n_columns, n_dim_axis
 
 
+def _read_simtel_data_for_lightguide_efficiency(file_path):
+    """
+    Read angular efficiency data and return a table with columns: angle, wavelength, efficiency.
+
+    Parameters
+    ----------
+    file_path : str or Path
+
+    Returns
+    -------
+    astropy.table.Table
+    """
+    wavelengths = []
+    data = []
+    meta_lines = []
+
+    lines = ascii_handler.read_file_encoded_in_utf_or_latin(file_path)
+
+    def extract_wavelengths_from_header(line):
+        match = re.search(r"orig\.:\s*(.*)", line)
+        return [float(wl.replace("nm", "")) for wl in match.group(1).split()]
+
+    for line in lines:
+        line = line.strip()
+
+        if not line:
+            continue
+
+        if line.startswith("#"):
+            meta_lines.append(line.lstrip("#").strip())
+            if "orig.:" in line:
+                wavelengths = extract_wavelengths_from_header(line)
+            continue
+
+        parts = line.split()
+        try:
+            theta = float(parts[0])
+            eff_values = list(map(float, parts[-len(wavelengths) :]))
+            data.extend((theta, wl, eff) for wl, eff in zip(wavelengths, eff_values))
+        except (ValueError, IndexError):
+            logger.debug(f"Skipping malformed line: {line}")
+            continue
+
+    if not data or not wavelengths:
+        raise ValueError("No valid data or wavelengths found in file")
+
+    table = Table(rows=data, names=["angle", "wavelength", "efficiency"])
+    table["angle"].unit = u.deg
+    table["wavelength"].unit = u.nm
+    table["efficiency"].unit = u.dimensionless_unscaled
+
+    table.meta.update(
+        {
+            "Name": "angular_efficiency",
+            "File": str(file_path),
+            "Description": "Angular efficiency vs wavelength",
+            "Context_from_sim_telarray": "\n".join(meta_lines),
+        }
+    )
+
+    return table
+
+
 def _read_simtel_data_for_atmospheric_transmission(file_path):
     """
     Read data and comments from sim_telarray table for atmospheric_transmission.
@@ -346,7 +428,7 @@ def _read_simtel_data_for_atmospheric_transmission(file_path):
     astropy table
         Table with atmospheric transmission.
     """
-    lines = lines = gen.read_file_encoded_in_utf_or_latin(file_path)
+    lines = ascii_handler.read_file_encoded_in_utf_or_latin(file_path)
 
     observatory_level, height_bins = _read_header_line_for_atmospheric_transmission(
         lines, file_path
@@ -366,7 +448,7 @@ def _read_simtel_data_for_atmospheric_transmission(file_path):
             wl = float(parts[0])
             for i, height in enumerate(height_bins):
                 extinction_value = float(parts[i + 1])
-                if extinction_value == 99999.0:
+                if np.isclose(extinction_value, 99999.0):
                     continue
                 wavelengths.append(wl)
                 heights.append(height)