Parallel Pandapower Solver

https://parallel-pandapower-solver.readthedocs.io/en/stable/
Admin
Parallel Pandapower Solver (p3s) provides accelerated CPU and GPU-based AC power-flow and N-1...
Tokens:17,445
Snippets:151
Trust Score:9.6
Update:1 week ago
Show doc for...
Tokens:
Raw
### Install from index: pip install parallel-pandapower-solver[cpp]

Source: https://parallel-pandapower-solver.readthedocs.io/en/stable/build.html

Installs the published p3s-cpp distribution, which includes the compiled nr_klu extension. This is the standard installation method for users.

```bash
pip install parallel-pandapower-solver[cpp]        # pulls in the published p3s-cpp distribution

```

--------------------------------

### Install from source

Source: https://parallel-pandapower-solver.readthedocs.io/en/stable/_sources/installation.rst.txt

Installs the package from the downloaded or cloned source directory using uv.

```sh
cd parallel-pandapower-solver
uv pip install .
```

--------------------------------

### Install p3s-cpp from source checkout

Source: https://parallel-pandapower-solver.readthedocs.io/en/stable/_sources/build.rst.txt

Builds and installs the extension from a local source checkout using pip and scikit-build-core.

```bash
pip install ./p3s/cpp
```

--------------------------------

### Install p3s-cpp from index

Source: https://parallel-pandapower-solver.readthedocs.io/en/stable/_sources/build.rst.txt

Installs the published p3s-cpp distribution via pip, pulling in the compiled extension. This is the recommended way to get the extension from an index.

```bash
pip install parallel-pandapower-solver[cpp]        # pulls in the published p3s-cpp distribution
```

--------------------------------

### Install with pip

Source: https://parallel-pandapower-solver.readthedocs.io/en/stable/_sources/installation.rst.txt

Installs the parallel pandapower solver using pip, an alternative to the uv command.

```sh
pip install parallel-pandapower-solver
```

--------------------------------

### Install with uv

Source: https://parallel-pandapower-solver.readthedocs.io/en/stable/_sources/installation.rst.txt

Installs the parallel pandapower solver using the uv package manager. This is the recommended command for a stable release installation.

```sh
uv add parallel-pandapower-solver
```

--------------------------------

### Install C++/KLU solver

Source: https://parallel-pandapower-solver.readthedocs.io/en/stable/_sources/usage.rst.txt

Install the C++/KLU accelerated solver. Building it needs a C++17 compiler and SuiteSparse/KLU (and CUDA toolkit for CUDA paths).

```bash
pip install parallel-pandapower-solver[cpp]     # from an index
pip install ./p3s/cpp    # from a source checkout
```

--------------------------------

### N-1 contingency benchmark quick start commands

Source: https://parallel-pandapower-solver.readthedocs.io/en/stable/benchmark.html

Run the standalone N-1 benchmark script with various options: all lines and transformers, limit to first 200 contingencies, skip pandapower loop, or use 8 threads and validate 25 contingencies.

```bash
# All lines + transformers
python -m tests.benchmark.benchmark_n_1_pegase

# First 200 contingencies (quick estimate)
python -m tests.benchmark.benchmark_n_1_pegase --limit 200

# p3s only (skip the slow pandapower loop)
python -m tests.benchmark.benchmark_n_1_pegase --skip-pandapower

# 8 threads + spot-check 25 contingencies against pandapower
python -m tests.benchmark.benchmark_n_1_pegase --threads 8 --validate 25
```

--------------------------------

### Install numpy for build isolation

Source: https://parallel-pandapower-solver.readthedocs.io/en/stable/build.html

Install numpy in the active environment when building with --no-build-isolation to ensure numpy headers are found.

```bash
pip install numpy
```

--------------------------------

### Install SuiteSparse via conda-forge

Source: https://parallel-pandapower-solver.readthedocs.io/en/stable/build.html

The easiest cross-platform route to get SuiteSparse/KLU headers, libraries, and CMake config packages is conda-forge. A system libsuitesparse-dev also works on Linux.

