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

simtools/simtel/simtel_config_writer.py

@@ -1,21 +1,31 @@
 #!/usr/bin/python3
+"""Configuration file writer for sim_telarray."""
 
 import logging
+from pathlib import Path
+
+import astropy.units as u
+import numpy as np
+
+import simtools.utils.general as gen
+import simtools.version
+from simtools.utils import names
 
 __all__ = ["SimtelConfigWriter"]
 
 
 class SimtelConfigWriter:
     """
-    SimtelConfigWriter writes sim_telarray configuration files. It is designed to be used by model
-    classes (TelescopeModel and ArrayModel) only.
+    SimtelConfigWriter writes sim_telarray configuration files.
+
+    It is designed to be used by model classes (TelescopeModel and ArrayModel) only.
 
     Parameters
     ----------
     site: str
         South or North.
     model_version: str
-        Version of the model (ex. prod5).
+        Model version.
     telescope_model_name: str
         Telescope model name.
     layout_name: str
@@ -25,36 +35,11 @@ class SimtelConfigWriter:
     """
 
     TAB = " " * 3
-    SITE_PARS = [
-        "altitude",
-        "atmospheric_transmission",
-        "ref_lat",
-        "ref_long",
-        "array_coordinates",
-        "atmospheric_profile",
-        "magnetic_field",
-    ]
-    PARS_NOT_TO_WRITE = [
-        "pixel_shape",
-        "pixel_diameter",
-        "lightguide_efficiency_angle_file",
-        "lightguide_efficiency_wavelength_file",
-        "ref_lat",
-        "ref_long",
-        "array_coordinates",
-        "atmospheric_profile",
-        "magnetic_field",
-        "EPSG",
-        "mirror_panel_shape",
-        "mirror_panel_diameter",
-    ]
 
     def __init__(
         self, site, model_version, layout_name=None, telescope_model_name=None, label=None
     ):
-        """
-        Initialize SimtelConfigWriter.
-        """
+        """Initialize SimtelConfigWriter."""
         self._logger = logging.getLogger(__name__)
         self._logger.debug("Init SimtelConfigWriter")
 
@@ -64,47 +49,114 @@ class SimtelConfigWriter:
         self._layout_name = layout_name
         self._telescope_model_name = telescope_model_name
 
-    def write_telescope_config_file(self, config_file_path, parameters):
+    def write_telescope_config_file(self, config_file_path, parameters, config_parameters=None):
         """
-        Writes the sim_telarray config file for a single telescope.
+        Write the sim_telarray config file for a single telescope.
 
         Parameters
         ----------
         config_file_path: str or Path
             Path of the file to write on.
         parameters: dict
-            Model parameters in the same structure as used by the TelescopeModel class.
+            Model parameters
+        config_parameters: dict
+            Simulation software configuration parameters
         """
+        self._logger.debug(f"Writing telescope config file {config_file_path}")
+
+        if config_parameters:
+            parameters.update(config_parameters)
+
         with open(config_file_path, "w", encoding="utf-8") as file:
             self._write_header(file, "TELESCOPE CONFIGURATION FILE")
 
             file.write("#ifdef TELESCOPE\n")
             file.write(
                 f"   echo Configuration for {self._telescope_model_name}"
-                + " - TELESCOPE $(TELESCOPE)\n"
+                " - TELESCOPE $(TELESCOPE)\n"
             )
             file.write("#endif\n\n")
 
