gammasimtools 0.16.0__py3-none-any.whl → 0.17.0__py3-none-any.whl

simtools/simtel/simulator_light_emission.py

@@ -46,6 +46,7 @@ class SimulatorLightEmission(SimtelRunner):
         self._telescope_model = telescope_model
 
         self.label = label if label is not None else self._telescope_model.label
+        self.test = test
 
         self._calibration_model = calibration_model
         self._site_model = site_model
@@ -56,7 +57,9 @@ class SimulatorLightEmission(SimtelRunner):
         self._rep_number = 0
         self.runs = 1
         self.photons_per_run = (
-            self._calibration_model.get_parameter_value("photons_per_run") if not test else 1e7
+            (self._calibration_model.get_parameter_value("photons_per_run"))
+            if not self.test
+            else 1e8
         )
 
         self.le_application = le_application
@@ -64,7 +67,6 @@ class SimulatorLightEmission(SimtelRunner):
         self.distance = None
         self.light_source_type = light_source_type
         self._telescope_model.write_sim_telarray_config_file(additional_model=site_model)
-        self.test = test
 
     @staticmethod
     def light_emission_default_configuration():
@@ -119,14 +121,15 @@ class SimulatorLightEmission(SimtelRunner):
         list
             The pointing vector from the calibration device to the telescope.
         """
-        # use DB coordinates later
-        x_cal, y_cal, z_cal = self._calibration_model.get_parameter_value(
+        x_cal, y_cal, z_cal = self._calibration_model.get_parameter_value_with_unit(
             "array_element_position_ground"
         )
+        x_cal, y_cal, z_cal = [coord.to(u.m).value for coord in (x_cal, y_cal, z_cal)]
         cal_vect = np.array([x_cal, y_cal, z_cal])
-        x_tel, y_tel, z_tel = self._telescope_model.get_parameter_value(
+        x_tel, y_tel, z_tel = self._telescope_model.get_parameter_value_with_unit(
             "array_element_position_ground"
         )
+        x_tel, y_tel, z_tel = [coord.to(u.m).value for coord in (x_tel, y_tel, z_tel)]
 
         tel_vect = np.array([x_tel, y_tel, z_tel])
 
@@ -153,6 +156,30 @@ class SimulatorLightEmission(SimtelRunner):
         )
         return pointing_vector.tolist(), [tel_theta, tel_phi, laser_theta, laser_phi]
 
+    def _write_telpos_file(self):
+        """
+        Write the telescope positions to a telpos file.
+
+        The file will contain lines in the format: x y z r in cm
+
+        Returns
+        -------
+        Path
+            The path to the generated telpos file.
+        """
+        telpos_file = self.output_directory.joinpath("telpos.dat")
+        x_tel, y_tel, z_tel = self._telescope_model.get_parameter_value_with_unit(
+            "array_element_position_ground"
+        )
+        x_tel, y_tel, z_tel = [coord.to(u.cm).value for coord in (x_tel, y_tel, z_tel)]
+
+        radius = self._telescope_model.get_parameter_value_with_unit("telescope_sphere_radius")
+        radius = radius.to(u.cm).value  # Convert radius to cm
+        with telpos_file.open("w", encoding="utf-8") as file:
+            file.write(f"{x_tel} {y_tel} {z_tel} {radius}\n")
+
+        return telpos_file
+
     def _make_light_emission_script(self):
         """
         Create the light emission script to run the light emission package.
