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

simtools/corsika/corsika_histograms.py

@@ -1,8 +1,6 @@
 """Extract Cherenkov photons from a CORSIKA IACT file and fill histograms."""
 
-import functools
 import logging
-import operator
 from pathlib import Path
 
 import boost_histogram as bh
@@ -21,6 +19,9 @@ class CorsikaHistograms:
     ----------
     input_file: str or Path
         CORSIKA IACT file.
+    axis_distance: astropy.units.Quantity or float
+        Distance from the axis to consider when calculating the lateral density profiles
+        along x and y axes. If a float is given, it is assumed to be in meters.
 
     Raises
     ------
@@ -28,30 +29,23 @@ class CorsikaHistograms:
         if the input file given does not exist.
     """
 
-    def __init__(self, input_file):
+    def __init__(self, input_file, normalization_method="per-telescope", axis_distance=1000 * u.m):
         self._logger = logging.getLogger(__name__)
-        self._logger.debug("Init CorsikaHistograms")
         self.input_file = Path(input_file)
         if not self.input_file.exists():
             raise FileNotFoundError(f"File {self.input_file} does not exist.")
 
+        self.axis_distance = (
+            axis_distance.to(u.m).value if isinstance(axis_distance, u.Quantity) else axis_distance
+        )
         self.events = None
         self.hist = self._set_2d_distributions()
         self.hist.update(self._set_1d_distributions())
+        self._density_samples = []
+        self.normalization_method = normalization_method
 
     def fill(self):
-        """
-        Fill Cherenkov photons histograms.
-
-        Returns
-        -------
-        list: list of boost_histogram.Histogram instances.
-
-        Raises
-        ------
-        AttributeError:
-            if event has not photon saved.
-        """
+        """Fill Cherenkov photons histograms."""
         self._read_event_headers()
 
         with IACTFile(self.input_file) as f:
@@ -59,7 +53,7 @@ class CorsikaHistograms:
             for event_counter, event in enumerate(f):
                 if hasattr(event, "photon_bunches"):
                     photons = list(event.photon_bunches.values())
-                    self._fill_histograms(photons, event_counter, telescope_positions, True)
+                    self._fill_histograms(photons, event_counter, telescope_positions, False)
 
         self._update_distributions()
 
@@ -155,7 +149,10 @@ class CorsikaHistograms:
             incoming direction of the primary particle.
         """
         hist_str = "histogram"
