gammasimtools 0.25.0__py3-none-any.whl → 0.26.0__py3-none-any.whl

simtools/testing/validate_output.py

@@ -13,26 +13,36 @@ from simtools.testing import assertions
 
 _logger = logging.getLogger(__name__)
 
+
+def _versions_match(from_command_line, from_config_file):
+    """Return True if validations should run for the given versions.
+
+    Behavior:
+    - If no version is provided from the command line, run validations.
+    - If a filter is provided from the command line, run only when it matches
+        the version(s) from the config file.
+    """
+    if from_command_line is None:
+        return True
+
+    # Normalize to collections for comparison
+    cmd_versions = from_command_line if isinstance(from_command_line, list) else [from_command_line]
+    cfg_versions = from_config_file if isinstance(from_config_file, list) else [from_config_file]
+
+    # Consider a match if any overlap exists
+    return any(cv in cmd_versions for cv in cfg_versions)
+
+
 # Keys to ignore when comparing sim_telarray configuration files
 # (e.g., version numbers, system dependent parameters, CORSIKA options)
 cfg_ignore_keys = [
     "config_release",
     "Label",
-    "simtools_version",
-    "simtools_model_production_version",
-    "simtools_build_opt",
-    "simtools_extra_def",
-    "simtools_hadronic_model",
-    "simtools_avx_flag",
-    "simtools_corsika_version",
-    "simtools_corsika_opt_patch_version",
-    "simtools_bernlohr_version",
+    "simtools_",  # ignore all simtools_ keys - version/build info dependence
 ]
 
 
-def validate_application_output(
-    config, from_command_line=None, from_config_file=None, db_config=None
-):
+def validate_application_output(config, from_command_line=None, from_config_file=None):
     """
     Validate application output against expected output.
 
@@ -60,8 +70,8 @@ def validate_application_output(
             f"from config file: {from_config_file}"
         )
 
-        if from_command_line == from_config_file:
-            _validate_output_files(config, integration_test, db_config)
+        if _versions_match(from_command_line, from_config_file):
+            _validate_output_files(config, integration_test)
 
             if "file_type" in integration_test:
                 assert assertions.assert_file_type(
@@ -73,7 +83,7 @@ def validate_application_output(
         _test_simtel_cfg_files(config, integration_test, from_command_line, from_config_file)
 
 
-def _validate_output_files(config, integration_test, db_config):
+def _validate_output_files(config, integration_test):
     """Validate output files."""
     if "reference_output_file" in integration_test:
         _validate_reference_output_file(config, integration_test)
@@ -85,11 +95,7 @@ def _validate_output_files(config, integration_test, db_config):
             [{"path_descriptor": "output_path", "file": integration_test["output_file"]}],
         )
     if "model_parameter_validation" in integration_test:
-        _validate_model_parameter_json_file(
-            config,
-            integration_test["model_parameter_validation"],
-            db_config,
-        )
+        _validate_model_parameter_json_file(config, integration_test["model_parameter_validation"])
 
 
 def _test_simtel_cfg_files(config, integration_test, from_command_line, from_config_file):
@@ -135,15 +141,20 @@ def _validate_output_path_and_file(config, integration_file_tests):
         try:
             assert output_file_path.exists()
         except AssertionError as exc:
-            raise AssertionError(f"Output file {output_file_path} does not exist. ") from exc
+            raise AssertionError(
+                f"Output file {output_file_path} does not exist. "
+                f"Directory contents: {list(output_file_path.parent.iterdir())}"
+            ) from exc
 
         if output_file_path.name.endswith(".simtel.zst"):
             assert assertions.check_output_from_sim_telarray(output_file_path, file_test)
         elif output_file_path.name.endswith(".log_hist.tar.gz"):
             assert assertions.check_simulation_logs(output_file_path, file_test)
+        elif output_file_path.suffix == ".log":
+            assert assertions.check_plain_log(output_file_path, file_test)
 
 
-def _validate_model_parameter_json_file(config, model_parameter_validation, db_config):
+def _validate_model_parameter_json_file(config, model_parameter_validation):
     """
     Validate model parameter json file and compare it with a reference parameter from the database.
 
