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

simtools/simulator.py

@@ -1,5 +1,6 @@
 """Simulator class for managing simulations of showers and array of telescopes."""
 
+import gzip
 import logging
 import re
 import shutil
@@ -17,6 +18,7 @@ from simtools.model.array_model import ArrayModel
 from simtools.runners.corsika_runner import CorsikaRunner
 from simtools.runners.corsika_simtel_runner import CorsikaSimtelRunner
 from simtools.simtel.simulator_array import SimulatorArray
+from simtools.testing.sim_telarray_metadata import assert_sim_telarray_metadata
 
 __all__ = [
     "InvalidRunsToSimulateError",
@@ -74,7 +76,14 @@ class Simulator:
         self._submit_options = self.args_dict.get("submit_options", None)
         self._extra_commands = extra_commands
 
-        self.array_model = self._initialize_array_model(mongo_db_config)
+        self.sim_telarray_seeds = {
+            "seed": self.args_dict.get("sim_telarray_instrument_seeds"),
+            "random_instrument_instances": self.args_dict.get(
+                "sim_telarray_random_instrument_instances"
+            ),
+            "seed_file_name": "sim_telarray_instrument_seeds.txt",  # name only; no directory
+        }
+        self.array_models = self._initialize_array_models(mongo_db_config)
         self._simulation_runner = self._initialize_simulation_runner(mongo_db_config)
 
     @property
@@ -89,8 +98,8 @@ class Simulator:
 
         Parameters
         ----------
-        simulation_software: choices: [simtel, corsika, corsika_simtel]
-            implemented are sim_telarray and CORSIKA or corsika_simtel
+        simulation_software: choices: [sim_telarray, corsika, corsika_sim_telarray]
+            implemented are sim_telarray and CORSIKA or corsika_sim_telarray
             (running CORSIKA and piping it directly to sim_telarray)
 
         Raises
@@ -98,14 +107,14 @@ class Simulator:
         gen.InvalidConfigDataError
 
         """
-        if simulation_software not in ["simtel", "corsika", "corsika_simtel"]:
+        if simulation_software not in ["sim_telarray", "corsika", "corsika_sim_telarray"]:
             self._logger.error(f"Invalid simulation software: {simulation_software}")
             raise gen.InvalidConfigDataError
         self._simulation_software = simulation_software.lower()
 
-    def _initialize_array_model(self, mongo_db_config):
+    def _initialize_array_models(self, mongo_db_config):
         """
-        Initialize array simulation model.
+        Initialize array simulation models.
 
         Parameters
         ----------
@@ -114,16 +123,59 @@ class Simulator:
 
         Returns
         -------
-        ArrayModel
-            ArrayModel object.
-        """
-        return ArrayModel(
-            label=self.label,
-            site=self.args_dict.get("site"),
-            layout_name=self.args_dict.get("array_layout_name"),
-            mongo_db_config=mongo_db_config,
-            model_version=self.args_dict.get("model_version", None),
-        )
+        list
+            List of ArrayModel objects.
+        """
+        model_version = self.args_dict.get("model_version", [])
+        versions = [model_version] if not isinstance(model_version, list) else model_version
+
+        return [
+            ArrayModel(
+                label=self.label,
+                site=self.args_dict.get("site"),
+                layout_name=self.args_dict.get("array_layout_name"),
+                mongo_db_config=mongo_db_config,
+                model_version=version,
+                sim_telarray_seeds={
+                    "seed": self._get_seed_for_random_instrument_instances(
+                        self.sim_telarray_seeds["seed"], version
+                    ),
+                    "random_instrument_instances": self.sim_telarray_seeds[
+                        "random_instrument_instances"
+                    ],
+                    "seed_file_name": self.sim_telarray_seeds["seed_file_name"],
+                },
+            )
+            for version in versions
+        ]
+
+    def _get_seed_for_random_instrument_instances(self, seed, model_version):
+        """
+        Generate seed for random instances of the instrument.
+
+        Parameters
+        ----------
+        seed : str
+            Seed string given through configuration.
+        model_version: str
+            Model version.
+
+        Returns
+        -------
+        int
+            Seed for random instances of the instrument.
+        """
+        if seed:
+            return int(seed.split(",")[0].strip())
+
+        def semver_to_int(version: str):
+            major, minor, patch = map(int, version.split("."))
+            return major * 10000 + minor * 100 + patch
+
+        seed = semver_to_int(model_version) * 10000000
+        seed = seed + 1000000 if self.args_dict.get("site") != "North" else seed + 2000000
+        seed = seed + (int)(self.args_dict["zenith_angle"].value) * 1000
+        return seed + (int)(self.args_dict["azimuth_angle"].value)
 
     def _initialize_run_list(self):
         """
@@ -214,22 +266,33 @@ class Simulator:
         CorsikaRunner or SimulatorArray or CorsikaSimtelRunner
             Simulation runner object.
         """
-        corsika_config = CorsikaConfig(
-            array_model=self.array_model,
-            label=self.label,
-            args_dict=self.args_dict,
-            db_config=db_config,
-        )
+        corsika_configurations = []
+        for array_model in self.array_models:
+            corsika_configurations.append(
+                CorsikaConfig(
+                    array_model=array_model,
+                    label=self.label,
+                    args_dict=self.args_dict,
+                    db_config=db_config,
+                )
+            )
 
         runner_class = {
             "corsika": CorsikaRunner,
-            "simtel": SimulatorArray,
-            "corsika_simtel": CorsikaSimtelRunner,
+            "sim_telarray": SimulatorArray,
+            "corsika_sim_telarray": CorsikaSimtelRunner,
         }.get(self.simulation_software)
 
+        # In case of CorsikaSimtelRunner we should pass all corsika_configurations
+        # to the runner, since we define multiple configurations to run in a single job
+        # using multipipe. In other cases we pass only the first one (there's only one anyway).
         runner_args = {
             "label": self.label,
-            "corsika_config": corsika_config,
+            "corsika_config": (
+                corsika_configurations
+                if runner_class is CorsikaSimtelRunner
+                else corsika_configurations[0]
+            ),
             "simtel_path": self.args_dict.get("simtel_path"),
             "use_multipipe": runner_class is CorsikaSimtelRunner,
         }
@@ -237,7 +300,7 @@ class Simulator:
         if runner_class is not SimulatorArray:
             runner_args["keep_seeds"] = self.args_dict.get("corsika_test_seeds", False)
         if runner_class is not CorsikaRunner:
-            runner_args["sim_telarray_seeds"] = self.args_dict.get("sim_telarray_seeds")
+            runner_args["sim_telarray_seeds"] = self.sim_telarray_seeds
 
         return runner_class(**runner_args)
 
@@ -325,10 +388,10 @@ class Simulator:
         _runs_and_files = {}
         self._logger.debug(f"Getting runs and files to submit ({input_file_list})")
 
-        if self.simulation_software == "simtel":
+        if self.simulation_software == "sim_telarray":
             input_file_list = self._enforce_list_type(input_file_list)
             _runs_and_files = {self._guess_run_from_file(file): file for file in input_file_list}
-        elif self.simulation_software in ["corsika", "corsika_simtel"]:
+        elif self.simulation_software in ["corsika", "corsika_sim_telarray"]:
             _runs_and_files = dict.fromkeys(self._get_runs_to_simulate())
         if len(_runs_and_files) == 0:
             raise ValueError("No runs to submit.")
@@ -392,39 +455,66 @@ class Simulator:
 
         """
         keys = ["output", "sub_out", "log", "input", "hist", "corsika_log"]
-        defaults = dict.fromkeys(keys)
-        results = {key: defaults[key] for key in keys}
-        results["output"] = str(
-            self._simulation_runner.get_file_name(file_type="output", run_number=run_number)
-        )
-        results["sub_out"] = str(
-            self._simulation_runner.get_file_name(
-                file_type="sub_log", mode="out", run_number=run_number
-            )
-        )
+        results = {key: [] for key in keys}
 
-        if "simtel" in self.simulation_software:
-            results["log"] = str(
-                self._simulation_runner.get_file_name(
-                    file_type="log", simulation_software="simtel", run_number=run_number
-                )
-            )
-            results["input"] = str(file)
-            results["hist"] = str(
+        if "sim_telarray" in self.simulation_software:
+            results["input"].append(str(file))
+
+        results["sub_out"].append(
+            str(
                 self._simulation_runner.get_file_name(
-                    file_type="histogram", simulation_software="simtel", run_number=run_number
+                    file_type="sub_log",
+                    mode="out",
+                    run_number=run_number,
                 )
             )
+        )
 
-        if "corsika" in self.simulation_software:
-            results["corsika_log"] = str(
-                self._simulation_runner.get_file_name(
-                    file_type="corsika_log", simulation_software="corsika", run_number=run_number
+        for model_version_index, _ in enumerate(self.array_models):
+            results["output"].append(
+                str(
+                    self._simulation_runner.get_file_name(
+                        file_type="output",
+                        run_number=run_number,
+                        model_version_index=model_version_index,
+                    )
                 )
             )
+            if "sim_telarray" in self.simulation_software:
+                results["log"].append(
+                    str(
+                        self._simulation_runner.get_file_name(
+                            file_type="log",
+                            simulation_software="sim_telarray",
+                            run_number=run_number,
+                            model_version_index=model_version_index,
+                        )
+                    )
+                )
+                results["hist"].append(
+                    str(
+                        self._simulation_runner.get_file_name(
+                            file_type="histogram",
+                            simulation_software="sim_telarray",
+                            run_number=run_number,
+                            model_version_index=model_version_index,
+                        )
+                    )
+                )
+            if "corsika" in self.simulation_software:
+                results["corsika_log"].append(
+                    str(
+                        self._simulation_runner.get_file_name(
+                            file_type="corsika_log",
+                            simulation_software="corsika",
+                            run_number=run_number,
+                            model_version_index=model_version_index,
+                        )
+                    )
+                )
 
         for key in keys:
-            self._results[key].append(results[key])
+            self._results[key].extend(results[key])
 
     def get_file_list(self, file_type="output"):
         """
@@ -563,6 +653,8 @@ class Simulator:
         """
         Pack simulation output files for registering on the grid.
 
+        Creates separate tarballs for each model version's log files.
+
         Parameters
         ----------
         directory_for_grid_upload: str
@@ -576,7 +668,7 @@ class Simulator:
         log_files = self.get_file_list(file_type="log")
         corsika_log_files = self.get_file_list(file_type="corsika_log")
         histogram_files = self.get_file_list(file_type="hist")
-        tar_file_name = Path(log_files[0]).name.replace("log.gz", "log_hist.tar.gz")
+
         directory_for_grid_upload = (
             Path(directory_for_grid_upload)
             if directory_for_grid_upload
@@ -586,24 +678,96 @@ class Simulator:
         )
         directory_for_grid_upload.mkdir(parents=True, exist_ok=True)
 
-        tar_file_name = directory_for_grid_upload.joinpath(tar_file_name)
+        # If there are more than one model version,
+        # duplicate the corsika log file to have one for each model version with the "right name".
+        if len(self.array_models) > 1 and corsika_log_files:
+            self._copy_corsika_log_file_for_all_versions(corsika_log_files)
 
-        with tarfile.open(tar_file_name, "w:gz") as tar:
-            files_to_tar = (
-                (log_files[:1] if log_files else [])
-                + (histogram_files[:1] if histogram_files else [])
-                + (corsika_log_files[:1] if corsika_log_files else [])
-            )
-            for file_to_tar in files_to_tar:
-                tar.add(file_to_tar, arcname=Path(file_to_tar).name)
+        # Group files by model version
+        for model in self.array_models:
+            model_version = model.model_version
+
+            # Filter files for this model version
+            model_logs = [f for f in log_files if model_version in f]
+            model_hists = [f for f in histogram_files if model_version in f]
+            model_corsika_logs = [f for f in corsika_log_files if model_version in f]
 
-        for file_to_move in [*output_files]:
+            if model_logs:
+                tar_file_name = Path(model_logs[0]).name.replace("log.gz", "log_hist.tar.gz")
+                tar_file_path = directory_for_grid_upload.joinpath(tar_file_name)
+
+                with tarfile.open(tar_file_path, "w:gz") as tar:
+                    files_to_tar = model_logs + model_hists + model_corsika_logs
+                    for file_to_tar in files_to_tar:
+                        tar.add(file_to_tar, arcname=Path(file_to_tar).name)
+
+        for file_to_move in output_files:
             source_file = Path(file_to_move)
             destination_file = directory_for_grid_upload / source_file.name
             if destination_file.exists():
                 self._logger.warning(f"Overwriting existing file: {destination_file}")
-            # Note that this will overwrite previous files which exist in the directory
-            # It should be fine for normal production since each run is on a separate node
-            # so no files are expected there.
             shutil.move(source_file, destination_file)
+
         self._logger.info(f"Output files for the grid placed in {directory_for_grid_upload!s}")
+
+    def validate_metadata(self):
+        """Validate metadata in the sim_telarray output files."""
+        if "sim_telarray" not in self.simulation_software:
+            self._logger.info("No sim_telarray files to validate.")
+            return
+
+        for model in self.array_models:
+            files = self.get_file_list(file_type="output")
+            output_file = next((f for f in files if model.model_version in f), None)
+            if output_file:
+                self._logger.info(f"Validating metadata for {output_file}")
+                assert_sim_telarray_metadata(output_file, model)
+                self._logger.info(f"Metadata for sim_telarray file {output_file} is valid.")
+            else:
+                self._logger.warning(
+                    f"No sim_telarray file found for model version {model.model_version}: {files}"
+                )
+
+    def _copy_corsika_log_file_for_all_versions(self, corsika_log_files):
+        """
+        Create copies of the CORSIKA log file for each model version.
+
+        Adds a header comment to each copy explaining its relationship to the original.
+
+        Parameters
+        ----------
+        corsika_log_files: list
+            List containing the original CORSIKA log file path.
+
+        """
+        original_log = Path(corsika_log_files[0])
+        # Find which model version the original log belongs to
+        original_version = next(
+            model.model_version
+            for model in self.array_models
+            if re.search(
+                rf"(?<![0-9A-Za-z]){re.escape(model.model_version)}(?![0-9A-Za-z])",
+                original_log.name,
+            )
+        )
+
+        for model in self.array_models:
+            if model.model_version == original_version:
+                continue
+
+            new_log = original_log.parent / original_log.name.replace(
+                original_version, model.model_version
+            )
+
+            with gzip.open(new_log, "wt") as new_file:
+                new_file.write(
+                    f"###############################################################\n"
+                    f"Copy of CORSIKA log file from model version {original_version}.\n"
+                    f"Applicable also for {model.model_version} (same CORSIKA configuration,\n"
+                    f"different sim_telarray model versions in the same run).\n"
+                    f"###############################################################\n\n"
+                )
+                with gzip.open(original_log, "rt") as orig_file:
+                    shutil.copyfileobj(orig_file, new_file)
+
+            corsika_log_files.append(str(new_log))

simtools/testing/configuration.py

@@ -102,6 +102,11 @@ def configure(config, tmp_test_directory, request):
     """
     tmp_output_path = create_tmp_output_path(tmp_test_directory, config)
     model_version_requested = request.config.getoption("--model_version")
+    model_version_requested = (
+        model_version_requested.split(",") if model_version_requested else None
+    )
+    if isinstance(model_version_requested, list) and len(model_version_requested) == 1:
+        model_version_requested = model_version_requested[0]
 
     if "CONFIGURATION" in config:
         _skip_test_for_model_version(config, model_version_requested)

simtools/testing/helpers.py

@@ -33,3 +33,21 @@ def _new_testeff_version():
             return False
     except FileNotFoundError as exc:
         raise FileNotFoundError("The testeff executable could not be found.") from exc
+
+
+def skip_multiple_version_test(config, model_version):
+    """Skip a test which is not meant for multiple versions if multiple versions are given."""
+    message = "Skipping test not meant for multiple model versions."
+
+    if not isinstance(model_version, list):
+        return None
+
+    config_model_version = config.get("CONFIGURATION", {}).get("MODEL_VERSION", [])
+
+    if not isinstance(config_model_version, list):
+        config_model_version = [config_model_version]
+
+    if 1 < len(model_version) != len(config_model_version):
+        return message
+
+    return None

simtools/testing/sim_telarray_metadata.py

@@ -0,0 +1,212 @@
+"""Test consistency of sim_telarray metadata."""
+
+import logging
+
+import numpy as np
+
+from simtools.simtel.simtel_config_reader import SimtelConfigReader
+from simtools.simtel.simtel_config_writer import sim_telarray_random_seeds
+from simtools.simtel.simtel_io_file_info import get_corsika_run_number
+from simtools.simtel.simtel_io_metadata import (
+    get_sim_telarray_telescope_id,
+    read_sim_telarray_metadata,
+)
+
+_logger = logging.getLogger(__name__)
+
+
+def assert_sim_telarray_metadata(file, array_model):
+    """
+    Assert consistency of sim_telarray metadata with given array model.
+
+    Parameters
+    ----------
+    file: Path
+        Path to the sim_telarray file.
+    array_model: ArrayModel
+        Array model to compare with.
+    """
+    global_meta, telescope_meta = read_sim_telarray_metadata(file)
+    _logger.info(f"Found metadata in sim_telarray file for {len(telescope_meta)} telescopes")
+    site_parameter_mismatch = _assert_model_parameters(global_meta, array_model.site_model)
+    sim_telarray_seed_mismatch = _assert_sim_telarray_seed(
+        global_meta, array_model.sim_telarray_seeds, file
+    )
+    if sim_telarray_seed_mismatch:
+        site_parameter_mismatch.append(sim_telarray_seed_mismatch)
+
+    if len(telescope_meta) != len(array_model.telescope_model):
+        raise ValueError(
+            f"Number of telescopes in sim_telarray file ({len(telescope_meta)}) does not match "
+            f"number of telescopes in array model ({len(array_model.telescope_model)})"
+        )
+
+    for telescope_name in array_model.telescope_model.keys():
+        if not get_sim_telarray_telescope_id(telescope_name, file):
+            raise ValueError(f"Telescope {telescope_name} not found in sim_telarray file metadata")
+
+    telescope_parameter_mismatch = [
+        _assert_model_parameters(telescope_meta[i], model)
+        for i, model in enumerate(array_model.telescope_model.values(), start=1)
+    ]
+
+    # ensure printout of all mismatches, not only those found first
+    telescope_parameter_mismatch.append(site_parameter_mismatch)
+    if any(len(m) > 0 for m in telescope_parameter_mismatch):
+        mismatches = [m for m in telescope_parameter_mismatch if len(m) > 0]
+        raise ValueError(
+            f"Telescope or site model parameters do not match sim_telarray metadata: {mismatches}"
+        )
+
+
+def _assert_model_parameters(metadata, model):
+    """
+    Assert that model parameter values matches the values in the sim_telarray metadata.
+
+    Parameters
+    ----------
+    metadata: dict
+        Metadata dictionary.
+    model: SiteModel, TelescopeModel
+        Model to compare with.
+
+    Returns
+    -------
+    invalid_parameter_list: list
+        List of parameters that do not match.
+
+    """
+    config_reader = SimtelConfigReader()
+
+    invalid_parameter_list = []
+
+    for param in model.parameters:
+        sim_telarray_name = _sim_telarray_name_from_parameter_name(param)
+        if sim_telarray_name in metadata.keys():
+            parameter_type = model.parameters[param]["type"]
+            if parameter_type not in ("string", "dict", "boolean"):
+                value, _ = config_reader.extract_value_from_sim_telarray_column(
+                    [metadata[sim_telarray_name]], parameter_type
+                )
+            else:
+                value = metadata[sim_telarray_name]
+                value = (int)(value) if value.isnumeric() else value
+
+            if not is_equal(value, model.parameters[param]["value"], parameter_type):
+                invalid_parameter_list.append(
+                    f"Parameter {param} mismatch between sim_telarray file: {value}, "
+                    f"and model: {model.parameters[param]['value']}"
+                )
+
+    return invalid_parameter_list
+
+
+def _assert_sim_telarray_seed(metadata, sim_telarray_seeds, file=None):
+    """
+    Assert that sim_telarray seed matches the values in the sim_telarray metadata.
+
+    Regenerate seeds using the sim_telarray_random_seeds function and compare with the metadata.
+
+    Parameters
+    ----------
+    metadata: dict
+        Metadata dictionary.
+    sim_telarray_seeds: dict
+        Dictionary of sim_telarray seeds.
+    file : Path
+        Path to the sim_telarray file.
+
+    Returns
+    -------
+    invalid_parameter_list: list
+        Error message if sim_telarray seeds do not match.
+
+    """
+    if not sim_telarray_seeds or not metadata:
+        return None
+
+    if "instrument_seed" in metadata.keys() and "instrument_instances" in metadata.keys():
+        if str(metadata.get("instrument_seed")) != str(sim_telarray_seeds.get("seed")):
+            return (
+                "Parameter instrument_seed mismatch between sim_telarray file: "
+                f"{metadata['instrument_seed']}, and model: {sim_telarray_seeds.get('seed')}"
+            )
+        _logger.info(
+            f"sim_telarray_seed in sim_telarray file: {metadata['instrument_seed']}, "
+            f"and model: {sim_telarray_seeds.get('seed')}"
+        )
+        if file:
+            run_number_modified = get_corsika_run_number(file) - 1
+            test_seeds = sim_telarray_random_seeds(
+                int(metadata["instrument_seed"]), int(metadata["instrument_instances"])
+            )
+            # no +1 as in sim_telarray (as we count from 0)
+            seed_used = run_number_modified % int(metadata["instrument_instances"])
+            if str(metadata.get("rng_select_seed")) != str(test_seeds[seed_used]):
+                return (
+                    "Parameter rng_select_seed mismatch between sim_telarray file: "
+                    f"{metadata['rng_select_seed']}, and model: {test_seeds[seed_used]}"
+                )
+
+    return None
+
+
+def _sim_telarray_name_from_parameter_name(parameter_name):
+    """Return sim_telarray parameter name. Some specific fine tuning."""
+    # parameters like "reference_point_latitude"
+    sim_telarray_name = parameter_name.replace("reference_point_", "")
+
+    if sim_telarray_name == "altitude":
+        return "corsika_observation_level"
+    if sim_telarray_name == "array_triggers":
+        return None
+
+    return sim_telarray_name
+
+
+def is_equal(value1, value2, value_type):
+    """
+    Check if two values are equal based on their type.
+
+    The complexity of this function reflects the complexity of the sim_telarray
+    metadata output.
+
+    Parameters
+    ----------
+    value1: any
+        First value to compare.
+    value2: any
+        Second value to compare.
+    value_type: str
+        Type of the values ('string', 'dict', etc.).
+
+    Returns
+    -------
+    bool
+        True if the values are equal, False otherwise.
+    """
+    value1 = value1[0] if isinstance(value1, tuple) else value1
+    value2 = value2[0] if isinstance(value2, tuple) else value2
+    if value1 is None or value2 is None:
+        if value1 in ("none", None) and value2 in ("none", None):
+            return True
+    if value_type == "string":
+        return str(value1).strip() == str(value2).strip()
+    if value_type == "dict":
+        return value1 == value2
+    if value_type == "boolean":
+        return bool(value1) == bool(value2)
+    return _is_equal_floats_or_ints(value1, value2)
+
+
+def _is_equal_floats_or_ints(value1, value2):
+    """Check if floats and ints are equal."""
+    if isinstance(value1, np.ndarray | list) and isinstance(value2, np.ndarray | list):
+        return bool(np.allclose(np.array(value1), np.array(value2), rtol=1e-10))
+    if isinstance(value1, list) and isinstance(value2, float | int | np.integer | np.floating):
+        if all(x == value1[0] for x in value1):
+            return bool(np.isclose(float(value1[0]), float(value2), rtol=1e-10))
+    if isinstance(value2, list) and isinstance(value1, float | int | np.integer | np.floating):
+        if all(x == value2[0] for x in value2):
+            return bool(np.isclose(float(value1), float(value2[0]), rtol=1e-10))
+    return bool(np.isclose(float(value1), float(value2), rtol=1e-10))

simtools/testing/validate_output.py

@@ -64,11 +64,18 @@ def _validate_output_files(config, integration_test):
 
 def _test_simtel_cfg_files(config, integration_test, from_command_line, from_config_file):
     """Test simtel cfg files."""
-    test_simtel_cfg_file = integration_test.get("TEST_SIMTEL_CFG_FILES", {}).get(
-        from_command_line or from_config_file
-    )
-    if test_simtel_cfg_file:
-        _validate_simtel_cfg_files(config, test_simtel_cfg_file)
+    cfg_files = integration_test.get("TEST_SIMTEL_CFG_FILES", {})
+    if isinstance(from_command_line, list):
+        sources = from_command_line
+    elif isinstance(from_config_file, list):
+        sources = from_config_file
+    else:
+        sources = [from_command_line or from_config_file]
+    for version in sources:
+        cfg = cfg_files.get(version)
+        if cfg:
+            _validate_simtel_cfg_files(config, cfg)
+            break
 
 
 def _validate_reference_output_file(config, integration_test):