gammasimtools 0.25.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.io.eventio_handler import get_combined_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_combined_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

@@ -94,8 +94,13 @@ def _exp_decay(t, tau):
     numpy.ndarray
         Exponential values at ``t`` (unitless), zero for ``t < 0``.
     """
-    tau = max(tau, 1e-9)
-    return np.where(t >= 0, np.exp(-t / tau), 0.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(

simtools/simtel/simtel_config_writer.py

@@ -10,7 +10,7 @@ import numpy as np
 
 import simtools.utils.general as gen
 import simtools.version
-from simtools.io import ascii_handler
+from simtools import dependencies, settings
 from simtools.simtel.pulse_shapes import generate_pulse_from_rise_fall_times
 from simtools.utils import names
 
@@ -56,8 +56,6 @@ class SimtelConfigWriter:
         Layout name.
     label: str
         Instance label. Important for output file naming.
-    simtel_path: str or Path
-        Path to the sim_telarray installation directory.
     """
 
     TAB = " " * 3
@@ -70,7 +68,6 @@ class SimtelConfigWriter:
         telescope_model_name=None,
         telescope_design_model=None,
         label=None,
-        simtel_path=None,
     ):
         """Initialize SimtelConfigWriter."""
         self._logger = logging.getLogger(__name__)
@@ -82,7 +79,6 @@ class SimtelConfigWriter:
         self._layout_name = layout_name
         self._telescope_model_name = telescope_model_name
         self._telescope_design_model = telescope_design_model
