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

simtools/layout/{layout_array.py → array_layout.py}

@@ -3,23 +3,28 @@ from pathlib import Path
 
 import astropy.units as u
 import numpy as np
-import pyproj
 from astropy.table import QTable
 
-from simtools import db_handler, io_handler
+from simtools import db_handler
+from simtools.data_model import data_reader
+from simtools.io_operations import io_handler
+from simtools.layout.geo_coordinates import GeoCoordinates
 from simtools.layout.telescope_position import TelescopePosition
 from simtools.utils import names
-from simtools.utils.general import collect_data_from_yaml_or_dict
-from simtools.utils.names import all_telescope_class_names
+from simtools.utils.general import collect_data_from_file_or_dict
 
-__all__ = ["InvalidTelescopeListFile", "LayoutArray"]
+__all__ = ["InvalidTelescopeListFile", "ArrayLayout"]
 
 
 class InvalidTelescopeListFile(Exception):
     """Exception for invalid telescope list file."""
 
 
-class LayoutArray:
+class InvalidCoordinateDataType(Exception):
+    """Exception for low-precision coordinate data type."""
+
+
+class ArrayLayout:
     """
     Manage telescope positions at the array layout level.
 
@@ -50,9 +55,11 @@ class LayoutArray:
         layout_center_data=None,
         corsika_telescope_data=None,
         telescope_list_file=None,
+        telescope_list_metadata_file=None,
+        validate=False,
     ):
         """
-        Initialize LayoutArray.
+        Initialize ArrayLayout.
         """
 
         self._logger = logging.getLogger(__name__)
@@ -62,18 +69,24 @@ class LayoutArray:
         self.name = name
         self.site = None if site is None else names.validate_site_name(site)
         self.io_handler = io_handler.IOHandler()
+        self.geo_coordinates = GeoCoordinates()
 
         self.telescope_list_file = None
         self._telescope_list = []
         self._epsg = None
+
         if telescope_list_file is None:
             self._initialize_coordinate_systems(layout_center_data)
             self._initialize_corsika_telescope(corsika_telescope_data)
         else:
-            self.initialize_layout_array_from_telescope_file(telescope_list_file)
+            self.initialize_array_layout_from_telescope_file(
+                telescope_list_file=telescope_list_file,
+                telescope_list_metadata_file=telescope_list_metadata_file,
+                validate=validate,
+            )
 
     @classmethod
-    def from_layout_array_name(cls, mongo_db_config, layout_array_name, label=None):
+    def from_array_layout_name(cls, mongo_db_config, array_layout_name, label=None):
         """
         Read telescope list from file for given layout name (e.g. South-4LST, North-Prod5, ...).
         Layout definitions are given in the `data/layout` path.
@@ -82,33 +95,33 @@ class LayoutArray:
         ----------
         mongo_db_config: dict
             MongoDB configuration.
-        layout_array_name: str
+        array_layout_name: str
             e.g. South-4LST, North-Prod5 ...
         label: str
             Instance label. Important for output file naming.
 
         Returns
         -------
-        LayoutArray
-            Instance of the LayoutArray.
+        ArrayLayout
+            Instance of the ArrayLayout.
         """
 
-        split_name = layout_array_name.split("-")
+        split_name = array_layout_name.split("-")
         site_name = names.validate_site_name(split_name[0])
-        array_name = names.validate_layout_array_name(split_name[1])
-        valid_layout_array_name = site_name + "-" + array_name
+        array_name = names.validate_array_layout_name(split_name[1])
+        valid_array_layout_name = site_name + "-" + array_name
 
         layout = cls(
             site=site_name,
             mongo_db_config=mongo_db_config,
-            name=valid_layout_array_name,
+            name=valid_array_layout_name,
             label=label,
         )
 
         telescope_list_file = layout.io_handler.get_input_data_file(
-            "layout", f"telescope_positions-{valid_layout_array_name}.ecsv"
+            "layout", f"telescope_positions-{valid_array_layout_name}.ecsv"
         )
-        layout.initialize_layout_array_from_telescope_file(telescope_list_file)
+        layout.initialize_array_layout_from_telescope_file(telescope_list_file)
 
         return layout
 
@@ -168,14 +181,19 @@ class LayoutArray:
             If file_name does not exist.
         """
         if file_name is None:
-            corsika_parameters_dict = collect_data_from_yaml_or_dict(
-                self.io_handler.get_input_data_file("parameters", "corsika_parameters.yml"), None
-            )
+            try:
+                corsika_parameters_dict = collect_data_from_file_or_dict(
+                    self.io_handler.get_input_data_file("parameters", "corsika_parameters.yml"),
+                    None,
+                )
+            except io_handler.IncompleteIOHandlerInit:
+                self._logger.info("Error reading CORSIKA parameters from file")
+                return {}
         else:
             if not isinstance(file_name, Path):
                 file_name = Path(file_name)
             if file_name.exists():
-                corsika_parameters_dict = collect_data_from_yaml_or_dict(file_name, None)
+                corsika_parameters_dict = collect_data_from_file_or_dict(file_name, None)
             else:
                 raise FileNotFoundError
 
@@ -184,22 +202,16 @@ class LayoutArray:
         for simtools_par in corsika_pars:
             corsika_par = names.translate_simtools_to_corsika(simtools_par)
             corsika_dict[simtools_par] = {}
-            for tel_type in all_telescope_class_names:
-                corsika_dict[simtools_par][tel_type] = corsika_parameters_dict[corsika_par][
-                    tel_type
-                ]["value"]
-
+            for key, value in corsika_parameters_dict[corsika_par].items():
+                corsika_dict[simtools_par][key] = value["value"]
                 try:
-                    unit = corsika_parameters_dict[corsika_par][tel_type]["unit"]
-                    corsika_dict[simtools_par][tel_type] = corsika_dict[simtools_par][
-                        tel_type
-                    ] * u.Unit(unit)
+                    unit = value["unit"]
+                    corsika_dict[simtools_par][key] = corsika_dict[simtools_par][key] * u.Unit(unit)
                 except KeyError:
                     self._logger.warning(
                         "Key not valid. Dictionary does not have a key 'unit'. Continuing without "
                         "the unit."
                     )
-                    corsika_dict[simtools_par][tel_type] = corsika_dict[simtools_par][tel_type]
 
         if self.mongo_db_config is None:
             self._logger.error("DB connection info was not provided, cannot set site altitude")
@@ -210,19 +222,20 @@ class LayoutArray:
 
         db = db_handler.DatabaseHandler(mongo_db_config=self.mongo_db_config)
         self._logger.debug("Reading site parameters from DB")
-        _site_pars = db.get_site_parameters(self.site, "Current", only_applicable=True)
+        _site_pars = db.get_site_parameters(self.site, "Released", only_applicable=True)
         corsika_dict["corsika_obs_level"] = _site_pars["altitude"]["Value"] * u.Unit(
             _site_pars["altitude"]["units"]
         )
 
         return corsika_dict
 
-    @staticmethod
-    def _initialize_sphere_parameters(sphere_dict):
+    def _initialize_sphere_parameters(self, sphere_dict):
         """
         Set CORSIKA sphere parameters from dictionary. Type of input varies and depend on data \
         source for these parameters.
 
+        Example for sphere_dict: {LST: 12.5 m, MST: 9.15 m, SST: 3 m}
+
         Parameters
         ----------
         sphere_dict: dict
@@ -242,8 +255,9 @@ class LayoutArray:
                     _sphere_dict_cleaned[key] = u.Quantity(value)
                 else:
                     _sphere_dict_cleaned[key] = value["value"] * u.Unit(value["unit"])
-        except (TypeError, KeyError):
-            pass
+        except (TypeError, KeyError) as exc:
+            self._logger.error(f"Error setting CORSIKA sphere parameters from {sphere_dict}")
+            raise exc
 
         return _sphere_dict_cleaned
 
@@ -257,28 +271,25 @@ class LayoutArray:
             dictionary with CORSIKA telescope parameters
 
         """
