gammasimtools 0.8.2__py3-none-any.whl → 0.10.0__py3-none-any.whl

simtools/production_configuration/calculate_statistical_errors_grid_point.py

@@ -1,13 +1,4 @@
-"""
-Provides functionality to evaluate statistical uncertainties from DL2 MC event files.
-
-Classes
--------
-StatisticalErrorEvaluator
-    Handles error calculation for given DL2 MC event files and specified metrics.
-
-
-"""
+"""Evaluate statistical uncertainties from DL2 MC event files."""
 
 import logging
 
@@ -15,7 +6,7 @@ import numpy as np
 from astropy import units as u
 from astropy.io import fits
 
-_logger = logging.getLogger(__name__)
+__all__ = ["StatisticalErrorEvaluator"]
 
 
 class StatisticalErrorEvaluator:
@@ -41,26 +32,13 @@ class StatisticalErrorEvaluator:
         metrics: dict[str, float],
         grid_point: tuple[float, float, float, float, float] | None = None,
     ):
-        """
-        Init the evaluator with a DL2 MC event file, its type, and metrics to calculate.
-
-        Parameters
-        ----------
-        file_path : str
-            The path to the DL2 MC event file.
-        file_type : str
-            The type of the file ('point-like' or 'cone').
-        metrics : dict, optional
-            Dictionary specifying which metrics to compute and their reference values.
-        grid_point : tuple, optional
-            Tuple specifying the grid point (energy, azimuth, zenith, NSB, offset).
-        """
-        self.file_path = file_path
+        """Init the evaluator with a DL2 MC event file, its type, and metrics to calculate."""
+        self._logger = logging.getLogger(__name__)
         self.file_type = file_type
         self.metrics = metrics
         self.grid_point = grid_point
 
-        self.data = self.load_data_from_file()
+        self.data = self.load_data_from_file(file_path)
 
         self.uncertainty_effective_area = None
         self.energy_estimate = None
@@ -70,7 +48,59 @@ class StatisticalErrorEvaluator:
         self.metric_results = None
         self.energy_threshold = None
 
-    def load_data_from_file(self):
+    def _load_event_data(self, hdul, data_type):
+        """
+        Load data and units for the event and simulated data data.
+
+        Parameters
+        ----------
+        hdul : HDUList
+            The HDUList object.
+        data_type: str
+            The type of data to load ('EVENTS' or 'SIMULATED EVENTS').
+
+        Returns
+        -------
+        dict
+            Dictionary containing units for the event data.
+        """
+        _data = hdul[data_type].data  # pylint: disable=E1101
+        _header = hdul[data_type].header  # pylint: disable=E1101
+        _units = {}
+        for idx, col_name in enumerate(_data.columns.names, start=1):
+            unit_key = f"TUNIT{idx}"
+            if unit_key in _header:
+                _units[col_name] = u.Unit(_header[unit_key])
+            else:
+                _units[col_name] = None
+        return _data, _units
+
+    def _set_grid_point(self, events_data):
+        """Set azimuth/zenith angle of grid point."""
+        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}) "
+                f"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 * u.deg,
+        )
+        self._logger.info(f"Grid point values: {self.grid_point}")
+
+    def load_data_from_file(self, file_path):
         """
         Load data from the DL2 MC event file and return dictionaries with units.
 
@@ -81,91 +111,24 @@ class StatisticalErrorEvaluator:
         """
         data = {}
         try:
-            with fits.open(self.file_path) as hdul:
-                events_data = hdul["EVENTS"].data  # pylint: disable=E1101
-                sim_events_data = hdul["SIMULATED EVENTS"].data  # pylint: disable=E1101
-                event_units = {}
-                for idx, col_name in enumerate(events_data.columns.names, start=1):
-                    unit_key = f"TUNIT{idx}"
-                    if unit_key in hdul["EVENTS"].header:  # pylint: disable=E1101
-                        event_units[col_name] = u.Unit(
-                            hdul["EVENTS"].header[unit_key]  # pylint: disable=E1101
-                        )
-                    else:
-                        event_units[col_name] = None
-
-                sim_units = {}
-                for idx, col_name in enumerate(sim_events_data.columns.names, start=1):
-                    unit_key = f"TUNIT{idx}"
-                    if unit_key in hdul["SIMULATED EVENTS"].header:  # pylint: disable=E1101
-                        sim_units[col_name] = u.Unit(
-                            hdul["SIMULATED EVENTS"].header[unit_key]  # pylint: disable=E1101
-                        )
-                    else:
-                        sim_units[col_name] = None
-                # dl2 files are required to have units for these entries
-                event_energies_reco = events_data["ENERGY"] * event_units["ENERGY"]
-
-                event_energies_mc = events_data["MC_ENERGY"] * event_units["MC_ENERGY"]
-
-                bin_edges_low = sim_events_data["MC_ENERG_LO"] * sim_units["MC_ENERG_LO"]
-
-                bin_edges_high = sim_events_data["MC_ENERG_HI"] * sim_units["MC_ENERG_HI"]
-
-                simulated_event_histogram = sim_events_data["EVENTS"] * u.count
-
-                viewcone = hdul[3].data["viewcone"][0][1]  # pylint: disable=E1101
-                core_range = hdul[3].data["core_range"][0][1]  # pylint: disable=E1101
+            with fits.open(file_path) as hdul:
+                events_data, event_units = self._load_event_data(hdul, "EVENTS")
+                sim_events_data, sim_units = self._load_event_data(hdul, "SIMULATED EVENTS")
 
                 data = {
-                    "event_energies_reco": event_energies_reco,
-                    "event_energies_mc": event_energies_mc,
-                    "bin_edges_low": bin_edges_low,
-                    "bin_edges_high": bin_edges_high,
-                    "simulated_event_histogram": simulated_event_histogram,
-                    "viewcone": viewcone,
-                    "core_range": core_range,
+                    "event_energies_reco": events_data["ENERGY"] * event_units["ENERGY"],
+                    "event_energies_mc": events_data["MC_ENERGY"] * event_units["MC_ENERGY"],
+                    "bin_edges_low": sim_events_data["MC_ENERG_LO"] * sim_units["MC_ENERG_LO"],
+                    "bin_edges_high": sim_events_data["MC_ENERG_HI"] * sim_units["MC_ENERG_HI"],
+                    "simulated_event_histogram": sim_events_data["EVENTS"] * u.count,
+                    "viewcone": hdul[3].data["viewcone"][0][1],  # pylint: disable=E1101
+                    "core_range": hdul[3].data["core_range"][0][1],  # pylint: disable=E1101
                 }
-                unique_azimuths = np.unique(events_data["PNT_AZ"]) * u.deg
-                unique_zeniths = 90 * u.deg - np.unique(events_data["PNT_ALT"]) * u.deg
-                if self.grid_point is None:
-                    _logger.info(f"Unique azimuths: {unique_azimuths}")
-                    _logger.info(f"Unique zeniths: {unique_zeniths}")
-
-                    if len(unique_azimuths) == 1 and len(unique_zeniths) == 1:
-                        _logger.info(
-                            f"Setting initial grid point with azimuth: {unique_azimuths[0]}"
-                            f" zenith: {unique_zeniths[0]}"
-                        )
-                        self.grid_point = (
-                            1 * u.TeV,
-                            unique_azimuths[0],
-                            unique_zeniths[0],
-                            0,
-                            0 * u.deg,
-                        )  # Initialize grid point with azimuth and zenith
-                    else:
-                        msg = "Multiple unique values found for azimuth or zenith."
-                        _logger.error(msg)
-                        raise ValueError(msg)
-                else:
-                    _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 * u.deg,
-                    )
-                    _logger.info(f"New grid point values: {self.grid_point}")
+                self._set_grid_point(events_data)
 
         except FileNotFoundError as e:
-            error_message = f"Error loading file {self.file_path}: {e}"
-            _logger.error(error_message)
+            error_message = f"Error loading file {file_path}: {e}"
+            self._logger.error(error_message)
             raise FileNotFoundError(error_message) from e
         return data
 
