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

simtools/reporting/docs_read_parameters.py

@@ -26,11 +26,10 @@ MARKDOWN_LINK_RE = re.compile(r"\[([^\]]+)\]\(([^)]+)\)")
 class ReadParameters:
     """Read and manage model parameter data for report generation."""
 
-    def __init__(self, db_config, args, output_path):
+    def __init__(self, args, output_path):
         """Initialise class."""
         self._logger = logging.getLogger(__name__)
-        self.db = db_handler.DatabaseHandler(db_config=db_config)
-        self.db_config = db_config
+        self.db = db_handler.DatabaseHandler()
         self.array_element = args.get("telescope", None)
         self.site = args.get("site", None)
         self.model_version = args.get("model_version", None)
@@ -109,7 +108,6 @@ class ReadParameters:
             plot_pixels.plot(
                 config=plot_config,
                 output_file=Path(f"{outpath}/{plot_name}"),
-                db_config=self.db_config,
             )
             plot_names.append(plot_name)
         else:
@@ -142,7 +140,6 @@ class ReadParameters:
             plot_mirrors.plot(
                 config=plot_config,
                 output_file=Path(f"{outpath}/{plot_name}"),
-                db_config=self.db_config,
             )
             plot_names.append(plot_name)
         else:
@@ -165,7 +162,6 @@ class ReadParameters:
             telescope=tel,
             output_path=outpath,
             plot_type="all",
-            db_config=self.db_config,
         )
 
         if not config_data:
@@ -180,7 +176,6 @@ class ReadParameters:
                 plot_tables.plot(
                     config=plot_config,
                     output_file=image_output_file,
-                    db_config=self.db_config,
                 )
                 plt.close("all")
 
@@ -582,7 +577,6 @@ class ReadParameters:
             telescope_name=self.array_element,
             model_version=self.model_version,
             label="reports",
-            db_config=self.db_config,
             ignore_software_version=True,
         )
 

simtools/runners/corsika_runner.py

@@ -2,8 +2,8 @@
 
 import logging
 import stat
-from pathlib import Path
 
+from simtools import settings
 from simtools.io import io_handler
 from simtools.runners.runner_services import RunnerServices
 
@@ -26,8 +26,6 @@ class CorsikaRunner:
     ----------
     corsika_config_data: CorsikaConfig
         CORSIKA configuration.
-    simtel_path: str or Path
-        Location of source of the sim_telarray/CORSIKA package.
     label: str
         Instance label.
     keep_seeds: bool