+
         try:
             self._corsika_telescope["corsika_obs_level"] = u.Quantity(
                 corsika_dict["corsika_obs_level"]
             )
         except (TypeError, KeyError):
             self._corsika_telescope["corsika_obs_level"] = np.nan * u.m
-        try:
-            self._corsika_telescope["corsika_sphere_center"] = self._initialize_sphere_parameters(
-                corsika_dict["corsika_sphere_center"]
-            )
-        except (TypeError, KeyError):
-            pass
-        try:
-            self._corsika_telescope["corsika_sphere_radius"] = self._initialize_sphere_parameters(
-                corsika_dict["corsika_sphere_radius"]
-            )
-        except (TypeError, KeyError):
-            pass
+
+        for key in ["corsika_sphere_center", "corsika_sphere_radius"]:
+            try:
+                self._corsika_telescope[key] = self._initialize_sphere_parameters(corsika_dict[key])
+            except (TypeError, KeyError):
+                pass
 
     def _initialize_coordinate_systems(self, center_dict=None):
         """
         Initialize array center and coordinate systems.
+        By definition, the array center is at (0,0) in
+        the ground coordinate system.
 
         Parameters
         ----------
@@ -292,11 +303,29 @@ class LayoutArray:
 
         """
 
+        center_dict = {} if center_dict is None else center_dict
+
         self._array_center = TelescopePosition()
         self._array_center.name = "array_center"
-        self._array_center.set_coordinates("corsika", 0.0 * u.m, 0.0 * u.m, 0.0 * u.m)
+        self._array_center.set_coordinates("ground", 0.0 * u.m, 0.0 * u.m, 0.0 * u.m)
+        self._set_array_center_mercator(center_dict)
+        self._set_array_center_utm(center_dict)
+        self._array_center.set_altitude(u.Quantity(center_dict.get("center_alt", np.nan * u.m)))
+        _name = center_dict.get("array_name")
+        self.name = _name if _name is not None else self.name
+
+        self._array_center.convert_all(
+            crs_local=self.geo_coordinates.crs_local(self._array_center),
+            crs_wgs84=self.geo_coordinates.crs_wgs84(),
+            crs_utm=self.geo_coordinates.crs_utm(self._epsg),
+        )
+
+    def _set_array_center_mercator(self, center_dict):
+        """
+        Set array center coordinates in mercator system.
+
+        """
 
-        center_dict = {} if center_dict is None else center_dict
         try:
             self._array_center.set_coordinates(
                 "mercator",
@@ -305,6 +334,15 @@ class LayoutArray:
             )
         except TypeError:
             pass
+
+    def _set_array_center_utm(self, center_dict):
+        """
+        Set array center coordinates in UTM system.
+        Convert array center position to WGS84 system
+        (as latitudes are required for the definition
+        for the definition of the ground coordinate system)
+
+        """
         try:
             self._epsg = center_dict.get("EPSG", None)
             self._array_center.set_coordinates(
@@ -312,23 +350,13 @@ class LayoutArray:
                 u.Quantity(center_dict.get("center_easting", np.nan * u.m)),
                 u.Quantity(center_dict.get("center_northing", np.nan * u.m)),
             )
+            self._array_center.convert_all(
+                crs_local=None,
+                crs_wgs84=self.geo_coordinates.crs_wgs84(),
+                crs_utm=self.geo_coordinates.crs_utm(self._epsg),
+            )
         except TypeError:
             pass
-        try:
-            self._array_center.set_altitude(u.Quantity(center_dict.get("center_alt", 0.0 * u.m)))
-        except TypeError:
-            pass
-        try:
-            _name = center_dict.get("array_name")
-            self.name = _name if _name is not None else self.name
-        except KeyError:
-            pass
-
-        self._array_center.convert_all(
-            crs_local=self._get_crs_local(),
-            crs_wgs84=self._get_crs_wgs84(),
-            crs_utm=self._get_crs_utm(),
-        )
 
     def _altitude_from_corsika_z(self, pos_z=None, altitude=None, tel_name=None):
         """
@@ -379,12 +407,26 @@ class LayoutArray:
         astropy.Quantity
             Telescope sphere center value (0.0*u.m if sphere center is not defined).
 
+        Raises
+        ------
+        KeyError
+            if Missing definition of CORSIKA sphere center for this telescope type.
+
         """
 
