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

simtools/simtel/pulse_shapes.py

@@ -0,0 +1,268 @@
+"""Pulse shape computations for light emission simulations for flasher."""
+
+import numpy as np
+from scipy.optimize import least_squares
+from scipy.signal import fftconvolve
+
+
+def _rise_width(t, y, y_low=0.1, y_high=0.9):
+    """Measure rise width between fractional amplitudes.
+
+    Parameters
+    ----------
+    t : array-like
+        Time samples in ns.
+    y : array-like
+        Pulse amplitude samples (normalized or arbitrary units).
+    y_low : float, optional
+        Lower fractional amplitude (0..1) on the rising edge. Default is 0.1.
+    y_high : float, optional
+        Upper fractional amplitude (0..1) on the rising edge. Default is 0.9.
+
+    Returns
+    -------
+    float
+        Width in ns between ``y_low`` and ``y_high`` on the rising edge.
+    """
+    i_peak = int(np.argmax(y))
+    tr = t[: i_peak + 1]
+    yr = y[: i_peak + 1]
+    t_low = np.interp(y_low, yr, tr)
+    t_high = np.interp(y_high, yr, tr)
+    return t_high - t_low
+
+
+def _fall_width(t, y, y_high=0.9, y_low=0.1):
+    """Measure fall width between fractional amplitudes.
+
+    Parameters
+    ----------
+    t : array-like
+        Time samples in ns.
+    y : array-like
+        Pulse amplitude samples (normalized or arbitrary units).
+    y_high : float, optional
+        Higher fractional amplitude (0..1) on the falling edge. Default is 0.9.
+    y_low : float, optional
+        Lower fractional amplitude (0..1) on the falling edge. Default is 0.1.
+
+    Returns
+    -------
+    float
+        Width in ns between ``y_high`` and ``y_low`` on the falling edge.
+    """
+    i_peak = int(np.argmax(y))
+    tf = t[i_peak:]
+    yf = y[i_peak:]
+    t_rev = tf[::-1]
+    y_rev = yf[::-1]
+    t_hi = np.interp(y_high, y_rev, t_rev)
+    t_lo = np.interp(y_low, y_rev, t_rev)
+    return t_lo - t_hi
+
+
+def _gaussian(t, sigma):
+    """Gaussian pulse shape.
+
+    Parameters
+    ----------
+    t : array-like
+        Time samples in ns.
+    sigma : float
+        Gaussian standard deviation in ns.
+
+    Returns
+    -------
+    numpy.ndarray
+        Gaussian values at ``t`` (unitless), with a small safeguard for ``sigma``.
+    """
+    return np.exp(-0.5 * (t / max(sigma, 1e-9)) ** 2)
+
+
+def _exp_decay(t, tau):
+    """Causal exponential decay shape.
+
+    Parameters
+    ----------
+    t : array-like
+        Time samples in ns.
+    tau : float
+        Exponential decay constant in ns.
+
+    Returns
+    -------
+    numpy.ndarray
+        Exponential values at ``t`` (unitless), zero for ``t < 0``.
+    """
+    tau = max(tau, 1e-9)
+    return np.where(t >= 0, np.exp(-t / tau), 0.0)
+
+
+def generate_gauss_expconv_pulse(
+    sigma_ns,
+    tau_ns,
+    dt_ns=0.1,
+    t_start_ns=-10,
+    t_stop_ns=25,
+    center_on_peak=False,
+):
+    """Generate a Gaussian convolved with a causal exponential.
+
+    Parameters
+    ----------
+    sigma_ns : float
+        Gaussian standard deviation (ns).
+    tau_ns : float
+        Exponential decay constant (ns).
+    dt_ns : float, optional
+        Time sampling step (ns). Default is 0.1 ns.
+    t_start_ns : float
+        Together with ``t_stop_ns``, defines the explicit start of the time grid
+        for pulse generation (ns).
+    t_stop_ns : float
+        Together with ``t_start_ns``, defines the explicit end of the time grid
+        for pulse generation (ns).
+    center_on_peak : bool, optional
+        If True, shift the returned time array so the pulse maximum is at t=0.
+        Default is False.
+
+    Returns
+    -------
+    tuple[numpy.ndarray, numpy.ndarray]
+        Tuple ``(t, y)`` with time samples in ns and normalized pulse amplitude (peak 1).
+    """
+    left = float(t_start_ns)
+    right = float(t_stop_ns)
+    t = np.arange(left, right, dt_ns, dtype=float)
+    g = _gaussian(t, sigma_ns)
+    e = _exp_decay(t, tau_ns)
+    y = fftconvolve(g, e, mode="same")
+    if y.max() > 0:
+        y = y / y.max()
+    if center_on_peak:
+        i_max = int(np.argmax(y))
+        t = t - float(t[i_max])
+    return t, y
+
+
+def solve_sigma_tau_from_rise_fall(
+    rise_width_ns,
+    fall_width_ns,
+    dt_ns=0.1,
+    rise_range=(0.1, 0.9),
+    fall_range=(0.9, 0.1),
+    t_start_ns=-10,
+    t_stop_ns=25,
+):
+    """Solve (sigma, tau) so convolved pulse matches target rise/fall widths.
+
+    Parameters
+    ----------
+    rise_width_ns : float
+        Desired width on the rising edge in ns between rise_range=(low, high) fractions.
+    fall_width_ns : float
+        Desired width on the falling edge in ns between fall_range=(high, low) fractions.
+    dt_ns : float
+        Time step for internal pulse sampling in ns.
+    rise_range : tuple[float, float]
+        Fractional amplitudes (low, high) for the rising width, defaults to (0.1, 0.9).
+    fall_range : tuple[float, float]
+        Fractional amplitudes (high, low) for the falling width, defaults to (0.9, 0.1).
+    t_start_ns : float
+        Optional start time (ns) for the internal sampling window. If provided together with
+        ``t_stop_ns``, overrides the default window.
+    t_stop_ns : float
+        Optional stop time (ns) for the internal sampling window. If provided together with
+        ``t_start_ns``, overrides the default window.
+
+    Returns
+    -------
+    tuple[float, float]
+        Tuple ``(sigma_ns, tau_ns)`` giving the Gaussian sigma and exponential tau in ns.
+    """
+    t = np.arange(float(t_start_ns), float(t_stop_ns) + dt_ns, dt_ns, dtype=float)
+
+    def pulse(sigma, tau):
+        g = _gaussian(t, sigma)
+        e = _exp_decay(t, tau)
+        y = fftconvolve(g, e, mode="same")
+        return y / y.max() if y.max() > 0 else y
+
+    rise_lo, rise_hi = rise_range
+    fall_hi, fall_lo = fall_range
+
+    def residuals(x):
+        sigma, tau = x
+        y = pulse(sigma, tau)
+        r = _rise_width(t, y, y_low=rise_lo, y_high=rise_hi) - rise_width_ns
+        f = _fall_width(t, y, y_high=fall_hi, y_low=fall_lo) - fall_width_ns
+        return [r, f]
+
+    res = least_squares(residuals, x0=[0.3, 10.0], bounds=(1e-6, 500))
+    sigma, tau = float(res.x[0]), float(res.x[1])
+    return sigma, tau
+
+
+def generate_pulse_from_rise_fall_times(
+    rise_width_ns,
+    fall_width_ns,
+    dt_ns=0.1,
+    rise_range=(0.1, 0.9),
+    fall_range=(0.9, 0.1),
+    t_start_ns=-10,
+    t_stop_ns=25,
+    center_on_peak=False,
+):
+    """Generate pulse from rise/fall time specifications.
+
+    Parameters
+    ----------
+    rise_width_ns : float
+    Target rise time (ns) between the fractional levels defined by ``rise_range``.
+    Defaults correspond to 10-90% rise time.
+    fall_width_ns : float
+    Target fall time (ns) between the fractional levels defined by ``fall_range``.
+    Defaults correspond to 90-10% fall time.
+    dt_ns : float, optional
+        Time sampling step (ns). Default is 0.1 ns.
+    rise_range : tuple[float, float], optional
+        Fractional amplitudes (low, high) for rise-time definition. Default (0.1, 0.9).
+    fall_range : tuple[float, float], optional
+        Fractional amplitudes (high, low) for fall-time definition. Default (0.9, 0.1).
+    t_start_ns : float, optional
+        Start time (ns) for the internal solver sampling window and output grid. Default -10.
+    t_stop_ns : float, optional
+        Stop time (ns) for the internal solver sampling window and output grid. Default 25.
+    center_on_peak : bool, optional
+        If True, shift the returned time array so the pulse maximum is at t=0.
+        Default is False.
+
+    Returns
+    -------
+    tuple[numpy.ndarray, numpy.ndarray]
+        Tuple ``(t, y)`` with time samples in ns and normalized pulse amplitude (peak 1).
+
+    Notes
+    -----
+    The model is a Gaussian convolved with an exponential. The parameters (sigma, tau)
+    are solved via least-squares such that the resulting pulse matches the requested rise and
+    fall times measured on monotonic segments relative to the peak.
+    """
+    sigma, tau = solve_sigma_tau_from_rise_fall(
+        rise_width_ns,
+        fall_width_ns,
+        dt_ns=dt_ns,
+        rise_range=rise_range,
+        fall_range=fall_range,
+        t_start_ns=t_start_ns,
+        t_stop_ns=t_stop_ns,
+    )
+
+    return generate_gauss_expconv_pulse(
+        sigma,
+        tau,
+        dt_ns=dt_ns,
+        t_start_ns=t_start_ns,
+        t_stop_ns=t_stop_ns,
+        center_on_peak=center_on_peak,
+    )