@@ -41,7 +39,6 @@ class CorsikaRunner:
     def __init__(
         self,
         corsika_config,
-        simtel_path,
         label=None,
         keep_seeds=False,
         use_multipipe=False,
@@ -57,7 +54,6 @@ class CorsikaRunner:
         self._use_multipipe = use_multipipe
         self.curved_atmosphere_min_zenith_angle = curved_atmosphere_min_zenith_angle
 
-        self._simtel_path = Path(simtel_path)
         self.io_handler = io_handler.IOHandler()
 
         self.runner_service = RunnerServices(corsika_config, label)
@@ -178,7 +174,7 @@ class CorsikaRunner:
         str
             pfp command.
         """
-        cmd = self._simtel_path.joinpath("sim_telarray/bin/pfp")
+        cmd = settings.config.sim_telarray_path / "bin/pfp"
         cmd = str(cmd) + f" -V -DWITHOUT_MULTIPIPE - < {corsika_input_file}"
         cmd += f" > {input_tmp_file} || exit\n"
         return cmd
@@ -203,17 +199,17 @@ class CorsikaRunner:
             autoinputs command.
         """
         if self.corsika_config.use_curved_atmosphere:
-            corsika_bin_path = self._simtel_path.joinpath("corsika-run/corsika-curved")
+            corsika_bin_path = settings.config.corsika_exe_curved
             self._logger.debug("Using curved-atmosphere CORSIKA binary.")
         else:
-            corsika_bin_path = self._simtel_path.joinpath("corsika-run/corsika")
+            corsika_bin_path = settings.config.corsika_exe
             self._logger.debug("Using flat-atmosphere CORSIKA binary.")
 
         log_file = self.get_file_name(file_type="log", run_number=run_number)
         if self._use_multipipe:
             log_file = log_file.with_name(f"multipipe_{log_file.name}")
 
-        cmd = self._simtel_path.joinpath("sim_telarray/bin/corsika_autoinputs")
+        cmd = settings.config.sim_telarray_path.joinpath("bin/corsika_autoinputs")
         cmd = str(cmd) + f" --run {corsika_bin_path}"
         cmd += f" -R {run_number}"
         cmd += ' -p "$CORSIKA_DATA"'

simtools/runners/corsika_simtel_runner.py

@@ -5,6 +5,7 @@ import stat
 from pathlib import Path
 
 import simtools.utils.general as gen
+from simtools import settings
 from simtools.runners.corsika_runner import CorsikaRunner
 from simtools.simtel.simulator_array import SimulatorArray
 
@@ -21,8 +22,6 @@ class CorsikaSimtelRunner:
     corsika_config : CorsikaConfig or list of CorsikaConfig
         A list of "CorsikaConfig" instances which
         contain the CORSIKA configuration parameters.
-    simtel_path : str or Path
-        Location of the sim_telarray package.
     label : str
         Label.
     keep_seeds : bool
@@ -38,7 +37,6 @@ class CorsikaSimtelRunner:
     def __init__(
         self,
         corsika_config,
-        simtel_path,
         label=None,
         keep_seeds=False,
         use_multipipe=False,
@@ -52,7 +50,6 @@ class CorsikaSimtelRunner:
         # the base corsika config is the one used to define the CORSIKA specific parameters.
         # The others are used for the array configurations.
         self.base_corsika_config = self.corsika_config[0]
-        self._simtel_path = simtel_path
         self.sim_telarray_seeds = sim_telarray_seeds
         self.label = label
         self.sequential = "--sequential" if sequential else ""
@@ -60,7 +57,6 @@ class CorsikaSimtelRunner:
         self.base_corsika_config.set_output_file_and_directory(use_multipipe)
         self.corsika_runner = CorsikaRunner(
             corsika_config=self.base_corsika_config,
-            simtel_path=simtel_path,
             label=label,
             keep_seeds=keep_seeds,
             use_multipipe=use_multipipe,
@@ -73,7 +69,6 @@ class CorsikaSimtelRunner:
             self.simulator_array.append(
                 SimulatorArray(
                     corsika_config=_corsika_config,
-                    simtel_path=simtel_path,
                     label=label,
                     use_multipipe=use_multipipe,
                     sim_telarray_seeds=sim_telarray_seeds,
@@ -171,8 +166,8 @@ class CorsikaSimtelRunner:
             "run_cta_multipipe"
         )
         with open(multipipe_script, "w", encoding="utf-8") as file:
-            multipipe_command = Path(self._simtel_path).joinpath(
-                f"sim_telarray/bin/multipipe_corsika -c {multipipe_file} {self.sequential} "
+            multipipe_command = settings.config.sim_telarray_path.joinpath(
+                f"bin/multipipe_corsika -c {multipipe_file} {self.sequential} "
                 "|| echo 'Fan-out failed'"
             )
             file.write(f"{multipipe_command}")

simtools/runners/simtel_runner.py

@@ -2,7 +2,6 @@
 
 import logging
 import subprocess
-from pathlib import Path
 
 import simtools.utils.general as gen
 from simtools.runners.runner_services import RunnerServices
@@ -25,8 +24,6 @@ class SimtelRunner:
 
     Parameters
     ----------
-    simtel_path: str or Path
-        Location of sim_telarray installation.
     label: str
         Instance label. Important for output file naming.
     corsika_config: CorsikaConfig
@@ -39,7 +36,6 @@ class SimtelRunner:
 
     def __init__(
         self,
-        simtel_path,
         label=None,
         corsika_config=None,
         use_multipipe=False,
@@ -48,7 +44,6 @@ class SimtelRunner:
         """Initialize SimtelRunner."""
         self._logger = logging.getLogger(__name__)
 
-        self._simtel_path = Path(simtel_path)
         self.label = label
         self._base_directory = None
         self.calibration_run_mode = calibration_run_mode

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/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/{io/eventio_handler.py → sim_events/file_info.py}

@@ -24,7 +24,7 @@ def get_corsika_run_number(file):
     int, None
         CORSIKA run number. Returns None if not found.
     """
-    run_header = get_combined_corsika_run_header(file)
+    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)
@@ -34,9 +34,9 @@ def get_corsika_run_number(file):
         return None
 
 
-def get_combined_corsika_run_header(sim_telarray_file):
+def get_combined_eventio_run_header(sim_telarray_file):
     """
-    Return the CORSIKA run header information from an 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.

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,