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

simtools/applications/validate_file_using_schema.py

@@ -3,26 +3,25 @@ r"""
     Validate a file or files in a directory using a schema.
 
     Input files can be metadata, schema, or data files in yaml, json, or ecsv format.
+    For model parameters, the schema files are taken from the simtools model parameter
+    schema directory by default.
 
     Command line arguments
     ----------------------
     file_name (str)
       input file to be validated
-    model_parameters_directory (str)
+    file_directory (str)
         directory with json files of model parameters to be validated
     schema (str)
       schema file (jsonschema format) used for validation
     data_type (str)
-        type of input data (allowed types: metadata, schema, data)
-
-    Raises
-    ------
-    FileNotFoundError
-      if file to be validated is not found
+        type of input data (allowed types: metadata, schema, data, model_parameter)
 
     Example
     -------
 
+    Validate metadata of a file:
+
     .. code-block:: console
 
         simtools-validate-file-using-schema \\
@@ -30,16 +29,29 @@ r"""
          --schema simtools/schemas/metadata.metaschema.yml \\
          --data_type metadata
 
-"""
+    Validate schema of a file:
+
+    .. code-block:: console
+
+        simtools-validate-file-using-schema \\
+         --file_name tests/resources/model_parameters/schema-0.3.0/num_gains-1.0.0.json \\
+         --schema src/simtools/schemas/model_parameter.metaschema.yml \\
+         --data_type schema
 
-import re
-from pathlib import Path
+    Validate all model parameter files in a directory:
+
+    .. code-block:: console
+
+        simtools-validate-file-using-schema \\
+         --file_directory tests/resources/model_parameters \\
+         --data_type model_parameter
+
+"""
 
 from simtools.application_control import get_application_label, startup_application
 from simtools.configuration import configurator
 from simtools.constants import MODEL_PARAMETER_SCHEMA_PATH
 from simtools.data_model import metadata_collector, schema, validate_data
-from simtools.io import ascii_handler
 
 
 def _parse():
@@ -62,7 +74,7 @@ def _parse():
             f"{MODEL_PARAMETER_SCHEMA_PATH}."
         ),
     )
-    config.parser.add_argument("--schema", help="Json schema file", required=False)
+    config.parser.add_argument("--schema", help="Schema file", required=False)
     config.parser.add_argument(
         "--data_type",
         help="Type of input data",
@@ -70,7 +82,7 @@ def _parse():
         default="data",
     )
     config.parser.add_argument(
-        "--require_exact_data_type",
+        "--check_exact_data_type",
         help="Require exact data type for validation",
         action="store_true",
     )
@@ -82,121 +94,35 @@ def _parse():
     return config.initialize(paths=False)
 
 
