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

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):

simtools/utils/general.py

@@ -133,28 +133,13 @@ def collect_data_from_http(url):
     try:
         with tempfile.NamedTemporaryFile(mode="w+t") as tmp_file:
             urllib.request.urlretrieve(url, tmp_file.name)
-            if url.endswith("yml") or url.endswith("yaml"):
-                try:
-                    data = yaml.safe_load(tmp_file)
-                except yaml.constructor.ConstructorError:
-                    data = _load_yaml_using_astropy(tmp_file)
-            elif url.endswith("json"):
-                data = json.load(tmp_file)
-            elif url.endswith("list"):
-                lines = tmp_file.readlines()
-                data = [line.strip() for line in lines]
-            else:
-                msg = f"File extension of {url} not supported (should be json or yaml)"
-                _logger.error(msg)
-                raise TypeError(msg)
+            data = _collect_data_from_different_file_types(
+                tmp_file, url, Path(url).suffix.lower(), None
+            )
     except TypeError as exc:
-        msg = "Invalid url {url}"
-        _logger.error(msg)
-        raise TypeError(msg) from exc
+        raise TypeError(f"Invalid url {url}") from exc
     except urllib.error.HTTPError as exc:
-        msg = f"Failed to download file from {url}"
-        _logger.error(msg)
-        raise FileNotFoundError(msg) from exc
+        raise FileNotFoundError(f"Failed to download file from {url}") from exc
 
     _logger.debug(f"Downloaded file from {url}")
     return data
@@ -182,20 +167,26 @@ def collect_data_from_file(file_name, yaml_document=None):
     suffix = Path(file_name).suffix.lower()
     try:
         with open(file_name, encoding="utf-8") as file:
-            if suffix == ".json":
-                return json.load(file)
-            if suffix == ".list":
-                return [line.strip() for line in file.readlines()]
-            if suffix in [".yml", ".yaml"]:
-                return _collect_data_from_yaml_file(file, file_name, yaml_document)
+            return _collect_data_from_different_file_types(file, file_name, suffix, yaml_document)
     # broad exception to catch all possible errors in reading the file
     except Exception as exc:  # pylint: disable=broad-except
         raise type(exc)(f"Failed to read file {file_name}: {exc}") from exc
     return None
 
 
+def _collect_data_from_different_file_types(file, file_name, suffix, yaml_document):
+    """Collect data from different file types."""
+    if suffix == ".json":
+        return json.load(file)
+    if suffix == ".list":
+        return [line.strip() for line in file.readlines()]
+    if suffix in [".yml", ".yaml"]:
+        return _collect_data_from_yaml_file(file, file_name, yaml_document)
+    raise TypeError(f"File type {suffix} not supported.")
+
+
 def _collect_data_from_yaml_file(file, file_name, yaml_document):
-    """Collect data from a yaml file."""
+    """Collect data from a yaml file (allow for multi-document yaml files)."""
     try:
         return yaml.safe_load(file)
     except yaml.constructor.ConstructorError:

simtools/utils/names.py

@@ -19,7 +19,11 @@ from pathlib import Path
 
 import yaml
 
-from simtools.constants import MODEL_PARAMETER_SCHEMA_PATH, SCHEMA_PATH
+from simtools.constants import (
+    MODEL_PARAMETER_DESCRIPTION_METASCHEMA,
+    MODEL_PARAMETER_SCHEMA_PATH,
+    SCHEMA_PATH,
+)
 
 _logger = logging.getLogger(__name__)
 
@@ -59,6 +63,21 @@ def array_elements():
         return yaml.safe_load(file)["data"]
 
 
+@cache
+def simulation_software():
+    """
+    Get simulation software names from the meta schema definition.
+
+    Returns
+    -------
+    list
+        List of simulation software names.
+    """
+    with open(Path(MODEL_PARAMETER_DESCRIPTION_METASCHEMA), encoding="utf-8") as file:
+        schema = yaml.safe_load(file)
+        return schema["definitions"]["SimulationSoftwareName"]["enum"]
+
+
 @cache
 def site_names():
     """
@@ -129,15 +148,18 @@ def _load_model_parameters():
     """
     Get model parameters properties from schema files.
 
+    For schema files including multiple schemas, only the first one is returned
+    (as this is the most recent definition).
+
     Returns
     -------
     dict
         Model parameters definitions for all model parameters.
     """
     _parameters = {}
-    for schema_file in list(Path(MODEL_PARAMETER_SCHEMA_PATH).rglob("*.yml")):
+    for schema_file in Path(MODEL_PARAMETER_SCHEMA_PATH).rglob("*.yml"):
         with open(schema_file, encoding="utf-8") as f:
-            data = yaml.safe_load(f)
+            data = next(yaml.safe_load_all(f))
             _parameters[data["name"]] = data
     return _parameters
 
@@ -512,7 +534,7 @@ def get_collection_name_from_parameter_name(parameter_name):
 
 def get_simulation_software_name_from_parameter_name(
     parameter_name,
-    simulation_software="sim_telarray",
+    software_name="sim_telarray",
     set_meta_parameter=False,
 ):
     """
@@ -541,7 +563,7 @@ def get_simulation_software_name_from_parameter_name(
 
     for software in _parameter.get("simulation_software", []):
         if (
-            software.get("name") == simulation_software
+            software.get("name") == software_name
             and software.get("set_meta_parameter", False) is set_meta_parameter
         ):
             return software.get("internal_parameter_name", parameter_name)

simtools/visualization/visualize.py

@@ -845,12 +845,12 @@ def finalize_plot(ax, patches, x_title, y_title, axes_range):
 
 def plot_simtel_ctapipe(filename, cleaning_args, distance, return_cleaned=False):
     """
-    Read in a simtel file and plots reconstructed photoelectrons via ctapipe.
+    Read in a sim_telarray file and plots reconstructed photoelectrons via ctapipe.
 
     Parameters
     ----------
     filename : str
-        Path to the simtel file.
+        Path to the sim_telarray file.
     cleaning_args : tuple, optional
         Cleaning parameters as (boundary_thresh, picture_thresh, min_number_picture_neighbors).
     distance : astropy Quantity, optional

simtools/applications/production_scale_events.py

@@ -1,185 +0,0 @@
-#!/usr/bin/python3
-
-r"""
-Application to run the StatisticalErrorEvaluator and interpolate results.
-
-This application evaluates statistical uncertainties from DL2 MC event files
-based on input parameters like zenith angles and offsets, and performs interpolation
-for a specified query point.
-
-Command line arguments
-----------------------
-base_path (str, required)
-    Path to the directory containing the DL2 MC event file for interpolation.
-zeniths (list of int, required)
-    List of zenith angles to consider.
-offsets (list of int, required)
-    List of offsets in degrees.
-query_point (list of float, required)
-    Query point for interpolation. The query point must contain exactly 5 values:
-        - Energy (TeV)
-        - Azimuth (degrees)
-        - Zenith (degrees)
-        - NSB (MHz)
-        - Offset (degrees)
-output_file (str, optional)
-    Output file to store the results. Default: 'interpolated_scaled_events.json'.
-metrics_file (str, optional)
-    Path to the metrics definition file. Default: 'production_simulation_config_metrics.yml'.
-file_name_template (str, optional)
-    Template for the file name. Default:
-    'prod6_LaPalma-{zenith}deg_gamma_cone.N.Am-4LSTs09MSTs_ID0_reduced.fits'.
-
-Example
--------
-To evaluate statistical uncertainties and perform interpolation, run the command line script:
-
-.. code-block:: console
-
-    simtools-production-scale-events --base_path tests/resources/production_dl2_fits/ \\
-        --zeniths 20 40 52 60 --offsets 0 --query_point 1 180 30 0 0 \\
-        --metrics_file "path/to/metrics.yaml" \\
-        --output_file "output.json"
-
-The output will display the scaled events for the specified query point and save
- the results to the specified output file.
-"""
-
-import itertools
-import json
-import logging
-from pathlib import Path
-
-import astropy.units as u
-import numpy as np
-
-import simtools.utils.general as gen
-from simtools.configuration import configurator
-from simtools.configuration.commandline_parser import CommandLineParser
-from simtools.io_operations import io_handler
-from simtools.production_configuration.calculate_statistical_errors_grid_point import (
-    StatisticalErrorEvaluator,
-)
-from simtools.production_configuration.interpolation_handler import InterpolationHandler
-
-
-def _parse(label, description):
-    """
-    Parse command line arguments for the statistical error evaluator application.
-
-    Returns
-    -------
-    argparse.Namespace
-        Parsed command line arguments.
-    """
-    config = configurator.Configurator(label=label, description=description)
-
-    config.parser.add_argument(
-        "--base_path",
-        type=str,
-        required=True,
-        help="Path to the DL2 MC event files for interpolation.",
-    )
-    config.parser.add_argument(
-        "--zeniths",
-        required=True,
-        nargs="+",
-        type=CommandLineParser.zenith_angle,
-        help="List of zenith angles.",
-    )
-    config.parser.add_argument(
-        "--offsets", required=True, nargs="+", type=float, help="List of offsets in degrees."
-    )
-
-    config.parser.add_argument(
-        "--query_point",
-        required=True,
-        nargs=5,
-        type=float,
-        help="Grid point for interpolation (energy, azimuth, zenith, NSB, offset).",
-    )
-    config.parser.add_argument(
-        "--output_file",
-        required=False,
-        type=str,
-        default="interpolated_scaled_events.json",
-        help="Output file to store the results. (default: 'interpolated_scaled_events.json').",
-    )
-    config.parser.add_argument(
-        "--metrics_file",
-        required=False,
-        type=str,
-        default="production_simulation_config_metrics.yml",
-        help="Metrics definition file. (default: production_simulation_config_metrics.yml)",
-    )
-    config.parser.add_argument(
-        "--file_name_template",
-        required=False,
-        type=str,
-        default=("prod6_LaPalma-{zenith}deg_gamma_cone.N.Am-4LSTs09MSTs_ID0_reduced.fits"),
-        help=(
-            "Template for the file name. (default: "
-            "'prod6_LaPalma-{zenith}deg_gamma_cone.N.Am-4LSTs09MSTs_ID0_reduced.fits')"
-        ),
-    )
-    return config.initialize(db_config=False)
-
-
-def main():
-    """Run the evaluator and interpolate."""
-    label = Path(__file__).stem
-    args_dict, _ = _parse(
-        label,
-        "Evaluate statistical uncertainties from DL2 MC event files and interpolate results.",
-    )
-    logger = logging.getLogger()
-    logger.setLevel(logging.INFO)
-    logger.info(f"args dict: {args_dict}")
-
-    output_path = io_handler.IOHandler().get_output_directory(label)
-    output_filepath = Path(output_path).joinpath(f"{args_dict['output_file']}")
-
-    evaluator_instances = []
-
-    metrics = gen.collect_data_from_file(args_dict["metrics_file"])
-
-    if args_dict["base_path"] and args_dict["zeniths"] and args_dict["offsets"]:
-        for zenith, offset in itertools.product(args_dict["zeniths"], args_dict["offsets"]):
-            file_name = args_dict["file_name_template"].format(zenith=int(zenith.value))
-            file_path = Path(args_dict["base_path"]).joinpath(file_name)
-
-            if not file_path.exists():
-                logger.warning(f"File not found: {file_path}. Skipping.")
-                continue
-
-            evaluator = StatisticalErrorEvaluator(
-                file_path,
-                file_type="Gamma-cone",
-                metrics=metrics,
-                grid_point=(1 * u.TeV, 180 * u.deg, zenith, 0, offset * u.deg),
-            )
-            evaluator.calculate_metrics()
-            evaluator_instances.append(evaluator)
-
-    else:
-        logger.warning("No files read")
-        logger.warning(f"Base Path: {args_dict['base_path']}")
-        logger.warning(f"Zeniths: {args_dict['zeniths']}")
-        logger.warning(f"Offsets: {args_dict['offsets']}")
-
-    interpolation_handler = InterpolationHandler(evaluator_instances, metrics=metrics)
-    query_points = np.array([args_dict["query_point"]])
-    scaled_events = interpolation_handler.interpolate(query_points)
-
-    output_data = {
-        "query_point": args_dict["query_point"],
-        "scaled_events": scaled_events.tolist(),
-    }
-    with open(output_filepath, "w", encoding="utf-8") as f:
-        json.dump(output_data, f, indent=4)
-    logger.info(f"Output saved to {output_filepath}")
-    logger.info(f"Scaled events for grid point {args_dict['query_point']}: {scaled_events}")
-
-
-if __name__ == "__main__":
-    main()