gammasimtools 0.25.0__py3-none-any.whl → 0.27.0__py3-none-any.whl

simtools/{simtel/simtel_io_event_reader.py → sim_events/reader.py}

@@ -44,11 +44,11 @@ class TriggeredEventData:
     angular_distance: list[float] = field(default_factory=list)
 
 
-class SimtelIOEventDataReader:
+class EventDataReader:
     """Read reduced MC data set stored in astropy tables."""
 
     def __init__(self, event_data_file, telescope_list=None):
-        """Initialize SimtelIOEventDataReader."""
+        """Initialize EventDataReader."""
         self._logger = logging.getLogger(__name__)
         self.telescope_list = telescope_list
 
@@ -61,7 +61,7 @@ class SimtelIOEventDataReader:
 
         Rearrange dictionary with tables names into a list of dictionaries
         under the assumption that the file contains the tables "SHOWERS",
-        "TRIGGERS", and "FILE_INFO".
+        "TRIGGERS", and "FILE_INFO". Note that not all tables need to be present.
 
         Parameters
         ----------
@@ -88,13 +88,13 @@ class SimtelIOEventDataReader:
         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],
-                    "TRIGGERS": dataset_dict["TRIGGERS"][i],
-                    "FILE_INFO": dataset_dict["FILE_INFO"][i],
-                }
-            )
+            entry = {
+                "SHOWERS": dataset_dict["SHOWERS"][i],
+                "FILE_INFO": dataset_dict["FILE_INFO"][i],
+            }
+            if i < len(dataset_dict["TRIGGERS"]) and dataset_dict["TRIGGERS"][i]:
+                entry["TRIGGERS"] = dataset_dict["TRIGGERS"][i]
+            data_sets.append(entry)
 
         return data_sets
 
@@ -248,20 +248,23 @@ class SimtelIOEventDataReader:
         tuple
             A tuple with file info table, shower, triggered shower, and triggered event data.
         """
-        table_name_map = table_name_map or {}
 
-        def get_name(key):
-            return table_name_map.get(key, key)
+        def get_name(k):
+            return k if table_name_map is None else table_name_map.get(k)
 
-        tables = table_handler.read_tables(
-            event_data_file,
-            table_names=[get_name(k) for k in ("SHOWERS", "TRIGGERS", "FILE_INFO")],
-        )
+        table_names = [
+            name for k in ("SHOWERS", "TRIGGERS", "FILE_INFO") if (name := get_name(k)) is not None
+        ]
+        tables = table_handler.read_tables(event_data_file, table_names=table_names)
         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")])
+        if tables.get(get_name("TRIGGERS")) is None:
+            self._logger.info("No triggered event data found in the file.")
+            return tables[get_name("FILE_INFO")], shower_data, None, None
+
         triggered_data = self._table_to_triggered_data(tables[get_name("TRIGGERS")])
         triggered_shower = self._get_triggered_shower_data(
             shower_data,

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,34 +10,13 @@ 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
 
 logger = logging.getLogger(__name__)
 
 
-def sim_telarray_random_seeds(seed, number):
-    """
-    Generate random seeds to be used in sim_telarray.
-
-    Parameters
-    ----------
-    seed: int
-        Seed for the random number generator.
-    number: int
-        Number of random seeds to generate.
-
-    Returns
-    -------
-    list
-        List of random seeds.
-    """
-    rng = np.random.default_rng(seed)
-    max_int32 = np.iinfo(np.int32).max  # sim_telarray requires 32 bit integers
-    return list(rng.integers(low=1, high=max_int32, size=number, dtype=np.int32))
-
-
 class SimtelConfigWriter:
     """
     SimtelConfigWriter writes sim_telarray configuration files.
@@ -56,8 +35,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,11 +47,9 @@ class SimtelConfigWriter:
         telescope_model_name=None,
         telescope_design_model=None,
         label=None,
-        simtel_path=None,
     ):
         """Initialize SimtelConfigWriter."""
         self._logger = logging.getLogger(__name__)
-        self._logger.debug("Init SimtelConfigWriter")
 
         self._site = site
         self._model_version = model_version
@@ -82,7 +57,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 +99,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 +117,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 +145,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 +166,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 +211,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 +275,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")
@@ -456,39 +470,6 @@ class SimtelConfigWriter:
                 file.write(f"# include <{tel_config_file}>\n\n")
             file.write("#endif \n\n")  # configuration files need to end with \n\n
 
-        if additional_metadata and additional_metadata.get("random_instrument_instances"):
-            self._write_random_seeds_file(additional_metadata, config_file_directory)
-
-    def _write_random_seeds_file(self, sim_telarray_seeds, config_file_directory):
-        """
-        Write list of random number used to generate random instances of instrument.
-
-        Parameters
-        ----------
-        random_instrument_instances: int
-            Number of random instances of the instrument.
-        """
-        self._logger.info(
-            "Writing random seed file "
-            f"{config_file_directory}/{sim_telarray_seeds['seed_file_name']}"
-            f" (global seed {sim_telarray_seeds['seed']})"
-        )
-        if sim_telarray_seeds["random_instrument_instances"] > 1024:
-            raise ValueError("Number of random instances of instrument must be less than 1024")
-        random_integers = sim_telarray_random_seeds(
-            sim_telarray_seeds["seed"], sim_telarray_seeds["random_instrument_instances"]
-        )
-        with open(
-            config_file_directory / sim_telarray_seeds["seed_file_name"], "w", encoding="utf-8"
-        ) as file:
-            file.write(
-                "# Random seeds for instrument configuration generated with seed "
-                f"{sim_telarray_seeds['seed']}"
-                f" (model version {self._model_version}, site {self._site})\n"
-            )
-            for number in random_integers:
-                file.write(f"{number}\n")
-
     def write_single_mirror_list_file(
         self, mirror_number, mirrors, single_mirror_list_file, set_focal_length_to_zero=False
     ):
@@ -576,17 +557,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