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

simtools/production_configuration/generate_simulation_config.py

@@ -0,0 +1,193 @@
+"""
+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
+
+from simtools.production_configuration.calculate_statistical_errors_grid_point import (
+    StatisticalErrorEvaluator,
+)
+from simtools.production_configuration.event_scaler import EventScaler
+
+_logger = logging.getLogger(__name__)
+
+
+class SimulationConfig:
+    """
+    Configures simulation parameters for a specific grid point.
+
+    Parameters
+    ----------
+    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
+        Type of the DL2 MC event file ('point-like' or 'cone').
+    metrics : dict, optional
+        Dictionary of metrics to evaluate.
+    """
+
+    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.simulation_params = {}
+
+    def configure_simulation(self) -> dict[str, float]:
+        """
+        Configure the simulation parameters for the grid point, data level, and science case.
+
+        Returns
+        -------
+        dict
+            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,
+        }
+
+        return self.simulation_params
+
+    def calculate_required_events(self) -> int:
+        """
+        Calculate the required number of simulated events based on statistical error metrics.
+
+        Uses the EventScaler to scale the events.
+
+        Returns
+        -------
+        int
+            The number of simulated events required.
+        """
+        return self.event_scaler.scale_events()
+
+    def _calculate_core_scatter_area(self) -> float:
+        """
+        Calculate the core scatter area based on the grid point and data level.
+
+        Returns
+        -------
+        float
+            The core scatter area.
+        """
+        base_area = self._fetch_simulated_core_scatter_area()
+        area_factor = self._get_area_factor_from_grid_point()
+        return base_area * area_factor
+
+    def _calculate_viewcone(self) -> float:
+        """
+        Calculate the viewcone based on the grid point conditions and data level.
+
+        Returns
+        -------
+        float
+            The viewcone value.
+        """
+        base_viewcone = self._fetch_simulated_viewcone()
+        viewcone_factor = self._get_viewcone_factor_from_grid_point()
+
+        return base_viewcone * viewcone_factor
+
+    def _get_area_factor_from_grid_point(self) -> float:
+        """
+        Determine the area factor.
+
+        The area factor is based on the grid point's azimuth,
+          elevation, and night sky background.
+
+        Returns
+        -------
+        float
+            The area factor.
+        """
+        azimuth = self.grid_point.get("azimuth", 0)
+        elevation = self.grid_point.get("elevation", 0)
+        night_sky_background = self.grid_point.get("night_sky_background", 0)
+
+        # Implement reading of factor from LUT
+        return azimuth + elevation + night_sky_background
+
+    def _get_viewcone_factor_from_grid_point(self) -> float:
+        """
+        Determine the viewcone factor.
+
+        The factor is based on the grid point's azimuth,
+          elevation, and night sky background.
+
+        Returns
+        -------
+        float
+            The viewcone factor.
+        """
+        azimuth = self.grid_point.get("azimuth", 0)
+        elevation = self.grid_point.get("elevation", 0)
+        night_sky_background = self.grid_point.get("night_sky_background", 0)
+
+        # Implement reading of factor from LUT
+        return azimuth + elevation + night_sky_background
+
+    def _fetch_simulated_core_scatter_area(self) -> float:
+        """
+        Fetch the core scatter area from existing simulated files based on grid point conditions.
+
+        Returns
+        -------
+        float
+            The fetched core scatter outer bound.
+        """
+        return self.evaluator.data["core_range"]
+
+    def _fetch_simulated_viewcone(self) -> float:
+        """
+        Fetch the viewcone from existing simulated files based on grid point conditions.
+
+        Returns
+        -------
+        float
+            The fetched viewcone outer bound.
+        """
+        return self.evaluator.data["viewcone"]

simtools/production_configuration/interpolation_handler.py