-        for photon, telescope in zip(photons, telescope_positions):
+        photons_per_telescope = np.zeros(len(telescope_positions))
+        zenith_rad = np.deg2rad(self.events["zenith_deg"][event_counter])
+
+        for tel_idx, (photon, telescope) in enumerate(zip(photons, telescope_positions)):
             if rotate_photons:
                 px, py = rotate(
                     photon["x"],
@@ -166,16 +163,16 @@ class CorsikaHistograms:
             else:
                 px, py = photon["x"], photon["y"]
 
-            px -= telescope["x"]
-            py -= telescope["y"]
+            px = px - telescope["x"]
+            py = py - telescope["y"]
             w = photon["photons"]
 
             pxm = px * u.cm.to(u.m)
             pym = py * u.cm.to(u.m)
             zem = (photon["zem"] * u.cm).to(u.km)
+            photons_per_telescope[tel_idx] += np.sum(w)
 
             self.hist["counts_xy"][hist_str].fill(pxm, pym, weight=w)
-            self.hist["density_xy"][hist_str].fill(pxm, pym, weight=w)
             self.hist["direction_xy"][hist_str].fill(photon["cx"], photon["cy"], weight=w)
             self.hist["time_altitude"][hist_str].fill(photon["time"] * u.ns, zem, weight=w)
             self.hist["wavelength_altitude"][hist_str].fill(
@@ -184,10 +181,23 @@ class CorsikaHistograms:
 
             r = np.hypot(px, py) * u.cm.to(u.m)
             self.hist["counts_r"][hist_str].fill(r, weight=w)
-            self.hist["density_r"][hist_str].fill(r, weight=w)
 
             self.events["num_photons"][event_counter] += np.sum(w)
 
+        for tel_idx, telescope in enumerate(telescope_positions):
+            area = np.pi * (telescope["r"] ** 2) / np.cos(zenith_rad) / 1.0e4  # in m^2
+            n_photons = photons_per_telescope[tel_idx]
+            density = n_photons / area if area > 0 else 0.0
+            density_error = np.sqrt(n_photons) / area if area > 0 else 0.0
+            self._density_samples.append(
+                {
+                    "x": telescope["x"] * u.cm.to(u.m),
+                    "y": telescope["y"] * u.cm.to(u.m),
+                    "density": density,
+                    "density_error": density_error,
+                }
+            )
+
     def get_hist_2d_projection(self, hist):
         """
         Get 2D distributions.
@@ -318,6 +328,9 @@ class CorsikaHistograms:
         x_axis_title = "x_axis_title"
         y_axis_unit = "y_axis_unit"
         y_axis_title = "y_axis_title"
+        log_y = "log_y"
+        photon_density = "Photon density"
+        distance_to_center = "Distance to center"
         hist_1d = {
             "wavelength": {
                 file_name: "hist_1d_photon_wavelength_distr",
@@ -328,27 +341,42 @@ class CorsikaHistograms:
                 file_name: "hist_1d_photon_radial_distr",
                 title: "Photon lateral distribution (ground level)",
                 x_bins: [bins, 0 * u.m, r_max, "linear"],
-                x_axis_title: "Distance to center",
+                x_axis_title: distance_to_center,
                 x_axis_unit: u.m,
             },
             "density_r": {
                 file_name: "hist_1d_photon_density_distr",
                 title: "Photon lateral density distribution (ground level)",
                 x_bins: [bins, 0 * u.m, r_max, "linear"],
-                x_axis_title: "Distance to center",
+                x_axis_title: distance_to_center,
+                x_axis_unit: u.m,
+                y_axis_title: photon_density,
+                y_axis_unit: u.m**-2,
+            },
+            "density_r_from_counts": {
+                file_name: "hist_1d_photon_density_from_counts_distr",
+                title: "Photon lateral density from counts distribution (ground level)",
+                x_bins: [bins, 0 * u.m, r_max, "linear"],
+                x_axis_title: distance_to_center,
                 x_axis_unit: u.m,
-                y_axis_title: "Photon density",
+                y_axis_title: photon_density,
                 y_axis_unit: u.m**-2,
             },
             "density_x": {
                 file_name: "hist_1d_photon_density_x_distr",
                 title: "Photon lateral density x distribution (ground level)",
-                projection: ["density_xy", "x"],
+                projection: ["counts_xy", "x"],  # projection requires counts_xy histogram
+                x_axis_title: distance_to_center,
+                x_axis_unit: u.m,
+                y_axis_title: photon_density,
+                y_axis_unit: u.m**-2,
             },
             "density_y": {
                 file_name: "hist_1d_photon_density_y_distr",
                 title: "Photon lateral density y distribution (ground level)",
-                projection: ["density_xy", "y"],
+                projection: ["counts_xy", "y"],  # projection requires counts_xy histogram
+                y_axis_title: photon_density,
+                y_axis_unit: u.m**-2,
             },
             "time": {
                 file_name: "hist_1d_photon_time_distr",
@@ -377,12 +405,13 @@ class CorsikaHistograms:
                 x_bins: [100, 0, None, "log"],
                 x_axis_title: "Cherenkov photons per event",
                 x_axis_unit: u.dimensionless_unscaled,
+                log_y: False,
             },
         }
 
         for value in hist_1d.values():
             value["is_1d"] = True
-            value["log_y"] = True
+            value["log_y"] = value.get("log_y", True)
             value[y_axis_title] = (
                 "Counts" if value.get(y_axis_title) is None else value[y_axis_title]
             )
@@ -419,6 +448,9 @@ class CorsikaHistograms:
         x_axis_title, x_axis_unit = "x_axis_title", "x_axis_unit"
         y_axis_title, y_axis_unit = "y_axis_title", "y_axis_unit"
         z_axis_title, z_axis_unit = "z_axis_title", "z_axis_unit"
+        photon_density = "Photon density"
+        x_pos = "x position on the ground"
+        y_pos = "y position on the ground"
 
         hist_2d = {
             "counts_xy": {
@@ -426,21 +458,33 @@ class CorsikaHistograms:
                 title: "Photon count distribution (ground level)",
                 x_bins: [xy_bin, -xy_maximum, xy_maximum, "linear"],
                 y_bins: [xy_bin, -xy_maximum, xy_maximum],
-                x_axis_title: "x position on the ground",
+                x_axis_title: x_pos,
                 x_axis_unit: xy_maximum.unit,
-                y_axis_title: "y position on the ground",
+                y_axis_title: y_pos,
                 y_axis_unit: xy_maximum.unit,
             },
             "density_xy": {
                 file_name: "hist_2d_photon_density_distr",
-                title: "Photon lateral density distribution (ground level)",
+                title: "Photon density distribution (ground level)",
+                x_bins: [xy_bin, -xy_maximum, xy_maximum, "linear"],
+                y_bins: [xy_bin, -xy_maximum, xy_maximum, "linear"],
+                x_axis_title: x_pos,
+                x_axis_unit: xy_maximum.unit,
+                y_axis_title: y_pos,
+                y_axis_unit: xy_maximum.unit,
+                z_axis_title: photon_density,
+                z_axis_unit: u.m**-2,
+            },
+            "density_xy_from_counts": {
+                file_name: "hist_2d_photon_density_from_counts_distr",
+                title: "Photon density from counts distribution (ground level)",
                 x_bins: [xy_bin, -xy_maximum, xy_maximum, "linear"],
                 y_bins: [xy_bin, -xy_maximum, xy_maximum, "linear"],
-                x_axis_title: "x position on the ground",
+                x_axis_title: x_pos,
                 x_axis_unit: xy_maximum.unit,
-                y_axis_title: "y position on the ground",
+                y_axis_title: y_pos,
                 y_axis_unit: xy_maximum.unit,
-                z_axis_title: "Photon density",
+                z_axis_title: photon_density,
                 z_axis_unit: u.m**-2,
             },
             "direction_xy": {
@@ -493,50 +537,183 @@ class CorsikaHistograms:
 
     def _update_distributions(self):
         """Update the distributions dictionary with the histogram values and bin edges."""
-        self._normalize_density_histograms()
+        self._populate_density_from_probes()
+        self._populate_density_from_counts()
+        self._filter_density_histograms()
 
         for key, value in self.hist.items():
             value["input_file_name"] = str(self.input_file)
-            if value["is_1d"]:
-                value["hist_values"], value["x_bin_edges"], value["uncertainties"] = (
-                    self.get_hist_1d_projection(key, value)
-                )
-            else:
-                (
-                    value["hist_values"],
-                    value["x_bin_edges"],
-                    value["y_bin_edges"],
-                    value["uncertainties"],
-                ) = self.get_hist_2d_projection(value["histogram"])
+            if "hist_values" not in value:
+                if value["is_1d"]:
+                    (
+                        value["hist_values"],
+                        value["x_bin_edges"],
+                        value["uncertainties"],
+                    ) = self.get_hist_1d_projection(key, value)
+                else:
+                    (
+                        value["hist_values"],
+                        value["x_bin_edges"],
+                        value["y_bin_edges"],
+                        value["uncertainties"],
+                    ) = self.get_hist_2d_projection(value["histogram"])
+
+    def _filter_density_histograms(self):
+        """Filter density histograms based on the normalization method."""
+        if self.normalization_method == "per-telescope":
+            keys_to_remove = ["density_xy_from_counts", "density_r_from_counts"]
+        elif self.normalization_method == "per-bin":
+            keys_to_remove = ["density_xy", "density_x", "density_y", "density_r"]
+        else:
+            raise ValueError(
+                f"Unknown normalization_method: {self.normalization_method}. "
+                "Must be 'per-telescope' or 'per-bin'."
+            )
 
-    def _normalize_density_histograms(self):
-        """Normalize the density histograms by the area of each bin."""
+        for key in keys_to_remove:
+            if key in self.hist:
+                del self.hist[key]
 
-        def normalize_histogram(hist, bin_areas):
-            view = hist.view()
-            if self._check_for_all_attributes(view):
-                view["value"] /= bin_areas
-                view["variance"] /= bin_areas**2
-            else:
-                hist /= bin_areas
+    def _fill_projected_density_values(self, value):
+        """Extract 1D density by using projection Counts and normalizing by area."""
+        histo_2d = value["projection"][0]
+        source_h = self.hist[histo_2d]["histogram"]
+        project_axis = value["projection"][1]
 
-        def normalize_histogram_1d(hist, bin_areas):
-            view = hist.view()
-            if self._check_for_all_attributes(view):
-                view["value"] /= bin_areas
-                view["variance"] /= bin_areas**2
-            else:
-                view /= bin_areas
+        if project_axis == "x":
+            h_1d = source_h[:, sum]
+            total_ortho_width = source_h.axes[1].edges[-1] - source_h.axes[1].edges[0]
+        else:
+            h_1d = source_h[sum, :]
+            total_ortho_width = source_h.axes[0].edges[-1] - source_h.axes[0].edges[0]
+
+        areas_1d = h_1d.axes[0].widths * total_ortho_width
+
+        view = h_1d.view()
+        if self._check_for_all_attributes(view):
+            vals = view["value"] / areas_1d
+            uncs = np.sqrt(view["variance"]) / areas_1d
+        else:
+            vals = view / areas_1d
+            uncs = np.sqrt(vals)  # Fallback if no weights
+
+        value["hist_values"] = np.asarray([vals.T])
+        value["x_bin_edges"] = np.asarray([h_1d.axes.edges[0]])
+        value["uncertainties"] = np.asarray([uncs.T])
+
+    def _populate_density_from_probes(self):
+        """Build density distributions from per-telescope sampling."""
+        if not self._density_samples:
+            return
+
+        s = self._density_samples
+        xs, ys = (np.array([p[k] for p in s]) for k in ("x", "y"))
+        dens = np.array([p["density"] for p in s])
+        errs = np.array([p["density_error"] for p in s])
+
+        hxy = self.hist["counts_xy"]["histogram"]
+        x_edges, y_edges = hxy.axes[0].edges, hxy.axes[1].edges
+        r_edges = self.hist["density_r"]["histogram"].axes[0].edges
+
+        def avg_unc_nd(coords, edges, values, errors):
+            num = np.histogramdd(coords, bins=edges, weights=values)[0]
+            den = np.histogramdd(coords, bins=edges)[0]
+            var = np.histogramdd(coords, bins=edges, weights=errors**2)[0]
+            with np.errstate(divide="ignore", invalid="ignore"):
+                avg = np.divide(num, den, out=np.zeros_like(num), where=den > 0)
+                unc = np.sqrt(np.divide(var, den**2, out=np.zeros_like(var), where=den > 0))
+            return avg, unc
+
+        # 2D
+        avg_xy, unc_xy = avg_unc_nd(np.column_stack((xs, ys)), (x_edges, y_edges), dens, errs)
+
+        self.hist["density_xy"].update(
+            {
+                "hist_values": np.asarray([avg_xy.T]),
+                "x_bin_edges": np.asarray([x_edges]),
+                "y_bin_edges": np.asarray([y_edges]),
+                "uncertainties": np.asarray([unc_xy.T]),
+            }
+        )
+
+        # 1D helpers
+        def avg_unc_1d(x, e, v, err):
+            return avg_unc_nd(x[:, None], (e,), v, err)
+
+        ax = self.axis_distance
 
-        density_xy_hist = self.hist["density_xy"]["histogram"]
-        density_r_hist = self.hist["density_r"]["histogram"]
+        avg_x, unc_x = (
+            avg_unc_1d(xs[np.abs(ys) < ax], x_edges, dens[np.abs(ys) < ax], errs[np.abs(ys) < ax])
+            if np.any(np.abs(ys) < ax)
+            else (np.zeros(len(x_edges) - 1),) * 2
+        )
+
+        avg_y, unc_y = (
+            avg_unc_1d(ys[np.abs(xs) < ax], y_edges, dens[np.abs(xs) < ax], errs[np.abs(xs) < ax])
+            if np.any(np.abs(xs) < ax)
+            else (np.zeros(len(y_edges) - 1),) * 2
+        )
+
+        # Radial density
+        rs = np.hypot(xs, ys)
+        avg_r, unc_r = avg_unc_1d(rs, r_edges, dens, errs)
+
+        for k, avg, unc, edges in (
+            ("density_x", avg_x, unc_x, x_edges),
+            ("density_y", avg_y, unc_y, y_edges),
+            ("density_r", avg_r, unc_r, r_edges),
+        ):
+            self.hist[k].update(
+                {
+                    "hist_values": np.asarray([avg]),
+                    "x_bin_edges": np.asarray([edges]),
+                    "uncertainties": np.asarray([unc]),
+                }
+            )
 
-        bin_areas_xy = functools.reduce(operator.mul, density_xy_hist.axes.widths)
-        normalize_histogram(density_xy_hist, bin_areas_xy)
+    def _populate_density_from_counts(self):
+        """Build density distributions by dividing counts histograms by bin area."""
+        # --- 2D ---
+        hxy = self.hist["counts_xy"]["histogram"]
+        xw = np.diff(hxy.axes[0].edges)
+        yw = np.diff(hxy.axes[1].edges)
+        areas2d = np.outer(xw, yw)
+
+        dens_xy, unc_xy = self._density_and_unc(hxy.view(), areas2d)
+
+        self.hist["density_xy_from_counts"].update(
+            {
+                "hist_values": np.asarray([dens_xy.T]),
+                "x_bin_edges": np.asarray([hxy.axes[0].edges]),
+                "y_bin_edges": np.asarray([hxy.axes[1].edges]),
+                "uncertainties": np.asarray([unc_xy.T]),
+            }
+        )
+
+        # --- 1D ---
+        hr = self.hist["counts_r"]["histogram"]
+        r = hr.axes[0].edges
+        areas1d = np.pi * (r[1:] ** 2 - r[:-1] ** 2)
 
-        bin_edges_r = density_r_hist.axes.edges[0]
-        bin_areas_r = np.pi * (bin_edges_r[1:] ** 2 - bin_edges_r[:-1] ** 2)
-        normalize_histogram_1d(density_r_hist, bin_areas_r)
+        dens_r, unc_r = self._density_and_unc(hr.view(), areas1d)
+
+        self.hist["density_r_from_counts"].update(
+            {
+                "hist_values": np.asarray([dens_r]),
+                "x_bin_edges": np.asarray([r]),
+                "uncertainties": np.asarray([unc_r]),
+            }
+        )
+
+    def _density_and_unc(self, view, areas):
+        """Calculate density and uncertainty by dividing histogram values by areas."""
+        if self._check_for_all_attributes(view):
+            values = view["value"]
+            unc = np.sqrt(view["variance"])
+        else:
+            values = view
+            unc = np.sqrt(view)
+        return values / areas, unc / areas
 
     def _check_for_all_attributes(self, view):
         """Check if view has dtype fields ('value', 'variance')."""

simtools/data_model/model_data_writer.py

@@ -7,6 +7,7 @@ import packaging.version
 from astropy.io.registry.base import IORegistryError
 
 import simtools.utils.general as gen
+from simtools import settings
 from simtools.data_model import schema, validate_data
 from simtools.data_model.metadata_collector import MetadataCollector
 from simtools.db import db_handler
@@ -20,69 +21,62 @@ class ModelDataWriter:
 
     Parameters
     ----------
-    product_data_file: str
+    output_file: str
         Name of output file.
-    product_data_format: str
+    output_file_format: str
         Format of output file.
-    args_dict: Dictionary
-        Dictionary with configuration parameters.
     output_path: str or Path
         Path to output file.
-    args_dict: dict
-        Dictionary with configuration parameters.
-
     """
 
-    def __init__(
-        self,
-        product_data_file=None,
-        product_data_format=None,
-        output_path=None,
-        args_dict=None,
-    ):
+    def __init__(self, output_file=None, output_file_format=None, output_path=None):
         """Initialize model data writer."""
         self._logger = logging.getLogger(__name__)
         self.io_handler = io_handler.IOHandler()
         self.schema_dict = {}
-        if args_dict is not None:
-            output_path = args_dict.get("output_path", output_path)
-        if output_path is not None:
-            self.io_handler.set_paths(output_path=output_path)
+        self.output_label = "model_data_writer"
+        self.io_handler.set_paths(
+            output_path=output_path or settings.config.args.get("output_path"),
+            output_path_label=self.output_label,
+        )
         try:
-            self.product_data_file = self.io_handler.get_output_file(file_name=product_data_file)
+            self.output_file = self.io_handler.get_output_file(
+                file_name=output_file, output_path_label=self.output_label
+            )
         except TypeError:
-            self.product_data_file = None
-        self.product_data_format = self._astropy_data_format(product_data_format)
+            self.output_file = None
+        self.output_file_format = self._derive_data_format(output_file_format, self.output_file)
 
     @staticmethod
     def dump(
-        args_dict, output_file=None, metadata=None, product_data=None, validate_schema_file=None
+        output_file=None,
+        metadata=None,
+        product_data=None,
+        output_file_format="ascii.ecsv",
+        validate_schema_file=None,
     ):
         """
         Write model data and metadata (as static method).
 
         Parameters
         ----------
-        args_dict: dict
-            Dictionary with configuration parameters (including output file name and path).
         output_file: string or Path
             Name of output file (args["output_file"] is used if this parameter is not set).
         metadata: MetadataCollector object
             Metadata to be written.
         product_data: astropy Table
             Model data to be written
+        output_file_format: str
+            Format of output file.
         validate_schema_file: str
             Schema file used in validation of output data.
-
         """
         writer = ModelDataWriter(
-            product_data_file=(
-                args_dict.get("output_file", None) if output_file is None else output_file
-            ),
-            product_data_format=args_dict.get("output_file_format", "ascii.ecsv"),
-            args_dict=args_dict,
+            output_file=output_file,
+            output_file_format=output_file_format,
         )
-        if validate_schema_file is not None and not args_dict.get("skip_output_validation", True):
+        skip_output_validation = settings.config.args.get("skip_output_validation", True)
+        if validate_schema_file is not None and not skip_output_validation:
             product_data = writer.validate_and_transform(
                 product_data_table=product_data,
                 validate_schema_file=validate_schema_file,
@@ -137,9 +131,8 @@ class ModelDataWriter:
             Validated parameter dictionary.
         """
         writer = ModelDataWriter(
-            product_data_file=output_file,
-            product_data_format="json",
-            args_dict=None,
+            output_file=output_file,
+            output_file_format="json",
             output_path=output_path,
         )
         if check_db_for_existing_parameter:
@@ -434,19 +427,17 @@ class ModelDataWriter:
                 gen.change_dict_keys_case(metadata.get_top_level_metadata(), True)
             )
 
-        self._logger.info(f"Writing data to {self.product_data_file}")
-        if isinstance(product_data, dict) and Path(self.product_data_file).suffix == ".json":
-            self.write_dict_to_model_parameter_json(self.product_data_file, product_data)
+        self._logger.info(f"Writing data to {self.output_file}")
+        if isinstance(product_data, dict) and Path(self.output_file).suffix == ".json":
+            self.write_dict_to_model_parameter_json(self.output_file, product_data)
             return
         try:
-            product_data.write(
-                self.product_data_file, format=self.product_data_format, overwrite=True
-            )
+            product_data.write(self.output_file, format=self.output_file_format, overwrite=True)
         except IORegistryError:
-            self._logger.error(f"Error writing model data to {self.product_data_file}.")
+            self._logger.error(f"Error writing model data to {self.output_file}.")
             raise
         if metadata is not None:
-            metadata.write(self.product_data_file, add_activity_name=True)
+            metadata.write(self.output_file, add_activity_name=True)
 
     def write_dict_to_model_parameter_json(self, file_name, data_dict):
         """
@@ -465,10 +456,13 @@ class ModelDataWriter:
             if data writing was not successful.
         """
         data_dict = ModelDataWriter.prepare_data_dict_for_writing(data_dict)
-        self._logger.info(f"Writing data to {self.io_handler.get_output_file(file_name)}")
+        output_file = self.io_handler.get_output_file(
+            file_name, output_path_label=self.output_label
+        )
+        self._logger.info(f"Writing data to {output_file}")
         ascii_handler.write_data_to_file(
             data=data_dict,
-            output_file=self.io_handler.get_output_file(file_name),
+            output_file=output_file,
             sort_keys=True,
             numpy_types=True,
         )
@@ -508,9 +502,12 @@ class ModelDataWriter:
         return data_dict
 
     @staticmethod
-    def _astropy_data_format(product_data_format):
+    def _derive_data_format(product_data_format, output_file=None):
         """
-        Ensure conformance with astropy data format naming.
+        Derive data format and ensure conformance with astropy data format naming.
+
+        If product_data_format is None and output_file is given, derive format
+        from output_file suffix.
 
         Parameters
         ----------
@@ -518,6 +515,6 @@ class ModelDataWriter:
             format identifier
 
         """
-        if product_data_format == "ecsv":
-            product_data_format = "ascii.ecsv"
-        return product_data_format
+        if product_data_format is None and output_file is not None:
+            product_data_format = Path(output_file).suffix.lstrip(".")
+        return "ascii.ecsv" if product_data_format == "ecsv" else product_data_format

simtools/data_model/schema.py

@@ -1,6 +1,7 @@
 """Module providing functionality to read and validate dictionaries using schema."""
 
 import logging
+from functools import lru_cache
 from pathlib import Path
 
 import jsonschema
@@ -153,6 +154,7 @@ def _validate_meta_schema_url(data):
         raise FileNotFoundError(f"Meta schema URL does not exist: {data['meta_schema_url']}")
 
 
+@lru_cache
 def _retrieve_yaml_schema_from_uri(uri):
     """Load schema from a file URI."""
     path = SCHEMA_PATH / Path(uri.removeprefix("file:/"))