distopf 1.1.0.dev3__tar.gz → 1.1.0.dev4__tar.gz

{distopf-1.1.0.dev3 → distopf-1.1.0.dev4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: distopf
-Version: 1.1.0.dev3
+Version: 1.1.0.dev4
 Summary: A package for solving unbalanced three-phase distribution system optimal power flow problems.
 Author: Abodh Poudyal
 Author-email: Nathan Gray <nathan.gray@pnnl.gov>, Rabayet Sadnan <rabayet.sadnan@pnnl.gov>
@@ -127,19 +127,21 @@ case = opf.create_case(opf.CASES_DIR / "csv" / "ieee13")
 result = case.run_enapp(
     area_info=area_info,
     objective="substation_power",
-    parallel=False,
+    parallel=True,
     max_iterations=25,
 )
 ```
 
-Runs made through these methods are recorded by [`record_call()`](src/distopf/utils/call_recorder.py:90). Calling [`PowerFlowResult.save()`](src/distopf/results.py:209) writes `run_config.json`, including the distributed solver and topology, so named-objective runs can be reproduced with [`replay()`](src/distopf/api.py:1140):
+Set `parallel=True` to solve the independent area subproblems with multiprocessing. The coordination iterations themselves remain sequential: each iteration waits for all area solves before exchanging boundary messages. Use `parallel=False` for serial execution or when debugging.
+
+Runs made through these methods are recorded by [`record_call()`](src/distopf/utils/call_recorder.py:90). Calling [`PowerFlowResult.save()`](src/distopf/results.py:209) writes `run_config.json`, including the distributed solver, topology, and `parallel` setting, so named-objective runs can be reproduced with [`replay()`](src/distopf/api.py:1140):
 
 ```python
 result.save("results/ieee13-enapp")
 replayed = opf.replay("results/ieee13-enapp/run_config.json")
 ```
 
-Custom objective callables and solve/iteration callbacks are intentionally marked non-replayable because they cannot be reconstructed from JSON.
+Replay preserves the recorded `parallel` setting for ENAPP and ADMM. Parallel replay requires a normal multiprocessing-capable execution environment; arbitrary custom objective callables and solve/iteration callbacks remain non-replayable because they cannot be reconstructed from JSON.
 
 
 
@@ -168,6 +170,27 @@ Use `formulation="branchflow"`.
 - **Speed**: Slower than linear, but more accurate
 - **Accuracy**: Nonlinear power flow representation
 
+### Pyomo Wrapper — SOCP Relaxation
+The SOCP formulation is a relaxation of the nonlinear BranchFlow model. It uses the same
+Pyomo/IPOPT solve path, but replaces the two branch-current equality constraints with
+inequality constraints. Use `formulation="socp"`.
+
+- **Model**: BranchFlow model with relaxed current constraints
+- **Solver**: IPOPT for continuous problems; MINLP solvers for discrete controls
+- **Use case**: Faster or more robust optimization when exact current equalities are not required
+- **Wrapper**: Pyomo only; it is not available through the matrix wrappers
+
+```python
+import distopf as opf
+
+case = opf.create_case(opf.CASES_DIR / "csv" / "ieee13")
+result = case.run_opf(
+    formulation="socp",
+    objective="loss",
+    solver="ipopt",
+)
+```
+
 #### Continuous Optimization (IPOPT)
 For continuous optimization without discrete controls:
 
@@ -210,7 +233,7 @@ result = case.run_opf(wrapper="matrix_bess", objective="loss")
 #### Wrapper Comparison
 | Feature | Matrix/Matrix BESS | Pyomo  |
 |---------|---|---|
-| Model Type | LinDistFlow (linear) | LinDistFlow or Non-Linear BranchFlow |
+| Model Type | LinDistFlow (linear) | LinDistFlow, BranchFlow, or SOCP-relaxed BranchFlow |
 | Formulation | Matrix-based | Algebraic equations |
 | Solver API | Scipy or CVXPY | Pyomo |
 | Prefered Solver | HiGHs or Clarabel | IPOPT, Gurobi, Knitro |
@@ -228,7 +251,7 @@ DistOPF supports multiple optimization objectives for distribution system OPF:
 | **Substation Power** | `"substation"`, `"substation_power"` | Pyomo, Matrix | Minimize power imported from substation |
 | **Voltage Deviation** | `"voltage_deviation"` | Pyomo | Minimize deviations from nominal voltage (1.0 p.u.) |
 | **Generation Curtailment** | `"curtail"`, `"curtail_min"`, `"curtailment"` | Pyomo | Minimize DER curtailment |
-| **Cost Minimization** | `"cost"`, `"cost_min"` | Pyomo (LinDistFlow, BranchFlow) | Minimize energy procurement cost from swing bus |
+| **Cost Minimization** | `"cost"`, `"cost_min"` | Pyomo (LinDistFlow, BranchFlow, SOCP) | Minimize energy procurement cost from swing bus |
 
 #### Cost Minimization with Price Data
 

{distopf-1.1.0.dev3 → distopf-1.1.0.dev4}/README.md

@@ -103,19 +103,21 @@ case = opf.create_case(opf.CASES_DIR / "csv" / "ieee13")
 result = case.run_enapp(
     area_info=area_info,
     objective="substation_power",
-    parallel=False,
+    parallel=True,
     max_iterations=25,
 )
 ```
 
-Runs made through these methods are recorded by [`record_call()`](src/distopf/utils/call_recorder.py:90). Calling [`PowerFlowResult.save()`](src/distopf/results.py:209) writes `run_config.json`, including the distributed solver and topology, so named-objective runs can be reproduced with [`replay()`](src/distopf/api.py:1140):
+Set `parallel=True` to solve the independent area subproblems with multiprocessing. The coordination iterations themselves remain sequential: each iteration waits for all area solves before exchanging boundary messages. Use `parallel=False` for serial execution or when debugging.
+
+Runs made through these methods are recorded by [`record_call()`](src/distopf/utils/call_recorder.py:90). Calling [`PowerFlowResult.save()`](src/distopf/results.py:209) writes `run_config.json`, including the distributed solver, topology, and `parallel` setting, so named-objective runs can be reproduced with [`replay()`](src/distopf/api.py:1140):
 
 ```python
 result.save("results/ieee13-enapp")
 replayed = opf.replay("results/ieee13-enapp/run_config.json")
 ```
 
-Custom objective callables and solve/iteration callbacks are intentionally marked non-replayable because they cannot be reconstructed from JSON.
+Replay preserves the recorded `parallel` setting for ENAPP and ADMM. Parallel replay requires a normal multiprocessing-capable execution environment; arbitrary custom objective callables and solve/iteration callbacks remain non-replayable because they cannot be reconstructed from JSON.
 
 
 
@@ -144,6 +146,27 @@ Use `formulation="branchflow"`.
 - **Speed**: Slower than linear, but more accurate
 - **Accuracy**: Nonlinear power flow representation
 
+### Pyomo Wrapper — SOCP Relaxation
+The SOCP formulation is a relaxation of the nonlinear BranchFlow model. It uses the same
+Pyomo/IPOPT solve path, but replaces the two branch-current equality constraints with
+inequality constraints. Use `formulation="socp"`.
+
+- **Model**: BranchFlow model with relaxed current constraints
+- **Solver**: IPOPT for continuous problems; MINLP solvers for discrete controls
+- **Use case**: Faster or more robust optimization when exact current equalities are not required
+- **Wrapper**: Pyomo only; it is not available through the matrix wrappers
+
+```python
+import distopf as opf
+
+case = opf.create_case(opf.CASES_DIR / "csv" / "ieee13")
+result = case.run_opf(
+    formulation="socp",
+    objective="loss",
+    solver="ipopt",
+)
+```
+
 #### Continuous Optimization (IPOPT)
 For continuous optimization without discrete controls:
 
@@ -186,7 +209,7 @@ result = case.run_opf(wrapper="matrix_bess", objective="loss")
 #### Wrapper Comparison
 | Feature | Matrix/Matrix BESS | Pyomo  |
 |---------|---|---|
-| Model Type | LinDistFlow (linear) | LinDistFlow or Non-Linear BranchFlow |
+| Model Type | LinDistFlow (linear) | LinDistFlow, BranchFlow, or SOCP-relaxed BranchFlow |
 | Formulation | Matrix-based | Algebraic equations |
 | Solver API | Scipy or CVXPY | Pyomo |
 | Prefered Solver | HiGHs or Clarabel | IPOPT, Gurobi, Knitro |
@@ -204,7 +227,7 @@ DistOPF supports multiple optimization objectives for distribution system OPF:
 | **Substation Power** | `"substation"`, `"substation_power"` | Pyomo, Matrix | Minimize power imported from substation |
 | **Voltage Deviation** | `"voltage_deviation"` | Pyomo | Minimize deviations from nominal voltage (1.0 p.u.) |
 | **Generation Curtailment** | `"curtail"`, `"curtail_min"`, `"curtailment"` | Pyomo | Minimize DER curtailment |
-| **Cost Minimization** | `"cost"`, `"cost_min"` | Pyomo (LinDistFlow, BranchFlow) | Minimize energy procurement cost from swing bus |
+| **Cost Minimization** | `"cost"`, `"cost_min"` | Pyomo (LinDistFlow, BranchFlow, SOCP) | Minimize energy procurement cost from swing bus |
 
 #### Cost Minimization with Price Data
 

{distopf-1.1.0.dev3 → distopf-1.1.0.dev4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "distopf"
-version = "1.1.0.dev3"
+version = "1.1.0.dev4"
 description = "A package for solving unbalanced three-phase distribution system optimal power flow problems."
 readme = "README.md"
 authors = [

{distopf-1.1.0.dev3 → distopf-1.1.0.dev4}/src/distopf/api.py

@@ -59,6 +59,12 @@ _FORMULATION_REGISTRY: dict[str, dict] = {
         "model_type": "branchflow",
         "compatible_wrappers": ["pyomo"],
     },
+    # Pyomo SOCP relaxation of BranchFlow (NLP/IPOPT path)
+    "socp": {
+        "default_wrapper": "pyomo",
+        "model_type": "socp",
+        "compatible_wrappers": ["pyomo"],
+    },
     # LinDistFlow — supported by both pyomo (default) and matrix
     "lindist": {
         "default_wrapper": "pyomo",
@@ -500,13 +506,14 @@ class Case:
             Solver wrapper to use:
             - "matrix": CVXPY/CLARABEL (fast, convex problems only)
             - "matrix_bess": Multi-period matrix model (supports batteries, schedules)
-            - "pyomo": Pyomo/IPOPT (NLP-capable, supports lindist and branchflow)
+            - "pyomo": Pyomo/IPOPT (NLP-capable, supports lindist, branchflow, and socp)
             - None: Auto-selected from ``formulation``, or defaults to "pyomo"
         formulation : str, optional
             Math formulation to use. Auto-selects the appropriate wrapper when
             ``wrapper`` is not specified. Options:
             - "lindist": Linear DistFlow (pyomo default; also in matrix)
             - "branchflow": Nonlinear BranchFlow (pyomo + IPOPT/MINLP)
+            - "socp": SOCP relaxation of BranchFlow (pyomo + IPOPT/MINLP)
             - "lindist_cap_mi": LinDist + capacitor MILP (matrix)
             - "lindist_reg_mi": LinDist + regulator MILP (matrix)
             - "lindist_cap_reg_mi": LinDist + capacitor+regulator MILP (matrix)
@@ -1244,7 +1251,6 @@ def replay(run_config_path: Path | str):
                 "Distributed replay does not support solve_callback or "
                 "iteration_callback"
             )
-        arguments["parallel"] = False
     return getattr(case, method)(**arguments)
 
 

{distopf-1.1.0.dev3 → distopf-1.1.0.dev4}/src/distopf/pyomo_models/constraints_nlp.py

@@ -1163,6 +1163,25 @@ def add_current_constraint1(m: LindistModelProtocol) -> None:
 
     m.current_constraint = pyo.Constraint(m.branch_phase_set, m.time_set, rule=_rule1)
 
+def add_current_constraint1_relaxed(m: LindistModelProtocol) -> None:
+    def _rule1(m: LindistModelProtocol, fb, tb, phases, t):
+        ph = _parse_phases(phases)[0]
+        # Use v2_reg for regulator branches
+        if (fb, tb, ph) in m.reg_phase_set:
+            return (
+                m.p_flow[fb, tb, ph, t] ** 2 + m.q_flow[fb, tb, ph, t] ** 2
+                <= m.v2_reg[fb, tb, ph, t] * m.l_flow[fb, tb, ph + ph, t]
+            )
+        fb_ph = getattr(m, "primary_phase_map", {}).get((fb, tb))
+        if fb_ph is None:
+            fb_ph = ph
+        return (
+            m.p_flow[fb, tb, ph, t] ** 2 + m.q_flow[fb, tb, ph, t] ** 2
+            <= m.v2[fb, fb_ph, t] * m.l_flow[fb, tb, ph + ph, t]
+        )
+
+    m.current_constraint = pyo.Constraint(m.branch_phase_set, m.time_set, rule=_rule1)
+
 
 def add_current_constraint1_downstream_power(m: LindistModelProtocol) -> None:
     def _rule1(m: LindistModelProtocol, fb, tb, phases, t):
@@ -1216,6 +1235,7 @@ def add_nlp_constraints(
     reg_tap_change_limit: int | None = None,
     free_swing_voltage: bool = False,
     free_boundary_loads: bool = False,
+    socp_relaxation: bool = False,
 ) -> None:
     """
     Add all constraints for the nonlinear BranchFlow model.
@@ -1304,5 +1324,9 @@ def add_nlp_constraints(
         add_circular_battery_constraints_pq_control(m)
 
     # Current constraints
-    add_current_constraint1(m)
-    add_current_constraint2(m)
+    if socp_relaxation:
+        add_current_constraint1_relaxed(m)
+        add_current_constraint2_relaxed(m)
+    else:
+        add_current_constraint1(m)
+        add_current_constraint2(m)

{distopf-1.1.0.dev3 → distopf-1.1.0.dev4}/src/distopf/wrappers/pyomo_wrapper.py

@@ -1,7 +1,7 @@
 """Pyomo wrapper for OPF (IPOPT solver).
 
-Supports both LinDistFlow (linear) and BranchFlow (nonlinear) models
-via the `model_type` parameter.
+Supports LinDistFlow plus the nonlinear BranchFlow and SOCP-relaxed
+BranchFlow models via the `model_type` parameter.
 """
 
 from __future__ import annotations
@@ -18,9 +18,10 @@ if TYPE_CHECKING:
 class PyomoWrapper(Wrapper):
     """Pyomo/IPOPT wrapper for OPF optimization.
 
-    Supports two model types:
+    Supports three model types:
     - "lindist" (default): LinDistFlow linear approximation
     - "branchflow": Nonlinear BranchFlow model (NLP)
+    - "socp": SOCP relaxation of the BranchFlow model
     """
 
     def solve(
@@ -47,16 +48,18 @@ class PyomoWrapper(Wrapper):
         **kwargs
             Additional options:
             - model_type : str, default "lindist"
-                "lindist" for LinDistFlow, "branchflow" for nonlinear BranchFlow.
+                "lindist" for LinDistFlow, "branchflow" for nonlinear BranchFlow,
+                or "socp" for its SOCP relaxation.
             - circular_constraints : bool
-                Use circular (quadratic) constraints. Default False for lindist, True for branchflow.
+                Use circular (quadratic) constraints. Default False for lindist,
+                True for branchflow and socp.
             - thermal_constraints : bool, default False
                 Add thermal limit constraints on branch power flows.
             - equality_only : bool, default False (lindist only)
                 Only add equality constraints (power flow, voltage drop).
             - reg_tap_change_limit : int or None (lindist only)
                 Max tap change per timestep (only if control_regulators=True)
-            - initialize : str or None (branchflow only)
+            - initialize : str or None (branchflow/socp only)
                 Warm-start strategy: 'fbs' to initialize from FBS results.
             - solver : str, default 'ipopt'
                 Solver to use. 'ipopt' for continuous, 'bonmin'/'couenne' for MINLP.
@@ -72,12 +75,13 @@ class PyomoWrapper(Wrapper):
 
         model_type = kwargs.pop("model_type", "lindist")
 
-        if model_type == "branchflow":
+        if model_type in ("branchflow", "socp"):
             return self._solve_branchflow(
                 objective=objective,
                 control_regulators=control_regulators,
                 control_capacitors=control_capacitors,
                 raw_result=raw_result,
+                socp_relaxation=model_type == "socp",
                 **kwargs,
             )
         return self._solve_lindist(
@@ -209,12 +213,13 @@ class PyomoWrapper(Wrapper):
         raw_result,
         **kwargs,
     ):
-        """Solve using nonlinear BranchFlow model."""
+        """Solve using nonlinear BranchFlow or its SOCP relaxation."""
         from distopf.pyomo_models.nl_branchflow import create_nl_branchflow_model
         from distopf.pyomo_models.constraints_nlp import add_nlp_constraints
         from distopf.pyomo_models.solvers import solve
         import pyomo.environ as pyo  # type: ignore[import-untyped]
 
+        socp_relaxation = kwargs.pop("socp_relaxation", False)
         circular_constraints = kwargs.pop("circular_constraints", True)
         thermal_constraints = kwargs.pop("thermal_constraints", False)
         initialize = kwargs.pop("initialize", "fbs")
@@ -233,8 +238,9 @@ class PyomoWrapper(Wrapper):
         )
         if (control_regulators or control_capacitors) and solver_name == "ipopt":
             raise ValueError(
-                "Discrete controls (control_regulators/control_capacitors) require a MINLP solver. "
-                "Use solver='bonmin' or solver='couenne', or disable discrete controls."
+                "Discrete controls (control_regulators/control_capacitors) "
+                "require a MINLP solver. Use solver='bonmin' or "
+                "solver='couenne', or disable discrete controls."
             )
 
         self.model = create_nl_branchflow_model(self.case)
@@ -245,6 +251,7 @@ class PyomoWrapper(Wrapper):
             thermal_constraints=thermal_constraints,
             control_regulators=control_regulators,
             control_capacitors=control_capacitors,
+            socp_relaxation=socp_relaxation,
             free_swing_voltage=free_swing_voltage,
             free_boundary_loads=free_boundary_loads,
         )
@@ -500,8 +507,12 @@ class PyomoWrapper(Wrapper):
             "curtail": objectives.generation_curtailment_objective_rule,
             "curtail_min": objectives.generation_curtailment_objective_rule,
             "curtailment": objectives.generation_curtailment_objective_rule,
-            "generation_cost_substation_penalty": objectives.generation_cost_with_substation_quadratic_penalty_objective_rule,
-            "gen_cost_substation_penalty": objectives.generation_cost_with_substation_quadratic_penalty_objective_rule,
+            "generation_cost_substation_penalty": (
+                objectives.generation_cost_with_substation_quadratic_penalty_objective_rule
+            ),
+            "gen_cost_substation_penalty": (
+                objectives.generation_cost_with_substation_quadratic_penalty_objective_rule
+            ),
             "cost": objectives.cost_minimization_rule,
             "cost_min": objectives.cost_minimization_rule,
         }

{distopf-1.1.0.dev3 → distopf-1.1.0.dev4}/tests/test_distributed_api.py

@@ -54,7 +54,7 @@ def test_admm_scaled_option_is_recorded_and_replayed(tmp_path):
         area_info=AREA_INFO,
         objective="substation_power",
         scaled=False,
-        parallel=False,
+        parallel=True,
         max_iterations=1,
         control_regulators=False,
         solver="ipopt",
@@ -63,16 +63,19 @@ def test_admm_scaled_option_is_recorded_and_replayed(tmp_path):
 
     config = json.loads((tmp_path / "run_config.json").read_text())
     assert config["call"]["arguments"]["scaled"] is False
+    assert config["call"]["arguments"]["parallel"] is True
 
     replayed = opf.replay(tmp_path / "run_config.json")
     assert replayed.metadata["call"]["arguments"]["scaled"] is False
+    assert replayed.metadata["call"]["arguments"]["parallel"] is True
+    assert replayed.raw_result["admm_parallel_used"] is True
 
 
 def test_enapp_save_and_replay(tmp_path):
     result = _case().run_enapp(
         area_info=AREA_INFO,
         objective="substation_power",
-        parallel=False,
+        parallel=True,
         max_iterations=1,
         control_regulators=False,
         solver="ipopt",
@@ -82,12 +85,15 @@ def test_enapp_save_and_replay(tmp_path):
     config = json.loads((tmp_path / "run_config.json").read_text())
     assert config["call"]["method"] == "run_enapp"
     assert config["call"]["replayable"] is True
+    assert config["call"]["arguments"]["parallel"] is True
     assert config["distributed"]["solver"] == "enapp"
     assert config["distributed"]["area_info"] == AREA_INFO
 
     replayed = opf.replay(tmp_path / "run_config.json")
     assert replayed.metadata["distributed_solver"] == "enapp"
     assert replayed.metadata["area_info"] == AREA_INFO
+    assert replayed.metadata["call"]["arguments"]["parallel"] is True
+    assert replayed.raw_result["enapp_parallel_used"] is True
 
 
 def test_distributed_callbacks_are_not_replayable(tmp_path):

{distopf-1.1.0.dev3 → distopf-1.1.0.dev4}/tests/test_nlp_backend.py

@@ -16,10 +16,25 @@ def small_case():
 
 
 class TestNlpWrapperSelection:
-    """Test that formulation='branchflow' is properly registered and selectable."""
+    """Test that nonlinear Pyomo formulations are properly registered and selectable."""
+
+    def test_formulation_socp_routes_to_pyomo(self):
+        """SOCP formulation should select Pyomo and preserve its model type."""
+        from distopf.api import _resolve_wrapper
+
+        wrapper_cls, extra_kwargs = _resolve_wrapper(None, "socp")
+        assert wrapper_cls is PyomoWrapper
+        assert extra_kwargs == {"model_type": "socp"}
+
+    def test_formulation_socp_rejects_matrix_wrapper(self):
+        """SOCP is only implemented by the Pyomo wrapper."""
+        from distopf.api import _resolve_wrapper
+
+        with pytest.raises(ValueError, match="not compatible"):
+            _resolve_wrapper("matrix", "socp")
 
     def test_formulation_branchflow_routes_to_pyomo(self):
-        """Test that 'branchflow' formulation resolves to PyomoWrapper with model_type."""
+        """BranchFlow formulation resolves to PyomoWrapper with model_type."""
         from distopf.api import _resolve_wrapper
 
         wrapper_cls, extra_kwargs = _resolve_wrapper(None, "branchflow")
@@ -57,6 +72,19 @@ class TestNlpModelCreation:
         assert hasattr(model, "power_balance_q")
         assert hasattr(model, "voltage_drop")
 
+    def test_add_nlp_constraints_socp_relaxes_current_constraints(self):
+        """SOCP mode should attach both relaxed current constraint families."""
+        # Use a multiphase case because the pairwise current constraint set is
+        # empty for the one-phase small_case fixture.
+        case = opf.create_case(opf.CASES_DIR / "csv" / "ieee13")
+        model = create_nl_branchflow_model(case)
+        add_nlp_constraints(model, socp_relaxation=True)
+
+        current = next(iter(model.current_constraint.values()))
+        current_sqr = next(iter(model.current_sqr_constraint.values()))
+        assert current.equality is False
+        assert current_sqr.equality is False
+
     def test_add_nlp_constraints_with_discrete_controls(self, small_case):
         """Test that discrete control constraints can be added."""
         model = create_nl_branchflow_model(
@@ -135,7 +163,23 @@ class TestNlpBackendSolverValidation:
 
 
 class TestNlpIntegration:
-    """Integration tests for branchflow formulation with Case API."""
+    """Integration tests for nonlinear formulations with the Case API."""
+
+    def test_case_run_opf_with_socp_formulation_builds_nlp_path(
+        self, small_case, monkeypatch
+    ):
+        """Case API should route SOCP to the nonlinear Pyomo path."""
+        calls = {}
+
+        def fake_solve(self, **kwargs):
+            calls.update(kwargs)
+            return object()
+
+        monkeypatch.setattr(PyomoWrapper, "solve", fake_solve)
+        result = small_case.run_opf(formulation="socp", raw_result=True)
+
+        assert result is not None
+        assert calls["model_type"] == "socp"
 
     def test_case_run_opf_with_branchflow_formulation(self, small_case):
         """Test that Case.run_opf() accepts formulation='branchflow'."""
@@ -208,7 +252,7 @@ class TestNlpDecomposedBoundaries:
         FBS(decomposed_cases["area4"])
 
     def test_case_run_opf_branchflow_with_initialization(self, small_case):
-        """Test that Case.run_opf() with formulation='branchflow' accepts initialize flag."""
+        """Case.run_opf() with BranchFlow accepts the initialize flag."""
         try:
             result = small_case.run_opf(
                 formulation="branchflow", initialize="fbs", raw_result=False