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

simtools/model/model_parameter.py

@@ -86,6 +86,18 @@ class ModelParameter:
         self._is_config_file_up_to_date = False
         self._is_exported_model_files_up_to_date = False
 
+    @property
+    def parameters(self):
+        """
+        Model parameters dictionary.
+
+        Returns
+        -------
+        dict
+            Dictionary containing all model parameters
+        """
+        return self._parameters
+
     def _get_parameter_dict(self, par_name):
         """
         Get model parameter dictionary as stored in the DB.
@@ -110,11 +122,11 @@ class ModelParameter:
             If par_name does not match any parameter in this model.
         """
         try:
-            return self._parameters[par_name]
+            return self.parameters[par_name]
         except (KeyError, ValueError) as e:
-            msg = f"Parameter {par_name} was not found in the model {self.name}, {self.site}."
-            self._logger.error(msg)
-            raise InvalidModelParameterError(msg) from e
+            raise InvalidModelParameterError(
+                f"Parameter {par_name} was not found in the model {self.name}, {self.site}."
+            ) from e
 
     def get_parameter_value(self, par_name, parameter_dict=None):
         """
@@ -258,7 +270,7 @@ class ModelParameter:
 
     def print_parameters(self):
         """Print parameters and their values for debugging purposes."""
-        for par in self._parameters:
+        for par in self.parameters:
             print(f"{par} = {self.get_parameter_value(par)}")
 
     def _set_config_file_directory_and_name(self):
@@ -298,21 +310,6 @@ class ModelParameter:
         """
         return self._simulation_config_parameters.get(simulation_software)
 
-    def has_parameter(self, par_name):
-        """Check if a parameter exists in the model.
-
-        Parameters
-        ----------
-        par_name : str
-            Name of the parameter.
-
-        Returns
-        -------
-        bool
-            True if parameter exists in the model.
-        """
-        return par_name in self._parameters
-
     def _load_simulation_software_parameter(self):
         """Read simulation software parameters from DB."""
         for simulation_software in self._simulation_config_parameters:
@@ -337,12 +334,12 @@ class ModelParameter:
         if self.db is None:
             return
 
-        if self.name is not None:
+        if self.name:
             self._parameters = self.db.get_model_parameters(
                 self.site, self.name, self.collection, self.model_version
             )
 
