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

simtools/runners/simtools_runner.py

@@ -9,7 +9,7 @@ from simtools import dependencies
 from simtools.io import ascii_handler
 
 
-def run_applications(args_dict, db_config, logger):
+def run_applications(args_dict, logger):
     """
     Run simtools applications step-by-step as defined in a configuration file.
 
@@ -17,8 +17,6 @@ def run_applications(args_dict, db_config, logger):
     ----------
     args_dict : dict
         Dictionary containing command line arguments.
-    db_config : dict
-        Database configuration
     logger : logging.Logger
         Logger for logging application output.
     """
@@ -33,7 +31,7 @@ def run_applications(args_dict, db_config, logger):
 
     with log_file.open("w", encoding="utf-8") as file:
         file.write("Running simtools applications\n")
-        file.write(dependencies.get_version_string(db_config, run_time))
+        file.write(dependencies.get_version_string(run_time))
 
         for config in configurations:
             app = config.get("application")

simtools/schemas/model_parameters/flasher_pulse_exp_decay.schema.yml

@@ -1,6 +1,8 @@
 %YAML 1.2
 ---
 title: Schema for flasher_pulse_exp_decay model parameter
+deprecated: true
+deprecation_note: "Replaced by updated definition of flasher_pulse_shape"
 schema_version: 0.1.0
 meta_schema: simpipe-schema
 meta_schema_url: https://raw.githubusercontent.com/gammasim/simtools/main/src/simtools/schemas/model_parameter_and_data_schema.metaschema.yml

simtools/schemas/model_parameters/flasher_pulse_shape.schema.yml

@@ -1,6 +1,56 @@
 %YAML 1.2
 ---
 title: Schema for flasher_pulse_shape model parameter
+schema_version: 0.2.0
+meta_schema: simpipe-schema
+meta_schema_url: https://raw.githubusercontent.com/gammasim/simtools/main/src/simtools/schemas/model_parameter_and_data_schema.metaschema.yml
+meta_schema_version: 0.1.0
+name: flasher_pulse_shape
+short_description: |-
+  Definition of flasher pulse shape.
+description: |-
+  Definition of flasher pulse shape both shape and relevant
+  timing parameters.
+data:
+  - type: string
+    description: Shape of the flasher pulse.
+    default: Gauss
+    allowed_values:
+      - Gauss
+      - TopHat
+      - Exponential
+      - Gauss-Exponential
+  - type: float64
+    description: |-
+     Characteristic width of the flasher pulse shape.
+     For 'TopHat', this is the pulse width, for 'Gauss' and 'Gauss-Exponential'
+     the rms width. Ignored if shape is 'Exponential'.
+    unit: ns
+    default: 0
+    allowed_range:
+      min: 0
+  - type: float64
+    description: |-
+      Exponential decay time of the flasher pulse shape.
+      Only relevant if shape is 'Exponential' or 'Gauss-Exponential'.
+    unit: ns
+    default: 0
+    allowed_range:
+      min: 0
+instrument:
+  class: Calibration
+activity:
+  setting:
+    - SetParameterFromExternal
+  validation:
+    - ValidateParameterByExpert
+source:
+  - Initial instrument setup
+simulation_software:
+  - name: simtools
+    version: ">0.24.0"
+---
+title: Schema for flasher_pulse_shape model parameter
 schema_version: 0.1.0
 meta_schema: simpipe-schema
 meta_schema_url: https://raw.githubusercontent.com/gammasim/simtools/main/src/simtools/schemas/model_parameter_and_data_schema.metaschema.yml

simtools/schemas/model_parameters/flasher_pulse_width.schema.yml

@@ -1,6 +1,8 @@
 %YAML 1.2
 ---
 title: Schema for flasher_pulse_width model parameter
+deprecated: true
+deprecation_note: "Replaced by updated definition of flasher_pulse_shape"
 schema_version: 0.1.0
 meta_schema: simpipe-schema
 meta_schema_url: https://raw.githubusercontent.com/gammasim/simtools/main/src/simtools/schemas/model_parameter_and_data_schema.metaschema.yml

simtools/schemas/simulation_models_info.schema.yml

@@ -74,6 +74,8 @@ $defs:
           - type: string
           - type: array
           - type: "null"
+      model_parameter_schema_version:
+        $ref: 'common_definitions.schema.yml#/$defs/semantic_version_pattern'
     required:
       - version
     additionalProperties: false

