VeraGridEngine 5.6.14__tar.gz → 5.6.15__tar.gz

{veragridengine-5.6.14 → veragridengine-5.6.15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: VeraGridEngine
-Version: 5.6.14
+Version: 5.6.15
 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-5.6.14 → veragridengine-5.6.15}/VeraGridEngine/IO/iidm/iidm_parser.py

@@ -26,6 +26,7 @@ from VeraGridEngine.IO.iidm.devices.iidm_circuit import IidmCircuit
     https://powsybl.readthedocs.io/projects/powsybl-core/en/stable/grid_model/network_subnetwork.html
 """
 
+
 def strip_ns(tag: str) -> str:
     """
 
@@ -84,7 +85,7 @@ def parse_xiidm_file(file_path: str) -> IidmCircuit:
                 _id=elem.attrib.get("id", ""),
                 area_number=elem.attrib.get("areaNumber", -1),
                 status=elem.attrib.get("status", ""),
-                nodes=[int(e) for e in elem.attrib.get("nodes", []).split(",")],
+                nodes=[int(e) for e in elem.attrib.get("nodes", "").split(",")],
             ))
 
         elif tag == "generator":
@@ -183,11 +184,9 @@ def parse_xiidm_file(file_path: str) -> IidmCircuit:
 
 
 if __name__ == "__main__":
-
-
-
     # fname = "/home/santi/Documentos/Git/GitHub/RTE7000/2021/01/01/recollement-auto-20210101-0000-enrichi.xiidm"
-    fname = "/home/santi/Documentos/Git/GitHub/RTE7000/2021/01/01/recollement-auto-20210101-0000-enrichi.xiidm.bz2"
+    # fname = "/home/santi/Documentos/Git/GitHub/RTE7000/2021/01/01/recollement-auto-20210101-0000-enrichi.xiidm.bz2"
+    fname = "/Users/santi/Git/eRoots/VeraGrid/src/tests/data/grids/ucte/network.xiidm"
 
     # import pypowsybl as pp
     # grid = pp.network.load(fname)
@@ -196,4 +195,3 @@ if __name__ == "__main__":
     iidm_circuit = parse_xiidm_file(fname)
 
     print()
-

{veragridengine-5.6.14 → veragridengine-5.6.15}/VeraGridEngine/IO/ucte/devices/ucte_comment.py

@@ -8,4 +8,4 @@ class UcteComment:
         self.content = ""
 
     def parse(self, line):
-        self.content = line.strip()
+        self.content = line.strip()

veragridengine-5.6.15/VeraGridEngine/IO/ucte/devices/ucte_exchange_power.py

@@ -0,0 +1,54 @@
+# 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
+from VeraGridEngine.IO.ucte.devices.ucte_base import sub_str, sub_float, try_float
+from VeraGridEngine.basic_structures import Logger
+
+
+class UcteExchangePower:
+    """
+    UcteExchangePower
+    """
+    def __init__(self):
+        self.country1 = ""  # 0-1: Country 1 (ISO code)
+        self.country2 = ""  # 3-4: Country 2 (ISO code)
+        self.active_power = 0.0  # 6-12: Scheduled active power exchange (MW)
+        self.comments = ""  # 14-25: Optional comments
+
+    def parse(self, line, logger: Logger):
+        """
+
+        :param line:
+        :param logger:
+        :return:
+        """
+
+        device = "Exchange Power"
+
+        if len(line) == 27:
+            self.country1 = sub_str(line, 0, 2, device, "country1", logger)
+            self.country2 = sub_str(line, 3, 5, device, "country2", logger)
+            self.active_power = sub_float(line, 6, 13, device, "active_power", logger)
+            self.comments = sub_str(line, 14, 26, device, "comments", logger)
+
+        else:
+
+            logger.add_warning("Non canonical line length",
+                               device_class=device,
+                               value=len(line),
+                               expected_value=27)
+
+            chunks = line.split()
+
+            if len(chunks) >= 1:
+                self.country1 = chunks[0]
+
+            if len(chunks) >= 2:
+                self.country2 = chunks[1]
+
+            if len(chunks) >= 3:
+                self.active_power = try_float(chunks[3], device, "active_power", logger)
+
+            if len(chunks) >= 4:
+                self.comments = chunks[4]