@@ -183,9 +146,9 @@ class StatisticalErrorEvaluator:
         bin_edges = np.concatenate([bin_edges_low, [bin_edges_high[-1]]])
         return np.unique(bin_edges)
 
-    def compute_triggered_event_histogram(self, event_energies_reco, bin_edges):
+    def compute_reconstructed_event_histogram(self, event_energies_reco, bin_edges):
         """
-        Compute histogram for triggered events.
+        Compute histogram of events as function of reconstructed energy.
 
         Parameters
         ----------
@@ -196,24 +159,26 @@ class StatisticalErrorEvaluator:
 
         Returns
         -------
-        triggered_event_histogram : array
-            Histogram of triggered events.
+        reconstructed_event_histogram : array
+            Histogram of reconstructed events.
         """
         event_energies_reco = event_energies_reco.to(bin_edges.unit)
 
-        triggered_event_histogram, _ = np.histogram(event_energies_reco.value, bins=bin_edges.value)
-        return triggered_event_histogram * u.count
+        reconstructed_event_histogram, _ = np.histogram(
+            event_energies_reco.value, bins=bin_edges.value
+        )
+        return reconstructed_event_histogram * u.count
 
-    def compute_efficiency_and_errors(self, triggered_event_counts, simulated_event_counts):
+    def compute_efficiency_and_errors(self, reconstructed_event_counts, simulated_event_counts):
         """
-        Compute trigger efficiency and its statistical error using the binomial distribution.
+        Compute reconstructed event efficiency and its uncertainty assuming binomial distribution.
 
         Parameters
         ----------
-        triggered_event_counts : array with units
-            Histogram counts of the triggered events.
+        reconstructed_event_counts : array with units
+            Histogram counts of reconstructed events.
         simulated_event_counts : array with units
-            Histogram counts of the simulated events.
+            Histogram counts of simulated events.
 
         Returns
         -------
@@ -223,32 +188,39 @@ class StatisticalErrorEvaluator:
             Array of relative uncertainties.
         """
         # Ensure the inputs have compatible units
-        triggered_event_counts = triggered_event_counts.to(u.ct)
-        simulated_event_counts = simulated_event_counts.to(u.ct)
+        reconstructed_event_counts = (
+            reconstructed_event_counts.to(u.ct)
+            if isinstance(reconstructed_event_counts, u.Quantity)
+            else reconstructed_event_counts * u.ct
+        )
+        simulated_event_counts = (
+            simulated_event_counts.to(u.ct)
+            if isinstance(simulated_event_counts, u.Quantity)
+            else simulated_event_counts * u.ct
+        )
+
+        if np.any(reconstructed_event_counts > simulated_event_counts):
+            raise ValueError("Reconstructed event counts exceed simulated event counts.")
 
         # Compute efficiencies, ensuring the output is dimensionless
         efficiencies = np.divide(
-            triggered_event_counts,
+            reconstructed_event_counts,
             simulated_event_counts,
-            out=np.zeros_like(triggered_event_counts),
+            out=np.zeros_like(reconstructed_event_counts),
             where=simulated_event_counts > 0,
         ).to(u.dimensionless_unscaled)
 
         # Set up a mask for valid data with a unit-consistent threshold
-        if np.any(triggered_event_counts > simulated_event_counts):
-            raise ValueError(
-                "Triggered event counts exceed simulated event counts. Please check input data."
-            )
-        valid = (simulated_event_counts > 0 * u.ct) & (triggered_event_counts > 0 * u.ct)
+        valid = (simulated_event_counts > 0) & (reconstructed_event_counts > 0)
 
-        uncertainties = np.zeros_like(triggered_event_counts.value) * u.dimensionless_unscaled
+        uncertainties = np.zeros_like(reconstructed_event_counts.value) * u.dimensionless_unscaled
 
         if np.any(valid):
             uncertainties[valid] = np.sqrt(
                 np.maximum(
                     simulated_event_counts[valid]
-                    / triggered_event_counts[valid]
-                    * (1 - triggered_event_counts[valid] / simulated_event_counts[valid]),
+                    / reconstructed_event_counts[valid]
+                    * (1 - reconstructed_event_counts[valid] / simulated_event_counts[valid]),
                     0,
                 )
             )
