FDNA Power Grid Cascading Failure Analysis

Implementation of Functional Dependency Network Analysis (FDNA) for quantifying systemic risk in power grid infrastructure.

Overview

This repository contains the complete Python implementation for applying FDNA methodology to power systems analysis. The code implements:

• Multi-layer dependency modeling (Physical, Cyber, Mission layers)
• Cascading failure propagation simulation
• Risk quantification metrics (TSI, CAF, CCI)
• IEEE standard test system integration (14-bus, 30-bus)
• Comparative validation with traditional methods

Project Structure

fdna_research/
├── code/                          # Python implementation
│   ├── fdna_core.py              # Core FDNA algorithm
│   ├── ieee_bus_fdna.py          # IEEE bus system adapter
│   ├── run_core_experiments.py   # Main experiment runner
│   ├── run_experiments.py        # Extended experiments
│   ├── generate_validation_data.py  # Validation data generator
│   ├── run_comparative_validation.py # Method comparison
│   ├── create_visualizations.py   # Figure generation
│   ├── create_publication_quality_figures.py  # Publication figures
│   ├── create_high_quality_diagrams.py  # Architecture diagrams
│   └── regenerate_figures_readable.py  # Figure regeneration
├── data/                          # System data and parameters
│   └── ieee14_model_info.json
├── results/                       # Experimental results (generated)
└── figures/                       # Generated figures (generated)

Installation

Requirements

• Python 3.8 or higher
• pip package manager

Install Dependencies

pip install -r requirements.txt

Or install individually:

pip install numpy pandas networkx matplotlib seaborn pandapower

Usage

1. Run Core Experiments

Execute the main experiments on IEEE test systems:

cd code
python3 run_core_experiments.py

This will:

• Load IEEE 14-bus and 30-bus systems
• Simulate various failure scenarios
• Calculate TSI and CAF metrics
• Save results to ../results/ directory

2. Generate Validation Data

Create comparative validation data:

python3 generate_validation_data.py

3. Run Comparative Validation

Compare FDNA with traditional methods:

python3 run_comparative_validation.py

4. Generate Visualizations

Create publication-quality figures:

python3 create_visualizations.py

Or create specific figure types:

python3 create_publication_quality_figures.py
python3 create_high_quality_diagrams.py
python3 regenerate_figures_readable.py

5. Extended Experiments

Run comprehensive experiments:

python3 run_experiments.py

Core Components

FDNA Core (fdna_core.py)

Implements the fundamental FDNA algorithm:

• FDNANode: Component representation with operability
• FDNAEdge: Dependency relationships (α, β parameters)
• FDNAModel: Main model class with cascade propagation
  • calculate_sod(): Supply of Dependency
  • calculate_cod(): Capacity of Dependency
  • propagate_cascade(): Failure propagation simulation
  • calculate_tsi(): Total System Impact
  • calculate_caf(): Cascade Amplification Factor
  • calculate_cci(): Critical Component Index

IEEE Bus Adapter (ieee_bus_fdna.py)

Converts IEEE standard test systems to FDNA models:

• Loads IEEE 14-bus and 30-bus systems from PandaPower
• Creates multi-layer dependency models
• Defines realistic dependency parameters (α, β)

Key Metrics

Total System Impact (TSI)

TSI = Σ_i w_i · (1 - P_i,final)

Cascade Amplification Factor (CAF)

CAF = TSI / Initial_Impact

Supply of Dependency (SOD)

SOD_i(t) = min_{j ∈ D_i} { P_j(t) / β_ij }

Capacity of Dependency (COD)

COD_i(t) = ∏_{j ∈ D_i} (1 - α_ij(1 - P_j(t)))

Output Files

Results Directory (results/)

• core_experiments.csv: Main experimental results
• core_experiments.json: Detailed results in JSON format
• summary_statistics.json: Aggregate statistics
• validation_data.json: Comparative validation data
• comparative_validation.json: Method comparison results

Figures Directory (figures/)

• caf_comparison.png: Cascade amplification comparison
• failure_propagation.png: Temporal failure propagation
• system_comparison.png: IEEE 14-bus vs 30-bus comparison
• methodology_flowchart.png: FDNA workflow diagram
• system_architecture.png: Multi-layer architecture diagram
• cascade_flow.png: Cascade propagation flow diagram

Methodology

FDNA (Functional Dependency Network Analysis) is an established methodology for analyzing system dependencies and cascading failures. This implementation applies FDNA to power grid infrastructure, modeling:

1. Physical Layer: Generators, transformers, transmission lines, buses, loads
2. Cyber Layer: SCADA systems, RTUs, communication networks
3. Mission Layer: Critical services, power delivery, grid stability

The model simulates cascading failures by iteratively updating component operability based on dependency relationships until convergence.

References

FDNA Methodology

• Garvey, P. R., & Pinto, C. A. (2009). Introduction to functional dependency network analysis. The MITRE Corporation, Tech. Rep. 09-4602.
• Servi, L. D., & Garvey, P. R. (2018). Deriving global criticality conditions from local dependencies using Functional Dependency Network Analysis (FDNA). Systems Engineering, 21(4), 349-360.

IEEE Test Systems

• Thurner, L., et al. (2018). pandapower - an Open-Source Python Tool for Advanced Power System Modeling and Analysis. IEEE Transactions on Power Systems, 33(6), 6837-6845.

License

This research implementation is provided for academic purposes.

Contact

For questions about this implementation, please refer to the code comments and documentation within each module.