simtools/settings.py

@@ -0,0 +1,154 @@
+"""Centralized settings object with command line and environment variables."""
+
+import os
+from pathlib import Path
+from types import MappingProxyType
+
+
+class _Config:
+    """Centralized settings object with command line and environment variables."""
+
+    def __init__(self):
+        """Initialize empty config."""
+        self._args = {}
+        self._db_config = {}
+        self._sim_telarray_path = None
+        self._sim_telarray_exe = None
+        self._corsika_path = None
+        self._corsika_exe = None
+
+    def load(self, args=None, db_config=None):
+        """
+        Load configuration from command line arguments and environment variables.
+
+        For paths, first check for environment variables, then command line arguments.
+
+        Parameters
+        ----------
+        args : dict, optional
+            Command line arguments.
+        db_config : dict, optional
+            Database configuration.
+
+        """
+        self._args = MappingProxyType(args) if args is not None else {}
+        self._db_config = MappingProxyType(db_config) if db_config is not None else {}
+        self._sim_telarray_path = (
+            args.get("sim_telarray_path")
+            if args is not None and "sim_telarray_path" in args
+            else os.getenv("SIMTOOLS_SIM_TELARRAY_PATH")
+        )
+
+        self._sim_telarray_exe = (
+            args.get("sim_telarray_executable")
+            if args is not None and "sim_telarray_executable" in args
+            else os.getenv("SIMTOOLS_SIM_TELARRAY_EXECUTABLE", "sim_telarray")
+        )
+
+        self._corsika_path = (
+            args.get("corsika_path")
+            if args is not None and "corsika_path" in args
+            else os.getenv("SIMTOOLS_CORSIKA_PATH")
+        )
+
+        self._corsika_exe = self._get_corsika_exec() if self._corsika_path is not None else None
+
+    def _get_corsika_exec(self):
+        """
+        Get the CORSIKA executable from environment variable or command line argument.
+
+        Build the executable name based on configured interaction models. Fall back to
+        legacy naming (simply "corsika") if models are not specified.
+        """
+        he_model = (
+            self._args.get("corsika_he_interaction")
+            if self._args is not None and "corsika_he_interaction" in self._args
+            else os.getenv("SIMTOOLS_CORSIKA_HE_INTERACTION")
+        )
+
+        le_model = (
+            self._args.get("corsika_le_interaction")
+            if self._args is not None and "corsika_le_interaction" in self._args
+            else os.getenv("SIMTOOLS_CORSIKA_LE_INTERACTION")
+        )
+
+        if he_model and le_model:
+            corsika_exe = self.corsika_path / f"corsika_{he_model}_{le_model}_flat"
+            if corsika_exe.exists():
+                return corsika_exe
+
+        # legacy naming
+        return self.corsika_path / "corsika"
+
+    @property
+    def args(self):
+        """Command line arguments."""
+        return self._args
+
+    @property
+    def db_config(self):
+        """Database configuration."""
+        return self._db_config
+
+    @property
+    def sim_telarray_path(self):
+        """Path to the sim_telarray installation directory."""
+        return Path(self._sim_telarray_path) if self._sim_telarray_path is not None else None
+
+    @property
+    def sim_telarray_exe(self):
+        """Path to the sim_telarray executable."""
+        return (
+            Path(self._sim_telarray_path) / "bin" / self._sim_telarray_exe
+            if self._sim_telarray_path is not None
+            else None
+        )
+
+    @property
+    def sim_telarray_exe_debug_trace(self):
+        """Path to the debug trace version of the sim_telarray executable."""
+        return (
+            Path(self._sim_telarray_path) / "bin" / (self._sim_telarray_exe + "_debug_trace")
+            if self._sim_telarray_path is not None
+            else None
+        )
+
+    @property
+    def corsika_path(self):
+        """Path to the CORSIKA installation directory."""
+        return Path(self._corsika_path) if self._corsika_path is not None else None
+
+    @property
+    def corsika_exe(self):
+        """Path to the CORSIKA executable."""
+        return (
+            Path(self._corsika_path) / self._corsika_exe if self._corsika_path is not None else None
+        )
+
+    @property
+    def corsika_exe_curved(self):
+        """Path to the curved version of the CORSIKA executable."""
+        if self._corsika_exe is None:
+            return None
+        corsika_curved = (
+            self._corsika_exe.name.replace("_flat", "_curved")
+            if "_flat" in self._corsika_exe.name
+            else self._corsika_exe.name + "-curved"  # legacy naming convention
+        )
+        return Path(self._corsika_path) / corsika_curved if self._corsika_path is not None else None
+
+    @property
+    def corsika_dummy_file(self):
+        """
+        Path to a dummy CORSIKA file required by sim_telarray for ray-tracing simulations.
+
+        This file does not need to exist; sim_telarray only requires a file path.
+        """
+        return (
+            self.sim_telarray_path / "run9991.corsika.gz"
+            if self._sim_telarray_path is not None
+            else None
+        )
+
+
+config = _Config()