-        if len(names.get_telescope_type(tel_name)) > 0:
+        try:
             return self._corsika_telescope["corsika_sphere_center"][
-                names.get_telescope_type(tel_name)
+                names.get_telescope_class(tel_name)
             ]
+        except KeyError:
+            self._logger.warning(
+                "Missing definition of CORSIKA sphere center for telescope "
+                f"{tel_name} of type {names.get_telescope_class(tel_name)}"
+            )
+        except ValueError:
+            self._logger.warning(
+                f"Missing definition of CORSIKA sphere center for telescope {tel_name}"
+            )
 
         return 0.0 * u.m
 
@@ -413,7 +455,11 @@ class LayoutArray:
         try:
             tel.name = row["telescope_name"]
             if "asset_code" not in row:
-                tel.asset_code = names.get_telescope_type(tel.name)
+                try:
+                    tel.asset_code = names.get_telescope_class(tel.name)
+                # asset code is not a valid telescope name; possibly a calibration device
+                except ValueError:
+                    tel.asset_code = tel.name.split("-")[0]
         except KeyError:
             pass
         try:
@@ -486,7 +532,7 @@ class LayoutArray:
                 self._assign_unit_to_quantity(row[key2], table[key2].unit),
             )
         except KeyError:
-            self._logger.debug(f"{key1} and {key2} are not given. Coordinates not set.")
+            pass
 
     def _try_set_altitude(self, row, tel, table):
         """
@@ -505,14 +551,16 @@ class LayoutArray:
         try:
             tel.set_altitude(
                 self._altitude_from_corsika_z(
-                    pos_z=self._assign_unit_to_quantity(row["pos_z"], table["pos_z"].unit),
+                    pos_z=self._assign_unit_to_quantity(
+                        row["position_z"], table["position_z"].unit
+                    ),
                     tel_name=tel.name,
                 )
             )
         except KeyError:
             pass
         try:
-            tel.set_altitude(self._assign_unit_to_quantity(row["alt"], table["alt"].unit))
+            tel.set_altitude(self._assign_unit_to_quantity(row["altitude"], table["altitude"].unit))
         except KeyError:
             pass
 
@@ -528,58 +576,44 @@ class LayoutArray:
         """
         for row in table:
             tel = self._load_telescope_names(row)
-            self._try_set_coordinate(row, tel, table, "corsika", "pos_x", "pos_y")
+            self._try_set_coordinate(row, tel, table, "ground", "position_x", "position_y")
             self._try_set_coordinate(row, tel, table, "utm", "utm_east", "utm_north")
-            self._try_set_coordinate(row, tel, table, "mercator", "mercator", "lon")
+            self._try_set_coordinate(row, tel, table, "mercator", "latitude", "longitude")
             self._try_set_altitude(row, tel, table)
 
             self._telescope_list.append(tel)
 
-    @staticmethod
-    def read_telescope_list_file(telescope_list_file):
+    def initialize_array_layout_from_telescope_file(
+        self, telescope_list_file, telescope_list_metadata_file=None, validate=False
+    ):
         """
-        Read list of telescopes from a ecsv file.
+        Initialize the Layout array from a telescope list file.
 
         Parameters
         ----------
         telescope_list_file: str or Path
             Path to the telescope list file.
+        telescope_list_metadata_file: str or Path
+            Path to the telescope list metadata file.
+        validate: bool
+            Validate the telescope list file.
 
         Returns
         -------
-        astropy.QTable
-            Astropy table with the telescope layout information.
-
-        Raises
-        ------
-        FileNotFoundError
-            If file cannot be opened.
-
-        """
-        _logger = logging.getLogger(__name__)
-        try:
-            table = QTable.read(telescope_list_file, format="ascii.ecsv")
-        except FileNotFoundError:
-            _logger.error(f"Error reading list of array elements from {telescope_list_file}")
-            raise
-        _logger.info(f"Reading array elements from {telescope_list_file}")
-
-        return table
-
-    def initialize_layout_array_from_telescope_file(self, telescope_list_file):
+        astropy.table.QTable
+            Table with the telescope layout information.
         """
-        Initialize the Layout array from a telescope list file.
-
-        Parameters
-        ----------
-        telescope_list_file: str or Path
-            Path to the telescope list file.
-        """
-        table = self.read_telescope_list_file(telescope_list_file=telescope_list_file)
+        table = data_reader.read_table_from_file(
+            file_name=telescope_list_file,
+            validate=validate,
+            metadata_file=telescope_list_metadata_file,
+        )
         self._initialize_corsika_telescope(table.meta)
         self._initialize_coordinate_systems(table.meta)
         self._load_telescope_list(table)
 
