gammasimtools 0.16.0__py3-none-any.whl → 0.18.0__py3-none-any.whl

simtools/visualization/plot_tables.py

@@ -1,10 +1,13 @@
 #!/usr/bin/python3
 """Plot tabular data."""
 
+from pathlib import Path
+
 import numpy as np
 from astropy.table import Table
 
 import simtools.utils.general as gen
+from simtools.constants import SCHEMA_PATH
 from simtools.db import db_handler
 from simtools.io_operations import legacy_data_handler
 from simtools.visualization import visualize
@@ -20,6 +23,8 @@ def plot(config, output_file, db_config=None):
         Configuration dictionary for plotting.
     output_file: str
         Output file.
+    db_config: dict, optional
+        Database configuration dictionary for accessing the model parameter database.
     """
     data = read_table_data(config, db_config)
 
@@ -29,6 +34,8 @@ def plot(config, output_file, db_config=None):
     )
     visualize.save_figure(fig, output_file)
 
+    return output_file
+
 
 def read_table_data(config, db_config):
     """
@@ -69,7 +76,8 @@ def read_table_data(config, db_config):
                 _config["select_values"]["column_name"],
                 _config["select_values"]["value"],
             )
-        data[_config["label"]] = gen.get_structure_array_from_table(
+        label = _config.get("label", f"{_config.get('column_x')} vs {_config.get('column_y')}")
+        data[label] = gen.get_structure_array_from_table(
             table,
             [
                 _config["column_x"],
@@ -93,7 +101,7 @@ def _read_table_from_model_database(table_config, db_config):
     Returns
     -------
     Table
-        Astropy table.
+        Astropy table
     """
     db = db_handler.DatabaseHandler(mongo_db_config=db_config)
     return db.export_model_file(
@@ -109,3 +117,74 @@ def _read_table_from_model_database(table_config, db_config):
 def _select_values_from_table(table, column_name, value):
     """Return a table with only the rows where column_name == value."""
     return table[np.isclose(table[column_name], value)]
+
+
+def generate_plot_configurations(
+    parameter, parameter_version, site, telescope, output_path, plot_type
+):
+    """
+    Generate plot configurations for a model parameter from schema files.
+
+    Parameters
+    ----------
+    parameter: str
+        Model parameter name.
+
+    Returns
+    -------
+    tuple
+        Tuple containing a list of plot configurations and a list of output file names.
+        Return None, if no plot configurations are found.
+    """
+    schema = gen.change_dict_keys_case(
+        gen.collect_data_from_file(
+            file_name=SCHEMA_PATH / "model_parameters" / f"{parameter}.schema.yml"
+        )
+    )
+    configs = schema.get("plot_configuration")
+    if not configs:
+        return None
+    if plot_type != "all":
+        configs = [config for config in configs if config.get("type") == plot_type]
+        if not configs:
+            raise ValueError(
+                f"No plot configuration found for type '{plot_type}' in parameter '{parameter}'."
+            )
+
+    output_files = []
+    for _config in configs:
+        for _table in _config.get("tables", []):
+            _table["parameter_version"] = parameter_version
+            _table["site"] = site
+        output_files.append(
+            _generate_output_file_name(
+                parameter=parameter,
+                parameter_version=parameter_version,
+                site=site,
+                telescope=telescope,
+                plot_type=_config.get("type"),
+                output_path=output_path,
+            )
+        )
+
+    return configs, output_files
+
+
+def _generate_output_file_name(
+    parameter,
+    parameter_version,
+    site,
+    telescope,
+    plot_type,
+    output_path=None,
+    file_extension=".pdf",
+):
+    """Generate output file name based on table file and appendix."""
+    parts = [parameter, parameter_version, site]
+    if telescope:
+        parts.append(telescope)
+    if plot_type != parameter:
+        parts.append(plot_type)
+    filename = "_".join(parts) + file_extension
+
+    return Path(output_path) / filename if output_path else Path(filename)

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,214 +627,6 @@ 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 sim_telarray file and plots reconstructed photoelectrons via ctapipe.
@@ -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,152 +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.
-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 \
-                --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(
-        "--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"],
-        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/layout/ctao_array_layouts.py

@@ -1,172 +0,0 @@
-"""Retrieve, merge, and write layouts from CTAO common identifiers repository."""
-
-import logging
-from pathlib import Path
-
-import simtools.utils.general as gen
-from simtools.data_model.metadata_collector import MetadataCollector
-from simtools.data_model.model_data_writer import ModelDataWriter
-from simtools.io_operations import io_handler
-from simtools.utils import names
-
-_logger = logging.getLogger(__name__)
-
-
-def retrieve_array_layouts(site, repository_url, branch_name="main"):
-    """
-    Retrieve array layouts from CTAO common identifiers repository.
-
-    Parameters
-    ----------
-    site : str
-        Site identifier.
-    repository_url : str
-        URL or path to CTAO common identifiers
-    branch_name : str
-        Repository branch to use for CTAO common identifiers.
-
-    Returns
-    -------
-    dict
-        Array layouts for all CTAO sites.
-    """
-    _logger.info(f"Retrieving array layouts from {repository_url} on branch {branch_name}.")
-
-    if gen.is_url(repository_url):
-        array_element_ids = gen.collect_data_from_http(
-            url=f"{repository_url}/{branch_name}/array-element-ids.json"
-        )
-        sub_arrays = gen.collect_data_from_http(
-            url=f"{repository_url}/{branch_name}/subarray-ids.json"
-        )
-    else:
-        array_element_ids = gen.collect_data_from_file(
-            Path(repository_url) / "array-element-ids.json"
-        )
-        sub_arrays = gen.collect_data_from_file(Path(repository_url) / "subarray-ids.json")
-
-    return _get_layouts_per_site(site, sub_arrays, array_element_ids)
-
-
-def _get_layouts_per_site(site, sub_arrays, array_element_ids):
-    """
-    Get array layouts for CTAO sites.
-
-    Parameters
-    ----------
-    site : str
-        Site identifier.
-    sub_arrays : dict
-        Sub-array definitions.
-    array_element_ids : dict
-        Array element definitions.
-
-    Returns
-    -------
-    dict
-        Array layouts for CTAO sites.
-    """
-    layouts_per_site = []
-
-    for array in sub_arrays.get("subarrays", []):
-        elements = []
-        for ids in array.get("array_element_ids", []):
-            element_name = _get_array_element_name(ids, array_element_ids)
-            if names.get_site_from_array_element_name(element_name) != site:
-                break
-            elements.append(element_name)
-        if len(elements) > 0:
-            array_layout = {
-                "name": array.get("name"),
-                "elements": elements,
-            }
-            layouts_per_site.append(array_layout)
-
-    _logger.info(f"CTAO array layout definition: {layouts_per_site}")
-    return layouts_per_site
-
-
-def _get_array_element_name(ids, array_element_ids):
-    """Return array element name for common identifier."""
-    for element in array_element_ids.get("array_elements", []):
-        if element.get("id") == ids:
-            return element.get("name")
-    return None
-
-
-def merge_array_layouts(layouts_1, layouts_2):
-    """
-    Compare array layout dictionaries and merge them.
-
-    Parameters
-    ----------
-    layouts_1 : dict
-        Array layout dictionary 1.
-    layouts_2 : dict
-        Array layout dictionary 2.
-
-    Returns
-    -------
-    dict
-        Merged array layout dictionary based on layout_1.
-    """
-    merged_layout = layouts_1
-    for layout_2 in layouts_2:
-        layout_found = False
-        for layout_1 in layouts_1.get("value", {}):
-            if sorted(layout_1["elements"]) == sorted(layout_2["elements"]):
-                print(
-                    f"Equal telescope list: simtools '{layout_1['name']}' "
-                    f"and CTAO '{layout_2['name']}'"
-                )
-                layout_1["name"] = layout_2["name"]
-                layout_found = True
-        if not layout_found:
-            merged_layout["value"].append(
-                {
-                    "name": layout_2["name"],
-                    "elements": layout_2["elements"],
-                }
-            )
-            _logger.info(f"Adding {layout_2['name']} with {layout_2['elements']}")
-    return merged_layout
-
-
-def write_array_layouts(array_layouts, args_dict, db_config):
-    """
-    Write array layouts as model parameter.
-
-    Parameters
-    ----------
-    args_dict : dict
-        Command line arguments.
-    array_layouts : dict
-        Array layouts to be written.
-    db_config : dict
-        Database configuration.
-    """
-    _logger.info(f"Writing updated array layouts to the database for site {args_dict['site']}.")
-
-    io_handler_instance = io_handler.IOHandler()
-    io_handler_instance.set_paths(
-        output_path=args_dict["output_path"],
-        use_plain_output_path=args_dict["use_plain_output_path"],
-    )
-    output_file = io_handler_instance.get_output_file(
-        f"array-layouts-{args_dict['updated_parameter_version']}.json"
-    )
-
-    ModelDataWriter.dump_model_parameter(
-        parameter_name="array_layouts",
-        value=array_layouts["value"],
-        instrument=args_dict["site"],
-        parameter_version=args_dict.get("updated_parameter_version"),
-        output_file=output_file,
-        use_plain_output_path=args_dict["use_plain_output_path"],
-        db_config=db_config,
-    )
-    MetadataCollector.dump(
-        args_dict,
-        output_file,
-        add_activity_name=True,
-    )