```bash
conda install -c conda-forge suitesparse
```

--------------------------------

### Host-tuned local build: pip install ./p3s/cpp --config-settings=cmake.define.P3S_CPP_NATIVE=ON

Source: https://parallel-pandapower-solver.readthedocs.io/en/stable/build.html

Builds a local development wheel tuned to the host CPU with -march=native. P3S_CPP_NATIVE defaults to OFF in the published wheel; use ON only for local development builds.

```bash
pip install ./p3s/cpp --config-settings=cmake.define.P3S_CPP_NATIVE=ON

```

--------------------------------

### Build from source checkout: pip install ./p3s/cpp

Source: https://parallel-pandapower-solver.readthedocs.io/en/stable/build.html

Builds the package from a local source checkout. The build is driven by pip + scikit-build-core, which runs the CMake build in p3s/cpp/CMakeLists.txt.

```bash
pip install ./p3s/cpp

```

--------------------------------

### Output JSON file path pattern

Source: https://parallel-pandapower-solver.readthedocs.io/en/stable/benchmark.html

Results are saved as JSON files using the pattern {output_dir}/{job_id}/{job_id}_{case}.json. Example: /mnt/home/user/p3s/results/123456/123456_case9.json.

```none
{output_dir}/{job_id}/{job_id}_{case}.json
```

--------------------------------

### Import the installed nr_klu module

Source: https://parallel-pandapower-solver.readthedocs.io/en/stable/build.html

After a successful build, the module is installed into the p3s package by CMake, so it resolves without any path juggling. The fallback import path is from p3s.cpp import nr_klu.

```python
from p3s import nr_klu  # installed build
# fallback: from p3s.cpp import nr_klu
```

--------------------------------

### Install CUDA toolkit

Source: https://parallel-pandapower-solver.readthedocs.io/en/stable/_sources/installation.rst.txt

Installs the CUDA toolkit and cuDSS via conda. Note that CUDA libraries are not part of the repository and must be acquired separately from NVIDIA under their license terms.

```sh
conda install -c nvidia/label/cuda-13.2.2 cuda-toolkit`
```

--------------------------------

### Set KLU_ROOT environment variable

Source: https://parallel-pandapower-solver.readthedocs.io/en/stable/_sources/build.rst.txt

Sets the KLU_ROOT environment variable to point the build at a non-standard SuiteSparse installation. Shown for Windows PowerShell and Linux/macOS.

```bash
# Windows (PowerShell)
$env:KLU_ROOT = "C:\path\to\suitesparse"