+        return table
+
     def add_telescope(self, telescope_name, crs_name, xx, yy, altitude=None, tel_corsika_z=None):
         """
         Add an individual telescope to the telescope list.
@@ -611,8 +645,8 @@ class LayoutArray:
 
     def _get_export_metadata(self, export_corsika_meta=False):
         """
-        File metadata for export of array element list to file. Included array center definiton,\
-        CORSIKA telescope parameters, and EPSG centre
+        File metadata for export of array element list to file. Included array center definition,\
+        CORSIKA telescope parameters, and EPSG center
 
         Parameters
         ----------
@@ -649,42 +683,25 @@ class LayoutArray:
 
         return _meta
 
-    def _set_telescope_list_file(self, crs_name):
+    def export_telescope_list_table(self, crs_name, corsika_z=False):
         """
-        Set file location for writing of telescope list
+        Export array elements positions to astropy table.
 
         Parameters
         ----------
         crs_name: str
             Name of coordinate system to be used for export.
+        corsika_z: bool
+            Write telescope height in CORSIKA coordinates (for CORSIKA system).
 
         Returns
         -------
-        Path
-            Output file
+        astropy.table.QTable
+            Astropy table with the telescope layout information.
 
         """
 
-        _output_directory = self.io_handler.get_output_directory(self.label, "layout")
-
-        _name = crs_name if self.name is None else self.name + "-" + crs_name
-        self.telescope_list_file = _output_directory.joinpath(
-            names.layout_telescope_list_file_name(_name, None)
-        )
-
-    def export_telescope_list(self, crs_name, corsika_z=False):
-        """
-        Export array elements positions to ECSV file
-
-        Parameters
-        ----------
-        crs_name: str
-            Name of coordinate system to be used for export.
-        corsika_z: bool
-            Write telescope height in CORSIKA coordinates (for CORSIKA system).
-        """
-
-        table = QTable(meta=self._get_export_metadata(crs_name == "corsika"))
+        table = QTable(meta=self._get_export_metadata(crs_name == "ground"))
 
         tel_names, asset_code, sequence_number, geo_code = [], [], [], []
         pos_x, pos_y, pos_z = [], [], []
@@ -716,15 +733,13 @@ class LayoutArray:
             table[_name_x] = pos_x
             table[_name_y] = pos_y
             if corsika_z:
-                table["pos_z"] = pos_z
+                table["position_z"] = pos_z
             else:
                 table[_name_z] = pos_z
         except IndexError:
             pass
 