-        self._simtel_path = simtel_path
 
     def write_telescope_config_file(
         self, config_file_path, parameters, telescope_name=None, telescope_design_model=None
@@ -125,14 +121,14 @@ class SimtelConfigWriter:
                 file.write(f"{meta}\n")
 
     @staticmethod
-    def write_lightpulse_table_gauss_expconv(
+    def write_light_pulse_table_gauss_exp_conv(
         file_path,
-        width_ns=None,
-        exp_decay_ns=None,
+        width_ns,
+        exp_decay_ns,
+        fadc_sum_bins,
         dt_ns=0.1,
         rise_range=(0.1, 0.9),
         fall_range=(0.9, 0.1),
-        fadc_sum_bins=None,
         time_margin_ns=10.0,
     ):
         """Write a pulse table for a Gaussian convolved with a causal exponential.
@@ -143,22 +139,19 @@ class SimtelConfigWriter:
             Destination path of the ASCII pulse table to write. Parent directory must exist.
         width_ns : float
             Target rise time in ns between the fractional levels defined by ``rise_range``.
-            Defaults correspond to 10-90% rise time.
         exp_decay_ns : float
             Target fall time in ns between the fractional levels defined by ``fall_range``.
-            Defaults correspond to 90-10% fall time.
-        dt_ns : float, optional
-            Time sampling step in ns for the generated pulse table. Default is 0.1.
-        rise_range : tuple[float, float], optional
-            Fractional amplitude bounds (low, high) for rise-time definition. Default (0.1, 0.9).
-        fall_range : tuple[float, float], optional
-            Fractional amplitude bounds (high, low) for fall-time definition. Default (0.9, 0.1).
         fadc_sum_bins : int
             Length of the FADC integration window (treated as ns here) used to derive
             the internal time sampling window of the solver as [-(margin), bins + margin].
+        dt_ns : float, optional
+            Time sampling step in ns for the generated pulse table.
+        rise_range : tuple[float, float], optional
+            Fractional amplitude bounds (low, high) for rise-time definition.
+        fall_range : tuple[float, float], optional
+            Fractional amplitude bounds (high, low) for fall-time definition.
         time_margin_ns : float, optional
             Margin in ns to add to both ends of the FADC window when ``fadc_sum_bins`` is given.
-            Default is 5.0 ns.
 
         Returns
         -------
@@ -174,8 +167,10 @@ class SimtelConfigWriter:
         if width_ns is None or exp_decay_ns is None:
             raise ValueError("width_ns (rise 10-90) and exp_decay_ns (fall 90-10) are required")
         logger.info(
-            f"Generating lightpulse table with rise10-90={width_ns} ns, "
-            f"fall90-10={exp_decay_ns} ns, dt={dt_ns} ns"
+            "Generating pulse-shape table with "
+            f"rise{int(rise_range[0] * 100)}-{int(rise_range[1] * 100)}={width_ns} ns, "
+            f"fall{int(fall_range[0] * 100)}-{int(fall_range[1] * 100)}={exp_decay_ns} ns, "
+            f"dt={dt_ns} ns"
         )
         width = float(fadc_sum_bins)
         t_start_ns = -abs(time_margin_ns + width)
@@ -193,6 +188,42 @@ class SimtelConfigWriter:
 
         return SimtelConfigWriter._write_ascii_pulse_table(file_path, t, y)
 
+    @staticmethod
+    def write_angular_distribution_table_lambertian(
+        file_path,
+        max_angle_deg,
+        n_samples=100,
+    ):
+        """Write a Lambertian angular distribution table (I(t) ~ cos(t)).
+
+        Parameters
+        ----------
+        file_path : str or pathlib.Path
+            Destination path of the ASCII table to write. Parent directory must exist.
+        max_angle_deg : float
+            Maximum angle (deg) for the distribution sampling range [0, max_angle_deg].
+        n_samples : int, optional
+            Number of samples (including end point) from 0 to max_angle_deg. Default 100.
+
+        Returns
+        -------
+        pathlib.Path
+            Path to created angular distribution table.
+        """
+        logger.info(
+            f"Generating Lambertian angular distribution table up to {max_angle_deg} deg "
+            f"with {n_samples} samples"
+        )
+        angles = np.linspace(0.0, float(max_angle_deg), int(n_samples), dtype=float)
+        intensities = np.cos(np.deg2rad(angles))
+        intensities[intensities < 0] = 0.0
+        if intensities.max() > 0:
+            intensities /= intensities.max()
+
+        return SimtelConfigWriter._write_ascii_angle_distribution_table(
+            file_path, angles, intensities
+        )
+
     @staticmethod
     def _write_ascii_pulse_table(file_path, t, y):
         """Write two-column ASCII pulse table."""
@@ -202,6 +233,15 @@ class SimtelConfigWriter:
                 fh.write(f"{ti:.6f} {yi:.8f}\n")
         return Path(file_path)
 
+    @staticmethod
+    def _write_ascii_angle_distribution_table(file_path, angles, intensities):
+        """Write two-column ASCII angular distribution table."""
+        with open(file_path, "w", encoding="utf-8") as fh:
+            fh.write("# angle[deg] relative_intensity\n")
+            for a, i in zip(angles, intensities):
+                fh.write(f"{a:.6f} {i:.8f}\n")
+        return Path(file_path)
+
     def _get_parameters_for_sim_telarray(self, parameters, config_file_path):
         """
         Convert parameter dictionary to sim_telarray configuration file format.
@@ -257,28 +297,24 @@ class SimtelConfigWriter:
             Model parameters in sim_telarray format including flasher parameters.
 
         """
-        if "flasher_pulse_shape" not in parameters and "flasher_pulse_width" not in parameters:
+        if "flasher_pulse_shape" not in parameters:
             return simtel_par
 
         mapping = {
             "gauss": "laser_pulse_sigtime",
             "tophat": "laser_pulse_twidth",
+            "gauss-exponential": "laser_pulse_sigtime",
         }
 
-        shape = parameters.get("flasher_pulse_shape", {}).get("value", "").lower()
-        if "exponential" in shape:
-            simtel_par["laser_pulse_exptime"] = parameters.get("flasher_pulse_exp_decay", {}).get(
-                "value", 0.0
-            )
-        else:
-            simtel_par["laser_pulse_exptime"] = 0.0
+        shape_value = parameters.get("flasher_pulse_shape", {}).get("value")
+        shape = shape_value[0].lower()
+        width = shape_value[1]
+        exp_decay = shape_value[2]
 
-        width = parameters.get("flasher_pulse_width", {}).get("value", 0.0)
+        simtel_par["laser_pulse_exptime"] = exp_decay if ("exponential" in shape) else 0.0
 
         simtel_par.update(dict.fromkeys(mapping.values(), 0.0))
-        if shape == "gauss-exponential":
-            simtel_par["laser_pulse_sigtime"] = width
-        elif shape in mapping:
+        if shape in mapping:
             simtel_par[mapping[shape]] = width
         else:
             self._logger.warning(f"Flasher pulse shape '{shape}' without width definition")
@@ -576,17 +612,24 @@ class SimtelConfigWriter:
             "simtools_model_production_version": self._model_version,
         }
         try:
-            build_opts = ascii_handler.collect_data_from_file(
-                Path(self._simtel_path) / "build_opts.yml"
-            )
+            build_opts = dependencies.get_build_options()
             for key, value in build_opts.items():
                 meta_items[f"simtools_{key}"] = value
         except (FileNotFoundError, TypeError):
             pass  # don't expect build_opts.yml to be present on all systems
 
+        # CORSIKA executable without _flat/_curved suffix (do not know here if curved or flat)
+        try:
+            meta_items["simtools_corsika_exec"] = settings.config.corsika_exe.name.removesuffix(
+                "_flat"
+            )
+        except AttributeError as exc:
+            raise AttributeError("CORSIKA executable path is not set in settings.") from exc
+
         file.write(f"{self.TAB}% Simtools parameters\n")
         for key, value in meta_items.items():
-            file.write(f"{self.TAB}metaparam global set {key} = {value}\n")
+            if not isinstance(value, list):
+                file.write(f"{self.TAB}metaparam global set {key} = {value}\n")
 
     def _write_site_parameters(
         self, file, site_parameters, model_path, telescope_model, additional_metadata=None

simtools/simtel/simtel_table_reader.py

@@ -154,14 +154,16 @@ def _data_columns_mirror_reflectivity(n_columns, n_dim):
         {"name": "wavelength", "description": "Wavelength", "unit": "nm"},
     ]
     if n_dim:
-        for angle in n_dim:
-            _columns.append(
+        _columns.extend(
+            [
                 {
                     "name": f"reflectivity_{angle}deg",
                     "description": f"Mirror reflectivity at {angle} deg",
                     "unit": None,
-                },
-            )
+                }
+                for angle in n_dim
+            ]
+        )
     else:
         _columns.append(
             {

simtools/simtel/simulator_array.py

@@ -3,6 +3,7 @@
 import logging
 import stat
 
+from simtools import settings
 from simtools.io import io_handler
 from simtools.runners.simtel_runner import InvalidOutputFileError, SimtelRunner
 from simtools.utils.general import clear_default_sim_telarray_cfg_directories
@@ -16,8 +17,6 @@ class SimulatorArray(SimtelRunner):
     ----------
     corsika_config_data: CorsikaConfig
         CORSIKA configuration.
-    simtel_path: str or Path
-        Location of source of the sim_telarray/CORSIKA package.
     label: str
         Instance label.
     use_multipipe: bool
@@ -29,7 +28,6 @@ class SimulatorArray(SimtelRunner):
     def __init__(
         self,
         corsika_config,
-        simtel_path,
         label=None,
         use_multipipe=False,
         sim_telarray_seeds=None,
@@ -40,7 +38,6 @@ class SimulatorArray(SimtelRunner):
         self._logger.debug("Init SimulatorArray")
         super().__init__(
             label=label,
-            simtel_path=simtel_path,
             corsika_config=corsika_config,
             use_multipipe=use_multipipe,
             calibration_run_mode=calibration_config.get("run_mode") if calibration_config else None,
@@ -181,7 +178,7 @@ class SimulatorArray(SimtelRunner):
         output_file = self.get_file_name(file_type="simtel_output", run_number=run_number)
         self.corsika_config.array_model.export_all_simtel_config_files()
 
-        command = str(self._simtel_path.joinpath("sim_telarray/bin/sim_telarray"))
+        command = str(settings.config.sim_telarray_exe)
         command += f" -c {self.corsika_config.array_model.config_file_path}"
         command += f" -I{config_dir}"
         command += super().get_config_option(
@@ -222,9 +219,7 @@ class SimulatorArray(SimtelRunner):
             "fadc_sysvar_pedestal",
             "fadc_dev_pedestal",
         ]
-        null_command_parts = []
-        for param in null_values:
-            null_command_parts.append(super().get_config_option(param, 0.0))
+        null_command_parts = [super().get_config_option(param, 0.0) for param in null_values]
         command = " ".join(null_command_parts)
 
         one_values = [
@@ -233,9 +228,7 @@ class SimulatorArray(SimtelRunner):
             "fadc_lg_dev_pedestal",
             "fadc_lg_sysvar_pedestal",
         ]
-        one_command_parts = []
-        for param in one_values:
-            one_command_parts.append(super().get_config_option(param, -1.0))
+        one_command_parts = [super().get_config_option(param, -1.0) for param in one_values]
         command += " " + " ".join(one_command_parts)
         return command
 

simtools/simtel/simulator_camera_efficiency.py

@@ -3,6 +3,7 @@
 import logging
 from pathlib import Path
 
+from simtools import settings
 from simtools.io import ascii_handler
 from simtools.runners.simtel_runner import SimtelRunner
 from simtools.utils import general
@@ -20,8 +21,6 @@ class SimulatorCameraEfficiency(SimtelRunner):
         Instance of SiteModel class.
     label: str
         Instance label. Important for output file naming.
-    simtel_path: str or Path
-        Location of sim_telarray installation.
     file_simtel: str or Path
         Location of the sim_telarray testeff tool output file.
     zenith_angle: float
@@ -37,7 +36,6 @@ class SimulatorCameraEfficiency(SimtelRunner):
         telescope_model,
         site_model,
         label=None,
-        simtel_path=None,
         file_simtel=None,
         file_log=None,
         zenith_angle=None,
@@ -48,7 +46,7 @@ class SimulatorCameraEfficiency(SimtelRunner):
         self._logger = logging.getLogger(__name__)
         self._logger.debug("Init SimulatorCameraEfficiency")
 
-        super().__init__(label=label, simtel_path=simtel_path)
+        super().__init__(label=label)
 
         self._telescope_model = telescope_model
         self._site_model = site_model
@@ -109,7 +107,7 @@ class SimulatorCameraEfficiency(SimtelRunner):
                 "mirror_reflectivity", "secondary_mirror_incidence_angle"
             )
 
-        command = str(self._simtel_path.joinpath("sim_telarray/testeff"))
+        command = str(settings.config.sim_telarray_path / "bin/testeff")
         if self.skip_correction_to_nsb_spectrum:
             command += " -nc"  # Do not apply correction to original altitude where B&E was derived
         command += " -I"  # Clear the fall-back configuration directories
@@ -150,7 +148,7 @@ class SimulatorCameraEfficiency(SimtelRunner):
         command = general.clear_default_sim_telarray_cfg_directories(command)
 
         return (
-            f"cd {self._simtel_path.joinpath('sim_telarray')} && {command}",
+            f"cd {settings.config.sim_telarray_path} && {command}",
             self._file_simtel,
             self._file_log,
         )