gammasimtools 0.9.0__py3-none-any.whl → 0.11.0__py3-none-any.whl

simtools/production_configuration/event_scaler.py

@@ -6,16 +6,10 @@ which scales the number of events for both the entire dataset and specific grid
 Scaling factors are calculated using error metrics and the evaluator's results.
 """
 
-import logging
-
 import astropy.units as u
 import numpy as np
 
-from simtools.production_configuration.calculate_statistical_errors_grid_point import (
-    StatisticalErrorEvaluator,
-)
-
-_logger = logging.getLogger(__name__)
+__all__ = ["EventScaler"]
 
 
 class EventScaler:
@@ -25,43 +19,36 @@ class EventScaler:
     Supports scaling both the entire dataset and specific grid points like energy values.
     """
 
-    def __init__(self, evaluator: StatisticalErrorEvaluator, science_case: str, metrics: dict):
+    def __init__(self, evaluator, metrics: dict):
         """
-        Initialize the EventScaler with the evaluator, science case, and metrics.
+        Initialize the EventScaler with the evaluator and metrics.
 
         Parameters
         ----------
         evaluator : StatisticalErrorEvaluator
             The evaluator responsible for calculating metrics and handling event data.
-        science_case : str
-            The science case used to adjust the uncertainty factor.
         metrics : dict
             Dictionary containing metrics, including target error for effective area.
         """
         self.evaluator = evaluator
-        self.science_case = science_case
         self.metrics = metrics
 
     def scale_events(self, return_sum: bool = True) -> u.Quantity:
         """
         Calculate the scaled number of events based on statistical error metrics.
 
-        If `return_sum` is `True`, the method returns the sum of scaled events for the entire
-        dataset. If `return_sum` is `False`, it returns the scaled number of events for each
-        grid point (e.g., along the energy axis).
-
         Parameters
         ----------
         return_sum : bool, optional
-            If `True`, returns the sum of scaled events for the entire dataset. If `False`,
-            returns the scaled events for each grid point along the energy axis. Default is `True`.
+            If True, returns the sum of scaled events for the entire set of MC events. If False,
+            returns the scaled events for each grid point along the energy axis. Default is True.
 
         Returns
         -------
         u.Quantity
-            If `return_sum` is `True`, returns the total scaled number of events as a `u.Quantity`.
-            If `return_sum` is `False`, returns an array of scaled events along the energy axis as
-            a `u.Quantity`.
+            If 'return_sum' is True, returns the total scaled number of events as a u.Quantity.
+            If 'return_sum' is False, returns an array of scaled events along the energy axis as
+            a u.Quantity.
         """
         scaling_factor = self._compute_scaling_factor()
 
@@ -87,20 +74,7 @@ class EventScaler:
             "value"
         ]
 
