PowerSimulations.jl

https://nrel-sienna.github.io/PowerSimulations.jl/stable
Admin
PowerSimulations.jl is a flexible, open-source power system operations simulation tool for...
Tokens:138,427
Snippets:503
Trust Score:8.3
Update:1 year ago
Show doc for...
Tokens:
Raw
### PowerSimulations.jl Quick Start Guide

Source: https://nrel-sienna.github.io/PowerSimulations.jl/stable/model_developer_guide/troubleshooting

The Quick Start Guide provides a rapid introduction to installing and using PowerSimulations.jl.

```APIDOC
PowerSimulations.jl Quick Start Guide:

Get started with PowerSimulations.jl quickly.

This guide covers:
- Installation instructions.
- Basic usage examples.

Find the guide at: [https://nrel-sienna.github.io/PowerSimulations.jl/stable/quick_start_guide/](https://nrel-sienna.github.io/PowerSimulations.jl/stable/quick_start_guide/)
```

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

### PowerSimulations.jl Code Base Developer Guide: Developer Guide

Source: https://nrel-sienna.github.io/PowerSimulations.jl/stable/modeler_guide/running_a_simulation

A guide for developers contributing to the PowerSimulations.jl codebase, outlining development practices and contribution guidelines.

```Julia
# Contributing to PowerSimulations.jl:
# 1. Fork the repository and create a new branch.
# 2. Make your changes and add tests.
# 3. Ensure code follows project style guidelines.
# 4. Submit a pull request.

```

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

### Install PowerSimulations.jl

Source: https://nrel-sienna.github.io/PowerSimulations.jl/stable/index

Installs the latest stable release of PowerSimulations.jl using the Julia package manager. Also shows how to checkout the main development branch.

```julia
]
add PowerSimulations

]
add PowerSimulations#main
```

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

### Formulation Library - Introduction

Source: https://nrel-sienna.github.io/PowerSimulations.jl/stable/formulation_library/Introduction

Introduction to the formulation library, explaining the structure and providing examples of formulations used in PowerSimulations.jl.

```APIDOC
Formulation Library - Introduction:

This section introduces the formulation library, which contains mathematical models for various power system components.

Key Concepts:
- **Example Formulation**: Demonstrates how to define a custom device model.
- **Nomenclature**: Explains the standard naming conventions used for variables, parameters, and expressions.

**Example Formulation Structure:**
```APIDOC
struct MyCustomDevice <: Device
    name::String
    capacity::Float64
    # other parameters...
end

function build_my_custom_device!(canonical::CanonicalModel, 
                                device_type::Type{MyCustomDevice},
                                device_name::String,
                                inputs::Dict{Symbol,Any})::Nothing
    # Model definition for MyCustomDevice
    # ...
end
```

**Nomenclature:**
Variables, parameters, and expressions follow a consistent naming convention to ensure clarity and ease of use. For instance, active power variables are typically named `P_` followed by the device name and stage.

This library provides building blocks for creating detailed power system models.
```

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

### Parallel Simulations Guide

Source: https://nrel-sienna.github.io/PowerSimulations.jl/stable/modeler_guide/parallel_simulations

This section details how to run simulations in parallel on both local computers and High-Performance Computing (HPC) environments. It covers the setup and execution of parallel simulations.

```APIDOC
Run a Simulation in Parallel on a local computer:
  - Description: Instructions for setting up and running parallel simulations on a local machine.
  - Related: Run a Simulation in Parallel on an HPC

Run a Simulation in Parallel on an HPC:
  - Description: Instructions for setting up and running parallel simulations on a High-Performance Computing cluster.
  - Related: Run a Simulation in Parallel on a local computer
```

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

### PowerSimulations.jl Tutorials

Source: https://nrel-sienna.github.io/PowerSimulations.jl/stable/model_developer_guide/troubleshooting

This section offers tutorials for PowerSimulations.jl, including guides on single-step problems and multi-stage production cost simulations.

```APIDOC
PowerSimulations.jl Tutorials:

Learn how to use PowerSimulations.jl through practical examples.

Tutorials available:
- **Single-step Problem**: Guide to setting up and solving a single-step optimization problem.
- **Multi-stage Production Cost Simulation**: Tutorial on simulating multi-stage production cost scenarios.

Access the tutorials here: [https://nrel-sienna.github.io/PowerSimulations.jl/stable/tutorials/](https://nrel-sienna.github.io/PowerSimulations.jl/stable/tutorials/)
```

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

### PowerSimulations.jl Modeler Guide: Operations Problem Templates

Source: https://nrel-sienna.github.io/PowerSimulations.jl/stable/modeler_guide/running_a_simulation

Guides users on creating and utilizing `ProblemTemplate`s for defining power system operations problems.

```Julia
using PowerSimulations

# Creating a ProblemTemplate
problem = ProblemTemplate(network_model=StandardPTDFModel)

# Adding components like generators and branches
# add_device!(problem, ThermalGen, ThermalStandard)
# add_branch!(problem, Line)

# Configuring objective functions and constraints
# set_objective!(problem, :minimize, PowerCost())

```

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

### PowerSimulations.jl Modeler Guide: Definitions

Source: https://nrel-sienna.github.io/PowerSimulations.jl/stable/modeler_guide/running_a_simulation

Explains the fundamental definitions and concepts used within the PowerSimulations.jl modeling framework.

```Julia
using PowerSimulations

# Example of defining a device model
# struct MyThermalGen <: Device
#     name::String
#     capacity::Float64
# end

# Example of adding a device to a problem template
# problem = ProblemTemplate()
# add_device!(problem, MyThermalGen, ThermalStandard)

```

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

### PowerSimulations.jl Modeler Guide: Modeling FAQ

Source: https://nrel-sienna.github.io/PowerSimulations.jl/stable/modeler_guide/running_a_simulation

