gammasimtools 0.16.0__py3-none-any.whl → 0.17.0__py3-none-any.whl

simtools/production_configuration/{calculate_statistical_errors_grid_point.py → calculate_statistical_uncertainties_grid_point.py}

@@ -6,21 +6,21 @@ import numpy as np
 from astropy import units as u
 from astropy.io import fits
 
-__all__ = ["StatisticalErrorEvaluator"]
+__all__ = ["StatisticalUncertaintyEvaluator"]
 
 
-class StatisticalErrorEvaluator:
+class StatisticalUncertaintyEvaluator:
     """
-    Evaluates statistical uncertainties from a DL2 MC event file.
+    Evaluate statistical uncertainties for a metric at a point in the observational parameter grid.
 
     Parameters
     ----------
     file_path : str
         Path to the DL2 MC event file.
-    metrics : dict, optional
-        Dictionary of metrics to evaluate. Default is None.
+    metrics : dict
+        Dictionary of metrics to evaluate.
     grid_point : tuple, optional
-        Tuple specifying the grid point (energy, azimuth, zenith, NSB, offset).
+        Grid point (energy, azimuth, zenith, NSB, offset).
     """
 
     def __init__(
@@ -35,13 +35,9 @@ class StatisticalErrorEvaluator:
         self.grid_point = grid_point
 
         self.data = self.load_data_from_file(file_path)
+        self.energy_bin_edges = self.create_energy_bin_edges()
 
-        self.uncertainty_effective_area = None
-        self.energy_estimate = None
-        self.sigma_energy = None
-        self.delta_energy = None
-
-        self.metric_results = None
+        self.metric_results = {}
         self.energy_threshold = None
 
     def _load_event_data(self, hdul, data_type):
@@ -76,21 +72,14 @@ class StatisticalErrorEvaluator:
         unique_azimuths = np.unique(events_data["PNT_AZ"]) * u.deg
         unique_zeniths = 90 * u.deg - np.unique(events_data["PNT_ALT"]) * u.deg
         if len(unique_azimuths) > 1 or len(unique_zeniths) > 1:
-            msg = (
-                f"Multiple values found for azimuth ({unique_azimuths}) zenith ({unique_zeniths})."
-            )
+            msg = f"Multiple values found for azimuth ({unique_azimuths}) zenith ({unique_zeniths})"
             self._logger.error(msg)
             raise ValueError(msg)
-        if self.grid_point is not None:
-            self._logger.warning(
-                f"Grid point already set to: {self.grid_point}. "
-                "Overwriting with new values from file."
-            )
         self.grid_point = (
             1 * u.TeV,
             unique_azimuths[0],
             unique_zeniths[0],
-            0,
+            0,  # NSB needs to be read and set here
             0 * u.deg,
         )
         self._logger.info(f"Grid point values: {self.grid_point}")
@@ -127,7 +116,7 @@ class StatisticalErrorEvaluator:
             raise FileNotFoundError(error_message) from e
         return data
 
-    def create_bin_edges(self):
+    def create_energy_bin_edges(self):
         """
         Create unique energy bin edges.
 
@@ -164,7 +153,9 @@ class StatisticalErrorEvaluator:
         )
         return reconstructed_event_histogram * u.count
 
-    def compute_efficiency_and_errors(self, reconstructed_event_counts, simulated_event_counts):
+    def compute_efficiency_and_uncertainties(
+        self, reconstructed_event_counts, simulated_event_counts
+    ):
         """
         Compute reconstructed event efficiency and its uncertainty assuming binomial distribution.
 
@@ -179,7 +170,7 @@ class StatisticalErrorEvaluator:
         -------
         efficiencies : array
             Array of calculated efficiencies.
-        relative_errors : array
+        relative_uncertainties : array
             Array of relative uncertainties.
         """
         # Ensure the inputs have compatible units
@@ -220,15 +211,15 @@ class StatisticalErrorEvaluator:
                 )
             )
 
-        # Compute relative errors
-        relative_errors = np.divide(
-            uncertainties,
+        # Compute relative uncertainties
+        relative_uncertainties = np.divide(
+            uncertainties.value,
             np.sqrt(simulated_event_counts.value),
-            out=np.zeros_like(uncertainties, dtype=float),
-            where=uncertainties > 0,
+            out=np.zeros_like(uncertainties.value, dtype=float),
+            where=uncertainties.value > 0,
         )
 
-        return efficiencies, relative_errors
+        return efficiencies, relative_uncertainties
 
     def calculate_energy_threshold(self, requested_eff_area_fraction=0.1):
         """
@@ -239,13 +230,12 @@ class StatisticalErrorEvaluator:
         float
             Energy threshold value.
         """
-        bin_edges = self.create_bin_edges()
         reconstructed_event_histogram = self.compute_reconstructed_event_histogram(
-            self.data["event_energies_mc"], bin_edges
+            self.data["event_energies_mc"], self.energy_bin_edges
         )
         simulated_event_histogram = self.data["simulated_event_histogram"]
 
-        efficiencies, _ = self.compute_efficiency_and_errors(
+        efficiencies, _ = self.compute_efficiency_and_uncertainties(
             reconstructed_event_histogram, simulated_event_histogram
         )
 
@@ -257,7 +247,7 @@ class StatisticalErrorEvaluator:
         if threshold_index == 0 and efficiencies[0] < threshold_efficiency:
             return
 
-        self.energy_threshold = bin_edges[threshold_index]
+        self.energy_threshold = self.energy_bin_edges[threshold_index]
 
     def calculate_uncertainty_effective_area(self):
         """
@@ -265,18 +255,42 @@ class StatisticalErrorEvaluator:
 
         Returns
         -------
-        errors : dict
+        dict
             Dictionary with uncertainties for the file.
         """
-        bin_edges = self.create_bin_edges()
         reconstructed_event_histogram = self.compute_reconstructed_event_histogram(
-            self.data["event_energies_mc"], bin_edges
+            self.data["event_energies_mc"], self.energy_bin_edges
         )
         simulated_event_histogram = self.data["simulated_event_histogram"]
-        _, relative_errors = self.compute_efficiency_and_errors(
+        _, relative_uncertainties = self.compute_efficiency_and_uncertainties(
             reconstructed_event_histogram, simulated_event_histogram
         )
-        return {"relative_errors": relative_errors}
+        return {"relative_uncertainties": relative_uncertainties}
+
+    def calculate_max_error_for_effective_area(self):
+        """
+        Calculate the maximum relative uncertainty for effective area within the validity range.
+
+        Returns
+        -------
+        max_error : float
+            Maximum relative error.
+        """
+        energy_range = self.metrics.get("uncertainty_effective_area", {}).get("energy_range")
+
+        min_energy, max_energy = (
+            energy_range["value"][0] * u.Unit(energy_range["unit"]),
+            energy_range["value"][1] * u.Unit(energy_range["unit"]),
+        )
+        valid_uncertainties = [
+            error
+            for energy, error in zip(
+                self.data["bin_edges_low"],
+                self.metric_results["uncertainty_effective_area"]["relative_uncertainties"],
+            )
+            if min_energy <= energy <= max_energy
+        ]
+        return max(valid_uncertainties)
 
     def calculate_energy_estimate(self):
         """
@@ -287,7 +301,7 @@ class StatisticalErrorEvaluator:
         float
             The calculated uncertainty for energy estimation.
         """
-        logging.info("Calculating Energy Resolution Error")
+        logging.info("Calculating Energy Resolution Uncertainty")
 
         event_energies_reco = self.data["event_energies_reco"]
         event_energies_mc = self.data["event_energies_mc"]
@@ -300,87 +314,59 @@ class StatisticalErrorEvaluator:
 
         energy_deviation = (event_energies_reco - event_energies_mc) / event_energies_mc
 
-        bin_edges = self.create_bin_edges()
-        bin_indices = np.digitize(event_energies_reco, bin_edges) - 1
+        bin_indices = np.digitize(event_energies_reco, self.energy_bin_edges) - 1
 
         energy_deviation_by_bin = [
-            energy_deviation[bin_indices == i] for i in range(len(bin_edges) - 1)
+            energy_deviation[bin_indices == i] for i in range(len(self.energy_bin_edges) - 1)
         ]
 
         # Calculate sigma for each bin
-        sigma_energy = [np.std(d) if len(d) > 0 else np.nan for d in energy_deviation_by_bin]
+        sigma_energy = [np.std(d.value) if len(d) > 0 else np.nan for d in energy_deviation_by_bin]
 
         # Calculate delta_energy as the mean deviation for each bin
-        delta_energy = [np.mean(d) if len(d) > 0 else np.nan for d in energy_deviation_by_bin]
+        delta_energy = [np.mean(d.value) if len(d) > 0 else np.nan for d in energy_deviation_by_bin]
 
         # Combine sigma into a single measure
         overall_uncertainty = np.nanmean(sigma_energy)
 
-        return overall_uncertainty, sigma_energy, delta_energy
+        self.metric_results["energy_estimate"] = {
+            "overall_uncertainty": overall_uncertainty,
+            "sigma_energy": sigma_energy,
+            "delta_energy": delta_energy,
+        }
 
     def calculate_metrics(self):
         """Calculate all defined metrics as specified in self.metrics and store results."""
         if "uncertainty_effective_area" in self.metrics:
-            self.uncertainty_effective_area = self.calculate_uncertainty_effective_area()
-            if self.uncertainty_effective_area:
-                energy_range = self.metrics.get("uncertainty_effective_area", {}).get(
-                    "energy_range"
-                )
-                min_energy, max_energy = (
-                    energy_range["value"][0] * u.Unit(energy_range["unit"]),
-                    energy_range["value"][1] * u.Unit(energy_range["unit"]),
-                )
-
-                valid_errors = [
-                    error
-                    for energy, error in zip(
-                        self.data["bin_edges_low"],
-                        self.uncertainty_effective_area["relative_errors"],
-                    )
-                    if min_energy <= energy <= max_energy
+            self.metric_results["uncertainty_effective_area"] = {
+                "relative_uncertainties": self.calculate_uncertainty_effective_area()[
+                    "relative_uncertainties"
                 ]
-                self.uncertainty_effective_area["max_error"] = (
-                    max(valid_errors) if valid_errors else 0.0
-                )
-                ref_value = self.metrics.get("uncertainty_effective_area", {}).get("target_error")[
-                    "value"
-                ]
-                self._logger.info(
-                    f"Effective Area Error (max in validity range): "
-                    f"{self.uncertainty_effective_area['max_error'].value:.6f}, "
-                    f"Reference: {ref_value:.3f}"
-                )
+            }
 
-        if "energy_estimate" in self.metrics:
-            self.energy_estimate, self.sigma_energy, self.delta_energy = (
-                self.calculate_energy_estimate()
+            self.metric_results["uncertainty_effective_area"]["max_error"] = (
+                self.calculate_max_error_for_effective_area()
             )
-            ref_value = self.metrics.get("energy_estimate", {}).get("target_error")["value"]
+            ref_value = self.metrics.get("uncertainty_effective_area", {}).get(
+                "target_uncertainty"
+            )["value"]
             self._logger.info(
-                f"Energy Estimate Error: {self.energy_estimate:.3f}, Reference: {ref_value:.3f}"
+                f"Effective Area Uncertainty (max in validity range): "
+                f"{self.metric_results['uncertainty_effective_area']['max_error']:.6f}, "
+                f"Reference: {ref_value:.3f}"
             )
-        else:
-            raise ValueError("Invalid metric specified.")
-        self.metric_results = {
-            "uncertainty_effective_area": self.uncertainty_effective_area,
-            "energy_estimate": self.energy_estimate,
-        }
-        return self.metric_results
 
-    def calculate_max_error_for_effective_area(self):
-        """
-        Calculate the maximum relative error for effective area.
+        if "energy_estimate" in self.metrics:
+            self.calculate_energy_estimate()
+            ref_value = self.metrics.get("energy_estimate", {}).get("target_uncertainty")["value"]
+            self._logger.info(
+                f"Energy Estimate Uncertainty: "
+                f"{self.metric_results['energy_estimate']['overall_uncertainty']:.6f}, "
+                f"Reference: {ref_value:.3f}"
+            )
 
-        Returns
-        -------
-        max_error : float
-            Maximum relative error.
-        """
-        if "relative_errors" in self.metric_results["uncertainty_effective_area"]:
-            return np.max(self.metric_results["uncertainty_effective_area"]["relative_errors"])
-        if self.uncertainty_effective_area:
-            return np.max(self.uncertainty_effective_area["relative_errors"])
-        return None
+        if not ("uncertainty_effective_area" in self.metrics or "energy_estimate" in self.metrics):
+            raise ValueError("Invalid metric specified.")
 
     def calculate_overall_metric(self, metric="average"):
         """
@@ -393,31 +379,34 @@ class StatisticalErrorEvaluator:
 
         Returns
         -------
-        dict
-            Dictionary with overall maximum errors for each metric.
+        float
+            The overall metric value.
         """
         # Decide how to combine the metrics
         if self.metric_results is None:
             raise ValueError("Metrics have not been computed yet.")
 
-        overall_max_errors = {}
+        overall_max_uncertainties = {}
 
         for metric_name, result in self.metric_results.items():
             if metric_name == "uncertainty_effective_area":
-                max_errors = self.calculate_max_error_for_effective_area()
-                overall_max_errors[metric_name] = max_errors if max_errors else 0
-            elif metric_name in [
-                "error_gamma_ray_psf",
-            ]:
-                overall_max_errors[metric_name] = result
+                max_uncertainties = self.calculate_max_error_for_effective_area()
+                overall_max_uncertainties[metric_name] = (
+                    max_uncertainties if max_uncertainties else 0
+                )
+            elif metric_name == "energy_estimate":
+                # Use the "overall_uncertainty"
+                overall_max_uncertainties[metric_name] = result["overall_uncertainty"]
             else:
                 raise ValueError(f"Unsupported result type for {metric_name}: {type(result)}")
-        self._logger.info(f"overall_max_errors {overall_max_errors}")
-        all_max_errors = list(overall_max_errors.values())
+
+        self._logger.info(f"overall_max_uncertainties {overall_max_uncertainties}")
+        all_max_uncertainties = list(overall_max_uncertainties.values())
+
         if metric == "average":
-            overall_metric = np.mean(all_max_errors)
+            overall_metric = np.mean(all_max_uncertainties)
         elif metric == "maximum":
-            overall_metric = np.max(all_max_errors)
+            overall_metric = np.nanmax(all_max_uncertainties)
         else:
             raise ValueError(f"Unsupported metric: {metric}")