gammasimtools 0.20.0__py3-none-any.whl → 0.22.0__py3-none-any.whl

simtools/simtel/simulator_light_emission.py

@@ -1,4 +1,4 @@
-"""Simulation using the light emission package for calibration devices."""
+"""Light emission simulation (e.g. illuminators or flashers)."""
 
 import logging
 import shutil
@@ -10,261 +10,202 @@ import astropy.units as u
 import numpy as np
 
 from simtools.io import io_handler
+from simtools.model.model_utils import initialize_simulation_models
 from simtools.runners.simtel_runner import SimtelRunner
 from simtools.utils.general import clear_default_sim_telarray_cfg_directories
+from simtools.utils.geometry import fiducial_radius_from_shape
 
 __all__ = ["SimulatorLightEmission"]
 
 
 class SimulatorLightEmission(SimtelRunner):
     """
-    Interface with sim_telarray to perform light emission package simulations.
+    Light emission simulation (e.g. illuminators or flashers).
 
-    The light emission package is used to simulate an artificial light source, used for calibration.
-    """
+    Uses the sim_telarray LightEmission package to simulate the light emission.
 
-    def __init__(
-        self,
-        *,
-        telescope_model,
-        calibration_model=None,
-        flasher_model=None,
-        site_model=None,
-        light_emission_config=None,
-        light_source_setup=None,
-        simtel_path=None,
-        light_source_type=None,
-        label=None,
-        test=False,
-    ):
-        """Initialize SimtelRunner.
-
-        Parameters
-        ----------
-        telescope_model : TelescopeModel
-            Model of the telescope to be simulated
-        calibration_model : CalibrationModel, optional
-            Model of the calibration device to be simulated
-        flasher_model : FlasherModel, optional
-            Model of the flasher device to be simulated
-        site_model : SiteModel, optional
-            Model of the site
-        light_emission_config : dict, optional
-            Configuration for the light emission
-        light_source_setup : str, optional
-            Setup for light source positioning ("variable" or "layout")
-        simtel_path : Path, optional
-            Path to the sim_telarray installation
-        light_source_type : str, optional
-            Type of light source: 'illuminator', or 'flasher'
-        label : str, optional
-            Label for the simulation
-        test : bool, optional
-            Whether this is a test run
-        """
-        super().__init__(simtel_path=simtel_path, label=label, corsika_config=None)
+    Parameters
+    ----------
+    light_emission_config : dict, optional
+        Configuration for the light emission (e.g. number of events, model names)
+    label : str, optional
+        Label for the simulation
+    """
 
+    def __init__(self, light_emission_config, db_config=None, label=None):
+        """Initialize SimulatorLightEmission."""
         self._logger = logging.getLogger(__name__)
+        self.io_handler = io_handler.IOHandler()
 
-        self._telescope_model = telescope_model
-        self._calibration_model = calibration_model
-        self._flasher_model = flasher_model
-        self._site_model = site_model
-        self.light_emission_config = light_emission_config or {}
-        self.light_source_setup = light_source_setup
-        self.light_source_type = light_source_type or "illuminator"
-        self.test = test
+        super().__init__(
+            simtel_path=light_emission_config.get("simtel_path"), label=label, corsika_config=None
+        )
 
-        # IO
-        self.io_handler = io_handler.IOHandler()
-        self.output_directory = self.io_handler.get_output_directory(self.label)
+        self.output_directory = self.io_handler.get_output_directory(label)
 
-        self.number_events = self.light_emission_config["number_events"]
+        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"),
+                model_version=light_emission_config.get("model_version"),
+            )
+        )
+        self.telescope_model.write_sim_telarray_config_file(additional_models=self.site_model)
+
+        self.light_emission_config = self._initialize_light_emission_configuration(
+            light_emission_config
+        )
+
+    def _initialize_light_emission_configuration(self, config):
+        """Initialize light emission configuration."""
+        if self.calibration_model.get_parameter_value("flasher_type"):
+            config["light_source_type"] = self.calibration_model.get_parameter_value(
+                "flasher_type"
+            ).lower()
+
+        config["flasher_photons"] = (
+            self.calibration_model.get_parameter_value("flasher_photons")
+            if not config.get("test", False)
+            else 1e8
+        )
 
-        # photons per run
-        if self._calibration_model is not None:
-            self.photons_per_run = (
-                self._calibration_model.get_parameter_value("photons_per_run")
-                if not self.test
-                else 1e8
+        if config.get("light_source_position") is not None:
+            config["light_source_position"] = (
+                np.array(config["light_source_position"], dtype=float) * u.m
             )
-        elif self._flasher_model is not None:
-            self.photons_per_run = (
-                self._flasher_model.get_parameter_value("photons_per_flasher")
-                if not self.test
-                else 1e8
+
+        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
+
+    def prepare_script(self):
+        """
+        Build and return 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():
+            raise FileExistsError(
+                f"sim_telarray output file exists, cancelling simulation: {target_out}"
             )
-        else:
-            self.photons_per_run = 1e8
 
-        # Ensure sim_telarray config exists on disk
-        if hasattr(self._telescope_model, "write_sim_telarray_config_file"):
-            self._telescope_model.write_sim_telarray_config_file(additional_model=site_model)
+        lines = [
+            "#!/usr/bin/env bash\n",
+            f"{self._make_light_emission_script()}\n\n",
+            (
+                f"[ -s '{self.output_directory}/{app_name}.iact.gz' ] || "
+                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",
+        ]
 
-        # Runtime variables
-        self.distance = None
+        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) -> str:
+    def _get_prefix(self):
         prefix = self.light_emission_config.get("output_prefix", "")
         if prefix is not None:
             return f"{prefix}_"
         return ""
 
-    def _infer_application(self) -> tuple[str, str]:
-        """Infer the LightEmission application and mode from type/setup.
+    def _get_light_emission_application_name(self):
+        """
+        Return the LightEmission application and mode from type.
 
         Returns
         -------
-        tuple[str, str]
-            (app_name, mode)
+        str
+            app_name
         """
-        if self.light_source_type == "flasher":
-            return ("ff-1m", "flasher")
+        if self.light_emission_config["light_source_type"] == "flat_fielding":
+            return "ff-1m"
         # default to illuminator xyzls, mode from setup
-        mode = self.light_source_setup or "layout"
-        return ("xyzls", mode)
+        return "xyzls"
 
-    @staticmethod
-    def light_emission_default_configuration():
+    def _get_telescope_pointing(self):
         """
-        Get default light emission configuration.
-
-        Returns
-        -------
-        dict
-            Default configuration light emission.
+        Return telescope pointing based on light source type.
 
-        """
-        return {
-            "zenith_angle": {
-                "len": 1,
-                "unit": u.Unit("deg"),
-                "default": 0.0 * u.deg,
-                "names": ["zenith", "theta"],
-            },
-            "azimuth_angle": {
-                "len": 1,
-                "unit": u.Unit("deg"),
-                "default": 0.0 * u.deg,
-                "names": ["azimuth", "phi"],
-            },
-            "source_distance": {
-                "len": 1,
-                "unit": u.Unit("m"),
-                "default": 1000 * u.m,
-                "names": ["sourcedist", "srcdist"],
-            },
-            "off_axis_angle": {
-                "len": 1,
-                "unit": u.Unit("deg"),
-                "default": 0 * u.deg,
-                "names": ["off_axis"],
-            },
-            "fadc_bins": {
-                "len": 1,
-                "unit": u.dimensionless_unscaled,
-                "default": 128,
-                "names": ["fadc_bins"],
-            },
-        }
-
-    @staticmethod
-    def flasher_default_configuration():
-        """
-        Get default flasher configuration.
+        For flat_fielding sims, avoid calibration pointing entirely; default angles to (0,0).
 
         Returns
         -------
-        dict
-            Default configuration for flasher devices.
+        tuple
+            The telescope pointing angles (theta, phi).
+
         """
-        return {
-            "number_events": {
-                "len": 1,
-                "unit": None,
-                "default": 1,
-                "names": ["number_events"],
-            },
-            "photons_per_flasher": {
-                "len": 1,
-                "unit": None,
-                "default": 2.5e6,
-                "names": ["photons"],
-            },
-            "bunch_size": {
-                "len": 1,
-                "unit": None,
-                "default": 1.0,
-                "names": ["bunchsize"],
-            },
-            "flasher_position": {
-                "len": 2,
-                "unit": u.Unit("cm"),
-                "default": [0.0, 0.0] * u.cm,
-                "names": ["xy", "position"],
-            },
-            "flasher_depth": {
-                "len": 1,
-                "unit": u.Unit("cm"),
-                "default": 60 * u.cm,
-                "names": ["depth", "distance"],
-            },
-            "flasher_inclination": {
-                "len": 1,
-                "unit": u.Unit("deg"),
-                "default": 0.0 * u.deg,
-                "names": ["inclination"],
-            },
-            "spectrum": {
-                "len": 1,
-                "unit": u.Unit("nm"),
-                "default": 400 * u.nm,
-                "names": ["wavelength"],
-            },
-            "lightpulse": {
-                "len": 1,
-                "unit": None,
-                "default": "Simple:0",
-                "names": ["pulse"],
-            },
-            "angular_distribution": {
-                "len": 1,
-                "unit": None,
-                "default": "isotropic",
-                "names": ["angular"],
-            },
-            "flasher_pattern": {
-                "len": 1,
-                "unit": None,
-                "default": "all",
-                "names": ["fire", "pattern"],
-            },
-        }
-
-    def calibration_pointing_direction(self):
+        if self.light_emission_config["light_source_type"] == "flat_fielding":
+            return 0.0, 0.0
+        if self.light_emission_config.get("light_source_position") is not None:
+            self._logger.info("Using fixed (vertical up) telescope pointing.")
+            return 0.0, 0.0
+        _, angles = self._calibration_pointing_direction()
+        return angles[0], angles[1]
+
+    def _calibration_pointing_direction(self, x_cal=None, y_cal=None, z_cal=None):
         """
         Calculate the pointing of the calibration device towards the telescope.
 