Addresses frequently asked questions related to modeling power systems using PowerSimulations.jl.

```Julia
# Common questions might include:
# - How to model a specific type of generator?
# - How to handle time-varying parameters?
# - What are the best practices for network model selection?
# Consult the documentation sections for specific answers.

```

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

### Build Simulation Example

Source: https://nrel-sienna.github.io/PowerSimulations.jl/stable/modeler_guide/parallel_simulations

Provides an example of how to construct a Simulation object and call the build! function within the build_simulation function. It includes error handling for build failures.

```julia
sim = Simulation(
    name=simulation_name,
    steps=partitions.num_steps,
    models=models,
    sequence=sequence,
    simulation_folder=output_dir,
)
status = build!(sim; partitions=partitions, index=index, serialize=isnothing(index))
if status != PSI.SimulationBuildStatus.BUILT
    error("Failed to build simulation: status=$status")
end
```

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

### PowerSimulations.jl Model Developer Guide

Source: https://nrel-sienna.github.io/PowerSimulations.jl/stable/model_developer_guide/troubleshooting

The Model Developer Guide is for users who need to extend or modify PowerSimulations.jl. It covers the structure of operation problems, troubleshooting, and general developer information.

```APIDOC
PowerSimulations.jl Model Developer Guide:

This guide is intended for developers contributing to or extending PowerSimulations.jl.

Key sections:
- **Operation Problem Structure**: Details on the internal structure of operation problems.
- **Troubleshooting**: Common issues and solutions for developers.
- **Developer Guide**: General guidelines for development.
- **Internals**: Information about the package's internal workings.

Access the guide here: [https://nrel-sienna.github.io/PowerSimulations.jl/stable/model_developer_guide/](https://nrel-sienna.github.io/PowerSimulations.jl/stable/model_developer_guide/)
```

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

### PowerSimulations.jl Modeler Guide: Reading Results

Source: https://nrel-sienna.github.io/PowerSimulations.jl/stable/modeler_guide/running_a_simulation

Provides instructions on how to access and interpret the results generated from PowerSimulations.jl simulations.

```Julia
using PowerSimulations

# Assuming 'results' is the output from run_simulation
# results = run_simulation(problem, sequence)

# Reading specific results, e.g., generator dispatch
# gen_dispatch = get_realized_variable(results, :P, ThermalGen)

# Reading network flows
# line_flow = get_realized_variable(results, :FlowActivePower, Line)

```

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

### PowerSimulations.jl Modeler Guide

Source: https://nrel-sienna.github.io/PowerSimulations.jl/stable/model_developer_guide/troubleshooting

The Modeler Guide explains the structure and usage of PowerSimulations.jl for modeling power systems. It covers definitions, problem templates, running simulations, reading results, simulation recorder, logging, debugging, and parallel simulations.

```APIDOC
PowerSimulations.jl Modeler Guide:

This guide provides essential information for users modeling power systems with PowerSimulations.jl.

Key topics include:
- **Definitions**: Understanding the core concepts and terminology.
- **PowerSimulations.jl Modeling Structure**: Overview of the package's architecture.
- **Operations `ProblemTemplate`s**: How to define and use problem templates.
- **Simulation**: Steps for running a simulation.
- **Read results**: Methods for accessing simulation outputs.
- **Simulation Recorder**: Functionality for recording simulation progress.
- **Logging**: Configuring and using logging.
- **Debugging infeasible models**: Strategies for resolving infeasibilities.
- **Parallel Simulations**: Techniques for running simulations in parallel.
- **Modeling FAQ**: Frequently asked questions.

For detailed information, visit: [https://nrel-sienna.github.io/PowerSimulations.jl/stable/modeler_guide/](https://nrel-sienna.github.io/PowerSimulations.jl/stable/modeler_guide/)
```

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

### PowerSimulations.jl Example Usage

Source: https://nrel-sienna.github.io/PowerSimulations.jl/stable/api/PowerSimulations

Illustrates the creation of a ProblemTemplate and a DecisionModel in PowerSimulations.jl.

```Julia
template = ProblemTemplate(CopperPlatePowerModel, devices, branches, services)
OpModel = DecisionModel(MockOperationProblem, template, system)

```

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

### PowerSimulations.jl Model Developer Guide: Troubleshooting

Source: https://nrel-sienna.github.io/PowerSimulations.jl/stable/modeler_guide/running_a_simulation

Offers guidance on troubleshooting common issues encountered during the development and use of PowerSimulations.jl models.

```Julia
# Troubleshooting tips:
# - Check data formats and units.
# - Verify model formulations against theoretical concepts.
# - Use debugging tools and logging effectively.
# - Consult the GitHub issues for known problems and solutions.

```

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

### API Reference

Source: https://nrel-sienna.github.io/PowerSimulations.jl/stable/modeler_guide/read_results

Provides detailed API documentation for PowerSimulations.jl, including function signatures, parameter descriptions, and usage examples.