-            for par in parameters.keys():
-                if par in self.PARS_NOT_TO_WRITE:
-                    continue
-                value = parameters[par]["Value"]
-                file.write(f"{par} = {value}\n")
+            for _simtel_name, value in parameters.items():
+                if _simtel_name.startswith("array_trigger"):
+                    continue  # array trigger is a site parameter, not a telescope parameter
+                if _simtel_name:
+                    file.write(f"{_simtel_name} = {self._get_value_string_for_simtel(value)}\n")
+            _config_meta = self._get_simtel_metadata("telescope")
+            for _simtel_name, value in _config_meta.items():
+                file.write(f"{_simtel_name} = {value}\n")
+
+    def _get_value_string_for_simtel(self, value):
+        """
+        Return a value string for simtel.
+
+        Parameters
+        ----------
+        value: any
+            Value to convert to string.
+
+        Returns
+        -------
+        str
+            Value string for simtel.
+        """
+        value = "none" if value is None else value  # simtel requires 'none'
+        if isinstance(value, bool):
+            value = 1 if value else 0
+        elif isinstance(value, (list, np.ndarray)):  # noqa: UP038
+            value = gen.convert_list_to_string(value, shorten_list=True)
+        return value
+
+    def _get_simtel_metadata(self, config_type):
+        """
+        Return simtel metadata.
+
+        Parameters
+        ----------
+        type: str
+            Type of the configuration file (telescope, site)
+
+        Returns
+        -------
+        dict
+            Dictionary with simtel metadata.
+
+        """
+        parameters = {}
+        parameters["config_release"] = (
+            f"{self._model_version} written by simtools v{simtools.version.__version__}"
+        )
+        parameters["config_version"] = self._model_version
+        if config_type == "telescope":
+            parameters["camera_config_name"] = self._telescope_model_name
+            parameters["camera_config_variant"] = ""
+            parameters["camera_config_version"] = self._model_version
+            parameters["optics_config_name"] = self._telescope_model_name
+            parameters["optics_config_variant"] = ""
+            parameters["optics_config_version"] = self._model_version
+        elif config_type == "site":
+            parameters["site_config_name"] = self._site
+            parameters["site_config_variant"] = ""
+            parameters["site_config_version"] = self._model_version
+            parameters["array_config_name"] = self._layout_name
+            parameters["array_config_variant"] = ""
+            parameters["array_config_version"] = self._model_version
+        else:
+            raise ValueError(f"Unknown metadata type {config_type}")
+        return parameters
 
-    def write_array_config_file(self, config_file_path, layout, telescope_model, site_parameters):
+    def write_array_config_file(self, config_file_path, telescope_model, site_model):
         """
-        Writes the sim_telarray config file for an array of telescopes.
+        Write the sim_telarray config file for an array of telescopes.
 
         Parameters
         ----------
         config_file_path: str or Path
             Path of the file to write on.
-        layout: ArrayLayout
-            Instance of ArrayLayout referent to the array model.
-        telescope_model: list of TelescopeModel
-            List of TelescopeModel's instances as used by the ArrayModel instance.
-        site_parameters: dict
-            Site parameters.
+        telescope_model: dict of TelescopeModel
+            Dictionary of TelescopeModel's instances as used by the ArrayModel instance.
+        site_model: Site model
+            Site model.
         """
         with open(config_file_path, "w", encoding="utf-8") as file:
             self._write_header(file, "ARRAY CONFIGURATION FILE")
@@ -123,28 +175,31 @@ class SimtelConfigWriter:
             file.write(self.TAB + "echo *****************************\n\n")
 
             # Writing site parameters
-            self._write_site_parameters(file, site_parameters)
+            self._write_site_parameters(
+                file, site_model, Path(config_file_path).parent, telescope_model
+            )
 
             # Maximum telescopes
             file.write(self.TAB + f"maximum_telescopes = {len(telescope_model)}\n\n")
 
-            # Default telescope - 0th tel in telescope list
-            tel_config_file = telescope_model[0].get_config_file(no_export=True).name
+            # Default telescope in sim_telarray - 0th tel in telescope list
+            _, first_telescope = next(iter(telescope_model.items()))
+            tel_config_file = first_telescope.get_config_file(no_export=True).name
             file.write(f"# include <{tel_config_file}>\n\n")
 
-            # Looping over telescopes - from 1 to ...
-            for count, tel_model in enumerate(telescope_model):
+            # Looping over telescopes
+            for count, (tel_name, tel_model) in enumerate(telescope_model.items()):
                 tel_config_file = tel_model.get_config_file(no_export=True).name
-                file.write(f"%{layout[count].name}\n")
+                file.write(f"%{tel_name}\n")
                 file.write(f"#elif TELESCOPE == {count + 1}\n\n")
                 file.write(f"# include <{tel_config_file}>\n\n")
-            file.write("#endif \n\n")
+            file.write("#endif \n\n")  # configuration files need to end with \n\n
 
     def write_single_mirror_list_file(
         self, mirror_number, mirrors, single_mirror_list_file, set_focal_length_to_zero=False
     ):
         """
-        Writes the sim_telarray mirror list file for a single mirror.
+        Write the sim_telarray mirror list file for a single mirror.
 
         Parameters
         ----------
@@ -190,8 +245,16 @@ class SimtelConfigWriter:
 
     def _write_header(self, file, title, comment_char="%"):
         """
