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

simtools/applications/plot_simtel_events.py

@@ -3,9 +3,9 @@
 r"""
 Plot simulated events.
 
-This application produces figures from one or more sim_telarray (.simtel.zst) files
-by calling functions in ``simtools.visualization.simtel_event_plots``. It is meant to
-run after simulations (e.g., simtools-simulate-flasher, simtools-simulate-illuminator).
+Produces figures from one or more sim_telarray (.simtel.zst) files
+It is meant to run after simulations (e.g., simtools-simulate-flasher,
+simtools-simulate-illuminator).
 
 What it does
 ------------
@@ -81,29 +81,8 @@ from pathlib import Path
 
 import simtools.utils.general as gen
 from simtools.configuration import configurator
-from simtools.corsika.corsika_histograms_visualize import save_figs_to_pdf
-from simtools.data_model.metadata_collector import MetadataCollector
 from simtools.io import io_handler
-from simtools.visualization.simtel_event_plots import (
-    plot_simtel_event_image,
-    plot_simtel_integrated_pedestal_image,
-    plot_simtel_integrated_signal_image,
-    plot_simtel_peak_timing,
-    plot_simtel_step_traces,
-    plot_simtel_time_traces,
-    plot_simtel_waveform_matrix,
-)
-
-PLOT_CHOICES = {
-    "event_image": "event_image",
-    "time_traces": "time_traces",
-    "waveform_matrix": "waveform_matrix",
-    "step_traces": "step_traces",
-    "integrated_signal_image": "integrated_signal_image",
-    "integrated_pedestal_image": "integrated_pedestal_image",
-    "peak_timing": "peak_timing",
-    "all": "all",
-}
+from simtools.visualization.plot_simtel_events import PLOT_CHOICES, generate_and_save_plots
 
 
 def _parse(label: str):
@@ -128,7 +107,6 @@ def _parse(label: str):
         default=["event_image"],
         choices=sorted(PLOT_CHOICES),
     )
-    # common plotting options
     config.parser.add_argument("--tel_id", type=int, default=None, help="Telescope ID")
     config.parser.add_argument(
         "--n_pixels", type=int, default=3, help="For time_traces: number of pixel traces"
@@ -179,7 +157,6 @@ def _parse(label: str):
         default=None,
         help="0-based index of the event to plot; default is the first event",
     )
-    # outputs
     config.parser.add_argument(
         "--output_file",
         type=str,
@@ -199,139 +176,6 @@ def _parse(label: str):
     return config.initialize(db_config=False, require_command_line=True)
 
 
-def _save_png(fig, out_dir: Path, stem: str, suffix: str, dpi: int):
-    """Save ``fig`` as a PNG into ``out_dir`` using ``stem`` and ``suffix``.
-
-    Errors during saving are logged as warnings and otherwise ignored.
-    """
-    png_path = out_dir.joinpath(f"{stem}_{suffix}.png")
-    try:
-        fig.savefig(png_path, dpi=dpi, bbox_inches="tight")
-    except Exception as ex:  # pylint:disable=broad-except
-        logging.getLogger(__name__).warning("Failed to save PNG %s: %s", png_path, ex)
-
-
-def _make_output_paths(
-    ioh: io_handler.IOHandler, base: str | None, input_file: Path
-) -> tuple[Path, Path]:
-    """Return (out_dir, pdf_path) based on base and input_file."""
-    out_dir = ioh.get_output_directory(label=Path(__file__).stem)
-    if base:
-        pdf_path = ioh.get_output_file(f"{base}_{input_file.stem}")
-    else:
-        pdf_path = ioh.get_output_file(input_file.stem)
-    pdf_path = Path(f"{pdf_path}.pdf") if pdf_path.suffix != ".pdf" else Path(pdf_path)
-    return out_dir, pdf_path
-
-
-def _collect_figures_for_file(
-    filename: Path,
-    plots: list[str],
-    args: dict,
-    out_dir: Path,
-    base_stem: str,
-    save_pngs: bool,
-    dpi: int,
-):
-    """Generate the selected plots for a single sim_telarray file.
-
-    Returns a list of figures. If ``save_pngs`` is True, also writes PNGs to
-    ``out_dir`` using ``base_stem`` for filenames.
-    """
-    logger = logging.getLogger(__name__)
-    figures: list[object] = []
-
-    def add(fig, tag: str):
-        if fig is not None:
-            figures.append(fig)
-            if save_pngs:
-                _save_png(fig, out_dir, base_stem, tag, dpi)
-        else:
-            logger.warning("Plot '%s' returned no figure for %s", tag, filename)
-
-    plots_to_run = (
-        [
-            "event_image",
-            "time_traces",
-            "waveform_matrix",
-            "step_traces",
-            "integrated_signal_image",
-            "integrated_pedestal_image",
-            "peak_timing",
-        ]
-        if "all" in plots
-        else list(plots)
-    )
-
-    def _call_peak_timing():
-        try:
-            fig_stats = plot_simtel_peak_timing(
-                filename,
-                tel_id=args.get("tel_id"),
-                sum_threshold=args.get("sum_threshold", 10.0),
-                peak_width=args.get("peak_width", 8),
-                examples=args.get("examples", 3),
-                timing_bins=args.get("timing_bins"),
-                return_stats=True,
-                event_index=args.get("event_index"),
-            )
-            return fig_stats[0] if isinstance(fig_stats, tuple) else fig_stats
-        except TypeError:
-            return plot_simtel_peak_timing(
-                filename,
-                tel_id=args.get("tel_id"),
-                sum_threshold=args.get("sum_threshold", 10.0),
-                peak_width=args.get("peak_width", 8),
-                examples=args.get("examples", 3),
-                timing_bins=args.get("timing_bins"),
-                event_index=args.get("event_index"),
-            )
-
-    # function name -> (callable, defaults)
-    dispatch: dict[str, tuple[object, dict[str, object]]] = {
-        "event_image": (
-            plot_simtel_event_image,
-            {"distance": None, "event_index": None},
-        ),
-        "time_traces": (
-            plot_simtel_time_traces,
-            {"tel_id": None, "n_pixels": 3, "event_index": None},
-        ),
-        "waveform_matrix": (
-            plot_simtel_waveform_matrix,
-            {"tel_id": None, "vmax": None, "event_index": None},
-        ),
-        "step_traces": (
-            plot_simtel_step_traces,
-            {"tel_id": None, "pixel_step": None, "max_pixels": None, "event_index": None},
-        ),
-        "integrated_signal_image": (
-            plot_simtel_integrated_signal_image,
-            {"tel_id": None, "half_width": 8, "event_index": None},
-        ),
-        "integrated_pedestal_image": (
-            plot_simtel_integrated_pedestal_image,
-            {"tel_id": None, "half_width": 8, "offset": 16, "event_index": None},
-        ),
-    }
-
-    for plot_name in plots_to_run:
-        if plot_name == "peak_timing":
-            add(_call_peak_timing(), "peak_timing")
-            continue
-        entry = dispatch.get(plot_name)
-        if entry is None:
-            logger.warning("Unknown plot selection '%s'", plot_name)
-            continue
-        func, defaults = entry
-        # Build kwargs with user args overriding defaults
-        kwargs = {k: args.get(k, v) for k, v in defaults.items()}
-        fig = func(filename, **kwargs)  # type: ignore[misc]
-        add(fig, plot_name)
-
-    return figures
-
-
 def main():
     """Generate plots from sim_telarray files."""
     label = Path(__file__).stem
@@ -341,38 +185,10 @@ def main():
     logger.setLevel(gen.get_log_level_from_user(args.get("log_level", "INFO")))
 
     ioh = io_handler.IOHandler()
-
     simtel_files = [Path(p).expanduser() for p in gen.ensure_iterable(args["simtel_files"])]
     plots = list(gen.ensure_iterable(args.get("plots")))
 
-    for simtel in simtel_files:
-        out_dir, pdf_path = _make_output_paths(ioh, args.get("output_file"), simtel)
-        figures = _collect_figures_for_file(
-            filename=simtel,
-            plots=plots,
-            args=args,
-            out_dir=out_dir,
-            base_stem=simtel.stem,
-            save_pngs=bool(args.get("save_pngs", False)),
-            dpi=int(args.get("dpi", 300)),
-        )
-
-        if not figures:
-            logger.warning("No figures produced for %s", simtel)
-            continue
-
-        # Save a multipage PDF
-        try:
-            save_figs_to_pdf(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)
-
-        # Dump run metadata alongside PDF
-        try:
-            MetadataCollector.dump(args, pdf_path, add_activity_name=True)
-        except Exception as ex:  # pylint:disable=broad-except
-            logger.warning("Failed to write metadata for %s: %s", pdf_path, ex)
+    generate_and_save_plots(simtel_files=simtel_files, plots=plots, args=args, ioh=ioh)
 
 
 if __name__ == "__main__":

simtools/applications/print_version.py

@@ -39,7 +39,7 @@ def _parse(label, description, usage):
     """
     config = configurator.Configurator(label=label, description=description, usage=usage)
 
