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

simtools/simtel/simulator_light_emission.py

@@ -9,9 +9,11 @@ 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
+from simtools.simtel.simtel_config_writer import SimtelConfigWriter
 from simtools.utils.general import clear_default_sim_telarray_cfg_directories
 from simtools.utils.geometry import fiducial_radius_from_shape
 
@@ -30,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"),
@@ -67,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:
@@ -291,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":
@@ -311,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}",
@@ -335,18 +334,57 @@ class SimulatorLightEmission(SimtelRunner):
     def _add_flasher_command_options(self):
         """Add flasher options for all telescope types (ff-1m style)."""
         flasher_xyz = self.calibration_model.get_parameter_value_with_unit("flasher_position")
-        camera_radius = fiducial_radius_from_shape(
+        camera_diam_cm = (
             self.telescope_model.get_parameter_value_with_unit("camera_body_diameter")
             .to(u.cm)
-            .value,
-            self.telescope_model.get_parameter_value("camera_body_shape"),
+            .value
         )
+        camera_shape = self.telescope_model.get_parameter_value("camera_body_shape")
+        camera_radius = fiducial_radius_from_shape(camera_diam_cm, camera_shape)
         flasher_wavelength = self.calibration_model.get_parameter_value_with_unit(
             "flasher_wavelength"
         )
         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 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()
+
+        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")
+
+                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_pulse_shape_{_sanitize_name(tel)}_{_sanitize_name(cal)}.dat"
+                table_path = base_dir / fname
+                fadc_bins = self.telescope_model.get_parameter_value("fadc_sum_bins")
+
+                SimtelConfigWriter.write_light_pulse_table_gauss_exp_conv(
+                    file_path=table_path,
+                    width_ns=width_ns,
+                    exp_decay_ns=exp_ns,
+                    fadc_sum_bins=fadc_bins,
+                    time_margin_ns=5.0,
+                )
+                pulse_arg = str(table_path)
+            except (ValueError, OSError) as err:
+                self._logger.warning(f"Failed to write pulse shape table, using token: {err}")
+
         return [
             f"--events {self.light_emission_config['number_of_events']}",
             f"--photons {self.light_emission_config['flasher_photons']}",
@@ -355,7 +393,7 @@ class SimulatorLightEmission(SimtelRunner):
             f"--distance {dist_cm}",
             f"--camera-radius {camera_radius}",
             f"--spectrum {int(flasher_wavelength.to(u.nm).value)}",
-            f"--lightpulse {self._get_pulse_shape_string_for_sim_telarray()}",
+            f"--lightpulse {pulse_arg}",
             f"--angular-distribution {angular_distribution}",
         ]
 
@@ -398,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}",
@@ -466,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.
@@ -475,9 +534,18 @@ class SimulatorLightEmission(SimtelRunner):
         str
             The angular distribution string.
         """
-        option_string = self.calibration_model.get_parameter_value(
-            "flasher_angular_distribution"
-        ).lower()
+        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"
         )
@@ -492,6 +560,20 @@ class SimulatorLightEmission(SimtelRunner):
         str
             The pulse shape string.
         """
-        option_string = self.calibration_model.get_parameter_value("flasher_pulse_shape").lower()
-        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
+        opt = self.calibration_model.get_parameter_value("flasher_pulse_shape")
+        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