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

simtools/simtel/simtel_config_writer.py

@@ -2,6 +2,7 @@
 """Configuration file writer for sim_telarray."""
 
 import logging
+from copy import deepcopy
 from pathlib import Path
 
 import astropy.units as u
@@ -14,6 +15,27 @@ from simtools.utils import names
 __all__ = ["SimtelConfigWriter"]
 
 
+def sim_telarray_random_seeds(seed, number):
+    """
+    Generate random seeds to be used in sim_telarray.
+
+    Parameters
+    ----------
+    seed: int
+        Seed for the random number generator.
+    number: int
+        Number of random seeds to generate.
+
+    Returns
+    -------
+    list
+        List of random seeds.
+    """
+    rng = np.random.default_rng(seed)
+    max_int32 = np.iinfo(np.int32).max  # sim_telarray requires 32 bit integers
+    return list(rng.integers(low=1, high=max_int32, size=number, dtype=np.int32))
+
+
 class SimtelConfigWriter:
     """
     SimtelConfigWriter writes sim_telarray configuration files.
@@ -49,7 +71,9 @@ class SimtelConfigWriter:
         self._layout_name = layout_name
         self._telescope_model_name = telescope_model_name
 
-    def write_telescope_config_file(self, config_file_path, parameters, config_parameters=None):
+    def write_telescope_config_file(
+        self, config_file_path, parameters, telescope_name=None, write_dummy_config=False
+    ):
         """
         Write the sim_telarray config file for a single telescope.
 
@@ -59,41 +83,38 @@ class SimtelConfigWriter:
             Path of the file to write on.
         parameters: dict
             Model parameters
-        config_parameters: dict
-            Simulation software configuration parameters
+        telescope_name: str
+            Name of the telescope (use self._telescope_model_name if None)
+        write_dummy_config: bool
+            Flag to write a dummy telescope configuration file.
         """
         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")
 
+            telescope_name = telescope_name or self._telescope_model_name
             file.write("#ifdef TELESCOPE\n")
-            file.write(
-                f"   echo Configuration for {self._telescope_model_name} - TELESCOPE $(TELESCOPE)\n"
-            )
+            file.write(f"   echo Configuration for {telescope_name} - TELESCOPE $(TELESCOPE)\n")
             file.write("#endif\n\n")
+            if write_dummy_config:
+                file.write("#define DUMMY_CONFIG 1\n")
 
             for par, value in parameters.items():
-                _simtel_name = names.get_simulation_software_name_from_parameter_name(
-                    par, simulation_software="sim_telarray"
-                )
-                # array trigger is a site parameter, not a telescope parameter
-                # fake_mirror_list is not a sim_telarray parameter (used for testeff only)
-                if (
-                    not _simtel_name
-                    or _simtel_name.startswith("array_trigger")
-                    or _simtel_name == "fake_mirror_list"
-                ):
-                    continue
-                file.write(
-                    f"{_simtel_name} = {self._get_value_string_for_simtel(value['value'])}\n"
+                simtel_name, value = self._convert_model_parameters_to_simtel_format(
+                    names.get_simulation_software_name_from_parameter_name(
+                        par, software_name="sim_telarray"
+                    ),
+                    value["value"],
+                    config_file_path,
+                    None,
                 )
-            _config_meta = self._get_simtel_metadata("telescope", parameters)
-            for value in _config_meta:
-                file.write(f"{value}\n")
+                if simtel_name:
+                    file.write(f"{simtel_name} = {self._get_value_string_for_simtel(value)}\n")
+            if "stars" not in parameters:  # sim_telarray requires 'stars' to be set
+                file.write("stars = none\n")
+            for meta in self._get_sim_telarray_metadata("telescope", parameters, telescope_name):
+                file.write(f"{meta}\n")
 
     def _get_value_string_for_simtel(self, value):
         """
@@ -116,9 +137,11 @@ class SimtelConfigWriter:
             value = gen.convert_list_to_string(value, shorten_list=True)
         return value
 
