gammasimtools 0.6.1__py3-none-any.whl → 0.8.2__py3-none-any.whl

simtools/simulator.py

@@ -1,277 +1,160 @@
+"""Simulator class for managing simulations of showers and array of telescopes."""
+
 import logging
 import re
 from collections import defaultdict
-from copy import copy
 from pathlib import Path
 
-import astropy.units as u
 import numpy as np
 
 import simtools.utils.general as gen
-from simtools.corsika.corsika_runner import CorsikaRunner
-from simtools.corsika_simtel.corsika_simtel_runner import CorsikaSimtelRunner
+from simtools.corsika.corsika_config import CorsikaConfig
 from simtools.io_operations import io_handler
 from simtools.job_execution.job_manager import JobManager
 from simtools.model.array_model import ArrayModel
-from simtools.simtel.simtel_runner_array import SimtelRunnerArray
-from simtools.utils import names
+from simtools.runners.corsika_runner import CorsikaRunner
+from simtools.runners.corsika_simtel_runner import CorsikaSimtelRunner
+from simtools.simtel.simulator_array import SimulatorArray
 
 __all__ = [
+    "InvalidRunsToSimulateError",
     "Simulator",
-    "InvalidRunsToSimulate",
 ]
 
 
-class InvalidRunsToSimulate(Exception):
+class InvalidRunsToSimulateError(Exception):
     """Exception for invalid runs to simulate."""
 
 
 class Simulator:
     """
-    Simulator is responsible for managing simulation of showers and array of telescopes. \
-    It interfaces with simulation software-specific packages, like CORSIKA or sim_telarray.
-
-    The configuration is set as a dict config_data or a yaml \
-    file config_file.
-
-    Example of config_data for shower simulations:
-
-    .. code-block:: python
-
-        config_data = {
-            'data_directory': '.',
-            'site': 'South',
-            'layout_name': 'Prod5',
-            'run_range': [1, 100],
-            'nshow': 10,
-            'primary': 'gamma',
-            'erange': [100 * u.GeV, 1 * u.TeV],
-            'eslope': -2,
-            'zenith': 20 * u.deg,
-            'azimuth': 0 * u.deg,
-            'viewcone': 0 * u.deg,
-            'cscat': [10, 1500 * u.m, 0]
-        }
+    Simulator is managing the simulation of showers and of the array of telescopes.
 
-    Example of config_data for array simulations:
-
-    .. code-block:: python
-
-        config_data = {
-            'data_directory': '(..)/data',
-            'primary': 'gamma',
-            'zenith': 20 * u.deg,
-            'azimuth': 0 * u.deg,
-            'viewcone': 0 * u.deg,
-            # ArrayModel
-            'site': 'North',
-            'layout_name': '1LST',
-            'model_version': 'Prod5',
-            'default': {
-                'LST': '1'
-            },
-            'MST-01': 'FlashCam-D'
-        }
+    It interfaces with simulation software packages (e.g., CORSIKA or sim_telarray).
+
+    The configuration is set as a dict corresponding to the command line configuration groups
+    (especially simulation_software, simulation_model, simulation_parameters).
 
     Parameters
     ----------
-    simulator: choices: [simtel, corsika]
-        implemented are sim_telarray and CORSIKA
-    simulator_source_path: str or Path
-        Location of executables for simulation software \
-            (e.g. path with CORSIKA or sim_telarray)
+    args_dict : dict
+        Configuration dictionary
+        (includes simulation_software, simulation_model, simulation_parameters groups).
     label: str
         Instance label.
-    config_data: dict
-        Dict with shower or array model configuration data.
-    config_file: str or Path
-        Path to yaml file containing configurable data.
-    submit_command: str
-        Job submission command.
     extra_commands: str or list of str
-        Extra commands to be added to the run script before the run command,
+        Extra commands to be added to the run script before the run command.
     mongo_db_config: dict
         MongoDB configuration.
-    test: bool
-        If True, no jobs are submitted; only run scripts are prepared
     """
 
     def __init__(
         self,
-        simulator,
-        simulator_source_path,
+        args_dict,
         label=None,
-        config_data=None,
-        config_file=None,
-        submit_command=None,
         extra_commands=None,
         mongo_db_config=None,
-        test=False,
     ):
