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

simtools/applications/plot_simtel_events.py

@@ -76,19 +76,18 @@ Examples
 
 """
 
-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.visualization.plot_simtel_events import PLOT_CHOICES, generate_and_save_plots
 
 
-def _parse(label: str):
+def _parse():
     """Parse command line configuration."""
     config = configurator.Configurator(
-        label=label,
+        label=get_application_label(__file__),
         description=(
             "Create diagnostic plots from sim_telarray files using simtools visualization."
         ),
@@ -178,17 +177,16 @@ def _parse(label: str):
 
 def main():
     """Generate plots from sim_telarray files."""
-    label = Path(__file__).stem
-    args, _db = _parse(label)
+    app_context = startup_application(_parse)
 
-    logger = logging.getLogger()
-    logger.setLevel(gen.get_log_level_from_user(args.get("log_level", "INFO")))
+    simtel_files = [
+        Path(p).expanduser() for p in gen.ensure_iterable(app_context.args["simtel_files"])
+    ]
+    plots = list(gen.ensure_iterable(app_context.args.get("plots")))
 
-    ioh = io_handler.IOHandler()
-    simtel_files = [Path(p).expanduser() for p in gen.ensure_iterable(args["simtel_files"])]
-    plots = list(gen.ensure_iterable(args.get("plots")))
-
-    generate_and_save_plots(simtel_files=simtel_files, plots=plots, args=args, ioh=ioh)
+    generate_and_save_plots(
+        simtel_files=simtel_files, plots=plots, args=app_context.args, ioh=app_context.io_handler
+    )
 
 
 if __name__ == "__main__":

simtools/applications/plot_tabular_data.py

@@ -23,37 +23,24 @@ Plot tabular data using a configuration file.
 
 """
 
-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.constants import PLOT_CONFIG_SCHEMA
 from simtools.data_model import schema
 from simtools.data_model.metadata_collector import MetadataCollector
-from simtools.io import ascii_handler, io_handler
+from simtools.io import ascii_handler
 from simtools.visualization import plot_tables
 
 
