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

simtools/simtel/simulator_light_emission.py

@@ -9,6 +9,7 @@ from pathlib import Path
 import astropy.units as u
 import numpy as np
 
+from simtools import settings
 from simtools.io import io_handler
 from simtools.model.model_utils import initialize_simulation_models
 from simtools.runners.simtel_runner import SimtelRunner
@@ -31,21 +32,18 @@ class SimulatorLightEmission(SimtelRunner):
         Label for the simulation
     """
 
-    def __init__(self, light_emission_config, db_config=None, label=None):
+    def __init__(self, light_emission_config, label=None):
         """Initialize SimulatorLightEmission."""
         self._logger = logging.getLogger(__name__)
         self.io_handler = io_handler.IOHandler()
 
-        super().__init__(
-            simtel_path=light_emission_config.get("simtel_path"), label=label, corsika_config=None
-        )
+        super().__init__(label=label, corsika_config=None)
 
         self.output_directory = self.io_handler.get_output_directory()
 
         self.telescope_model, self.site_model, self.calibration_model = (
             initialize_simulation_models(
                 label=label,
-                db_config=db_config,
                 site=light_emission_config.get("site"),
                 telescope_name=light_emission_config.get("telescope"),
                 calibration_device_name=light_emission_config.get("light_source"),
@@ -68,7 +66,7 @@ class SimulatorLightEmission(SimtelRunner):
         config["flasher_photons"] = (
             self.calibration_model.get_parameter_value("flasher_photons")
             if not config.get("test", False)
-            else 1e8
+            else 1e5
         )
 
         if config.get("light_source_position") is not None:
@@ -292,7 +290,7 @@ class SimulatorLightEmission(SimtelRunner):
             "corsika_observation_level"
         )
 
-        parts = [str(self._simtel_path / "sim_telarray/LightEmission") + f"/{app_name}"]
+        parts = [str(settings.config.sim_telarray_path / "LightEmission") + f"/{app_name}"]
         parts.extend(self._get_site_command(app_name, config_directory, corsika_observation_level))
         parts.extend(self._get_light_source_command())
         if self.light_emission_config["light_source_type"] == "illuminator":
@@ -312,7 +310,7 @@ class SimulatorLightEmission(SimtelRunner):
             atmo_id = self._prepare_flasher_atmosphere_files(config_directory)
             return [
                 "-I.",
-                f"-I{self._simtel_path / 'sim_telarray/cfg'}",
+                f"-I{settings.config.sim_telarray_path / 'cfg'}",
                 f"-I{config_directory}",
                 f"--altitude {corsika_observation_level.to(u.m).value}",
                 f"--atmosphere {atmo_id}",
@@ -349,16 +347,19 @@ class SimulatorLightEmission(SimtelRunner):
         dist_cm = self.calculate_distance_focal_plane_calibration_device().to(u.cm).value
         angular_distribution = self._get_angular_distribution_string_for_sim_telarray()
 
-        # Build pulse table for ff-1m using model width/exp parameters; else use token.
+        # Build pulse table for ff-1m using unified list parameter [shape, width, exp]
+        pulse_shape_value = self.calibration_model.get_parameter_value("flasher_pulse_shape")
+        shape_name = pulse_shape_value[0]
+        width_ns = pulse_shape_value[1]
+        exp_ns = pulse_shape_value[2]
         pulse_arg = self._get_pulse_shape_string_for_sim_telarray()
-        pulse_shape = self.calibration_model.get_parameter_value("flasher_pulse_shape")
-        width_q = self.calibration_model.get_parameter_value_with_unit("flasher_pulse_width")
-        exp_q = self.calibration_model.get_parameter_value_with_unit("flasher_pulse_exp_decay")
-        if (
-            isinstance(exp_q, u.Quantity)
-            and isinstance(width_q, u.Quantity)
-            and pulse_shape == "Gauss-Exponential"
-        ):
+
+        if shape_name == "Gauss-Exponential":
+            if width_ns <= 0 or exp_ns <= 0:
+                raise ValueError(
+                    "Gauss-Exponential pulse shape requires positive width"
+                    " and exponential decay values"
+                )
             try:
                 base_dir = self.io_handler.get_output_directory("pulse_shapes")
 
@@ -373,10 +374,10 @@ class SimulatorLightEmission(SimtelRunner):
                 table_path = base_dir / fname
                 fadc_bins = self.telescope_model.get_parameter_value("fadc_sum_bins")
 
-                SimtelConfigWriter.write_lightpulse_table_gauss_expconv(
+                SimtelConfigWriter.write_light_pulse_table_gauss_exp_conv(
                     file_path=table_path,
-                    width_ns=width_q.to(u.ns).value,
-                    exp_decay_ns=exp_q.to(u.ns).value,
+                    width_ns=width_ns,
+                    exp_decay_ns=exp_ns,
                     fadc_sum_bins=fadc_bins,
                     time_margin_ns=5.0,
                 )
@@ -435,7 +436,7 @@ class SimulatorLightEmission(SimtelRunner):
         """
         theta, phi = self._get_telescope_pointing()
 
