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

simtools/simtel/simtel_io_metadata.py

@@ -1,11 +1,18 @@
 #!/usr/bin/python3
 """Read metadata from sim_telarray files."""
 
+import logging
+import re
 from functools import cache
 
 from eventio import EventIOFile
+from eventio.iact import InputCard
 from eventio.simtel import HistoryMeta
 
+from simtools.utils import names
+
+_logger = logging.getLogger(__name__)
+
 
 @cache
 def read_sim_telarray_metadata(file, encoding="utf8"):
@@ -28,10 +35,6 @@ def read_sim_telarray_metadata(file, encoding="utf8"):
     telescope_meta: dict
         Dictionary of telescope metadata, keyed by telescope ID.
     """
-
-    def decode(meta):
-        return {k.decode(encoding): v.decode(encoding) for k, v in meta.items()}
-
     global_meta = None
     telescope_meta = {}
 
@@ -45,7 +48,7 @@ def read_sim_telarray_metadata(file, encoding="utf8"):
                     break
                 continue
 
-            meta = decode(o.parse())
+            meta = _decode_dictionary(o.parse(), encoding=encoding)
             if o.header.id == -1:
                 global_meta = meta
             else:
@@ -57,9 +60,28 @@ def read_sim_telarray_metadata(file, encoding="utf8"):
         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()
-    }
+    try:
+        return clean_meta(global_meta), {
+            tel_id: clean_meta(meta) for tel_id, meta in telescope_meta.items()
+        }
+    except AttributeError as e:
+        raise AttributeError(f"Error reading metadata from file {file}: {e}") from e
+
+
+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):
@@ -89,3 +111,92 @@ def get_sim_telarray_telescope_id(telescope_name, file):
             telescope_name_to_sim_telarray_id[telescope_name] = tel_id
 
     return telescope_name_to_sim_telarray_id.get(telescope_name, None)
+
+
+def get_sim_telarray_telescope_id_to_telescope_name_mapping(file):
+    """
+    Return a mapping of telescope IDs to telescope names from a sim_telarray file.
+
+    Parameters
+    ----------
+    file: str
+        Path to the sim_telarray file.
+
+    Returns
+    -------
+    dict
+        Dictionary mapping telescope IDs to telescope names.
+    """
+    _, telescope_meta = read_sim_telarray_metadata(file)
+    telescope_map = {}
+    for i, (tel_id, meta) in enumerate(telescope_meta.items()):
+        try:
+            telescope_name = names.validate_array_element_name(
+                meta.get("optics_config_name", f"Unknown-{tel_id}")
+            )
+        except ValueError:
+            telescope_name = _guess_telescope_name_for_legacy_files(i, file)
+        if telescope_name is not None:
+            telescope_map[tel_id] = telescope_name
+
+    return telescope_map
+
+
+def _guess_telescope_name_for_legacy_files(tel_counter, file):
+    """
+    Guess telescope names for legacy prod6 sim_telarray files with incomplete metadata.
+
+    Parameters
+    ----------
+    tel_counter: int
+        Telescope counter, used to index into the telescope list.
+    file: str, Path
+        Path to the sim_telarray file.
+
+    Returns
+    -------
+    str, None
+        Guessed telescope name or None if not found.
+    """
+    telescope_list = _get_telescope_list_from_input_card(file)
+    try:
+        return names.validate_array_element_name(telescope_list[tel_counter])
+    except (IndexError, ValueError):
+        pass
+    return None
+
+
+@cache
+def _get_telescope_list_from_input_card(file):
+    r"""
+    Return telescope list from CORSIKA input card.
+
+    Note hardwired regex pattern with telescope naming convention.
+    This function is intended for legacy files generated for prod6,
+    where metadata is incomplete.
+
+    Expected format in input card:
+
+    .. code-block:: console
+        TELESCOPE    -70.91E2     -52.35E2 45.00E2  12.50E2  # (ID=1)  LSTN   01   2B5\n
+
+    Parameters
+    ----------
+    file: str, Path
+        Path to the sim_telarray file.
+
+    Returns
+    -------
+    list
+        List of telescope names as found in CORSIKA input card.
+    """
+    with EventIOFile(file) as f:
+        for o in f:
+            if isinstance(o, InputCard):
+                input_card = o.parse().decode("utf-8")
+                regex = (
+                    r"TELESCOPE\s+[-\d.E]+\s+[-\d.E]+\s+[-\d.E]+\s+[-\d.E]+\s+"
+                    r"# \(ID=\d+\)\s+(LST[N|S]|MST[N|S]|S[S|C]TS)\s+([^\s]+)"
+                )
+                return [f"{m[0]}-{m[1]}" for m in re.findall(regex, input_card)]
+    return []

simtools/simtel/simulator_array.py

@@ -71,7 +71,7 @@ class SimulatorArray(SimtelRunner):
         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()
 
         command = str(self._simtel_path.joinpath("sim_telarray/bin/sim_telarray"))
@@ -124,7 +124,7 @@ 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)

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,