VeraGridEngine 6.7.3__tar.gz → 6.7.5__tar.gz

{veragridengine-6.7.3 → veragridengine-6.7.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: VeraGridEngine
-Version: 6.7.3
+Version: 6.7.5
 Summary: VeraGrid is a Power Systems simulation program intended for professional use and research
 Home-page: https://github.com/SanPen/VeraGrid
 Author: Santiago Peñate Vera et. Al.

veragridengine-6.7.5/VeraGridEngine/Devices/Branches/dc_cable_type.py

@@ -0,0 +1,26 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+# SPDX-License-Identifier: MPL-2.0
+"""Compatibility constructor for the former DC cable catalogue."""
+import numpy as np
+from VeraGridEngine.Devices.Branches.underground_line_type import UndergroundLineType
+
+
+class DcCableType(UndergroundLineType):
+    """Deprecated constructor; the resulting device is a common Cable System.
+
+    Constructor L and C retain the old H/km and F/km units. Once constructed,
+    properties follow Cable System units (X in ohm/km, C in microfarad/km).
+    Use get_dc_parameters()/get_dc_values() for DC quantities. There is no
+    separate device type, catalogue or persisted DC record.
+    """
+    __slots__ = ()
+
+    def __init__(self, name: str = 'Cable System', idtag: str | None = None,
+                 Vnom: float = 1.0, Imax: float = 1.0, R: float = 0.0,
+                 L: float = 0.0, C: float = 0.0):
+        omega = 2.0 * np.pi * 50.0
+        super().__init__(name=name, idtag=idtag, Vnom=Vnom, Imax=Imax,
+                         R=R, X=omega * L, C=C * 1.0e6,
+                         B=omega * C * 1.0e6, freq=50.0)

{veragridengine-6.7.3 → veragridengine-6.7.5}/VeraGridEngine/Devices/Branches/dc_line.py

@@ -8,7 +8,7 @@ from typing import Dict, Union, Tuple
 import numpy as np
 from VeraGridEngine.basic_structures import Logger
 from VeraGridEngine.Devices.Substation.bus import Bus
-from VeraGridEngine.Devices.Branches.dc_cable_type import DcCableType
+from VeraGridEngine.Devices.Branches.underground_line_type import UndergroundLineType
 from VeraGridEngine.Devices.Parents.branch_parent import BranchParent
 from VeraGridEngine.Devices.Profiles import ProfileFloat
 from VeraGridEngine.enumerations import DeviceType, BuildStatus, SubObjectType, PrpCat, ParamPowerFlowReferenceType
@@ -25,10 +25,14 @@ class DcLine(BranchParent):
         '_fault_pos',
         '_R',
         'template',
+        'dc_conductor',
         '_locations',
     )
 
     LOCAL_PROPERTY_DECLARATIONS: Tuple[GCProp, ...] = (
+        GCProp(prop_name='dc_conductor', units='', tpe=int,
+               definition='Global conductor number in the Cable System (one-based).',
+               cat=[PrpCat.TP]),
         GCProp(
             prop_name='R',
             units='p.u.',
@@ -63,8 +67,8 @@ class DcLine(BranchParent):
         GCProp(
             prop_name='template',
             units='',
-            tpe=DeviceType.DcCableTypeDevice,
-            definition='Physical DC cable type applied to this line.',
+            tpe=DeviceType.UnderGroundLineDevice,
+            definition='Cable System applied to this DC line.',
             editable=False,
             cat=[PrpCat.TP],
         ),
@@ -98,14 +102,15 @@ class DcLine(BranchParent):
                  temp_base=20,
                  temp_oper=20,
                  alpha=0.00330,
-                 template: DcCableType | None = None,
+                 template: UndergroundLineType | None = None,
                  contingency_factor=1.0,
                  protection_rating_factor: float = 1.4,
                  contingency_enabled=True,
                  monitor_loading=True,
                  capex=0,
                  opex=0,
-                 build_status: BuildStatus = BuildStatus.Commissioned):
+                 build_status: BuildStatus = BuildStatus.Commissioned,
+                 dc_conductor: int = 1):
         """
         DC current line
         :param bus_from: Bus from
@@ -127,7 +132,8 @@ class DcLine(BranchParent):
         :param temp_base: base temperature (i.e 25º °C)
         :param temp_oper: Operational temperature (°C)
         :param alpha: Thermal constant of the material (°C)
-        :param template: Basic branch template
+        :param template: Cable System supplying the DC equivalent
+        :param dc_conductor: One-based global conductor number in the Cable System
         :param contingency_factor: Rating factor in case of contingency
         :param contingency_enabled: enabled for contingencies (Legacy)
         :param monitor_loading: monitor the loading (used in OPF)
@@ -178,7 +184,8 @@ class DcLine(BranchParent):
         self.R = float(r) if r is not None else 0.0001
 
         # type template
-        self.template: DcCableType | None = template
+        self.template: UndergroundLineType | None = template
+        self.dc_conductor = int(dc_conductor)
 
         # Line locations
         self._locations: LineLocations = LineLocations()
@@ -243,7 +250,7 @@ class DcLine(BranchParent):
         if isinstance(val, float):
             if val > 0.0:
 
-                if self._length != 0:
+                if self._length != 0 and self.auto_update_enabled:
                     factor = np.round(val / self._length, 6)  # new length / old length
 
                     self.R *= factor
@@ -273,19 +280,19 @@ class DcLine(BranchParent):
         return self.R
 
     def apply_template(self,
-                       obj: DcCableType,
+                       obj: UndergroundLineType,
                        Sbase: float,
                        logger: Logger | None = None) -> None:
         """
