GridCal 5.3.37__tar.gz → 5.3.38__tar.gz

{gridcal-5.3.37 → gridcal-5.3.38}/GridCal/Gui/Diagrams/Editors/line_editor.py

@@ -237,7 +237,10 @@ class LineEditor(QDialog):
                 self.line.disable_auto_updates()
                 self.line.set_length(val=length)
                 self.line.set_circuit_idx(val=int(self.circuit_idx.value()), obj=self.selected_template)
-                self.line.apply_template(obj=self.selected_template, Sbase=self.Sbase, freq=self.frequency)
+                template = self.selected_template
+                if isinstance(template, OverheadLineType):
+                    template.compute()
+                self.line.apply_template(obj=template, Sbase=self.Sbase, freq=self.frequency)
                 self.line.enable_auto_updates()
                 self.accept()
             else:
@@ -292,8 +295,8 @@ class LineEditor(QDialog):
             self.selected_template = template
 
         elif isinstance(template, OverheadLineType):
-            if self.current_template.check():
-                R1, X1, Bsh1, I_kA = self.current_template.get_sequence_values(
+            if template.check():
+                R1, X1, Bsh1, I_kA = template.get_sequence_values(
                     circuit_idx=int(self.circuit_idx.value()),
                     seq=1
                 )
@@ -301,9 +304,9 @@ class LineEditor(QDialog):
                 self.r_spinner.setValue(R1)
                 self.x_spinner.setValue(X1)
                 self.b_spinner.setValue(Bsh1)
-                self.circuit_idx.setMaximum(self.current_template.n_circuits)
+                self.circuit_idx.setMaximum(template.n_circuits)
             else:
-                warning_msg(text=f"The template {self.current_template.name} contains errors",
+                warning_msg(text=f"The template {template.name} contains errors",
                             title="Load template")
 
             self.selected_template = template

{gridcal-5.3.37 → gridcal-5.3.38}/GridCal/Gui/Diagrams/MapWidget/Branches/line_location_graphic_item.py

@@ -4,6 +4,8 @@
 # SPDX-License-Identifier: MPL-2.0
 from __future__ import annotations
 from typing import Tuple, List, TYPE_CHECKING
+
+from GridCalEngine.enumerations import DeviceType
 from PySide6.QtWidgets import QMenu, QGraphicsSceneContextMenuEvent
 from GridCal.Gui.gui_functions import add_menu_entry
 from PySide6 import QtWidgets
@@ -258,6 +260,28 @@ class LineLocationGraphicItem(QtWidgets.QGraphicsEllipseItem, NodeTemplate):
                        icon_path=":/Icons/icons/delete_schematic.svg",
                        function_ptr=self.remove)
 
+        add_menu_entry(menu=menu,
+                       text="Transform waypoint into substation",
+                       function_ptr=self.editor.transform_waypoint_to_substation,
+                       icon_path=":/Icons/icons/divide.svg")
+
+        menu.addSeparator()
+
+        has_substation = False
+
+        for graphic_obj in self.editor._get_selected():
+            if hasattr(graphic_obj, 'api_object'):
+                if hasattr(graphic_obj.api_object, 'device_type'):
+                    if graphic_obj.api_object.device_type == DeviceType.SubstationDevice:
+                        has_substation = True
+
+        if has_substation:
+
+            add_menu_entry(menu=menu,
+                           text="Connect line to selected substation (T-joint) at this waypoint",
+                           function_ptr=self.editor.create_t_joint_to_substation,
+                           icon_path=":/Icons/icons/divide.svg")
+
         menu.exec_(event.screenPos())
 
     def remove(self):

{gridcal-5.3.37 → gridcal-5.3.38}/GridCal/Gui/Diagrams/MapWidget/Branches/map_line_segment.py

@@ -272,7 +272,6 @@ class MapLineSegment(QGraphicsLineItem):
         has_substation = False
         substation_counter = 0
         line_counter = 0
-        lineloc_counter = 0
 
         for graphic_obj in self.editor._get_selected():
             if hasattr(graphic_obj, 'api_object'):
@@ -283,10 +282,8 @@ class MapLineSegment(QGraphicsLineItem):
                     elif graphic_obj.api_object.device_type == DeviceType.LineDevice:
                         line_counter += 1
 
-                    elif graphic_obj.api_object.device_type == DeviceType.LineLocation:
-                        lineloc_counter += 1
-
         if line_counter > 1:
+
             add_menu_entry(menu=menu,
                            text="Merge selected lines",
                            function_ptr=self.editor.merge_selected_lines,
@@ -294,14 +291,6 @@ class MapLineSegment(QGraphicsLineItem):
 
         menu.addSeparator()
 
-        if lineloc_counter > 0:
-            add_menu_entry(menu=menu,
-                           text="Transform waypoint into substation",
-                           function_ptr=self.editor.transform_waypoint_to_substation,
-                           icon_path=":/Icons/icons/divide.svg")
-
-        menu.addSeparator()
-
         # Add the split line to substation option if a substation is selected
         if has_substation:
             if substation_counter == 1:
@@ -310,10 +299,6 @@ class MapLineSegment(QGraphicsLineItem):
                                function_ptr=self.editor.split_line_to_substation,
                                icon_path=":/Icons/icons/divide.svg")
 
-                add_menu_entry(menu=menu,
-                               text="Connect line to selected substation (T-joint)",
-                               function_ptr=self.editor.create_t_joint_to_substation,
-                               icon_path=":/Icons/icons/divide.svg")
             elif substation_counter == 2:
 
                 add_menu_entry(menu=menu,

{gridcal-5.3.37 → gridcal-5.3.38}/GridCal/Gui/Diagrams/MapWidget/Substation/substation_graphic_item.py

@@ -626,7 +626,8 @@ class SubstationGraphicItem(NodeTemplate, QGraphicsRectItem):
                 dlg = CheckListDialogue(
                     objects_list=[f'Create schematic diagram for the recipient substation {self.api_object.name}',
                                   f'Unify buses and voltage levels with the same nominal voltage in recipient '
-                                  f'substation {self.api_object.name}'],
+                                  f'substation {self.api_object.name}. This will reattach the following items to the '
+                                  f'recipient substation: Lines, generators, loads, shunts, controllable shunts'],
                     title=f"Finishing merging proces in substation{self.api_object.name}"
                 )
                 dlg.setModal(True)
@@ -655,6 +656,18 @@ class SubstationGraphicItem(NodeTemplate, QGraphicsRectItem):
                                 line.bus_to = recipient_buses[line.bus_to.Vnom]
                                 line_graphic = self.editor.graphics_manager.query(elm=line)
                                 line_graphic.calculate_total_length()
+                        for load in self.editor.circuit.loads:
+                            if load.bus in removed_buses:
+                                load.bus = recipient_buses[load.bus.Vnom]
+                        for gen in self.editor.circuit.generators:
+                            if gen.bus in removed_buses:
+                                gen.bus = recipient_buses[gen.bus.Vnom]
+                        for sh in self.editor.circuit.shunts:
+                            if sh.bus in removed_buses:
+                                sh.bus = recipient_buses[sh.bus.Vnom]
+                        for csh in self.editor.circuit.controllable_shunts:
+                            if csh.bus in removed_buses:
+                                csh.bus = recipient_buses[csh.bus.Vnom]
 
                         for bus in removed_buses:
                             self.editor.circuit.delete_bus(obj=bus, delete_associated=False)

{gridcal-5.3.37 → gridcal-5.3.38}/GridCal/Gui/Diagrams/MapWidget/Tiles/TileProviders/cartodb.py

@@ -30,35 +30,53 @@ from GridCal.Gui.Diagrams.MapWidget.Tiles.tiles import Tiles
 
 
 class CartoDbTiles(Tiles):
-    """An object to source server tiles for pySlipQt."""
+    """
+    An object to source server tiles for pySlipQt.
+    """
 
     def __init__(self, tiles_dir='open_street_map_tiles',
                  http_proxy=None,
                  tile_servers: List[str] | None = None,
-                 name: str = 'Carto positron'):
+                 url_path='/{Z}/{X}/{Y}.png',
+                 name: str = 'Carto positron',
+                 tile_set_short_name='CartoDb Dark Matter',
+                 tile_set_version='1.0',
+                 attribution="© CARTO, © OpenStreetMap contributors",
+                 min_zoom: int = 0,
+                 max_zoom: int = 22,
+                 tile_width=256,
+                 tile_height=256):
         """
         Override the base class for these tiles.
-
         Basically, just fill in the BaseTiles class with values from above
         and provide the Geo2Tile() and Tile2Geo() methods.
-        :param tiles_dir:
-        :param http_proxy:
-        :param tile_servers:
+        :param tiles_dir: Tiles directory
+        :param http_proxy: Proxy URL
+        :param tile_servers: List of tile servers
+        :param url_path: extra path to query the tiles
+        :param name: Name of the tile set
+        :param tile_set_short_name: Short name of the tile set
+        :param tile_set_version: Version of the tile set
+        :param attribution: Attribution string of the tile set
+        :param min_zoom: Minimal zoom
+        :param max_zoom: Maximum zoom (+1)
+        :param tile_width: Width of the tile (px)
+        :param tile_height: Height of the tile (px)
         """
 
         super().__init__(tile_set_name=name,
-                         tile_set_short_name='CartoDb Dark Matter',
-                         tile_set_version='1.0',
-                         levels=list(range(22)),
-                         tile_width=256,
-                         tile_height=256,
+                         tile_set_short_name=tile_set_short_name,
+                         tile_set_version=tile_set_version,
+                         levels=[z for z in range(min_zoom, max_zoom)],
+                         tile_width=tile_width,
+                         tile_height=tile_height,
                          tiles_dir=tiles_dir,
                          servers=["https://basemaps.cartocdn.com/dark_all/"] if tile_servers is None else tile_servers,
-                         url_path='/{Z}/{X}/{Y}.png',
+                         url_path=url_path,
                          max_server_requests=2,
                          max_lru=10000,
                          http_proxy=http_proxy,
-                         attribution="© CARTO, © OpenStreetMap contributors")
+                         attribution=attribution)
 
         # get tile information into instance
         self.level = min(self.levels)