-        simtel_bin = self._simtel_path.joinpath("sim_telarray/bin/sim_telarray/")
+        simtel_bin = str(settings.config.sim_telarray_exe)
 
         parts = [
             f"{simtel_bin}",
@@ -503,6 +504,27 @@ class SimulatorLightEmission(SimtelRunner):
         )
         return focal_length - flasher_z
 
+    def _generate_lambertian_angular_distribution_table(self):
+        """Generate Lambertian angular distribution table via config writer and return path.
+
+        Uses a pure cosine profile normalized to 1 at 0 deg and spans 0..90 deg by default.
+        """
+        base_dir = self.io_handler.get_output_directory("angular_distributions")
+
+        def _sanitize_name(value):
+            return "".join(ch if (ch.isalnum() or ch in ("-", "_")) else "_" for ch in str(value))
+
+        tel = self.light_emission_config.get("telescope") or "telescope"
+        cal = self.light_emission_config.get("light_source") or "calibration"
+        fname = f"flasher_angular_distribution_{_sanitize_name(tel)}_{_sanitize_name(cal)}.dat"
+        table_path = base_dir / fname
+        SimtelConfigWriter.write_angular_distribution_table_lambertian(
+            file_path=table_path,
+            max_angle_deg=90.0,
+            n_samples=100,
+        )
+        return str(table_path)
+
     def _get_angular_distribution_string_for_sim_telarray(self):
         """
         Get the angular distribution string for sim_telarray.
@@ -514,6 +536,16 @@ class SimulatorLightEmission(SimtelRunner):
         """
         opt = self.calibration_model.get_parameter_value("flasher_angular_distribution")
         option_string = str(opt).lower() if opt is not None else ""
+        if option_string == "lambertian":
+            try:
+                return self._generate_lambertian_angular_distribution_table()
+            except (OSError, ValueError) as err:
+                self._logger.warning(
+                    f"Failed to write Lambertian angular distribution table: {err};"
+                    f" using token instead."
+                )
+                return option_string
+
         width = self.calibration_model.get_parameter_value_with_unit(
             "flasher_angular_distribution_width"
         )