# Linux/macOS
export KLU_ROOT=/path/to/suitesparse
```

--------------------------------

### Test locally with all methods

Source: https://parallel-pandapower-solver.readthedocs.io/en/stable/_sources/benchmark.rst.txt

Runs the benchmark for case9 with all methods (pp, p3s, cpp-1thr, cpp-Nthr, gpu).

```bash
# Test case9 with all methods
python tests/benchmark/benchmark_batched.py --case case9 --methods pp,p3s,cpp-1thr,cpp-Nthr,gpu
```

--------------------------------

### Custom method selection - C++ and GPU

Source: https://parallel-pandapower-solver.readthedocs.io/en/stable/_sources/benchmark.rst.txt

Runs the benchmark for case9 with only the cpp and gpu methods.

```bash
# Only test C++ and GPU
python tests/benchmark/benchmark_batched.py --case case9 --methods cpp,gpu
```

--------------------------------

### Configure and build with CMake

Source: https://parallel-pandapower-solver.readthedocs.io/en/stable/build.html

Commands to configure and build the project using CMake directly against p3s/cpp/CMakeLists.txt. Requires providing Python, pybind11, numpy, and KLU discovery manually. Use -DKLU_ROOT or -DSuiteSparse_ROOT for non-standard KLU locations.

```bash
mkdir build && cd build
cmake .. -DCMAKE_BUILD_TYPE=Release -DCMAKE_PREFIX_PATH=<path-to-python>
cmake --build . --config Release
```

--------------------------------

### N-1 benchmark GPU backend commands

Source: https://parallel-pandapower-solver.readthedocs.io/en/stable/benchmark.html

Run the N-1 benchmark with GPU backend, optionally setting GPU max chunk size, or compare CPU vs GPU with 'both' backend.

```bash
python -m tests.benchmark.benchmark_n_1_pegase --backend gpu --limit 2000
python -m tests.benchmark.benchmark_n_1_pegase --backend gpu --gpu-max-chunk 512
python -m tests.benchmark.benchmark_n_1_pegase --backend both --limit 2000  # CPU vs GPU
```

--------------------------------

### Host-tuned local build with P3S_CPP_NATIVE

Source: https://parallel-pandapower-solver.readthedocs.io/en/stable/_sources/build.rst.txt

Builds the extension with host-specific tuning (-march=native) for local development. P3S_CPP_NATIVE defaults to OFF in published wheels; use ON only for local builds.

```bash
pip install ./p3s/cpp --config-settings=cmake.define.P3S_CPP_NATIVE=ON
```

--------------------------------

### Set KLU_ROOT environment variable

Source: https://parallel-pandapower-solver.readthedocs.io/en/stable/build.html

Set the KLU_ROOT environment variable to point the build at a non-standard SuiteSparse installation. The cmake/FindKLU.cmake honors KLU_ROOT, SuiteSparse_ROOT, and CONDA_PREFIX.

```powershell
# Windows (PowerShell)
$env:KLU_ROOT = "C:\path\to\suitesparse"
```

```bash
# Linux/macOS
export KLU_ROOT=/path/to/suitesparse
```

--------------------------------

### Custom method selection for benchmark_batched.py

Source: https://parallel-pandapower-solver.readthedocs.io/en/stable/benchmark.html

Run benchmark_batched.py with specific methods: 'cpp,gpu' for C++ and GPU, or 'cpp-1thr' for single-threaded C++.

```bash
# Only test C++ and GPU
python tests/benchmark/benchmark_batched.py --case case9 --methods cpp,gpu

# Only single-threaded C++
python tests/benchmark/benchmark_batched.py --case case14 --method cpp-1thr
```

--------------------------------

### Run on a cluster with sbatch

Source: https://parallel-pandapower-solver.readthedocs.io/en/stable/benchmark.html

Submit all IEEE cases as a job array, or submit a specific method by setting the METHOD environment variable.

```bash
# Submit all IEEE cases (job array: 0-29)
sbatch tests/benchmark/benchmark_all.sbatch
```

```bash
# Submit specific method
METHOD=gpu sbatch tests/benchmark/benchmark_all.sbatch
```

--------------------------------

### Run p3s-only benchmark (skip pandapower)

Source: https://parallel-pandapower-solver.readthedocs.io/en/stable/_sources/benchmark.rst.txt

Times only the p3s solver, skipping the slow pandapower loop. Use for a quick estimate of p3s performance.

```bash
# p3s only (skip the slow pandapower loop)
python -m tests.benchmark.benchmark_n_1_pegase --skip-pandapower
```

--------------------------------

### Initialize NewtonPowerflowCUDA

Source: https://parallel-pandapower-solver.readthedocs.io/en/stable/usage.html

Initializes the CUDA-accelerated Newton solver and calculates time-series voltages. The batch_size parameter determines the number of operating points solved per GPU chunk.

```python
from p3s.cuda.NewtonPowerflowCuda import NewtonPowerflowCUDA
npf = NewtonPowerflowCUDA(net) voltages = npf.calculate_timeseries_cuda(net, timeseries, batch_size=5)
```

--------------------------------

### Custom method selection - single-threaded C++

Source: https://parallel-pandapower-solver.readthedocs.io/en/stable/_sources/benchmark.rst.txt

Runs the benchmark for case14 with only the cpp-1thr method.

```bash
# Only single-threaded C++
python tests/benchmark/benchmark_batched.py --case case14 --method cpp-1thr
```

--------------------------------

### Import p3s solvers

Source: https://parallel-pandapower-solver.readthedocs.io/en/stable/_sources/usage.rst.txt

Import the pure-Python CPU solver, the C++/KLU CPU solver, and the GPU solver from their respective submodules.

```python
from p3s.NewtonPowerflow import NewtonPowerflow            # pure-Python CPU solver
from p3s.NewtonPowerflowCpp import NewtonPowerflow as NewtonPowerflowCpp  # C++/KLU CPU solver
from p3s.cuda.NewtonPowerflowCuda import NewtonPowerflowCUDA              # GPU solver
```

--------------------------------

### C++/KLU accelerated solver (p3s.NewtonPowerflowCpp)

Source: https://parallel-pandapower-solver.readthedocs.io/en/stable/_sources/usage.rst.txt

Drop-in accelerated variant of the Newton solver that offloads sparse factorisation to the compiled nr_klu extension.

```python
from p3s.NewtonPowerflowCpp import NewtonPowerflow as NewtonPowerflowCpp