@@ -165,17 +192,28 @@ class SimulatorLightEmission(SimtelRunner):
         str
             The commands to run the Light Emission package
         """
-        x_cal, y_cal, z_cal = (
-            self._calibration_model.get_parameter_value("array_element_position_ground") * u.m
+        x_cal, y_cal, z_cal = self._calibration_model.get_parameter_value_with_unit(
+            "array_element_position_ground"
+        )
+        x_tel, y_tel, z_tel = self._telescope_model.get_parameter_value_with_unit(
+            "array_element_position_ground"
         )
-        x_tel, y_tel, z_tel = (
-            self._telescope_model.get_parameter_value("array_element_position_ground") * u.m
+
+        config_directory = self.io_handler.get_output_directory(
+            label=self.label, sub_dir=f"model/{self._site_model.model_version}"
         )
-        _model_directory = self.io_handler.get_output_directory(self.label, "model")
-        command = f" rm {self.output_directory}/"
+
+        telpos_file = self._write_telpos_file()
+
+        command = f"rm {self.output_directory}/"
         command += f"{self.le_application[0]}_{self.le_application[1]}.simtel.gz\n"
         command += str(self._simtel_path.joinpath("sim_telarray/LightEmission/"))
         command += f"/{self.le_application[0]}"
+        corsika_observation_level = self._site_model.get_parameter_value_with_unit(
+            "corsika_observation_level"
+        )
+        command += f" -h  {corsika_observation_level.to(u.m).value}"
+        command += f" --telpos-file {telpos_file}"
 
         if self.light_source_type == "led":
             if self.le_application[1] == "variable":
@@ -188,28 +226,27 @@ class SimulatorLightEmission(SimtelRunner):
                 command += f" -n {self.photons_per_run}"
 
             elif self.le_application[1] == "layout":
-                x_origin = x_cal - x_tel
-                y_origin = y_cal - y_tel
-                z_origin = z_cal - z_tel
-                # light_source coordinates relative to telescope
-                command += f" -x {x_origin.to(u.cm).value}"
-                command += f" -y {y_origin.to(u.cm).value}"
-                command += f" -z {z_origin.to(u.cm).value}"
+                command += f" -x {x_cal.to(u.cm).value}"
+                command += f" -y {y_cal.to(u.cm).value}"
+                command += f" -z {z_cal.to(u.cm).value}"
                 pointing_vector = self.calibration_pointing_direction()[0]
                 command += f" -d {','.join(map(str, pointing_vector))}"
 
                 command += f" -n {self.photons_per_run}"
+                self._logger.info(f"Photons per run: {self.photons_per_run} ")
 
-                # same wavelength as for laser
-                command += f" -s {self._calibration_model.get_parameter_value('laser_wavelength')}"
+                laser_wavelength = self._calibration_model.get_parameter_value_with_unit(
+                    "laser_wavelength"
+                )
+                command += f" -s {int(laser_wavelength.to(u.nm).value)}"
 
-                # pulse
-                command += (
-                    f" -p Gauss:{self._calibration_model.get_parameter_value('led_pulse_sigtime')}"
+                led_pulse_sigtime = self._calibration_model.get_parameter_value_with_unit(
+                    "led_pulse_sigtime"
                 )
-                command += " -a isotropic"  # angular distribution
+                command += f" -p Gauss:{led_pulse_sigtime.to(u.ns).value}"
+                command += " -a isotropic"
 
-            command += f" -A {_model_directory}/"
+            command += f" -A {config_directory}/"
             command += f"{self._telescope_model.get_parameter_value('atmospheric_profile')}"
 
         elif self.light_source_type == "laser":
@@ -217,11 +254,13 @@ class SimulatorLightEmission(SimtelRunner):
             command += " --bunches 2500000"
             command += " --step 0.1"
             command += " --bunchsize 1"
-            command += (
-                f" --spectrum {self._calibration_model.get_parameter_value('laser_wavelength')}"
-            )
+            spectrum = self._calibration_model.get_parameter_value_with_unit("laser_wavelength")
+            command += f" --spectrum {int(spectrum.to(u.nm).value)}"
             command += " --lightpulse Gauss:"
-            command += f"{self._calibration_model.get_parameter_value('laser_pulse_sigtime')}"
+            pulse_sigtime = self._calibration_model.get_parameter_value_with_unit(
+                "laser_pulse_sigtime"
+            )
+            command += f"{pulse_sigtime.to(u.ns).value}"
             x_origin = x_cal - x_tel
             y_origin = y_cal - y_tel
             z_origin = z_cal - z_tel
@@ -234,8 +273,8 @@ class SimulatorLightEmission(SimtelRunner):
             command += f" --telescope-theta {angle_theta}"
             command += f" --telescope-phi {angle_phi}"
             command += f" --laser-theta {90 - angles[2]}"
-            command += f" --laser-phi {angles[3]}"  # convention north (x) towards east (-y)
-            command += f" --atmosphere {_model_directory}/"
+            command += f" --laser-phi {angles[3]}"
+            command += f" --atmosphere {config_directory}/"
             command += f"{self._telescope_model.get_parameter_value('atmospheric_profile')}"
         command += f" -o {self.output_directory}/{self.le_application[0]}.iact.gz"
         command += "\n"
@@ -264,7 +303,10 @@ class SimulatorLightEmission(SimtelRunner):
         command += " -DNUM_TELESCOPES=1"
 
         command += super().get_config_option(
-            "altitude", self._site_model.get_parameter_value("corsika_observation_level")
+            "altitude",
+            self._site_model.get_parameter_value_with_unit("corsika_observation_level")
+            .to(u.m)
+            .value,
         )
         command += super().get_config_option(
             "atmospheric_transmission",
@@ -526,15 +568,18 @@ class SimulatorLightEmission(SimtelRunner):
         """
         if not self.light_emission_config:
             # Layout positions: Use DB coordinates
