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

simtools/simtel/simtel_config_writer.py

@@ -515,7 +515,7 @@ class SimtelConfigWriter:
             width = trigger_dict["width"]["value"] * u.Unit(trigger_dict["width"]["unit"]).to("ns")
             trigger_lines[tel_type] += f" width {width}"
             if trigger_dict.get("hard_stereo"):
-                trigger_lines[tel_type] += " hard_stereo"
+                trigger_lines[tel_type] += " hardstereo"
             if all(trigger_dict["min_separation"][key] is not None for key in ["value", "unit"]):
                 min_sep = trigger_dict["min_separation"]["value"] * u.Unit(
                     trigger_dict["min_separation"]["unit"]

simtools/simulator.py

@@ -19,6 +19,7 @@ from simtools.runners.corsika_simtel_runner import CorsikaSimtelRunner
 from simtools.simtel.simtel_io_event_writer import SimtelIOEventDataWriter
 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",
@@ -163,10 +164,6 @@ class Simulator:
         if seed:
             return int(seed.split(",")[0].strip())
 
-        def semver_to_int(version: str):
-            major, minor, patch = map(int, version.split("."))
-            return major * 10000 + minor * 100 + patch
-
         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

simtools/version.py

@@ -4,6 +4,8 @@
 # which is adapted from https://github.com/astropy/astropy/blob/master/astropy/version.py
 # see https://github.com/astropy/astropy/pull/10774 for a discussion on why this needed.
 
+from packaging.version import InvalidVersion, Version
+
 try:
     try:
         from ._dev_version import version
@@ -17,3 +19,90 @@ except Exception:  # pylint: disable=broad-except
     version = "0.0.0"  # pylint: disable=invalid-name
 
 __version__ = version
+
+
+def resolve_version_to_latest_patch(partial_version, available_versions):
+    """
+    Resolve a partial version (major.minor) to the latest patch version.
+
+    Given a partial version string (e.g., "6.0") and a list of available versions,
+    finds the latest patch version that matches the major.minor pattern.
+
+    Parameters
+    ----------
+    partial_version : str
+        Partial version string in format "major.minor" (e.g., "6.0", "5.2")
+    available_versions : list of str
+        List of available semantic versions (e.g., ["5.0.0", "5.0.1", "6.0.0", "6.0.2"])
+
+    Returns
+    -------
+    str
+        Latest patch version matching the partial version pattern
+
+    Raises
+    ------
+    ValueError
+        If partial_version is not in major.minor format
+    ValueError
+        If no matching versions are found
+
+    Examples
+    --------
+    >>> versions = ["5.0.0", "5.0.1", "6.0.0", "6.0.2", "6.1.0"]
+    >>> resolve_version_to_latest_patch("6.0", versions)
+    '6.0.2'
+    >>> resolve_version_to_latest_patch("5.0", versions)
+    '5.0.1'
+    >>> resolve_version_to_latest_patch("5.0.1", versions)
+    '5.0.1'
+    """
+    try:
+        pv = Version(partial_version)
+    except InvalidVersion as exc:
+        raise ValueError(f"Invalid version string: {partial_version}") from exc
+
+    if pv.release and len(pv.release) >= 3:
+        return str(pv)
+
+    if len(pv.release) != 2:
+        raise ValueError(f"Partial version must be major.minor, got: {partial_version}")
+
+    major, minor = pv.release
+
+    candidates = [
+        v for v in available_versions if Version(v).major == major and Version(v).minor == minor
+    ]
+
+    if not candidates:
+        raise ValueError(
+            f"No versions found matching '{partial_version}.x' "
+            f"in available versions: {sorted(available_versions)}"
+        )
+
+    return str(max(map(Version, candidates)))
+
+
+def semver_to_int(version_string):
+    """
+    Convert a semantic version string to an integer.
+
+    Parameters
+    ----------
+    version_string : str
+        Semantic version string (e.g., "6.0.2")
+
+    Returns
+    -------
+    int
+        Integer representation of the version (e.g., 60002 for "6.0.2")
+
+    """
+    try:
+        v = Version(version_string)
+    except InvalidVersion as exc:
+        raise ValueError(f"Invalid version: {version_string}") from exc
+
+    release = v.release + (0,) * (3 - len(v.release))
+    major, minor, patch = release[:3]
+    return major * 10000 + minor * 100 + patch

simtools/{corsika/corsika_histograms_visualize.py → visualization/plot_corsika_histograms.py}

@@ -1,6 +1,7 @@
 """Visualize Cherenkov photon distributions from CORSIKA."""
 
 import logging
+import re
 from pathlib import Path
 
 import matplotlib.pyplot as plt
@@ -569,3 +570,111 @@ def save_figs_to_pdf(figs, pdf_file_name):
         plt.tight_layout()
         pdf_pages.savefig(fig)
     pdf_pages.close()
+
+
+def build_all_photon_figures(histograms_instance, test: bool = False):
+    """Return list of all photon histogram figures for the given instance.
+
+    When test is True, only generate the first two figure groups to reduce runtime.
+    """
+    plot_function_names = sorted(
+        [
+            name
+            for name, obj in globals().items()
+            if name.startswith("plot_")
+            and "event_header_distribution" not in name
+            and callable(obj)
+        ]
+    )
+    if test:
+        plot_function_names = plot_function_names[:2]
+
+    figure_list = []
+    module_obj = globals()
+    for fn_name in plot_function_names:
+        plot_fn = module_obj[fn_name]
+        figs = plot_fn(histograms_instance)
+        for fig in figs:
+            figure_list.append(fig)
+    return np.array(figure_list).flatten()
+
+
+def export_all_photon_figures_pdf(histograms_instance, test: bool = False):
+    """Build and save all photon histogram figures into a single PDF.
+
+    The PDF name is derived from the HDF5 file name core and written under output_path.
+    """
+    figs = build_all_photon_figures(histograms_instance, test=test)
+    core_name = re.sub(r"\.hdf5$", "", Path(histograms_instance.hdf5_file_name).name)
+    output_file_name = Path(histograms_instance.output_path).joinpath(f"{core_name}.pdf")
+    save_figs_to_pdf(figs, output_file_name)
+    return output_file_name
+
+
+def derive_event_1d_histograms(
+    histograms_instance,
+    event_1d_header_keys,
+    pdf: bool,
+    hdf5: bool,
+    overwrite: bool = False,
+):
+    """Create 1D event header histograms; optionally save to PDF and/or HDF5."""
+    figure_list = []
+    for key in event_1d_header_keys:
+        if pdf:
+            fig = plot_1d_event_header_distribution(histograms_instance, key)
+            figure_list.append(fig)
+        if hdf5:
+            histograms_instance.export_event_header_1d_histogram(
+                key, bins=50, hist_range=None, overwrite=overwrite
+            )
+    if pdf:
+        figs_array = np.array(figure_list).flatten()
+        pdf_name = Path(histograms_instance.output_path).joinpath(
+            f"{Path(histograms_instance.hdf5_file_name).name}_event_1d_histograms.pdf"
+        )
+        save_figs_to_pdf(figs_array, pdf_name)
+        return pdf_name
+    return None
+
+
+def derive_event_2d_histograms(
+    histograms_instance,
+    event_2d_header_keys,
+    pdf: bool,
+    hdf5: bool,
+    overwrite: bool = False,
+):
+    """Create 2D event header histograms in pairs; optionally save PDF and/or HDF5.
+
+    If an odd number of keys is provided, the last one is ignored (with a warning).
+    """
+    if len(event_2d_header_keys) % 2 == 1:
+        _logger.warning(
+            "An odd number of keys was passed to generate 2D histograms.\n"
+            "The last key is being ignored."
+        )
+
+    figure_list = []
+    for i, _ in enumerate(event_2d_header_keys[::2]):
+        if pdf:
+            fig = plot_2d_event_header_distribution(
+                histograms_instance, event_2d_header_keys[i], event_2d_header_keys[i + 1]
+            )
+            figure_list.append(fig)
+        if hdf5:
+            histograms_instance.export_event_header_2d_histogram(
+                event_2d_header_keys[i],
+                event_2d_header_keys[i + 1],
+                bins=50,
+                hist_range=None,
+                overwrite=overwrite,
+            )
+    if pdf:
+        figs_array = np.array(figure_list).flatten()
+        pdf_name = Path(histograms_instance.output_path).joinpath(
+            f"{Path(histograms_instance.hdf5_file_name).name}_event_2d_histograms.pdf"
+        )
+        save_figs_to_pdf(figs_array, pdf_name)
+        return pdf_name
+    return None