npf = NewtonPowerflowCpp(net)
voltage = npf.calculate(net, tolerance=1e-8, max_iterations=30)
```

--------------------------------

### Run benchmark with 8 threads and validate 25 contingencies

Source: https://parallel-pandapower-solver.readthedocs.io/en/stable/_sources/benchmark.rst.txt

Uses 8 OpenMP threads for nr_klu and spot-checks 25 contingencies against pandapower. The default validation count is 10.

```bash
# 8 threads + spot-check 25 contingencies against pandapower
python -m tests.benchmark.benchmark_n_1_pegase --threads 8 --validate 25
```

--------------------------------

### Import p3s package

Source: https://parallel-pandapower-solver.readthedocs.io/en/stable/_sources/usage.rst.txt

Import the p3s package. Most functionality lives in submodules, so import the solver you need explicitly.

```python
import p3s
```

--------------------------------

### Submit specific method on cluster

Source: https://parallel-pandapower-solver.readthedocs.io/en/stable/_sources/benchmark.rst.txt

Submits the benchmark job with the gpu method by setting the METHOD environment variable.

```bash
# Submit specific method
METHOD=gpu sbatch tests/benchmark/benchmark_all.sbatch
```

--------------------------------

### N-1 contingency benchmark - all lines and transformers

Source: https://parallel-pandapower-solver.readthedocs.io/en/stable/_sources/benchmark.rst.txt

Runs the standalone N-1 contingency benchmark for all lines and transformers.

```bash
# All lines + transformers
python -m tests.benchmark.benchmark_n_1_pegase
```

--------------------------------

### Test locally with benchmark_batched.py

Source: https://parallel-pandapower-solver.readthedocs.io/en/stable/benchmark.html

Run the benchmark script locally for a specific IEEE case and method, or with specific T values for the GPU method.

```bash
# Test case9 with all methods
python tests/benchmark/benchmark_batched.py –case case9 –methods pp,p3s,cpp-1thr,cpp-Nthr,gpu
```

```bash
# Test with specific T values
python tests/benchmark/benchmark_batched.py –case case118 –method gpu –T 64 256 1024
```

--------------------------------

### Submit all IEEE cases on cluster

Source: https://parallel-pandapower-solver.readthedocs.io/en/stable/_sources/benchmark.rst.txt

Submits a SLURM job array (0-29) for all IEEE cases using the benchmark_all.sbatch script.

```bash
# Submit all IEEE cases (job array: 0-29)
sbatch tests/benchmark/benchmark_all.sbatch
```

--------------------------------

### N-1 contingency benchmark - first 200 contingencies

Source: https://parallel-pandapower-solver.readthedocs.io/en/stable/_sources/benchmark.rst.txt

Runs the N-1 contingency benchmark with a limit of 200 contingencies for a quick estimate.

```bash
# First 200 contingencies (quick estimate)
python -m tests.benchmark.benchmark_n_1_pegase --limit 200
```

--------------------------------

### Verify p3s import

Source: https://parallel-pandapower-solver.readthedocs.io/en/stable/build.html

Import the nr_klu module from p3s to confirm the build succeeded.

```python
from p3s import nr_klu

