GridCalEngine 5.1.52__tar.gz → 5.1.54__tar.gz

{GridCalEngine-5.1.52 → GridCalEngine-5.1.54}/GridCalEngine/DataStructures/branch_data.py

@@ -14,13 +14,15 @@
 # You should have received a copy of the GNU Lesser General Public License
 # along with this program; if not, write to the Free Software Foundation,
 # Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+from __future__ import annotations
+
 import numpy as np
 import pandas as pd
 import scipy.sparse as sp
 import GridCalEngine.Topology.topology as tp
 from GridCalEngine.enumerations import WindingsConnection
 from GridCalEngine.Utils.Sparse.sparse_array import SparseObjectArray
-from GridCalEngine.basic_structures import Vec, IntVec, StrVec, ObjVec, CxVec, BoolVec
+from GridCalEngine.basic_structures import Vec, IntVec, StrVec, ObjVec, CxVec, BoolVec, Logger
 from typing import List, Tuple, Dict, Set
 
 
@@ -126,11 +128,12 @@ class BranchData:
 
         return self.nelm
 
-    def slice(self, elm_idx: IntVec, bus_idx: IntVec) -> "BranchData":
+    def slice(self, elm_idx: IntVec, bus_idx: IntVec, logger: Logger | None) -> "BranchData":
         """
         Slice branch data by given indices
         :param elm_idx: array of branch indices
         :param bus_idx: array of bus indices
+        :param logger: Logger
         :return: new BranchData instance
         """
 
@@ -204,8 +207,21 @@ class BranchData:
         data.T = self.T[elm_idx]
         bus_map: Dict[int, int] = {o: i for i, o in enumerate(bus_idx)}
         for k in range(data.nelm):
-            data.F[k] = bus_map[data.F[k]]
-            data.T[k] = bus_map[data.T[k]]
+            data.F[k] = bus_map.get(data.F[k], -1)
+
+            if data.F[k] == -1:
+                if logger is not None:
+                    logger.add_error(f"Branch {k}, {self.names[k]} if connected to a disconnected node",
+                                     value=data.F[k])
+                data.active[k] = 0
+
+            data.T[k] = bus_map.get(data.T[k], -1)
+
+            if data.T[k] == -1:
+                if logger is not None:
+                    logger.add_error(f"Branch {k}, {self.names[k]} if connected to a disconnected node",
+                                     value=data.T[k])
+                data.active[k] = 0
 
         data.overload_cost = self.overload_cost[elm_idx]
 

{GridCalEngine-5.1.52 → GridCalEngine-5.1.54}/GridCalEngine/DataStructures/numerical_circuit.py

@@ -24,7 +24,7 @@ from GridCalEngine.Devices import RemedialAction
 from GridCalEngine.basic_structures import Logger
 from GridCalEngine.Devices.multi_circuit import MultiCircuit
 from GridCalEngine.basic_structures import Vec, IntVec, CxVec
-from GridCalEngine.enumerations import BranchImpedanceMode, BusMode
+from GridCalEngine.enumerations import BranchImpedanceMode, BusMode, ContingencyOperationTypes
 import GridCalEngine.Topology.topology as tp
 import GridCalEngine.Topology.simulation_indices as si
 
@@ -494,12 +494,12 @@ class NumericalCircuit:
                 structure, idx = self.structs_dict.get(cnt.device_idtag, (None, 0))
 
                 if structure is not None:
-                    if cnt.prop == 'active':
+                    if cnt.prop == ContingencyOperationTypes.Active:
                         if revert:
                             structure.active[idx] = int(not bool(cnt.value))
                         else:
                             structure.active[idx] = int(cnt.value)
-                    elif cnt.prop == '%':
+                    elif cnt.prop == ContingencyOperationTypes.PowerPercentage:
                         if revert:
                             structure.p[idx] /= float(cnt.value / 100.0)
                         else:
@@ -528,12 +528,12 @@ class NumericalCircuit:
                 structure, idx = self.structs_dict.get(cnt.device_idtag, (None, 0))
 
                 if structure is not None:
-                    if cnt.prop == 'active':
+                    if cnt.prop == ContingencyOperationTypes.Active:
                         if revert:
                             structure.active[idx] = int(not bool(cnt.value))
                         else:
                             structure.active[idx] = int(cnt.value)
-                    elif cnt.prop == '%':
+                    elif cnt.prop == ContingencyOperationTypes.PowerPercentage:
                         # TODO Cambiar el acceso a P por una función (o función que incremente- decremente porcentaje)
                         assert not isinstance(structure, ds.HvdcData)  # TODO Arreglar esto
                         dev_injections = np.zeros(structure.size())
@@ -1834,13 +1834,17 @@ class NumericalCircuit:
         return df
 
     def get_island(self, bus_idx: IntVec,
-                   consider_hvdc_as_island_links: bool = False) -> "NumericalCircuit":
+                   consider_hvdc_as_island_links: bool = False,
+                   logger: Logger | None = None) -> "NumericalCircuit":
         """
         Get the island corresponding to the given buses
         :param bus_idx: array of bus indices
         :param consider_hvdc_as_island_links: Does the HVDCLine works for the topology as a normal line?
+        :param logger: Logger
         :return: SnapshotData
         """
+        if logger is None:
+            logger = Logger()
 
         # if the island is the same as the original bus indices, no slicing is needed
         if len(bus_idx) == len(self.bus_data.original_idx):
@@ -1875,7 +1879,7 @@ class NumericalCircuit:
 
         # slice data
         nc.bus_data = self.bus_data.slice(elm_idx=bus_idx)
-        nc.branch_data = self.branch_data.slice(elm_idx=br_idx, bus_idx=bus_idx)
+        nc.branch_data = self.branch_data.slice(elm_idx=br_idx, bus_idx=bus_idx, logger=logger)
 
         nc.load_data = self.load_data.slice(elm_idx=load_idx, bus_idx=bus_idx)
         nc.battery_data = self.battery_data.slice(elm_idx=batt_idx, bus_idx=bus_idx)
@@ -1890,13 +1894,17 @@ class NumericalCircuit:
 
     def split_into_islands(self,
                            ignore_single_node_islands: bool = False,
-                           consider_hvdc_as_island_links: bool = False) -> List["NumericalCircuit"]:
+                           consider_hvdc_as_island_links: bool = False,
+                           logger: Logger | None = None) -> List["NumericalCircuit"]:
         """
         Split circuit into islands
         :param ignore_single_node_islands: ignore islands composed of only one bus
         :param consider_hvdc_as_island_links: Does the HVDCLine works for the topology as a normal line?
+        :param logger: Logger
         :return: List[NumericCircuit]
         """
+        if logger is None:
+            logger = Logger()
 
         # find the matching islands
         adj = self.compute_adjacency_matrix(consider_hvdc_as_island_links=consider_hvdc_as_island_links)
@@ -1907,10 +1915,14 @@ class NumericalCircuit:
         for bus_idx in idx_islands:
             if ignore_single_node_islands:
                 if len(bus_idx) > 1:
-                    island = self.get_island(bus_idx, consider_hvdc_as_island_links=consider_hvdc_as_island_links)
+                    island = self.get_island(bus_idx,
+                                             consider_hvdc_as_island_links=consider_hvdc_as_island_links,
+                                             logger=logger)
                     circuit_islands.append(island)
             else:
-                island = self.get_island(bus_idx, consider_hvdc_as_island_links=consider_hvdc_as_island_links)
+                island = self.get_island(bus_idx,
+                                         consider_hvdc_as_island_links=consider_hvdc_as_island_links,
+                                         logger=logger)
                 circuit_islands.append(island)
 
         return circuit_islands

{GridCalEngine-5.1.52 → GridCalEngine-5.1.54}/GridCalEngine/Devices/Aggregation/contingency.py

@@ -18,6 +18,7 @@
 from typing import Union
 from GridCalEngine.Devices.Parents.editable_device import EditableDevice, DeviceType
 from GridCalEngine.Devices.Aggregation.contingency_group import ContingencyGroup