```APIDOC
PowerSimulations.jl API Reference:

This section provides detailed documentation for the PowerSimulations.jl library, covering its various modules, functions, and data structures.

Modules:
- Core: Basic functionalities and data structures.
- Formulations: Definitions of various power system model formulations.
- Simulations: Tools for running and managing simulations.
- IO: Functions for reading and writing simulation data.

Key Functions:

`run_simulation(system, models, optimizer, time_steps)`
  - Description: Executes a power system simulation.
  - Parameters:
    - system: The power system model.
    - models: A list of optimization models to be solved.
    - optimizer: The optimization solver to use.
    - time_steps: The number of time steps for the simulation.
  - Returns: Simulation results.

`read_results(simulation_output)`
  - Description: Reads and processes the results of a simulation.
  - Parameters:
    - simulation_output: The output from a simulation run.
  - Returns: Processed simulation results.

`create_system(data)`
  - Description: Creates a power system object from input data.
  - Parameters:
    - data: Input data for the power system.
  - Returns: A PowerSystem object.

`add_device!(system, device)`
  - Description: Adds a device to the power system.
  - Parameters:
    - system: The power system object.
    - device: The device to add.
  - Returns: Nothing.

`remove_device!(system, device_name)`
  - Description: Removes a device from the power system.
  - Parameters:
    - system: The power system object.
    - device_name: The name of the device to remove.
  - Returns: Nothing.

`get_device(system, device_name)`
  - Description: Retrieves a device from the power system.
  - Parameters:
    - system: The power system object.
    - device_name: The name of the device to retrieve.
  - Returns: The specified device.

`get_components(system, component_type)`
  - Description: Retrieves all components of a specified type from the system.
  - Parameters:
    - system: The power system object.
    - component_type: The type of component to retrieve (e.g., :Generator, :Line).
  - Returns: A list of components of the specified type.

`get_variables(results, variable_name)`
  - Description: Retrieves simulation variables from the results.
  - Parameters:
    - results: The simulation results object.
    - variable_name: The name of the variable to retrieve.
  - Returns: The values of the specified variable.

`get_parameters(results, parameter_name)`
  - Description: Retrieves simulation parameters from the results.
  - Parameters:
    - results: The simulation results object.
    - parameter_name: The name of the parameter to retrieve.
  - Returns: The values of the specified parameter.

`get_objective_value(results)`
  - Description: Retrieves the objective function value from the simulation results.
  - Parameters:
    - results: The simulation results object.
  - Returns: The objective function value.

`get_status(results)`
  - Description: Retrieves the solution status of the optimization problem.
  - Parameters:
    - results: The simulation results object.
  - Returns: The solution status (e.g., :Optimal, :Infeasible).

`get_model(results)`
  - Description: Retrieves the optimization model used in the simulation.
  - Parameters:
    - results: The simulation results object.
  - Returns: The optimization model.

`get_time_stamps(results)`
  - Description: Retrieves the time stamps associated with the simulation results.
  - Parameters:
    - results: The simulation results object.
  - Returns: A list of time stamps.

`get_internal_model(results)`
  - Description: Retrieves the internal model representation used by the solver.
  - Parameters:
    - results: The simulation results object.
  - Returns: The internal model representation.

`get_raw_result(results)`
  - Description: Retrieves the raw result object from the solver.
  - Parameters:
    - results: The simulation results object.
  - Returns: The raw solver result.

`get_dual(results, constraint_name)`
  - Description: Retrieves the dual values for a given constraint.
  - Parameters:
    - results: The simulation results object.
    - constraint_name: The name of the constraint.
  - Returns: The dual values for the constraint.

`get_slacks(results, constraint_name)`
  - Description: Retrieves the slack values for a given constraint.
  - Parameters:
    - results: The simulation results object.
    - constraint_name: The name of the constraint.
  - Returns: The slack values for the constraint.

`get_expressions(results, expression_name)`
  - Description: Retrieves the values of defined expressions from the results.
  - Parameters:
    - results: The simulation results object.
    - expression_name: The name of the expression.
  - Returns: The values of the expression.

`get_warm_start_values(results)`
  - Description: Retrieves warm-start values from the simulation results.
  - Parameters:
    - results: The simulation results object.
  - Returns: Warm-start values.

`get_solution_summary(results)`
  - Description: Retrieves a summary of the solution, including status and objective value.
  - Parameters:
    - results: The simulation results object.
  - Returns: A solution summary.

`get_iteration_count(results)`
  - Description: Retrieves the number of iterations performed by the solver.
  - Parameters:
    - results: The simulation results object.
  - Returns: The iteration count.

`get_solve_time(results)`
  - Description: Retrieves the time taken by the solver to find the solution.
  - Parameters:
    - results: The simulation results object.
  - Returns: The solve time.

`get_node_results(results, node_name)`
  - Description: Retrieves results for a specific node in a multi-stage simulation.
  - Parameters:
    - results: The simulation results object.
    - node_name: The name of the node.
  - Returns: Results for the specified node.

`get_stage_results(results, stage_number)`
  - Description: Retrieves results for a specific stage in a multi-stage simulation.
  - Parameters:
    - results: The simulation results object.
    - stage_number: The number of the stage.
  - Returns: Results for the specified stage.

`get_simulation_time(results)`
  - Description: Retrieves the total simulation time.
  - Parameters:
    - results: The simulation results object.
  - Returns: The total simulation time.

`get_simulation_status(results)`
  - Description: Retrieves the overall status of the simulation.
  - Parameters:
    - results: The simulation results object.
  - Returns: The overall simulation status.

`get_simulation_objective(results)`
  - Description: Retrieves the overall objective value of the simulation.
  - Parameters:
    - results: The simulation results object.
  - Returns: The overall simulation objective value.

`get_simulation_iterations(results)`
  - Description: Retrieves the total number of iterations across all stages of the simulation.
  - Parameters:
    - results: The simulation results object.
  - Returns: The total number of iterations.

`get_simulation_solve_time(results)`
  - Description: Retrieves the total solve time across all stages of the simulation.
  - Parameters:
    - results: The simulation results object.
  - Returns: The total solve time.

`get_simulation_warm_start_values(results)`
  - Description: Retrieves warm-start values for the entire simulation.
  - Parameters:
    - results: The simulation results object.
  - Returns: Warm-start values for the simulation.

`get_simulation_solution_summary(results)`
  - Description: Retrieves a summary of the entire simulation's solution.
  - Parameters:
    - results: The simulation results object.
  - Returns: A simulation solution summary.

`get_simulation_dual(results, constraint_name)`
  - Description: Retrieves dual values for a constraint across all stages of the simulation.
  - Parameters:
    - results: The simulation results object.
    - constraint_name: The name of the constraint.
  - Returns: Dual values for the constraint across all stages.

`get_simulation_slacks(results, constraint_name)`
  - Description: Retrieves slack values for a constraint across all stages of the simulation.
  - Parameters:
    - results: The simulation results object.
    - constraint_name: The name of the constraint.
  - Returns: Slack values for the constraint across all stages.

`get_simulation_expressions(results, expression_name)`
  - Description: Retrieves the values of defined expressions across all stages of the simulation.
  - Parameters:
    - results: The simulation results object.
    - expression_name: The name of the expression.
  - Returns: Values of the expression across all stages.

`get_simulation_internal_model(results)`
  - Description: Retrieves the internal model representation used by the solver across all stages.
  - Parameters:
    - results: The simulation results object.
  - Returns: Internal model representation across all stages.

`get_simulation_raw_result(results)`
  - Description: Retrieves the raw result object from the solver across all stages.
  - Parameters:
    - results: The simulation results object.
  - Returns: Raw solver result across all stages.

`get_simulation_node_results(results, node_name)`
  - Description: Retrieves results for a specific node across all stages of a multi-stage simulation.
  - Parameters:
    - results: The simulation results object.
    - node_name: The name of the node.
  - Returns: Results for the specified node across all stages.

`get_simulation_stage_results(results, stage_number)`
  - Description: Retrieves results for a specific stage in a multi-stage simulation.
  - Parameters:
    - results: The simulation results object.
    - stage_number: The number of the stage.
  - Returns: Results for the specified stage.

`get_simulation_time_stamps(results)`
  - Description: Retrieves the time stamps associated with the simulation results across all stages.
  - Parameters:
    - results: The simulation results object.
  - Returns: A list of time stamps across all stages.

Error Handling:
- Infeasible models: The `get_status` function will return `:Infeasible` if the model cannot be solved.
- Solver errors: Specific solver errors may be returned by the underlying optimization library.
```

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

