gammasimtools 0.21.0__py3-none-any.whl → 0.23.0__py3-none-any.whl

simtools/schemas/simulation_models_info.schema.yml

@@ -0,0 +1,78 @@
+---
+$schema: http://json-schema.org/draft-06/schema#
+$ref: '#/definitions/SimulationModelsInfo'
+title: Production and simulation model information schema
+description: Schema for validating 'info.yml' files used to update CTAO simulation models.
+schema_version: 0.1.0
+schema_name: simulation_models_info.metaschema
+type: object
+additionalProperties: false
+
+definitions:
+  SimulationModelsInfo:
+    properties:
+      model_version:
+        $ref: 'common_definitions.schema.yml#/$defs/semantic_version_pattern'
+      model_update:
+        type: string
+        description: The type of update for the model version.
+        enum:
+          - patch_update
+          - full_update
+      model_version_history:
+        type: array
+        description: A list of previous model versions.
+        items:
+          $ref: 'common_definitions.schema.yml#/$defs/semantic_version_pattern'
+      description:
+        type: string
+        description: A detailed description of the model changes.
+      changes:
+        type: object
+        description: A map of design names to their parameter changes.
+        propertyNames:
+          $ref: 'common_definitions.schema.yml#/$defs/telescope_name_pattern'
+        additionalProperties:
+          type: object
+          additionalProperties:
+            anyOf:
+              - $ref: '#/$defs/ParameterValue'
+              - $ref: '#/$defs/DeprecatedParameter'
+    required:
+      - model_version
+      - model_update
+      - model_version_history
+      - description
+      - changes
+
+$defs:
+  DeprecatedParameter:
+    type: object
+    properties:
+      deprecated:
+        type: boolean
+        const: true
+    required:
+      - deprecated
+    additionalProperties: false
+
+  ParameterValue:
+    type: object
+    properties:
+      version:
+        $ref: 'common_definitions.schema.yml#/$defs/semantic_version_pattern'
+      value:
+        oneOf:
+          - type: string
+          - type: number
+          - type: boolean
+          - type: array
+          - type: object
+      unit:
+        oneOf:
+          - type: string
+          - type: array
+          - type: "null"
+    required:
+      - version
+    additionalProperties: false

simtools/simtel/simtel_config_reader.py

@@ -10,8 +10,6 @@ import numpy as np
 from simtools.io import ascii_handler
 from simtools.utils import names
 
-__all__ = ["SimtelConfigReader"]
-
 
 def get_list_of_simtel_parameters(simtel_config_file):
     """

simtools/simtel/simtel_config_writer.py

@@ -13,8 +13,6 @@ import simtools.version
 from simtools.io import ascii_handler
 from simtools.utils import names
 
-__all__ = ["SimtelConfigWriter"]
-
 
 def sim_telarray_random_seeds(seed, number):
     """
@@ -67,6 +65,7 @@ class SimtelConfigWriter:
         model_version,
         layout_name=None,
         telescope_model_name=None,
+        telescope_design_model=None,
         label=None,
         simtel_path=None,
     ):
@@ -79,9 +78,12 @@ class SimtelConfigWriter:
         self._label = label
         self._layout_name = layout_name
         self._telescope_model_name = telescope_model_name
+        self._telescope_design_model = telescope_design_model
         self._simtel_path = simtel_path
 
-    def write_telescope_config_file(self, config_file_path, parameters, telescope_name=None):
+    def write_telescope_config_file(
+        self, config_file_path, parameters, telescope_name=None, telescope_design_model=None
+    ):
         """
         Write the sim_telarray config file for a single telescope.
 
@@ -93,33 +95,115 @@ class SimtelConfigWriter:
             Model parameters
         telescope_name: str
             Name of the telescope (use self._telescope_model_name if None)
+        telescope_design_model: str
+            Telescope design model.
         """
         self._logger.debug(f"Writing telescope config file {config_file_path}")
 
+        simtel_par = self._get_parameters_for_sim_telarray(parameters, config_file_path)
+        telescope_name = telescope_name or self._telescope_model_name
+        _telescope_design_model = telescope_design_model or self._telescope_design_model
+
         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 {telescope_name} - TELESCOPE $(TELESCOPE)\n")
             file.write("#endif\n\n")
 
-            for par, value in parameters.items():
-                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,
-                )
-                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):
+            for simtel_name, simtel_value in simtel_par.items():
+                file.write(f"{simtel_name} = {self._get_value_string_for_simtel(simtel_value)}\n")
+            for meta in self._get_sim_telarray_metadata(
+                "telescope",
+                parameters,
+                telescope_name,
+                telescope_design_model=_telescope_design_model,
+            ):
                 file.write(f"{meta}\n")
 