-            x_cal, y_cal, z_cal = self._calibration_model.get_parameter_value(
+            x_cal, y_cal, z_cal = self._calibration_model.get_parameter_value_with_unit(
                 "array_element_position_ground"
             )
-            x_tel, y_tel, z_tel = self._telescope_model.get_parameter_value(
+            x_cal, y_cal, z_cal = [coord.to(u.m).value for coord in (x_cal, y_cal, z_cal)]
+            x_tel, y_tel, z_tel = self._telescope_model.get_parameter_value_with_unit(
                 "array_element_position_ground"
             )
+            x_tel, y_tel, z_tel = [coord.to(u.m).value for coord in (x_tel, y_tel, z_tel)]
             tel_vect = np.array([x_tel, y_tel, z_tel])
             cal_vect = np.array([x_cal, y_cal, z_cal])
             distance = np.linalg.norm(cal_vect - tel_vect)
+            print("Distance between telescope and calibration device:", distance * u.m)
             return [distance * u.m]
 
         # Variable positions: Calculate distances for all positions

simtools/simtel/simulator_ray_tracing.py

@@ -61,7 +61,7 @@ class SimulatorRayTracing(SimtelRunner):
         self.label = label if label is not None else self.telescope_model.label
 
         self.io_handler = io_handler.IOHandler()
-        self._base_directory = self.io_handler.get_output_directory(self.label, "ray-tracing")
+        self._base_directory = self.io_handler.get_output_directory(self.label, "ray_tracing")
 
         self.config = (
             self._config_to_namedtuple(config_data)
@@ -93,7 +93,7 @@ class SimulatorRayTracing(SimtelRunner):
         # Files will be named _base_file = self.__dict__['_' + base + 'File']
         for base_name in ["stars", "photons", "log"]:
             file_name = names.generate_file_name(
-                file_type=base_name,
+                file_type=f"ray_tracing_{base_name}",
                 suffix=".log" if base_name == "log" else ".lis",
                 site=self.telescope_model.site,
                 telescope_model_name=self.telescope_model.name,

simtools/simulator.py

@@ -12,11 +12,12 @@ import numpy as np
 
 import simtools.utils.general as gen
 from simtools.corsika.corsika_config import CorsikaConfig
-from simtools.io_operations import io_handler
+from simtools.io_operations import io_handler, io_table_handler
 from simtools.job_execution.job_manager import JobManager
 from simtools.model.array_model import ArrayModel
 from simtools.runners.corsika_runner import CorsikaRunner
 from simtools.runners.corsika_simtel_runner import CorsikaSimtelRunner
+from simtools.simtel.simtel_io_event_writer import SimtelIOEventDataWriter
 from simtools.simtel.simulator_array import SimulatorArray
 from simtools.testing.sim_telarray_metadata import assert_sim_telarray_metadata
 
@@ -72,8 +73,6 @@ class Simulator:
         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.sim_telarray_seeds = {
@@ -145,6 +144,7 @@ class Simulator:
                     ],
                     "seed_file_name": self.sim_telarray_seeds["seed_file_name"],
                 },
+                simtel_path=self.args_dict.get("simtel_path", None),
             )
             for version in versions
         ]
@@ -179,7 +179,10 @@ class Simulator:
 
     def _initialize_run_list(self):
         """
-        Initialize run list using the configuration values 'run_number_start' and 'number_of_runs'.
+        Initialize run list using the configuration values.
+
+        Uses 'run_number', 'run_number_offset' and 'number_of_runs' arguments
+        to create a list of run numbers.
 
         Returns
         -------
@@ -189,19 +192,27 @@ class Simulator:
         Raises
         ------
         KeyError
-            If 'run_number_start' or 'number_of_runs' are not found in the configuration.
+            If 'run_number', 'run_number_offset' and 'number_of_runs' are
+            not found in the configuration.
         """
         try:
+            offset_run_number = self.args_dict["run_number_offset"] + self.args_dict["run_number"]
+            if self.args_dict["number_of_runs"] <= 1:
+                return self._validate_run_list_and_range(
+                    run_list=offset_run_number,
+                    run_range=None,
+                )
             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"],
+                    offset_run_number,
+                    offset_run_number + 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')"
+                "Error in initializing run list "
+                "(missing 'run_number', 'run_number_offset' or 'number_of_runs')."
             )
             raise exc
 