@@ -273,13 +245,13 @@ class StatisticalErrorEvaluator:
             Energy threshold value.
         """
         bin_edges = self.create_bin_edges()
-        triggered_event_histogram = self.compute_triggered_event_histogram(
+        reconstructed_event_histogram = self.compute_reconstructed_event_histogram(
             self.data["event_energies_mc"], bin_edges
         )
         simulated_event_histogram = self.data["simulated_event_histogram"]
 
         efficiencies, _ = self.compute_efficiency_and_errors(
-            triggered_event_histogram, simulated_event_histogram
+            reconstructed_event_histogram, simulated_event_histogram
         )
 
         # Determine the effective area threshold (10% of max effective area)
@@ -302,12 +274,12 @@ class StatisticalErrorEvaluator:
             Dictionary with uncertainties for the file.
         """
         bin_edges = self.create_bin_edges()
-        triggered_event_histogram = self.compute_triggered_event_histogram(
+        reconstructed_event_histogram = self.compute_reconstructed_event_histogram(
             self.data["event_energies_mc"], bin_edges
         )
         simulated_event_histogram = self.data["simulated_event_histogram"]
         _, relative_errors = self.compute_efficiency_and_errors(
-            triggered_event_histogram, simulated_event_histogram
+            reconstructed_event_histogram, simulated_event_histogram
         )
         return {"relative_errors": relative_errors}
 
@@ -326,7 +298,10 @@ class StatisticalErrorEvaluator:
         event_energies_mc = self.data["event_energies_mc"]
 
         if len(event_energies_reco) != len(event_energies_mc):
-            raise ValueError(f"Mismatch in the number of energies for file {self.file_path}")
+            raise ValueError(
+                f"Mismatch in the number of energies: {len(event_energies_reco)} vs "
+                f"{len(event_energies_mc)}"
+            )
 
         energy_deviation = (event_energies_reco - event_energies_mc) / event_energies_mc
 
@@ -354,12 +329,12 @@ class StatisticalErrorEvaluator:
 
             self.uncertainty_effective_area = self.calculate_uncertainty_effective_area()
             if self.uncertainty_effective_area:
-                validity_range = self.metrics.get("uncertainty_effective_area", {}).get(
-                    "valid_range"
+                energy_range = self.metrics.get("uncertainty_effective_area", {}).get(
+                    "energy_range"
                 )
-                min_energy, max_energy = validity_range["value"][0] * u.Unit(
-                    validity_range["unit"]
-                ), validity_range["value"][1] * u.Unit(validity_range["unit"])
+                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
@@ -375,7 +350,7 @@ class StatisticalErrorEvaluator:
                 ref_value = self.metrics.get("uncertainty_effective_area", {}).get("target_error")[
                     "value"
                 ]
-                _logger.info(
+                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}"
@@ -386,7 +361,7 @@ class StatisticalErrorEvaluator:
                 self.calculate_energy_estimate()
             )
             ref_value = self.metrics.get("energy_estimate", {}).get("target_error")["value"]
-            _logger.info(
+            self._logger.info(
                 f"Energy Estimate Error: {self.energy_estimate:.3f}, Reference: {ref_value:.3f}"
             )
         else:
@@ -442,7 +417,7 @@ class StatisticalErrorEvaluator:
                 overall_max_errors[metric_name] = result
             else:
                 raise ValueError(f"Unsupported result type for {metric_name}: {type(result)}")
-        _logger.info(f"overall_max_errors {overall_max_errors}")
+        self._logger.info(f"overall_max_errors {overall_max_errors}")
         all_max_errors = list(overall_max_errors.values())
         if metric == "average":
             overall_metric = np.mean(all_max_errors)

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,7 +19,7 @@ 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, science_case: str, metrics: dict):
         """
         Initialize the EventScaler with the evaluator, science case, and metrics.
 
@@ -46,22 +40,18 @@ class EventScaler:
         """
         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()
 

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:
@@ -80,16 +58,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:

simtools/production_configuration/interpolation_handler.py

@@ -4,18 +4,15 @@ 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, science_case: str, metrics: dict):
         self.evaluators = evaluators
         self.science_case = science_case
         self.metrics = metrics
