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

simtools/corsika/corsika_output_visualize.py

@@ -1,345 +0,0 @@
-import logging
-
-import matplotlib.pyplot as plt
-import numpy as np
-from matplotlib import colors
-
-_logger = logging.getLogger(__name__)
-
-
-def _kernel_plot_2D_photons(corsika_output_instance, property_name, log_z=False):
-    """
-    The next functions below are used by the the corsikaOutput class to plot all sort of information
-    from the Cherenkov photons saved.
-
-    Create the figure of a 2D plot. The parameter `name` indicate which plot. Choices are
-    "counts", "density", "direction".
-
-    Parameters
-    ----------
-    corsika_output_instance: corsika.corsika_output.corsikaOutput
-        instance of corsika.corsika_output.corsikaOutput.
-    property_name: string
-        Name of the quantity. Options are: "counts", "density", "direction", "time_altitude" and
-        "num_photons_per_telescope".
-    log_z: bool
-        if True, the intensity of the color bar is given in logarithmic scale.
-
-    Returns
-    -------
-    list
-        List of figures for the given telescopes.
-
-    Raises
-    ------
-    ValueError
-        if `name` is not allowed.
-
-    """
-    x_label = {
-        "counts": "x (m)",
-        "density": "x (m)",
-        "direction": "cos(x)",
-        "time_altitude": "Time since 1st interaction (ns)",
-        "num_photons_per_telescope": "Event number",
-    }
-    y_label = {
-        "counts": "y (m)",
-        "density": "y (m)",
-        "direction": "cos(y)",
-        "time_altitude": "Altitude of emission (km)",
-        "num_photons_per_telescope": "Telescope index",
-    }
-    if property_name not in x_label:
-        msg = f"property_name must be one of {list(x_label.keys())}"
-        _logger.error(msg)
-        raise ValueError(msg)
-
-    if property_name == "counts":
-        hist_values, x_edges, y_edges = corsika_output_instance.get_2D_photon_position_distr(
-            density=False
-        )
-    elif property_name == "density":
-        hist_values, x_edges, y_edges = corsika_output_instance.get_2D_photon_position_distr(
-            density=True
-        )
-    elif property_name == "direction":
-        hist_values, x_edges, y_edges = corsika_output_instance.get_2D_photon_direction_distr()
-    elif property_name == "time_altitude":
-        hist_values, x_edges, y_edges = corsika_output_instance.get_2D_photon_time_altitude()
-    elif property_name == "num_photons_per_telescope":
-        hist_values, x_edges, y_edges = corsika_output_instance.get_2D_num_photons_distr()
-        hist_values, x_edges, y_edges = [hist_values], [x_edges], [y_edges]
-
-    all_figs = []
-    for i_hist, _ in enumerate(x_edges):
-        fig, ax = plt.subplots()
-        if log_z is True:
-            norm = colors.LogNorm(vmin=1, vmax=np.amax([np.amax(hist_values[i_hist]), 2]))
-        else:
-            norm = None
-        mesh = ax.pcolormesh(x_edges[i_hist], y_edges[i_hist], hist_values[i_hist], norm=norm)
-        ax.set_xlabel(x_label[property_name])
-        ax.set_ylabel(y_label[property_name])
-        ax.set_xlim(np.amin(x_edges[i_hist]), np.amax(x_edges[i_hist]))
-        ax.set_ylim(np.amin(y_edges[i_hist]), np.amax(y_edges[i_hist]))
-        ax.set_facecolor("xkcd:black")
-        fig.colorbar(mesh)
-        all_figs.append(fig)
-        if corsika_output_instance.individual_telescopes is False:
-            fig.savefig(f"histogram_{property_name}_2D_all_tels.png", bbox_inches="tight")
-        else:
-            ax.text(
-                0.99,
-                0.99,
-                "tel. " + str(i_hist),
-                ha="right",
-                va="top",
-                transform=ax.transAxes,
-                color="white",
-            )
-            fig.savefig(
-                f"histogram_{property_name}_2D_tel_"
-                f"{str(corsika_output_instance.telescope_indices[i_hist])}.png",
-                bbox_inches="tight",
-            )
-        plt.close()
-
-    return all_figs
-
-
-def plot_2D_counts(corsika_output_instance, log_z=True):
-    """
-    Plot the 2D histogram of the photon positions on the ground.
-
-    Parameters
-    ----------
-    corsika_output_instance: corsika.corsika_output.corsikaOutput
-        instance of corsika.corsika_output.corsikaOutput.
-    log_z: bool
-        if True, the intensity of the color bar is given in logarithmic scale.
-    """
-    return _kernel_plot_2D_photons(corsika_output_instance, "counts", log_z=log_z)
-
-
-def plot_2D_density(corsika_output_instance, log_z=True):
-    """
-    Plot the 2D histogram of the photon density distribution on the ground.
-
-    Parameters
-    ----------
-    corsika_output_instance: corsika.corsika_output.corsikaOutput
-        instance of corsika.corsika_output.corsikaOutput.
-    log_z: bool
-        if True, the intensity of the color bar is given in logarithmic scale.
-    """
-    return _kernel_plot_2D_photons(corsika_output_instance, "density", log_z=log_z)
-
-
-def plot_2D_direction(corsika_output_instance, log_z=True):
-    """
-    Plot the 2D histogram of the incoming direction of photons.
-
-    Parameters
-    ----------
-    corsika_output_instance: corsika.corsika_output.corsikaOutput
-        instance of corsika.corsika_output.corsikaOutput.
-    log_z: bool
-        if True, the intensity of the color bar is given in logarithmic scale.
-    """
-    return _kernel_plot_2D_photons(corsika_output_instance, "direction", log_z=log_z)
-
-
-def plot_2D_time_altitude(corsika_output_instance, log_z=True):
-    """
-    Plot the 2D histogram of the time and altitude where the photon was produced.
-
-    Parameters
-    ----------
-    corsika_output_instance: corsika.corsika_output.corsikaOutput
-        instance of corsika.corsika_output.corsikaOutput.
-    log_z: bool
-        if True, the intensity of the color bar is given in logarithmic scale.
-    """
-    return _kernel_plot_2D_photons(corsika_output_instance, "time_altitude", log_z=log_z)
-
-
-def plot_2D_num_photons_per_telescope(corsika_output_instance, log_z=True):
-    """
-    Plot the 2D histogram of the number of photons per event and per telescope.
-
-    Parameters
-    ----------
-    corsika_output_instance: corsika.corsika_output.corsikaOutput
-        instance of corsika.corsika_output.corsikaOutput.
-    log_z: bool
-        if True, the intensity of the color bar is given in logarithmic scale.
-    """
-    return _kernel_plot_2D_photons(
-        corsika_output_instance, "num_photons_per_telescope", log_z=log_z
-    )
-
-
-def _kernel_plot_1D_photons(corsika_output_instance, property_name, log_y=True):
-    """
-    Create the figure of a 1D plot. The parameter `name` indicate which plot. Choices are
-    "counts", "density", "direction".
-
-    Parameters
-    ----------
-    corsika_output_instance: corsika.corsika_output.corsikaOutput
-        instance of corsika.corsika_output.corsikaOutput.
-    property_name: string
-        Name of the quantity. Options are: "wavelength", "counts", "density", "time", "altitude",
-        "num_photons".
-    log_y: bool
-        if True, the intensity of the Y axis is given in logarithmic scale.
-
-    Returns
-    -------
-    list
-        List of figures for the given telescopes.
-
-    Raises
-    ------
-    ValueError
-        if `name` is not allowed.
-    """
-
-    x_label = {
-        "wavelength": "Wavelength (nm)",
-        "counts": "Distance to center (m)",
-        "density": "Distance to center (m)",
-        "time": "Time since 1st interaction (ns)",
-        "altitude": "Altitude of emission (km)",
-        "num_photons": "Number of photons per event",
-    }
-    if property_name not in x_label:
-        msg = f"results: status must be one of {list(x_label.keys())}"
-        _logger.error(msg)
-        raise ValueError(msg)
-
-    if property_name == "wavelength":
-        hist_values, edges = corsika_output_instance.get_photon_wavelength_distr()
-    elif property_name == "counts":
-        hist_values, edges = corsika_output_instance.get_photon_radial_distr(density=False)
-    elif property_name == "density":
-        hist_values, edges = corsika_output_instance.get_photon_radial_distr(density=True)
-    elif property_name == "time":
-        hist_values, edges = corsika_output_instance.get_photon_time_of_emission_distr()
-    elif property_name == "altitude":
-        hist_values, edges = corsika_output_instance.get_photon_altitude_distr()
-    elif property_name == "num_photons":
-        hist_values, edges = corsika_output_instance.get_num_photons_distr()
-        hist_values, edges = [hist_values], [edges]
-
-    all_figs = []
-    for i_hist, _ in enumerate(edges):
-        fig, ax = plt.subplots()
-        ax.bar(
-            edges[i_hist][:-1],
-            hist_values[i_hist],
-            align="edge",
-            width=np.abs(np.diff(edges[i_hist])),
-        )
-        ax.set_xlabel(x_label[property_name])
-        ax.set_ylabel("Counts")
-
-        if log_y is True:
-            ax.set_yscale("log")
-        if corsika_output_instance.individual_telescopes is False:
-            fig.savefig(f"histogram_{property_name}_tels.png", bbox_inches="tight")
-        else:
-            fig.savefig(
-                f"histogram_{property_name}_tel_"
-                f"{str(corsika_output_instance.telescope_indices[i_hist])}.png",
-                bbox_inches="tight",
-            )
-        all_figs.append(fig)
-    return all_figs
-
-
-def plot_wavelength_distr(corsika_output_instance, log_y=True):
-    """
-    Plots the 1D distribution of the photon wavelengths
-
-    Parameters
-    ----------
-    corsika_output_instance: corsika.corsika_output.corsikaOutput
-        instance of corsika.corsika_output.corsikaOutput.
-    log_y: bool
-        if True, the intensity of the Y axis is given in logarithmic scale.
-
-    """
-    return _kernel_plot_1D_photons(corsika_output_instance, "wavelength", log_y=log_y)
-
-
-def plot_counts_distr(corsika_output_instance, log_y=True):
-    """
-    Plots the 1D distribution, i.e. the radial distribution, of the photons on the ground.
-
-    Parameters
-    ----------
-    corsika_output_instance: corsika.corsika_output.corsikaOutput
-        instance of corsika.corsika_output.corsikaOutput.
-    log_y: bool
-        if True, the intensity of the Y axis is given in logarithmic scale.
-    """
-    return _kernel_plot_1D_photons(corsika_output_instance, "counts", log_y=log_y)
-
-
-def plot_density_distr(corsika_output_instance, log_y=True):
-    """
-    Plots the photon density distribution on the ground.
-
-    Parameters
-    ----------
-    corsika_output_instance: corsika.corsika_output.corsikaOutput
-        instance of corsika.corsika_output.corsikaOutput.
-    log_y: bool
-        if True, the intensity of the Y axis is given in logarithmic scale.
-
-    """
-    return _kernel_plot_1D_photons(corsika_output_instance, "density", log_y=log_y)
-
-
-def plot_time_distr(corsika_output_instance, log_y=True):
-    """
-    Plots the distribution times in which the photons were generated in ns.
-
-    Parameters
-    ----------
-    corsika_output_instance: corsika.corsika_output.corsikaOutput
-        instance of corsika.corsika_output.corsikaOutput.
-    log_y: bool
-        if True, the intensity of the Y axis is given in logarithmic scale.
-    """
-    return _kernel_plot_1D_photons(corsika_output_instance, "time", log_y=log_y)
-
-
-def plot_altitude_distr(corsika_output_instance, log_y=True):
-    """
-    Plots the distribution of altitude in which the photons were generated in km.
-
-    Parameters
-    ----------
-    corsika_output_instance: corsika.corsika_output.corsikaOutput
-        instance of corsika.corsika_output.corsikaOutput.
-    log_y: bool
-        if True, the intensity of the Y axis is given in logarithmic scale.
-    """
-    return _kernel_plot_1D_photons(corsika_output_instance, "altitude", log_y=log_y)
-
-
-def plot_num_photons_distr(corsika_output_instance, log_y=True):
-    """
-    Plots the distribution of the number of Cherenkov photons per event.
-
-    Parameters
-    ----------
-    corsika_output_instance: corsika.corsika_output.corsikaOutput
-        instance of corsika.corsika_output.corsikaOutput.
-    log_y: bool
-        if True, the intensity of the Y axis is given in logarithmic scale.
-    """
-    return _kernel_plot_1D_photons(corsika_output_instance, "num_photons", log_y=log_y)