-    def _get_simtel_metadata(self, config_type, model_parameters):
+    def _get_sim_telarray_metadata(
+        self, config_type, model_parameters, telescope_model_name, sim_telarray_seeds=None
+    ):
         """
-        Return simtel metadata.
+        Return sim_telarray metadata.
 
         Parameters
         ----------
@@ -126,12 +149,15 @@ class SimtelConfigWriter:
             Type of the configuration file (telescope, site)
         model_parameters: dict
             Model parameters dictionary.
+        telescope_model_name: str
+            Name of the telescope model
+        sim_telarray_seeds: dict
+            Dictionary with configuration for sim_telarray random instrument setup.
 
         Returns
         -------
         list
-            List with simtel metadata.
-
+            List with sim_telarray metadata.
         """
         meta_parameters = [
             f"config_release = {self._model_version} with simtools v{simtools.version.__version__}",
@@ -140,10 +166,10 @@ class SimtelConfigWriter:
         if config_type == "telescope":
             meta_parameters.extend(
                 [
-                    f"camera_config_name = {self._telescope_model_name}",
+                    f"camera_config_name = {telescope_model_name}",
                     "camera_config_variant = ",
                     f"camera_config_version = {self._model_version}",
-                    f"optics_config_name = {self._telescope_model_name}",
+                    f"optics_config_name = {telescope_model_name}",
                     "optics_config_variant = ",
                     f"optics_config_version = {self._model_version}",
                 ]
@@ -161,25 +187,41 @@ class SimtelConfigWriter:
                 ]
             )
             prefix = "metaparam global"
+            meta_parameters.append("metaparam global add random_seed")
         else:
             raise ValueError(f"Unknown metadata type {config_type}")
 
-        if model_parameters:
-            for key, value in model_parameters.items():
-                simtel_name = names.get_simulation_software_name_from_parameter_name(
-                    key, simulation_software="sim_telarray", set_meta_parameter=False
-                )
-                if simtel_name and value.get("meta_parameter"):
-                    meta_parameters.append(f"{prefix} add {simtel_name}")
-                simtel_name = names.get_simulation_software_name_from_parameter_name(
-                    key, simulation_software="sim_telarray", set_meta_parameter=True
-                )
-                if simtel_name and value.get("meta_parameter"):
-                    meta_parameters.append(f"{prefix} set {simtel_name}={value['value']}")
+        self._add_model_parameters_to_metadata(model_parameters, meta_parameters, prefix)
+
+        if sim_telarray_seeds and sim_telarray_seeds.get("random_instrument_instances"):
+            meta_parameters.append(f"{prefix} set instrument_seed={sim_telarray_seeds['seed']}")
+            meta_parameters.append(
+                f"{prefix} set instrument_instances="
+                f"{sim_telarray_seeds['random_instrument_instances']}"
+            )
 
         return meta_parameters
 
-    def write_array_config_file(self, config_file_path, telescope_model, site_model):
+    def _add_model_parameters_to_metadata(self, model_parameters, meta_parameters, prefix):
+        """Add model parameters to metadata."""
+        if not model_parameters:
+            return
+
+        for key, value in model_parameters.items():
+            simtel_name = names.get_simulation_software_name_from_parameter_name(
+                key, software_name="sim_telarray", set_meta_parameter=False
+            )
+            if simtel_name and value.get("meta_parameter"):
+                meta_parameters.append(f"{prefix} add {simtel_name}")
+            simtel_name = names.get_simulation_software_name_from_parameter_name(
+                key, software_name="sim_telarray", set_meta_parameter=True
+            )
+            if simtel_name and value.get("meta_parameter"):
+                meta_parameters.append(f"{prefix} set {simtel_name}={value['value']}")
+
+    def write_array_config_file(
+        self, config_file_path, telescope_model, site_model, sim_telarray_seeds=None
+    ):
         """
         Write the sim_telarray config file for an array of telescopes.
 
@@ -191,11 +233,13 @@ class SimtelConfigWriter:
             Dictionary of TelescopeModel's instances as used by the ArrayModel instance.
         site_model: Site model
             Site model.
+        sim_telarray_seeds: dict
+            Dictionary with configuration for sim_telarray random instrument setup.
         """
+        config_file_directory = Path(config_file_path).parent
         with open(config_file_path, "w", encoding="utf-8") as file:
             self._write_header(file, "ARRAY CONFIGURATION FILE")
 
-            # Be careful with the formatting - simtel is sensitive
             file.write("#ifndef TELESCOPE\n")
             file.write("# define TELESCOPE 0\n")
             file.write("#endif\n\n")
@@ -208,27 +252,66 @@ class SimtelConfigWriter:
             file.write(self.TAB + f"echo ModelVersion: {self._model_version}\n")
             file.write(self.TAB + "echo *****************************\n\n")
 
-            # Writing site parameters
             self._write_site_parameters(
-                file, site_model.parameters, Path(config_file_path).parent, telescope_model
+                file,
+                site_model.parameters,
+                config_file_directory,
+                telescope_model,
+                sim_telarray_seeds,
             )
 
-            # Maximum telescopes
             file.write(self.TAB + f"maximum_telescopes = {len(telescope_model)}\n\n")
 
             # 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")
