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

simtools/simtel/simtel_seeds.py

@@ -0,0 +1,184 @@
+"""Seeds for sim_telarray simulations."""
+
+import logging
+from pathlib import Path
+
+from simtools import settings
+from simtools.constants import SIMTEL_MAX_SEED
+from simtools.io import ascii_handler
+from simtools.utils import names, random
+from simtools.version import semver_to_int
+
+
+class SimtelSeeds:
+    """Manage seeds for sim_telarray simulations."""
+
+    def __init__(
+        self, output_path=None, site=None, model_version=None, zenith_angle=None, azimuth_angle=None
+    ):
+        """
+        Initialize seeds for sim_telarray simulations.
+
+        Two seeds are set for sim_telarray simulations:
+
+            - Instrument seed: used to randomize the instrument setup
+            - Simulation seed: used for the shower simulation
+
+        Parameters
+        ----------
+        output_path : str or Path or None
+            Output path for the seed file.
+        site : str or None
+            Site name.
+        model_version : str or None
+            Model version.
+        zenith_angle : float or None
+            Zenith angle.
+        azimuth_angle : float or None
+            Azimuth angle.
+        """
+        self._logger = logging.getLogger(__name__)
+
+        self.instrument_seed = settings.config.args.get("sim_telarray_instrument_seed", None)
+        self.instruments = settings.config.args.get(
+            "sim_telarray_random_instrument_instances", None
+        )
+        self.simulation_seed = settings.config.args.get("sim_telarray_seed", None)
+        self.seed_file = settings.config.args.get("sim_telarray_seed_file", None)
+        if output_path is not None:
+            self.seed_file = Path(output_path) / self.seed_file
+
+        self.seed_string = self.initialize_seeds(site, model_version, zenith_angle, azimuth_angle)
+
+    def initialize_seeds(self, site, model_version, zenith_angle, azimuth_angle):
+        """Initialize seeds based on provided parameters."""
+        if isinstance(self.simulation_seed, list):
+            return self._set_fixed_seeds()
+
+        if not self.simulation_seed:
+            self.simulation_seed = random.seeds(max_seed=SIMTEL_MAX_SEED)
+
+        if not self.instruments or self.instruments <= 1:
+            return self._generate_seed_pair()
+
+        return self._generate_seeds_with_file(site, model_version, zenith_angle, azimuth_angle)
+
+    def _set_fixed_seeds(self):
+        """
+        Set fixed seeds to be using for testing purposes only.
+
+        Fixes both instrument and simulation seeds.
+        """
+        try:
+            seed_string = f"{self.simulation_seed[0]},{self.simulation_seed[1]}"
+        except IndexError as exc:
+            raise IndexError(
+                "Two seeds must be provided for testing purposes: "
+                "first for instrument, second for shower simulation."
+            ) from exc
+        self._logger.warning(f"Using fixed test seeds: {seed_string}")
+        return seed_string
+
+    def _generate_seed_pair(self):
+        """Generate seed string."""
+        if not self.instrument_seed:
+            self.instrument_seed = random.seeds(max_seed=SIMTEL_MAX_SEED)
+
+        self._logger.info(
+            f"Generated sim_telarray seeds - Instrument: {self.instrument_seed}, "
+            f"Shower simulation: {self.simulation_seed}"
+        )
+        return f"{self.instrument_seed},{self.simulation_seed}"
+
+    def _generate_seeds_with_file(self, site, model_version, zenith_angle, azimuth_angle):
+        """Generate a seed file for the instrument seeds and return the seed string."""
+        self.instrument_seed = self._get_instrument_seed(
+            site, model_version, zenith_angle, azimuth_angle
+        )
+
+        self._logger.info(
+            f"Writing random instrument seed file {self.seed_file}"
+            f" (instrument seed {self.instrument_seed})"
+        )
+        if self.instruments > 1024:
+            raise ValueError("Number of random instances of instrument must be less than 1024")
+        random_integers = random.seeds(
+            n_seeds=self.instruments,
+            max_seed=SIMTEL_MAX_SEED,
+            fixed_seed=self.instrument_seed,
+        )
+        with open(self.seed_file, "w", encoding="utf-8") as file:
+            file.write(
+                "# Random seeds for instrument configuration generated with seed "
+                f"{self.instrument_seed} (model version {model_version}, site {site})\n"
+                f"# Zenith angle: {zenith_angle}, Azimuth angle: {azimuth_angle}\n"
+            )
+            for number in random_integers:
+                file.write(f"{number}\n")
+
+        return f"file-by-run:{self.seed_file},{self.simulation_seed}"
+
+    def _get_instrument_seed(self, site, model_version, zenith_angle, azimuth_angle):
+        """
+        Get configuration dependent instrument seed.
+
+        Three different scenarios are possible:
+
+            - instrument seed provided through configuration: use it
+            - site, model_version, zenith_angle, azimuth_angle provided:
+              generate a seed based on these parameters
+            - none of the above: generate a random seed
+
+        Parameters
+        ----------
+        site : str or None
+            Site name.
+        model_version : str or None
+            Model version.
+        zenith_angle : float or None
+            Zenith angle.
+        azimuth_angle : float or None
+            Azimuth angle.
+
+        Returns
+        -------
+        int
+            Instrument seed.
+        """
+        # Use the instrument seed from the configuration if provided
+        if self.instrument_seed:
+            return self.instrument_seed
+
+        # Generate a seed based on site, model_version, zenith_angle, and azimuth_angle
+        if model_version and zenith_angle is not None and azimuth_angle is not None:
+            try:
+                key_index = next(
+                    i + 1
+                    for i, (_, values) in enumerate(names.site_names().items())
+                    if site.lower() in values
+                )
+            except StopIteration as exc:
+                raise ValueError(f"Unknown site: {site!r}") from exc
+
+            seed = semver_to_int(model_version) * 10000000
+            seed = seed + key_index * 1000000
+            seed = seed + int(zenith_angle) * 1000
+            return seed + int(azimuth_angle)
+
+        # Generate a random instrument seed
+        return random.seeds(max_seed=SIMTEL_MAX_SEED)
+
+    def save_seeds(self, path):
+        """
+        Save the seeds to a file.
+
+        Parameters
+        ----------
+        path : str or Path
+            Path to the seed file.
+        """
+        seed_dict = {
+            "instrument_seed": self.instrument_seed,
+            "simulation_seed": self.simulation_seed,
+        }
+        ascii_handler.write_data_to_file(path, seed_dict)

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,11 +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):
@@ -16,68 +15,46 @@ 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
         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,
-        simtel_path,
         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,
-            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,
-        )
+        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")
@@ -89,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.
 
@@ -108,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):
         """
@@ -138,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(self._simtel_path.joinpath("sim_telarray/bin/sim_telarray"))
-        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",
@@ -222,10 +228,8 @@ 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))
-        command = " ".join(null_command_parts)
+            options[param] = 0.0
 
         one_values = [
             "fadc_lg_var_pedestal",
@@ -233,11 +237,10 @@ 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))
-        command += " " + " ".join(one_command_parts)
-        return command
+            options[param] = -1.0
+
+        return options
 
     def _check_run_result(self, run_number=None):
         """
@@ -255,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