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

simtools/configuration/configurator.py

@@ -163,6 +163,7 @@ class Configurator:
             self.config["activity_id"] = str(uuid.uuid4())
         if self.config["label"] is None:
             self.config["label"] = self.label
+        self._initialize_model_versions()
 
         self._initialize_io_handler()
         if output:
@@ -329,6 +330,15 @@ class Configurator:
 
         self._fill_from_config_dict(_env_dict)
 
+    def _initialize_model_versions(self):
+        """Initialize model versions."""
+        if (
+            self.config.get("model_version", None)
+            and isinstance(self.config["model_version"], list)
+            and len(self.config["model_version"]) == 1
+        ):
+            self.config["model_version"] = self.config["model_version"][0]
+
     def _initialize_io_handler(self):
         """Initialize IOHandler with input and output paths."""
         _io_handler = io_handler.IOHandler()

simtools/corsika/corsika_config.py

@@ -124,9 +124,15 @@ class CorsikaConfig:
         if db_config is None:  # all following parameter require DB
             return config
 
-        db_model_parameters = ModelParameter(
-            mongo_db_config=db_config, model_version=args_dict["model_version"]
-        )
+        # If the user provided multiple model versions, we take the first one
+        # because for CORSIKA config we need only one and it doesn't matter which
+        model_versions = args_dict.get("model_version", None)
+        if not isinstance(model_versions, list):
+            model_versions = [model_versions]
+        self.assert_corsika_configurations_match(model_versions, db_config=db_config)
+        model_version = model_versions[0]
+        self._logger.debug(f"Using model version {model_version} for CORSIKA parameters")
+        db_model_parameters = ModelParameter(mongo_db_config=db_config, model_version=model_version)
         parameters_from_db = db_model_parameters.get_simulation_software_parameters("corsika")
 
         config["INTERACTION_FLAGS"] = self._corsika_configuration_interaction_flags(
@@ -140,6 +146,60 @@ class CorsikaConfig:
 
         return config
 
+    def assert_corsika_configurations_match(self, model_versions, db_config=None):
+        """
+        Assert that CORSIKA configurations match across all model versions.
+
+        Parameters
+        ----------
+        model_versions : list
+            List of model versions to check.
+        db_config : dict, optional
+            Database configuration.
+
+        Raises
+        ------
+        InvalidCorsikaInputError
+            If CORSIKA parameters are not identical across all model versions.
+        """
+        if len(model_versions) < 2:
+            return
+
+        parameters_from_db_list = []
+
+        # Get parameters for all model versions
+        for model_version in model_versions:
+            db_model_parameters = ModelParameter(
+                mongo_db_config=db_config, model_version=model_version
+            )
+            parameters_from_db_list.append(
+                db_model_parameters.get_simulation_software_parameters("corsika")
+            )
+
+        # Parameters that can differ between model versions (e.g., i/o buffer size)
+        skip_parameters = ["corsika_iact_io_buffer", "corsika_iact_split_auto"]
+
+        # Check if all parameters match
+        for i in range(len(parameters_from_db_list) - 1):
+            for key in parameters_from_db_list[i]:
+                if key in skip_parameters:
+                    continue
+
+                current_value = parameters_from_db_list[i][key]["value"]
+                next_value = parameters_from_db_list[i + 1][key]["value"]
+
+                if current_value != next_value:
+                    self._logger.warning(
+                        f"Parameter '{key}' mismatch between model versions:\n"
+                        f"  {model_versions[i]}: {current_value}\n"
+                        f"  {model_versions[i + 1]}: {next_value}"
+                    )
+                    raise InvalidCorsikaInputError(
+                        f"CORSIKA parameter '{key}' differs between model versions "
+                        f"{model_versions[i]} and {model_versions[i + 1]}. "
+                        f"Values are {current_value} and {next_value} respectively."
+                    )
+
     def _corsika_configuration_from_user_input(self, args_dict):
         """
         Get CORSIKA configuration from user input.
@@ -236,7 +296,45 @@ class CorsikaConfig:
 
     def _input_config_corsika_starting_grammage(self, entry):
         """Return FIXCHI parameter CORSIKA format."""
-        return f"{entry['value'] * u.Unit(entry['unit']).to('g/cm2')}"
+        value = self._get_starting_grammage_value(entry["value"])
+        return f"{value * u.Unit(entry['unit']).to('g/cm2')}"
+
+    def _get_starting_grammage_value(self, value_entry):
+        """
+        Get appropriate starting grammage value from entry values.
+
+        Parameters
+        ----------
+        value_entry : float or list
+            Value or list of grammage configurations
+
+        Returns
+        -------
+        float
+            Selected grammage value
+        """
+        if not isinstance(value_entry, list):
+            return value_entry
+
+        tel_types = {tel.design_model for tel in self.array_model.telescope_model.values()}
+        particle = self.primary_particle.name
+        matched_values = self._get_matching_grammage_values(value_entry, tel_types, particle)
+
+        return min(matched_values) if matched_values else 0
+
+    def _get_matching_grammage_values(self, configs, tel_types, particle):
+        """Get list of matching grammage values for particle and telescope types."""
+        matched = []
+        defaults = []
+
+        for config in configs:
+            if config.get("instrument") is None or config.get("instrument") in tel_types:
+                if config["primary_particle"] == particle:
+                    matched.append(config["value"])
+                elif config["primary_particle"] == "default":
+                    defaults.append(config["value"])
+
+        return matched if matched else defaults
 
     def _input_config_corsika_particle_kinetic_energy_cutoff(self, entry):
         """Return ECUTS parameter CORSIKA format."""
@@ -587,7 +685,7 @@ class CorsikaConfig:
         str
             Output file name.
         """
-        sub_dir = "corsika_simtel" if use_multipipe else "corsika"
+        sub_dir = "corsika_sim_telarray" if use_multipipe else "corsika"
         config_file_name = self.get_corsika_config_file_name(file_type="config")
         file_directory = self.io_handler.get_output_directory(label=self.label, sub_dir=sub_dir)
         self._logger.debug(f"Creating directory {file_directory}")

simtools/data_model/format_checkers.py

@@ -5,6 +5,7 @@ import re
 import astropy.units as u
 import jsonschema
 
+from simtools.corsika.primary_particle import PrimaryParticle
 from simtools.utils import names
 
 format_checker = jsonschema.FormatChecker()
@@ -50,3 +51,11 @@ def check_array_triggers_name(name):
         raise ValueError(f"Array trigger name '{name}' does not match pattern '{pattern}'")
     names.validate_array_element_type(re.match(pattern, name).group(1))
     return True
+
+
+@format_checker.checks("common_particle_name")
+def check_common_particle_name(name):
+    """Validate common particle names for jsonschema."""
+    if name in PrimaryParticle.particle_names() or name == "default":
+        return True
+    raise ValueError(f"Invalid common particle name: '{name}'")

simtools/data_model/model_data_writer.py

@@ -270,6 +270,9 @@ class ModelDataWriter:
             "type": self._get_parameter_type(),
             "file": self._parameter_is_a_file(),
             "meta_parameter": False,
+            "model_parameter_schema_version": self.schema_dict.get(
+                "model_parameter_schema_version", "0.1.0"
+            ),
         }
         return self.validate_and_transform(
             product_data_dict=data_dict,

simtools/data_model/schema.py

@@ -18,7 +18,7 @@ from simtools.utils import names
 _logger = logging.getLogger(__name__)
 
 
-def get_get_model_parameter_schema_files(schema_directory=MODEL_PARAMETER_SCHEMA_PATH):
+def get_model_parameter_schema_files(schema_directory=MODEL_PARAMETER_SCHEMA_PATH):
     """
     Return list of parameters and schema files located in schema file directory.
 
@@ -35,7 +35,8 @@ def get_get_model_parameter_schema_files(schema_directory=MODEL_PARAMETER_SCHEMA
         raise FileNotFoundError(f"No schema files found in {schema_directory}")
     parameters = []
     for schema_file in schema_files:
-        schema_dict = gen.collect_data_from_file(file_name=schema_file)
+        # reading parameter 'name' only - first document in schema file should be ok
+        schema_dict = gen.collect_data_from_file(file_name=schema_file, yaml_document=0)
         parameters.append(schema_dict.get("name"))
     return parameters, schema_files
 
@@ -182,6 +183,15 @@ def load_schema(schema_file=None, schema_version=None):
     return schema
 
 
+def _get_array_element_list():
+    """Build complete list of array elements including design types."""
+    elements = set(names.array_elements().keys())
+    for array_element in names.array_elements():
+        for design_type in names.array_element_design_types(array_element):
+            elements.add(f"{array_element}-{design_type}")
+    return sorted(elements)
+
+
 def _add_array_elements(key, schema):
     """
     Add list of array elements to schema.
@@ -200,22 +210,23 @@ def _add_array_elements(key, schema):
     -------
     dict
         Schema dictionary with added array elements.
-
     """
-    _list_of_array_elements = sorted(names.array_elements().keys())
-
-    def recursive_search(sub_schema, key):
-        if key in sub_schema:
-            if "enum" in sub_schema[key] and isinstance(sub_schema[key]["enum"], list):
-                sub_schema[key]["enum"] = list(
-                    set(sub_schema[key]["enum"] + _list_of_array_elements)
-                )
-            else:
-                sub_schema[key]["enum"] = _list_of_array_elements
+    array_elements = _get_array_element_list()
+
+    def update_enum(sub_schema):
+        if "enum" in sub_schema and isinstance(sub_schema["enum"], list):
+            sub_schema["enum"] = list(set(sub_schema["enum"] + array_elements))
         else:
-            for _, v in sub_schema.items():
-                if isinstance(v, dict):
-                    recursive_search(v, key)
+            sub_schema["enum"] = array_elements
+
+    def recursive_search(sub_schema, target_key):
+        if target_key in sub_schema:
+            update_enum(sub_schema[target_key])
+            return
+
+        for v in sub_schema.values():
+            if isinstance(v, dict):
+                recursive_search(v, target_key)
 
     recursive_search(schema, key)
     return schema

simtools/data_model/validate_data.py

@@ -177,7 +177,11 @@ class DataValidator:
         if is_model_parameter:
             self._prepare_model_parameter()
 
-        self._data_description = self._read_validation_schema(self.schema_file_name)
+        self._data_description = self._read_validation_schema(
+            self.schema_file_name,
+            # use 0.1.0 as default; this corresponds to the first definition of the schema
+            self.data_dict.get("model_parameter_schema_version", "0.1.0"),
+        )
 
         value_as_list, unit_as_list = self._get_value_and_units_as_lists()
 
@@ -701,14 +705,20 @@ class DataValidator:
 
         return False
 
-    def _read_validation_schema(self, schema_file):
+    def _read_validation_schema(self, schema_file, schema_version=None):
         """
         Read validation schema from file.
 
+        The schema file can be a yaml file with several documents, each document
+        describing a different schema version. Returns first document if no
+        schema version is requested.
+
         Parameters
         ----------
         schema_file: Path
             Schema file describing input data.
+        schema_version: str
+            Version of the schema to be used.
 
         Returns
         -------
@@ -719,11 +729,21 @@ class DataValidator:
         ------
         KeyError
             if 'data' can not be read from dict in schema file
-        """
-        try:
-            return gen.collect_data_from_file(file_name=schema_file)["data"]
-        except KeyError as exc:
-            raise KeyError(f"Error reading validation schema from {schema_file}") from exc
+        ValueError
+            if schema version is not found in schema file
+        """
+        schema_data = gen.collect_data_from_file(file_name=schema_file)
+        entries = schema_data if isinstance(schema_data, list) else [schema_data]
+
+        for entry in entries:
+            if not schema_version or entry.get("version") == schema_version:
+                try:
+                    return entry["data"]
+                except KeyError as exc:
+                    raise KeyError(f"Error reading validation schema from {schema_file}") from exc
+        raise ValueError(
+            f"Schema version {schema_version} not found in schema file {schema_file}. "
+        )
 
     def _get_data_description(self, column_name=None, status_test=False):
         """

simtools/db/db_handler.py

@@ -122,9 +122,11 @@ class DatabaseHandler:
             port=self.mongo_db_config["db_api_port"],
             username=self.mongo_db_config["db_api_user"],
             password=self.mongo_db_config["db_api_pw"],
-            authSource=self.mongo_db_config.get("db_api_authentication_database")
-            if self.mongo_db_config.get("db_api_authentication_database")
-            else "admin",
+            authSource=(
+                self.mongo_db_config.get("db_api_authentication_database")
+                if self.mongo_db_config.get("db_api_authentication_database")
+                else "admin"
+            ),
             directConnection=direct_connection,
             ssl=not direct_connection,
             tlsallowinvalidhostnames=True,
@@ -211,6 +213,10 @@ class DatabaseHandler:
         """
         collection_name = names.get_collection_name_from_parameter_name(parameter)
         if model_version:
+            if isinstance(model_version, list):
+                raise ValueError(
+                    "Only one model version can be passed to get_model_parameter, not a list."
+                )
             production_table = self._read_production_table_from_mongo_db(
                 collection_name, model_version
             )
@@ -678,7 +684,7 @@ class DatabaseHandler:
                 model_version=model_version,
                 collection="configuration_corsika",
             )
