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

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(label)
-    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"],
+        mongo_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__":

simtools/applications/simulate_flasher.py

@@ -1,140 +1,138 @@
 #!/usr/bin/python3
 
 r"""
-Simulate flasher devices using the light emission package.
+Simulate flasher devices used e.g. for camera flat fielding.
 
-Run the application in the command line.
+The flasher simulation allows for two different run modes:
+
+1. Direct injection of light into the camera (bypassing the telescope optics).
+2. Simulation of the full light path (using the light-emission package from sim_telarray).
+
+The direct injection mode uses a simplified model for the flasher light source. Both run modes
+provide events in sim_telarray format that can be processed by standard analysis steps or
+visualized using e.g. the 'simtools-plot-simtel-events' application.
 
 Example Usage
 -------------
 
-1. Simulate flashers for a telescope:
+1. Simulate flashers for a telescope (direct injection):
+
+    .. code-block:: console
+
+        simtools-simulate-flasher --run_mode direct_injection \
+        --light_source MSFx-FlashCam --model_version 6.0.0 \
+        --array_layout_name subsystem_msts --site South \
+        --run_number 3
+
+2. Simulate flashers for a telescope (detailed simulation):
 
     .. code-block:: console
 
-        simtools-simulate-flasher --telescope MSTN-04 --site North \
-        --flasher FLSN-01 --model_version 6.0.0
+        simtools-simulate-flasher --run_mode full_simulation \
+        --light_source MSFx-FlashCam --model_version 6.0.0 \
+        --telescope MSTS-04 --site South
 
 Command Line Arguments
 ----------------------
+run_mode (str, required)
+    Run mode, either "direct_injection" or "full_simulation".
 telescope (str, required)
     Telescope model name (e.g. LSTN-01, MSTN-04, SSTS-04, ...)
 site (str, required)
     Site name (North or South).
-flasher (str, required)
-    Flasher device in array, e.g., FLSN-01.
+light_source (str, required)
+    Calibration light source, e.g., MSFx-FlashCam
 number_of_events (int, optional):
     Number of events to simulate (default: 1).
 output_prefix (str, optional):
     Prefix for output files (default: empty).
 model_version (str, optional)
     Version of the simulation model.
-
-Example
--------
-
-Simulate flashers for MSTN-04:
-
-.. code-block:: console
-
-    simtools-simulate-flasher --telescope MSTN-04 --site North \
-    --flasher FLSN-01 --model_version 6.0.0
-
-Expected Output:
-    The simulation will run the light emission package for the flasher
-    devices and produce the output files.
+array_layout_name (str, optional)
+    Name of the array layout to use (required for direct injection mode).
+run_number (int, optional)
+    Run number to use (default: 1, required for direct injection mode).
+telescope (str, optional)
+    Telescope name (required for full simulation mode).
 """
 
-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.model.flasher_model import FlasherModel
-from simtools.model.model_utils import initialize_simulation_models
 from simtools.simtel.simulator_light_emission import SimulatorLightEmission
+from simtools.simulator import Simulator
 
 
-def _parse(label):
+def _parse():
     """Parse command line configuration."""
     config = configurator.Configurator(
-        label=label,
-        description=("Simulate flasher devices using the light emission package."),
+        label=get_application_label(__file__), description="Simulate flasher devices."
     )
     config.parser.add_argument(
-        "--flasher",
-        help="Flasher device in array associated with a specific telescope, i.e. FLSN-01",
+        "--run_mode",
+        help="Flasher simulation run mode",
         type=str,
+        choices=["direct_injection", "full_simulation"],
         required=True,
+        default="direct_injection",
     )
     config.parser.add_argument(
-        "--number_events",
-        help="Number of number_events to simulate (default: 1)",
+        "--light_source",
+        help="Flasher device associated with a specific telescope, i.e. MSFx-FlashCam",
+        type=str,
+        required=True,
+    )
+    config.parser.add_argument(
+        "--number_of_events",
+        help="Number of flasher events to simulate",
         type=int,
         default=1,
         required=False,
     )
     config.parser.add_argument(
         "--output_prefix",
-        help="Prefix for output files (default: empty)",
+        help="Prefix for output files",
         type=str,
         default=None,
         required=False,
     )
-
     return config.initialize(
         db_config=True,
-        simulation_model=["telescope", "model_version"],
-        require_command_line=True,
+        simulation_model=["site", "layout", "telescope", "model_version"],
+        simulation_configuration={
+            "corsika_configuration": ["run_number"],
+            "sim_telarray_configuration": ["all"],
+        },
     )
 
 
-def flasher_configs():
-    """Return default setup for flasher runs (no distances)."""
-    return {"light_source_setup": "layout"}
-
-
 def main():
-    """Run the application."""
-    label = Path(__file__).stem
-    logger = logging.getLogger(__name__)
-
-    args_dict, db_config = _parse(label)
-    logger.setLevel(gen.get_log_level_from_user(args_dict["log_level"]))
-
-    telescope_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"],
-    )
-
-    flasher_model = FlasherModel(
-        site=args_dict["site"],
-        flasher_device_model_name=args_dict["flasher"],
-        mongo_db_config=db_config,
-        model_version=args_dict["model_version"],
-        label=label,
+    """Simulate flasher devices."""
+    app_context = startup_application(_parse)
+
+    app_context.logger.info(
+        f"Flasher simulation for telescope {app_context.args['telescope']} "
+        f" with light source {app_context.args['light_source']} "
+        f" ({app_context.args['number_of_events']} events, "
+        f"run mode: {app_context.args['run_mode']})"
     )
 
-    flasher_cfg = flasher_configs()
-
-    sim_runner = SimulatorLightEmission(
-        telescope_model=telescope_model,
-        flasher_model=flasher_model,
-        site_model=site_model,
-        light_emission_config=args_dict,
-        light_source_setup=flasher_cfg["light_source_setup"],
-        simtel_path=args_dict["simtel_path"],
-        light_source_type="flasher",
-        label=args_dict["label"],
-        test=args_dict.get("test", False),
-    )
-
-    sim_runner.run_simulation()
-
-    logger.info("Flasher simulation completed. Use simtools-plot-simtel-number_events for plots.")
+    if app_context.args["run_mode"] == "full_simulation":
+        light_source = SimulatorLightEmission(
+            light_emission_config=app_context.args,
+            db_config=app_context.db_config,
+            label=app_context.args.get("label"),
+        )
+    elif app_context.args["run_mode"] == "direct_injection":
+        light_source = Simulator(
+            args_dict=app_context.args,
+            db_config=app_context.db_config,
+            label=app_context.args.get("label"),
+        )
+    else:
+        raise ValueError(f"Unsupported run_mode: {app_context.args['run_mode']}")
+
+    light_source.simulate()
+    app_context.logger.info("Flasher simulation completed.")
 
 
 if __name__ == "__main__":