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

simtools/simtel/simtel_io_event_histograms.py

@@ -1,11 +1,10 @@
 """Histograms for shower and triggered events."""
 
+import copy
 import logging
 
 import astropy.units as u
-import matplotlib.pyplot as plt
 import numpy as np
-from matplotlib.colors import LogNorm
 
 from simtools.simtel.simtel_io_event_reader import SimtelIOEventDataReader
 
@@ -15,6 +14,7 @@ class SimtelIOEventHistograms:
     Generate and fill histograms for shower and triggered events.
 
     Event data is read from the reduced MC event data file.
+    Calculate cumulative and relative (efficiency) distributions.
 
     Parameters
     ----------
@@ -31,54 +31,25 @@ class SimtelIOEventHistograms:
         self._logger = logging.getLogger(__name__)
         self.event_data_file = event_data_file
         self.array_name = array_name
-        self.telescope_list = telescope_list
 
         self.histograms = {}
         self.file_info = {}
 
         self.reader = SimtelIOEventDataReader(event_data_file, telescope_list=telescope_list)
 
-    def _fill_histogram_and_bin_edges(self, name, data, bins, hist1d=True):
-        """
-        Fill histogram and bin edges and it both to histogram dictionary.
-
-        Adds histogram to existing histogram if it exists, otherwise initializes it.
-
-        """
-        if name in self.histograms:
-            if hist1d:
-                bins = self.histograms[f"{name}_bin_edges"]
-                hist, _ = np.histogram(data, bins=bins)
-                self.histograms[name] += hist
-            else:
-                x_bins = self.histograms[f"{name}_bin_x_edges"]
-                y_bins = self.histograms[f"{name}_bin_y_edges"]
-                hist, _, _ = np.histogram2d(data[0], data[1], bins=[x_bins, y_bins])
-                self.histograms[name] += hist
-        else:
-            if hist1d:
-                hist, bin_edges = np.histogram(data, bins=bins)
-                self.histograms[name] = hist
-                self.histograms[f"{name}_bin_edges"] = bin_edges
-            else:
-                hist, x_edges, y_edges = np.histogram2d(data[0], data[1], bins=bins)
-                self.histograms[name] = hist
-                self.histograms[f"{name}_bin_x_edges"] = x_edges
-                self.histograms[f"{name}_bin_y_edges"] = y_edges
-
     def fill(self):
         """
         Fill histograms with event data.
 
         Involves looping over all event data, and therefore is the slowest part of the
-        limit calculation. Adds the histograms to the histogram dictionary.
+        histogram module. Adds the histograms to the histogram dictionary.
 
         Assume that all event data files are generated with similar configurations
-        (self.file_info contains the latest file info).
+        (self.file_info contains the file info of the last file).
         """
         for data_set in self.reader.data_sets:
             self._logger.info(f"Reading event data from {self.event_data_file} for {data_set}")
-            _file_info_table, _, event_data, triggered_data = self.reader.read_event_data(
+            _file_info_table, shower_data, event_data, triggered_data = self.reader.read_event_data(
                 self.event_data_file, table_name_map=data_set
             )
             _file_info_table = self.reader.get_reduced_simulation_file_info(_file_info_table)
@@ -86,533 +57,287 @@ class SimtelIOEventHistograms:
                 "energy_min": _file_info_table["energy_min"].to("TeV"),
                 "core_scatter_max": _file_info_table["core_scatter_max"].to("m"),
                 "viewcone_max": _file_info_table["viewcone_max"].to("deg"),
+                "solid_angle": _file_info_table["solid_angle"].to("sr"),
+                "scatter_area": _file_info_table["scatter_area"].to("cm2"),
             }
 
-            self._fill_histogram_and_bin_edges(
-                "energy", event_data.simulated_energy, self.energy_bins
-            )
-            self._fill_histogram_and_bin_edges(
-                "core_distance", event_data.core_distance_shower, self.core_distance_bins
-            )
-            self._fill_histogram_and_bin_edges(
-                "angular_distance", triggered_data.angular_distance, self.view_cone_bins
-            )
+            self.histograms = self._define_histograms(event_data, triggered_data, shower_data)
 