simtools/simtel/simtel_config_writer.py

@@ -11,8 +11,11 @@ import numpy as np
 import simtools.utils.general as gen
 import simtools.version
 from simtools.io import ascii_handler
+from simtools.simtel.pulse_shapes import generate_pulse_from_rise_fall_times
 from simtools.utils import names
 
+logger = logging.getLogger(__name__)
+
 
 def sim_telarray_random_seeds(seed, number):
     """
@@ -121,6 +124,84 @@ class SimtelConfigWriter:
             ):
                 file.write(f"{meta}\n")
 
+    @staticmethod
+    def write_lightpulse_table_gauss_expconv(
+        file_path,
+        width_ns=None,
+        exp_decay_ns=None,
+        dt_ns=0.1,
+        rise_range=(0.1, 0.9),
+        fall_range=(0.9, 0.1),
+        fadc_sum_bins=None,
+        time_margin_ns=10.0,
+    ):
+        """Write a pulse table for a Gaussian convolved with a causal exponential.
+
+        Parameters
+        ----------
+        file_path : str or pathlib.Path
+            Destination path of the ASCII pulse table to write. Parent directory must exist.
+        width_ns : float
+            Target rise time in ns between the fractional levels defined by ``rise_range``.
+            Defaults correspond to 10-90% rise time.
+        exp_decay_ns : float
+            Target fall time in ns between the fractional levels defined by ``fall_range``.
+            Defaults correspond to 90-10% fall time.
+        dt_ns : float, optional
+            Time sampling step in ns for the generated pulse table. Default is 0.1.
+        rise_range : tuple[float, float], optional
+            Fractional amplitude bounds (low, high) for rise-time definition. Default (0.1, 0.9).
+        fall_range : tuple[float, float], optional
+            Fractional amplitude bounds (high, low) for fall-time definition. Default (0.9, 0.1).
+        fadc_sum_bins : int
+            Length of the FADC integration window (treated as ns here) used to derive
+            the internal time sampling window of the solver as [-(margin), bins + margin].
+        time_margin_ns : float, optional
+            Margin in ns to add to both ends of the FADC window when ``fadc_sum_bins`` is given.
+            Default is 5.0 ns.
+
+        Returns
+        -------
+        pathlib.Path
+            The path to the created pulse table file.
+
+        Notes
+        -----
+        The underlying model is a Gaussian convolved with a causal exponential. The model
+        parameters (sigma, tau) are solved such that the normalized pulse matches the requested
+        rise and fall times. The pulse is normalized to a peak amplitude of 1.
+        """
+        if width_ns is None or exp_decay_ns is None:
+            raise ValueError("width_ns (rise 10-90) and exp_decay_ns (fall 90-10) are required")
+        logger.info(
+            f"Generating lightpulse table with rise10-90={width_ns} ns, "
+            f"fall90-10={exp_decay_ns} ns, dt={dt_ns} ns"
+        )
+        width = float(fadc_sum_bins)
+        t_start_ns = -abs(time_margin_ns + width)
+        t_stop_ns = +abs(time_margin_ns + width)
+        t, y = generate_pulse_from_rise_fall_times(
+            width_ns,
+            exp_decay_ns,
+            dt_ns=dt_ns,
+            rise_range=rise_range,
+            fall_range=fall_range,
+            t_start_ns=t_start_ns,
+            t_stop_ns=t_stop_ns,
+            center_on_peak=True,
+        )
+
+        return SimtelConfigWriter._write_ascii_pulse_table(file_path, t, y)
+
+    @staticmethod
+    def _write_ascii_pulse_table(file_path, t, y):
+        """Write two-column ASCII pulse table."""
+        with open(file_path, "w", encoding="utf-8") as fh:
+            fh.write("# time[ns] amplitude\n")
+            for ti, yi in zip(t, y):
+                fh.write(f"{ti:.6f} {yi:.8f}\n")
+        return Path(file_path)
+
     def _get_parameters_for_sim_telarray(self, parameters, config_file_path):
         """
         Convert parameter dictionary to sim_telarray configuration file format.