@@ -529,6 +561,19 @@ class SimulatorLightEmission(SimtelRunner):
             The pulse shape string.
         """
         opt = self.calibration_model.get_parameter_value("flasher_pulse_shape")
-        option_string = str(opt).lower() if opt is not None else ""
-        width = self.calibration_model.get_parameter_value_with_unit("flasher_pulse_width")
-        return f"{option_string}:{width.to(u.ns).value}" if width is not None else option_string
+        shape = opt[0].lower()
+        # Map internal shapes to sim_telarray expected tokens
+        # 'tophat' corresponds to a simple (flat) pulse in sim_telarray.
+        shape_token_map = {
+            "tophat": "simple",
+        }
+        shape_out = shape_token_map.get(shape, shape)
+        width = opt[1]
+        expv = opt[2]
+        if shape_out == "gauss-exponential" and width is not None and expv is not None:
+            return f"{shape_out}:{float(width)}:{float(expv)}"
+        if shape_out in ("gauss", "simple") and width is not None:
+            return f"{shape_out}:{float(width)}"
+        if shape_out == "exponential" and expv is not None:
+            return f"{shape_out}:{float(expv)}"
+        return shape_out

simtools/simtel/simulator_ray_tracing.py

@@ -5,6 +5,7 @@ from collections import namedtuple
 
 import astropy.units as u
 
+from simtools import settings
 from simtools.io import io_handler
 from simtools.runners.simtel_runner import SimtelRunner
 from simtools.utils import names
@@ -27,8 +28,6 @@ class SimulatorRayTracing(SimtelRunner):
         site model
     label: str
         label used for output file naming.
-    simtel_path: str or Path
-        Location of sim_telarray installation.
     config_data: namedtuple
         namedtuple containing the configurable parameters as values (expected units in
         brackets): zenith_angle (deg), off_axis_angle (deg), source_distance (km),
@@ -43,7 +42,6 @@ class SimulatorRayTracing(SimtelRunner):
         telescope_model,
         site_model,
         label=None,
-        simtel_path=None,
         config_data=None,
         force_simulate=False,
         test=False,
@@ -52,7 +50,7 @@ class SimulatorRayTracing(SimtelRunner):
         self._logger = logging.getLogger(__name__)
         self._logger.debug("Init SimulatorRayTracing")
 
-        super().__init__(label=label, simtel_path=simtel_path)
+        super().__init__(label=label)
 
         self.telescope_model = telescope_model
         self.site_model = site_model
@@ -83,10 +81,6 @@ class SimulatorRayTracing(SimtelRunner):
         force_simulate: bool
             Remove existing files and force re-running of the ray-tracing simulation.
         """
-        # This file is not actually needed and does not exist in simtools.
-        # It is required as CORSIKA input file to sim_telarray
-        self._corsika_file = self._simtel_path.joinpath("run9991.corsika.gz")
-
         # Loop to define and remove existing files.
         # Files will be named _base_file = self.__dict__['_' + base + 'File']
         for base_name in ["stars", "photons", "log"]:
@@ -153,7 +147,7 @@ class SimulatorRayTracing(SimtelRunner):
             )
 
         # RayTracing
-        command = str(self._simtel_path.joinpath("sim_telarray/bin/sim_telarray"))
+        command = str(settings.config.sim_telarray_exe)
         command += f" -c {self.telescope_model.config_file_path}"
         command += f" -I{self.telescope_model.config_file_directory}"
         command += super().get_config_option("random_state", "none")
@@ -197,7 +191,7 @@ class SimulatorRayTracing(SimtelRunner):
             command += super().get_config_option("parabolic_dish", "0")
             command += super().get_config_option("mirror_align_random_distance", "0.")
             command += super().get_config_option("mirror_align_random_vertical", "0.,28.,0.,0.")
-        command += " " + str(self._corsika_file)
+        command += " " + str(settings.config.corsika_dummy_file)
 
         return clear_default_sim_telarray_cfg_directories(command), self._log_file, self._log_file
 

simtools/simulator.py

@@ -11,12 +11,13 @@ import numpy as np
 from astropy import units as u
 
 from simtools.corsika.corsika_config import CorsikaConfig
-from simtools.io import eventio_handler, io_handler, table_handler
+from simtools.io import io_handler, table_handler
 from simtools.job_execution.job_manager import JobManager
 from simtools.model.array_model import ArrayModel
 from simtools.runners.corsika_runner import CorsikaRunner
 from simtools.runners.corsika_simtel_runner import CorsikaSimtelRunner
-from simtools.simtel.simtel_io_event_writer import SimtelIOEventDataWriter
+from simtools.sim_events import file_info
+from simtools.sim_events.writer import EventDataWriter
 from simtools.simtel.simulator_array import SimulatorArray
 from simtools.testing.sim_telarray_metadata import assert_sim_telarray_metadata
 from simtools.utils import general, names
