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

simtools/runners/corsika_simtel_runner.py

@@ -2,11 +2,10 @@
 
 import logging
 import stat
-from pathlib import Path
 
 import simtools.utils.general as gen
 from simtools import settings
-from simtools.runners.corsika_runner import CorsikaRunner
+from simtools.runners import corsika_runner, runner_services, simtel_runner
 from simtools.simtel.simulator_array import SimulatorArray
 
 
@@ -24,42 +23,38 @@ class CorsikaSimtelRunner:
         contain the CORSIKA configuration parameters.
     label : str
         Label.
-    keep_seeds : bool
-        Use seeds based on run number and primary particle. If False, use sim_telarray seeds.
     use_multipipe : bool
         Use multipipe to run CORSIKA and sim_telarray.
-    sim_telarray_seeds : dict
         Dictionary with configuration for sim_telarray random instrument setup.
-    calibration_config : dict
-        Configuration for the calibration of the sim_telarray data.
+    is_calibration_run : bool
+        Flag to indicate if this is a calibration run.
     """
 
     def __init__(
         self,
         corsika_config,
         label=None,
-        keep_seeds=False,
-        use_multipipe=False,
-        sim_telarray_seeds=None,
         sequential=False,
-        calibration_config=None,
         curved_atmosphere_min_zenith_angle=None,
+        is_calibration_run=False,
     ):
         self._logger = logging.getLogger(__name__)
         self.corsika_config = gen.ensure_iterable(corsika_config)
         # the base corsika config is the one used to define the CORSIKA specific parameters.
         # The others are used for the array configurations.
         self.base_corsika_config = self.corsika_config[0]
-        self.sim_telarray_seeds = sim_telarray_seeds
         self.label = label
         self.sequential = "--sequential" if sequential else ""
 
-        self.base_corsika_config.set_output_file_and_directory(use_multipipe)
-        self.corsika_runner = CorsikaRunner(
+        self.runner_service = runner_services.RunnerServices(
+            self.base_corsika_config, run_type="multi_pipe", label=label
+        )
+        self.file_list = None
+
+        self.corsika_runner = corsika_runner.CorsikaRunner(
             corsika_config=self.base_corsika_config,
             label=label,
-            keep_seeds=keep_seeds,
-            use_multipipe=use_multipipe,
+            use_multipipe=True,
             curved_atmosphere_min_zenith_angle=curved_atmosphere_min_zenith_angle,
         )
         # The simulator array should be defined for every CORSIKA configuration
@@ -70,15 +65,11 @@ class CorsikaSimtelRunner:
                 SimulatorArray(
                     corsika_config=_corsika_config,
                     label=label,
-                    use_multipipe=use_multipipe,
-                    sim_telarray_seeds=sim_telarray_seeds,
-                    calibration_config=calibration_config,
+                    is_calibration_run=is_calibration_run,
                 )
             )
 
-    def prepare_run_script(
-        self, run_number=None, input_file=None, extra_commands=None, use_pfp=False
-    ):
+    def prepare_run(self, run_number=None, sub_script=None, corsika_file=None, extra_commands=None):
         """
         Get the full path of the run script file for a given run number.
 
@@ -86,21 +77,24 @@ class CorsikaSimtelRunner:
         ----------
         run_number: int
             Run number.
-        use_pfp: bool
-            Whether to use the preprocessor in preparing the CORSIKA input file
-
-        Returns
-        -------
-        Path:
-            Full path of the run script file.
+        corsika_file: str or Path
+            Path to the CORSIKA input file.
+        extra_commands: str
+            Additional commands for running simulations.
         """
+        self.file_list = self.runner_service.load_files(run_number=run_number)
         self._export_multipipe_script(run_number)
-        return self.corsika_runner.prepare_run_script(
+        self.corsika_runner.prepare_run(
             run_number=run_number,
-            input_file=input_file,
+            sub_script=sub_script,
+            corsika_file=self.runner_service.get_file_name(
+                file_type="multi_pipe_script", run_number=run_number
+            )
+            if not corsika_file
+            else corsika_file,
             extra_commands=extra_commands,
-            use_pfp=use_pfp,
         )
+        self.update_file_list_from_runners()
 
     def _export_multipipe_script(self, run_number):
         """
