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

simtools/utils/general.py

@@ -180,13 +180,17 @@ def collect_data_from_file(file_name, yaml_document=None):
         return collect_data_from_http(file_name)
 
     suffix = Path(file_name).suffix.lower()
-    with open(file_name, encoding="utf-8") as file:
-        if suffix == ".json":
-            return json.load(file)
-        if suffix == ".list":
-            return [line.strip() for line in file.readlines()]
-        if suffix in [".yml", ".yaml"]:
-            return _collect_data_from_yaml_file(file, file_name, yaml_document)
+    try:
+        with open(file_name, encoding="utf-8") as file:
+            if suffix == ".json":
+                return json.load(file)
+            if suffix == ".list":
+                return [line.strip() for line in file.readlines()]
+            if suffix in [".yml", ".yaml"]:
+                return _collect_data_from_yaml_file(file, file_name, yaml_document)
+    # broad exception to catch all possible errors in reading the file
+    except Exception as exc:  # pylint: disable=broad-except
+        raise type(exc)(f"Failed to read file {file_name}: {exc}") from exc
     return None
 
 
@@ -842,6 +846,28 @@ def _load_yaml_using_astropy(file):
     return astropy_yaml.load(file)
 
 
+def is_utf8_file(file_name):
+    """
+    Check if a file is encoded in UTF-8.
+
+    Parameters
+    ----------
+    file_name: str, Path
+        Name of the file to be checked.
+
+    Returns
+    -------
+    bool
+        True if the file is encoded in UTF-8, False otherwise.
+    """
+    try:
+        with open(file_name, encoding="utf-8") as file:
+            file.read()
+        return True
+    except UnicodeDecodeError:
+        return False
+
+
 def read_file_encoded_in_utf_or_latin(file_name):
     """
     Read a file encoded in UTF-8 or Latin-1.

simtools/utils/geometry.py

@@ -161,3 +161,22 @@ def rotate(x, y, rotation_around_z_axis, rotation_around_y_axis=0):
     y_trans = x * np.sin(rotation_around_z_axis) + y * np.cos(rotation_around_z_axis)
 
     return x_trans, y_trans
+
+
+def calculate_circular_mean(angles):
+    """
+    Calculate circular mean of angles in radians.
+
+    Parameters
+    ----------
+    angles: numpy.array
+        Array of angles in radians.
+
+    Returns
+    -------
+    float
+        Circular mean of the angles.
+    """
+    sin_sum = np.sum(np.sin(angles))
+    cos_sum = np.sum(np.cos(angles))
+    return np.arctan2(sin_sum, cos_sum)

simtools/utils/names.py

@@ -513,6 +513,7 @@ def get_collection_name_from_parameter_name(parameter_name):
 def get_simulation_software_name_from_parameter_name(
     parameter_name,
     simulation_software="sim_telarray",
+    set_meta_parameter=False,
 ):
     """
     Get the name used in the given simulation software from the model parameter name.
