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

simtools/simtel/simtel_config_writer.py

@@ -528,7 +528,7 @@ class SimtelConfigWriter:
         """
         file.write(self.TAB + "% Site parameters\n")
         for par, value in site_parameters.items():
-            simtel_name, value = self._convert_model_parameters_to_simtel_format(
+            simtel_name, simtel_value = self._convert_model_parameters_to_simtel_format(
                 names.get_simulation_software_name_from_parameter_name(
                     par, software_name="sim_telarray"
                 ),
@@ -537,7 +537,7 @@ class SimtelConfigWriter:
                 telescope_model,
             )
             if simtel_name is not None:
-                file.write(f"{self.TAB}{simtel_name} = {value}\n")
+                file.write(f"{self.TAB}{simtel_name} = {simtel_value}\n")
         for meta in self._get_sim_telarray_metadata(
             "site", site_parameters, None, additional_metadata
         ):
@@ -592,34 +592,111 @@ class SimtelConfigWriter:
         telescope_model: dict of TelescopeModel
             Telescope models.
         """
+        trigger_per_telescope_type = self._group_telescopes_by_type(telescope_model)
+        hardstereo_lines, non_hardstereo_groups, all_non_hardstereo_tels, multiplicity = (
+            self._process_telescope_triggers(array_triggers, trigger_per_telescope_type)
+        )
+
+        array_triggers_file = "array_triggers.dat"
+        with open(model_path / array_triggers_file, "w", encoding="utf-8") as file:
+            file.write("# Array trigger definition\n")
+            self._write_trigger_lines(
+                file, hardstereo_lines, non_hardstereo_groups, all_non_hardstereo_tels, multiplicity
+            )
+
+        return array_triggers_file
+
+    def _group_telescopes_by_type(self, telescope_model):
+        """Group telescopes by their type."""
         trigger_per_telescope_type = {}
         for count, tel_name in enumerate(telescope_model.keys()):
             telescope_type = names.get_array_element_type_from_name(tel_name)
             trigger_per_telescope_type.setdefault(telescope_type, []).append(count + 1)
+        return trigger_per_telescope_type
+
+    def _process_telescope_triggers(self, array_triggers, trigger_per_telescope_type):
+        """Process telescope triggers and group them by hardstereo and parameters."""
+        hardstereo_lines = []
+        non_hardstereo_groups = {}
+        all_non_hardstereo_tels = []
+        multiplicity = None
 
-        trigger_lines = {}
         for tel_type, tel_list in trigger_per_telescope_type.items():
             trigger_dict = self._get_array_triggers_for_telescope_type(
                 array_triggers, tel_type, len(tel_list)
             )
-            trigger_lines[tel_type] = f"Trigger {trigger_dict['multiplicity']['value']} of "
-            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", {}).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(
-                    trigger_dict["min_separation"]["unit"]
-                ).to("m")
-                trigger_lines[tel_type] += f" minsep {min_sep}"
-
-        array_triggers_file = "array_triggers.dat"
-        with open(model_path / array_triggers_file, "w", encoding="utf-8") as file:
-            file.write("# Array trigger definition\n")
-            file.writelines(f"{line}\n" for line in trigger_lines.values())
+            width, minsep = self._extract_trigger_parameters(trigger_dict)
+            multiplicity = trigger_dict["multiplicity"]["value"]  # Store for later use
 