@@ -116,44 +110,29 @@ class CorsikaSimtelRunner:
         Path:
             Full path of the run script file.
         """
-        multipipe_file = Path(self.base_corsika_config.config_file_path.parent).joinpath(
-            self.base_corsika_config.get_corsika_config_file_name("multipipe")
+        multipipe_file = self.runner_service.get_file_name(
+            "multi_pipe_config", run_number=run_number
         )
-
         with open(multipipe_file, "w", encoding="utf-8") as file:
             for simulator_array in self.simulator_array:
+                log_file = simulator_array.runner_service.get_file_name(
+                    file_type="sim_telarray_log", run_number=run_number
+                )
                 run_command = simulator_array.make_run_command(
                     run_number=run_number,
-                    input_file="-",  # instruct sim_telarray to take input from standard output
-                    weak_pointing=self._determine_pointing_option(self.label),
+                    input_file="-",  # instruct sim_telarray to take input from stdout
+                )
+                file.write(
+                    f"{simtel_runner.sim_telarray_env_as_string()} "
+                    + " ".join(run_command)
+                    + f" | gzip > {log_file} 2>&1\n"
                 )
-                file.write(f"{run_command}")
                 file.write("\n")
-        self._logger.info(f"Multipipe script: {multipipe_file}")
-        self._write_multipipe_script(multipipe_file)
-
-    @staticmethod
-    def _determine_pointing_option(label):
-        """
-        Determine the pointing option for sim_telarray.
 
-        Parameters
-        ----------
-        label: str
-            Label of the simulation.
-
-        Returns
-        -------
-        str:
-            Pointing option.
-        """
-        try:
-            return any(pointing in label for pointing in ["divergent", "convergent"])
-        except TypeError:  # allow for pointing_option to be None
-            pass
-        return False
+        self._logger.info(f"Multipipe script: {multipipe_file}")
+        self._write_multipipe_script(multipipe_file, run_number)
 
-    def _write_multipipe_script(self, multipipe_file):
+    def _write_multipipe_script(self, multipipe_file, run_number):
         """
         Write script used to call the multipipe_corsika command.
 
@@ -161,9 +140,11 @@ class CorsikaSimtelRunner:
         ----------
         multipipe_file: str or Path
             The name of the multipipe file which contains all of the multipipe commands.
+        run_number: int
+            Run number.
         """
-        multipipe_script = Path(self.base_corsika_config.config_file_path.parent).joinpath(
-            "run_cta_multipipe"
+        multipipe_script = self.runner_service.get_file_name(
+            "multi_pipe_script", run_number=run_number
         )
         with open(multipipe_script, "w", encoding="utf-8") as file:
             multipipe_command = settings.config.sim_telarray_path.joinpath(
@@ -174,48 +155,41 @@ class CorsikaSimtelRunner:
 
         multipipe_script.chmod(multipipe_script.stat().st_mode | stat.S_IEXEC)
 
-    def get_file_name(
-        self,
-        simulation_software=None,
-        file_type=None,
-        run_number=None,
-        mode=None,
-        model_version_index=0,
-    ):
+    def get_resources(self, run_number=None):
+        """Return computing resources used."""
+        return self.corsika_runner.get_resources(run_number)
+
+    def update_file_list_from_runners(self):
         """
-        Get the full path of a file for a given run number.
+        Get list of generated files (independent of type).
+
+        Includes file lists from all runners.
 
         Parameters
         ----------
-        simulation_software: str
-            Simulation software.
-        file_type: str
-            File type.
-        run_number: int
-            Run number.
-        mode: str
-            Mode to use for the file name.
-        model_version_index: int
-            Index of the model version.
-            This is used to select the correct simulator_array instance
-            in case multiple array models are simulated.
+        file_type : str
+            File type to be listed.
 
         Returns
         -------
-        str
-            File name with full path.
-        """
-        if simulation_software is None:
-            # preference to sim_telarray output (multipipe)
-            simulation_software = "sim_telarray" if self.simulator_array else "corsika"
-
-        runner = (
-            self.corsika_runner
-            if simulation_software == "corsika"
-            else self.simulator_array[model_version_index]
-        )
-        return runner.get_file_name(file_type=file_type, run_number=run_number, mode=mode)
+        list
+            List with the full path of all output files.
 
-    def get_resources(self, run_number=None):
-        """Return computing resources used."""
-        return self.corsika_runner.get_resources(run_number)
+        """
+        if self.file_list is None:
+            self.file_list = self.corsika_runner.file_list
+        else:
+            self.file_list.update(self.corsika_runner.file_list)
+
+        for simulator_array in self.simulator_array:
+            _tmp_list = simulator_array.file_list
+            for key, data in _tmp_list.items():
+                if key in self.file_list:
+                    # in case of multiple sim_telarray instances, make list of files
+                    if not isinstance(self.file_list[key], list):
+                        self.file_list[key] = [self.file_list[key]]
+                    self.file_list[key].append(data)
+                else:
+                    self.file_list[key] = [data]
+
+        return self.file_list