gammasimtools 0.26.0__py3-none-any.whl → 0.27.0__py3-none-any.whl

simtools/layout/array_layout_utils.py

@@ -483,7 +483,56 @@ def _get_array_name(array_name):
     return array_name[1:], int(array_name[0])
 
 
-def create_regular_array(array_name, site, telescope_distance):
+def _create_star_array(tel_name, pos_x, pos_y, pos_z, n_telescopes, tel_type, site, distance):
+    """Create star-shaped array positions along x and y axes."""
+    axis_sequence = ["x", "y", "-x", "-y"]
+    step = 1
+    for i in range(n_telescopes):
+        tel_name.append(
+            names.generate_array_element_name_from_type_site_id(tel_type, site, f"{i + 1:02d}")
+        )
+        axis = axis_sequence[i % 4]
+        dist = distance * step
+        if axis == "x":
+            pos_x.append(dist)
+            pos_y.append(0 * u.m)
+        elif axis == "-x":
+            pos_x.append(-dist)
+            pos_y.append(0 * u.m)
+        elif axis == "y":
+            pos_x.append(0 * u.m)
+            pos_y.append(dist)
+        elif axis == "-y":
+            pos_x.append(0 * u.m)
+            pos_y.append(-dist)
+        pos_z.append(0 * u.m)
+
+        if (i + 1) % 4 == 0:
+            step += 1
+
+
+def _create_square_array(tel_name, pos_x, pos_y, pos_z, n_tel, tel_type, site, distance):
+    """Create square array positions."""
+    if n_tel == 1:
+        tel_name.append(names.generate_array_element_name_from_type_site_id(tel_type, site, "01"))
+        pos_x.append(0 * u.m)
+        pos_y.append(0 * u.m)
+        pos_z.append(0 * u.m)
+    elif n_tel == 4:
+        for i in range(1, 5):
+            tel_name.append(
+                names.generate_array_element_name_from_type_site_id(tel_type, site, f"0{i}")
+            )
+            pos_x.append(distance * (-1) ** (i // 2))
+            pos_y.append(distance * (-1) ** (i % 2))
+            pos_z.append(0 * u.m)
+    else:
+        raise ValueError(f"Unsupported number of telescopes for square array: {n_tel}.")
+
+
+def create_regular_array(
+    array_name, site, n_telescopes, telescope_type, telescope_distance, shape="square"
+):
     """
     Create a regular array layout table.
 
@@ -493,8 +542,14 @@ def create_regular_array(array_name, site, telescope_distance):
         Name of the regular array (e.g. "4MST").
     site : str
         Site identifier.
-    telescope_distance : dict
-        Dictionary with telescope distances per telescope type.
+    n_telescopes : int
+        Number of telescopes in the array.
+    telescope_type : str
+        Type of telescope (e.g. "MST").
+    telescope_distance : Quantity
+        Distance between telescopes in the array.
+    shape : str
+        Shape of the array: "square" or "star" (default: "square").
 
     Returns
     -------
@@ -502,26 +557,31 @@ def create_regular_array(array_name, site, telescope_distance):
         Table with the regular array layout.
     """
     tel_name, pos_x, pos_y, pos_z = [], [], [], []
-    tel_size, n_tel = _get_array_name(array_name)
-    tel_size = array_name[1:4]
 
-    # Single telescope at the center
-    if n_tel == 1:
-        tel_name.append(names.generate_array_element_name_from_type_site_id(tel_size, site, "01"))
-        pos_x.append(0 * u.m)
-        pos_y.append(0 * u.m)
-        pos_z.append(0 * u.m)
-    # 4 telescopes in a regular square grid
-    elif n_tel == 4:
-        for i in range(1, 5):
-            tel_name.append(
-                names.generate_array_element_name_from_type_site_id(tel_size, site, f"0{i}")
-            )
-            pos_x.append(telescope_distance[tel_size] * (-1) ** (i // 2))
-            pos_y.append(telescope_distance[tel_size] * (-1) ** (i % 2))
-            pos_z.append(0 * u.m)
+    if shape == "square":
+        _create_square_array(
+            tel_name,
+            pos_x,
+            pos_y,
+            pos_z,
+            n_telescopes,
+            telescope_type,
+            site,
+            telescope_distance,
+        )
+    elif shape == "star":
+        _create_star_array(
+            tel_name,
+            pos_x,
+            pos_y,
+            pos_z,
+            n_telescopes,
+            telescope_type,
+            site,
+            telescope_distance,
+        )
     else:
-        raise ValueError(f"Unsupported number of telescopes: {n_tel}.")
+        raise ValueError(f"Unsupported array shape: {shape}. Allowed: 'square' or 'star'.")
 
     table = QTable(meta={"array_name": array_name, "site": site})
     table["telescope_name"] = tel_name
@@ -591,3 +651,65 @@ def write_array_elements_from_file_to_repository(
             output_path=repository_path / instrument,
             output_file=f"{parameter_name}.json",
         )
+
+
+def write_array_elements_info_yaml(
+    array_table, site, model_version, output_file, parameter_version="2.0.0"
+):
+    """
+    Write YAML file for array layout in a format compatible with overwrite.
+
+    Parameters
+    ----------
+    array_table : astropy.table.Table
+        Table with telescope positions.
+    site : str
+        Site identifier (e.g., 'North' or 'South').
+    model_version : str
+        Model version.
+    output_file : Path
+        Path to the output YAML file.
+    parameter_version : str
+        Parameter version to use in the YAML file.
+    """
+    telescope_names = [str(name) for name in array_table["telescope_name"]]
+
+    data = {
+        "model_version": model_version,
+        "model_update": "patch_update",
+        "model_version_history": [model_version],
+        "description": f"Regular array layout: {array_table.meta['array_name']}",
+        "changes": {
+            f"OBS-{site}": {
+                "array_layouts": {
+                    "version": parameter_version,
+                    "value": [],
+                    "unit": None,
+                }
+            }
+        },
+    }
+
+    data["changes"][f"OBS-{site}"]["array_layouts"]["value"].append(
+        {"name": array_table.meta["array_name"], "elements": telescope_names}
+    )
+
+    for tel_name, pos_x, pos_y, pos_z in zip(
+        telescope_names,
+        array_table["position_x"],
+        array_table["position_y"],
+        array_table["position_z"],
+    ):
+        data["changes"][tel_name] = {
+            "array_element_position_ground": {
+                "version": parameter_version,
+                "value": [
+                    float(pos_x.to(u.m).value),
+                    float(pos_y.to(u.m).value),
+                    float(pos_z.to(u.m).value),
+                ],
+                "unit": "m",
+            }
+        }
+
+    ascii_handler.write_data_to_file(data, output_file)

simtools/model/array_model.py

@@ -9,9 +9,10 @@ from astropy.table import QTable
 from simtools.data_model import data_reader, schema
 from simtools.io import io_handler
 from simtools.model.calibration_model import CalibrationModel
+from simtools.model.model_utils import read_overwrite_model_parameter_dict
 from simtools.model.site_model import SiteModel
 from simtools.model.telescope_model import TelescopeModel
-from simtools.simtel.simtel_config_writer import SimtelConfigWriter
+from simtools.simtel import simtel_config_writer, simtel_seeds
 from simtools.utils import general, names
 
 
@@ -50,7 +51,6 @@ class ArrayModel:
     ):
         """Initialize ArrayModel."""
         self._logger = logging.getLogger(__name__)
-        self._logger.debug("Init ArrayModel")
         self.model_version = model_version
         self.label = label
         self.layout_name = (
@@ -62,7 +62,9 @@ class ArrayModel:
         self._config_file_directory = None
         self.io_handler = io_handler.IOHandler()
 
-        self.overwrite_model_parameters = overwrite_model_parameters
+        self.overwrite_model_parameter_dict = read_overwrite_model_parameter_dict(
+            overwrite_model_parameters
+        )
 
         self.array_elements, self.site_model, self.telescope_models, self.calibration_models = (
             self._initialize(site, array_elements, calibration_device_types)
@@ -70,7 +72,7 @@ class ArrayModel:
 
         self._telescope_model_files_exported = False
         self._array_model_file_exported = False
-        self._sim_telarray_seeds = None
+        self.sim_telarray_seed = None
 
     def _initialize(self, site, array_elements_config, calibration_device_types):
         """
@@ -99,7 +101,7 @@ class ArrayModel:
             site=names.validate_site_name(site),
             model_version=self.model_version,
             label=self.label,
-            overwrite_model_parameters=self.overwrite_model_parameters,
+            overwrite_model_parameter_dict=self.overwrite_model_parameter_dict,
         )
 
         # Case 1: array_elements is a file name
@@ -127,41 +129,6 @@ class ArrayModel:
 
         return array_elements, site_model, telescope_models, calibration_models
 
-    @property
-    def sim_telarray_seeds(self):
-        """
-        Return sim_telarray seeds.
-
-        Returns
-        -------
-        dict
-            Dictionary with sim_telarray seeds.
-        """
-        return self._sim_telarray_seeds
-
-    @sim_telarray_seeds.setter
-    def sim_telarray_seeds(self, value):
-        """
-        Set sim_telarray seeds.
-
-        Parameters
-        ----------
-        value: dict
-            Dictionary with sim_telarray seeds.
-        """
-        if isinstance(value, dict):
-            required_keys = {
-                "seed",
-                "random_instrument_instances",
-                "seed_file_name",
-            }
-            if not required_keys.issubset(value):
-                raise ValueError(
-                    "sim_telarray_seeds dictionary must contain the following keys: "
-                    f"{required_keys}"
-                )
-        self._sim_telarray_seeds = value
-
     @property
     def config_file_path(self):
         """
@@ -242,7 +209,7 @@ class ArrayModel:
                 telescope_name=element_name,
                 model_version=self.model_version,
                 label=self.label,
-                overwrite_model_parameters=self.overwrite_model_parameters,
+                overwrite_model_parameter_dict=self.overwrite_model_parameter_dict,
             )
             calibration_models[element_name] = self._build_calibration_models(
                 telescope_models[element_name],
@@ -274,7 +241,7 @@ class ArrayModel:
                 calibration_device_model_name=device_name,
                 model_version=self.model_version,
                 label=self.label,
-                overwrite_model_parameters=self.overwrite_model_parameters,
+                overwrite_model_parameter_dict=self.overwrite_model_parameter_dict,
             )
         return calibration_models
 
@@ -289,7 +256,6 @@ class ArrayModel:
         for tel_model in self.telescope_models.values():
             name = tel_model.name
             if name not in exported_models:
-                self._logger.debug(f"Exporting configuration file for telescope {name}")
                 tel_model.write_sim_telarray_config_file(
                     additional_models=self.calibration_models.get(tel_model.name)
                 )
@@ -306,7 +272,7 @@ class ArrayModel:
         self.site_model.export_model_files()
 
         self._logger.info(f"Writing array configuration file into {self.config_file_path}")
-        simtel_writer = SimtelConfigWriter(
+        simtel_writer = simtel_config_writer.SimtelConfigWriter(
             site=self.site_model.site,
             layout_name=self.layout_name,
             model_version=self.model_version,
@@ -531,10 +497,16 @@ class ArrayModel:
         dict
             Dictionary with additional metadata.
         """
-        metadata = {}
-        if self.sim_telarray_seeds is not None:
-            metadata.update(self.sim_telarray_seeds)
-
-        metadata["nsb_integrated_flux"] = self.site_model.get_nsb_integrated_flux()
+        return {
+            "nsb_integrated_flux": self.site_model.get_nsb_integrated_flux(),
+        }
 
-        return metadata
+    def initialize_seeds(self, zenith_angle=None, azimuth_angle=None):
+        """Initialize sim_telarray seeds for instrument and shower simulations."""
+        self.sim_telarray_seed = simtel_seeds.SimtelSeeds(
+            output_path=self.get_config_directory(),
+            site=self.site_model.site,
+            model_version=self.model_version,
+            zenith_angle=zenith_angle,
+            azimuth_angle=azimuth_angle,
+        )

simtools/model/calibration_model.py

@@ -21,8 +21,8 @@ class CalibrationModel(ModelParameter):
         Model version.
     label: str, optional
         Instance label. Important for output file naming.
-    overwrite_model_parameters: str, optional
-        File name to overwrite model parameters from DB with provided values.
+    overwrite_model_parameter_dict: dict, optional
+        Dictionary to overwrite model parameters from DB with provided values.
     """
 
     def __init__(
@@ -31,7 +31,7 @@ class CalibrationModel(ModelParameter):
         calibration_device_model_name,
         model_version,
         label=None,
-        overwrite_model_parameters=None,
+        overwrite_model_parameter_dict=None,
     ):
         """Initialize CalibrationModel."""
         super().__init__(
@@ -40,7 +40,7 @@ class CalibrationModel(ModelParameter):
             collection="calibration_devices",
             model_version=model_version,
             label=label,
-            overwrite_model_parameters=overwrite_model_parameters,
+            overwrite_model_parameter_dict=overwrite_model_parameter_dict,
         )
 
         self._logger = logging.getLogger(__name__)

simtools/model/model_parameter.py

@@ -4,13 +4,14 @@
 import logging
 import shutil
 from copy import copy, deepcopy
+from pathlib import Path
 
 import astropy.units as u
 
 import simtools.utils.general as gen
 from simtools.data_model import schema
 from simtools.db import db_handler
-from simtools.io import ascii_handler, io_handler
+from simtools.io import io_handler
 from simtools.model import legacy_model_parameter
 from simtools.simtel.simtel_config_writer import SimtelConfigWriter
 from simtools.utils import names, value_conversion
@@ -40,8 +41,8 @@ class ModelParameter:
         as stored under collection in the DB.
     label: str
         Instance label. Used for output file naming.
-    overwrite_model_parameters: str, optional
-        File name to overwrite model parameters from DB with provided values.
+    overwrite_model_parameter_dict: dict, optional
+        Dictionary to overwrite model parameters from DB with provided values.
         Instance label. Important for output file naming.
     ignore_software_version: bool
         If True, ignore software version checks for deprecated parameters.
@@ -55,7 +56,7 @@ class ModelParameter:
         array_element_name=None,
         collection="telescopes",
         label=None,
-        overwrite_model_parameters=None,
+        overwrite_model_parameter_dict=None,
         ignore_software_version=False,
     ):
         self._logger = logging.getLogger(__name__)
@@ -81,7 +82,7 @@ class ModelParameter:
         )
         self._config_file_directory = None
         self._config_file_path = None
-        self.overwrite_model_parameters = overwrite_model_parameters
+        self.overwrite_model_parameter_dict = overwrite_model_parameter_dict
         self._added_parameter_files = None
         self._is_exported_model_files_up_to_date = False
 
@@ -276,8 +277,6 @@ class ModelParameter:
         )
         self._config_file_path = self.config_file_directory.joinpath(config_file_name)
 
-        self._logger.debug(f"Config file path: {self._config_file_path}")
-
     def get_simulation_software_parameters(self, simulation_software):
         """
         Get simulation software parameters.
@@ -325,8 +324,7 @@ class ModelParameter:
                     self.site, self.name, self.collection, self.model_version
                 )
             )
-            if self.overwrite_model_parameters:
-                self.overwrite_parameters_from_file(self.overwrite_model_parameters)
+            self.overwrite_parameters(self.overwrite_model_parameter_dict)
             self._check_model_parameter_versions(self.parameters)
 
         self._load_simulation_software_parameter()
@@ -396,22 +394,20 @@ class ModelParameter:
             raise InvalidModelParameterError(f"Parameter {par_name} not in the model")
 
         if value is None and parameter_version:
-            _para_dict = self.db.get_model_parameter(
-                parameter=par_name,
-                site=self.site,
-                array_element_name=self.name,
-                parameter_version=parameter_version,
-            )
-            if _para_dict:
-                self.parameters[par_name] = _para_dict.get(par_name)
-            self._logger.debug(
-                f"Changing parameter {par_name} to version {parameter_version} with value "
-                f"{self.parameters[par_name]['value']}"
-            )
+            self._overwrite_model_parameter_from_db(par_name, parameter_version)
         else:
-            value = gen.convert_string_to_list(value) if isinstance(value, str) else value
+            self._overwrite_model_parameter_from_value(par_name, value, parameter_version)
 
-            par_type = self.get_parameter_type(par_name)
+        # In case parameter is a file, the model files will be outdated
+        if self.get_parameter_file_flag(par_name):
+            self._is_exported_model_files_up_to_date = False
+
+    def _overwrite_model_parameter_from_value(self, par_name, value, parameter_version=None):
+        """Overwrite model parameter from provided value only."""
+        value = gen.convert_string_to_list(value) if isinstance(value, str) else value
+        par_type = self.get_parameter_type(par_name)
+
+        if par_type in ("list", "dict"):
             if not gen.validate_data_type(
                 reference_dtype=par_type,
                 value=value,
@@ -419,40 +415,40 @@ class ModelParameter:
                 allow_subtypes=True,
             ):
                 raise ValueError(f"Could not cast {value} of type {type(value)} to {par_type}.")
+        else:
+            for value_element in gen.ensure_iterable(value):
+                if not gen.validate_data_type(
+                    reference_dtype=par_type,
+                    value=value_element,
+                    dtype=None,
+                    allow_subtypes=True,
+                ):
+                    raise ValueError(
+                        f"Could not cast {value_element} of type "
+                        f"{type(value_element)} to {par_type}."
+                    )
 
-            self._logger.debug(
-                f"Changing parameter {par_name} from {self.get_parameter_value(par_name)} "
-                f"to {value}"
-            )
-            self.parameters[par_name]["value"] = value
-            if parameter_version:
-                self.parameters[par_name]["parameter_version"] = parameter_version
-
-        # In case parameter is a file, the model files will be outdated
-        if self.get_parameter_file_flag(par_name):
-            self._is_exported_model_files_up_to_date = False
-
-    def overwrite_parameters_from_file(self, file_name):
-        """
-        Overwrite parameters from a file.
-
-        File is expected to follow the format described in 'simulation_models_info.schema.yml'.
-
-        This function does not modify the DB, it affects only the current instance.
-        This feature is intended for developers and lacks validation.
-
-        Parameters
-        ----------
-        file_name: str
-            File containing the parameters to be changed.
-        """
-        changes_data = schema.validate_dict_using_schema(
-            data=ascii_handler.collect_data_from_file(file_name=file_name),
-            schema_file="simulation_models_info.schema.yml",
-        ).get("changes", {})
-
-        key_for_changes = self._get_key_for_parameter_changes(self.site, self.name, changes_data)
-        self.overwrite_parameters(changes_data.get(key_for_changes, {}) if key_for_changes else {})
+        self._logger.debug(
+            f"Changing parameter {par_name} from {self.get_parameter_value(par_name)} to {value}"
+        )
+        self.parameters[par_name]["value"] = value
+        if parameter_version:
+            self.parameters[par_name]["parameter_version"] = parameter_version
+
+    def _overwrite_model_parameter_from_db(self, par_name, parameter_version):
+        """Overwrite model parameter from DB for a specific version."""
+        _para_dict = self.db.get_model_parameter(
+            parameter=par_name,
+            site=self.site,
+            array_element_name=self.name,
+            parameter_version=parameter_version,
+        )
+        if _para_dict:
+            self.parameters[par_name] = _para_dict.get(par_name)
+        self._logger.debug(
+            f"Changing parameter {par_name} to version {parameter_version} with value "
+            f"{self.parameters[par_name]['value']}"
+        )
 
     def _get_key_for_parameter_changes(self, site, array_element_name, changes_data):
         """
@@ -494,7 +490,7 @@ class ModelParameter:
 
         return None
 
-    def overwrite_parameters(self, changes):
+    def overwrite_parameters(self, changes, flat_dict=False):
         """
         Change the value of multiple existing parameters in the model.
 
@@ -502,23 +498,43 @@ class ModelParameter:
 
         Allows for two types of 'changes' dictionary:
 
-        - simple: '{parameter_name: new_value, ...}'
-        - model repository style:
-          '{parameter_name: {"value": new_value, "version": new_version}, ...}'
+        - simple (flat_dict=True): '{parameter_name: new_value, ...}'
+        - model repository style (flat_dict=False):
+          '{array_element: {parameter_name: {"value": new_value, "version": new_version}, ...}}'
 
         Parameters
         ----------
         changes: dict
             Parameters to be changed.
         """
+        if not changes:
+            return
+        if not flat_dict:
+            key_for_changes = self._get_key_for_parameter_changes(self.site, self.name, changes)
+            changes = changes.get(key_for_changes, {})
+        if not changes:
+            return
+
+        if flat_dict:
+            self._logger.debug(f"Overwriting parameters with changes: {changes}")
+        else:
+            self._logger.debug(
+                f"Overwriting parameters for {key_for_changes} with changes: {changes}"
+            )
+
         for par_name, par_value in changes.items():
-            if par_name in self.parameters:
-                if isinstance(par_value, dict) and ("value" in par_value or "version" in par_value):
-                    self.overwrite_model_parameter(
-                        par_name, par_value.get("value"), par_value.get("version")
-                    )
-                else:
-                    self.overwrite_model_parameter(par_name, par_value)
+            if par_name not in self.parameters:
+                self._logger.warning(
+                    f"Parameter {par_name} not found in model {self.name}, cannot overwrite it."
+                )
+                continue
+
+            if isinstance(par_value, dict) and ("value" in par_value or "version" in par_value):
+                self.overwrite_model_parameter(
+                    par_name, par_value.get("value"), par_value.get("version")
+                )
+            else:
+                self.overwrite_model_parameter(par_name, par_value)
 
     def overwrite_model_file(self, par_name, file_path):
         """
@@ -566,7 +582,29 @@ class ModelParameter:
         )
         self._is_exported_model_files_up_to_date = True
 
-    def write_sim_telarray_config_file(self, additional_models=None):
+    def get_config_file_path(self, label=None):
+        """Return config file path for a given label.
+
+        Parameters
+        ----------
+        label : str or None
+            Label used for output file naming. If None, use this model's label.
+
+        Returns
+        -------
+        pathlib.Path
+            Path to the sim_telarray configuration file.
+        """
+        config_file_name = names.simtel_config_file_name(
+            self.site,
+            telescope_model_name=self.name,
+            label=self.label if label is None else label,
+        )
+        return self.config_file_directory.joinpath(config_file_name)
+
+    def write_sim_telarray_config_file(
+        self, additional_models=None, label=None, config_file_path=None
+    ):
         """
         Write the sim_telarray configuration file.
 
@@ -574,15 +612,26 @@ class ModelParameter:
         ----------
         additional_models: TelescopeModel or SiteModel
             Model object for additional parameter to be written to the config file.
+        label: str or None
+            Optional label override used for output file naming.
+        config_file_path: pathlib.Path or str or None
+            Optional explicit path of the config file. If not given, it is derived from ``label``.
         """
         self.parameters.update(self._simulation_config_parameters.get("sim_telarray", {}))
         self.export_model_files(update_if_necessary=True)
 
         self._add_additional_models(additional_models)
 
-        self._load_simtel_config_writer()
+        config_file_path = (
+            Path(config_file_path)
+            if config_file_path is not None
+            else self.get_config_file_path(label=label)
+        )
+
+        # Ensure the writer label matches the config file naming label.
+        self._load_simtel_config_writer(label=label)
         self.simtel_config_writer.write_telescope_config_file(
-            config_file_path=self.config_file_path,
+            config_file_path=config_file_path,
             parameters=self.parameters,
         )
 
@@ -613,15 +662,16 @@ class ModelParameter:
             self._set_config_file_directory_and_name()
         return self._config_file_path
 
-    def _load_simtel_config_writer(self):
+    def _load_simtel_config_writer(self, label=None):
         """Load the SimtelConfigWriter object."""
-        if self.simtel_config_writer is None:
+        desired_label = self.label if label is None else label
+        if label is not None or self.simtel_config_writer is None:
             self.simtel_config_writer = SimtelConfigWriter(
                 site=self.site,
                 telescope_model_name=self.name,
                 telescope_design_model=self.design_model,
                 model_version=self.model_version,
-                label=self.label,
+                label=desired_label,
             )
 
     def export_nsb_spectrum_to_telescope_altitude_correction_file(self, model_directory):