@@ -221,7 +302,7 @@ class SimtelConfigWriter:
         value = "none" if value is None else value  # simtel requires 'none'
         if isinstance(value, bool):
             value = 1 if value else 0
-        elif isinstance(value, (list, np.ndarray)):
+        elif isinstance(value, list | np.ndarray):
             value = gen.convert_list_to_string(value, shorten_list=True)
         return value
 
@@ -528,7 +609,7 @@ class SimtelConfigWriter:
         """
         file.write(self.TAB + "% Site parameters\n")
         for par, value in site_parameters.items():
-            simtel_name, value = self._convert_model_parameters_to_simtel_format(
+            simtel_name, simtel_value = self._convert_model_parameters_to_simtel_format(
                 names.get_simulation_software_name_from_parameter_name(
                     par, software_name="sim_telarray"
                 ),
@@ -537,7 +618,7 @@ class SimtelConfigWriter:
                 telescope_model,
             )
             if simtel_name is not None:
-                file.write(f"{self.TAB}{simtel_name} = {value}\n")
+                file.write(f"{self.TAB}{simtel_name} = {simtel_value}\n")
         for meta in self._get_sim_telarray_metadata(
             "site", site_parameters, None, additional_metadata
         ):
@@ -592,34 +673,111 @@ class SimtelConfigWriter:
         telescope_model: dict of TelescopeModel
             Telescope models.
         """
