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

simtools/production_configuration/generate_production_grid.py

@@ -0,0 +1,364 @@
+"""
+Module defines the `GridGeneration` class.
+
+Used to generate a grid of simulation points based on flexible axes definitions such
+azimuth, zenith angle, night-sky background, and camera offset.
+The module handles axis binning, scaling and interpolation of energy thresholds, viewcone,
+and radius limits from a lookup table.
+Additionally, it allows for converting between Altitude/Azimuth and Right Ascension
+Declination coordinates. The resulting grid points are saved to a file.
+"""
+
+import json
+import logging
+
+import numpy as np
+from astropy import units as u
+from astropy.coordinates import AltAz, EarthLocation, SkyCoord
+from astropy.table import Table
+from astropy.units import Quantity
+from scipy.interpolate import griddata
+
+
+class GridGeneration:
+    """
+    Defines and generates a grid of simulation points based on flexible axes definitions.
+
+    This class generates a grid of points for a simulation based on parameters such as
+    azimuth, zenith angle, night-sky background, and camera offset,
+    taking into account axis definitions, scaling, and units and interpolating values
+    for simulations from a lookup table.
+    """
+
+    def __init__(
+        self,
+        axes: dict,
+        coordinate_system: str = "zenith_azimuth",
+        observing_location=None,
+        observing_time=None,
+        lookup_table: str | None = None,
+        telescope_ids: list | None = None,
+    ):
+        """
+        Initialize the grid with the given axes and coordinate system.
+
+        Parameters
+        ----------
+        axes : dict
+            Dictionary where each key is the axis name and the value is a dictionary
+            defining the axis properties (range, binning, scaling, etc.).
+        coordinate_system : str, optional
+            The coordinate system for the grid generation (default is 'zenith_azimuth').
+        observing_location : EarthLocation, optional
+            The location of the observation (latitude, longitude, height).
+        observing_time : Time, optional
+            The time of the observation. If None, coordinate conversion to RA/Dec not working.
+        lookup_table : str, optional
+            Path to the lookup table file (ECSV format).
+        telescope_ids : list of int, optional
+            List of telescope IDs to get the limits for.
+        """
+        self._logger = logging.getLogger(__name__)
+
+        self.axes = axes["axes"] if "axes" in axes else axes
+        self.coordinate_system = coordinate_system
+        self.observing_location = (
+            observing_location
+            if observing_location is not None
+            else EarthLocation(lat=0.0 * u.deg, lon=0.0 * u.deg, height=0 * u.m)
+        )
+        self.observing_time = observing_time
+        self.lookup_table = lookup_table
+        self.telescope_ids = telescope_ids
+
+        # Store target values for each axis
+        self.target_values = self._generate_target_values()
+
+        if self.lookup_table:
+            self._apply_lookup_table_limits()
+
+    def _generate_target_values(self):
+        """
+        Generate target axis values and store them as Quantities.
+
+        Returns
+        -------
+        dict
+            Dictionary of target values for each axis, stored as Quantity objects.
+        """
+        target_values = {}
+        for axis_name, axis in self.axes.items():
+            axis_range = axis["range"]
+            binning = axis["binning"]
+            scaling = axis.get("scaling", "linear")
+            units = axis.get("units", None)
+
+            if axis_name == "azimuth":
+                # Use circular binning for azimuth
+                values = self.create_circular_binning(axis_range, binning)
+            elif scaling == "log":
+                # Log scaling
+                values = np.logspace(np.log10(axis_range[0]), np.log10(axis_range[1]), binning)
+            elif scaling == "1/cos":
+                # 1/cos scaling
+                cos_min = np.cos(np.radians(axis_range[0]))
+                cos_max = np.cos(np.radians(axis_range[1]))
+                inv_cos_values = np.linspace(1 / cos_min, 1 / cos_max, binning)
+                values = np.degrees(np.arccos(1 / inv_cos_values))
+            else:
+                # Linear scaling
+                values = np.linspace(axis_range[0], axis_range[1], binning)
+
+            if units:
+                values = values * u.Unit(units)
+
+            target_values[axis_name] = values
+
+        return target_values
+
+    def _apply_lookup_table_limits(self):
+        """Apply limits from the lookup table and interpolate values."""
+        lookup_table = Table.read(self.lookup_table, format="ascii.ecsv")
+
+        matching_rows = [
+            row for row in lookup_table if set(self.telescope_ids) == set(row["telescope_ids"])
+        ]
+
+        if not matching_rows:
+            raise ValueError(
+                f"No matching rows in the lookup table for telescope_ids: {self.telescope_ids}"
+            )
+
+        def extract_array(field, transform=lambda x: x):
+            return np.array([transform(row[field]) for row in matching_rows])
+
+        zeniths = extract_array("zenith")
+        azimuths = extract_array("azimuth", lambda x: x % 360)
+        nsb_values = extract_array("nsb", lambda x: 1 if x == "dark" else 5)
+        lower_energy_thresholds = extract_array("lower_energy_threshold")
+        upper_radius_thresholds = extract_array("upper_radius_threshold")
+        viewcone_radii = extract_array("viewcone_radius")
+
+        # Wrap azimuths and repeat others
+        azimuths_wrapped = np.concatenate([azimuths + shift for shift in (0, 360, -360)])
+
+        def repeat_3(arr):
+            """Repeat an array three times."""
+            return np.tile(arr, 3)
+
+        points = np.column_stack(
+            (
+                repeat_3(zeniths),
+                azimuths_wrapped,
+                repeat_3(nsb_values),
+            )
+        )
+
+        target_grid = (
+            np.array(
+                np.meshgrid(
+                    self.target_values["zenith_angle"].value,
+                    self.target_values["azimuth"].value,
+                    self.target_values["nsb"].value,
+                    indexing="ij",
+                )
+            )
+            .reshape(3, -1)
+            .T
+        )
+
+        def interpolate(values):
+            return griddata(
+                points, repeat_3(values), target_grid, method="linear", fill_value=np.nan
+            ).reshape(
+                len(self.target_values["zenith_angle"]),
+                len(self.target_values["azimuth"]),
+                len(self.target_values["nsb"]),
+            )
+
+        self.interpolated_limits = {
+            "energy": interpolate(lower_energy_thresholds),
+            "radius": interpolate(upper_radius_thresholds),
+            "viewcone": interpolate(viewcone_radii),
+        }
+
+    def create_circular_binning(self, azimuth_range, num_bins):
+        """
+        Create bin centers for azimuth angles, handling circular wraparound (0 deg to 360 deg).
+
+        Parameters
+        ----------
+        azimuth_range : tuple
+            (min_azimuth, max_azimuth), can wrap around 0 deg.
+        num_bins : int
+            Number of bins.
+
+        Returns
+        -------
+        np.ndarray
+            Array of bin centers.
+        """
+        azimuth_min, azimuth_max = azimuth_range
+        azimuth_min %= 360  # Normalize to [0, 360)
+        azimuth_max %= 360
+
+        clockwise_distance = (azimuth_max - azimuth_min) % 360
+        counterclockwise_distance = (azimuth_min - azimuth_max) % 360
+
+        if clockwise_distance <= counterclockwise_distance:
+            bin_centers = (
+                np.linspace(azimuth_min, azimuth_min + clockwise_distance, num_bins, endpoint=True)
+                % 360
+            )
+        else:
+            bin_centers = (
+                np.linspace(
+                    azimuth_min, azimuth_min - counterclockwise_distance, num_bins, endpoint=True
+                )
+                % 360
+            )
+
+        return bin_centers
+
+    def generate_grid(self) -> list[dict]:
+        """
+        Generate the grid based on the required axes and include interpolated limits.
+
+        Takes energy threshold, viewcone, and radius from the interpolated lookup table.
+
+        Returns
+        -------
+        list of dict
+            A list of grid points, each represented as a dictionary with axis names
+            as keys and axis values as values. Axis values may include units where defined.
+        """
+        value_arrays = [value.value for value in self.target_values.values()]
+        units = [value.unit for value in self.target_values.values()]
+        grid = np.meshgrid(*value_arrays, indexing="ij")
+        combinations = np.vstack(list(map(np.ravel, grid))).T
+        grid_points = []
+        for combination in combinations:
+            grid_point = {
+                key: Quantity(combination[i], units[i])
+                for i, key in enumerate(self.target_values.keys())
+            }
+
+            if "energy" in self.interpolated_limits:
+                zenith_idx = np.searchsorted(
+                    self.target_values["zenith_angle"].value, grid_point["zenith_angle"].value
+                )
+                azimuth_idx = np.searchsorted(
+                    self.target_values["azimuth"].value, grid_point["azimuth"].value
+                )
+                nsb_idx = np.searchsorted(self.target_values["nsb"].value, grid_point["nsb"].value)
+                energy_lower = self.interpolated_limits["energy"][zenith_idx, azimuth_idx, nsb_idx]
+                grid_point["energy_threshold"] = {"lower": energy_lower * u.TeV}
+
+            if "radius" in self.interpolated_limits:
+                radius_value = self.interpolated_limits["radius"][zenith_idx, azimuth_idx, nsb_idx]
+                grid_point["radius"] = radius_value * u.m
+
+            if "viewcone" in self.interpolated_limits:
+                viewcone_value = self.interpolated_limits["viewcone"][
+                    zenith_idx, azimuth_idx, nsb_idx
+                ]
+                grid_point["viewcone"] = viewcone_value * u.deg
+
+            grid_points.append(grid_point)
+
+        return grid_points
+
+    def convert_altaz_to_radec(self, alt, az):
+        """
+        Convert Altitude/Azimuth (AltAz) coordinates to Right Ascension/Declination (RA/Dec).
+
+        Parameters
+        ----------
+        alt : float
+            Altitude angle in degrees.
+        az : float
+            Azimuth angle in degrees.
+
+        Returns
+        -------
+        SkyCoord
+            SkyCoord object containing the RA/Dec coordinates.
+
+        Raises
+        ------
+        ValueError
+            If observing_time is not set.
+        """
+        if self.observing_time is None:
+            raise ValueError(
+                "Observing time is not set. "
+                "Please provide an observing_time to convert coordinates."
+            )
+
+        alt_rad = alt.to(u.rad)
+        az_rad = az.to(u.rad)
+        aa = AltAz(
+            alt=alt_rad,
+            az=az_rad,
+            location=self.observing_location,
+            obstime=self.observing_time,
+        )
+        skycoord = SkyCoord(aa)
+        return skycoord.icrs  # Return RA/Dec in ICRS frame
+
+    def convert_coordinates(self, grid_points: list[dict]) -> list[dict]:
+        """
+        Convert the grid points to RA/Dec coordinates if necessary.
+
+        Parameters
+        ----------
+        grid_points : list of dict
+            List of grid points, each represented as a dictionary with axis
+              names as keys and values.
+
+        Returns
+        -------
+        list of dict
+            The grid points with converted RA/Dec coordinates.
+        """
+        if self.coordinate_system == "ra_dec":
+            for point in grid_points:
+                if "zenith_angle" in point and "azimuth" in point:
+                    alt = (90.0 * u.deg) - point.pop("zenith_angle")
+                    az = point.pop("azimuth")
+                    radec = self.convert_altaz_to_radec(alt, az)
+                    point["ra"] = radec.ra.deg * u.deg
+                    point["dec"] = radec.dec.deg * u.deg
+        return grid_points
+
+    def serialize_grid_points(self, grid_points, output_file=None):
+        """Serialize the grid output and save to a file or print to the console."""
+        cleaned_points = []
+
+        for point in grid_points:
+            cleaned_point = {}
+            for key, value in point.items():
+                if isinstance(value, dict):
+                    # Nested dictionaries
+                    cleaned_point[key] = {k: self.serialize_quantity(v) for k, v in value.items()}
+                else:
+                    cleaned_point[key] = self.serialize_quantity(value)
+
+            cleaned_points.append(cleaned_point)
+
+        output_data = json.dumps(cleaned_points, indent=4)
+
+        if output_file:
+            with open(output_file, "w", encoding="utf-8") as f:
+                f.write(output_data)
+            self._logger.info(f"Output saved to {output_file}")
+        else:
+            self._logger.info(output_data)
+        return output_data
+
+    def serialize_quantity(self, value):
+        """Serialize Quantity."""
+        if isinstance(value, u.Quantity):
+            return {"value": value.value, "unit": str(value.unit)}
+        self._logger.warning(f"Unsupported type {type(value)} for serialization. Returning as is.")
+        return value

