gammasimtools 0.6.1__py3-none-any.whl → 0.8.2__py3-none-any.whl

simtools/applications/plot_array_layout.py

@@ -1,74 +1,105 @@
 #!/usr/bin/python3
 
 """
-    Summary
-    -------
-    This application plots the layout array and saves into disk.
+Plot array elements (array layout).
 
-    It accepts as input the telescope list file, the name of the layout, a sequence of arguments
-    with the telescope files or a sequence of arguments with the layout names.
+Plot an array layout and save it to file (e.g., pdf). Layouts are defined in the database,
+or given as command line arguments (explicit listing or telescope list file). A list of input
+files is also accepted.
+Layouts can be plotted in ground or UTM coordinate systems.
 
-    A rotation angle in degrees can be passed in case the array should be rotated before plotting.
-    A sequence of arguments for the rotation angle is also permitted, in which case all of them
-    are plotted and saved separately.
+Listing of array elements follows this logic:
 
+* explicit listing: e.g., ``-array_element_list MSTN-01, MSTN05``
+* listing of types: e.g, ``-array_element_list MSTN`` plots all telescopes of type MSTN.
 
-    Command line arguments
-    ----------------------
-    figure_name (str, optional)
-        File name for the pdf output.
-    telescope_list (str, optional)
-        The telescopes file (.ecsv) with the array information.
-    array_layout_name (str, optional)
-        Name of the layout array (e.g., North-TestLayout, South-TestLayout, North-4LST, etc.).
-    rotate_angle (float, optional)
-        Angle to rotate the array before plotting (in degrees).
-    show_tel_label (bool, optional)
-        Shows the telescope labels in the plot.
-    verbosity (str, optional)
-        Log level to print.
+A rotation angle in degrees allows to rotate the array before plotting.
+The typical image formats (e.g., pdf, png, jpg) are allowed for the output figures.
+If no ``figure_name`` is given as output, layouts are plotted in pdf and png format.
 
-    Example
-    -------
-    .. code-block:: console
+Example of a layout plot:
+
+.. _plot_array_layout_plot:
+.. image:: images/plot_array_layout_example.png
+    :width: 49 %
+
+Command line arguments
+----------------------
+figure_name : str
+    File name for the output figure.
+array_layout_file : str
+    File (astropy table compatible) with a list of array elements.
+array_layout_name : str
+    Name of the layout array (e.g., test_layout, alpha, 4mst, etc.).
+array_element_list : list
+    List of array elements (e.g., telescopes) to plot (e.g., ``LSTN-01 LSTN-02 MSTN``).
+coordinate_system : str, optional
+    Coordinate system for the array layout (ground or utm).
+rotate_angle : float, optional
+    Angle to rotate the array before plotting (in degrees).
+show_labels : bool, optional
+    Shows the telescope labels in the plot.
+axes_range : float, optional
+    Range of the both axes in meters.
+marker_scaling : float, optional.
+    Scaling factor for plotting of array elements, optional.
+
+Examples
+--------
+Plot layout with the name "test_layout":
+
+.. code-block:: console
+
+    simtools-plot-layout-array --figure_name northern_array_alpha
+                               --array_layout_name test_layout
+
+
+Plot layout with 2 LSTs and all northern MSTs in UTM coordinates:
+
+.. code-block:: console
+
+    simtools-plot-layout-array --array_element_list LSTN-01 LSTN-02 MSTN
+                               --coordinate_system utm
+
+Plot layout from a file with the list of telescopes:
 
-        simtools-plot-layout-array --figure_name northern_array_alpha \
-        --array_layout_name North-TestLayout
+.. code-block:: console
 
+    simtools-plot-layout-array --array_element_list telescope_positions-test_layout.ecsv
 """
 
 import logging
 from pathlib import Path
 
+import matplotlib as mpl
 import matplotlib.pyplot as plt
 from astropy import units as u
 
 import simtools.utils.general as gen
 from simtools.configuration import configurator
-from simtools.data_model import data_reader
 from simtools.io_operations import io_handler
-from simtools.layout.array_layout import ArrayLayout
+from simtools.model.array_model import ArrayModel
+from simtools.utils import names
 from simtools.visualization.visualize import plot_array
 
 
 def _parse(label, description, usage):
     """
-    Parse command line configuration
+    Parse command line configuration.
 
     Parameters
     ----------
-    label: str
+    label : str
         Label describing the application.
-    description: str
+    description : str
         Description of the application.
-    usage: str
+    usage : str
         Example on how to use the application.
 
     Returns
     -------
     CommandLineParser
-        Command line parser object
-
+        Command line parser object.
     """
     config = configurator.Configurator(label=label, description=description, usage=usage)
 