+        This is for calibration devices not installed on telescopes (e.g. illuminators).
+
         Returns
         -------
         list
             The pointing vector from the calibration device to the telescope.
         """
-        x_cal, y_cal, z_cal = self._calibration_model.get_parameter_value_with_unit(
-            "array_element_position_ground"
-        )
+        if x_cal is None or y_cal is None or z_cal is None:
+            x_cal, y_cal, z_cal = self.calibration_model.get_parameter_value_with_unit(
+                "array_element_position_ground"
+            )
         x_cal, y_cal, z_cal = [coord.to(u.m).value for coord in (x_cal, y_cal, z_cal)]
         cal_vect = np.array([x_cal, y_cal, z_cal])
-        x_tel, y_tel, z_tel = self._telescope_model.get_parameter_value_with_unit(
+        x_tel, y_tel, z_tel = self.telescope_model.get_parameter_value_with_unit(
             "array_element_position_ground"
         )
         x_tel, y_tel, z_tel = [coord.to(u.m).value for coord in (x_tel, y_tel, z_tel)]
-
         tel_vect = np.array([x_tel, y_tel, z_tel])
 
         direction_vector = tel_vect - cal_vect
         # pointing vector from calibration device to telescope
-
         pointing_vector = np.round(direction_vector / np.linalg.norm(direction_vector), 6)
 
         # Calculate telescope theta and phi angles
@@ -285,53 +226,52 @@ class SimulatorLightEmission(SimtelRunner):
         )
         return pointing_vector.tolist(), [tel_theta, tel_phi, source_theta, source_phi]
 
-    def _write_telpos_file(self):
+    def _write_telescope_position_file(self):
         """
-        Write the telescope positions to a telpos file.
+        Write the telescope positions to a telescope_position file.
 
         The file will contain lines in the format: x y z r in cm
 
         Returns
         -------
         Path
-            The path to the generated telpos file.
+            The path to the generated telescope_position file.
         """
-        telpos_file = self.output_directory.joinpath("telpos.dat")
-        x_tel, y_tel, z_tel = self._telescope_model.get_parameter_value_with_unit(
+        x_tel, y_tel, z_tel = self.telescope_model.get_parameter_value_with_unit(
             "array_element_position_ground"
         )
         x_tel, y_tel, z_tel = [coord.to(u.cm).value for coord in (x_tel, y_tel, z_tel)]
 
-        radius = self._telescope_model.get_parameter_value_with_unit("telescope_sphere_radius")
+        radius = self.telescope_model.get_parameter_value_with_unit("telescope_sphere_radius")
         radius = radius.to(u.cm).value  # Convert radius to cm
-        with telpos_file.open("w", encoding="utf-8") as file:
-            file.write(f"{x_tel} {y_tel} {z_tel} {radius}\n")
 
-        return telpos_file
+        telescope_position_file = self.output_directory.joinpath("telescope_position.dat")
+        telescope_position_file.write_text(f"{x_tel} {y_tel} {z_tel} {radius}\n", encoding="utf-8")
+        return telescope_position_file
 
-    def _prepare_flasher_atmosphere_files(self, config_directory: Path) -> int:
-        """Prepare canonical atmosphere aliases for ff-1m and return model id 1."""
-        atmo_name = self._site_model.get_parameter_value("atmospheric_profile")
-        self._logger.debug(f"Using atmosphere profile: {atmo_name}")
+    def _prepare_flasher_atmosphere_files(self, config_directory, model_id=1):
+        """
+        Prepare canonical atmosphere aliases for ff-1m and return model id.
 