simtools/production_configuration/generate_simulation_config.py

@@ -3,7 +3,9 @@
 from simtools.production_configuration.calculate_statistical_errors_grid_point import (
     StatisticalErrorEvaluator,
 )
-from simtools.production_configuration.event_scaler import EventScaler
+from simtools.production_configuration.derive_production_statistics import (
+    ProductionStatisticsDerivator,
+)
 
 __all__ = ["SimulationConfig"]
 
@@ -18,8 +20,6 @@ class SimulationConfig:
         Dictionary representing a grid point with azimuth, elevation, and night sky background.
     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.
     """
@@ -28,16 +28,16 @@ class SimulationConfig:
         self,
         grid_point: dict[str, float],
         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.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, self.metrics)
+        self.evaluator = StatisticalErrorEvaluator(file_path, metrics)
+        self.derive_production_statistics = ProductionStatisticsDerivator(
+            self.evaluator, self.metrics
+        )
         self.simulation_params = {}
 
     def configure_simulation(self) -> dict[str, float]:
@@ -61,14 +61,14 @@ class SimulationConfig:
         """
         Calculate the required number of simulated events based on statistical error metrics.
 
-        Uses the EventScaler to scale the events.
+        Uses the ProductionStatisticsDerivator to scale the events.
 
         Returns
         -------
         int
             The number of simulated events required.
         """
-        return self.event_scaler.scale_events()
+        return self.derive_production_statistics.derive_statistics()
 
     def _calculate_core_scatter_area(self) -> float:
         """