+            invalid_telescope_name = "InvalidTelescope"
+            file.write(f"# include <{invalid_telescope_name}.cfg>\n\n")
+            self.write_dummy_telescope_configuration_file(
+                deepcopy(first_telescope.parameters),
+                config_file_directory / f"{invalid_telescope_name}.cfg",
+                invalid_telescope_name,
+            )
 
-            # 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"%{tel_name}\n")
+                tel_config_file = tel_model.config_file_path.name
+                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")  # configuration files need to end with \n\n
 
+        if sim_telarray_seeds and sim_telarray_seeds.get("random_instrument_instances"):
+            self._write_random_seeds_file(sim_telarray_seeds, config_file_directory)
+
+    def _write_random_seeds_file(self, sim_telarray_seeds, config_file_directory):
+        """
+        Write list of random number used to generate random instances of instrument.
+
+        Parameters
+        ----------
+        random_instrument_instances: int
+            Number of random instances of the instrument.
+        """
+        self._logger.info(
+            "Writing random seed file "
+            f"{config_file_directory}/{sim_telarray_seeds['seed_file_name']}"
+            f" (global seed {sim_telarray_seeds['seed']})"
+        )
+        if sim_telarray_seeds["random_instrument_instances"] > 1024:
+            raise ValueError("Number of random instances of instrument must be less than 1024")
+        random_integers = sim_telarray_random_seeds(
+            sim_telarray_seeds["seed"], sim_telarray_seeds["random_instrument_instances"]
+        )
+        with open(
+            config_file_directory / sim_telarray_seeds["seed_file_name"], "w", encoding="utf-8"
+        ) as file:
+            file.write(
+                "# Random seeds for instrument configuration generated with seed "
+                f"{sim_telarray_seeds['seed']}"
+                f" (model version {self._model_version}, site {self._site})\n"
+            )
+            for number in random_integers:
+                file.write(f"{number}\n")
+
     def write_single_mirror_list_file(
         self, mirror_number, mirrors, single_mirror_list_file, set_focal_length_to_zero=False
     ):
@@ -288,7 +371,7 @@ class SimtelConfigWriter:
         title: str
             Title of the header.
         comment_char: str
-            Character to be used for comments, which differs among ctypes of config files.
+            Character to be used for comments, which differs among types of config files.
         """
         header = f"{comment_char}{50 * '='}\n"
         header += f"{comment_char} {title}\n"
@@ -309,7 +392,9 @@ class SimtelConfigWriter:
         header += f"{comment_char}\n"
         file.write(header)
 
-    def _write_site_parameters(self, file, site_parameters, model_path, telescope_model):
+    def _write_site_parameters(
+        self, file, site_parameters, model_path, telescope_model, sim_telarray_seeds=None
+    ):
         """
         Write site parameters.
 
@@ -323,20 +408,25 @@ class SimtelConfigWriter:
             Path to the model for writing of additional files.
         telescope_model: dict of TelescopeModel
             Telescope models.