-        src_path = config_directory.joinpath(atmo_name)
-        for canonical in ("atmprof1.dat", "atm_profile_model_1.dat"):
-            dst = config_directory.joinpath(canonical)
-            if dst.exists() or dst.is_symlink():
-                try:
-                    dst.unlink()
-                except OSError:
-                    pass
+        The ff-1m tool requires atmosphere files atmprof1.dat or atm_profile_model_1.dat and
+        as configuration parameter the atmosphere id ('--atmosphere id').
+
+        """
+        src_path = config_directory / self.site_model.get_parameter_value("atmospheric_profile")
+        self._logger.debug(f"Using atmosphere profile: {src_path}")
+
+        for name in (f"atmprof{model_id}.dat", f"atm_profile_model_{model_id}.dat"):
+            dst = config_directory / name
             try:
-                dst.symlink_to(src_path)
-            except OSError:
+                if dst.exists() or dst.is_symlink():
+                    dst.unlink()
                 try:
+                    dst.symlink_to(src_path)
+                except OSError:
                     shutil.copy2(src_path, dst)
-                except OSError as copy_err:
-                    self._logger.warning(
-                        f"Failed to create atmosphere alias {dst.name}: {copy_err}"
-                    )
-        return 1
+            except OSError as copy_err:
+                self._logger.warning(f"Failed to create atmosphere alias {dst.name}: {copy_err}")
+        return model_id
 
     def _make_light_emission_script(self):
         """