-def _parse(label, description, usage):
-    """
-    Parse command line configuration.
-
-    Parameters
-    ----------
-    label : str
-        Label describing the application.
-    description : str
-        Description of the application.
-    usage : str
-        Example on how to use the application.
-
-    Returns
-    -------
-    CommandLineParser
-        Command line parser object.
-    """
-    config = configurator.Configurator(label=label, description=description, usage=usage)
+def _parse():
+    """Parse command line configuration."""
+    config = configurator.Configurator(
+        label=get_application_label(__file__),
+        description="Plots tabular data.",
+        usage="""simtools-plot-tabular-data --plot_config config_file_name "
+                 --output_file output_file_name""",
+    )
 
     config.parser.add_argument(
         "--plot_config",
@@ -79,33 +66,25 @@ def _parse(label, description, usage):
 
 def main():
     """Plot tabular data."""
-    args_dict, db_config_ = _parse(
-        label=Path(__file__).stem,
-        description="Plots tabular data.",
-        usage="""simtools-plot-tabular-data --plot_config config_file_name "
-                 --output_file output_file_name""",
-    )
-    logger = logging.getLogger()
-    logger.setLevel(gen.get_log_level_from_user(args_dict.get("log_level", "INFO")))
-    io_handler_instance = io_handler.IOHandler()
+    app_context = startup_application(_parse)
 
     plot_config = gen.convert_keys_in_dict_to_lowercase(
         schema.validate_dict_using_schema(
-            ascii_handler.collect_data_from_file(args_dict["plot_config"]),
+            ascii_handler.collect_data_from_file(app_context.args["plot_config"]),
             PLOT_CONFIG_SCHEMA,
         )
     )
 
     plot_tables.plot(
         config=plot_config["plot"],
-        output_file=io_handler_instance.get_output_file(args_dict["output_file"]),
-        db_config=db_config_,
-        data_path=args_dict.get("table_data_path"),
+        output_file=app_context.io_handler.get_output_file(app_context.args["output_file"]),
+        db_config=app_context.db_config,
+        data_path=app_context.args.get("table_data_path"),
     )
 
     MetadataCollector.dump(
-        args_dict,
-        io_handler_instance.get_output_file(args_dict["output_file"]),
+        app_context.args,
+        app_context.io_handler.get_output_file(app_context.args["output_file"]),
         add_activity_name=True,
     )
 

simtools/applications/plot_tabular_data_for_model_parameter.py

@@ -46,19 +46,18 @@ Plot tabular data for all types defined in the schema file:
 
 """
 
-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.data_model.metadata_collector import MetadataCollector
-from simtools.io import io_handler
 from simtools.visualization import plot_tables
 
 
-def _parse(label, description):
+def _parse():
     """Parse command line configuration."""
-    config = configurator.Configurator(label=label, description=description)
+    config = configurator.Configurator(
+        label=get_application_label(__file__),
+        description="Plots tabular data for a model parameter.",
+    )
 
     config.parser.add_argument("--parameter", type=str, required=True, help="Parameter name.")
     config.parser.add_argument(
@@ -73,31 +72,25 @@ def _parse(label, description):
 
 def main():
     """Plot tabular data."""
-    args_dict, db_config = _parse(
-        label=Path(__file__).stem,
-        description="Plots tabular data for a model parameter.",
-    )
-    logger = logging.getLogger()
-    logger.setLevel(gen.get_log_level_from_user(args_dict.get("log_level", "INFO")))
-    io_handler_instance = io_handler.IOHandler()
+    app_context = startup_application(_parse)
 
     plot_configs, output_files = plot_tables.generate_plot_configurations(
-        parameter=args_dict["parameter"],
-        parameter_version=args_dict["parameter_version"],
-        site=args_dict["site"],
-        telescope=args_dict.get("telescope"),
-        output_path=io_handler_instance.get_output_directory(),
-        plot_type=args_dict["plot_type"],
-        db_config=db_config,
+        parameter=app_context.args["parameter"],
+        parameter_version=app_context.args["parameter_version"],
+        site=app_context.args["site"],
+        telescope=app_context.args.get("telescope"),
+        output_path=app_context.io_handler.get_output_directory(),
+        plot_type=app_context.args["plot_type"],
+        db_config=app_context.db_config,
     )
 
     for plot_config, output_file in zip(plot_configs, output_files):
         plot_tables.plot(
             config=plot_config,
             output_file=output_file,
-            db_config=db_config,
+            db_config=app_context.db_config,
         )
-        MetadataCollector.dump(args_dict, output_file=output_file, add_activity_name=True)
+        MetadataCollector.dump(app_context.args, output_file=output_file, add_activity_name=True)
 
 
 if __name__ == "__main__":

simtools/applications/print_version.py

@@ -6,55 +6,27 @@ The versions of simtools, the DB, sim_telarray, and CORSIKA are printed.
 
 """
 
-import logging
-from pathlib import Path
-
 from simtools import dependencies, version
+from simtools.application_control import get_application_label, startup_application
 from simtools.configuration import configurator
-from simtools.io import ascii_handler, io_handler
-from simtools.utils import general as gen
-
-
-def _parse(label, description, usage):
-    """
-    Parse command line configuration.
+from simtools.io import ascii_handler
 
-    No command line arguments are required for this application,
-    but the configurator is called to set up the DB connection and
-    the structure with _parse is kept from other applications for consistency.
-
-    Parameters
-    ----------
-    label : str
-        Label describing the application.
-    description : str
-        Description of the application.
-    usage : str
-        Example on how to use the application.
-
-    Returns
-    -------
-    CommandLineParser
-        Command line parser object.
-    """
-    config = configurator.Configurator(label=label, description=description, usage=usage)
 
+def _parse():
+    """Parse command line configuration."""
+    config = configurator.Configurator(
+        label=get_application_label(__file__),
+        description="Print the versions of simtools, the DB, sim_telarray and CORSIKA.",
+        usage="simtools-print-version",
+    )
     return config.initialize(db_config=True, output=True, require_command_line=False)
 
 
 def main():
     """Print the versions of the simtools software."""
-    label = Path(__file__).stem
-    args_dict, db_config = _parse(
-        label=label,
-        description="Print the versions of simtools, the DB, sim_telarray and CORSIKA.",
-        usage="simtools-print-version",
-    )
-    logger = logging.getLogger()
-    logger.setLevel(gen.get_log_level_from_user(args_dict["log_level"]))
-    io_handler_instance = io_handler.IOHandler()
+    app_context = startup_application(_parse)
 
-    version_string = dependencies.get_version_string(db_config)
+    version_string = dependencies.get_version_string(app_context.db_config)
     version_dict = {"simtools version": version.__version__}
 
     print()
@@ -68,11 +40,11 @@ def main():
         key, value = version_entry.split(": ", 1)
         version_dict[key] = value
 
-    if not args_dict.get("output_file_from_default", False):
+    if not app_context.args.get("output_file_from_default", False):
         ascii_handler.write_data_to_file(
             data=version_dict,
-            output_file=io_handler_instance.get_output_file(
-                args_dict.get("output_file", "simtools_version.json")
+            output_file=app_context.io_handler.get_output_file(
+                app_context.args.get("output_file", "simtools_version.json")
             ),
         )
 

simtools/applications/production_derive_corsika_limits.py

@@ -82,9 +82,7 @@ Derive limits for a given file for custom defined array layouts:
         --output_file corsika_simulation_limits_lookup.ecsv
 """
 
-import logging
-
-import simtools.utils.general as gen
+from simtools.application_control import get_application_label, startup_application
 from simtools.configuration import configurator
 from simtools.production_configuration.derive_corsika_limits import (
     generate_corsika_limits_grid,
@@ -94,7 +92,8 @@ from simtools.production_configuration.derive_corsika_limits import (
 def _parse():
     """Parse command line configuration."""
     config = configurator.Configurator(
-        description="Derive limits for energy, radial distance, and viewcone."
+        label=get_application_label(__file__),
+        description="Derive limits for energy, radial distance, and viewcone.",
     )
     config.parser.add_argument(
         "--event_data_file",
@@ -133,12 +132,9 @@ def _parse():
 
 def main():
     """Derive limits for energy, radial distance, and viewcone."""
-    args_dict, db_config = _parse()
-
-    logger = logging.getLogger()
-    logger.setLevel(gen.get_log_level_from_user(args_dict.get("log_level", "info")))
+    app_context = startup_application(_parse)
 
-    generate_corsika_limits_grid(args_dict, db_config)
+    generate_corsika_limits_grid(app_context.args, app_context.db_config)
 
 
 if __name__ == "__main__":

simtools/applications/production_derive_statistics.py

@@ -50,27 +50,21 @@ The output will be a file containing the grid points with the derived number of
 added.
 """
 
-import logging
-from pathlib import Path
-
+from simtools.application_control import get_application_label, startup_application
 from simtools.configuration import configurator
-from simtools.io import io_handler
 from simtools.production_configuration.derive_production_statistics_handler import (
     ProductionStatisticsHandler,
 )
-from simtools.utils import general as gen
-
 
-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)
+def _parse():
+    """Parse command line arguments."""
+    config = configurator.Configurator(
+        label=get_application_label(__file__),
+        description=(
+            "Evaluate statistical uncertainties from DL2 MC event files and interpolate results."
+        ),
+    )
 
     config.parser.add_argument(
         "--grid_points_production_file",
@@ -139,18 +133,11 @@ def _parse(label, description):
 
 def main():
     """Run the ProductionStatisticsHandler."""
-    label = Path(__file__).stem
+    app_context = startup_application(_parse)
 
-    args_dict, _ = _parse(
-        label,
-        "Evaluate statistical uncertainties from DL2 MC event files and interpolate results.",
+    manager = ProductionStatisticsHandler(
+        app_context.args, output_path=app_context.io_handler.get_output_directory()
     )
-    logger = logging.getLogger()
-    logger.setLevel(gen.get_log_level_from_user(args_dict["log_level"]))
-
-    _io_handler = io_handler.IOHandler()
-
-    manager = ProductionStatisticsHandler(args_dict, output_path=_io_handler.get_output_directory())
     manager.run()
 
 

simtools/applications/production_generate_grid.py

@@ -42,46 +42,24 @@ To generate a grid of simulation points, execute the script as follows:
         --telescope_ids 1
 """
 
-import logging
 from pathlib import Path
 
 from astropy.coordinates import EarthLocation
 from astropy.time import Time
 
+from simtools.application_control import get_application_label, startup_application
 from simtools.configuration import configurator
-from simtools.io import io_handler
 from simtools.io.ascii_handler import collect_data_from_file
 from simtools.model.site_model import SiteModel
 from simtools.production_configuration.generate_production_grid import GridGeneration
 
 
-def _parse(label, description):
-    """
-    Parse command line configuration.
-
-    Parameters
-    ----------
-    axes (str, required)
-        Path to a YAML or JSON file defining the axes of the grid.
-    coordinate_system (str, optional, default='zenith_azimuth')
-        The coordinate system for the grid generation ('zenith_azimuth' or 'ra_dec').
-    observing_time (str, optional, default=now)
-        Time of the observation (format: 'YYYY-MM-DD HH:MM:SS').
-    lookup_table (str, required)
-        Path to the lookup table for simulation limits. The table should contain
-        varying azimuth and/or zenith angles.
-    telescope_ids (list of int, optional)
-        List of telescope IDs as used in sim_telarray to filter the events.
-    output_file (str, optional, default='grid_output.json')
-        Output file for the generated grid points (default: 'grid_output.json').
-
-
-    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="Generate a grid of simulation points using flexible axes definitions.",
+    )
 
     config.parser.add_argument(
         "--axes",
@@ -148,23 +126,15 @@ def load_axes(file_path: str):
 
 def main():
     """Run the Grid Generation application."""
-    label = Path(__file__).stem
-    args_dict, db_config = _parse(
-        label,
-        "Generate a grid of simulation points using flexible axes definitions.",
-    )
-
-    _logger = logging.getLogger()
-    _logger.setLevel(logging.INFO)
+    app_context = startup_application(_parse)
 
-    output_path = io_handler.IOHandler().get_output_directory()
-    output_filepath = Path(output_path).joinpath(f"{args_dict['output_file']}")
+    output_filepath = app_context.io_handler.get_output_file(app_context.args["output_file"])
 
-    axes = load_axes(args_dict["axes"])
+    axes = load_axes(app_context.args["axes"])
     site_model = SiteModel(
-        mongo_db_config=db_config,
-        model_version=args_dict["model_version"],
-        site=args_dict["site"],
+        db_config=app_context.db_config,
+        model_version=app_context.args["model_version"],
+        site=app_context.args["site"],
     )
 
     ref_lat = site_model.get_parameter_value_with_unit("reference_point_latitude")
@@ -174,21 +144,23 @@ def main():
     observing_location = EarthLocation(lat=ref_lat, lon=ref_long, height=altitude)
 
     observing_time = (
-        Time(args_dict["observing_time"]) if args_dict.get("observing_time") else Time.now()
+        Time(app_context.args["observing_time"])
+        if app_context.args.get("observing_time")
+        else Time.now()
     )
 
     grid_gen = GridGeneration(
         axes=axes,
-        coordinate_system=args_dict["coordinate_system"],
+        coordinate_system=app_context.args["coordinate_system"],
         observing_location=observing_location,
         observing_time=observing_time,
-        lookup_table=args_dict["lookup_table"],
-        telescope_ids=args_dict["telescope_ids"],
+        lookup_table=app_context.args["lookup_table"],
+        telescope_ids=app_context.args["telescope_ids"],
     )
 
     grid_points = grid_gen.generate_grid()
 
-    if args_dict["coordinate_system"] == "ra_dec":
+    if app_context.args["coordinate_system"] == "ra_dec":
         grid_points = grid_gen.convert_coordinates(grid_points)
     grid_gen.serialize_grid_points(grid_points, output_file=output_filepath)
 

simtools/applications/production_merge_corsika_limits.py

@@ -77,22 +77,20 @@ Examples
           --output_file merged_limits.ecsv
 """
 
-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.data_model import data_reader
 from simtools.io import ascii_handler
 from simtools.production_configuration.merge_corsika_limits import CorsikaMergeLimits
 
-_logger = logging.getLogger(__name__)
-
 
 def _parse():
     """Parse command line configuration."""
     config = configurator.Configurator(
-        description="Merge CORSIKA limit tables and check grid completeness."
+        label=get_application_label(__file__),
+        description="Merge CORSIKA limit tables and check grid completeness.",
     )
     config.parser.add_argument(
         "--input_files",
@@ -142,29 +140,27 @@ def _parse():
 
 def main():
     """Merge CORSIKA limit tables and check grid completeness."""
-    args_dict, _ = _parse()
-    logger = logging.getLogger()
-    logger.setLevel(gen.get_log_level_from_user(args_dict.get("log_level", "info")))
+    app_context = startup_application(_parse)
 
     merger = CorsikaMergeLimits()
     grid_definition = (
-        ascii_handler.collect_data_from_file(args_dict["grid_definition"])
-        if args_dict.get("grid_definition")
+        ascii_handler.collect_data_from_file(app_context.args["grid_definition"])
+        if app_context.args.get("grid_definition")
         else None
     )
 
-    if args_dict.get("merged_table"):
+    if app_context.args.get("merged_table"):
         # Case 3: Check coverage on an existing merged table
-        merged_table_path = Path(args_dict["merged_table"]).expanduser()
+        merged_table_path = Path(app_context.args["merged_table"]).expanduser()
         merged_table = data_reader.read_table_from_file(merged_table_path)
         input_files = [merged_table_path]
-    elif args_dict.get("input_files") or args_dict.get("input_files_list"):
+    elif app_context.args.get("input_files") or app_context.args.get("input_files_list"):
         # Case 1 & 2: Merge files
         input_files = []
 
         # Process input_files argument
-        if args_dict.get("input_files"):
-            raw_paths = args_dict.get("input_files")
+        if app_context.args.get("input_files"):
+            raw_paths = app_context.args.get("input_files")
             if len(raw_paths) == 1 and Path(raw_paths[0]).expanduser().is_dir():
                 input_dir = Path(raw_paths[0]).expanduser()
                 input_files.extend(input_dir.glob("*.ecsv"))
@@ -172,8 +168,8 @@ def main():
                 input_files.extend(Path(f).expanduser() for f in raw_paths)
 
         # Process input_files_list argument
-        if args_dict.get("input_files_list"):
-            files_from_list = merger.read_file_list(args_dict["input_files_list"])
+        if app_context.args.get("input_files_list"):
+            files_from_list = merger.read_file_list(app_context.args["input_files_list"])
             input_files.extend(files_from_list)
 
         if not input_files:
@@ -188,15 +184,15 @@ def main():
 
     is_complete, grid_completeness = merger.check_grid_completeness(merged_table, grid_definition)
 
-    if args_dict.get("plot_grid_coverage"):
+    if app_context.args.get("plot_grid_coverage"):
         merger.plot_grid_coverage(merged_table, grid_definition)
 
-    if args_dict.get("plot_limits"):
+    if app_context.args.get("plot_limits"):
         merger.plot_limits(merged_table)
 
-    if not args_dict.get("merged_table"):
+    if not app_context.args.get("merged_table"):
         # Write output file only when merging
-        output_file = merger.output_dir / args_dict["output_file"]
+        output_file = merger.output_dir / app_context.args["output_file"]
         merger.write_merged_table(
             merged_table,
             output_file,

simtools/applications/run_application.py

@@ -62,33 +62,18 @@ step 2 and 3 (useful for debugging):
 
 """
 
-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.runners import simtools_runner
 
 
-def _parse(label, description, usage):
-    """
-    Parse command line configuration.
-
-    Parameters
-    ----------
-    label : str
-        Label describing the application.
-    description : str
-        Description of the application.
-    usage : str
-        Example on how to use the application.
-
-    Returns
-    -------
-    CommandLineParser
-        Command line parser object.
-    """
-    config = configurator.Configurator(label=label, description=description, usage=usage)
+def _parse():
+    """Parse command line configuration."""
+    config = configurator.Configurator(
+        label=get_application_label(__file__),
+        description="Run simtools applications using a configuration file.",
+        usage="simtools-run-application --config_file config_file_name",
+    )
 
     config.parser.add_argument(
         "--configuration_file",
@@ -112,16 +97,11 @@ def _parse(label, description, usage):
     return config.initialize(db_config=True)
 
 
-def main():  # noqa: D103
-    args_dict, db_config = _parse(
-        Path(__file__).stem,
-        description="Run simtools applications using a configuration file.",
-        usage="simtools-run-application --config_file config_file_name",
-    )
-    logger = logging.getLogger()
-    logger.setLevel(gen.get_log_level_from_user(args_dict["log_level"]))
+def main():
+    """Run several simtools applications using a configuration file."""
+    app_context = startup_application(_parse, setup_io_handler=False)
 
-    simtools_runner.run_applications(args_dict, db_config, logger)
+    simtools_runner.run_applications(app_context.args, app_context.db_config, app_context.logger)
 
 
 if __name__ == "__main__":