-        return (
-            current_max_error / target_max_error
-        ) ** 2 * self._apply_science_case_scaling_factor()
-
-    def _apply_science_case_scaling_factor(self) -> float:
-        """
-        Apply the uncertainty factor based on the science case.
-
-        Returns
-        -------
-        float
-            The final scaling factor after applying uncertainty.
-        """
-        return 1 if self.science_case == "science case 1" else 1.0
+        return (current_max_error / target_max_error) ** 2
 
     def _number_of_simulated_events(self) -> u.Quantity:
         """

simtools/production_configuration/generate_simulation_config.py

@@ -1,33 +1,11 @@
-"""
-Configures and generates simulation parameters for a specific grid point.
-
-Used to configure and generate simulation parameters for a specific grid point
-based on statistical uncertainties.
-The class considers parameters, such as azimuth, elevation, and night sky background,
-to compute core scatter area, viewcone, and the required number of simulated events.
-
-Key Components:
----------------
-- `SimulationConfig`: Main class to handle simulation configuration for a grid point.
-  - Attributes:
-    - `grid_point` (dict): Contains azimuth, elevation, and night sky background.
-    - `ctao_data_level` (str): The data level for the simulation (e.g., 'A', 'B', 'C').
-    - `science_case` (str): The science case for the simulation.
-    - `file_path` (str): Path to the DL2 MC event file
-       used for statistical error evaluation.
-    - `file_type` (str): Type of the DL2 MC event file ('point-like' or 'cone').
-    - `metrics` (dict, optional): Dictionary of metrics to evaluate.
-
-"""
-
-import logging
+"""Derives simulation configuration parameters for a grid point based on several metrics."""
 
 from simtools.production_configuration.calculate_statistical_errors_grid_point import (
     StatisticalErrorEvaluator,
 )
 from simtools.production_configuration.event_scaler import EventScaler
 
-_logger = logging.getLogger(__name__)
+__all__ = ["SimulationConfig"]
 
 
 class SimulationConfig:
@@ -38,10 +16,6 @@ class SimulationConfig:
     ----------
     grid_point : dict
         Dictionary representing a grid point with azimuth, elevation, and night sky background.
-    ctao_data_level : str
-        The data level (e.g., 'A', 'B', 'C') for the simulation configuration.
-    science_case : str
-        The science case for the simulation configuration.
     file_path : str
         Path to the DL2 MC event file for statistical uncertainty evaluation.
     file_type : str
@@ -53,26 +27,22 @@ class SimulationConfig:
     def __init__(
         self,
         grid_point: dict[str, float],
-        ctao_data_level: str,
-        science_case: str,
         file_path: str,
         file_type: str,
         metrics: dict[str, float] | None = None,
     ):
         """Initialize the simulation configuration for a grid point."""
         self.grid_point = grid_point
-        self.ctao_data_level = ctao_data_level
-        self.science_case = science_case
         self.file_path = file_path
         self.file_type = file_type
         self.metrics = metrics or {}
         self.evaluator = StatisticalErrorEvaluator(file_path, file_type, metrics)
-        self.event_scaler = EventScaler(self.evaluator, science_case, self.metrics)
+        self.event_scaler = EventScaler(self.evaluator, self.metrics)
         self.simulation_params = {}
 
     def configure_simulation(self) -> dict[str, float]:
         """
-        Configure the simulation parameters for the grid point, data level, and science case.
+        Configure the simulation parameters for the grid point.
 
         Returns
         -------
@@ -80,16 +50,11 @@ class SimulationConfig:
             A dictionary with simulation parameters such as core scatter area,
               viewcone, and number of simulated events.
         """
-        core_scatter_area = self._calculate_core_scatter_area()
-        viewcone = self._calculate_viewcone()
-        number_of_events = self.calculate_required_events()
-
         self.simulation_params = {
-            "core_scatter_area": core_scatter_area,
-            "viewcone": viewcone,
-            "number_of_events": number_of_events,
+            "core_scatter_area": self._calculate_core_scatter_area(),
+            "viewcone": self._calculate_viewcone(),
+            "number_of_events": self.calculate_required_events(),
         }
-
         return self.simulation_params
 
     def calculate_required_events(self) -> int:
@@ -107,7 +72,7 @@ class SimulationConfig:
 
     def _calculate_core_scatter_area(self) -> float:
         """
-        Calculate the core scatter area based on the grid point and data level.
+        Calculate the core scatter area based on the grid point.
 
         Returns
         -------
@@ -120,7 +85,7 @@ class SimulationConfig:
 
     def _calculate_viewcone(self) -> float:
         """
-        Calculate the viewcone based on the grid point conditions and data level.
+        Calculate the viewcone based on the grid point conditions.
 
         Returns
         -------

simtools/production_configuration/interpolation_handler.py

@@ -4,24 +4,18 @@ import astropy.units as u
 import numpy as np
 from scipy.interpolate import griddata
 
-from simtools.production_configuration.calculate_statistical_errors_grid_point import (
-    StatisticalErrorEvaluator,
-)
 from simtools.production_configuration.event_scaler import EventScaler
 
+__all__ = ["InterpolationHandler"]
+
 
 class InterpolationHandler:
     """Handle interpolation between multiple StatisticalErrorEvaluator instances."""
 
-    def __init__(
-        self, evaluators: list["StatisticalErrorEvaluator"], science_case: str, metrics: dict
-    ):
+    def __init__(self, evaluators, metrics: dict):
         self.evaluators = evaluators
-        self.science_case = science_case
         self.metrics = metrics
-        self.event_scalers = [
-            EventScaler(e, self.science_case, self.metrics) for e in self.evaluators
-        ]
+        self.event_scalers = [EventScaler(e, self.metrics) for e in self.evaluators]
 
         self.azimuths = [e.grid_point[1].to(u.deg).value for e in self.evaluators]
         self.zeniths = [e.grid_point[2].to(u.deg).value for e in self.evaluators]
@@ -157,9 +151,9 @@ class InterpolationHandler:
 
         return interpolated_threshold.item()
 
-    def plot_comparison(self, evaluator: "StatisticalErrorEvaluator"):
+    def plot_comparison(self, evaluator):
         """