-        Writes a generic header. commen_char is the character to be used for comments, which \
-        differs among ctypes of config files.
+        Write a generic header.
+
+        Parameters
+        ----------
+        file: file
+            File to write.
+        title: str
+            Title of the header.
+        comment_char: str
+            Character to be used for comments, which differs among ctypes of config files.
         """
         header = f"{comment_char}{50 * '='}\n"
         header += f"{comment_char} {title}\n"
@@ -212,12 +275,130 @@ class SimtelConfigWriter:
         header += f"{comment_char}\n"
         file.write(header)
 
-    def _write_site_parameters(self, file, site_parameters):
-        """Writes site parameters."""
+    def _write_site_parameters(self, file, site_model, model_path, telescope_model):
+        """
+        Write site parameters.
+
+        Parameters
+        ----------
+        file: file
+            File to write on.
+        site_model: SiteModel
+            Site model.
+        model_path: Path
+            Path to the model for writing of additional files.
+        telescope_model: dict of TelescopeModel
+            Telescope models.
+        """
         file.write(self.TAB + "% Site parameters\n")
-        for par in site_parameters:
-            if par in self.PARS_NOT_TO_WRITE:
-                continue
-            value = site_parameters[par]["Value"]
-            file.write(self.TAB + f"{par} = {value}\n")
+        _site_parameters = site_model.get_simtel_parameters()
+        for par, value in _site_parameters.items():
+            _simtel_name = names.get_simulation_software_name_from_parameter_name(
+                par,
+                simulation_software="sim_telarray",
+                search_telescope_parameters=False,
+                search_site_parameters=True,
+            )
+            _simtel_name, value = self._convert_model_parameters_to_simtel_format(
+                _simtel_name, value, model_path, telescope_model
+            )
+            if _simtel_name is not None:
+                file.write(f"{self.TAB}{_simtel_name} = {value}\n")
+        _simtel_meta = self._get_simtel_metadata("site")
+        for _simtel_name, value in _simtel_meta.items():
+            file.write(f"{self.TAB}{_simtel_name} = {value}\n")
         file.write("\n")
+
+    def _convert_model_parameters_to_simtel_format(
+        self, simtel_name, value, model_path, telescope_model
+    ):
+        """
+        Convert model parameter value to simtel format.
+
+        This might involve format or unit conversion and writing to a parameter file.
+
+        Parameters
+        ----------
+        simtel_name: str
+            Parameter name.
+        value: any
+            Value to convert.
+        model_path: Path
+            Path to the model for writing of additional files.
+        telescope_model: dict of TelescopeModel
+            Telescope models.
+
+        Returns
+        -------
+        str, any
+            Converted parameter name and value.
+        """
+        conversion_dict = {
+            "array_triggers": self._write_array_triggers_file,
+        }
+        try:
+            value = conversion_dict[simtel_name](value, model_path, telescope_model)
+        except KeyError:
+            pass
+        return simtel_name, value
+
+    def _write_array_triggers_file(self, array_triggers, model_path, telescope_model):
+        """
+        Write array trigger definition file in simtel format.
+
+        Parameters
+        ----------
+        array_triggers: dict
+            Array trigger definitions.
+        model_path: Path
+            Path to the model for writing of additional files.
+        telescope_model: dict of TelescopeModel
+            Telescope models.
+        """
+        trigger_per_telescope_type = {}
+        for count, tel_name in enumerate(telescope_model.keys()):
+            telescope_type = names.get_array_element_type_from_name(tel_name)
+            trigger_per_telescope_type.setdefault(telescope_type, []).append(count + 1)
+
+        trigger_lines = {}
+        for tel_type, tel_list in trigger_per_telescope_type.items():
+            trigger_dict = self._get_array_triggers_for_telescope_type(array_triggers, tel_type)
+            trigger_lines[tel_type] = f"Trigger {trigger_dict['multiplicity']['value']} of "
+            trigger_lines[tel_type] += ", ".join(map(str, tel_list))
+            width = trigger_dict["width"]["value"] * u.Unit(trigger_dict["width"]["unit"]).to("ns")
+            trigger_lines[tel_type] += f" width {width}"
+            if trigger_dict.get("hard_stereo"):
+                trigger_lines[tel_type] += " hard_stereo"
+            if all(trigger_dict["min_separation"][key] is not None for key in ["value", "unit"]):
+                min_sep = trigger_dict["min_separation"]["value"] * u.Unit(
+                    trigger_dict["min_separation"]["unit"]
+                ).to("m")
+                trigger_lines[tel_type] += f" minsep {min_sep}"
+
+        array_triggers_file = "array_triggers.dat"
+        with open(model_path / array_triggers_file, "w", encoding="utf-8") as file:
+            file.write("# Array trigger definition\n")
+            file.writelines(f"{line}\n" for line in trigger_lines.values())
+
+        return array_triggers_file
+
+    def _get_array_triggers_for_telescope_type(self, array_triggers, telescope_type):
+        """
+        Get array trigger for a specific telescope type.
+
+        Parameters
+        ----------
+        array_triggers: dict
+            Array trigger definitions.
+        telescope_type: str
+            Telescope type.
+
+        Returns
+        -------
+        dict
+            Array trigger for the telescope type.
+        """
+        for trigger_dict in array_triggers:
+            if trigger_dict["name"] == telescope_type + "_array":
+                return trigger_dict
+        return None

simtools/simtel/{simtel_events.py → simtel_io_events.py}

@@ -1,3 +1,5 @@
+"""Read sim_telarray events from file."""
+
 import logging
 import math
 from copy import copy
@@ -6,16 +8,18 @@ import astropy.units as u
 import numpy as np
 from eventio.simtel import SimTelFile
 
-__all__ = ["InconsistentInputFile", "SimtelEvents"]
+__all__ = ["InconsistentInputFileError", "SimtelIOEvents"]
 
 
-class InconsistentInputFile(Exception):
+class InconsistentInputFileError(Exception):
     """Exception for inconsistent input file."""
 
 
-class SimtelEvents:
+class SimtelIOEvents:
     """
