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

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,
-    )

simtools/production_configuration/event_scaler.py

@@ -1,120 +0,0 @@
-"""
-Calculate the scaled number of events based on metrics.
-
-Module for scaling events based on statistical error metrics. Contains the `EventScaler` class,
-which scales the number of events for both the entire dataset and specific grid points.
-Scaling factors are calculated using error metrics and the evaluator's results.
-"""
-
-import astropy.units as u
-import numpy as np
-
-__all__ = ["EventScaler"]
-
-
-class EventScaler:
-    """
-    Scales the number of events based on statistical error metrics.
-
-    Supports scaling both the entire dataset and specific grid points like energy values.
-    """
-
-    def __init__(self, evaluator, metrics: dict):
-        """
-        Initialize the EventScaler with the evaluator and metrics.
-
-        Parameters
-        ----------
-        evaluator : StatisticalErrorEvaluator
-            The evaluator responsible for calculating metrics and handling event data.
-        metrics : dict
-            Dictionary containing metrics, including target error for effective area.
-        """
-        self.evaluator = evaluator
-        self.metrics = metrics
-
-    def scale_events(self, return_sum: bool = True) -> u.Quantity:
-        """
-        Calculate the scaled number of events based on statistical error metrics.
-
-        Parameters
-        ----------
-        return_sum : bool, optional
-            If True, returns the sum of scaled events for the entire set of MC events. If False,
-            returns the scaled events for each grid point along the energy axis. Default is True.
-
-        Returns
-        -------
-        u.Quantity
-            If 'return_sum' is True, returns the total scaled number of events as a u.Quantity.
-            If 'return_sum' is False, returns an array of scaled events along the energy axis as
-            a u.Quantity.
-        """
-        scaling_factor = self._compute_scaling_factor()
-
-        base_events = self._number_of_simulated_events()
-
-        if return_sum:
-            return np.sum(base_events * scaling_factor)
-        return base_events * scaling_factor
-
-    def _compute_scaling_factor(self) -> float:
-        """
-        Compute the scaling factor based on the error metrics.
-
-        Returns
-        -------
-        float
-            The scaling factor.
-        """
-        metric_results = self.evaluator.calculate_metrics()
-        uncertainty_effective_area = metric_results.get("uncertainty_effective_area")
-        current_max_error = uncertainty_effective_area.get("max_error")
-        target_max_error = self.metrics.get("uncertainty_effective_area").get("target_error")[
-            "value"
-        ]
-
-        return (current_max_error / target_max_error) ** 2
-
-    def _number_of_simulated_events(self) -> u.Quantity:
-        """
-        Fetch the number of simulated events from the evaluator's data.
-
-        Returns
-        -------
-        u.Quantity
-            The number of simulated events.
-        """
-        return self.evaluator.data.get("simulated_event_histogram")
-
-    def calculate_scaled_events_at_grid_point(
-        self,
-        grid_point: tuple,
-    ) -> u.Quantity:
-        """
-        Calculate the scaled number of events for a specific energy grid point.
-
-        Parameters
-        ----------
-        grid_point : tuple
-            The grid point specifying energy, azimuth, zenith, NSB, and offset.
-
-        Returns
-        -------
-        float
-            The scaled number of events at the specified grid point (energy).
-        """
-        energy = grid_point[0]
-        bin_edges = self.evaluator.create_bin_edges()
-        bin_idx = np.digitize(energy, bin_edges) - 1
-
-        scaling_factor = self._compute_scaling_factor()
-
-        simulated_event_histogram = self.evaluator.data.get("simulated_event_histogram", [])
-
-        if bin_idx < 0 or bin_idx >= len(simulated_event_histogram):
-            raise ValueError(f"Energy {energy} is outside the range of the simulated events data.")
-
-        base_events = self._number_of_simulated_events()
-        base_event_at_energy = base_events[bin_idx]
-        return base_event_at_energy * scaling_factor

simtools/production_configuration/generate_simulation_config.py