-        """
-        Initialize Simulator class.
-        """
+        """Initialize Simulator class."""
         self._logger = logging.getLogger(__name__)
-        self._logger.debug(f"Init Simulator {simulator}")
+        self.args_dict = args_dict
 
+        self.simulation_software = self.args_dict["simulation_software"]
+        self._logger.debug(f"Init Simulator {self.simulation_software}")
         self.label = label
-        self.simulator = simulator
-        self.runs = []
-        self._results = defaultdict(list)
-        self.test = test
-
-        self._corsika_config_data = None
-        self.site = None
-        self.layout_name = None
-        self._corsika_parameters_file = None
-        self.config = None
-        self.array_model = None
-        self._simulation_runner = None
 
         self.io_handler = io_handler.IOHandler()
-        self._output_directory = self.io_handler.get_output_directory(self.label, self.simulator)
-        self._simulator_source_path = Path(simulator_source_path)
-        self._submit_command = submit_command
-        self._extra_commands = extra_commands
-        self._mongo_db_config = mongo_db_config
 
-        self._load_configuration_and_simulation_model(config_data, config_file)
+        self.runs = self._initialize_run_list()
+        self._results = defaultdict(list)
+        self._test = self.args_dict.get("test", False)
+        self._submit_engine = self.args_dict.get("submit_engine", "local")
+        self._submit_options = self.args_dict.get("submit_options", None)
+        self._extra_commands = extra_commands
 
-        self._set_simulation_runner()
+        self.array_model = self._initialize_array_model(mongo_db_config)
+        self._simulation_runner = self._initialize_simulation_runner(mongo_db_config)
 
     @property
-    def simulator(self):
-        """The attribute simulator"""
-        return self._simulator
+    def simulation_software(self):
+        """The attribute simulation_software."""
+        return self._simulation_software
 
-    @simulator.setter
-    def simulator(self, simulator):
+    @simulation_software.setter
+    def simulation_software(self, simulation_software):
         """
-        Set and test simulator type
+        Set and test simulation_software type.
 
         Parameters
         ----------
-        simulator: choices: [simtel, corsika, corsika_simtel]
+        simulation_software: choices: [simtel, corsika, corsika_simtel]
             implemented are sim_telarray and CORSIKA or corsika_simtel
             (running CORSIKA and piping it directly to sim_telarray)
 
         Raises
         ------
-        gen.InvalidConfigData
-
-        """
-
-        if simulator not in ["simtel", "corsika", "corsika_simtel"]:
-            raise gen.InvalidConfigData
-        self._simulator = simulator.lower()
-
-    def _load_configuration_and_simulation_model(self, config_data=None, config_file=None):
-        """
-        Load configuration data and initialize simulation models.
-
-        Parameters
-        ----------
-        config_data: dict
-            Dict with simulator configuration data.
-        config_file: str or Path
-            Path to yaml file containing configurable data.
-
-        """
-        simulator_config_data = gen.collect_data_from_file_or_dict(config_file, config_data)
-        if self.simulator == "corsika":
-            self._load_corsika_config_and_model(simulator_config_data)
-        if self.simulator == "simtel":
-            self._load_sim_tel_config_and_model(simulator_config_data)
-        if self.simulator == "corsika_simtel":
-            config_showers, config_arrays = self._separate_corsika_and_simtel_config_data(
-                simulator_config_data
-            )
-            self._load_corsika_config_and_model(config_showers)
-            self._load_sim_tel_config_and_model(config_arrays)
+        gen.InvalidConfigDataError
 