@@ -81,110 +112,309 @@ def _parse(label, description, usage):
     )
     config.parser.add_argument(
         "--rotate_angle",
-        help="Angle to rotate the array before plotting (in degrees).",
+        help="Angle to rotate the array (in degrees).",
         type=str,
-        nargs="+",
         required=False,
         default=None,
     )
     config.parser.add_argument(
-        "--show_tel_label",
-        help="Shows the telescope labels in the plot.",
+        "--show_labels",
+        help="Plot array element labels.",
         action="store_true",
         required=False,
         default=False,
     )
-    input_group = config.parser.add_mutually_exclusive_group()
-    input_group.add_argument(
-        "--telescope_list",
-        help="ECSV file with the list of telescopes",
-        nargs="+",
-        type=str,
+    config.parser.add_argument(
+        "--marker_scaling",
+        help="Scaling factor for the markers.",
+        type=float,
         required=False,
-        default=None,
+        default=1.0,
     )
-    input_group.add_argument(
-        "--array_layout_name",
-        help="Name of the array layout.",
-        nargs="+",
+    config.parser.add_argument(
+        "--coordinate_system",
+        help="Coordinate system for the array layout.",
         type=str,
         required=False,
+        default="ground",
+        choices=["ground", "utm"],
+    )
+    config.parser.add_argument(
+        "--axes_range",
+        help="Range of the both axes in meters.",
+        type=float,
+        required=False,
         default=None,
     )
+    return config.initialize(db_config=True, simulation_model=["site", "layout", "layout_file"])
+
+
+def _get_site_from_telescope_list_name(telescope_list_file):
+    """
+    Get the site name from the telescope list file name.
+
+    Parameters
+    ----------
+    telescope_list_file : str
+        Telescope list file name.
+
+    Returns
+    -------
+    str
+        Site name.
+    """
+    for _site in names.site_names():
+        if _site in str(telescope_list_file):
+            return _site
+    return None
 
-    return config.initialize()
+
+def _get_list_of_plot_files(plot_file_name, output_dir):
+    """
+    Get list of output file names for plotting.
+
+    Parameters
+    ----------
+    plot_file_name : str
+        Name of the plot file.
+    output_dir : str
+        Output directory.
+
+    Returns
+    -------
+    list
+        List of output file names.
+
+    Raises
+    ------
+    NameError
+        If the file extension is not valid.
+    """
+    plot_file = output_dir.joinpath(plot_file_name)
+
+    if len(plot_file.suffix) == 0:
+        return [plot_file.with_suffix(f".{ext}") for ext in ["pdf", "png"]]
+
+    allowed_extensions = [".jpeg", ".jpg", ".png", ".tiff", ".ps", ".pdf", ".bmp"]
+    if plot_file.suffix in allowed_extensions:
+        return [plot_file]
+    msg = f"Extension in {plot_file} is not valid. Valid extensions are: {allowed_extensions}."
+    raise NameError(msg)
+
+
+def _get_plot_file_name(figure_name, layout_name, site, coordinate_system, rotate_angle):
+    """
+    Generate and return the file name for plots.
+
+    Parameters
+    ----------
+    figure_name : str
+        Figure name given through command line.
+    layout_name : str
+        Name of the layout.
+    site : str
+        Site name.
+    coordinate_system : str
+        Coordinate system for the array layout.
+    rotate_angle : float
+        Angle to rotate the array before plotting.
+
+    Returns
+    -------
+    str
+        Plot file name.
+    """
+    if figure_name is not None:
+        return figure_name
+
+    return (
+        f"array_layout_{layout_name}_{site}_{coordinate_system}_"
+        f"{round(rotate_angle.to(u.deg).value)!s}deg"
+    )
+
+
+def _layouts_from_array_layout_file(args_dict, db_config, rotate_angle):
+    """
+    Read array layout positions from file(s) and return a list of layouts.
+
+    Parameters
+    ----------
+    args_dict : dict
+        Dictionary with the command line arguments.
+    db_config : dict
+        Database configuration.
+    rotate_angle : float
+        Angle to rotate the array before plotting (in degrees).
+
+    Returns
+    -------
+    list
+        List of array layouts.
+    """
+    layouts = []
+    telescope_files = args_dict["array_layout_file"]
+    for one_file in telescope_files:
+        site = (
+            _get_site_from_telescope_list_name(one_file)
+            if args_dict["site"] is None
+            else args_dict["site"]
+        )
+        array_model = ArrayModel(
+            mongo_db_config=db_config,
+            model_version=args_dict["model_version"],
+            site=site,
+            array_elements=one_file,
+        )
+        layouts.append(
+            {
+                "array_elements": array_model.export_array_elements_as_table(),
+                "plot_file_name": _get_plot_file_name(
+                    args_dict["figure_name"],
+                    (Path(one_file).name).split(".")[0],
+                    site,
+                    args_dict["coordinate_system"],
+                    rotate_angle,
+                ),
+            }
+        )
+    return layouts
+
+
+def _layouts_from_list(args_dict, db_config, rotate_angle):
+    """
+    Read positions for a list of array elements from the database and return a list of layouts.
+
+    Parameters
+    ----------
+    args_dict : dict
+        Dictionary with the command line arguments.
+    db_config : dict
+        Database configuration.
+    rotate_angle : float
+        Angle to rotate the array before plotting (in degrees).
+
+    Returns
+    -------
+    list
+        List of array layouts.
+    """
+    site = (
+        names.get_site_from_array_element_name(args_dict["array_element_list"][0])
+        if args_dict["site"] is None
+        else args_dict["site"]
+    )
+    array_model = ArrayModel(
+        mongo_db_config=db_config,
+        model_version=args_dict["model_version"],
+        site=site,
+        array_elements=args_dict["array_element_list"],
+    )
+    return [
+        {
+            "array_elements": array_model.export_array_elements_as_table(
+                coordinate_system=args_dict["coordinate_system"]
+            ),
+            "plot_file_name": _get_plot_file_name(
+                args_dict["figure_name"],
+                "list",
+                site,
+                args_dict["coordinate_system"],
+                rotate_angle,
+            ),
+        }
+    ]
+
+
+def _layouts_from_db(args_dict, db_config, rotate_angle):
+    """
+    Read array elements and their positions from data base using the layout name.
+
+    Parameters
+    ----------
+    args_dict : dict
+        Dictionary with the command line arguments.
+    db_config : dict
+        Database configuration.
+    rotate_angle : float
+        Angle to rotate the array before plotting (in degrees).
+
+    Returns
+    -------
+    list
+        List of array layouts.
+    """
+    layouts = []
+    array_model = ArrayModel(
+        mongo_db_config=db_config,
+        model_version=args_dict["model_version"],
+        site=args_dict["site"],
+        layout_name=args_dict["array_layout_name"],
+    )
+    layouts.append(
+        {
+            "array_elements": array_model.export_array_elements_as_table(
+                coordinate_system=args_dict["coordinate_system"]
+            ),
+            "plot_file_name": _get_plot_file_name(
+                figure_name=args_dict["figure_name"],
+                layout_name=args_dict["array_layout_name"],
+                site=args_dict["site"],
+                coordinate_system=args_dict["coordinate_system"],
+                rotate_angle=rotate_angle,
+            ),
+        }
+    )
+    return layouts
 
 
 def main():
+    """Plot array layout application."""
     label = Path(__file__).stem
-    description = "Plots layout array."
-    usage = "python applications/plot_array_layout.py --array_layout_name test_layout"
-    args_dict, _ = _parse(label, description, usage)
+    args_dict, db_config = _parse(
+        label,
+        "Plots array layout.",
+        "python applications/plot_array_layout.py --array_layout_name test_layout",
+    )
+    logger = logging.getLogger()
+    logger.setLevel(gen.get_log_level_from_user(args_dict["log_level"]))
     io_handler_instance = io_handler.IOHandler()
 
-    if args_dict["rotate_angle"] is None:
-        rotate_angles = [0 * u.deg]
-    else:
-        rotate_angles = []
-        for one_angle in args_dict["rotate_angle"]:
-            rotate_angles.append(float(one_angle) * u.deg)
+    rotate_angle = (
+        0.0 * u.deg
+        if args_dict["rotate_angle"] is None
+        else float(args_dict["rotate_angle"]) * u.deg
+    )
+
+    layouts = []
+    if args_dict["array_layout_name"] is not None:
+        logger.info("Plotting array from layout array name.")
+        layouts = _layouts_from_db(args_dict, db_config, rotate_angle)
+    elif args_dict["array_layout_file"] is not None:
+        logger.info("Plotting array from telescope list file.")
+        layouts = _layouts_from_array_layout_file(args_dict, db_config, rotate_angle)
+    elif args_dict["array_element_list"] is not None:
+        logger.info("Plotting array from list of array elements.")
+        layouts = _layouts_from_list(args_dict, db_config, rotate_angle)
 
-    logger = logging.getLogger()
-    logger.setLevel(gen.get_log_level_from_user(args_dict["log_level"]))
+    mpl.use("Agg")
+    for layout in layouts:
+        fig_out = plot_array(
+            telescopes=layout["array_elements"],
+            rotate_angle=rotate_angle,
+            show_tel_label=args_dict["show_labels"],
+            axes_range=args_dict["axes_range"],
+            marker_scaling=args_dict["marker_scaling"],
+        )
+        _plot_files = _get_list_of_plot_files(
+            layout["plot_file_name"],
+            io_handler_instance.get_output_directory(label, sub_dir="application-plots"),
+        )
 
-    if args_dict["telescope_list"] is not None:
-        logger.info("Plotting array from telescope list file(s).")
-        telescope_file = args_dict["telescope_list"]
-
-    elif args_dict["array_layout_name"] is not None:
-        logger.info("Plotting array from layout array name(s).")
-        telescope_file = [
-            io_handler_instance.get_input_data_file(
-                "layout", f"telescope_positions-{one_array}.ecsv"
-            )
-            for one_array in args_dict["array_layout_name"]
-        ]
-
-    for one_file in telescope_file:
-        logger.debug(f"Processing: {one_file}.")
-        for one_angle in rotate_angles:
-            logger.debug(f"Processing: {one_angle}.")
-            if args_dict["figure_name"] is None:
-                plot_file_name = (
-                    f"plot_array_layout_{(Path(one_file).name).split('.')[0]}_"
-                    f"{str((round((one_angle.to(u.deg).value))))}deg"
-                )
-            else:
-                plot_file_name = args_dict["figure_name"]
-
-            telescope_table = data_reader.read_table_from_file(one_file)
-            telescopes_dict = ArrayLayout.include_radius_into_telescope_table(telescope_table)
-            fig_out = plot_array(
-                telescopes_dict, rotate_angle=one_angle, show_tel_label=args_dict["show_tel_label"]
-            )
-            output_dir = io_handler_instance.get_output_directory(
-                label, sub_dir="application-plots"
-            )
-            plot_file = output_dir.joinpath(plot_file_name)
-
-            allowed_extensions = ["jpeg", "jpg", "png", "tiff", "ps", "pdf", "bmp"]
-
-            splitted_plot_file_name = plot_file_name.split(".")
-            if len(splitted_plot_file_name) > 1:
-                if splitted_plot_file_name[-1] in allowed_extensions:
-                    logger.info(f"Saving figure as {plot_file}.")
-                    plt.savefig(plot_file, bbox_inches="tight", dpi=400)
-                else:
-                    msg = (
-                        f"Extension in {plot_file} is not valid. Valid extensions are:"
-                        f" {allowed_extensions}."
-                    )
-                    raise NameError(msg)
-            else:
-                for ext in ["pdf", "png"]:
-                    logger.info(f"Saving figure to {plot_file}.{ext}.")
-                    plt.savefig(f"{str(plot_file)}.{ext}", bbox_inches="tight", dpi=400)
-                fig_out.clf()
+        for file in _plot_files:
+            logger.info(f"Saving figure as {file}")
+            plt.savefig(file, bbox_inches="tight", dpi=400)
+        fig_out.clf()
+        plt.close()
 
 
 if __name__ == "__main__":

simtools/applications/production_generate_simulation_config.py

@@ -0,0 +1,158 @@
+#!/usr/bin/python3
+
+r"""
+Configure a simulation based on command-line arguments.
+
+This application configures and
+generates simulation parameters for a specific grid point in a statistical uncertainty
+evaluation setup.
+
+Command line arguments
+----------------------
+azimuth (float, required)
+    Azimuth angle in degrees.
+elevation (float, required)
+    Elevation angle in degrees.
+nsb (float, required)
+    Night sky background value.
+ctao_data_level (str, required)
+    The data level for the simulation (e.g., 'A', 'B', 'C').
+science_case (str, required)
+    The science case for the simulation.
+file_path (str, required)
+    Path to file with MC events at CTAO DL2 data level. Used for statistical uncertainty evaluation.
+file_type (str, required)
+    Type of the DL2 MC event file ('point-like' or 'cone').
+metrics (str, optional)
+    Path to a YAML file containing metrics for evaluation.
+site (str, required)
+    The observatory site (North or South).
+
+Example
+-------
+To run the simulation configuration, execute the script as follows:
+
+.. code-block:: console
+
+    simtools-production-generate-simulation-config --azimuth 60.0 --elevation 45.0 \
+        --nsb 0.3 --ctao_data_level "A" --science_case "high_precision" \
+        --file_path tests/resources/production_dl2_fits/dl2_mc_events_file.fits \
+        --file_type "point-like"    \
+        --metrics_file tests/resources/production_simulation_config_metrics.yaml --site North
+
+The output will show the configured simulation parameters.
+"""
+
+import json
+import logging
+from pathlib import Path
+
+import astropy.units as u
+
+import simtools.utils.general as gen
+from simtools.configuration import configurator
+from simtools.io_operations import io_handler
+from simtools.production_configuration.generate_simulation_config import (
+    SimulationConfig,
+)
+
+
+def _parse(label):
+    """Parse command-line arguments."""
+    config = configurator.Configurator(
+        label=label, description="Configure and run a simulation based on input parameters."
+    )
+    config.parser.add_argument(
+        "--azimuth", type=float, required=True, help="Azimuth angle in degrees."
+    )
+    config.parser.add_argument(
+        "--elevation", type=float, required=True, help="Elevation angle in degrees."
+    )
+    config.parser.add_argument(
+        "--nsb", type=float, required=True, help="Night sky background in units of 1/(sr*ns*cm**2)."
+    )
+    config.parser.add_argument(
+        "--ctao_data_level", type=str, required=True, help="Data level (e.g., 'A', 'B', 'C')."
+    )
+    config.parser.add_argument(
+        "--science_case", type=str, required=True, help="Science case for the simulation."
+    )
+    config.parser.add_argument(
+        "--file_path", type=str, required=True, help="Path to MC event file in DL2 format."
+    )
+    config.parser.add_argument(
+        "--file_type",
+        type=str,
+        required=True,
+        help="Type of the DL2 MC event file ('point-like' or 'cone').",
+    )
+    config.parser.add_argument(
+        "--metrics_file",
+        required=True,
+        type=str,
+        help="Path to YAML file containing metrics and required precision as values.",
+    )
+    config.parser.add_argument(
+        "--site",
+        type=str,
+        required=True,
+        help="Site location for the simulation (e.g., 'North', 'South').",
+    )
+    config.parser.add_argument(
+        "--output_file",
+        help="Name of the file to save the configured simulation parameters.",
+        type=str,
+        required=False,
+        default="configured_simulation_params.json",
+    )
+
+    return config.initialize(db_config=False)
+
+
+def main():
+    """Run the Simulation Config application."""
+    label = Path(__file__).stem
+    args_dict, _ = _parse(label)
+
+    logger = logging.getLogger()
+    logger.setLevel(gen.get_log_level_from_user(args_dict["log_level"]))
+    output_path = io_handler.IOHandler().get_output_directory(label)
+    output_filepath = Path(output_path).joinpath(f"{args_dict['output_file']}")
+
+    grid_point_config = {
+        "azimuth": args_dict["azimuth"],
+        "elevation": args_dict["elevation"],
+        "night_sky_background": args_dict["nsb"],
+    }
+
+    metrics = (
+        gen.collect_data_from_file(args_dict["metrics_file"]) if "metrics_file" in args_dict else {}
+    )
+
+    simulation_config = SimulationConfig(
+        grid_point=grid_point_config,
+        ctao_data_level=args_dict["ctao_data_level"],
+        science_case=args_dict["science_case"],
+        file_path=args_dict["file_path"],
+        file_type=args_dict["file_type"],
+        metrics=metrics,
+    )
+
+    simulation_params = simulation_config.configure_simulation()
+
+    serializable_config = {}
+
+    for key, value in simulation_params.items():
+        if isinstance(value, u.Quantity):
+            serializable_config[key] = f"{value.value} {value.unit}"
+        else:
+            serializable_config[key] = value
+
+    logger.info(f"Simulation configuration: {serializable_config}")
+    with open(output_filepath, "w", encoding="utf-8") as f:
+        json.dump(serializable_config, f, indent=4)
+    logger.info(f"Simulation configuration saved to: {output_filepath}")
+
+
+if __name__ == "__main__":
+    main()