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

simtools/simtel/simulator_array.py

@@ -1,12 +1,10 @@
 """Simulation runner for array simulations."""
 
-import logging
-import stat
+from pathlib import Path
 
 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
+from simtools.runners.simtel_runner import SimtelRunner, sim_telarray_env_as_string
 
 
 class SimulatorArray(SimtelRunner):
@@ -21,60 +19,42 @@ class SimulatorArray(SimtelRunner):
         Instance label.
     use_multipipe: bool
         Use multipipe to run CORSIKA and sim_telarray.
-    sim_telarray_seeds: dict
-        Dictionary with configuration for sim_telarray random instrument setup.
+    is_calibration_run: bool
+        Flag to indicate if this is a calibration run.
     """
 
     def __init__(
         self,
         corsika_config,
         label=None,
-        use_multipipe=False,
-        sim_telarray_seeds=None,
-        calibration_config=None,
+        is_calibration_run=False,
     ):
         """Initialize SimulatorArray."""
-        self._logger = logging.getLogger(__name__)
-        self._logger.debug("Init SimulatorArray")
-        super().__init__(
-            label=label,
-            corsika_config=corsika_config,
-            use_multipipe=use_multipipe,
-            calibration_run_mode=calibration_config.get("run_mode") if calibration_config else None,
-        )
+        super().__init__(label=label, config=corsika_config, is_calibration_run=is_calibration_run)
 
-        self.sim_telarray_seeds = sim_telarray_seeds
         self.corsika_config = corsika_config
-        self.calibration_config = calibration_config
+        self.is_calibration_run = is_calibration_run
         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):
+    def prepare_run(self, run_number=None, sub_script=None, corsika_file=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.
+        corsika_file: str or Path
+            Full path of the input CORSIKA file.
         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}")
+        command = self.make_run_command(run_number=run_number, input_file=corsika_file)
+        sub_script = Path(sub_script)
+        self._logger.debug(f"Run bash script - {sub_script}")
         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:
+        with sub_script.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")
@@ -86,16 +66,12 @@ class SimulatorArray(SimtelRunner):
                     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")
+            for _ in range(self.runs_per_set):
+                file.write(f"{sim_telarray_env_as_string()} " + " ".join(command) + "\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):
+    def make_run_command(self, run_number=None, input_file=None):
         """
         Build and return the command to run sim_telarray.
 
@@ -105,26 +81,22 @@ class SimulatorArray(SimtelRunner):
             Full path of the input CORSIKA file
         run_number: int (optional)
             run number
-        weak_pointing: bool (optional)
-            Specify weak pointing option for sim_telarray.
 
         Returns
         -------
-        str
+        list
             Command to run sim_telarray.
         """
-        command = self._common_run_command(run_number, weak_pointing)
+        self.file_list = self.runner_service.load_files(run_number=run_number)
+        command = self._common_run_command(run_number)
 
-        if self.calibration_config:
+        if self.is_calibration_run:
             command += self._make_run_command_for_calibration_simulations()
         else:
             command += self._make_run_command_for_shower_simulations()
 
         # "-C show=all" should be the last option
-        command += super().get_config_option("show", "all")
-        command += f" {input_file} | gzip > {self._log_file} 2>&1 || exit"
-
-        return clear_default_sim_telarray_cfg_directories(command)
+        return [*command, "-C", "show=all", input_file]
 
     def _make_run_command_for_shower_simulations(self):
         """