### PowerSimulations.jl Modeler Guide: Parallel Simulations

Source: https://nrel-sienna.github.io/PowerSimulations.jl/stable/modeler_guide/running_a_simulation

Explains how to leverage parallel computing capabilities in PowerSimulations.jl to accelerate simulation runs.

```Julia
using PowerSimulations
using Distributed

# Add worker processes
# addprocs(4) # Add 4 worker processes

# Ensure PowerSimulations is loaded on workers
# @everywhere using PowerSimulations

# Run simulation in parallel (conceptual)
# results = run_simulation_parallel(problem, sequence)

```

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

### PowerSimulations.jl DeviceModel Assignment Example

Source: https://nrel-sienna.github.io/PowerSimulations.jl/stable/formulation_library/Introduction

Shows the mapping of PowerSystems.jl device types to specific PowerSimulations.jl DeviceModel formulations for a given system configuration.

```julia
Type | Formulation
--|--
Network | `CopperPlatePowerModel`
`ThermalStandard` | `ThermalDispatchNoMin`
`RenewableDispatch` | `RenewableFullDispatch`
`PowerLoad` | `StaticPowerLoad`
```

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

### Example Optimization Problem Structure

Source: https://nrel-sienna.github.io/PowerSimulations.jl/stable/formulation_library/Introduction

Illustrates the abstract form of an optimization problem in PowerSimulations.jl with multiple DeviceModels, showing the minimization of device-specific objectives subject to network and device constraints.

```mathematics
\begin{align*} &\min_{\boldsymbol{x}}~ \text{Objective\_DeviceModelA} + \text{Objective\_DeviceModelB} + \text{Objective\_DeviceModelC} \\ &~~\text{s.t.} \\ & \hspace{0.9cm} \text{Constraints\_NetworkModel} \\ & \hspace{0.9cm} \text{Constraints\_DeviceModelA} \\ & \hspace{0.9cm} \text{Constraints\_DeviceModelB} \\ & \hspace{0.9cm} \text{Constraints\_DeviceModelC} \end{align*}
```

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

### PowerSimulations.jl Code Base Developer Guide: Internals

Source: https://nrel-sienna.github.io/PowerSimulations.jl/stable/modeler_guide/running_a_simulation

Explores the internal workings and architecture of the PowerSimulations.jl package for advanced users and developers.

```Julia
# Understanding internal components:
# - Data structures for representing power systems.
# - Optimization solver integration.
# - Simulation engine logic.
# Refer to the source code for detailed implementation information.

```

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

### PowerSimulations.jl Modeler Guide: Logging

Source: https://nrel-sienna.github.io/PowerSimulations.jl/stable/modeler_guide/running_a_simulation

Details the logging mechanisms within PowerSimulations.jl for monitoring simulation execution and debugging.

```Julia
using PowerSimulations
using Logging

# Setting up logging levels (example)
# global_logger(ConsoleLogger(stderr, Logging.Info))

# PowerSimulations.jl logs messages during simulation execution.
# Check the console output for log messages.

```

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

### PowerSimulations.jl Modeler Guide: Simulation Recorder

Source: https://nrel-sienna.github.io/PowerSimulations.jl/stable/modeler_guide/running_a_simulation

Explains the functionality of the simulation recorder for logging and tracking simulation progress and data.

```Julia
using PowerSimulations

# Configuring the simulation recorder (conceptual)
# recorder = SimulationRecorder(path="./output")
# add_recorder!(problem, recorder)

# The recorder automatically logs simulation steps and data.

```

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

### PowerSimulations.jl Modeler Guide: Debugging Infeasible Models

Source: https://nrel-sienna.github.io/PowerSimulations.jl/stable/modeler_guide/running_a_simulation

Offers strategies and techniques for identifying and resolving infeasibilities in power system optimization models created with PowerSimulations.jl.