-        Plot a comparison between the simulated, scaled, and triggered events.
+        Plot a comparison between the simulated, scaled, and reconstructed events.
 
         Parameters
         ----------
@@ -184,14 +178,14 @@ class InterpolationHandler:
 
         plt.plot(midpoints, evaluator.scaled_events, label="Scaled")
 
-        triggered_event_histogram, _ = np.histogram(
+        reconstructed_event_histogram, _ = np.histogram(
             evaluator.data["event_energies_reco"], bins=evaluator.data["bin_edges_low"]
         )
-        plt.plot(midpoints[:-1], triggered_event_histogram, label="Triggered")
+        plt.plot(midpoints[:-1], reconstructed_event_histogram, label="Reconstructed")
 
         plt.legend()
         plt.xscale("log")
         plt.xlabel("Energy (Midpoint of Bin Edges)")
         plt.ylabel("Event Count")
-        plt.title("Comparison of Simulated, Scaled, and Triggered Events")
+        plt.title("Comparison of Simulated, scaled, and reconstructed events")
         plt.show()

simtools/production_configuration/limits_calculation.py

@@ -0,0 +1,202 @@
+"""Calculate the thresholds for energy, radial distance, and viewcone."""
+
+import astropy.units as u
+import numpy as np
+
+
+class LimitCalculator:
+    """
+    Compute thresholds/limits for energy, radial distance, and viewcone.
+
+    Histograms are generated with simtools-generate-simtel-array-histograms with --hdf5 flag.
+
+    Event data is read from the generated HDF5 file from the following tables:
+    - angle_to_observing_position__triggered_showers_ for the viewcone limit.
+    - event_weight__ra3d__log10_e__ for the energy and radial distance limit.
+
+
+    Parameters
+    ----------
+    event_data_file : list of astropy.table.Table
+        The list of tables containing the event data.
+    """
+
+    def __init__(self, event_data_file_tables):
+        """
+        Initialize the LimitCalculator with the given event data file.
+
+        Parameters
+        ----------
+        event_data_file : list of astropy.table.Table
+            The list of tables containing the event data.
+        """
+        self.angle_to_observing_position__triggered_showers_ = None
+        self.event_weight__ra3d__log10_e__ = None
+
+        for table in event_data_file_tables:
+            if (
+                "Title" in table.meta
+                and table.meta["Title"] == "angle_to_observing_position__triggered_showers_"
+            ):
+                self.angle_to_observing_position__triggered_showers_ = table
+            elif "Title" in table.meta and table.meta["Title"] == "event_weight__ra3d__log10_e__":
+                self.event_weight__ra3d__log10_e__ = table
+
+    def _compute_limits(
+        self, event_weight_array, bin_edges, loss_fraction, axis=0, limit_type="lower"
+    ):
+        """
+        Compute the limits based on the loss fraction.
+
+        Parameters
+        ----------
+        event_weight_array : np.ndarray
+            Array of event weights.
+        bin_edges : np.ndarray
+            Array of bin edges.
+        loss_fraction : float
+            Fraction of events to be lost.
+        axis : int, optional
+            Axis along which to sum the event weights. Default is 0.
+        limit_type : str, optional
+            Type of limit ('lower' or 'upper'). Default is 'lower'.
+
+        Returns
+        -------
+        int
+            Bin index where the threshold is reached.
+        float
+            Bin edge value corresponding to the threshold.
+        """
+        projection = np.sum(event_weight_array, axis=axis)
+        bin_edge_value = None
+        cumulative_sum = None
+        if limit_type == "upper":
+            cumulative_sum = np.cumsum(projection)
+
+        elif limit_type == "lower":
+            cumulative_sum = np.cumsum(projection[::-1])
+
+        total_events = np.sum(projection)
+        threshold = (1 - loss_fraction) * total_events
+        bin_index = np.searchsorted(cumulative_sum, threshold)
+        if limit_type == "upper":
+            bin_edge_value = bin_edges[bin_index]
+        elif limit_type == "lower":
+            bin_edge_value = bin_edges[-bin_index]
+        return bin_index, bin_edge_value
+
+    def get_bin_edges_and_units(self, table, axis="x"):
+        """
+        Extract bin edges and units from the table metadata.
+
+        Parameters
+        ----------
+        table : astropy.table.Table
+            Table containing the event data.
+
+        Returns
+        -------
+        tuple
+            Tuple containing the bin edges and their units.
+        """
+        bin_edges = table.meta[f"{axis}_bin_edges"]
+        try:
+            bin_edges_unit = table.meta[f"{axis}_bin_edges_unit"]
+        except KeyError:
+            bin_edges_unit = ""
+        return bin_edges, bin_edges_unit
+
+    def compute_lower_energy_limit(self, loss_fraction):
+        """
+        Compute the lower energy limit in TeV based on the event loss fraction.
+
+        Parameters
+        ----------
+        loss_fraction : float
+            Fraction of events to be lost.
+
+        Returns
+        -------
+        astropy.units.Quantity
+            Lower energy limit.
+        """
+        event_weight_array = np.column_stack(
+            [
+                self.event_weight__ra3d__log10_e__[name]
+                for name in self.event_weight__ra3d__log10_e__.dtype.names
+            ]
+        )
+        bin_edges, bin_edges_unit = self.get_bin_edges_and_units(
+            self.event_weight__ra3d__log10_e__, axis="y"
+        )
+        if bin_edges_unit == "":
+            bin_edges_unit = "TeV"
+        _, lower_bin_edge_value = self._compute_limits(
+            event_weight_array, bin_edges, loss_fraction, axis=0, limit_type="lower"
+        )
+        return (10**lower_bin_edge_value) * u.Unit(bin_edges_unit)
+
+    def compute_upper_radial_distance(self, loss_fraction):
+        """
+        Compute the upper radial distance based on the event loss fraction.
+
+        Parameters
+        ----------
+        loss_fraction : float
+            Fraction of events to be lost.
+
+        Returns
+        -------
+        astropy.units.Quantity
+            Upper radial distance in m.
+        """
+        event_weight_array = np.column_stack(
+            [
+                self.event_weight__ra3d__log10_e__[name]
+                for name in self.event_weight__ra3d__log10_e__.dtype.names
+            ]
+        )
+        bin_edges, bin_edges_unit = self.get_bin_edges_and_units(
+            self.event_weight__ra3d__log10_e__, axis="x"
+        )
+        if bin_edges_unit == "":
+            bin_edges_unit = "m"
+        _, upper_bin_edge_value = self._compute_limits(
+            event_weight_array, bin_edges, loss_fraction, axis=1, limit_type="upper"
+        )
+        return upper_bin_edge_value * u.Unit(bin_edges_unit)
+
+    def compute_viewcone(self, loss_fraction):
+        """
+        Compute the viewcone based on the event loss fraction.
+
+        Parameters
+        ----------
+        loss_fraction : float
+            Fraction of events to be lost.
+
+        Returns
+        -------
+        astropy.units.Quantity
+            Viewcone radius in degrees.
+        """
+        angle_to_observing_position__triggered_showers = np.column_stack(
+            [
+                self.angle_to_observing_position__triggered_showers_[name]
+                for name in self.angle_to_observing_position__triggered_showers_.dtype.names
+            ]
+        )
+        bin_edges, bin_edges_unit = self.get_bin_edges_and_units(
+            self.angle_to_observing_position__triggered_showers_, axis="x"
+        )
+        if bin_edges_unit == "":
+            bin_edges_unit = "deg"
+        _, upper_bin_edge_value = self._compute_limits(
+            angle_to_observing_position__triggered_showers,
+            bin_edges,
+            loss_fraction,
+            axis=0,
+            limit_type="upper",
+        )
+        return upper_bin_edge_value * u.Unit(bin_edges_unit)