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

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/utils/random.py

@@ -0,0 +1,36 @@
+"""Random numbers utilities."""
+
+import secrets
+
+import numpy as np
+
+
+def seeds(n_seeds=1, min_seed=1, max_seed=2_000_000_000, fixed_seed=None):
+    """
+    Generate independent random seeds.
+
+    Parameters
+    ----------
+    n_seeds : int
+        Number of seeds to generate.
+    min_seed : int
+        Lower limit for the seed (inclusive).
+    max_seed : int
+        Upper limit for the seed (exclusive).
+    fixed_seed : int or None
+        If provided, use this fixed seed.
+
+    Returns
+    -------
+    int or list of int:
+        A single seed if n_seeds is 1, otherwise a list of seeds.
+    """
+    entropy = fixed_seed if fixed_seed is not None else secrets.randbits(128)
+    ss = np.random.SeedSequence(entropy)
+    rng = np.random.default_rng(ss)
+
+    seed_list = rng.integers(low=min_seed, high=max_seed, size=n_seeds)
+
+    if n_seeds == 1:
+        return int(seed_list[0])
+    return [int(x) for x in seed_list]

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):