From 4c8adb3743d957f2829b864a122888c8f9e0762a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Fran=C3=A7ois=20Pacaud?= Date: Wed, 16 Feb 2022 14:20:13 -0600 Subject: [PATCH] update README.md (#229) --- README.md | 52 +++++++++++++++++++++++++++++++++------------------- 1 file changed, 33 insertions(+), 19 deletions(-) diff --git a/README.md b/README.md index 2145f99f..3274f87f 100644 --- a/README.md +++ b/README.md @@ -5,15 +5,19 @@ | [![][docs-stable-img]][docs-stable-url] | [![][build-stable-img]][build-url] | [![][build-latest-img]][build-url] | | | [![][codecov-stable-img]][codecov-stable-url] | [![][codecov-latest-img]][codecov-latest-url] | -ExaPF is a HPC package for solving power flow (PF) on a GPU. It currently solves PF using the Newton-Raphson algorithm on NVIDIA GPUs. -Its main features are: +ExaPF is a HPC package implementing a vectorized modeler +for power systems. It targets primarily GPU architectures, and provides a portable abstraction to model power system on upcoming HPC architectures. -* Using [CUDA.jl](https://juliagpu.gitlab.io/CUDA.jl/) CuArrays arrays for generating CUDA kernels using the broadcast '.' operator. -* Using [ForwardDiff.jl](https://github.com/JuliaDiff/ForwardDiff.jl) and Jacobian coloring to generate the compressed Jacobian of the PF equations. The Jacobian evaluation is taking place fully on the GPU. -* Preconditioned BICGSTAB with support for [Krylov.jl](https://github.com/JuliaSmoothOptimizers/Krylov.jl). -* A block Jacobi preconditioner that updates on the GPU. +Its main features are: +* **Portable approach:** All [expressions](https://exanauts.github.io/ExaPF.jl/dev/lib/formulations/#Constraints) (`PowerFlowBalance`, `CostFunction`, `PowerGenerationBounds`, ...) are evaluated fully on the GPU, without data transfers to the host. +* **Differentiable kernels:** All the expressions are differentiable with [ForwardDiff.jl](https://github.com/JuliaDiff/ForwardDiff.jl). ExaPF uses matrix coloring to generate efficiently the Jacobian and the Hessian in sparse format. +* **Power flow solver:** ExaPF implements a power flow solver working fully on the GPU, based on a Newton-Raphson algorithm. +* **Iterative linear algebra:** ExaPF uses [Krylov.jl](https://github.com/JuliaSmoothOptimizers/Krylov.jl) to solve sparse linear systems entirely on the GPU, together with an overlapping Schwarz preconditioner. -This code will serve as the basis for OPF on GPUs using the reduced gradient method. A similar abstraction than CuArrays will be used to port the code to AMD ROCm and Intel oneAPI through [AMDGPU.jl](https://github.com/JuliaGPU/AMDGPU.jl) and [oneAPI.jl](https://github.com/JuliaGPU/oneAPI.jl), respectively. +ExaPF leverages [KernelAbstractions.jl](https://github.com/JuliaGPU/KernelAbstractions.jl) +to generate portable kernels working on different backends. +Right now, only CUDA is fully supported, but in the medium term we have good hope to support +both [AMD ROCm](https://github.com/JuliaGPU/AMDGPU.jl) and [Intel oneAPI](https://github.com/JuliaGPU/oneAPI.jl). ## Quick-start ### Installation @@ -29,26 +33,36 @@ pkg> test ExaPF ### How to solve the power flow of a given MATPOWER instance? -ExaPF implements a Newton-Raphson algorithm to solve -the power flow equations of a power network. +ExaPF solves the power flow equations of a power network with a Newton-Raphson algorithm: ```julia # Input file julia> case = "case57.m" # Instantiate a PolarForm object on the CPU. +# (Replace CPU() by CUDADevice() to deport computation on a CUDA GPU) julia> polar = ExaPF.PolarForm(case, CPU()) -# Instantiate a Newton-Raphson algorithm with verbose activated -julia> pf_algo = NewtonRaphson(verbose=1) -# Resolution -julia> ExaPF.powerflow(polar, algo) -Iteration 0. Residual norm: 4.295. -Iteration 1. Residual norm: 0.250361. -Iteration 2. Residual norm: 0.00441074. -Iteration 3. Residual norm: 2.81269e-06. -Iteration 4. Residual norm: 3.9111e-12. -ExaPF.ConvergenceStatus(true, 4, 3.911102241031109e-12, 0) +# Initial variables +julia> stack = ExaPF.NetworkStack(polar) +# Solve power flow +julia> conv = run_pf(polar, stack; verbose=1) +#it 0: 6.18195e-01 +#it 1: 8.19603e-03 +#it 2: 7.24135e-06 +#it 3: 4.68355e-12 +Power flow has converged: true + * #iterations: 3 + * Time Jacobian (s) ........: 0.0004 + * Time linear solver (s) ...: 0.0010 + * Time total (s) ...........: 0.0014 ``` +For more information on how to solve power flow on the GPU, +please refer to the [quickstart guide](https://exanauts.github.io/ExaPF.jl/dev/quickstart/). + +## Extensions + +- [Argos.jl](https://github.com/exanauts/Argos.jl/) uses ExaPF as a modeler to accelerate the resolution of OPF problems on CUDA GPU. + ## Development We welcome any contribution to ExaPF! Bug fixes or feature requests