GridCalEngine 5.1.18__tar.gz → 5.1.20__tar.gz

{GridCalEngine-5.1.18 → GridCalEngine-5.1.20}/GridCalEngine/DataStructures/numerical_circuit.py

@@ -1995,7 +1995,8 @@ def compile_numerical_circuit_at(circuit: MultiCircuit,
                                  opf_results: Union[OptimalPowerFlowResults, None] = None,
                                  use_stored_guess=False,
                                  bus_dict: Union[Dict[Bus, int], None] = None,
-                                 areas_dict: Union[Dict[Area, int], None] = None) -> NumericalCircuit:
+                                 areas_dict: Union[Dict[Area, int], None] = None,
+                                 logger=Logger()) -> NumericalCircuit:
     """
     Compile a NumericalCircuit from a MultiCircuit
     :param circuit: MultiCircuit instance
@@ -2006,11 +2007,10 @@ def compile_numerical_circuit_at(circuit: MultiCircuit,
     :param use_stored_guess: use the storage voltage guess?
     :param bus_dict (optional) Dict[Bus, int] dictionary
     :param areas_dict (optional) Dict[Area, int] dictionary
+    :param logger: Logger instance
     :return: NumericalCircuit instance
     """
 
-    logger = Logger()
-
     if circuit.get_connectivity_nodes_number() + circuit.get_switches_number():
         # process topology, this
         circuit.process_topology_at(t_idx=t_idx, logger=logger)

{GridCalEngine-5.1.18 → GridCalEngine-5.1.20}/GridCalEngine/Devices/Aggregation/area.py

@@ -41,10 +41,8 @@ class GenericAreaGroup(EditableDevice):
         self.latitude = latitude
         self.longitude = longitude
 
-        self.register(key='longitude', units='deg', tpe=float, definition='longitude.', profile_name='',
-                      editable=False)
-        self.register(key='latitude', units='deg', tpe=float, definition='latitude.', profile_name='',
-                      editable=False)
+        self.register(key='longitude', units='deg', tpe=float, definition='longitude.', profile_name='')
+        self.register(key='latitude', units='deg', tpe=float, definition='latitude.', profile_name='')
 
 
 class Area(GenericAreaGroup):

{GridCalEngine-5.1.18 → GridCalEngine-5.1.20}/GridCalEngine/Devices/Diagrams/base_diagram.py

@@ -25,6 +25,7 @@ from GridCalEngine.Devices.Substation.bus import Bus
 from GridCalEngine.enumerations import DiagramType, DeviceType
 from GridCalEngine.basic_structures import Logger
 from GridCalEngine.Devices.types import ALL_DEV_TYPES
+from GridCalEngine.enumerations import Colormaps
 
 
 class PointsGroup:
@@ -103,7 +104,7 @@ class PointsGroup:
                 # locations with no API object are not created
                 logger.add_error("Diagram location could not find API object",
                                  device_class=category,
-                                 device=idtag,)
+                                 device=idtag, )
             else:
                 if 'x' in location:
                     self.locations[idtag] = GraphicLocation(x=location['x'],
@@ -125,10 +126,29 @@ class BaseDiagram:
     Diagram
     """
 
-    def __init__(self, idtag: Union[str, None], name: str, diagram_type: DiagramType = DiagramType):
+    def __init__(self,
+                 idtag: Union[str, None],
+                 name: str,
+                 diagram_type: DiagramType = DiagramType,
+                 use_flow_based_width: bool = False,
+                 min_branch_width: int = 5,
+                 max_branch_width=5,
+                 min_bus_width=20,
+                 max_bus_width=20,
+                 palette: Colormaps = Colormaps.GridCal,
+                 default_bus_voltage: float = 10):
         """
 
-        :param name: Diagram name
+        :param idtag:
+        :param name:
+        :param diagram_type:
+        :param use_flow_based_width:
+        :param min_branch_width:
+        :param max_branch_width:
+        :param min_bus_width:
+        :param max_bus_width:
+        :param palette:
+        :param default_bus_voltage:
         """
         if idtag is None:
             self.idtag = uuid.uuid4().hex
@@ -140,7 +160,81 @@ class BaseDiagram:
         # device_type: {device uuid: {x, y, h, w, r}}
         self.data: Dict[str, PointsGroup] = dict()
 
-        self.diagram_type = diagram_type
+        # diagram type: Map or Schematic, ...
+        self.diagram_type: DiagramType = diagram_type
+
+        # sizes
+        self._use_flow_based_width: bool = use_flow_based_width
+        self._min_branch_width: float = min_branch_width
+        self._max_branch_width: float = max_branch_width
+        self._min_bus_width: float = min_bus_width
+        self._max_bus_width: float = max_bus_width
+
+        self._palette = palette
+        self._default_bus_voltage: float = default_bus_voltage
+
+    @property
+    def use_flow_based_width(self) -> bool:
+        return self._use_flow_based_width
+
+    @use_flow_based_width.setter
+    def use_flow_based_width(self, value: bool):
+        self._use_flow_based_width = value
+
+    # min_branch_width property
+    @property
+    def min_branch_width(self) -> float:
+        return self._min_branch_width
+
+    @min_branch_width.setter
+    def min_branch_width(self, value: float):
+        self._min_branch_width = value
+
+    # max_branch_width property
+    @property
+    def max_branch_width(self) -> float:
+        return self._max_branch_width
+
+    @max_branch_width.setter
+    def max_branch_width(self, value: float):
+        self._max_branch_width = value
+
+    # min_bus_width property
+    @property
+    def min_bus_width(self) -> float:
+        return self._min_bus_width
+
+    @min_bus_width.setter
+    def min_bus_width(self, value: float):
+        self._min_bus_width = value
+
+    # max_bus_width property
+    @property
+    def max_bus_width(self) -> float:
+        return self._max_bus_width
+
+    @max_bus_width.setter
+    def max_bus_width(self, value: float):
+        self._max_bus_width = value
+
+    # palette property
+    @property
+    def palette(self) -> Colormaps:
+        return self._palette
+
+    @palette.setter
+    def palette(self, value: Colormaps):
+        assert isinstance(value, Colormaps)
+        self._palette = value
+
+    # default_bus_voltage property
+    @property
+    def default_bus_voltage(self) -> float:
+        return self._default_bus_voltage
+
+    @default_bus_voltage.setter
+    def default_bus_voltage(self, value: float):
+        self._default_bus_voltage = value
 
     def set_point(self, device: ALL_DEV_TYPES, location: Union[GraphicLocation, MapLocation]):
         """
@@ -209,7 +303,7 @@ class BaseDiagram:
 
         return group
 
-    def get_properties_dict(self) -> Dict[str, Union[str, int, float, Dict[str,  Union[GraphicLocation, MapLocation]]]]:
+    def get_properties_dict(self) -> Dict[str, Union[str, int, float, Dict[str, Union[GraphicLocation, MapLocation]]]]:
         """
         get the properties dictionary to save
         :return: dictionary to serialize
@@ -219,6 +313,13 @@ class BaseDiagram:
         return {'type': self.diagram_type.value,
                 'idtag': self.idtag,
                 'name': self.name,
+                "use_flow_based_width": self.use_flow_based_width,
+                "min_branch_width": self.min_branch_width,
+                "max_branch_width": self.max_branch_width,
+                "min_bus_width": self.min_bus_width,
+                "max_bus_width": self.max_bus_width,
+                "palette": self.palette.value,
+                "default_bus_voltage": self.default_bus_voltage,
                 'data': data}
 
     def parse_data(self,
@@ -235,13 +336,20 @@ class BaseDiagram:
 
         self.name = data['name']
 
+        self.use_flow_based_width: bool = data.get("use_flow_based_width", False)
+        self.min_branch_width: float = data.get("min_branch_width", 5)
+        self.max_branch_width: float = data.get("max_branch_width", 5)
+        self.min_bus_width: float = data.get("min_bus_width", 20)
+        self.max_bus_width: float = data.get("max_bus_width", 20)
+        self.palette = Colormaps(data.get("palette", 'GridCal'))
+        self.default_bus_voltage = data.get("default_bus_voltage", 10)
+
         if data['type'] == 'bus-branch':
             self.diagram_type = DiagramType.Schematic
         else:
             self.diagram_type = DiagramType(data['type'])
 
         for category, loc_dict in data['data'].items():
-
             points_group = PointsGroup(name=category)
             points_group.parse_data(data=loc_dict,
                                     obj_dict=obj_dict.get(category, dict()),
@@ -325,7 +433,6 @@ class BaseDiagram:
                     t = graph_node_dictionary.get(branch.target.idtag, None)
 
                     if f is not None and t is not None:
-
                         w = 0.01
 
                         tuples.append((f, t, w))
@@ -356,3 +463,29 @@ class BaseDiagram:
                 min_y = min(min_y, y)
 
         return min_x, max_x, min_y, max_y
+
+    def set_size_constraints(self,
+                             use_flow_based_width: bool = False,
+                             min_branch_width: int = 5,
+                             max_branch_width=5,
+                             min_bus_width=20,
+                             max_bus_width=20):
+        """
+        Set the size constraints
+        :param use_flow_based_width:
+        :param min_branch_width:
+        :param max_branch_width:
+        :param min_bus_width:
+        :param max_bus_width:
+        """
+        self.use_flow_based_width: bool = use_flow_based_width
+        self.min_branch_width: float = min_branch_width
+        self.max_branch_width: float = max_branch_width
+        self.min_bus_width: float = min_bus_width
+        self.max_bus_width: float = max_bus_width
+
+        # print(f"{self.use_flow_based_width}, "
+        #       f"{self.min_branch_width}, "
+        #       f"{self.max_branch_width}, "
+        #       f"{self.min_bus_width}, "
+        #       f"{self.max_bus_width}")

{GridCalEngine-5.1.18 → GridCalEngine-5.1.20}/GridCalEngine/Devices/Diagrams/map_location.py

@@ -37,12 +37,63 @@ class MapLocation:
         :param draw_labels:
         """
 
-        self.latitude = latitude
-        self.longitude = longitude
-        self.altitude = altitude
+        self._latitude = latitude if latitude is not None else 0.0
+        self._longitude = longitude if longitude is not None else 0.0
+        self._altitude = altitude if altitude is not None else 0.0
         self.draw_labels = draw_labels
         self.api_object = api_object
 
+    @property
+    def latitude(self):
+        """
+
+        :return:
+        """
+        return self._latitude
+
+    @latitude.setter
+    def latitude(self, val: float):
+        """
+
+        :param val:
+        :return:
+        """
+        self._latitude = val if val is not None else 0.0
+
+    @property
+    def longitude(self):
+        """
+
+        :return:
+        """
+        return self._longitude
+
+    @longitude.setter
+    def longitude(self, val: float):
+        """
+
+        :param val:
+        :return:
+        """
+        self._longitude = val if val is not None else 0.0
+
+    @property
+    def altitude(self):
+        """
+
+        :return:
+        """
+        return self._altitude
+
+    @altitude.setter
+    def altitude(self, val: float):
+        """
+
+        :param val:
+        :return:
+        """
+        self._altitude = val if val is not None else 0.0
+
     def get_properties_dict(self) -> Dict[str, float]:
         """
         get as a dictionary point