@@ -345,153 +285,109 @@ class SimulatorLightEmission(SimtelRunner):
         str
             The commands to run the Light Emission package
         """
-        x_tel, y_tel, z_tel = self._telescope_model.get_parameter_value_with_unit(
-            "array_element_position_ground"
-        )
-
         config_directory = self.io_handler.get_model_configuration_directory(
-            label=self.label, model_version=self._site_model.model_version
+            model_version=self.site_model.model_version
         )
-        telpos_file = self._write_telpos_file()
-
-        app_name, _ = self._infer_application()
-
-        parts: list[str] = []
-        # application path
-        parts.append(str(self._simtel_path.joinpath("sim_telarray/LightEmission/")))
-        parts.append(f"/{app_name}")
-
-        corsika_observation_level = self._site_model.get_parameter_value_with_unit(
+        app_name = self._get_light_emission_application_name()
+        corsika_observation_level = self.site_model.get_parameter_value_with_unit(
             "corsika_observation_level"
         )
-        parts.append(
-            self._build_altitude_atmo_block(
-                app_name, config_directory, corsika_observation_level, telpos_file
-            )
-        )
-
-        parts.append(self._build_source_specific_block(x_tel, y_tel, z_tel, config_directory))
-
-        if self.light_source_type == "illuminator":
-            parts.append(f" -A {config_directory}/")
-            parts.append(f"{self._telescope_model.get_parameter_value('atmospheric_profile')}")
-
-        parts.append(f" -o {self.output_directory}/{app_name}.iact.gz")
-        parts.append("\n")
-
-        return "".join(parts)
 
-    def _build_altitude_atmo_block(
-        self, app_name, config_directory: Path, corsika_observation_level, telpos_file: Path
-    ) -> str:
-        """Return CLI segment for altitude/atmosphere and telpos handling."""
+        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 += [
+                "-A",
+                (
+                    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)
+
+    def _get_site_command(self, app_name, config_directory, corsika_observation_level):
+        """Return site command with altitude, atmosphere and telescope_position handling."""
         if app_name in ("ff-1m",):
-            seg = []
-            seg.append(" -I.")
-            seg.append(f" -I{self._simtel_path.joinpath('sim_telarray/cfg')}")
-            seg.append(f" -I{config_directory}")
-            seg.append(f" --altitude {corsika_observation_level.to(u.m).value}")
             atmo_id = self._prepare_flasher_atmosphere_files(config_directory)
-            seg.append(f" --atmosphere {atmo_id}")
-            return "".join(seg)
+            return [
+                "-I.",
+                f"-I{self._simtel_path / 'sim_telarray/cfg'}",
+                f"-I{config_directory}",
+                f"--altitude {corsika_observation_level.to(u.m).value}",
+                f"--atmosphere {atmo_id}",
+            ]
         # default path (not used for flasher now, but kept for completeness)
-        return f" -h  {corsika_observation_level.to(u.m).value} --telpos-file {telpos_file}"
-
-    def _build_source_specific_block(self, _x_tel, _y_tel, _z_tel, _config_directory: Path) -> str:
-        """Return CLI segment for light-source specific flags."""
-        if self.light_source_type == "flasher":
-            return self._add_flasher_command_options("")
-        if self.light_source_type == "illuminator":
-            return self._add_illuminator_command_options("")
-        self._logger.warning("Unknown light_source_type '%s'", self.light_source_type)
-        return ""
-
-    def _add_flasher_command_options(self, command):
-        """Add flasher-specific options to the script (uniform ff-1m)."""
-        return self._add_flasher_options(command)
+        return [
+            f"-h  {corsika_observation_level.to(u.m).value} ",
+            f"--telpos-file {self._write_telescope_position_file()}",
+        ]
+
+    def _get_light_source_command(self):
+        """Return light-source specific command options."""
+        if self.light_emission_config["light_source_type"] == "flat_fielding":
+            return self._add_flasher_command_options()
+        if self.light_emission_config["light_source_type"] == "illuminator":
+            return self._add_illuminator_command_options()
+        raise ValueError(
+            f"Unknown light_source_type '{self.light_emission_config['light_source_type']}'"
+        )
 
-    def _add_flasher_options(self, command):
+    def _add_flasher_command_options(self):
         """Add flasher options for all telescope types (ff-1m style)."""
-        # For MST/LST we used to use ff-1m; now apply same for all telescopes
-        flasher_xy = self._flasher_model.get_parameter_value_with_unit("flasher_position")
-        flasher_distance = self._flasher_model.get_parameter_value_with_unit("flasher_depth")
-        # Camera radius required for application, Radius of fiducial sphere enclosing camera
-        camera_radius = (
-            self._telescope_model.get_parameter_value_with_unit("camera_body_diameter")
+        flasher_xyz = self.calibration_model.get_parameter_value_with_unit("flasher_position")
+        camera_radius = fiducial_radius_from_shape(
+            self.telescope_model.get_parameter_value_with_unit("camera_body_diameter")
             .to(u.cm)
-            .value
-            / 2
+            .value,
+            self.telescope_model.get_parameter_value("camera_body_shape"),
         )
-        spectrum = self._flasher_model.get_parameter_value_with_unit("spectrum")
-        pulse = self._flasher_model.get_parameter_value("lightpulse")
-        angular = self._flasher_model.get_parameter_value("angular_distribution")
-        bunch_size = self._flasher_model.get_parameter_value("bunch_size")
-
-        # Convert to plain numbers for CLI
-        fx = flasher_xy[0].to(u.cm).value
-        fy = flasher_xy[1].to(u.cm).value
-        dist_cm = flasher_distance.to(u.cm).value
-        spec_nm = int(spectrum.to(u.nm).value)
-
-        command += f" --events {self.number_events}"
-        command += f" --photons {self.photons_per_run}"
-        command += f" --bunchsize {bunch_size}"
-        command += f" --xy {fx},{fy}"
-        command += f" --distance {dist_cm}"
-        command += f" --camera-radius {camera_radius}"
-        command += f" --spectrum {spec_nm}"
-        command += f" --lightpulse {pulse}"
-        command += f" --angular-distribution {angular}"
-        return command
-
-    def _add_illuminator_command_options(self, command):
-        """
-        Add illuminator-specific command options to the light emission script.
-
-        Parameters
-        ----------
-        command : str
-            The command string to add options to
-
-        Returns
-        -------
-        str
-            The updated command string
-        """
-        if self.light_source_setup == "variable":
-            command += f" -x {self.light_emission_config['x_pos']['default'].to(u.cm).value}"
-            command += f" -y {self.light_emission_config['y_pos']['default'].to(u.cm).value}"
-            command += f" -z {self.light_emission_config['z_pos']['default'].to(u.cm).value}"
-            command += (
-                f" -d {','.join(map(str, self.light_emission_config['direction']['default']))}"
-            )
-            command += f" -n {self.photons_per_run}"
-
-        elif self.light_source_setup == "layout":
-            x_cal, y_cal, z_cal = self._calibration_model.get_parameter_value_with_unit(
+        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()
+
+        return [
+            f"--events {self.light_emission_config['number_of_events']}",
+            f"--photons {self.light_emission_config['flasher_photons']}",
+            f"--bunchsize {self.calibration_model.get_parameter_value('flasher_bunch_size')}",
+            f"--xy {flasher_xyz[0].to(u.cm).value},{flasher_xyz[1].to(u.cm).value}",
+            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"--angular-distribution {angular_distribution}",
+        ]
+
+    def _add_illuminator_command_options(self):
+        """Get illuminator-specific command options for light emission script."""
+        pos = self.light_emission_config.get("light_source_position")
+        if pos is None:
+            pos = self.calibration_model.get_parameter_value_with_unit(
                 "array_element_position_ground"
             )
-            command += f" -x {x_cal.to(u.cm).value}"
-            command += f" -y {y_cal.to(u.cm).value}"
-            command += f" -z {z_cal.to(u.cm).value}"
-            pointing_vector = self.calibration_pointing_direction()[0]
-            command += f" -d {','.join(map(str, pointing_vector))}"
-
-            command += f" -n {self.photons_per_run}"
-            self._logger.info(f"Photons per run: {self.photons_per_run} ")
-
-            laser_wavelength = self._calibration_model.get_parameter_value_with_unit(
-                "laser_wavelength"
-            )
-            command += f" -s {int(laser_wavelength.to(u.nm).value)}"
-
-            led_pulse_sigtime = self._calibration_model.get_parameter_value_with_unit(
-                "led_pulse_sigtime"
-            )
-            command += f" -p Gauss:{led_pulse_sigtime.to(u.ns).value}"
-            command += " -a isotropic"
-
-        return command
+        x_cal, y_cal, z_cal = pos
+        if self.light_emission_config.get("light_source_pointing"):
+            pointing_vector = self.light_emission_config["light_source_pointing"]
+        else:
+            pointing_vector = self._calibration_pointing_direction(x_cal, y_cal, z_cal)[0]
+        flasher_wavelength = self.calibration_model.get_parameter_value_with_unit(
+            "flasher_wavelength"
+        )
+        angular_distribution = self._get_angular_distribution_string_for_sim_telarray()
+
+        return [
+            f"-x {x_cal.to(u.cm).value}",
+            f"-y {y_cal.to(u.cm).value}",
+            f"-z {z_cal.to(u.cm).value}",
+            f"-d {','.join(map(str, pointing_vector))}",
+            f"-n {self.light_emission_config['flasher_photons']}",
+            f"-s {int(flasher_wavelength.to(u.nm).value)}",
+            f"-p {self._get_pulse_shape_string_for_sim_telarray()}",
+            f"-a {angular_distribution}",
+        ]
 
     def _make_simtel_script(self):
         """
@@ -502,291 +398,102 @@ class SimulatorLightEmission(SimtelRunner):
         str
             The command to run sim_telarray
         """
-        # For flasher sims, avoid calibration pointing entirely; default angles to (0,0)
-        if self.light_source_type == "flasher":
-            angles = [0, 0]
-        else:
-            _, angles = self.calibration_pointing_direction()
+        theta, phi = self._get_telescope_pointing()
 
         simtel_bin = self._simtel_path.joinpath("sim_telarray/bin/sim_telarray/")
-        # Build command without prefix; caller will add SIM_TELARRAY_CONFIG_PATH once
-        command = f"{simtel_bin} "
-        command += f"-I{self._telescope_model.config_file_directory} "
-        command += f"-I{simtel_bin} "
-        command += f"-c {self._telescope_model.config_file_path} "
-        self._remove_line_from_config(self._telescope_model.config_file_path, "array_triggers")
-        self._remove_line_from_config(self._telescope_model.config_file_path, "axes_offsets")
-
-        command += "-DNUM_TELESCOPES=1 "
-
-        command += super().get_config_option(
-            "altitude",
-            self._site_model.get_parameter_value_with_unit("corsika_observation_level")
-            .to(u.m)
-            .value,
-        )
-        command += super().get_config_option(
-            "atmospheric_transmission",
-            self._site_model.get_parameter_value("atmospheric_transmission"),
-        )
-        command += super().get_config_option("TRIGGER_TELESCOPES", "1")
-
-        command += super().get_config_option("TELTRIG_MIN_SIGSUM", "2")
-        command += super().get_config_option("PULSE_ANALYSIS", "-30")
-        command += super().get_config_option("MAXIMUM_TELESCOPES", 1)
-
-        if self.light_source_type == "variable":
-            command += super().get_config_option("telescope_theta", 0)
-            command += super().get_config_option("telescope_phi", 0)
-        else:
-            command += super().get_config_option("telescope_theta", f"{angles[0]}")
-            command += super().get_config_option("telescope_phi", f"{angles[1]}")
-
-        # For flasher runs, bypass reflections on primary mirror
-        if self.light_source_type == "flasher":
-            command += super().get_config_option("Bypass_Optics", "1")
 
-        command += super().get_config_option("power_law", "2.68")
-        app_name, app_mode = self._infer_application()
+        parts = [
+            f"{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(
+                "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}"),
+        ]
+
+        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()
-        command += super().get_config_option(
-            "input_file", f"{self.output_directory}/{app_name}.iact.gz"
-        )
-        dist_suffix = ""
-        if self.light_source_setup == "variable":
-            try:
-                dist_val = int(self._get_distance_for_plotting().to_value(u.m))
-                dist_suffix = f"_d_{dist_val}"
-            except Exception:  # pylint:disable=broad-except
-                dist_suffix = ""
-
-        command += super().get_config_option(
-            "output_file",
-            f"{self.output_directory}/{pref}{app_name}_{app_mode}{dist_suffix}.simtel.zst",
-        )
-        command += super().get_config_option(
-            "histogram_file",
-            f"{self.output_directory}/{pref}{app_name}_{app_mode}{dist_suffix}.ctsim.hdata\n",
-        )
-
-        # Remove the default sim_telarray configuration directories
-        return clear_default_sim_telarray_cfg_directories(command)
-
-    def _remove_line_from_config(self, file_path, line_prefix):
-        """
-        Remove lines starting with a specific prefix from the config.
-
-        Parameters
-        ----------
-        file_path : Path
-            The path to the configuration file.
-        line_prefix : str
-            The prefix of lines to be removed.
-        """
-        file_path = Path(file_path)
-        with file_path.open("r", encoding="utf-8") as file:
-            lines = file.readlines()
-
-        with file_path.open("w", encoding="utf-8") as file:
-            for line in lines:
-                if not line.startswith(line_prefix):
-                    file.write(line)
-
-    def prepare_script(self):
-        """
-        Build and return bash run script containing the light-emission command.
-
-        Returns
-        -------
-        Path
-            Full path of the run script.
-        """
-        self._logger.debug("Creating run bash script")
-
-        _script_dir = self.output_directory.joinpath("scripts")
-        _script_dir.mkdir(parents=True, exist_ok=True)
-        _script_file = _script_dir.joinpath(f"{self._infer_application()[0]}-lightemission.sh")
-        self._logger.debug(f"Run bash script - {_script_file}")
-
-        target_out = Path(self._get_simulation_output_filename())
-        if target_out.exists():
-            msg = f"Simtel output file exists already, cancelling simulation: {target_out}"
-            self._logger.error(msg)
-            raise FileExistsError(msg)
-
-        command_le = self._make_light_emission_script()
-        command_simtel = self._make_simtel_script()
-
-        with _script_file.open("w", encoding="utf-8") as file:
-            file.write("#!/usr/bin/env bash\n")
-
-            file.write(f"{command_le}\n\n")
-            app_name, _ = self._infer_application()
-            file.write(
-                f"[ -s '{self.output_directory}/{app_name}.iact.gz' ] || "
-                f"{{ echo 'LightEmission did not produce IACT file' >&2; exit 1; }}\n\n"
-            )
-            file.write(f"{command_simtel}\n\n")
-
-            # Cleanup intermediate IACT file at the end of the run
-            file.write(f"rm -f '{self.output_directory}/{app_name}.iact.gz'\n\n")
-
-        _script_file.chmod(_script_file.stat().st_mode | stat.S_IXUSR | stat.S_IXGRP)
-        return _script_file
+        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"
+            ),
+        ]
+
+        return clear_default_sim_telarray_cfg_directories(" ".join(parts))
 
     def _get_simulation_output_filename(self):
         """Get the filename of the simulation output."""
-        dist_suffix = ""
-        if self.light_source_setup == "variable":
-            try:
-                dist_val = int(self._get_distance_for_plotting().to_value(u.m))
-                dist_suffix = f"_d_{dist_val}"
-            except Exception:  # pylint:disable=broad-except
-                dist_suffix = ""
-        app_name, app_mode = self._infer_application()
+        app_name = self._get_light_emission_application_name()
         pref = self._get_prefix()
-        return f"{self.output_directory}/{pref}{app_name}_{app_mode}{dist_suffix}.simtel.zst"
-
-    def _get_distance_for_plotting(self):
-        """Get the distance to be used for plotting as an astropy Quantity.
+        return f"{self.output_directory}/{pref}{app_name}.simtel.zst"
 
-        For flasher runs, use the flasher_depth (cm) from the flasher model.
-        For illuminator runs, use the configured z_pos quantity.
-        Otherwise, fall back to self.distance if set, or 0 m.
+    def calculate_distance_focal_plane_calibration_device(self):
         """
-        if self.light_source_type == "flasher" and self._flasher_model is not None:
-            return self._flasher_model.get_parameter_value_with_unit("flasher_depth").to(u.m)
+        Calculate distance between focal plane and calibration device.
 
-        def _as_meters(val):
-            if isinstance(val, u.Quantity):
-                return val.to(u.m)
-            try:
-                return float(val) * u.m
-            except (TypeError, ValueError):
-                return None
-
-        cfg = self.light_emission_config or {}
-        z = cfg.get("z_pos")
-        if isinstance(z, dict):
-            z_def = z.get("default")
-            z_val = z_def[0] if isinstance(z_def, list | tuple) and z_def else z_def
-            z_q = _as_meters(z_val)
-            if z_q is not None:
-                return z_q
-
-        d_q = _as_meters(getattr(self, "distance", None))
-        if d_q is not None:
-            return d_q
-
-        return 0 * u.m
-
-    def run_simulation(self) -> Path:
-        """Run the light emission simulation and return 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 simtel output not found: {out}")
-        return out
+        For flasher-type light sources. Flasher position is given in mirror coordinates,
+        with positive z pointing towards the camera, so the distance is focal_length - flasher_z.
 