@@ -1,158 +0,0 @@
-"""Derives simulation configuration parameters for a grid point based on several metrics."""
-
-from simtools.production_configuration.calculate_statistical_errors_grid_point import (
-    StatisticalErrorEvaluator,
-)
-from simtools.production_configuration.event_scaler import EventScaler
-
-__all__ = ["SimulationConfig"]
-
-
-class SimulationConfig:
-    """
-    Configures simulation parameters for a specific grid point.
-
-    Parameters
-    ----------
-    grid_point : dict
-        Dictionary representing a grid point with azimuth, elevation, and night sky background.
-    file_path : str
-        Path to the DL2 MC event file for statistical uncertainty evaluation.
-    file_type : str
-        Type of the DL2 MC event file ('point-like' or 'cone').
-    metrics : dict, optional
-        Dictionary of metrics to evaluate.
-    """
-
-    def __init__(
-        self,
-        grid_point: dict[str, float],
-        file_path: str,
-        file_type: str,
-        metrics: dict[str, float] | None = None,
-    ):
-        """Initialize the simulation configuration for a grid point."""
-        self.grid_point = grid_point
-        self.file_path = file_path
-        self.file_type = file_type
-        self.metrics = metrics or {}
-        self.evaluator = StatisticalErrorEvaluator(file_path, file_type, metrics)
-        self.event_scaler = EventScaler(self.evaluator, self.metrics)
-        self.simulation_params = {}
-
-    def configure_simulation(self) -> dict[str, float]:
-        """
-        Configure the simulation parameters for the grid point.
-
-        Returns
-        -------
-        dict
-            A dictionary with simulation parameters such as core scatter area,
-              viewcone, and number of simulated events.
-        """
-        self.simulation_params = {
-            "core_scatter_area": self._calculate_core_scatter_area(),
-            "viewcone": self._calculate_viewcone(),
-            "number_of_events": self.calculate_required_events(),
-        }
-        return self.simulation_params
-
-    def calculate_required_events(self) -> int:
-        """
-        Calculate the required number of simulated events based on statistical error metrics.
-
-        Uses the EventScaler to scale the events.
-
-        Returns
-        -------
-        int
-            The number of simulated events required.
-        """
-        return self.event_scaler.scale_events()
-
-    def _calculate_core_scatter_area(self) -> float:
-        """
-        Calculate the core scatter area based on the grid point.
-
-        Returns
-        -------
-        float
-            The core scatter area.
-        """
-        base_area = self._fetch_simulated_core_scatter_area()
-        area_factor = self._get_area_factor_from_grid_point()
-        return base_area * area_factor
-
-    def _calculate_viewcone(self) -> float:
-        """
-        Calculate the viewcone based on the grid point conditions.
-
-        Returns
-        -------
-        float
-            The viewcone value.
-        """
-        base_viewcone = self._fetch_simulated_viewcone()
-        viewcone_factor = self._get_viewcone_factor_from_grid_point()
-
-        return base_viewcone * viewcone_factor
-
-    def _get_area_factor_from_grid_point(self) -> float:
-        """
-        Determine the area factor.
-
-        The area factor is based on the grid point's azimuth,
-          elevation, and night sky background.
-
-        Returns
-        -------
-        float
-            The area factor.
-        """
-        azimuth = self.grid_point.get("azimuth", 0)
-        elevation = self.grid_point.get("elevation", 0)
-        night_sky_background = self.grid_point.get("night_sky_background", 0)
-
-        # Implement reading of factor from LUT
-        return azimuth + elevation + night_sky_background
-
-    def _get_viewcone_factor_from_grid_point(self) -> float:
-        """
-        Determine the viewcone factor.
-
-        The factor is based on the grid point's azimuth,
-          elevation, and night sky background.
-
-        Returns
-        -------
-        float
-            The viewcone factor.
-        """
-        azimuth = self.grid_point.get("azimuth", 0)
-        elevation = self.grid_point.get("elevation", 0)
-        night_sky_background = self.grid_point.get("night_sky_background", 0)
-
-        # Implement reading of factor from LUT
-        return azimuth + elevation + night_sky_background
-
-    def _fetch_simulated_core_scatter_area(self) -> float:
-        """
-        Fetch the core scatter area from existing simulated files based on grid point conditions.
-
-        Returns
-        -------
-        float
-            The fetched core scatter outer bound.
-        """
-        return self.evaluator.data["core_range"]
-
-    def _fetch_simulated_viewcone(self) -> float:
-        """
-        Fetch the viewcone from existing simulated files based on grid point conditions.
-
-        Returns
-        -------
-        float
-            The fetched viewcone outer bound.
-        """
-        return self.evaluator.data["viewcone"]