🌱

Generation

What do we need to build? PyPSA-based optimization to plan renewable capacity (solar, wind, storage) with weather-informed modeling.

View live example Get started Jump to reference

Framework

A reusable framework for the Generation tool is on the roadmap but not yet funded. PyPSA-VGR currently exists as a full implementation. The code is open source and can be cloned directly.

energy-toolkit-generation

Planned

A reusable framework for the Generation tool is not yet funded. PyPSA-VGR currently exists as a standalone implementation. Contact us if you are interested in funding a framework extraction.

No public framework repository yet. If you are interested in funding a reusable framework extraction, get in touch.

How it works

config (JSON)                ← Scenarios, financial assumptions, geography
    │
    ▼
Generator (PyPSA)            ← Weather data + demand + optimization model
    │
    ▼
Output (CSV/NetCDF)          ← Capacity plans, costs, generation profiles
    │
    ▼
API (file-based)             ← Local filesystem or HTTP server
    │
    ▼
Dashboard (Streamlit)        ← Scenario exploration, capacity mix, LCOE analysis

Generator

The generator uses PyPSA (Python for Power System Analysis) to find the optimal renewable capacity mix. Given a demand profile, weather data, and technology cost assumptions, it determines how much solar, wind, battery storage, and hydrogen capacity is needed to meet demand under different self-sufficiency targets.

PyPSA optimization

Builds a power system network with buses for load, renewables, battery, hydrogen, and turbines. Links model charge/discharge, electrolysis, and gas turbines. Optimizes for minimum cost subject to self-sufficiency and biogas constraints.

Weather-informed capacity factors

Uses ERA5 reanalysis data at 3-hour resolution to compute solar and wind capacity factors. Atlite handles land-cover exclusions using CORINE classification for realistic available area estimates.

Multi-scenario exploration

Configuration defines a scenario space across self-sufficiency targets (50–100%), energy demand variations (-20% to +20%), hydrogen options, offshore wind toggles, and biogas limits. The generator validates and runs all combinations.

Technology cost modeling

Comprehensive cost assumptions from 2020–2050 with multi-currency support (EUR, USD, SEK), present value calculations, and technology learning curves. Covers solar, onshore/offshore wind, battery, hydrogen electrolysis, nuclear, and biogas.

API

The API layer abstracts over the storage backend through a unified interface. The same dashboard code reads scenario data from the local filesystem during development or from any HTTP-accessible store in production.

Frontend (Dashboard)

A Streamlit application with interactive scenario controls and energy system visualizations. Designed for three audience levels.

Scenario explorer

Slider controls for self-sufficiency targets and energy scenarios. Toggle hydrogen, offshore wind, and biogas limits. Bookmarkable URLs preserve parameter state.

Capacity & cost analysis

Energy metric cards showing capacity per technology. Stacked bar charts for generation mix at weekly resolution. LCOE breakdown by energy source. Performance metrics showing met/unmet demand.

Geographic context

Interactive map with Folium for regional selection. Land use comparison showing physical footprint of renewable installations relative to municipal areas.

Technology stack

Generator

Python 3.8+, PyPSA ≥0.28
Atlite (renewable resources)
Pandas, NumPy, GeoPandas
CBC/GLPK/HiGHS solvers

API

File-based (local filesystem)
Optional HTTP server backend
CSV + JSON output formats

Frontend

Streamlit 1.38
Plotly, Altair
Folium (maps)
Bilingual (Swedish/English)

Reference

Technical reference for implementers. Expand the section below for model internals, scenario configuration, input data structure, and deployment details.

▶ Technical reference

Project structure

/pypsa-vgr/
├── model/              # Core PyPSA modeling (network, constraints, assumptions)
├── generator/          # Scenario execution pipeline
├── input/              # All input data
│   ├── assumptions.csv # Technology costs 2020-2050
│   ├── demand/         # Historical demand data (3h resolution)
│   ├── weather/        # ERA5 weather data and capacity factors
│   ├── renewables/     # Renewable resource assessment
│   └── geo/            # Geographic boundaries and land use
├── api/                # Output data directory
├── dashboard/          # Streamlit frontend
├── workspace/          # Analysis Jupyter notebooks
├── paths.py            # Central path configuration
└── environment.yaml    # Conda environment specification