-        if simulation_software == "simtel":
+        if simulation_software == "sim_telarray":
             return (
                 self.get_model_parameters(
                     site,

simtools/layout/array_layout.py

@@ -642,6 +642,7 @@ class ArrayLayout:
             "type": "float64",
             "file": False,
             "meta_parameter": False,
+            "model_parameter_schema_version": "0.1.0",
         }
 
     def get_number_of_telescopes(self):

simtools/model/array_model.py

@@ -36,6 +36,8 @@ class ArrayModel:
     array_elements: Union[str, Path, List[str]], optional
         Array element definitions (list of array element or path to file with
         the array element positions).
+    sim_telarray_seeds : dict, optional
+        Dictionary with configuration for sim_telarray random instrument setup.
     """
 
     def __init__(
@@ -46,6 +48,7 @@ class ArrayModel:
         site: str | None = None,
         layout_name: str | None = None,
         array_elements: str | Path | list[str] | None = None,
+        sim_telarray_seeds: dict | None = None,
     ):
         """Initialize ArrayModel."""
         self._logger = logging.getLogger(__name__)
@@ -65,6 +68,7 @@ class ArrayModel:
 
         self._telescope_model_files_exported = False
         self._array_model_file_exported = False
+        self.sim_telarray_seeds = sim_telarray_seeds
 
     def _initialize(self, site: str, array_elements_config: str | Path | list[str]):
         """
@@ -116,6 +120,26 @@ class ArrayModel:
         telescope_model = self._build_telescope_models(site_model, array_elements)
         return array_elements, site_model, telescope_model
 
+    @property
+    def config_file_path(self) -> Path:
+        """
+        Return the path of the array config file for sim_telarray.
+
+        Returns
+        -------
+        Path
+            Path of the exported config file for sim_telarray.
+        """
+        if self._config_file_path is None:
+            config_file_name = names.simtel_config_file_name(
+                array_name=self.layout_name,
+                site=self.site_model.site,
+                model_version=self.model_version,
+                label=self.label,
+            )
+            self._config_file_path = self.get_config_directory().joinpath(config_file_name)
+        return self._config_file_path
+
     @property
     def number_of_telescopes(self) -> int:
         """
@@ -140,6 +164,34 @@ class ArrayModel:
         """
         return self.site_model.site
 
+    @property
+    def model_version(self):
+        """Model version."""
+        return self._model_version
+
+    @model_version.setter
+    def model_version(self, model_version):
+        """
+        Set model version.
+
+        Parameters
+        ----------
+        _model_version: str or list
+            Model version (e.g., "6.0.0").
+            If a list is passed, it must contain exactly one element,
+            and only that element will be used.
+
+        Raises
+        ------
+        ValueError
+            If more than one model version is passed.
+        """
+        if isinstance(model_version, list):
+            raise ValueError(
+                f"Only one model version can be passed to {self.__class__.__name__}, not a list."
+            )
+        self._model_version = model_version
+
     def _build_telescope_models(self, site_model: SiteModel, array_elements: dict) -> dict:
         """
         Build the the telescope models for all telescopes of this array.
@@ -187,7 +239,7 @@ class ArrayModel:
             )
             if name not in exported_models:
                 self._logger.debug(f"Exporting configuration file for telescope {name}")
-                tel_model.export_config_file()
+                tel_model.write_sim_telarray_config_file()
                 exported_models.append(name)
             else:
                 self._logger.debug(
@@ -196,19 +248,11 @@ class ArrayModel:
 
         self._telescope_model_files_exported = True
 
-    def export_simtel_array_config_file(self):
+    def export_sim_telarray_config_file(self):
         """Export sim_telarray configuration file for the array into the model directory."""
-        # Setting file name and the location
-        config_file_name = names.simtel_config_file_name(
-            array_name=self.layout_name,
-            site=self.site_model.site,
-            model_version=self.model_version,
-            label=self.label,
-        )
-        self._config_file_path = self.get_config_directory().joinpath(config_file_name)
+        self.site_model.export_model_files()
 
-        # Writing parameters to the file
-        self._logger.info(f"Writing array configuration file into {self._config_file_path}")
+        self._logger.info(f"Writing array configuration file into {self.config_file_path}")
         simtel_writer = SimtelConfigWriter(
             site=self.site_model.site,
             layout_name=self.layout_name,
@@ -216,9 +260,10 @@ class ArrayModel:
             label=self.label,
         )
         simtel_writer.write_array_config_file(
-            config_file_path=self._config_file_path,
+            config_file_path=self.config_file_path,
             telescope_model=self.telescope_model,
             site_model=self.site_model,
+            sim_telarray_seeds=self.sim_telarray_seeds,
         )
         self._array_model_file_exported = True
 
@@ -231,21 +276,7 @@ class ArrayModel:
         if not self._telescope_model_files_exported:
             self.export_simtel_telescope_config_files()
         if not self._array_model_file_exported:
-            self.export_simtel_array_config_file()
-
-    def get_config_file(self) -> Path:
-        """
-        Return the path of the array config file for sim_telarray.
-
-        A new config file is produced if the file is not updated.
-
-        Returns
-        -------
-        Path
-            Path of the exported config file for sim_telarray.
-        """
-        self.export_all_simtel_config_files()
-        return self._config_file_path
+            self.export_sim_telarray_config_file()
 
     def get_config_directory(self) -> Path:
         """
@@ -257,7 +288,9 @@ class ArrayModel:
             Path of the config directory path for sim_telarray.
         """
         if self._config_file_directory is None:
-            self._config_file_directory = self.io_handler.get_output_directory(self.label, "model")
+            self._config_file_directory = self.io_handler.get_output_directory(
+                self.label, f"model/{self.model_version}"
+            )
         return self._config_file_directory
 
     def _load_array_element_positions_from_file(
@@ -331,6 +364,7 @@ class ArrayModel:
             "type": "float64",
             "file": False,
             "meta_parameter": False,
+            "model_parameter_schema_version": "0.1.0",
         }
 
     def _get_array_elements_from_list(self, array_elements_list: list[str]) -> dict: