gammasimtools 0.15.0__py3-none-any.whl → 0.17.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.
@@ -32,12 +54,20 @@ class SimtelConfigWriter:
         Layout name.
     label: str
         Instance label. Important for output file naming.
+    simtel_path: str or Path
+        Path to the sim_telarray installation directory.
     """
 
     TAB = " " * 3
 
     def __init__(
-        self, site, model_version, layout_name=None, telescope_model_name=None, label=None
+        self,
+        site,
+        model_version,
+        layout_name=None,
+        telescope_model_name=None,
+        label=None,
+        simtel_path=None,
     ):
         """Initialize SimtelConfigWriter."""
         self._logger = logging.getLogger(__name__)
@@ -48,8 +78,9 @@ class SimtelConfigWriter:
         self._label = label
         self._layout_name = layout_name
         self._telescope_model_name = telescope_model_name
+        self._simtel_path = simtel_path
 
-    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 the sim_telarray config file for a single telescope.
 
@@ -59,41 +90,34 @@ 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)
         """
         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")
 
             for par, value in 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"],
+                    config_file_path,
+                    None,
                 )
-                # 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"
-                )
-            _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 +140,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 +152,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 +169,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 +190,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 +236,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 +255,68 @@ 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_simtools_parameters(file)
+
             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 +376,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 +397,26 @@ class SimtelConfigWriter:
         header += f"{comment_char}\n"
         file.write(header)
 
-    def _write_site_parameters(self, file, site_parameters, model_path, telescope_model):
+    def _write_simtools_parameters(self, file):
+        """Write simtools-specific parameters."""
+        meta_items = {
+            "simtools_version": simtools.version.__version__,
+            "simtools_model_production_version": self._model_version,
+        }
+        try:
+            build_opts = gen.collect_data_from_file(Path(self._simtel_path) / "build_opts.yml")
+            for key, value in build_opts.items():
+                meta_items[f"simtools_{key}"] = value
+        except (FileNotFoundError, TypeError):
+            pass  # don't expect build_opts.yml to be present on all systems
+
+        file.write(f"{self.TAB}% Simtools parameters\n")
+        for key, value in meta_items.items():
+            file.write(f"{self.TAB}metaparam global set {key} = {value}\n")
+
+    def _write_site_parameters(
+        self, file, site_parameters, model_path, telescope_model, sim_telarray_seeds=None
+    ):
         """
         Write site parameters.
 
@@ -323,20 +430,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(
-                _simtel_name, value["value"], model_path, telescope_model
+            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,
             )
-            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 +482,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 +546,81 @@ 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": 9999,
+            "dsum_threshold": 9999,
+            "discriminator_threshold": 9999,
+            "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)
+
+        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")