simtools/sim_events/file_info.py

@@ -0,0 +1,128 @@
+#!/usr/bin/python3
+"""Read file info and run headers from eventio (CORSIKA IACT, sim_telarray) files."""
+
+import warnings
+
+from eventio import EventIOFile, iact
+from eventio.simtel import MCRunHeader, MCShower, RunHeader
+
+# Suppress all UserWarnings from corsikaio - no CORSIKA versions <7.7 are supported anyway
+warnings.filterwarnings("ignore", category=UserWarning, module=r"corsikaio\.subblocks\..*")
+
+
+def get_corsika_run_number(file):
+    """
+    Return the CORSIKA run number from an eventio (CORSIKA IACT or sim_telarray) file.
+
+    Parameters
+    ----------
+    file: str
+        Path to the eventio file.
+
+    Returns
+    -------
+    int, None
+        CORSIKA run number. Returns None if not found.
+    """
+    run_header = get_combined_eventio_run_header(file)
+    if run_header and "run" in run_header:
+        return run_header["run"]
+    run_header, _ = get_corsika_run_and_event_headers(file)
+    try:
+        return int(run_header["run_number"])
+    except (TypeError, KeyError, ValueError):
+        return None
+
+
+def get_combined_eventio_run_header(sim_telarray_file):
+    """
+    Return the CORSIKA run header information from an eventio (sim_telarray) file.
+
+    Reads both RunHeader and MCRunHeader object from file and returns a merged dictionary.
+    Adds primary id from the first event.
+
+    Parameters
+    ----------
+    sim_telarray_file: str
+        Path to the sim_telarray file.
+
+    Returns
+    -------
+    dict, None
+        CORSIKA run header. Returns None if not found.
+    """
+    run_header = mc_run_header = None
+    primary_id = None
+
+    with EventIOFile(sim_telarray_file) as f:
+        for o in f:
+            if isinstance(o, RunHeader) and run_header is None:
+                run_header = o.parse()
+            elif isinstance(o, MCRunHeader) and mc_run_header is None:
+                mc_run_header = o.parse()
+            elif isinstance(o, MCShower):  # get primary_id from first MCShower
+                primary_id = o.parse().get("primary_id")
+            if run_header and mc_run_header and primary_id is not None:
+                break
+
+    run_header = run_header or {}
+    mc_run_header = mc_run_header or {}
+    if primary_id is not None:
+        mc_run_header["primary_id"] = primary_id
+    return run_header | mc_run_header or None
+
+
+def get_corsika_run_and_event_headers(corsika_iact_file):
+    """
+    Return the CORSIKA run and event headers from a CORSIKA IACT eventio file.
+
+    Parameters
+    ----------
+    corsika_iact_file: str, Path
+        Path to the CORSIKA IACT eventio file.
+
+    Returns
+    -------
+    tuple
+        CORSIKA run header and event header as dictionaries.
+    """
+    run_header = event_header = None
+
+    with EventIOFile(corsika_iact_file) as f:
+        for o in f:
+            if isinstance(o, iact.RunHeader) and run_header is None:
+                run_header = o.parse()
+            elif isinstance(o, iact.EventHeader) and event_header is None:
+                event_header = o.parse()
+            if run_header and event_header:
+                break
+
+    return run_header, event_header
+
+
+def get_simulated_events(event_io_file):
+    """
+    Return the number of shower and MC events from a simulation (eventio) file.
+
+    For a sim_telarray file, the number of simulated showers and MC events is
+    determined by counting the number of MCShower (type id 2020) and MCEvent
+    objects (type id 2021). For a CORSIKA IACT file, the number of simulated
+    showers is determined by counting the number of IACTShower (type id 1202).
+
+    Parameters
+    ----------
+    event_io_file: str, Path
+        Path to the eventio file.
+
+    Returns
+    -------
+    tuple
+        Number of showers and number of MC events (MC events for sim_telarray files only).
+    """
+    counts = {1202: 0, 2020: 0, 2021: 0}
+    with EventIOFile(event_io_file) as f:
+        for o in f:
+            t = o.header.type
+            if t in counts:
+                counts[t] += 1
+    return counts[2020] if counts[2020] else counts[1202], counts[2021]