@@ -67,21 +85,21 @@ class CartoDbTiles(Tiles):
     def copy(self) -> "CartoDbTiles":
         """
         Copy of this object
-        :return:
+        :return: CartoDbTiles
         """
-        # cpy = super().copy()
-        # cpy.__class__ == CartoDbTiles
-        # cpy: CartoDbTiles = cpy
-        # cpy.level = self.level
-        # cpy.num_tiles_x = self.num_tiles_x
-        # cpy.num_tiles_y = self.num_tiles_y
-        # cpy.ppd_x = self.ppd_x
-        # cpy.ppd_y = self.ppd_y
-
         cpy = CartoDbTiles(tiles_dir=self.tiles_dir,
                            http_proxy=self.http_proxy,
                            tile_servers=self.servers.copy(),
-                           name=self.tile_set_name)
+                           url_path=self.url_path,
+                           name=self.tile_set_name,
+                           tile_set_short_name=self.tile_set_short_name,
+                           tile_set_version=self.tile_set_version,
+                           attribution=self.attribution_string,
+                           min_zoom=self.min_level,
+                           max_zoom=self.max_level,
+                           tile_width=self.tile_width,
+                           tile_height=self.tile_height
+                           )
 
         return cpy
 

{gridcal-5.3.37 → gridcal-5.3.38}/GridCal/Gui/Diagrams/MapWidget/Tiles/base_tiles.py