-    This class handle sim_telarray events. sim_telarray files are read with eventio package.
+    Read sim_telarray events from file.
+
+    sim_telarray files are read with eventio package.
 
     Parameters
     ----------
@@ -24,9 +28,7 @@ class SimtelEvents:
     """
 
     def __init__(self, input_files=None):
-        """
-        Initialize SimtelEvents.
-        """
+        """Initialize SimtelIOEvents."""
         self._logger = logging.getLogger(__name__)
         self.load_input_files(input_files)
         if self.number_of_files > 0:
@@ -54,7 +56,6 @@ class SimtelEvents:
 
         for file in files:
             self.input_files.append(file)
-        return
 
     @property
     def number_of_files(self):
@@ -69,10 +70,10 @@ class SimtelEvents:
 
     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.
-        """
+        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",
@@ -119,7 +120,7 @@ class SimtelEvents:
                     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 InconsistentInputFile(msg)
+                        raise InconsistentInputFileError(msg)
 
                 is_first_file = False
 
@@ -154,13 +155,10 @@ class SimtelEvents:
         energy_range = self._validate_energy_range(energy_range)
         core_max = self._validate_core_max(core_max)
 
-        is_in_energy_range = list(
-            map(
-                lambda e: energy_range[0] < e < energy_range[1],
-                self.summary_events["energy"],
-            )
-        )
-        is_in_core_range = list(map(lambda r: r < core_max, self.summary_events["r_core"]))
+        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)
@@ -203,8 +201,9 @@ class SimtelEvents:
     @u.quantity_input(core_max=u.m)
     def count_simulated_events(self, energy_range=None, core_max=None):
         """
-        Count (or calculate) number of simulated events within a certain energy range and \
-        core radius, based on the simulated power law.
+        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
@@ -236,8 +235,9 @@ class SimtelEvents:
 
     def _validate_energy_range(self, energy_range):
         """
-        Returns the default energy range from mc_header in case energy_range=None.
-        Checks units, convert it to TeV and return it in the right format, otherwise.
+        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"]
@@ -258,7 +258,8 @@ class SimtelEvents:
 
     def _validate_core_max(self, core_max):
         """
-        Returns the default core_max from mc_header in case core_max=None.
-        Checks units, convert it to m and return it in the right format, otherwise.
+        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