gammasimtools 0.21.0__py3-none-any.whl → 0.22.0__py3-none-any.whl

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.config = (
             self._config_to_namedtuple(config_data)
@@ -146,7 +146,7 @@ class SimulatorRayTracing(SimtelRunner):
 
         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)
+        self.telescope_model.write_sim_telarray_config_file(additional_models=self.site_model)
 
         if self.config.single_mirror_mode:
             # Note: no mirror length defined for dual-mirror telescopes

simtools/simulator.py

@@ -8,6 +8,7 @@ from collections import defaultdict
 from pathlib import Path
 
 import numpy as np
+from astropy import units as u
 
 import simtools.utils.general as gen
 from simtools.corsika.corsika_config import CorsikaConfig
@@ -68,8 +69,8 @@ class Simulator:
         self.db_config = db_config
 
         self.simulation_software = self.args_dict.get("simulation_software", "corsika_sim_telarray")
-        self.run_mode = self.args_dict.get("run_mode")
         self.logger.debug(f"Init Simulator {self.simulation_software}")
+        self.run_mode = args_dict.get("run_mode", None)
 
         self.io_handler = io_handler.IOHandler()
 
@@ -141,6 +142,9 @@ class Simulator:
                     "seed_file_name": self.sim_telarray_seeds["seed_file_name"],
                 },
                 simtel_path=self.args_dict.get("simtel_path", None),
+                calibration_device_types=self._get_calibration_device_types(
+                    self.args_dict.get("run_mode")
+                ),
             )
             for version in versions
         ]
@@ -166,8 +170,8 @@ class Simulator:
 
         seed = semver_to_int(model_version) * 10000000
         seed = seed + 1000000 if self.args_dict.get("site") != "North" else seed + 2000000
-        seed = seed + (int)(self.args_dict["zenith_angle"].value) * 1000
-        return seed + (int)(self.args_dict["azimuth_angle"].value)
+        seed = seed + (int)(self.args_dict.get("zenith_angle", 0.0 * u.deg).value) * 1000
+        return seed + (int)(self.args_dict.get("azimuth_angle", 0.0 * u.deg).value)
 
     def _initialize_run_list(self):
         """
@@ -257,7 +261,7 @@ class Simulator:
                     label=self.label,
                     args_dict=self.args_dict,
                     db_config=self.db_config,
-                    dummy_simulations=self._is_calibration_run(),
+                    dummy_simulations=self._is_calibration_run(self.run_mode),
                 )
             )
         return (
@@ -296,8 +300,9 @@ class Simulator:
             runner_args["sim_telarray_seeds"] = self.sim_telarray_seeds
         if runner_class is CorsikaSimtelRunner:
             runner_args["sequential"] = self.args_dict.get("sequential", False)
-            if self._is_calibration_run():
-                runner_args["calibration_runner_args"] = self.args_dict
+            runner_args["calibration_config"] = (
+                self.args_dict if self._is_calibration_run(self.run_mode) else None
+            )
 
         return runner_class(**runner_args)
 
@@ -583,9 +588,7 @@ class Simulator:
     def save_file_lists(self):
         """Save files lists for output and log files."""
         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"
-            )
+            file_name = self.io_handler.get_output_directory().joinpath(f"{file_type}_files.txt")
             file_list = self.get_file_list(file_type=file_type)
             if all(element is not None for element in file_list) and len(file_list) > 0:
                 self.logger.info(f"Saving list of {file_type} files to {file_name}")
@@ -646,9 +649,7 @@ class Simulator:
         directory_for_grid_upload = (
             Path(directory_for_grid_upload)
             if directory_for_grid_upload
-            else self.io_handler.get_output_directory(label=self.label).joinpath(
-                "directory_for_grid_upload"
-            )
+            else self.io_handler.get_output_directory().joinpath("directory_for_grid_upload")
         )
         directory_for_grid_upload.mkdir(parents=True, exist_ok=True)
 
@@ -749,13 +750,43 @@ class Simulator:
 
             corsika_log_files.append(str(new_log))
 
-    def _is_calibration_run(self):
+    @staticmethod
+    def _is_calibration_run(run_mode):
         """
         Check if this simulation is a calibration run.
 