-def _get_schema_file_name(args_dict, data_dict=None):
-    """
-    Get schema file name from metadata, data dict, or from command line argument.
-
-    Parameters
-    ----------
-    args_dict (dict)
-        command line arguments
-    data_dict (dict)
-        dictionary with metaschema information
-
-    Returns
-    -------
-    schema_file: str
-        schema file name
-
-    """
-    schema_file = args_dict.get("schema")
-    if schema_file is None and data_dict is not None:
-        schema_file = data_dict.get("meta_schema_url")
-    if schema_file is None:
-        metadata = metadata_collector.MetadataCollector(
-            None, metadata_file_name=args_dict["file_name"]
-        )
-        schema_file = metadata.get_data_model_schema_file_name()
-    return schema_file
-
-
-def _get_file_list(file_directory=None, file_name="*.json"):
-    """Return list of files in a directory."""
-    file_list = []
-    if file_directory is not None:
-        file_list = list(Path(file_directory).rglob(file_name))
-        if not file_list:
-            raise FileNotFoundError(f"No files found in {file_directory}")
-    elif file_name is not None:
-        file_list = [file_name]
-
-    return file_list
-
-
-def validate_dict_using_schema(args_dict, logger):
-    """
-    Validate a schema file (or several files) given in yaml or json format.
-
-    This function validate all documents in a multi-document YAML file.
-    Schema is either given as command line argument, read from the meta_schema_url or from
-    the metadata section of the data dictionary.
-
-    """
-    for file_name in _get_file_list(args_dict.get("file_directory"), args_dict.get("file_name")):
-        try:
-            data = ascii_handler.collect_data_from_file(file_name=file_name)
-        except FileNotFoundError as exc:
-            raise FileNotFoundError(f"Error reading schema file from {file_name}") from exc
-        data = data if isinstance(data, list) else [data]
-        try:
-            for data_dict in data:
-                schema.validate_dict_using_schema(
-                    data_dict,
-                    _get_schema_file_name(args_dict, data_dict),
-                    ignore_software_version=args_dict.get("ignore_software_version", False),
-                )
-        except Exception as exc:
-            raise ValueError(f"Validation of file {file_name} failed") from exc
-        logger.info(f"Successful validation of file {file_name}")
-
-
-def validate_data_files(args_dict, logger):
-    """Validate data files."""
-    if args_dict.get("file_directory") is not None:
-        tmp_args_dict = {}
-        for file_name in _get_file_list(args_dict.get("file_directory")):
-            tmp_args_dict["file_name"] = file_name
-            parameter_name = re.sub(r"-\d+\.\d+\.\d+", "", file_name.stem)
-            schema_file = schema.get_model_parameter_schema_file(f"{parameter_name}")
-            tmp_args_dict["schema"] = schema_file
-            tmp_args_dict["data_type"] = "model_parameter"
-            tmp_args_dict["require_exact_data_type"] = args_dict["require_exact_data_type"]
-            validate_data_file(tmp_args_dict, logger)
-    else:
-        validate_data_file(args_dict, logger)
-
-
-def validate_data_file(args_dict, logger):
-    """Validate a data file (e.g., in ecsv, json, yaml format)."""
-    data_validator = validate_data.DataValidator(
-        schema_file=_get_schema_file_name(args_dict),
-        data_file=args_dict["file_name"],
-        check_exact_data_type=args_dict["require_exact_data_type"],
-    )
-    data_validator.validate_and_transform(
-        is_model_parameter=(args_dict["data_type"].lower() == "model_parameter")
-    )
-
-    logger.info(f"Successful validation of data file {args_dict['file_name']}")
-
-
-def validate_metadata(args_dict, logger):
-    """Validate metadata."""
-    # metadata_collector runs the metadata validation by default, no need to do anything else
-    metadata_collector.MetadataCollector(None, metadata_file_name=args_dict["file_name"])
-    logger.info(f"Successful validation of metadata {args_dict['file_name']}")
-
-
 def main():
     """Validate a file or files in a directory using a schema."""
     app_context = startup_application(_parse)
 
-    if app_context.args["data_type"].lower() == "metadata":
-        validate_metadata(app_context.args, app_context.logger)
-    elif app_context.args["data_type"].lower() == "schema":
-        validate_dict_using_schema(app_context.args, app_context.logger)
+    file_name = app_context.args.get("file_name")
+    file_directory = app_context.args.get("file_directory")
+    schema_file = app_context.args.get("schema")
+    data_type = app_context.args.get("data_type").lower()
+
+    if data_type == "metadata":
+        # metadata_collector runs the metadata validation by default, no need to do anything else
+        metadata_collector.MetadataCollector(None, metadata_file_name=file_name)
+        app_context.logger.info(f"Successful validation of metadata {file_name}")
+
+    elif data_type == "schema":
+        schema.validate_schema_from_files(
+            file_directory=file_directory,
+            file_name=file_name,
+            schema_file=schema_file,
+            ignore_software_version=app_context.args.get("ignore_software_version", False),
+        )
     else:
-        validate_data_files(app_context.args, app_context.logger)
+        validate_data.DataValidator.validate_data_files(
+            file_name=file_name,
+            file_directory=file_directory,
+            is_model_parameter=(data_type == "model_parameter"),
+            check_exact_data_type=app_context.args.get("check_exact_data_type", False),
+            schema_file=schema_file,
+        )
 
 
 if __name__ == "__main__":