-            xy_bins = np.linspace(
-                -1.0 * self.core_distance_bins.max(),
-                self.core_distance_bins.max(),
-                len(self.core_distance_bins),
-            )
-            self._fill_histogram_and_bin_edges(
-                "shower_cores",
-                (event_data.x_core_shower, event_data.y_core_shower),
-                [xy_bins, xy_bins],
-                hist1d=False,
-            )
-            self._fill_histogram_and_bin_edges(
-                "core_vs_energy",
-                (event_data.core_distance_shower, event_data.simulated_energy),
-                [self.core_distance_bins, self.energy_bins],
-                hist1d=False,
-            )
-            self._fill_histogram_and_bin_edges(
-                "angular_distance_vs_energy",
-                (triggered_data.angular_distance, event_data.simulated_energy),
-                [self.view_cone_bins, self.energy_bins],
-                hist1d=False,
-            )
+            for name, data in self.histograms.items():
+                self._logger.debug(f"Filling histogram {name}")
+                self._fill_histogram_and_bin_edges(data)
 
-    @property
-    def energy_bins(self):
-        """Return bins for the energy histogram."""
-        if "energy_bin_edges" in self.histograms:
-            return self.histograms["energy_bin_edges"]
-        return np.logspace(
-            np.log10(self.file_info.get("energy_min", 1.0e-3 * u.TeV).to("TeV").value),
-            np.log10(self.file_info.get("energy_max", 1.0e3 * u.TeV).to("TeV").value),
-            100,
-        )
+        self.print_summary()
 
-    @property
-    def core_distance_bins(self):
-        """Return bins for the core distance histogram."""
-        if "core_distance_bin_edges" in self.histograms:
-            return self.histograms["core_distance_bin_edges"]
-        return np.linspace(
-            self.file_info.get("core_scatter_min", 0.0 * u.m).to("m").value,
-            self.file_info.get("core_scatter_max", 1.0e5 * u.m).to("m").value,
-            100,
-        )
+        self.calculate_efficiency_data()
+        self.calculate_cumulative_data()
 
-    @property
-    def view_cone_bins(self):
-        """Return bins for the viewcone histogram."""
-        if "viewcone_bin_edges" in self.histograms:
-            return self.histograms["viewcone_bin_edges"]
-        return np.linspace(
-            self.file_info.get("viewcone_min", 0.0 * u.deg).to("deg").value,
-            self.file_info.get("viewcone_max", 20.0 * u.deg).to("deg").value,
-            100,
-        )
-
-    def plot_data(self, output_path=None, limits=None, rebin_factor=2):
+    def _define_histograms(self, event_data, triggered_data, shower_data):
         """
-        Histogram plotting.
+        Define histograms including event data, binning, naming, and labels.
+
+        All histograms are defined for simulated and triggered events (note
+        the subtlety of triggered events being read from event_data and triggered_data).
 
         Parameters
         ----------
-        output_path: Path or str, optional
-            Directory to save plots. If None, plots will be displayed.
-        limits: dict, optional
-            Dictionary containing limits for plotting. Keys can include:
-            - "upper_radius_limit": Upper limit for core distance
-            - "lower_energy_limit": Lower limit for energy
-            - "viewcone_radius": Radius for the viewcone
-        rebin_factor: int, optional
-            Factor by which to reduce the number of bins in 2D histograms for rebinned plots.
-            Default is 2 (merge every 2 bins). Set to 0 or 1 to disable rebinning.
-        """
-        # Plot label constants
-        core_distance_label = "Core Distance [m]"
-        energy_label = "Energy [TeV]"
-        pointing_direction_label = "Distance to pointing direction [deg]"
-        cumulative_prefix = "Cumulative "
-        event_count_label = "Event Count"
-        core_x_label = "Core X [m]"
-        core_y_label = "Core Y [m]"
-
-        # Plot parameter constants
-        hist_1d_params = {"color": "tab:green", "edgecolor": "tab:green", "lw": 1}
-        hist_1d_cumulative_params = {"color": "tab:blue", "edgecolor": "tab:blue", "lw": 1}
-        hist_2d_params = {"norm": "log", "cmap": "viridis", "show_contour": False}
-        hist_2d_equal_params = {
-            "norm": "log",
-            "cmap": "viridis",
-            "aspect": "equal",
-            "show_contour": False,
-        }
-        hist_2d_normalized_params = {"norm": "linear", "cmap": "viridis", "show_contour": True}
-
-        self._logger.info(f"Plotting histograms written to {output_path}")
+        event_data : EventData
+            The event data to use for filling the histograms.
+        triggered_data : TriggeredData
+            The triggered data to use for filling the histograms.
+        shower_data : ShowerData
+            The shower data to use for filling the histograms.
 