@@ -37,7 +37,9 @@ from GridCal.Gui.Diagrams.MapWidget.Tiles.tiles_cache import TilesCache
 
 
 class BaseTiles:
-    """A base tile object to source local tiles for pySlip."""
+    """
+    A base tile object to source local tiles for pySlip.
+    """
 
     def __init__(self,
                  levels: List[int],
@@ -71,11 +73,10 @@ class BaseTiles:
         self.ppd_x = 0
         self.ppd_y = 0
 
-        # TODO: implement map wrap-around
         self.wrap_x = False
         self.wrap_y = False
 
-        # setup the tile cache
+        # set up the tile cache
         self.cache = TilesCache(tiles_dir=tiles_dir, max_lru=max_lru)
 
         #####
@@ -91,10 +92,9 @@ class BaseTiles:
                 msg = ("%s doesn't appear to be a tile cache directory" % tiles_dir)
                 raise Exception(msg) from None
 
-            msg = "The tiles directory %s doesn't exist." % tiles_dir
-            print(msg)
             # raise Exception(msg) from None
             os.makedirs(tiles_dir)
+            print(f"The tiles directory {tiles_dir} has been created")
 
     @property
     def max_level(self):
@@ -112,6 +112,15 @@ class BaseTiles:
         """
         return self._min_level
 
+    def level_in_range(self, level) -> bool:
+        """
+        Check if the level is in range
+        :param level: level value
+        :return: in range?
+        """
+        # first, CAN we zoom to this level?
+        return self.min_level <= level <= self.max_level
+
     @property
     def tile_width(self):
         """
@@ -176,34 +185,37 @@ class BaseTiles:
         """
         return self.extent[3]
 
-    def UseLevel(self, level):
-        """Prepare to serve tiles from the required level.
+    def set_level(self, level: int):
+        """
+        Prepare to serve tiles from the required level.
 
-        level  the required level
+        :param level:  the required level
 
         Return True if level change occurred, else False if not possible.
         """
 
         # first, CAN we zoom to this level?
-        if level not in self.levels:
-            return False
+        if self.level_in_range(level):
 
-        # get tile info
-        info = self.GetInfo(level)
-        if info is None:
-            return False
+            # get tile info
+            info = self.GetInfo(level)
+            if info is None:
+                return False
 
-        # OK, save new level
-        self.level = level
-        self.num_tiles_x, self.num_tiles_y, self.ppd_x, self.ppd_y = info
+            # OK, save new level
+            self.level = level
+            self.num_tiles_x, self.num_tiles_y, self.ppd_x, self.ppd_y = info
+            return True
 
-        return True
+        else:
+            return False
 
     def GetTile(self, x: float, y: float) -> QPixmap:
-        """Get bitmap for tile at tile coords (x, y) and current level.
+        """
+        Get bitmap for tile at tile coords (x, y) and current level.
 
-        x  X coord of tile required (tile coordinates)
-        y  Y coord of tile required (tile coordinates)
+        :param x: X coord of tile required (tile coordinates)
+        :param y: Y coord of tile required (tile coordinates)
 
         Returns bitmap object for the tile image.
         Tile coordinates are measured from map top-left.
@@ -212,21 +224,21 @@ class BaseTiles:
         # if we are wrapping X or Y, get wrapped tile coords
         if self.wrap_x:
             x = (x + self.num_tiles_x * self.tile_size_x) % self.num_tiles_x
+
         if self.wrap_y:
             y = (y + self.num_tiles_y * self.tile_size_y) % self.num_tiles_y
 
-            # retrieve the tile
         try:
             # get tile from cache
             return self.cache[(self.level, x, y)]
+
         except KeyError as e:
             raise KeyError("Can't find tile for key '%s'" % str((self.level, x, y))) from None
 
     def GetInfo(self, level: int) -> Union[Tuple[float, float, None, None], None]:
-        """Get tile info for a particular level.
-
-        level  the level to get tile info for
-
+        """
+        Get tile info for a particular level.
+        :param level:  the level to get tile info for
         Returns (num_tiles_x, num_tiles_y, ppd_x, ppd_y) or None if 'level'
         doesn't exist.
 
@@ -235,18 +247,22 @@ class BaseTiles:
         """
 
         # is required level available?
-        if level not in self.levels:
-            return None
+        if self.level_in_range(level):
 
-        # otherwise get the information
-        self.num_tiles_x = int(math.pow(2, level))
-        self.num_tiles_y = int(math.pow(2, level))
+            # otherwise get the information
+            self.num_tiles_x = int(math.pow(2, level))
+            self.num_tiles_y = int(math.pow(2, level))
 
-        return self.num_tiles_x, self.num_tiles_y, None, None
+            return self.num_tiles_x, self.num_tiles_y, None, None
+
+        else:
+            return None
 
     def GetExtent(self):
-        """Get geo limits of the map tiles.
-                         (min_lon,   max_lon,   min_lat,   max_lat)
+        """
+        Get geo limits of the map tiles.
+        (min_lon,   max_lon,   min_lat,   max_lat)
+
         Returns a tuple: (min_geo_x, max_geo_x, min_geo_y, max_geo_y)
         """
 
@@ -255,6 +271,9 @@ class BaseTiles:
     def tile_on_disk(self, level: int, x: float, y: float):
         """
         Return True if tile at (level, x, y) is on-disk.
+        :param level: Map level
+        :param x: map x coordinate
+        :param y: map y coordinate
         """
         raise Exception('You must override BaseTiles.tile_on_disk(level, x, y))')
 
@@ -268,13 +287,13 @@ class BaseTiles:
     def Geo2Tile(self, longitude: float, latitude: float) -> Tuple[int, int]:
         """
         Convert geo to tile fractional coordinates for level in use.
-        xgeo   geo longitude in degrees
-        ygeo   geo latitude in degrees
-
         Note that we assume the point *is* on the map!
+        :param longitude: geo longitude in degrees
+        :param latitude: geo latitude in degrees
+        :return x_tile, y_tile (tile fractional X, Y coordinate)
         """
 
-        raise Exception('You must override BaseTiles.Geo2Tile(xgeo, ygeo)')
+        raise Exception('You must override BaseTiles.Geo2Tile(longitude, latitude)')
 
     def Tile2Geo(self, x_tile: float, y_tile: float) -> Tuple[float, float]:
         """
@@ -286,4 +305,4 @@ class BaseTiles:
         Note that we assume the point *is* on the map!
         """
 
-        raise Exception('You must override BaseTiles.Tile2Geo(xtile, ytile)')
+        raise Exception('You must override BaseTiles.Tile2Geo(x_tile, y_tile)')

{gridcal-5.3.37 → gridcal-5.3.38}/GridCal/Gui/Diagrams/MapWidget/Tiles/tiles.py

@@ -134,6 +134,9 @@ class Tiles(BaseTiles):
         tile_extension = os.path.splitext(url_path)[1][1:]
         tile_extension_lower = tile_extension.lower()  # ensure lower case
 
+        if tile_extension_lower == "":
+            tile_extension_lower = 'jpg'
+
         # determine the file bitmap type
         try:
             self.filetype = self.AllowedFileTypes[tile_extension_lower]
@@ -221,61 +224,41 @@ class Tiles(BaseTiles):
                 self.workers.append(worker)
                 worker.start()
 
-    # def copy(self) -> "Tiles":
-    #     """
-    #     Perform a copy of the Tiles object.
-    #     :return:
-    #     """
-    #     return Tiles(tile_set_name=self.tile_set_name,
-    #              tile_set_short_name=self.tile_set_short_name,
-    #              tile_set_version=self.tile_set_version,
-    #              levels=self.levels.copy(),
-    #              tile_width=self.tile_width,
-    #              tile_height=self.tile_height,
-    #              tiles_dir=self.tiles_dir,
-    #              max_lru=self.max_lru,
-    #              servers=self.servers.copy(),
-    #              url_path=self.url_path,
-    #              max_server_requests=self.max_requests,
-    #              http_proxy=self.http_proxy,
-    #              re_fetch_days=self.refresh_tiles_after_days,
-    #              attribution=self.attribution_string)
-
-    def UseLevel(self, level):
+    def set_level(self, level: int):
         """
         Prepare to serve tiles from the required level.
-
-        level  the required level
-
-        Return True if level change occurred, else False if not possible.
+        :param level: the required level
+        :return: True if level change occurred, else False if not possible.
         """
-
         # first, CAN we zoom to this level?
-        if level not in self.levels:
-            return False
+        if self.level_in_range(level):
 
-        # get tile info
-        info = self.GetInfo(level)
-        if info is None:
-            return False
+            # get tile info
+            info = self.GetInfo(level)
+            if info is None:
+                return False
+
+            # OK, save new level
+            self.level = level
+            self.num_tiles_x, self.num_tiles_y, self.ppd_x, self.ppd_y = info
 
-        # OK, save new level
-        self.level = level
-        self.num_tiles_x, self.num_tiles_y, self.ppd_x, self.ppd_y = info
+            # flush any outstanding requests.
+            # we do this to speed up multiple-level zooms so the user doesn't
+            # sit waiting for tiles to arrive that won't be shown.
+            self.FlushRequests()
 
-        # flush any outstanding requests.
-        # we do this to speed up multiple-level zooms so the user doesn't
-        # sit waiting for tiles to arrive that won't be shown.
-        self.FlushRequests()
+            return True
 
-        return True
+        else:
+            # the zoom is out of bounds...
+            return False
 
-    def GetTile(self, x, y) -> QPixmap:
+    def GetTile(self, x: float, y: float) -> QPixmap:
         """
         Get bitmap for tile at tile coords (x, y) and current level.
 
-        x  X coord of tile required (tile coordinates)
-        y  Y coord of tile required (tile coordinates)
+        :param x:  X coord of tile required (tile coordinates)
+        :param y:  Y coord of tile required (tile coordinates)
 
         Returns bitmap object for the tile image.
         Tile coordinates are measured from map top-left.
@@ -290,18 +273,18 @@ class Tiles(BaseTiles):
         try:
             # get tile from cache
             tile = self.cache[(self.level, x, y)]
-            if self.tile_on_disk(self.level, x, y):
+            if self.tile_on_disk(level=self.level, x=x, y=y):
                 tile_date = self.cache.tile_date((self.level, x, y))
                 if self.re_request_age and (tile_date < self.re_request_age):
-                    self.get_server_tile(self.level, x, y)
+                    self.get_server_tile(level=self.level, x=x, y=y)
         except KeyError:
             # not cached, start process of getting tile from 'net, return 'pending' image
-            self.get_server_tile(self.level, x, y)
+            self.get_server_tile(level=self.level, x=x, y=y)
             tile = self.pending_tile
 
         return tile
 
-    def GetInfo(self, level):
+    def GetInfo(self, level: int):
         """
         Get tile info for a particular level.
 
@@ -317,14 +300,15 @@ class Tiles(BaseTiles):
         """
 
         # is required level available?
-        if level not in self.levels:
-            return None
+        if self.level_in_range(level):
 
-        # otherwise get the information
-        self.num_tiles_x = int(math.pow(2, level))
-        self.num_tiles_y = int(math.pow(2, level))
+            # otherwise get the information
+            self.num_tiles_x = int(math.pow(2, level))
+            self.num_tiles_y = int(math.pow(2, level))
 
-        return self.num_tiles_x, self.num_tiles_y, None, None
+            return self.num_tiles_x, self.num_tiles_y, None, None
+        else:
+            return None
 
     def FlushRequests(self):
         """
@@ -355,7 +339,9 @@ class Tiles(BaseTiles):
             self.queued_requests[tile_key] = True
 
     def tile_on_disk(self, level: int, x: float, y: float):
-        """Return True if tile at (level, x, y) is on-disk."""
+        """
+        Return True if tile at (level, x, y) is on-disk.
+        """
 
         tile_path = self.cache.tile_path((level, x, y))
         return os.path.exists(tile_path)
@@ -400,11 +386,11 @@ class Tiles(BaseTiles):
 
     def SetAgeThresholdDays(self, num_days):
         """
-        Set the tile refetch threshold time.
+        Set the tile re-fetch threshold time.
 
-        num_days  number of days before refetching tiles
+        num_days  number of days before re-fetching tiles
 
-        If 'num_days' is 0 refetching is inhibited.
+        If 'num_days' is 0 re-fetching is inhibited.
         """
 
         # update the global in case we instantiate again