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

simtools/layout/geo_coordinates.py

@@ -0,0 +1,196 @@
+import logging
+
+import astropy.units as u
+import numpy as np
+import pyproj
+
+
+class GeoCoordinates:
+    """
+    Geospatial Coordinate systems.
+    Defines UTM, WGS84 and ground (sim_telarray) coordinate systems.
+
+    """
+
+    def __init__(self):
+        """
+        Initialize GeoCoordinates
+
+        """
+
+        self._logger = logging.getLogger(__name__)
+
+    def crs_utm(self, epsg):
+        """
+        UTM coordinate system definition.
+
+        Parameters
+        ----------
+        epsg: int
+            EPSG code for UTM zone.
+
+        Returns
+        -------
+        pyproj.CRS
+            UTM coordinate system.
+
+        """
+        if epsg:
+            crs_utm = pyproj.CRS.from_user_input(epsg)
+            self._logger.debug(f"UTM coordinate system: {crs_utm}")
+            return crs_utm
+
+        return None
+
+    @staticmethod
+    def crs_wgs84():
+        """
+        WGS84 coordinate system definition.
+
+        Returns
+        -------
+        pyproj.CRS
+            WGS84 coordinate system.
+
+        """
+        return pyproj.CRS("EPSG:4326")
+
+    def crs_local(self, reference_point):
+        """
+        Local coordinate system definition.
+        This is a cartesian coordinate system with the origin at the array center.
+        X-axis points towards geographic North, y-axis towards geographic West.
+
+        Parameters
+        ----------
+        reference_point: simtools.layout.telescope_position
+            Reference coordinate.
+
+        Returns
+        -------
+        pyproj.CRS
+            local coordinate system.
+
+        """
+        try:
+            if self._valid_reference_point(reference_point):
+                _center_lat, _center_lon, _ = reference_point.get_coordinates("mercator")
+                _scale_factor_k_0 = self._coordinate_scale_factor(reference_point)
+                proj4_string = (
+                    "+proj=tmerc +ellps=WGS84 +datum=WGS84"
+                    f" +lon_0={_center_lon} +lat_0={_center_lat}"
+                    f" +axis=nwu +units=m +k_0={_scale_factor_k_0}"
+                )
+                crs_local = pyproj.CRS.from_proj4(proj4_string)
+                self._logger.debug(f"Ground (sim_telarray) coordinate system: {crs_local}")
+                return crs_local
+        except AttributeError:
+            self._logger.error("Failed to derive local coordinate system. Missing reference point")
+            raise
+
+        return None
+
+    def _valid_reference_point(self, reference_point):
+        """
+        Check if reference point has valid long/lat coordinates (including altitude).
+        This is required to derive the local coordinate system.
+        Try if a conversion from UTM coordinates to long/lat is possible.
+
+        Parameters
+        ----------
+        reference_point: simtools.layout.telescope_position
+            Reference coordinate.
+
+        Returns
+        -------
+        bool
+            True if reference point has valid coordinates.
+
+        """
+        _center_lat, _center_lon, _center_alt = reference_point.get_coordinates("mercator")
+        if np.isnan(_center_alt.value):
+            self._logger.debug("Missing array center altitude")
+            return False
+
+        if np.isnan(_center_lat.value) or np.isnan(_center_lon.value):
+            self._logger.debug(
+                "Invalid array center coordinates "
+                f"(lat={_center_lat}, lon={_center_lon}, alt={_center_alt})"
+            )
+            return False
+
+        return True
+
+    def _coordinate_scale_factor(self, reference_point):
+        """
+        Derive coordinate scale factor for transformation into
+        local coordinate system
+
+        Depends on latitude and altitude of array center.
+        Ignores transformation of geodetic height to geocentric height
+        (this introduces an error on the sub-mm scale).
+
+        Parameters
+        ----------
+        reference_point: simtools.layout.telescope_position
+            Reference coordinate.
+
+        Returns
+        -------
+        k_0: float
+            Scale factor for local coordinate system.
+
+        Raises
+        ------
+        AttributeError
+            If reference_point does not have a valid center or UTM system is not defined.
+
+        """
+
+        try:
+            _center_lat, _, _centre_altitude = reference_point.get_coordinates("mercator")
+        except AttributeError:
+            self._logger.debug("Missing array center, cannot derive coordinate scale factor")
+            raise
+
+        crs_utm = self.crs_wgs84()
+        _semi_major_axis = crs_utm.geodetic_crs.ellipsoid.semi_major_metre * u.m
+        _semi_minor_axis = crs_utm.geodetic_crs.ellipsoid.semi_minor_metre * u.m
+
+        _local_geo_radius = self._geocentric_radius(_center_lat, _semi_major_axis, _semi_minor_axis)
+
+        return (_local_geo_radius.value + _centre_altitude.value) / _local_geo_radius.value
+
+    def _geocentric_radius(self, latitude, semi_major_axis, semi_minor_axis):
+        """
+        Calculate geocentric radius from WGS84 ellipsoid parameters.
+
+        derivation:
+        https://gis.stackexchange.com/questions/20200/how-do-you-compute-the-earths-radius-at-a-given-geodetic-latitude
+
+        Parameters
+        ----------
+        latitude: astropy.Quantity
+            Latitude in degrees.
+        semi_major_axis: astropy.Quantity
+            Semi-major axis of ellipsoid in meters.
+        semi_minor_axis: astropy.Quantity
+            Semi-minor axis of ellipsoid in meters.
+
+        Returns
+        -------
+        float
+            Ellipsoid radius at given latitude.
+
+        """
+
+        _lat_rad = np.deg2rad(latitude)
+        _numerator = (semi_major_axis**2 * np.cos(_lat_rad)) ** 2 + (
+            semi_minor_axis**2 * np.sin(_lat_rad)
+        ) ** 2
+
+        _denominator = (
+            semi_major_axis**2 * np.cos(_lat_rad) ** 2
+            + semi_minor_axis**2 * np.sin(_lat_rad) ** 2
+        )
+        return np.sqrt(_numerator / _denominator)

