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

simtools/visualization/plot_incident_angles.py

@@ -351,6 +351,7 @@ def _plot_component_angles(
     out_path,
     bin_width_deg,
     log,
+    model_version=None,
 ):
     arrays = _gather_angle_arrays(results_by_offset, column, log)
     if not arrays:
@@ -365,6 +366,17 @@ def _plot_component_angles(
     ax.set_title(f"Incident angle {title_suffix} vs off-axis angle")
     ax.grid(True, alpha=0.3)
     ax.legend()
+    if model_version:
+        ax.text(
+            0.03,
+            0.97,
+            f"Model version: {model_version}",
+            transform=ax.transAxes,
+            fontsize=8,
+            verticalalignment="top",
+            horizontalalignment="left",
+            bbox={"boxstyle": "round", "facecolor": "white", "alpha": 0.5},
+        )
     plt.tight_layout()
     plt.savefig(out_path, dpi=300)
     plt.close(fig)
@@ -378,8 +390,30 @@ def plot_incident_angles(
     radius_bin_width_m=0.01,
     debug_plots=False,
     logger=None,
+    model_version=None,
 ):
-    """Plot overlaid histograms of focal, primary, secondary angles, and primary hit radius."""
+    """Plot overlaid histograms of focal, primary, secondary angles, and primary hit radius.
+
+    Parameters
+    ----------
+    results_by_offset : dict
+        Mapping from off-axis angle to result tables containing angle and radius columns.
+    output_dir : path-like
+        Base output directory where the ``plots`` subdirectory will be created.
+    label : str
+        Label used to distinguish this set of plots in the output filenames.
+    bin_width_deg : float, optional
+        Bin width in degrees for the angle-of-incidence histograms.
+    radius_bin_width_m : float, optional
+        Bin width in meters for the primary mirror hit-radius histograms.
+    debug_plots : bool, optional
+        If True, generate additional diagnostic plots.
+    logger : logging.Logger or None, optional
+        Logger instance to use for messages. If None, a module-level logger is used.
+    model_version : str or None, optional
+        Semantic model version identifier to annotate the generated plots. If None,
+        no model version text is added to the figures.
+    """
     log = logger or logging.getLogger(__name__)
     if not results_by_offset:
         log.warning("No results provided for multi-offset plot")
@@ -402,6 +436,17 @@ def plot_incident_angles(
             ax.set_title("Incident angle distribution vs off-axis angle")
             ax.grid(True, alpha=0.3)
             ax.legend()
+            if model_version:
+                ax.text(
+                    0.03,
+                    0.97,
+                    f"Model version: {model_version}",
+                    transform=ax.transAxes,
+                    fontsize=8,
+                    verticalalignment="top",
+                    horizontalalignment="left",
+                    bbox={"boxstyle": "round", "facecolor": "white", "alpha": 0.5},
+                )
             plt.tight_layout()
             plt.savefig(out_dir / f"incident_angles_multi_{label}.png", dpi=300)
             plt.close(fig)
@@ -414,6 +459,7 @@ def plot_incident_angles(
         out_path=out_dir / f"incident_angles_primary_multi_{label}.png",
         bin_width_deg=bin_width_deg,
         log=log,
+        model_version=model_version,
     )
     _plot_component_angles(
         results_by_offset=results_by_offset,
@@ -422,6 +468,7 @@ def plot_incident_angles(
         out_path=out_dir / f"incident_angles_secondary_multi_{label}.png",
         bin_width_deg=bin_width_deg,
         log=log,
+        model_version=model_version,
     )
 
     # Debug plots

simtools/visualization/plot_mirrors.py

@@ -63,7 +63,7 @@ def _detect_segmentation_type(data_file_path):
     return "standard"
 
 
-def plot(config, output_file, db_config=None):
+def plot(config, output_file):
     """
     Plot mirror panel layout based on configuration.
 
@@ -79,8 +79,6 @@ def plot(config, output_file, db_config=None):
         - title: str, optional, plot title
     output_file : str or Path
         Path where to save the plot (without extension)
-    db_config : dict, optional
-        Database configuration dictionary
 
     Returns
     -------
@@ -91,7 +89,6 @@ def plot(config, output_file, db_config=None):
         site=config["site"],
         telescope_name=config["telescope"],
         model_version=config.get("model_version"),
-        db_config=db_config,
         ignore_software_version=True,
     )
 

simtools/visualization/plot_pixels.py

@@ -21,7 +21,7 @@ from simtools.visualization import visualize
 logger = logging.getLogger(__name__)
 
 
-def plot(config, output_file, db_config=None):
+def plot(config, output_file):
     """
     Plot pixel layout based on configuration.
 
@@ -36,15 +36,13 @@ def plot(config, output_file, db_config=None):
         - telescope : str, name of the telescope
     output_file : str
         Path where to save the plot
-    db_config : dict, optional
-        Database configuration.
 
     Returns
     -------
     None
         The function saves the plot to the specified output file.
     """
-    db = db_handler.DatabaseHandler(db_config=db_config)
+    db = db_handler.DatabaseHandler()
     db.export_model_file(
         parameter=config["parameter"],
         site=config["site"],

simtools/visualization/plot_psf.py

@@ -6,6 +6,7 @@ including parameter comparison plots, convergence plots, and PSF diameter vs off
 """
 
 import logging
+from pathlib import Path
 
 import astropy.units as u
 import matplotlib.pyplot as plt
@@ -141,22 +142,27 @@ def _create_base_plot_figure(data_to_plot, simulated_data=None):
 
 
 def _build_parameter_title(pars, is_best):
-    """Build parameter title string for plots."""
+    """Build parameter title string for plots, handling optional parameter groups."""
     title_prefix = "* " if is_best else ""
-    return (
-        f"{title_prefix}reflection = "
-        f"{pars['mirror_reflection_random_angle'][0]:.5f}, "
-        f"{pars['mirror_reflection_random_angle'][1]:.5f}, "
-        f"{pars['mirror_reflection_random_angle'][2]:.5f}\n"
-        f"align_vertical = {pars['mirror_align_random_vertical'][0]:.5f}, "
-        f"{pars['mirror_align_random_vertical'][1]:.5f}, "
-        f"{pars['mirror_align_random_vertical'][2]:.5f}, "
-        f"{pars['mirror_align_random_vertical'][3]:.5f}\n"
-        f"align_horizontal = {pars['mirror_align_random_horizontal'][0]:.5f}, "
-        f"{pars['mirror_align_random_horizontal'][1]:.5f}, "
-        f"{pars['mirror_align_random_horizontal'][2]:.5f}, "
-        f"{pars['mirror_align_random_horizontal'][3]:.5f}"
-    )
+    title_lines = []
+
+    if "mirror_reflection_random_angle" in pars:
+        refl = pars["mirror_reflection_random_angle"]
+        title_lines.append(f"reflection = {refl[0]:.5f}, {refl[1]:.5f}, {refl[2]:.5f}")
+
+    if "mirror_align_random_vertical" in pars:
+        vert = pars["mirror_align_random_vertical"]
+        title_lines.append(
+            f"align_vertical = {vert[0]:.5f}, {vert[1]:.5f}, {vert[2]:.5f}, {vert[3]:.5f}"
+        )
+
+    if "mirror_align_random_horizontal" in pars:
+        horiz = pars["mirror_align_random_horizontal"]
+        title_lines.append(
+            f"align_horizontal = {horiz[0]:.5f}, {horiz[1]:.5f}, {horiz[2]:.5f}, {horiz[3]:.5f}"
+        )
+
+    return title_prefix + "\n".join(title_lines)
 
 
 def _add_metric_text_box(ax, metrics_text, is_best):
@@ -640,7 +646,7 @@ def create_psf_vs_offaxis_plot(tel_model, site_model, args_dict, best_pars, outp
     logger.info(f"Creating {psf_label_cm} vs off-axis angle plot with best parameters...")
 
     # Apply best parameters to telescope model
-    tel_model.overwrite_parameters(best_pars)
+    tel_model.overwrite_parameters(best_pars, flat_dict=True)
 
     # Create off-axis angle array
     max_offset = args_dict.get("max_offset", MAX_OFFSET_DEFAULT)
@@ -654,7 +660,7 @@ def create_psf_vs_offaxis_plot(tel_model, site_model, args_dict, best_pars, outp
     ray = RayTracing(
         telescope_model=tel_model,
         site_model=site_model,
-        simtel_path=args_dict["simtel_path"],
+        label=args_dict.get("label") or getattr(tel_model, "label", None),
         zenith_angle=args_dict["zenith"] * u.deg,
         source_distance=args_dict["src_distance"] * u.km,
         off_axis_angle=off_axis_angles * u.deg,
@@ -662,9 +668,9 @@ def create_psf_vs_offaxis_plot(tel_model, site_model, args_dict, best_pars, outp
 
     logger.info(f"Running ray tracing for {len(off_axis_angles)} off-axis angles...")
     ray.simulate(test=args_dict.get("test", False), force=True)
-    ray.analyze(force=True)
+    ray.analyze(force=True, containment_fraction=fraction)
 
-    for key in ["d80_cm", "d80_deg"]:
+    for key in ["psf_cm", "psf_deg"]:
         plt.figure(figsize=(10, 6), tight_layout=True)
 
         ray.plot(key, marker="o", linestyle="-", color="blue", linewidth=2, markersize=6)
@@ -773,3 +779,138 @@ def create_optimization_plots(args_dict, gd_results, tel_model, data_to_plot, ou
                 use_ks_statistic=False,
             )
     pdf_pages.close()
+
+
+def create_summary_psf_comparison_plot(
+    tel_model, optimized_params, data_to_plot, output_dir, final_rmsd, simulated_data
+):
+    """
+    Create a standalone plot comparing measured vs simulated PSF with final optimized parameters.
+
+    This creates a single plot showing the cumulative PSF comparison
+    before and after the optimization.
+
+    Parameters
+    ----------
+    tel_model : TelescopeModel
+        Telescope model with optimized parameters
+    optimized_params : dict
+        Dictionary of optimized parameter values
+    data_to_plot : dict
+        Measured PSF data
+    output_dir : Path
+        Directory for output files
+    final_rmsd : float
+        Final RMSD value at the end of optimization
+    simulated_data : dict
+        Final simulated PSF data with optimized parameters
+
+    Returns
+    -------
+    Path
+        Path to the created plot file
+    """
+    fig, ax = _create_base_plot_figure(data_to_plot, simulated_data)
+
+    title_lines = ["Final Optimized Parameters:"]
+    if "mirror_reflection_random_angle" in optimized_params:
+        refl = optimized_params["mirror_reflection_random_angle"]
+        title_lines.append(
+            f"mirror_reflection_random_angle = [{refl[0]:.6f}, {refl[1]:.6f}, {refl[2]:.6f}]"
+        )
+
+    if "mirror_align_random_vertical" in optimized_params:
+        vert = optimized_params["mirror_align_random_vertical"]
+        title_lines.append(
+            f"mirror_align_random_vertical = "
+            f"[{vert[0]:.6f}, {vert[1]:.6f}, {vert[2]:.6f}, {vert[3]:.6f}]"
+        )
+
+    if "mirror_align_random_horizontal" in optimized_params:
+        horiz = optimized_params["mirror_align_random_horizontal"]
+        title_lines.append(
+            f"mirror_align_random_horizontal = "
+            f"[{horiz[0]:.6f}, {horiz[1]:.6f}, {horiz[2]:.6f}, {horiz[3]:.6f}]"
+        )
+
+    ax.set_title("\n".join(title_lines), fontsize=9, loc="left")
+
+    rmsd_text = f"RMSD = {final_rmsd:.4f} ({final_rmsd * 100:.2f}%)"
+    ax.text(
+        0.98,
+        0.02,
+        rmsd_text,
+        transform=ax.transAxes,
+        fontsize=12,
+        verticalalignment="bottom",
+        horizontalalignment="right",
+        bbox={"boxstyle": "round", "facecolor": "wheat", "alpha": 0.8},
+    )
+
+    output_file = Path(output_dir) / f"{tel_model.name}_final_psf_comparison.png"
+    fig.savefig(output_file, dpi=150, bbox_inches="tight")
+    plt.close(fig)
+
+    logger.info(f"Final PSF comparison plot saved to {output_file}")
+    return output_file
+
+
+def plot_psf_histogram(measured, simulated, args_dict):
+    """Write histogram comparing measured vs simulated PSF diameter distributions."""
+    output_dir = Path(args_dict.get("output_path", "."))
+    out_name = args_dict.get("psf_hist")
+    if not out_name:
+        return None
+    out_path = Path(out_name)
+    if not out_path.is_absolute():
+        out_path = output_dir / out_path
+    out_path.parent.mkdir(parents=True, exist_ok=True)
+    measured = np.asarray(measured, dtype=float)
+    simulated = np.asarray(simulated, dtype=float)
+    measured = measured[np.isfinite(measured)]
+    simulated = simulated[np.isfinite(simulated)]
+    if measured.size == 0 or simulated.size == 0:
+        return None
+    bins = 25
+    all_vals = np.concatenate([measured, simulated])
+    x_min = float(np.nanmin(all_vals))
+    x_max = float(np.nanmax(all_vals))
+    if not np.isfinite(x_min) or not np.isfinite(x_max) or x_max <= x_min:
+        return None
+    bin_edges = np.linspace(x_min, x_max, bins + 1)
+    meas_mean = float(np.mean(measured))
+    meas_rms = float(np.std(measured, ddof=0))
+    sim_mean = float(np.mean(simulated))
+    sim_rms = float(np.std(simulated, ddof=0))
+    fig, ax = plt.subplots(figsize=(7.5, 4.5), constrained_layout=True)
+    ax.hist(
+        measured,
+        bins=bin_edges,
+        alpha=0.55,
+        color="tab:red",
+        edgecolor="white",
+        label=f"Measured (mean={meas_mean:.2f} mm, rms={meas_rms:.2f} mm)",
+    )
+    ax.hist(
+        simulated,
+        bins=bin_edges,
+        alpha=0.55,
+        color="tab:blue",
+        edgecolor="white",
+        label=f"Simulated (mean={sim_mean:.2f} mm, rms={sim_rms:.2f} mm)",
+    )
+    ax.axvline(meas_mean, color="tab:red", linestyle="--", linewidth=1)
+    ax.axvline(sim_mean, color="tab:blue", linestyle="--", linewidth=1)
+    tel = args_dict.get("telescope", "")
+    model_version = args_dict.get("model_version", "")
+    fraction = args_dict.get("fraction")
+    label = get_psf_diameter_label(fraction, unit="mm") if fraction is not None else "PSF"
+    suffix = " ".join([s for s in (tel, model_version) if s])
+    ax.set_xlabel(label)
+    ax.set_ylabel("Count")
+    ax.set_title(f"{label} ({suffix})" if suffix else label)
+    ax.legend(loc="best", fontsize=9, frameon=True)
+    fig.savefig(out_path)
+    plt.close(fig)
+    logger.info("PSF histogram written to %s", str(out_path))
+    return str(out_path)

simtools/visualization/plot_simtel_event_histograms.py

@@ -1,4 +1,4 @@
-"""Plot simtel event histograms filled with SimtelIOEventHistograms."""
+"""Plot simtel event histograms filled with EventDataHistograms."""
 
 import logging
 
@@ -6,7 +6,7 @@ import matplotlib.pyplot as plt
 import numpy as np
 from matplotlib.colors import LogNorm
 
-from simtools.simtel.simtel_io_event_histograms import SimtelIOEventHistograms
+from simtools.sim_events.histograms import EventDataHistograms
 
 _logger = logging.getLogger(__name__)
 
@@ -17,7 +17,7 @@ def plot(histograms, output_path=None, limits=None, rebin_factor=2, array_name=N
 
     Parameters
     ----------
-    histograms: SimtelIOEventHistograms
+    histograms: EventDataHistograms
         Instance containing the histograms to plot.
     output_path: Path or str, optional
         Directory to save plots. If None, plots will be displayed.
@@ -230,7 +230,7 @@ def _create_rebinned_plot(plot_args, filename, output_path, rebin_factor):
     data = plot_args["data"]
     bins = plot_args["bins"]
 
-    rebinned_data, rebinned_x_bins, rebinned_y_bins = SimtelIOEventHistograms.rebin_2d_histogram(
+    rebinned_data, rebinned_x_bins, rebinned_y_bins = EventDataHistograms.rebin_2d_histogram(
         data, bins[0], bins[1], rebin_factor
     )
 

simtools/visualization/plot_simtel_events.py

@@ -13,8 +13,7 @@ from ctapipe.visualization import CameraDisplay
 from scipy import signal as _signal
 
 from simtools.data_model.metadata_collector import MetadataCollector
-from simtools.visualization.plot_corsika_histograms import save_figs_to_pdf
-from simtools.visualization.visualize import save_figure
+from simtools.visualization.visualize import save_figure, save_figures_to_single_document
 
 _logger = logging.getLogger(__name__)
 
@@ -665,24 +664,21 @@ def plot_simtel_peak_timing(
 
     fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(10, 4), dpi=300)
 
-    edges = _histogram_edges(n_samp, timing_bins)
-    et_name = getattr(getattr(event.trigger, "event_type", None), "name", "?")
     tel = source.subarray.tel[tel_id]
     tel_label = getattr(tel, "name", f"CT{tel_id}")
     _draw_peak_hist(
         ax1,
         peak_samples,
-        edges,
+        _histogram_edges(n_samp, timing_bins),
         mean_sample,
         std_sample,
         tel_label,
-        et_name,
+        getattr(getattr(event.trigger, "event_type", None), "name", "?"),
         pix_ids.size,
         found_count,
     )
 
-    readout = source.subarray.tel[tel_id].camera.readout
-    t = _time_axis_from_readout(readout, n_samp)
+    t = _time_axis_from_readout(source.subarray.tel[tel_id].camera.readout, n_samp)
 
     ex_ids = pix_ids[: max(1, int(examples))]
     for pid in ex_ids:
@@ -698,13 +694,12 @@ def plot_simtel_peak_timing(
     fig.tight_layout()
 
     if return_stats:
-        stats = {
+        return fig, {
             "considered": int(pix_ids.size),
             "found": int(found_count),
             "mean": float(mean_sample),
             "std": float(std_sample),
         }
-        return fig, stats
     return fig
 
 
@@ -991,7 +986,7 @@ def generate_and_save_plots(
             continue
 
         try:
-            save_figs_to_pdf(figures, pdf_path)
+            save_figures_to_single_document(figures, pdf_path)
             _logger.info("Saved PDF: %s", pdf_path)
         except Exception as ex:  # pylint:disable=broad-except
             _logger.error("Failed to save PDF %s: %s", pdf_path, ex)

simtools/visualization/plot_tables.py

@@ -16,7 +16,7 @@ from simtools.visualization import visualize
 _logger = logging.getLogger(__name__)
 
 
-def plot(config, output_file, db_config=None, data_path=None):
+def plot(config, output_file, data_path=None):
     """
     Plot tabular data from data or from model parameter files.
 
@@ -26,12 +26,10 @@ def plot(config, output_file, db_config=None, data_path=None):
         Configuration dictionary for plotting.
     output_file: str
         Output file.
-    db_config: dict, optional
-        Database configuration dictionary for accessing the model parameter database.
     data_path: Path or str, optional
         Path to the data files (optional). Expect all files to be in the same directory.
     """
-    data = read_table_data(config, db_config, data_path)
+    data = read_table_data(config, data_path)
 
     fig = visualize.plot_1d(
         data,
@@ -42,7 +40,7 @@ def plot(config, output_file, db_config=None, data_path=None):
     return output_file
 
 
-def read_table_data(config, db_config, data_path=None):
+def read_table_data(config, data_path=None):
     """
     Read table data from file or parameter database.
 
@@ -50,8 +48,6 @@ def read_table_data(config, db_config, data_path=None):
     ----------
     config: dict
         Configuration dictionary for plotting.
-    db_config: dict
-        Database configuration dictionary for accessing the model parameter database.
     data_path: Path or str, optional
         Path to the data files (optional). Expect all files to be in the same directory.
 
@@ -64,7 +60,7 @@ def read_table_data(config, db_config, data_path=None):
 
     for _config in config["tables"]:
         if "parameter" in _config:
-            table = _read_table_from_model_database(_config, db_config)
+            table = _read_table_from_model_database(_config)
         elif "file_name" in _config:
             file_name = (
                 _config["file_name"]
@@ -117,7 +113,7 @@ def _process_table_data(table, _config):
     )
 
 
-def _read_table_from_model_database(table_config, db_config):
+def _read_table_from_model_database(table_config):
     """
     Read table data from model parameter database.
 
@@ -131,7 +127,7 @@ def _read_table_from_model_database(table_config, db_config):
     Table
         Astropy table
     """
-    db = db_handler.DatabaseHandler(db_config=db_config)
+    db = db_handler.DatabaseHandler()
     return db.export_model_file(
         parameter=table_config["parameter"],
         site=table_config["site"],
@@ -170,15 +166,11 @@ def _validate_config_columns(config, valid_columns, logger):
 
 def _get_valid_columns(table):
     """Return columns that exist and have valid data (not all NaN)."""
-    valid_columns = []
-    for col in table.colnames:
-        if not all(np.isnan(table[col])):
-            valid_columns.append(col)
-    return valid_columns
+    return [col for col in table.colnames if not all(np.isnan(table[col]))]
 
 
 def generate_plot_configurations(
-    parameter, parameter_version, site, telescope, output_path, plot_type, db_config
+    parameter, parameter_version, site, telescope, output_path, plot_type
 ):
     """
     Generate plot configurations for a model parameter from schema files.
@@ -197,8 +189,6 @@ def generate_plot_configurations(
         Output path for the plots.
     plot_type: str
         Plot type or "all" for all plots.
-    db_config: dict
-        Database configuration.
 
     Returns
     -------
@@ -226,7 +216,6 @@ def generate_plot_configurations(
             "telescope": telescope,
             "parameter_version": parameter_version,
         },
-        db_config=db_config,
     )
     valid_columns = _get_valid_columns(table)
 

simtools/visualization/visualize.py

@@ -11,6 +11,7 @@ import matplotlib.pyplot as plt
 from astropy.table import QTable
 from cycler import cycler
 from matplotlib import gridspec
+from matplotlib.backends.backend_pdf import PdfPages
 
 COLORS = {}
 COLORS["classic"] = [
@@ -615,7 +616,7 @@ def plot_hist_2d(data, **kwargs):
     return fig
 
 
-def save_figure(fig, output_file, figure_format=None, log_title="", dpi="figure"):
+def save_figure(fig, output_file, figure_format=("pdf", "png"), log_title="", dpi="figure"):
     """
     Save figure to output file(s).
 
@@ -630,10 +631,29 @@ def save_figure(fig, output_file, figure_format=None, log_title="", dpi="figure"
     title: str
         Title of the figure to be added to the log message.
     """
-    figure_format = figure_format or ["pdf", "png"]
     for fmt in figure_format:
         _file = Path(output_file).with_suffix(f".{fmt}")
         fig.savefig(_file, format=fmt, bbox_inches="tight", dpi=dpi)
         logging.info(f"Saved plot {log_title} to {_file}")
 
     fig.clf()
+
+
+def save_figures_to_single_document(figs, output_file_name):
+    """
+    Save multiple figures to a single PDF document.
+
+    Parameters
+    ----------
+    figs: list
+        List of plt.figure instances to save.
+    output_file_name: Path, str
+        PDF file name
+    """
+    _logger.info(f"Saving {len(figs)} figures to {output_file_name}")
+    pdf_pages = PdfPages(Path(output_file_name).absolute().as_posix())
+    for fig in figs:
+        plt.tight_layout()
+        pdf_pages.savefig(fig)
+
+    pdf_pages.close()