```Julia
using PowerSimulations

# When a simulation results in an infeasibility:
# 1. Check constraints and bounds for devices and branches.
# 2. Use the logging output to pinpoint the stage or constraint causing infeasibility.
# 3. Simplify the model to isolate the issue.
# 4. Review the formulation library for correct usage of components.

```

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

### Solving Optimization Models

Source: https://nrel-sienna.github.io/PowerSimulations.jl/stable/api/PowerSimulations

Examples demonstrating how to solve an operation model, with an option to export problem results. Exporting results can reduce solution times during simulation.

```julia
results = solve!(OpModel)
results = solve!(OpModel, export_problem_results = true)
```

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

### PowerSimulations.jl Nomenclature Guide

Source: https://nrel-sienna.github.io/PowerSimulations.jl/stable/formulation_library/Introduction

Explains the conventions for using lowercase for variables, uppercase for parameters, subscripts for indexing (e.g., time), superscripts for descriptions (e.g., thermal), and bold for vectors in PowerSimulations.jl formulations.

```APIDOC
Nomenclature:
  Variables: Lowercase letters (e.g., ppp for power).
  Parameters: Uppercase letters (e.g., CCC for costs).
  Indexing: Subscripts (e.g., (⋅)t for indexing at time t).
  Descriptions: Superscripts (e.g., (⋅)th to describe a thermal variable/parameter).
  Vectors: Bold letters (e.g., p = \{p\}_1,...,24).
```

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

### Conda Environment Setup Commands

Source: https://nrel-sienna.github.io/PowerSimulations.jl/stable/modeler_guide/parallel_simulations

These Julia commands are used to set up a Conda environment named 'jade' with Python and Conda installed, and then configure the Julia environment to use this specific Conda environment for PyCall integration.

```julia
run(`conda create -n conda_jl python conda`)
ENV["CONDA_JL_HOME"] = joinpath(ENV["HOME"], ".conda-envs", "jade")  # change this to your path
pkg> build Conda
```

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

### Add Start Type Constraint for ThermalMultiStart

Source: https://nrel-sienna.github.io/PowerSimulations.jl/stable/code_base_developer_guide/internal

Constructs constraints that restrict thermal generation units with multiple start types to only one type of start at a time. This is essential for accurate modeling of unit commitment.

```Julia
add_constraints!(container::PowerSimulations.OptimizationContainer, _::Type{StartTypeConstraint}, devices::InfrastructureSystems.FlattenIteratorWrapper{T<:ThermalMultiStart}, model::DeviceModel{T<:ThermalMultiStart, ThermalMultiStartUnitCommitment}, _::NetworkModel)

# Constructs contraints that restricts devices to one type of start at a time
**Equations**
sum(var_starts[name, s, t] for s in starts) = var_start[name, t]
**LaTeX**
$\sum^{S_g}_{s=1} δ^{s}(t) \eq x^{start}(t)$
```

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

### PowerSimulations.jl Formulation Library: Introduction

Source: https://nrel-sienna.github.io/PowerSimulations.jl/stable/modeler_guide/running_a_simulation

An introduction to the formulation library, explaining its purpose and how it facilitates the definition of various power system components and behaviors.

```Julia
using PowerSimulations

# The formulation library provides pre-defined models for:
# - Generators (Thermal, Renewable)
# - Loads
# - Branches (Lines, Transformers)
# - Services (Ancillary Services)
# These formulations can be customized or extended.

```

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

### Formulation Library - General Models

Source: https://nrel-sienna.github.io/PowerSimulations.jl/stable/formulation_library/Introduction

Details on general formulations used in PowerSimulations.jl, covering common components and their modeling approaches.

```APIDOC
Formulation Library - General:

This section covers general formulations applicable to various power system components in PowerSimulations.jl.

Includes models for:
- **Nodes**: Buses and their properties.
- **Branches**: Transmission lines, transformers, and their characteristics.
- **Storage Units**: Modeling of energy storage systems.

**Example: Branch Model**
```APIDOC
struct Line <: Branch
    name::String
    from_node::Node
    to_node::Node
    active_power_flow::Float64
    reactive_power_flow::Float64
    # other parameters...
end

function build_line_model!(canonical::CanonicalModel, 
                           device_type::Type{Line},
                           device_name::String,
                           inputs::Dict{Symbol,Any})::Nothing
    # Model definition for Line
    # ...
end
```

These general formulations serve as a foundation for more specific device models.
```

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

### Example Optimization Problem with Specific Formulations

Source: https://nrel-sienna.github.io/PowerSimulations.jl/stable/formulation_library/Introduction

Presents a concrete optimization problem for a system with thermal and renewable units, demonstrating the objective function and constraints based on assigned DeviceModel formulations like CopperPlatePowerModel, ThermalDispatchNoMin, RenewableFullDispatch, and StaticPowerLoad.

```mathematics
\begin{align*} &\min_{\boldsymbol{p}^{\text{th}}, \boldsymbol{p}^{\text{re}}}~ \sum_{t=1}^{48} C^{\text{th}} p_t^{\text{th}} - C^{\text{re}} p_t^{\text{re}} \\ & ~~	ext{s.t.} \\ & \hspace{0.9cm} p_t^{\text{th}} + p_t^{\text{re}} = P_t^{\text{load}}, \quad \forall t \in {1,\dots, 48} \\ & \hspace{0.9cm} 0 le p_t^{\text{th}} \le P^{\text{th,max}} \\ & \hspace{0.9cm} 0 le p_t^{\text{re}} \le \text{ActivePowerTimeSeriesParameter}_t \end{align*}
```

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

### Simulation Setup and Execution

Source: https://nrel-sienna.github.io/PowerSimulations.jl/stable/modeler_guide/running_a_simulation

This code snippet demonstrates the complete process of setting up and running a simulation pipeline in PowerSimulations.jl. It includes creating Decision Models for Unit Commitment (UC) and Economic Dispatch (ED), defining feedforwards, configuring the simulation sequence with inter-problem chronology, building the simulation, and executing it.

