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

simtools/simtel/simtel_io_histograms.py

@@ -24,7 +24,7 @@ __all__ = [
 
 class SimtelIOHistograms:
     """
-    Read the content of either multiple histogram (.hdata, or .hdata.zst) or simtel_array files.
+    Read the content of either multiple histogram (.hdata, or .hdata.zst) or sim_telarray files.
 
     Allow both the .hdata.zst histogram and the .simtel.zst output file type.
     It uses the SimtelIOHistogram class to deal with individual files.
@@ -159,7 +159,7 @@ class SimtelIOHistograms:
         if sim_hist is None or trig_hist is None:
             msg = (
                 "Simulated and triggered histograms were not found in the stacked histograms."
-                " Please check your simtel_array files!"
+                " Please check your sim_telarray files!"
             )
             self._logger.error(msg)
             raise HistogramIdNotFoundError

simtools/simtel/simtel_io_metadata.py

@@ -0,0 +1,106 @@
+#!/usr/bin/python3
+"""Read metadata from sim_telarray files."""
+
+import logging
+from functools import cache
+
+from eventio import EventIOFile
+from eventio.simtel import HistoryMeta
+
+_logger = logging.getLogger(__name__)
+
+
+@cache
+def read_sim_telarray_metadata(file, encoding="utf8"):
+    """
+    Return global and per-telescope metadata from sim_telarray file.
+
+    Cached to avoid re-reading the file multiple times.
+
+    Parameters
+    ----------
+    file: str
+        Path to the sim_telarray file.
+    encoding: str
+        Encoding to use for decoding metadata. Default is 'utf8'.
+
+    Returns
+    -------
+    global_meta: dict
+        Global metadata dictionary.
+    telescope_meta: dict
+        Dictionary of telescope metadata, keyed by telescope ID.
+    """
+    global_meta = None
+    telescope_meta = {}
+
+    with EventIOFile(file) as f:
+        found_meta = False
+        for o in f:
+            if isinstance(o, HistoryMeta):
+                found_meta = True
+            else:
+                if found_meta:
+                    break
+                continue
+
+            meta = _decode_dictionary(o.parse(), encoding=encoding)
+            if o.header.id == -1:
+                global_meta = meta
+            else:
+                telescope_meta[o.header.id] = meta
+
+    def clean_meta(meta):
+        """Clean metadata dictionary."""
+        meta = {k.lower().lstrip("*"): v for k, v in meta.items()}
+        return {k: v.strip() if isinstance(v, str) else v for k, v in meta.items()}
+
+    # keys to lower case and strip leading '*', trailing spaces
+    return clean_meta(global_meta), {
+        tel_id: clean_meta(meta) for tel_id, meta in telescope_meta.items()
+    }
+
+
+def _decode_dictionary(meta, encoding="utf8"):
+    """Decode metadata dictionary."""
+
+    def safe_decode(byte_str, encoding, errors="ignore"):
+        return byte_str.decode(encoding, errors=errors)
+
+    try:
+        return {k.decode(encoding, errors="ignore"): v.decode(encoding) for k, v in meta.items()}
+    except UnicodeDecodeError as e:
+        _logger.warning(
+            f"Failed to decode metadata with encoding {encoding}: {e}. "
+            "Falling back to 'utf-8' with errors='ignore'."
+        )
+        return {safe_decode(k, encoding): safe_decode(v, encoding) for k, v in meta.items()}
+
+
+def get_sim_telarray_telescope_id(telescope_name, file):
+    """
+    Return the telescope ID for a given telescope name in a sim_telarray file.
+
+    Translates e.g. 'LSTN-01' to the corresponding telescope ID.
+
+    Parameters
+    ----------
+    telescope_name: str
+        Name of the telescope.
+    file: str
+        Path to the sim_telarray file.
+
+    Returns
+    -------
+    int, None
+        Telescope ID. Returns None if not found.
+    """
+    _, telescope_meta = read_sim_telarray_metadata(file)
+    telescope_name_to_sim_telarray_id = {}
+    for tel_id in telescope_meta.keys():
+        _optics_name = telescope_meta[tel_id].get("optics_config_name", None)
+        _camera_name = telescope_meta[tel_id].get("camera_config_name", None)
+        if _optics_name == _camera_name and _optics_name == telescope_name:
+            telescope_name_to_sim_telarray_id[telescope_name] = tel_id
+
+    return telescope_name_to_sim_telarray_id.get(telescope_name, None)

simtools/simtel/simulator_array.py

@@ -23,6 +23,8 @@ class SimulatorArray(SimtelRunner):
         Instance label.
     use_multipipe: bool
         Use multipipe to run CORSIKA and sim_telarray.
+    sim_telarray_seeds: dict
+        Dictionary with configuration for sim_telarray random instrument setup.
     """
 
     def __init__(
@@ -48,9 +50,9 @@ class SimulatorArray(SimtelRunner):
         self.io_handler = io_handler.IOHandler()
         self._log_file = None
 
-    def _make_run_command(self, run_number=None, input_file=None):
+    def make_run_command(self, run_number=None, input_file=None, weak_pointing=None):
         """
-        Build and return the command to run simtel_array.
+        Build and return the command to run sim_telarray.
 
         Parameters
         ----------
@@ -58,22 +60,29 @@ 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
             Command to run sim_telarray.
         """
+        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="output", 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()
 
-        # Array
         command = str(self._simtel_path.joinpath("sim_telarray/bin/sim_telarray"))
-        command += f" -c {self.corsika_config.array_model.get_config_file()}"
-        command += f" -I{self.corsika_config.array_model.get_config_directory()}"
-        command += super().get_config_option("telescope_theta", self.corsika_config.zenith_angle)
-        command += super().get_config_option("telescope_phi", self.corsika_config.azimuth_angle)
+        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
+        )
+        command += super().get_config_option(
+            "telescope_phi", self.corsika_config.azimuth_angle, weak_pointing
+        )
         command += super().get_config_option(
             "power_law",
             SimulatorArray.get_power_law_for_sim_telarray_histograms(
@@ -81,13 +90,18 @@ class SimulatorArray(SimtelRunner):
             ),
         )
         command += super().get_config_option("histogram_file", histogram_file)
-        command += super().get_config_option("output_file", output_file)
         command += super().get_config_option("random_state", "none")
-        if self.sim_telarray_seeds:
-            command += super().get_config_option("random_seed", self.sim_telarray_seeds)
+        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("show", "all")
+        command += super().get_config_option("output_file", output_file)
         command += f" {input_file}"
-        command += f" > {self._log_file} 2>&1 || exit"
+        command += f" | gzip > {self._log_file} 2>&1 || exit"
 
         return clear_default_sim_telarray_cfg_directories(command)
 
@@ -110,12 +124,12 @@ class SimulatorArray(SimtelRunner):
         InvalidOutputFileError
             If simtel output file does not exist.
         """
-        output_file = self.get_file_name(file_type="output", run_number=run_number)
+        output_file = self.get_file_name(file_type="simtel_output", run_number=run_number)
         if not output_file.exists():
             msg = f"sim_telarray output file {output_file} does not exist."
             self._logger.error(msg)
             raise InvalidOutputFileError(msg)
-        self._logger.debug(f"simtel_array output file {output_file} exists.")
+        self._logger.debug(f"sim_telarray output file {output_file} exists.")
         return True
 
     @staticmethod

simtools/simtel/simulator_camera_efficiency.py

@@ -16,8 +16,10 @@ class SimulatorCameraEfficiency(SimtelRunner):
 
     Parameters
     ----------
-    telescope_model: str
+    telescope_model: TelescopeModel
         Instance of TelescopeModel class.
+    site_model: SiteModel
+        Instance of SiteModel class.
     label: str
         Instance label. Important for output file naming.
     simtel_path: str or Path
@@ -28,11 +30,14 @@ class SimulatorCameraEfficiency(SimtelRunner):
         Zenith angle given in the config to CameraEfficiency.
     nsb_spectrum: str or Path
         Path to the nsb spectrum file.
+    skip_correction_to_nsb_spectrum: bool
+        If True, skip the correction to the original altitude where the NSB spectrum was derived.
     """
 
     def __init__(
         self,
         telescope_model,
+        site_model,
         label=None,
         simtel_path=None,
         file_simtel=None,
@@ -48,6 +53,7 @@ class SimulatorCameraEfficiency(SimtelRunner):
         super().__init__(label=label, simtel_path=simtel_path)
 
         self._telescope_model = telescope_model
+        self._site_model = site_model
         self.label = label if label is not None else self._telescope_model.label
 
         self._file_simtel = file_simtel
@@ -68,8 +74,8 @@ class SimulatorCameraEfficiency(SimtelRunner):
             self._nsb_spectrum = self._validate_or_fix_nsb_spectrum_file_format(nsb_spectrum)
         else:
             self._nsb_spectrum = (
-                self._telescope_model.config_file_directory
-                / Path(self._telescope_model.get_parameter_value("nsb_reference_spectrum")).name
+                self._site_model.config_file_directory
+                / Path(self._site_model.get_parameter_value("nsb_reference_spectrum")).name
             )
 
     def _make_run_command(self, run_number=None, input_file=None):  # pylint: disable=unused-argument
@@ -127,8 +133,8 @@ class SimulatorCameraEfficiency(SimtelRunner):
         if self.nsb_spectrum is not None:
             command += f" -fnsb {self.nsb_spectrum}"
         command += " -nm -nsb-extra"
-        command += f" -alt {self._telescope_model.get_parameter_value('corsika_observation_level')}"
-        command += f" -fatm {self._telescope_model.get_parameter_value('atmospheric_transmission')}"
+        command += f" -alt {self._site_model.get_parameter_value('corsika_observation_level')}"
+        command += f" -fatm {self._site_model.get_parameter_value('atmospheric_transmission')}"
         command += f" -flen {focal_length}"
         command += f" {pixel_shape_cmd} {pixel_diameter}"
         if mirror_class == 0:
@@ -152,7 +158,7 @@ class SimulatorCameraEfficiency(SimtelRunner):
         command += f" -fqe {self._telescope_model.get_parameter_value('quantum_efficiency')}"
         command += " 200 1000"  # lmin and lmax
         command += " 300"  # Xmax
-        command += f" {self._telescope_model.get_parameter_value('atmospheric_profile')}"
+        command += f" {self._site_model.get_parameter_value('atmospheric_profile')}"
         command += f" {self.zenith_angle}"
 
         # Remove the default sim_telarray configuration directories

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,15 +57,16 @@ 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
         self.light_emission_config = light_emission_config
         self.distance = None
         self.light_source_type = light_source_type
-        self._telescope_model.export_config_file()
-        self.test = test
+        self._telescope_model.write_sim_telarray_config_file(additional_model=site_model)
 
     @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"
@@ -244,12 +283,12 @@ class SimulatorLightEmission(SimtelRunner):
 
     def _make_simtel_script(self):
         """
-        Return the command to run simtel_array using the output from the previous step.
+        Return the command to run sim_telarray using the output from the previous step.
 
         Returns
         -------
         str
-            The command to run simtel_array
+            The command to run sim_telarray
         """
         # LightEmission
         _, angles = self.calibration_pointing_direction()
@@ -257,19 +296,17 @@ class SimulatorLightEmission(SimtelRunner):
         command = f"{self._simtel_path.joinpath('sim_telarray/bin/sim_telarray/')}"
         command += " -I"
         command += f" -I{self._telescope_model.config_file_directory}"
-        command += f" -c {self._telescope_model.get_config_file(no_export=True)}"
-        if not self.test:
-            self._remove_line_from_config(
-                self._telescope_model.get_config_file(no_export=True), "array_triggers"
-            )
-            self._remove_line_from_config(
-                self._telescope_model.get_config_file(no_export=True), "axes_offsets"
-            )
+        command += f" -c {self._telescope_model.config_file_path}"
+        self._remove_line_from_config(self._telescope_model.config_file_path, "array_triggers")
+        self._remove_line_from_config(self._telescope_model.config_file_path, "axes_offsets")
 
         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",
@@ -531,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

@@ -25,6 +25,8 @@ class SimulatorRayTracing(SimtelRunner):
     ----------
     telescope_model: TelescopeModel
         telescope model
+    site_model: SiteModel
+        site model
     label: str
         label used for output file naming.
     simtel_path: str or Path
@@ -41,6 +43,7 @@ class SimulatorRayTracing(SimtelRunner):
     def __init__(
         self,
         telescope_model,
+        site_model,
         label=None,
         simtel_path=None,
         config_data=None,
@@ -54,10 +57,11 @@ class SimulatorRayTracing(SimtelRunner):
         super().__init__(label=label, simtel_path=simtel_path)
 
         self.telescope_model = telescope_model
+        self.site_model = site_model
         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)
@@ -89,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,
@@ -115,7 +119,7 @@ class SimulatorRayTracing(SimtelRunner):
                 file.write(f"#{50 * '='}\n")
                 file.write("# List of photons for RayTracing simulations\n")
                 file.write(f"#{50 * '='}\n")
-                file.write(f"# config_file = {self.telescope_model.get_config_file()}\n")
+                file.write(f"# config_file = {self.telescope_model.config_file_path}\n")
                 file.write(f"# zenith_angle [deg] = {self.config.zenith_angle}\n")
                 file.write(f"# off_axis_angle [deg] = {self.config.off_axis_angle}\n")
                 file.write(f"# source_distance [km] = {self.config.source_distance}\n")
@@ -137,7 +141,13 @@ class SimulatorRayTracing(SimtelRunner):
             self._write_out_single_pixel_camera_file()
 
     def _make_run_command(self, run_number=None, input_file=None):  # pylint: disable=unused-argument
-        """Generate simtel_array run command."""
+        """
+        Generate sim_telarray run command. Export sim_telarray configuration file(s).
+
+        The run_number and input_file parameters are not relevant for the ray tracing simulation.
+        """
+        self.telescope_model.write_sim_telarray_config_file(additional_model=self.site_model)
+
         if self.config.single_mirror_mode:
             # Note: no mirror length defined for dual-mirror telescopes
             _mirror_focal_length = float(
@@ -146,13 +156,13 @@ class SimulatorRayTracing(SimtelRunner):
 
         # RayTracing
         command = str(self._simtel_path.joinpath("sim_telarray/bin/sim_telarray"))
-        command += f" -c {self.telescope_model.get_config_file()}"
+        command += f" -c {self.telescope_model.config_file_path}"
         command += f" -I{self.telescope_model.config_file_directory}"
         command += super().get_config_option("random_state", "none")
         command += super().get_config_option("IMAGING_LIST", str(self._photons_file))
         command += super().get_config_option("stars", str(self._stars_file))
         command += super().get_config_option(
-            "altitude", self.telescope_model.get_parameter_value("corsika_observation_level")
+            "altitude", self.site_model.get_parameter_value("corsika_observation_level")
         )
         command += super().get_config_option(
             "telescope_theta",