simtools/applications/validate_optics.py

@@ -122,23 +122,11 @@ def main():
 
     tel_model, site_model, _ = initialize_simulation_models(
         label=Path(__file__).stem,
-        db_config=app_context.db_config,
         site=app_context.args["site"],
         telescope_name=app_context.args["telescope"],
         model_version=app_context.args["model_version"],
     )
 
-    ######################################################################
-    # This is here as an example how to change parameters when necessary.
-    ######################################################################
-    # pars_to_change = {
-    #     'mirror_focal_length': 1608.3,
-    #     'mirror_offset': -177.5,
-    #     'camera_body_diameter': 289.7,
-    #     'telescope_transmission': 1
-    # }
-    # tel_model.overwrite_parameters(pars_to_change)
-
     app_context.logger.info(
         f"\nValidating telescope optics with ray tracing simulations for {tel_model.name}\n"
     )
@@ -146,7 +134,6 @@ def main():
     ray = RayTracing(
         telescope_model=tel_model,
         site_model=site_model,
-        simtel_path=app_context.args["simtel_path"],
         zenith_angle=app_context.args["zenith"] * u.deg,
         source_distance=app_context.args["src_distance"] * u.km,
         off_axis_angle=np.linspace(

simtools/camera/camera_efficiency.py

@@ -22,25 +22,21 @@ class CameraEfficiency:
 
     Parameters
     ----------
-    db_config: dict
-        Configuration for the database.
     label: str
         Instance label, optional.
     config_data: dict.
         Dict containing the configurable parameters.
     """
 
-    def __init__(self, config_data, label, db_config):
+    def __init__(self, config_data, label):
         """Initialize the CameraEfficiency class."""
         self._logger = logging.getLogger(__name__)
 
-        self._simtel_path = config_data.get("simtel_path")
         self.label = label
 
         self.io_handler = io_handler.IOHandler()
         self.telescope_model, self.site_model, _ = initialize_simulation_models(
             label=self.label,
-            db_config=db_config,
             model_version=config_data["model_version"],
             site=config_data["site"],
             telescope_name=config_data["telescope"],
@@ -109,7 +105,6 @@ class CameraEfficiency:
         self.export_model_files()
 
         simtel = SimulatorCameraEfficiency(
-            simtel_path=self._simtel_path,
             telescope_model=self.telescope_model,
             site_model=self.site_model,
             zenith_angle=self.config["zenith_angle"],

simtools/camera/single_photon_electron_spectrum.py

@@ -12,6 +12,7 @@ from astropy.table import Table
 from scipy.optimize import curve_fit
 
 import simtools.data_model.model_data_writer as writer
+from simtools import settings
 from simtools.constants import MODEL_PARAMETER_SCHEMA_URL, SCHEMA_PATH
 from simtools.data_model import validate_data
 from simtools.data_model.metadata_collector import MetadataCollector
@@ -140,7 +141,7 @@ class SinglePhotonElectronSpectrum:
         )
 
         command = [
-            f"{self.args_dict['simtel_path']}/sim_telarray/bin/norm_spe",
+            f"{settings.config.sim_telarray_path}/bin/norm_spe",
             "-r",
             f"{self.args_dict['step_size']},{self.args_dict['max_amplitude']}",
         ]

simtools/configuration/commandline_parser.py

@@ -106,7 +106,7 @@ class CommandLineParser(argparse.ArgumentParser):
             required=False,
         )
         _job_group.add_argument(
-            "--simtel_path",
+            "--sim_telarray_path",
             help="path pointing to sim_telarray installation",
             type=Path,
             required=False,
@@ -160,6 +160,18 @@ class CommandLineParser(argparse.ArgumentParser):
         _job_group.add_argument(
             "--version", action="version", version=f"%(prog)s {simtools.version.__version__}"
         )
+        _job_group.add_argument(
+            "--build_info",
+            action=BuildInfoAction,
+            build_info=f"%(prog)s {simtools.version.__version__}",
+            help="show build information and exit",
+        )
+        _job_group.add_argument(
+            "--export_build_info",
+            help="export build information to file",
+            required=False,
+            type=str,
+        )
 
     def initialize_user_arguments(self):
         """Initialize user arguments."""
@@ -269,7 +281,7 @@ class CommandLineParser(argparse.ArgumentParser):
                 type=self.telescope,
             )
         if "layout" in model_options or "layout_file" in model_options:
-            _job_group = self._add_model_option_layout(
+            self._add_model_option_layout(
                 job_group=_job_group,
                 model_options=model_options,
                 # layout info is always required for layout related tasks with the exception
@@ -377,12 +389,6 @@ class CommandLineParser(argparse.ArgumentParser):
                 "required": True,
                 "default": 1,
             },
-            "number_of_runs": {
-                "help": "Number of runs to be simulated.",
-                "type": int,
-                "required": True,
-                "default": 1,
-            },
             "event_number_first_shower": {
                 "help": "Event number of first shower",
                 "type": int,
@@ -395,6 +401,14 @@ class CommandLineParser(argparse.ArgumentParser):
                 "required": False,
                 "default": True,
             },
+            "curved_atmosphere_min_zenith_angle": {
+                "help": (
+                    "Minimum zenith angle (deg) for using curved-atmosphere CORSIKA binaries. "
+                ),
+                "type": CommandLineParser.zenith_angle,
+                "required": False,
+                "default": 65 * u.deg,
+            },
         }
 
     @staticmethod
@@ -823,3 +837,24 @@ class CommandLineParser(argparse.ArgumentParser):
             raise ValueError("Input string does not contain an integer and a astropy quantity.")
 
         return (int(match.group(1)), u.Quantity(float(match.group(2)), match.group(3)))
+
+
+class BuildInfoAction(argparse.Action):
+    """Custom argparse action to display build information."""
+
+    def __init__(self, option_strings, dest=argparse.SUPPRESS, default=argparse.SUPPRESS, **kwargs):
+        """Initialize BuildInfoAction."""
+        self.build_info = kwargs.pop("build_info", "Build information")
+        kwargs.pop("nargs", None)
+        super().__init__(option_strings, dest=dest, default=default, nargs=0, **kwargs)
+
+    def __call__(self, parser, namespace, values, option_string=None):
+        """Display build information and exit."""
+        # for efficiency reason, allow import here
+        from simtools import dependencies  # pylint: disable=C0415
+
+        build_options = dependencies.get_build_options()
+        print(f"{self.build_info}")
+        for key, value in build_options.items():
+            print(f"{key}: {value}")
+        parser.exit()

simtools/configuration/configurator.py

@@ -2,12 +2,10 @@
 
 import argparse
 import logging
-import os
 import sys
 import uuid
 
 import astropy.units as u
-from dotenv import load_dotenv
 
 import simtools.configuration.commandline_parser as argparser
 from simtools.db.mongo_db import jsonschema_db_dict
@@ -305,19 +303,16 @@ class Configurator:
         Only parameters which are not already configured are changed (i.e., parameter is None).
 
         """
+        _all_env_dict = gen.load_environment_variables(
+            env_file=self.config.get("env_file", None), env_list=self.config.keys()
+        )
+
         _env_dict = {}
-        try:
-            load_dotenv(self.config["env_file"])
-        except KeyError:
-            pass
         for key, value in self.config.items():
-            # environmental variables for simtools should always start with SIMTOOLS_
-            env_variable_to_read = f"SIMTOOLS_{key.upper()}"
             if value is None:
-                env_value = os.environ.get(env_variable_to_read)
+                env_value = _all_env_dict.get(key)
                 if env_value is not None:
-                    env_value = env_value.split("#")[0].strip().replace('"', "").replace("'", "")
-                _env_dict[key] = env_value
+                    _env_dict[key] = env_value
 
         self._fill_from_config_dict(_env_dict)