Generator pipeline

The generator runs a sequential pipeline for each scenario combination:

Validation: Checks geographic functions, weather/renewables files exist
Input generation: Creates parameters, demand profiles, network specifications
Optimization: Runs PyPSA model, generates statistics
Output: Produces results and addon results (CSV/NetCDF)
Cleanup: Optional removal of temporary files

Scenario configuration

Scenarios are defined in JSON configuration files with these parameters:

Parameter	Range	Description
Self-sufficiency	50–100% (11 levels)	Target for local generation vs imports
Energy scenario	-20% to +20% (3 levels)	Demand variation from base projection
Hydrogen	on/off	Include hydrogen electrolysis and storage
Offshore wind	on/off	Include offshore wind capacity
Biogas limit	0%, 25%, 50%, 100%	Maximum biogas share of total demand

The generator validates scenario counts (warns >10,000, blocks >50,000) before execution.

PyPSA network model

Buses

Load bus: Where demand is served
Renewable bus: Solar and wind generation
Battery bus: Battery storage
Hydrogen bus: Hydrogen electrolysis and storage
Turbine bus: Gas turbines

Generators

Solar PV, onshore wind, offshore wind
Biogas (market purchase)
Backstop/import at high marginal cost (900 SEK/MWh)

Storage

Lithium-ion batteries with charge/discharge links and cycling constraints
Hydrogen electrolysis → storage → fuel cell path

Constraints

Biogas constraint: Limits biogas imports to a percentage of total demand
Self-sufficiency constraint: Caps energy sourced from market below self-sufficiency threshold
Battery flow constraint: Enforces charge/discharge capacity symmetry

Input data

Technology assumptions

Comprehensive cost and performance data from 2020–2050 in input/assumptions.csv. Key technologies and their 2020 costs:

Technology	Capital Cost (2020)	Lifetime
Solar PV	€560k/MW	25–40 years
Onshore Wind	€1.1–1.2M/MW	25–30 years
Offshore Wind	€2.12M/MW	25–30 years
Battery Storage	€246k/MWh	20–30 years
H2 Electrolysis	€1.3M/MWe	25 years

Weather data

Source: ERA5 reanalysis from Copernicus
Resolution: 3-hour temporal, 0.125° spatial
Year: 2023 baseline
Processing: Atlite generates cutout objects, capacity factors, and availability matrices

Demand data

Historical hourly demand for SE3 region, normalized to 3-hour intervals
Base demand: 19 TWh, target: 34 TWh by 2030
Regional energy percentage breakdowns for VGR municipalities

Geographic data

Swedish municipality boundaries (GeoJSON)
Land use data by municipality
VGR region: 49 municipalities in 4 sub-regions (Fyrbodal, Göteborgsregionen, Sjuhärad, Skaraborg)

Dashboard

Pages

Page	Content
Explorer	Main scenario exploration with charts, cards, and maps
About	Project description (Markdown, bilingual)
Assumptions	Technology costs and land use data tables

API modes

The dashboard's library/api.py abstracts over the storage backend behind a unified interface. The local filesystem backend is used for development; the HTTP-server backend lets the dashboard read scenario data from any HTTP-accessible store in production.

Implementations

Live applications built with the Generation tool.

PyPSA-VGR

VGR

Live

Renewable capacity planner for Västra Götaland. Uses PyPSA optimization to determine the solar, wind, and storage mix needed to meet future demand.

PyPSAStreamlitVästra Götaland

View live example Implementation source

Deploy and extend

The Generation tool deploys as a Docker container running the Streamlit dashboard. Run it on any container platform; scenario data can be served from the local filesystem or any HTTP-accessible store.

# Build and run locally
docker build -t pypsa-vgr .
docker run -p 8501:8501 pypsa-vgr

# Or run directly
streamlit run dashboard/app.py

Get started Implementation source