simtools/{simtel/simtel_io_event_histograms.py → sim_events/histograms.py}

@@ -1,4 +1,4 @@
-"""Histograms for shower and triggered events."""
+"""Histograms for shower and (if available) triggered events."""
 
 import copy
 import logging
@@ -6,12 +6,12 @@ import logging
 import astropy.units as u
 import numpy as np
 
-from simtools.simtel.simtel_io_event_reader import SimtelIOEventDataReader
+from simtools.sim_events.reader import EventDataReader
 
 
-class SimtelIOEventHistograms:
+class EventDataHistograms:
     """
-    Generate and fill histograms for shower and triggered events.
+    Generate and fill histograms for shower and (if available) triggered events.
 
     Event data is read from the reduced MC event data file.
     Calculate cumulative and relative (efficiency) distributions.
@@ -35,7 +35,7 @@ class SimtelIOEventHistograms:
         self.histograms = {}
         self.file_info = {}
 
-        self.reader = SimtelIOEventDataReader(event_data_file, telescope_list=telescope_list)
+        self.reader = EventDataReader(event_data_file, telescope_list=telescope_list)
 
     def fill(self):
         """
@@ -63,12 +63,10 @@ class SimtelIOEventHistograms:
 
             self.histograms = self._define_histograms(event_data, triggered_data, shower_data)
 
-            for name, data in self.histograms.items():
-                self._logger.debug(f"Filling histogram {name}")
+            for data in self.histograms.values():
                 self._fill_histogram_and_bin_edges(data)
 
         self.print_summary()
-
         self.calculate_efficiency_data()
         self.calculate_cumulative_data()
 
@@ -202,11 +200,14 @@ class SimtelIOEventHistograms:
         Adds to existing histogram if present, otherwise initializes it.
         """
         if data["1d"]:
+            if data["event_data"] is None:
+                return
             hist, _ = np.histogram(
-                getattr(data["event_data"], data["event_data_column"]),
-                bins=data["bin_edges"],
+                getattr(data["event_data"], data["event_data_column"]), bins=data["bin_edges"]
             )
         else:
+            if data["event_data"][0] is None or data["event_data"][1] is None:
+                return
             hist, _, _ = np.histogram2d(
                 getattr(data["event_data"][0], data["event_data_column"][0]),
                 getattr(data["event_data"][1], data["event_data_column"][1]),
@@ -227,6 +228,8 @@ class SimtelIOEventHistograms:
         dict
             Dictionary containing the efficiency histograms.
         """
+        if not any(isinstance(ds, dict) and "TRIGGERS" in ds for ds in self.reader.data_sets):
+            return None
 
         def calculate_efficiency(trig_hist, mc_hist):
             with np.errstate(divide="ignore", invalid="ignore"):
@@ -295,11 +298,15 @@ class SimtelIOEventHistograms:
         """Return bins for the viewcone histogram."""
         if "viewcone_bin_edges" in self.histograms:
             return self.histograms["viewcone_bin_edges"]
-        return np.linspace(
-            self.file_info.get("viewcone_min", 0.0 * u.deg).to("deg").value,
-            self.file_info.get("viewcone_max", 20.0 * u.deg).to("deg").value,
-            100,
-        )
+
+        viewcone_min = self.file_info.get("viewcone_min", 0.0 * u.deg).to("deg").value
+        viewcone_max = self.file_info.get("viewcone_max", 20.0 * u.deg).to("deg").value
+
+        # avoid zero-width bins
+        if viewcone_min == viewcone_max:
+            viewcone_max = viewcone_min + 0.5
+
+        return np.linspace(viewcone_min, viewcone_max, 100)
 
     def calculate_cumulative_data(self):
         """
@@ -310,6 +317,9 @@ class SimtelIOEventHistograms:
         dict
             Dictionary containing the cumulative histograms.
         """
+        if not any(isinstance(ds, dict) and "TRIGGERS" in ds for ds in self.reader.data_sets):
+            return None
+
         cumulative_data = {}
         suffix = "_cumulative"
 

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,