VeraGridEngine 6.4.2__tar.gz → 6.4.4__tar.gz

veragridengine-6.4.4/PKG-INFO

@@ -0,0 +1,28 @@
+Metadata-Version: 2.1
+Name: VeraGridEngine
+Version: 6.4.4
+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.
+Author-email: spenate@eroots.tech
+License: MPL2
+Keywords: power systems planning
+Classifier:  Programming Language :: Python :: 3.10
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Provides-Extra: gch5
+
+# VeraGrid 
+This software aims to be a complete platform for power systems research and simulation.)
+
+[Watch the video https](https://youtu.be/SY66WgLGo54)
+[Check out the documentation](https://veragrid.readthedocs.io)
+
+## Installation
+
+pip install veragrid
+
+For more options (including a standalone setup one), follow the
+[installation instructions]( https://veragrid.readthedocs.io/en/latest/getting_started/install.html)
+from the project's [documentation](https://veragrid.readthedocs.io)
+

veragridengine-6.4.4/VeraGridEngine/Compilers/Gslv/Devices/areas.py

@@ -0,0 +1,36 @@
+# 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.Devices.Aggregation.area import Area
+from VeraGridEngine.Compilers.Gslv.activation import pg
+from VeraGridEngine.Devices.multi_circuit import MultiCircuit
+from typing import Dict
+
+def convert_area(area: Area) -> "pg.Area":
+    """
+    
+    :param area:
+    :return:
+    """
+    return pg.Area(idtag=area.idtag, code=str(area.code), name=area.name)
+
+
+def add_areas(circuit: MultiCircuit,
+              gslv_grid: "pg.MultiCircuit") -> Dict[Area, "pg.Area"]:
+    """
+    Add GSLV Areas
+    :param circuit: VeraGrid circuit
+    :param gslv_grid: GSLV Circuit
+    :return: Dictionary [VeraGrid area] -> GSLV Area
+    """
+    d = dict()
+
+    for i, area in enumerate(circuit.areas):
+        elm = convert_area(area)
+        gslv_grid.add_area(elm)
+        d[area] = elm
+
+    return d
+

veragridengine-6.4.4/VeraGridEngine/Compilers/Gslv/Devices/batteries.py

@@ -0,0 +1,138 @@
+# 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 typing import Dict, TYPE_CHECKING
+
+from VeraGridEngine.Compilers.Gslv.activation import pg
+from VeraGridEngine.Compilers.Gslv.common import fill_profile, fill_profile_with_array
+from VeraGridEngine.Devices.Injections.battery import Battery
+from VeraGridEngine.Devices.multi_circuit import MultiCircuit
+from VeraGridEngine.basic_structures import IntVec
+
+if TYPE_CHECKING:
+    from VeraGridEngine.Simulations.OPF.opf_results import OptimalPowerFlowResults
+
+
+def convert_battery(k: int,
+                    elm: Battery,
+                    bus_dict: Dict[str, "pg.Bus"],
+                    n_time: int,
+                    use_time_series: bool,
+                    time_indices: IntVec | None = None,
+                    opf_results: OptimalPowerFlowResults | None = None,
+                    add_three_phase_data: bool = False) -> "pg.Battery":
+    """
+    Convert one VeraGrid battery into one GSLV battery.
+
+    :param k: Battery index.
+    :param elm: VeraGrid battery.
+    :param bus_dict: Bus lookup by VeraGrid id tag.
+    :param n_time: Number of exported time steps.
+    :param use_time_series: Whether the export is time-series based.
+    :param time_indices: Optional time-series selection.
+    :param opf_results: Optional OPF results.
+    :param add_three_phase_data: Export sequence impedances needed by three-phase studies.
+    :return: GSLV battery.
+    """
+    battery_r0: float
+    battery_x0: float
+    battery_r2: float
+    battery_x2: float
+
+    if add_three_phase_data:
+        battery_r0 = float(elm.R0)
+        battery_x0 = float(elm.X0)
+        battery_r2 = float(elm.R2)
+        battery_x2 = float(elm.X2)
+    else:
+        battery_r0 = 1e-20
+        battery_x0 = 1e-20
+        battery_r2 = 1e-20
+        battery_x2 = 1e-20
+
+    gen = pg.Battery(
+        nt=n_time,
+        bus=None if elm.bus is None else bus_dict[elm.bus.idtag],
+        name=elm.name,
+        idtag=elm.idtag,
+        P=elm.P,
+        power_factor=elm.Pf,
+        vset=elm.Vset,
+        max_soc=elm.max_soc,
+        min_soc=elm.min_soc,
+        Qmin=elm.Qmin,
+        Qmax=elm.Qmax,
+        Pmin=elm.Pmin,
+        Pmax=elm.Pmax,
+        Snom=elm.Snom,
+        Enom=elm.Enom,
+        charge_efficiency=elm.charge_efficiency,
+        discharge_efficiency=elm.discharge_efficiency,
+        is_controlled=elm.is_controlled,
+        r0=battery_r0,
+        x0=battery_x0,
+        r2=battery_r2,
+        x2=battery_x2,
+    )
+
+    fill_profile(gen.active, elm.active_prof, use_time_series, time_indices, n_time, elm.active)
+
+    if opf_results is None:
+        fill_profile(gen.P, elm.P_prof, use_time_series, time_indices, n_time, elm.P)
+    else:
+        fill_profile_with_array(
+            gslv_profile=gen.P,
+            arr=opf_results.battery_power[:, k],
+            use_time_series=use_time_series,
+            time_indices=time_indices,
+            n_time=n_time,
+            default_val=elm.P,
+        )
+
+    fill_profile(gen.Q, elm.Q_prof, use_time_series, time_indices, n_time, elm.Q)
+    fill_profile(gen.Vset, elm.Vset_prof, use_time_series, time_indices, n_time, elm.Vset)
+    fill_profile(gen.cost, elm.Cost_prof, use_time_series, time_indices, n_time, elm.Cost)
+    fill_profile(gen.Cost0, elm.Cost0_prof, use_time_series, time_indices, n_time, elm.Cost0)
+    fill_profile(gen.Cost2, elm.Cost2_prof, use_time_series, time_indices, n_time, elm.Cost2)
+
+    return gen
+
+
+def add_battery_data(circuit: MultiCircuit,
+                     gslv_grid: "pg.MultiCircuit",
+                     bus_dict: Dict[str, "pg.Bus"],
+                     time_series: bool,
+                     n_time: int = 1,
+                     time_indices: IntVec | None = None,
+                     opf_results: OptimalPowerFlowResults | None = None,
+                     add_three_phase_data: bool = False) -> None:
+    """
+    Add every VeraGrid battery to the target GSLV grid.
+
+    :param circuit: VeraGrid circuit.
+    :param gslv_grid: GSLV circuit.
+    :param bus_dict: Bus lookup by VeraGrid id tag.
+    :param time_series: Whether the export is time-series based.
+    :param n_time: Number of exported time steps.
+    :param time_indices: Optional time-series selection.
+    :param opf_results: Optional OPF results.
+    :param add_three_phase_data: Export sequence impedances needed by three-phase studies.
+    :return: None.
+    """
+    devices = circuit.get_batteries()
+
+    for k, elm in enumerate(devices):
+        batt = convert_battery(
+            k=k,
+            elm=elm,
+            bus_dict=bus_dict,
+            n_time=n_time,
+            use_time_series=time_series,
+            time_indices=time_indices,
+            opf_results=opf_results,
+            add_three_phase_data=add_three_phase_data,
+        )
+        gslv_grid.add_battery(batt)

veragridengine-6.4.4/VeraGridEngine/Compilers/Gslv/Devices/branch_groups.py

@@ -0,0 +1,44 @@
+# 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.Devices.Aggregation.branch_group import BranchGroup
+from VeraGridEngine.Compilers.Gslv.activation import (
+    group_type_dict,
+    pg,
+)
+from VeraGridEngine.Devices.multi_circuit import MultiCircuit
+from typing import Dict
+
+def convert_branch_group(country: BranchGroup) -> "pg.BranchGroup":
+    """
+
+    :param country:
+    :return:
+    """
+    return pg.BranchGroup(
+        idtag=country.idtag,
+        code=str(country.code),
+        name=country.name,
+        group_type=group_type_dict[country.group_type]
+    )
+
+
+def add_branch_groups(circuit: MultiCircuit,
+                      gslv_grid: "pg.MultiCircuit") -> Dict[BranchGroup, "pg.BranchGroup"]:
+    """
+    Add GSLV countries
+    :param circuit: VeraGrid circuit
+    :param gslv_grid: GSLV Circuit
+    :return: Dictionary [VeraGrid country] -> GSLV country
+    """
+    d = dict()
+
+    for i, branch_group in enumerate(circuit.branch_groups):
+        elm = convert_branch_group(branch_group)
+        gslv_grid.add_branch_group(elm)
+        d[branch_group] = elm
+
+    return d
+

veragridengine-6.4.4/VeraGridEngine/Compilers/Gslv/Devices/buses.py

@@ -0,0 +1,141 @@
+# 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.Devices.Aggregation.area import Area
+from VeraGridEngine.Devices.Aggregation.country import Country
+from VeraGridEngine.Devices.Aggregation.zone import Zone
+from VeraGridEngine.Devices.Substation.bus import Bus
+from VeraGridEngine.Devices.Substation.substation import Substation
+from VeraGridEngine.Devices.Substation.voltage_level import VoltageLevel
+from VeraGridEngine.Compilers.Gslv.activation import pg
+from VeraGridEngine.Compilers.Gslv.common import fill_profile
+from VeraGridEngine.Devices.multi_circuit import MultiCircuit
+from VeraGridEngine.basic_structures import IntVec
+from typing import (
+    Dict,
+    Union,
+)
+
+def convert_bus(elm: Bus, n_time: int,
+                area_dict: Dict[Area, "pg.Area"],
+                zone_dict: Dict[Zone, "pg.Zone"],
+                substation_dict: Dict[Substation, "pg.Substation"],
+                voltage_level_dict: Dict[VoltageLevel, "pg.VoltageLevel"],
+                country_dict: Dict[Country, "pg.Country"],
+                time_indices: IntVec,
+                use_time_series: bool) -> "pg.Bus":
+    """
+
+    :param elm:
+    :param n_time:
+    :param area_dict:
+    :param zone_dict:
+    :param substation_dict:
+    :param voltage_level_dict:
+    :param country_dict:
+    :param time_indices:
+    :param use_time_series:
+    :return:
+    """
+    bus = pg.Bus(nt=n_time,
+                 name=str(elm.name),
+                 idtag=elm.idtag,
+                 code=str(elm.code),
+                 Vnom=elm.Vnom,
+                 vmin=elm.Vmin,
+                 vmax=elm.Vmax,
+                 angle_min=elm.angle_min,
+                 angle_max=elm.angle_max,
+                 # r_fault=elm.r_fault,
+                 # x_fault=elm.x_fault,
+                 active_default=elm.active,
+
+                 is_slack=elm.is_slack,
+                 is_dc=elm.is_dc,
+                 is_internal=elm.internal,
+
+                 area=area_dict.get(elm.area, None),
+                 zone=zone_dict.get(elm.zone, None),
+                 substation=substation_dict.get(elm.substation, None),
+                 voltage_level=voltage_level_dict.get(elm.substation, None),
+                 country=country_dict.get(elm.country, None),
+                 latitude=elm.latitude,
+                 longitude=elm.longitude,
+                 Vm0=elm.Vm0,
+                 Va0=elm.Va0,
+                 )
+
+    fill_profile(gslv_profile=bus.active,
+                 gc_profile=elm.active_prof,
+                 use_time_series=use_time_series,
+                 time_indices=time_indices,
+                 n_time=n_time,
+                 default_val=elm.active)
+    if use_time_series:
+        fill_profile(gslv_profile=bus.Vm0,
+                     gc_profile=elm.Vm0_prof,
+                     use_time_series=use_time_series,
+                     time_indices=time_indices,
+                     n_time=n_time,
+                     default_val=elm.Vm0)
+        fill_profile(gslv_profile=bus.Va0,
+                     gc_profile=elm.Va0_prof,
+                     use_time_series=use_time_series,
+                     time_indices=time_indices,
+                     n_time=n_time,
+                     default_val=elm.Va0)
+
+    return bus
+
+def add_buses(
+        circuit: MultiCircuit,
+        gslv_grid: "pg.MultiCircuit",
+        area_dict: Dict[Area, "pg.Area"],
+        zone_dict: Dict[Zone, "pg.Zone"],
+        substation_dict: Dict[Substation, "pg.Substation"],
+        voltage_level_dict: Dict[VoltageLevel, "pg.VoltageLevel"],
+        country_dict: Dict[Country, "pg.Country"],
+        use_time_series: bool,
+        n_time: int = 1,
+        time_indices: Union[IntVec, None] = None,
+) -> Dict[str, "pg.Bus"]:
+    """
+    Convert the buses to GSLV buses
+    :param circuit: VeraGrid circuit
+    :param gslv_grid: GSLV circuit
+    :param use_time_series: compile the time series from VeraGrid? otherwise, just the snapshot
+    :param n_time: number of time steps
+    :param time_indices: Array of time indices
+    :param area_dict: Area object translation dictionary
+    :param zone_dict: Zone object translation dictionary
+    :param substation_dict: Substation object translation dictionary
+    :param voltage_level_dict: Voltage level object translation dictionary
+    :param country_dict: Country object translation dictionary
+    :return: bus dictionary buses[uuid] -> Bus
+    """
+
+    if time_indices is not None:
+        assert (len(time_indices) == n_time)
+
+    if area_dict is None:
+        area_dict = {elm: k for k, elm in enumerate(circuit.areas)}
+
+    bus_dict: Dict[str, "pg.Bus"] = dict()
+
+    for i, bus in enumerate(circuit.buses):
+        elm = convert_bus(elm=bus, n_time=n_time,
+                          area_dict=area_dict,
+                          zone_dict=zone_dict,
+                          substation_dict=substation_dict,
+                          voltage_level_dict=voltage_level_dict,
+                          country_dict=country_dict,
+                          use_time_series=use_time_series,
+                          time_indices=time_indices)
+
+        gslv_grid.add_bus(elm)
+        bus_dict[bus.idtag] = elm
+
+    return bus_dict
+

veragridengine-6.4.4/VeraGridEngine/Compilers/Gslv/Devices/contingencies.py

@@ -0,0 +1,87 @@
+# 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.Devices.Events.contingency import Contingency
+from VeraGridEngine.Devices.Events.contingency_group import ContingencyGroup
+from VeraGridEngine.Compilers.Gslv.activation import (
+    contingency_ops_type_dict,
+    pg,
+)
+from VeraGridEngine.Devices.multi_circuit import MultiCircuit
+from typing import Dict
+
+def convert_contingency_groups(elm: ContingencyGroup) -> "pg.ContingencyGroup":
+    """
+
+    :param elm:
+    :return:
+    """
+    return pg.ContingencyGroup(idtag=elm.idtag,
+                               code=str(elm.code),
+                               name=elm.name,
+                               category=elm.category)
+
+
+def add_contingency_groups(circuit: MultiCircuit,
+                           gslv_grid: "pg.MultiCircuit") -> Dict[ContingencyGroup, "pg.ContingencyGroup"]:
+    """
+    Add GSLV ContingenciesGroup
+    :param circuit: VeraGrid circuit
+    :param gslv_grid: GSLV Circuit
+    :return: Dictionary [VeraGrid ContingenciesGroup] -> GSLV ContingenciesGroup
+    """
+    d = dict()
+
+    for i, elm in enumerate(circuit.get_contingency_groups()):
+        cg = convert_contingency_groups(elm)
+        gslv_grid.add_contingency_group(cg)
+        d[elm] = cg
+
+    return d
+
+
+def convert_contingencies(elm: Contingency,
+                          n_time: int,
+                          groups_dict: Dict[ContingencyGroup, "pg.ContingencyGroup"]) -> "pg.Contingency":
+    """
+
+    :param elm:
+    :param n_time:
+    :param groups_dict:
+    :return:
+    """
+
+    return pg.Contingency(idtag=elm.idtag,
+                          device_idtag=elm.device_idtag,
+                          name=elm.name,
+                          code=str(elm.code),
+                          prop=contingency_ops_type_dict[elm.prop],
+                          value=elm.value,
+                          group=groups_dict[elm.group])
+
+
+def add_contingencies(circuit: MultiCircuit,
+                      gslv_grid: "pg.MultiCircuit",
+                      n_time: int,
+                      groups_dict: Dict[ContingencyGroup, "pg.ContingencyGroup"], ):
+    """
+    Add GSLV ContingenciesGroup
+    :param circuit: VeraGrid circuit
+    :param gslv_grid: GSLV Circuit
+    :param n_time: number of time steps
+    :param groups_dict: Contingency groups dictionary
+    :return: Dictionary [VeraGrid ContingenciesGroup] -> GSLV ContingenciesGroup
+    """
+    d = dict()
+
+    for i, elm in enumerate(circuit.contingencies):
+        con = convert_contingencies(elm=elm,
+                                    n_time=n_time,
+                                    groups_dict=groups_dict)
+        gslv_grid.add_contingency(con)
+        d[elm] = con
+
+    return d
+

veragridengine-6.4.4/VeraGridEngine/Compilers/Gslv/Devices/controllable_shunts.py

@@ -0,0 +1,158 @@
+# 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 typing import Dict
+
+import numpy as np
+
+from VeraGridEngine.Compilers.Gslv.activation import build_status_dict, pg
+from VeraGridEngine.Compilers.Gslv.common import (
+    apply_three_phase_shunt_data,
+    fill_profile,
+    get_single_three_phase_snapshot_index,
+)
+from VeraGridEngine.Devices.Injections.controllable_shunt import ControllableShunt
+from VeraGridEngine.Devices.multi_circuit import MultiCircuit
+from VeraGridEngine.basic_structures import IntVec
+from VeraGridEngine.enumerations import ShuntControlMode
+
+
+def convert_controllable_shunt(elm: ControllableShunt,
+                               bus_dict: Dict[str, "pg.Bus"],
+                               n_time: int,
+                               use_time_series: bool,
+                               shunt_control_mode_dict: Dict[ShuntControlMode, "pg.ShuntControlMode"],
+                               time_indices: IntVec | None = None,
+                               add_three_phase_data: bool = False) -> "pg.ControllableShunt":
+    """
+    Convert one VeraGrid controllable shunt into one GSLV controllable shunt.
+
+    :param elm: VeraGrid controllable shunt.
+    :param bus_dict: Bus lookup by VeraGrid id tag.
+    :param n_time: Number of exported time steps.
+    :param use_time_series: Whether the export is time-series based.
+    :param shunt_control_mode_dict: Shunt-control enum translator.
+    :param time_indices: Optional time-series selection.
+    :param add_three_phase_data: Export explicit three-phase fields when available.
+    :return: GSLV controllable shunt.
+    """
+    if not isinstance(elm.g_steps, np.ndarray):
+        raise TypeError(f"ControllableShunt.g_steps must be np.ndarray, got {type(elm.g_steps)}")
+    else:
+        pass
+
+    if not isinstance(elm.b_steps, np.ndarray):
+        raise TypeError(f"ControllableShunt.b_steps must be np.ndarray, got {type(elm.b_steps)}")
+    else:
+        pass
+
+    g_steps: np.ndarray = np.asarray(elm.g_steps, dtype=float).reshape(-1)
+    b_steps: np.ndarray = np.asarray(elm.b_steps, dtype=float).reshape(-1)
+
+    number_of_steps: int = max(int(g_steps.size), int(b_steps.size), 1)
+    if g_steps.size == 0:
+        g_steps = np.zeros(number_of_steps, dtype=float)
+    elif b_steps.size not in (0, g_steps.size):
+        raise ValueError(f"ControllableShunt {elm.name} has mismatched step arrays")
+    else:
+        pass
+
+    if b_steps.size == 0:
+        b_steps = np.zeros(number_of_steps, dtype=float)
+    elif g_steps.size != b_steps.size:
+        raise ValueError(f"ControllableShunt {elm.name} has mismatched step arrays")
+    else:
+        pass
+
+    step: int = min(max(int(elm.step), 0), number_of_steps - 1)
+
+    sh = pg.ControllableShunt(
+        nt=n_time,
+        bus=None if elm.bus is None else bus_dict[elm.bus.idtag],
+        name=elm.name,
+        idtag=elm.idtag,
+        code=str(elm.code),
+        number_of_steps=number_of_steps,
+        step=step,
+        g_per_step=0.0,
+        b_per_step=0.0,
+        Cost=elm.Cost,
+        active=elm.active,
+        G=elm.G,
+        B=elm.B,
+        G0=elm.G0,
+        B0=elm.B0,
+        vset=elm.Vset,
+        vmin=elm.Vmin,
+        vmax=elm.Vmax,
+        mttf=elm.mttf,
+        mttr=elm.mttr,
+        capex=elm.capex,
+        opex=elm.opex,
+        control_bus=None if elm.control_bus is None else bus_dict[elm.control_bus.idtag],
+        control_mode=shunt_control_mode_dict[elm.control_mode],
+        build_status=build_status_dict[elm.build_status],
+    )
+
+    sh.g_steps = g_steps.tolist()
+    sh.b_steps = b_steps.tolist()
+
+    if add_three_phase_data:
+        snapshot_time_index: int | None = get_single_three_phase_snapshot_index(
+            use_time_series=use_time_series,
+            time_indices=time_indices,
+            n_time=n_time,
+        )
+        apply_three_phase_shunt_data(gslv_shunt=sh, elm=elm, time_index=snapshot_time_index)
+    else:
+        pass
+
+    fill_profile(sh.active, elm.active_prof, use_time_series, time_indices, n_time, elm.active)
+    fill_profile(sh.G, elm.G_prof, use_time_series, time_indices, n_time, elm.G)
+    fill_profile(sh.B, elm.B_prof, use_time_series, time_indices, n_time, elm.B)
+    fill_profile(sh.cost, elm.Cost_prof, use_time_series, time_indices, n_time, elm.Cost)
+    fill_profile(sh.Vset, elm.Vset_prof, use_time_series, time_indices, n_time, elm.Vset)
+
+    return sh
+
+
+def add_controllable_shunts(circuit: MultiCircuit,
+                            gslv_grid: "pg.MultiCircuit",
+                            bus_dict: Dict[str, "pg.Bus"],
+                            time_series: bool,
+                            n_time: int = 1,
+                            time_indices: IntVec | None = None,
+                            add_three_phase_data: bool = False) -> None:
+    """
+    Add every VeraGrid controllable shunt to the target GSLV grid.
+
+    :param circuit: VeraGrid circuit.
+    :param gslv_grid: GSLV circuit.
+    :param bus_dict: Bus lookup by VeraGrid id tag.
+    :param time_series: Whether the export is time-series based.
+    :param n_time: Number of exported time steps.
+    :param time_indices: Optional time-series selection.
+    :param add_three_phase_data: Export explicit three-phase fields when available.
+    :return: None.
+    """
+    shunt_control_mode_dict: Dict[ShuntControlMode, "pg.ShuntControlMode"] = {
+        ShuntControlMode.Locked: pg.ShuntControlMode.Locked,
+        ShuntControlMode.Continuous: pg.ShuntControlMode.Continuous,
+        ShuntControlMode.Discrete: pg.ShuntControlMode.Discrete,
+    }
+
+    devices = circuit.get_controllable_shunts()
+    for elm in devices:
+        sh = convert_controllable_shunt(
+            elm=elm,
+            bus_dict=bus_dict,
+            n_time=n_time,
+            use_time_series=time_series,
+            time_indices=time_indices,
+            shunt_control_mode_dict=shunt_control_mode_dict,
+            add_three_phase_data=add_three_phase_data,
+        )
+        gslv_grid.add_controllable_shunt(sh)

veragridengine-6.4.4/VeraGridEngine/Compilers/Gslv/Devices/countries.py

@@ -0,0 +1,36 @@
+# 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.Devices.Aggregation.country import Country
+from VeraGridEngine.Compilers.Gslv.activation import pg
+from VeraGridEngine.Devices.multi_circuit import MultiCircuit
+from typing import Dict
+
+def convert_country(country: Country) -> "pg.Country":
+    """
+
+    :param country:
+    :return:
+    """
+    return pg.Country(idtag=country.idtag, code=str(country.code), name=country.name)
+
+
+def add_countries(circuit: MultiCircuit,
+                  gslv_grid: "pg.MultiCircuit") -> Dict[Country, "pg.Country"]:
+    """
+    Add GSLV countries
+    :param circuit: VeraGrid circuit
+    :param gslv_grid: GSLV Circuit
+    :return: Dictionary [VeraGrid country] -> GSLV country
+    """
+    d = dict()
+
+    for i, country in enumerate(circuit.countries):
+        elm = convert_country(country)
+        gslv_grid.add_country(elm)
+        d[country] = elm
+
+    return d
+