+    def _get_parameters_for_sim_telarray(self, parameters, config_file_path):
+        """
+        Convert parameter dictionary to sim_telarray configuration file format.
+
+        Accounts for differences between the data models for sim_telarray configuration
+        and the simulation models.
+
+        Parameters
+        ----------
+        parameters: dict
+            Model parameters.
+        config_file_path: str or Path
+            Path of the file to write on.
+
+        Returns
+        -------
+        dict
+            Model parameters in sim_telarray format.
+        """
+        simtel_par = {}
+        for par, value in parameters.items():
+            simtel_name, simtel_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,
+            )
+            if simtel_name:
+                simtel_par[simtel_name] = simtel_value
+        if "stars" not in parameters:  # sim_telarray requires 'stars' to be set
+            simtel_par["stars"] = None
+
+        return self._get_flasher_parameters_for_sim_telarray(parameters, simtel_par)
+
+    def _get_flasher_parameters_for_sim_telarray(self, parameters, simtel_par):
+        """
+        Combine flasher pulse time parameters into a single parameter.
+
+        Takes into account that sim_telarray expects a single parameter with a specific name.
+
+        Parameters
+        ----------
+        parameters: dict
+            Model parameters.
+        simtel_par: dict
+            Model parameters in sim_telarray format.
+
+        Returns
+        -------
+        dict
+            Model parameters in sim_telarray format including flasher parameters.
+
+        """
+        if "flasher_pulse_shape" not in parameters and "flasher_pulse_width" not in parameters:
+            return simtel_par
+
+        mapping = {
+            "gauss": "laser_pulse_sigtime",
+            "tophat": "laser_pulse_twidth",
+        }
+
+        shape = parameters.get("flasher_pulse_shape", {}).get("value", "").lower()
+        if "exponential" in shape:
+            simtel_par["laser_pulse_exptime"] = parameters.get("flasher_pulse_exp_decay", {}).get(
+                "value", 0.0
+            )
+        else:
+            simtel_par["laser_pulse_exptime"] = 0.0
+
+        width = parameters.get("flasher_pulse_width", {}).get("value", 0.0)
+
+        simtel_par.update(dict.fromkeys(mapping.values(), 0.0))
+        if shape == "gauss-exponential":
+            simtel_par["laser_pulse_sigtime"] = width
+        elif shape in mapping:
+            simtel_par[mapping[shape]] = width
+        else:
+            self._logger.warning(f"Flasher pulse shape '{shape}' without width definition")
+
+        return simtel_par
+
     def _get_value_string_for_simtel(self, value):
         """
         Return a value string for simtel.
@@ -137,12 +221,17 @@ class SimtelConfigWriter:
         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
+        elif isinstance(value, (list, np.ndarray)):
             value = gen.convert_list_to_string(value, shorten_list=True)
         return value
 
     def _get_sim_telarray_metadata(
-        self, config_type, model_parameters, telescope_model_name, additional_metadata=None
+        self,
+        config_type,
+        model_parameters,
+        telescope_model_name,
+        additional_metadata=None,
+        telescope_design_model=None,
     ):
         """
         Return sim_telarray metadata.
@@ -157,6 +246,8 @@ class SimtelConfigWriter:
             Name of the telescope model
         additional_metadata: dict
             Dictionary with additional metadata to include using 'set'.
+        telescope_design_model: str
+            Name of the telescope design model.
 
         Returns
         -------
@@ -167,14 +258,15 @@ class SimtelConfigWriter:
             f"config_release = {self._model_version} with simtools v{simtools.version.__version__}",
             f"config_version = {self._model_version}",
         ]
+        telescope_design_model = telescope_design_model or "design_model_not_set"
         if config_type == "telescope":
             meta_parameters.extend(
                 [
-                    f"camera_config_name = {telescope_model_name}",
-                    "camera_config_variant = ",
+                    f"camera_config_name = {telescope_design_model}",
+                    f"camera_config_variant = {telescope_model_name}",
                     f"camera_config_version = {self._model_version}",
-                    f"optics_config_name = {telescope_model_name}",
-                    "optics_config_variant = ",
+                    f"optics_config_name = {telescope_design_model}",
+                    f"optics_config_variant = {telescope_model_name}",
                     f"optics_config_version = {self._model_version}",
                 ]
             )
@@ -447,7 +539,7 @@ class SimtelConfigWriter:
             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, additional_metadata