+        trigger_per_telescope_type = self._group_telescopes_by_type(telescope_model)
+        hardstereo_lines, non_hardstereo_groups, all_non_hardstereo_tels, multiplicity = (
+            self._process_telescope_triggers(array_triggers, trigger_per_telescope_type)
+        )
+
+        array_triggers_file = "array_triggers.dat"
+        with open(model_path / array_triggers_file, "w", encoding="utf-8") as file:
+            file.write("# Array trigger definition\n")
+            self._write_trigger_lines(
+                file, hardstereo_lines, non_hardstereo_groups, all_non_hardstereo_tels, multiplicity
+            )
+
+        return array_triggers_file
+
+    def _group_telescopes_by_type(self, telescope_model):
+        """Group telescopes by their type."""
         trigger_per_telescope_type = {}
         for count, tel_name in enumerate(telescope_model.keys()):
             telescope_type = names.get_array_element_type_from_name(tel_name)
             trigger_per_telescope_type.setdefault(telescope_type, []).append(count + 1)
+        return trigger_per_telescope_type
+
+    def _process_telescope_triggers(self, array_triggers, trigger_per_telescope_type):
+        """Process telescope triggers and group them by hardstereo and parameters."""
+        hardstereo_lines = []
+        non_hardstereo_groups = {}
+        all_non_hardstereo_tels = []
+        multiplicity = None
 
