GridCalEngine 5.1.19__tar.gz → 5.1.21__tar.gz

{GridCalEngine-5.1.19 → GridCalEngine-5.1.21}/GridCalEngine/Compilers/circuit_to_data.py

@@ -30,6 +30,8 @@ if TYPE_CHECKING:  # Only imports the below statements during type checking
 
 
 def set_bus_control_voltage(i: int,
+                            j: int,
+                            remote_control: bool,
                             bus_name: str,
                             bus_voltage_used: BoolVec,
                             bus_data: ds.BusData,
@@ -39,6 +41,8 @@ def set_bus_control_voltage(i: int,
     """
     Set the bus control voltage
     :param i: Bus index
+    :param j: Remote Bus index
+    :param remote_control: Using remote control?
     :param bus_name: Bus name
     :param bus_voltage_used: Array of flags indicating if a bus voltage has been modified before
     :param bus_data: BusData
@@ -46,13 +50,26 @@ def set_bus_control_voltage(i: int,
     :param use_stored_guess: Use the stored seed values?
     :param logger: Logger
     """
-    if bus_data.bus_types[i] != BusMode.Slack.value:  # if it is not Slack
-        bus_data.bus_types[i] = BusMode.PV.value  # set as PV
+    if bus_data.bus_types[i] != BusMode.Slack_tpe.value:  # if it is not Slack
+        if remote_control and j > -1 and j != i:
+            # remove voltage control
+            bus_data.bus_types[j] = BusMode.PQV_tpe.value  # remote bus to PQV type
+            bus_data.bus_types[i] = BusMode.P_tpe.value  # local bus to P type
+        else:
+            # local voltage control
+            bus_data.bus_types[i] = BusMode.PV_tpe.value  # set as PV
 
     if not use_stored_guess:
         if not bus_voltage_used[i]:
-            bus_data.Vbus[i] = complex(candidate_Vm, 0)
-            bus_voltage_used[i] = True
+            if remote_control and j > -1 and j != i:
+                # initialize the remote bus voltage to the control value
+                bus_data.Vbus[j] = complex(candidate_Vm, 0)
+                bus_voltage_used[j] = True
+            else:
+                # initialize the local bus voltage to the control value
+                bus_data.Vbus[i] = complex(candidate_Vm, 0)
+                bus_voltage_used[i] = True
+
         elif candidate_Vm != bus_data.Vbus[i]:
             logger.add_error(msg='Different control voltage set points',
                              device=bus_name,
@@ -89,18 +106,18 @@ def get_bus_data(circuit: MultiCircuit,
         bus_data.cost_v[i] = bus.Vm_cost
         # TODO: Check that the devices are are changing the guess
         bus_data.Vbus[i] = bus.get_voltage_guess(None, use_stored_guess=use_stored_guess)
+        bus_data.is_dc[i] = bus.is_dc
 
         bus_data.angle_min[i] = bus.angle_min
         bus_data.angle_max[i] = bus.angle_max
 
         if bus.is_slack:
-            bus_data.bus_types[i] = BusMode.Slack.value  # VD
+            bus_data.bus_types[i] = BusMode.Slack_tpe.value  # VD
         else:
             # bus.determine_bus_type().value
-            bus_data.bus_types[i] = BusMode.PQ.value  # PQ by default, later it is modified by generators and batteries
+            bus_data.bus_types[i] = BusMode.PQ_tpe.value  # PQ by default, later it is modified by generators and batteries
 
-        if bus.substation is not None:
-            bus_data.substations[i] = substation_dict[bus.substation]
+        bus_data.substations[i] = substation_dict.get(bus.substation, 0)
 
         bus_data.areas[i] = areas_dict.get(bus.area, 0)
 
@@ -203,11 +220,13 @@ def get_load_data(circuit: MultiCircuit,
 
         # change stuff depending on the modes
         if elm.mode == ExternalGridMode.VD:
-            bus_data.bus_types[i] = BusMode.Slack.value  # set as Slack
+            bus_data.bus_types[i] = BusMode.Slack_tpe.value  # set as Slack
 
         elif elm.mode == ExternalGridMode.PV:
 
             set_bus_control_voltage(i=i,
+                                    j=-1,
+                                    remote_control=False,
                                     bus_name=elm.bus.name,
                                     bus_data=bus_data,
                                     bus_voltage_used=bus_voltage_used,
@@ -318,7 +337,17 @@ def get_shunt_data(circuit: MultiCircuit,
             data.cost[ii] = elm.Cost_prof[t_idx]
 
             if elm.is_controlled and elm.active_prof[t_idx]:
+
+                if elm.control_bus_prof[t_idx] is not None:
+                    remote_control = True
+                    j = bus_dict[elm.control_bus_prof[t_idx]]
+                else:
+                    remote_control = False
+                    j = -1
+
                 set_bus_control_voltage(i=i,
+                                        j=j,
+                                        remote_control=remote_control,
                                         bus_name=elm.bus.name,
                                         bus_data=bus_data,
                                         bus_voltage_used=bus_voltage_used,
@@ -332,7 +361,16 @@ def get_shunt_data(circuit: MultiCircuit,
             data.cost[ii] = elm.Cost
 
             if elm.is_controlled and elm.active:
+                if elm.control_bus is not None:
+                    remote_control = True
+                    j = bus_dict[elm.control_bus]
+                else:
+                    remote_control = False
+                    j = -1
+
                 set_bus_control_voltage(i=i,
+                                        j=j,
+                                        remote_control=remote_control,
                                         bus_name=elm.bus.name,
                                         bus_data=bus_data,
                                         bus_voltage_used=bus_voltage_used,
@@ -428,7 +466,16 @@ def get_generator_data(circuit: MultiCircuit,
                     bus_data.srap_availbale_power[i] += data.p[k]
 
                 if elm.is_controlled:
+                    if elm.control_bus_prof[t_idx] is not None:
+                        remote_control = True
+                        j = bus_dict[elm.control_bus_prof[t_idx]]
+                    else:
+                        remote_control = False
+                        j = -1
+
                     set_bus_control_voltage(i=i,
+                                            j=j,
+                                            remote_control=remote_control,
                                             bus_name=elm.bus.name,
                                             bus_data=bus_data,
                                             bus_voltage_used=bus_voltage_used,
@@ -455,7 +502,16 @@ def get_generator_data(circuit: MultiCircuit,
                 if elm.srap_enabled and data.p[k] > 0.0:
                     bus_data.srap_availbale_power[i] += data.p[k]
 
+                if elm.control_bus is not None:
+                    remote_control = True
+                    j = bus_dict[elm.control_bus]
+                else:
+                    remote_control = False
+                    j = -1
+
                 set_bus_control_voltage(i=i,
+                                        j=j,
+                                        remote_control=remote_control,
                                         bus_name=elm.bus.name,
                                         bus_data=bus_data,
                                         bus_voltage_used=bus_voltage_used,
@@ -563,7 +619,17 @@ def get_battery_data(circuit: MultiCircuit,
                     bus_data.srap_availbale_power[i] += data.p[k]
 
                 if elm.is_controlled:
+
+                    if elm.control_bus_prof[t_idx] is not None:
+                        remote_control = True
+                        j = bus_dict[elm.control_bus_prof[t_idx]]
+                    else:
+                        remote_control = False
+                        j = -1
+
                     set_bus_control_voltage(i=i,
+                                            j=j,
+                                            remote_control=remote_control,
                                             bus_name=elm.bus.name,
                                             bus_data=bus_data,
                                             bus_voltage_used=bus_voltage_used,
@@ -591,7 +657,17 @@ def get_battery_data(circuit: MultiCircuit,
                     bus_data.srap_availbale_power[i] += data.p[k]
 
                 if elm.is_controlled:
+
+                    if elm.control_bus is not None:
+                        remote_control = True
+                        j = bus_dict[elm.control_bus]
+                    else:
+                        remote_control = False
+                        j = -1
+
                     set_bus_control_voltage(i=i,
+                                            j=j,
+                                            remote_control=remote_control,
                                             bus_name=elm.bus.name,
                                             bus_data=bus_data,
                                             bus_voltage_used=bus_voltage_used,
@@ -1209,6 +1285,8 @@ def get_hvdc_data(circuit: MultiCircuit,
             # hack the bus types to believe they are PV
             if elm.active_prof[t_idx]:
                 set_bus_control_voltage(i=f,
+                                        j=-1,
+                                        remote_control=False,
                                         bus_name=elm.bus_from.name,
                                         bus_data=bus_data,
                                         bus_voltage_used=bus_voltage_used,
@@ -1217,6 +1295,8 @@ def get_hvdc_data(circuit: MultiCircuit,
                                         logger=logger)
 
                 set_bus_control_voltage(i=t,
+                                        j=-1,
+                                        remote_control=False,
                                         bus_name=elm.bus_to.name,
                                         bus_data=bus_data,
                                         bus_voltage_used=bus_voltage_used,
@@ -1246,6 +1326,8 @@ def get_hvdc_data(circuit: MultiCircuit,
             # hack the bus types to believe they are PV
             if elm.active:
                 set_bus_control_voltage(i=f,
+                                        j=-1,
+                                        remote_control=False,
                                         bus_name=elm.bus_from.name,
                                         bus_data=bus_data,
                                         bus_voltage_used=bus_voltage_used,
@@ -1254,6 +1336,8 @@ def get_hvdc_data(circuit: MultiCircuit,
                                         logger=logger)
 
                 set_bus_control_voltage(i=t,
+                                        j=-1,
+                                        remote_control=False,
                                         bus_name=elm.bus_to.name,
                                         bus_data=bus_data,
                                         bus_voltage_used=bus_voltage_used,

{GridCalEngine-5.1.19 → GridCalEngine-5.1.21}/GridCalEngine/DataStructures/bus_data.py

@@ -15,7 +15,6 @@
 # along with this program; if not, write to the Free Software Foundation,
 # Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 import numpy as np
-from typing import Tuple
 from GridCalEngine.basic_structures import CxVec, Vec, IntVec, BoolVec, StrVec
 
 

{GridCalEngine-5.1.19 → GridCalEngine-5.1.21}/GridCalEngine/DataStructures/numerical_circuit.py

@@ -163,6 +163,8 @@ class NumericalCircuit:
         'Qmin',
         'Qmax',
         'pq',
+        'pqv',
+        'p',
         'pv',
         'vd',
         'pqpv',
@@ -839,7 +841,7 @@ class NumericalCircuit:
                                     control_mode=self.branch_data.control_mode,
                                     F=self.branch_data.F,
                                     T=self.branch_data.T,
-                                    dc=self.branch_data.dc)
+                                    dc=self.bus_data.is_dc)
 
     def get_connectivity_matrices(self) -> tp.ConnectivityMatrices:
         """
@@ -1098,6 +1100,28 @@ class NumericalCircuit:
 
         return self.simulation_indices_.pv
 
+    @property
+    def pqv(self):
+        """
+
+        :return:
+        """
+        if self.simulation_indices_ is None:
+            self.simulation_indices_ = self.get_simulation_indices()
+
+        return self.simulation_indices_.pqv
+
+    @property
+    def p(self):
+        """
+
+        :return:
+        """
+        if self.simulation_indices_ is None:
+            self.simulation_indices_ = self.get_simulation_indices()
+
+        return self.simulation_indices_.p
+
     @property
     def pqpv(self):
         """
@@ -1436,10 +1460,10 @@ class NumericalCircuit:
                 bus_active=self.bus_data.active
             )
 
-    def get_structure(self, structure_type) -> pd.DataFrame:
+    def get_structure(self, structure_type: str) -> pd.DataFrame:
         """
         Get a DataFrame with the input.
-        :param: structure_type: String representig structure type
+        :param: structure_type: String representing structure type
         :return: pandas DataFrame
         """
 
@@ -1688,6 +1712,20 @@ class NumericalCircuit:
                 index=self.bus_data.names[self.pv],
             )
 
+        elif structure_type == 'pqv':
+            df = pd.DataFrame(
+                data=self.pqv,
+                columns=['pqv'],
+                index=self.bus_data.names[self.pqv],
+            )
+
+        elif structure_type == 'p':
+            df = pd.DataFrame(
+                data=self.p,
+                columns=['p'],
+                index=self.bus_data.names[self.p],
+            )
+
         elif structure_type == 'vd':
             df = pd.DataFrame(
                 data=self.vd,
@@ -1995,7 +2033,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 +2045,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.19 → GridCalEngine-5.1.21}/GridCalEngine/Devices/Branches/line.py

@@ -27,6 +27,7 @@ from GridCalEngine.Devices.Parents.branch_parent import BranchParent
 from GridCalEngine.Devices.Branches.sequence_line_type import SequenceLineType
 from GridCalEngine.Devices.Branches.transformer import Transformer2W
 from GridCalEngine.Devices.profile import Profile
+from GridCalEngine.Devices.Associations.association import Associations
 from GridCalEngine.Devices.Branches.line_locations import LineLocations
 
 
@@ -137,6 +138,11 @@ class Line(BranchParent):
         # type template
         self.template: Union[OverheadLineType, SequenceLineType, UndergroundLineType] = template
 
+        # association with various templates
+        self.possible_tower_types: Associations = Associations(device_type=DeviceType.OverheadLineTypeDevice)
+        self.possible_undergroud_line_types: Associations = Associations(device_type=DeviceType.UnderGroundLineDevice)
+        self.possible_sequence_line_types: Associations = Associations(device_type=DeviceType.SequenceLineDevice)
+
         # Line locations
         self._locations: LineLocations = LineLocations()
 
@@ -173,6 +179,18 @@ class Line(BranchParent):
         self.register(key='template', units='', tpe=DeviceType.SequenceLineDevice, definition='', editable=False)
         self.register(key='locations', units='', tpe=SubObjectType.LineLocations, definition='', editable=False)
 
+        self.register(key='possible_tower_types', units='', tpe=SubObjectType.Associations,
+                      definition='Possible overhead line types (>1 to denote association), - to denote no association',
+                      display=False)
+
+        self.register(key='possible_undergroud_line_types', units='', tpe=SubObjectType.Associations,
+                      definition='Possible underground line types (>1 to denote association), - to denote no association',
+                      display=False)
+
+        self.register(key='possible_sequence_line_types', units='', tpe=SubObjectType.Associations,
+                      definition='Possible sequence line types (>1 to denote association), - to denote no association',
+                      display=False)
+
     @property
     def temp_oper_prof(self) -> Profile:
         """
@@ -353,8 +371,8 @@ class Line(BranchParent):
         """
         R = r_ohm * length
         X = x_ohm * length
-        B = (
-                    2 * np.pi * freq * c_nf * 1e-9) * length  # impedance = 1 / (2 * pi * f * c), susceptance = (2 * pi * f * c)
+        # impedance = 1 / (2 * pi * f * c), susceptance = (2 * pi * f * c)
+        B = (2 * np.pi * freq * c_nf * 1e-9) * length
 
         Vf = self.get_max_bus_nominal_voltage()
 
@@ -367,12 +385,17 @@ class Line(BranchParent):
         self.rate = np.round(Imax * Vf * 1.73205080757, 6)  # nominal power in MVA = kA * kV * sqrt(3)
         self.length = length
 
-    def copyData(self, second_Line):
+    def set_data_from(self, second_Line: "Line"):
+        """
+        Set the data from another line
+        :param second_Line:
+        :return:
+        """
         self.copy()
-        self.busfrom = getattr(second_Line, 'bus_from', None)
-        self.busto = getattr(second_Line, 'bus_to', None)
-        self.cnfrom = getattr(second_Line, 'cn_from', None)
-        self.cnto = getattr(second_Line, 'cn_to', None)
+        self.bus_from = second_Line.bus_from
+        self.bus_to = second_Line.bus_to
+        self.cn_from = second_Line.cn_from
+        self.cn_to = second_Line.cn_to
         self.name = second_Line.name
         self.idtag = second_Line.idtag
         self.code = second_Line.code
@@ -406,16 +429,3 @@ class Line(BranchParent):
         self.capex = second_Line.capex
         self.opex = second_Line.opex
         self.build_status = second_Line.build_status
-
-        # # Fetch all attributes from second_Line dynamically
-        # attributes = [attr for attr in dir(second_Line) if
-        #               not attr.startswith('__') and not callable(getattr(second_Line, attr))]
-        #
-        # # Using getattr to fetch each attribute, defaulting to None if not found
-        # for attr in attributes:
-        #     if not attr == 'locations':
-        #         try:
-        #             # Try setting the attribute, if it is writable
-        #             setattr(self, attr, getattr(second_Line, attr, None))
-        #         except AttributeError as e:
-        #             print(f"Cannot set protected attribute {attr}: {str(e)}")

{GridCalEngine-5.1.19 → GridCalEngine-5.1.21}/GridCalEngine/Devices/Branches/line_locations.py

@@ -108,6 +108,9 @@ class LineLocations(EditableDevice):
         """
         self.data.append(LineLocation(lat=latitude, lon=longitude, z=altitude, seq=sequence, idtag=idtag))
 
+    def remove(self, loc: LineLocation):
+        self.data.remove(loc)
+
     def parse(self, data: List[Union[Tuple[int, float, float, float], Tuple[int, float, float, float, str]]]):
         """
         Parse Json data

{GridCalEngine-5.1.19 → GridCalEngine-5.1.21}/GridCalEngine/Devices/Branches/transformer.py

@@ -21,8 +21,9 @@ from typing import Tuple, Union
 from GridCalEngine.basic_structures import Logger
 from GridCalEngine.Devices.Substation.bus import Bus
 from GridCalEngine.Devices.Substation.connectivity_node import ConnectivityNode
+from GridCalEngine.Devices.Associations.association import Associations
 from GridCalEngine.enumerations import (TransformerControlType, WindingsConnection, BuildStatus,
-                                        TapAngleControl, TapModuleControl, TapChangerTypes)
+                                        TapAngleControl, TapModuleControl, TapChangerTypes, SubObjectType)
 from GridCalEngine.Devices.Parents.controllable_branch_parent import ControllableBranchParent
 from GridCalEngine.Devices.Branches.transformer_type import TransformerType, reverse_transformer_short_circuit_study
 from GridCalEngine.Devices.Parents.editable_device import DeviceType
@@ -66,7 +67,7 @@ class Transformer2W(ControllableBranchParent):
                  temp_base: float = 20.0,
                  temp_oper: float = 20.0,
                  alpha: float = 0.00330,
-                 control_mode: TransformerControlType = TransformerControlType.fixed,
+                 control_mode: TransformerControlType = TransformerControlType.fixed,    # legacy?
                  tap_module_control_mode: TapModuleControl = TapModuleControl.fixed,
                  tap_angle_control_mode: TapAngleControl = TapAngleControl.fixed,
                  template: TransformerType = None,
@@ -225,6 +226,9 @@ class Transformer2W(ControllableBranchParent):
         # type template
         self.template = template
 
+        # association with transformer templates
+        self.possible_transformer_types: Associations = Associations(device_type=DeviceType.TransformerTypeDevice)
+
         # register
         self.register(key='HV', units='kV', tpe=float, definition='High voltage rating')
         self.register(key='LV', units='kV', tpe=float, definition='Low voltage rating')
@@ -239,6 +243,10 @@ class Transformer2W(ControllableBranchParent):
 
         self.register(key='template', units='', tpe=DeviceType.TransformerTypeDevice, definition='', editable=False)
 
+        self.register(key='possible_transformer_types', units='', tpe=SubObjectType.Associations,
+                      definition='Possible transformer types (>1 to denote association), - to denote no association',
+                      display=False)
+
     def set_hv_and_lv(self, HV: float, LV: float):
         """
         set the high and low voltage values
@@ -404,17 +412,18 @@ class Transformer2W(ControllableBranchParent):
         for property_name, properties in self.registered_properties.items():
             obj = getattr(self, property_name)
 
-            if properties.tpe == DeviceType.BusDevice:
-                obj = obj.idtag
-
-            elif properties.tpe == DeviceType.TransformerTypeDevice:
-                if obj is None:
-                    obj = ''
-                else:
+            if obj is not None:
+                if properties.tpe == DeviceType.BusDevice:
                     obj = obj.idtag
 
-            elif properties.tpe not in [str, float, int, bool]:
-                obj = str(obj)
+                elif properties.tpe == DeviceType.TransformerTypeDevice:
+                    if obj is None:
+                        obj = ''
+                    else:
+                        obj = obj.idtag
+
+                elif properties.tpe not in [str, float, int, bool]:
+                    obj = str(obj)
 
             data.append(obj)
         return data

{GridCalEngine-5.1.19 → GridCalEngine-5.1.21}/GridCalEngine/Devices/Branches/transformer3w.py

@@ -43,7 +43,9 @@ def delta_to_star(z12: float, z23: float, z31: float) -> Tuple[float, float, flo
 
 class Transformer3W(EditableDevice):
 
-    def __init__(self, idtag=None, code='', name='Branch',
+    def __init__(self, idtag: Union[str, None] = None,
+                 code: str = '',
+                 name: str = 'Branch',
                  bus0: Union[None, Bus] = None,
                  bus1: Bus = None, bus2: Bus = None, bus3: Bus = None,
                  V1=10.0, V2=10.0, V3=10.0, active=True,

{GridCalEngine-5.1.19 → GridCalEngine-5.1.21}/GridCalEngine/Devices/Branches/wire.py

@@ -24,7 +24,7 @@ class Wire(EditableDevice):
     This class represents a wire (an actual wire)
     to compose towers
     """
-    def __init__(self, name='', idtag: Union[str, None] = None, gmr=0.01, r=0.01, x=0.0, max_current=1):
+    def __init__(self, name='', idtag: Union[str, None] = None, gmr=0.01, r=0.01, x=0.0, max_current=1, stranding=0.0, material=0.0, diameter=0.0):
         """
         Wire definition
         :param name: Name of the wire type
@@ -42,6 +42,9 @@ class Wire(EditableDevice):
                                 device_type=DeviceType.WireDevice)
 
         # self.wire_name = name
+        self.stranding = stranding
+        self.material = material
+        self.diameter = diameter
         self.r = r
         self.x = x
         self.gmr = gmr
@@ -51,6 +54,9 @@ class Wire(EditableDevice):
         self.register(key='x', units='Ohm/km', tpe=float, definition='reactance of the conductor')
         self.register(key='gmr', units='m', tpe=float, definition='Geometric Mean Radius of the conductor')
         self.register(key='max_current', units='kA', tpe=float, definition='Maximum current of the conductor')
+        self.register(key='stranding', tpe=float, definition='Stranding of wire')
+        self.register(key='material', tpe=float, definition='Material of wire')
+        self.register(key='diameter', units='cm', tpe=float, definition='Diameter of wire')
 
     def copy(self):
         """
@@ -58,4 +64,4 @@ class Wire(EditableDevice):
         :return:
         """
         # name='', idtag=None, gmr=0.01, r=0.01, x=0.0, max_current=1
-        return Wire(name=self.name, gmr=self.gmr, r=self.r, x=self.x, max_current=self.max_current)
+        return Wire(name=self.name, gmr=self.gmr, r=self.r, x=self.x, max_current=self.max_current, stranding=self.stranding, material=self.material, diameter=self.diameter)