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

simtools/simtel/simtel_config_writer.py

@@ -10,9 +10,12 @@ import numpy as np
 
 import simtools.utils.general as gen
 import simtools.version
-from simtools.io import ascii_handler
+from simtools import dependencies, settings
+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):
     """
@@ -53,8 +56,6 @@ class SimtelConfigWriter:
         Layout name.
     label: str
         Instance label. Important for output file naming.
-    simtel_path: str or Path
-        Path to the sim_telarray installation directory.
     """
 
     TAB = " " * 3
@@ -67,7 +68,6 @@ class SimtelConfigWriter:
         telescope_model_name=None,
         telescope_design_model=None,
         label=None,
-        simtel_path=None,
     ):
         """Initialize SimtelConfigWriter."""
         self._logger = logging.getLogger(__name__)
@@ -79,7 +79,6 @@ class SimtelConfigWriter:
         self._layout_name = layout_name
         self._telescope_model_name = telescope_model_name
         self._telescope_design_model = telescope_design_model
-        self._simtel_path = simtel_path
 
     def write_telescope_config_file(
         self, config_file_path, parameters, telescope_name=None, telescope_design_model=None
@@ -121,6 +120,128 @@ class SimtelConfigWriter:
             ):
                 file.write(f"{meta}\n")
 