{veragridengine-5.6.14 → veragridengine-5.6.15}/VeraGridEngine/IO/ucte/devices/ucte_line.py

@@ -80,40 +80,33 @@ class UcteLine:
 
             chunks = line.split()
 
-            if len(chunks) >= 9:
-
+            if len(chunks) >= 1:
                 self.node1 = chunks[0].strip()
+
+            if len(chunks) >= 2:
                 self.node2 = chunks[1].strip()
+
+            if len(chunks) >= 3:
                 self.order_code = chunks[2].strip()
+
+            if len(chunks) >= 4:
                 self.status = try_int(chunks[3].strip(), device, "status", logger)
+
+            if len(chunks) >= 5:
                 self.resistance = try_float(chunks[4].strip(), device, "resistance", logger)
+
+            if len(chunks) >= 6:
                 self.reactance = try_float(chunks[5].strip(), device, "reactance", logger)
+
+            if len(chunks) >= 7:
                 self.susceptance = try_float(chunks[6].strip(), device, "susceptance", logger)
-                self.current_limit = try_float(chunks[7].strip(), device, "current_limit", logger, 9999.0)
-                self.name = chunks[8].strip()
 
-            elif len(chunks) == 8:
+            if len(chunks) >= 8:
+                self.current_limit = try_float(chunks[7].strip(), device, "current_limit", logger,
+                                               9999.0)
 
-                self.node1 = chunks[0].strip()
-                self.node2 = chunks[1].strip()
-                self.order_code = chunks[2].strip()
-                self.status = try_int(chunks[3].strip(), device, "status", logger)
-                self.resistance = try_float(chunks[4].strip(), device, "resistance", logger)
-                self.reactance = try_float(chunks[5].strip(), device, "reactance", logger)
-                self.susceptance = try_float(chunks[6].strip(), device, "susceptance", logger)
-                self.current_limit = try_float(chunks[7].strip(), device, "current_limit", logger, 9999.0)
-                self.name = f"{self.node1}_{self.node2}_{self.order_code}"
-
-                logger.add_warning("Incorrect number of parameters",
-                                   device_class=device,
-                                   value=len(chunks),
-                                   expected_value=9)
-
-            else:
-                logger.add_error("Incorrect number of parameters",
-                                 device_class=device,
-                                 value=len(chunks),
-                                 expected_value=9)
+            if len(chunks) >= 9:
+                self.name = chunks[8].strip()
 
         if self.current_limit < 0:
             self.current_limit = 9999.0

veragridengine-5.6.15/VeraGridEngine/IO/ucte/devices/ucte_node.py