-        Apply one physical DC cable type to this line atomically.
+        Apply one Cable System to this line atomically.
 
         The resistance copied to ``DcLine`` is the static per-unit value used
         by network compilation. Inductance and capacitance remain canonical in
-        ``DcCableType`` and are converted on demand by the dynamic consumers.
+        ``UndergroundLineType`` and are converted on demand by the dynamic consumers.
         The branch rating is intentionally preserved until the public DC pole
         voltage convention is defined.
 
-        :param obj: DC cable type to apply.
+        :param obj: Cable System to apply.
         :param Sbase: System power base in MVA.
         :param logger: Optional logger receiving validation failures.
         :return: None.
@@ -296,38 +303,25 @@ class DcLine(BranchParent):
             calculation_logger = logger
 
         line_voltage: float = self.get_max_bus_nominal_voltage()
-        valid_type: bool = isinstance(obj, DcCableType)
-        valid_bases: bool = Sbase > 0.0 and line_voltage > 0.0 and self.length > 0.0
-        valid_parameters: bool = (
-            valid_type
-            and obj.Vnom > 0.0
-            and obj.Imax >= 0.0
-            and obj.R >= 0.0
-            and obj.L >= 0.0
-            and obj.C >= 0.0
-        )
-
-        if valid_type and valid_bases and valid_parameters:
-            resistance_pu: float
-            inductance_pu_seconds: float
-            capacitance_pu_seconds: float
-            resistance_pu, inductance_pu_seconds, capacitance_pu_seconds = obj.get_values(
-                Sbase=Sbase,
-                length=self.length,
-                line_Vnom=line_voltage,
+        try:
+            if not isinstance(obj, UndergroundLineType):
+                raise ValueError('Select a Cable System')
+            if not np.isfinite(obj.Vnom) or obj.Vnom <= 0.0 or not np.isfinite(obj.Imax) or obj.Imax < 0.0:
+                raise ValueError('Invalid Cable System rating')
+            resistance_pu, _, _ = obj.get_dc_values(
+                Sbase=Sbase, length=self.length, line_Vnom=line_voltage,
+                conductor=self.dc_conductor,
             )
+        except ValueError as error:
+            calculation_logger.add_error('DC cable template could not be applied',
+                                         device=self.name, value=str(error))
+            return
 
-            # All validation and conversion finishes before the branch changes,
-            # so a failed application cannot leave a mixed old/new state.
-            self.R = resistance_pu
-            self.template = obj
-            self.rms_template = obj.rms_template
-            self.emt_template = obj.emt_template
-        else:
-            calculation_logger.add_error(
-                msg='DC cable template could not be applied',
-                device=self.name,
-            )
+        # Conversion succeeds before changing the branch; preserve its rating.
+        self.R = resistance_pu
+        self.template = obj
+        self.rms_template, self.emt_template = obj.get_branch_dynamic_templates(
+            device_type=self.device_type, logger=calculation_logger)
 
     def get_applied_dynamic_values_pu_seconds(self,
                                               Sbase: float) -> Tuple[float, float] | None:
@@ -346,10 +340,11 @@ class DcLine(BranchParent):
             resistance_pu: float
             inductance_pu_seconds: float
             capacitance_pu_seconds: float
-            resistance_pu, inductance_pu_seconds, capacitance_pu_seconds = self.template.get_values(
+            resistance_pu, inductance_pu_seconds, capacitance_pu_seconds = self.template.get_dc_values(
                 Sbase=Sbase,
                 length=self.length,
                 line_Vnom=line_voltage,
+                conductor=self.dc_conductor,
             )
             return inductance_pu_seconds, capacitance_pu_seconds
         else:
@@ -377,7 +372,7 @@ class DcLine(BranchParent):
         else:
             # No physical L/C default exists for a DC cable. Returning zero
             # selects the existing resistive simulation reduction without
-            # creating a fictitious physical DcCableType.
+            # creating a fictitious physical UndergroundLineType.
             logger.add_warning(
                 msg='DC line has no cable template; using the resistive fallback',
                 device=self.name,
@@ -415,6 +410,7 @@ class DcLine(BranchParent):
             temp_oper=self.temp_oper,
             alpha=self.alpha,
             template=self.template,
+            dc_conductor=self.dc_conductor,
         )
 
         copied_line.measurements = self.measurements

{veragridengine-6.7.3 → veragridengine-6.7.5}/VeraGridEngine/Devices/Branches/line.py

@@ -790,8 +790,8 @@ class Line(BranchParent):
                                    Vnom=line_voltage_kv)
 
             self.template = obj
-            self.rms_template = obj.rms_template
-            self.emt_template = obj.emt_template
+            self.rms_template, self.emt_template = obj.get_branch_dynamic_templates(
+                device_type=self.device_type, logger=logger)
 
         elif isinstance(obj, SequenceLineType):
             (self.R, self.X, self.B,

{veragridengine-6.7.3 → veragridengine-6.7.5}/VeraGridEngine/Devices/Branches/underground_cable_type.py

@@ -4,10 +4,11 @@
 # SPDX-License-Identifier: MPL-2.0
 from __future__ import annotations
 
-from typing import Tuple
+import math
+from typing import Any, Tuple
 
 from VeraGridEngine.Devices.Parents.editable_device import EditableDevice, GCProp
-from VeraGridEngine.enumerations import DeviceType, PrpCat
+from VeraGridEngine.enumerations import CableResistanceInput, DeviceType, PrpCat
 
 
 class UndergroundCableType(EditableDevice):
@@ -15,7 +16,9 @@ class UndergroundCableType(EditableDevice):
 
     __slots__ = (
         '_nominal_voltage',
+        '_resistance_input',
         '_core_dc_resistance',
+        '_sheath_dc_resistance',
         '_core_diameter',
         '_core_internal_diameter',
         '_cable_diameter',
@@ -41,9 +44,15 @@ class UndergroundCableType(EditableDevice):
         GCProp(prop_name='nominal_voltage', old_names=('Vnom',), units='kV', tpe=float,
                definition='Rated cable voltage (PowerFactory uline)',
                cat=(PrpCat.TP,)),
+        GCProp(prop_name='resistance_input', old_names=('core_resistance_input',), units='', tpe=CableResistanceInput,
+               definition='Choose the resistance inputs for both core and sheath at 20 degrees Celsius: DC resistances, or resistivities and filling factors',
+               cat=(PrpCat.TP,)),
         GCProp(prop_name='core_dc_resistance', old_names=('rpha',), units='Ohm/km', tpe=float,
-               definition='Imported core DC resistance at 20 degrees Celsius; informational, not used by the geometric calculation',
-               editable=False, cat=(PrpCat.TP,)),
+               definition='Core DC resistance at 20 degrees Celsius: input in DC resistance mode, otherwise calculated from resistivity, filling factor and diameter',
+               cat=(PrpCat.TP,)),
+        GCProp(prop_name='sheath_dc_resistance', units='Ohm/km', tpe=float,
+               definition='Sheath DC resistance at 20 degrees Celsius: input in DC resistance mode, otherwise calculated from resistivity, filling factor and annular area',
+               cat=(PrpCat.TP,)),
         GCProp(prop_name='core_diameter', old_names=('diaCon',), units='mm', tpe=float,
                definition='Core outer diameter',
                cat=(PrpCat.TP,)),
@@ -60,16 +69,16 @@ class UndergroundCableType(EditableDevice):
                definition='Core-to-sheath insulation thickness (PowerFactory thIns[0]); outer insulation is derived from cable_diameter',
                cat=(PrpCat.TP,)),
         GCProp(prop_name='core_resistivity', old_names=('crho_core',), units='uOhm*cm', tpe=float,
-               definition='Core resistivity at 20 degrees Celsius (PowerFactory crho[0])',
+               definition='Core resistivity at 20 degrees Celsius (PowerFactory crho[0]); inactive in DC resistance mode',
                cat=(PrpCat.TP,)),
         GCProp(prop_name='sheath_resistivity', old_names=('crho_sheath',), units='uOhm*cm', tpe=float,
-               definition='Sheath resistivity at 20 degrees Celsius (PowerFactory crho[1])',
+               definition='Sheath resistivity at 20 degrees Celsius (PowerFactory crho[1]); inactive in DC resistance mode',
                cat=(PrpCat.TP,)),
         GCProp(prop_name='core_filling_factor', old_names=('Cf_core',), units='%', tpe=float,
-               definition='Core conducting filling factor (PowerFactory Cf[0])',
+               definition='Core conducting filling factor (PowerFactory Cf[0]); inactive in DC resistance mode',
                cat=(PrpCat.TP,)),
         GCProp(prop_name='sheath_filling_factor', old_names=('Cf_sheath',), units='%', tpe=float,
-               definition='Sheath conducting filling factor (PowerFactory Cf[1])',
+               definition='Sheath conducting filling factor (PowerFactory Cf[1]); inactive in DC resistance mode',
                cat=(PrpCat.TP,)),
         GCProp(prop_name='main_insulation_permittivity', old_names=('cepsr_core_sheath',), units='', tpe=float,
                definition='Core-to-sheath insulation relative permittivity (PowerFactory cepsr[0])',
@@ -119,14 +128,20 @@ class UndergroundCableType(EditableDevice):
                  core_relative_permeability: float = 1.0,
                  sheath_relative_permeability: float = 1.0,
                  skin_effect_factor: float = 1.0,
-                 proximity_effect_factor: float = 1.0) -> None:
+                 proximity_effect_factor: float = 1.0,
+                 core_resistance_input: CableResistanceInput | None = None,
+                 resistance_input: CableResistanceInput | None = None,
+                 sheath_dc_resistance: float | None = None) -> None:
         """Create one physical cable using scalar inputs for its two conducting layers.
 
         :param name: Cable catalogue name.
         :param idtag: Persistent VeraGrid identifier.
         :param code: Optional user code.
         :param nominal_voltage: Rated cable voltage (PowerFactory uline) in kV.
-        :param core_dc_resistance: Imported core DC resistance at 20 degrees Celsius; informational, not used by the geometric calculation in Ohm/km.
+        :param core_dc_resistance: Core DC resistance at 20 degrees Celsius in Ohm/km, used only in DC resistance mode.
+        :param core_resistance_input: Deprecated alias of the shared resistance_input selector.
+        :param resistance_input: Select DC resistances or material inputs for both core and sheath; defaults to material inputs.
+        :param sheath_dc_resistance: Sheath DC resistance at 20 degrees Celsius in Ohm/km, required in DC resistance mode.
         :param core_diameter: Core outer diameter in mm.
         :param core_internal_diameter: Core inner diameter in mm.
         :param cable_diameter: Overall cable diameter, including outer insulation in mm.
@@ -156,7 +171,14 @@ class UndergroundCableType(EditableDevice):
 
         # Store only the supported layers; the DGS parser maps the PowerFactory vectors.
         self.nominal_voltage = nominal_voltage
+        if (core_resistance_input is not None and resistance_input is not None
+                and CableResistanceInput(core_resistance_input) != CableResistanceInput(resistance_input)):
+            raise ValueError('Specify one common resistance input method for core and sheath')
+        self.resistance_input = (resistance_input if resistance_input is not None else
+                                 core_resistance_input if core_resistance_input is not None else
+                                 CableResistanceInput.Resistivity)
         self.core_dc_resistance = core_dc_resistance
+        self.sheath_dc_resistance = 0.0 if sheath_dc_resistance is None else sheath_dc_resistance
         self.core_diameter = core_diameter
         self.core_internal_diameter = core_internal_diameter
         self.cable_diameter = cable_diameter
@@ -174,6 +196,10 @@ class UndergroundCableType(EditableDevice):
         self.sheath_relative_permeability = sheath_relative_permeability
         self.skin_effect_factor = skin_effect_factor
         self.proximity_effect_factor = proximity_effect_factor
+        if (core_resistance_input is not None and resistance_input is None
+                and sheath_dc_resistance is None):
+            # Preserve the former core-only constructor's sheath definition.
+            self.sheath_dc_resistance = self.get_sheath_dc_resistance_from_material()
 
     @property
     def nominal_voltage(self) -> float:
@@ -193,22 +219,152 @@ class UndergroundCableType(EditableDevice):
         self._nominal_voltage = float(value)
 
     @property
-    def core_dc_resistance(self) -> float:
-        """Read the core_dc_resistance input.
+    def resistance_input(self) -> CableResistanceInput:
+        """Return the common resistance input method for core and sheath."""
+        return self._resistance_input
 