@@ -158,7 +169,7 @@ def _validate_model_parameter_json_file(config, model_parameter_validation, db_c
 
     """
     _logger.info(f"Checking model parameter json file: {model_parameter_validation}")
-    db = db_handler.DatabaseHandler(db_config=db_config)
+    db = db_handler.DatabaseHandler()
 
     reference_parameter_name = model_parameter_validation.get("reference_parameter_name")
 

simtools/utils/general.py

@@ -11,6 +11,7 @@ import urllib.request
 from pathlib import Path
 from urllib.parse import urlparse
 
+import dotenv
 import numpy as np
 
 _logger = logging.getLogger(__name__)
@@ -850,3 +851,39 @@ def get_list_of_files_from_command_line(file_names, suffix_list):
 def now_date_time_in_isoformat():
     """Return date and time in isoformat and second accuracy."""
     return datetime.datetime.now(datetime.UTC).isoformat(timespec="seconds")
+
+
+def load_environment_variables(env_file=".env", env_list=None):
+    """
+    Load environment variables (from a .env file or directly from the environment).
+
+    Allow to read a specific list of variables or all variables from the .env file.
+
+    Parameters
+    ----------
+    env_file: str
+        Path to the .env file.
+    env_list: list, optional
+        List of environment variables to be read. If None, all variables are read.
+
+    Returns
+    -------
+    dict
+        Dictionary mapping environment variable names (lowercase, without the
+        ``SIMTOOLS_`` prefix) to their cleaned string values.
+    """
+    dotenv.load_dotenv(env_file or None)
+    keys = (
+        list(dotenv.dotenv_values(env_file).keys())
+        if env_list is None
+        else [f"SIMTOOLS_{s.upper()}" for s in env_list]
+    )
+
+    env_values = {}
+    for key in keys:
+        env_value = os.environ.get(key)
+        if env_value is None:
+            continue
+        cleaned_value = env_value.split("#")[0].strip().replace('"', "").replace("'", "")
+        env_values[key.removeprefix("SIMTOOLS_").lower()] = cleaned_value
+    return env_values

simtools/utils/geometry.py

@@ -1,88 +1,11 @@
 """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
 
-_logger = logging.getLogger(__name__)
-
-
-def convert_2d_to_radial_distr(hist_2d, xaxis, yaxis, bins=50, max_dist=1000):
-    """
-    Convert a 2d histogram of positions, e.g. photon positions on the ground, to a 1D distribution.
-
-    Parameters
-    ----------
-    hist_2d: numpy.ndarray
-        The histogram counts.
-    xaxis: numpy.array
-        The values of the x axis (histogram bin edges) on the ground.
-    yaxis: numpy.array
-        The values of the y axis (histogram bin edges) on the ground.
-    bins: float
-        Number of bins in distance.
-    max_dist: float
-       Maximum distance to consider in the 1D histogram, usually in meters.
-
-    Returns
-    -------
-    np.array
-        The values of the 1D histogram with size = int(max_dist/bin_size).
-    np.array
-        The bin edges of the 1D histogram with size = int(max_dist/bin_size) + 1.
-
-    """
-    # Check if the histogram will make sense
-    bins_step = 2 * max_dist / bins  # in the 2d array, the positive and negative direction count.
-    for axis in [xaxis, yaxis]:
-        if (bins_step < np.diff(axis)).any():
-            msg = (
-                f"The histogram with number of bins {bins} and maximum distance of {max_dist} "
-                f"resulted in a bin size smaller than the original array. Please adjust those "
-                f"parameters to increase the bin size and avoid nan in the histogram values."
-            )
-            _logger.warning(msg)
-            break
-
-    grid_2d_x, grid_2d_y = np.meshgrid(xaxis[:-1], yaxis[:-1])  # [:-1], since xaxis and yaxis are
-    # the hist bin_edges (n + 1).
-    # radial_distance_map maps the distance to the center from each element in a square matrix.
-    radial_distance_map = np.sqrt(grid_2d_x**2 + grid_2d_y**2)
-    # The sorting and unravel_index give us the two indices for the position of the sorted element
-    # in the original 2d matrix
-    sorted_indices = np.unravel_index(
-        np.argsort(radial_distance_map, axis=None), np.shape(radial_distance_map)
-    )
-    x_indices_sorted, y_indices_sorted = sorted_indices[0], sorted_indices[1]
-
-    # We construct a 1D array with the histogram counts sorted according to the distance to the
-    # center.
-    hist_sorted = np.array(
-        [hist_2d[i_x, i_y] for i_x, i_y in zip(x_indices_sorted, y_indices_sorted)]
-    )
-    distance_sorted = np.sort(radial_distance_map, axis=None)
-
-    # For larger distances, we have more elements in a slice 'dr' in radius, hence, we need to
-    # account for it using weights below.
-
-    weights, radial_bin_edges = np.histogram(distance_sorted, bins=bins, range=(0, max_dist))
-    histogram_1d = np.empty_like(weights, dtype=float)
-
-    for i_radial, _ in enumerate(radial_bin_edges[:-1]):
-        # Here we sum all the events within a radial interval 'dr' and then divide by the number of
-        # bins that fit this interval.
-        indices_to_sum = (distance_sorted >= radial_bin_edges[i_radial]) * (
-            distance_sorted < radial_bin_edges[i_radial + 1]
-        )
-        if weights[i_radial] != 0:
-            histogram_1d[i_radial] = np.sum(hist_sorted[indices_to_sum]) / weights[i_radial]
-        else:
-            histogram_1d[i_radial] = 0
-    return histogram_1d, radial_bin_edges
-
 
 @u.quantity_input(rotation_angle_phi=u.rad, rotation_angle_theta=u.rad)
 def rotate(x, y, rotation_around_z_axis, rotation_around_y_axis=0):

simtools/utils/names.py

@@ -189,13 +189,13 @@ def model_parameters(class_key_list=None):
     dict
         Model parameters definitions.
     """
-    _parameters = {}
     if class_key_list is None:
         return _load_model_parameters()
-    for key, value in _load_model_parameters().items():
-        if value.get("instrument", {}).get("class", "") in class_key_list:
-            _parameters[key] = value
-    return _parameters
+    return {
+        key: value
+        for key, value in _load_model_parameters().items()
+        if value.get("instrument", {}).get("class", "") in class_key_list
+    }
 
 
 def site_parameters():

simtools/visualization/legend_handlers.py

@@ -1,14 +1,13 @@
 """Helper functions for legend handlers used for plotting."""
 
+# pylint: disable=too-few-public-methods
+
 import matplotlib.colors as mcolors
 import matplotlib.patches as mpatches
 import numpy as np
 
-"""
-Define properties of different telescope types for visualization purposes.
-
-Radii are relative to a reference radius (REFERENCE_RADIUS).
-"""
+# Define properties of different telescope types for visualization purposes.
+# Radii are relative to a reference radius (REFERENCE_RADIUS).
 TELESCOPE_CONFIG = {
     "LST": {"color": "darkorange", "radius": 12.5, "shape": "circle", "filled": False},
     "MST": {"color": "dodgerblue", "radius": 9.15, "shape": "circle", "filled": False},
@@ -51,7 +50,7 @@ def get_telescope_config(telescope_type):
     config = TELESCOPE_CONFIG.get(telescope_type)
     if not config and len(telescope_type) >= 3:
         config = TELESCOPE_CONFIG.get(telescope_type[:3])
-    return config
+    return config.copy() if config else None
 
 
 def calculate_center(handlebox, width_factor=3, height_factor=3):
@@ -272,6 +271,8 @@ class BaseLegendHandler:
             x0, y0 = calculate_center(handlebox)
             radius = handlebox.height
             patch = self._create_hexagon(handlebox, x0, y0, radius)
+        else:
+            raise ValueError(f"Unknown shape: {shape}")
 
         handlebox.add_artist(patch)
         return patch

simtools/visualization/plot_array_layout.py

@@ -5,15 +5,18 @@ from collections import Counter
 from typing import NamedTuple
 
 import astropy.units as u
+import matplotlib as mpl
 import matplotlib.patches as mpatches
 import matplotlib.pyplot as plt
 import numpy as np
+from adjustText import adjust_text
 from astropy.table import Column
 from matplotlib.collections import PatchCollection
 
 from simtools.utils import geometry as transf
 from simtools.utils import names
 from simtools.visualization import legend_handlers as leg_h
+from simtools.visualization import visualize
 
 
 class PlotBounds(NamedTuple):
@@ -31,6 +34,61 @@ class PlotBounds(NamedTuple):
     y_lim: tuple[float, float]
 
 
+def plot_array_layouts(args_dict, output_path, layouts, background_layout=None):
+    """
+    Plot multiple array layouts.
+
+    Parameters
+    ----------
+    args_dict : dict
+        Application arguments.
+    output_path : Path
+        Output path for figures.
+    layouts : dict
+        Dictionary of layout name to telescope table.
+    background_layout : Table or None
+        Optional background telescope table.
+
+    Returns
+    -------
+    figs : dict
+        Dictionary of layout name to matplotlib figure object.
+
+    """
+    mpl.use("Agg")
+    for layout in layouts:
+        fig_out = plot_array_layout(
+            telescopes=layout["array_elements"],
+            show_tel_label=args_dict["show_labels"],
+            axes_range=args_dict["axes_range"],
+            marker_scaling=args_dict["marker_scaling"],
+            background_telescopes=background_layout,
+            grayed_out_elements=args_dict["grayed_out_array_elements"],
+            highlighted_elements=args_dict["highlighted_array_elements"],
+            legend_location=args_dict["legend_location"],
+            bounds_mode=args_dict["bounds"],
+            padding=args_dict["padding"],
+            x_lim=tuple(args_dict["x_lim"]) if args_dict["x_lim"] else None,
+            y_lim=tuple(args_dict["y_lim"]) if args_dict["y_lim"] else None,
+        )
+        site_string = ""
+        if layout.get("site") is not None:
+            site_string = f"_{layout['site']}"
+        elif args_dict["site"] is not None:
+            site_string = f"_{args_dict['site']}"
+        coordinate_system_string = (
+            f"_{args_dict['coordinate_system']}"
+            if args_dict["coordinate_system"] not in layout["name"]
+            else ""
+        )
+        plot_file_name = args_dict["figure_name"] or (
+            f"array_layout_{layout['name']}{site_string}{coordinate_system_string}"
+        )
+
+        visualize.save_figure(fig_out, output_path / plot_file_name, dpi=400)
+        plt.close()
+
+
 def plot_array_layout(
     telescopes,
     show_tel_label=False,
@@ -89,7 +147,7 @@ def plot_array_layout(
     filter_x = x_lim
     filter_y = y_lim
 
-    patches, plot_range, highlighted_patches, bounds = get_patches(
+    patches, plot_range, highlighted_patches, bounds, text_objects = get_patches(
         ax,
         telescopes,
         show_tel_label,
@@ -122,6 +180,17 @@ def plot_array_layout(
 
     finalize_plot(ax, patches, "Easting [m]", "Northing [m]", x_lim, y_lim, highlighted_patches)
 
+    if text_objects:
+        adjust_text(
+            text_objects,
+            ax=ax,
+            arrowprops={"arrowstyle": "->", "color": "grey", "alpha": 0.8, "lw": 0.8, "ls": "--"},
+            expand=(2.0, 2.0),
+            prevent_crossings=True,
+            min_arrow_len=8,
+            ensure_inside_axes=True,
+        )
+
     return fig
 
 
@@ -178,7 +247,7 @@ def _get_patches_for_background_telescopes(
     if background_telescopes is None:
         return plot_range, bounds
 
-    bg_patches, bg_range, _, bg_bounds = get_patches(
+    bg_patches, bg_range, _, bg_bounds, _ = get_patches(
         ax,
         background_telescopes,
         False,
@@ -268,6 +337,8 @@ def get_patches(
         List of highlighted telescope patches.
     bounds : PlotBounds
         Min/max for x and y in meters.
+    text_objects : list
+        List of text objects for labels.
     """
     pos_x, pos_y = get_positions(telescopes)
     tel_table, pos_x, pos_y = _apply_limits_filter(
@@ -277,7 +348,7 @@ def get_patches(
     tel_table["pos_x_rotated"] = Column(pos_x)
     tel_table["pos_y_rotated"] = Column(pos_y)
 
-    patches, radii, highlighted_patches = create_patches(
+    patches, radii, highlighted_patches, text_objects = create_patches(
         tel_table, marker_scaling, show_tel_label, ax, grayed_out_elements, highlighted_elements
     )
 
@@ -290,8 +361,8 @@ def get_patches(
     if len(pos_x) == 0:
         bounds = PlotBounds(x_lim=(0.0, 0.0), y_lim=(0.0, 0.0))
         if axes_range:
-            return patches, axes_range, highlighted_patches, bounds
-        return patches, 0.0, highlighted_patches, bounds
+            return patches, axes_range, highlighted_patches, bounds, text_objects
+        return patches, 0.0, highlighted_patches, bounds, text_objects
 
     x_min = float(np.nanmin(pos_x).to_value(u.m)) - r
     x_max = float(np.nanmax(pos_x).to_value(u.m)) + r
@@ -300,13 +371,13 @@ def get_patches(
     bounds = PlotBounds(x_lim=(x_min, x_max), y_lim=(y_min, y_max))
 
     if axes_range:
-        return patches, axes_range, highlighted_patches, bounds
+        return patches, axes_range, highlighted_patches, bounds, text_objects
 
     max_x = max(abs(x_min), abs(x_max))
     max_y = max(abs(y_min), abs(y_max))
     updated_axes_range = max(max_x, max_y) * 1.1
 
-    return patches, updated_axes_range, highlighted_patches, bounds
+    return patches, updated_axes_range, highlighted_patches, bounds, text_objects
 
 
 @u.quantity_input(x=u.m, y=u.m, radius=u.m)
@@ -417,8 +488,10 @@ def create_patches(
         Telescope radii.
     highlighted_patches : list
         List of highlighted telescope patches.
+    text_objects : list
+        List of text objects for labels.
     """
-    patches, radii, highlighted_patches = [], [], []
+    patches, radii, highlighted_patches, text_objects = [], [], [], []
     fontsize, scale_factor = (4, 2) if len(telescopes) > 30 else (8, 1)
 
     grayed_out_set = set(grayed_out_elements) if grayed_out_elements else set()
@@ -457,16 +530,18 @@ def create_patches(
             highlighted_patches.append(highlight_patch)
 
         if show_label:
-            ax.text(
-                tel["pos_x_rotated"].value,
-                tel["pos_y_rotated"].value + scale_factor * radius.value,
-                name,
-                ha="center",
-                va="bottom",
-                fontsize=fontsize * 0.8,
+            text_objects.append(
+                ax.text(
+                    tel["pos_x_rotated"].value,
+                    tel["pos_y_rotated"].value + scale_factor * radius.value,
+                    name,
+                    ha="center",
+                    va="center",
+                    fontsize=fontsize * 0.8,
+                )
             )
 
-    return patches, radii, highlighted_patches
+    return patches, radii, highlighted_patches, text_objects
 
 
 def get_telescope_name(tel):