@@ -0,0 +1,241 @@
+# 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
+from __future__ import annotations
+
+from VeraGridEngine.IO.ucte.devices.ucte_base import sub_int, sub_str, sub_float, try_int, try_float
+from VeraGridEngine.basic_structures import Logger
+
+UCTE_VOLTAGE_MAP = {
+    "0": 750,
+    "1": 380,
+    "2": 220,
+    "3": 150,
+    "4": 120,
+    "5": 110,
+    "6": 70,
+    "7": 27,
+    "8": 330,
+    "9": 500,
+    "A": 26,
+    "B": 25,
+    "C": 24,
+    "D": 23,
+    "E": 22,
+    "F": 21,
+    "G": 20,
+    "H": 19,
+    "I": 18,
+    "J": 17,
+    "K": 15.7,
+    "L": 15,
+    "M": 13.7,
+    "N": 13,
+    "O": 12,
+    "P": 11,
+    "Q": 9.8,
+    "R": 9,
+    "S": 8,
+    "T": 7,
+    "U": 6,
+    "V": 5,
+    "W": 4,
+    "X": 3,
+    "Y": 2,
+    "Z": 1,
+}
+
+
+def try_parse_voltage(val: str | float, name: str, logger: Logger) -> float:
+    """
+
+    :return:
+    """
+    try:
+        return float(val)
+    except ValueError:
+        val2 = UCTE_VOLTAGE_MAP.get(val, None)
+        if val2 is None:
+            logger.add_error('Could not parse UCTE voltage',
+                             device=name, value=f"'{val}'")
+            return 1.0
+        else:
+            return val2
+
+
+class UcteNode:
+    """
+    UcteNode
+    """
+    def __init__(self):
+
+        self.current_country = ""
+
+        self.node_code = ""  # 0-7: Node (code)
+        self.geo_name = ""  # 9-20: Geographical name
+        self.status = 0  # 22: Status: 0 = real, 1 = equivalent
+
+        # Node type code (0 = P and Q constant (PQ node);
+        # 1 = Q and θ constant, 2 = P and U constant(PU node),
+        # 3 = U and θ constant(global slack node, only one in the whole network))
+        self.node_type = 0  # 24: Node type code
+
+        self.voltage = 10.0  # 26-31: Voltage (reference value, kV)
+
+        self.active_load = 0.0  # 33-39: Active load (MW)
+        self.reactive_load = 0.0  # 41-47: Reactive load (MVAr)
+
+        self.active_gen = 0.0  # 49-55: Active power generation (MW)
+        self.reactive_gen = 0.0  # 57-63: Reactive power generation (MVAr)
+
+        self.min_gen_mw = 0.0  # 65-71: Minimum permissible generation (MW) *
+        self.max_gen_mw = 0.0  # 73-79: Maximum permissible generation (MW) *
+        self.min_gen_mvar = 0.0  # 81-87: Minimum permissible generation (MVAr) *
+        self.max_gen_mvar = 0.0  # 89-95: Maximum permissible generation (MVAr) *
+
+        self.static_primary_control = 0.0  # 97-101: Static of primary control (%) *
+
+        self.nominal_power_primary_control = 0.0  # 103-109: Nominal power for primary control (MW) *
+
+        self.short_circuit_power = 0.0  # 111-117: Three-phase short circuit power (MVA) **
+
+        self.xr_ratio = 0.0  # 119-125: X/R ratio **
+
+        # Power plant type *
+        # H: hydro, N: nuclear, L: lignite,
+        # C: hard coal, G: gas, O: oil, W: wind, F: further
+        self.plant_type = ""  # 127: Power plant type (e.g., H: hydro, N: nuclear)
+
+    def has_load(self) -> bool:
+        """
+
+        :return:
+        """
+        return self.active_load != 0.0 or self.reactive_load != 0.0
+
+    def has_gen(self) -> bool:
+        """
+
+        :return:
+        """
+        return self.active_gen != 0.0 or self.reactive_gen != 0.0
+
+    def parse(self, line: str, logger: Logger):
+        """
+
+        :param line:
+        :param logger:
+        :return:
+        """
+
+        device = "Node"
+
+        voltage_code = line[26:32].strip()
+        if voltage_code != "" and len(line) == 129:
+            # Things may seem canonical
+            self.node_code = sub_str(line, 0, 8, device, "node_code", logger)
+            self.geo_name = sub_str(line, 9, 21, device, "geo_name", logger)
+            self.status = sub_int(line, 22, 23, device, "status", logger)
+            self.node_type = sub_int(line, 24, 25, device, "node_type", logger)
+            self.voltage = try_parse_voltage(val=line[26:32].strip(), name=self.node_code, logger=logger)
+            self.active_load = sub_float(line, 33, 40, device, "active_load", logger)
+            self.reactive_load = sub_float(line, 41, 48, device, "reactive_load", logger)
+            self.active_gen = sub_float(line, 49, 56, device, "active_gen", logger)
+            self.reactive_gen = sub_float(line, 57, 64, device, "reactive_gen", logger)
+            self.min_gen_mw = sub_float(line, 65, 72, device, "min_gen_mw", logger, -9999.0)
+            self.max_gen_mw = sub_float(line, 73, 80, device, "max_gen_mw", logger, 9999.0)
+            self.min_gen_mvar = sub_float(line, 81, 88, device, "min_gen_mvar", logger, -9999.0)
+            self.max_gen_mvar = sub_float(line, 89, 96, device, "max_gen_mvar", logger, 9999.0)
+            self.static_primary_control = sub_float(line, 97, 102, device, "static_primary_control", logger)
+            self.nominal_power_primary_control = sub_float(line, 103, 110, device, "nominal_power_primary_control", logger)
+            self.short_circuit_power = sub_float(line, 111, 118, device, "short_circuit_power", logger)
+            self.xr_ratio = sub_float(line, 119, 126, device, "xr_ratio", logger)
+            self.plant_type = sub_str(line, 127, 128, device, "plant_type", logger)
+        else:
+
+            if len(line) != 129:
+                logger.add_warning("Non canonical line length",
+                                   device_class=device,
+                                   value=len(line),
+                                   expected_value=128)
+            elif voltage_code == "":
+                logger.add_warning("Incorrect line formatting impede finding the voltage code",
+                                   device_class=device,
+                                   value=line,)
+
+            chunks = line.split()
+
+            if len(chunks) >= 1:
+                self.node_code = chunks[0]
+
+            if len(chunks) >= 2:
+                self.geo_name = chunks[1]
+
+            if len(chunks) >= 3:
+                self.status = try_int(chunks[2], device, "status", logger)
+
+            if len(chunks) >= 4:
+                self.node_type = try_int(chunks[3], device, "node_type", logger)
+
+            if len(chunks) >= 5:
+                self.voltage = try_parse_voltage(val=chunks[4], name=self.node_code, logger=logger)
+
+            if len(chunks) >= 6:
+                self.active_load = try_float(chunks[5], device, "active_load", logger)
+
+            if len(chunks) >= 7:
+                self.reactive_load = try_float(chunks[6], device, "reactive_load", logger)
+
+            if len(chunks) >= 8:
+                self.active_gen = try_float(chunks[7], device, "active_gen", logger)
+
+            if len(chunks) >= 9:
+                self.reactive_gen = try_float(chunks[8], device, "reactive_gen", logger)
+
+            if len(chunks) >= 10:
+                self.min_gen_mw = try_float(chunks[9], device, "min_gen_mw", logger, -9999.0)
+
+            if len(chunks) >= 11:
+                self.max_gen_mw = try_float(chunks[10], device, "max_gen_mw", logger, 9999.0)
+
+            if len(chunks) >= 12:
+                self.min_gen_mvar = try_float(chunks[11], device, "min_gen_mvar", logger, -9999.0)
+
+            if len(chunks) >= 13:
+                self.max_gen_mvar = try_float(chunks[12], device, "max_gen_mvar", logger, 9999.0)
+
+            if len(chunks) >= 14:
+                self.static_primary_control = try_float(chunks[13], device, "static_primary_control", logger)
+
+            if len(chunks) >= 15:
+                self.nominal_power_primary_control = try_float(chunks[14], device, "nominal_power_primary_control", logger)
+
+            if len(chunks) >= 16:
+                self.short_circuit_power = try_float(chunks[15], device, "short_circuit_power", logger)
+
+            if len(chunks) >= 17:
+                self.xr_ratio = try_float(chunks[16], device, "xr_ratio", logger)
+
+            if len(chunks) >= 18:
+                self.plant_type = try_float(chunks[17], device, "plant_type", logger)
+
+        if self.min_gen_mw > self.max_gen_mw:
+            # switch order
+            self.max_gen_mw, self.min_gen_mw = self.min_gen_mw, self.max_gen_mw
+
+        if self.min_gen_mvar > self.max_gen_mvar:
+            # switch order
+            self.max_gen_mvar, self.min_gen_mvar = self.min_gen_mvar, self.max_gen_mvar
+
+        if self.active_gen > self.max_gen_mw:
+            self.max_gen_mw = self.active_gen
+
+        if self.active_gen < self.min_gen_mw:
+            self.min_gen_mw = self.active_gen
+
+        if self.reactive_gen > self.max_gen_mvar:
+            self.max_gen_mvar = self.reactive_gen
+
+        if self.reactive_gen < self.min_gen_mvar:
+            self.min_gen_mvar = self.reactive_gen