+            "site", site_parameters, None, additional_metadata
         ):
             file.write(f"{self.TAB}{meta}\n")
         file.write("\n")
@@ -514,7 +606,7 @@ class SimtelConfigWriter:
             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"):
+            if trigger_dict.get("hard_stereo", {}).get("value"):
                 trigger_lines[tel_type] += " hardstereo"
             if all(trigger_dict["min_separation"][key] is not None for key in ["value", "unit"]):
                 min_sep = trigger_dict["min_separation"]["value"] * u.Unit(

simtools/simtel/simtel_io_metadata.py

@@ -105,8 +105,8 @@ def get_sim_telarray_telescope_id(telescope_name, file):
     _, telescope_meta = read_sim_telarray_metadata(file)
     telescope_name_to_sim_telarray_id = {}
     for tel_id in telescope_meta.keys():
-        _optics_name = telescope_meta[tel_id].get("optics_config_name", None)
-        _camera_name = telescope_meta[tel_id].get("camera_config_name", None)
+        _optics_name = telescope_meta[tel_id].get("optics_config_variant", None)
+        _camera_name = telescope_meta[tel_id].get("camera_config_variant", None)
         if _optics_name == _camera_name and _optics_name == telescope_name:
             telescope_name_to_sim_telarray_id[telescope_name] = tel_id
 
@@ -132,7 +132,7 @@ def get_sim_telarray_telescope_id_to_telescope_name_mapping(file):
     for i, (tel_id, meta) in enumerate(telescope_meta.items()):
         try:
             telescope_name = names.validate_array_element_name(
-                meta.get("optics_config_name", f"Unknown-{tel_id}")
+                meta.get("optics_config_variant", f"Unknown-{tel_id}")
             )
         except ValueError:
             telescope_name = _guess_telescope_name_for_legacy_files(i, file)

simtools/simtel/simulator_array.py

@@ -6,8 +6,6 @@ from simtools.io import io_handler
 from simtools.runners.simtel_runner import InvalidOutputFileError, SimtelRunner
 from simtools.utils.general import clear_default_sim_telarray_cfg_directories
 
-__all__ = ["SimulatorArray"]
-
 
 class SimulatorArray(SimtelRunner):
     """
@@ -34,6 +32,7 @@ class SimulatorArray(SimtelRunner):
         label=None,
         use_multipipe=False,
         sim_telarray_seeds=None,
+        calibration_config=None,
     ):
         """Initialize SimulatorArray."""
         self._logger = logging.getLogger(__name__)
@@ -47,6 +46,7 @@ class SimulatorArray(SimtelRunner):
 
         self.sim_telarray_seeds = sim_telarray_seeds
         self.corsika_config = corsika_config
+        self.calibration_config = calibration_config
         self.io_handler = io_handler.IOHandler()
         self._log_file = None
 
@@ -70,68 +70,60 @@ class SimulatorArray(SimtelRunner):
         """
         command = self._common_run_command(run_number, weak_pointing)
 
-        command += f" {input_file}"
-        command += f" | gzip > {self._log_file} 2>&1 || exit"
-        command += super().get_config_option(
-            "power_law",
-            SimulatorArray.get_power_law_for_sim_telarray_histograms(
-                self.corsika_config.primary_particle
-            ),
-        )
+        if self.calibration_config:
+            command += self._make_run_command_for_calibration_simulations()
+        else:
+            command += self._make_run_command_for_shower_simulations()
+
+        # "-C show=all" should be the last option
+        command += super().get_config_option("show", "all")
+        command += f" {input_file} | gzip > {self._log_file} 2>&1 || exit"
 
         return clear_default_sim_telarray_cfg_directories(command)
 
-    def make_run_command_for_calibration_simulations(
-        self, run_number=None, input_file=None, calibration_runner_args=None
-    ):
+    def _make_run_command_for_shower_simulations(self):
         """
-        Build and return the command to run sim_telarray for calibration simulations.
-
-        Parameters
-        ----------
-        calibration_runner_args: dict
-            Dictionary with calibration runner arguments.
-        input_file: str
-            Full path of the input CORSIKA file
-        run_number: int (optional)
-            run number
+        Build and return the command to run sim_telarray shower simulations.
 
         Returns
         -------
         str
-            Command to run sim_telarray for pedestal simulations.
+            Command to run sim_telarray.
         """
-        command = self._common_run_command(run_number)
-
-        command += super().get_config_option(
-            "Altitude",
-            self.corsika_config.array_model.site_model.get_parameter_value_with_unit(
-                "reference_point_altitude"
-            ).to_value("m"),
-        )
-        command += super().get_config_option(
-            "nsb_scaling_factor", calibration_runner_args["nsb_scaling_factor"]
+        return super().get_config_option(
+            "power_law",
+            SimulatorArray.get_power_law_for_sim_telarray_histograms(
+                self.corsika_config.primary_particle
+            ),
         )
-        if calibration_runner_args.get("stars"):
-            command += super().get_config_option("stars", calibration_runner_args["stars"])
 
-        if calibration_runner_args.get("run_mode") in ("pedestals", "nsb_only_pedestals"):
-            command += super().get_config_option(
-                "pedestal_events", calibration_runner_args["number_of_events"]
-            )
-        if calibration_runner_args.get("run_mode") == "nsb_only_pedestals":
-            command += self._nsb_only_pedestals_command()
-        if calibration_runner_args.get("run_mode") == "dark_pedestals":
-            command += super().get_config_option(
-                "dark_events", calibration_runner_args["number_of_events"]
-            )
-        if calibration_runner_args.get("run_mode") == "flasher":
-            command += self._flasher_command(calibration_runner_args)
+    def _make_run_command_for_calibration_simulations(self):
+        """Build sim_telarray command for calibration simulations."""
+        cfg = self.calibration_config
+        altitude = self.corsika_config.array_model.site_model.get_parameter_value_with_unit(
+            "reference_point_altitude"
+        ).to_value("m")
 
-        command += f" {input_file}"
-        command += f" | gzip > {self._log_file} 2>&1 || exit"
+        command = super().get_config_option("Altitude", altitude)
 
-        return clear_default_sim_telarray_cfg_directories(command)
+        for key in ("nsb_scaling_factor", "stars"):
+            if cfg.get(key):
+                command += super().get_config_option(key, cfg[key])
+
+        run_mode = cfg.get("run_mode")
+        if run_mode in ("pedestals", "nsb_only_pedestals"):
+            n_events = cfg.get("number_of_pedestal_events", cfg["number_of_events"])
+            command += super().get_config_option("pedestal_events", n_events)
+        if run_mode == "nsb_only_pedestals":
+            command += self._nsb_only_pedestals_command()
+        if run_mode == "dark_pedestals":
+            n_events = cfg.get("number_of_dark_events", cfg["number_of_events"])
+            command += super().get_config_option("dark_events", n_events)
+        if run_mode == "direct_injection":
+            n_events = cfg.get("number_of_flasher_events", cfg["number_of_events"])
+            command += super().get_config_option("laser_events", n_events)
+
+        return command
 
     def _common_run_command(self, run_number, weak_pointing=None):
         """Build generic run command for sim_telarray."""
@@ -159,44 +151,10 @@ class SimulatorArray(SimtelRunner):
             )
         elif self.sim_telarray_seeds and self.sim_telarray_seeds.get("seed"):
             command += super().get_config_option("random_seed", self.sim_telarray_seeds["seed"])
-        command += super().get_config_option("show", "all")
         command += super().get_config_option("output_file", output_file)
 
         return command
 
-    def _flasher_command(self, calibration_runner_args):
-        """
-        Generate the command to run sim_telarray for flasher simulations.
-
-        Parameters
-        ----------
-        calibration_runner_args: dict
-            Dictionary with calibration runner arguments.
-
-        Returns
-        -------
-        str
-            Command to run sim_telarray for flasher simulations.
-        """
-        command = super().get_config_option(
-            "laser_events", calibration_runner_args["number_of_events"]
-        )
-        command += super().get_config_option(
-            "laser_photons", calibration_runner_args["flasher_photons"]
-        )
-        command += super().get_config_option(
-            "laser_var_photons", calibration_runner_args["flasher_var_photons"]
-        )
-        command += super().get_config_option(
-            "laser_pulse_exptime", calibration_runner_args["flasher_exp_time"]
-        )
-        command += super().get_config_option(
-            "laser_pulse_sigtime", calibration_runner_args["flasher_sig_time"]
-        )
-        command += super().get_config_option("laser_external_trigger", 1)
-
-        return command
-
     def _nsb_only_pedestals_command(self):
         """
         Generate the command to run sim_telarray for nsb-only pedestal simulations.

simtools/simtel/simulator_camera_efficiency.py

@@ -7,8 +7,6 @@ from simtools.io import ascii_handler
 from simtools.runners.simtel_runner import SimtelRunner
 from simtools.utils import general
 
-__all__ = ["SimulatorCameraEfficiency"]
-
 
 class SimulatorCameraEfficiency(SimtelRunner):
     """