simtools/layout/telescope_position.py

@@ -45,10 +45,10 @@ class TelescopePosition:
 
         """
         telstr = self.name
-        if self.has_coordinates("corsika"):
+        if self.has_coordinates("ground"):
             telstr += (
-                f"\t CORSIKA x(->North): {self.crs['corsika']['xx']['value']:0.2f} "
-                f"y(->West): {self.crs['corsika']['yy']['value']:0.2f}"
+                f"\t Ground x(->North): {self.crs['ground']['xx']['value']:0.2f} "
+                f"y(->West): {self.crs['ground']['yy']['value']:0.2f}"
             )
         if self.has_coordinates("utm"):
             telstr += (
@@ -94,7 +94,7 @@ class TelescopePosition:
             _zz = self.crs[crs_name]["zz"]["value"]
             _zz_header = self.crs[crs_name]["zz"]["name"]
             if (
-                crs_name == "corsika"
+                crs_name == "ground"
                 and corsika_obs_level is not None
                 and corsika_sphere_center is not None
             ):
@@ -105,7 +105,7 @@ class TelescopePosition:
                         corsika_sphere_center,
                     )
                 ).value
-                _zz_header = "pos_z"
+                _zz_header = "position_z"
 
             if crs_name == "mercator":
                 telstr = (
@@ -304,7 +304,7 @@ class TelescopePosition:
 
     def _get_reference_system_from(self):
         """
-        Return coordinate system and coordinatee for a fully defined system. The first fully\
+        Return coordinate system and coordinates for a fully defined system. The first fully\
         defined system from self.crs is returned.
 
         Returns
@@ -353,7 +353,7 @@ class TelescopePosition:
             np.isfinite(
                 np.array(
                     [self.crs[crs_name]["xx"]["value"], self.crs[crs_name]["yy"]["value"]],
-                    dtype=float,
+                    dtype=np.float64,
                 )
             )
         )