```julia
using PowerSimulations
using Xpress
using TimeStructures

# Assume template_uc, template_ed, sys_da, sys_rt, and start_time are defined

# Create the UC Decision Model
decision_model_uc = DecisionModel(
    template_uc,
    sys_da;
    name = "UC",
    optimizer = optimizer_with_attributes(
        Xpress.Optimizer,
        "MIPRELSTOP" => 1e-1,
    ),
)

# Create the ED Decision Model
decision_model_ed = DecisionModel(
    template_ed,
    sys_rt;
    name = "ED",
    optimizer = optimizer_with_attributes(Xpress.Optimizer),
)

# Specify the SimulationModels using a Vector of decision_models: UC, ED
sim_models = SimulationModels(;
    decision_models = [
        decision_model_uc,
        decision_model_ed,
    ],
)

# Create the FeedForwards:
semi_ff = SemiContinuousFeedforward(;
    component_type = ThermalStandard,
    source = OnVariable,
    affected_values = [ActivePowerVariable],
)

# Specify the sequencing:
sim_sequence = SimulationSequence(;
    # Specify the vector of decision models: sim_models
    models = sim_models,
    # Specify a Dict of feedforwards on which the FF applies
    # based on the DecisionModel name, in this case "ED"
    feedforwards = Dict(
        "ED" => [semi_ff],
    ),
    # Specify the chronology, in this case inter-stage
    ini_cond_chronology = InterProblemChronology(),
)

# Construct the simulation:
sim = Simulation(;
    name = "compact_sim",
    steps = 10, # 10 days
    models = sim_models,
    sequence = sim_sequence,
    # Specify the start_time as a DateTime: e.g. DateTime("2020-10-11T00:00:00")
    initial_time = start_time,
    # Specify a temporary folder to avoid storing logs if not needed
    simulation_folder = mktempdir(; cleanup = true),
)

# Build the decision models and simulation setup
build!(sim)

# Execute the simulation using the Optimizer specified in each DecisionModel
execute!(sim; enable_progress_bar = true)

```

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

### Infeasibility Conflict Output Example

Source: https://nrel-sienna.github.io/PowerSimulations.jl/stable/modeler_guide/debugging_infeasible_models

This example shows the typical output format when the `calculate_conflict` option is enabled and an infeasibility is detected. It lists the constraints and variables that are part of the irreducible infeasible set (IIS), aiding in the diagnosis of model issues.

```APIDOC
Error: Constraints participating in conflict basis (IIS) 
│ 
│ ┌──────────────────────────────────────┐
│ │ CopperPlateBalanceConstraint__System │
│ ├──────────────────────────────────────┤
│ │                            (113, 26) │
│ └──────────────────────────────────────┘
│ ┌──────────────────────────────────┐
│ │ EnergyAssetBalance__HybridSystem │
│ ├──────────────────────────────────┤
│ │               ("317_Hybrid", 26) │
│ └──────────────────────────────────┘
│ ┌─────────────────────────────────────────────┐
│ │ PieceWiseLinearCostConstraint__HybridSystem │
│ ├─────────────────────────────────────────────┤
│ │                          ("317_Hybrid", 26) │
│ └─────────────────────────────────────────────┘
│ ┌────────────────────────────────────────────────┐
│ │ PieceWiseLinearCostConstraint__ThermalStandard │
│ ├────────────────────────────────────────────────┤
│ │                            ("202_STEAM_3", 26) │
│ │                            ("101_STEAM_3", 26) │
│ │                               ("118_CC_1", 26) │
│ │                            ("202_STEAM_4", 26) │
│ │                               ("315_CT_6", 26) │
│ │                            ("201_STEAM_3", 26) │
│ │                            ("102_STEAM_4", 26) │
│ └────────────────────────────────────────────────┘
│ ┌──────────────────────────────────────────────────────────────────────┐
│ │ ActivePowerVariableTimeSeriesLimitsConstraint__RenewableDispatch__ub │
│ ├──────────────────────────────────────────────────────────────────────┤
│ │                                                   ("122_WIND_1", 26) │
│ │                                                     ("324_PV_3", 26) │
│ │                                                     ("312_PV_1", 26) │
│ │                                                     ("102_PV_1", 26) │
│ │                                                     ("101_PV_1", 26) │
│ │                                                     ("324_PV_2", 26) │
│ │                                                     ("313_PV_2", 26) │
│ │                                                     ("104_PV_1", 26) │
│ │                                                     ("101_PV_2", 26) │
│ │                                                   ("309_WIND_1", 26) │
│ │                                                     ("310_PV_2", 26) │
│ │                                                     ("113_PV_1", 26) │
│ │                                                     ("314_PV_1", 26) │
│ │                                                     ("324_PV_1", 26) │
│ │                                                     ("103_PV_1", 26) │
│ │                                                   ("303_WIND_1", 26) │
│ │                                                     ("314_PV_2", 26) │
│ │                                                     ("102_PV_2", 26) │
│ │                                                     ("314_PV_3", 26) │
│ │                                                     ("320_PV_1", 26) │
│ │                                                     ("101_PV_3", 26) │
│ │                                                     ("319_PV_1", 26) │
│ │                                                     ("314_PV_4", 26) │
│ │                                                     ("310_PV_1", 26) │
│ │                                                     ("215_PV_1", 26) │
│ │                                                     ("313_PV_1", 26) │
```

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

### PowerSimulations API Documentation

Source: https://nrel-sienna.github.io/PowerSimulations.jl/stable/code_base_developer_guide/internal

This section provides API documentation for various methods within the PowerSimulations.jl package, including methods for setting expressions, initial conditions, solving simulations, and converting data structures.