```

--------------------------------

### Newton-Raphson solver (p3s.NewtonPowerflow)

Source: https://parallel-pandapower-solver.readthedocs.io/en/stable/_sources/usage.rst.txt

General AC power-flow solver for transmission networks, PV/generator buses and trafos. Pure-Python implementation (NumPy/SciPy). init="dc" (default) initialises with a DC power flow; tolerance defaults to 1e-5; max_iterations defaults to 30. Writes results back into the network and returns the converged voltage vector.

```python
from p3s.NewtonPowerflow import NewtonPowerflow

npf = NewtonPowerflow(net)
voltage = npf.calculate(net, init="dc", tolerance=1e-8, max_iterations=30)
```

--------------------------------

### NewtonPowerflowCpp.calculate

Source: https://parallel-pandapower-solver.readthedocs.io/en/stable/_sources/usage.rst.txt

A drop-in accelerated variant of the Newton solver that offloads the sparse factorisation to the compiled `nr_klu` extension. It is opt-in because building it needs a C++17 compiler and SuiteSparse/KLU.

```APIDOC
## NewtonPowerflowCpp.calculate

### Description
A drop-in accelerated variant of the Newton solver that offloads the sparse factorisation to the compiled `nr_klu` extension. It is opt-in because building it needs a C++17 compiler and SuiteSparse/KLU.

### Method
Function call

### Endpoint
`from p3s.NewtonPowerflowCpp import NewtonPowerflow as NewtonPowerflowCpp`

### Parameters
- **net** (pandapowerNet) - Required - The pandapower network to solve.
- **tolerance** (float) - Optional - Convergence threshold. Default is `1e-5` (implied).
- **max_iterations** (int) - Optional - Maximum number of iterations. Default is `30`.

### Request Example
```python
from p3s.NewtonPowerflowCpp import NewtonPowerflow as NewtonPowerflowCpp

npf = NewtonPowerflowCpp(net)
voltage = npf.calculate(net, tolerance=1e-8, max_iterations=30)
```

### Response
#### Success Response
- **voltage** (array) - The converged voltage vector.

#### Response Example
```python
voltage = npf.calculate(net, tolerance=1e-8, max_iterations=30)
print(voltage)
```
```

--------------------------------

### Compile results with compile_results.py

Source: https://parallel-pandapower-solver.readthedocs.io/en/stable/benchmark.html

Submit a SLURM job to compile benchmark results into a specified output directory.

```bash
sbatch tests/resources/compile_results.sbatch
python tests/compile_results.py –output-dir /mnt/home/user/p3s/results
```

--------------------------------

### Custom T values for benchmark_batched.py

Source: https://parallel-pandapower-solver.readthedocs.io/en/stable/benchmark.html

Run benchmark_batched.py with custom time steps using the --T flag.

```bash
# Test with different time steps
python tests/benchmark/benchmark_batched.py --case case300 --T 100 500 1000 5000
```

--------------------------------

### Import p3s module

Source: https://parallel-pandapower-solver.readthedocs.io/en/stable/_sources/build.rst.txt

Verifies that the built p3s module imports correctly.

```python
from p3s import nr_klu
```

--------------------------------

### Download tarball

Source: https://parallel-pandapower-solver.readthedocs.io/en/stable/_sources/installation.rst.txt

Downloads the source code as a tarball from the master branch.

```sh
curl -OJL https://github.com/e2niee/parallel-pandapower-solver/tarball/master
```

--------------------------------

### Test with specific T values

Source: https://parallel-pandapower-solver.readthedocs.io/en/stable/_sources/benchmark.rst.txt

Runs the benchmark for case118 with the gpu method and specific T values (64, 256, 1024).

```bash
# Test with specific T values
python tests/benchmark/benchmark_batched.py --case case118 --method gpu --T 64 256 1024
```

--------------------------------

### Run validation tests with pytest

Source: https://parallel-pandapower-solver.readthedocs.io/en/stable/build.html

Run the test suite located in p3s/cpp/tests using pytest. The tests cover solve_batch vs scipy, NewtonPowerflowCpp.calculate vs pandapower runpp, and self-consistency of converged voltages.

```bash
python -m pytest p3s/cpp/tests

