gammasimtools 0.24.0__py3-none-any.whl → 0.26.0__py3-none-any.whl

simtools/{simtel/simtel_io_event_writer.py → sim_events/writer.py}

@@ -1,4 +1,4 @@
-"""Generate a reduced dataset from sim_telarray output files using astropy tables."""
+"""Generate a reduced dataset from simulation files (CORSIKA/sim_telarray) using astropy tables."""
 
 import logging
 from dataclasses import dataclass
@@ -6,7 +6,7 @@ from dataclasses import dataclass
 import astropy.units as u
 import numpy as np
 from astropy.table import Table
-from eventio import EventIOFile
+from eventio import EventIOFile, iact
 from eventio.simtel import (
     ArrayEvent,
     MCEvent,
@@ -17,7 +17,10 @@ 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.sim_events.file_info import (
+    get_combined_eventio_run_header,
+    get_corsika_run_and_event_headers,
+)
 from simtools.simtel.simtel_io_metadata import (
     get_sim_telarray_telescope_id_to_telescope_name_mapping,
     read_sim_telarray_metadata,
@@ -68,11 +71,11 @@ class TableSchemas:
     }
 
 
-class SimtelIOEventDataWriter:
+class EventDataWriter:
     """
-    Process sim_telarray events and write tables to file.
+    Process simulation events (CORSIKA/sim_telarray) and write tables to file.
 
-    Extracts essential information from sim_telarray output files:
+    Extracts essential information from simulation files, including:
 
     - Shower parameters (energy, core location, direction)
     - Trigger patterns
@@ -108,7 +111,7 @@ class SimtelIOEventDataWriter:
         Returns
         -------
         list
-            List of astropy tables containing processed data.
+            List of tables containing processed data.
         """
         for i, file in enumerate(self.input_files[: self.max_files]):
             self._logger.info(f"Processing file {i + 1}/{self.max_files}: {file}")
@@ -117,13 +120,15 @@ class SimtelIOEventDataWriter:
         return self.create_tables()
 
     def create_tables(self):
-        """Create astropy tables from collected data."""
+        """Create tables from collected data."""
         tables = []
         for data, schema, name in [
             (self.shower_data, TableSchemas.shower_schema, "SHOWERS"),
             (self.trigger_data, TableSchemas.trigger_schema, "TRIGGERS"),
             (self.file_info, TableSchemas.file_info_schema, "FILE_INFO"),
         ]:
+            if len(data) == 0:
+                continue
             table = Table(rows=data, names=schema.keys())
             table.meta["EXTNAME"] = name
             self._add_units_to_table(table, schema)
@@ -149,40 +154,69 @@ class SimtelIOEventDataWriter:
                     self._process_mc_event(eventio_object)
                 elif isinstance(eventio_object, ArrayEvent):
                     self._process_array_event(eventio_object, file_id)
+                elif isinstance(eventio_object, iact.EventHeader):
+                    self._process_mc_shower_from_iact(eventio_object, file_id)
 
     def _process_mc_run_header(self, eventio_object):
-        """Process MC run header and update data lists."""
+        """Process MC run header (sim_telarray file)."""
         mc_head = eventio_object.parse()
         self.n_use = mc_head["n_use"]  # reuse factor n_use needed to extend the values below
         self._logger.info(f"Shower reuse factor: {self.n_use} (viewcone: {mc_head['viewcone']})")
 
     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)