```APIDOC
PowerSimulations.set_expression!

set_expression!(container::PowerSimulations.OptimizationContainer, _::Type{S<:CostExpressions}, cost_expression::JuMP.AbstractJuMPScalar, component::Component, time_period::Int64)

Replaces an expression value in the expression container if the key exists.

Source: src/devices_models/devices/common/set_expression.jl:1

---

PowerSimulations.set_ic_quantity!

set_ic_quantity!(ic::InitialCondition{T<:InfrastructureSystems.Optimization.InitialConditionType, Float64}, var_value::Float64)

Default implementation of set _initial_ condition_value.

Source: src/initial_conditions/calculate_initial_condition.jl:13

---

set_ic_quantity!(ic::InitialCondition{T<:InfrastructureSystems.Optimization.InitialConditionType, JuMP.VariableRef}, var_value::Float64)

Default implementation of set _initial_ condition_value.

Source: src/initial_conditions/calculate_initial_condition.jl:1

---

PowerSimulations.solve_impl!

solve_impl!(container::PowerSimulations.OptimizationContainer, system::System) -> Any

Default solve method for OptimizationContainer.

Source: src/core/optimization_container.jl:782

---

PowerSimulations.sparse_container_spec

sparse_container_spec(_::Type{T<:JuMP.AbstractJuMPScalar}, axs...)

Returns the correct container specification for the selected type of JuMP Model.

Source: src/utils/jump_utils.jl:146

---

PowerSimulations.to_dataframe

to_dataframe(array::JuMP.Containers.DenseAxisArray{T<:Number, 2, Ax, L} where {Ax, L<:Tuple{JuMP.Containers._AxisLookup, JuMP.Containers._AxisLookup}}, key::InfrastructureSystems.Optimization.OptimizationContainerKey) -> DataFrames.DataFrame

Creates a DataFrame from a JuMP DenseAxisArray or SparseAxisArray.
Arguments:
  * array: JuMP DenseAxisArray or SparseAxisArray to convert
  * key::OptimizationContainerKey: 

Source: 

```

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

### PowerSimulations.jl Modeler Guide: PSI Structure

Source: https://nrel-sienna.github.io/PowerSimulations.jl/stable/modeler_guide/running_a_simulation

Details the internal structure and organization of the PowerSimulations.jl modeling components.

```Julia
using PowerSimulations

# Accessing components of the PSI structure (conceptual)
# psi_container = PSIContainer()
# network_model = get_network_model(psi_container)
# device_models = get_device_models(psi_container)

```

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

### Get Decision Problem Results

Source: https://nrel-sienna.github.io/PowerSimulations.jl/stable/api/PowerSimulations

Retrieves the results for a specific decision problem from a simulation results object.

```APIDOC
PowerSimulations.get_decision_problem_results
get_decision_problem_results(
    results::SimulationResults,
    problem::String;
)
```

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

### PowerSimulations.jl Formulation Library: General

Source: https://nrel-sienna.github.io/PowerSimulations.jl/stable/modeler_guide/running_a_simulation

Covers general modeling concepts and formulations applicable across different power system components in PowerSimulations.jl.

```Julia
using PowerSimulations

# General modeling aspects include:
# - Network representation (e.g., PTDF, Ybus)
# - Time-series data handling
# - Common constraints and objectives

```

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

### Create Simulation Object

Source: https://nrel-sienna.github.io/PowerSimulations.jl/stable/tutorials/pcm_simulation

Initializes a `Simulation` object with a name, number of steps, models, sequence definition, and a folder for storing simulation results.

```Julia
sim = Simulation(
    name = "rts-test",
    steps = 2,
    models = models,
    sequence = DA_RT_sequence,
    simulation_folder = joinpath(".", "rts-store"),
)
```

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

### Load Packages

Source: https://nrel-sienna.github.io/PowerSimulations.jl/stable/tutorials/pcm_simulation

Loads necessary packages for PowerSimulations.jl, including PowerSystems, HydroPowerSimulations, PowerSystemCaseBuilder, Dates, and the HiGHS solver.

```Julia
using PowerSystems
using PowerSimulations
using HydroPowerSimulations
const PSI = PowerSimulations
using PowerSystemCaseBuilder
using Dates
using HiGHS #solver
```

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

### Formulation Library - Network Models

Source: https://nrel-sienna.github.io/PowerSimulations.jl/stable/formulation_library/Introduction

Details on network formulations in PowerSimulations.jl, including power flow and related constraints.

```APIDOC
Formulation Library - Network:

This section details the network formulations used in PowerSimulations.jl, focusing on power flow equations and network constraints.

Key aspects include:
- **Power Flow Equations**: Modeling of active and reactive power flow across branches.
- **Bus Voltage Constraints**: Limits on voltage magnitudes at network buses.
- **Network Topology**: Representation of the grid structure.

**Example: Power Flow Constraint**
```APIDOC
function network_flow_balance!(canonical::CanonicalModel, 
                             network_type::Type{<:Network},
                             devices::Vector{<:Device},
                             time_steps::Int):
    # Implementation of power flow balance equations
    # For example, for a bus 'b':
    # sum(P_inj[b, t]) - sum(P_out[b, t]) == 0 for all t
    # ...
end
```

These formulations are crucial for simulating the physical behavior of the power grid.
```

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

### PowerSimulations API Documentation

Source: https://nrel-sienna.github.io/PowerSimulations.jl/stable/api/PowerSimulations

Provides API documentation for key components of PowerSimulations.jl related to simulation management. This includes constructors for the `Simulation` type, methods for building and executing simulations, and utilities for managing simulation partitions.