-        self._set_telescope_list_file(crs_name)
-        self._logger.info(f"Exporting telescope list to {self.telescope_list_file}")
-        table.write(self.telescope_list_file, format="ascii.ecsv", overwrite=True)
+        return table
 
     def get_number_of_telescopes(self):
         """
@@ -754,10 +769,10 @@ class LayoutArray:
 
         corsika_list = ""
         for tel in self._telescope_list:
-            pos_x, pos_y, pos_z = tel.get_coordinates("corsika")
+            pos_x, pos_y, pos_z = tel.get_coordinates("ground")
             try:
                 sphere_radius = self._corsika_telescope["corsika_sphere_radius"][
-                    names.get_telescope_type(tel.name)
+                    names.get_telescope_class(tel.name)
                 ]
             except KeyError:
                 self._logger.error("Missing definition of CORSIKA sphere radius")
@@ -773,9 +788,8 @@ class LayoutArray:
                 raise
 
             corsika_list += "TELESCOPE"
-            corsika_list += f"\t {pos_x.value:.3f}E2"
-            corsika_list += f"\t {pos_y.value:.3f}E2"
-            corsika_list += f"\t {pos_z.value:.3f}E2"
+            for pos in [pos_x, pos_y, pos_z]:
+                corsika_list += f"\t {pos.value:.3f}E2"
             corsika_list += f"\t {sphere_radius.value:.3f}E2"
             corsika_list += f"\t # {tel.name}\n"
 
@@ -787,7 +801,7 @@ class LayoutArray:
 
         """
 
-        print(f"LayoutArray: {self.name}")
+        print(f"ArrayLayout: {self.name}")
         print("ArrayCenter")
         print(self._array_center)
         print("Telescopes")
@@ -826,7 +840,7 @@ class LayoutArray:
 
     def print_telescope_list(self, compact_printing="", corsika_z=False):
         """
-        Print list of telescopes in current layout.
+        Print list of telescopes in latest released layout.
 
         Parameters
         ----------
@@ -846,69 +860,17 @@ class LayoutArray:
 
         self._logger.info("Converting telescope coordinates")
 
-        wgs84 = self._get_crs_wgs84()
-        crs_local = self._get_crs_local()
-        crs_utm = self._get_crs_utm()
+        crs_wgs84 = self.geo_coordinates.crs_wgs84()
+        crs_local = self.geo_coordinates.crs_local(self._array_center)
+        crs_utm = self.geo_coordinates.crs_utm(self._epsg)
 
         for tel in self._telescope_list:
             tel.convert_all(
                 crs_local=crs_local,
-                crs_wgs84=wgs84,
+                crs_wgs84=crs_wgs84,
                 crs_utm=crs_utm,
             )
 
-    def _get_crs_local(self):
-        """
-        Local coordinate system definition.
-
-        Returns
-        -------
-        pyproj.CRS
-            local coordinate system.
-
-        """
-        if self._array_center:
-            _center_lat, _center_lon, _ = self._array_center.get_coordinates("mercator")
-            if not np.isnan(_center_lat.value) and not np.isnan(_center_lon.value):
-                proj4_string = (
-                    "+proj=tmerc +ellps=WGS84 +datum=WGS84"
-                    + f" +lon_0={_center_lon} +lat_0={_center_lat}"
-                    + " +axis=nwu +units=m +k_0=1.0"
-                )
-                crs_local = pyproj.CRS.from_proj4(proj4_string)
-                return crs_local
-
-        return None
-
-    def _get_crs_utm(self):
-        """
-        UTM coordinate system definition.
-
-        Returns
-        -------
-        pyproj.CRS
-            UTM coordinate system.
-
-        """
-        if self._epsg:
-            crs_utm = pyproj.CRS.from_user_input(self._epsg)
-            return crs_utm
-
-        return None
-
-    @staticmethod
-    def _get_crs_wgs84():
-        """
-        WGS coordinate system definition.
-
-        Returns
-        -------
-        pyproj.CRS
-            WGS coordinate system.
-
-        """
-        return pyproj.CRS("EPSG:4326")
-
     @staticmethod
     def include_radius_into_telescope_table(telescope_table):
         """
@@ -926,9 +888,16 @@ class LayoutArray:
         """
 
         telescope_table["radius"] = [
-            telescope_table.meta["corsika_sphere_radius"][names.get_telescope_type(tel_name_now)]
+            u.Quantity(
+                telescope_table.meta["corsika_sphere_radius"][
+                    names.get_telescope_class(tel_name_now)
+                ]
+            )
+            .to("m")
+            .value
             for tel_name_now in telescope_table["telescope_name"]
         ]
+        telescope_table["radius"] = telescope_table["radius"].quantity * u.m
         return telescope_table
 
     def select_assets(self, asset_list=None):