-        :return: Imported core DC resistance at 20 degrees Celsius; informational, not used by the geometric calculation in Ohm/km.
-        """
-        return self._core_dc_resistance
+    @resistance_input.setter
+    def resistance_input(self, value: CableResistanceInput | str) -> None:
+        """Store the selector without reinterpreting other inputs during file loading."""
+        self._resistance_input = CableResistanceInput(value)
+
+    @property
+    def core_resistance_input(self) -> CableResistanceInput:
+        """Compatibility alias; this selector now controls both conducting layers."""
+        return self.resistance_input
+
+    @core_resistance_input.setter
+    def core_resistance_input(self, value: CableResistanceInput | str) -> None:
+        self.resistance_input = value
+
+    def get_sheath_area_m2(self) -> float:
+        """Return the tubular sheath area, excluding the core and insulation."""
+        inner_radius_m = (self.core_diameter / 2.0 + self.main_insulation_thickness) * 1e-3
+        thickness_m = self.sheath_thickness * 1e-3
+        return math.pi * thickness_m * (2.0 * inner_radius_m + thickness_m)
+
+    def get_sheath_dc_resistance_from_material(self) -> float:
+        """Derive sheath resistance from its material data, also for legacy migration."""
+        conducting_area_m2 = self.get_sheath_area_m2() * self.sheath_filling_factor / 100.0
+        if conducting_area_m2 <= 0.0:
+            return float('nan')
+        return self.sheath_resistivity * 1e-5 / conducting_area_m2
+
+    def get_core_material_properties(self) -> tuple[float, float]:
+        """Return effective calculation inputs in micro-ohm cm and percent.
+
+        A directly specified resistance determines effective resistivity over
+        the solid core section; a 100 percent factor avoids applying it twice.
+        The material-input path is unchanged for legacy files and DGS imports.
+        """
+        if self.resistance_input == CableResistanceInput.DcResistance:
+            area_m2 = math.pi * (self.core_diameter * 0.5e-3) ** 2
+            return self._core_dc_resistance * area_m2 * 1.0e5, 100.0
+        return self.core_resistivity, self.core_filling_factor
+
+    def get_sheath_material_properties(self) -> tuple[float, float]:
+        """Return the active sheath calculation inputs in micro-ohm cm and percent."""
+        if self.resistance_input == CableResistanceInput.DcResistance:
+            return self.sheath_dc_resistance * self.get_sheath_area_m2() * 1e5, 100.0
+        return self.sheath_resistivity, self.sheath_filling_factor
+
+    def validate_resistance_inputs(self) -> None:
+        """Reject invalid active inputs before calculating an impedance matrix."""
+        if not math.isfinite(self.core_diameter) or self.core_diameter <= 0.0:
+            raise ValueError('Core diameter must be finite and positive')
+        if (not math.isfinite(self.sheath_thickness) or self.sheath_thickness <= 0.0
+                or not math.isfinite(self.main_insulation_thickness) or self.main_insulation_thickness <= 0.0
+                or not math.isfinite(self.get_sheath_area_m2()) or self.get_sheath_area_m2() <= 0.0):
+            raise ValueError('Sheath annular area and its defining dimensions must be finite and positive')
+        for layer in ('core', 'sheath'):
+            if self.resistance_input == CableResistanceInput.DcResistance:
+                resistance = getattr(self, f'{layer}_dc_resistance')
+                if not math.isfinite(resistance) or resistance <= 0.0:
+                    raise ValueError(f'{layer.capitalize()} DC resistance must be finite and positive')
+            else:
+                resistivity = getattr(self, f'{layer}_resistivity')
+                factor = getattr(self, f'{layer}_filling_factor')
+                if not math.isfinite(resistivity) or resistivity <= 0.0:
+                    raise ValueError(f'{layer.capitalize()} resistivity must be finite and positive')
+                if not math.isfinite(factor) or not 0.0 < factor <= 100.0:
+                    raise ValueError(f'{layer.capitalize()} filling factor must be greater than zero and at most 100 percent')
+
+    def is_property_editable(self, prop: GCProp) -> bool:
+        """Allow only the selected resistance representation to be edited."""
+        if prop.name in ('core_dc_resistance', 'sheath_dc_resistance'):
+            return self.resistance_input == CableResistanceInput.DcResistance
+        if prop.name in ('core_resistivity', 'core_filling_factor', 'sheath_resistivity', 'sheath_filling_factor'):
+            return self.resistance_input == CableResistanceInput.Resistivity
+        return super().is_property_editable(prop)
+
+    def set_value(self, prop: GCProp, t_idx: int | None, value: Any) -> None:
+        """Apply GUI edits, preserving resistance when switching input method.
+
+        Snapshot setters used by file loading deliberately bypass this UI
+        transition so saved inputs are restored independently of field order.
+        """
+        if not self.is_property_editable(prop):
+            raise ValueError(f'{prop.name} is not an active input')
+        if prop.name == 'resistance_input':
+            mode = CableResistanceInput(value)
+            if mode != self.resistance_input:
+                self.validate_resistance_inputs()
+                if mode == CableResistanceInput.DcResistance:
+                    self._core_dc_resistance = self.core_dc_resistance
+                    self._sheath_dc_resistance = self.sheath_dc_resistance
+                else:
+                    # Preserve each layer's R when returning to material inputs.
+                    for layer, properties in (('core', self.get_core_material_properties()),
+                                               ('sheath', self.get_sheath_material_properties())):
+                        factor = getattr(self, f'{layer}_filling_factor')
+                        if not math.isfinite(factor) or not 0.0 < factor <= 100.0:
+                            factor = 100.0
+                        setattr(self, f'{layer}_resistivity', properties[0] * factor / 100.0)
+                        setattr(self, f'{layer}_filling_factor', factor)
+                self.resistance_input = mode
+            return
+        if prop.name in ('core_dc_resistance', 'core_resistivity', 'core_filling_factor', 'core_diameter',
+                         'sheath_dc_resistance', 'sheath_resistivity', 'sheath_filling_factor',
+                         'sheath_thickness', 'main_insulation_thickness'):
+            number = float(value)
+            if not math.isfinite(number) or number <= 0.0:
+                raise ValueError(f'{prop.name} must be finite and positive')
+            if prop.name in ('core_filling_factor', 'sheath_filling_factor') and number > 100.0:
+                raise ValueError('Filling factor cannot exceed 100 percent')
+        super().set_value(prop=prop, t_idx=t_idx, value=value)
+
+    @property
+    def core_dc_resistance(self) -> float:
+        """Return the active or derived core DC resistance at 20 C in Ohm/km."""
+        if self.resistance_input == CableResistanceInput.DcResistance:
+            return self._core_dc_resistance
+        area_m2 = math.pi * (self.core_diameter * 0.5e-3) ** 2
+        conducting_area_m2 = area_m2 * self.core_filling_factor / 100.0
+        if conducting_area_m2 <= 0.0:
+            return float('nan')
+        return self.core_resistivity * 1.0e-5 / conducting_area_m2
 
     @core_dc_resistance.setter
     def core_dc_resistance(self, value: float) -> None:
         """Store the core_dc_resistance input.
 