{veragridengine-5.6.14 → veragridengine-5.6.15}/VeraGridEngine/IO/ucte/devices/ucte_transformer.py

@@ -92,68 +92,44 @@ class UcteTransformer:
 
             chunks = line.split()
 
-            if len(chunks) >= 13:
-
+            if len(chunks) >= 1:
                 self.node1 = chunks[0].strip()
-                self.node2 = chunks[1].strip()
-                self.order_code = chunks[2].strip()
-                self.status = try_int(chunks[3].strip(), device, "status", logger)
-                self.rated_voltage1 = try_float(chunks[4].strip(), device, "rated_voltage1", logger)
-                self.rated_voltage2 = try_float(chunks[5].strip(), device, "rated_voltage2", logger)
-                self.nominal_power = try_float(chunks[6].strip(), device, "nominal_power", logger)
-                self.resistance = try_float(chunks[7].strip(), device, "resistance", logger)
-                self.reactance = try_float(chunks[8].strip(), device, "reactance", logger)
-                self.susceptance = try_float(chunks[9].strip(), device, "susceptance", logger)
-                self.conductance = try_float(chunks[10].strip(), device, "conductance", logger)
-                self.current_limit = try_int(chunks[11].strip(), device, "current_limit", logger)
-                self.name = chunks[12].strip()
 