-    def _load_corsika_config_and_model(self, config_data):
         """
-        Validate configuration data for CORSIKA shower simulation and
-        remove entries needed for CorsikaRunner.
+        if simulation_software not in ["simtel", "corsika", "corsika_simtel"]:
+            self._logger.error(f"Invalid simulation software: {simulation_software}")
+            raise gen.InvalidConfigDataError
+        self._simulation_software = simulation_software.lower()
 
-        Parameters
-        ----------
-        config_data: dict
-            Dict with simulator configuration data.
-
-        """
-
-        self._corsika_config_data = copy(config_data)
-
-        try:
-            self.site = names.validate_site_name(self._corsika_config_data.pop("site"))
-            self.layout_name = names.validate_array_layout_name(
-                self._corsika_config_data.pop("layout_name")
-            )
-        except KeyError:
-            self._logger.error("Missing parameter in simulation configuration data")
-            raise
-
-        self.runs = self._validate_run_list_and_range(
-            self._corsika_config_data.pop("run_list", None),
-            self._corsika_config_data.pop("run_range", None),
-        )
-
-        self._corsika_parameters_file = self._corsika_config_data.pop(
-            "corsika_parameters_file", None
-        )
-
-    def _load_sim_tel_config_and_model(self, config_data):
+    def _initialize_array_model(self, mongo_db_config):
         """
-        Load array model and configuration parameters for array simulations
+        Initialize array simulation model.
 
         Parameters
         ----------
-        config_data: dict
-            Dict with simulator configuration data.
+        mongo_db_config: dict
+            Database configuration.
 
+        Returns
+        -------
+        ArrayModel
+            ArrayModel object.
         """