-    return config.initialize(db_config=True, output=True)
+    return config.initialize(db_config=True, output=True, require_command_line=False)
 
 
 def main():
@@ -68,12 +68,13 @@ def main():
         key, value = version_entry.split(": ", 1)
         version_dict[key] = value
 
-    ascii_handler.write_data_to_file(
-        data=version_dict,
-        output_file=io_handler_instance.get_output_file(
-            args_dict.get("output_file", "simtools_version.json"), label=label
-        ),
-    )
+    if not args_dict.get("output_file_from_default", False):
+        ascii_handler.write_data_to_file(
+            data=version_dict,
+            output_file=io_handler_instance.get_output_file(
+                args_dict.get("output_file", "simtools_version.json"), label=label
+            ),
+        )
 
 
 if __name__ == "__main__":

simtools/applications/validate_file_using_schema.py

@@ -145,10 +145,13 @@ def validate_dict_using_schema(args_dict, logger):
         except FileNotFoundError as exc:
             raise FileNotFoundError(f"Error reading schema file from {file_name}") from exc
         data = data if isinstance(data, list) else [data]
-        for data_dict in data:
-            schema.validate_dict_using_schema(
-                data_dict, _get_schema_file_name(args_dict, data_dict)
-            )
+        try:
+            for data_dict in data:
+                schema.validate_dict_using_schema(
+                    data_dict, _get_schema_file_name(args_dict, data_dict)
+                )
+        except Exception as exc:
+            raise ValueError(f"Validation of file {file_name} failed") from exc
         logger.info(f"Successful validation of file {file_name}")
 
 