simtools/production_configuration/interpolation_handler.py

@@ -1,10 +1,12 @@
-"""Interpolates between instances of StatisticalErrorEvaluator using EventScaler."""
+"""Handle interpolation between multiple StatisticalErrorEvaluator instances."""
 
 import astropy.units as u
 import numpy as np
 from scipy.interpolate import griddata
 
-from simtools.production_configuration.event_scaler import EventScaler
+from simtools.production_configuration.derive_production_statistics import (
+    ProductionStatisticsDerivator,
+)
 
 __all__ = ["InterpolationHandler"]
 
@@ -15,7 +17,9 @@ class InterpolationHandler:
     def __init__(self, evaluators, metrics: dict):
         self.evaluators = evaluators
         self.metrics = metrics
-        self.event_scalers = [EventScaler(e, self.metrics) for e in self.evaluators]
+        self.derive_production_statistics = [
+            ProductionStatisticsDerivator(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]
@@ -26,8 +30,9 @@ class InterpolationHandler:
             (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.production_statistics = [
+            derivator.derive_statistics(return_sum=False)
+            for derivator in self.derive_production_statistics
         ]
         self.energy_thresholds = np.array([e.energy_threshold for e in self.evaluators])
 
@@ -48,8 +53,8 @@ class InterpolationHandler:
         flat_data_list = []
         flat_grid_points = []
 
-        for e, energy_grid, scaled_events in zip(
-            self.evaluators, self.energy_grids, self.scaled_events
+        for e, energy_grid, production_statistics in zip(
+            self.evaluators, self.energy_grids, self.production_statistics
         ):
             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)
@@ -59,7 +64,7 @@ class InterpolationHandler:
             # 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)
+            flat_data_list.append(production_statistics)
 
         # Flatten the list and convert to numpy arrays
         flat_grid_points = np.vstack(flat_grid_points)
@@ -153,7 +158,7 @@ class InterpolationHandler:
 
     def plot_comparison(self, evaluator):
         """
-        Plot a comparison between the simulated, scaled, and reconstructed events.
+        Plot a comparison between the simulated, derived, and reconstructed events.
 
         Parameters
         ----------
@@ -176,7 +181,7 @@ class InterpolationHandler:
 
         self.interpolate(self.grid_points)
 
-        plt.plot(midpoints, evaluator.scaled_events, label="Scaled")
+        plt.plot(midpoints, evaluator.production_statistics, label="Derived")
 
         reconstructed_event_histogram, _ = np.histogram(
             evaluator.data["event_energies_reco"], bins=evaluator.data["bin_edges_low"]
@@ -187,5 +192,5 @@ class InterpolationHandler:
         plt.xscale("log")
         plt.xlabel("Energy (Midpoint of Bin Edges)")
         plt.ylabel("Event Count")
-        plt.title("Comparison of Simulated, scaled, and reconstructed events")
+        plt.title("Comparison of simulated, derived, and reconstructed events")
         plt.show()

simtools/ray_tracing/mirror_panel_psf.py

@@ -9,7 +9,7 @@ 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.model.model_utils import initialize_simulation_models
 from simtools.ray_tracing.ray_tracing import RayTracing
 
 
@@ -38,7 +38,7 @@ class MirrorPanelPSF:
         self._logger.debug("Initializing MirrorPanelPSF")
 
         self.args_dict = args_dict
-        self.telescope_model = self._define_telescope_model(label, db_config)
+        self.telescope_model, self.site_model = self._define_telescope_model(label, db_config)
 
         if self.args_dict["test"]:
             self.args_dict["number_of_mirrors_to_test"] = 2
@@ -63,37 +63,32 @@ class MirrorPanelPSF:
         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
+            The telescope model.
+        site_model : SiteModel
+            The site model.
         """
-        tel = TelescopeModel(
+        tel_model, site_model = initialize_simulation_models(
+            label=label,
+            db_config=db_config,
             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)
+            tel_model.change_parameter("mirror_list", self.args_dict["mirror_list"])
+            tel_model.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()
+            tel_model.change_parameter(
+                "random_focal_length", str(self.args_dict["random_focal_length"])
+            )
 
-        return tel
+        return tel_model, site_model
 
     def _get_psf_containment(self):
         """Read measured single-mirror point-spread function from file and return mean and sigma."""
@@ -229,6 +224,7 @@ class MirrorPanelPSF:
         self.telescope_model.change_parameter("mirror_reflection_random_angle", rnda)
         ray = RayTracing(
             telescope_model=self.telescope_model,
+            site_model=self.site_model,
             simtel_path=self.args_dict.get("simtel_path", None),
             single_mirror_mode=True,
             mirror_numbers=(

simtools/ray_tracing/psf_analysis.py

@@ -91,7 +91,7 @@ class PSFImage:
 
     def _process_simtel_file_using_rx(self, photon_file):
         """
-        Process a simtel file with photon lists using the RX method.
+        Process a sim_telarray file with photon lists using the RX method.
 
         Parameters
         ----------
@@ -152,7 +152,7 @@ class PSFImage:
                 self._process_simtel_line(line)
 
         if not self._is_photon_positions_ok():
-            msg = "Problems reading Simtel file - invalid data"
+            msg = "Problems reading sim_telarray file - invalid data"
             self._logger.error(msg)
             raise RuntimeError(msg)
 

simtools/ray_tracing/ray_tracing.py

@@ -33,6 +33,8 @@ class RayTracing:
     ----------
     telescope_model: TelescopeModel
         telescope model
+    site_model: SiteModel
+        site model
     simtel_path: str (or Path)
         Location of sim_telarray installation.
     label: str
@@ -61,6 +63,7 @@ class RayTracing:
     def __init__(
         self,
         telescope_model,
+        site_model,
         simtel_path,
         label=None,
         zenith_angle=20.0 * u.deg,
@@ -77,7 +80,7 @@ class RayTracing:
         self.simtel_path = Path(simtel_path)
         self._io_handler = io_handler.IOHandler()
 
-        self.telescope_model = telescope_model
+        self.telescope_model, self.site_model = telescope_model, site_model
         self.label = label if label is not None else self.telescope_model.label
 
         self.zenith_angle = zenith_angle.to("deg").value
@@ -211,6 +214,7 @@ class RayTracing:
                 simtel = SimulatorRayTracing(
                     simtel_path=self.simtel_path,
                     telescope_model=self.telescope_model,
+                    site_model=self.site_model,
                     test=test,
                     config_data={
                         "zenith_angle": self.zenith_angle,