VeraGridEngine 5.4.2__tar.gz → 5.4.4__tar.gz

{veragridengine-5.4.2 → veragridengine-5.4.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: VeraGridEngine
-Version: 5.4.2
+Version: 5.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.

{veragridengine-5.4.2 → veragridengine-5.4.4}/VeraGridEngine/Compilers/circuit_to_gslv.py

@@ -21,7 +21,7 @@ from VeraGridEngine.Devices.multi_circuit import MultiCircuit
 import VeraGridEngine.Devices as dev
 from VeraGridEngine.Simulations.PowerFlow.power_flow_options import PowerFlowOptions
 from VeraGridEngine.Simulations.PowerFlow.power_flow_results import PowerFlowResults
-from VeraGridEngine import TapModuleControl, TapPhaseControl
+from VeraGridEngine.enumerations import TapModuleControl, TapPhaseControl
 from VeraGridEngine.enumerations import SolverType
 from VeraGridEngine.DataStructures.numerical_circuit import NumericalCircuit
 

{veragridengine-5.4.2 → veragridengine-5.4.4}/VeraGridEngine/Devices/Parents/branch_parent.py

@@ -6,7 +6,7 @@ from __future__ import annotations
 import numpy as np
 from typing import Tuple, Union, TYPE_CHECKING
 
-from VeraGridEngine import SubObjectType
+from VeraGridEngine.enumerations import SubObjectType
 from VeraGridEngine.basic_structures import Logger
 from VeraGridEngine.Devices.Substation.substation import Substation
 from VeraGridEngine.Devices.Substation.voltage_level import VoltageLevel

{veragridengine-5.4.2 → veragridengine-5.4.4}/VeraGridEngine/IO/cim/cgmes/cgmes_to_veragrid.py

@@ -1841,20 +1841,25 @@ def get_transformer_tap_changers(cgmes_model: CgmesCircuit,
                         target_idtag=winding_id
                     )
 
-                    winding_w_tc.tap_changer.init_from_cgmes(
-                        low=tap_changer.lowStep,
-                        high=tap_changer.highStep,
-                        normal=tap_changer.normalStep,
-                        neutral=tap_changer.neutralStep,
-                        stepVoltageIncrement=tap_changer.stepVoltageIncrement,
-                        step=int(tap_changer.step),
-                        # asymmetry_angle=90,
-                        tc_type=tc_type
-                    )
+                    if winding_w_tc is not None:
+                        winding_w_tc.tap_changer.init_from_cgmes(
+                            low=tap_changer.lowStep,
+                            high=tap_changer.highStep,
+                            normal=tap_changer.normalStep,
+                            neutral=tap_changer.neutralStep,
+                            stepVoltageIncrement=tap_changer.stepVoltageIncrement,
+                            step=int(tap_changer.step),
+                            # asymmetry_angle=90,
+                            tc_type=tc_type
+                        )
 
-                    # SET tap_module and tap_phase from its own TapChanger object
-                    winding_w_tc.tap_module = winding_w_tc.tap_changer.get_tap_module()
-                    winding_w_tc.tap_phase = winding_w_tc.tap_changer.get_tap_phase()
+                        # SET tap_module and tap_phase from its own TapChanger object
+                        winding_w_tc.tap_module = winding_w_tc.tap_changer.get_tap_module()
+                        winding_w_tc.tap_phase = winding_w_tc.tap_changer.get_tap_phase()
+                    else:
+                        logger.add_error("Winding of the tap changer not found",
+                                         device_class="TransformerEnd",
+                                         device=winding_id)
 
                 else:
                     logger.add_error(msg='Transformer not found for TapChanger',

{veragridengine-5.4.2 → veragridengine-5.4.4}/VeraGridEngine/Simulations/LinearFactors/linear_analysis.py

@@ -13,7 +13,7 @@ from typing import Union, List, Dict, Tuple, TYPE_CHECKING
 from scipy.sparse import lil_matrix
 from scipy.sparse.linalg import spsolve as scipy_spsolve
 
-from VeraGridEngine import DeviceType
+from VeraGridEngine.enumerations import DeviceType
 from VeraGridEngine.basic_structures import Logger, Vec, IntVec, CxVec, Mat, ObjVec, CxMat, BoolVec
 from VeraGridEngine.DataStructures.numerical_circuit import NumericalCircuit
 from VeraGridEngine.Devices.Aggregation.contingency_group import ContingencyGroup

{veragridengine-5.4.2 → veragridengine-5.4.4}/VeraGridEngine/Simulations/NodalCapacity/nodal_capacity_ts_driver.py

@@ -231,13 +231,11 @@ class NodalCapacityTimeSeriesDriver(TimeSeriesDriverTemplate):
             # run opf
             res = run_nonlinear_opf(grid=self.grid,
                                     opf_options=self.opf_options,
-                                    pf_options=self.pf_options,
                                     t_idx=t,
                                     # for the first power flow, use the given strategy
                                     # for the successive ones, use the previous solution
-                                    pf_init=self.opf_options.ips_init_with_pf if it == 0 else True,
-                                    Sbus_pf0=self.results.Sbus[it - 1, :] if it > 0 else None,
-                                    voltage_pf0=self.results.voltage[it - 1, :] if it > 0 else None,
+                                    # Sbus_pf0=self.results.Sbus[it - 1, :] if it > 0 else None,
+                                    # voltage_pf0=self.results.voltage[it - 1, :] if it > 0 else None,
                                     optimize_nodal_capacity=True,
                                     nodal_capacity_sign=self.options.nodal_capacity_sign,
                                     capacity_nodes_idx=self.options.capacity_nodes_idx,

{veragridengine-5.4.2 → veragridengine-5.4.4}/VeraGridEngine/Simulations/OPF/Formulations/ac_opf_problem.py

@@ -1306,8 +1306,8 @@ class NonLinearOptimalPfProblem:
                 Hqvmvm = (self.Cdispgen @ diags(mu[- self.n_gen_disp - 2 * self.n_disp_hvdc: b])
                           @ (- 2 * diags(np.power(self.Inom, 2.0)) * self.Cdispgen_t))
             else:
-                Hqpgpg = lil_matrix((self.n_gen_disp, self.n_gen_disp))
-                Hqqgqg = lil_matrix((self.n_gen_disp, self.n_gen_disp))
+                Hqpgpg = lil_matrix((self.n_gen_disp_sh, self.n_gen_disp_sh))
+                Hqqgqg = lil_matrix((self.n_gen_disp_sh, self.n_gen_disp_sh))
                 Hqvmvm = lil_matrix((self.nbus, self.nbus))
 
             Hfvava = 2 * (Sfvava + Sfva.T @ muf_mat @ np.conj(Sfva)).real

{veragridengine-5.4.2 → veragridengine-5.4.4}/VeraGridEngine/Simulations/OPF/NumericalMethods/ac_opf.py

@@ -38,10 +38,7 @@ def remap_original_bus_indices(n_bus, original_bus_idx: Sequence[int]) -> Tuple[
 
 def run_nonlinear_opf(grid: MultiCircuit,
                       opf_options: OptimalPowerFlowOptions,
-                      pf_options: PowerFlowOptions,
                       t_idx: Union[None, int] = None,
-                      Sbus_pf0: Union[CxVec, None] = None,
-                      voltage_pf0: Union[CxVec, None] = None,
                       plot_error: bool = False,
                       optimize_nodal_capacity: bool = False,
                       nodal_capacity_sign: float = 1.0,
@@ -51,10 +48,7 @@ def run_nonlinear_opf(grid: MultiCircuit,
     Run optimal power flow for a MultiCircuit
     :param grid: MultiCircuit
     :param opf_options: OptimalPowerFlowOptions
-    :param pf_options: PowerFlowOptions
     :param t_idx: Time index
-    :param Sbus_pf0: Sbus initial solution
-    :param voltage_pf0: Voltage initial solution
     :param plot_error: Plot the error evolution
     :param optimize_nodal_capacity:
     :param nodal_capacity_sign:
@@ -66,20 +60,15 @@ def run_nonlinear_opf(grid: MultiCircuit,
     # compile the system
     nc = compile_numerical_circuit_at(circuit=grid, t_idx=t_idx, logger=logger)
 
-    if opf_options.ips_init_with_pf:
-        if Sbus_pf0 is None:
-            # run power flow to initialize
-            pf_results = multi_island_pf_nc(nc=nc, options=pf_options)
-            Sbus_pf = pf_results.Sbus
-            voltage_pf = pf_results.voltage
-        else:
-            # pick the passed values
-            Sbus_pf = Sbus_pf0
-            voltage_pf = voltage_pf0
+    if opf_options.ips_init_with_pf and opf_options.acopf_S0 is not None and opf_options.acopf_v0 is not None:
+        # pick the passed values
+        Sbus_pf = opf_options.acopf_S0
+        voltage_pf = opf_options.acopf_v0
     else:
-        # initialize with sensible values
+        # pick the default values
         Sbus_pf = nc.bus_data.installed_power
         voltage_pf = nc.bus_data.Vbus
+        logger.add_error("Initialized with PF, but no PF values were passed")
 
     # split into islands, but considering the HVDC lines as actual links
     islands = nc.split_into_islands(ignore_single_node_islands=True,

{veragridengine-5.4.2 → veragridengine-5.4.4}/VeraGridEngine/Simulations/OPF/opf_driver.py

@@ -235,9 +235,9 @@ class OptimalPowerFlowDriver(TimeSeriesDriverTemplate):
 
             res = run_nonlinear_opf(grid=self.grid,
                                     opf_options=self.options,
-                                    pf_options=self.pf_options,
                                     t_idx=None,
                                     logger=self.logger)
+
             Sbase = self.grid.Sbase
             self.results.voltage = res.V
             self.results.Sbus = res.S * Sbase

{veragridengine-5.4.2 → veragridengine-5.4.4}/VeraGridEngine/Simulations/OPF/opf_options.py

@@ -11,6 +11,7 @@ from VeraGridEngine.Simulations.PowerFlow.power_flow_options import PowerFlowOpt
 from VeraGridEngine.Devices.Aggregation.contingency_group import ContingencyGroup
 from VeraGridEngine.Devices.Aggregation.inter_aggregation_info import InterAggregationInfo
 from VeraGridEngine.Simulations.options_template import OptionsTemplate
+from VeraGridEngine.basic_structures import Vec
 
 
 class OptimalPowerFlowOptions(OptionsTemplate):
@@ -42,6 +43,8 @@ class OptimalPowerFlowOptions(OptionsTemplate):
                  ips_init_with_pf: bool = False,
                  ips_control_q_limits: bool = False,
                  acopf_mode: AcOpfMode = AcOpfMode.ACOPFstd,
+                 acopf_v0: Vec | None = None,
+                 acopf_S0: Vec | None = None,
                  robust: bool = False,):
         """
         Optimal power flow options
@@ -67,6 +70,8 @@ class OptimalPowerFlowOptions(OptionsTemplate):
         :param ips_init_with_pf:
         :param ips_control_q_limits:
         :param acopf_mode:
+        :param acopf_S0: Sbus initial solution
+        :param acopf_v0: Voltage initial solution
         """
         OptionsTemplate.__init__(self, name="Optimal power flow options")
 
@@ -118,6 +123,9 @@ class OptimalPowerFlowOptions(OptionsTemplate):
         self.ips_init_with_pf = ips_init_with_pf
         self.ips_control_q_limits = ips_control_q_limits
 
+        self.acopf_v0 = acopf_v0
+        self.acopf_S0 = acopf_S0
+
         self.register(key="verbose", tpe=int)
         self.register(key="solver", tpe=SolverType)
         self.register(key="time_grouping", tpe=TimeGrouping)
@@ -142,3 +150,6 @@ class OptimalPowerFlowOptions(OptionsTemplate):
         self.register(key="ips_init_with_pf", tpe=bool)
         self.register(key="ips_control_q_limits", tpe=bool)
         self.register(key="robust", tpe=bool)
+
+        self.register(key="acopf_v0", tpe=Vec)
+        self.register(key="acopf_S0", tpe=Vec)

{veragridengine-5.4.2 → veragridengine-5.4.4}/VeraGridEngine/Simulations/OPF/opf_ts_driver.py

@@ -190,13 +190,11 @@ class OptimalPowerFlowTimeSeriesDriver(TimeSeriesDriverTemplate):
                 res = run_nonlinear_opf(
                     grid=self.grid,
                     opf_options=self.options,
-                    pf_options=self.pf_options,
                     t_idx=t,
                     # for the first power flow, use the given strategy
                     # for the successive ones, use the previous solution
-                    pf_init=self.options.ips_init_with_pf if it == 0 else True,
-                    Sbus_pf0=self.results.Sbus[it - 1, :] if it > 0 else None,
-                    voltage_pf0=self.results.voltage[it - 1, :] if it > 0 else None,
+                    # Sbus_pf0=self.results.Sbus[it - 1, :] if it > 0 else None,
+                    # voltage_pf0=self.results.voltage[it - 1, :] if it > 0 else None,
                     logger=self.logger
                 )
                 Sbase = self.grid.Sbase
@@ -386,13 +384,11 @@ class OptimalPowerFlowTimeSeriesDriver(TimeSeriesDriverTemplate):
                     res = run_nonlinear_opf(
                         grid=self.grid,
                         opf_options=self.options,
-                        pf_options=self.pf_options,
                         t_idx=t,
                         # for the first power flow, use the given strategy
                         # for the successive ones, use the previous solution
-                        pf_init=self.options.ips_init_with_pf if it == 0 else True,
-                        Sbus_pf0=self.results.Sbus[it - 1, :] if it > 0 else None,
-                        voltage_pf0=self.results.voltage[it - 1, :] if it > 0 else None,
+                        # Sbus_pf0=self.results.Sbus[it - 1, :] if it > 0 else None,
+                        # voltage_pf0=self.results.voltage[it - 1, :] if it > 0 else None,
                         logger=self.logger
                     )
                     Sbase = self.grid.Sbase

{veragridengine-5.4.2 → veragridengine-5.4.4}/VeraGridEngine/Simulations/PowerFlow/NumericalMethods/newton_raphson_fx.py

@@ -88,7 +88,6 @@ def newton_raphson_fx(problem: PfFormulationTemplate,
                                  value=len(f), expected_value=J.shape[0])
                 return problem.get_solution(elapsed=time.time() - start, iterations=iteration)
 
-
             try:
 
                 # compute update step: J x Δx = Δg
@@ -131,5 +130,4 @@ def newton_raphson_fx(problem: PfFormulationTemplate,
             elif verbose == 1:
                 print(f'It {iteration}, error {error}, converged {converged}')
 
-
     return problem.get_solution(elapsed=time.time() - start, iterations=iteration)

{veragridengine-5.4.2 → veragridengine-5.4.4}/VeraGridEngine/Simulations/PowerFlow/NumericalMethods/powell_fx.py

@@ -105,6 +105,11 @@ def powell_fx(problem: PfFormulationTemplate,
             logger.add_error("Jacobian not square, check the controls!", "Powell")
             return problem.get_solution(elapsed=time.time() - start, iterations=0)
 
+        if J.shape[0] != len(f):
+            logger.add_error("Jacobian and residuals have different sizes!", "Powell",
+                             value=len(f), expected_value=J.shape[0])
+            return problem.get_solution(elapsed=time.time() - start, iterations=0)
+
         g = J.T @ f
 
         iteration = 0
@@ -162,6 +167,11 @@ def powell_fx(problem: PfFormulationTemplate,
                     logger.add_error("Jacobian not square, check the controls!", "Powell")
                     return problem.get_solution(elapsed=time.time() - start, iterations=iteration)
 
+                if J.shape[0] != len(f):
+                    logger.add_error("Jacobian and residuals have different sizes!", "Powell",
+                                     value=len(f), expected_value=J.shape[0])
+                    return problem.get_solution(elapsed=time.time() - start, iterations=iteration)
+
                 g = J.T @ f
                 f_error = f_error_new
 

{veragridengine-5.4.2 → veragridengine-5.4.4}/VeraGridEngine/Simulations/SigmaAnalysis/sigma_analysis_driver.py

@@ -7,7 +7,6 @@ import numba as nb
 from matplotlib import pyplot as plt
 from typing import Union
 
-from VeraGridEngine import BusMode
 from VeraGridEngine.basic_structures import Logger
 from VeraGridEngine.Simulations.PowerFlow.power_flow_options import PowerFlowOptions
 from VeraGridEngine.Simulations.results_table import ResultsTable

{veragridengine-5.4.2 → veragridengine-5.4.4}/VeraGridEngine/Simulations/StateEstimation/pseudo_measurements_augmentation.py

@@ -9,6 +9,8 @@ from VeraGridEngine.enumerations import DeviceType
 class PseudoMeasurement(MeasurementTemplate):
     def __init__(self, value, sigma, api_obj: Bus, name="",
                  idtag = None):
+        # If this has to be injected in DB it has to get a object instance of class Device. In order
+        # to persist it in DB it should be saved in Asset class !
         """
         Parameters
         ----------
@@ -93,8 +95,6 @@ def add_pseudo_measurements(se_input, unobservable_buses, V, Ybus, neighbors,bus
     Extend se_input with pseudo-measurements for unobservable buses.
     neighbors: prebuilt neighbor list per bus
     """
-    # Build reverse lookup: idx -> Bus object
-    idx_to_bus = {idx: bus for bus, idx in bus_dict.items()}
     for bus_idx in unobservable_buses:
         Pi, Qi = compute_power_injection(bus_idx, V, Ybus, neighbors)
 
@@ -110,7 +110,7 @@ def add_pseudo_measurements(se_input, unobservable_buses, V, Ybus, neighbors,bus
             Qi = 0.0  # often reactive load is unknown; can keep 0 or small value
 
         # Get the Bus object for this bus_idx
-        bus_obj = idx_to_bus[bus_idx]
+        bus_obj = bus_dict[bus_idx]
         pm_p = PseudoMeasurement(Pi*Sbase, sigma_pseudo, bus_obj,"pseudo")
         pm_q = PseudoMeasurement(Qi*Sbase, sigma_pseudo, bus_obj, "pseudo",)# converted later to pu in get_measurements
         se_input.p_idx.append(bus_idx)  # or appropriate index mapping

{veragridengine-5.4.2 → veragridengine-5.4.4}/VeraGridEngine/Simulations/StateEstimation/state_stimation_driver.py

@@ -254,6 +254,8 @@ class StateEstimation(DriverTemplate):
             se_input_island = se_input.slice(bus_idx=island.bus_data.original_idx,
                                              branch_idx=island.passive_branch_data.original_idx)
 
+            bus_dict = {i:self.grid.buses[idx] for i, idx in enumerate(island.bus_data.original_idx)}
+
             conn = island.get_connectivity_matrices()
 
             report = StateEstimationConvergenceReport()
@@ -289,7 +291,7 @@ class StateEstimation(DriverTemplate):
                     include_line_measurements_on_both_ends=self.options.include_line_measurements_on_both_ends,
                     logger=self.logger)
                 if unobservable_buses and self.options.add_pseudo_measurements:
-                    se_input_island = add_pseudo_measurements_for_unobservable_buses(bus_dict=nc.bus_dict,
+                    se_input_island = add_pseudo_measurements_for_unobservable_buses(bus_dict=bus_dict,
                                                                                      unobservable_buses=unobservable_buses,
                                                                                      se_input=se_input, V=V,
                                                                                      Ybus=adm.Ybus,
@@ -365,7 +367,7 @@ class StateEstimation(DriverTemplate):
                                                  c_threshold=self.options.c_threshold,
                                                  fixed_slack=self.options.fixed_slack,
                                                  logger=self.logger)
-            elif self.options.solver == SolverType.LU:
+            elif self.options.solver == SolverType.Decoupled_LU:
                 solution = decoupled_state_estimation(nc=island,
                                                       Ybus=adm.Ybus,
                                                       Yf=adm.Yf,

{veragridengine-5.4.2 → veragridengine-5.4.4}/VeraGridEngine/Topology/detect_substations.py

@@ -6,7 +6,7 @@ from __future__ import annotations
 from typing import List, Union, TYPE_CHECKING
 import numpy as np
 import VeraGridEngine.Devices as dev
-from VeraGridEngine import DeviceType
+from VeraGridEngine.enumerations import DeviceType
 from VeraGridEngine.Devices.types import BRANCH_TYPES
 from VeraGridEngine.Topology.topology import find_islands, get_adjacency_matrix
 from VeraGridEngine.basic_structures import IntVec

{veragridengine-5.4.2 → veragridengine-5.4.4}/VeraGridEngine/Utils/ThirdParty/gslv/gslv_activation.py

@@ -6,7 +6,7 @@ from __future__ import annotations
 import os.path
 import warnings
 from VeraGridEngine.IO.file_system import get_create_veragrid_folder
-from VeraGridEngine import TapModuleControl, TapPhaseControl, BusMode
+from VeraGridEngine.enumerations import TapModuleControl, TapPhaseControl, BusMode
 from VeraGridEngine.enumerations import (HvdcControlType, SolverType, TimeGrouping,
                                          ZonalGrouping, MIPSolvers, ContingencyMethod, ContingencyOperationTypes,
                                          BuildStatus, BranchGroupTypes, ConverterControlType)

veragridengine-5.4.4/VeraGridEngine/__init__.py

@@ -0,0 +1,31 @@
+# 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
+
+
+try:
+
+    from VeraGridEngine.enumerations import *
+    from VeraGridEngine.basic_structures import *
+    from VeraGridEngine.Simulations import *
+    from VeraGridEngine.IO import *
+    from VeraGridEngine.Devices import *
+    from VeraGridEngine.DataStructures import *
+    from VeraGridEngine.Topology import *
+    from VeraGridEngine.Compilers import *
+    from VeraGridEngine.IO.file_handler import FileOpen, FileSave, FileSavingOptions
+    from VeraGridEngine.IO.veragrid.remote import (gather_model_as_jsons_for_communication, RemoteInstruction,
+                                                   SimulationTypes, send_json_data, get_certificate_path,
+                                                   get_certificate)
+    from VeraGridEngine.Compilers.circuit_to_data import compile_numerical_circuit_at, NumericalCircuit
+
+    from VeraGridEngine.api import *
+
+    PROPERLY_LOADED_API = True
+except ModuleNotFoundError as e:
+    print("Modules not found :/", e)
+    PROPERLY_LOADED_API = False
+except NameError as e:
+    print("Name not found :/", e)
+    PROPERLY_LOADED_API = False

{veragridengine-5.4.2 → veragridengine-5.4.4}/VeraGridEngine/__version__.py

@@ -6,7 +6,7 @@ import datetime
 _current_year_ = datetime.datetime.now().year
 
 # remember to keep a three-number version!!!
-__VeraGridEngine_VERSION__ = "5.4.2"
+__VeraGridEngine_VERSION__ = "5.4.4"
 
 url = 'https://github.com/SanPen/VeraGrid'
 

veragridengine-5.4.2/VeraGridEngine/__init__.py → veragridengine-5.4.4/VeraGridEngine/api.py

@@ -5,7 +5,8 @@
 
 from __future__ import annotations
 
-# try:
+# NOTE: Do not optimize or remove imports here
+
 from VeraGridEngine.enumerations import *
 from VeraGridEngine.basic_structures import *
 from VeraGridEngine.Simulations import *
@@ -20,16 +21,6 @@ from VeraGridEngine.IO.veragrid.remote import (gather_model_as_jsons_for_communi
 from VeraGridEngine.Compilers.circuit_to_data import compile_numerical_circuit_at, NumericalCircuit
 
 
-# PROPERLY_LOADED_API = True
-# except ModuleNotFoundError as e:
-#     print("Modules not found :/", e)
-#     PROPERLY_LOADED_API = False
-# except NameError as e:
-#     print("Name not found :/", e)
-#     PROPERLY_LOADED_API = False
-
-# if PROPERLY_LOADED_API:
-
 def open_file(filename: Union[str, List[str]]) -> MultiCircuit:
     """
     Open file
@@ -269,25 +260,19 @@ def continuation_power_flow(grid: MultiCircuit,
 
 
 def nonlinear_opf(grid: MultiCircuit,
-                  pf_options: PowerFlowOptions = PowerFlowOptions(),
                   opf_options: OptimalPowerFlowOptions = OptimalPowerFlowOptions(),
-                  plot_error: bool = False,
-                  pf_init: bool = True) -> NonlinearOPFResults:
+                  plot_error: bool = False) -> NonlinearOPFResults:
     """
     Run AC Optimal Power Flow
     :param grid: MultiCircuit instance
-    :param pf_options: Power Flow Options instance (optional)
     :param opf_options: Optimal Power Flow Options instance (optional)
     :param plot_error: Boolean that selects to plot error
-    :param pf_init: Boolean that selects a power-flow initialization of the problem
     :return: AC Optimal Power Flow results
     """
 
     acopf_res = run_nonlinear_opf(grid=grid,
-                                  pf_options=pf_options,
                                   opf_options=opf_options,
-                                  plot_error=plot_error,
-                                  pf_init=pf_init)
+                                  plot_error=plot_error)
 
     return acopf_res
 

{veragridengine-5.4.2 → veragridengine-5.4.4}/VeraGridEngine/enumerations.py

@@ -219,7 +219,7 @@ class SolverType(Enum):
 
     NR = 'Newton Raphson'
     GAUSS = 'Gauss-Seidel'
-    LU = 'Decoupled-LU Decomposition'
+    Decoupled_LU = 'Decoupled-LU Decomposition'
     GN = "Gauss-Newton"
     Linear = 'Linear'
     HELM = 'Holomorphic Embedding'

veragridengine-5.4.2/VeraGridEngine/api.py

@@ -1,6 +0,0 @@
-# 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 import *