API Reference
Table of Contents
- Device Models
- Decision Models
- Emulation Models
- Service Models
- Simulation Models
- Variables
- Constraints
- Parameters
Device Models
List of structures and methods for Device models
PowerSimulations.DeviceModel
— TypeDeviceModel(
::Type{D},
::Type{B},
feedforwards::Vector{<:AbstractAffectFeedforward}
use_slacks::Bool,
duals::Vector{DataType},
services::Vector{ServiceModel}
attributes::Dict{String, Any}
)
Establishes the model for a particular device specified by type. Uses the keyword argument feedforward to enable passing values between operation model at simulation time
Arguments
::Type{D} where D<:PSY.Device
: Power System Device Type::Type{B} where B<:AbstractDeviceFormulation
: Abstract Device Formulationfeedforward::Array{<:AbstractAffectFeedforward} = Vector{AbstractAffectFeedforward}()
: use to pass parameters between modelsuse_slacks::Bool = false
: Add slacks to the device model. Implementation is model dependent and not all models feature slacksduals::Vector{DataType} = Vector{DataType}()
: use to pass constraint type to calculate the duals. The DataType needs to be a valid ConstraintTypetime_series_names::Dict{Type{<:TimeSeriesParameter}, String} = get_default_time_series_names(D, B)
: use to specify time series names associated to the device`attributes::Dict{String, Any} = get_default_attributes(D, B)
: use to specify attributes to the device
Example
thermal_gens = DeviceModel(ThermalStandard, ThermalBasicUnitCommitment)
Formulations
Refer to the Formulations Page for each Abstract Device Formulation.
Problem Templates
Refer to the Problem Templates Page for available ProblemTemplate
s.
Decision Models
PowerSimulations.DecisionModel
— TypeDecisionModel{M}(
template::AbstractProblemTemplate,
sys::PSY.System,
jump_model::Union{Nothing, JuMP.Model}=nothing;
kwargs...) where {M<:DecisionProblem}
Build the optimization problem of type M with the specific system and template.
Arguments
::Type{M} where M<:DecisionProblem
: The abstract operation model typetemplate::AbstractProblemTemplate
: The model reference made up of transmission, devices, branches, and services.sys::PSY.System
: the system created using Power Systemsjump_model::Union{Nothing, JuMP.Model}
: Enables passing a custom JuMP model. Use with carename = nothing
: name of model, string or symbol; defaults to the type of template converted to a symbol.optimizer::Union{Nothing,MOI.OptimizerWithAttributes} = nothing
: The optimizer does not get serialized. Callers should pass whatever they passed to the original problem.horizon::Dates.Period = UNSET_HORIZON
: Manually specify the length of the forecast Horizonresolution::Dates.Period = UNSET_RESOLUTION
: Manually specify the model's resolutionwarm_start::Bool = true
: True will use the current operation point in the system to initialize variable values. False initializes all variables to zero. Default is truesystem_to_file::Bool = true:
: True to create a copy of the system used in the model.initialize_model::Bool = true
: Option to decide to initialize the model or not.initialization_file::String = ""
: This allows to pass pre-existing initialization values to avoid the solution of an optimization problem to find feasible initial conditions.deserialize_initial_conditions::Bool = false
: Option to deserialize conditionsexport_pwl_vars::Bool = false
: True to export all the pwl intermediate variables. It can slow down significantly the build and solve time.allow_fails::Bool = false
: True to allow the simulation to continue even if the optimization step fails. Use with care.optimizer_solve_log_print::Bool = false
: Uses JuMP.unset_silent() to print the optimizer's log. By default all solvers are set to MOI.Silent()detailed_optimizer_stats::Bool = false
: True to save detailed optimizer stats log.calculate_conflict::Bool = false
: True to use solver to calculate conflicts for infeasible problems. Only specific solvers are able to calculate conflicts.direct_mode_optimizer::Bool = false
: True to use the solver in direct mode. Creates a JuMP.direct_model.store_variable_names::Bool = false
: to store variable names in optimization model. Decreases the build times.rebuild_model::Bool = false
: It will force the rebuild of the underlying JuMP model with each call to update the model. It increases solution times, use only if the model can't be updated in memory.initial_time::Dates.DateTime = UNSET_INI_TIME
: Initial Time for the model solve.time_series_cache_size::Int = IS.TIME_SERIES_CACHE_SIZE_BYTES
: Size in bytes to cache for each time array. Default is 1 MiB. Set to 0 to disable.
Example
template = ProblemTemplate(CopperPlatePowerModel, devices, branches, services)
OpModel = DecisionModel(MockOperationProblem, template, system)
DecisionModel(
::Type{M<:PowerSimulations.DecisionProblem},
template::PowerSimulations.AbstractProblemTemplate,
sys::System;
...
) -> DecisionModel
DecisionModel(
::Type{M<:PowerSimulations.DecisionProblem},
template::PowerSimulations.AbstractProblemTemplate,
sys::System,
jump_model::Union{Nothing, JuMP.Model};
kwargs...
) -> DecisionModel
Build the optimization problem of type M with the specific system and template
Arguments
::Type{M} where M<:DecisionProblem
: The abstract operation model typetemplate::AbstractProblemTemplate
: The model reference made up of transmission, devices, branches, and services.sys::PSY.System
: the system created using Power Systemsjump_model::Union{Nothing, JuMP.Model}
= nothing: Enables passing a custom JuMP model. Use with care.
Example
template = ProblemTemplate(CopperPlatePowerModel, devices, branches, services)
problem = DecisionModel(MyOpProblemType, template, system, optimizer)
Builds an empty decision model. This constructor is used for the implementation of custom decision models that do not require a template.
Arguments
::Type{M} where M<:DecisionProblem
: The abstract operation model typesys::PSY.System
: the system created using Power Systemsjump_model::Union{Nothing, JuMP.Model}
= nothing: Enables passing a custom JuMP model. Use with care.
Example
problem = DecisionModel(system, optimizer)
DecisionModel(
directory::AbstractString,
optimizer::MathOptInterface.OptimizerWithAttributes;
jump_model,
system
) -> Any
Construct an DecisionProblem from a serialized file.
Arguments
directory::AbstractString
: Directory containing a serialized modeljump_model::Union{Nothing, JuMP.Model}
= nothing: The JuMP model does not get serialized. Callers should pass whatever they passed to the original problem.optimizer::Union{Nothing,MOI.OptimizerWithAttributes}
= nothing: The optimizer does not get serialized. Callers should pass whatever they passed to the original problem.system::Union{Nothing, PSY.System}
: Optionally, the system used for the model. If nothing and systofile was set to true when the model was created, the system will be deserialized from a file.
PowerSimulations.DecisionModel
— MethodDecisionModel(
::Type{M<:PowerSimulations.DecisionProblem},
template::PowerSimulations.AbstractProblemTemplate,
sys::System;
...
) -> DecisionModel
DecisionModel(
::Type{M<:PowerSimulations.DecisionProblem},
template::PowerSimulations.AbstractProblemTemplate,
sys::System,
jump_model::Union{Nothing, JuMP.Model};
kwargs...
) -> DecisionModel
Build the optimization problem of type M with the specific system and template
Arguments
::Type{M} where M<:DecisionProblem
: The abstract operation model typetemplate::AbstractProblemTemplate
: The model reference made up of transmission, devices, branches, and services.sys::PSY.System
: the system created using Power Systemsjump_model::Union{Nothing, JuMP.Model}
= nothing: Enables passing a custom JuMP model. Use with care.
Example
template = ProblemTemplate(CopperPlatePowerModel, devices, branches, services)
problem = DecisionModel(MyOpProblemType, template, system, optimizer)
PowerSimulations.DecisionModel
— MethodDecisionModel(
directory::AbstractString,
optimizer::MathOptInterface.OptimizerWithAttributes;
jump_model,
system
) -> Any
Construct an DecisionProblem from a serialized file.
Arguments
directory::AbstractString
: Directory containing a serialized modeljump_model::Union{Nothing, JuMP.Model}
= nothing: The JuMP model does not get serialized. Callers should pass whatever they passed to the original problem.optimizer::Union{Nothing,MOI.OptimizerWithAttributes}
= nothing: The optimizer does not get serialized. Callers should pass whatever they passed to the original problem.system::Union{Nothing, PSY.System}
: Optionally, the system used for the model. If nothing and systofile was set to true when the model was created, the system will be deserialized from a file.
PowerSimulations.build!
— Methodbuild!(
model::DecisionModel;
output_dir,
recorders,
console_level,
file_level,
disable_timer_outputs
)
Build the Decision Model based on the specified DecisionProblem.
Arguments
model::DecisionModel{<:DecisionProblem}
: DecisionModel objectoutput_dir::String
: Output directory for resultsrecorders::Vector{Symbol} = []
: recorder names to registerconsole_level = Logging.Error
:file_level = Logging.Info
:disable_timer_outputs = false
: Enable/Disable timing outputs
PowerSimulations.solve!
— Methodsolve!(
model::DecisionModel;
export_problem_results,
console_level,
file_level,
disable_timer_outputs,
serialize,
kwargs...
) -> InfrastructureSystems.Simulation.RunStatusModule.RunStatus
Default solve method for models that conform to the requirements of DecisionModel{<: DecisionProblem}.
This will call build!
on the model if it is not already built. It will forward all keyword arguments to that function.
Arguments
model::OperationModel = model
: operation modelexport_problem_results::Bool = false
: If true, export OptimizationProblemResults DataFrames to CSV files. Reduces solution times during simulation.console_level = Logging.Error
:file_level = Logging.Info
:disable_timer_outputs = false
: Enable/Disable timing outputsserialize::Bool = true
: If true, serialize the model to a file to allow re-execution later.
Examples
results = solve!(OpModel)
results = solve!(OpModel, export_problem_results = true)
Emulation Models
PowerSimulations.EmulationModel
— TypeEmulationModel{M}(
template::AbstractProblemTemplate,
sys::PSY.System,
jump_model::Union{Nothing, JuMP.Model}=nothing;
kwargs...) where {M<:EmulationProblem}
Build the optimization problem of type M with the specific system and template.
Arguments
::Type{M} where M<:EmulationProblem
: The abstract Emulation model typetemplate::AbstractProblemTemplate
: The model reference made up of transmission, devices, branches, and services.sys::PSY.System
: the system created using Power Systemsjump_model::Union{Nothing, JuMP.Model}
: Enables passing a custom JuMP model. Use with carename = nothing
: name of model, string or symbol; defaults to the type of template converted to a symbol.optimizer::Union{Nothing,MOI.OptimizerWithAttributes} = nothing
: The optimizer does not get serialized. Callers should pass whatever they passed to the original problem.warm_start::Bool = true
: True will use the current operation point in the system to initialize variable values. False initializes all variables to zero. Default is truesystem_to_file::Bool = true:
: True to create a copy of the system used in the model.initialize_model::Bool = true
: Option to decide to initialize the model or not.initialization_file::String = ""
: This allows to pass pre-existing initialization values to avoid the solution of an optimization problem to find feasible initial conditions.deserialize_initial_conditions::Bool = false
: Option to deserialize conditionsexport_pwl_vars::Bool = false
: True to export all the pwl intermediate variables. It can slow down significantly the build and solve time.allow_fails::Bool = false
: True to allow the simulation to continue even if the optimization step fails. Use with care.calculate_conflict::Bool = false
: True to use solver to calculate conflicts for infeasible problems. Only specific solvers are able to calculate conflicts.optimizer_solve_log_print::Bool = false
: Uses JuMP.unset_silent() to print the optimizer's log. By default all solvers are set to MOI.Silent()detailed_optimizer_stats::Bool = false
: True to save detailed optimizer stats log.direct_mode_optimizer::Bool = false
: True to use the solver in direct mode. Creates a JuMP.direct_model.store_variable_names::Bool = false
: True to store variable names in optimization model.rebuild_model::Bool = false
: It will force the rebuild of the underlying JuMP model with each call to update the model. It increases solution times, use only if the model can't be updated in memory.initial_time::Dates.DateTime = UNSET_INI_TIME
: Initial Time for the model solve.time_series_cache_size::Int = IS.TIME_SERIES_CACHE_SIZE_BYTES
: Size in bytes to cache for each time array. Default is 1 MiB. Set to 0 to disable.
Example
template = ProblemTemplate(CopperPlatePowerModel, devices, branches, services)
OpModel = EmulationModel(MockEmulationProblem, template, system)
PowerSimulations.EmulationModel
— MethodEmulationModel(
::Type{M<:PowerSimulations.EmulationProblem},
template::PowerSimulations.AbstractProblemTemplate,
sys::System;
...
) -> EmulationModel
EmulationModel(
::Type{M<:PowerSimulations.EmulationProblem},
template::PowerSimulations.AbstractProblemTemplate,
sys::System,
jump_model::Union{Nothing, JuMP.Model};
kwargs...
) -> EmulationModel
Build the optimization problem of type M with the specific system and template
Arguments
::Type{M} where M<:EmulationProblem
: The abstract Emulation model typetemplate::AbstractProblemTemplate
: The model reference made up of transmission, devices, branches, and services.sys::PSY.System
: the system created using Power Systemsjump_model::Union{Nothing, JuMP.Model}
: Enables passing a custom JuMP model. Use with care
Example
template = ProblemTemplate(CopperPlatePowerModel, devices, branches, services)
problem = EmulationModel(MyEmProblemType, template, system, optimizer)
PowerSimulations.EmulationModel
— MethodEmulationModel(
directory::AbstractString,
optimizer::MathOptInterface.OptimizerWithAttributes;
jump_model,
system,
kwargs...
) -> Any
Construct an EmulationProblem from a serialized file.
Arguments
directory::AbstractString
: Directory containing a serialized model.optimizer::MOI.OptimizerWithAttributes
: The optimizer does not get serialized. Callers should pass whatever they passed to the original problem.jump_model::Union{Nothing, JuMP.Model}
= nothing: The JuMP model does not get serialized. Callers should pass whatever they passed to the original problem.system::Union{Nothing, PSY.System}
: Optionally, the system used for the model. If nothing and systofile was set to true when the model was created, the system will be deserialized from a file.
PowerSimulations.build!
— Methodbuild!(
model::EmulationModel;
executions,
output_dir,
recorders,
console_level,
file_level,
disable_timer_outputs
)
Implementation of build for any EmulationProblem
PowerSimulations.run!
— Methodrun!(
model::EmulationModel;
export_problem_results,
console_level,
file_level,
disable_timer_outputs,
serialize,
kwargs...
) -> InfrastructureSystems.Simulation.RunStatusModule.RunStatus
Default run method for problems that conform to the requirements of EmulationModel{<: EmulationProblem}
This will call build!
on the model if it is not already built. It will forward all keyword arguments to that function.
Arguments
model::EmulationModel = model
: Emulation modeloptimizer::MOI.OptimizerWithAttributes
: The optimizer that is used to solve the modelexecutions::Int
: Number of executions for the emulator runexport_problem_results::Bool
: If true, export OptimizationProblemResults DataFrames to CSV files.output_dir::String
: Required if the model is not already built, otherwise ignoredenable_progress_bar::Bool
: Enables/Disable progress bar printingserialize::Bool
: If true, serialize the model to a file to allow re-execution later.
Examples
status = run!(model; optimizer = GLPK.Optimizer, executions = 10)
status = run!(model; output_dir = ./model_output, optimizer = GLPK.Optimizer, executions = 10)
Service Models
List of structures and methods for Service models
PowerSimulations.ServiceModel
— TypeEstablishes the model for a particular services specified by type. Uses the keyword argument use_service_name
to assign the model to a service with the same name as the name in the template. Uses the keyword argument feedforward to enable passing values between operation model at simulation time
Arguments
-::Type{D}
: Power System Service Type -::Type{B}
: Abstract Service Formulation
Accepted Key Words
feedforward::Array{<:AbstractAffectFeedforward}
: use to pass parameters between modelsuse_service_name::Bool
: use the name as the name for the service
Example
reserves = ServiceModel(PSY.VariableReserve{PSY.ReserveUp}, RangeReserve)
Simulation Models
Refer to the Simulations Page to explanations on how to setup a Simulation, with Sequencing and Feedforwards.
PowerSimulations.SimulationModels
— TypeSimulationModels(
decision_models::Vector{<:DecisionModel},
emulation_models::Union{Nothing, EmulationModel}
)
Stores the OperationProblem definitions to be used in the simulation. When creating the SimulationModels, the order in which the models are created determines the order on which the simulation is executed.
Arguments
decision_models::Vector{<:DecisionModel}
: Vector of decision models.emulation_models::Union{Nothing, EmulationModel}
: Optional argument to include
an EmulationModel in the Simulation
Example
template_uc = template_unit_commitment()
template_ed = template_economic_dispatch()
my_decision_model_uc = DecisionModel(template_1, sys_uc, optimizer, name = "UC")
my_decision_model_ed = DecisionModel(template_ed, sys_ed, optimizer, name = "ED")
models = SimulationModels(
decision_models = [
my_decision_model_uc,
my_decision_model_ed
]
)
PowerSimulations.SimulationSequence
— TypeSimulationSequence(
models::SimulationModels,
feedforward::Dict{String, Vector{<:AbstractAffectFeedforward}}
ini_cond_chronology::InitialConditionChronology
)
Construct the simulation sequence between decision and emulation models.
Arguments
models::SimulationModels
: Vector of decisions and emulation models.feedforward = Dict{String, Vector{<:AbstractAffectFeedforward}}()
: Optional dictionary to specify how information
and variables are exchanged between decision and emulation models.
ini_cond_chronology::nitialConditionChronology = InterProblemChronology()
: TODO
Example
template_uc = template_unit_commitment()
template_ed = template_economic_dispatch()
my_decision_model_uc = DecisionModel(template_1, sys_uc, optimizer, name = "UC")
my_decision_model_ed = DecisionModel(template_ed, sys_ed, optimizer, name = "ED")
models = SimulationModels(
decision_models = [
my_decision_model_uc,
my_decision_model_ed
]
)
# The following sequence set the commitment variables (`OnVariable`) for `ThermalStandard` units from UC to ED.
sequence = SimulationSequence(;
models = models,
feedforwards = Dict(
"ED" => [
SemiContinuousFeedforward(;
component_type = ThermalStandard,
source = OnVariable,
affected_values = [ActivePowerVariable],
),
],
),
)
PowerSimulations.Simulation
— TypeSimulation(
sequence::SimulationSequence,
name::String,
steps::Int
models::SimulationModels,
simulation_folder::String,
initial_time::Union{Nothing, Dates.DateTime}
)
Construct the Simulation structure to run the sequence of decision and emulation models specified.
Arguments
-sequence::SimulationSequence
: Simulation sequence that specify how the decision and emulation models will be executed. -name::String
: Name of the Simulation -steps::Int
: Number of steps on which the sequence of models will be executed -models::SimulationModels
: List of Decision and Emulation Models -simulation_folder::String
: Folder on which results will be stored -initial_time::Union{Nothing, Dates.DateTime} = nothing
: Initial time of which the simulation starts. If nothing it will default to the first timestamp of time series of the system.
Example
template_uc = template_unit_commitment()
template_ed = template_economic_dispatch()
my_decision_model_uc = DecisionModel(template_1, sys_uc, optimizer, name = "UC")
my_decision_model_ed = DecisionModel(template_ed, sys_ed, optimizer, name = "ED")
models = SimulationModels(
decision_models = [
my_decision_model_uc,
my_decision_model_ed
]
)
# The following sequence set the commitment variables (`OnVariable`) for `ThermalStandard` units from UC to ED.
sequence = SimulationSequence(;
models = models,
feedforwards = Dict(
"ED" => [
SemiContinuousFeedforward(;
component_type = ThermalStandard,
source = OnVariable,
affected_values = [ActivePowerVariable],
),
],
),
)
sim = Simulation(
sequence = sequence,
name = "Sim",
steps = 5,
models = models,
simulation_folder = mktempdir(cleanup=true),
)
PowerSimulations.Simulation
— MethodSimulation(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 serializemodel_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!
— Methodbuild!(
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 objectrecorders::Vector{Symbol} = []
: recorder names to registerserialize::Bool = true
: serializes the simulation objects in the simulationconsole_level = Logging.Error
:file_level = Logging.Info
:
PowerSimulations.execute!
— Methodexecute!(
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...)
Variables
For a list of variables for each device refer to its Formulations page.
Common Variables
PowerSimulations.ActivePowerVariable
— TypeStruct to dispatch the creation of Active Power Variables
Docs abbreviation: $p$
PowerSimulations.ReactivePowerVariable
— TypeStruct to dispatch the creation of Reactive Power Variables
Docs abbreviation: $q$
PowerSimulations.PieceWiseLinearCostVariable
— TypeStruct to dispatch the creation of piecewise linear cost variables for objective function
Docs abbreviation: $\delta$
Thermal Unit Variables
PowerSimulations.OnVariable
— TypeStruct to dispatch the creation of a binary commitment status variable
Docs abbreviation: $u$
PowerSimulations.StartVariable
— TypeStruct to dispatch the creation of Binary Start Variables
Docs abbreviation: $v$
PowerSimulations.StopVariable
— TypeStruct to dispatch the creation of Binary Stop Variables
Docs abbreviation: $w$
PowerSimulations.TimeDurationOn
— TypeAuxiliary Variable for Thermal Generation Models to keep track of time elapsed on
PowerSimulations.TimeDurationOff
— TypeAuxiliary Variable for Thermal Generation Models to keep track of time elapsed off
PowerSimulations.HotStartVariable
— TypeStruct to dispatch the creation of Hot Start Variable for Thermal units with temperature considerations
Docs abbreviation: $z^\text{th}$
PowerSimulations.WarmStartVariable
— TypeStruct to dispatch the creation of Warm Start Variable for Thermal units with temperature considerations
Docs abbreviation: $y^\text{th}$
PowerSimulations.ColdStartVariable
— TypeStruct to dispatch the creation of Cold Start Variable for Thermal units with temperature considerations
Docs abbreviation: $x^\text{th}$
PowerSimulations.PowerAboveMinimumVariable
— TypeStruct to dispatch the creation of Active Power Variables above minimum power for Thermal Compact formulations
Docs abbreviation: $\Delta p$
PowerSimulations.PowerOutput
— TypeAuxiliary Variable for Thermal Generation Models that solve for power above min
Storage Unit Variables
PowerSimulations.ReservationVariable
— TypeStruct to dispatch the creation of binary storage charge reservation variable
Docs abbreviation: $u^\text{st}$
Branches and Network Variables
PowerSimulations.FlowActivePowerVariable
— TypeStruct to dispatch the creation of bidirectional Active Power Flow Variables
Docs abbreviation: $f$
PowerSimulations.FlowActivePowerSlackUpperBound
— TypeStruct to dispatch the creation of active power flow upper bound slack variables. Used when there is not enough flow through the branch in the forward direction.
Docs abbreviation: $f^\text{sl,up}$
PowerSimulations.FlowActivePowerSlackLowerBound
— TypeStruct to dispatch the creation of active power flow lower bound slack variables. Used when there is not enough flow through the branch in the reverse direction.
Docs abbreviation: $f^\text{sl,lo}$
PowerSimulations.FlowActivePowerFromToVariable
— TypeStruct to dispatch the creation of unidirectional Active Power Flow Variables
Docs abbreviation: $f^\text{from-to}$
PowerSimulations.FlowActivePowerToFromVariable
— TypeStruct to dispatch the creation of unidirectional Active Power Flow Variables
Docs abbreviation: $f^\text{to-from}$
PowerSimulations.FlowReactivePowerFromToVariable
— TypeStruct to dispatch the creation of unidirectional Reactive Power Flow Variables
Docs abbreviation: $f^\text{q,from-to}$
PowerSimulations.FlowReactivePowerToFromVariable
— TypeStruct to dispatch the creation of unidirectional Reactive Power Flow Variables
Docs abbreviation: $f^\text{q,to-from}$
PowerSimulations.PhaseShifterAngle
— TypeStruct to dispatch the creation of Phase Shifters Variables
Docs abbreviation: $\theta^\text{shift}$
PowerSimulations.HVDCLosses
— TypeStruct to dispatch the creation of HVDC Losses Auxiliary Variables
Docs abbreviation: $\ell$
PowerSimulations.HVDCFlowDirectionVariable
— TypeStruct to dispatch the creation of HVDC Flow Direction Auxiliary Variables
Docs abbreviation: $u^\text{dir}$
PowerSimulations.VoltageMagnitude
— TypeStruct to dispatch the creation of Voltage Magnitude Variables for AC formulations
Docs abbreviation: $v$
PowerSimulations.VoltageAngle
— TypeStruct to dispatch the creation of Voltage Angle Variables for AC/DC formulations
Docs abbreviation: $\theta$
Services Variables
PowerSimulations.ActivePowerReserveVariable
— TypeStruct to dispatch the creation of Active Power Reserve Variables
Docs abbreviation: $r$
PowerSimulations.ServiceRequirementVariable
— TypeStruct to dispatch the creation of Service Requirement Variables
Docs abbreviation: $\text{req}$
PowerSimulations.SystemBalanceSlackUp
— TypeStruct to dispatch the creation of System-wide slack up variables. Used when there is not enough generation.
Docs abbreviation: $p^\text{sl,up}$
PowerSimulations.SystemBalanceSlackDown
— TypeStruct to dispatch the creation of System-wide slack down variables. Used when there is not enough load curtailment.
Docs abbreviation: $p^\text{sl,dn}$
PowerSimulations.ReserveRequirementSlack
— TypeStruct to dispatch the creation of Reserve requirement slack variables. Used when there is not reserves in the system to satisfy the requirement.
Docs abbreviation: $r^\text{sl}$
PowerSimulations.InterfaceFlowSlackUp
— TypeStruct to dispatch the creation of Interface Flow Slack Up variables
Docs abbreviation: $f^\text{sl,up}$
PowerSimulations.InterfaceFlowSlackDown
— TypeStruct to dispatch the creation of Interface Flow Slack Down variables
Docs abbreviation: $f^\text{sl,dn}$
Feedforward Variables
PowerSimulations.UpperBoundFeedForwardSlack
— TypeStruct to dispatch the creation of Slack variables for UpperBoundFeedforward
Docs abbreviation: $p^\text{ff,ubsl}$
PowerSimulations.LowerBoundFeedForwardSlack
— TypeStruct to dispatch the creation of Slack variables for LowerBoundFeedforward
Docs abbreviation: $p^\text{ff,lbsl}$
Constraints
Common Constraints
PowerSimulations.PieceWiseLinearCostConstraint
— TypeStruct to create the PieceWiseLinearCostConstraint associated with a specified variable.
See Piecewise linear cost functions for more information.
Network Constraints
PowerSimulations.CopperPlateBalanceConstraint
— TypeStruct to create the constraint to balance power in the copperplate model. For more information check Network Formulations.
The specified constraint is generally formulated as:
\[\sum_{c \in \text{components}} p_t^c = 0, \quad \forall t \in \{1, \dots, T\}\]
PowerSimulations.NodalBalanceActiveConstraint
— TypeStruct to create the constraint to balance active power in nodal formulation. For more information check Network Formulations.
The specified constraint depends on the network model chosen.
PowerSimulations.NodalBalanceReactiveConstraint
— TypeStruct to create the constraint to balance reactive power in nodal formulation. For more information check Network Formulations.
The specified constraint depends on the network model chosen.
Power Variable Limit Constraints
PowerSimulations.ActivePowerVariableLimitsConstraint
— TypeStruct to create the constraint to limit active power expressions. For more information check Device Formulations.
The specified constraint depends on the UpperBound and LowerBound expressions, but in its most basic formulation is of the form:
\[P^\text{min} \le p_t \le P^\text{max}, \quad \forall t \in \{1,\dots,T\}\]
PowerSimulations.ReactivePowerVariableLimitsConstraint
— TypeStruct to create the constraint to limit reactive power expressions. For more information check Device Formulations.
The specified constraint depends on the UpperBound and LowerBound expressions, but in its most basic formulation is of the form:
\[Q^\text{min} \le q_t \le Q^\text{max}, \quad \forall t \in \{1,\dots,T\}\]
PowerSimulations.ActivePowerVariableTimeSeriesLimitsConstraint
— TypeStruct to create the constraint to limit active power expressions by a time series parameter. For more information check Device Formulations.
The specified constraint depends on the UpperBound expressions, but in its most basic formulation is of the form:
\[p_t \le \text{ActivePowerTimeSeriesParameter}_t, \quad \forall t \in \{1,\dots,T\}\]
PowerSimulations.InputActivePowerVariableLimitsConstraint
— TypeStruct to create the constraint to limit active power input expressions. For more information check Device Formulations.
The specified constraint depends on the UpperBound and LowerBound expressions, but in its most basic formulation is of the form:
\[P^\text{min} \le p_t^\text{in} \le P^\text{max}, \quad \forall t \in \{1,\dots,T\}\]
PowerSimulations.OutputActivePowerVariableLimitsConstraint
— TypeStruct to create the constraint to limit active power output expressions. For more information check Device Formulations.
The specified constraint depends on the UpperBound and LowerBound expressions, but in its most basic formulation is of the form:
\[P^\text{min} \le p_t^\text{out} \le P^\text{max}, \quad \forall t \in \{1,\dots,T\}\]
Services Constraints
PowerSimulations.RequirementConstraint
— TypeStruct to create the constraint for satisfying active power reserve requirements. For more information check Service Formulations.
The constraint is as follows:
\[\sum_{d\in\mathcal{D}_s} r_{d,t} + r_t^\text{sl} \ge \text{Req},\quad \forall t\in \{1,\dots, T\} \quad \text{(for a ConstantReserve)} \\ \sum_{d\in\mathcal{D}_s} r_{d,t} + r_t^\text{sl} \ge \text{RequirementTimeSeriesParameter}_{t},\quad \forall t\in \{1,\dots, T\} \quad \text{(for a VariableReserve)}\]
PowerSimulations.ParticipationFractionConstraint
— TypeStruct to create the constraint to participation assignments limits in the active power reserves. For more information check Service Formulations.
The constraint is as follows:
\[r_{d,t} \le \text{Req} \cdot \text{PF} ,\quad \forall d\in \mathcal{D}_s, \forall t\in \{1,\dots, T\} \quad \text{(for a ConstantReserve)} \\ r_{d,t} \le \text{RequirementTimeSeriesParameter}_{t} \cdot \text{PF}\quad \forall d\in \mathcal{D}_s, \forall t\in \{1,\dots, T\}, \quad \text{(for a VariableReserve)}\]
PowerSimulations.ReservePowerConstraint
— TypeStruct to create the constraint for ensuring that NonSpinning Reserve can be delivered from turn-off thermal units.
For more information check Service Formulations for NonSpinningReserve.
The constraint is as follows:
\[r_{d,t} \le (1 - u_{d,t}^\text{th}) \cdot R^\text{limit}_d, \quad \forall d \in \mathcal{D}_s, \forall t \in \{1,\dots, T\}\]
Thermal Unit Constraints
PowerSimulations.ActiveRangeICConstraint
— TypeStruct to create the constraint for starting up ThermalMultiStart units. For more information check ThermalGen Formulations for ThermalMultiStartUnitCommitment.
The specified constraint is formulated as:
\[\max\{P^\text{th,max} - P^\text{th,shdown}, 0\} \cdot w_1^\text{th} \le u^\text{th,init} (P^\text{th,max} - P^\text{th,min}) - P^\text{th,init}\]
PowerSimulations.CommitmentConstraint
— TypeStruct to create the commitment constraint between the on, start, and stop variables. For more information check ThermalGen Formulations.
The specified constraints are formulated as:
\[u_1^\text{th} = u^\text{th,init} + v_1^\text{th} - w_1^\text{th} \\ u_t^\text{th} = u_{t-1}^\text{th} + v_t^\text{th} - w_t^\text{th}, \quad \forall t \in \{2,\dots,T\} \\ v_t^\text{th} + w_t^\text{th} \le 1, \quad \forall t \in \{1,\dots,T\}\]
PowerSimulations.DurationConstraint
— TypeStruct to create the duration constraint for commitment formulations, i.e. min-up and min-down.
For more information check ThermalGen Formulations.
PowerSimulations.RampConstraint
— TypeStruct to create the RampConstraint associated with a specified thermal device or reserve service.
For thermal units, see more information in Thermal Formulations. The constraint is as follows:
\[-R^\text{th,dn} \le p_t^\text{th} - p_{t-1}^\text{th} \le R^\text{th,up}, \quad \forall t\in \{1, \dots, T\}\]
For Ramp Reserve, see more information in Service Formulations. The constraint is as follows:
\[r_{d,t} \le R^\text{th,up} \cdot \text{TF}\quad \forall d\in \mathcal{D}_s, \forall t\in \{1,\dots, T\}, \quad \text{(for ReserveUp)} \\ r_{d,t} \le R^\text{th,dn} \cdot \text{TF}\quad \forall d\in \mathcal{D}_s, \forall t\in \{1,\dots, T\}, \quad \text{(for ReserveDown)}\]
PowerSimulations.StartupInitialConditionConstraint
— TypeStruct to create the start-up initial condition constraints for ThermalMultiStart.
For more information check ThermalGen Formulations for ThermalMultiStartUnitCommitment.
PowerSimulations.StartupTimeLimitTemperatureConstraint
— TypeStruct to create the start-up time limit constraints for ThermalMultiStart.
For more information check ThermalGen Formulations for ThermalMultiStartUnitCommitment.
Renewable Unit Constraints
PowerSimulations.EqualityConstraint
— TypeStruct to create the constraint that sets the reactive power to the power factor in the RenewableConstantPowerFactor formulation for renewable units.
For more information check RenewableGen Formulations.
The specified constraint is formulated as:
\[q_t^\text{re} = \text{pf} \cdot p_t^\text{re}, \quad \forall t \in \{1,\dots, T\}\]
Branches Constraints
PowerSimulations.FlowLimitConstraint
— TypeStruct to create the constraint that set the flow limits through a PhaseShiftingTransformer.
For more information check Branch Formulations.
The specified constraint is formulated as:
\[-R^\text{max} \le f_t \le R^\text{max}, \quad \forall t \in \{1,\dots,T\}\]
PowerSimulations.FlowRateConstraint
— TypeStruct to create the constraint that set the flow limits through an HVDC two-terminal branch.
For more information check Branch Formulations.
The specified constraint is formulated as:
\[R^\text{min} \le f_t \le R^\text{max}, \quad \forall t \in \{1,\dots,T\}\]
PowerSimulations.FlowRateConstraintFromTo
— TypeStruct to create the constraint that set the flow from-to limits through an HVDC two-terminal branch.
For more information check Branch Formulations.
The specified constraint is formulated as:
\[R^\text{from,min} \le f_t^\text{from-to} \le R^\text{from,max}, \forall t \in \{1,\dots, T\}\]
PowerSimulations.FlowRateConstraintToFrom
— TypeStruct to create the constraint that set the flow to-from limits through an HVDC two-terminal branch.
For more information check Branch Formulations.
The specified constraint is formulated as:
\[R^\text{to,min} \le f_t^\text{to-from} \le R^\text{to,max},\quad \forall t \in \{1,\dots, T\}\]
PowerSimulations.HVDCLossesAbsoluteValue
— TypeStruct to create the constraints that set the losses through a lossy HVDC two-terminal line.
For more information check Branch Formulations.
The specified constraints are formulated as:
\[\begin{align*} & f_t^\text{to-from} - f_t^\text{from-to} \le \ell_t,\quad \forall t \in \{1,\dots, T\} \\ & f_t^\text{from-to} - f_t^\text{to-from} \le \ell_t,\quad \forall t \in \{1,\dots, T\} \end{align*}\]
PowerSimulations.HVDCPowerBalance
— TypeStruct to create the constraints that set the power balance across a lossy HVDC two-terminal line.
For more information check Branch Formulations.
The specified constraints are formulated as:
\[\begin{align*} & f_t^\text{to-from} - f_t^\text{from-to} \le L_1 \cdot f_t^\text{to-from} - L_0,\quad \forall t \in \{1,\dots, T\} \\ & f_t^\text{from-to} - f_t^\text{to-from} \ge L_1 \cdot f_t^\text{from-to} + L_0,\quad \forall t \in \{1,\dots, T\} \\ & f_t^\text{from-to} - f_t^\text{to-from} \ge - M^\text{big} (1 - u^\text{dir}_t),\quad \forall t \in \{1,\dots, T\} \\ & f_t^\text{to-from} - f_t^\text{from-to} \ge - M^\text{big} u^\text{dir}_t,\quad \forall t \in \{1,\dots, T\} \\ \end{align*}\]
PowerSimulations.NetworkFlowConstraint
— TypeStruct to create the constraint the AC branch flows depending on the network model. For more information check Branch Formulations.
The specified constraint depends on the network model chosen. The most common application is the StaticBranch in a PTDF Network Model:
\[f_t = \sum_{i=1}^N \text{PTDF}_{i,b} \cdot \text{Bal}_{i,t}, \quad \forall t \in \{1,\dots, T\}\]
PowerSimulations.RateLimitConstraint
— TypeStruct to create the constraint that set the AC flow limits through branches.
For more information check Branch Formulations.
The specified constraint is formulated as:
\[\begin{align*} & f_t - f_t^\text{sl,up} \le R^\text{max},\quad \forall t \in \{1,\dots, T\} \\ & f_t + f_t^\text{sl,lo} \ge -R^\text{max},\quad \forall t \in \{1,\dots, T\} \end{align*}\]
PowerSimulations.PhaseAngleControlLimit
— TypeStruct to create the constraint that set the angle limits through a PhaseShiftingTransformer.
For more information check Branch Formulations.
The specified constraint is formulated as:
\[\Theta^\text{min} \le \theta^\text{shift}_t \le \Theta^\text{max}, \quad \forall t \in \{1,\dots,T\}\]
Feedforward Constraints
PowerSimulations.FeedforwardSemiContinuousConstraint
— TypeStruct to create the constraint for semicontinuous feedforward limits.
For more information check Feedforward Formulations.
The specified constraint is formulated as:
\[\begin{align*} & \text{ActivePowerRangeExpressionUB}_t := p_t^\text{th} - \text{on}_t^\text{th}P^\text{th,max} \le 0, \quad \forall t\in \{1, \dots, T\} \\ & \text{ActivePowerRangeExpressionLB}_t := p_t^\text{th} - \text{on}_t^\text{th}P^\text{th,min} \ge 0, \quad \forall t\in \{1, \dots, T\} \end{align*}\]
PowerSimulations.FeedforwardUpperBoundConstraint
— TypeStruct to create the constraint for upper bound feedforward limits.
For more information check Feedforward Formulations.
The specified constraint is formulated as:
\[\begin{align*} & \text{AffectedVariable}_t - p_t^\text{ff,ubsl} \le \text{SourceVariableParameter}_t, \quad \forall t \in \{1,\dots, T\} \end{align*}\]
PowerSimulations.FeedforwardLowerBoundConstraint
— TypeStruct to create the constraint for lower bound feedforward limits.
For more information check Feedforward Formulations.
The specified constraint is formulated as:
\[\begin{align*} & \text{AffectedVariable}_t + p_t^\text{ff,lbsl} \ge \text{SourceVariableParameter}_t, \quad \forall t \in \{1,\dots, T\} \end{align*}\]
Parameters
Time Series Parameters
PowerSimulations.ActivePowerTimeSeriesParameter
— TypeParameter to define active power time series
PowerSimulations.ReactivePowerTimeSeriesParameter
— TypeParameter to define reactive power time series
PowerSimulations.RequirementTimeSeriesParameter
— TypeParameter to define requirement time series
Variable Value Parameters
PowerSimulations.UpperBoundValueParameter
— TypeParameter to define variable upper bound
PowerSimulations.LowerBoundValueParameter
— TypeParameter to define variable lower bound
PowerSimulations.OnStatusParameter
— TypeParameter to define unit commitment status
PowerSimulations.FixValueParameter
— TypeParameter to FixValueParameter
Objective Function Parameters
PowerSimulations.CostFunctionParameter
— TypeParameter to define cost function coefficient