@@ -42,8 +43,6 @@ class Simulator:
         Instance label.
     extra_commands: str or list of str
         Extra commands to be added to the run script before the run command.
-    db_config: dict
-        Database configuration.
     """
 
     def __init__(
@@ -51,14 +50,12 @@ class Simulator:
         args_dict,
         label=None,
         extra_commands=None,
-        db_config=None,
     ):
         """Initialize Simulator class."""
         self.logger = logging.getLogger(__name__)
         self.label = label
 
         self.args_dict = args_dict
-        self.db_config = db_config
         self.site = self.args_dict.get("site", None)
         self.model_version = self.args_dict.get("model_version", None)
 
@@ -114,7 +111,7 @@ class Simulator:
         }
 
         if self.args_dict.get("corsika_file"):
-            self.run_number = eventio_handler.get_corsika_run_number(self.args_dict["corsika_file"])
+            self.run_number = file_info.get_corsika_run_number(self.args_dict["corsika_file"])
         else:
             self.run_number = self.args_dict.get("run_number_offset", 0) + self.args_dict.get(
                 "run_number", 1
@@ -140,11 +137,9 @@ class Simulator:
                     label=self.label,
                     site=self.site,
                     layout_name=self.args_dict.get("array_layout_name"),
-                    db_config=self.db_config,
                     model_version=version,
                     calibration_device_types=self._get_calibration_device_types(self.run_mode),
                     overwrite_model_parameters=self.args_dict.get("overwrite_model_parameters"),
-                    simtel_path=self.args_dict.get("simtel_path"),
                 )
             )
             corsika_configurations.append(
@@ -152,7 +147,6 @@ class Simulator:
                     array_model=array_model[-1],
                     label=self.label,
                     args_dict=self.args_dict,
-                    db_config=self.db_config,
                     dummy_simulations=self._is_calibration_run(self.run_mode),
                 )
             )
@@ -232,7 +226,6 @@ class Simulator:
         runner_args = {
             "label": self.label,
             "corsika_config": self.corsika_configurations,
-            "simtel_path": self.args_dict.get("simtel_path"),
             "use_multipipe": runner_class is CorsikaSimtelRunner,
         }
 
@@ -445,7 +438,7 @@ class Simulator:
         input_files = self.get_file_list(file_type="simtel_output")
         output_files = self.get_file_list(file_type="event_data")
         for input_file, output_file in zip(input_files, output_files):
-            generator = SimtelIOEventDataWriter([input_file])
+            generator = EventDataWriter([input_file])
             table_handler.write_tables(
                 tables=generator.process_files(),
                 output_file=Path(output_file),
@@ -691,7 +684,7 @@ class Simulator:
 
         event_errors = []
         for file in self.get_file_list(file_type="corsika_output"):
-            shower_events, _ = eventio_handler.get_simulated_events(file)
+            shower_events, _ = file_info.get_simulated_events(file)
 
             if shower_events != expected_mc_events:
                 if consistent(shower_events, expected_mc_events, tol=tolerance):
@@ -736,7 +729,7 @@ class Simulator:
         """
         event_errors = []
         for file in self.get_file_list(file_type="simtel_output"):