-        angular_dist_vs_energy = self.histograms.get("angular_distance_vs_energy")
-        normalized_cumulative_angular_vs_energy = self._calculate_cumulative_histogram(
-            angular_dist_vs_energy, axis=0, normalize=True
-        )
-
-        core_vs_energy = self.histograms.get("core_vs_energy")
-        normalized_cumulative_core_vs_energy = self._calculate_cumulative_histogram(
-            core_vs_energy, axis=0, normalize=True
+        Returns
+        -------
+        dict
+            Dictionary with histogram definitions.
+        """
+        xy_bins = np.linspace(
+            -1.0 * self.core_distance_bins.max(),
+            self.core_distance_bins.max(),
+            len(self.core_distance_bins),
         )
-
-        energy_hist = self.histograms.get("energy")
-        cumulative_energy = self._calculate_cumulative_histogram(energy_hist, reverse=True)
-
-        core_distance_hist = self.histograms.get("core_distance")
-        cumulative_core_distance = self._calculate_cumulative_histogram(core_distance_hist)
-
-        angular_distance_hist = self.histograms.get("angular_distance")
-        cumulative_angular_distance = self._calculate_cumulative_histogram(angular_distance_hist)
-
-        upper_radius_limit, lower_energy_limit, viewcone_radius = self._get_limits(limits)
-
-        plots = {
-            "core_vs_energy": {
-                "data": self.histograms.get("core_vs_energy"),
-                "bins": [
-                    self.histograms.get("core_vs_energy_bin_x_edges"),
-                    self.histograms.get("core_vs_energy_bin_y_edges"),
-                ],
-                "plot_type": "histogram2d",
-                "plot_params": hist_2d_params,
-                "labels": {
-                    "x": core_distance_label,
-                    "y": energy_label,
-                    "title": "Triggered events: core distance vs energy",
-                },
-                "lines": {"x": upper_radius_limit, "y": lower_energy_limit},
-                "scales": {"y": "log"},
-                "colorbar_label": event_count_label,
-                "filename": "core_vs_energy_distribution",
-            },
-            "energy_distribution": {
-                "data": self.histograms.get("energy"),
-                "bins": self.histograms.get("energy_bin_edges"),
-                "plot_type": "histogram",
-                "plot_params": hist_1d_params,
-                "labels": {
-                    "x": energy_label,
-                    "y": event_count_label,
-                    "title": "Triggered events: energy distribution",
-                },
-                "scales": {"x": "log", "y": "log"},
-                "lines": {"x": lower_energy_limit},
-                "filename": "energy_distribution",
-            },
-            "energy_distribution_cumulative": {
-                "data": cumulative_energy,
-                "bins": self.histograms.get("energy_bin_edges"),
-                "plot_type": "histogram",
-                "plot_params": hist_1d_cumulative_params,
-                "labels": {
-                    "x": energy_label,
-                    "y": cumulative_prefix + event_count_label,
-                    "title": "Triggered events: cumulative energy distribution",
-                },
-                "scales": {"x": "log", "y": "log"},
-                "lines": {"x": lower_energy_limit},
-                "filename": "energy_distribution_cumulative",
+        hists = {}
+
+        energy_axis_title = "Energy (TeV)"
+        event_count_axis_title = "Event Count"
+
+        definitions = {
+            "energy": {
+                "event_data_column": "simulated_energy",
+                "event_data": event_data,
+                "bin_edges": self.energy_bins,
+                "axis_titles": [energy_axis_title, event_count_axis_title],
+                "plot_scales": {"x": "log", "y": "log"},
             },
             "core_distance": {
-                "data": self.histograms.get("core_distance"),
-                "bins": self.histograms.get("core_distance_bin_edges"),
-                "plot_type": "histogram",
-                "plot_params": hist_1d_params,
-                "labels": {
-                    "x": core_distance_label,
-                    "y": event_count_label,
-                    "title": "Triggered events: core distance distribution",
-                },
-                "lines": {"x": upper_radius_limit},
-                "filename": "core_distance_distribution",
-            },
-            "core_distance_cumulative": {
-                "data": cumulative_core_distance,
-                "bins": self.histograms.get("core_distance_bin_edges"),
-                "plot_type": "histogram",
-                "plot_params": hist_1d_cumulative_params,
-                "labels": {
-                    "x": core_distance_label,
-                    "y": cumulative_prefix + event_count_label,
-                    "title": "Triggered events: cumulative core distance distribution",
-                },
-                "lines": {"x": upper_radius_limit},
-                "filename": "core_distance_cumulative_distribution",
-            },
-            "core_xy": {
-                "data": self.histograms.get("shower_cores"),
-                "bins": [
-                    self.histograms.get("shower_cores_bin_x_edges"),
-                    self.histograms.get("shower_cores_bin_y_edges"),
-                ],
-                "plot_type": "histogram2d",
-                "plot_params": hist_2d_equal_params,
-                "labels": {
-                    "x": core_x_label,
-                    "y": core_y_label,
-                    "title": "Triggered events: core x vs core y",
-                },
-                "colorbar_label": event_count_label,
-                "lines": {
-                    "r": upper_radius_limit,
-                },
-                "filename": "core_xy_distribution",
+                "event_data_column": "core_distance_shower",
+                "event_data": event_data,
+                "bin_edges": self.core_distance_bins,
+                "axis_titles": ["Core Distance (m)", event_count_axis_title],
             },
             "angular_distance": {
-                "data": self.histograms.get("angular_distance"),
-                "bins": self.histograms.get("angular_distance_bin_edges"),
-                "plot_type": "histogram",
-                "plot_params": hist_1d_params,
-                "labels": {
-                    "x": pointing_direction_label,
-                    "y": event_count_label,
-                    "title": "Triggered events: angular distance distribution",
-                },
-                "lines": {"x": viewcone_radius},
-                "filename": "angular_distance_distribution",
-            },
-            "angular_distance_cumulative": {
-                "data": cumulative_angular_distance,
-                "bins": self.histograms.get("angular_distance_bin_edges"),
-                "plot_type": "histogram",
-                "plot_params": hist_1d_cumulative_params,
-                "labels": {
-                    "x": pointing_direction_label,
-                    "y": cumulative_prefix + event_count_label,
-                    "title": "Triggered events: cumulative angular distance distribution",
-                },
-                "lines": {"x": viewcone_radius},
-                "filename": "angular_distance_cumulative_distribution",
+                "event_data_column": "angular_distance",
+                "event_data": triggered_data,
+                "bin_edges": self.view_cone_bins,
+                "axis_titles": ["Angular Distance (deg)", event_count_axis_title],
             },
-            "angular_distance_vs_energy": {
-                "data": self.histograms.get("angular_distance_vs_energy"),
-                "bins": [
-                    self.histograms.get("angular_distance_vs_energy_bin_x_edges"),
-                    self.histograms.get("angular_distance_vs_energy_bin_y_edges"),
-                ],
-                "plot_type": "histogram2d",
-                "plot_params": hist_2d_params,
-                "labels": {
-                    "x": pointing_direction_label,
-                    "y": energy_label,
-                    "title": "Triggered events: angular distance distance vs energy",
-                },
-                "lines": {
-                    "x": viewcone_radius,
-                    "y": lower_energy_limit,
-                },
-                "scales": {"y": "log"},
-                "colorbar_label": event_count_label,
-                "filename": "angular_distance_vs_energy_distribution",
+            "x_core_shower_vs_y_core_shower": {
+                "event_data_column": ("x_core_shower", "y_core_shower"),
+                "event_data": (event_data, event_data),
+                "bin_edges": (xy_bins, xy_bins),
+                "is_1d": False,
+                "axis_titles": ["Core X (m)", "Core Y (m)", event_count_axis_title],
             },
-            "angular_distance_vs_energy_cumulative": {
-                "data": normalized_cumulative_angular_vs_energy,
-                "bins": [
-                    self.histograms.get("angular_distance_vs_energy_bin_x_edges"),
-                    self.histograms.get("angular_distance_vs_energy_bin_y_edges"),
-                ],
-                "plot_type": "histogram2d",
-                "plot_params": hist_2d_normalized_params,  # Includes contour line at value=1
-                "labels": {
-                    "x": pointing_direction_label,
-                    "y": energy_label,
-                    "title": "Triggered events: fraction of events by angular distance vs energy",
-                },
-                "lines": {
-                    "x": viewcone_radius,
-                    "y": lower_energy_limit,
-                },
-                "scales": {"y": "log"},
-                "colorbar_label": "Fraction of events",
-                "filename": "angular_distance_vs_energy_cumulative_distribution",
+            "core_vs_energy": {
+                "event_data_column": ("core_distance_shower", "simulated_energy"),
+                "event_data": (event_data, event_data),
+                "bin_edges": (self.core_distance_bins, self.energy_bins),
+                "is_1d": False,
+                "axis_titles": ["Core Distance (m)", energy_axis_title, event_count_axis_title],
+                "plot_scales": {"y": "log"},
             },
-            "core_vs_energy_cumulative": {
-                "data": normalized_cumulative_core_vs_energy,
-                "bins": [
-                    self.histograms.get("core_vs_energy_bin_x_edges"),
-                    self.histograms.get("core_vs_energy_bin_y_edges"),
+            "angular_distance_vs_energy": {
+                "event_data_column": ("angular_distance", "simulated_energy"),
+                "event_data": (triggered_data, event_data),
+                "bin_edges": (self.view_cone_bins, self.energy_bins),
+                "is_1d": False,
+                "axis_titles": [
+                    "Angular Distance (deg)",
+                    energy_axis_title,
+                    event_count_axis_title,
                 ],
-                "plot_type": "histogram2d",
-                "plot_params": hist_2d_normalized_params,
-                "labels": {
-                    "x": core_distance_label,
-                    "y": energy_label,
-                    "title": "Triggered events: fraction of events by core distance vs energy",
-                },
-                "lines": {
-                    "x": upper_radius_limit,
-                    "y": lower_energy_limit,
-                },
-                "scales": {"y": "log"},
-                "colorbar_label": "Fraction of events",
-                "filename": "core_vs_energy_cumulative_distribution",
+                "plot_scales": {"y": "log"},
             },
         }
 
-        for plot_key, plot_args in plots.items():
-            plot_filename = plot_args.pop("filename")
-            if self.array_name and plot_args.get("labels", {}).get("title"):
-                plot_args["labels"]["title"] += f" ({self.array_name} array)"
-
-            filename = self._build_plot_filename(plot_filename, self.array_name)
-            output_file = output_path / filename if output_path else None
-            self._create_plot(**plot_args, output_file=output_file)
-
-            if self._should_create_rebinned_plot(rebin_factor, plot_args, plot_key):
-                self._create_rebinned_plot(plot_args, filename, output_path, rebin_factor)
-
-    def _get_limits(self, limits):
-        """Extract limits from the provided dictionary for plotting."""
-        upper_radius_limit = None
-        lower_energy_limit = None
-        viewcone_radius = None
-        if limits:
-            upper_radius_limit = (
-                limits["upper_radius_limit"].value if "upper_radius_limit" in limits else None
-            )
-            lower_energy_limit = (
-                limits["lower_energy_limit"].value if "lower_energy_limit" in limits else None
-            )
-            viewcone_radius = (
-                limits["viewcone_radius"].value if "viewcone_radius" in limits else None
+        hists = {
+            name: self.get_histogram_definition(**cfg) | {"suffix": "", "title": "Triggered Events"}
+            for name, cfg in definitions.items()
+        }
+
+        hists_mc = {}
+        for key, hist in hists.items():
+            key_mc = f"{key}_mc"
+            hists_mc[key_mc] = copy.copy(hist)
+            hists_mc[key_mc]["suffix"] = "_mc"
+            hists_mc[key_mc]["title"] = "Simulated Events"
+            hists_mc[key_mc]["event_data"] = (
+                shower_data if hist["1d"] else (shower_data, shower_data)
             )
-        return upper_radius_limit, lower_energy_limit, viewcone_radius
 
-    def _build_plot_filename(self, base_filename, array_name=None):
-        """
-        Build the full plot filename with appropriate extensions.
+        hists.update(hists_mc)
+        return hists
 
-        Parameters
-        ----------
-        base_filename : str
-            The base filename without extension
-        array_name : str, optional
-            Name of the array to append to filename
+    def get_histogram_definition(
+        self,
+        event_data_column=None,
+        event_data=None,
+        histogram=None,
+        bin_edges=None,
+        title=None,
+        axis_titles=None,
+        suffix=None,
+        is_1d=True,
+        plot_scales=None,
+    ):
+        """Return a single histogram definition."""
+        return {
+            "histogram": histogram,
+            "event_data_column": event_data_column,
+            "event_data": event_data,
+            "1d": is_1d,
+            "bin_edges": bin_edges,
+            "title": title,
+            "axis_titles": axis_titles,
+            "suffix": suffix,
+            "plot_scales": plot_scales,
+        }
 
-        Returns
-        -------
-        str
-            Complete filename with extension
+    def _fill_histogram_and_bin_edges(self, data):
         """
-        if array_name:
-            return f"{base_filename}_{array_name}.png"
-        return f"{base_filename}.png"
+        Fill histogram and bin edges into the histogram dictionary.
 
-    def _should_create_rebinned_plot(self, rebin_factor, plot_args, plot_key):
+        Adds to existing histogram if present, otherwise initializes it.
         """
-        Check if a rebinned version of the plot should be created.
+        if data["1d"]:
+            hist, _ = np.histogram(
+                getattr(data["event_data"], data["event_data_column"]),
+                bins=data["bin_edges"],
+            )
+        else:
+            hist, _, _ = np.histogram2d(
+                getattr(data["event_data"][0], data["event_data_column"][0]),
+                getattr(data["event_data"][1], data["event_data_column"][1]),
+                bins=[data["bin_edges"][0], data["bin_edges"][1]],
+            )
 
-        Parameters
-        ----------
-        rebin_factor : int
-            Factor by which to rebin the energy axis
-        plot_args : dict
-            Plot arguments
-        plot_key : str
-            Key identifying the plot type
+        data["histogram"] = hist if data["histogram"] is None else data["histogram"] + hist
 
-        Returns
-        -------
-        bool
-            True if a rebinned plot should be created, False otherwise
+    def calculate_efficiency_data(self):
         """
-        return (
-            rebin_factor > 1
-            and plot_args["plot_type"] == "histogram2d"
-            and plot_key.endswith("_cumulative")
-            and plot_args.get("plot_params", {}).get("norm") == "linear"
-        )
+        Calculate efficiency histograms (triggered divided by simulated).
 
-    def _create_rebinned_plot(self, plot_args, filename, output_path, rebin_factor):
-        """
-        Create a rebinned version of a 2D histogram plot.
+        Assumes that for each histogram with simulated events, there is a
+        corresponding histogram with triggered events.
 
-        Parameters
-        ----------
-        plot_args : dict
-            Plot arguments for the original plot
-        filename : str
-            Filename of the original plot
-        output_path : Path or None
-            Path to save the plot to, or None
-        rebin_factor : int
-            Factor by which to rebin the energy axis
+        Returns
+        -------
+        dict
+            Dictionary containing the efficiency histograms.
         """
-        data = plot_args["data"]
-        bins = plot_args["bins"]
 
-        rebinned_data, rebinned_x_bins, rebinned_y_bins = self._rebin_2d_histogram(
-            data, bins[0], bins[1], rebin_factor
-        )
+        def calculate_efficiency(trig_hist, mc_hist):
+            with np.errstate(divide="ignore", invalid="ignore"):
+                return np.divide(
+                    trig_hist,
+                    mc_hist,
+                    out=np.zeros_like(trig_hist, dtype=float),
+                    where=mc_hist > 0,
+                )
 
-        rebinned_plot_args = plot_args.copy()
-        rebinned_plot_args["data"] = rebinned_data
-        rebinned_plot_args["bins"] = [rebinned_x_bins, rebinned_y_bins]
+        eff_histograms = {}
+        for name, mc_hist in self.histograms.items():
+            if not name.endswith("_mc"):
+                continue
 
-        if rebinned_plot_args.get("labels", {}).get("title"):
-            rebinned_plot_args["labels"]["title"] += f" (Energy rebinned {rebin_factor}x)"
+            base_name = name[:-3]
+            trig_hist = self.histograms.get(base_name)
+            if trig_hist is None:
+                continue
 
-        rebinned_filename = f"{filename.replace('.png', '')}_rebinned.png"
-        rebinned_output_file = output_path / rebinned_filename if output_path else None
-        self._create_plot(**rebinned_plot_args, output_file=rebinned_output_file)
+            if mc_hist["histogram"].shape != trig_hist["histogram"].shape:
+                self._logger.warning(
+                    f"Shape mismatch for {base_name} and {name}, skipping efficiency calculation."
+                )
+                continue
+
+            eff = copy.copy(mc_hist)
+            eff.update(
+                {
+                    "histogram": calculate_efficiency(trig_hist["histogram"], mc_hist["histogram"]),
+                    "suffix": "_eff",
+                    "title": "Efficiency",
+                }
+            )
+            eff["axis_titles"] = copy.copy(mc_hist["axis_titles"])
+            eff["axis_titles"][-1] = "Efficiency"
+            eff_histograms[f"{base_name}_eff"] = eff
 
-    def _create_plot(
-        self,
-        data,
-        bins=None,
-        plot_type="histogram",
-        plot_params=None,
-        labels=None,
-        scales=None,
-        colorbar_label=None,
-        output_file=None,
-        lines=None,
-    ):
-        """
-        Create and save a plot with the given parameters.
+        self.histograms.update(eff_histograms)
+        return eff_histograms
 
-        For normalized 2D histograms, a contour line is drawn at the value of 1.0
-        to indicate the boundary where each energy bin reaches complete containment.
-        This can be controlled with the 'show_contour' parameter in plot_params.
-        """
-        plot_params = plot_params or {}
-        labels = labels or {}
-        scales = scales or {}
-        lines = lines or {}
-
-        fig, ax = plt.subplots(figsize=(8, 6))
-
-        if plot_type == "histogram":
-            plt.bar(bins[:-1], data, width=np.diff(bins), **plot_params)
-        elif plot_type == "histogram2d":
-            pcm = self._create_2d_histogram_plot(data, bins, plot_params)
-            plt.colorbar(pcm, label=colorbar_label)
-
-        if "x" in lines:
-            plt.axvline(lines["x"], color="r", linestyle="--", linewidth=0.5)
-        if "y" in lines:
-            plt.axhline(lines["y"], color="r", linestyle="--", linewidth=0.5)
-        if "r" in lines:
-            circle = plt.Circle(
-                (0, 0), lines["r"], color="r", fill=False, linestyle="--", linewidth=0.5
-            )
-            plt.gca().add_artist(circle)
-
-        ax.set(
-            xlabel=labels.get("x", ""),
-            ylabel=labels.get("y", ""),
-            title=labels.get("title", ""),
-            xscale=scales.get("x", "linear"),
-            yscale=scales.get("y", "linear"),
+    @property
+    def energy_bins(self):
+        """Return bins for the energy histogram."""
+        if "energy_bin_edges" in self.histograms:
+            return self.histograms["energy_bin_edges"]
+        return np.logspace(
+            np.log10(self.file_info.get("energy_min", 1.0e-3 * u.TeV).to("TeV").value),
+            np.log10(self.file_info.get("energy_max", 1.0e3 * u.TeV).to("TeV").value),
+            100,
         )
 
-        if output_file:
-            self._logger.info(f"Saving plot to {output_file}")
-            plt.savefig(output_file, dpi=300, bbox_inches="tight")
-            plt.close()
-        else:
-            plt.tight_layout()
-            plt.show()
+    @property
+    def core_distance_bins(self):
+        """Return bins for the core distance histogram."""
+        if "core_distance_bin_edges" in self.histograms:
+            return self.histograms["core_distance_bin_edges"]
+        return np.linspace(
+            self.file_info.get("core_scatter_min", 0.0 * u.m).to("m").value,
+            self.file_info.get("core_scatter_max", 1.0e5 * u.m).to("m").value,
+            100,
+        )
 
-        return fig
+    @property
+    def view_cone_bins(self):
+        """Return bins for the viewcone histogram."""
+        if "viewcone_bin_edges" in self.histograms:
+            return self.histograms["viewcone_bin_edges"]
+        return np.linspace(
+            self.file_info.get("viewcone_min", 0.0 * u.deg).to("deg").value,
+            self.file_info.get("viewcone_max", 20.0 * u.deg).to("deg").value,
+            100,
+        )
 
-    def _create_2d_histogram_plot(self, data, bins, plot_params):
+    def calculate_cumulative_data(self):
         """
-        Create a 2D histogram plot with the given parameters.
-
-        Parameters
-        ----------
-        data : np.ndarray
-            2D histogram data
-        bins : tuple of np.ndarray
-            Bin edges for x and y axes
-        plot_params : dict
-            Plot parameters including norm, cmap, and show_contour
+        Calculate cumulative distributions for triggered histograms.
 
         Returns
         -------
-        matplotlib.collections.QuadMesh
-            The created pcolormesh object for colorbar attachment
+        dict
+            Dictionary containing the cumulative histograms.
         """
-        if plot_params.get("norm") == "linear":
-            pcm = plt.pcolormesh(
-                bins[0],
-                bins[1],
-                data.T,
-                vmin=0,
-                vmax=1,
-                cmap=plot_params.get("cmap", "viridis"),
-            )
-            # Add contour line at value=1.0 for normalized histograms
-            if plot_params.get("show_contour", True):
-                x_centers = (bins[0][1:] + bins[0][:-1]) / 2
-                y_centers = (bins[1][1:] + bins[1][:-1]) / 2
-                x_mesh, y_mesh = np.meshgrid(x_centers, y_centers)
-                plt.contour(
-                    x_mesh,
-                    y_mesh,
-                    data.T,
-                    levels=[0.999999],  # very close to 1 for floating point precision
-                    colors=["tab:red"],
-                    linestyles=["--"],
-                    linewidths=[0.5],
-                )
-        else:
-            pcm = plt.pcolormesh(
-                bins[0], bins[1], data.T, norm=LogNorm(vmin=1, vmax=data.max()), cmap="viridis"
+        cumulative_data = {}
+        suffix = "_cumulative"
+
+        def add_cumulative(name, hist, **kwargs):
+            new = copy.copy(hist)
+            new["histogram"] = self._calculate_cumulative_histogram(hist["histogram"], **kwargs)
+            new["axis_titles"] = copy.copy(hist["axis_titles"])
+            new.update(
+                {
+                    "suffix": suffix,
+                    "title": "Cumulative triggered events",
+                }
             )
+            new["axis_titles"][-1] = "Fraction of Events"
+            cumulative_data[f"{name}{suffix}"] = new
 
-        return pcm
+        # 2D histograms vs energy
+        for name, hist in self.histograms.items():
+            if name.endswith("_vs_energy") and not name.endswith("_mc"):
+                add_cumulative(name, hist, axis=0, normalize=True)
+
+        # 1D histograms
+        for name in ["energy", "core_distance", "angular_distance"]:
+            if (hist := self.histograms.get(name)) is not None:
+                add_cumulative(name, hist, reverse=name == "energy")
+
+        self.histograms.update(cumulative_data)
+        return cumulative_data
 
     def _calculate_cumulative_histogram(self, hist, reverse=False, axis=None, normalize=False):
         """
@@ -647,12 +372,13 @@ class SimtelIOEventHistograms:
                 result = result / np.sum(hist)
             return result
 
-        if axis is None:
-            axis = 1
-
+        axis = axis if axis is not None else 1
         result = self._apply_cumsum_along_axis(hist.copy(), axis, reverse)
 
         if normalize:
+            # Ensure floating dtype to allow in-place normalization without casting errors
+            if not np.issubdtype(result.dtype, np.floating):
+                result = result.astype(float)
             self._normalize_along_axis(result, hist, axis)
 
         return result
@@ -693,9 +419,7 @@ class SimtelIOEventHistograms:
 
     def _calculate_cumulative_2d(self, hist, reverse, axis=None):
         """Calculate cumulative distribution for 2D histogram."""
-        if axis is None:
-            axis = 1
-
+        axis = axis if axis is not None else 1
         return self._apply_cumsum_along_axis(hist, axis, reverse)
 
     def _apply_cumsum_along_axis(self, hist, axis, reverse):
@@ -706,7 +430,8 @@ class SimtelIOEventHistograms:
 
         return np.apply_along_axis(cumsum_func, axis, hist)
 
-    def _rebin_2d_histogram(self, hist, x_bins, y_bins, rebin_factor=2):
+    @staticmethod
+    def rebin_2d_histogram(hist, x_bins, y_bins, rebin_factor=2):
         """
         Rebin a 2D histogram by merging neighboring bins along the energy dimension (y-axis) only.
 
@@ -725,7 +450,7 @@ class SimtelIOEventHistograms:
         Returns
         -------
         tuple
-            (rebinned_hist, x_bins, rebinned_y_bins)
+            (re-binned_hist, x_bins, re-binned_y_bins)
         """
         if rebin_factor <= 1:
             return hist, x_bins, y_bins
@@ -744,3 +469,15 @@ class SimtelIOEventHistograms:
         new_y_bins = y_bins[::rebin_factor]
 
         return new_hist, x_bins, new_y_bins
+
+    def print_summary(self):
+        """
+        Print a summary of the histogram statistics.
+
+        Total number of events is retrieved from the 'energy' histograms.
+        """
+        total_simulated = np.sum(self.histograms.get("energy_mc", {}).get("histogram", []))
+        total_triggered = np.sum(self.histograms.get("energy", {}).get("histogram", []))
+
+        self._logger.info(f"Total simulated events: {total_simulated}")
+        self._logger.info(f"Total triggered events: {total_triggered}")