@@ -526,6 +527,8 @@ def get_simulation_software_name_from_parameter_name(
         Model parameter name.
     simulation_software: str
         Simulation software name.
+    set_meta_parameter: bool
+        If True, return values with 'set_meta_parameter' field set to True.
 
     Returns
     -------
@@ -537,7 +540,10 @@ def get_simulation_software_name_from_parameter_name(
         raise KeyError(f"Parameter {parameter_name} without schema definition")
 
     for software in _parameter.get("simulation_software", []):
-        if software.get("name") == simulation_software:
+        if (
+            software.get("name") == simulation_software
+            and software.get("set_meta_parameter", False) is set_meta_parameter
+        ):
             return software.get("internal_parameter_name", parameter_name)
 
     return None

simtools/visualization/visualize.py

@@ -197,7 +197,7 @@ def set_style(palette="default", big_plot=False):
         raise KeyError(f"palette must be one of {', '.join(COLORS)}")
 
     fontsize = {"default": 17, "big_plot": 30}
-    markersize = {"default": 8, "big_plot": 18}
+    markersize = {"default": 6, "big_plot": 18}
     plot_size = "big_plot" if big_plot else "default"
 
     plt.rc("lines", linewidth=2, markersize=markersize[plot_size])
@@ -740,7 +740,7 @@ def plot_array(
 
 
 def initialize_tel_counters():
-    return {one_telescope: 0 for one_telescope in names.get_list_of_array_element_types()}
+    return dict.fromkeys(names.get_list_of_array_element_types(), 0)
 
 
 def get_rotated_positions(telescopes, rotate_angle):

simtools/production_configuration/extract_mc_event_data.py

@@ -1,253 +0,0 @@
-"""Generate a reduced dataset from given simulation event list and save the output to file."""
-
-import logging
-
-import numpy as np
-import tables
-from ctapipe.core import Container, Field
-from ctapipe.io import HDF5TableWriter
-from eventio import EventIOFile
-from eventio.simtel import ArrayEvent, MCEvent, MCRunHeader, MCShower, TriggerInformation
-
-DEFAULT_FILTERS = tables.Filters(complevel=5, complib="zlib", shuffle=True, bitshuffle=False)
-
-
-class ReducedDatasetContainer(Container):
-    """Container for reduced dataset information."""
-
-    simulated = Field(None, "Simulated energy")
-    core_x = Field(None, "X-coordinate of the shower core")
-    core_y = Field(None, "Y-coordinate of the shower core")
-    shower_sim_azimuth = Field(None, "Simulated azimuth angle of the shower")
-    shower_sim_altitude = Field(None, "Simulated altitude angle of the shower")
-    array_altitudes = Field(None, "Altitudes for the array")
-    array_azimuths = Field(None, "Azimuths for the array")
-
-
-class TriggeredShowerContainer(Container):
-    """Container for triggered shower information."""
-
-    shower_id_triggered = Field(None, "Triggered shower ID")
-    triggered_energies = Field(None, "Triggered energies")
-
-
-class FileNamesContainer(Container):
-    """Container for file names."""
-
-    file_names = Field(None, "Input file names")
-
-
-class MCEventExtractor:
-    """
-    Generate a reduced dataset from given simulation event list and save the output to file.
-
-    Attributes
-    ----------
-    input_files : list
-        List of input file paths to process.
-    output_file : str
-        Path to the output HDF5 file.
-    max_files : int, optional
-        Maximum number of files to process.
-    """
-
-    def __init__(self, input_files, output_file, max_files=100):
-        """
-        Initialize the MCEventExtractor with input files, output file, and max file limit.
-
-        Parameters
-        ----------
-        input_files : list
-            List of input file paths to process.
-        output_file : str
-            Path to the output HDF5 file.
-        max_files : int, optional
-            Maximum number of files to process.
-        """
-        self._logger = logging.getLogger(__name__)
-        self.input_files = input_files
-        self.output_file = output_file
-        self.max_files = max_files
-        self.shower = None
-        self.n_use = None
-        self.shower_id_offset = 0
-
-    def process_files(self):
-        """Process the input files and store them in an HDF5 file."""
-        if not self.input_files:
-            self._logger.warning("No input files provided.")
-            return
-
-        data_lists = self._initialize_data_lists()
-        self.shower_id_offset = 0
-        # Process the first file in write mode
-        self._logger.info(f"Processing file 1/{self.max_files}: {self.input_files[0]}")
-        self._process_file(self.input_files[0], data_lists, str(self.input_files[0]))
-        self._write_all_data(data_lists, mode="w")
-        self.shower_id_offset = len(data_lists["simulated"])
-        self._reset_data_lists(data_lists)
-
-        # Process remaining files in append mode
-        for i_file, file in enumerate(self.input_files[1 : self.max_files], start=2):
-            self._logger.info(f"Processing file {i_file}/{self.max_files}: {file}")
-            self._process_file(file, data_lists, str(file))
-            if len(data_lists["simulated"]) >= 1e7:
-                self._write_all_data(data_lists, mode="a")
-                self.shower_id_offset += len(data_lists["simulated"])
-                self._reset_data_lists(data_lists)
-
-        # Final write for any remaining data
-        self._write_all_data(data_lists, mode="a")
-
-    def _write_all_data(self, data_lists, mode):
-        """Write all data sections at once helper method."""
-        self._write_data(data_lists, mode=mode)
-        self._write_variable_length_data(data_lists["trigger_telescope_list_list"], mode="a")
-        self._write_file_names(data_lists["file_names"], mode="a")
-
-    def _write_file_names(self, file_names, mode="a"):
-        """Write file names to HDF5 file."""
-        print("file_names", file_names)
-        with HDF5TableWriter(
-            self.output_file, group_name="data", mode=mode, filters=DEFAULT_FILTERS
-        ) as writer:
-            file_names_container = FileNamesContainer()
-            for file_name in file_names:
-                file_names_container.file_names = file_name
-                writer.write(table_name="file_names", containers=[file_names_container])
-
-    def _write_variable_length_data(self, trigger_telescope_list_list, mode="a"):
-        """Write variable-length array data to HDF5 file."""
-        with tables.open_file(self.output_file, mode=mode) as f:
-            if "trigger_telescope_list_list" in f.root.data:
-                vlarray = f.root.data.trigger_telescope_list_list
-            else:
-                vlarray = f.create_vlarray(
-                    f.root.data,
-                    "trigger_telescope_list_list",
-                    tables.Int16Atom(),
-                    "List of triggered telescope IDs",
-                )
-
-            for item in trigger_telescope_list_list:
-                vlarray.append(item)
-
-    def _initialize_data_lists(self):
-        """Initialize data lists."""
-        return {
-            "simulated": [],
-            "shower_id_triggered": [],
-            "triggered_energies": [],
-            "core_x": [],
-            "core_y": [],
-            "trigger_telescope_list_list": [],
-            "file_names": [],
-            "shower_sim_azimuth": [],
-            "shower_sim_altitude": [],
-            "array_altitudes": [],
-            "array_azimuths": [],
-        }
-
-    def _process_file(self, file, data_lists, file_name):
-        """Process a single file and update data lists."""
-        with EventIOFile(file) as f:
-            array_altitude = None
-            array_azimuth = None
-            for eventio_object in f:
-                if isinstance(eventio_object, MCRunHeader):
-                    self._process_mc_run_header(eventio_object, data_lists)
-                elif isinstance(eventio_object, MCShower):
-                    self._process_mc_shower(
-                        eventio_object, data_lists, array_altitude, array_azimuth
-                    )
-                elif isinstance(eventio_object, MCEvent):
-                    self._process_mc_event(eventio_object, data_lists)
-                elif isinstance(eventio_object, ArrayEvent):
-                    self._process_array_event(eventio_object, data_lists)
-            data_lists["file_names"].extend([file_name])
-
-    def _process_mc_run_header(self, eventio_object, data_lists):
-        """Process MC run header and update data lists."""
-        mc_head = eventio_object.parse()
-        self.n_use = mc_head["n_use"]  # reuse factor n_use needed to extend the values below
-        array_altitude = np.mean(mc_head["alt_range"])
-        array_azimuth = np.mean(mc_head["az_range"])
-        data_lists["array_altitudes"].extend(self.n_use * [array_altitude])
-        data_lists["array_azimuths"].extend(self.n_use * [array_azimuth])
-
-    def _process_mc_shower(self, eventio_object, data_lists, array_altitude, array_azimuth):
-        """Process MC shower and update data lists."""
-        self.shower = eventio_object.parse()
-        data_lists["simulated"].extend(self.n_use * [self.shower["energy"]])
-        data_lists["shower_sim_azimuth"].extend(self.n_use * [self.shower["azimuth"]])
-        data_lists["shower_sim_altitude"].extend(self.n_use * [self.shower["altitude"]])
-        data_lists["array_altitudes"].extend(self.n_use * [array_altitude])
-        data_lists["array_azimuths"].extend(self.n_use * [array_azimuth])
-
-    def _process_mc_event(self, eventio_object, data_lists):
-        """Process MC event and update data lists."""
-        event = eventio_object.parse()
-        data_lists["core_x"].append(event["xcore"])
-        data_lists["core_y"].append(event["ycore"])
-
-    def _process_array_event(self, eventio_object, data_lists):
-        """Process array event and update data lists."""
-        for i, obj in enumerate(eventio_object):
-            if i == 0 and isinstance(obj, TriggerInformation):
-                self._process_trigger_information(obj, data_lists)
-
-    def _process_trigger_information(self, trigger_info, data_lists):
-        """Process trigger information and update data lists."""
-        trigger_info = trigger_info.parse()
-        telescopes = trigger_info["telescopes_with_data"]
-        if len(telescopes) > 0:
-            data_lists["shower_id_triggered"].append(self.shower["shower"] + self.shower_id_offset)
-            data_lists["triggered_energies"].append(self.shower["energy"])
-            data_lists["trigger_telescope_list_list"].append(np.array(telescopes, dtype=np.int16))
-
-    def _write_data(self, data_lists, mode="a"):
-        """Write data to HDF5 file using HDF5TableWriter."""
-        with HDF5TableWriter(
-            self.output_file, group_name="data", mode=mode, filters=DEFAULT_FILTERS
-        ) as writer:
-            # Write reduced dataset container
-            reduced_container = ReducedDatasetContainer()
-            for i in range(len(data_lists["simulated"])):
-                reduced_container.simulated = data_lists["simulated"][i]
-                reduced_container.core_x = data_lists["core_x"][i]
-                reduced_container.core_y = data_lists["core_y"][i]
-                reduced_container.shower_sim_azimuth = data_lists["shower_sim_azimuth"][i]
-                reduced_container.shower_sim_altitude = data_lists["shower_sim_altitude"][i]
-                reduced_container.array_altitudes = data_lists["array_altitudes"][i]
-                reduced_container.array_azimuths = data_lists["array_azimuths"][i]
-                writer.write(table_name="reduced_data", containers=[reduced_container])
-
-            # Write triggered shower container
-            triggered_container = TriggeredShowerContainer()
-            for i in range(len(data_lists["shower_id_triggered"])):
-                triggered_container.shower_id_triggered = data_lists["shower_id_triggered"][i]
-                triggered_container.triggered_energies = data_lists["triggered_energies"][i]
-                writer.write(table_name="triggered_data", containers=[triggered_container])
-
-    def _reset_data_lists(self, data_lists):
-        """Reset data lists during batch processing."""
-        for key in data_lists:
-            data_lists[key] = []
-
-    def print_dataset_information(self):
-        """Print information about the datasets in the generated HDF5 file."""
-        try:
-            with tables.open_file(self.output_file, mode="r") as reader:
-                print("Datasets in file:")
-                for key in reader.root.data._v_children.keys():  # pylint: disable=protected-access
-                    dset = reader.root.data._v_children[key]  # pylint: disable=protected-access
-                    print(f"- {key}: shape={dset.shape}, dtype={dset.dtype}")
-
-                    # Print first 5 values each
-                    print(f"  First 5 values: {dset[:5]}")
-
-                    # Print units if available
-                    # units = dset.attrs.get("units", "N/A")
-                    # print(f"  Units: {units}")
-        except Exception as exc:
-            raise ValueError("An error occurred while reading the HDF5 file") from exc

simtools/simtel/simtel_io_events.py

@@ -1,265 +0,0 @@
-"""Read sim_telarray events from file."""
-
-import logging
-import math
-from copy import copy
-
-import astropy.units as u
-import numpy as np
-from eventio.simtel import SimTelFile
-
-__all__ = ["InconsistentInputFileError", "SimtelIOEvents"]
-
-
-class InconsistentInputFileError(Exception):
-    """Exception for inconsistent input file."""
-
-
-class SimtelIOEvents:
-    """
-    Read sim_telarray events from file.
-
-    sim_telarray files are read with eventio package.
-
-    Parameters
-    ----------
-    input_files: list
-        List of sim_telarray output files (str of Path).
-    """
-
-    def __init__(self, input_files=None):
-        """Initialize SimtelIOEvents."""
-        self._logger = logging.getLogger(__name__)
-        self.load_input_files(input_files)
-        if self.number_of_files > 0:
-            self.load_header_and_summary()
-
-    def load_input_files(self, files=None):
-        """
-        Store list of input files into input_files attribute.
-
-        Parameters
-        ----------
-        files: list
-            List of sim_telarray files (str or Path).
-        """
-        if not hasattr(self, "input_files"):
-            self.input_files = []
-
-        if files is None:
-            msg = "No input file was given"
-            self._logger.debug(msg)
-            return
-
-        if not isinstance(files, list):
-            files = [files]
-
-        for file in files:
-            self.input_files.append(file)
-
-    @property
-    def number_of_files(self):
-        """Return number of files loaded.
-
-        Returns
-        -------
-        int
-            Number of files loaded.
-        """
-        return len(self.input_files) if hasattr(self, "input_files") else 0
-
-    def load_header_and_summary(self):
-        """
-        Read MC header from sim_telarray files and store it into _mc_header.
-
-        Also fills summary_events with energy and core radius of triggered events.
-        """
-        self._number_of_files = len(self.input_files)
-        keys_to_grab = [
-            "obsheight",
-            "n_showers",
-            "n_use",
-            "core_range",
-            "diffuse",
-            "viewcone",
-            "E_range",
-            "spectral_index",
-            "B_total",
-        ]
-        self._mc_header = {}
-
-        def _are_headers_consistent(header0, header1):
-            comparison = {}
-            for k in keys_to_grab:
-                value = header0[k] == header1[k]
-                comparison[k] = value if isinstance(value, bool) else all(value)
-
-            return all(comparison)
-
-        is_first_file = True
-        number_of_triggered_events = 0
-        summary_energy, summary_rcore = [], []
-        for file in self.input_files:
-            with SimTelFile(file) as f:
-                for event in f:
-                    en = event["mc_shower"]["energy"]
-                    rc = math.sqrt(
-                        math.pow(event["mc_event"]["xcore"], 2)
-                        + math.pow(event["mc_event"]["ycore"], 2)
-                    )
-
-                    summary_energy.append(en)
-                    summary_rcore.append(rc)
-                    number_of_triggered_events += 1
-
-                if is_first_file:
-                    # First file - grabbing parameters
-                    self._mc_header.update({k: copy(f.mc_run_headers[0][k]) for k in keys_to_grab})
-                else:
-                    # Remaining files - Checking whether the parameters are consistent
-                    if not _are_headers_consistent(self._mc_header, f.mc_run_headers[0]):
-                        msg = "MC header pamameters from different files are inconsistent"
-                        self._logger.error(msg)
-                        raise InconsistentInputFileError(msg)
-
-                is_first_file = False
-
-        self.summary_events = {
-            "energy": np.array(summary_energy),
-            "r_core": np.array(summary_rcore),
-        }
-
-        # Calculating number of events
-        self._mc_header["n_events"] = (
-            self._mc_header["n_use"] * self._mc_header["n_showers"] * self._number_of_files
-        )
-        self._mc_header["n_triggered"] = number_of_triggered_events
-
-    @u.quantity_input(core_max=u.m)
-    def count_triggered_events(self, energy_range=None, core_max=None):
-        """
-        Count number of triggered events within a certain energy range and core radius.
-
-        Parameters
-        ----------
-        energy_range: Tuple with len 2
-            Max and min energy of energy range, e.g. energy_range=(100 * u.GeV, 10 * u.TeV).
-        core_max: astropy.Quantity distance
-            Maximum core radius for selecting showers, e.g. core_max=1000 * u.m.
-
-        Returns
-        -------
-        int
-            Number of triggered events.
-        """
-        energy_range = self._validate_energy_range(energy_range)
-        core_max = self._validate_core_max(core_max)
-
-        is_in_energy_range = [
-            energy_range[0] < e < energy_range[1] for e in self.summary_events["energy"]
-        ]
-        is_in_core_range = [r < core_max for r in self.summary_events["r_core"]]
-        return np.sum(np.array(is_in_energy_range) * np.array(is_in_core_range))
-
-    @u.quantity_input(core_max=u.m)
-    def select_events(self, energy_range=None, core_max=None):
-        """
-        Select sim_telarray events within a certain energy range and core radius.
-
-        Parameters
-        ----------
-        energy_range: Tuple len 2
-            Max and min energy of energy range, e.g. energy_range=(100 * u.GeV, 10 * u.TeV).
-        core_max: astropy.Quantity distance
-            Maximum core radius for selecting showers, e.g. core_max=1000 * u.m.
-
-        Returns
-        -------
-        list
-            List of events.
-        """
-        energy_range = self._validate_energy_range(energy_range)
-        core_max = self._validate_core_max(core_max)
-
-        selected_events = []
-        for file in self.input_files:
-            with SimTelFile(file) as f:
-                for event in f:
-                    energy = event["mc_shower"]["energy"]
-                    if energy < energy_range[0] or energy > energy_range[1]:
-                        continue
-
-                    x_core = event["mc_event"]["xcore"]
-                    y_core = event["mc_event"]["ycore"]
-                    r_core = math.sqrt(math.pow(x_core, 2) + math.pow(y_core, 2))
-                    if r_core > core_max:
-                        continue
-
-                    selected_events.append(event)
-        return selected_events
-
-    @u.quantity_input(core_max=u.m)
-    def count_simulated_events(self, energy_range=None, core_max=None):
-        """
-        Determine number of simulated events within a certain energy range and  core radius.
-
-        Use the simulated power law.
-        This calculation assumes the simulated spectrum is given by a single power law.
-
-        Parameters
-        ----------
-        energy_range: Tuple len 2
-            Max and min energy of energy range, e.g. energy_range=(100 * u.GeV, 10 * u.TeV).
-        core_max: astropy.Quantity distance
-            Maximum core radius for selecting showers, e.g. core_max=1000 * u.m.
-
-        Returns
-        -------
-        int
-            Number of simulated events.
-        """
-        energy_range = self._validate_energy_range(energy_range)
-        core_max = self._validate_core_max(core_max)
-
-        # energy factor
-        def integral(erange):
-            power = self._mc_header["spectral_index"] + 1
-            return math.pow(erange[0], power) - math.pow(erange[1], power)
-
-        energy_factor = integral(energy_range) / integral(self._mc_header["E_range"])
-
-        # core factor
-        core_factor = math.pow(core_max, 2) / math.pow(self._mc_header["core_range"][1], 2)
-
-        return self._mc_header["n_events"] * energy_factor * core_factor
-
-    def _validate_energy_range(self, energy_range):
-        """
-        Return the default energy range from mc_header in case energy_range=None.
-
-        Check units, convert it to TeV and return it in the right format, otherwise.
-        """
-        if energy_range is None:
-            return self._mc_header["E_range"]
-
-        if not isinstance(energy_range[0], u.Quantity) or not isinstance(
-            energy_range[1], u.Quantity
-        ):
-            msg = "energy_range must be given as u.Quantity in units of energy"
-            self._logger.error(msg)
-            raise TypeError(msg)
-
-        try:
-            return (energy_range[0].to(u.TeV).value, energy_range[1].to(u.TeV).value)
-        except u.core.UnitConversionError as e:
-            msg = "energy_range must be in units of energy"
-            self._logger.error(msg)
-            raise TypeError(msg) from e
-
-    def _validate_core_max(self, core_max):
-        """
-        Return the default core_max from mc_header in case core_max=None.
-
-        Check units, convert it to m and return it in the right format, otherwise.
-        """
-        return self._mc_header["core_range"][1] if core_max is None else core_max.to(u.m).value