-        )
+        run_info = get_combined_eventio_run_header(file)
+        if run_info:  # sim_telarray file
+            self.telescope_id_to_name = get_sim_telarray_telescope_id_to_telescope_name_mapping(
+                file
+            )
+            corsika7_id = PrimaryParticle(
+                particle_id_type="eventio_id",
+                particle_id=run_info.get("primary_id", 1),
+            ).corsika7_id
+            nsb = self.get_nsb_level_from_sim_telarray_metadata(file)
+
+            e_min, e_max = run_info["E_range"]
+            view_cone_min, view_cone_max = run_info["viewcone"]
+            core_min, core_max = run_info["core_range"]
+            azimuth, el = np.degrees(run_info["direction"])
+            zenith = 90.0 - el
+        else:  # CORSIKA IACT file
+            run_header, event_header = get_corsika_run_and_event_headers(file)
+            corsika7_id = int(event_header["particle_id"])
+            e_min = event_header["energy_min"]
+            e_max = event_header["energy_max"]
+            zenith = np.degrees(event_header["zenith"])
+            # Rotate to geographic north
+            azimuth = np.degrees(
+                event_header["azimuth"] - event_header["angle_array_x_magnetic_north"]
+            )
+            view_cone_min = event_header["viewcone_inner_angle"]
+            view_cone_max = event_header["viewcone_outer_angle"]
+            core_min = 0.0
+            core_max = run_header["x_scatter"] / 1.0e2  # cm to m
+            nsb = 0.0
+
         self.file_info.append(
             {
                 "file_name": str(file),
                 "file_id": file_id,
-                "particle_id": particle.corsika7_id,
-                "energy_min": run_info["E_range"][0],
-                "energy_max": run_info["E_range"][1],
-                "viewcone_min": run_info["viewcone"][0],
-                "viewcone_max": run_info["viewcone"][1],
-                "core_scatter_min": run_info["core_range"][0],
-                "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_nsb_level_from_sim_telarray_metadata(file),
+                "particle_id": corsika7_id,
+                "energy_min": e_min,
+                "energy_max": e_max,
+                "viewcone_min": view_cone_min,
+                "viewcone_max": view_cone_max,
+                "core_scatter_min": core_min,
+                "core_scatter_max": core_max,
+                "zenith": zenith,
+                "azimuth": azimuth,
+                "nsb_level": nsb,
             }
         )
 
     def _process_mc_shower(self, eventio_object, file_id):
         """
-        Process MC shower and update shower event list.
+        Process MC shower from sim_telarray file and update shower event list.
 
         Duplicated entries 'self.n_use' times to match the number simulated events with
         different core positions.
@@ -204,6 +238,31 @@ class SimtelIOEventDataWriter:
             for _ in range(self.n_use)
         )
 
+    def _process_mc_shower_from_iact(self, eventio_object, file_id):
+        """
+        Process MC shower from IACT file and update shower event list.
+
+        Duplicated entries 'self.n_use' times to match the number simulated events with
+        different core positions.
+        """
+        shower_header = eventio_object.parse()
+        self.n_use = int(shower_header["n_reuse"])
+
+        self.shower_data.extend(
+            {
+                "shower_id": shower_header["event_number"],
+                "event_id": shower_header["event_number"] * 100 + i,
+                "file_id": file_id,
+                "simulated_energy": shower_header["total_energy"],
+                "x_core": shower_header["reuse_x"][i] / 1.0e2,
+                "y_core": shower_header["reuse_y"][i] / 1.0e2,
+                "shower_azimuth": np.degrees(shower_header["azimuth"]),
+                "shower_altitude": 90.0 - np.degrees(shower_header["zenith"]),
+                "area_weight": 1.0,
+            }
+            for i in range(self.n_use)
+        )
+
     def _process_mc_event(self, eventio_object):
         """
         Process MC event and update shower event list.

simtools/simtel/pulse_shapes.py