-            elif len(chunks) == 12:
-
-                self.node1 = chunks[0].strip()
+            if len(chunks) >= 2:
                 self.node2 = chunks[1].strip()
+
+            if len(chunks) >= 3:
                 self.order_code = chunks[2].strip()
+
+            if len(chunks) >= 4:
                 self.status = try_int(chunks[3].strip(), device, "status", logger)
+
+            if len(chunks) >= 5:
                 self.rated_voltage1 = try_float(chunks[4].strip(), device, "rated_voltage1", logger)
+
+            if len(chunks) >= 6:
                 self.rated_voltage2 = try_float(chunks[5].strip(), device, "rated_voltage2", logger)
+
+            if len(chunks) >= 7:
                 self.nominal_power = try_float(chunks[6].strip(), device, "nominal_power", logger)
+
+            if len(chunks) >= 8:
                 self.resistance = try_float(chunks[7].strip(), device, "resistance", logger)
+
+            if len(chunks) >= 9:
                 self.reactance = try_float(chunks[8].strip(), device, "reactance", logger)
+
+            if len(chunks) >= 10:
                 self.susceptance = try_float(chunks[9].strip(), device, "susceptance", logger)
+
+            if len(chunks) >= 11:
                 self.conductance = try_float(chunks[10].strip(), device, "conductance", logger)
-                self.current_limit = try_int(chunks[11].strip(), device, "current_limit", logger)
-                self.name = "No name provided"
 
-                logger.add_warning("Incorrect number of parameters",
-                                   device_class=device,
-                                   value=len(chunks),
-                                   expected_value=13)
-            elif len(chunks) == 11:
+            if len(chunks) >= 12:
+                self.current_limit = try_int(chunks[11].strip(), device, "current_limit", logger)
 
-                self.node1 = chunks[0].strip()
-                self.node2 = chunks[1].strip()
-                self.order_code = chunks[2].strip()
-                self.status = try_int(chunks[3].strip(), device, "status", logger)
-                self.rated_voltage1 = try_float(chunks[4].strip(), device, "rated_voltage1", logger)
-                self.rated_voltage2 = try_float(chunks[5].strip(), device, "rated_voltage2", logger)
-                self.nominal_power = 9999.0  # WTF!!!!
-                self.resistance = try_float(chunks[6].strip(), device, "resistance", logger)
-                self.reactance = try_float(chunks[7].strip(), device, "reactance", logger)
-                self.susceptance = try_float(chunks[8].strip(), device, "susceptance", logger)
-                self.conductance = try_float(chunks[9].strip(), device, "conductance", logger)
-                self.current_limit = try_int(chunks[10].strip(), device, "current_limit", logger)
-                self.name = "No name provided"
-
-                logger.add_warning("Incorrect number of parameters",
-                                   device_class=device,
-                                   value=len(chunks),
-                                   expected_value=13)
-
-            else:
-                logger.add_error("Completely incorrect number of parameters",
-                                 device_class=device,
-                                 value=len(chunks),
-                                 expected_value=13)
+            if len(chunks) >= 13:
+                self.name = chunks[12].strip()
 
         if self.current_limit < 0:
             self.current_limit = 9999.0

veragridengine-5.6.15/VeraGridEngine/IO/ucte/devices/ucte_transformer_regulation.py

