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

simtools/simtel/simulator_camera_efficiency.py

@@ -3,9 +3,9 @@
 import logging
 from pathlib import Path
 
+from simtools import settings
 from simtools.io import ascii_handler
 from simtools.runners.simtel_runner import SimtelRunner
-from simtools.utils import general
 
 
 class SimulatorCameraEfficiency(SimtelRunner):
@@ -20,12 +20,12 @@ class SimulatorCameraEfficiency(SimtelRunner):
         Instance of SiteModel class.
     label: str
         Instance label. Important for output file naming.
-    simtel_path: str or Path
-        Location of sim_telarray installation.
     file_simtel: str or Path
         Location of the sim_telarray testeff tool output file.
     zenith_angle: float
         Zenith angle given in the config to CameraEfficiency.
+    x_max: float
+        Maximum depth of shower development in g/cm2.
     nsb_spectrum: str or Path
         Path to the nsb spectrum file.
     skip_correction_to_nsb_spectrum: bool
@@ -37,18 +37,18 @@ class SimulatorCameraEfficiency(SimtelRunner):
         telescope_model,
         site_model,
         label=None,
-        simtel_path=None,
         file_simtel=None,
         file_log=None,
         zenith_angle=None,
+        x_max=None,
         nsb_spectrum=None,
         skip_correction_to_nsb_spectrum=False,
     ):
-        """Initialize SimtelRunner."""
+        """Camera efficiency simulator initialization."""
         self._logger = logging.getLogger(__name__)
         self._logger.debug("Init SimulatorCameraEfficiency")
 
-        super().__init__(label=label, simtel_path=simtel_path)
+        super().__init__(label=label)
 
         self._telescope_model = telescope_model
         self._site_model = site_model
@@ -57,6 +57,7 @@ class SimulatorCameraEfficiency(SimtelRunner):
         self._file_simtel = file_simtel
         self._file_log = file_log
         self.zenith_angle = zenith_angle
+        self.x_max = x_max
         self.nsb_spectrum = nsb_spectrum
         self.skip_correction_to_nsb_spectrum = skip_correction_to_nsb_spectrum
 
@@ -76,7 +77,7 @@ class SimulatorCameraEfficiency(SimtelRunner):
                 / Path(self._site_model.get_parameter_value("nsb_reference_spectrum")).name
             )
 
-    def _make_run_command(self, run_number=None, input_file=None):  # pylint: disable=unused-argument
+    def make_run_command(self, run_number=None, input_file=None):  # pylint: disable=unused-argument
         """Prepare the command used to run testeff."""
         self._logger.debug("Preparing the command to run testeff")
 
@@ -109,52 +110,73 @@ class SimulatorCameraEfficiency(SimtelRunner):
                 "mirror_reflectivity", "secondary_mirror_incidence_angle"
             )
 
-        command = str(self._simtel_path.joinpath("sim_telarray/testeff"))
+        cmd = [str(settings.config.sim_telarray_path / "bin/testeff")]
+
         if self.skip_correction_to_nsb_spectrum:
-            command += " -nc"  # Do not apply correction to original altitude where B&E was derived
-        command += " -I"  # Clear the fall-back configuration directories
-        command += f" -I{self._telescope_model.config_file_directory}"
-        if self.nsb_spectrum is not None:
-            command += f" -fnsb {self.nsb_spectrum}"
-        command += " -nm -nsb-extra"
-        command += f" -alt {self._site_model.get_parameter_value('corsika_observation_level')}"
-        command += f" -fatm {self._site_model.get_parameter_value('atmospheric_transmission')}"
-        command += f" -flen {focal_length}"
-        command += f" -fcur {curvature_radius:.3f}"
-        command += f" {pixel_shape_cmd} {pixel_diameter}"
-        if mirror_class == 0:
-            command += f" -fmir {self._telescope_model.get_parameter_value('mirror_list')}"
-        if mirror_class == 2:
-            command += f" -fmir {self._telescope_model.get_parameter_value('fake_mirror_list')}"
-        command += f" -fref {mirror_reflectivity}"
-        if mirror_class == 2:
-            command += " -m2"
-            command += f" -fref2 {mirror_reflectivity_secondary}"
-        command += " -teltrans "
-        command += f"{self._telescope_model.get_parameter_value('telescope_transmission')[0]}"
-        command += f" -camtrans {camera_transmission}"
-        command += f" -fflt {camera_filter_file}"
-        command += (
-            f" -fang {self._telescope_model.camera.get_lightguide_efficiency_angle_file_name()}"
+            cmd.append("-nc")
+
+        cmd.extend(
+            [
+                "-I",
+                f"-I{self._telescope_model.config_file_directory}",
+            ]
         )
-        command += (
-            f" -fwl {self._telescope_model.camera.get_lightguide_efficiency_wavelength_file_name()}"
+
+        if self.nsb_spectrum is not None:
+            cmd.extend(["-fnsb", str(self.nsb_spectrum)])
+
+        cmd.extend(
+            [
+                "-nm",
+                "-nsb-extra",
+                "-alt",
+                str(self._site_model.get_parameter_value("corsika_observation_level")),
+                "-fatm",
+                str(self._site_model.get_parameter_value("atmospheric_transmission")),
+                "-flen",
+                str(focal_length),
+                "-fcur",
+                f"{curvature_radius:.3f}",
+                pixel_shape_cmd,
+                str(pixel_diameter),
+            ]
         )
-        command += f" -fqe {self._telescope_model.get_parameter_value('quantum_efficiency')}"
-        command += " 200 1000"  # lmin and lmax
-        command += " 300"  # Xmax
-        command += f" {self._site_model.get_parameter_value('atmospheric_profile')}"
-        command += f" {self.zenith_angle}"
 
-        # Remove the default sim_telarray configuration directories
-        command = general.clear_default_sim_telarray_cfg_directories(command)
+        if mirror_class == 0:
+            cmd.extend(["-fmir", self._telescope_model.get_parameter_value("mirror_list")])
+        elif mirror_class == 2:
+            cmd.extend(["-fmir", self._telescope_model.get_parameter_value("fake_mirror_list")])
 
-        return (
-            f"cd {self._simtel_path.joinpath('sim_telarray')} && {command}",
-            self._file_simtel,
-            self._file_log,
+        cmd.extend(["-fref", mirror_reflectivity])
+
+        if mirror_class == 2:
+            cmd.append("-m2")
+            cmd.extend(["-fref2", mirror_reflectivity_secondary])
+
+        cmd.extend(
+            [
+                "-teltrans",
+                str(self._telescope_model.get_parameter_value("telescope_transmission")[0]),
+                "-camtrans",
+                str(camera_transmission),
+                "-fflt",
+                camera_filter_file,
+                "-fang",
+                self._telescope_model.camera.get_lightguide_efficiency_angle_file_name(),
+                "-fwl",
+                self._telescope_model.camera.get_lightguide_efficiency_wavelength_file_name(),
+                "-fqe",
+                str(self._telescope_model.get_parameter_value("quantum_efficiency")),
+                "200",  # lmin
+                "1000",  # lmax
+                f"{self.x_max:.1f}" if self.x_max is not None else "300",
+                str(self._site_model.get_parameter_value("atmospheric_profile")),
+                str(self.zenith_angle),
+            ]
         )
 
+        return cmd, self._file_simtel, self._file_log
+
     def _check_run_result(self, run_number=None):  # pylint: disable=unused-argument
         """Check run results.
 

simtools/simtel/simulator_light_emission.py

@@ -2,18 +2,18 @@
 
 import logging
 import shutil
-import stat
-import subprocess
 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.job_execution import job_manager
 from simtools.model.model_utils import initialize_simulation_models
-from simtools.runners.simtel_runner import SimtelRunner
+from simtools.runners import runner_services
+from simtools.runners.simtel_runner import SimtelRunner, sim_telarray_env_as_string
 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
 
 
@@ -31,21 +31,19 @@ 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, config=light_emission_config)
+        self.job_files = runner_services.RunnerServices(
+            light_emission_config, run_type="sub", label=label
         )
 
-        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:
@@ -79,73 +77,47 @@ class SimulatorLightEmission(SimtelRunner):
         return config
 
     def simulate(self):
-        """
-        Simulate light emission.
-
-        Returns
-        -------
-        Path
-            The output simtel file path.
-        """
-        run_script = self.prepare_script()
-        log_path = Path(self.output_directory) / "logfile.log"
-        with open(log_path, "w", encoding="utf-8") as fh:
-            subprocess.run(
-                run_script,
-                shell=False,
-                check=False,
-                text=True,
-                stdout=fh,
-                stderr=fh,
-            )
-        out = Path(self._get_simulation_output_filename())
-        if not out.exists():
-            self._logger.warning(f"Expected sim_telarray output not found: {out}")
-        return out
+        """Simulate light emission."""
+        run_script = self.prepare_run()
+        job_manager.submit(
+            run_script,
+            out_file=self.job_files.get_file_name("sub_out"),
+            err_file=self.job_files.get_file_name("sub_err"),
+        )
 
-    def prepare_script(self):
+    def prepare_run(self):
         """
-        Build and return bash run script containing the light-emission command.
+        Prepare the bash run script containing the light-emission command.
 
         Returns
         -------
         Path
             Full path of the run script.
         """
-        script_dir = self.output_directory.joinpath("scripts")
-        script_dir.mkdir(parents=True, exist_ok=True)
-
-        app_name = self._get_light_emission_application_name()
-        script_file = script_dir / f"{app_name}-light_emission.sh"
-        self._logger.debug(f"Run bash script - {script_file}")
-
-        target_out = Path(self._get_simulation_output_filename())
-        if target_out.exists():
+        script_file = self.job_files.get_file_name(file_type="sub_script")
+        output_file = self.runner_service.get_file_name(file_type="sim_telarray_output")
+        if output_file.exists():
             raise FileExistsError(
-                f"sim_telarray output file exists, cancelling simulation: {target_out}"
+                f"sim_telarray output file exists, cancelling simulation: {output_file}"
             )
+        lines = self.make_run_command()
+        script_file.write_text("".join(lines), encoding="utf-8")
+        return script_file
 
-        lines = [
+    def make_run_command(self, run_number=None, input_file=None):  # pylint: disable=unused-argument
+        """Light emission and sim_telarray run command."""
+        iact_output = self.runner_service.get_file_name(file_type="iact_output")
+        return [
             "#!/usr/bin/env bash\n",
-            f"{self._make_light_emission_script()}\n\n",
+            f"{self._make_light_emission_command(iact_output)}\n\n",
             (
-                f"[ -s '{self.output_directory}/{app_name}.iact.gz' ] || "
+                f"[ -s '{iact_output}' ] || "
                 f"{{ echo 'LightEmission did not produce IACT file' >&2; exit 1; }}\n\n"
             ),
             f"{self._make_simtel_script()}\n\n",
-            f"rm -f '{self.output_directory}/{app_name}.iact.gz'\n\n",
+            f"rm -f '{iact_output}'\n\n",
         ]
 
-        script_file.write_text("".join(lines), encoding="utf-8")
-        script_file.chmod(script_file.stat().st_mode | stat.S_IXUSR | stat.S_IXGRP)
-        return script_file
-
-    def _get_prefix(self):
-        prefix = self.light_emission_config.get("output_prefix", "")
-        if prefix is not None:
-            return f"{prefix}_"
-        return ""
-
     def _get_light_emission_application_name(self):
         """
         Return the LightEmission application and mode from type.
@@ -244,7 +216,9 @@ class SimulatorLightEmission(SimtelRunner):
         radius = self.telescope_model.get_parameter_value_with_unit("telescope_sphere_radius")
         radius = radius.to(u.cm).value  # Convert radius to cm
 
-        telescope_position_file = self.output_directory.joinpath("telescope_position.dat")
+        telescope_position_file = (
+            self.io_handler.get_output_directory("light_emission") / "telescope_position.dat"
+        )
         telescope_position_file.write_text(f"{x_tel} {y_tel} {z_tel} {radius}\n", encoding="utf-8")
         return telescope_position_file
 
@@ -272,13 +246,18 @@ class SimulatorLightEmission(SimtelRunner):
                 self._logger.warning(f"Failed to create atmosphere alias {dst.name}: {copy_err}")
         return model_id
 
-    def _make_light_emission_script(self):
+    def _make_light_emission_command(self, iact_output):
         """
-        Create the light emission script to run the light emission package.
+        Create the light emission command to run the light emission package.
 
         Require the specified pre-compiled light emission package application
         in the sim_telarray/LightEmission/ path.
 
+        Parameters
+        ----------
+        iact_output: str or Path
+            The output iact file path.
+
         Returns
         -------
         str
@@ -287,24 +266,24 @@ class SimulatorLightEmission(SimtelRunner):
         config_directory = self.io_handler.get_model_configuration_directory(
             model_version=self.site_model.model_version
         )
-        app_name = self._get_light_emission_application_name()
-        corsika_observation_level = self.site_model.get_parameter_value_with_unit(
-            "corsika_observation_level"
-        )
+        obs_level = self.site_model.get_parameter_value_with_unit("corsika_observation_level")
+
+        app = self._get_light_emission_application_name()
+        cmd = [
+            str(settings.config.sim_telarray_path / "LightEmission" / app),
+            *self._get_site_command(app, config_directory, obs_level),
+            *self._get_light_source_command(),
+        ]
 
-        parts = [str(self._simtel_path / "sim_telarray/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":
-            parts += [
+            cmd += [
                 "-A",
-                (
-                    f"{config_directory}/"
-                    f"{self.telescope_model.get_parameter_value('atmospheric_profile')}"
-                ),
+                f"{config_directory}/"
+                f"{self.telescope_model.get_parameter_value('atmospheric_profile')}",
             ]
-        parts += [f"-o {self.output_directory}/{app_name}.iact.gz", "\n"]
-        return " ".join(parts)
+
+        cmd += ["-o", str(iact_output)]
+        return " ".join(cmd)
 
     def _get_site_command(self, app_name, config_directory, corsika_observation_level):
         """Return site command with altitude, atmosphere and telescope_position handling."""
@@ -312,7 +291,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,34 +328,32 @@ 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"
-        ):
-            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)
-                    )
 
+        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:
                 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
+                fname = (
+                    f"flasher_pulse_shape_{self._sanitize_name(tel)}_{self._sanitize_name(cal)}.dat"
+                )
+                table_path = self.io_handler.get_output_directory("light_emission") / 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,
                 )
@@ -396,6 +373,9 @@ class SimulatorLightEmission(SimtelRunner):
             f"--angular-distribution {angular_distribution}",
         ]
 
+    def _sanitize_name(self, value):
+        return "".join(ch if (ch.isalnum() or ch in ("-", "_")) else "_" for ch in str(value))
+
     def _add_illuminator_command_options(self):
         """Get illuminator-specific command options for light emission script."""
         pos = self.light_emission_config.get("light_source_position")
@@ -434,56 +414,52 @@ class SimulatorLightEmission(SimtelRunner):
             The command to run sim_telarray
         """
         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}",
+            simtel_bin,
             f"-I{self.telescope_model.config_file_directory}",
             f"-I{simtel_bin}",
             f"-c {self.telescope_model.config_file_path}",
             "-DNUM_TELESCOPES=1",
-            super().get_config_option(
+        ]
+
+        options = [
+            (
                 "altitude",
                 self.site_model.get_parameter_value_with_unit("corsika_observation_level")
                 .to(u.m)
                 .value,
             ),
-            super().get_config_option(
+            (
                 "atmospheric_transmission",
                 self.site_model.get_parameter_value("atmospheric_transmission"),
             ),
-            super().get_config_option("TRIGGER_TELESCOPES", "1"),
-            super().get_config_option("TELTRIG_MIN_SIGSUM", "2"),
-            super().get_config_option("PULSE_ANALYSIS", "-30"),
-            super().get_config_option("MAXIMUM_TELESCOPES", 1),
-            super().get_config_option("telescope_theta", f"{theta}"),
-            super().get_config_option("telescope_phi", f"{phi}"),
+            ("TRIGGER_TELESCOPES", "1"),
+            ("TELTRIG_MIN_SIGSUM", "2"),
+            ("PULSE_ANALYSIS", "-30"),
+            ("MAXIMUM_TELESCOPES", 1),
+            ("telescope_theta", f"{theta}"),
+            ("telescope_phi", f"{phi}"),
         ]
 
         if self.light_emission_config["light_source_type"] == "flat_fielding":
-            parts.append(super().get_config_option("Bypass_Optics", "1"))
-
-        app_name = self._get_light_emission_application_name()
-        pref = self._get_prefix()
-        parts += [
-            super().get_config_option("power_law", "2.68"),
-            super().get_config_option("input_file", f"{self.output_directory}/{app_name}.iact.gz"),
-            super().get_config_option(
-                "output_file", f"{self.output_directory}/{pref}{app_name}.simtel.zst"
-            ),
-            super().get_config_option(
-                "histogram_file", f"{self.output_directory}/{pref}{app_name}.ctsim.hdata\n"
-            ),
+            options.append(("Bypass_Optics", "1"))
+
+        input_file = self.runner_service.get_file_name(file_type="iact_output")
+        output_file = self.runner_service.get_file_name(file_type="sim_telarray_output")
+        histo_file = self.runner_service.get_file_name(file_type="sim_telarray_histogram")
+
+        options += [
+            ("power_law", "2.68"),
+            ("input_file", f"{input_file}"),
+            ("output_file", f"{output_file}"),
+            ("histogram_file", f"{histo_file}"),
         ]
 
-        return clear_default_sim_telarray_cfg_directories(" ".join(parts))
+        parts += [f"-C {key}={value}" for key, value in options]
 
-    def _get_simulation_output_filename(self):
-        """Get the filename of the simulation output."""
-        app_name = self._get_light_emission_application_name()
-        pref = self._get_prefix()
-        return f"{self.output_directory}/{pref}{app_name}.simtel.zst"
+        return sim_telarray_env_as_string() + " ".join(parts)
 
     def calculate_distance_focal_plane_calibration_device(self):
         """
@@ -503,6 +479,20 @@ 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.
+        """
+        tel = self._sanitize_name(self.light_emission_config.get("telescope") or "telescope")
+        cal = self._sanitize_name(self.light_emission_config.get("light_source") or "calibration")
+        fname = f"flasher_angular_distribution_{tel}_{cal}.dat"
+        return SimtelConfigWriter.write_angular_distribution_table_lambertian(
+            file_path=self.io_handler.get_output_directory("light_emission") / fname,
+            max_angle_deg=90.0,
+            n_samples=100,
+        )
+
     def _get_angular_distribution_string_for_sim_telarray(self):
         """
         Get the angular distribution string for sim_telarray.
@@ -514,6 +504,19 @@ 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
+
+        if option_string == "isotropic":
+            return option_string
+
         width = self.calibration_model.get_parameter_value_with_unit(
             "flasher_angular_distribution_width"
         )
@@ -529,6 +532,35 @@ 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
+
+    def verify_simulations(self):
+        """
+        Verify that the simulations were successful.
+
+        Returns
+        -------
+        bool
+            True if simulations were successful, False otherwise.
+        """
+        out = Path(self.runner_service.get_file_name(file_type="sim_telarray_output"))
+        if not out.exists():
+            self._logger.error(f"Expected sim_telarray output not found: {out}")
+            return False
+        self._logger.info(f"sim_telarray output found: {out}")
+        return True