+from GridCalEngine.enumerations import ContingencyOperationTypes
 
 
 class Contingency(EditableDevice):
@@ -29,7 +30,9 @@ class Contingency(EditableDevice):
                  idtag: Union[str, None] = None,
                  device_idtag='',
                  name="Contingency",
-                 code='', prop='active', value=0.0,
+                 code='',
+                 prop: ContingencyOperationTypes = ContingencyOperationTypes.Active,
+                 value=0.0,
                  group: Union[None, ContingencyGroup] = None):
         """
         Contingency
@@ -49,13 +52,13 @@ class Contingency(EditableDevice):
 
         # Contingency type
         self.device_idtag = device_idtag
-        self._prop = prop
+        self._prop: ContingencyOperationTypes = prop
         self._value = value
         self._group: ContingencyGroup = group
-        self._allowed_properties = ['active', '%']
 
         self.register(key='device_idtag', units='', tpe=str, definition='Unique ID', editable=False)
-        self.register(key='prop', units='', tpe=str, definition='Name of the object property to change (active, %)')
+        self.register(key='prop', units='', tpe=ContingencyOperationTypes,
+                      definition=f'Object property to change')
         self.register(key='value', units='', tpe=float, definition='Property value')
         self.register(key='group', units='', tpe=DeviceType.ContingencyGroupDevice, definition='Contingency group')
 
@@ -68,19 +71,19 @@ class Contingency(EditableDevice):
         self._name = val
 
     @property
-    def prop(self) -> str:
+    def prop(self) -> ContingencyOperationTypes:
         """
         Property to modify when contingency is triggered out
-        :return:
+        :return: ContingencyOperationsTypes
         """
         return self._prop
 
     @prop.setter
-    def prop(self, val: str):
-        if val in self._allowed_properties:
+    def prop(self, val: ContingencyOperationTypes):
+        if isinstance(val, ContingencyOperationTypes):
             self._prop = val
         else:
-            print(f"Not allowed property {val}, allowed: " + "".join(self._allowed_properties))
+            print(f"Not allowed property {val}")
 
     @property
     def value(self) -> float:

{GridCalEngine-5.1.52 → GridCalEngine-5.1.54}/GridCalEngine/Devices/Aggregation/remedial_action.py

@@ -18,6 +18,7 @@
 from typing import Union
 from GridCalEngine.Devices.Parents.editable_device import EditableDevice, DeviceType
 from GridCalEngine.Devices.Aggregation.remedial_action_group import RemedialActionGroup
+from GridCalEngine.enumerations import ContingencyOperationTypes
 
 
 class RemedialAction(EditableDevice):
@@ -30,7 +31,7 @@ class RemedialAction(EditableDevice):
                  device_idtag='',
                  name="Remedial action",
                  code='',
-                 prop='active',
+                 prop: ContingencyOperationTypes = ContingencyOperationTypes.Active,
                  value=0.0,
                  group: Union[None, RemedialActionGroup] = None):
         """
@@ -51,13 +52,13 @@ class RemedialAction(EditableDevice):
 
         # Contingency type
         self.device_idtag = device_idtag
-        self._prop = prop
+        self._prop: ContingencyOperationTypes = prop
         self._value = value
         self._group: RemedialActionGroup = group
-        self._allowed_properties = ['active', '%']
 
         self.register(key='device_idtag', units='', tpe=str, definition='Unique ID', editable=False)
-        self.register(key='prop', units='', tpe=str, definition='Name of the object property to change (active, %)')
+        self.register(key='prop', units='', tpe=ContingencyOperationTypes,
+                      definition=f'Object property to change')
         self.register(key='value', units='', tpe=float, definition='Property value')
         self.register(key='group', units='', tpe=DeviceType.RemedialActionGroupDevice,
                       definition='Remedial action group')
@@ -71,19 +72,19 @@ class RemedialAction(EditableDevice):
         self._name = val
 
     @property
-    def prop(self) -> str:
+    def prop(self) -> ContingencyOperationTypes:
         """
         Property to modify when contingency is triggered out
-        :return:
+        :return: ContingencyOperationsTypes
         """
         return self._prop
 
     @prop.setter
