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

simtools/model/array_model.py

@@ -12,7 +12,7 @@ from simtools.io_operations import io_handler
 from simtools.model.site_model import SiteModel
 from simtools.model.telescope_model import TelescopeModel
 from simtools.simtel.simtel_config_writer import SimtelConfigWriter
-from simtools.utils import general, names
+from simtools.utils import names
 
 __all__ = ["ArrayModel"]
 
@@ -326,12 +326,11 @@ class ArrayModel:
             "site": site,
             "parameter_version": parameter_version,
             "unique_id": None,
-            "value": general.convert_list_to_string(
-                [x.to("m").value, y.to("m").value, z.to("m").value]
-            ),
+            "value": [x.to("m").value, y.to("m").value, z.to("m").value],
             "unit": "m",
             "type": "float64",
             "file": False,
+            "meta_parameter": False,
         }
 
     def _get_array_elements_from_list(self, array_elements_list: list[str]) -> dict:

simtools/model/model_parameter.py

@@ -6,12 +6,10 @@ import shutil
 from copy import copy
 
 import astropy.units as u
-from astropy.table import Table
 
 import simtools.utils.general as gen
 from simtools.db import db_handler
 from simtools.io_operations import io_handler
-from simtools.simtel import simtel_table_reader
 from simtools.simtel.simtel_config_writer import SimtelConfigWriter
 from simtools.utils import names
 
@@ -88,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.
@@ -112,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):
         """
@@ -260,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):
@@ -300,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:
@@ -339,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,
@@ -355,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.
@@ -423,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):
@@ -485,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
@@ -509,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,49 +462,16 @@ class ModelParameter:
         self.db.export_model_files(parameters=pars_from_db, dest=self.config_file_directory)
         self._is_exported_model_files_up_to_date = True
 
-    def get_model_file_as_table(self, par_name):
-        """
-        Return tabular data from file as astropy table.
-
-        Parameters
-        ----------
-        par_name: str
-            Name of the parameter.
-
-        Returns
-        -------
-        Table
-            Astropy table.
-        """
-        _par_entry = {}
-        try:
-            _par_entry[par_name] = self._parameters[par_name]
-        except KeyError as exc:
-            raise ValueError(f"Parameter {par_name} not found in the model.") from exc
-        self.db.export_model_files(parameters=_par_entry, dest=self.config_file_directory)
-        if _par_entry[par_name]["value"].endswith("ecsv"):
-            return Table.read(
-                self.config_file_directory.joinpath(_par_entry[par_name]["value"]),
-                format="ascii.ecsv",
-            )
-        return simtel_table_reader.read_simtel_table(
-            par_name, self.config_file_directory.joinpath(_par_entry[par_name]["value"])
-        )
-
     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

@@ -0,0 +1,328 @@
+"""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
+
+from simtools.simtel.simtel_io_event_reader import SimtelIOEventDataReader
+
+
+class LimitCalculator:
+    """
+    Compute thresholds for CORSIKA configuration for energy, radial distance, and viewcone.
+
+    Event data is read from the reduced MC event data file.
+
+    Parameters
+    ----------
+    event_data_file : str
+        Path to the HDF5 file containing the event data.
+    telescope_list : list, optional
+        List of telescope IDs to filter the events (default is None).
+    """
+
+    def __init__(self, event_data_file, telescope_list=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.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"):
+        """
+        Compute the limits based on the loss fraction.
+
+        Parameters
+        ----------
+        hist : np.ndarray
+            1D histogram array.
+        bin_edges : np.ndarray
+            Array of bin edges.
+        loss_fraction : float
+            Fraction of events to be lost.
+        limit_type : str, optional
+            Type of limit ('lower' or 'upper'). Default is 'lower'.
+
+        Returns
+        -------
+        float
+            Bin edge value corresponding to the threshold.
+        """
+        cumulative_sum = np.cumsum(hist) if limit_type == "upper" else np.cumsum(hist[::-1])
+        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]
+
+    @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,
+        )
+
+    def compute_lower_energy_limit(self, loss_fraction):
+        """
+        Compute the lower energy limit in TeV based on the event loss fraction.
+
+        Parameters
+        ----------
+        loss_fraction : float
+            Fraction of events to be lost.
+
+        Returns
+        -------
+        astropy.units.Quantity
+            Lower energy limit.
+        """
+        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
+        )
+
+    @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,
+        )
+
+    def compute_upper_radial_distance(self, loss_fraction):
+        """
+        Compute the upper radial distance based on the event loss fraction.
+
+        Parameters
+        ----------
+        loss_fraction : float
+            Fraction of events to be lost.
+
+        Returns
+        -------
+        astropy.units.Quantity
+            Upper radial distance in m.
+        """
+        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
+        )
+
+    @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,
+        )
+
+    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
+            Fraction of events to be lost.
+
+        Returns
+        -------
+        astropy.units.Quantity
+            Viewcone radius in degrees.
+        """
+        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
+        )
+
+    def plot_data(self, lower_energy_limit, upper_radial_distance, viewcone, output_path=None):
+        """
+        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
+        -------
+        matplotlib.figure.Figure
+            The created figure object.
+        """
+        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"
         ]
 

simtools/ray_tracing/mirror_panel_psf.py

@@ -295,6 +295,6 @@ class MirrorPanelPSF:
         )
         writer.ModelDataWriter.dump(
             args_dict=self.args_dict,
-            metadata=MetadataCollector(args_dict=self.args_dict).get_top_level_metadata(),
+            metadata=MetadataCollector(args_dict=self.args_dict),
             product_data=result_table,
         )