@@ -0,0 +1,119 @@
+# 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
+from VeraGridEngine.IO.ucte.devices.ucte_base import sub_int, sub_str, sub_float, try_int, try_float
+from VeraGridEngine.basic_structures import Logger
+
+
+class UcteTransformerRegulation:
+    """
+    UcteTransformerRegulation
+    """
+    def __init__(self):
+        self.node1 = ""  # 0-7: Node 1 (non-regulated winding) To bus for VeraGrid
+        self.node2 = ""  # 9-16: Node 2 (regulated winding) From bus for VeraGrid
+        self.order_code = ""  # 18: Order code
+
+        # Phase regulation
+        self.delta_u1 = 0.0  # 20-24: δu1 (%)
+        self.n1 = 0  # 26-27: Number of taps (n1)
+        self.n1_prime = 0  # 29-31: Alternate taps (n1')
+        self.u1 = 0.0  # 33-37: U1 (kV, optional)
+
+        # Angle regulation
+        self.delta_u2 = 0.0  # 39-43: δu2 (%)
+        self.theta = 0.0  # 45-49: Θ (°)
+        self.n2 = 0  # 51-52: Number of taps (n2)
+        self.n2_prime = 0  # 54-56: Alternate taps (n2')
+        self.p = 0.0  # 58-62: P (MW, optional)
+        self.regulation_type = ""  # 64-67: Regulation type (ASYM, SYMM)
+
+        self.valid_regulation = True  # assume true for now...
+
+    def get_primary_key(self):
+        """
+        Get a transformer primary key
+        :return:
+        """
+        return f"{self.node1}_{self.node2}_{self.order_code}"
+
+    def parse(self, line: str, logger: Logger):
+        """
+
+        :param line:
+        :param logger:
+        :return:
+        """
+
+        device = "TransformerRegulation"
+
+        if len(line) == 69:
+            self.node1 = sub_str(line, 0, 8, device, "node1", logger)
+            self.node2 = sub_str(line, 9, 17, device, "node2", logger)
+            self.order_code = sub_str(line, 18, 19, device, "order_code", logger)
+
+            self.delta_u1 = sub_float(line, 20, 25, device, "delta_u1", logger)
+            self.n1 = sub_int(line, 26, 28, device, "n1", logger)
+            self.n1_prime = sub_int(line, 29, 32, device, "n1_prime", logger)
+            self.u1 = sub_float(line, 33, 38, device, "u1", logger)
+
+            self.delta_u2 = sub_float(line, 39, 44, device, "delta_u2", logger)
+            self.theta = sub_float(line, 45, 50, device, "theta", logger)
+            self.n2 = sub_int(line, 51, 53, device, "n2", logger)
+            self.n2_prime = sub_int(line, 54, 57, device, "n2_prime", logger)
+            self.p = sub_float(line, 58, 63, device, "p", logger)
+            self.regulation_type = sub_str(line, 64, 68, device, "regulation_type", logger)
+        else:
+
+            logger.add_warning("Non canonical line length",
+                               device_class=device,
+                               value=len(line),
+                               expected_value=128)
+
+            chunks = line.split()
+
+            if len(chunks) >= 1:
+                self.node1 = chunks[0]
+
+            if len(chunks) >= 2:
+                self.node2 = chunks[1]
+
+            if len(chunks) >= 3:
+                self.order_code = chunks[2]
+
+            if len(chunks) >= 4:
+                self.delta_u1 = try_float(chunks[3], device, "delta_u1", logger)
+
+            if len(chunks) >= 5:
+                self.n1 = try_int(chunks[4], device, "n1", logger)
+
+            if len(chunks) >= 6:
+                self.n1_prime = try_int(chunks[5], device, "n1_prime", logger)
+
+            if len(chunks) >= 7:
+                self.u1 = try_float(chunks[6], device, "u1", logger)
+
+            if len(chunks) >= 8:
+                self.delta_u2 = try_float(chunks[7], device, "delta_u2", logger)
+
+            if len(chunks) >= 9:
+                self.theta = try_float(chunks[8], device, "theta", logger)
+
+            if len(chunks) >= 10:
+                self.n2 = try_int(chunks[9], device, "n2", logger)
+
+            if len(chunks) >= 11:
+                self.n2_prime = try_int(chunks[10], device, "n2_prime", logger)
+
+            if len(chunks) >= 12:
+                self.p = try_float(chunks[11], device, "p", logger)
+
+            if len(chunks) >= 13:
+                self.regulation_type = chunks[12]
+
+        if self.n1 == 0:
+            self.valid_regulation = False
+
+        if self.n2 == 0:
+            self.valid_regulation = False