@@ -0,0 +1,197 @@
+"""Interpolates between instances of StatisticalErrorEvaluator using EventScaler."""
+
+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
+
+
+class InterpolationHandler:
+    """Handle interpolation between multiple StatisticalErrorEvaluator instances."""
+
+    def __init__(
+        self, evaluators: list["StatisticalErrorEvaluator"], science_case: str, 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.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]
+        self.nsbs = [e.grid_point[3] for e in self.evaluators]
+        self.offsets = [e.grid_point[4].to(u.deg).value for e in self.evaluators]
+
+        self.energy_grids = [
+            (e.data["bin_edges_low"][:-1] + e.data["bin_edges_high"][:-1]) / 2
+            for e in self.evaluators
+        ]
+        self.scaled_events = [
+            scaler.scale_events(return_sum=False) for scaler in self.event_scalers
+        ]
+        self.energy_thresholds = np.array([e.energy_threshold for e in self.evaluators])
+
+        self.data, self.grid_points = self._build_data_array()
+
+    def _build_data_array(self):
+        """
+        Build a data array with interpolated values across all dimensions including energy.
+
+        Returns
+        -------
+        np.ndarray
+            The data array with interpolated values.
+        np.ndarray
+            The corresponding grid points.
+        """
+        # Flatten the energy grid and other dimensions into a combined array
+        flat_data_list = []
+        flat_grid_points = []
+
+        for e, energy_grid, scaled_events in zip(
+            self.evaluators, self.energy_grids, self.scaled_events
+        ):
+            az = np.full(len(energy_grid), e.grid_point[1].to(u.deg).value)
+            zen = np.full(len(energy_grid), e.grid_point[2].to(u.deg).value)
+            nsb = np.full(len(energy_grid), e.grid_point[3])
+            offset = np.full(len(energy_grid), e.grid_point[4].to(u.deg).value)
+
+            # Combine grid points and data
+            grid_points = np.column_stack([energy_grid.to(u.TeV).value, az, zen, nsb, offset])
+            flat_grid_points.append(grid_points)
+            flat_data_list.append(scaled_events)
+
+        # Flatten the list and convert to numpy arrays
+        flat_grid_points = np.vstack(flat_grid_points)
+        flat_data = np.hstack(flat_data_list)
+
+        # Sort the grid points and corresponding data by energy
+        sorted_indices = np.argsort(flat_grid_points[:, 0])
+        sorted_grid_points = flat_grid_points[sorted_indices]
+        sorted_data = flat_data[sorted_indices]
+
+        return sorted_data, sorted_grid_points
+
+    def _remove_flat_dimensions(self, grid_points):
+        """Identify and remove flat dimensions (dimensions with no variance)."""
+        variance = np.var(grid_points, axis=0)
+        non_flat_mask = variance > 1e-6  # Threshold for determining flatness
+        reduced_grid_points = grid_points[:, non_flat_mask]
+        return reduced_grid_points, non_flat_mask
+
+    def interpolate(self, query_points: np.ndarray) -> np.ndarray:
+        """
+        Interpolate the number of simulated events given query points.
+
+        Parameters
+        ----------
+        query_points : np.ndarray
+            Array of query points with shape (n, 5), where n is the number of points,
+            and 5 represents (energy, azimuth, zenith, nsb, offset).
+
+        Returns
+        -------
+        np.ndarray
+            Interpolated values at the query points.
+        """
+        reduced_grid_points, non_flat_mask = self._remove_flat_dimensions(self.grid_points)
+        reduced_query_points = query_points[:, non_flat_mask]
+
+        # Interpolate using the reduced dimensions
+        return griddata(
+            reduced_grid_points,
+            self.data,
+            reduced_query_points,
+            method="linear",
+            fill_value=np.nan,
+            rescale=True,
+        )
+
+    def interpolate_energy_threshold(self, query_point: np.ndarray) -> float:
+        """
+        Interpolate the energy threshold for a given grid point.
+
+        Parameters
+        ----------
+        query_point : np.ndarray
+            Array specifying the grid point (energy, azimuth, zenith, NSB, offset).
+
+        Returns
+        -------
+        float
+            Interpolated energy threshold.
+        """
+        flat_grid_points = []
+        flat_energy_thresholds = []
+
+        for e in self.evaluators:
+            az = e.grid_point[1].to(u.deg).value
+            zen = e.grid_point[2].to(u.deg).value
+            nsb = e.grid_point[3]
+            offset = e.grid_point[4].to(u.deg).value
+            grid_point = np.array([az, zen, nsb, offset])
+            flat_grid_points.append(grid_point)
+            flat_energy_thresholds.append(e.energy_threshold)
+
+        flat_grid_points = np.array(flat_grid_points)
+        flat_energy_thresholds = np.array(flat_energy_thresholds)
+
+        reduced_grid_points, non_flat_mask = self._remove_flat_dimensions(flat_grid_points)
+        full_non_flat_mask = np.concatenate(([False], non_flat_mask))
+        reduced_query_point = query_point[0][full_non_flat_mask]
+
+        interpolated_threshold = griddata(
+            reduced_grid_points,
+            flat_energy_thresholds,
+            reduced_query_point,
+            method="linear",
+            fill_value=np.nan,
+            rescale=False,
+        )
+
+        return interpolated_threshold.item()
+
+    def plot_comparison(self, evaluator: "StatisticalErrorEvaluator"):
+        """
+        Plot a comparison between the simulated, scaled, and triggered events.
+
+        Parameters
+        ----------
+        evaluator : StatisticalErrorEvaluator
+            The evaluator for which to plot the comparison.
+        """
+        import matplotlib.pyplot as plt  # pylint: disable=import-outside-toplevel
+
+        midpoints = 0.5 * (evaluator.data["bin_edges_high"] + evaluator.data["bin_edges_low"])
+
+        self.grid_points = np.column_stack(
+            [
+                midpoints,
+                np.full_like(midpoints, evaluator.grid_point[1]),
+                np.full_like(midpoints, evaluator.grid_point[2]),
+                np.full_like(midpoints, evaluator.grid_point[3]),
+                np.full_like(midpoints, evaluator.grid_point[4]),
+            ]
+        )
+
+        self.interpolate(self.grid_points)
+
+        plt.plot(midpoints, evaluator.scaled_events, label="Scaled")
+
+        triggered_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.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.show()