-        :param value: Imported core DC resistance at 20 degrees Celsius; informational, not used by the geometric calculation in Ohm/km.
+        :param value: Core DC resistance at 20 degrees Celsius in Ohm/km; active only in DC resistance mode.
         :return: None.
         """
         self._core_dc_resistance = float(value)
 
+    @property
+    def sheath_dc_resistance(self) -> float:
+        """Return the active or derived sheath DC resistance at 20 C in Ohm/km."""
+        if self.resistance_input == CableResistanceInput.DcResistance:
+            return self._sheath_dc_resistance
+        return self.get_sheath_dc_resistance_from_material()
+
+    @sheath_dc_resistance.setter
+    def sheath_dc_resistance(self, value: float) -> None:
+        """Store the sheath resistance input; used only in DC resistance mode."""
+        self._sheath_dc_resistance = float(value)
+
     @property
     def core_diameter(self) -> float:
         """Read the core_diameter input.

{veragridengine-6.7.3 → veragridengine-6.7.5}/VeraGridEngine/Devices/Branches/underground_line_type.py

@@ -475,6 +475,70 @@ class UndergroundLineType(DynamicDevice):
             and self._y_nabc is not None
         )
 
+    def get_dc_parameters(self, conductor: int = 1) -> tuple[float, float, float]:
+        """Return Rdc [ohm/km], L [H/km] and C [F/km] for one DC conductor.
+
+        For a physical system, ``conductor`` is its global phase number. The
+        existing sheath-reduced matrices supply the diagonal L/C at ``freq``;
+        Rdc comes from the physical core, without AC skin/earth-return losses.
+        A scalar DcLine does not represent mutual coupling between conductors.
+        Parameter-only systems use R, X and C (or B), including imported DGS
+        equivalents whose construction is unknown.
+        """
+        if not np.isfinite(self.freq) or self.freq <= 0.0:
+            raise ValueError('Cable System reference frequency must be positive')
+        omega = 2.0 * np.pi * self.freq
+        if self.has_physical_data():
+            if not np.isfinite(self.earth_resistivity) or self.earth_resistivity <= 0.0:
+                raise ValueError('Cable System earth resistivity must be positive')
+            # Recompute so edits to a referenced Cable cannot leave stale L/C.
+            logger = Logger()
+            if not self.compute(logger=logger):
+                raise ValueError('Cable System geometry or materials are invalid')
+            indices = np.flatnonzero(self.z_phases_nabc == conductor)
+            if len(indices) != 1:
+                raise ValueError('Select an existing Cable System conductor number')
+            idx = int(indices[0])
+            cable = next(item.cable for item in self.cables_in_system.data
+                         if item.phase == conductor)
+            values = (float(cable.core_dc_resistance),
+                      float(self.z_nabc[idx, idx].imag / omega),
+                      float(self.y_nabc[idx, idx].imag / omega))
+        else:
+            if conductor != 1:
+                raise ValueError('A parameter-only Cable System has one DC equivalent')
+            values = (self.R, self.X / omega,
+                      (self.C if self.C != 0.0 else self.B / omega) * 1.0e-6)
+        if not all(np.isfinite(value) and value >= 0.0 for value in values):
+            raise ValueError('Cable System DC parameters must be finite and non-negative')
+        return values
+
+    def get_dc_values(self, Sbase: float, length: float, line_Vnom: float,
+                      conductor: int = 1) -> tuple[float, float, float]:
+        """Return total DC R in p.u. and L/C in p.u. seconds.
+
+        Keep the historical DC conversion: Zbase = Vnom**2/Sbase,
+        Rpu = R*length/Zbase, Lpu = L*length/Zbase, Cpu = C*length*Zbase.
+        """
+        if not all(np.isfinite(value) and value > 0.0
+                   for value in (Sbase, length, line_Vnom)):
+            raise ValueError('DC bases and cable length must be positive and finite')
+        resistance, inductance, capacitance = self.get_dc_parameters(conductor)
+        zbase = line_Vnom * line_Vnom / Sbase
+        return resistance * length / zbase, inductance * length / zbase, capacitance * length * zbase
+
+    def get_branch_dynamic_templates(self, device_type: DeviceType, logger: Logger) -> tuple:
+        """Share electrical data without assigning AC dynamic models to DC or vice versa."""
+        templates = []
+        for model in (self.rms_template, self.emt_template):
+            if model is None or model.tpe in (device_type, DeviceType.NoDevice):
+                templates.append(model)
+            else:
+                logger.add_warning('Cable System dynamic template does not match the branch type; not applied',
+                                   device=self.name, value=model.name, expected_value=str(device_type))
+                templates.append(None)
+        return tuple(templates)
+
     def get_values(self,
                    Sbase: float,
                    length: float,
@@ -682,14 +746,17 @@ class UndergroundLineType(DynamicDevice):
                     and cable.cable_diameter > cable.core_diameter
                     and cable.sheath_thickness > 0.0
                     and relationship.ypos > 0.0
-                    and cable.core_filling_factor > 0.0
-                    and cable.sheath_filling_factor > 0.0
                 ):
                     pass
                 else:
                     validation_logger.add_error('Invalid cable dimensions, depth or filling factor',
                                                 device=relationship.name)
                     valid = False