```

--------------------------------

### GPU solver (p3s.cuda.NewtonPowerflowCUDA)

Source: https://parallel-pandapower-solver.readthedocs.io/en/stable/_sources/usage.rst.txt

CUDA-accelerated Newton solver. Batched solves run fully on the GPU. voltages has shape (n_bus, T). batch_size controls how many operating points are solved per GPU chunk. The underlying linear solve can be selected via a backend argument (e.g. "cudss").

```python
from p3s.cuda.NewtonPowerflowCuda import NewtonPowerflowCUDA

npf = NewtonPowerflowCUDA(net)
voltages = npf.calculate_timeseries_cuda(net, timeseries, batch_size=5)
```

--------------------------------

### Solve contingencies with CPU solver solve_contingencies_cpp

Source: https://parallel-pandapower-solver.readthedocs.io/en/stable/_sources/usage.rst.txt

Solves all contingencies in parallel using the CPU backend. n_threads controls parallelism; if not given, all cores are used. reslack_islands=False by default.

```python
from p3s.contingency.solver_cpp import solve_contingencies_cpp

res = solve_contingencies_cpp(net, reslack_islands=False, n_threads=1)
```

--------------------------------

### Clone repository

Source: https://parallel-pandapower-solver.readthedocs.io/en/stable/_sources/installation.rst.txt

Clones the public repository from GitHub to obtain the source files.

```sh
git clone git://github.com/e2niee/parallel-pandapower-solver
```

--------------------------------

### Run p3s test suite

Source: https://parallel-pandapower-solver.readthedocs.io/en/stable/_sources/build.rst.txt

Runs the validation tests located in p3s/cpp/tests/.

```bash
python -m pytest p3s/cpp/tests
```

--------------------------------

### solve_contingencies_cpp

Source: https://parallel-pandapower-solver.readthedocs.io/en/stable/_sources/usage.rst.txt

Solves all N-1 contingencies in parallel on CPU using the C++ backend. Returns a ContingencyResultTable with voltages, served mask, convergence flags, and iteration counts.

```APIDOC
## solve_contingencies_cpp

### Description
Solves all N-1 contingencies in parallel on CPU. The function takes the network and optional parameters for island re-slacking and thread count. Returns a ContingencyResultTable.

### Method
Function call

### Endpoint
from p3s.contingency.solver_cpp import solve_contingencies_cpp

### Parameters
- **net** (pandapower network) - Required - The pandapower network with outage_group columns on lines and transformers.
- **reslack_islands** (bool) - Optional - If True, re-slacks islands that form after an outage so that the whole island is served. If False, such islands are entirely unserved. Default is False.
- **n_threads** (int) - Optional - Number of threads to use in parallel. If not given, all cores are used.

### Request Example
```python
from p3s.contingency.solver_cpp import solve_contingencies_cpp

res = solve_contingencies_cpp(net, reslack_islands=False, n_threads=1)
```

### Response
#### Success Response
- **res** (ContingencyResultTable) - The result table with groups, voltages, served mask, convergence flags, and iterations.

#### Response Example
```python
res = solve_contingencies_cpp(net, reslack_islands=False, n_threads=1)
```
```

--------------------------------

### Diagnose GPU

Source: https://parallel-pandapower-solver.readthedocs.io/en/stable/_sources/installation.rst.txt

Performs in-depth analysis to verify that the powerflow solver works and that the hardware produces correct results.

```sh
python -m p3s.cuda.diagnose_gpu
```

--------------------------------

### Solve contingencies with GPU solver solve_contingencies_cuda

Source: https://parallel-pandapower-solver.readthedocs.io/en/stable/_sources/usage.rst.txt

Solves all contingencies using a GPU backend. backend options: cudss (default), rf (old cusolverRF), qr (more stable but slower). reslack_islands=False by default.

```python
from p3s.contingency.solver_cuda import solve_contingencies_cuda