-            shower_events, mc_events = eventio_handler.get_simulated_events(file)
+            shower_events, mc_events = file_info.get_simulated_events(file)
 
             if (shower_events, mc_events) != (expected_shower_events, expected_mc_events):
                 event_errors.append(

simtools/telescope_trigger_rates.py

@@ -8,13 +8,13 @@ from ctao_cr_spectra.definitions import IRFDOC_PROTON_SPECTRUM
 
 from simtools.io import ascii_handler, io_handler
 from simtools.layout.array_layout_utils import get_array_elements_from_db_for_layouts
-from simtools.simtel.simtel_io_event_histograms import SimtelIOEventHistograms
+from simtools.sim_events.histograms import EventDataHistograms
 from simtools.visualization import plot_simtel_event_histograms
 
 _logger = logging.getLogger(__name__)
 
 
-def telescope_trigger_rates(args_dict, db_config):
+def telescope_trigger_rates(args_dict):
     """
     Calculate trigger rates for single telescopes or arrays of telescopes.
 
@@ -27,7 +27,6 @@ def telescope_trigger_rates(args_dict, db_config):
             args_dict["array_layout_name"],
             args_dict.get("site"),
             args_dict.get("model_version"),
-            db_config,
         )
     else:
         telescope_configs = ascii_handler.collect_data_from_file(args_dict["telescope_ids"])[
@@ -38,7 +37,7 @@ def telescope_trigger_rates(args_dict, db_config):
         _logger.info(
             f"Processing file: {args_dict['event_data_file']} with telescope config: {array_name}"
         )
-        histograms = SimtelIOEventHistograms(
+        histograms = EventDataHistograms(
             args_dict["event_data_file"], array_name=array_name, telescope_list=telescope_ids
         )
         histograms.fill()

simtools/testing/assertions.py

@@ -68,8 +68,7 @@ def assert_n_showers_and_energy_range(file):
     simulation_config = {}
     with SimTelFile(file, skip_non_triggered=False) as f:
         simulation_config = f.mc_run_headers[0]
-        for event in f:
-            simulated_energies.append(event["mc_shower"]["energy"])
+        simulated_energies.extend(event["mc_shower"]["energy"] for event in f)
 
     # The relative tolerance is set to 1% because ~0.5% shower simulations do not
     # succeed, without resulting in an error. This tolerance therefore is not an issue.
@@ -191,54 +190,94 @@ def check_output_from_sim_telarray(file, file_test):
     return assert_n_showers_and_energy_range(file=file) and assert_output and assert_metadata
 
 
-def _find_patterns(text, patterns):
-    """Find patterns in text."""
-    return {p for p in patterns if p in text}
-
-
-def _read_log(member, tar):
-    """Read and decode a gzipped log file from a tar archive."""
-    with tar.extractfile(member) as gz, gzip.open(gz, "rb") as f:
-        return f.read().decode("utf-8", "ignore")
-
-
 def check_simulation_logs(tar_file, file_test):
     """
-    Check log files of CORSIKA and sim_telarray for expected output.
+    Check simulation logs for wanted and forbidden patterns.
 
     Parameters
     ----------
-    tar_file: Path
-        Path to a log file tar package.
-    file_test: dict
-        File test description including expected log output.
-
-    Raises
-    ------
-    ValueError
-        If the file is not a tar file.
+    tar_file : str
+        Path to the tar file.
+    file_test : dict
+        Dictionary with the test configuration.
+
+    Returns
+    -------
+    bool
+        True if the logs are correct.
     """
-    expected_log = file_test.get("expected_log_output", {})
-    wanted = expected_log.get("pattern", [])
-    forbidden = expected_log.get("forbidden_pattern", [])
-
-    if not (wanted or forbidden):
-        _logger.debug(f"No expected log output provided, skipping checks {file_test}")
+    wanted, forbidden = _get_expected_patterns(file_test)
+    if wanted is None:
         return True
 
     if not tarfile.is_tarfile(tar_file):
-        raise ValueError(f"File {tar_file} is not a tar file.")
+        raise ValueError(f"{tar_file} is not a tar file")
 
-    found, bad = set(), set()
+    found_wanted = set()
+    found_forbidden = set()
     with tarfile.open(tar_file, "r:*") as tar:
         for member in tar.getmembers():
             if not member.name.endswith(".log.gz"):
                 continue
             _logger.info(f"Scanning {member.name}")
             text = _read_log(member, tar)
-            found |= _find_patterns(text, wanted)
-            bad |= _find_patterns(text, forbidden)
+            found_wanted |= _find_patterns(text, wanted)
+            found_forbidden |= _find_patterns(text, forbidden)
+
+    return _validate_patterns(found_wanted, found_forbidden, wanted)
+
+
+def check_plain_log(log_file, file_test):
+    """
+    Check plain log file for wanted and forbidden patterns.
+
+    Parameters
+    ----------
+    log_file : str
+        Path to the log file.
+    file_test : dict
+        Dictionary with the test configuration.
+
+    Returns
+    -------
+    bool
+        True if the logs are correct.
+    """
+    wanted, forbidden = _get_expected_patterns(file_test)
+    if wanted is None:
+        return True
+
+    try:
+        with open(log_file, encoding="utf-8") as f:
+            text = f.read()
+    except FileNotFoundError:
+        _logger.error(f"Log file {log_file} not found")
+        return False
+
+    found = _find_patterns(text, wanted)
+    bad = _find_patterns(text, forbidden)
+
+    return _validate_patterns(found, bad, wanted)
+
+
+def _get_expected_patterns(file_test):
+    """Get wanted and forbidden patterns from file test configuration."""
+    expected_log = file_test.get("expected_log_output")
+    if isinstance(expected_log, dict):
+        wanted = expected_log.get("pattern", [])
+        forbidden = expected_log.get("forbidden_pattern", [])
+    else:
+        wanted = file_test.get("pattern", [])
+        forbidden = file_test.get("forbidden_pattern", [])
+    if not (wanted or forbidden):
+        _logger.debug(f"No expected log output provided, skipping checks {file_test}")
+        return None, None
 
+    return wanted, forbidden
+
+
+def _validate_patterns(found, bad, wanted):
+    """Validate found patterns against wanted and forbidden ones."""
     if bad:
         _logger.error(f"Forbidden patterns found: {list(bad)}")
         return False
@@ -249,3 +288,15 @@ def check_simulation_logs(tar_file, file_test):
 
     _logger.debug(f"All expected patterns found: {wanted}")
     return True
+
+
+def _find_patterns(text, patterns):
+    """Find patterns in text (case insensitive)."""
+    text_lower = text.lower()
+    return {p for p in patterns if p.lower() in text_lower}
+
+
+def _read_log(member, tar):
+    """Read and decode a gzipped log file from a tar archive."""
+    with tar.extractfile(member) as gz, gzip.open(gz, "rb") as f:
+        return f.read().decode("utf-8", "ignore")

simtools/testing/configuration.py

@@ -76,8 +76,7 @@ def _read_configs_from_files(config_files):
         _dict = gen.remove_substring_recursively_from_dict(
             ascii_handler.collect_data_from_file(file_name=config_file), substring="\n"
         )
-        for application in _dict.get("applications", []):
-            configs.append(application)
+        configs.extend(_dict.get("applications", []))
     return configs
 
 

simtools/testing/helpers.py

@@ -1,7 +1,6 @@
 """Helper functions for integration testing."""
 
-import os
-from pathlib import Path
+from simtools import settings
 
 
 def skip_camera_efficiency(config):
@@ -21,7 +20,7 @@ def _new_testeff_version():
 
     This test checks if the new version is used.
     """
-    testeff_path = Path(os.getenv("SIMTOOLS_SIMTEL_PATH")) / "sim_telarray/testeff.c"
+    testeff_path = settings.config.sim_telarray_path / "testeff.c"
     try:
         with open(testeff_path, encoding="utf-8") as file:
             file_content = file.read()

simtools/testing/log_inspector.py

@@ -18,6 +18,7 @@ ERROR_PATTERNS = [
 IGNORE_PATTERNS = [
     re.compile(r"Falling back to 'utf-8' with errors='ignore'", re.IGNORECASE),
     re.compile(r"Failed to get user name[^\n]*setting it to UNKNOWN_USER", re.IGNORECASE),
+    re.compile(r"adjust_text::Error", re.IGNORECASE),
 ]
 
 

simtools/testing/sim_telarray_metadata.py

@@ -4,7 +4,7 @@ import logging
 
 import numpy as np
 
-from simtools.io.eventio_handler import get_corsika_run_number
+from simtools.sim_events.file_info import get_corsika_run_number
 from simtools.simtel.simtel_config_reader import SimtelConfigReader
 from simtools.simtel.simtel_config_writer import sim_telarray_random_seeds
 from simtools.simtel.simtel_io_metadata import (