@@ -301,6 +312,8 @@ class Simulator:
             runner_args["keep_seeds"] = self.args_dict.get("corsika_test_seeds", False)
         if runner_class is not CorsikaRunner:
             runner_args["sim_telarray_seeds"] = self.sim_telarray_seeds
+        if runner_class is CorsikaSimtelRunner:
+            runner_args["sequential"] = self.args_dict.get("sequential", False)
 
         return runner_class(**runner_args)
 
@@ -330,8 +343,6 @@ 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_engine}")
-
         runs_and_files_to_submit = self._get_runs_and_files_to_submit(
             input_file_list=input_file_list
         )
@@ -345,11 +356,7 @@ class Simulator:
                 run_number=run_number, input_file=input_file, extra_commands=self._extra_commands
             )
 
-            job_manager = JobManager(
-                submit_engine=self.submit_engine,
-                submit_options=self._submit_options,
-                test=self._test,
-            )
+            job_manager = JobManager(test=self._test)
             job_manager.submit(
                 run_script=run_script,
                 run_out_file=self._simulation_runner.get_file_name(
@@ -454,73 +461,66 @@ class Simulator:
             run number
 
         """
-        keys = ["output", "sub_out", "log", "input", "hist", "corsika_log"]
+        keys = ["simtel_output", "sub_out", "log", "input", "hist", "corsika_log", "event_data"]
         results = {key: [] for key in keys}
 
+        def get_file_name(name, **kwargs):
+            return str(self._simulation_runner.get_file_name(file_type=name, **kwargs))
+
         if "sim_telarray" in self.simulation_software:
             results["input"].append(str(file))
 
-        results["sub_out"].append(
-            str(
-                self._simulation_runner.get_file_name(
-                    file_type="sub_log",
-                    mode="out",
-                    run_number=run_number,
-                )
-            )
-        )
+        results["sub_out"].append(get_file_name("sub_log", mode="out", run_number=run_number))
 
-        for model_version_index, _ in enumerate(self.array_models):
-            results["output"].append(
-                str(
-                    self._simulation_runner.get_file_name(
-                        file_type="output",
-                        run_number=run_number,
-                        model_version_index=model_version_index,
-                    )
-                )
+        for i in range(len(self.array_models)):
+            results["simtel_output"].append(
+                get_file_name("simtel_output", run_number=run_number, model_version_index=i)
             )
+
             if "sim_telarray" in self.simulation_software:
                 results["log"].append(
-                    str(
-                        self._simulation_runner.get_file_name(
-                            file_type="log",
-                            simulation_software="sim_telarray",
-                            run_number=run_number,
-                            model_version_index=model_version_index,
-                        )
+                    get_file_name(
+                        "log",
+                        simulation_software="sim_telarray",
+                        run_number=run_number,
+                        model_version_index=i,
                     )
                 )
                 results["hist"].append(
-                    str(
-                        self._simulation_runner.get_file_name(
-                            file_type="histogram",
-                            simulation_software="sim_telarray",
-                            run_number=run_number,
-                            model_version_index=model_version_index,
-                        )
+                    get_file_name(
+                        "histogram",
+                        simulation_software="sim_telarray",
+                        run_number=run_number,
+                        model_version_index=i,
                     )
                 )
+                results["event_data"].append(
+                    get_file_name(
+                        "event_data",
+                        simulation_software="sim_telarray",
+                        run_number=run_number,
+                        model_version_index=i,
+                    )
+                )
+
             if "corsika" in self.simulation_software:
                 results["corsika_log"].append(
-                    str(
-                        self._simulation_runner.get_file_name(
-                            file_type="corsika_log",
-                            simulation_software="corsika",
-                            run_number=run_number,
-                            model_version_index=model_version_index,
-                        )
+                    get_file_name(
+                        "corsika_log",
+                        simulation_software="corsika",
+                        run_number=run_number,
+                        model_version_index=i,
                     )
                 )
 
         for key in keys:
             self._results[key].extend(results[key])
 
-    def get_file_list(self, file_type="output"):
+    def get_file_list(self, file_type="simtel_output"):
         """
         Get list of files generated by simulations.
 
-        Options are "input", "output", "hist", "log", "corsika_log".
+        Options are "input", "simtel_output", "hist", "log", "corsika_log".
         Not all file types are available for all simulation types.
         Returns an empty list for an unknown file type.
 
@@ -538,11 +538,11 @@ class Simulator:
         self._logger.info(f"Getting list of {file_type} files")
         return self._results[file_type]
 
-    def print_list_of_files(self, file_type="output"):
+    def print_list_of_files(self, file_type="simtel_output"):
         """
         Print list of output files generated by simulations.
 
-        Options are "input", "output", "hist", "log".
+        Options are "input", "simtel_output", "hist", "log".
 
         Parameters
         ----------
@@ -636,7 +636,7 @@ class Simulator:
 
     def save_file_lists(self):
         """Save files lists for output and log files."""
-        for file_type in ["output", "log", "corsika_log", "hist"]:
+        for file_type in ["simtel_output", "log", "corsika_log", "hist"]:
             file_name = self.io_handler.get_output_directory(label=self.label).joinpath(
                 f"{file_type}_files.txt"
             )
@@ -649,6 +649,29 @@ class Simulator:
             else:
                 self._logger.debug(f"No files to save for {file_type} files.")
 
+    def save_reduced_event_lists(self):
+        """
+        Save reduced event lists with event data on simulated and triggered events.
+
+        The files are saved with the same name as the sim_telarray output file
+        but with a 'hdf5' extension.
+        """
+        if "sim_telarray" not in self.simulation_software:
+            self._logger.warning(
+                "Reduced event lists can only be saved for sim_telarray simulations."
+            )
+            return
+
+        input_files = self.get_file_list(file_type="simtel_output")
+        output_files = self.get_file_list(file_type="event_data")
+        for input_file, output_file in zip(input_files, output_files):
+            generator = SimtelIOEventDataWriter([input_file])
+            io_table_handler.write_tables(
+                tables=generator.process_files(),
+                output_file=Path(output_file),
+                overwrite_existing=True,
+            )
+
     def pack_for_register(self, directory_for_grid_upload=None):
         """
         Pack simulation output files for registering on the grid.
@@ -664,10 +687,15 @@ class Simulator:
         self._logger.info(
             f"Packing the output files for registering on the grid ({directory_for_grid_upload})"
         )
-        output_files = self.get_file_list(file_type="output")
+        output_files = self.get_file_list(file_type="simtel_output")
         log_files = self.get_file_list(file_type="log")
         corsika_log_files = self.get_file_list(file_type="corsika_log")
         histogram_files = self.get_file_list(file_type="hist")
+        reduced_event_files = (
+            self.get_file_list(file_type="event_data")
+            if self.args_dict.get("save_reduced_event_lists")
+            else []
+        )
 
         directory_for_grid_upload = (
             Path(directory_for_grid_upload)
@@ -697,11 +725,12 @@ class Simulator:
                 tar_file_path = directory_for_grid_upload.joinpath(tar_file_name)
 
                 with tarfile.open(tar_file_path, "w:gz") as tar:
+                    # Add all relevant log, histogram, and CORSIKA log files to the tarball
                     files_to_tar = model_logs + model_hists + model_corsika_logs
                     for file_to_tar in files_to_tar:
                         tar.add(file_to_tar, arcname=Path(file_to_tar).name)
 
-        for file_to_move in output_files:
+        for file_to_move in output_files + reduced_event_files:
             source_file = Path(file_to_move)
             destination_file = directory_for_grid_upload / source_file.name
             if destination_file.exists():
@@ -717,7 +746,7 @@ class Simulator:
             return
 
         for model in self.array_models:
-            files = self.get_file_list(file_type="output")
+            files = self.get_file_list(file_type="simtel_output")
             output_file = next((f for f in files if model.model_version in f), None)
             if output_file:
                 self._logger.info(f"Validating metadata for {output_file}")
@@ -738,7 +767,6 @@ class Simulator:
         ----------
         corsika_log_files: list
             List containing the original CORSIKA log file path.
-
         """
         original_log = Path(corsika_log_files[0])
         # Find which model version the original log belongs to
@@ -759,15 +787,20 @@ class Simulator:
                 original_version, model.model_version
             )
 
-            with gzip.open(new_log, "wt") as new_file:
-                new_file.write(
+            with gzip.open(new_log, "wt", encoding="utf-8") as new_file:
+                # Write the header to the new file
+                header = (
                     f"###############################################################\n"
                     f"Copy of CORSIKA log file from model version {original_version}.\n"
                     f"Applicable also for {model.model_version} (same CORSIKA configuration,\n"
                     f"different sim_telarray model versions in the same run).\n"
                     f"###############################################################\n\n"
                 )
-                with gzip.open(original_log, "rt") as orig_file:
-                    shutil.copyfileobj(orig_file, new_file)
+                new_file.write(header)
+
+                # Copy the content of the original log file, ignoring invalid characters
+                with gzip.open(original_log, "rt", encoding="utf-8", errors="ignore") as orig_file:
+                    for line in orig_file:
+                        new_file.write(line)
 
             corsika_log_files.append(str(new_log))

simtools/testing/validate_output.py

@@ -102,7 +102,10 @@ def _validate_output_path_and_file(config, integration_file_tests):
 
         output_file_path = Path(output_path) / file_test["FILE"]
         _logger.info(f"Checking path: {output_file_path}")
-        assert output_file_path.exists()
+        try:
+            assert output_file_path.exists()
+        except AssertionError as exc:
+            raise AssertionError(f"Output file {output_file_path} does not exist. ") from exc
 
         if "EXPECTED_OUTPUT" in file_test:
             assert assertions.check_output_from_sim_telarray(

simtools/utils/general.py

@@ -178,7 +178,7 @@ def _collect_data_from_different_file_types(file, file_name, suffix, yaml_docume
     """Collect data from different file types."""
     if suffix == ".json":
         return json.load(file)
-    if suffix == ".list":
+    if suffix in (".list", ".txt"):
         return [line.strip() for line in file.readlines()]
     if suffix in [".yml", ".yaml"]:
         return _collect_data_from_yaml_file(file, file_name, yaml_document)

simtools/utils/names.py

@@ -658,7 +658,7 @@ def generate_file_name(
     """
     Generate a file name for output, config, or plotting.
 
-    Used e.g., to generate camera-efficiency and ray-tracing output files.
+    Used e.g., to generate camera_efficiency and ray_tracing output files.
 
     Parameters
     ----------
@@ -690,10 +690,10 @@ def generate_file_name(
     str
         File name.
     """
-    name = f"{file_type}-{site}-{telescope_model_name}"
-    name += f"-d{source_distance:.1f}km" if source_distance is not None else ""
-    name += f"-za{float(zenith_angle):.1f}deg"
-    name += f"-off{off_axis_angle:.3f}deg" if off_axis_angle is not None else ""
+    name = f"{file_type}_{site}_{telescope_model_name}"
+    name += f"_d{source_distance:.1f}km" if source_distance is not None else ""
+    name += f"_za{float(zenith_angle):.1f}deg"
+    name += f"_off{off_axis_angle:.3f}deg" if off_axis_angle is not None else ""
     name += f"_azm{round(azimuth_angle):03}deg" if azimuth_angle is not None else ""
     name += f"_mirror{mirror_number}" if mirror_number is not None else ""
     name += f"_{label}" if label is not None else ""