@@ -135,80 +107,117 @@ class SimulatorArray(SimtelRunner):
         str
             Command to run sim_telarray.
         """
-        return super().get_config_option(
-            "power_law",
-            SimulatorArray.get_power_law_for_sim_telarray_histograms(
-                self.corsika_config.primary_particle
-            ),
-        )
+        return [
+            "-C",
+            "power_law="
+            f"{
+                SimulatorArray.get_power_law_for_sim_telarray_histograms(
+                    self.corsika_config.primary_particle
+                )
+            }",
+        ]
 
     def _make_run_command_for_calibration_simulations(self):
         """Build sim_telarray command for calibration simulations."""
-        cfg = self.calibration_config
+        cfg = settings.config.args
         altitude = self.corsika_config.array_model.site_model.get_parameter_value_with_unit(
             "reference_point_altitude"
         ).to_value("m")
 
-        command = super().get_config_option("Altitude", altitude)
-
+        options = {"Altitude": altitude}
         for key in ("nsb_scaling_factor", "stars"):
-            if cfg.get(key):
-                command += super().get_config_option(key, cfg[key])
+            if key in cfg:
+                options[key] = cfg[key]
 
         run_mode = cfg.get("run_mode")
         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)
+            options["pedestal_events"] = n_events
         if run_mode == "pedestals_nsb_only":
-            command += self._pedestals_nsb_only_command()
+            options.update(self._pedestals_nsb_only_options())
         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)
+            options["dark_events"] = n_events
         if run_mode == "direct_injection":
             n_events = cfg.get("number_of_flasher_events", cfg["number_of_events"])
-            command += super().get_config_option("laser_events", n_events)
+            options["laser_events"] = n_events
 
-        return command
+        cmd = []
+        for key, value in options.items():
+            cmd.extend(["-C", f"{key}={value}"])
+        return cmd
 
-    def _common_run_command(self, run_number, weak_pointing=None):
+    def _common_run_command(self, run_number):
         """Build generic run command for sim_telarray."""
+        weak_pointing = self._determine_pointing_option()
         config_dir = self.corsika_config.array_model.get_config_directory()
-        self._log_file = self.get_file_name(file_type="log", run_number=run_number)
-        histogram_file = self.get_file_name(file_type="histogram", run_number=run_number)
-        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(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(
-            "telescope_theta", self.corsika_config.zenith_angle, weak_pointing
+        self._log_file = self.runner_service.get_file_name(
+            file_type="sim_telarray_log", run_number=run_number
         )
-        command += super().get_config_option(
-            "telescope_phi", self.corsika_config.azimuth_angle, weak_pointing
+        histogram_file = self.runner_service.get_file_name(
+            file_type="sim_telarray_histogram", run_number=run_number
         )
-        command += super().get_config_option("histogram_file", histogram_file)
-        command += super().get_config_option("random_state", "none")
-        if self.sim_telarray_seeds and self.sim_telarray_seeds.get("random_instrument_instances"):
-            command += super().get_config_option(
-                "random_seed",
-                f"file-by-run:{config_dir}/{self.sim_telarray_seeds['seed_file_name']},auto",
-            )
-        elif self.sim_telarray_seeds and self.sim_telarray_seeds.get("seed"):
-            command += super().get_config_option("random_seed", self.sim_telarray_seeds["seed"])
-        command += super().get_config_option("output_file", output_file)
-
-        return command
-
-    def _pedestals_nsb_only_command(self):
+        output_file = self.runner_service.get_file_name(
+            file_type="sim_telarray_output", run_number=run_number
+        )
+        self.corsika_config.array_model.export_all_simtel_config_files()
+
+        cmd = [
+            str(settings.config.sim_telarray_exe),
+            "-c",
+            str(self.corsika_config.array_model.config_file_path),
+            f"-I{config_dir}",
+        ]
+        weak_options = {
+            "telescope_theta": self.corsika_config.zenith_angle,
+            "telescope_phi": self.corsika_config.azimuth_angle,
+        }
+        options = {
+            "histogram_file": histogram_file,
+            "random_state": "none",
+            "output_file": output_file,
+        }
+
+        try:
+            options["random_seed"] = self.corsika_config.array_model.sim_telarray_seed.seed_string
+        except AttributeError as exc:
+            raise AttributeError("Error setting sim_telarray seed string") from exc
+
+        for key, value in options.items():
+            cmd.extend(["-C", f"{key}={value}"])
+        for key, value in weak_options.items():
+            cmd.extend([("-W" if weak_pointing else "-C"), f"{key}={value}"])
+        return cmd
+
+    def _determine_pointing_option(self):
         """
-        Generate the command to run sim_telarray for nsb-only pedestal simulations.
+        Determine the pointing option for sim_telarray.
+
+        Parameters
+        ----------
+        label: str
+            Label of the simulation.
 
         Returns
         -------
-        str
+        bool:
+            True if weak pointing is to be used.
+        """
+        if isinstance(self.label, str):
+            return any(pointing in self.label for pointing in ["divergent", "convergent"])
+        return False
+
+    def _pedestals_nsb_only_options(self):
+        """
+        Generate options to run sim_telarray for nsb-only pedestal simulations.
+
+        Returns
+        -------
+        dict
             Command to run sim_telarray.
         """
+        options = {}
+
         null_values = [
             "fadc_noise",
             "fadc_lg_noise",
@@ -219,8 +228,8 @@ class SimulatorArray(SimtelRunner):
             "fadc_sysvar_pedestal",
             "fadc_dev_pedestal",
         ]
-        null_command_parts = [super().get_config_option(param, 0.0) for param in null_values]
-        command = " ".join(null_command_parts)
+        for param in null_values:
+            options[param] = 0.0
 
         one_values = [
             "fadc_lg_var_pedestal",
@@ -228,9 +237,10 @@ class SimulatorArray(SimtelRunner):
             "fadc_lg_dev_pedestal",
             "fadc_lg_sysvar_pedestal",
         ]
-        one_command_parts = [super().get_config_option(param, -1.0) for param in one_values]
-        command += " " + " ".join(one_command_parts)
-        return command
+        for param in one_values:
+            options[param] = -1.0
+
+        return options
 
     def _check_run_result(self, run_number=None):
         """
@@ -248,12 +258,14 @@ class SimulatorArray(SimtelRunner):
 
         Raises
         ------
-        InvalidOutputFileError
+        FileNotFoundError
             If sim_telarray output file does not exist.
         """
-        output_file = self.get_file_name(file_type="simtel_output", run_number=run_number)
+        output_file = self.runner_service.get_file_name(
+            file_type="simtel_output", run_number=run_number
+        )
         if not output_file.exists():
-            raise InvalidOutputFileError(f"sim_telarray output file {output_file} does not exist.")
+            raise FileNotFoundError(f"sim_telarray output file {output_file} does not exist.")
         self._logger.debug(f"sim_telarray output file {output_file} exists.")
         return True
 

simtools/simtel/simulator_camera_efficiency.py

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