@@ -157,9 +154,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 +181,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/ray_tracing/mirror_panel_psf.py

@@ -138,43 +138,63 @@ class MirrorPanelPSF:
             self.rnda_opt, save_figures=save_figures
         )
 
-    def _optimize_reflection_angle(self, step_size=0.1):
-        """Optimize the random reflection angle to minimize the difference in D80 containment."""
+    def _optimize_reflection_angle(self, step_size=0.1, max_iteration=100):
+        """
+        Optimize the random reflection angle to minimize the difference in D80 containment.
+
+        Parameters
+        ----------
+        step_size: float
+            Initial step size for optimization.
+        max_iteration: int
+            Maximum number of iterations.
+
+        Raises
+        ------
+        ValueError
+            If the optimization reaches the maximum number of iterations without converging.
+
+        """
+        relative_tolerance_d80 = self.args_dict["rtol_psf_containment"]
+        self._logger.info(
+            "Optimizing random reflection angle "
+            f"(relative tolerance = {relative_tolerance_d80}, "
+            f"step size = {step_size}, max iteration = {max_iteration})"
+        )
 
         def collect_results(rnda, mean, sig):
             self.results_rnda.append(rnda)
             self.results_mean.append(mean)
             self.results_sig.append(sig)
 
-        stop = False
-        mean_d80, sig_d80 = self.run_simulations_and_analysis(self.rnda_start)
+        reference_d80 = self.args_dict["psf_measurement_containment_mean"]
         rnda = self.rnda_start
-        sign_delta = np.sign(mean_d80 - self.args_dict["psf_measurement_containment_mean"])
-        collect_results(rnda, mean_d80, sig_d80)
-        while not stop:
-            rnda = rnda - (step_size * self.rnda_start * sign_delta)
-            if rnda < 0:
-                rnda = 0
-                collect_results(rnda, mean_d80, sig_d80)
-                break
+        prev_error_d80 = float("inf")
+        iteration = 0
+
+        while True:
             mean_d80, sig_d80 = self.run_simulations_and_analysis(rnda)
-            new_sign_delta = np.sign(mean_d80 - self.args_dict["psf_measurement_containment_mean"])
-            stop = new_sign_delta != sign_delta
-            sign_delta = new_sign_delta
+            error_d80 = abs(1 - mean_d80 / reference_d80)
             collect_results(rnda, mean_d80, sig_d80)
 
-        self._interpolate_optimal_rnda()
+            if error_d80 < relative_tolerance_d80:
+                break
+
+            if mean_d80 < reference_d80:
+                rnda += step_size * self.rnda_start
+            else:
+                rnda -= step_size * self.rnda_start
 
-    def _interpolate_optimal_rnda(self):
-        """Interpolate to find the optimal random reflection angle."""
-        self.results_rnda, self.results_mean, self.results_sig = gen.sort_arrays(
-            self.results_rnda, self.results_mean, self.results_sig
-        )
-        self.rnda_opt = np.interp(
-            x=self.args_dict["psf_measurement_containment_mean"],
-            xp=self.results_mean,
-            fp=self.results_rnda,
-        )
+            if error_d80 >= prev_error_d80:
+                step_size = step_size / 2
+            prev_error_d80 = error_d80
+            iteration += 1
+            if iteration > max_iteration:
+                raise ValueError(
+                    f"Maximum iterations ({max_iteration}) reached without convergence."
+                )
+
+        self.rnda_opt = rnda
 
     def _get_starting_value(self):
         """Get optimization starting value from command line or previous model."""
@@ -275,6 +295,6 @@ class MirrorPanelPSF:
         )
         writer.ModelDataWriter.dump(
             args_dict=self.args_dict,
-            metadata=MetadataCollector(args_dict=self.args_dict).top_level_meta,
+            metadata=MetadataCollector(args_dict=self.args_dict).get_top_level_metadata(),
             product_data=result_table,
         )