GridCalEngine 5.1.50__tar.gz → 5.1.52__tar.gz

{GridCalEngine-5.1.50 → GridCalEngine-5.1.52}/GridCalEngine/Compilers/circuit_to_data.py

@@ -16,6 +16,7 @@
 # Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 from __future__ import annotations
 from typing import Dict, Union, TYPE_CHECKING, Tuple
+
 from GridCalEngine.basic_structures import Logger
 import GridCalEngine.Devices as dev
 from GridCalEngine.Devices.Substation.bus import Bus
@@ -29,6 +30,17 @@ import GridCalEngine.DataStructures as ds
 
 if TYPE_CHECKING:  # Only imports the below statements during type checking
     from GridCalEngine.Simulations.OPF.opf_results import OptimalPowerFlowResults
+    from GridCalEngine.Simulations.OPF.opf_ts_results import OptimalPowerFlowTimeSeriesResults
+    from GridCalEngine.Simulations.NTC.ntc_results import OptimalNetTransferCapacityResults
+    from GridCalEngine.Simulations.NTC.ntc_ts_results import OptimalNetTransferCapacityTimeSeriesResults
+    from GridCalEngine.Simulations import OptimalNetTransferCapacityResults
+
+    VALID_OPF_RESULTS = Union[
+        OptimalPowerFlowResults,
+        OptimalPowerFlowTimeSeriesResults,
+        OptimalNetTransferCapacityResults,
+        OptimalNetTransferCapacityTimeSeriesResults
+    ]
 
 
 def set_bus_control_voltage(i: int,
@@ -430,7 +442,7 @@ def get_generator_data(
         bus_voltage_used: BoolVec,
         logger: Logger,
         bus_data: ds.BusData,
-        opf_results: Union[OptimalPowerFlowResults, None] = None,
+        opf_results: VALID_OPF_RESULTS | None = None,
         t_idx=-1,
         time_series=False,
         use_stored_guess=False,
@@ -452,8 +464,7 @@ def get_generator_data(
     """
     devices = circuit.get_generators()
 
-    data = ds.GeneratorData(nelm=len(devices),
-                            nbus=circuit.get_bus_number())
+    data = ds.GeneratorData(nelm=len(devices), nbus=circuit.get_bus_number())
 
     gen_index_dict: Dict[str, int] = dict()
     for k, elm in enumerate(devices):
@@ -591,7 +602,7 @@ def get_battery_data(
         bus_voltage_used: BoolVec,
         logger: Logger,
         bus_data: ds.BusData,
-        opf_results: Union[OptimalPowerFlowResults, None] = None,
+        opf_results: VALID_OPF_RESULTS | None = None,
         t_idx=-1,
         time_series=False,
         use_stored_guess=False,
@@ -844,7 +855,7 @@ def fill_controllable_branch(
         branch_tolerance_mode: BranchImpedanceMode,
         t_idx: int,
         time_series: bool,
-        opf_results: Union[OptimalPowerFlowResults, None],
+        opf_results: VALID_OPF_RESULTS | None,
         use_stored_guess: bool,
         bus_voltage_used: BoolVec,
         Sbase: float,
@@ -977,7 +988,7 @@ def get_branch_data(
         branch_tolerance_mode: BranchImpedanceMode,
         t_idx: int = -1,
         time_series: bool = False,
-        opf_results: Union[OptimalPowerFlowResults, None] = None,
+        opf_results: VALID_OPF_RESULTS | None = None,
         use_stored_guess: bool = False,
         control_taps_modules: bool = True,
         control_taps_phase: bool = True,
@@ -1200,7 +1211,7 @@ def get_hvdc_data(circuit: MultiCircuit,
                   bus_voltage_used: BoolVec,
                   t_idx=-1,
                   time_series=False,
-                  opf_results: Union[OptimalPowerFlowResults, None] = None,
+                  opf_results: Union[OptimalPowerFlowResults, OptimalNetTransferCapacityResults, None] = None,
                   use_stored_guess: bool = False,
                   logger: Logger = Logger()):
     """

{GridCalEngine-5.1.50 → GridCalEngine-5.1.52}/GridCalEngine/Compilers/circuit_to_newton_pa.py

@@ -766,10 +766,10 @@ def add_transformer3w_data(circuit: MultiCircuit,
                                 V3=elm.V3,
                                 r12=elm.r12, r23=elm.r23, r31=elm.r31,
                                 x12=elm.x12, x23=elm.x23, x31=elm.x31,
-                                rate12=elm.rate12, rate23=elm.rate23, rate31=elm.rate31,
-                                contingency_rate12=elm.rate12,
-                                contingency_rate23=elm.rate23,
-                                contingency_rate31=elm.rate31, )
+                                rate12=elm.rate1, rate23=elm.rate2, rate31=elm.rate3,
+                                contingency_rate12=elm.rate1,
+                                contingency_rate23=elm.rate2,
+                                contingency_rate31=elm.rate3, )
 
         # this is because the central node is in the buses list already from GridCal
         tr3.central_node = bus_dict[elm.bus0.idtag]
@@ -1199,11 +1199,9 @@ def get_newton_pa_nonlinear_opf_options(pf_opt: PowerFlowOptions,
     q_control_dict = {False: npa.ReactivePowerControlMode.NoControl,
                       True: npa.ReactivePowerControlMode.Direct}
 
-    solver_dict = {MIPSolvers.CBC: npa.LpSolvers.Highs,
-                   MIPSolvers.HIGHS: npa.LpSolvers.Highs,
+    solver_dict = {MIPSolvers.HIGHS: npa.LpSolvers.Highs,
                    MIPSolvers.XPRESS: npa.LpSolvers.Xpress,
                    MIPSolvers.CPLEX: npa.LpSolvers.CPLEX,
-                   MIPSolvers.GLOP: npa.LpSolvers.Highs,
                    MIPSolvers.SCIP: npa.LpSolvers.Highs,
                    MIPSolvers.GUROBI: npa.LpSolvers.Gurobi}
 
@@ -1230,11 +1228,9 @@ def get_newton_pa_linear_opf_options(opf_opt: OptimalPowerFlowOptions,
     :param area_dict:
     :return:
     """
-    solver_dict = {MIPSolvers.CBC: npa.LpSolvers.Highs,
-                   MIPSolvers.HIGHS: npa.LpSolvers.Highs,
+    solver_dict = {MIPSolvers.HIGHS: npa.LpSolvers.Highs,
                    MIPSolvers.XPRESS: npa.LpSolvers.Xpress,
                    MIPSolvers.CPLEX: npa.LpSolvers.CPLEX,
-                   MIPSolvers.GLOP: npa.LpSolvers.Highs,
                    MIPSolvers.SCIP: npa.LpSolvers.Scip,
                    MIPSolvers.GUROBI: npa.LpSolvers.Gurobi}
 

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

@@ -21,7 +21,7 @@ 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 typing import List, Tuple, Dict
+from typing import List, Tuple, Dict, Set
 
 
 class BranchData:
@@ -372,7 +372,7 @@ class BranchData:
         """
         return np.where(self.contingency_enabled == 1)[0]
 
-    def get_inter_areas(self, bus_idx_from, bus_idx_to):
+    def get_inter_areas(self, bus_idx_from: IntVec | Set[int], bus_idx_to: IntVec | Set[int]):
         """
         Get the Branches that join two areas
         :param bus_idx_from: Area from

{GridCalEngine-5.1.50 → GridCalEngine-5.1.52}/GridCalEngine/DataStructures/hvdc_data.py

@@ -15,7 +15,7 @@
 # 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 List, Tuple
+from typing import List, Tuple, Set
 import scipy.sparse as sp
 import GridCalEngine.Topology.topology as tp
 from GridCalEngine.enumerations import HvdcControlType
@@ -242,8 +242,25 @@ class HvdcData:
         :param Sbase: base power
         :return:
         """
+        # convert MW/deg to pu/rad
+        # MW    180 deg    1
+        # --- x ------- x ------ = 360 * 180 / pi / 100 = 206.26 aprox
+        # deg   pi rad    100 MVA
         return self.angle_droop * 57.295779513 / Sbase
 
+    def get_angle_droop_in_pu_rad_at(self, i: int, Sbase: float):
+        """
+        Get the angle droop in pu/rad
+        :param i: index
+        :param Sbase: base power
+        :return:
+        """
+        # convert MW/deg to pu/rad
+        # MW    180 deg    1
+        # --- x ------- x ------ = 360 * 180 / pi / 100 = 206.26 aprox
+        # deg   pi rad    100 MVA
+        return self.angle_droop[i] * 57.295779513 / Sbase
+
     def get_power(self, Sbase: float, theta: Vec) -> Tuple[Vec, Vec, Vec, Vec, Vec, int]:
         """
         Get hvdc power
@@ -310,7 +327,7 @@ class HvdcData:
         # Shvdc, Losses_hvdc, Pf_hvdc, Pt_hvdc, loading_hvdc, n_free
         return Pbus, Losses, Pf, Pt, loading, nfree
 
-    def get_inter_areas(self, bus_idx_from, bus_idx_to):
+    def get_inter_areas(self, bus_idx_from: IntVec | Set[int], bus_idx_to: IntVec | Set[int]):
         """
         Get the hvdcs that join two areas
         :param bus_idx_from: Area from

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

@@ -20,6 +20,7 @@ import pandas as pd
 import scipy.sparse as sp
 from typing import List, Tuple, Dict, Union, TYPE_CHECKING
 
+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
@@ -477,68 +478,78 @@ class NumericalCircuit:
             else:
                 raise Exception('Could not find the idtag, is this a programming bug?')
 
-    def set_contingency_status(self, contingencies_list: List[Contingency], revert: bool = False):
+    def set_con_or_ra_status(self, event_list: List[Contingency | RemedialAction],
+                             revert: bool = False):
         """
         Set the status of a list of contingencies
-        :param contingencies_list: list of contingencies
+        :param event_list: list of contingencies and or remedial actions
         :param revert: if false, the contingencies are applied, else they are reversed
         """
         # apply the contingencies
-        for cnt in contingencies_list:
-
-            # search the investment device
-            structure, idx = self.structs_dict.get(cnt.device_idtag, (None, 0))
-
-            if structure is not None:
-                if cnt.prop == 'active':
-                    if revert:
-                        structure.active[idx] = int(not bool(cnt.value))
-                    else:
-                        structure.active[idx] = int(cnt.value)
-                elif cnt.prop == '%':
-                    if revert:
-                        structure.p[idx] /= float(cnt.value / 100.0)
+        for cnt in event_list:
+
+            if isinstance(cnt, (Contingency, RemedialAction)):
+
+                # search the investment device
+                structure, idx = self.structs_dict.get(cnt.device_idtag, (None, 0))
+
+                if structure is not None:
+                    if cnt.prop == 'active':
+                        if revert:
+                            structure.active[idx] = int(not bool(cnt.value))
+                        else:
+                            structure.active[idx] = int(cnt.value)
+                    elif cnt.prop == '%':
+                        if revert:
+                            structure.p[idx] /= float(cnt.value / 100.0)
+                        else:
+                            structure.p[idx] *= float(cnt.value / 100.0)
                     else:
-                        structure.p[idx] *= float(cnt.value / 100.0)
+                        print(f'Unknown contingency property {cnt.prop} at {cnt.name} {cnt.idtag}')
                 else:
-                    print(f'Unknown contingency property {cnt.prop} at {cnt.name} {cnt.idtag}')
+                    print(f'contingency device not found {cnt.name} {cnt.idtag}')
             else:
-                print(f'contingency device not found {cnt.name} {cnt.idtag}')
+                raise Exception(f"The object {cnt} is not a Contingency or a remedial action")
 
-    def set_linear_contingency_status(self, contingencies_list: List[Contingency], revert: bool = False):
+    def set_linear_con_or_ra_status(self, event_list: List[Contingency | RemedialAction],
+                                    revert: bool = False):
         """
         Set the status of a list of contingencies
-        :param contingencies_list: list of contingencies
+        :param event_list: list of contingencies and or remedial actions
         :param revert: if false, the contingencies are applied, else they are reversed
         """
         injections = np.zeros(self.nbus)
         # apply the contingencies
-        for cnt in contingencies_list:
-
-            # search the investment device
-            structure, idx = self.structs_dict.get(cnt.device_idtag, (None, 0))
-
-            if structure is not None:
-                if cnt.prop == 'active':
-                    if revert:
-                        structure.active[idx] = int(not bool(cnt.value))
-                    else:
-                        structure.active[idx] = int(cnt.value)
-                elif cnt.prop == '%':
-                    # 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())
-                    dev_injections[idx] -= structure.p[idx]
-                    if revert:
-                        structure.p[idx] /= float(cnt.value / 100.0)
+        for cnt in event_list:
+
+            if isinstance(cnt, (Contingency, RemedialAction)):
+
+                # search the investment device
+                structure, idx = self.structs_dict.get(cnt.device_idtag, (None, 0))
+
+                if structure is not None:
+                    if cnt.prop == 'active':
+                        if revert:
+                            structure.active[idx] = int(not bool(cnt.value))
+                        else:
+                            structure.active[idx] = int(cnt.value)
+                    elif cnt.prop == '%':
+                        # 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())
+                        dev_injections[idx] -= structure.p[idx]
+                        if revert:
+                            structure.p[idx] /= float(cnt.value / 100.0)
+                        else:
+                            structure.p[idx] *= float(cnt.value / 100.0)
+                        dev_injections[idx] += structure.p[idx]
+                        injections += structure.get_array_per_bus(dev_injections)
                     else:
-                        structure.p[idx] *= float(cnt.value / 100.0)
-                    dev_injections[idx] += structure.p[idx]
-                    injections += structure.get_array_per_bus(dev_injections)
+                        print(f'Unknown contingency property {cnt.prop} at {cnt.name} {cnt.idtag}')
                 else:
-                    print(f'Unknown contingency property {cnt.prop} at {cnt.name} {cnt.idtag}')
+                    print(f'contingency device not found {cnt.name} {cnt.idtag}')
             else:
-                print(f'contingency device not found {cnt.name} {cnt.idtag}')
+                raise Exception(f"The object {cnt} is not a Contingency or a remedial action")
 
         return injections
 
@@ -2018,20 +2029,20 @@ class NumericalCircuit:
         # if any error in the logger, bad
         return logger.error_count() == 0, logger
 
-    def get_structural_ntc(self, bus_idx_from: IntVec, bus_idx_to: IntVec) -> float:
+    def get_structural_ntc(self, bus_a1_idx: IntVec, bus_a2_idx: IntVec) -> float:
         """
         Get the structural NTC
-        :param bus_idx_from: list of buses of the area from
-        :param bus_idx_to: list of buses of the area to
+        :param bus_a1_idx: list of buses of the area from
+        :param bus_a2_idx: list of buses of the area to
         :return: structural NTC in MVA
         """
 
-        inter_area_branches = self.branch_data.get_inter_areas(bus_idx_from=bus_idx_from, bus_idx_to=bus_idx_to)
+        inter_area_branches = self.branch_data.get_inter_areas(bus_idx_from=bus_a1_idx, bus_idx_to=bus_a2_idx)
         sum_ratings = 0.0
         for k, sense in inter_area_branches:
             sum_ratings += self.branch_data.rates[k]
 
-        inter_area_hvdcs = self.hvdc_data.get_inter_areas(bus_idx_from=bus_idx_from, bus_idx_to=bus_idx_to)
+        inter_area_hvdcs = self.hvdc_data.get_inter_areas(bus_idx_from=bus_a1_idx, bus_idx_to=bus_a2_idx)
         for k, sense in inter_area_hvdcs:
             sum_ratings += self.hvdc_data.rate[k]
 
@@ -2042,7 +2053,7 @@ def compile_numerical_circuit_at(circuit: MultiCircuit,
                                  t_idx: Union[int, None] = None,
                                  apply_temperature=False,
                                  branch_tolerance_mode=BranchImpedanceMode.Specified,
-                                 opf_results: Union[OptimalPowerFlowResults, None] = None,
+                                 opf_results: gc_compiler2.VALID_OPF_RESULTS | None = None,
                                  use_stored_guess=False,
                                  bus_dict: Union[Dict[Bus, int], None] = None,
                                  areas_dict: Union[Dict[Area, int], None] = None,

{GridCalEngine-5.1.50 → GridCalEngine-5.1.52}/GridCalEngine/Devices/Aggregation/__init__.py

@@ -17,6 +17,8 @@
 
 from GridCalEngine.Devices.Aggregation.contingency import Contingency
 from GridCalEngine.Devices.Aggregation.contingency_group import ContingencyGroup
+from GridCalEngine.Devices.Aggregation.remedial_action import RemedialAction
+from GridCalEngine.Devices.Aggregation.remedial_action_group import RemedialActionGroup
 from GridCalEngine.Devices.Aggregation.investment import Investment
 from GridCalEngine.Devices.Aggregation.investments_group import InvestmentsGroup
 from GridCalEngine.Devices.Aggregation.area import Area
@@ -28,3 +30,4 @@ from GridCalEngine.Devices.Aggregation.municipality import Municipality
 from GridCalEngine.Devices.Aggregation.branch_group import BranchGroup
 from GridCalEngine.Devices.Aggregation.modelling_authority import ModellingAuthority
 from GridCalEngine.Devices.Aggregation.inter_aggregation_info import InterAggregationInfo
+from GridCalEngine.Devices.Aggregation.facility import Facility

GridCalEngine-5.1.52/GridCalEngine/Devices/Aggregation/facility.py

@@ -0,0 +1,47 @@
+# GridCal
+# Copyright (C) 2015 - 2024 Santiago Peñate Vera
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 3 of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# 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 typing import Union
+from GridCalEngine.Devices.Parents.editable_device import EditableDevice, DeviceType
+
+
+class Facility(EditableDevice):
+    """
+    This is an aggregation of Injection devices
+    """
+
+    def __init__(self, name='', code='', idtag: Union[str, None] = None, latitude=0.0, longitude=0.0):
+        """
+        Constructor
+        :param name: Name
+        :param code: Secondary code
+        :param idtag: IdTag
+        :param latitude: latitude (deg)
+        :param longitude: longitude (deg)
+        """
+        EditableDevice.__init__(self,
+                                name=name,
+                                code=code,
+                                idtag=idtag,
+                                device_type=DeviceType.FacilityDevice)
+
+        self.latitude = float(latitude)
+        self.longitude = float(longitude)
+
+        self.register(key='longitude', units='deg', tpe=float, definition='longitude.')
+        self.register(key='latitude', units='deg', tpe=float, definition='latitude.')

GridCalEngine-5.1.52/GridCalEngine/Devices/Aggregation/remedial_action.py

@@ -0,0 +1,123 @@
+# GridCal
+# Copyright (C) 2015 - 2024 Santiago Peñate Vera
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 3 of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# 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 typing import Union
+from GridCalEngine.Devices.Parents.editable_device import EditableDevice, DeviceType
+from GridCalEngine.Devices.Aggregation.remedial_action_group import RemedialActionGroup
+
+
+class RemedialAction(EditableDevice):
+    """
+    The RemedialAction object
+    """
+
+    def __init__(self,
+                 idtag: Union[str, None] = None,
+                 device_idtag='',
+                 name="Remedial action",
+                 code='',
+                 prop='active',
+                 value=0.0,
+                 group: Union[None, RemedialActionGroup] = None):
+        """
+        RemedialAction
+        :param idtag: String. Element unique identifier
+        :param name: String. Contingency name
+        :param code: String. Contingency code name
+        :param prop: String. Property to modify when contingency is triggered out
+        :param value: Float. Property value to apply when contingency happens
+        :param group: RemedialActionGroup. RemedialAction group
+        """
+
+        EditableDevice.__init__(self,
+                                idtag=idtag,
+                                code=code,
+                                name=name,
+                                device_type=DeviceType.RemedialActionDevice)
+
+        # Contingency type
+        self.device_idtag = device_idtag
+        self._prop = 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='value', units='', tpe=float, definition='Property value')
+        self.register(key='group', units='', tpe=DeviceType.RemedialActionGroupDevice,
+                      definition='Remedial action group')
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+    @name.setter
+    def name(self, val: str):
+        self._name = val
+
+    @property
+    def prop(self) -> str:
+        """
+        Property to modify when contingency is triggered out
+        :return:
+        """
+        return self._prop
+
+    @prop.setter
+    def prop(self, val: str):
+        if val in self._allowed_properties:
+            self._prop = val
+        else:
+            print(f"Not allowed property {val}, allowed: " + "".join(self._allowed_properties))
+
+    @property
+    def value(self) -> float:
+        """
+        Property value to apply when contingency happens
+        :return:
+        """
+        return self._value
+
+    @value.setter
+    def value(self, val: float):
+        self._value = val
+
+    @property
+    def group(self) -> RemedialActionGroup:
+        """
+        Contingency group
+        :return:
+        """
+        return self._group
+
+    @group.setter
+    def group(self, val: RemedialActionGroup):
+        self._group = val
+
+    @property
+    def category(self):
+        """
+
+        :return:
+        """
+        return self.group.category
+
+    @category.setter
+    def category(self, val):
+        # self.group.category = val
+        pass

GridCalEngine-5.1.52/GridCalEngine/Devices/Aggregation/remedial_action_group.py

@@ -0,0 +1,66 @@
+# GridCal
+# Copyright (C) 2015 - 2024 Santiago Peñate Vera
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 3 of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# 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
+
+from typing import Union
+from GridCalEngine.Devices.Parents.editable_device import EditableDevice, DeviceType
+from GridCalEngine.Devices.Aggregation.contingency_group import ContingencyGroup
+
+
+class RemedialActionGroup(EditableDevice):
+    """
+    The RemedialAction group
+    """
+
+    def __init__(self,
+                 idtag: Union[str, None] = None,
+                 name="RemedialActionGroup",
+                 category='',
+                 conn_group: ContingencyGroup | None = None,):
+        """
+        RemedialAction group
+        :param idtag: Unique identifier
+        :param name: contingency group name
+        :param category: tag to category the group
+        """
+
+        EditableDevice.__init__(self,
+                                name=name,
+                                idtag=idtag,
+                                code='',
+                                device_type=DeviceType.RemedialActionGroupDevice)
+
+        # Contingency type
+        self.category = category
+
+        self._conn_group: ContingencyGroup = conn_group
+
+        self.register(key='category', units='', tpe=str, definition='Some tag to category the contingency group')
+
+        self.register(key='conn_group', units='', tpe=DeviceType.ContingencyGroupDevice, definition='Contingency group')
+
+    @property
+    def conn_group(self) -> ContingencyGroup:
+        """
+        Contingency group
+        :return:
+        """
+        return self._conn_group
+
+    @conn_group.setter
+    def conn_group(self, val: ContingencyGroup):
+        self._conn_group = val

{GridCalEngine-5.1.50 → GridCalEngine-5.1.52}/GridCalEngine/Devices/Branches/dc_line.py

@@ -109,7 +109,7 @@ class DcLine(BranchParent):
         self.measurements = list()
 
         # line length in km
-        self.length = float(length)
+        self._length = float(length)
 
         # line impedance tolerance
         self.tolerance = float(tolerance)
@@ -190,13 +190,45 @@ class DcLine(BranchParent):
         """
         return self.R * (1 + self.alpha * (self.temp_oper - self.temp_base))
 
+    @property
+    def length(self) -> float:
+        """
+        Line length in km
+        :return: float
+        """
+        return self._length
+
+    @length.setter
+    def length(self, val: float):
+        if isinstance(val, float):
+            if val > 0.0:
+
+                if self._length != 0:
+                    factor = np.round(val / self._length, 6)  # new length / old length
+
+                    self.R *= factor
+
+                self._length = val
+            else:
+                print('The length cannot be zero, ignoring value')
+        else:
+            raise Exception('The length must be a float value')
+
     def change_base(self, Sbase_old, Sbase_new):
+        """
 
+        :param Sbase_old:
+        :param Sbase_new:
+        """
         b = Sbase_new / Sbase_old
 
         self.R *= b
 
     def get_weight(self):
+        """
+
+        :return:
+        """
         return self.R
 
     def copy(self, bus_dict=None):