+        Parameters
+        ----------
+        run_mode: str
+            Run mode of the simulation.
+
         Returns
         -------
         bool
             True if it is a calibration run, False otherwise.
         """
-        return self.run_mode in ["pedestals", "dark_pedestals", "nsb_only_pedestals", "flasher"]
+        return run_mode in [
+            "pedestals",
+            "dark_pedestals",
+            "nsb_only_pedestals",
+            "direct_injection",
+        ]
+
+    @staticmethod
+    def _get_calibration_device_types(run_mode):
+        """
+        Get the list of calibration device types based on the run mode.
+
+        Parameters
+        ----------
+        run_mode: str
+            Run mode of the simulation.
+
+        Returns
+        -------
+        list
+            List of calibration device types.
+        """
+        if run_mode == "direct_injection":
+            return ["flat_fielding"]
+        return []

simtools/testing/configuration.py

@@ -184,14 +184,16 @@ def _prepare_test_options(config, output_path, model_version=None):
 
     tmp_config_file = output_path / "tmp_config.yml"
     config_file_model_version = config.get("model_version")
+    if isinstance(config_file_model_version, list):
+        config_file_model_version = [str(item) for item in config_file_model_version]
+    elif config_file_model_version is not None:
+        config_file_model_version = str(config_file_model_version)
     if model_version and "model_version" in config:
         config.update({"model_version": model_version})
 
     for key in ["output_path", "data_directory", "pack_for_grid_register"]:
         if key in config:
             config[key] = str(Path(output_path).joinpath(config[key]))
-            if key == "output_path":
-                config["use_plain_output_path"] = True
 
     _logger.info(f"Writing config file: {tmp_config_file}")
     ascii_handler.write_data_to_file(data=config, output_file=tmp_config_file, sort_keys=False)

simtools/testing/sim_telarray_metadata.py

@@ -35,19 +35,19 @@ def assert_sim_telarray_metadata(file, array_model):
     if sim_telarray_seed_mismatch:
         site_parameter_mismatch.append(sim_telarray_seed_mismatch)
 
-    if len(telescope_meta) != len(array_model.telescope_model):
+    if len(telescope_meta) != len(array_model.telescope_models):
         raise ValueError(
             f"Number of telescopes in sim_telarray file ({len(telescope_meta)}) does not match "
-            f"number of telescopes in array model ({len(array_model.telescope_model)})"
+            f"number of telescopes in array model ({len(array_model.telescope_models)})"
         )
 
-    for telescope_name in array_model.telescope_model.keys():
+    for telescope_name in array_model.telescope_models.keys():
         if not get_sim_telarray_telescope_id(telescope_name, file):
             raise ValueError(f"Telescope {telescope_name} not found in sim_telarray file metadata")
 
     telescope_parameter_mismatch = [
         _assert_model_parameters(telescope_meta[i], model)
-        for i, model in enumerate(array_model.telescope_model.values(), start=1)
+        for i, model in enumerate(array_model.telescope_models.values(), start=1)
     ]
 
     # ensure printout of all mismatches, not only those found first

simtools/utils/geometry.py

@@ -1,6 +1,7 @@
 """A collection of functions related to geometrical transformations."""
 
 import logging
+import math
 
 import astropy.units as u
 import numpy as np
@@ -236,3 +237,36 @@ def transform_ground_to_shower_coordinates(x_ground, y_ground, z_ground, azimuth
     z_s = -sz * x + cz * z
 
     return x_s, y_s, z_s
+
+
+def fiducial_radius_from_shape(width, shape):
+    """
+    Calculate minimum radius including different geometrical shapes.
+
+    Assumes definition of shapes as in 'camera_body_shape' model parameter:
+
+    - circle: shape = 0, width is diameter
+    - hexagon: shape = 1 or 3, width is flat-to-flat distance
+    - square: shape = 2, width is side length
+
+    Parameters
+    ----------
+    width : float
+        Characteristic width
+    shape : int
+        Geometrical shape parameter
+
+    Returns
+    -------
+    float
+        Minimum fiducial radius
+    """
+    if shape == 0:
+        return width / 2.0
+    if shape == 2:
+        return width / math.sqrt(2.0)
+    if shape in (1, 3):
+        return width / math.sqrt(3.0)
+    raise ValueError(
+        f"Unknown shape value {shape}. Valid values are: 0 (circle), 1 or 3 (hexagon), 2 (square)."
+    )

simtools/version.py

@@ -106,3 +106,25 @@ def semver_to_int(version_string):
     release = v.release + (0,) * (3 - len(v.release))
     major, minor, patch = release[:3]
     return major * 10000 + minor * 100 + patch
+
+
+def sort_versions(version_list, reverse=False):
+    """
+    Sort a list of semantic version strings.
+
+    Parameters
+    ----------
+    version_list : list of str
+        List of semantic version strings (e.g., ["5.0.0", "6.0.2", "5.1.0"])
+    reverse : bool, optional
+        Sort in descending order if True (default False)
+
+    Returns
+    -------
+    list of str
+        Sorted list of version strings.
+    """
+    try:
+        return [str(v) for v in sorted(map(Version, version_list), reverse=reverse)]
+    except InvalidVersion as exc:
+        raise ValueError(f"Invalid version in list: {version_list}") from exc