+        sim_telarray_seeds: dict
+            Dictionary with configuration for sim_telarray random instrument setup.
         """
         file.write(self.TAB + "% Site parameters\n")
         for par, value in site_parameters.items():
-            _simtel_name = names.get_simulation_software_name_from_parameter_name(
-                par, simulation_software="sim_telarray"
+            simtel_name, value = self._convert_model_parameters_to_simtel_format(
+                names.get_simulation_software_name_from_parameter_name(
+                    par, software_name="sim_telarray"
+                ),
+                value["value"],
+                model_path,
+                telescope_model,
             )
-            _simtel_name, value = self._convert_model_parameters_to_simtel_format(
-                _simtel_name, value["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", site_parameters)
-        for value in _simtel_meta:
-            file.write(f"{self.TAB}{value}\n")
+            if simtel_name is not None:
+                file.write(f"{self.TAB}{simtel_name} = {value}\n")
+        for meta in self._get_sim_telarray_metadata(
+            "site", site_parameters, self._telescope_model_name, sim_telarray_seeds
+        ):
+            file.write(f"{self.TAB}{meta}\n")
         file.write("\n")
 
     def _convert_model_parameters_to_simtel_format(
@@ -370,6 +460,8 @@ class SimtelConfigWriter:
             value = conversion_dict[simtel_name](value, model_path, telescope_model)
         except KeyError:
             pass
+        except AttributeError:  # covers cases where telescope_model is None
+            return None, None
         return simtel_name, value
 
     def _write_array_triggers_file(self, array_triggers, model_path, telescope_model):
@@ -432,3 +524,83 @@ class SimtelConfigWriter:
             if trigger_dict["name"] == telescope_type + "_array":
                 return trigger_dict
         return None
+
+    def write_dummy_telescope_configuration_file(
+        self, parameters, config_file_path, telescope_name
+    ):
+        """
+        Write 'dummy' telescope configuration file used as zeroth telescope in sim_telarray.
+
+        Replaces key telescope configuration values with dummy values.
+
+        Parameters
+        ----------
+        parameters: dict
+            Telescope parameters used as template.
+        config_file_path: str or Path
+            Path of the dummy configuration file to write on.
+        telescope_name: str
+            Name of the telescope.
+        """
+        self._logger.debug(f"Writing {telescope_name} telescope config file {config_file_path}")
+        dummy_defaults = {
+            "camera_config_file": f"{telescope_name}_single_pixel_camera.dat",
+            "discriminator_pulse_shape": f"{telescope_name}_pulse.dat",
+            "fadc_pulse_shape": f"{telescope_name}_pulse.dat",
+            "mirror_list": f"{telescope_name}_single_12m_mirror.dat",
+            "mirror_reflectivity": f"{telescope_name}_reflectivity.dat",
+            "camera_pixels": 1,
+            "trigger_pixels": 1,
+            "num_gains": 1,
+            "fadc_bins": 10,
+            "disc_bins": 10,
+            "fadc_sum_bins": 10,
+            "fadc_sum_offset": 0,
+            "asum_threshold": 0,
+            "dsum_threshold": 0,
+            "discriminator_threshold": 1,
+            "fadc_amplitude": 1.0,
+            "discriminator_amplitude": 1.0,
+        }
+
+        for key, val in dummy_defaults.items():
+            if key in parameters:
+                parameters[key]["value"] = val
+
+        self.write_telescope_config_file(
+            config_file_path, parameters, telescope_name, write_dummy_config=True
+        )
+
+        config_file_directory = Path(config_file_path).parent
+        self._write_dummy_mirror_list_files(config_file_directory, telescope_name)
+        self._write_dummy_camera_files(config_file_directory, telescope_name)
+
+    def _write_dummy_mirror_list_files(self, config_directory, telescope_name):
+        """Write dummy mirror list with single mirror and reflectivity file."""
+        with open(
+            config_directory / f"{telescope_name}_single_12m_mirror.dat", "w", encoding="utf-8"
+        ) as file:
+            file.write("0 0 1200 0.0 0\n")
+        with open(
+            config_directory / f"{telescope_name}_reflectivity.dat", "w", encoding="utf-8"
+        ) as file:
+            file.writelines(f"{w} 0.8\n" for w in range(200, 801, 50))
+
+    def _write_dummy_camera_files(self, config_directory, telescope_name):
+        """Write dummy camera, pulse shape, and funnels file with a single pixel."""
+        with open(
+            config_directory / f"{telescope_name}_single_pixel_camera.dat", "w", encoding="utf-8"
+        ) as file:
+            file.write(f'PixType 1   0  0 300   1 300 0.00   "{telescope_name}_funnels.dat"\n')
+            file.write("Pixel 0 1 0. 0.  0  0  0 0x00 1\n")
+            file.write("Trigger 1 of 0\n")
+
+        with open(config_directory / f"{telescope_name}_funnel.dat", "w", encoding="utf-8") as file:
+            file.writelines(f"{a} 0.78 1.5\n" for a in range(36))
+
+        with open(config_directory / f"{telescope_name}_pulse.dat", "w", encoding="utf-8") as file:
+            file.write("0 0 0\n")
+            file.write("1 1 1\n")
+            file.write("2 2 2\n")
+            file.write("3 3 3\n")
+            file.write("4 0 0\n")

simtools/simtel/simtel_io_file_info.py

@@ -0,0 +1,57 @@
+#!/usr/bin/python3
+"""Read file info and run headers from sim_telarray files."""
+
+from eventio import EventIOFile
+from eventio.simtel import MCRunHeader, RunHeader
+
+
+def get_corsika_run_number(file):
+    """
+    Return the CORSIKA run number from a sim_telarray file.
+
+    Parameters
+    ----------
+    file: str
+        Path to the sim_telarray file.
+
+    Returns
+    -------
+    int, None
+        CORSIKA run number. Returns None if not found.
+    """
+    run_header = get_corsika_run_header(file)
+    return run_header.get("run") if run_header else None
+
+
+def get_corsika_run_header(file):
+    """
+    Return the CORSIKA run header from a sim_telarray file.
+
+    Reads both RunHeader and MCRunHeader object from file and
+    returns a merged dictionary.
+
+    Parameters
+    ----------
+    file: str
+        Path to the sim_telarray file.
+
+    Returns
+    -------
+    dict, None
+        CORSIKA run header. Returns None if not found.
+    """
+    run_header = None
+    mc_run_header = None
+
+    with EventIOFile(file) as f:
+        for o in f:
+            if isinstance(o, RunHeader) and run_header is None:
+                run_header = o.parse()
+            elif isinstance(o, MCRunHeader) and mc_run_header is None:
+                mc_run_header = o.parse()
+            if run_header and mc_run_header:
+                break
+
+    run_header = run_header or {}
+    mc_run_header = mc_run_header or {}
+    return run_header | mc_run_header or None

simtools/simtel/simtel_io_histogram.py

@@ -1,4 +1,4 @@
-"""Reads the content of either a single histogram or simtel_array output file."""
+"""Reads the content of either a single histogram or sim_telarray output file."""
 
 import copy
 import logging
@@ -11,7 +11,8 @@ from ctao_cr_spectra.definitions import IRFDOC_PROTON_SPECTRUM
 from ctao_cr_spectra.spectral import cone_solid_angle
 from eventio import EventIOFile, Histograms
 from eventio.search_utils import yield_toplevel_of_type
-from eventio.simtel import MCRunHeader
+
+from simtools.simtel.simtel_io_file_info import get_corsika_run_header
 
 __all__ = [
     "HistogramIdNotFoundError",
@@ -32,13 +33,13 @@ class SimtelIOHistogram:
     """
     Reads and generates histograms from sim_telarray output.
 
