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

simtools/simtel/simulator_ray_tracing.py

@@ -10,8 +10,6 @@ from simtools.runners.simtel_runner import SimtelRunner
 from simtools.utils import names
 from simtools.utils.general import clear_default_sim_telarray_cfg_directories
 
-__all__ = ["SimulatorRayTracing"]
-
 # pylint: disable=no-member
 # The line above is needed because there are members which are created
 # by adding them to the __dict__ of the class rather than directly.
@@ -61,7 +59,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 +144,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
@@ -21,11 +22,6 @@ from simtools.simtel.simulator_array import SimulatorArray
 from simtools.testing.sim_telarray_metadata import assert_sim_telarray_metadata
 from simtools.version import semver_to_int
 
-__all__ = [
-    "InvalidRunsToSimulateError",
-    "Simulator",
-]
-
 
 class InvalidRunsToSimulateError(Exception):
     """Exception for invalid runs to simulate."""
@@ -68,8 +64,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 +137,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 +165,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 +256,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 +295,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 +583,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 +644,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 +745,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/assertions.py

@@ -62,9 +62,9 @@ def assert_n_showers_and_energy_range(file):
 
     simulated_energies = []
     simulation_config = {}
-    with SimTelFile(file) as f:
+    with SimTelFile(file, skip_non_triggered=False) as f:
         simulation_config = f.mc_run_headers[0]
-        for event in f.iter_mc_events():
+        for event in f:
             simulated_energies.append(event["mc_shower"]["energy"])
 
     # The relative tolerance is set to 1% because ~0.5% shower simulations do not

simtools/testing/configuration.py

@@ -5,6 +5,7 @@ import os
 from pathlib import Path
 
 import simtools.utils.general as gen
+import simtools.version as simtools_version
 from simtools.io import ascii_handler
 
 _logger = logging.getLogger(__name__)
@@ -130,11 +131,23 @@ def configure(config, tmp_test_directory, request):
 
 
 def _skip_test_for_model_version(config, model_version_requested):
-    """Skip test if model version requested is not supported."""
-    if config.get("model_version_use_current") is None or model_version_requested is None:
+    """
+    Skip test if model version requested is not supported.
+
+    Compares full and major.minor version strings.
+    """
+    if not (config.get("model_version_use_current") and model_version_requested):
         return
-    model_version_config = config["configuration"]["model_version"]
-    if model_version_requested != model_version_config:
+    model_version_config = str(config["configuration"]["model_version"])
+
+    if (
+        simtools_version.compare_versions(
+            model_version_requested,
+            model_version_config,
+            level=simtools_version.version_kind(model_version_requested),
+        )
+        != 0
+    ):
         raise VersionError(
             f"Model version requested {model_version_requested} not supported for this test"
         )
@@ -184,14 +197,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/general.py

@@ -13,17 +13,6 @@ from urllib.parse import urlparse
 
 import numpy as np
 
-__all__ = [
-    "change_dict_keys_case",
-    "clear_default_sim_telarray_cfg_directories",
-    "collect_final_lines",
-    "collect_kwargs",
-    "get_log_excerpt",
-    "get_log_level_from_user",
-    "remove_substring_recursively_from_dict",
-    "set_default_kwargs",
-]
-
 _logger = logging.getLogger(__name__)
 
 
@@ -345,7 +334,7 @@ def resolve_file_patterns(file_names):
     return _files
 
 
-def pack_tar_file(tar_file_name, file_list):
+def pack_tar_file(tar_file_name, file_list, sub_dir=None):
     """
     Pack files into a tar.gz archive.
 
@@ -355,6 +344,8 @@ def pack_tar_file(tar_file_name, file_list):
         Name of the output tar.gz file.
     file_list: list
         List of files to include in the archive.
+    sub_dir: str, optional
+        Subdirectory within the archive to place the files.
     """
     file_list = [Path(f) for f in file_list]
     base = Path(os.path.commonpath([f.resolve() for f in file_list]))
