4pace 0.1.0a0__tar.gz

4pace-0.1.0a0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 daniel-sakdinun
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

4pace-0.1.0a0/PKG-INFO

@@ -0,0 +1,59 @@
+Metadata-Version: 2.4
+Name: 4pace
+Version: 0.1.0a0
+Summary: Four-Quadrant Power Analysis & Computational Engine
+Author-email: daniel-sakdinun <sakdinun.thewana@gmail.com>
+Project-URL: Homepage, https://github.com/daniel-sakdinun/4PACE.git
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: networkx
+Requires-Dist: pyyaml
+Dynamic: license-file
+
+# ⚡ Four-Quadrant Power Analysis & Computational Engine (4PACE)
+
+[![Status](https://img.shields.io/badge/Status-Early%20Access-orange.svg)]()
+[![Python](https://img.shields.io/badge/Python-3.10+-blue.svg)](https://www.python.org/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+> **⚠️ Early Access Notice**
+> 
+> This project is currently in **Early Access (Pre-v1.0.0)**. While the core engine is functional and capable of solving complex power flow and optimization problems, it is still undergoing significant development. Features may change, and bug reports or feedback are highly encouraged to help reach the stable v1.0.0 release.
+
+4PACE is a high-precision Power System Optimization Engine designed for analyzing and determining the most efficient operating points for electrical grids. Developed entirely in Python using only core scientific libraries, it ensures maximum computational efficiency and provides the flexibility needed to scale capabilities for modern grid demands.
+
+## 🧐 Why "4PACE"?
+
+The name 4PACE reflects the core pillars of this project:
+* **4-Quadrant:** The ability to simulate electrical equipment behavior across all four quadrants of active and reactive power, whether operating as a Generator, Motor, or Condenser.
+* **Power Analysis:** Comprehensive steady-state analysis powered by a robust Newton-Raphson solver.
+* **Computational** Engine: Driven by the mathematical prowess of NumPy and SciPy to ensure rapid numerical convergence.
+
+## ✨ Key Features
+
+* **Network Topology Management:** Built on top of `networkx` for robust and intuitive graph-based grid modeling.
+* **Steady-State Analysis:** Accurate **Newton-Raphson Power Flow** algorithm for evaluating grid voltage and power distribution.
+* **Optimal Power Flow (OPF):**
+  * **AC OPF:** Full non-linear optimization considering $I^2R$ losses, voltage limits, reactive power (Q), and branch flow limits ($S_{max}$).
+* **Economic Dispatch:** Lambda iteration method for minimizing generation fuel costs.
+* **Advanced Equipment Models:**
+  * **Synchronous Machines:** Supports both Generator and Motor modes with PQ limits.
+  * **Branch Models:** Pi-model Transmission Lines and Off-nominal Tap / Phase-shifting Transformers.
+  * **Loads:** Supports Constant Power (PQ), Constant Current (I), and Constant Impedance (Z) models.
+* **Human-Readable Config:** Effortlessly load entire grid topologies via `YAML` without hardcoding Python scripts.
+
+## 📦 Installation
+
+Clone this repository and install the required dependencies. This engine is intentionally kept lightweight and relies only on core scientific libraries.
+
+```bash
+git clone https://github.com/yourusername/4PACE.git
+cd 4PACE
+pip install -r requirements.txt

4pace-0.1.0a0/README.md

@@ -0,0 +1,40 @@
+# ⚡ Four-Quadrant Power Analysis & Computational Engine (4PACE)
+
+[![Status](https://img.shields.io/badge/Status-Early%20Access-orange.svg)]()
+[![Python](https://img.shields.io/badge/Python-3.10+-blue.svg)](https://www.python.org/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+> **⚠️ Early Access Notice**
+> 
+> This project is currently in **Early Access (Pre-v1.0.0)**. While the core engine is functional and capable of solving complex power flow and optimization problems, it is still undergoing significant development. Features may change, and bug reports or feedback are highly encouraged to help reach the stable v1.0.0 release.
+
+4PACE is a high-precision Power System Optimization Engine designed for analyzing and determining the most efficient operating points for electrical grids. Developed entirely in Python using only core scientific libraries, it ensures maximum computational efficiency and provides the flexibility needed to scale capabilities for modern grid demands.
+
+## 🧐 Why "4PACE"?
+
+The name 4PACE reflects the core pillars of this project:
+* **4-Quadrant:** The ability to simulate electrical equipment behavior across all four quadrants of active and reactive power, whether operating as a Generator, Motor, or Condenser.
+* **Power Analysis:** Comprehensive steady-state analysis powered by a robust Newton-Raphson solver.
+* **Computational** Engine: Driven by the mathematical prowess of NumPy and SciPy to ensure rapid numerical convergence.
+
+## ✨ Key Features
+
+* **Network Topology Management:** Built on top of `networkx` for robust and intuitive graph-based grid modeling.
+* **Steady-State Analysis:** Accurate **Newton-Raphson Power Flow** algorithm for evaluating grid voltage and power distribution.
+* **Optimal Power Flow (OPF):**
+  * **AC OPF:** Full non-linear optimization considering $I^2R$ losses, voltage limits, reactive power (Q), and branch flow limits ($S_{max}$).
+* **Economic Dispatch:** Lambda iteration method for minimizing generation fuel costs.
+* **Advanced Equipment Models:**
+  * **Synchronous Machines:** Supports both Generator and Motor modes with PQ limits.
+  * **Branch Models:** Pi-model Transmission Lines and Off-nominal Tap / Phase-shifting Transformers.
+  * **Loads:** Supports Constant Power (PQ), Constant Current (I), and Constant Impedance (Z) models.
+* **Human-Readable Config:** Effortlessly load entire grid topologies via `YAML` without hardcoding Python scripts.
+
+## 📦 Installation
+
+Clone this repository and install the required dependencies. This engine is intentionally kept lightweight and relies only on core scientific libraries.
+
+```bash
+git clone https://github.com/yourusername/4PACE.git
+cd 4PACE
+pip install -r requirements.txt

4pace-0.1.0a0/pyproject.toml

@@ -0,0 +1,28 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "4pace"
+version = "0.1.0-alpha"
+authors = [
+  { name="daniel-sakdinun", email="sakdinun.thewana@gmail.com" },
+]
+description = "Four-Quadrant Power Analysis & Computational Engine"
+readme = "README.md"
+requires-python = ">=3.10"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Topic :: Scientific/Engineering",
+]
+dependencies = [
+    "numpy",
+    "scipy",
+    "networkx",
+    "pyyaml",
+]
+
+[project.urls]
+"Homepage" = "https://github.com/daniel-sakdinun/4PACE.git"

4pace-0.1.0a0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

4pace-0.1.0a0/src/4pace.egg-info/PKG-INFO

@@ -0,0 +1,59 @@
+Metadata-Version: 2.4
+Name: 4pace
+Version: 0.1.0a0
+Summary: Four-Quadrant Power Analysis & Computational Engine
+Author-email: daniel-sakdinun <sakdinun.thewana@gmail.com>
+Project-URL: Homepage, https://github.com/daniel-sakdinun/4PACE.git
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: networkx
+Requires-Dist: pyyaml
+Dynamic: license-file
+
+# ⚡ Four-Quadrant Power Analysis & Computational Engine (4PACE)
+
+[![Status](https://img.shields.io/badge/Status-Early%20Access-orange.svg)]()
+[![Python](https://img.shields.io/badge/Python-3.10+-blue.svg)](https://www.python.org/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+> **⚠️ Early Access Notice**
+> 
+> This project is currently in **Early Access (Pre-v1.0.0)**. While the core engine is functional and capable of solving complex power flow and optimization problems, it is still undergoing significant development. Features may change, and bug reports or feedback are highly encouraged to help reach the stable v1.0.0 release.
+
+4PACE is a high-precision Power System Optimization Engine designed for analyzing and determining the most efficient operating points for electrical grids. Developed entirely in Python using only core scientific libraries, it ensures maximum computational efficiency and provides the flexibility needed to scale capabilities for modern grid demands.
+
+## 🧐 Why "4PACE"?
+
+The name 4PACE reflects the core pillars of this project:
+* **4-Quadrant:** The ability to simulate electrical equipment behavior across all four quadrants of active and reactive power, whether operating as a Generator, Motor, or Condenser.
+* **Power Analysis:** Comprehensive steady-state analysis powered by a robust Newton-Raphson solver.
+* **Computational** Engine: Driven by the mathematical prowess of NumPy and SciPy to ensure rapid numerical convergence.
+
+## ✨ Key Features
+
+* **Network Topology Management:** Built on top of `networkx` for robust and intuitive graph-based grid modeling.
+* **Steady-State Analysis:** Accurate **Newton-Raphson Power Flow** algorithm for evaluating grid voltage and power distribution.
+* **Optimal Power Flow (OPF):**
+  * **AC OPF:** Full non-linear optimization considering $I^2R$ losses, voltage limits, reactive power (Q), and branch flow limits ($S_{max}$).
+* **Economic Dispatch:** Lambda iteration method for minimizing generation fuel costs.
+* **Advanced Equipment Models:**
+  * **Synchronous Machines:** Supports both Generator and Motor modes with PQ limits.
+  * **Branch Models:** Pi-model Transmission Lines and Off-nominal Tap / Phase-shifting Transformers.
+  * **Loads:** Supports Constant Power (PQ), Constant Current (I), and Constant Impedance (Z) models.
+* **Human-Readable Config:** Effortlessly load entire grid topologies via `YAML` without hardcoding Python scripts.
+
+## 📦 Installation
+
+Clone this repository and install the required dependencies. This engine is intentionally kept lightweight and relies only on core scientific libraries.
+
+```bash
+git clone https://github.com/yourusername/4PACE.git
+cd 4PACE
+pip install -r requirements.txt

4pace-0.1.0a0/src/4pace.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE
+README.md
+pyproject.toml
+src/4pace.egg-info/PKG-INFO
+src/4pace.egg-info/SOURCES.txt
+src/4pace.egg-info/dependency_links.txt
+src/4pace.egg-info/requires.txt
+src/4pace.egg-info/top_level.txt
+src/fourpace/__init__.py
+src/fourpace/model.py
+src/fourpace/psys.py

4pace-0.1.0a0/src/4pace.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

4pace-0.1.0a0/src/4pace.egg-info/requires.txt

@@ -0,0 +1,4 @@
+numpy
+scipy
+networkx
+pyyaml

4pace-0.1.0a0/src/4pace.egg-info/top_level.txt

@@ -0,0 +1 @@
+fourpace

4pace-0.1.0a0/src/fourpace/model.py

@@ -0,0 +1,156 @@
+from abc import ABC, abstractmethod
+import numpy as np
+
+class BusComponent(ABC):
+    def __init__(self, name: str, P: float = 0.0, Q: float = 0.0, R: float = 0.0, X: float = 0.0):
+        self.name = name
+        self.P = P
+        self.Q = Q
+        
+        self.Z = complex(R, X)
+
+    @property
+    def S(self) -> complex:
+        """Complex Power (S)"""
+        return complex(self.P, self.Q)
+
+    @abstractmethod
+    def cost(self) -> float:
+        pass
+    
+    @abstractmethod
+    def incremental_cost(self) -> float:
+        pass
+
+class BranchComponent(ABC):
+    def __init__(self, name: str, R: float, X: float, S_max: float | None = None):
+        self.name = name
+        self.R = R
+        self.X = X
+        self.S_max = S_max
+        
+        self.Z = complex(R, X)
+        self.Y = 1 / self.Z if self.Z != 0 else 0j
+
+class SynchronousMachine(BusComponent):
+    def __init__(self, name: str, P: float = 0.0, Q: float = 0.0,
+                 a: float = 0.0, b: float = 0.0, c: float= 0.0,
+                 Pmin: float = 0.0, Pmax: float | None = None, 
+                 Qmin: float | None = None, Qmax: float | None = None,
+                 S_rated: float | None = None, pf: float = 0.85, mode: str = 'generator',
+                 R: float = 0.0, X: float = 0.0):
+        super().__init__(name, P, Q, R, X)
+        self.a, self.b, self.c = a, b, c
+        self.mode:str = mode
+        
+        if S_rated is not None:
+            max_p = S_rated * pf
+            max_q = S_rated * np.sin(np.acos(pf))
+            
+            if mode == 'generator':
+                self.Pmax = max_p
+                self.Pmin = Pmin if Pmin is not None else 0.0
+            elif mode == 'motor':
+                self.Pmax = Pmax if Pmax is not None else 0.0
+                self.Pmin = -max_p
+            elif mode == 'condenser':
+                self.Pmax = 0.0
+                self.Pmin = 0.0
+            elif mode == 'pumped_storage': # เป็นได้ทั้งสองอย่าง
+                self.Pmax = max_p
+                self.Pmin = -max_p
+                
+            self.Qmax = max_q
+            self.Qmin = Qmin if Qmin is not None else (-max_q * 0.3)
+        else:
+            self.Pmax = Pmax if Pmax is not None else float('inf')
+            self.Pmin = Pmin if Pmin is not None else (0.0 if mode == 'generator' else float('-inf'))
+            self.Qmax = Qmax if Qmax is not None else float('inf')
+            self.Qmin = Qmin if Qmin is not None else float('-inf')
+    
+    def cost(self) -> float:
+        if self.P <= 0:
+            return 0.0
+        return self.a + self.b*self.P + self.c*(self.P**2)
+    
+    def incremental_cost(self) -> float:
+        if self.P <= 0:
+            return 0.0
+        return self.b + (2 * self.c * self.P)
+
+class Load(BusComponent):
+    def __init__(self, name: str, model: str ='P',
+                 P: float = 0, Q: float = 0,
+                 R: float = 0, X: float = 0):
+        """
+        model: 'Z' (constant Z, P ∝ V^2)
+               'I' (constant I, P ∝ V), 
+               'P' (constant PQ), 
+        """
+        
+        super().__init__(name, -abs(P), -Q, R, X)
+        self.model = model
+        
+        self.P_nom = self.P
+        self.Q_nom = self.Q
+        
+    def cost(self) -> float:
+        return 0.0
+
+    def incremental_cost(self) -> float:
+        return 0.0
+        
+    def update_voltage_dependence(self, V_mag: float, V_nom: float = 1.0):
+        if self.model == 'Z':
+            self.P = self.P_nom * (V_mag / V_nom)**2
+            self.Q = self.Q_nom * (V_mag / V_nom)**2
+        elif self.model == 'I':
+            self.P = self.P_nom * (V_mag / V_nom)
+            self.Q = self.Q_nom * (V_mag / V_nom)
+        elif self.model == 'P':
+            self.P = self.P_nom
+            self.Q = self.Q_nom
+
+class Inverter(BusComponent):
+    def __init__(self, name: str, S_max: float, 
+                 P: float = 0.0, Q: float = 0.0,
+                 control_mode: str = 'grid_following',
+                 source_type: str = 'solar',
+                 R: float = 0.0, X: float = 0.0):
+        super().__init__(name, P, Q, R, X)
+        self.S_max = S_max
+        self.control_mode = control_mode
+        self.source_type = source_type
+        
+        self.Qmax = S_max
+        self.Qmin = -S_max
+        
+        if source_type in ['solar', 'wind']:
+            self.Pmax = S_max
+            self.Pmin = 0.0
+        elif source_type == 'bess':
+            self.Pmax = S_max
+            self.Pmin = -S_max
+
+    def cost(self) -> float:
+        return 0.0
+    
+    def incremental_cost(self) -> float:
+        return 0.0
+
+class TransmissionLine(BranchComponent):
+    def __init__(self, name: str,
+                 R: float, X: float, B_shunt:float = 0.0,
+                 S_max: float | None = None, length_km: float = 1.0):
+        super().__init__(name, R, X, S_max)
+        self.B_shunt = B_shunt
+        self.length_km = length_km
+
+class Transformer(BranchComponent):
+    def __init__(self, name: str,
+                 R: float, X: float,
+                 tap_ratio: float = 1.0, phase_shift: float = 0.0,
+                 S_max: float | None = None):
+        super().__init__(name, R, X, S_max)
+        self.tap_ratio = tap_ratio
+        self.phase_shift = phase_shift

4pace-0.1.0a0/src/fourpace/psys.py

@@ -0,0 +1,482 @@
+import yaml
+from pathlib import Path
+import numpy as np
+import scipy.optimize as opt
+import networkx as nx
+
+from src.fourpace.model import BusComponent, SynchronousMachine, Load, BranchComponent, TransmissionLine, Transformer
+
+class Bus(nx.Graph):
+    def __init__(self, name: str, Vbase: float, bus_type: str = 'PQ'):
+        super().__init__()
+        self.name = name
+        self.Vbase: float | None = Vbase
+        
+        self.type = bus_type
+        self.v:float = 1.0
+        self.phi:float = 0.0
+        self.add_node(name, obj=self)
+    
+    @property
+    def P(self) -> float:
+        total_p = 0.0
+        for _, data in self.nodes(data=True):
+            obj = data.get('obj')
+            if obj is not self and hasattr(obj, 'P'):
+                total_p += obj.P
+        return total_p
+
+    @property
+    def Q(self) -> float:
+        total_q = 0.0
+        for _, data in self.nodes(data=True):
+            obj = data.get('obj')
+            if obj is not self and hasattr(obj, 'Q'):
+                total_q += obj.Q
+        return total_q
+    
+    @property
+    def S(self) -> complex:
+        return self.P + 1j*self.Q;
+    
+    def flat_start(self):
+        self.V = 1.0
+        self.phi = 0.0
+        
+    def get(self):
+        return [self.v, self.phi, self.P, self.Q]
+    
+    def add_component(self, component: BusComponent):
+        self.add_node(component.name, obj=component)
+        self.add_edge(self.name, component.name)
+    
+    def add_components(self, components: list[BusComponent]):
+        for component in components:
+            self.add_component(component)
+        
+    def total_cost(self) -> float:
+        components = [component for _, component in self.nodes(data='obj')]
+        components.remove(self)
+        sum = 0
+        for com in components:
+            sum += com.cost()
+        return sum
+
+class Grid(nx.Graph):
+    def __init__(self, Sbase: float):
+        super().__init__()
+        self.Ybus: np.ndarray | None = None
+        self.Sbase: float = Sbase
+    
+    @classmethod
+    def load(cls, filepath: str) -> 'Grid':
+        path = Path(filepath)
+        with open(path, 'r', encoding='utf-8') as f:
+            if path.suffix in ['.yaml', '.yml']:
+                data = yaml.safe_load(f)
+            else:
+                raise ValueError("❌ Unsupported format! Please use .yaml or .json")
+
+        grid = cls(Sbase=data.get('Sbase', 100.0))
+
+        comp_classes = {
+            'SynchronousMachine': SynchronousMachine,
+            'Load': Load,
+            'TransmissionLine': TransmissionLine,
+            'Transformer': Transformer
+        }
+
+        for b_data in data.get('buses', []):
+            bus = Bus(name=b_data['name'], Vbase=b_data['Vbase'], bus_type=b_data.get('bus_type', 'PQ'))
+            grid.add_bus(bus)
+            
+            for comp_data in b_data.get('components', []):
+                comp_type = comp_data.pop('type')
+                if comp_type in comp_classes:
+                    comp_obj = comp_classes[comp_type](**comp_data) 
+                    grid.bus(bus.name).add_component(comp_obj)
+
+        for branch_data in data.get('branches', []):
+            branch_type = branch_data.pop('type')
+            from_bus = branch_data.pop('from_bus')
+            to_bus = branch_data.pop('to_bus')
+            
+            if branch_type in comp_classes:
+                branch_obj = comp_classes[branch_type](**branch_data)
+                grid.connect(from_bus, to_bus, branch_obj)
+
+        print(f"✅ Successfully loaded grid from {path.name}")
+        return grid
+    
+    def add_bus(self, bus:Bus):
+        self.add_node(bus.name, bus=bus)
+    
+    def add_busses(self, busses:list[Bus]):
+        for bus in busses:
+            self.add_bus(bus)
+        
+    def connect(self, from_bus:str, to_bus:str, branch: BranchComponent):
+        self.add_edge(from_bus, to_bus, obj=branch)
+    
+    def bus(self, name: str) -> Bus:
+        if name in self.nodes:
+            return self.nodes[name]['bus']
+        
+        raise KeyError(f"❌  Bus  '{name}' not found in this grid.")
+    
+    @property
+    def busses(self) -> list[Bus]:
+        return [bus for _, bus in self.nodes(data='bus')]
+    
+    def build_ybus(self) -> np.ndarray:
+        nodes = list(self.nodes)
+        n = len(nodes)
+        Y = np.zeros((n, n), dtype=complex)
+        
+        for u, v, data in self.edges(data=True):
+            i = nodes.index(u)
+            j = nodes.index(v)
+            obj = data.get('obj')
+            
+            if obj is None: continue
+            
+            y = obj.Y
+            
+            if isinstance(obj, TransmissionLine):
+                b_sh = obj.B_shunt
+                Y[i, i] += y + (1j * b_sh / 2)
+                Y[j, j] += y + (1j * b_sh / 2)
+                Y[i, j] -= y
+                Y[j, i] -= y
+                
+            elif isinstance(obj, Transformer):
+                a = obj.tap_ratio
+                alpha = obj.phase_shift
+                
+                tap_complex = a * np.exp(1j * alpha)
+                
+                Y[i, i] += y / (a**2)
+                Y[j, j] += y
+                Y[i, j] -= y / np.conj(tap_complex)
+                Y[j, i] -= y / tap_complex
+                
+        self.Ybus = Y
+        return Y
+    
+    def result(self):
+        print("\n=== 📊 POWER FLOW RESULTS ===")
+        for i, bus in enumerate(self.busses):
+            P_pu, Q_pu = self.calculate_PQ(i)
+            
+            P_actual = P_pu * self.Sbase
+            Q_actual = Q_pu * self.Sbase
+            
+            print(f"Bus {bus.name} | V = {bus.v:.4f} pu | phi = {bus.phi:8.4f} rad | P = {P_actual:7.2f} MW | Q = {Q_actual:7.2f} MVAr")
+    
+    def flat_start(self):
+        for bus in self.busses:
+            bus.flat_start()
+    
+    def update_busses(self, correction: np.ndarray, damping = .5):
+        pv_pq_idx = [i for i, b in enumerate(self.busses) if b.type in ['PV', 'PQ']]
+        pq_idx = [i for i, b in enumerate(self.busses) if b.type == 'PQ']
+        
+        n1 = len(pv_pq_idx)
+        
+        for row_i, i in enumerate(pv_pq_idx):
+            self.busses[i].phi += damping * float(correction[row_i])
+            
+        for row_i, i in enumerate(pq_idx):
+            self.busses[i].v += damping * float(correction[n1 + row_i])
+    
+    def calculate_PQ(self, i):
+        bus_i = self.busses[i]
+        Vi = bus_i.v
+        phi_i = bus_i.phi
+        
+        G = self.Ybus.real
+        B = self.Ybus.imag
+        
+        P_i = 0
+        Q_i = 0
+        
+        for j in range(len(self.busses)):
+            bus_j = self.busses[j]
+            Vj = bus_j.v
+            phi_j = bus_j.phi
+            delta_ij = phi_i - phi_j
+
+            P_i += Vi * Vj * (G[i, j] * np.cos(delta_ij) + B[i, j] * np.sin(delta_ij))
+            Q_i += Vi * Vj * (G[i, j] * np.sin(delta_ij) - B[i, j] * np.cos(delta_ij))
+
+        return P_i, Q_i
+
+    def jacobian(self):
+        n = len(self.busses)
+        G = self.Ybus.real
+        B = self.Ybus.imag
+        
+        pv_pq_idx = [i for i, b in enumerate(self.busses) if b.type in ['PV', 'PQ']]
+        pq_idx = [i for i, b in enumerate(self.busses) if b.type == 'PQ']
+        
+        n1 = len(pv_pq_idx)
+        n2 = len(pq_idx)
+        J = np.zeros((n1 + n2, n1 + n2))
+
+        for row_i, i in enumerate(pv_pq_idx):
+            Vi = self.busses[i].v
+            phi_i = self.busses[i].phi
+            
+            for col_j, j in enumerate(pv_pq_idx):
+                Vj = self.busses[j].v
+                phi_j = self.busses[j].phi
+                delta_ij = phi_i - phi_j
+                
+                if i == j: # Diagonal elements
+                    # dPi/dphi_i = -Qi - (Vi^2 * Bii)
+                    _, Qi_calc = self.calculate_PQ(i)
+                    J[row_i, col_j] = -Qi_calc - (Vi**2 * B[i, i])
+                else: # Off-diagonal
+                    # dPi/dphi_j = Vi*Vj*(Gij*sin(d_ij) - Bij*cos(d_ij))
+                    J[row_i, col_j] = Vi * Vj * (G[i, j] * np.sin(delta_ij) - B[i, j] * np.cos(delta_ij))
+
+        for row_i, i in enumerate(pv_pq_idx):
+            Vi = self.busses[i].v
+            phi_i = self.busses[i].phi
+            
+            for col_j, j in enumerate(pq_idx):
+                Vj = self.busses[j].v
+                phi_j = self.busses[j].phi
+                delta_ij = phi_i - phi_j
+                
+                if i == j: # Diagonal
+                    # dPi/dVi = (Pi/Vi) + (Gii * Vi)
+                    Pi_calc, _ = self.calculate_PQ(i)
+                    J[row_i, n1 + col_j] = (Pi_calc / Vi) + (G[i, i] * Vi)
+                else: # Off-diagonal
+                    # dPi/dVj = Vi*(Gij*cos(d_ij) + Bij*sin(d_ij))
+                    J[row_i, n1 + col_j] = Vi * (G[i, j] * np.cos(delta_ij) + B[i, j] * np.sin(delta_ij))
+
+        for row_i, i in enumerate(pq_idx):
+            Vi = self.busses[i].v
+            phi_i = self.busses[i].phi
+            Pi_calc, Qi_calc = self.calculate_PQ(i)
+            actual_row = n1 + row_i
+            
+            # dQ/dphi
+            for col_j, j in enumerate(pv_pq_idx):
+                Vj = self.busses[j].v
+                phi_j = self.busses[j].phi
+                delta_ij = phi_i - phi_j
+                
+                if i == j:
+                    # dQi/dphi_i = Pi - (Vi^2 * Gii)
+                    Pi_calc, _ = self.calculate_PQ(i)
+                    J[actual_row, col_j] = Pi_calc - (Vi**2 * G[i, i])
+                else:
+                    # dQi/dphi_j = -Vi*Vj*(Gij*cos(d_ij) + Bij*sin(d_ij))
+                    J[actual_row, col_j] = -Vi * Vj * (G[i, j] * np.cos(delta_ij) + B[i, j] * np.sin(delta_ij))
+            
+            # dQ/dV
+            for col_j, j in enumerate(pq_idx):
+                Vj = self.busses[j].v
+                phi_j = self.busses[j].phi
+                delta_ij = phi_i - phi_j
+                
+                if i == j:
+                    J[actual_row, n1 + col_j] = (Qi_calc / Vi) - (B[i, i] * Vi)
+                else:
+                    delta_ij = phi_i - phi_j
+                    J[actual_row, n1 + col_j] = Vi * (G[i, j] * np.sin(delta_ij) - B[i, j] * np.cos(delta_ij))
+                    
+        return J
+    
+    def mismatch(self):
+        delta_P = []
+        delta_Q = []
+        
+        for i, bus in enumerate(self.busses):
+            if bus.type == 'Slack':
+                continue
+                
+            P_calc, Q_calc = self.calculate_PQ(i)
+            
+            delta_P.append((bus.P/self.Sbase) - P_calc)
+            
+            if bus.type == 'PQ':
+                delta_Q.append((bus.Q/self.Sbase) - Q_calc)
+        return np.array(delta_P + delta_Q).flatten()
+    
+    def solve(self, tolerance=1e-6, max_iteration=100):
+        self.flat_start()
+        self.build_ybus()
+        
+        for i in range(max_iteration):
+            m = self.mismatch()
+            if np.max(np.abs(m)) < tolerance:
+                print(f"\n✅ Power Flow Converged in {i} iterations!")
+                break
+            
+            dx = np.linalg.solve(self.jacobian(), m)
+            self.update_busses(dx)
+        else:
+            print(f"\n⚠️ Warning: Power Flow did not converge within max iterations ({max_iteration}).")
+        
+        self.result()
+    
+    def eco_dispatch(self):
+        machines = []
+        machine_bus_idx = []
+        P_load_bus = np.zeros(len(self.busses))
+        Q_load_bus = np.zeros(len(self.busses))
+        
+        for i, bus in enumerate(self.busses):
+            for _, data in bus.nodes(data=True):
+                obj = data.get('obj')
+                if type(obj).__name__ == 'SynchronousMachine':
+                    machines.append(obj)
+                    machine_bus_idx.append(i)
+                elif type(obj).__name__ == 'Load':
+                    P_load_bus[i] += abs(obj.P) 
+                    Q_load_bus[i] += abs(obj.Q)
+                    
+        num_gen = len(machines)
+        num_bus = len(self.busses)
+        
+        if self.Ybus is None:
+            self.build_ybus()
+            
+        G = self.Ybus.real
+        B = self.Ybus.imag
+        
+        idx_Pg = slice(0, num_gen)
+        idx_Qg = slice(num_gen, 2*num_gen)
+        idx_V = slice(2*num_gen, 2*num_gen + num_bus)
+        idx_theta = slice(2*num_gen + num_bus, 2*num_gen + 2*num_bus)
+        
+        def objective(x):
+            Pg = x[idx_Pg]
+            cost = 0.0
+            for i, m in enumerate(machines):
+                if Pg[i] > 0:
+                    cost += m.a + (m.b * Pg[i]) + (m.c * (Pg[i]**2))
+            return cost
+
+        def power_balance(x):
+            Pg = x[idx_Pg]
+            Qg = x[idx_Qg]
+            V = x[idx_V]
+            theta = x[idx_theta]
+            
+            P_gen_bus = np.zeros(num_bus)
+            Q_gen_bus = np.zeros(num_bus)
+            for i, bus_idx in enumerate(machine_bus_idx):
+                P_gen_bus[bus_idx] += Pg[i]
+                Q_gen_bus[bus_idx] += Qg[i]
+                
+            P_inj_pu = (P_gen_bus - P_load_bus) / self.Sbase
+            Q_inj_pu = (Q_gen_bus - Q_load_bus) / self.Sbase
+            
+            P_calc_pu = np.zeros(num_bus)
+            Q_calc_pu = np.zeros(num_bus)
+            
+            for i in range(num_bus):
+                for j in range(num_bus):
+                    delta_ij = theta[i] - theta[j]
+                    P_calc_pu[i] += V[i] * V[j] * (G[i, j] * np.cos(delta_ij) + B[i, j] * np.sin(delta_ij))
+                    Q_calc_pu[i] += V[i] * V[j] * (G[i, j] * np.sin(delta_ij) - B[i, j] * np.cos(delta_ij))
+                    
+            mismatch_P = P_inj_pu - P_calc_pu
+            mismatch_Q = Q_inj_pu - Q_calc_pu
+            
+            return np.concatenate((mismatch_P, mismatch_Q))
+        
+        def line_limits(x):
+            V = x[idx_V]
+            theta = x[idx_theta]
+            V_complex = V * np.exp(1j * theta)
+            
+            margins = []
+            nodes_list = list(self.nodes)
+            
+            for u, v, data in self.edges(data=True):
+                obj = data.get('obj')
+                if obj and getattr(obj, 'S_max', None) is not None:
+                    i = nodes_list.index(u)
+                    j = nodes_list.index(v)
+                    
+                    Vi = V_complex[i]
+                    Vj = V_complex[j]
+                    
+                    if type(obj).__name__ == 'Transformer':
+                        t = obj.tap_ratio * np.exp(1j * obj.phase_shift)
+                        I_ij = (Vi/t - Vj) * obj.Y
+                    else:
+                        I_ij = (Vi - Vj) * obj.Y
+                        
+                    # Apparent Power (S = V * I*)
+                    S_flow_pu = abs(Vi * np.conj(I_ij))
+                    S_flow_MVA = S_flow_pu * self.Sbase
+                    
+                    margins.append(obj.S_max - S_flow_MVA)
+            
+            if not margins:
+                return [1.0]
+            return np.array(margins)
+
+        bounds = []
+        
+        for m in machines:
+            p_min = m.Pmin if m.Pmin != float('-inf') else 0.0
+            p_max = m.Pmax if m.Pmax != float('inf') else 9999.0 
+            bounds.append((p_min, p_max))
+            
+        for m in machines:
+            q_min = m.Qmin if m.Qmin != float('-inf') else -9999.0
+            q_max = m.Qmax if m.Qmax != float('inf') else 9999.0
+            bounds.append((q_min, q_max))
+            
+        for bus in self.busses:
+            bounds.append((0.95, 1.05))
+            
+        slack_idx = next(i for i, b in enumerate(self.busses) if b.type == 'Slack')
+        for i in range(num_bus):
+            if i == slack_idx:
+                bounds.append((0.0, 0.0))
+            else:
+                bounds.append((-np.pi, np.pi))
+
+        Pg0 = [m.Pmax / 2 if m.Pmax != float('inf') else 50.0 for m in machines]
+        Qg0 = [0.0 for m in machines]
+        V0 = [1.0 for b in self.busses]
+        theta0 = [0.0 for b in self.busses]
+        x0 = np.concatenate((Pg0, Qg0, V0, theta0))
+
+        constraints = [
+            {'type': 'eq', 'fun': power_balance},
+            {'type': 'ineq', 'fun': line_limits}
+        ]
+        
+        print("\n⏳ Running AC Optimal Power Flow...")
+        result = opt.minimize(objective, x0, bounds=bounds, constraints=constraints, 
+                              method='SLSQP', options={'maxiter': 500, 'ftol': 1e-6})
+        
+        if result.success:
+            print("✅ ACOPF Converged Successfully!")
+            Pg_opt = result.x[idx_Pg]
+            Qg_opt = result.x[idx_Qg]
+            V_opt = result.x[idx_V]
+            theta_opt = result.x[idx_theta]
+            
+            for i, m in enumerate(machines):
+                m.P = Pg_opt[i]
+                m.Q = Qg_opt[i]
+            for i, bus in enumerate(self.busses):
+                bus.v = V_opt[i]
+                bus.phi = theta_opt[i]
+                
+            print(f"Total Optimal Cost: ${result.fun:.2f}/hr")
+            self.result()
+        else:
+            print("❌ ACOPF Failed to Converge!")
+            print(result.message)