-    Read the content of either a single histogram (.hdata, or .hdata.zst) or a single simtel_array
+    Read the content of either a single histogram (.hdata, or .hdata.zst) or a single sim_telarray
     output file (.simtel or .simtel.zst).
 
     Parameters
     ----------
     histogram_file: str
-        The histogram (.hdata.zst) or simtel_array (.simtel.zst) file.
+        The histogram (.hdata.zst) or sim_telarray (.simtel.zst) file.
     area_from_distribution: bool
         If true, the area thrown (the area in which the simulated events are distributed)
         in the trigger rate calculation is estimated based on the event distribution.
@@ -135,14 +136,9 @@ class SimtelIOHistogram:
         Returns
         -------
         dict:
-            dictionary with information about the simulation (pyeventio MCRunHeader object).
+            dictionary with information about the simulation
         """
-        if self._config is None:
-            with EventIOFile(self.histogram_file) as f:
-                self._config = next(
-                    (obj.parse() for obj in f if isinstance(obj, MCRunHeader)), None
-                )
-        return self._config
+        return self._config if self._config else get_corsika_run_header(self.histogram_file)
 
     @property
     def total_number_of_events(self):
@@ -348,7 +344,7 @@ class SimtelIOHistogram:
             for the triggered events.
         """
         if self.trigger_rate is None:
-            # Get the simulated and triggered 2D histograms from the simtel_array output file
+            # Get the simulated and triggered 2D histograms from the sim_telarray output file
             if events_histogram is None and triggered_events_histogram is None:
                 events_histogram, triggered_events_histogram = self.fill_event_histogram_dicts()
             # Calculate triggered/simulated event 1D histogram (energy dependent)
@@ -408,7 +404,7 @@ class SimtelIOHistogram:
         """
         Produce the meta data to include in the tabulated form of the trigger rate per energy bin.
 
-        It shows some information from the input file (simtel_array file) and the final estimate
+        It shows some information from the input file (sim_telarray file) and the final estimate
         system trigger rate.
 
         Returns
@@ -417,7 +413,7 @@ class SimtelIOHistogram:
             dictionary with the metadata.
         """
         return {
-            "simtel_array_file": self.histogram_file,
+            "sim_telarray_file": self.histogram_file,
             "simulation_input": self.print_info(mode="silent"),
             "system_trigger_rate (Hz)": self.trigger_rate.value,
         }

simtools/simtel/simtel_io_histograms.py

@@ -24,7 +24,7 @@ __all__ = [
 
 class SimtelIOHistograms:
     """
-    Read the content of either multiple histogram (.hdata, or .hdata.zst) or simtel_array files.
+    Read the content of either multiple histogram (.hdata, or .hdata.zst) or sim_telarray files.
 
     Allow both the .hdata.zst histogram and the .simtel.zst output file type.
     It uses the SimtelIOHistogram class to deal with individual files.
@@ -159,7 +159,7 @@ class SimtelIOHistograms:
         if sim_hist is None or trig_hist is None:
             msg = (
                 "Simulated and triggered histograms were not found in the stacked histograms."
-                " Please check your simtel_array files!"
+                " Please check your sim_telarray files!"
             )
             self._logger.error(msg)
             raise HistogramIdNotFoundError