res = solve_contingencies_cuda(net, reslack_islands=False, backend="cudss")
```

--------------------------------

### Manual result compilation with compile_results.py

Source: https://parallel-pandapower-solver.readthedocs.io/en/stable/benchmark.html

Compile results manually with options to include partial and error-unknown results, specifying an output directory.

```bash
python compile_results.py \
  --include-partial \
  --include-error-unknown \
  --output-dir ./results/235449/
```

--------------------------------

### Time-series data format

Source: https://parallel-pandapower-solver.readthedocs.io/en/stable/usage.html

Describes the dictionary format accepted by batched solvers (calculate_timeseries_cpp, calculate_timeseries_cuda, etc.) for time-series simulation.

```APIDOC
## Time-series data format

### Description
Batched solvers accept a timeseries dictionary mapping each controlled (element, variable) pair to an array of shape (n_element, T). Supported elements are load, sgen, and gen; supported variables are p_mw and q_mvar.

### Parameters
- **timeseries** (dict) - Required - Dictionary with keys as (element, variable) tuples and values as arrays of shape (n_element, T).

### Example
```python
timeseries = {
    ("load", "p_mw"):   p_matrix,   # (n_load,  T)
    ("load", "q_mvar"): q_matrix,   # (n_load,  T)
    ("sgen", "p_mw"):   ...,        # (n_sgen,  T)
    ("gen",  "p_mw"):   ...,        # (n_gen,   T)
}
```
```

--------------------------------

### Batched time-series with C++ solver

Source: https://parallel-pandapower-solver.readthedocs.io/en/stable/_sources/usage.rst.txt

Solve many operating points at once, sharing the symbolic factorisation across the whole batch. voltages has shape (n_bus, T). n_threads=0 (default) uses all available threads; set to 1 for a single thread.

```python
npf = NewtonPowerflowCpp(net)
voltages = npf.calculate_timeseries_cpp(net, timeseries, n_threads=0)
```

--------------------------------

### Solve contingencies on CPU

Source: https://parallel-pandapower-solver.readthedocs.io/en/stable/usage.html

Executes contingency analysis using the CPU-based solver. The n_threads parameter controls parallel execution.

```python
from p3s.contingency.solver_cpp import solve_contingencies_cpp
res = solve_contingencies_cpp(net, reslack_islands=False, n_threads=1)
```

--------------------------------

### NewtonPowerflow.calculate

Source: https://parallel-pandapower-solver.readthedocs.io/en/stable/_sources/usage.rst.txt

Runs the Newton-Raphson AC power-flow solver on a pandapower network. This is the pure-Python implementation (NumPy/SciPy) for transmission networks, PV/generator buses and trafos. It writes results back into the network and returns the converged voltage vector.

```APIDOC
## NewtonPowerflow.calculate

### Description
Runs the Newton-Raphson AC power-flow solver on a pandapower network. This is the pure-Python implementation (NumPy/SciPy) for transmission networks, PV/generator buses and trafos. It writes results back into the network (e.g., `net.res_bus.vm_pu`, `net.res_bus.va_degree`, plus other `res_*` tables) and returns the converged voltage vector.

### Method
Function call

### Endpoint
`from p3s.NewtonPowerflow import NewtonPowerflow`

### Parameters
- **net** (pandapowerNet) - Required - The pandapower network to solve.
- **init** (str) - Optional - Initialisation method: `"dc"` (default) uses a DC power flow; `"flat"` uses a 1.0 pu / 0° flat start. DC init preserves voltage-magnitude set-points at PV buses.
- **tolerance** (float) - Optional - Convergence threshold (infinity norm of the power mismatch). Default is `1e-5`.
- **max_iterations** (int) - Optional - Maximum number of iterations. Default is `30`.
- **Additional keyword arguments** - Optional - Passed through to `scipy.sparse.linalg.spsolve`.

### Request Example
```python
from p3s.NewtonPowerflow import NewtonPowerflow

npf = NewtonPowerflow(net)
voltage = npf.calculate(net, init="dc", tolerance=1e-8, max_iterations=30)
```

### Response
#### Success Response
- **voltage** (array) - The converged voltage vector.
- **net.res_bus.vm_pu** (DataFrame) - Voltage magnitudes written to the network.
- **net.res_bus.va_degree** (DataFrame) - Voltage angles written to the network.
- **net["_ppc"]["iterations"]** (int) - Number of iterations taken.

#### Response Example
```python
voltage = npf.calculate(net, init="dc", tolerance=1e-8, max_iterations=30)
print(voltage)
```
```

--------------------------------

### Calculate transformer tap table

Source: https://parallel-pandapower-solver.readthedocs.io/en/stable/_sources/usage.rst.txt

Compute the tap table for networks with transformers. With inplace=True the result is written to net.trafo_characteristic_table; with the default inplace=False it is returned instead. Call this before any of the solvers for networks that contain trafos.

```python
from p3s.calculateTrafoTapTable import calculateTrafoCharacteristic

calculateTrafoCharacteristic(net, inplace=True)
```

--------------------------------

### solve_contingencies_cuda

Source: https://parallel-pandapower-solver.readthedocs.io/en/stable/_sources/usage.rst.txt

Solves all N-1 contingencies in parallel on GPU using the CUDA backend. Supports multiple backends (cudss, rf, qr) and returns a ContingencyResultTable.

```APIDOC
## solve_contingencies_cuda

### Description
Solves all N-1 contingencies in parallel on GPU. The function takes the network and optional parameters for island re-slacking and backend selection. Returns a ContingencyResultTable.

### Method
Function call

### Endpoint
from p3s.contingency.solver_cuda import solve_contingencies_cuda

### Parameters
- **net** (pandapower network) - Required - The pandapower network with outage_group columns on lines and transformers.
- **reslack_islands** (bool) - Optional - If True, re-slacks islands that form after an outage so that the whole island is served. If False, such islands are entirely unserved. Default is False.
- **backend** (str) - Optional - Backend to use: 'cudss' (cudss backend), 'rf' (old cusolverRF backend), or 'qr' (cuda QR algorithm, more stable but slower). Default is 'cudss'.

### Request Example
```python
from p3s.contingency.solver_cuda import solve_contingencies_cuda

res = solve_contingencies_cuda(net, reslack_islands=False, backend="cudss")
```

### Response
#### Success Response
- **res** (ContingencyResultTable) - The result table with groups, voltages, served mask, convergence flags, and iterations.

#### Response Example
```python
res = solve_contingencies_cuda(net, reslack_islands=False, backend="cudss")
```
```

--------------------------------

### NewtonPowerflowCpp.calculate_timeseries_cpp

Source: https://parallel-pandapower-solver.readthedocs.io/en/stable/_sources/usage.rst.txt

Solves many operating points at once using the C++ solver, sharing the symbolic factorisation across the whole batch. Returns a voltage array of shape (n_bus, T).

```APIDOC
## NewtonPowerflowCpp.calculate_timeseries_cpp

### Description
Solves many operating points at once using the C++ solver, sharing the symbolic factorisation across the whole batch. Returns a voltage array of shape `(n_bus, T)`.

### Method
Function call

### Endpoint
`from p3s.NewtonPowerflowCpp import NewtonPowerflow as NewtonPowerflowCpp`

### Parameters
- **net** (pandapowerNet) - Required - The pandapower network to solve.
- **timeseries** (dict) - Required - Dictionary mapping each controlled `(element, variable)` pair to an array of shape `(n_element, T)`. See Time-series data section.
- **n_threads** (int) - Optional - Number of threads to use. Default `0` uses all available threads; set to `1` for a single thread.

### Request Example
```python
npf = NewtonPowerflowCpp(net)
voltages = npf.calculate_timeseries_cpp(net, timeseries, n_threads=0)
```

### Response
#### Success Response
- **voltages** (array) - Array of shape `(n_bus, T)`, one complex voltage per bus per time step.

#### Response Example
```python
voltages = npf.calculate_timeseries_cpp(net, timeseries, n_threads=0)
print(voltages.shape)
```
```
Tokens:
Raw