-        return array_triggers_file
+            if trigger_dict.get("hard_stereo", {}).get("value"):
+                line = self._build_trigger_line(
+                    trigger_dict, tel_list, width, minsep, hardstereo=True
+                )
+                hardstereo_lines.append(line)
+            else:
+                key = (width, minsep)
+                non_hardstereo_groups.setdefault(key, []).extend(tel_list)
+                all_non_hardstereo_tels.extend(tel_list)
+
+        return hardstereo_lines, non_hardstereo_groups, all_non_hardstereo_tels, multiplicity
+
+    def _extract_trigger_parameters(self, trigger_dict):
+        """Extract width and min_separation parameters from trigger dictionary."""
+        width = trigger_dict["width"]["value"] * u.Unit(trigger_dict["width"]["unit"]).to("ns")
+        minsep = None
+        if all(trigger_dict["min_separation"][key] is not None for key in ["value", "unit"]):
+            minsep = trigger_dict["min_separation"]["value"] * u.Unit(
+                trigger_dict["min_separation"]["unit"]
+            ).to("m")
+        return width, minsep
+
+    def _build_trigger_line(self, trigger_dict, tel_list, width, minsep, hardstereo=False):
+        """Build a trigger line string."""
+        line = f"Trigger {trigger_dict['multiplicity']['value']} of "
+        line += ", ".join(map(str, tel_list))
+        line += f" width {width}"
+        if hardstereo:
+            line += " hardstereo"
+        if minsep is not None:
+            line += f" minsep {minsep}"
+        return line
+
+    def _write_trigger_lines(
+        self, file, hardstereo_lines, non_hardstereo_groups, all_non_hardstereo_tels, multiplicity
+    ):
+        """Write all trigger lines to file."""
+        # Write hardstereo lines first
+        for line in hardstereo_lines:
+            file.write(f"{line}\n")
+
+        # Write individual non-hardstereo groups if they have different parameters
+        if len(non_hardstereo_groups) > 1:
+            for (width, minsep), tel_list in non_hardstereo_groups.items():
+                line = f"Trigger {multiplicity} of "
+                line += ", ".join(map(str, tel_list))
+                line += f" width {width}"
+                if minsep is not None:
+                    line += f" minsep {minsep}"
+                file.write(f"{line}\n")
+
+        # Write combined line with all non-hardstereo telescopes using shortest values
+        if all_non_hardstereo_tels:
+            min_width = min(width for width, minsep in non_hardstereo_groups.keys())
+            min_minsep = self._get_minimum_minsep(non_hardstereo_groups)
+
+            combined_line = f"Trigger {multiplicity} of "
+            combined_line += ", ".join(map(str, sorted(all_non_hardstereo_tels)))
+            combined_line += f" width {min_width}"
+            if min_minsep is not None:
+                combined_line += f" minsep {min_minsep}"
+            file.write(f"{combined_line}\n")
+
+    def _get_minimum_minsep(self, non_hardstereo_groups):
+        """Get minimum min_separation value from groups."""
+        minsep_values = [
+            minsep for width, minsep in non_hardstereo_groups.keys() if minsep is not None
+        ]
+        return min(minsep_values) if minsep_values else None
 
     def _get_array_triggers_for_telescope_type(
         self, array_triggers, telescope_type, num_telescopes_of_type

simtools/simulator.py

@@ -125,7 +125,7 @@ class Simulator:
                 label=self.label,
                 site=self.args_dict.get("site"),
                 layout_name=self.args_dict.get("array_layout_name"),
-                mongo_db_config=self.db_config,
+                db_config=self.db_config,
                 model_version=version,
                 sim_telarray_seeds={
                     "seed": self._get_seed_for_random_instrument_instances(
@@ -140,6 +140,7 @@ class Simulator:
                 calibration_device_types=self._get_calibration_device_types(
                     self.args_dict.get("run_mode")
                 ),
+                overwrite_model_parameters=self.args_dict.get("overwrite_model_parameters", None),
             )
             for version in versions
         ]

simtools/testing/assertions.py

@@ -8,6 +8,8 @@ from pathlib import Path
 import numpy as np
 import yaml
 
+from simtools.simtel.simtel_io_metadata import read_sim_telarray_metadata
+
 _logger = logging.getLogger(__name__)
 
 
@@ -124,7 +126,35 @@ def assert_expected_output(file, expected_output):
     return True
 
 
-def check_output_from_sim_telarray(file, expected_output):
+def assert_expected_simtel_metadata(file, expected_metadata):
+    """
+    Assert that expected metadata is present in the sim_telarray file.
+
+    Parameters
+    ----------
+    file: Path
+        Path to the sim_telarray file.
+    expected_metadata: dict
+        Expected metadata values.
+
+    """
+    global_meta, telescope_meta = read_sim_telarray_metadata(file)
+
+    for key, value in expected_metadata.items():
+        if key not in global_meta and key not in telescope_meta:
+            _logger.error(f"Metadata key {key} not found in sim_telarray file {file}")
+            return False
+        if key in global_meta and global_meta[key] != value:
+            _logger.error(
+                f"Metadata key {key} has value {global_meta[key]} instead of expected {value}"
+            )
+            return False
+        _logger.debug(f"Metadata key {key} matches expected value {value}")
+
+    return True
+
+
+def check_output_from_sim_telarray(file, file_test):
     """
     Check that the sim_telarray simulation result is reasonable and matches the expected output.
 
@@ -132,20 +162,34 @@ def check_output_from_sim_telarray(file, expected_output):
     ----------
     file: Path
         Path to the sim_telarray file.
-    expected_output: dict
-        Expected output values.
+    file_test: dict
+        File test description including expected output and metadata.
 
     Raises
     ------
     ValueError
         If the file is not a zstd compressed file.
     """
+    if "expected_output" not in file_test and "expected_simtel_metadata" not in file_test:
+        _logger.debug(f"No expected output or metadata provided, skipping checks {file_test}")
+        return True
+
     if file.suffix != ".zst":
         raise ValueError(
             f"Expected output file {file} is not a zstd compressed file "
             f"(i.e., a sim_telarray file)."
         )
 
-    return assert_n_showers_and_energy_range(file=file) and assert_expected_output(
-        file=file, expected_output=expected_output
-    )
+    assert_output = assert_metadata = True
+
+    if "expected_output" in file_test:
+        assert_output = assert_expected_output(
+            file=file, expected_output=file_test["expected_output"]
+        )
+
+    if "expected_simtel_metadata" in file_test:
+        assert_metadata = assert_expected_simtel_metadata(
+            file=file, expected_metadata=file_test["expected_simtel_metadata"]
+        )
+
+    return assert_n_showers_and_energy_range(file=file) and assert_output and assert_metadata

simtools/testing/validate_output.py

@@ -117,11 +117,7 @@ def _validate_output_path_and_file(config, integration_file_tests):
         except AssertionError as exc:
             raise AssertionError(f"Output file {output_file_path} does not exist. ") from exc
 
-        if "expected_output" in file_test:
-            assert assertions.check_output_from_sim_telarray(
-                output_file_path,
-                file_test["expected_output"],
-            )
+        assert assertions.check_output_from_sim_telarray(output_file_path, file_test)
 
 
 def _validate_model_parameter_json_file(config, model_parameter_validation, db_config):
@@ -139,7 +135,7 @@ def _validate_model_parameter_json_file(config, model_parameter_validation, db_c
 
     """
     _logger.info(f"Checking model parameter json file: {model_parameter_validation}")
-    db = db_handler.DatabaseHandler(mongo_db_config=db_config)
+    db = db_handler.DatabaseHandler(db_config=db_config)
 
     reference_parameter_name = model_parameter_validation.get("reference_parameter_name")
 
@@ -346,7 +342,7 @@ def _validate_simtel_cfg_files(config, simtel_cfg_file):
         f"Comparing simtel cfg files: {reference_file} and {test_file} "
         f"for model version {config['configuration']['model_version']}"
     )
-    return _compare_simtel_cfg_files(reference_file, test_file)
+    assert _compare_simtel_cfg_files(reference_file, test_file)
 
 
 def _compare_simtel_cfg_files(reference_file, test_file):
@@ -382,7 +378,7 @@ def _compare_simtel_cfg_files(reference_file, test_file):
         return False
 
     for ref_line, test_line in zip(reference_cfg, test_cfg):
-        if any(ignore in ref_line for ignore in ("config_release", "Label")):
+        if any(ignore in ref_line for ignore in ("config_release", "Label", "simtools_version")):
             continue
         if ref_line != test_line:
             _logger.error(

simtools/utils/value_conversion.py

@@ -170,16 +170,21 @@ def get_value_as_quantity(value, unit):
 
     Raises
     ------
-    u.UnitConversionError
+    ValueError
         If the value cannot be converted to the given unit.
     """
     if isinstance(value, u.Quantity):
         try:
             return value.to(unit)
-        except u.UnitConversionError:
-            _logger.error(f"Cannot convert {value.unit} to {unit}.")
-            raise
-    return value * unit
+        except u.UnitConversionError as exc:
+            raise ValueError(f"Cannot convert {value} with unit {value.unit} to {unit}.") from exc
+    elif not isinstance(value, int | float):
+        return value
+
+    if unit is None or unit == "null":
+        return value * u.dimensionless_unscaled
+
+    return value * u.Unit(unit)
 
 
 def _unit_as_string(unit):

simtools/version.py

@@ -4,6 +4,7 @@
 # which is adapted from https://github.com/astropy/astropy/blob/master/astropy/version.py
 # see https://github.com/astropy/astropy/pull/10774 for a discussion on why this needed.
 
+from packaging.specifiers import SpecifierSet
 from packaging.version import InvalidVersion, Version
 
 MAJOR_MINOR_PATCH = "major.minor.patch"
@@ -189,3 +190,26 @@ def compare_versions(version_string_1, version_string_2, level=MAJOR_MINOR_PATCH
         raise ValueError(f"Unknown level: {level}")
 
     return (ver1 > ver2) - (ver1 < ver2)
+
+
+def check_version_constraint(version_string, constraint):
+    """
+    Check if a version satisfies a constraint.
+
+    Parameters
+    ----------
+    version_string : str
+        The version string to check (e.g., "6.0.2").
+    constraint : str
+        The version constraint to check against (e.g., ">=6.0.0").
+
+    Returns
+    -------
+    bool
+        True if the version satisfies the constraint, False otherwise.
+    """
+    spec = SpecifierSet(constraint.strip(), prereleases=True)
+    ver = Version(version_string)
+    if ver in spec:
+        return True
+    return False

simtools/visualization/plot_pixels.py

@@ -44,7 +44,7 @@ def plot(config, output_file, db_config=None):
     None
         The function saves the plot to the specified output file.
     """
-    db = db_handler.DatabaseHandler(mongo_db_config=db_config)
+    db = db_handler.DatabaseHandler(db_config=db_config)
     db.export_model_file(
         parameter=config["parameter"],
         site=config["site"],

simtools/visualization/plot_psf.py

@@ -640,7 +640,7 @@ def create_psf_vs_offaxis_plot(tel_model, site_model, args_dict, best_pars, outp
     logger.info(f"Creating {psf_label_cm} vs off-axis angle plot with best parameters...")
 
     # Apply best parameters to telescope model
-    tel_model.change_multiple_parameters(**best_pars)
+    tel_model.overwrite_parameters(best_pars)
 
     # Create off-axis angle array
     max_offset = args_dict.get("max_offset", MAX_OFFSET_DEFAULT)

simtools/visualization/plot_tables.py

@@ -131,7 +131,7 @@ def _read_table_from_model_database(table_config, db_config):
     Table
         Astropy table
     """
-    db = db_handler.DatabaseHandler(mongo_db_config=db_config)
+    db = db_handler.DatabaseHandler(db_config=db_config)
     return db.export_model_file(
         parameter=table_config["parameter"],
         site=table_config["site"],