-        trigger_lines = {}
         for tel_type, tel_list in trigger_per_telescope_type.items():
             trigger_dict = self._get_array_triggers_for_telescope_type(
                 array_triggers, tel_type, len(tel_list)
             )
-            trigger_lines[tel_type] = f"Trigger {trigger_dict['multiplicity']['value']} of "
-            trigger_lines[tel_type] += ", ".join(map(str, tel_list))
-            width = trigger_dict["width"]["value"] * u.Unit(trigger_dict["width"]["unit"]).to("ns")
-            trigger_lines[tel_type] += f" width {width}"
-            if trigger_dict.get("hard_stereo", {}).get("value"):
-                trigger_lines[tel_type] += " hardstereo"
-            if all(trigger_dict["min_separation"][key] is not None for key in ["value", "unit"]):
-                min_sep = trigger_dict["min_separation"]["value"] * u.Unit(
-                    trigger_dict["min_separation"]["unit"]
-                ).to("m")
-                trigger_lines[tel_type] += f" minsep {min_sep}"
+            width, minsep = self._extract_trigger_parameters(trigger_dict)
+            multiplicity = trigger_dict["multiplicity"]["value"]  # Store for later use
 
-        array_triggers_file = "array_triggers.dat"
-        with open(model_path / array_triggers_file, "w", encoding="utf-8") as file:
-            file.write("# Array trigger definition\n")
-            file.writelines(f"{line}\n" for line in trigger_lines.values())
-
-        return array_triggers_file
+            if trigger_dict.get("hard_stereo", {}).get("value"):
+                line = self._build_trigger_line(
+                    trigger_dict, tel_list, width, minsep, hardstereo=True
+                )
+                hardstereo_lines.append(line)
+            else:
+                key = (width, minsep)
+                non_hardstereo_groups.setdefault(key, []).extend(tel_list)
+                all_non_hardstereo_tels.extend(tel_list)
+
+        return hardstereo_lines, non_hardstereo_groups, all_non_hardstereo_tels, multiplicity
+
+    def _extract_trigger_parameters(self, trigger_dict):
+        """Extract width and min_separation parameters from trigger dictionary."""
+        width = trigger_dict["width"]["value"] * u.Unit(trigger_dict["width"]["unit"]).to("ns")
+        minsep = None
+        if all(trigger_dict["min_separation"][key] is not None for key in ["value", "unit"]):
+            minsep = trigger_dict["min_separation"]["value"] * u.Unit(
+                trigger_dict["min_separation"]["unit"]
+            ).to("m")
+        return width, minsep
+
+    def _build_trigger_line(self, trigger_dict, tel_list, width, minsep, hardstereo=False):
+        """Build a trigger line string."""
+        line = f"Trigger {trigger_dict['multiplicity']['value']} of "
+        line += ", ".join(map(str, tel_list))
+        line += f" width {width}"
+        if hardstereo:
+            line += " hardstereo"
+        if minsep is not None:
+            line += f" minsep {minsep}"
+        return line
+
+    def _write_trigger_lines(
+        self, file, hardstereo_lines, non_hardstereo_groups, all_non_hardstereo_tels, multiplicity
+    ):
+        """Write all trigger lines to file."""
+        # Write hardstereo lines first
+        for line in hardstereo_lines:
+            file.write(f"{line}\n")
+
+        # Write individual non-hardstereo groups if they have different parameters
+        if len(non_hardstereo_groups) > 1:
+            for (width, minsep), tel_list in non_hardstereo_groups.items():
+                line = f"Trigger {multiplicity} of "
+                line += ", ".join(map(str, tel_list))
+                line += f" width {width}"
+                if minsep is not None:
+                    line += f" minsep {minsep}"
+                file.write(f"{line}\n")
+
+        # Write combined line with all non-hardstereo telescopes using shortest values
+        if all_non_hardstereo_tels:
+            min_width = min(width for width, minsep in non_hardstereo_groups.keys())
+            min_minsep = self._get_minimum_minsep(non_hardstereo_groups)
+
+            combined_line = f"Trigger {multiplicity} of "
+            combined_line += ", ".join(map(str, sorted(all_non_hardstereo_tels)))
+            combined_line += f" width {min_width}"
+            if min_minsep is not None:
+                combined_line += f" minsep {min_minsep}"
+            file.write(f"{combined_line}\n")
+
+    def _get_minimum_minsep(self, non_hardstereo_groups):
+        """Get minimum min_separation value from groups."""
+        minsep_values = [
+            minsep for width, minsep in non_hardstereo_groups.keys() if minsep is not None
+        ]
+        return min(minsep_values) if minsep_values else None
 
     def _get_array_triggers_for_telescope_type(
         self, array_triggers, telescope_type, num_telescopes_of_type

simtools/simtel/simtel_io_event_writer.py

@@ -17,7 +17,7 @@ from eventio.simtel import (
 )
 
 from simtools.corsika.primary_particle import PrimaryParticle
-from simtools.simtel.simtel_io_file_info import get_corsika_run_header
+from simtools.io.eventio_handler import get_combined_corsika_run_header
 from simtools.simtel.simtel_io_metadata import (
     get_sim_telarray_telescope_id_to_telescope_name_mapping,
     read_sim_telarray_metadata,
@@ -158,7 +158,7 @@ class SimtelIOEventDataWriter:
 
     def _process_file_info(self, file_id, file):
         """Process file information and append to file info list."""
-        run_info = get_corsika_run_header(file)
+        run_info = get_combined_corsika_run_header(file)
         self.telescope_id_to_name = get_sim_telarray_telescope_id_to_telescope_name_mapping(file)
         particle = PrimaryParticle(
             particle_id_type="eventio_id", particle_id=run_info.get("primary_id", 1)

simtools/simtel/simulator_array.py

@@ -1,6 +1,7 @@
 """Simulation runner for array simulations."""
 
 import logging
+import stat
 
 from simtools.io import io_handler
 from simtools.runners.simtel_runner import InvalidOutputFileError, SimtelRunner
@@ -42,6 +43,7 @@ class SimulatorArray(SimtelRunner):
             simtel_path=simtel_path,
             corsika_config=corsika_config,
             use_multipipe=use_multipipe,
+            calibration_run_mode=calibration_config.get("run_mode") if calibration_config else None,
         )
 
         self.sim_telarray_seeds = sim_telarray_seeds
@@ -50,6 +52,52 @@ class SimulatorArray(SimtelRunner):
         self.io_handler = io_handler.IOHandler()
         self._log_file = None
 
+    def prepare_run_script(self, test=False, input_file=None, run_number=None, extra_commands=None):
+        """
+        Build and return the full path of the bash run script containing the sim_telarray command.
+
+        Parameters
+        ----------
+        test: bool
+            Test flag for faster execution.
+        input_file: str or Path
+            Full path of the input CORSIKA file.
+        run_number: int
+            Run number.
+        extra_commands: list[str]
+            Additional commands for running simulations given in config.yml.
+
+        Returns
+        -------
+        Path
+            Full path of the run script.
+        """
+        script_file_path = self.get_file_name(file_type="sub_script", run_number=run_number)
+        self._logger.debug(f"Run bash script - {script_file_path}")
+        self._logger.debug(f"Extra commands to be added to the run script {extra_commands}")
+
+        command = self.make_run_command(run_number=run_number, input_file=input_file)
+        with script_file_path.open("w", encoding="utf-8") as file:
+            file.write("#!/usr/bin/env bash\n\n")
+            file.write("set -e\n")
+            file.write("set -o pipefail\n")
+            file.write("\nSECONDS=0\n")
+
+            if extra_commands:
+                file.write("# Writing extras\n")
+                for line in extra_commands:
+                    file.write(f"{line}\n")
+                file.write("# End of extras\n\n")
+
+            n = 1 if test else self.runs_per_set
+            for _ in range(n):
+                file.write(f"{command}\n\n")
+
+            file.write('\necho "RUNTIME: $SECONDS"\n')
+
+        script_file_path.chmod(script_file_path.stat().st_mode | stat.S_IXUSR | stat.S_IXGRP)
+        return script_file_path
+
     def make_run_command(self, run_number=None, input_file=None, weak_pointing=None):
         """
         Build and return the command to run sim_telarray.
@@ -111,12 +159,12 @@ class SimulatorArray(SimtelRunner):
                 command += super().get_config_option(key, cfg[key])
 
         run_mode = cfg.get("run_mode")
-        if run_mode in ("pedestals", "nsb_only_pedestals"):
+        if run_mode in ("pedestals", "pedestals_nsb_only"):
             n_events = cfg.get("number_of_pedestal_events", cfg["number_of_events"])
             command += super().get_config_option("pedestal_events", n_events)
-        if run_mode == "nsb_only_pedestals":
-            command += self._nsb_only_pedestals_command()
-        if run_mode == "dark_pedestals":
+        if run_mode == "pedestals_nsb_only":
+            command += self._pedestals_nsb_only_command()
+        if run_mode == "pedestals_dark":
             n_events = cfg.get("number_of_dark_events", cfg["number_of_events"])
             command += super().get_config_option("dark_events", n_events)
         if run_mode == "direct_injection":
@@ -155,7 +203,7 @@ class SimulatorArray(SimtelRunner):
 
         return command
 
-    def _nsb_only_pedestals_command(self):
+    def _pedestals_nsb_only_command(self):
         """
         Generate the command to run sim_telarray for nsb-only pedestal simulations.
 
@@ -193,7 +241,7 @@ class SimulatorArray(SimtelRunner):
 
     def _check_run_result(self, run_number=None):
         """
-        Check if simtel output file exists.
+        Check if sim_telarray output file exists.
 
         Parameters
         ----------
@@ -203,18 +251,16 @@ class SimulatorArray(SimtelRunner):
         Returns
         -------
         bool
-            True if simtel output file exists.
+            True if sim_telarray output file exists.
 
         Raises
         ------
         InvalidOutputFileError
-            If simtel output file does not exist.
+            If sim_telarray output file does not exist.
         """
         output_file = self.get_file_name(file_type="simtel_output", run_number=run_number)
         if not output_file.exists():
-            msg = f"sim_telarray output file {output_file} does not exist."
-            self._logger.error(msg)
-            raise InvalidOutputFileError(msg)
+            raise InvalidOutputFileError(f"sim_telarray output file {output_file} does not exist.")
         self._logger.debug(f"sim_telarray output file {output_file} exists.")
         return True
 
@@ -223,7 +269,7 @@ class SimulatorArray(SimtelRunner):
         """
         Get the power law index for sim_telarray.
 
-        Events will be histogrammed in sim_telarray with a weight according to
+        Events will be filled in histograms in sim_telarray with a weight according to
         the difference between this exponent and the one used for the shower simulations.
 
         Parameters