simtools/ray_tracing/mirror_panel_psf.py

@@ -0,0 +1,280 @@
+"""Mirror panel PSF calculation."""
+
+import logging
+
+import astropy.units as u
+import numpy as np
+from astropy.table import QTable, Table
+
+import simtools.data_model.model_data_writer as writer
+import simtools.utils.general as gen
+from simtools.data_model.metadata_collector import MetadataCollector
+from simtools.model.telescope_model import TelescopeModel
+from simtools.ray_tracing.ray_tracing import RayTracing
+
+
+class MirrorPanelPSF:
+    """
+    Mirror panel PSF and random reflection angle calculation.
+
+    This class is used to derive the random reflection angle for the mirror panels in the telescope.
+
+    Known limitations: single Gaussian PSF model, no support for multiple PSF components (as allowed
+    in the model parameters).
+
+    Parameters
+    ----------
+    label: str
+        Application label.
+    args_dict: dict
+        Dictionary with input arguments.
+    db_config:
+        Dictionary with database configuration.
+    """
+
+    def __init__(self, label, args_dict, db_config):
+        """Initialize the MirrorPanelPSF class."""
+        self._logger = logging.getLogger(__name__)
+        self._logger.debug("Initializing MirrorPanelPSF")
+
+        self.args_dict = args_dict
+        self.telescope_model = self._define_telescope_model(label, db_config)
+
+        if self.args_dict["test"]:
+            self.args_dict["number_of_mirrors_to_test"] = 2
+
+        if self.args_dict["psf_measurement"]:
+            self._get_psf_containment()
+        if not self.args_dict["psf_measurement_containment_mean"]:
+            raise ValueError("Missing PSF measurement")
+
+        self.mean_d80 = None
+        self.sig_d80 = None
+        self.rnda_start = self._get_starting_value()
+        self.rnda_opt = None
+        self.results_rnda = []
+        self.results_mean = []
+        self.results_sig = []
+
+    def _define_telescope_model(self, label, db_config):
+        """
+        Define telescope model.
+
+        This includes updating the configuration with mirror list and/or random focal length given
+        as input.
+
+        Attributes
+        ----------
+        label: str
+            Application label.
+        db_config:
+            Dictionary with database configuration.
+
+        Returns
+        -------
+        tel TelescopeModel
+            telescope model
+
+        """
+        tel = TelescopeModel(
+            site=self.args_dict["site"],
+            telescope_name=self.args_dict["telescope"],
+            model_version=self.args_dict["model_version"],
+            mongo_db_config=db_config,
+            label=label,
+        )
+        if self.args_dict["mirror_list"] is not None:
+            mirror_list_file = gen.find_file(
+                name=self.args_dict["mirror_list"], loc=self.args_dict["model_path"]
+            )
+            tel.change_parameter("mirror_list", self.args_dict["mirror_list"])
+            tel.export_parameter_file("mirror_list", mirror_list_file)
+        if self.args_dict["random_focal_length"] is not None:
+            tel.change_parameter("random_focal_length", str(self.args_dict["random_focal_length"]))
+        tel.export_model_files()
+
+        return tel
+
+    def _get_psf_containment(self):
+        """Read measured single-mirror point-spread function from file and return mean and sigma."""
+        # If this is a test, read just the first few lines since we only simulate those mirrors
+        data_end = (
+            self.args_dict["number_of_mirrors_to_test"] + 1 if self.args_dict["test"] else None
+        )
+        _psf_list = Table.read(
+            self.args_dict["psf_measurement"], format="ascii.ecsv", data_end=data_end
+        )
+        try:
+            self.args_dict["psf_measurement_containment_mean"] = np.nanmean(
+                np.array(_psf_list["psf_opt"].to("cm").value)
+            )
+            self.args_dict["psf_measurement_containment_sigma"] = np.nanstd(
+                np.array(_psf_list["psf_opt"].to("cm").value)
+            )
+        except KeyError as exc:
+            raise KeyError(
+                f"Missing column psf measurement (psf_opt) in {self.args_dict['psf_measurement']}"
+            ) from exc
+
+        self._logger.info(
+            f"Determined PSF containment to {self.args_dict['psf_measurement_containment_mean']:.4}"
+            f" +- {self.args_dict['psf_measurement_containment_sigma']:.4} cm"
+        )
+
+    def derive_random_reflection_angle(self, save_figures=False):
+        """
+        Minimize the difference between measured and simulated PSF for reflection angle.
+
+        Main loop of the optimization process. The method iterates over different values of the
+        random reflection angle until the difference in the mean value of the D80 containment
+        is minimal.
+        """
+        if self.args_dict["no_tuning"]:
+            self.rnda_opt = self.rnda_start
+        else:
+            self._optimize_reflection_angle()
+
+        self.mean_d80, self.sig_d80 = self.run_simulations_and_analysis(
+            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 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)
+        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
+            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
+            collect_results(rnda, mean_d80, sig_d80)
+
+        self._interpolate_optimal_rnda()
+
+    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,
+        )
+
+    def _get_starting_value(self):
+        """Get optimization starting value from command line or previous model."""
+        if self.args_dict["rnda"] != 0:
+            rnda_start = self.args_dict["rnda"]
+        else:
+            rnda_start = self.telescope_model.get_parameter_value("mirror_reflection_random_angle")[
+                0
+            ]
+
+        self._logger.info(f"Start value for mirror_reflection_random_angle: {rnda_start} deg")
+        return rnda_start
+
+    def run_simulations_and_analysis(self, rnda, save_figures=False):
+        """
+        Run ray tracing simulations and analysis for one given value of rnda.
+
+        Parameters
+        ----------
+        rnda: float
+            Random reflection angle in degrees.
+        save_figures: bool
+            Save figures.
+
+        Returns
+        -------
+        mean_d80: float
+            Mean value of D80 in cm.
+        sig_d80: float
+            Standard deviation of D80 in cm.
+        """
+        self.telescope_model.change_parameter("mirror_reflection_random_angle", rnda)
+        ray = RayTracing(
+            telescope_model=self.telescope_model,
+            simtel_path=self.args_dict.get("simtel_path", None),
+            single_mirror_mode=True,
+            mirror_numbers=(
+                list(range(1, self.args_dict["number_of_mirrors_to_test"] + 1))
+                if self.args_dict["test"]
+                else "all"
+            ),
+            use_random_focal_length=self.args_dict["use_random_focal_length"],
+        )
+        ray.simulate(test=self.args_dict["test"], force=True)  # force has to be True, always
+        ray.analyze(force=True)
+        if save_figures:
+            ray.plot("d80_cm", save=True, d80=self.args_dict["psf_measurement_containment_mean"])
+
+        return (
+            ray.get_mean("d80_cm").to(u.cm).value,
+            ray.get_std_dev("d80_cm").to(u.cm).value,
+        )
+
+    def print_results(self):
+        """Print results to stdout."""
+        containment_fraction_percent = int(self.args_dict["containment_fraction"] * 100)
+
+        print(f"\nMeasured D{containment_fraction_percent}:")
+        if self.args_dict["psf_measurement_containment_sigma"] is not None:
+            print(
+                f"Mean = {self.args_dict['psf_measurement_containment_mean']:.3f} cm, "
+                f"StdDev = {self.args_dict['psf_measurement_containment_sigma']:.3f} cm"
+            )
+        else:
+            print(f"Mean = {self.args_dict['psf_measurement_containment_mean']:.3f} cm")
+        print(f"\nSimulated D{containment_fraction_percent}:")
+        print(f"Mean = {self.mean_d80:.3f} cm, StdDev = {self.sig_d80:.3f} cm")
+        print("\nmirror_random_reflection_angle")
+        print(f"Previous value = {self.rnda_start:.6f}")
+        print(f"New value = {self.rnda_opt:.6f}\n")
+
+    def write_optimization_data(self):
+        """
+        Write optimization results to an astropy table (ecsv file).
+
+        Used mostly for debugging of the optimization process.
+        The first entry of the table is the best fit result.
+        """
+        containment_fraction_percent = int(self.args_dict["containment_fraction"] * 100)
+
+        result_table = QTable(
+            [
+                [True] + [False] * len(self.results_rnda),
+                [self.rnda_opt, *self.results_rnda] * u.deg,
+                ([0.0] * (len(self.results_rnda) + 1)),
+                ([0.0] * (len(self.results_rnda) + 1)) * u.deg,
+                [self.mean_d80, *self.results_mean] * u.cm,
+                [self.sig_d80, *self.results_sig] * u.cm,
+            ],
+            names=(
+                "best_fit",
+                "mirror_reflection_random_angle_sigma1",
+                "mirror_reflection_random_angle_fraction2",
+                "mirror_reflection_random_angle_sigma2",
+                f"containment_radius_D{containment_fraction_percent}",
+                f"containment_radius_sigma_D{containment_fraction_percent}",
+            ),
+        )
+        writer.ModelDataWriter.dump(
+            args_dict=self.args_dict,
+            metadata=MetadataCollector(args_dict=self.args_dict).top_level_meta,
+            product_data=result_table,
+        )