@@ -365,7 +356,8 @@ def pack_tar_file(tar_file_name, file_list):
 
     with tarfile.open(tar_file_name, "w:gz") as tar:
         for file in file_list:
-            tar.add(file, arcname=file.name)
+            arc_name = Path(sub_dir) / file.name if sub_dir else file.name
+            tar.add(file, arcname=str(arc_name))
 
 
 def get_log_excerpt(log_file, n_last_lines=30):

simtools/utils/geometry.py

@@ -1,16 +1,12 @@
 """A collection of functions related to geometrical transformations."""
 
 import logging
+import math
 
 import astropy.units as u
 import numpy as np
 from astropy.units import UnitsError
 
-__all__ = [
-    "convert_2d_to_radial_distr",
-    "rotate",
-]
-
 _logger = logging.getLogger(__name__)
 
 
@@ -236,3 +232,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/utils/names.py

@@ -28,18 +28,6 @@ from simtools.constants import (
 
 _logger = logging.getLogger(__name__)
 
-__all__ = [
-    "generate_file_name",
-    "get_array_element_type_from_name",
-    "get_site_from_array_element_name",
-    "sanitize_name",
-    "simtel_config_file_name",
-    "simtel_single_mirror_list_file_name",
-    "validate_array_element_id_name",
-    "validate_array_element_name",
-    "validate_site_name",
-]
-
 # Mapping of db collection names to class keys
 db_collections_to_class_keys = {
     "sites": ["Site"],
@@ -122,7 +110,7 @@ def site_names():
 @cache
 def array_element_design_types(array_element_type):
     """
-    Get array element site types (e.g., 'design' or 'flashcam').
+    Get array element design type (e.g., 'design' or 'flashcam').
 
     Default values are ['design', 'test'].
 

simtools/version.py

@@ -6,6 +6,9 @@
 
 from packaging.version import InvalidVersion, Version
 
+MAJOR_MINOR_PATCH = "major.minor.patch"
+MAJOR_MINOR = "major.minor"
+
 try:
     try:
         from ._dev_version import version
@@ -106,3 +109,83 @@ 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
+
+
+def version_kind(version_string):
+    """
+    Determine the kind of version string.
+
+    Parameters
+    ----------
+    version_string : str
+        The version string to analyze.
+
+    Returns
+    -------
+    str
+        The kind of version string ("major.minor", "major.minor.patch", or "major").
+    """
+    try:
+        ver = Version(version_string)
+    except InvalidVersion as exc:
+        raise ValueError(f"Invalid version string: {version_string}") from exc
+    if ver.release and len(ver.release) >= 3:
+        return MAJOR_MINOR_PATCH
+    if len(ver.release) == 2:
+        return MAJOR_MINOR
+    return "major"
+
+
+def compare_versions(version_string_1, version_string_2, level=MAJOR_MINOR_PATCH):
+    """
+    Compare two versions at the given level: "major", "major.minor", "major.minor.patch".
+
+    Parameters
+    ----------
+    version_string_1 : str
+        First version string to compare.
+    version_string_2 : str
+        Second version string to compare.
+    level : str, optional
+        Level of comparison: "major", "major.minor", or "major.minor.patch"
+
+    Returns
+    -------
+    int
+        -1 if version_string_1 < version_string_2
+         0 if version_string_1 == version_string_2
+         1 if version_string_1 > version_string_2
+    """
+    ver1 = Version(version_string_1).release
+    ver2 = Version(version_string_2).release
+
+    if level == "major":
+        ver1, ver2 = ver1[:1], ver2[:1]
+    elif level == MAJOR_MINOR:
+        ver1, ver2 = ver1[:2], ver2[:2]
+    elif level != MAJOR_MINOR_PATCH:
+        raise ValueError(f"Unknown level: {level}")
+
+    return (ver1 > ver2) - (ver1 < ver2)