simtools/configuration/commandline_parser.py

@@ -222,6 +222,13 @@ class CommandLineParser(argparse.ArgumentParser):
             required=False,
             default=None,
         )
+        _job_group.add_argument(
+            "--db_simulation_model_version",
+            help="version of simulation model database",
+            type=str.strip,
+            required=False,
+            default=None,
+        )
 
     def initialize_simulation_model_arguments(self, model_options):
         """
@@ -740,28 +747,27 @@ class CommandLineParser(argparse.ArgumentParser):
     @staticmethod
     def parse_quantity_pair(string):
         """
-        Parse a string representing a pair of astropy quantities separated by a space.
-
-        Args:
-            string: The input string (e.g., "0 deg 1.5 deg").
+        Parse a string representing a pair of astropy quantities.
 
         Returns
         -------
-            tuple: A tuple containing two astropy.units.Quantity objects.
+        tuple
+            A tuple of two astropy.units.Quantity objects.
 
         Raises
         ------
-            ValueError: If the string is not formatted correctly (e.g., missing space).
+        ValueError
+            If the string cannot be parsed into exactly two quantities.
         """
-        pattern = r"(\d+\.?\d*)\s*([a-zA-Z]+)"
+        pattern = r"(?>[\d\.eE+-]+)\s*(?>[A-Za-z]+)"
         matches = re.findall(pattern, string)
         if len(matches) != 2:
             raise ValueError("Input string does not contain exactly two quantities.")
 
-        return (
-            u.Quantity(float(matches[0][0]), matches[0][1]),
-            u.Quantity(float(matches[1][0]), matches[1][1]),
-        )
+        try:
+            return tuple(u.Quantity(m) for m in matches)
+        except Exception as exc:
+            raise ValueError(f"Could not parse quantities: {exc}") from exc
 
     @staticmethod
     def parse_integer_and_quantity(input_string):

simtools/corsika/corsika_histograms.py

@@ -22,6 +22,7 @@ from simtools.io.ascii_handler import collect_data_from_file
 from simtools.io.hdf5_handler import fill_hdf5_table
 from simtools.utils.geometry import convert_2d_to_radial_distr, rotate
 from simtools.utils.names import sanitize_name
+from simtools.visualization import plot_corsika_histograms as visualize
 
 X_AXIS_STRING = "x axis"
 Y_AXIS_STRING = "y axis"
@@ -111,6 +112,86 @@ class CorsikaHistograms:
         self.read_event_information()
         self._initialize_header()
 
+    def parse_telescope_indices(self, indices_arg):
+        """Return telescope indices as ndarray[int] or None.
+
+        Accepts None, a sequence of strings/ints. Raises ValueError on invalid input.
+        """
+        if indices_arg is None:
+            return None
+        try:
+            return np.array(indices_arg).astype(int)
+        except ValueError as exc:
+            msg = (
+                f"{indices_arg} not a valid input. Please use integer numbers for telescope_indices"
+            )
+            self._logger.error(msg)
+            raise ValueError(msg) from exc
+
+    def should_overwrite(
+        self, write_hdf5: bool, event1d: list | None, event2d: list | None
+    ) -> bool:
+        """Return True if output HDF5 exists and any writing flag is requested."""
+        exists = Path(self.hdf5_file_name).exists()
+        if exists and (write_hdf5 or bool(event1d) or bool(event2d)):
+            self._logger.warning(
+                f"Output hdf5 file {self.hdf5_file_name} already exists. Overwriting it."
+            )
+            return True
+        return False
+
+    def run_export_pipeline(
+        self,
+        *,
+        individual_telescopes: bool,
+        hist_config,
+        indices_arg,
+        write_pdf: bool,
+        write_hdf5: bool,
+        event1d: list | None,
+        event2d: list | None,
+        test: bool = False,
+    ) -> dict:
+        """Run the full histogram export pipeline and return output artifact paths.
+
+        Returns a dict with optional keys: pdf_photons, pdf_event1d, pdf_event2d.
+        """
+        outputs: dict[str, Path | None] = {
+            "pdf_photons": None,
+            "pdf_event_1d": None,
+            "pdf_event_2d": None,
+        }
+
+        indices = self.parse_telescope_indices(indices_arg)
+        overwrite = self.should_overwrite(write_hdf5, event1d, event2d)
+
+        self.set_histograms(
+            telescope_indices=indices,
+            individual_telescopes=individual_telescopes,
+            hist_config=hist_config,
+        )
+
+        if write_pdf:
+            pdf_path = visualize.export_all_photon_figures_pdf(self, test=test)
+            outputs["pdf_photons"] = pdf_path
+        if write_hdf5:
+            self.export_histograms(overwrite=overwrite)
+
+        if event1d is not None:
+            outputs["pdf_event_1d"] = visualize.derive_event_1d_histograms(
+                self, event1d, pdf=write_pdf, hdf5=write_hdf5, overwrite=not write_hdf5
+            )
+        if event2d is not None:
+            outputs["pdf_event_2d"] = visualize.derive_event_2d_histograms(
+                self,
+                event2d,
+                pdf=write_pdf,
+                hdf5=write_hdf5,
+                overwrite=not (write_hdf5 or bool(event1d)),
+            )
+
+        return outputs
+
     @property
     def hdf5_file_name(self):
         """

simtools/data_model/validate_data.py

@@ -187,9 +187,14 @@ class DataValidator:
         value_as_list, unit_as_list = self._get_value_and_units_as_lists()
 
         for index, (value, unit) in enumerate(zip(value_as_list, unit_as_list)):
-            value_as_list[index], unit_as_list[index] = self._validate_value_and_unit(
-                value, unit, index
-            )
+            try:
+                value_as_list[index], unit_as_list[index] = self._validate_value_and_unit(
+                    value, unit, index
+                )
+            except TypeError as ex:
+                raise TypeError(
+                    f"Error validating dictionary using {self.schema_file_name}"
+                ) from ex
 
         if len(value_as_list) == 1:
             self.data_dict["value"], self.data_dict["unit"] = value_as_list[0], unit_as_list[0]