-    def distance_list(self, arg):
+        Returns
+        -------
+        astropy.units.Quantity
+            Distance between calibration device and focal plane.
         """
-        Convert distance list to astropy quantities.
+        focal_length = self.telescope_model.get_parameter_value_with_unit("focal_length").to(u.m)
+        flasher_z = self.calibration_model.get_parameter_value_with_unit("flasher_position")[2].to(
+            u.m
+        )
+        return focal_length - flasher_z
 
-        Parameters
-        ----------
-        arg: list
-            List of distances.
+    def _get_angular_distribution_string_for_sim_telarray(self):
+        """
+        Get the angular distribution string for sim_telarray.
 
         Returns
         -------
-        values: list
-            List of distances as astropy quantities.
+        str
+            The angular distribution string.
         """
-        try:
-            return [float(x) * u.m for x in arg]
-        except ValueError as exc:
-            raise ValueError("Distances must be numeric values") from exc
+        option_string = self.calibration_model.get_parameter_value(
+            "flasher_angular_distribution"
+        ).lower()
+        width = self.calibration_model.get_parameter_value_with_unit(
+            "flasher_angular_distribution_width"
+        )
+        return f"{option_string}:{width.to(u.deg).value}" if width is not None else option_string
 
-    def update_light_emission_config(self, key: str, value):
-        """
-        Update the light emission configuration.
-
-        Parameters
-        ----------
-        key : str
-            The key in the configuration to update.
-        value : Any
-            The new value to set for the key.
+    def _get_pulse_shape_string_for_sim_telarray(self):
         """
-        if key in self.light_emission_config:
-            self.light_emission_config[key]["default"] = value
-        else:
-            raise KeyError(f"Key '{key}' not found in light emission configuration.")
+        Get the pulse shape string for sim_telarray.
 
-    def calculate_distance_telescope_calibration_device(self):
-        """Calculate distance(s) between telescope and calibration device."""
-        if self.light_source_setup == "layout":
-            # Layout positions: Use DB coordinates
-            x_cal, y_cal, z_cal = self._calibration_model.get_parameter_value_with_unit(
-                "array_element_position_ground"
-            )
-            x_cal, y_cal, z_cal = [coord.to(u.m).value for coord in (x_cal, y_cal, z_cal)]
-            x_tel, y_tel, z_tel = self._telescope_model.get_parameter_value_with_unit(
-                "array_element_position_ground"
-            )
-            x_tel, y_tel, z_tel = [coord.to(u.m).value for coord in (x_tel, y_tel, z_tel)]
-            tel_vect = np.array([x_tel, y_tel, z_tel])
-            cal_vect = np.array([x_cal, y_cal, z_cal])
-            distance = np.linalg.norm(cal_vect - tel_vect)
-            self._logger.info(f"Distance between telescope and calibration device: {distance} m")
-            return [distance * u.m]
-
-        # Variable positions: Calculate distances for all positions
-        x_tel = self.light_emission_config["x_pos"]["default"].to(u.m).value
-        y_tel = self.light_emission_config["y_pos"]["default"].to(u.m).value
-        z_positions = self.light_emission_config["z_pos"]["default"]
-
-        distances = []
-        for z in z_positions:
-            tel_vect = np.array([x_tel, y_tel, z.to(u.m).value])
-            cal_vect = np.array([0, 0, 0])  # Calibration device at origin
-            distances.append(np.linalg.norm(cal_vect - tel_vect) * u.m)
-        return distances
-
-    def simulate_variable_distances(self, args_dict):
-        """Simulate light emission for variable distances and return output files list."""
-        if args_dict["distances_ls"] is not None:
-            self.update_light_emission_config(
-                "z_pos", self.distance_list(args_dict["distances_ls"])
-            )
-        self._logger.info(
-            f"Simulating for distances: {self.light_emission_config['z_pos']['default']}"
-        )
-        outputs: list[Path] = []
-        distances = self.calculate_distance_telescope_calibration_device()
-
-        for current_distance, z_pos in zip(
-            distances, self.light_emission_config["z_pos"]["default"]
-        ):
-            self.update_light_emission_config("z_pos", z_pos)
-            self.distance = current_distance
-            outputs.append(self.run_simulation())
-        return outputs
-
-    def simulate_layout_positions(self, args_dict):  # pylint: disable=unused-argument
-        """Simulate light emission for layout positions and return output files list."""
-        # args_dict kept for API symmetry; explicitly mark as unused
-        del args_dict
-        self.distance = self.calculate_distance_telescope_calibration_device()[0]
-        # Single distance for layout
-        return [self.run_simulation()]
+        Returns
+        -------
+        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