```APIDOC
PowerSimulations.Simulation

Constructors:
  Simulation(directory::AbstractString, model_info::Dict)
    Constructs Simulation from a serialized directory. Callers should pass any kwargs here that they passed to the original Simulation.
    Arguments:
      directory::AbstractString: the directory returned from the call to serialize
      model_info::Dict: Two-level dictionary containing model parameters that cannot be serialized. The outer dict should be keyed by the problem name. The inner dict must contain 'optimizer' and may contain 'jump_model'. These should be the same values used for the original simulation.

PowerSimulations.build!

Method:
  build!(sim::Simulation; recorders, console_level, file_level, serialize, partitions, index) -> InfrastructureSystems.Simulation.SimulationBuildStatusModule.SimulationBuildStatus
    Build the Simulation, problems and the related folder structure.
    Arguments:
      sim::Simulation: simulation object
      recorders::Vector{Symbol} = []: recorder names to register
      serialize::Bool = true: serializes the simulation objects in the simulation
      console_level = Logging.Error:
      file_level = Logging.Info:

PowerSimulations.execute!

Method:
  execute!(sim::Simulation; kwargs...) -> InfrastructureSystems.Simulation.RunStatusModule.RunStatus
    Solves the simulation model for sequential Simulations.
    Arguments:
      sim::Simulation=sim: simulation object created by Simulation()
    The optional keyword argument `exports` controls exporting of results to CSV files as the simulation runs.
    Example:
      sim = Simulation("Test", 7, problems, "/Users/folder")
      execute!(sim::Simulation; kwargs...)

PowerSimulations.SimulationPartitions

Type:
  Defines how a simulation can be partition into partitions and run in parallel.

PowerSimulations.get_num_partitions

Method:
  get_num_partitions(x::SimulationPartitions) -> Int64
    Return the number of partitions in the simulation.

PowerSimulations.run_parallel_simulation

Method:
  run_parallel_simulation(build_function, execute_function; script, output_dir, name, num_steps, period, num_overlap_steps, num_parallel_processes, exeflags, force)
    Run a partitioned simulation in parallel on a local computer.
    Arguments:
      build_function: Function reference that returns a built Simulation.
      execute_function: Function reference that executes a Simulation.

```

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

### Get Component from Results

Source: https://nrel-sienna.github.io/PowerSimulations.jl/stable/code_base_developer_guide/internal

Retrieves a component from the results store using its UUID. This is equivalent to calling `get_available_component` on the system associated with the results.

```julia
get_component(
    res::InfrastructureSystems.Results,
    uuid::Base.UUID
) -> Union{Nothing, InfrastructureSystems.InfrastructureSystemsComponent}
```

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

### Get Update Timestamp

Source: https://nrel-sienna.github.io/PowerSimulations.jl/stable/code_base_developer_guide/internal

Retrieves the timestamp associated with the last data update. This function can be used with abstract datasets or dataset containers.

```APIDOC
PowerSimulations.get_update_timestamp(s::PowerSimulations.AbstractDataset) -> Any

Return the timestamp from the data used in the last update

PowerSimulations.get_update_timestamp(container::PowerSimulations.DatasetContainer, ...)

Return the timestamp from the data used in the last update
```

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

### Get Optimizer Statistics

Source: https://nrel-sienna.github.io/PowerSimulations.jl/stable/tutorials/decision_problem

Retrieves detailed statistics from the optimizer, including objective value, termination status, solve time, and more, from the OptimizationProblemResults.

```Julia
get_optimizer_stats(res)
```

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

### PowerSimulations.jl Model Developer Guide: Structure of Operation Problem

Source: https://nrel-sienna.github.io/PowerSimulations.jl/stable/modeler_guide/running_a_simulation

Provides insights into the internal structure of operation problems as defined and managed by PowerSimulations.jl.

```Julia
using PowerSimulations

# Understanding the components of an operation problem:
# - Variables: Decision variables for the optimization problem.
# - Parameters: Input data to the problem.
# - Constraints: Mathematical relationships that must be satisfied.
# - Objectives: The function to be minimized or maximized.

```

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

### Building a ProblemTemplate

Source: https://nrel-sienna.github.io/PowerSimulations.jl/stable/modeler_guide/problem_templates

Demonstrates how to construct a ProblemTemplate by setting network models, device models, and service models. This involves initializing a template and then using specific functions to add different components.

```Julia
template = ProblemTemplate()
set_network_model!(template, NetworkModel(CopperPlatePowerModel))
set_device_model!(template, PowerLoad, StaticPowerLoad)
set_device_model!(template, ThermalStandard, ThermalBasicUnitCommitment)
set_service_model!(template, VariableReserve{ReserveUp}, RangeReserve)
```

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

### Read All Realized Parameters

Source: https://nrel-sienna.github.io/PowerSimulations.jl/stable/api/PowerSimulations

Retrieves the final values for all parameters across all time steps for a given simulation problem. Refer to `read_realized_parameters` for usage examples.

```APIDOC
PowerSimulations.read_realized_parameters(res::PowerSimulations.SimulationProblemResults; kwargs...) -> Dict

Return the final values for the requested parameters for each time step for a problem.
Refer to [`read_realized_parameters`](https://nrel-sienna.github.io/PowerSimulations.jl/stable/api/PowerSimulations/#PowerSimulations.read_realized_parameters-Tuple{PowerSimulations.SimulationProblemResults}) for help and examples.
```

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

### Read All Realized Expressions

Source: https://nrel-sienna.github.io/PowerSimulations.jl/stable/api/PowerSimulations

Retrieves the final values for all expressions across all time steps for a given simulation problem. Refer to `read_realized_expressions` for usage examples.

```APIDOC
PowerSimulations.read_realized_expressions(res::PowerSimulations.SimulationProblemResults; kwargs...) -> Dict

Return the final values for the requested expressions for each time step for a problem.
Refer to [`read_realized_expressions`](https://nrel-sienna.github.io/PowerSimulations.jl/stable/api/PowerSimulations/#PowerSimulations.read_realized_expressions-Tuple{PowerSimulations.SimulationProblemResults}) for help and examples.
```
Tokens:
Raw