-        _array_model_config, _rest_config = self._collect_array_model_parameters(config_data)
-
-        _parameter_file = self.io_handler.get_input_data_file(
-            "parameters", "array-simulator_parameters.yml"
-        )
-        _parameters = gen.collect_data_from_file_or_dict(_parameter_file, None)
-        self.config = gen.validate_config_data(_rest_config, _parameters, ignore_unidentified=True)
-
-        self.array_model = ArrayModel(
+        return ArrayModel(
             label=self.label,
-            array_config_data=_array_model_config,
-            mongo_db_config=self._mongo_db_config,
+            site=self.args_dict.get("site"),
+            layout_name=self.args_dict.get("array_layout_name"),
+            mongo_db_config=mongo_db_config,
+            model_version=self.args_dict.get("model_version", None),
         )
 
-    def _separate_corsika_and_simtel_config_data(self, config_data):
+    def _initialize_run_list(self):
         """
-        Separate the CORSIKA and sim_telarray simulation configuration to two dictionaries.
-
-        Parameters
-        ----------
-        config_data: dict
-            Dictionary with both the CORSIKA and sim_telarray simulation configuration data.
+        Initialize run list using the configuration values 'run_number_start' and 'number_of_runs'.
 
         Returns
         -------
-        dict
-            Configuration of shower simulations.
-        dict
-            Configuration of array simulations.
+        list
+            List of run numbers.
 
+        Raises
+        ------
+        KeyError
+            If 'run_number_start' or 'number_of_runs' are not found in the configuration.
         """
-
-        common = copy(config_data.pop("common", {}))
-        config_showers = copy(config_data.pop("showers", {})) | common
-        config_arrays = copy(config_data.pop("array", {})) | common
-
-        return config_showers, config_arrays
+        try:
+            return self._validate_run_list_and_range(
+                run_list=None,
+                run_range=[
+                    self.args_dict["run_number_start"],
+                    self.args_dict["run_number_start"] + self.args_dict["number_of_runs"],
+                ],
+            )
+        except KeyError as exc:
+            self._logger.error(
+                "Error in initializing run list (missing 'run_number_start' or 'number_of_runs')"
+            )
+            raise exc
 
     def _validate_run_list_and_range(self, run_list, run_range):
         """
-        Prepares list of run numbers from a list or from a range.
+        Prepare list of run numbers from a list or from a range.
+
         If both arguments are given, they will be merged into a single list.
 
         Attributes
@@ -298,118 +181,72 @@ class Simulator:
             if not all(isinstance(r, int) for r in run_list):
                 msg = "run_list must contain only integers."
                 self._logger.error(msg)
-                raise InvalidRunsToSimulate
-
-            self._logger.debug(f"run_list: {run_list}")
+                raise InvalidRunsToSimulateError
             validated_runs = list(run_list)
 
         if run_range is not None:
             if not all(isinstance(r, int) for r in run_range) or len(run_range) != 2:
                 msg = "run_range must contain two integers only."
                 self._logger.error(msg)
-                raise InvalidRunsToSimulate
+                raise InvalidRunsToSimulateError
 
-            run_range = np.arange(run_range[0], run_range[1] + 1)
+            run_range = np.arange(run_range[0], run_range[1])
             self._logger.debug(f"run_range: {run_range}")
             validated_runs.extend(list(run_range))
 
         validated_runs_unique = sorted(set(validated_runs))
+        self._logger.info(f"run_list: {validated_runs_unique}")
         return list(validated_runs_unique)
 
-    def _collect_array_model_parameters(self, config_data):
+    def _initialize_simulation_runner(self, db_config):
         """
-        Separate configuration and model parameters from configuration data.
+        Initialize corsika configuration and simulation runners.
 
         Parameters
         ----------
-        config_data: dict
-            Dict with configuration data.
+        db_config: dict
+            Database configuration.
 
+        Returns
+        -------
+        CorsikaRunner or SimulatorArray or CorsikaSimtelRunner
+            Simulation runner object.
         """
-        _array_model_data = {}
-        _rest_data = copy(config_data)
-
-        try:
-            _array_model_data["site"] = names.validate_site_name(_rest_data.pop("site"))
-            _array_model_data["layout_name"] = names.validate_array_layout_name(
-                _rest_data.pop("layout_name")
-            )
-            _array_model_data["model_version"] = _rest_data.pop("model_version")
-            _array_model_data["default"] = _rest_data.pop("default")
-        except KeyError:
-            self._logger.error("Missing parameter in simulation configuration data")
-            raise
-
-        # Reading telescope keys
-        tel_keys = [k for k in _rest_data.keys() if k[1:4] in ["ST-", "CT-"]]
-        for key in tel_keys:
-            _array_model_data[key] = _rest_data.pop(key)
+        corsika_config = CorsikaConfig(
+            array_model=self.array_model,
+            label=self.label,
+            args_dict=self.args_dict,
+            db_config=db_config,
+        )
 
-        return _array_model_data, _rest_data
+        runner_class = {
+            "corsika": CorsikaRunner,
+            "simtel": SimulatorArray,
+            "corsika_simtel": CorsikaSimtelRunner,
+        }.get(self.simulation_software)
 
-    def _set_simulation_runner(self):
-        """
-        Set simulation runners
-
-        """
-        common_args = {
+        runner_args = {
             "label": self.label,
-            "simtel_source_path": self._simulator_source_path,
+            "corsika_config": corsika_config,
+            "simtel_path": self.args_dict.get("simtel_path"),
+            "use_multipipe": runner_class is CorsikaSimtelRunner,
         }
-        corsika_args = {
-            "mongo_db_config": self._mongo_db_config,
-            "site": self.site,
-            "layout_name": self.layout_name,
-            "corsika_parameters_file": self._corsika_parameters_file,
-            "corsika_config_data": self._corsika_config_data,
-        }
-        if self.simulator in ["simtel", "corsika_simtel"]:
-            simtel_args = {
-                "array_model": self.array_model,
-                "config_data": {
-                    "simtel_data_directory": self.config.data_directory,
-                    "primary": self.config.primary,
-                    "zenith_angle": self.config.zenith_angle * u.deg,
-                    "azimuth_angle": self.config.azimuth_angle * u.deg,
-                },
-            }
-        if self.simulator == "corsika":
-            self._set_corsika_runner(common_args | corsika_args)
-        if self.simulator == "simtel":
-            self._set_simtel_runner(common_args | simtel_args)
-        if self.simulator == "corsika_simtel":
-            self._set_corsika_simtel_runner(common_args, corsika_args, simtel_args)
-
-    def _set_corsika_runner(self, simulator_args):
-        """
-        Creating CorsikaRunner.
-
-        """
-        self._simulation_runner = CorsikaRunner(**simulator_args)
 
-    def _set_simtel_runner(self, simulator_args):
-        """
-        Creating a SimtelRunnerArray.
-
-        """
-        self._simulation_runner = SimtelRunnerArray(**simulator_args)
-
-    def _set_corsika_simtel_runner(self, common_args, corsika_args, simtel_args):
-        """
-        Creating CorsikaRunner.
+        if runner_class is not SimulatorArray:
+            runner_args["keep_seeds"] = self.args_dict.get("corsika_test_seeds", False)
+        if runner_class is not CorsikaRunner:
+            runner_args["sim_telarray_seeds"] = self.args_dict.get("sim_telarray_seeds")
 
-        """
-        self._simulation_runner = CorsikaSimtelRunner(common_args, corsika_args, simtel_args)
+        return runner_class(**runner_args)
 
     def _fill_results_without_run(self, input_file_list):
         """
-        Fill in the results dict without calling submit.
+        Fill results dict without calling submit (e.g., for testing).
 
         Parameters
         ----------
         input_file_list: str or list of str
             Single file or list of files of shower simulations.
-
         """
         input_file_list = self._enforce_list_type(input_file_list)
 
@@ -427,10 +264,8 @@ class Simulator:
         ----------
         input_file_list: str or list of str
             Single file or list of files of shower simulations.
-
         """
-
-        self._logger.info(f"Submission command: {self._submit_command}")
+        self._logger.info(f"Submission command: {self._submit_engine}")
 
         runs_and_files_to_submit = self._get_runs_and_files_to_submit(
             input_file_list=input_file_list
@@ -440,50 +275,67 @@ class Simulator:
             f"run{'s' if len(runs_and_files_to_submit) > 1 else ''}"
         )
 
-        for run, file in runs_and_files_to_submit.items():
+        for run_number, input_file in runs_and_files_to_submit.items():
             run_script = self._simulation_runner.prepare_run_script(
-                run_number=run, input_file=file, extra_commands=self._extra_commands
+                run_number=run_number, input_file=input_file, extra_commands=self._extra_commands
             )
 
-            job_manager = JobManager(submit_command=self._submit_command, test=self.test)
+            job_manager = JobManager(
+                submit_engine=self._submit_engine,
+                submit_options=self._submit_options,
+                test=self._test,
+            )
             job_manager.submit(
                 run_script=run_script,
                 run_out_file=self._simulation_runner.get_file_name(
-                    file_type="sub_log", **self._simulation_runner.get_info_for_file_name(run)
+                    file_type="sub_log", run_number=run_number
                 ),
                 log_file=self._simulation_runner.get_file_name(
-                    file_type="corsika_autoinputs_log" if self.simulator == "corsika" else "log",
-                    **self._simulation_runner.get_info_for_file_name(run),
+                    file_type=("log"), run_number=run_number
                 ),
             )
 
-            self._fill_results(file, run)
+            self._fill_results(input_file, run_number)
 
-    def file_list(self, input_file_list=None):
+    def _get_runs_and_files_to_submit(self, input_file_list=None):
         """
-        List output files obtained with simulation run
+        Return a dictionary with run numbers and simulation files.
+
+        The latter are expected to be given for the simtel simulator.
 
         Parameters
         ----------
         input_file_list: str or list of str
             Single file or list of files of shower simulations.
 
-        """
+        Returns
+        -------
+        runs_and_files: dict
+            dictionary with run number as key and (if available) simulation
+            file name as value
 
-        runs_and_files_to_submit = self._get_runs_and_files_to_submit(
-            input_file_list=input_file_list
-        )
+        Raises
+        ------
+        ValueError
+            If no runs are to be submitted.
 
-        for run, _ in runs_and_files_to_submit.items():
-            output_file_name = self._simulation_runner.get_file_name(
-                file_type="output", **self._simulation_runner.get_info_for_file_name(run)
-            )
-            print(f"{str(output_file_name)} (file exists: {Path.exists(output_file_name)})")
+        """
+        _runs_and_files = {}
+        self._logger.debug(f"Getting runs and files to submit ({input_file_list})")
+
+        if self.simulation_software == "simtel":
+            input_file_list = self._enforce_list_type(input_file_list)
+            _runs_and_files = {self._guess_run_from_file(file): file for file in input_file_list}
+        elif self.simulation_software in ["corsika", "corsika_simtel"]:
+            _runs_and_files = {run: None for run in self._get_runs_to_simulate()}
+        if len(_runs_and_files) == 0:
+            raise ValueError("No runs to submit.")
+        return _runs_and_files
 
-    def _get_runs_and_files_to_submit(self, input_file_list=None):
+    @staticmethod
+    def _enforce_list_type(input_file_list):
         """
-        Return a dictionary with run numbers and (if applicable) simulation
-        files. The latter are expected to be given for the simtel simulator.
+        Enforce the input list to be a list.
 
         Parameters
         ----------
@@ -492,91 +344,75 @@ class Simulator:
 
         Returns
         -------
-        runs_and_files: dict
-            dictionary with runnumber as key and (if availble) simulation
-            file name as value
-
+        list
+            List of input files.
         """
-
-        _runs_and_files = {}
-
-        if self.simulator == "simtel":
-            _file_list = self._enforce_list_type(input_file_list)
-            for file in _file_list:
-                _runs_and_files[self._guess_run_from_file(file)] = file
-        if self.simulator in ["corsika", "corsika_simtel"]:
-            _run_list = self._get_runs_to_simulate()
-            for run in _run_list:
-                _runs_and_files[run] = None
-
-        return _runs_and_files
-
-    @staticmethod
-    def _enforce_list_type(input_file_list):
-        """Enforce the input list to be a list."""
         if not input_file_list:
             return []
-        if not isinstance(input_file_list, list):
-            return [input_file_list]
-
-        return input_file_list
+        return input_file_list if isinstance(input_file_list, list) else [input_file_list]
 
     def _guess_run_from_file(self, file):
         """
-        Finds the run number for a given input file name.
+        Extract the run number from the given file name.
+
         Input file names can follow any pattern with the
         string 'run' followed by the run number.
-        If not found, returns 1.
 
         Parameters
         ----------
         file: Path
             Simulation file name
 
+        Returns
+        -------
+        int
+            The extracted run number. If extraction fails, returns 1 and logs a warning.
         """
         file_name = str(Path(file).name)
 
         try:
-            run_str = re.search("run[0-9]*", file_name).group()
+            run_str = re.search(r"run\d*", file_name).group()
             return int(run_str[3:])
         except (ValueError, AttributeError):
-            msg = f"Run number could not be guessed from {file_name} using run = 1"
-            self._logger.warning(msg)
+            self._logger.warning(f"Run number could not be guessed from {file_name} using run = 1")
             return 1
 
-    def _fill_results(self, file, run):
+    def _fill_results(self, file, run_number):
         """
-        Fill the results dict with input, output and log files.
+        Fill the results dict with input, output, hist, and log files.
 
         Parameters
         ----------
         file: str
             input file name
-        run: int
+        run_number: int
             run number
 
         """
-
-        info_for_file_name = self._simulation_runner.get_info_for_file_name(run)
         self._results["output"].append(
-            str(self._simulation_runner.get_file_name(file_type="output", **info_for_file_name))
+            str(self._simulation_runner.get_file_name(file_type="output", run_number=run_number))
         )
         self._results["sub_out"].append(
             str(
                 self._simulation_runner.get_file_name(
-                    file_type="sub_log", **info_for_file_name, mode="out"
+                    file_type="sub_log", run_number=run_number, mode="out"
                 )
             )
         )
-        if self.simulator in ["simtel", "corsika_simtel"]:
+
+        if self.simulation_software in ["simtel", "corsika_simtel"]:
             self._results["log"].append(
-                str(self._simulation_runner.get_file_name(file_type="log", **info_for_file_name))
+                str(
+                    self._simulation_runner.get_file_name(
+                        simulation_software="simtel", file_type="log", run_number=run_number
+                    )
+                )
             )
             self._results["input"].append(str(file))
             self._results["hist"].append(
                 str(
                     self._simulation_runner.get_file_name(
-                        file_type="histogram", **info_for_file_name
+                        simulation_software="simtel", file_type="histogram", run_number=run_number
                     )
                 )
             )
@@ -584,7 +420,7 @@ class Simulator:
             self._results["corsika_autoinputs_log"].append(
                 str(
                     self._simulation_runner.get_file_name(
-                        file_type="corsika_autoinputs_log", **info_for_file_name
+                        simulation_software="corsika", file_type="log", run_number=run_number
                     )
                 )
             )
@@ -592,101 +428,47 @@ class Simulator:
             self._results["hist"].append(None)
             self._results["log"].append(None)
 
-    def get_list_of_output_files(self, run_list=None, run_range=None):
+    def get_file_list(self, file_type="output"):
         """
-        Get list of output files.
+        Get list of files generated by simulations.
+
+        Options are "input", "output", "hist", "log".
+        Not all file types are available for all simulation types.
+        Returns an empty list for an unknown file type.
 
         Parameters
         ----------
-        run_list: list
-            List of run numbers.
-        run_range: list
-            List of len 2 with the limits of the range of the run numbers.
+        file_type : str
+            File type to be listed.
 
         Returns
         -------
         list
-            List with the full path of all the output files.
-
-        """
-        self._logger.info("Getting list of output files")
-
-        if run_list or run_range or len(self._results["output"]) == 0:
-            runs_to_list = self._get_runs_to_simulate(run_list=run_list, run_range=run_range)
-
-            for run in runs_to_list:
-                output_file_name = self._simulation_runner.get_file_name(
-                    file_type="output", **self._simulation_runner.get_info_for_file_name(run)
-                )
-                self._results["output"].append(str(output_file_name))
-        return self._results["output"]
+            List with the full path of all output files.
 
-    def get_list_of_histogram_files(self):
         """
-        Get list of histogram files.
-        (not applicable to all simulation types)
+        self._logger.info(f"Getting list of {file_type} files")
+        return self._results[file_type]
 
-        Returns
-        -------
-        list
-            List with the full path of all the histogram files.
+    def print_list_of_files(self, file_type="output"):
         """
-        self._logger.info("Getting list of histogram files")
-        return self._results["hist"]
+        Print list of output files generated by simulations.
 
-    def get_list_of_input_files(self):
-        """
-        Get list of input files.
+        Options are "input", "output", "hist", "log".
 
-        Returns
-        -------
-        list
-            List with the full path of all the input files.
-        """
-        self._logger.info("Getting list of input files")
-        return self._results["input"]
+        Parameters
+        ----------
+        file_type : str
+            File type to be listed.
 
-    def get_list_of_log_files(self):
         """
-        Get list of log files.
-
-        Returns
-        -------
-        list
-            List with the full path of all the log files.
-        """
-        self._logger.info("Getting list of log files")
-        if self.simulator in ["simtel", "corsika_simtel"]:
-            return self._results["log"]
-        return self._results["corsika_autoinputs_log"]
-
-    def print_list_of_output_files(self):
-        """Print list of output files."""
-        self._logger.info("Printing list of output files")
-        self._print_list_of_files(which="output")
-
-    def print_list_of_histogram_files(self):
-        """Print list of histogram files."""
-        self._logger.info("Printing list of histogram files")
-        self._print_list_of_files(which="hist")
-
-    def print_list_of_input_files(self):
-        """Print list of output files."""
-        self._logger.info("Printing list of input files")
-        self._print_list_of_files(which="input")
-
-    def print_list_of_log_files(self):
-        """Print list of log files."""
-        self._logger.info("Printing list of log files")
-        if self.simulator in ["simtel", "corsika_simtel"]:
-            self._print_list_of_files(which="log")
-        else:
-            self._print_list_of_files(which="corsika_autoinputs_log")
+        self._logger.info(f"Printing list of {file_type} files")
+        for file in self._results[file_type]:
+            print(file)
 
     def _make_resources_report(self, input_file_list):
         """
-        Prepare a simple report on computing resources used
-        (includes wall clock time per run only at this point)
+        Prepare a simple report on computing wall clock time used in the simulations.
 
         Parameters
         ----------
@@ -699,10 +481,9 @@ class Simulator:
            Dictionary with reports on computing resources
 
         """
-
         if len(self._results["sub_out"]) == 0:
             if input_file_list is None:
-                return {"Walltime/run [sec]": np.nan}
+                return {"Wall time/run [sec]": np.nan}
             self._fill_results_without_run(input_file_list)
 
         runtime = []
@@ -710,16 +491,16 @@ class Simulator:
         _resources = {}
         for run in self.runs:
             _resources = self._simulation_runner.get_resources(run_number=run)
-            if "runtime" in _resources and _resources["runtime"]:
+            if _resources.get("runtime"):
                 runtime.append(_resources["runtime"])
 
         mean_runtime = np.mean(runtime)
 
         resource_summary = {}
-        resource_summary["Walltime/run [sec]"] = mean_runtime
+        resource_summary["Wall time/run [sec]"] = mean_runtime
         if "n_events" in _resources and _resources["n_events"] > 0:
             resource_summary["#events/run"] = _resources["n_events"]
-            resource_summary["Walltime/1000 events [sec]"] = (
+            resource_summary["Wall time/1000 events [sec]"] = (
                 mean_runtime * 1000 / _resources["n_events"]
             )
 
@@ -727,8 +508,9 @@ class Simulator:
 
     def resources(self, input_file_list=None):
         """
-        Print a simple report on computing resources used
-        (includes run time per run only at this point)
+        Print a simple report on computing resources used.
+
+        Includes run time per run only at this point.
 
         Parameters
         ----------
@@ -738,7 +520,7 @@ class Simulator:
         """
         resources = self._make_resources_report(input_file_list)
         print("-----------------------------")
-        print(f"Computing Resources Report - {self.simulator} Simulations")
+        print(f"Computing Resources Report - {self.simulation_software} Simulations")
         for key, value in resources.items():
             print(f"{key} = {value:.2f}")
         print("-----------------------------")
@@ -761,28 +543,20 @@ class Simulator:
 
         """
         if run_list is None and run_range is None:
-            if self.runs is None:
-                msg = "Runs to simulate were not given as arguments nor in config_data - aborting"
-                self._logger.error(msg)
-                return []
-
-            return self.runs
-
+            return [] if self.runs is None else self.runs
         return self._validate_run_list_and_range(run_list, run_range)
 
-    def _print_list_of_files(self, which):
-        """
-        Print list of files of a certain type
-
-        Parameters
-        ----------
-        which str
-            file type (e.g., log)
-
-        """
-
-        if which not in self._results:
-            self._logger.error(f"Invalid file type {which}")
-            raise KeyError
-        for file in self._results[which]:
-            print(file)
+    def save_file_lists(self):
+        """Save files lists for output and log files."""
+        for file_type in ["output", "log", "hist"]:
+            file_name = self.io_handler.get_output_directory(label=self.label).joinpath(
+                f"{file_type}_files.txt"
+            )
+            file_list = self.get_file_list(file_type=file_type)
+            if all(element is not None for element in file_list) and len(file_list) > 0:
+                self._logger.info(f"Saving list of {file_type} files to {file_name}")
+                with open(file_name, "w", encoding="utf-8") as f:
+                    for line in self.get_file_list(file_type=file_type):
+                        f.write(f"{line}\n")
+            else:
+                self._logger.debug(f"No files to save for {file_type} files.")