gammasimtools 0.15.0__py3-none-any.whl → 0.17.0__py3-none-any.whl

simtools/visualization/visualize.py

@@ -8,24 +8,16 @@ from collections import OrderedDict
 from pathlib import Path
 
 import astropy.units as u
-import matplotlib.patches as mpatches
 import matplotlib.pyplot as plt
-from astropy.table import Column, QTable
+from astropy.table import QTable
 from cycler import cycler
 from matplotlib import gridspec
-from matplotlib.collections import PatchCollection
-
-from simtools.utils import geometry as transf
-from simtools.utils import names
-from simtools.visualization import legend_handlers as leg_h
 
 __all__ = [
     "get_colors",
     "get_lines",
     "get_markers",
-    "get_telescope_patch",
     "plot_1d",
-    "plot_array",
     "plot_hist_2d",
     "plot_table",
     "save_figure",
@@ -635,222 +627,14 @@ def plot_hist_2d(data, **kwargs):
     return fig
 
 
-@u.quantity_input(x=u.m, y=u.m, radius=u.m)
-def get_telescope_patch(name, x, y, radius):
-    """
-    Collect the patch of one telescope to be plotted by plot_array.
-
-    Parameters
-    ----------
-    name: str
-        Name of the telescope (type).
-    x: astropy.units.Quantity
-        x position of the telescope usually in meters.
-    y: astropy.units.Quantity
-        y position of the telescope usually in meters.
-    radius: astropy.units.Quantity
-        Radius of the telescope sphere usually in meters.
-
-    Returns
-    -------
-    patch
-        Instance of mpatches.Circle.
-    """
-    tel_obj = leg_h.TelescopeHandler()
-    valid_name = names.get_array_element_type_from_name(name)
-    fill_flag = False
-
-    x = x.to(u.m)
-    y = y.to(u.m)
-    radius = radius.to(u.m)
-
-    if valid_name.startswith("MST"):
-        fill_flag = True
-    if valid_name == "SCTS":
-        patch = mpatches.Rectangle(
-            ((x - radius / 2).value, (y - radius / 2).value),
-            width=radius.value,
-            height=radius.value,
-            fill=False,
-            color=tel_obj.colors_dict["SCTS"],
-        )
-    else:
-        patch = mpatches.Circle(
-            (x.value, y.value),
-            radius=radius.value,
-            fill=fill_flag,
-            color=tel_obj.colors_dict[valid_name],
-        )
-    return patch
-
-
-@u.quantity_input(rotate_angle=u.deg)
-def plot_array(
-    telescopes, rotate_angle=0, show_tel_label=False, axes_range=None, marker_scaling=1.0
-):
-    """
-    Plot the array of telescopes.
-
-    The x axis gives the easting direction and y axis gives the northing direction.
-    Note that in order to convert from the CORSIKA coordinate system to the 'conventional' system
-    of North/East, a 90 degree rotation is always applied.
-    Rotation of the array elements is possible through the 'rotate_angle' given either in degrees,
-    or in radians.
-    The direction of rotation of the array elements is counterclockwise.
-    The rotation does not change Telescope instance attributes.
-
-    Parameters
-    ----------
-    telescopes: astropy.table
-        Table with the telescope position and names. Note the orientation of the axes.
-    rotate_angle:
-        Angle to rotate the plot. For rotate_angle = 0 the resulting plot will have
-        the x-axis pointing towards the east, and the y-axis pointing towards the North.
-    show_tel_label: bool
-        If True it will print the label of the individual telescopes in the plot.
-        While it works well for the smaller arrays, it gets crowded for larger arrays.
-    axes_range : float
-        Axis range for both axes. Range is from -plot_range to plot_range.
-    maker_scaling : float
-        Scaling factor for marker size to be plotted.
-
-    Returns
-    -------
-    plt.figure
-        Instance of plt.figure with the array of telescopes plotted.
-    """
-    fig, ax = plt.subplots(1)
-    legend_objects = []
-    legend_labels = []
-    tel_counters = initialize_tel_counters()
-
-    pos_x_rotated, pos_y_rotated = get_rotated_positions(telescopes, rotate_angle)
-    telescopes.add_column(Column(pos_x_rotated, name="pos_x_rotated"))
-    telescopes.add_column(Column(pos_y_rotated, name="pos_y_rotated"))
-
-    fontsize, scale = get_plot_params(len(pos_x_rotated))
-    patches = create_patches(
-        telescopes, scale, marker_scaling, show_tel_label, ax, fontsize, tel_counters
-    )
-
-    update_legend(ax, tel_counters, legend_objects, legend_labels)
-    finalize_plot(ax, patches, x_title="Easting [m]", y_title="Northing [m]", axes_range=axes_range)
-
-    return fig
-
-
-def initialize_tel_counters():
-    return dict.fromkeys(names.get_list_of_array_element_types(), 0)
-
-
-def get_rotated_positions(telescopes, rotate_angle):
-    pos_x_rotated = pos_y_rotated = None
-    if "position_x" in telescopes.colnames and "position_y" in telescopes.colnames:
-        pos_x_rotated, pos_y_rotated = telescopes["position_x"], telescopes["position_y"]
-        rotate_angle = rotate_angle + 90.0 * u.deg
-    elif "utm_east" in telescopes.colnames and "utm_north" in telescopes.colnames:
-        pos_x_rotated, pos_y_rotated = telescopes["utm_east"], telescopes["utm_north"]
-    else:
-        raise ValueError(
-            "Telescopes table must contain either 'position_x'/'position_y'"
-            "or 'utm_east'/'utm_north' columns"
-        )
-    if rotate_angle != 0:
-        pos_x_rotated, pos_y_rotated = transf.rotate(pos_x_rotated, pos_y_rotated, rotate_angle)
-    return pos_x_rotated, pos_y_rotated
-
-
-def get_plot_params(position_length):
-    if position_length > 30:
-        return 4, 2
-    return 8, 1
-
-
-def create_patches(telescopes, scale, marker_scaling, show_tel_label, ax, fontsize, tel_counters):
-    patches = []
-    for tel_now in telescopes:
-        telescope_name = get_telescope_name(tel_now)
-        update_tel_counters(tel_counters, telescope_name)
-        sphere_radius = get_sphere_radius(tel_now)
-        i_tel_name = names.get_array_element_type_from_name(telescope_name)
-        patches.append(
-            get_telescope_patch(
-                i_tel_name,
-                tel_now["pos_x_rotated"],
-                tel_now["pos_y_rotated"],
-                scale * sphere_radius * marker_scaling,
-            )
-        )
-        if show_tel_label:
-            ax.text(
-                tel_now["pos_x_rotated"].value,
-                tel_now["pos_y_rotated"].value + scale * sphere_radius.value,
-                telescope_name,
-                horizontalalignment="center",
-                verticalalignment="bottom",
-                fontsize=fontsize,
-            )
-    return patches
-
-
-def get_telescope_name(tel_now):
-    """Get the telescope name from the table row."""
-    try:
-        return tel_now["telescope_name"]
-    except KeyError:
-        return tel_now["asset_code"] + "-" + tel_now["sequence_number"]
-
-
-def update_tel_counters(tel_counters, telescope_name):
-    """Update the counter for the given telescope type."""
-    for tel_type in tel_counters:
-        if tel_type in telescope_name:
-            tel_counters[tel_type] += 1
-
-
-def get_sphere_radius(tel_now):
-    """Get the sphere radius of the telescope."""
-    return 1.0 * u.m if "sphere_radius" not in tel_now.colnames else tel_now["sphere_radius"]
-
-
-def update_legend(ax, tel_counters, legend_objects, legend_labels):
-    """Update the legend with the telescope counts."""
-    for one_telescope in names.get_list_of_array_element_types():
-        if tel_counters[one_telescope] > 0:
-            legend_objects.append(leg_h.all_telescope_objects[one_telescope]())
-            legend_labels.append(f"{one_telescope} ({tel_counters[one_telescope]})")
-    legend_handler_map = {k: v() for k, v in leg_h.legend_handler_map.items()}
-    ax.legend(
-        legend_objects,
-        legend_labels,
-        handler_map=legend_handler_map,
-        prop={"size": 11},
-        loc="best",
-    )
-
-
-def finalize_plot(ax, patches, x_title, y_title, axes_range):
-    """Finalize the plot by adding titles, setting limits, and adding patches."""
-    ax.add_collection(PatchCollection(patches, match_original=True))
-    ax.set_xlabel(x_title, fontsize=12, labelpad=0)
-    ax.set_ylabel(y_title, fontsize=12, labelpad=0)
-    ax.tick_params(axis="both", which="major", labelsize=8)
-    ax.set_axisbelow(True)
-    ax.axis("square")
-    if axes_range is not None:
-        ax.set_xlim(-axes_range, axes_range)
-        ax.set_ylim(-axes_range, axes_range)
-    plt.tight_layout()
-
-
 def plot_simtel_ctapipe(filename, cleaning_args, distance, return_cleaned=False):
     """
-    Read in a simtel file and plots reconstructed photoelectrons via ctapipe.
+    Read in a sim_telarray file and plots reconstructed photoelectrons via ctapipe.
 
     Parameters
     ----------
     filename : str
-        Path to the simtel file.
+        Path to the sim_telarray file.
     cleaning_args : tuple, optional
         Cleaning parameters as (boundary_thresh, picture_thresh, min_number_picture_neighbors).
     distance : astropy Quantity, optional
@@ -942,7 +726,7 @@ def plot_simtel_ctapipe(filename, cleaning_args, distance, return_cleaned=False)
     return fig
 
 
-def save_figure(fig, output_file, figure_format=None, log_title=""):
+def save_figure(fig, output_file, figure_format=None, log_title="", dpi="figure"):
     """
     Save figure to output file(s).
 
@@ -960,7 +744,7 @@ def save_figure(fig, output_file, figure_format=None, log_title=""):
     figure_format = figure_format or ["pdf", "png"]
     for fmt in figure_format:
         _file = Path(output_file).with_suffix(f".{fmt}")
-        fig.savefig(_file, format=fmt, bbox_inches="tight")
+        fig.savefig(_file, format=fmt, bbox_inches="tight", dpi=dpi)
         logging.info(f"Saved plot {log_title} to {_file}")
 
     fig.clf()

simtools/applications/production_generate_simulation_config.py

@@ -1,162 +0,0 @@
-#!/usr/bin/python3
-
-r"""
-Derive simulation configuration parameters for a simulation production.
-
-Derived simulation configuration parameters include:
-
-* energy range
-* shower core scatter radius
-* view cone radius
-* total number of events to be simulated
-
-Configuration parameters depend on characteristics of the observations, especially elevation,
-azimuth, and night sky background.
-
-The configuration parameters are derived according to the required precision. The metrics are:
-
-* statistical uncertainty on the determination of the effective area as function of primary energy
-* fraction of lost events to the selected core scatter and view cone radius (to be implemented)
-* statistical uncertainty of the energy migration matrix as function of primary energy
-    (to be implemented)
-
-Command line arguments
-----------------------
-azimuth (float, required)
-        Azimuth angle in degrees.
-elevation (float, required)
-        Elevation angle in degrees.
-nsb (float, required)
-        Night sky background value.
-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, required)
-        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 --file_path tests/resources/production_dl2_fits/dl2_mc_events_file.fits \
-                --file_type "point-like"    \
-                --metrics_file tests/resources/production_simulation_config_metrics.yml --site North
-
-The output will show the derived 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.data_model import schema
-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="Derive simulation configuration parameters for a simulation production.",
-    )
-    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(
-        "--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"])
-    schema.validate_dict_using_schema(
-        data=metrics, schema_file="production_configuration_metrics.schema.yml"
-    )
-
-    simulation_config = SimulationConfig(
-        grid_point=grid_point_config,
-        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()

simtools/applications/production_scale_events.py

@@ -1,185 +0,0 @@
-#!/usr/bin/python3
-
-r"""
-Application to run the StatisticalErrorEvaluator and interpolate results.
-
-This application evaluates statistical uncertainties from DL2 MC event files
-based on input parameters like zenith angles and offsets, and performs interpolation
-for a specified query point.
-
-Command line arguments
-----------------------
-base_path (str, required)
-    Path to the directory containing the DL2 MC event file for interpolation.
-zeniths (list of int, required)
-    List of zenith angles to consider.
-offsets (list of int, required)
-    List of offsets in degrees.
-query_point (list of float, required)
-    Query point for interpolation. The query point must contain exactly 5 values:
-        - Energy (TeV)
-        - Azimuth (degrees)
-        - Zenith (degrees)
-        - NSB (MHz)
-        - Offset (degrees)
-output_file (str, optional)
-    Output file to store the results. Default: 'interpolated_scaled_events.json'.
-metrics_file (str, optional)
-    Path to the metrics definition file. Default: 'production_simulation_config_metrics.yml'.
-file_name_template (str, optional)
-    Template for the file name. Default:
-    'prod6_LaPalma-{zenith}deg_gamma_cone.N.Am-4LSTs09MSTs_ID0_reduced.fits'.
-
-Example
--------
-To evaluate statistical uncertainties and perform interpolation, run the command line script:
-
-.. code-block:: console
-
-    simtools-production-scale-events --base_path tests/resources/production_dl2_fits/ \\
-        --zeniths 20 40 52 60 --offsets 0 --query_point 1 180 30 0 0 \\
-        --metrics_file "path/to/metrics.yaml" \\
-        --output_file "output.json"
-
-The output will display the scaled events for the specified query point and save
- the results to the specified output file.
-"""
-
-import itertools
-import json
-import logging
-from pathlib import Path
-
-import astropy.units as u
-import numpy as np
-
-import simtools.utils.general as gen
-from simtools.configuration import configurator
-from simtools.configuration.commandline_parser import CommandLineParser
-from simtools.io_operations import io_handler
-from simtools.production_configuration.calculate_statistical_errors_grid_point import (
-    StatisticalErrorEvaluator,
-)
-from simtools.production_configuration.interpolation_handler import InterpolationHandler
-
-
-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)
-
-    config.parser.add_argument(
-        "--base_path",
-        type=str,
-        required=True,
-        help="Path to the DL2 MC event files for interpolation.",
-    )
-    config.parser.add_argument(
-        "--zeniths",
-        required=True,
-        nargs="+",
-        type=CommandLineParser.zenith_angle,
-        help="List of zenith angles.",
-    )
-    config.parser.add_argument(
-        "--offsets", required=True, nargs="+", type=float, help="List of offsets in degrees."
-    )
-
-    config.parser.add_argument(
-        "--query_point",
-        required=True,
-        nargs=5,
-        type=float,
-        help="Grid point for interpolation (energy, azimuth, zenith, NSB, offset).",
-    )
-    config.parser.add_argument(
-        "--output_file",
-        required=False,
-        type=str,
-        default="interpolated_scaled_events.json",
-        help="Output file to store the results. (default: 'interpolated_scaled_events.json').",
-    )
-    config.parser.add_argument(
-        "--metrics_file",
-        required=False,
-        type=str,
-        default="production_simulation_config_metrics.yml",
-        help="Metrics definition file. (default: production_simulation_config_metrics.yml)",
-    )
-    config.parser.add_argument(
-        "--file_name_template",
-        required=False,
-        type=str,
-        default=("prod6_LaPalma-{zenith}deg_gamma_cone.N.Am-4LSTs09MSTs_ID0_reduced.fits"),
-        help=(
-            "Template for the file name. (default: "
-            "'prod6_LaPalma-{zenith}deg_gamma_cone.N.Am-4LSTs09MSTs_ID0_reduced.fits')"
-        ),
-    )
-    return config.initialize(db_config=False)
-
-
-def main():
-    """Run the evaluator and interpolate."""
-    label = Path(__file__).stem
-    args_dict, _ = _parse(
-        label,
-        "Evaluate statistical uncertainties from DL2 MC event files and interpolate results.",
-    )
-    logger = logging.getLogger()
-    logger.setLevel(logging.INFO)
-    logger.info(f"args dict: {args_dict}")
-
-    output_path = io_handler.IOHandler().get_output_directory(label)
-    output_filepath = Path(output_path).joinpath(f"{args_dict['output_file']}")
-
-    evaluator_instances = []
-
-    metrics = gen.collect_data_from_file(args_dict["metrics_file"])
-
-    if args_dict["base_path"] and args_dict["zeniths"] and args_dict["offsets"]:
-        for zenith, offset in itertools.product(args_dict["zeniths"], args_dict["offsets"]):
-            file_name = args_dict["file_name_template"].format(zenith=int(zenith.value))
-            file_path = Path(args_dict["base_path"]).joinpath(file_name)
-
-            if not file_path.exists():
-                logger.warning(f"File not found: {file_path}. Skipping.")
-                continue
-
-            evaluator = StatisticalErrorEvaluator(
-                file_path,
-                file_type="Gamma-cone",
-                metrics=metrics,
-                grid_point=(1 * u.TeV, 180 * u.deg, zenith, 0, offset * u.deg),
-            )
-            evaluator.calculate_metrics()
-            evaluator_instances.append(evaluator)
-
-    else:
-        logger.warning("No files read")
-        logger.warning(f"Base Path: {args_dict['base_path']}")
-        logger.warning(f"Zeniths: {args_dict['zeniths']}")
-        logger.warning(f"Offsets: {args_dict['offsets']}")
-
-    interpolation_handler = InterpolationHandler(evaluator_instances, metrics=metrics)
-    query_points = np.array([args_dict["query_point"]])
-    scaled_events = interpolation_handler.interpolate(query_points)
-
-    output_data = {
-        "query_point": args_dict["query_point"],
-        "scaled_events": scaled_events.tolist(),
-    }
-    with open(output_filepath, "w", encoding="utf-8") as f:
-        json.dump(output_data, f, indent=4)
-    logger.info(f"Output saved to {output_filepath}")
-    logger.info(f"Scaled events for grid point {args_dict['query_point']}: {scaled_events}")
-
-
-if __name__ == "__main__":
-    main()