@@ -481,7 +481,7 @@ class TelescopePosition:
 
         """
 
-        self._set_coordinate_system("corsika", crs_local)
+        self._set_coordinate_system("ground", crs_local)
         self._set_coordinate_system("utm", crs_utm)
         self._set_coordinate_system("mercator", crs_wgs84)
 
@@ -512,15 +512,15 @@ class TelescopePosition:
         Returns
         -------
         dict
-           coordinate system defintion
+           coordinate system definition
 
         """
 
         return {
-            "corsika": {
+            "ground": {
                 "crs": None,
-                "xx": {"name": "pos_x", "value": np.nan, "unit": u.Unit("m")},
-                "yy": {"name": "pos_y", "value": np.nan, "unit": u.Unit("m")},
+                "xx": {"name": "position_x", "value": np.nan, "unit": u.Unit("m")},
+                "yy": {"name": "position_y", "value": np.nan, "unit": u.Unit("m")},
                 "zz": {"name": "altitude", "value": np.nan, "unit": u.Unit("m")},
             },
             "mercator": {

simtools/model/array_model.py

@@ -1,12 +1,13 @@
 import logging
 from copy import copy
 
-from simtools import db_handler, io_handler
-from simtools.layout.layout_array import LayoutArray
+from simtools import db_handler
+from simtools.io_operations import io_handler
+from simtools.layout.array_layout import ArrayLayout
 from simtools.model.telescope_model import TelescopeModel
 from simtools.simtel.simtel_config_writer import SimtelConfigWriter
 from simtools.utils import names
-from simtools.utils.general import collect_data_from_yaml_or_dict
+from simtools.utils.general import collect_data_from_file_or_dict
 
 __all__ = ["ArrayModel", "InvalidArrayConfigData"]
 
@@ -18,7 +19,7 @@ class InvalidArrayConfigData(Exception):
 class ArrayModel:
     """
     ArrayModel is an abstract representation of the MC model at the array level. It contains the\
-    list of TelescopeModel's and a LayoutArray.
+    list of TelescopeModel's and a ArrayLayout.
 
     Parameters
     ----------
@@ -46,7 +47,7 @@ class ArrayModel:
         self.model_version = None
         self._config_file_path = None
         self.io_handler = io_handler.IOHandler()
-        array_config_data = collect_data_from_yaml_or_dict(array_config_file, array_config_data)
+        array_config_data = collect_data_from_file_or_dict(array_config_file, array_config_data)
         self._load_array_data(array_config_data)
         self._set_config_file_directory()
         self._build_array_model()
@@ -81,11 +82,11 @@ class ArrayModel:
         # Site
         self.site = names.validate_site_name(array_config_data["site"])
 
-        # Grabbing layout name and building LayoutArray
-        self.layout_name = names.validate_layout_array_name(array_config_data["layout_name"])
-        self.layout = LayoutArray.from_layout_array_name(
+        # Grabbing layout name and building ArrayLayout
+        self.layout_name = names.validate_array_layout_name(array_config_data["layout_name"])
+        self.layout = ArrayLayout.from_array_layout_name(
             mongo_db_config=self.mongo_db_config,
-            layout_array_name=self.site + "-" + self.layout_name,
+            array_layout_name=self.site + "-" + self.layout_name,
             label=self.label,
         )
 
@@ -94,8 +95,8 @@ class ArrayModel:
             "model_version" not in array_config_data.keys()
             or array_config_data["model_version"] is None
         ):
-            self._logger.warning("model_version not given in array_config_data - using current")
-            self.model_version = "current"
+            self._logger.warning("model_version not given in array_config_data - using 'Released'")
+            self.model_version = "Released"
         else:
             self.model_version = names.validate_model_version_name(
                 array_config_data["model_version"]
@@ -144,6 +145,7 @@ class ArrayModel:
         """
 
         # Getting site parameters from DB
+        self._logger.debug("Getting site parameters from DB")
         db = db_handler.DatabaseHandler(mongo_db_config=self.mongo_db_config)
         self._site_parameters = db.get_site_parameters(
             self.site, self.model_version, only_applicable=True
@@ -154,7 +156,7 @@ class ArrayModel:
         _all_telescope_model_names = []  # List of telescope names without repetition
         _all_pars_to_change = {}
         for tel in self.layout:
-            tel_size = names.get_telescope_type(tel.name)
+            tel_size = names.get_telescope_class(tel.name)
 
             # Collecting telescope name and pars to change from array_config_data
             tel_model_name, pars_to_change = self._get_single_telescope_info_from_array_config(
@@ -174,7 +176,7 @@ class ArrayModel:
                     telescope_model_name=tel_model_name,
                     model_version=self.model_version,
                     label=self.label,
-                    mongo_db_config=self.mongo_db_config,
+                    db=db,
                 )
             else:
                 # Telescope name already exists.
@@ -192,7 +194,7 @@ class ArrayModel:
         if len(self._telescope_model) != len(self.layout):
             self._logger.warning(
                 "Number of telescopes in the list of telescope models does "
-                "not match the number of telescopes in the LayoutArray - something is wrong!"
+                "not match the number of telescopes in the ArrayLayout - something is wrong!"
             )
 
         # Changing parameters, if there are any in all_pars_to_change

simtools/model/camera.py

@@ -11,12 +11,9 @@ from scipy.spatial import cKDTree as KDTree
 from scipy.spatial import distance
 
 import simtools.visualization.legend_handlers as leg_h
-from simtools.model.model_utils import (
-    get_camera_name,
-    get_telescope_class,
-    is_two_mirror_telescope,
-)
-from simtools.utils.general import rotate
+from simtools.model.model_utils import is_two_mirror_telescope
+from simtools.utils import names
+from simtools.utils.geometry import rotate
 
 __all__ = ["Camera"]
 
@@ -51,7 +48,7 @@ class Camera:
         self._logger = logging.getLogger(__name__)
 
         self._telescope_model_name = telescope_model_name
-        self._camera_name = get_camera_name(self._telescope_model_name)
+        _, self._camera_name, _ = names.split_telescope_model_name(telescope_model_name)
         self._camera_config_file = camera_config_file
         self._focal_length = focal_length
         if self._focal_length <= 0:
@@ -743,7 +740,7 @@ class Camera:
 
             if self._pixels["pix_id"][i_pix] < pixels_id_to_print + 1:
                 font_size = 4
-                if get_telescope_class(self._telescope_model_name) == "SCT":
+                if names.get_telescope_class(self._telescope_model_name) == "SCT":
                     font_size = 2
                 plt.text(
                     xy_pix_pos[0],

simtools/model/mirrors.py

@@ -1,5 +1,7 @@
 import logging
 
+import astropy.units as u
+import numpy as np
 from astropy.table import Table
 
 __all__ = ["InvalidMirrorListFile", "Mirrors"]
@@ -19,24 +21,25 @@ class Mirrors:
         mirror list in sim_telarray or ecsv format (with panel focal length only).
     """
 
-    def __init__(self, mirror_list_file):
+    def __init__(self, mirror_list_file, parameters=None):
         """
         Initialize Mirrors.
         """
         self._logger = logging.getLogger(__name__)
         self._logger.debug("Mirrors Init")
 
-        self._mirrors = {}
-        self.diameter = None
-        self.shape = None
+        self.mirror_table = Table()
+        self.mirror_diameter = None
+        self.shape_type = None
         self.number_of_mirrors = 0
+        self.parameters = parameters
 
         self._mirror_list_file = mirror_list_file
         self._read_mirror_list()
 
     def _read_mirror_list(self):
         """
-        Read the mirror lists from disk and store the data. Allow reading of mirro lists in \
+        Read the mirror lists from disk and store the data. Allow reading of mirror lists in \
         sim_telarray and ecsv format
         """
 
@@ -54,32 +57,66 @@ class Mirrors:
         InvalidMirrorListFile
             If number of mirrors is 0.
         """
+        # Getting mirror parameters from mirror list.
 
-        # TODO - temporary hard wired geopars - should come from DB
-        self.diameter = 120
-        self.shape = 1
-        self._logger.debug(f"Shape = {self.shape}")
-        self._logger.debug(f"Diameter = {self.diameter}")
-
-        _mirror_table = Table.read(self._mirror_list_file, format="ascii.ecsv")
+        self.mirror_table = Table.read(self._mirror_list_file, format="ascii.ecsv")
         self._logger.debug(f"Reading mirror properties from {self._mirror_list_file}")
-        try:
-            self._mirrors["flen"] = list(_mirror_table["mirror_panel_radius"].to("cm").value / 2.0)
-            self.number_of_mirrors = len(self._mirrors["flen"])
-            self._mirrors["number"] = list(range(self.number_of_mirrors))
-            self._mirrors["pos_x"] = [0.0] * self.number_of_mirrors
-            self._mirrors["pos_y"] = [0.0] * self.number_of_mirrors
-            self._mirrors["diameter"] = [self.diameter] * self.number_of_mirrors
-            self._mirrors["shape"] = [self.shape] * self.number_of_mirrors
-        except KeyError:
-            self._logger.debug(
-                f"Missing column for mirror panel focal length (flen) in {self._mirror_list_file}"
-            )
+
+        self.number_of_mirrors = np.shape(self.mirror_table)[0]
+        self._logger.debug(f"Number of Mirrors = {self.number_of_mirrors}")
 
         if self.number_of_mirrors == 0:
             msg = "Problem reading mirror list file"
             self._logger.error(msg)
-            raise InvalidMirrorListFile()
+            raise InvalidMirrorListFile
+
+        try:
+            self.mirror_diameter = u.Quantity(self.mirror_table["mirror_diameter"])[0]
+            self._logger.debug(f"Mirror diameter = {self.mirror_diameter}")
+        except KeyError:
+            self._logger.debug("Mirror mirror_panel_diameter not in mirror file")
+            try:
+                self.mirror_diameter = u.Quantity(
+                    self.parameters["mirror_panel_diameter"]["Value"],
+                    self.parameters["mirror_panel_diameter"]["units"],
+                )
+                self._logger.debug("Take mirror_panel_diameter from parameters")
+            except TypeError as error:
+                msg = "Mirror mirror_panel_diameter not contained in DB"
+                self._logger.error(msg)
+                raise TypeError(msg) from error
+        if "focal_length" not in self.mirror_table.colnames:
+            try:
+                self.mirror_table["focal_length"] = (
+                    self.mirror_table["mirror_curvature_radius"].to("cm") / 2
+                )
+            except KeyError:
+                self._logger.debug("mirror_curvature_radius not contained in mirror list")
+                try:
+                    self.mirror_table["focal_length"] = self.number_of_mirrors * [
+                        u.Quantity(
+                            self.parameters["mirror_focal_length"]["Value"],
+                            self.parameters["mirror_focal_length"]["units"],
+                        )
+                    ]
+                    self._logger.debug("Take mirror_focal_length from parameters")
+                except TypeError as error:
+                    msg = "mirror_focal_length not contained in DB"
+                    self._logger.error(msg)
+                    raise TypeError(msg) from error
+
+        try:
+            self.shape_type = u.Quantity(self.mirror_table["shape_type"])[0]
+            self._logger.debug(f"Mirror shape_type = {self.shape_type}")
+        except KeyError:
+            self._logger.debug("Mirror shape_type not in mirror file")
+            try:
+                self.shape_type = self.parameters["mirror_panel_shape"]["Value"]
+                self._logger.debug("Take shape_type from parameters")
+            except TypeError as error:
+                msg = "Mirror shape_type not contained in DB"
+                self._logger.error(msg)
+                raise TypeError(msg) from error
 
     def _read_mirror_list_from_sim_telarray(self):
         """
@@ -91,39 +128,37 @@ class Mirrors:
             If number of mirrors is 0.
         """
 
-        self._mirrors["number"] = []
-        self._mirrors["pos_x"] = []
-        self._mirrors["pos_y"] = []
-        self._mirrors["diameter"] = []
-        self._mirrors["flen"] = []
-        self._mirrors["shape"] = []
-
-        mirror_counter = 0
-        collect_geo_pars = True
-        with open(self._mirror_list_file, "r", encoding="utf-8") as file:
-            for line in file:
-                line = line.split()
-                if "#" in line[0] or "$" in line[0]:
-                    continue
-                if collect_geo_pars:
-                    self.diameter = float(line[2])
-                    self.shape = int(line[4])
-                    collect_geo_pars = False
-                    self._logger.debug(f"Shape = {self.shape}")
-                    self._logger.debug(f"Diameter = {self.diameter}")
-
-                self._mirrors["number"].append(mirror_counter)
-                self._mirrors["pos_x"].append(float(line[0]))
-                self._mirrors["pos_y"].append(float(line[1]))
-                self._mirrors["diameter"].append(float(line[2]))
-                self._mirrors["flen"].append(float(line[3]))
-                self._mirrors["shape"].append(float(line[4]))
-                mirror_counter += 1
-        self.number_of_mirrors = mirror_counter
-        if self.number_of_mirrors == 0:
-            msg = "Problem reading mirror list file"
-            self._logger.error(msg)
-            raise InvalidMirrorListFile()
+        self.mirror_table = Table.read(
+            self._mirror_list_file,
+            format="ascii.no_header",
+            names=[
+                "mirror_x",
+                "mirror_y",
+                "mirror_diameter",
+                "focal_length",
+                "shape_type",
+                "mirror_z",
+                "sep",
+                "mirror_panel_id",
+            ],
+            units=["cm", "cm", "cm", "cm", None, "cm", None, None],
+        )
+        self.mirror_table["mirror_panel_id"] = np.array(
+            [
+                int("".join(filter(str.isdigit, string)))
+                for string in self.mirror_table["mirror_panel_id"]
+            ]
+        )
+
+        self.shape_type = self.mirror_table["shape_type"][0]
+        self.mirror_diameter = u.Quantity(
+            self.mirror_table["mirror_diameter"][0], self.mirror_table["mirror_diameter"].unit
+        )
+        self.number_of_mirrors = len(self.mirror_table["focal_length"])
+
+        self._logger.debug(f"Mirror shape_type = {self.shape_type}")
+        self._logger.debug(f"Mirror diameter = {self.mirror_diameter}")
+        self._logger.debug(f"Number of Mirrors = {self.number_of_mirrors}")
 
     def get_single_mirror_parameters(self, number):
         """
@@ -136,24 +171,52 @@ class Mirrors:
 
         Returns
         -------
-        (pos_x, pos_y, diameter, flen, shape): tuple of float
-            X, Y positions, diameter, focal length and shape.
+        (pos_x, pos_y, mirror_diameter, focal_length, shape_type): tuple of float
+            X, Y positions, mirror_diameter, focal length and shape_type.
         """
 
-        if number > self.number_of_mirrors - 1:
-            self._logger.error("Mirror number is out range")
-            return None
-        return (
-            self._mirrors["pos_x"][number],
-            self._mirrors["pos_y"][number],
-            self._mirrors["diameter"][number],
-            self._mirrors["flen"][number],
-            self._mirrors["shape"][number],
-        )
+        mask = self.mirror_table["mirror_panel_id"] == number
+        if not np.any(mask):
+            self._logger.debug(f"Mirror id{number} not in table, using first mirror instead")
+            mask[0] = True
+        try:
+            return_values = (
+                u.Quantity(
+                    self.mirror_table[mask]["mirror_x"].value[0],
+                    self.mirror_table[mask]["mirror_x"].unit,
+                ),
+                u.Quantity(
+                    self.mirror_table[mask]["mirror_y"].value[0],
+                    self.mirror_table[mask]["mirror_y"].unit,
+                ),
+                u.Quantity(
+                    self.mirror_table[mask]["mirror_diameter"].value[0],
+                    self.mirror_table[mask]["mirror_diameter"].unit,
+                ),
+                u.Quantity(
+                    self.mirror_table[mask]["focal_length"].value[0],
+                    self.mirror_table[mask]["focal_length"].unit,
+                ),
+                u.Quantity(
+                    self.mirror_table[mask]["shape_type"].value[0],
+                    self.mirror_table[mask]["shape_type"].unit,
+                ),
+            )
+        except KeyError:
+            self._logger.debug("Mirror list missing required column")
+            return_values = (
+                0,
+                0,
+                self.mirror_diameter,
+                u.Quantity(
+                    self.mirror_table[mask]["focal_length"].value[0],
+                    self.mirror_table[mask]["focal_length"].unit,
+                ),
+                self.shape_type,
+            )
+        return return_values
 
     def plot_mirror_layout(self):
         """
-        Plot the mirror layout.
-
-        TODO
+        Plot the mirror layout (not implemented yet).
         """