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

simtools/utils/value_conversion.py

@@ -0,0 +1,176 @@
+"""Value and quantity conversion."""
+
+import logging
+import re
+
+import numpy as np
+from astropy import units as u
+
+import simtools.utils.general as gen
+
+_logger = logging.getLogger(__name__)
+
+
+def extract_type_of_value(value) -> str:
+    """
+    Extract the string representation of the the type of a value.
+
+    For example, for a string, it returns 'str' rather than '<class 'str'>'.
+    Take into account also the case where the value is a numpy type.
+    """
+    _type = str(type(value))
+    if "numpy" in _type:
+        return re.sub(r"\d+", "", _type.split("'")[1].split(".")[-1])
+    if "astropy" in _type:
+        raise NotImplementedError("Astropy types are not supported yet.")
+    return _type.split("'")[1]
+
+
+def get_value_unit_type(value, unit_str=None):
+    """
+    Get the value, unit and type of a value.
+
+    The value is stripped of its unit and the unit is returned
+    in its string form (i.e., to_string()).
+    The type is returned as a string representation of the type.
+    For example, for a string, it returns 'str' rather than '<class 'str'>'.
+    An additional unit string can be given and the return value is converted to this units.
+
+    Note that Quantities are always floats, even if the original value is represented as an int.
+
+    Parameters
+    ----------
+    value: str, int, float, bool, u.Quantity
+        Value to be parsed.
+    unit_str: str
+        Unit to be used for the value.
+
+    Returns
+    -------
+    type of value, str, str
+        Value, unit in string representation (to_string())),
+        and string representation of the type of the value.
+    """
+    base_unit = None
+    if isinstance(value, str | u.Quantity):
+        try:
+            _quantity_value = u.Quantity(value)
+            base_value = _quantity_value.value
+            base_type = extract_type_of_value(base_value)
+            if _quantity_value.unit.to_string() != "":
+                base_unit = _quantity_value.unit.to_string()
+                try:  # handle case of e.g., "0 0" and avoid unit.scale
+                    float(base_unit)
+                    base_value = value
+                    base_type = "str"
+                    base_unit = None
+                except ValueError:
+                    pass
+        # ValueError: covers strings of type "5 not a unit"
+        except (TypeError, ValueError):
+            base_value = value
+            base_type = "str"
+    else:
+        base_value = value
+        base_type = extract_type_of_value(base_value)
+
+    if unit_str is not None:
+        try:
+            base_value = base_value * u.Unit(base_unit).to(u.Unit(unit_str))
+        except u.UnitConversionError:
+            _logger.error(f"Cannot convert {base_unit} to {unit_str}.")
+            raise
+        except TypeError:
+            pass
+        base_unit = unit_str
+
+    return base_value, base_unit, base_type
+
+
+def split_value_and_unit(value):
+    """
+    Split a value into its value and unit.
+
+    Takes into account the case where the value is a Quantity, a number,
+    or a simtools-type string encoding a list of values and units.
+
+    Parameters
+    ----------
+    value: str, int, float, bool, u.Quantity
+        Value to be parsed.
+
+    Returns
+    -------
+    value, str
+        Value and units as (value, unit), or lists of values and unites
+    """
+    if isinstance(value, u.Quantity):
+        return _split_value_is_quantity(value)
+    if isinstance(value, str):
+        return _split_value_is_string(value)
+    if isinstance(value, list | np.ndarray):
+        return _split_value_is_list(value)
+    return value, None
+
+
+def _split_value_is_quantity(value):
+    """Split value and unit for an astropy Quantity."""
+    if isinstance(value.value, list | np.ndarray):  # type [100.0, 200] * u.m,
+        return list(value.value), [str(value.unit)] * len(value)
+    return value.value, str(value.unit)
+
+
+def _split_value_is_string(value):
+    """Split vale and unit for a string."""
+    if value.isdigit():  # single integer value
+        return int(value), None
+    try:  # single value with/without unit
+        return u.Quantity(value).value, str(u.Quantity(value).unit)
+    except ValueError:
+        return _split_value_is_list(gen.convert_string_to_list(value))
+    except TypeError:  # string value (not numerical)
+        return value, None
+
+
+def _split_value_is_list(value):
+    """Split value and unit for a list."""
+    value_list = []
+    unit_list = []
+    for item in value:
+        _value, _unit = split_value_and_unit(item)
+        value_list.append(_value)
+        if isinstance(_unit, str):
+            unit_list.append(_unit)
+        else:
+            unit_list.append(None)
+    return value_list, unit_list
+
+
+def get_value_as_quantity(value, unit):
+    """
+    Get a value as a Quantity with a given unit. If value is a Quantity, convert to the given unit.
+
+    Parameters
+    ----------
+    value:
+        value to get a unit. It can be a float, int, or a Quantity (convertible to 'unit').
+    unit: astropy.units.Unit
+        Unit to apply to 'quantity'.
+
+    Returns
+    -------
+    astropy.units.Quantity
+        Quantity of value 'quantity' and unit 'unit'.
+
+    Raises
+    ------
+    u.UnitConversionError
+        If the value cannot be converted to the given unit.
+    """
+    if isinstance(value, u.Quantity):
+        try:
+            return value.to(unit)
+        except u.UnitConversionError:
+            _logger.error(f"Cannot convert {value.unit} to {unit}.")
+            raise
+    return value * unit