-    def prop(self, val: str):
-        if val in self._allowed_properties:
+    def prop(self, val: ContingencyOperationTypes):
+        if isinstance(val, ContingencyOperationTypes):
             self._prop = val
         else:
-            print(f"Not allowed property {val}, allowed: " + "".join(self._allowed_properties))
+            print(f"Not allowed property {val}")
 
     @property
     def value(self) -> float:

{GridCalEngine-5.1.52 → GridCalEngine-5.1.54}/GridCalEngine/Devices/Branches/hvdc_line.py

@@ -145,7 +145,8 @@ class HvdcLine(BranchParent):
                  overload_cost=1000.0, min_firing_angle_f=-1.0, max_firing_angle_f=1.0, min_firing_angle_t=-1.0,
                  max_firing_angle_t=1.0, contingency_factor=1.0, protection_rating_factor: float = 1.4,
                  control_mode: HvdcControlType = HvdcControlType.type_1_Pset, dispatchable=True, angle_droop=0,
-                 capex=0, opex=0, build_status: BuildStatus = BuildStatus.Commissioned, n_lines: int = 1):
+                 capex=0, opex=0, build_status: BuildStatus = BuildStatus.Commissioned,
+                 dc_link_voltage: float = 200):
         """
         HVDC Line model
         :param bus_from: Bus from
@@ -199,6 +200,10 @@ class HvdcLine(BranchParent):
 
         self.r = float(r)
 
+        self.dc_link_voltage = float(dc_link_voltage)
+
+        # self.n_lines = int(n_lines)
+
         self.angle_droop = float(angle_droop)
 
         self.loss_factor = float(loss_factor)
@@ -238,8 +243,6 @@ class HvdcLine(BranchParent):
         self._Vset_t_prof: Vec = Profile(default_value=Vset_t, data_type=float)
         self._angle_droop_prof: Vec = Profile(default_value=angle_droop, data_type=float)
 
-        self.n_lines = n_lines
-
         # Line locations
         self._locations: LineLocations = LineLocations()
 
@@ -248,11 +251,16 @@ class HvdcLine(BranchParent):
         self.register(key='control_mode', units='-', tpe=HvdcControlType, definition='Control type.')
         self.register(key='Pset', units='MW', tpe=float, definition='Set power flow.', profile_name='Pset_prof')
         self.register(key='r', units='Ohm', tpe=float, definition='line resistance.')
+        self.register(key='dc_link_voltage', units='kV', tpe=float,
+                      definition='line voltage (only for compatibility, not used in calcs.)')
+
         self.register(key='angle_droop', units='MW/deg', tpe=float, definition='Power/angle rate control',
                       profile_name='angle_droop_prof')
-        self.register(key='n_lines', units='', tpe=int,
-                      definition='Number of parallel lines between the converter stations. '
-                                 'The rating will be equally divided')
+
+        # self.register(key='n_lines', units='', tpe=int,
+        #               definition='Number of parallel lines between the converter stations. '
+        #                          'The rating will be equally divided')
+
         self.register(key='Vset_f', units='p.u.', tpe=float, definition='Set voltage at the from side',
                       profile_name='Vset_f_prof')
         self.register(key='Vset_t', units='p.u.', tpe=float, definition='Set voltage at the to side',

{GridCalEngine-5.1.52 → GridCalEngine-5.1.54}/GridCalEngine/Devices/Branches/transformer3w.py

@@ -18,6 +18,7 @@
 from typing import Tuple, Union
 import numpy as np
 from GridCalEngine.Devices.Substation.bus import Bus
+from GridCalEngine.Devices.Substation.connectivity_node import ConnectivityNode
 from GridCalEngine.Devices.Parents.physical_device import PhysicalDevice
 from GridCalEngine.Devices.Branches.winding import Winding
 from GridCalEngine.Devices.Branches.transformer_type import get_impedances
@@ -28,6 +29,7 @@ from GridCalEngine.enumerations import DeviceType
 def delta_to_star(z12: float, z23: float, z31: float) -> Tuple[float, float, float]:
     """
     Perform the delta->star transformation