-        if self.site is not None:
+        if self.site:
             self._parameters.update(
                 self.db.get_model_parameters(
                     self.site,
@@ -353,56 +350,11 @@ class ModelParameter:
             )
         self._load_simulation_software_parameter()
 
-    def set_extra_label(self, extra_label):
-        """
-        Set an extra label for the name of the config file.
-
-        Notes
-        -----
-        The config file directory name is not affected by the extra label. Only the file name is \
-        changed. This is important for the ArrayModel class to export multiple config files in the\
-        same directory.
-
-        Parameters
-        ----------
-        extra_label: str
-            Extra label to be appended to the original label.
-        """
-        self._extra_label = extra_label
-        self._set_config_file_directory_and_name()
-
     @property
     def extra_label(self):
         """Return the extra label if defined, if not return ''."""
         return self._extra_label if self._extra_label is not None else ""
 
-    def get_simtel_parameters(self, parameters=None):
-        """
-        Get simtel parameters as name and value pairs.
-
-        Parameters
-        ----------
-        parameters: dict
-            Parameters (simtools) to be renamed (if necessary)
-
-        Returns
-        -------
-        dict
-            simtel parameters as dict (sorted by parameter names)
-
-        """
-        if parameters is None:
-            parameters = self._parameters
-
-        _simtel_parameter_value = {}
-        for key in parameters:
-            _par_name = names.get_simulation_software_name_from_parameter_name(
-                key, simulation_software="sim_telarray"
-            )
-            if _par_name is not None:
-                _simtel_parameter_value[_par_name] = parameters[key].get("value")
-        return dict(sorted(_simtel_parameter_value.items()))
-
     def change_parameter(self, par_name, value):
         """
         Change the value of an existing parameter.
@@ -421,29 +373,24 @@ class ModelParameter:
         InvalidModelParameterError
             If the parameter to be changed does not exist in this model.
         """
-        if par_name not in self._parameters:
-            msg = f"Parameter {par_name} not in the model"
-            self._logger.error(msg)
-            raise InvalidModelParameterError(msg)
+        if par_name not in self.parameters:
+            raise InvalidModelParameterError(f"Parameter {par_name} not in the model")
 
-        if isinstance(value, str):
-            value = gen.convert_string_to_list(value)
+        value = gen.convert_string_to_list(value) if isinstance(value, str) else value
 
+        par_type = self.get_parameter_type(par_name)
         if not gen.validate_data_type(
-            reference_dtype=self.get_parameter_type(par_name),
+            reference_dtype=par_type,
             value=value,
             dtype=None,
             allow_subtypes=True,
         ):
-            raise ValueError(
-                f"Could not cast {value} of type {type(value)} "
-                f"to {self.get_parameter_type(par_name)}."
-            )
+            raise ValueError(f"Could not cast {value} of type {type(value)} to {par_type}.")
 
         self._logger.debug(
             f"Changing parameter {par_name} from {self.get_parameter_value(par_name)} to {value}"
         )
-        self._parameters[par_name]["value"] = value
+        self.parameters[par_name]["value"] = value
 
         # In case parameter is a file, the model files will be outdated
         if self.get_parameter_file_flag(par_name):
@@ -483,7 +430,7 @@ class ModelParameter:
 
         """
         for par, value in kwargs.items():
-            if par in self._parameters:
+            if par in self.parameters:
                 self.change_parameter(par, value)
 
         self._is_config_file_up_to_date = False
@@ -507,7 +454,7 @@ class ModelParameter:
     def export_model_files(self):
         """Export the model files into the config file directory."""
         # Removing parameter files added manually (which are not in DB)
-        pars_from_db = copy(self._parameters)
+        pars_from_db = copy(self.parameters)
         if self._added_parameter_files is not None:
             for par in self._added_parameter_files:
                 pars_from_db.pop(par)
@@ -517,18 +464,14 @@ class ModelParameter:
 
     def export_config_file(self):
         """Export the config file used by sim_telarray."""
-        # Exporting model file
         if not self._is_exported_model_files_up_to_date:
             self.export_model_files()
 
-        # Using SimtelConfigWriter to write the config file.
         self._load_simtel_config_writer()
         self.simtel_config_writer.write_telescope_config_file(
             config_file_path=self.config_file_path,
-            parameters=self.get_simtel_parameters(parameters=self._parameters),
-            config_parameters=self.get_simtel_parameters(
-                parameters=self._simulation_config_parameters["simtel"]
-            ),
+            parameters=self.parameters,
+            config_parameters=self._simulation_config_parameters["simtel"],
         )
 
     @property

simtools/production_configuration/derive_corsika_limits.py

@@ -1,16 +1,17 @@
-"""Calculate the thresholds for energy, radial distance, and viewcone."""
+"""Calculate CORSIKA thresholds for energy, radial distance, and viewcone."""
+
+import logging
 
 import astropy.units as u
 import matplotlib.pyplot as plt
 import numpy as np
-import tables
-from astropy.coordinates import AltAz
-from ctapipe.coordinates import GroundFrame, TiltedGroundFrame
+
+from simtools.simtel.simtel_io_event_reader import SimtelIOEventDataReader
 
 
 class LimitCalculator:
     """
-    Compute thresholds/limits for energy, radial distance, and viewcone.
+    Compute thresholds for CORSIKA configuration for energy, radial distance, and viewcone.
 
     Event data is read from the reduced MC event data file.
 
@@ -23,52 +24,14 @@ class LimitCalculator:
     """
 
     def __init__(self, event_data_file, telescope_list=None):
-        """
-        Initialize the LimitCalculator with the given event data file.
-
-        Parameters
-        ----------
-        event_data_file : str
-            Path to the reduced MC event data file.
-        telescope_list : list, optional
-            List of telescope IDs to filter the events (default is None).
-        """
+        """Initialize the LimitCalculator with the given event data file."""
+        self._logger = logging.getLogger(__name__)
         self.event_data_file = event_data_file
         self.telescope_list = telescope_list
-        self.event_x_core = None
-        self.event_y_core = None
-        self.simulated = None
-        self.shower_id_triggered = None
-        self.list_of_files = None
-        self.shower_sim_azimuth = None
-        self.shower_sim_altitude = None
-        self.array_azimuth = None
-        self.array_altitude = None
-        self.trigger_telescope_list_list = None
-        self.units = {}
-        self._read_event_data()
-
-    def _read_event_data(self):
-        """Read the event data from the reduced MC event data file."""
-        with tables.open_file(self.event_data_file, mode="r") as f:
-            reduced_data = f.root.data.reduced_data
-            triggered_data = f.root.data.triggered_data
-            file_names = f.root.data.file_names
-            trigger_telescope_list_list = f.root.data.trigger_telescope_list_list
-
-            self.event_x_core = reduced_data.col("core_x")
-            self.event_y_core = reduced_data.col("core_y")
-            self.simulated = reduced_data.col("simulated")
-            self.shower_id_triggered = triggered_data.col("shower_id_triggered")
-            self.list_of_files = file_names.col("file_names")
-            self.shower_sim_azimuth = reduced_data.col("shower_sim_azimuth")
-            self.shower_sim_altitude = reduced_data.col("shower_sim_altitude")
-            self.array_altitude = reduced_data.col("array_altitudes")
-            self.array_azimuth = reduced_data.col("array_azimuths")
-
-            self.trigger_telescope_list_list = [
-                [np.int16(tel) for tel in event] for event in trigger_telescope_list_list
-            ]
+
+        self.reader = SimtelIOEventDataReader(event_data_file, telescope_list=telescope_list)
+        self.event_data = self.reader.triggered_shower_data
+        self.triggered_data = self.reader.triggered_data
 
     def _compute_limits(self, hist, bin_edges, loss_fraction, limit_type="lower"):
         """
@@ -94,40 +57,18 @@ class LimitCalculator:
         total_events = np.sum(hist)
         threshold = (1 - loss_fraction) * total_events
         bin_index = np.searchsorted(cumulative_sum, threshold)
-        return bin_edges[bin_index] if limit_type == "upper" else bin_edges[-bin_index]
 
-    def _prepare_data_for_limits(self):
-        """
-        Prepare the data required for computing limits.
+        return bin_edges[bin_index] if limit_type == "upper" else bin_edges[-bin_index]
 
-        Returns
-        -------
-        tuple
-            Tuple containing core distances, triggered energies, core bins, and energy bins.
-        """
-        shower_id_triggered_masked = self.shower_id_triggered
-        if self.telescope_list is not None:
-            mask = np.array(
-                [
-                    all(tel in event for tel in self.telescope_list)
-                    for event in self.trigger_telescope_list_list
-                ]
-            )
-            shower_id_triggered_masked = self.shower_id_triggered[mask]
-
-        triggered_energies = self.simulated[shower_id_triggered_masked]
-        energy_bins = np.logspace(
-            np.log10(triggered_energies.min()), np.log10(triggered_energies.max()), 1000
-        )
-        event_x_core_shower, event_y_core_shower = self._transform_to_shower_coordinates()
-        core_distances_all = np.sqrt(event_x_core_shower**2 + event_y_core_shower**2)
-        core_distances_triggered = core_distances_all[shower_id_triggered_masked]
-        core_bins = np.linspace(
-            core_distances_triggered.min(), core_distances_triggered.max(), 1000
+    @property
+    def energy_bins(self):
+        """Return bins for the energy histogram."""
+        return np.logspace(
+            np.log10(self.event_data.simulated_energy.min()),
+            np.log10(self.event_data.simulated_energy.max()),
+            1000,
         )
 
-        return core_distances_triggered, triggered_energies, core_bins, energy_bins
-
     def compute_lower_energy_limit(self, loss_fraction):
         """
         Compute the lower energy limit in TeV based on the event loss fraction.
@@ -142,13 +83,19 @@ class LimitCalculator:
         astropy.units.Quantity
             Lower energy limit.
         """
-        _, triggered_energies, _, energy_bins = self._prepare_data_for_limits()
+        hist, _ = np.histogram(self.event_data.simulated_energy, bins=self.energy_bins)
+        return (
+            self._compute_limits(hist, self.energy_bins, loss_fraction, limit_type="lower") * u.TeV
+        )
 
-        hist, _ = np.histogram(triggered_energies, bins=energy_bins)
-        lower_bin_edge_value = self._compute_limits(
-            hist, energy_bins, loss_fraction, limit_type="lower"
+    @property
+    def core_distance_bins(self):
+        """Return bins for the core distance histogram."""
+        return np.linspace(
+            self.event_data.core_distance_shower.min(),
+            self.event_data.core_distance_shower.max(),
+            1000,
         )
-        return lower_bin_edge_value * u.TeV
 
     def compute_upper_radial_distance(self, loss_fraction):
         """
@@ -164,18 +111,29 @@ class LimitCalculator:
         astropy.units.Quantity
             Upper radial distance in m.
         """
-        core_distances_triggered, _, core_bins, _ = self._prepare_data_for_limits()
+        hist, _ = np.histogram(self.event_data.core_distance_shower, bins=self.core_distance_bins)
+        return (
+            self._compute_limits(hist, self.core_distance_bins, loss_fraction, limit_type="upper")
+            * u.m
+        )
 
-        hist, _ = np.histogram(core_distances_triggered, bins=core_bins)
-        upper_bin_edge_value = self._compute_limits(
-            hist, core_bins, loss_fraction, limit_type="upper"
+    @property
+    def view_cone_bins(self):
+        """Return bins for the viewcone histogram."""
+        return np.linspace(
+            self.triggered_data.angular_distance.min(),
+            self.triggered_data.angular_distance.max(),
+            1000,
         )
-        return upper_bin_edge_value * u.m
 
     def compute_viewcone(self, loss_fraction):
         """
         Compute the viewcone based on the event loss fraction.
 
+        The shower IDs of triggered events are used to create a mask for the
+        azimuth and altitude of the triggered events. A mapping is created
+        between the triggered events and the simulated events using the shower IDs.
+
         Parameters
         ----------
         loss_fraction : float
@@ -186,75 +144,185 @@ class LimitCalculator:
         astropy.units.Quantity
             Viewcone radius in degrees.
         """
-        # already in radians
-        azimuth_diff = self.array_azimuth - self.shower_sim_azimuth  # * (np.pi / 180.0)
-        sim_altitude_rad = self.shower_sim_altitude  # * (np.pi / 180.0)
-        array_altitude_rad = self.array_altitude  # * (np.pi / 180.0)
-        x_1 = np.cos(azimuth_diff) * np.cos(sim_altitude_rad)
-        y_1 = np.sin(azimuth_diff) * np.cos(sim_altitude_rad)
-        z_1 = np.sin(sim_altitude_rad)
-        x_2 = x_1 * np.sin(array_altitude_rad) - z_1 * np.cos(array_altitude_rad)
-        y_2 = y_1
-        z_2 = x_1 * np.cos(array_altitude_rad) + z_1 * np.sin(array_altitude_rad)
-        off_angles = np.arctan2(np.sqrt(x_2**2 + y_2**2), z_2) * (180.0 / np.pi)
-        angle_bins = np.linspace(off_angles.min(), off_angles.max(), 400)
-        hist, _ = np.histogram(off_angles, bins=angle_bins)
-
-        upper_bin_edge_value = self._compute_limits(
-            hist, angle_bins, loss_fraction, limit_type="upper"
+        hist, _ = np.histogram(self.triggered_data.angular_distance, bins=self.view_cone_bins)
+        return (
+            self._compute_limits(hist, self.view_cone_bins, loss_fraction, limit_type="upper")
+            * u.deg
         )
-        return upper_bin_edge_value * u.deg
 
-    def _transform_to_shower_coordinates(self):
+    def plot_data(self, lower_energy_limit, upper_radial_distance, viewcone, output_path=None):
         """
-        Transform core positions from ground coordinates to shower coordinates.
+        Plot the core distances and energies of triggered events.
+
+        Parameters
+        ----------
+        lower_energy_limit: astropy.units.Quantity
+            Lower energy limit to display on plots.
+        upper_radial_distance: astropy.units.Quantity
+            Upper radial distance limit to display on plots.
+        viewcone: astropy.units.Quantity
+            Viewcone radius to display on plots.
+        output_path: Path or str, optional
+            Directory to save plots. If None, plots will be displayed.
+        """
+        event_counts = "Event Count"
+        plots = {
+            "core_vs_energy": {
+                "x_data": self.event_data.core_distance_shower,
+                "y_data": self.event_data.simulated_energy,
+                "bins": [self.core_distance_bins, self.energy_bins],
+                "plot_type": "histogram2d",
+                "plot_params": {"norm": "log", "cmap": "viridis"},
+                "labels": {
+                    "x": "Core Distance [m]",
+                    "y": "Energy [TeV]",
+                    "title": "Triggered events: core distance vs energy",
+                },
+                "scales": {"y": "log"},
+                "colorbar_label": event_counts,
+                "filename": "core_vs_energy_distribution.png",
+            },
+            "energy_distribution": {
+                "x_data": self.event_data.simulated_energy,
+                "bins": np.logspace(-3, 0.0, 100),
+                "plot_type": "histogram",
+                "plot_params": {"histtype": "step", "color": "k", "lw": 2},
+                "labels": {
+                    "x": "Energy [TeV]",
+                    "y": event_counts,
+                    "title": "Triggered events: energy distribution",
+                },
+                "scales": {"x": "log", "y": "log"},
+                "lines": {"x": lower_energy_limit.value},
+                "filename": "energy_distribution.png",
+            },
+            "core_distance": {
+                "x_data": self.event_data.core_distance_shower,
+                "bins": self.core_distance_bins,
+                "plot_type": "histogram",
+                "plot_params": {"histtype": "step", "color": "k", "lw": 2},
+                "labels": {
+                    "x": "Core Distance [m]",
+                    "y": event_counts,
+                    "title": "Triggered events: core distance distribution",
+                },
+                "lines": {"x": upper_radial_distance.value},
+                "filename": "core_distance_distribution.png",
+            },
+            "core_xy": {
+                "x_data": self.event_data.x_core_shower,
+                "y_data": self.event_data.y_core_shower,
+                "bins": 100,
+                "plot_type": "histogram2d",
+                "plot_params": {"norm": "log", "cmap": "viridis"},
+                "labels": {
+                    "x": "Core X [m]",
+                    "y": "Core Y [m]",
+                    "title": "Triggered events: core x vs core y",
+                },
+                "colorbar_label": event_counts,
+                "lines": {"x": upper_radial_distance.value, "y": upper_radial_distance.value},
+                "filename": "core_xy_distribution.png",
+            },
+            "view-cone": {
+                "x_data": self.triggered_data.angular_distance,
+                "bins": self.view_cone_bins,
+                "plot_type": "histogram",
+                "plot_params": {"histtype": "step", "color": "k", "lw": 2},
+                "labels": {
+                    "x": "Distance to pointing direction [deg]",
+                    "y": event_counts,
+                    "title": "Triggered events: viewcone distribution",
+                },
+                "lines": {"x": viewcone.value},
+                "filename": "viewcone_distribution.png",
+            },
+        }
+
+        for _, plot_args in plots.items():
+            filename = plot_args.pop("filename")
+            output_file = output_path / filename if output_path else None
+            self._create_plot(**plot_args, output_file=output_file)
+
+    def _create_plot(
+        self,
+        x_data,
+        y_data=None,
+        bins=None,
+        plot_type="histogram",
+        plot_params=None,
+        labels=None,
+        scales=None,
+        colorbar_label=None,
+        output_file=None,
+        lines=None,
+    ):
+        """
+        Create and save a plot with the given parameters.
+
+        Parameters
+        ----------
+        x_data : array-like
+            Data for the x-axis or primary data for histograms.
+        y_data : array-like, optional
+            Data for the y-axis in scatter or 2D histograms.
+        bins : int, array-like, or list, optional
+            Bins specification for histograms.
+        plot_type : str, optional
+            Type of plot: 'histogram', 'histogram2d', or 'scatter'.
+        plot_params : dict, optional
+            Additional parameters to pass to the plotting function.
+        labels : dict, optional
+            Dictionary containing 'x', 'y', and 'title' labels.
+        scales : dict, optional
+            Dictionary containing 'x' and 'y' scale types ('log' or 'linear').
+        colorbar_label : str, optional
+            Label for the colorbar in 2D histograms.
+        output_file : Path, optional
+            File path to save the plot. If not provided, the plot will be displayed.
+        lines : dict, optional
+            Dictionary containing 'x' and 'y' values for reference lines.
 
         Returns
         -------
-        tuple
-            Core positions in shower coordinates (x, y).
+        matplotlib.figure.Figure
+            The created figure object.
         """
-        pointing_az = self.shower_sim_azimuth * u.rad
-        pointing_alt = self.shower_sim_altitude * u.rad
-
-        pointing = AltAz(az=pointing_az, alt=pointing_alt)
-        ground = GroundFrame(x=self.event_x_core * u.m, y=self.event_y_core * u.m, z=0 * u.m)
-        shower_frame = ground.transform_to(TiltedGroundFrame(pointing_direction=pointing))
-
-        return shower_frame.x.value, shower_frame.y.value
-
-    def plot_data(self):
-        """Plot the core distances and energies of triggered events."""
-        shower_id_triggered_masked = self.shower_id_triggered
-        if self.telescope_list is not None:
-            mask = np.array(
-                [
-                    all(tel in event for tel in self.telescope_list)
-                    for event in self.trigger_telescope_list_list
-                ]
-            )
-            shower_id_triggered_masked = self.shower_id_triggered[mask]
-
-        core_distances_all = np.sqrt(self.event_x_core**2 + self.event_y_core**2)
-        core_distances_triggered = core_distances_all[shower_id_triggered_masked]
-        triggered_energies = self.simulated[shower_id_triggered_masked]
-
-        core_bins = np.linspace(core_distances_triggered.min(), core_distances_triggered.max(), 400)
-        energy_bins = np.logspace(
-            np.log10(triggered_energies.min()), np.log10(triggered_energies.max()), 400
-        )
-        plt.figure(figsize=(8, 6))
-        plt.hist2d(
-            core_distances_triggered,
-            triggered_energies,
-            bins=[core_bins, energy_bins],
-            norm="log",
-            cmap="viridis",
-        )
-
-        plt.colorbar(label="Event Count")
-        plt.xlabel("Core Distance [m]")
-        plt.ylabel("Energy [TeV]")
-        plt.yscale("log")
-        plt.title("2D Histogram of Triggered Core Distance vs Energy")
-        plt.show()
+        fig = plt.figure(figsize=(8, 6))
+        plot_params = plot_params or {}
+        labels = labels or {}
+        scales = scales or {}
+        lines = lines or {}
+
+        if plot_type == "histogram":
+            plt.hist(x_data, bins=bins, **plot_params)
+        elif plot_type == "histogram2d":
+            plt.hist2d(x_data, y_data, bins=bins, **plot_params)
+            if colorbar_label:
+                plt.colorbar(label=colorbar_label)
+        elif plot_type == "scatter":
+            plt.scatter(x_data, y_data, **plot_params)
+
+        if "x" in lines:
+            plt.axvline(lines["x"], color="r", linestyle="--")
+        if "y" in lines:
+            plt.axhline(lines["y"], color="r", linestyle="--")
+
+        plt.xlabel(labels.get("x", ""))
+        plt.ylabel(labels.get("y", ""))
+        plt.title(labels.get("title", ""))
+
+        if "x" in scales:
+            plt.xscale(scales["x"])
+        if "y" in scales:
+            plt.yscale(scales["y"])
+
+        if output_file:
+            self._logger.info(f"Saving plot to {output_file}")
+            plt.savefig(output_file, dpi=300, bbox_inches="tight")
+            plt.close()
+        else:
+            plt.tight_layout()
+            plt.show()
+
+        return fig

simtools/production_configuration/event_scaler.py

@@ -68,9 +68,9 @@ class EventScaler:
             The scaling factor.
         """
         metric_results = self.evaluator.calculate_metrics()
-        uncertainty_effective_area = metric_results.get("uncertainty_effective_area", {})
+        uncertainty_effective_area = metric_results.get("uncertainty_effective_area")
         current_max_error = uncertainty_effective_area.get("max_error")
-        target_max_error = self.metrics.get("uncertainty_effective_area", {}).get("target_error")[
+        target_max_error = self.metrics.get("uncertainty_effective_area").get("target_error")[
             "value"
         ]