simtools/version.py

@@ -1,3 +1,5 @@
+"""Software version setting."""
+
 # this is adapted from https://github.com/cta-observatory/ctapipe/blob/main/ctapipe/version.py
 # which is adapted from https://github.com/astropy/astropy/blob/master/astropy/version.py
 # see https://github.com/astropy/astropy/pull/10774 for a discussion on why this needed.

simtools/visualization/legend_handlers.py

@@ -1,12 +1,9 @@
+"""Helper functions for legend handlers used for plotting."""
+
 import matplotlib.colors as mcolors
 import matplotlib.patches as mpatches
 import numpy as np
 
-from simtools.corsika.corsika_config import CorsikaConfig
-from simtools.io_operations.io_handler import IOHandler
-from simtools.utils import names
-from simtools.utils.names import hess, lst, magic, mst, sct, sst, veritas
-
 __all__ = [
     "EdgePixelObject",
     "HexEdgePixelHandler",
@@ -30,87 +27,124 @@ __all__ = [
     "TelescopeHandler",
 ]
 
+# assume same size of telescope at both sides
+# (good assumption for plotting)
+lst = "LSTN"
+mst = "MSTN"
+sst = "SSTS"
+sct = "SCTS"
+hess = "HESS"
+magic = "MAGIC"
+veritas = "VERITAS"
+
 
-class TelescopeHandler(object):
+def calculate_center(handlebox, width_factor=3, height_factor=3):
     """
-    Telescope handler that centralizes the telescope information. Individual telescopes handlers
-    inherit from this class.
+    Calculate the center of the handlebox based on given factors.
+
+    Parameters
+    ----------
+    handlebox: matplotlib.legend.Legend
+        The handlebox object from the legend.
+    width_factor: int, optional
+        The factor to adjust the width.
+    height_factor: int, optional
+        The factor to adjust the height.
+
+    Returns
+    -------
+    tuple
+        The calculated (x0, y0) position.
     """
+    x0 = handlebox.xdescent + handlebox.width / width_factor
+    y0 = handlebox.ydescent + handlebox.height / height_factor
+    return x0, y0
 
-    def __init__(self):
-        io_handler = IOHandler()
-        corsika_parameters_file = io_handler.get_input_data_file(
-            "parameters", "corsika_parameters.yml"
-        )
-        corsika_info = CorsikaConfig.load_corsika_parameters_file(corsika_parameters_file)
 
-        self.radius_dict = {}
+class TelescopeHandler:
+    """
+    Telescope handler that centralizes the telescope information.
+
+    Individual telescopes handlers inherit from this class.
+    """
+
+    def __init__(self, radius=None):
         self.colors_dict = {
-            lst: "darkorange",
-            mst: "dodgerblue",
-            sct: "black",
-            sst: "darkgreen",
-            hess: "grey",
-            magic: "grey",
-            veritas: "grey",
+            "LSTN": "darkorange",
+            "MSTN": "dodgerblue",
+            "LSTS": "darkorange",
+            "MSTS": "dodgerblue",
+            "SCTS": "black",
+            "SSTS": "darkgreen",
+            "HESS": "grey",
+            "MAGIC": "grey",
+            "VERITAS": "grey",
+        }
+
+        # hardwired values; this is for plotting purposes only
+        self.radius_dict = {
+            "LSTN": 12.5,
+            "MSTN": 9.15,
+            "LSTS": 12.5,
+            "MSTS": 9.15,
+            "SCTS": 7.15,
+            "SSTS": 3.0,
+            "HESS": 6.0,
+            "MAGIC": 8.5,
+            "VERITAS": 6.0,
         }
-        for key, value in corsika_info["corsika_sphere_radius"].items():
-            self.radius_dict[key] = value["value"]
 
 
-class PixelObject(object):
+class PixelObject:
     """Pixel Object."""
 
 
-class EdgePixelObject(object):
+class EdgePixelObject:
     """Edge-Pixel Object."""
 
 
-class OffPixelObject(object):
+class OffPixelObject:
     """Off-Pixel Object."""
 
 
-class LSTObject(object):
+class LSTObject:
     """LST Object."""
 
 
-class MSTObject(object):
+class MSTObject:
     """MST Object."""
 
 
-class SCTObject(object):
+class SCTObject:
     """SCT Object."""
 
 
-class SSTObject(object):
+class SSTObject:
     """SST Object."""
 
 
-class HESSObject(object):
+class HESSObject:
     """HESS Object."""
 
 
-class MAGICObject(object):
+class MAGICObject:
     """MAGIC Object."""
 
 
-class VERITASObject(object):
+class VERITASObject:
     """VERITAS Object."""
 
 
-class MeanRadiusOuterEdgeObject(object):
+class MeanRadiusOuterEdgeObject:
     """Object for Mean radius outer edge."""
 
 
-class HexPixelHandler(object):
-    """
-    Legend handler class to plot a hexagonal "on" pixel.
-    """
+class HexPixelHandler:
+    """Legend handler class to plot a hexagonal "on" pixel."""
 
     @staticmethod
-    def legend_artist(legend, orig_handle, fontsize, handlebox):
-        x0, y0 = handlebox.xdescent + handlebox.width / 3, handlebox.ydescent + handlebox.height / 3
-        # width = height = handlebox.height
+    def legend_artist(_, __, ___, handlebox):  # noqa: D102
+        x0, y0 = calculate_center(handlebox)
         patch = mpatches.RegularPolygon(
             (x0, y0),
             numVertices=6,
@@ -124,43 +158,31 @@ class HexPixelHandler(object):
         return patch
 
 
-class HexEdgePixelHandler(object):
-    """
-    Legend handler class to plot a hexagonal "edge" pixel.
-    """
+class HexEdgePixelHandler:
+    """Legend handler class to plot a hexagonal "edge" pixel."""
 
     @staticmethod
-    def legend_artist(legend, orig_handle, fontsize, handlebox):
-        x0, y0 = (
-            handlebox.xdescent + handlebox.width / 3,
-            handlebox.ydescent + handlebox.height / 3,
-        )
-        # width = height = handlebox.height
+    def legend_artist(_, __, ___, handlebox):  # noqa: D102
+        x0, y0 = calculate_center(handlebox)
         patch = mpatches.RegularPolygon(
             (x0, y0),
             numVertices=6,
             radius=0.7 * handlebox.height,
             orientation=np.deg2rad(30),
-            facecolor=mcolors.to_rgb("brown") + (0.5,),
-            edgecolor=mcolors.to_rgb("black") + (1,),
+            facecolor=(*mcolors.to_rgb("brown"), 0.5),
+            edgecolor=(*mcolors.to_rgb("black"), 1),
             transform=handlebox.get_transform(),
         )
         handlebox.add_artist(patch)
         return patch
 
 
-class HexOffPixelHandler(object):
-    """
-    Legend handler class to plot a hexagonal "off" pixel.
-    """
+class HexOffPixelHandler:
+    """Legend handler class to plot a hexagonal "off" pixel."""
 
     @staticmethod
-    def legend_artist(legend, orig_handle, fontsize, handlebox):
-        x0, y0 = (
-            handlebox.xdescent + handlebox.width / 3,
-            handlebox.ydescent + handlebox.height / 3,
-        )
-        # width = height = handlebox.height
+    def legend_artist(_, __, ___, handlebox):  # noqa: D102
+        x0, y0 = calculate_center(handlebox)
         patch = mpatches.RegularPolygon(
             (x0, y0),
             numVertices=6,
@@ -174,13 +196,11 @@ class HexOffPixelHandler(object):
         return patch
 
 
-class SquarePixelHandler(object):
-    """
-    Legend handler class to plot a square "on" pixel.
-    """
+class SquarePixelHandler:
+    """Legend handler class to plot a square "on" pixel."""
 
     @staticmethod
-    def legend_artist(legend, orig_handle, fontsize, handlebox):
+    def legend_artist(_, __, ___, handlebox):  # noqa: D102
         x0, y0 = handlebox.xdescent, handlebox.ydescent
         width = height = handlebox.height
         patch = mpatches.Rectangle(
@@ -195,34 +215,30 @@ class SquarePixelHandler(object):
         return patch
 
 
-class SquareEdgePixelHandler(object):
-    """
-    Legend handler class to plot a square "edge" pixel.
-    """
+class SquareEdgePixelHandler:
+    """Legend handler class to plot a square "edge" pixel."""
 
     @staticmethod
-    def legend_artist(legend, orig_handle, fontsize, handlebox):
+    def legend_artist(_, __, ___, handlebox):  # noqa: D102
         x0, y0 = handlebox.xdescent, handlebox.ydescent
         width = height = handlebox.height
         patch = mpatches.Rectangle(
             [x0, y0],
             width,
             height,
-            facecolor=mcolors.to_rgb("brown") + (0.5,),
-            edgecolor=mcolors.to_rgb("black") + (1,),
+            facecolor=(*mcolors.to_rgb("brown"), 0.5),
+            edgecolor=(*mcolors.to_rgb("black"), 1),
             transform=handlebox.get_transform(),
         )
         handlebox.add_artist(patch)
         return patch
 
 
-class SquareOffPixelHandler(object):
-    """
-    Legend handler class to plot a square "off" pixel.
-    """
+class SquareOffPixelHandler:
+    """Legend handler class to plot a square "off" pixel."""
 
     @staticmethod
-    def legend_artist(legend, orig_handle, fontsize, handlebox):
+    def legend_artist(_, __, ___, handlebox):  # noqa: D102
         x0, y0 = handlebox.xdescent, handlebox.ydescent
         width = height = handlebox.height
         patch = mpatches.Rectangle(
@@ -238,18 +254,13 @@ class SquareOffPixelHandler(object):
 
 
 class LSTHandler(TelescopeHandler):
-    """
-    Legend handler class to plot a representation of an LST in an array layout.
-    """
+    """Legend handler class to plot a representation of an LST in an array layout."""
 
-    def legend_artist(self, legend, orig_handle, fontsize, handlebox):
-        center = (
-            handlebox.xdescent + 0.3 * handlebox.width,
-            handlebox.ydescent + 0.5 * handlebox.height,
-        )
+    def legend_artist(self, _, __, ___, handlebox):  # noqa: D102
+        x0, y0 = calculate_center(handlebox, 10 / 3, 2)
         radius = handlebox.height
         patch = mpatches.Circle(
-            xy=center,
+            xy=(x0, y0),
             radius=radius * self.radius_dict[lst] / self.radius_dict[lst],
             facecolor="none",
             edgecolor=self.colors_dict[lst],
@@ -260,18 +271,13 @@ class LSTHandler(TelescopeHandler):
 
 
 class MSTHandler(TelescopeHandler):
-    """
-    Legend handler class to plot a representation of an MST in an array layout.
-    """
+    """Legend handler class to plot a representation of an MST in an array layout."""
 
-    def legend_artist(self, legend, orig_handle, fontsize, handlebox):
-        center = (
-            handlebox.xdescent + 0.25 * handlebox.width,
-            handlebox.ydescent + 0.5 * handlebox.height,
-        )
+    def legend_artist(self, _, __, ___, handlebox):  # noqa: D102
+        x0, y0 = calculate_center(handlebox, 4, 2)
         radius = handlebox.height
         patch = mpatches.Circle(
-            xy=center,
+            xy=(x0, y0),
             radius=radius * self.radius_dict[mst] / self.radius_dict[lst],
             facecolor=self.colors_dict[mst],
             edgecolor=self.colors_dict[mst],
@@ -282,18 +288,13 @@ class MSTHandler(TelescopeHandler):
 
 
 class SSTHandler(TelescopeHandler):
-    """
-    Legend handler class to plot a representation of an SST in an array layout.
-    """
+    """Legend handler class to plot a representation of an SST in an array layout."""
 
-    def legend_artist(self, legend, orig_handle, fontsize, handlebox):
-        center = (
-            handlebox.xdescent + 0.25 * handlebox.width,
-            handlebox.ydescent + 0.5 * handlebox.height,
-        )
+    def legend_artist(self, _, __, ___, handlebox):  # noqa: D102
+        x0, y0 = calculate_center(handlebox, 4, 2)
         radius = handlebox.height
         patch = mpatches.Circle(
-            xy=center,
+            xy=(x0, y0),
             radius=radius * self.radius_dict[sst] / self.radius_dict[lst],
             facecolor=self.colors_dict[sst],
             edgecolor=self.colors_dict[sst],
@@ -304,12 +305,10 @@ class SSTHandler(TelescopeHandler):
 
 
 class SCTHandler(TelescopeHandler):
-    """
-    Legend handler class to plot a representation of an SCT in an array layout.
-    """
+    """Legend handler class to plot a representation of an SCT in an array layout."""
 
-    def legend_artist(self, legend, orig_handle, fontsize, handlebox):
-        x0, y0 = handlebox.xdescent + 0.1 * handlebox.width, handlebox.ydescent
+    def legend_artist(self, _, __, ___, handlebox):  # noqa: D102
+        x0, y0 = calculate_center(handlebox, 10, 1)
         width = height = handlebox.height
         patch = mpatches.Rectangle(
             [x0, y0],
@@ -324,15 +323,10 @@ class SCTHandler(TelescopeHandler):
 
 
 class HESSHandler(TelescopeHandler):
-    """
-    Legend handler class to plot a representation of an HESS in an array layout.
-    """
+    """Legend handler class to plot a representation of an HESS in an array layout."""
 
-    def legend_artist(self, legend, orig_handle, fontsize, handlebox):
-        x0, y0 = (
-            handlebox.xdescent + handlebox.width / 3,
-            handlebox.ydescent + handlebox.height / 3,
-        )
+    def legend_artist(self, _, __, ___, handlebox):
+        x0, y0 = calculate_center(handlebox)
         radius = handlebox.height
         patch = mpatches.RegularPolygon(
             (x0, y0),
@@ -348,15 +342,10 @@ class HESSHandler(TelescopeHandler):
 
 
 class MAGICHandler(TelescopeHandler):
-    """
-    Legend handler class to plot a representation of an MAGIC in an array layout.
-    """
+    """Legend handler class to plot a representation of an MAGIC in an array layout."""
 
-    def legend_artist(self, legend, orig_handle, fontsize, handlebox):
-        x0, y0 = (
-            handlebox.xdescent + handlebox.width / 3,
-            handlebox.ydescent + handlebox.height / 3,
-        )
+    def legend_artist(self, _, __, ___, handlebox):
+        x0, y0 = calculate_center(handlebox)
         radius = handlebox.height
         patch = mpatches.RegularPolygon(
             (x0, y0),
@@ -372,15 +361,10 @@ class MAGICHandler(TelescopeHandler):
 
 
 class VERITASHandler(TelescopeHandler):
-    """
-    Legend handler class to plot a representation of an VERITAS in an array layout.
-    """
+    """Legend handler class to plot a representation of an VERITAS in an array layout."""
 
-    def legend_artist(self, legend, orig_handle, fontsize, handlebox):
-        x0, y0 = (
-            handlebox.xdescent + handlebox.width / 3,
-            handlebox.ydescent + handlebox.height / 3,
-        )
+    def legend_artist(self, _, __, ___, handlebox):
+        x0, y0 = calculate_center(handlebox)
         radius = handlebox.height
         patch = mpatches.RegularPolygon(
             (x0, y0),
@@ -395,20 +379,15 @@ class VERITASHandler(TelescopeHandler):
         return patch
 
 
-class MeanRadiusOuterEdgeHandler(object):
-    """
-    Legend handler class to plot a the mean radius outer edge of the dish.
-    """
+class MeanRadiusOuterEdgeHandler:
+    """Legend handler class to plot a the mean radius outer edge of the dish."""
 
     @staticmethod
-    def legend_artist(legend, orig_handle, fontsize, handlebox):
-        center = (
-            handlebox.xdescent + 0.25 * handlebox.width,
-            handlebox.ydescent + 0.25 * handlebox.height,
-        )
+    def legend_artist(_, __, ___, handlebox):  # noqa: D102
+        x0, y0 = calculate_center(handlebox, 4, 4)
         radius = handlebox.height
         patch = mpatches.Circle(
-            xy=center,
+            xy=(x0, y0),
             radius=radius,
             facecolor="none",
             edgecolor="darkorange",
@@ -419,8 +398,10 @@ class MeanRadiusOuterEdgeHandler(object):
 
 
 all_telescope_objects = {
-    lst: LSTObject,
-    mst: MSTObject,
+    "LSTN": LSTObject,
+    "LSTS": LSTObject,
+    "MSTN": MSTObject,
+    "MSTS": MSTObject,
     sct: SCTObject,
     sst: SSTObject,
     hess: HESSObject,
@@ -428,8 +409,10 @@ all_telescope_objects = {
     veritas: VERITASObject,
 }
 all_telescope_handlers = {
-    lst: LSTHandler,
-    mst: MSTHandler,
+    "LSTN": LSTHandler,
+    "LSTS": LSTHandler,
+    "MSTN": MSTHandler,
+    "MSTS": MSTHandler,
     sct: SCTHandler,
     sst: SSTHandler,
     hess: HESSHandler,
@@ -438,7 +421,7 @@ all_telescope_handlers = {
 }
 legend_handler_map = {}
 try:
-    for tel_type in names.all_telescope_class_names:
+    for tel_type in all_telescope_objects.keys():
         legend_handler_map[all_telescope_objects[tel_type]] = all_telescope_handlers[tel_type]
 except KeyError:
     pass