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

simtools/applications/submit_data_from_external.py

@@ -36,34 +36,19 @@ r"""
 
 """
 
-import logging
-from pathlib import Path
-
 import simtools.data_model.model_data_writer as writer
-import simtools.utils.general as gen
+from simtools.application_control import get_application_label, startup_application
 from simtools.configuration import configurator
 from simtools.data_model import validate_data
 from simtools.data_model.metadata_collector import MetadataCollector
 
 
-def _parse(label, description):
-    """
-    Parse command line configuration.
-
-    Parameters
-    ----------
-    label: str
-        Label describing application.
-    description: str
-        Description of application.
-
-    Returns
-    -------
-    CommandLineParser
-        Command line parser object
-
-    """
-    config = configurator.Configurator(label=label, description=description)
+def _parse():
+    """Parse command line configuration."""
+    config = configurator.Configurator(
+        label=get_application_label(__file__),
+        description="Submit and validate data (e.g., input data to tools, model parameters).",
+    )
 
     config.parser.add_argument(
         "--input_meta",
@@ -92,26 +77,25 @@ def _parse(label, description):
     return config.initialize(output=True)
 
 
-def main():  # noqa: D103
-    args_dict, _ = _parse(
-        label=Path(__file__).stem,
-        description="Submit and validate data (e.g., input data to tools, model parameters).",
-    )
+def main():
+    """Submit and validate data (e.g., input data to tools, model parameters)."""
+    app_context = startup_application(_parse)
 
-    logger = logging.getLogger()
-    logger.setLevel(gen.get_log_level_from_user(args_dict["log_level"]))
-
-    _metadata = None if args_dict.get("ignore_metadata") else MetadataCollector(args_dict)
+    _metadata = (
+        None if app_context.args.get("ignore_metadata") else MetadataCollector(app_context.args)
+    )
 
     data_validator = validate_data.DataValidator(
         schema_file=(
-            _metadata.get_data_model_schema_file_name() if _metadata else args_dict.get("schema")
+            _metadata.get_data_model_schema_file_name()
+            if _metadata
+            else app_context.args.get("schema")
         ),
-        data_file=args_dict["input"],
+        data_file=app_context.args["input"],
     )
 
     writer.ModelDataWriter.dump(
-        args_dict=args_dict,
+        args_dict=app_context.args,
         metadata=_metadata,
         product_data=data_validator.validate_and_transform(),
     )

simtools/applications/submit_model_parameter_from_external.py

@@ -38,32 +38,19 @@ r"""
 
 """
 
-import logging
 from pathlib import Path
 
 import simtools.data_model.model_data_writer as writer
-import simtools.utils.general as gen
+from simtools.application_control import get_application_label, startup_application
 from simtools.configuration import configurator
 
 
-def _parse(label, description):
-    """
-    Parse command line configuration.
-
-    Parameters
-    ----------
-    label: str
-        Label describing application.
-    description: str
-        Description of application.
-
-    Returns
-    -------
-    CommandLineParser
-        Command line parser object
-
-    """
-    config = configurator.Configurator(label=label, description=description)
+def _parse():
+    """Parse command line configuration."""
+    config = configurator.Configurator(
+        label=get_application_label(__file__),
+        description="Submit and validate a model parameter.",
+    )
 
     config.parser.add_argument(
         "--parameter", type=str, required=True, help="Parameter for simulation model"
@@ -98,31 +85,30 @@ def _parse(label, description):
     return config.initialize(output=True, db_config=True)
 
 
-def main():  # noqa: D103
-    args_dict, db_config = _parse(
-        label=Path(__file__).stem,
-        description="Submit and validate a model parameters).",
-    )
-
-    logger = logging.getLogger()
-    logger.setLevel(gen.get_log_level_from_user(args_dict["log_level"]))
+def main():
+    """Submit and validate a model parameter value and metadata."""
+    app_context = startup_application(_parse)
 
-    output_path = (
-        Path(args_dict["output_path"]) / args_dict["parameter"]
-        if args_dict.get("output_path")
-        else None
-    )
+    if app_context.args.get("output_path"):
+        output_path = app_context.io_handler.get_output_directory(
+            sub_dir=app_context.args.get("parameter")
+        )
+    else:
+        output_path = None
 
     writer.ModelDataWriter.dump_model_parameter(
-        parameter_name=args_dict["parameter"],
-        value=args_dict["value"],
-        instrument=args_dict["instrument"],
-        parameter_version=args_dict["parameter_version"],
-        output_file=Path(args_dict["parameter"] + "-" + args_dict["parameter_version"] + ".json"),
+        parameter_name=app_context.args["parameter"],
+        value=app_context.args["value"],
+        instrument=app_context.args["instrument"],
+        parameter_version=app_context.args["parameter_version"],
+        output_file=Path(
+            app_context.args["parameter"] + "-" + app_context.args["parameter_version"] + ".json"
+        ),
         output_path=output_path,
-        use_plain_output_path=args_dict.get("use_plain_output_path"),
-        metadata_input_dict=args_dict,
-        db_config=db_config if args_dict.get("check_parameter_version") else None,
+        metadata_input_dict=app_context.args,
+        db_config=app_context.db_config
+        if app_context.args.get("check_parameter_version")
+        else None,
     )
 
 

simtools/applications/validate_camera_efficiency.py

@@ -44,19 +44,18 @@ r"""
     The output is saved in simtools-output/validate_camera_efficiency.
 """
 
-import logging
 from pathlib import Path
 
 import simtools.data_model.model_data_writer as writer
-import simtools.utils.general as gen
+from simtools.application_control import get_application_label, startup_application
 from simtools.camera.camera_efficiency import CameraEfficiency
 from simtools.configuration import configurator
 
 
-def _parse(label):
+def _parse():
     """Parse command line configuration."""
     config = configurator.Configurator(
-        label=label,
+        label=get_application_label(__file__),
         description=(
             "Calculate the camera efficiency and NSB pixel rates. "
             "Plot the camera efficiency vs wavelength for Cherenkov and NSB light."
@@ -91,29 +90,26 @@ def _parse(label):
         action="store_true",
         required=False,
     )
-    _args_dict, _db_config = config.initialize(
+    args_dict, db_config = config.initialize(
         db_config=True,
         simulation_model=["telescope", "model_version", "parameter_version"],
         simulation_configuration={"corsika_configuration": ["zenith_angle", "azimuth_angle"]},
     )
-    if _args_dict["site"] is None or _args_dict["telescope"] is None:
+    if args_dict["site"] is None or args_dict["telescope"] is None:
         config.parser.print_help()
         print("\n\nSite and telescope must be provided\n\n")
         raise RuntimeError("Site and telescope must be provided")
-    return _args_dict, _db_config
+    return args_dict, db_config
 
 
-def main():  # noqa: D103
-    label = Path(__file__).stem
-    args_dict, db_config = _parse(label)
-
-    logger = logging.getLogger()
-    logger.setLevel(gen.get_log_level_from_user(args_dict["log_level"]))
+def main():
+    """Calculate the camera efficiency and NSB pixel rates."""
+    app_context = startup_application(_parse)
 
     ce = CameraEfficiency(
-        db_config=db_config,
-        label=args_dict.get("label", label),
-        config_data=args_dict,
+        db_config=app_context.db_config,
+        label=app_context.args.get("label"),
+        config_data=app_context.args,
     )
     ce.simulate()
     ce.analyze(force=True)
@@ -123,13 +119,18 @@ def main():  # noqa: D103
     writer.ModelDataWriter.dump_model_parameter(
         parameter_name="nsb_pixel_rate",
         value=ce.get_nsb_pixel_rate(
-            reference_conditions=args_dict.get("write_reference_nsb_rate_as_parameter", False)
+            reference_conditions=app_context.args.get(
+                "write_reference_nsb_rate_as_parameter", False
+            )
+        ),
+        instrument=app_context.args["telescope"],
+        parameter_version=app_context.args.get("parameter_version", "0.0.0"),
+        output_file=Path(
+            f"nsb_pixel_rate-{app_context.args.get('parameter_version', '0.0.0')}.json"
         ),
-        instrument=args_dict["telescope"],
-        parameter_version=args_dict.get("parameter_version", "0.0.0"),
-        output_file=Path(f"nsb_pixel_rate-{args_dict.get('parameter_version', '0.0.0')}.json"),
-        output_path=Path(args_dict["output_path"]) / args_dict["telescope"] / "nsb_pixel_rate",
-        use_plain_output_path=args_dict.get("use_plain_output_path"),
+        output_path=app_context.io_handler.get_output_directory()
+        / app_context.args["telescope"]
+        / "nsb_pixel_rate",
     )
 
 

simtools/applications/validate_camera_fov.py

@@ -47,19 +47,16 @@ r"""
 
 """
 
-import logging
-from pathlib import Path
-
-import simtools.utils.general as gen
+from simtools.application_control import get_application_label, startup_application
 from simtools.configuration import configurator
-from simtools.io import io_handler
 from simtools.model.telescope_model import TelescopeModel
 from simtools.visualization import plot_camera, visualize
 
 
 def _parse():
+    """Parse command line configuration."""
     config = configurator.Configurator(
-        label=Path(__file__).stem,
+        label=get_application_label(__file__),
         description=(
             "Calculate the camera FoV of the telescope requested. "
             "Plot the camera, as seen for an observer facing the camera."
@@ -86,52 +83,49 @@ def _parse():
     return config.initialize(db_config=True, simulation_model=["telescope", "model_version"])
 
 
-def main():  # noqa: D103
-    args_dict, db_config = _parse()
+def main():
+    """Validate camera field of view."""
+    app_context = startup_application(_parse)
 
     label = "validate_camera_fov"
 
-    logger = logging.getLogger()
-    logger.setLevel(gen.get_log_level_from_user(args_dict["log_level"]))
-
-    # Output directory to save files related directly to this app
-    _io_handler = io_handler.IOHandler()
-    output_dir = _io_handler.get_output_directory(label, sub_dir="application-plots")
-
     tel_model = TelescopeModel(
-        site=args_dict["site"],
-        telescope_name=args_dict["telescope"],
-        mongo_db_config=db_config,
-        model_version=args_dict["model_version"],
+        site=app_context.args["site"],
+        telescope_name=app_context.args["telescope"],
+        mongo_db_config=app_context.db_config,
+        model_version=app_context.args["model_version"],
         label=label,
     )
     tel_model.export_model_files()
 
-    print(f"\nValidating the camera FoV of {tel_model.name}\n")
+    app_context.logger.info(f"\nValidating the camera FoV of {tel_model.name}\n")
 
     focal_length = tel_model.get_telescope_effective_focal_length("cm")
     camera = tel_model.camera
 
     fov, r_edge_avg = camera.calc_fov()
 
-    print("\nEffective focal length = " + f"{focal_length:.3f} cm")
-    print(f"{tel_model.name} FoV = {fov:.3f} deg")
-    print(f"Avg. edge radius = {r_edge_avg:.3f} cm\n")
+    app_context.logger.info(f"\nEffective focal length = {focal_length:.3f} cm")
+    app_context.logger.info(f"{tel_model.name} FoV = {fov:.3f} deg")
+    app_context.logger.info(f"Avg. edge radius = {r_edge_avg:.3f} cm\n")
 
     # Now plot the camera as well
     try:
-        pixel_ids_to_print = int(args_dict["print_pixels_id"])
+        pixel_ids_to_print = int(app_context.args["print_pixels_id"])
         if pixel_ids_to_print == 0:
             pixel_ids_to_print = -1  # so not print the zero pixel
     except ValueError as exc:
-        if args_dict["print_pixels_id"].lower() == "all":
+        if app_context.args["print_pixels_id"].lower() == "all":
             pixel_ids_to_print = camera.get_number_of_pixels()
         else:
             raise ValueError(
-                f"The value provided to --print_pixels_id ({args_dict['print_pixels_id']}) "
+                f"The value provided to --print_pixels_id ({app_context.args['print_pixels_id']}) "
                 "should be an integer or All"
             ) from exc
-    fig = plot_camera.plot_pixel_layout(camera, args_dict["camera_in_sky_coor"], pixel_ids_to_print)
+    fig = plot_camera.plot_pixel_layout(
+        camera, app_context.args["camera_in_sky_coor"], pixel_ids_to_print
+    )
+    output_dir = app_context.io_handler.get_output_directory()
     plot_file_prefix = output_dir.joinpath(f"{label}_{tel_model.name}_pixel_layout")
     visualize.save_figure(fig, f"{plot_file_prefix!s}", log_title="camera")
 

simtools/applications/validate_cumulative_psf.py

@@ -69,25 +69,24 @@
 
 """
 
-import logging
 from collections import OrderedDict
-from pathlib import Path
 
 import astropy.units as u
 import matplotlib.pyplot as plt
 import numpy as np
 
 import simtools.utils.general as gen
+from simtools.application_control import get_application_label, startup_application
 from simtools.configuration import configurator
-from simtools.io import io_handler
 from simtools.model.model_utils import initialize_simulation_models
 from simtools.ray_tracing.ray_tracing import RayTracing
 from simtools.visualization import visualize
 
 
-def _parse(label):
+def _parse():
+    """Parse command line configuration."""
     config = configurator.Configurator(
-        label=label,
+        label=get_application_label(__file__),
         description=(
             "Calculate and plot the PSF and eff. mirror area as a function of off-axis angle "
             "of the telescope requested."
@@ -125,55 +124,47 @@ def load_data(datafile):
     return data
 
 
-def main():  # noqa: D103
-    label = Path(__file__).stem
-    args_dict, db_config = _parse(label)
+def main():
+    """Validate the cumulative PSF of a telescope model against data."""
+    app_context = startup_application(_parse)
 
-    logger = logging.getLogger()
-    logger.setLevel(gen.get_log_level_from_user(args_dict["log_level"]))
-
-    # Output directory to save files related directly to this app
-    _io_handler = io_handler.IOHandler()
-    output_dir = _io_handler.get_output_directory(label, sub_dir="application-plots")
-
-    tel_model, site_model = initialize_simulation_models(
-        label=label,
-        db_config=db_config,
-        site=args_dict["site"],
-        telescope_name=args_dict["telescope"],
-        model_version=args_dict["model_version"],
+    tel_model, site_model, _ = initialize_simulation_models(
+        label=app_context.args.get("label"),
+        db_config=app_context.db_config,
+        site=app_context.args["site"],
+        telescope_name=app_context.args["telescope"],
+        model_version=app_context.args["model_version"],
     )
 
-    if args_dict.get("telescope_model_file"):
-        tel_model.change_multiple_parameters_from_file(args_dict["telescope_model_file"])
+    if app_context.args.get("telescope_model_file"):
+        tel_model.change_multiple_parameters_from_file(app_context.args["telescope_model_file"])
 
     ray = RayTracing(
         telescope_model=tel_model,
         site_model=site_model,
-        simtel_path=args_dict["simtel_path"],
-        zenith_angle=args_dict["zenith"] * u.deg,
-        source_distance=args_dict["src_distance"] * u.km,
+        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=[0.0] * u.deg,
     )
 
-    ray.simulate(test=args_dict["test"], force=False)
+    ray.simulate(test=app_context.args["test"], force=False)
     ray.analyze(force=False)
 
     # Plotting cumulative PSF
     im = ray.images()[0]
 
-    print(f"d80 in cm = {im.get_psf()}")
+    app_context.logger.info(f"d80 in cm = {im.get_psf()}")
 
-    # Plotting cumulative PSF
-    # Measured cumulative PSF
+    # Plotting measured cumulative PSF
     data_to_plot = OrderedDict()
     radius = None
-    if args_dict.get("data", None):
-        data_file = gen.find_file(args_dict["data"], args_dict["model_path"])
+    if app_context.args.get("data", None):
+        data_file = gen.find_file(app_context.args["data"], app_context.args["model_path"])
         data_to_plot["measured"] = load_data(data_file)
         radius = data_to_plot["measured"]["Radius [cm]"]
 
-    # Simulated cumulative PSF
+    # Plotting simulated cumulative PSF
     if radius is not None:
         data_to_plot[r"sim$\_$telarray"] = im.get_cumulative_data(radius * u.cm)
     else:
@@ -182,8 +173,8 @@ def main():  # noqa: D103
     fig = visualize.plot_1d(data_to_plot)
     fig.gca().set_ylim(0, 1.05)
 
-    plot_file_name = label + "_" + tel_model.name + "_cumulative_PSF"
-    plot_file = output_dir.joinpath(plot_file_name)
+    plot_file_name = app_context.args.get("label") + "_" + tel_model.name + "_cumulative_PSF"
+    plot_file = app_context.io_handler.get_output_file(plot_file_name)
     visualize.save_figure(fig, plot_file)
 
     # Plotting image
@@ -193,8 +184,8 @@ def main():  # noqa: D103
     fig.gca().add_artist(circle)
     fig.gca().set_aspect("equal")
 
-    plot_file_name = label + "_" + tel_model.name + "_image"
-    plot_file = output_dir.joinpath(plot_file_name)
+    plot_file_name = app_context.args.get("label") + "_" + tel_model.name + "_image"
+    plot_file = app_context.io_handler.get_output_file(plot_file_name)
     visualize.save_figure(fig, plot_file)
 
 

simtools/applications/validate_file_using_schema.py

@@ -32,41 +32,31 @@ r"""
 
 """
 
-import logging
 import re
 from pathlib import Path
 
-import simtools.utils.general as gen
+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(label, description):
-    """
-    Parse command line configuration.
-
-    Parameters
-    ----------
-    label (str)
-        application label
-    description (str)
-        application description
-
-    Returns
-    -------
-    config (Configurator)
-        application configuration
-
-    """
-    config = configurator.Configurator(label=label, description=description)
-    group = config.parser.add_mutually_exclusive_group(required=True)
-    group.add_argument("--file_name", help="File to be validated")
-    group.add_argument(
+def _parse():
+    """Parse command line configuration."""
+    config = configurator.Configurator(
+        label=get_application_label(__file__),
+        description="Validate a file (metadata, schema, or data file) using a schema.",
+    )
+    config.parser.add_argument(
+        "--file_name",
+        help="File to be validated (full path or name pattern, e.g., '*.json')",
+        default="*.json",
+    )
+    config.parser.add_argument(
         "--file_directory",
         help=(
-            "Directory with json files to be validated. "
+            "Directory with files to be validated. "
             "If no schema file is provided, the assumption is that model "
             "parameters are validated and the schema files are taken from "
             f"{MODEL_PARAMETER_SCHEMA_PATH}."
@@ -84,6 +74,11 @@ def _parse(label, description):
         help="Require exact data type for validation",
         action="store_true",
     )
+    config.parser.add_argument(
+        "--ignore_software_version",
+        help="Ignore software version check.",
+        action="store_true",
+    )
     return config.initialize(paths=False)
 
 
@@ -115,11 +110,11 @@ def _get_schema_file_name(args_dict, data_dict=None):
     return schema_file
 
 
-def _get_json_file_list(file_directory=None, file_name=None):
-    """Return list of json files in a directory."""
+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("*.json"))
+        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:
@@ -137,9 +132,7 @@ def validate_dict_using_schema(args_dict, logger):
     the metadata section of the data dictionary.
 
     """
-    for file_name in _get_json_file_list(
-        args_dict.get("file_directory"), args_dict.get("file_name")
-    ):
+    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:
@@ -148,7 +141,9 @@ def validate_dict_using_schema(args_dict, logger):
         try:
             for data_dict in data:
                 schema.validate_dict_using_schema(
-                    data_dict, _get_schema_file_name(args_dict, data_dict)
+                    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
@@ -159,7 +154,7 @@ 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_json_file_list(args_dict.get("file_directory")):
+        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}")
@@ -192,21 +187,16 @@ def validate_metadata(args_dict, logger):
     logger.info(f"Successful validation of metadata {args_dict['file_name']}")
 
 
-def main():  # noqa: D103
-    label = Path(__file__).stem
-    args_dict, _ = _parse(
-        label, description="Validate a file (metadata, schema, or data file) using a schema."
-    )
-
-    logger = logging.getLogger()
-    logger.setLevel(gen.get_log_level_from_user(args_dict["log_level"]))
+def main():
+    """Validate a file or files in a directory using a schema."""
+    app_context = startup_application(_parse)
 
-    if args_dict["data_type"].lower() == "metadata":
-        validate_metadata(args_dict, logger)
-    elif args_dict["data_type"].lower() == "schema":
-        validate_dict_using_schema(args_dict, logger)
+    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)
     else:
-        validate_data_files(args_dict, logger)
+        validate_data_files(app_context.args, app_context.logger)
 
 
 if __name__ == "__main__":