+    @staticmethod
+    def write_light_pulse_table_gauss_exp_conv(
+        file_path,
+        width_ns,
+        exp_decay_ns,
+        fadc_sum_bins,
+        dt_ns=0.1,
+        rise_range=(0.1, 0.9),
+        fall_range=(0.9, 0.1),
+        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``.
+        exp_decay_ns : float
+            Target fall time in ns between the fractional levels defined by ``fall_range``.
+        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].
+        dt_ns : float, optional
+            Time sampling step in ns for the generated pulse table.
+        rise_range : tuple[float, float], optional
+            Fractional amplitude bounds (low, high) for rise-time definition.
+        fall_range : tuple[float, float], optional
+            Fractional amplitude bounds (high, low) for fall-time definition.
+        time_margin_ns : float, optional
+            Margin in ns to add to both ends of the FADC window when ``fadc_sum_bins`` is given.
+
+        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(
+            "Generating pulse-shape table with "
+            f"rise{int(rise_range[0] * 100)}-{int(rise_range[1] * 100)}={width_ns} ns, "
+            f"fall{int(fall_range[0] * 100)}-{int(fall_range[1] * 100)}={exp_decay_ns} ns, "
+            f"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_angular_distribution_table_lambertian(
+        file_path,
+        max_angle_deg,
+        n_samples=100,
+    ):
+        """Write a Lambertian angular distribution table (I(t) ~ cos(t)).
+
+        Parameters
+        ----------
+        file_path : str or pathlib.Path
+            Destination path of the ASCII table to write. Parent directory must exist.
+        max_angle_deg : float
+            Maximum angle (deg) for the distribution sampling range [0, max_angle_deg].
+        n_samples : int, optional
+            Number of samples (including end point) from 0 to max_angle_deg. Default 100.
+
+        Returns
+        -------
+        pathlib.Path
+            Path to created angular distribution table.
+        """
+        logger.info(
+            f"Generating Lambertian angular distribution table up to {max_angle_deg} deg "
+            f"with {n_samples} samples"
+        )
+        angles = np.linspace(0.0, float(max_angle_deg), int(n_samples), dtype=float)
+        intensities = np.cos(np.deg2rad(angles))
+        intensities[intensities < 0] = 0.0
+        if intensities.max() > 0:
+            intensities /= intensities.max()
+
+        return SimtelConfigWriter._write_ascii_angle_distribution_table(
+            file_path, angles, intensities
+        )
+
+    @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)
+
+    @staticmethod
+    def _write_ascii_angle_distribution_table(file_path, angles, intensities):
+        """Write two-column ASCII angular distribution table."""
+        with open(file_path, "w", encoding="utf-8") as fh:
+            fh.write("# angle[deg] relative_intensity\n")
+            for a, i in zip(angles, intensities):
+                fh.write(f"{a:.6f} {i:.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.
@@ -176,28 +297,24 @@ class SimtelConfigWriter:
             Model parameters in sim_telarray format including flasher parameters.
 
         """
-        if "flasher_pulse_shape" not in parameters and "flasher_pulse_width" not in parameters:
+        if "flasher_pulse_shape" not in parameters:
             return simtel_par
 
         mapping = {
             "gauss": "laser_pulse_sigtime",
             "tophat": "laser_pulse_twidth",
+            "gauss-exponential": "laser_pulse_sigtime",
         }
 
-        shape = parameters.get("flasher_pulse_shape", {}).get("value", "").lower()
-        if "exponential" in shape:
-            simtel_par["laser_pulse_exptime"] = parameters.get("flasher_pulse_exp_decay", {}).get(
-                "value", 0.0
-            )
-        else:
-            simtel_par["laser_pulse_exptime"] = 0.0
+        shape_value = parameters.get("flasher_pulse_shape", {}).get("value")
+        shape = shape_value[0].lower()
+        width = shape_value[1]
+        exp_decay = shape_value[2]
 
-        width = parameters.get("flasher_pulse_width", {}).get("value", 0.0)
+        simtel_par["laser_pulse_exptime"] = exp_decay if ("exponential" in shape) else 0.0
 
         simtel_par.update(dict.fromkeys(mapping.values(), 0.0))
-        if shape == "gauss-exponential":
-            simtel_par["laser_pulse_sigtime"] = width
-        elif shape in mapping:
+        if shape in mapping:
             simtel_par[mapping[shape]] = width
         else:
             self._logger.warning(f"Flasher pulse shape '{shape}' without width definition")
@@ -221,7 +338,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
 
@@ -495,17 +612,24 @@ class SimtelConfigWriter:
             "simtools_model_production_version": self._model_version,
         }
         try:
-            build_opts = ascii_handler.collect_data_from_file(
-                Path(self._simtel_path) / "build_opts.yml"
-            )
+            build_opts = dependencies.get_build_options()
             for key, value in build_opts.items():
                 meta_items[f"simtools_{key}"] = value
         except (FileNotFoundError, TypeError):
             pass  # don't expect build_opts.yml to be present on all systems
 
+        # CORSIKA executable without _flat/_curved suffix (do not know here if curved or flat)
+        try:
+            meta_items["simtools_corsika_exec"] = settings.config.corsika_exe.name.removesuffix(
+                "_flat"
+            )
+        except AttributeError as exc:
+            raise AttributeError("CORSIKA executable path is not set in settings.") from exc
+
         file.write(f"{self.TAB}% Simtools parameters\n")
         for key, value in meta_items.items():
-            file.write(f"{self.TAB}metaparam global set {key} = {value}\n")
+            if not isinstance(value, list):
+                file.write(f"{self.TAB}metaparam global set {key} = {value}\n")
 
     def _write_site_parameters(
         self, file, site_parameters, model_path, telescope_model, additional_metadata=None

simtools/simtel/simtel_table_reader.py

@@ -154,14 +154,16 @@ def _data_columns_mirror_reflectivity(n_columns, n_dim):
         {"name": "wavelength", "description": "Wavelength", "unit": "nm"},
     ]
     if n_dim:
-        for angle in n_dim:
-            _columns.append(
+        _columns.extend(
+            [
                 {
                     "name": f"reflectivity_{angle}deg",
                     "description": f"Mirror reflectivity at {angle} deg",
                     "unit": None,
-                },
-            )
+                }
+                for angle in n_dim
+            ]
+        )
     else:
         _columns.append(
             {

simtools/simtel/simulator_array.py

@@ -1,7 +1,9 @@
 """Simulation runner for array simulations."""
 
 import logging
+import stat
 
+from simtools import settings
 from simtools.io import io_handler
 from simtools.runners.simtel_runner import InvalidOutputFileError, SimtelRunner
 from simtools.utils.general import clear_default_sim_telarray_cfg_directories
@@ -15,8 +17,6 @@ class SimulatorArray(SimtelRunner):
     ----------
     corsika_config_data: CorsikaConfig
         CORSIKA configuration.
-    simtel_path: str or Path
-        Location of source of the sim_telarray/CORSIKA package.
     label: str
         Instance label.
     use_multipipe: bool
@@ -28,7 +28,6 @@ class SimulatorArray(SimtelRunner):
     def __init__(
         self,
         corsika_config,
-        simtel_path,
         label=None,
         use_multipipe=False,
         sim_telarray_seeds=None,
@@ -39,9 +38,9 @@ class SimulatorArray(SimtelRunner):
         self._logger.debug("Init SimulatorArray")
         super().__init__(
             label=label,
-            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 +49,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 +156,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":
@@ -133,7 +178,7 @@ class SimulatorArray(SimtelRunner):
         output_file = self.get_file_name(file_type="simtel_output", run_number=run_number)
         self.corsika_config.array_model.export_all_simtel_config_files()
 
-        command = str(self._simtel_path.joinpath("sim_telarray/bin/sim_telarray"))
+        command = str(settings.config.sim_telarray_exe)
         command += f" -c {self.corsika_config.array_model.config_file_path}"
         command += f" -I{config_dir}"
         command += super().get_config_option(
@@ -155,7 +200,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.
 
@@ -174,9 +219,7 @@ class SimulatorArray(SimtelRunner):
             "fadc_sysvar_pedestal",
             "fadc_dev_pedestal",
         ]
-        null_command_parts = []
-        for param in null_values:
-            null_command_parts.append(super().get_config_option(param, 0.0))
+        null_command_parts = [super().get_config_option(param, 0.0) for param in null_values]
         command = " ".join(null_command_parts)
 
         one_values = [
@@ -185,15 +228,13 @@ class SimulatorArray(SimtelRunner):
             "fadc_lg_dev_pedestal",
             "fadc_lg_sysvar_pedestal",
         ]
-        one_command_parts = []
-        for param in one_values:
-            one_command_parts.append(super().get_config_option(param, -1.0))
+        one_command_parts = [super().get_config_option(param, -1.0) for param in one_values]
         command += " " + " ".join(one_command_parts)
         return command
 
     def _check_run_result(self, run_number=None):
         """
-        Check if simtel output file exists.
+        Check if sim_telarray output file exists.
 
         Parameters
         ----------
@@ -203,18 +244,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 +262,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

simtools/simtel/simulator_camera_efficiency.py

@@ -3,6 +3,7 @@
 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
@@ -20,8 +21,6 @@ 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
@@ -37,7 +36,6 @@ class SimulatorCameraEfficiency(SimtelRunner):
         telescope_model,
         site_model,
         label=None,
-        simtel_path=None,
         file_simtel=None,
         file_log=None,
         zenith_angle=None,
@@ -48,7 +46,7 @@ class SimulatorCameraEfficiency(SimtelRunner):
         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
@@ -109,7 +107,7 @@ class SimulatorCameraEfficiency(SimtelRunner):
                 "mirror_reflectivity", "secondary_mirror_incidence_angle"
             )
 
-        command = str(self._simtel_path.joinpath("sim_telarray/testeff"))
+        command = 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
@@ -150,7 +148,7 @@ class SimulatorCameraEfficiency(SimtelRunner):
         command = general.clear_default_sim_telarray_cfg_directories(command)
 
         return (
-            f"cd {self._simtel_path.joinpath('sim_telarray')} && {command}",
+            f"cd {settings.config.sim_telarray_path} && {command}",
             self._file_simtel,
             self._file_log,
         )