+                try:
+                    cable.validate_resistance_inputs()
+                except ValueError as error:
+                    validation_logger.add_error(str(error), device=cable.name)
+                    valid = False
             else:
                 validation_logger.add_error('Cable relationship has no catalogue type', device=relationship.name)
                 valid = False
@@ -752,8 +819,10 @@ class UndergroundLineType(DynamicDevice):
                     th_sht[cable_index] = cable.sheath_thickness
                     # Numerical routines receive only the core and sheath (or their two insulations).
                     th_ins[cable_index] = cable.main_insulation_thickness
-                    resistivity[cable_index, :] = (cable.core_resistivity, cable.sheath_resistivity)
-                    filling_factor[cable_index, :] = (cable.core_filling_factor, cable.sheath_filling_factor)
+                    core_resistivity, core_filling_factor = cable.get_core_material_properties()
+                    sheath_resistivity, sheath_filling_factor = cable.get_sheath_material_properties()
+                    resistivity[cable_index, :] = (core_resistivity, sheath_resistivity)
+                    filling_factor[cable_index, :] = (core_filling_factor, sheath_filling_factor)
                     relative_permittivity[cable_index, :] = (cable.main_insulation_permittivity, cable.outer_insulation_permittivity)
                     loss_factor[cable_index, :] = (cable.main_insulation_loss_tangent, cable.outer_insulation_loss_tangent)
                     relative_permeability[cable_index, :] = (cable.core_relative_permeability, cable.sheath_relative_permeability)

{veragridengine-6.7.3 → veragridengine-6.7.5}/VeraGridEngine/Devices/Parents/editable_device.py

@@ -1092,6 +1092,10 @@ class EditableDevice(metaclass=EditableDeviceMeta):
                 # return the normal property
                 return getattr(self, prop.name)
 
+    def is_property_editable(self, prop: GCProp) -> bool:
+        """Return instance-specific GUI editability without mutating shared metadata."""
+        return prop.editable
+
     def set_value(self, prop: GCProp, t_idx: Union[None, int], value: Any) -> None:
         """
         Return value regardless of the property index