+    See: https://www.electronics-tutorials.ws/dccircuits/dcp_10.html
     :param z12: 1 to 2 delta value
     :param z23: 2 to 3 delta value
     :param z31: 3 to 1 delta value
@@ -43,6 +45,23 @@ def delta_to_star(z12: float, z23: float, z31: float) -> Tuple[float, float, flo
         return 1e-20, 1e-20, 1e-20
 
 
+def star_to_delta(z1: float, z2: float, z3: float) -> Tuple[float, float, float]:
+    """
+    Perform the star->delta transformation
+    See: https://www.electronics-tutorials.ws/dccircuits/dcp_10.html
+    :param z1: 0->1 impedance
+    :param z2: 0->2 impedance
+    :param z3: 0->3 impedance
+    :return: z12, z23, z31 impedances
+    """
+    zt = z1 * z2 + z2 * z3 + z3 * z1
+    z12 = zt / z3
+    z23 = zt / z2
+    z31 = zt / z1
+
+    return z12, z23, z31
+
+
 class Transformer3W(PhysicalDevice):
 
     def __init__(self, idtag: Union[str, None] = None,
@@ -50,6 +69,10 @@ class Transformer3W(PhysicalDevice):
                  name: str = 'Branch',
                  bus0: Union[None, Bus] = None,
                  bus1: Bus = None, bus2: Bus = None, bus3: Bus = None,
+                 cn0: Union[None, ConnectivityNode] = None,
+                 cn1: ConnectivityNode = None,
+                 cn2: ConnectivityNode = None,
+                 cn3: ConnectivityNode = None,
                  w1_idtag: Union[str, None] = None,
                  w2_idtag: Union[str, None] = None,
                  w3_idtag: Union[str, None] = None,
@@ -95,10 +118,23 @@ class Transformer3W(PhysicalDevice):
             bus0.Vnom = 1.0
             self.bus0 = bus0
 
+        if cn0 is None:
+            self.cn0 = ConnectivityNode(name=name + '_cn', Vnom=1.0, internal=True)
+        else:
+            cn0.is_internal = True
+            cn0.Vnom = 1.0
+            self.cn0 = cn0
+
+        self.cn0.default_bus = self.bus0
+
         self._bus1 = bus1
         self._bus2 = bus2
         self._bus3 = bus3
 
+        self._cn1 = cn1
+        self._cn2 = cn2
+        self._cn3 = cn3
+
         self.active = bool(active)
         self._active_prof = Profile(default_value=self.active, data_type=bool)
 
@@ -130,9 +166,21 @@ class Transformer3W(PhysicalDevice):
         self._Pfe: float = 0.0
         self._I0: float = 0.0
 
-        self._winding1 = Winding(bus_from=self.bus0, idtag=w1_idtag, bus_to=bus1, HV=V1, LV=1.0, name=name + "_W1")
-        self._winding2 = Winding(bus_from=self.bus0, idtag=w2_idtag, bus_to=bus2, HV=V2, LV=1.0, name=name + "_W2")
-        self._winding3 = Winding(bus_from=self.bus0, idtag=w3_idtag, bus_to=bus3, HV=V3, LV=1.0, name=name + "_W3")
+        self._winding1 = Winding(bus_from=self.bus0, idtag=w1_idtag,
+                                 bus_to=bus1,
+                                 cn_from=self.cn0,
+                                 cn_to=self.cn1,
+                                 HV=V1, LV=1.0, name=name + "_W1")
+        self._winding2 = Winding(bus_from=self.bus0, idtag=w2_idtag,
+                                 bus_to=bus2,
+                                 cn_from=self.cn0,
+                                 cn_to=self.cn2,
+                                 HV=V2, LV=1.0, name=name + "_W2")
+        self._winding3 = Winding(bus_from=self.bus0, idtag=w3_idtag,
+                                 bus_to=bus3,
+                                 cn_from=self.cn0,
+                                 cn_to=self.cn3,
+                                 HV=V3, LV=1.0, name=name + "_W3")
 
         self.x = float(x)
         self.y = float(y)
@@ -143,6 +191,16 @@ class Transformer3W(PhysicalDevice):
         self.register(key='bus2', units='', tpe=DeviceType.BusDevice, definition='Bus 2.', editable=False)
         self.register(key='bus3', units='', tpe=DeviceType.BusDevice, definition='Bus 3.', editable=False)
 
+        self.register(key='cn0', units='', tpe=DeviceType.ConnectivityNodeDevice,
+                      definition='Middle point connection cn.',
+                      editable=False)
+        self.register(key='cn1', units='', tpe=DeviceType.ConnectivityNodeDevice, definition='ConnectivityNode 1.',
+                      editable=False)
+        self.register(key='cn2', units='', tpe=DeviceType.ConnectivityNodeDevice, definition='ConnectivityNode 2.',
+                      editable=False)
+        self.register(key='cn3', units='', tpe=DeviceType.ConnectivityNodeDevice, definition='ConnectivityNode 3.',
+                      editable=False)
+
         self.register('active', units="", tpe=bool, definition='Is active?', profile_name="active_prof")
 
         self.register(key='winding1', units='', tpe=DeviceType.WindingDevice, definition='Winding 1.', editable=False)
@@ -269,6 +327,42 @@ class Transformer3W(PhysicalDevice):
         if obj is not None:
             self.winding3.set_hv_and_lv(self.winding3.HV, self.winding3.LV)
 
+    @property
+    def cn1(self) -> ConnectivityNode:
+        """
+        ConnectivityNode 1
+        """
+        return self._cn1
+
+    @cn1.setter
+    def cn1(self, obj: ConnectivityNode):
+        self._cn1 = obj
+        self.winding1.cn_to = obj
+
+    @property
+    def cn2(self) -> ConnectivityNode:
+        """
+        ConnectivityNode 2
+        """
+        return self._cn2
+
+    @cn2.setter
+    def cn2(self, obj: ConnectivityNode):
+        self._cn2 = obj
+        self.winding2.cn_to = obj
+
+    @property
+    def cn3(self) -> ConnectivityNode:
+        """
+        ConnectivityNode 3
+        """
+        return self._cn3
+
+    @cn3.setter
+    def cn3(self, obj: ConnectivityNode):
+        self._cn3 = obj
+        self.winding3.cn_to = obj
+
     @property
     def V1(self) -> float:
         """
@@ -326,6 +420,28 @@ class Transformer3W(PhysicalDevice):
         self.winding3.X = x3
         self.winding3.rate = self.rate3
 
+    def fill_from_star(self, r1: float, r2: float, r3: float, x1: float, x2: float, x3: float) -> None:
+        """
+        Fill from Star values
+        :param r1: resistance of the branch 1 (p.u.)
+        :param r2: resistance of the branch 2 (p.u.)
+        :param r3: resistance of the branch 3 (p.u.)
+        :param x1: reactance of the branch 1 (p.u.)
+        :param x2: reactance of the branch 2 (p.u.)
+        :param x3: reactance of the branch 3 (p.u.)
+        """
+        self._r12, self._r23, self._r31 = star_to_delta(z1=r1, z2=r2, z3=r3)
+        self._x12, self._x23, self._x31 = star_to_delta(z1=x1, z2=x2, z3=x3)
+
+        self.winding1.R = r1
+        self.winding1.X = x1
+
+        self.winding2.R = r2
+        self.winding2.X = x2
+
+        self.winding3.R = r3
+        self.winding3.X = x3
+
     @property
     def r12(self):
         """

{GridCalEngine-5.1.52 → GridCalEngine-5.1.54}/GridCalEngine/Devices/Diagrams/base_diagram.py

@@ -135,6 +135,7 @@ class BaseDiagram:
                  max_branch_width=5,
                  min_bus_width=20,
                  max_bus_width=20,
+                 arrow_size=20,
                  palette: Colormaps = Colormaps.GridCal,
                  default_bus_voltage: float = 10):
         """
@@ -147,6 +148,7 @@ class BaseDiagram:
         :param max_branch_width:
         :param min_bus_width:
         :param max_bus_width:
+        :param arrow_size:
         :param palette:
         :param default_bus_voltage:
         """
@@ -169,6 +171,7 @@ class BaseDiagram:
         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._arrow_size: float = arrow_size
 
         self._palette = palette
         self._default_bus_voltage: float = default_bus_voltage
@@ -188,6 +191,10 @@ class BaseDiagram:
     # min_branch_width property
     @property
     def min_branch_width(self) -> float:
+        """
+
+        :return:
+        """
         return self._min_branch_width
 
     @min_branch_width.setter
@@ -197,6 +204,10 @@ class BaseDiagram:
     # max_branch_width property
     @property
     def max_branch_width(self) -> float:
+        """
+
+        :return:
+        """
         return self._max_branch_width
 
     @max_branch_width.setter
@@ -206,24 +217,48 @@ class BaseDiagram:
     # min_bus_width property
     @property
     def min_bus_width(self) -> float:
+        """
+
+        :return:
+        """
         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:
+        """
         return self._max_bus_width
 
     @max_bus_width.setter
     def max_bus_width(self, value: float):
         self._max_bus_width = value
 
+    @property
+    def arrow_size(self) -> float:
+        """
+
+        :return:
+        """
+        return self._arrow_size
+
+    @arrow_size.setter
+    def arrow_size(self, value: float):
+        self._arrow_size = value
+
     # palette property
     @property
     def palette(self) -> Colormaps:
+        """
+
+        :return:
+        """
         return self._palette
 
     @palette.setter
@@ -234,6 +269,10 @@ class BaseDiagram:
     # default_bus_voltage property
     @property
     def default_bus_voltage(self) -> float:
+        """
+
+        :return:
+        """
         return self._default_bus_voltage
 
     @default_bus_voltage.setter
@@ -322,6 +361,8 @@ class BaseDiagram:
                 "max_branch_width": self.max_branch_width,
                 "min_bus_width": self.min_bus_width,
                 "max_bus_width": self.max_bus_width,
+                "arrow_size": self.arrow_size,
+
                 "palette": self.palette.value,
                 "default_bus_voltage": self.default_bus_voltage,
                 'data': data}
@@ -345,6 +386,7 @@ class BaseDiagram:
         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.arrow_size: float = data.get("arrow_size", 20)
         self.palette = Colormaps(data.get("palette", 'GridCal'))
         self.default_bus_voltage = data.get("default_bus_voltage", 10)
 
@@ -473,7 +515,8 @@ class BaseDiagram:
                              min_branch_width: int = 5,
                              max_branch_width=5,
                              min_bus_width=20,
-                             max_bus_width=20):
+                             max_bus_width=20,
+                             arrow_size=20):
         """
         Set the size constraints
         :param use_flow_based_width:
@@ -481,15 +524,11 @@ class BaseDiagram:
         :param max_branch_width:
         :param min_bus_width:
         :param max_bus_width:
+        :param arrow_size:
         """
         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}")
+        self.arrow_size = arrow_size

{GridCalEngine-5.1.52 → GridCalEngine-5.1.54}/GridCalEngine/Devices/Parents/editable_device.py

@@ -25,7 +25,7 @@ from GridCalEngine.enumerations import (DeviceType, TimeFrame, BuildStatus, Wind
                                         CpfParametrization, CpfStopAt, InvestmentEvaluationMethod, SolverType,
                                         InvestmentsEvaluationObjectives, NodalCapacityMethod, TimeGrouping,
                                         ZonalGrouping, MIPSolvers, AcOpfMode, SubstationTypes,
-                                        BranchImpedanceMode, FaultType, TapChangerTypes)
+                                        BranchImpedanceMode, FaultType, TapChangerTypes, ContingencyOperationTypes)
 
 # types that can be assigned to a GridCal property
 GCPROP_TYPES = Union[
@@ -56,7 +56,8 @@ GCPROP_TYPES = Union[
     Type[BranchImpedanceMode],
     Type[FaultType],
     Type[TapChangerTypes],
-    Type[SubstationTypes]
+    Type[SubstationTypes],
+    Type[ContingencyOperationTypes]
 ]