simtools/data_model/validate_schema.py

@@ -1,285 +0,0 @@
-import datetime
-import logging
-import re
-
-import simtools.utils.general as gen
-from simtools.data_model import metadata_model
-
-
-class SchemaValidator:
-    """
-    Validate a dictionary against the simpipe reference schema.
-    Used e.g., to validate metadata provided as input.
-
-    Parameters
-    ----------
-    data_dict: dict
-        Metadata dict to be validated against reference schema.
-
-    """
-
-    def __init__(self, data_dict=None):
-        """
-        Initialize validation class and load reference schema.
-        """
-
-        self._logger = logging.getLogger(__name__)
-
-        self._reference_schema = gen.change_dict_keys_case(
-            metadata_model.metadata_input_reference_schema(), lower_case=True
-        )
-        self.data_dict = data_dict
-
-    def validate_and_transform(self, meta_file_name=None):
-        """
-        Schema validation and processing.
-
-        Parameters
-        ----------
-        meta_file_name
-            file name for file with meta data to
-            be validated (might also be given as
-            dictionary during initialization of the class).
-
-        Returns
-        -------
-        dict
-            Complete set of metadata following the CTA top-level metadata defintion
-            (None if meta_file_name is undefined)
-
-        """
-        try:
-            self._logger.debug(f"Reading meta data from {meta_file_name}")
-            self.data_dict = gen.collect_data_from_yaml_or_dict(meta_file_name, self.data_dict)
-        except gen.InvalidConfigData:
-            self._logger.debug("Failed reading metadata from file.")
-            return None
-
-        self.data_dict = gen.change_dict_keys_case(self.data_dict, True)
-        self._validate_schema(self._reference_schema, self.data_dict)
-        self._process_schema()
-        return self.data_dict
-
-    def _validate_schema(self, ref_schema, data_dict):
-        """
-        Validate schema for data types and required fields.
-
-        Parameters
-        ----------
-        ref_schema: dict
-            Reference metadata schema
-        data_dict: dict
-            input metadata dict to be validated against
-            reference schema.
-
-        Raises
-        ------
-        UnboundLocalError
-            If no data is available for metadata key from the
-            reference schema.
-
-        """
-
-        for key, value in ref_schema.items():
-            if data_dict and key in data_dict:
-                _this_data = data_dict[key]
-            else:
-                if self._field_is_optional(value):
-                    self._logger.debug(f"Optional field {key}")
-                    continue
-                msg = f"Missing required field '{key}'"
-                raise ValueError(msg)
-
-            if isinstance(value, dict):
-                # "type" is used for data types (str) and for telescope types (dict)
-                if "type" in value and isinstance(value["type"], str):
-                    try:
-                        self._validate_data_type(value, key, _this_data)
-                    except UnboundLocalError:
-                        self._logger.error(f"No data for {key} key")
-                        raise
-                else:
-                    self._validate_schema(value, _this_data)
-
-    def _process_schema(self):
-        """
-        Process schema entries for inconsistencies
-        (quite fine tuned)
-        - remove linefeeds from description string
-
-        Raises
-        ------
-        KeyError
-            if data_dict["product"]["description"] is not available.
-
-        """
-
-        try:
-            self.data_dict["product"]["description"] = self._remove_line_feed(
-                self.data_dict["product"]["description"]
-            )
-        except KeyError:
-            pass
-
-    def _validate_data_type(self, schema, key, data_field):
-        """
-        Validate data type against the expected data type
-        from schema.
-
-        Parameters
-        ----------
-        schema: dict
-            metadata description from reference schema.
-        key: str
-            data field name to be validated.
-        data_field: dict
-            data field to be validated.
-
-        Raises
-        ------
-        ValueError
-            if data types are inconsistent.
-
-        """
-
-        self._logger.debug(f"checking data field {key} for {schema['type']}")
-
-        convert = {"str": type("str"), "float": type(1.0), "int": type(0), "bool": type(True)}
-
-        if schema["type"] == "datetime":
-            self._validate_datetime(data_field, self._field_is_optional(schema))
-        elif schema["type"] == "email":
-            self._validate_email(data_field, key)
-        elif schema["type"].endswith("list"):
-            self._validate_list(schema["type"], data_field)
-        elif type(data_field).__name__ != schema["type"]:
-            try:
-                if isinstance(data_field, (int, str)):
-                    convert[schema["type"]](data_field)
-                elif data_field is not None:
-                    raise ValueError
-            except ValueError as error:
-                raise ValueError(
-                    f"invalid type for key {key}. Expected: {schema['type']}, "
-                    f"Found: {type(data_field).__name__}"
-                ) from error
-
-    @staticmethod
-    def _validate_datetime(data_field, optional_field=False):
-        """
-        Validate entry to be of type datetime and of
-        format %Y-%m-%d %H:%M:%S.
-
-        Parameters
-        ----------
-        data_field: dict
-            data field to be validated
-        optional_field: boolean
-            data field is optional
-
-        Raises
-        ------
-        ValueError
-            if data field is of invalid format
-
-        """
-        format_date = "%Y-%m-%d %H:%M:%S"
-        try:
-            datetime.datetime.strptime(data_field, format_date)
-        except (ValueError, TypeError) as error:
-            if not optional_field:
-                raise ValueError(
-                    f"invalid date format. Expected {format_date}; Found {data_field}"
-                ) from error
-
-    @staticmethod
-    def _validate_email(data_field, key):
-        """
-        Validate entry to be a email address
-
-        Parameters
-        ----------
-        data_field: dict
-            data field to be validated.
-        key: str
-            data field name to be validated.
-
-        Raises
-        ------
-        ValueError
-            if data field is of invalid format.
-
-        """
-        regex = r"\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b"
-        if not re.fullmatch(regex, data_field):
-            raise ValueError(f"invalid email format in field {key}: {data_field}")
-
-    def _validate_list(self, schema_type, data_list):
-        """
-        Validate schmema for list type entry
-
-        Parameters
-        ----------
-        schema_type
-            reference schema type (e.g., instrumentlist, documentlist).
-        data_list: list
-            list of dictionaries to be validated.
-        """
-
-        _ref_schema = gen.change_dict_keys_case(
-            metadata_model.metadata_input_reference_document_list(schema_type), lower_case=True
-        )
-        for entry in data_list:
-            self._validate_schema(_ref_schema, entry)
-
-    def _field_is_optional(self, field_dict):
-        """
-        Check if data field is labeled as optional in the reference metadata schema.
-        Dictionaries as datafields are tested for any optional fields.
-
-        Parameters
-        ----------
-        field_dict: dict
-            required field from reference metadata schema
-
-        Returns
-        -------
-        boolean
-            True if data field is required
-
-        Raises
-        ------
-        KeyError
-            if 'required' field is not defined in reference
-            metadata schema
-
-        """
-        try:
-            if field_dict["required"]:
-                return False
-        except KeyError:
-            if isinstance(field_dict, dict):
-                for value in field_dict.values():
-                    if isinstance(value, dict) and not self._field_is_optional(value):
-                        return False
-                return True
-            return False
-        return True
-
-    @staticmethod
-    def _remove_line_feed(string):
-        """
-        Remove all line feeds from a string
-
-        Parameters
-        ----------
-        str
-            input string
-
-        Returns
-        -------
-        str
-            with line feeds removed
-        """
-
-        return string.replace("\n", " ").replace("\r", "")