@@ -0,0 +1,273 @@
+"""Pulse shape computations for light emission simulations for flasher."""
+
+import numpy as np
+from scipy.optimize import least_squares
+from scipy.signal import fftconvolve
+
+
+def _rise_width(t, y, y_low=0.1, y_high=0.9):
+    """Measure rise width between fractional amplitudes.
+
+    Parameters
+    ----------
+    t : array-like
+        Time samples in ns.
+    y : array-like
+        Pulse amplitude samples (normalized or arbitrary units).
+    y_low : float, optional
+        Lower fractional amplitude (0..1) on the rising edge. Default is 0.1.
+    y_high : float, optional
+        Upper fractional amplitude (0..1) on the rising edge. Default is 0.9.
+
+    Returns
+    -------
+    float
+        Width in ns between ``y_low`` and ``y_high`` on the rising edge.
+    """
+    i_peak = int(np.argmax(y))
+    tr = t[: i_peak + 1]
+    yr = y[: i_peak + 1]
+    t_low = np.interp(y_low, yr, tr)
+    t_high = np.interp(y_high, yr, tr)
+    return t_high - t_low
+
+
+def _fall_width(t, y, y_high=0.9, y_low=0.1):
+    """Measure fall width between fractional amplitudes.
+
+    Parameters
+    ----------
+    t : array-like
+        Time samples in ns.
+    y : array-like
+        Pulse amplitude samples (normalized or arbitrary units).
+    y_high : float, optional
+        Higher fractional amplitude (0..1) on the falling edge. Default is 0.9.
+    y_low : float, optional
+        Lower fractional amplitude (0..1) on the falling edge. Default is 0.1.
+
+    Returns
+    -------
+    float
+        Width in ns between ``y_high`` and ``y_low`` on the falling edge.
+    """
+    i_peak = int(np.argmax(y))
+    tf = t[i_peak:]
+    yf = y[i_peak:]
+    t_rev = tf[::-1]
+    y_rev = yf[::-1]
+    t_hi = np.interp(y_high, y_rev, t_rev)
+    t_lo = np.interp(y_low, y_rev, t_rev)
+    return t_lo - t_hi
+
+
+def _gaussian(t, sigma):
+    """Gaussian pulse shape.
+
+    Parameters
+    ----------
+    t : array-like
+        Time samples in ns.
+    sigma : float
+        Gaussian standard deviation in ns.
+
+    Returns
+    -------
+    numpy.ndarray
+        Gaussian values at ``t`` (unitless), with a small safeguard for ``sigma``.
+    """
+    return np.exp(-0.5 * (t / max(sigma, 1e-9)) ** 2)
+
+
+def _exp_decay(t, tau):
+    """Causal exponential decay shape.
+
+    Parameters
+    ----------
+    t : array-like
+        Time samples in ns.
+    tau : float
+        Exponential decay constant in ns.
+
+    Returns
+    -------
+    numpy.ndarray
+        Exponential values at ``t`` (unitless), zero for ``t < 0``.
+    """
+    tau = max(float(tau), 1e-9)
+    t_arr = np.asarray(t, dtype=float)
+    expo = -t_arr / tau
+    expo = np.minimum(expo, 0.0)
+    with np.errstate(over="ignore", under="ignore", invalid="ignore"):
+        e = np.exp(expo)
+    return np.where(t_arr >= 0, e, 0.0)
+
+
+def generate_gauss_expconv_pulse(
+    sigma_ns,
+    tau_ns,
+    dt_ns=0.1,
+    t_start_ns=-10,
+    t_stop_ns=25,
+    center_on_peak=False,
+):
+    """Generate a Gaussian convolved with a causal exponential.
+
+    Parameters
+    ----------
+    sigma_ns : float
+        Gaussian standard deviation (ns).
+    tau_ns : float
+        Exponential decay constant (ns).
+    dt_ns : float, optional
+        Time sampling step (ns). Default is 0.1 ns.
+    t_start_ns : float
+        Together with ``t_stop_ns``, defines the explicit start of the time grid
+        for pulse generation (ns).
+    t_stop_ns : float
+        Together with ``t_start_ns``, defines the explicit end of the time grid
+        for pulse generation (ns).
+    center_on_peak : bool, optional
+        If True, shift the returned time array so the pulse maximum is at t=0.
+        Default is False.
+
+    Returns
+    -------
+    tuple[numpy.ndarray, numpy.ndarray]
+        Tuple ``(t, y)`` with time samples in ns and normalized pulse amplitude (peak 1).
+    """
+    left = float(t_start_ns)
+    right = float(t_stop_ns)
+    t = np.arange(left, right, dt_ns, dtype=float)
+    g = _gaussian(t, sigma_ns)
+    e = _exp_decay(t, tau_ns)
+    y = fftconvolve(g, e, mode="same")
+    if y.max() > 0:
+        y = y / y.max()
+    if center_on_peak:
+        i_max = int(np.argmax(y))
+        t = t - float(t[i_max])
+    return t, y
+
+
+def solve_sigma_tau_from_rise_fall(
+    rise_width_ns,
+    fall_width_ns,
+    dt_ns=0.1,
+    rise_range=(0.1, 0.9),
+    fall_range=(0.9, 0.1),
+    t_start_ns=-10,
+    t_stop_ns=25,
+):
+    """Solve (sigma, tau) so convolved pulse matches target rise/fall widths.
+
+    Parameters
+    ----------
+    rise_width_ns : float
+        Desired width on the rising edge in ns between rise_range=(low, high) fractions.
+    fall_width_ns : float
+        Desired width on the falling edge in ns between fall_range=(high, low) fractions.
+    dt_ns : float
+        Time step for internal pulse sampling in ns.
+    rise_range : tuple[float, float]
+        Fractional amplitudes (low, high) for the rising width, defaults to (0.1, 0.9).
+    fall_range : tuple[float, float]
+        Fractional amplitudes (high, low) for the falling width, defaults to (0.9, 0.1).
+    t_start_ns : float
+        Optional start time (ns) for the internal sampling window. If provided together with
+        ``t_stop_ns``, overrides the default window.
+    t_stop_ns : float
+        Optional stop time (ns) for the internal sampling window. If provided together with
+        ``t_start_ns``, overrides the default window.
+
+    Returns
+    -------
+    tuple[float, float]
+        Tuple ``(sigma_ns, tau_ns)`` giving the Gaussian sigma and exponential tau in ns.
+    """
+    t = np.arange(float(t_start_ns), float(t_stop_ns) + dt_ns, dt_ns, dtype=float)
+
+    def pulse(sigma, tau):
+        g = _gaussian(t, sigma)
+        e = _exp_decay(t, tau)
+        y = fftconvolve(g, e, mode="same")
+        return y / y.max() if y.max() > 0 else y
+
+    rise_lo, rise_hi = rise_range
+    fall_hi, fall_lo = fall_range
+
+    def residuals(x):
+        sigma, tau = x
+        y = pulse(sigma, tau)
+        r = _rise_width(t, y, y_low=rise_lo, y_high=rise_hi) - rise_width_ns
+        f = _fall_width(t, y, y_high=fall_hi, y_low=fall_lo) - fall_width_ns
+        return [r, f]
+
+    res = least_squares(residuals, x0=[0.3, 10.0], bounds=(1e-6, 500))
+    sigma, tau = float(res.x[0]), float(res.x[1])
+    return sigma, tau
+
+
+def generate_pulse_from_rise_fall_times(
+    rise_width_ns,
+    fall_width_ns,
+    dt_ns=0.1,
+    rise_range=(0.1, 0.9),
+    fall_range=(0.9, 0.1),
+    t_start_ns=-10,
+    t_stop_ns=25,
+    center_on_peak=False,
+):
+    """Generate pulse from rise/fall time specifications.
+
+    Parameters
+    ----------
+    rise_width_ns : float
+    Target rise time (ns) between the fractional levels defined by ``rise_range``.
+    Defaults correspond to 10-90% rise time.
+    fall_width_ns : float
+    Target fall time (ns) between the fractional levels defined by ``fall_range``.
+    Defaults correspond to 90-10% fall time.
+    dt_ns : float, optional
+        Time sampling step (ns). Default is 0.1 ns.
+    rise_range : tuple[float, float], optional
+        Fractional amplitudes (low, high) for rise-time definition. Default (0.1, 0.9).
+    fall_range : tuple[float, float], optional
+        Fractional amplitudes (high, low) for fall-time definition. Default (0.9, 0.1).
+    t_start_ns : float, optional
+        Start time (ns) for the internal solver sampling window and output grid. Default -10.
+    t_stop_ns : float, optional
+        Stop time (ns) for the internal solver sampling window and output grid. Default 25.
+    center_on_peak : bool, optional
+        If True, shift the returned time array so the pulse maximum is at t=0.
+        Default is False.
+
+    Returns
+    -------
+    tuple[numpy.ndarray, numpy.ndarray]
+        Tuple ``(t, y)`` with time samples in ns and normalized pulse amplitude (peak 1).
+
+    Notes
+    -----
+    The model is a Gaussian convolved with an exponential. The parameters (sigma, tau)
+    are solved via least-squares such that the resulting pulse matches the requested rise and
+    fall times measured on monotonic segments relative to the peak.
+    """
+    sigma, tau = solve_sigma_tau_from_rise_fall(
+        rise_width_ns,
+        fall_width_ns,
+        dt_ns=dt_ns,
+        rise_range=rise_range,
+        fall_range=fall_range,
+        t_start_ns=t_start_ns,
+        t_stop_ns=t_stop_ns,
+    )
+
+    return generate_gauss_expconv_pulse(
+        sigma,
+        tau,
+        dt_ns=dt_ns,
+        t_start_ns=t_start_ns,
+        t_stop_ns=t_stop_ns,
+        center_on_peak=center_on_peak,
+    )