AVR
AVRFixed
PowerSystems.AVRFixed
— Typemutable struct AVRFixed <: AVR
Vf::Float64
V_ref::Float64
ext::Dict{String, Any}
states::Vector{Symbol}
n_states::Int
states_types::Vector{StateTypes}
internal::InfrastructureSystemsInternal
end
Parameters of a AVR that returns a fixed voltage to the rotor winding
Arguments
Vf::Float64
: Fixed voltage field applied to the rotor winding in pu (DEVICE_BASE
), validation range:(0, nothing)
V_ref::Float64
: (default:1.0
) Reference Voltage Set-point (pu), validation range:(0, nothing)
ext::Dict{String, Any}
: (default:Dict{String, Any}()
) An extra dictionary for users to add metadata that are not used in simulation, such as latitude and longitude.states::Vector{Symbol}
: (Do not modify.) Fixed AVR has no statesn_states::Int
: (Do not modify.) Fixed AVR has no statesstates_types::Vector{StateTypes}
: (Do not modify.) Fixed AVR has no statesinternal::InfrastructureSystemsInternal
: (Do not modify.) PowerSystems.jl internal reference
PowerSystems.get_V_ref
— Methodget_V_ref(value::AVRFixed) -> Float64
Get AVRFixed
V_ref
.
PowerSystems.get_Vf
— Methodget_Vf(value::AVRFixed) -> Float64
Get AVRFixed
Vf
.
PowerSystems.get_ext
— Methodget_ext(value::AVRFixed) -> Dict{String, Any}
Get AVRFixed
ext
.
PowerSystems.get_n_states
— Methodget_n_states(value::AVRFixed) -> Int64
Get AVRFixed
n_states
.
PowerSystems.get_states
— Methodget_states(value::AVRFixed) -> Vector{Symbol}
Get AVRFixed
states
.
PowerSystems.get_states_types
— Methodget_states_types(value::AVRFixed) -> Vector{StateTypes}
Get AVRFixed
states_types
.
PowerSystems.set_V_ref!
— Methodset_V_ref!(value::AVRFixed, val) -> Any
Set AVRFixed
V_ref
.
PowerSystems.set_Vf!
— Methodset_Vf!(value::AVRFixed, val) -> Any
Set AVRFixed
Vf
.
PowerSystems.set_ext!
— Methodset_ext!(value::AVRFixed, val) -> Any
Set AVRFixed
ext
.
PowerSystems.set_states_types!
— Methodset_states_types!(value::AVRFixed, val) -> Any
Set AVRFixed
states_types
.
AVRSimple
PowerSystems.AVRSimple
— Typemutable struct AVRSimple <: AVR
Kv::Float64
V_ref::Float64
ext::Dict{String, Any}
states::Vector{Symbol}
n_states::Int
states_types::Vector{StateTypes}
internal::InfrastructureSystemsInternal
end
Parameters of a simple proportional AVR in the derivative of EMF i.e. an integrator controller on EMF
Arguments
Kv::Float64
: Proportional Gain, validation range:(0, nothing)
V_ref::Float64
: (default:1.0
) Reference Voltage Set-point (pu), validation range:(0, nothing)
ext::Dict{String, Any}
: (default:Dict{String, Any}()
) An extra dictionary for users to add metadata that are not used in simulation, such as latitude and longitude.states::Vector{Symbol}
: (Do not modify.) The states are:
Vf: field voltage
n_states::Int
: (Do not modify.) Fixed AVR has 1 statestates_types::Vector{StateTypes}
: (Do not modify.) Simple AVR has 1 differential statesinternal::InfrastructureSystemsInternal
: (Do not modify.) PowerSystems.jl internal reference
PowerSystems.get_Kv
— Methodget_Kv(value::AVRSimple) -> Float64
Get AVRSimple
Kv
.
PowerSystems.get_V_ref
— Methodget_V_ref(value::AVRSimple) -> Float64
Get AVRSimple
V_ref
.
PowerSystems.get_ext
— Methodget_ext(value::AVRSimple) -> Dict{String, Any}
Get AVRSimple
ext
.
PowerSystems.get_n_states
— Methodget_n_states(value::AVRSimple) -> Int64
Get AVRSimple
n_states
.
PowerSystems.get_states
— Methodget_states(value::AVRSimple) -> Vector{Symbol}
Get AVRSimple
states
.
PowerSystems.get_states_types
— Methodget_states_types(value::AVRSimple) -> Vector{StateTypes}
Get AVRSimple
states_types
.
PowerSystems.set_Kv!
— Methodset_Kv!(value::AVRSimple, val) -> Any
Set AVRSimple
Kv
.
PowerSystems.set_V_ref!
— Methodset_V_ref!(value::AVRSimple, val) -> Any
Set AVRSimple
V_ref
.
PowerSystems.set_ext!
— Methodset_ext!(value::AVRSimple, val) -> Any
Set AVRSimple
ext
.
PowerSystems.set_states_types!
— Methodset_states_types!(value::AVRSimple, val) -> Any
Set AVRSimple
states_types
.
AVRTypeI
PowerSystems.AVRTypeI
— Typemutable struct AVRTypeI <: AVR
Ka::Float64
Ke::Float64
Kf::Float64
Ta::Float64
Te::Float64
Tf::Float64
Tr::Float64
Va_lim::MinMax
Ae::Float64
Be::Float64
V_ref::Float64
ext::Dict{String, Any}
states::Vector{Symbol}
n_states::Int
states_types::Vector{StateTypes}
internal::InfrastructureSystemsInternal
end
Parameters of an Automatic Voltage Regulator Type I - Resembles IEEE Type DC1
Arguments
Ka::Float64
: Amplifier Gain, validation range:(0, nothing)
Ke::Float64
: Field circuit integral deviation, validation range:(0, nothing)
Kf::Float64
: Stabilizer Gain in s * pu/pu, validation range:(0, nothing)
Ta::Float64
: Amplifier Time Constant in s, validation range:(0, nothing)
Te::Float64
: Field Circuit Time Constant in s, validation range:(0, nothing)
Tf::Float64
: Stabilizer Time Constant in s, validation range:(0, nothing)
Tr::Float64
: Voltage Measurement Time Constant in s, validation range:(0, nothing)
Va_lim::MinMax
: Limits for pi controler(Va_min, Va_max)
Ae::Float64
: 1st ceiling coefficient, validation range:(0, nothing)
Be::Float64
: 2nd ceiling coefficient, validation range:(0, nothing)
V_ref::Float64
: (default:1.0
) Reference Voltage Set-point (pu), validation range:(0, nothing)
ext::Dict{String, Any}
: (default:Dict{String, Any}()
) An extra dictionary for users to add metadata that are not used in simulation, such as latitude and longitude.states::Vector{Symbol}
: (Do not modify.) The states are:
Vf: Voltage field,
Vr1: Amplifier State,
Vr2: Stabilizing Feedback State,
Vm: Measured voltage
n_states::Int
: (Do not modify.) The AVR Type I has 4 statesstates_types::Vector{StateTypes}
: (Do not modify.) AVR Type I has 4 differential statesinternal::InfrastructureSystemsInternal
: (Do not modify.) PowerSystems.jl internal reference
PowerSystems.get_Ae
— Methodget_Ae(value::AVRTypeI) -> Float64
Get AVRTypeI
Ae
.
PowerSystems.get_Be
— Methodget_Be(value::AVRTypeI) -> Float64
Get AVRTypeI
Be
.
PowerSystems.get_Ka
— Methodget_Ka(value::AVRTypeI) -> Float64
Get AVRTypeI
Ka
.
PowerSystems.get_Ke
— Methodget_Ke(value::AVRTypeI) -> Float64
Get AVRTypeI
Ke
.
PowerSystems.get_Kf
— Methodget_Kf(value::AVRTypeI) -> Float64
Get AVRTypeI
Kf
.
PowerSystems.get_Ta
— Methodget_Ta(value::AVRTypeI) -> Float64
Get AVRTypeI
Ta
.
PowerSystems.get_Te
— Methodget_Te(value::AVRTypeI) -> Float64
Get AVRTypeI
Te
.
PowerSystems.get_Tf
— Methodget_Tf(value::AVRTypeI) -> Float64
Get AVRTypeI
Tf
.
PowerSystems.get_Tr
— Methodget_Tr(value::AVRTypeI) -> Float64
Get AVRTypeI
Tr
.
PowerSystems.get_V_ref
— Methodget_V_ref(value::AVRTypeI) -> Float64
Get AVRTypeI
V_ref
.
PowerSystems.get_Va_lim
— Methodget_Va_lim(
value::AVRTypeI
) -> @NamedTuple{min::Float64, max::Float64}
Get AVRTypeI
Va_lim
.
PowerSystems.get_ext
— Methodget_ext(value::AVRTypeI) -> Dict{String, Any}
Get AVRTypeI
ext
.
PowerSystems.get_n_states
— Methodget_n_states(value::AVRTypeI) -> Int64
Get AVRTypeI
n_states
.
PowerSystems.get_states
— Methodget_states(value::AVRTypeI) -> Vector{Symbol}
Get AVRTypeI
states
.
PowerSystems.get_states_types
— Methodget_states_types(value::AVRTypeI) -> Vector{StateTypes}
Get AVRTypeI
states_types
.
PowerSystems.set_Ae!
— Methodset_Ae!(value::AVRTypeI, val) -> Any
Set AVRTypeI
Ae
.
PowerSystems.set_Be!
— Methodset_Be!(value::AVRTypeI, val) -> Any
Set AVRTypeI
Be
.
PowerSystems.set_Ka!
— Methodset_Ka!(value::AVRTypeI, val) -> Any
Set AVRTypeI
Ka
.
PowerSystems.set_Ke!
— Methodset_Ke!(value::AVRTypeI, val) -> Any
Set AVRTypeI
Ke
.
PowerSystems.set_Kf!
— Methodset_Kf!(value::AVRTypeI, val) -> Any
Set AVRTypeI
Kf
.
PowerSystems.set_Ta!
— Methodset_Ta!(value::AVRTypeI, val) -> Any
Set AVRTypeI
Ta
.
PowerSystems.set_Te!
— Methodset_Te!(value::AVRTypeI, val) -> Any
Set AVRTypeI
Te
.
PowerSystems.set_Tf!
— Methodset_Tf!(value::AVRTypeI, val) -> Any
Set AVRTypeI
Tf
.
PowerSystems.set_Tr!
— Methodset_Tr!(value::AVRTypeI, val) -> Any
Set AVRTypeI
Tr
.
PowerSystems.set_V_ref!
— Methodset_V_ref!(value::AVRTypeI, val) -> Any
Set AVRTypeI
V_ref
.
PowerSystems.set_Va_lim!
— Methodset_Va_lim!(value::AVRTypeI, val) -> Any
Set AVRTypeI
Va_lim
.
PowerSystems.set_ext!
— Methodset_ext!(value::AVRTypeI, val) -> Any
Set AVRTypeI
ext
.
PowerSystems.set_states_types!
— Methodset_states_types!(value::AVRTypeI, val) -> Any
Set AVRTypeI
states_types
.
AVRTypeII
PowerSystems.AVRTypeII
— Typemutable struct AVRTypeII <: AVR
K0::Float64
T1::Float64
T2::Float64
T3::Float64
T4::Float64
Te::Float64
Tr::Float64
Va_lim::MinMax
Ae::Float64
Be::Float64
V_ref::Float64
ext::Dict{String, Any}
states::Vector{Symbol}
n_states::Int
states_types::Vector{StateTypes}
internal::InfrastructureSystemsInternal
end
Parameters of an Automatic Voltage Regulator Type II - Typical static exciter model
Arguments
K0::Float64
: Regulator Gain, validation range:(0, nothing)
T1::Float64
: First Pole in s, validation range:(0, nothing)
T2::Float64
: First zero in s, validation range:(0, nothing)
T3::Float64
: First Pole in s, validation range:(0, nothing)
T4::Float64
: First zero in s, validation range:(0, nothing)
Te::Float64
: Field Circuit Time Constant in s, validation range:(0, nothing)
Tr::Float64
: Voltage Measurement Time Constant in s, validation range:(0, nothing)
Va_lim::MinMax
: Limits for pi controler(Va_min, Va_max)
Ae::Float64
: 1st ceiling coefficient, validation range:(0, nothing)
Be::Float64
: 2nd ceiling coefficient, validation range:(0, nothing)
V_ref::Float64
: (default:1.0
) Reference Voltage Set-point (pu), validation range:(0, nothing)
ext::Dict{String, Any}
: (default:Dict{String, Any}()
) An extra dictionary for users to add metadata that are not used in simulation, such as latitude and longitude.states::Vector{Symbol}
: (Do not modify.) The states are:
Vf: Voltage field,
Vr1: First Lead-Lag state,
Vr2: Second lead-lag state,
Vm: Measured voltage
n_states::Int
: (Do not modify.) AVR Type II has 4 statesstates_types::Vector{StateTypes}
: (Do not modify.) AVR Type II has 4 differential statesinternal::InfrastructureSystemsInternal
: (Do not modify.) PowerSystems.jl internal reference
PowerSystems.get_Ae
— Methodget_Ae(value::AVRTypeII) -> Float64
Get AVRTypeII
Ae
.
PowerSystems.get_Be
— Methodget_Be(value::AVRTypeII) -> Float64
Get AVRTypeII
Be
.
PowerSystems.get_K0
— Methodget_K0(value::AVRTypeII) -> Float64
Get AVRTypeII
K0
.
PowerSystems.get_T1
— Methodget_T1(value::AVRTypeII) -> Float64
Get AVRTypeII
T1
.
PowerSystems.get_T2
— Methodget_T2(value::AVRTypeII) -> Float64
Get AVRTypeII
T2
.
PowerSystems.get_T3
— Methodget_T3(value::AVRTypeII) -> Float64
Get AVRTypeII
T3
.
PowerSystems.get_T4
— Methodget_T4(value::AVRTypeII) -> Float64
Get AVRTypeII
T4
.
PowerSystems.get_Te
— Methodget_Te(value::AVRTypeII) -> Float64
Get AVRTypeII
Te
.
PowerSystems.get_Tr
— Methodget_Tr(value::AVRTypeII) -> Float64
Get AVRTypeII
Tr
.
PowerSystems.get_V_ref
— Methodget_V_ref(value::AVRTypeII) -> Float64
Get AVRTypeII
V_ref
.
PowerSystems.get_Va_lim
— Methodget_Va_lim(
value::AVRTypeII
) -> @NamedTuple{min::Float64, max::Float64}
Get AVRTypeII
Va_lim
.
PowerSystems.get_ext
— Methodget_ext(value::AVRTypeII) -> Dict{String, Any}
Get AVRTypeII
ext
.
PowerSystems.get_n_states
— Methodget_n_states(value::AVRTypeII) -> Int64
Get AVRTypeII
n_states
.
PowerSystems.get_states
— Methodget_states(value::AVRTypeII) -> Vector{Symbol}
Get AVRTypeII
states
.
PowerSystems.get_states_types
— Methodget_states_types(value::AVRTypeII) -> Vector{StateTypes}
Get AVRTypeII
states_types
.
PowerSystems.set_Ae!
— Methodset_Ae!(value::AVRTypeII, val) -> Any
Set AVRTypeII
Ae
.
PowerSystems.set_Be!
— Methodset_Be!(value::AVRTypeII, val) -> Any
Set AVRTypeII
Be
.
PowerSystems.set_K0!
— Methodset_K0!(value::AVRTypeII, val) -> Any
Set AVRTypeII
K0
.
PowerSystems.set_T1!
— Methodset_T1!(value::AVRTypeII, val) -> Any
Set AVRTypeII
T1
.
PowerSystems.set_T2!
— Methodset_T2!(value::AVRTypeII, val) -> Any
Set AVRTypeII
T2
.
PowerSystems.set_T3!
— Methodset_T3!(value::AVRTypeII, val) -> Any
Set AVRTypeII
T3
.
PowerSystems.set_T4!
— Methodset_T4!(value::AVRTypeII, val) -> Any
Set AVRTypeII
T4
.
PowerSystems.set_Te!
— Methodset_Te!(value::AVRTypeII, val) -> Any
Set AVRTypeII
Te
.
PowerSystems.set_Tr!
— Methodset_Tr!(value::AVRTypeII, val) -> Any
Set AVRTypeII
Tr
.
PowerSystems.set_V_ref!
— Methodset_V_ref!(value::AVRTypeII, val) -> Any
Set AVRTypeII
V_ref
.
PowerSystems.set_Va_lim!
— Methodset_Va_lim!(value::AVRTypeII, val) -> Any
Set AVRTypeII
Va_lim
.
PowerSystems.set_ext!
— Methodset_ext!(value::AVRTypeII, val) -> Any
Set AVRTypeII
ext
.
PowerSystems.set_states_types!
— Methodset_states_types!(value::AVRTypeII, val) -> Any
Set AVRTypeII
states_types
.
ESAC1A
PowerSystems.ESAC1A
— Typemutable struct ESAC1A <: AVR
Tr::Float64
Tb::Float64
Tc::Float64
Ka::Float64
Ta::Float64
Va_lim::MinMax
Te::Float64
Kf::Float64
Tf::Float64
Kc::Float64
Kd::Float64
Ke::Float64
E_sat::Tuple{Float64, Float64}
Se::Tuple{Float64, Float64}
Vr_lim::MinMax
V_ref::Float64
saturation_coeffs::Tuple{Float64, Float64}
ext::Dict{String, Any}
states::Vector{Symbol}
n_states::Int
states_types::Vector{StateTypes}
internal::InfrastructureSystemsInternal
end
This excitation systems consists of an alternator main exciter feeding its output via non-controlled rectifiers. The exciter does not employ self-excitation, and the voltage regulator power is taken from a source that is not affected by external transients. Parameters of IEEE Std 421.5 Type AC1A Excitacion System. This model corresponds to ESAC1A in PSSE and PSLF
Arguments
Tr::Float64
: Regulator input filter time constant in s, validation range:(0, 0.5)
Tb::Float64
: Regulator denominator (lag) time constant in s, validation range:(0, 20)
Tc::Float64
: Regulator numerator (lead) time constant in s, validation range:(0, 20)
Ka::Float64
: Regulator output gain, validation range:(0, 1000)
Ta::Float64
: Regulator output time constant in s, validation range:(0, 10)
Va_lim::MinMax
: Limits for regulator output(Va_min, Va_max)
Te::Float64
: Exciter field time constant in s, validation range:(eps(), 2)
Kf::Float64
: Rate feedback excitation system stabilizer gain, validation range:(0, 0.3)
Tf::Float64
: Rate feedback time constant, validation range:(eps(), 1.5)
Kc::Float64
: Rectifier loading factor proportional to commutating reactance, validation range:(0, 1)
Kd::Float64
: Demagnetizing factor, function of exciter alternator reactances, validation range:(0, 1)
Ke::Float64
: Exciter field proportional constant, validation range:(0, 1)
E_sat::Tuple{Float64, Float64}
: Exciter output voltage for saturation factor: (E1, E2)Se::Tuple{Float64, Float64}
: Exciter saturation factor at exciter output voltage: (Se(E1), Se(E2))Vr_lim::MinMax
: Limits for exciter field voltage:(Vr_min, Vr_max)
V_ref::Float64
: (default:1.0
) Reference Voltage Set-point (pu), validation range:(0, nothing)
saturation_coeffs::Tuple{Float64, Float64}
: (default:PowerSystems.get_avr_saturation(E_sat, Se)
) (Do not modify.) Coefficients (A,B) of the function: Se(x) = B(x - A)^2/xext::Dict{String, Any}
: (default:Dict{String, Any}()
) An extra dictionary for users to add metadata that are not used in simulation, such as latitude and longitude.states::Vector{Symbol}
: (Do not modify.) The states are:
Vm: Sensed terminal voltage,
Vr1: Lead-lag state,
Vr2: Regulator output state,
Ve: Integrator output state,
Vr3: Feedback output state
n_states::Int
: (Do not modify.) ESAC1A has 5 statesstates_types::Vector{StateTypes}
: (Do not modify.) ESAC1A has 5 statesinternal::InfrastructureSystemsInternal
: (Do not modify.) PowerSystems.jl internal reference
PowerSystems.get_E_sat
— Methodget_E_sat(value::ESAC1A) -> Tuple{Float64, Float64}
Get ESAC1A
E_sat
.
PowerSystems.get_Ka
— Methodget_Ka(value::ESAC1A) -> Float64
Get ESAC1A
Ka
.
PowerSystems.get_Kc
— Methodget_Kc(value::ESAC1A) -> Float64
Get ESAC1A
Kc
.
PowerSystems.get_Kd
— Methodget_Kd(value::ESAC1A) -> Float64
Get ESAC1A
Kd
.
PowerSystems.get_Ke
— Methodget_Ke(value::ESAC1A) -> Float64
Get ESAC1A
Ke
.
PowerSystems.get_Kf
— Methodget_Kf(value::ESAC1A) -> Float64
Get ESAC1A
Kf
.
PowerSystems.get_Se
— Methodget_Se(value::ESAC1A) -> Tuple{Float64, Float64}
Get ESAC1A
Se
.
PowerSystems.get_Ta
— Methodget_Ta(value::ESAC1A) -> Float64
Get ESAC1A
Ta
.
PowerSystems.get_Tb
— Methodget_Tb(value::ESAC1A) -> Float64
Get ESAC1A
Tb
.
PowerSystems.get_Tc
— Methodget_Tc(value::ESAC1A) -> Float64
Get ESAC1A
Tc
.
PowerSystems.get_Te
— Methodget_Te(value::ESAC1A) -> Float64
Get ESAC1A
Te
.
PowerSystems.get_Tf
— Methodget_Tf(value::ESAC1A) -> Float64
Get ESAC1A
Tf
.
PowerSystems.get_Tr
— Methodget_Tr(value::ESAC1A) -> Float64
Get ESAC1A
Tr
.
PowerSystems.get_V_ref
— Methodget_V_ref(value::ESAC1A) -> Float64
Get ESAC1A
V_ref
.
PowerSystems.get_Va_lim
— Methodget_Va_lim(
value::ESAC1A
) -> @NamedTuple{min::Float64, max::Float64}
Get ESAC1A
Va_lim
.
PowerSystems.get_Vr_lim
— Methodget_Vr_lim(
value::ESAC1A
) -> @NamedTuple{min::Float64, max::Float64}
Get ESAC1A
Vr_lim
.
PowerSystems.get_ext
— Methodget_ext(value::ESAC1A) -> Dict{String, Any}
Get ESAC1A
ext
.
PowerSystems.get_n_states
— Methodget_n_states(value::ESAC1A) -> Int64
Get ESAC1A
n_states
.
PowerSystems.get_saturation_coeffs
— Methodget_saturation_coeffs(
value::ESAC1A
) -> Tuple{Float64, Float64}
Get ESAC1A
saturation_coeffs
.
PowerSystems.get_states
— Methodget_states(value::ESAC1A) -> Vector{Symbol}
Get ESAC1A
states
.
PowerSystems.get_states_types
— Methodget_states_types(value::ESAC1A) -> Vector{StateTypes}
Get ESAC1A
states_types
.
PowerSystems.set_E_sat!
— Methodset_E_sat!(value::ESAC1A, val) -> Any
Set ESAC1A
E_sat
.
PowerSystems.set_Ka!
— Methodset_Ka!(value::ESAC1A, val) -> Any
Set ESAC1A
Ka
.
PowerSystems.set_Kc!
— Methodset_Kc!(value::ESAC1A, val) -> Any
Set ESAC1A
Kc
.
PowerSystems.set_Kd!
— Methodset_Kd!(value::ESAC1A, val) -> Any
Set ESAC1A
Kd
.
PowerSystems.set_Ke!
— Methodset_Ke!(value::ESAC1A, val) -> Any
Set ESAC1A
Ke
.
PowerSystems.set_Kf!
— Methodset_Kf!(value::ESAC1A, val) -> Any
Set ESAC1A
Kf
.
PowerSystems.set_Se!
— Methodset_Se!(value::ESAC1A, val) -> Any
Set ESAC1A
Se
.
PowerSystems.set_Ta!
— Methodset_Ta!(value::ESAC1A, val) -> Any
Set ESAC1A
Ta
.
PowerSystems.set_Tb!
— Methodset_Tb!(value::ESAC1A, val) -> Any
Set ESAC1A
Tb
.
PowerSystems.set_Tc!
— Methodset_Tc!(value::ESAC1A, val) -> Any
Set ESAC1A
Tc
.
PowerSystems.set_Te!
— Methodset_Te!(value::ESAC1A, val) -> Any
Set ESAC1A
Te
.
PowerSystems.set_Tf!
— Methodset_Tf!(value::ESAC1A, val) -> Any
Set ESAC1A
Tf
.
PowerSystems.set_Tr!
— Methodset_Tr!(value::ESAC1A, val) -> Any
Set ESAC1A
Tr
.
PowerSystems.set_V_ref!
— Methodset_V_ref!(value::ESAC1A, val) -> Any
Set ESAC1A
V_ref
.
PowerSystems.set_Va_lim!
— Methodset_Va_lim!(value::ESAC1A, val) -> Any
Set ESAC1A
Va_lim
.
PowerSystems.set_Vr_lim!
— Methodset_Vr_lim!(value::ESAC1A, val) -> Any
Set ESAC1A
Vr_lim
.
PowerSystems.set_ext!
— Methodset_ext!(value::ESAC1A, val) -> Any
Set ESAC1A
ext
.
PowerSystems.set_saturation_coeffs!
— Methodset_saturation_coeffs!(value::ESAC1A, val) -> Any
Set ESAC1A
saturation_coeffs
.
PowerSystems.set_states_types!
— Methodset_states_types!(value::ESAC1A, val) -> Any
Set ESAC1A
states_types
.
ESAC6A
PowerSystems.ESAC6A
— Typemutable struct ESAC6A <: AVR
Tr::Float64
Ka::Float64
Ta::Float64
Tk::Float64
Tb::Float64
Tc::Float64
Va_lim::MinMax
Vr_lim::MinMax
Te::Float64
VFE_lim::Float64
Kh::Float64
VH_max::Float64
Th::Float64
Tj::Float64
Kc::Float64
Kd::Float64
Ke::Float64
E_sat::Tuple{Float64, Float64}
Se::Tuple{Float64, Float64}
V_ref::Float64
saturation_coeffs::Tuple{Float64, Float64}
ext::Dict{String, Any}
states::Vector{Symbol}
n_states::Int
states_types::Vector{StateTypes}
internal::InfrastructureSystemsInternal
end
Modified AC6A. Used to represent field-controlled alternator-rectifier excitation systems with system-supplied electronic voltage regulators. Parameters of IEEE Std 421.5 Type AC6A Excitacion System. ESAC6A in PSSE and PSLF
Arguments
Tr::Float64
: Regulator input filter time constant in s, validation range:(0, 0.5)
Ka::Float64
: Regulator output gain, validation range:(0, 1000)
Ta::Float64
: Regulator output lag time constant in s, validation range:(0, 10)
Tk::Float64
: Voltage Regulator lead time constant, validation range:(0, 10)
Tb::Float64
: Regulator denominator (lag) time constant in s, validation range:(0, 20)
Tc::Float64
: Regulator numerator (lead) time constant in s, validation range:(0, 20)
Va_lim::MinMax
: Limits for regulator output(Va_min, Va_max)
Vr_lim::MinMax
: Limits for exciter field voltage(Vr_min, Vr_max)
Te::Float64
: Exciter field time constant, validation range:(eps(), 2)
VFE_lim::Float64
: Exciter field current limiter reference, validation range:(-5, 20)
Kh::Float64
: Exciter field current regulator feedback gain, validation range:(0, 100)
VH_max::Float64
: Exciter field current limiter maximum output, validation range:(0, 100)
Th::Float64
: Exciter field current limiter denominator (lag) time constant, validation range:(0, 1)
Tj::Float64
: Exciter field current limiter numerator (lead) time constant, validation range:(0, 1)
Kc::Float64
: Rectifier loading factor proportional to commutating reactance, validation range:(0, 1)
Kd::Float64
: Demagnetizing factor, function of exciter alternator reactances, validation range:(0, 2)
Ke::Float64
: Exciter field proportional constant, validation range:(0, 2)
E_sat::Tuple{Float64, Float64}
: Exciter output voltage for saturation factor: (E1, E2)Se::Tuple{Float64, Float64}
: Exciter saturation factor at exciter output voltage: (Se(E1), Se(E2))V_ref::Float64
: (default:1.0
) Reference Voltage Set-point (pu), validation range:(0, nothing)
saturation_coeffs::Tuple{Float64, Float64}
: (default:PowerSystems.get_avr_saturation(E_sat, Se)
) (Do not modify.) Coefficients (A,B) of the function: Se(V) = B(V - A)^2/Vext::Dict{String, Any}
: (default:Dict{String, Any}()
) An extra dictionary for users to add metadata that are not used in simulation, such as latitude and longitude.states::Vector{Symbol}
: (Do not modify.) The states are:
Vm: Sensed terminal voltage,
Vr1: Lead-lag state,
Vr2: Regulator output state,
Ve: Integrator output state,
Vr3: Feedback output state
n_states::Int
: (Do not modify.) ESAC6A has 5 statesstates_types::Vector{StateTypes}
: (Do not modify.) ESAC6A has 5 statesinternal::InfrastructureSystemsInternal
: (Do not modify.) PowerSystems.jl internal reference
PowerSystems.get_E_sat
— Methodget_E_sat(value::ESAC6A) -> Tuple{Float64, Float64}
Get ESAC6A
E_sat
.
PowerSystems.get_Ka
— Methodget_Ka(value::ESAC6A) -> Float64
Get ESAC6A
Ka
.
PowerSystems.get_Kc
— Methodget_Kc(value::ESAC6A) -> Float64
Get ESAC6A
Kc
.
PowerSystems.get_Kd
— Methodget_Kd(value::ESAC6A) -> Float64
Get ESAC6A
Kd
.
PowerSystems.get_Ke
— Methodget_Ke(value::ESAC6A) -> Float64
Get ESAC6A
Ke
.
PowerSystems.get_Kh
— Methodget_Kh(value::ESAC6A) -> Float64
Get ESAC6A
Kh
.
PowerSystems.get_Se
— Methodget_Se(value::ESAC6A) -> Tuple{Float64, Float64}
Get ESAC6A
Se
.
PowerSystems.get_Ta
— Methodget_Ta(value::ESAC6A) -> Float64
Get ESAC6A
Ta
.
PowerSystems.get_Tb
— Methodget_Tb(value::ESAC6A) -> Float64
Get ESAC6A
Tb
.
PowerSystems.get_Tc
— Methodget_Tc(value::ESAC6A) -> Float64
Get ESAC6A
Tc
.
PowerSystems.get_Te
— Methodget_Te(value::ESAC6A) -> Float64
Get ESAC6A
Te
.
PowerSystems.get_Th
— Methodget_Th(value::ESAC6A) -> Float64
Get ESAC6A
Th
.
PowerSystems.get_Tj
— Methodget_Tj(value::ESAC6A) -> Float64
Get ESAC6A
Tj
.
PowerSystems.get_Tk
— Methodget_Tk(value::ESAC6A) -> Float64
Get ESAC6A
Tk
.
PowerSystems.get_Tr
— Methodget_Tr(value::ESAC6A) -> Float64
Get ESAC6A
Tr
.
PowerSystems.get_VFE_lim
— Methodget_VFE_lim(value::ESAC6A) -> Float64
Get ESAC6A
VFE_lim
.
PowerSystems.get_VH_max
— Methodget_VH_max(value::ESAC6A) -> Float64
Get ESAC6A
VH_max
.
PowerSystems.get_V_ref
— Methodget_V_ref(value::ESAC6A) -> Float64
Get ESAC6A
V_ref
.
PowerSystems.get_Va_lim
— Methodget_Va_lim(
value::ESAC6A
) -> @NamedTuple{min::Float64, max::Float64}
Get ESAC6A
Va_lim
.
PowerSystems.get_Vr_lim
— Methodget_Vr_lim(
value::ESAC6A
) -> @NamedTuple{min::Float64, max::Float64}
Get ESAC6A
Vr_lim
.
PowerSystems.get_ext
— Methodget_ext(value::ESAC6A) -> Dict{String, Any}
Get ESAC6A
ext
.
PowerSystems.get_n_states
— Methodget_n_states(value::ESAC6A) -> Int64
Get ESAC6A
n_states
.
PowerSystems.get_saturation_coeffs
— Methodget_saturation_coeffs(
value::ESAC6A
) -> Tuple{Float64, Float64}
Get ESAC6A
saturation_coeffs
.
PowerSystems.get_states
— Methodget_states(value::ESAC6A) -> Vector{Symbol}
Get ESAC6A
states
.
PowerSystems.get_states_types
— Methodget_states_types(value::ESAC6A) -> Vector{StateTypes}
Get ESAC6A
states_types
.
PowerSystems.set_E_sat!
— Methodset_E_sat!(value::ESAC6A, val) -> Any
Set ESAC6A
E_sat
.
PowerSystems.set_Ka!
— Methodset_Ka!(value::ESAC6A, val) -> Any
Set ESAC6A
Ka
.
PowerSystems.set_Kc!
— Methodset_Kc!(value::ESAC6A, val) -> Any
Set ESAC6A
Kc
.
PowerSystems.set_Kd!
— Methodset_Kd!(value::ESAC6A, val) -> Any
Set ESAC6A
Kd
.
PowerSystems.set_Ke!
— Methodset_Ke!(value::ESAC6A, val) -> Any
Set ESAC6A
Ke
.
PowerSystems.set_Kh!
— Methodset_Kh!(value::ESAC6A, val) -> Any
Set ESAC6A
Kh
.
PowerSystems.set_Se!
— Methodset_Se!(value::ESAC6A, val) -> Any
Set ESAC6A
Se
.
PowerSystems.set_Ta!
— Methodset_Ta!(value::ESAC6A, val) -> Any
Set ESAC6A
Ta
.
PowerSystems.set_Tb!
— Methodset_Tb!(value::ESAC6A, val) -> Any
Set ESAC6A
Tb
.
PowerSystems.set_Tc!
— Methodset_Tc!(value::ESAC6A, val) -> Any
Set ESAC6A
Tc
.
PowerSystems.set_Te!
— Methodset_Te!(value::ESAC6A, val) -> Any
Set ESAC6A
Te
.
PowerSystems.set_Th!
— Methodset_Th!(value::ESAC6A, val) -> Any
Set ESAC6A
Th
.
PowerSystems.set_Tj!
— Methodset_Tj!(value::ESAC6A, val) -> Any
Set ESAC6A
Tj
.
PowerSystems.set_Tk!
— Methodset_Tk!(value::ESAC6A, val) -> Any
Set ESAC6A
Tk
.
PowerSystems.set_Tr!
— Methodset_Tr!(value::ESAC6A, val) -> Any
Set ESAC6A
Tr
.
PowerSystems.set_VFE_lim!
— Methodset_VFE_lim!(value::ESAC6A, val) -> Any
Set ESAC6A
VFE_lim
.
PowerSystems.set_VH_max!
— Methodset_VH_max!(value::ESAC6A, val) -> Any
Set ESAC6A
VH_max
.
PowerSystems.set_V_ref!
— Methodset_V_ref!(value::ESAC6A, val) -> Any
Set ESAC6A
V_ref
.
PowerSystems.set_Va_lim!
— Methodset_Va_lim!(value::ESAC6A, val) -> Any
Set ESAC6A
Va_lim
.
PowerSystems.set_Vr_lim!
— Methodset_Vr_lim!(value::ESAC6A, val) -> Any
Set ESAC6A
Vr_lim
.
PowerSystems.set_ext!
— Methodset_ext!(value::ESAC6A, val) -> Any
Set ESAC6A
ext
.
PowerSystems.set_saturation_coeffs!
— Methodset_saturation_coeffs!(value::ESAC6A, val) -> Any
Set ESAC6A
saturation_coeffs
.
PowerSystems.set_states_types!
— Methodset_states_types!(value::ESAC6A, val) -> Any
Set ESAC6A
states_types
.
ESAC8B
PowerSystems.ESAC8B
— Typemutable struct ESAC8B <: AVR
Tr::Float64
Kp::Float64
Ki::Float64
Kd::Float64
Td::Float64
Ka::Float64
Ta::Float64
Vr_lim::MinMax
Te::Float64
Ke::Float64
E_sat::Tuple{Float64, Float64}
Se::Tuple{Float64, Float64}
V_ref::Float64
saturation_coeffs::Tuple{Float64, Float64}
ext::Dict{String, Any}
states::Vector{Symbol}
n_states::Int
states_types::Vector{StateTypes}
internal::InfrastructureSystemsInternal
end
Excitation System AC8B. Used to represent the Basler Digital Excitation Control System (DECS) with PID controller in PSSE.
Arguments
Tr::Float64
: Regulator input filter time constant in s, validation range:(0, nothing)
Kp::Float64
: Regulator proportional PID gain, validation range:(0, nothing)
Ki::Float64
: Regulator integral PID gain, validation range:(0, nothing)
Kd::Float64
: Regulator derivative PID gain, validation range:(0, nothing)
Td::Float64
: Regulator derivative PID time constant., validation range:(0, 10)
Ka::Float64
: Regulator output gain, validation range:(0, 1000)
Ta::Float64
: Regulator output lag time constant in s, validation range:(0, 10)
Vr_lim::MinMax
: Limits for exciter field voltage(Vr_min, Vr_max)
Te::Float64
: Exciter field time constant, validation range:(eps(), 2)
Ke::Float64
: Exciter field proportional constant, validation range:(0, 2)
E_sat::Tuple{Float64, Float64}
: Exciter output voltage for saturation factor: (E1, E2)Se::Tuple{Float64, Float64}
: Exciter saturation factor at exciter output voltage: (Se(E1), Se(E2))V_ref::Float64
: (default:1.0
) Reference Voltage Set-point (pu), validation range:(0, nothing)
saturation_coeffs::Tuple{Float64, Float64}
: (default:PowerSystems.get_avr_saturation(E_sat, Se)
) (Do not modify.) Coefficients (A,B) of the function: Se(V) = B(V - A)^2/Vext::Dict{String, Any}
: (default:Dict{String, Any}()
) An extra dictionary for users to add metadata that are not used in simulation, such as latitude and longitude.states::Vector{Symbol}
: (Do not modify.) The states are:
Vm: Sensed terminal voltage,
x_i: Internal PI-block state,
x_d: Internal Derivative-block state,
Vr: Voltage regulator state,
Efd: Exciter output state
n_states::Int
: (Do not modify.) ESAC8B has 5 statesstates_types::Vector{StateTypes}
: (Do not modify.) ESAC8B has 5 statesinternal::InfrastructureSystemsInternal
: (Do not modify.) PowerSystems.jl internal reference
PowerSystems.get_E_sat
— Methodget_E_sat(value::ESAC8B) -> Tuple{Float64, Float64}
Get ESAC8B
E_sat
.
PowerSystems.get_Ka
— Methodget_Ka(value::ESAC8B) -> Float64
Get ESAC8B
Ka
.
PowerSystems.get_Kd
— Methodget_Kd(value::ESAC8B) -> Float64
Get ESAC8B
Kd
.
PowerSystems.get_Ke
— Methodget_Ke(value::ESAC8B) -> Float64
Get ESAC8B
Ke
.
PowerSystems.get_Ki
— Methodget_Ki(value::ESAC8B) -> Float64
Get ESAC8B
Ki
.
PowerSystems.get_Kp
— Methodget_Kp(value::ESAC8B) -> Float64
Get ESAC8B
Kp
.
PowerSystems.get_Se
— Methodget_Se(value::ESAC8B) -> Tuple{Float64, Float64}
Get ESAC8B
Se
.
PowerSystems.get_Ta
— Methodget_Ta(value::ESAC8B) -> Float64
Get ESAC8B
Ta
.
PowerSystems.get_Td
— Methodget_Td(value::ESAC8B) -> Float64
Get ESAC8B
Td
.
PowerSystems.get_Te
— Methodget_Te(value::ESAC8B) -> Float64
Get ESAC8B
Te
.
PowerSystems.get_Tr
— Methodget_Tr(value::ESAC8B) -> Float64
Get ESAC8B
Tr
.
PowerSystems.get_V_ref
— Methodget_V_ref(value::ESAC8B) -> Float64
Get ESAC8B
V_ref
.
PowerSystems.get_Vr_lim
— Methodget_Vr_lim(
value::ESAC8B
) -> @NamedTuple{min::Float64, max::Float64}
Get ESAC8B
Vr_lim
.
PowerSystems.get_ext
— Methodget_ext(value::ESAC8B) -> Dict{String, Any}
Get ESAC8B
ext
.
PowerSystems.get_n_states
— Methodget_n_states(value::ESAC8B) -> Int64
Get ESAC8B
n_states
.
PowerSystems.get_saturation_coeffs
— Methodget_saturation_coeffs(
value::ESAC8B
) -> Tuple{Float64, Float64}
Get ESAC8B
saturation_coeffs
.
PowerSystems.get_states
— Methodget_states(value::ESAC8B) -> Vector{Symbol}
Get ESAC8B
states
.
PowerSystems.get_states_types
— Methodget_states_types(value::ESAC8B) -> Vector{StateTypes}
Get ESAC8B
states_types
.
PowerSystems.set_E_sat!
— Methodset_E_sat!(value::ESAC8B, val) -> Any
Set ESAC8B
E_sat
.
PowerSystems.set_Ka!
— Methodset_Ka!(value::ESAC8B, val) -> Any
Set ESAC8B
Ka
.
PowerSystems.set_Kd!
— Methodset_Kd!(value::ESAC8B, val) -> Any
Set ESAC8B
Kd
.
PowerSystems.set_Ke!
— Methodset_Ke!(value::ESAC8B, val) -> Any
Set ESAC8B
Ke
.
PowerSystems.set_Ki!
— Methodset_Ki!(value::ESAC8B, val) -> Any
Set ESAC8B
Ki
.
PowerSystems.set_Kp!
— Methodset_Kp!(value::ESAC8B, val) -> Any
Set ESAC8B
Kp
.
PowerSystems.set_Se!
— Methodset_Se!(value::ESAC8B, val) -> Any
Set ESAC8B
Se
.
PowerSystems.set_Ta!
— Methodset_Ta!(value::ESAC8B, val) -> Any
Set ESAC8B
Ta
.
PowerSystems.set_Td!
— Methodset_Td!(value::ESAC8B, val) -> Any
Set ESAC8B
Td
.
PowerSystems.set_Te!
— Methodset_Te!(value::ESAC8B, val) -> Any
Set ESAC8B
Te
.
PowerSystems.set_Tr!
— Methodset_Tr!(value::ESAC8B, val) -> Any
Set ESAC8B
Tr
.
PowerSystems.set_V_ref!
— Methodset_V_ref!(value::ESAC8B, val) -> Any
Set ESAC8B
V_ref
.
PowerSystems.set_Vr_lim!
— Methodset_Vr_lim!(value::ESAC8B, val) -> Any
Set ESAC8B
Vr_lim
.
PowerSystems.set_ext!
— Methodset_ext!(value::ESAC8B, val) -> Any
Set ESAC8B
ext
.
PowerSystems.set_saturation_coeffs!
— Methodset_saturation_coeffs!(value::ESAC8B, val) -> Any
Set ESAC8B
saturation_coeffs
.
PowerSystems.set_states_types!
— Methodset_states_types!(value::ESAC8B, val) -> Any
Set ESAC8B
states_types
.
ESDC1A
PowerSystems.ESDC1A
— Typemutable struct ESDC1A <: AVR
Tr::Float64
Ka::Float64
Ta::Float64
Tb::Float64
Tc::Float64
Vr_lim::MinMax
Ke::Float64
Te::Float64
Kf::Float64
Tf::Float64
switch::Int
E_sat::Tuple{Float64, Float64}
Se::Tuple{Float64, Float64}
V_ref::Float64
saturation_coeffs::Tuple{Float64, Float64}
ext::Dict{String, Any}
states::Vector{Symbol}
n_states::Int
states_types::Vector{StateTypes}
internal::InfrastructureSystemsInternal
end
Self-excited shunt fields with the voltage regulator operating in a mode commonly termed buck-boost. Parameters of IEEE Std 421.5 Type DC1A Excitacion System. This model corresponds to ESDC1A in PSSE and PSLF
Arguments
Tr::Float64
: Voltage Measurement Time Constant in s, validation range:(0, 0.5)
Ka::Float64
: Amplifier Gain, validation range:(10, 500)
Ta::Float64
: Amplifier Time Constant in s, validation range:(0, 1)
Tb::Float64
: Regulator input Time Constant in s, validation range:(0, nothing)
Tc::Float64
: Regulator input Time Constant in s, validation range:(0, nothing)
Vr_lim::MinMax
: Voltage regulator limits (regulator output) (Vimin, Vimax)Ke::Float64
: Exciter constant related to self-excited field, validation range:(0, nothing)
Te::Float64
: Exciter time constant, integration rate associated with exciter control, validation range:(eps(), 1)
Kf::Float64
: Excitation control system stabilizer gain, validation range:(eps(), 0.3)
Tf::Float64
: Excitation control system stabilizer time constant, validation range:(eps(), nothing)
switch::Int
: Switch, validation range:(0, 1)
E_sat::Tuple{Float64, Float64}
: Exciter output voltage for saturation factor: (E1, E2)Se::Tuple{Float64, Float64}
: Exciter saturation factor at exciter output voltage: (Se(E1), Se(E2))V_ref::Float64
: (default:1.0
) Reference Voltage Set-point (pu), validation range:(0, nothing)
saturation_coeffs::Tuple{Float64, Float64}
: (default:PowerSystems.get_avr_saturation(E_sat, Se)
) (Do not modify.) Coefficients (A,B) of the function: Se(V) = B(V - A)^2/Vext::Dict{String, Any}
: (default:Dict{String, Any}()
) An extra dictionary for users to add metadata that are not used in simulation, such as latitude and longitude.states::Vector{Symbol}
: (Do not modify.) The states are:
Vt: Terminal Voltage,
Vr1: input lead lag,
Vr2: Regulator Output,
Vf: Exciter Output,
Vr3: Rate feedback integrator
n_states::Int
: (Do not modify.) The ESDC1A has 5 statesstates_types::Vector{StateTypes}
: (Do not modify.) ESDC1A has 5 differential statesinternal::InfrastructureSystemsInternal
: (Do not modify.) PowerSystems.jl internal reference
PowerSystems.get_E_sat
— Methodget_E_sat(value::ESDC1A) -> Tuple{Float64, Float64}
Get ESDC1A
E_sat
.
PowerSystems.get_Ka
— Methodget_Ka(value::ESDC1A) -> Float64
Get ESDC1A
Ka
.
PowerSystems.get_Ke
— Methodget_Ke(value::ESDC1A) -> Float64
Get ESDC1A
Ke
.
PowerSystems.get_Kf
— Methodget_Kf(value::ESDC1A) -> Float64
Get ESDC1A
Kf
.
PowerSystems.get_Se
— Methodget_Se(value::ESDC1A) -> Tuple{Float64, Float64}
Get ESDC1A
Se
.
PowerSystems.get_Ta
— Methodget_Ta(value::ESDC1A) -> Float64
Get ESDC1A
Ta
.
PowerSystems.get_Tb
— Methodget_Tb(value::ESDC1A) -> Float64
Get ESDC1A
Tb
.
PowerSystems.get_Tc
— Methodget_Tc(value::ESDC1A) -> Float64
Get ESDC1A
Tc
.
PowerSystems.get_Te
— Methodget_Te(value::ESDC1A) -> Float64
Get ESDC1A
Te
.
PowerSystems.get_Tf
— Methodget_Tf(value::ESDC1A) -> Float64
Get ESDC1A
Tf
.
PowerSystems.get_Tr
— Methodget_Tr(value::ESDC1A) -> Float64
Get ESDC1A
Tr
.
PowerSystems.get_V_ref
— Methodget_V_ref(value::ESDC1A) -> Float64
Get ESDC1A
V_ref
.
PowerSystems.get_Vr_lim
— Methodget_Vr_lim(
value::ESDC1A
) -> @NamedTuple{min::Float64, max::Float64}
Get ESDC1A
Vr_lim
.
PowerSystems.get_ext
— Methodget_ext(value::ESDC1A) -> Dict{String, Any}
Get ESDC1A
ext
.
PowerSystems.get_n_states
— Methodget_n_states(value::ESDC1A) -> Int64
Get ESDC1A
n_states
.
PowerSystems.get_saturation_coeffs
— Methodget_saturation_coeffs(
value::ESDC1A
) -> Tuple{Float64, Float64}
Get ESDC1A
saturation_coeffs
.
PowerSystems.get_states
— Methodget_states(value::ESDC1A) -> Vector{Symbol}
Get ESDC1A
states
.
PowerSystems.get_states_types
— Methodget_states_types(value::ESDC1A) -> Vector{StateTypes}
Get ESDC1A
states_types
.
PowerSystems.get_switch
— Methodget_switch(value::ESDC1A) -> Int64
Get ESDC1A
switch
.
PowerSystems.set_E_sat!
— Methodset_E_sat!(value::ESDC1A, val) -> Any
Set ESDC1A
E_sat
.
PowerSystems.set_Ka!
— Methodset_Ka!(value::ESDC1A, val) -> Any
Set ESDC1A
Ka
.
PowerSystems.set_Ke!
— Methodset_Ke!(value::ESDC1A, val) -> Any
Set ESDC1A
Ke
.
PowerSystems.set_Kf!
— Methodset_Kf!(value::ESDC1A, val) -> Any
Set ESDC1A
Kf
.
PowerSystems.set_Se!
— Methodset_Se!(value::ESDC1A, val) -> Any
Set ESDC1A
Se
.
PowerSystems.set_Ta!
— Methodset_Ta!(value::ESDC1A, val) -> Any
Set ESDC1A
Ta
.
PowerSystems.set_Tb!
— Methodset_Tb!(value::ESDC1A, val) -> Any
Set ESDC1A
Tb
.
PowerSystems.set_Tc!
— Methodset_Tc!(value::ESDC1A, val) -> Any
Set ESDC1A
Tc
.
PowerSystems.set_Te!
— Methodset_Te!(value::ESDC1A, val) -> Any
Set ESDC1A
Te
.
PowerSystems.set_Tf!
— Methodset_Tf!(value::ESDC1A, val) -> Any
Set ESDC1A
Tf
.
PowerSystems.set_Tr!
— Methodset_Tr!(value::ESDC1A, val) -> Any
Set ESDC1A
Tr
.
PowerSystems.set_V_ref!
— Methodset_V_ref!(value::ESDC1A, val) -> Any
Set ESDC1A
V_ref
.
PowerSystems.set_Vr_lim!
— Methodset_Vr_lim!(value::ESDC1A, val) -> Any
Set ESDC1A
Vr_lim
.
PowerSystems.set_ext!
— Methodset_ext!(value::ESDC1A, val) -> Any
Set ESDC1A
ext
.
PowerSystems.set_saturation_coeffs!
— Methodset_saturation_coeffs!(value::ESDC1A, val) -> Any
Set ESDC1A
saturation_coeffs
.
PowerSystems.set_states_types!
— Methodset_states_types!(value::ESDC1A, val) -> Any
Set ESDC1A
states_types
.
PowerSystems.set_switch!
— Methodset_switch!(value::ESDC1A, val) -> Any
Set ESDC1A
switch
.
ESDC2A
PowerSystems.ESDC2A
— Typemutable struct ESDC2A <: AVR
Tr::Float64
Ka::Float64
Ta::Float64
Tb::Float64
Tc::Float64
Vr_lim::MinMax
Ke::Float64
Te::Float64
Kf::Float64
Tf::Float64
switch::Int
E_sat::Tuple{Float64, Float64}
Se::Tuple{Float64, Float64}
V_ref::Float64
saturation_coeffs::Tuple{Float64, Float64}
ext::Dict{String, Any}
states::Vector{Symbol}
n_states::Int
states_types::Vector{StateTypes}
internal::InfrastructureSystemsInternal
end
Is used to represent field-controlled dc commutator exciters with continuously acting voltage regulators having power supplies derived from the generator or auxiliaries bus. Parameters of IEEE Std 421.5 Type DC2A Excitacion System. This model corresponds to ESDC2A in PSSE and PSLF
Arguments
Tr::Float64
: Voltage Measurement Time Constant in s, validation range:(0, 0.5)
Ka::Float64
: Amplifier Gain, validation range:(10, 500)
Ta::Float64
: Amplifier Time Constant in s, validation range:(0, 1)
Tb::Float64
: Regulator input Time Constant in s, validation range:(0, nothing)
Tc::Float64
: Regulator input Time Constant in s, validation range:(0, nothing)
Vr_lim::MinMax
: Voltage regulator limits (regulator output) (Vimin, Vimax)Ke::Float64
: Exciter constant related to self-excited field, validation range:(-1, 1)
Te::Float64
: Exciter time constant, integration rate associated with exciter control, validation range:(eps(), 2)
Kf::Float64
: Excitation control system stabilizer gain, validation range:(0, 0.3)
Tf::Float64
: Excitation control system stabilizer time constant. Appropiate Data: 5.0 <= Tf/Kf <= 15.0, validation range:(eps(), 1.5)
switch::Int
: Switch, validation range:(0, 1)
E_sat::Tuple{Float64, Float64}
: Exciter output voltage for saturation factor: (E1, E2)Se::Tuple{Float64, Float64}
: Exciter saturation factor at exciter output voltage: (Se(E1), Se(E2))V_ref::Float64
: (default:1.0
) Reference Voltage Set-point (pu), validation range:(0, nothing)
saturation_coeffs::Tuple{Float64, Float64}
: (default:PowerSystems.get_avr_saturation(E_sat, Se)
) (Do not modify.) Coefficients (A,B) of the function: Se(V) = B(V - A)^2/Vext::Dict{String, Any}
: (default:Dict{String, Any}()
) An extra dictionary for users to add metadata that are not used in simulation, such as latitude and longitude.states::Vector{Symbol}
: (Do not modify.) The states are:
Vt: Terminal Voltage,
Vr1: input lead lag,
Vr2: Regulator Output,
Vf: Exciter Output,
Vr3: Rate feedback integrator
n_states::Int
: (Do not modify.) The ESDC2A has 5 statesstates_types::Vector{StateTypes}
: (Do not modify.) ESDC2A has 5 differential statesinternal::InfrastructureSystemsInternal
: (Do not modify.) PowerSystems.jl internal reference
PowerSystems.get_E_sat
— Methodget_E_sat(value::ESDC2A) -> Tuple{Float64, Float64}
Get ESDC2A
E_sat
.
PowerSystems.get_Ka
— Methodget_Ka(value::ESDC2A) -> Float64
Get ESDC2A
Ka
.
PowerSystems.get_Ke
— Methodget_Ke(value::ESDC2A) -> Float64
Get ESDC2A
Ke
.
PowerSystems.get_Kf
— Methodget_Kf(value::ESDC2A) -> Float64
Get ESDC2A
Kf
.
PowerSystems.get_Se
— Methodget_Se(value::ESDC2A) -> Tuple{Float64, Float64}
Get ESDC2A
Se
.
PowerSystems.get_Ta
— Methodget_Ta(value::ESDC2A) -> Float64
Get ESDC2A
Ta
.
PowerSystems.get_Tb
— Methodget_Tb(value::ESDC2A) -> Float64
Get ESDC2A
Tb
.
PowerSystems.get_Tc
— Methodget_Tc(value::ESDC2A) -> Float64
Get ESDC2A
Tc
.
PowerSystems.get_Te
— Methodget_Te(value::ESDC2A) -> Float64
Get ESDC2A
Te
.
PowerSystems.get_Tf
— Methodget_Tf(value::ESDC2A) -> Float64
Get ESDC2A
Tf
.
PowerSystems.get_Tr
— Methodget_Tr(value::ESDC2A) -> Float64
Get ESDC2A
Tr
.
PowerSystems.get_V_ref
— Methodget_V_ref(value::ESDC2A) -> Float64
Get ESDC2A
V_ref
.
PowerSystems.get_Vr_lim
— Methodget_Vr_lim(
value::ESDC2A
) -> @NamedTuple{min::Float64, max::Float64}
Get ESDC2A
Vr_lim
.
PowerSystems.get_ext
— Methodget_ext(value::ESDC2A) -> Dict{String, Any}
Get ESDC2A
ext
.
PowerSystems.get_n_states
— Methodget_n_states(value::ESDC2A) -> Int64
Get ESDC2A
n_states
.
PowerSystems.get_saturation_coeffs
— Methodget_saturation_coeffs(
value::ESDC2A
) -> Tuple{Float64, Float64}
Get ESDC2A
saturation_coeffs
.
PowerSystems.get_states
— Methodget_states(value::ESDC2A) -> Vector{Symbol}
Get ESDC2A
states
.
PowerSystems.get_states_types
— Methodget_states_types(value::ESDC2A) -> Vector{StateTypes}
Get ESDC2A
states_types
.
PowerSystems.get_switch
— Methodget_switch(value::ESDC2A) -> Int64
Get ESDC2A
switch
.
PowerSystems.set_E_sat!
— Methodset_E_sat!(value::ESDC2A, val) -> Any
Set ESDC2A
E_sat
.
PowerSystems.set_Ka!
— Methodset_Ka!(value::ESDC2A, val) -> Any
Set ESDC2A
Ka
.
PowerSystems.set_Ke!
— Methodset_Ke!(value::ESDC2A, val) -> Any
Set ESDC2A
Ke
.
PowerSystems.set_Kf!
— Methodset_Kf!(value::ESDC2A, val) -> Any
Set ESDC2A
Kf
.
PowerSystems.set_Se!
— Methodset_Se!(value::ESDC2A, val) -> Any
Set ESDC2A
Se
.
PowerSystems.set_Ta!
— Methodset_Ta!(value::ESDC2A, val) -> Any
Set ESDC2A
Ta
.
PowerSystems.set_Tb!
— Methodset_Tb!(value::ESDC2A, val) -> Any
Set ESDC2A
Tb
.
PowerSystems.set_Tc!
— Methodset_Tc!(value::ESDC2A, val) -> Any
Set ESDC2A
Tc
.
PowerSystems.set_Te!
— Methodset_Te!(value::ESDC2A, val) -> Any
Set ESDC2A
Te
.
PowerSystems.set_Tf!
— Methodset_Tf!(value::ESDC2A, val) -> Any
Set ESDC2A
Tf
.
PowerSystems.set_Tr!
— Methodset_Tr!(value::ESDC2A, val) -> Any
Set ESDC2A
Tr
.
PowerSystems.set_V_ref!
— Methodset_V_ref!(value::ESDC2A, val) -> Any
Set ESDC2A
V_ref
.
PowerSystems.set_Vr_lim!
— Methodset_Vr_lim!(value::ESDC2A, val) -> Any
Set ESDC2A
Vr_lim
.
PowerSystems.set_ext!
— Methodset_ext!(value::ESDC2A, val) -> Any
Set ESDC2A
ext
.
PowerSystems.set_saturation_coeffs!
— Methodset_saturation_coeffs!(value::ESDC2A, val) -> Any
Set ESDC2A
saturation_coeffs
.
PowerSystems.set_states_types!
— Methodset_states_types!(value::ESDC2A, val) -> Any
Set ESDC2A
states_types
.
PowerSystems.set_switch!
— Methodset_switch!(value::ESDC2A, val) -> Any
Set ESDC2A
switch
.
ESST1A
PowerSystems.ESST1A
— Typemutable struct ESST1A <: AVR
UEL_flags::Int
PSS_flags::Int
Tr::Float64
Vi_lim::Tuple{Float64, Float64}
Tc::Float64
Tb::Float64
Tc1::Float64
Tb1::Float64
Ka::Float64
Ta::Float64
Va_lim::MinMax
Vr_lim::MinMax
Kc::Float64
Kf::Float64
Tf::Float64
K_lr::Float64
I_lr::Float64
V_ref::Float64
ext::Dict{String, Any}
states::Vector{Symbol}
n_states::Int
states_types::Vector{StateTypes}
internal::InfrastructureSystemsInternal
end
This excitation system supplies power through a transformer from the generator terminals and its regulated by a controlled rectifier (via thyristors). Parameters of IEEE Std 421.5 Type ST1A Excitacion System. ESST1A in PSSE and PSLF
Arguments
UEL_flags::Int
: Code input for Underexcitization limiter (UEL) entry. Not supported, validation range:(1, 3)
PSS_flags::Int
: Code input for Power System Stabilizer (PSS) or (VOS) entry, validation range:(1, 2)
Tr::Float64
: Regulator input filter time constant in s, validation range:(0, 0.1)
Vi_lim::Tuple{Float64, Float64}
: Voltage error limits (regulator input) (Vimin, Vimax)Tc::Float64
: First regulator denominator (lead) time constant in s, validation range:(0, 10)
Tb::Float64
: First regulator denominator (lag) time constant in s, validation range:(0, 20)
Tc1::Float64
: Second regulator denominator (lead) time constant in s, validation range:(0, 10)
Tb1::Float64
: Second regulator denominator (lead) time constant in s, validation range:(0, 20)
Ka::Float64
: Voltage regulator gain, validation range:(50, 1000)
Ta::Float64
: Voltage regulator time constant in s, validation range:(0, 0.5)
Va_lim::MinMax
: Limits for regulator output(Va_min, Va_max)
Vr_lim::MinMax
: Limits for exciter output(Vr_min, Vr_max)
Kc::Float64
: Rectifier loading factor proportional to commutating reactance, validation range:(0, 0.3)
Kf::Float64
: Rate feedback gain, validation range:(0, 0.3)
Tf::Float64
: Rate feedback time constant in s, validation range:(eps(), 1.5)
K_lr::Float64
: Exciter output current limiter gain, validation range:(0, 5)
I_lr::Float64
: Exciter output current limit reference, validation range:(0, 5)
V_ref::Float64
: (default:1.0
) Reference Voltage Set-point (pu), validation range:(0, nothing)
ext::Dict{String, Any}
: (default:Dict{String, Any}()
) An extra dictionary for users to add metadata that are not used in simulation, such as latitude and longitude.states::Vector{Symbol}
: (Do not modify.) The states are:
Vm: Sensed terminal voltage,
Vr1: First Lead-lag state,
Vr2: Second lead-lag state,
Va: Regulator output state,
Vr3: Feedback output state
n_states::Int
: (Do not modify.) ST1A has 5 statesstates_types::Vector{StateTypes}
: (Do not modify.) ST1A has 5 statesinternal::InfrastructureSystemsInternal
: (Do not modify.) PowerSystems.jl internal reference
PowerSystems.get_I_lr
— Methodget_I_lr(value::ESST1A) -> Float64
Get ESST1A
I_lr
.
PowerSystems.get_K_lr
— Methodget_K_lr(value::ESST1A) -> Float64
Get ESST1A
K_lr
.
PowerSystems.get_Ka
— Methodget_Ka(value::ESST1A) -> Float64
Get ESST1A
Ka
.
PowerSystems.get_Kc
— Methodget_Kc(value::ESST1A) -> Float64
Get ESST1A
Kc
.
PowerSystems.get_Kf
— Methodget_Kf(value::ESST1A) -> Float64
Get ESST1A
Kf
.
PowerSystems.get_PSS_flags
— Methodget_PSS_flags(value::ESST1A) -> Int64
Get ESST1A
PSS_flags
.
PowerSystems.get_Ta
— Methodget_Ta(value::ESST1A) -> Float64
Get ESST1A
Ta
.
PowerSystems.get_Tb
— Methodget_Tb(value::ESST1A) -> Float64
Get ESST1A
Tb
.
PowerSystems.get_Tb1
— Methodget_Tb1(value::ESST1A) -> Float64
Get ESST1A
Tb1
.
PowerSystems.get_Tc
— Methodget_Tc(value::ESST1A) -> Float64
Get ESST1A
Tc
.
PowerSystems.get_Tc1
— Methodget_Tc1(value::ESST1A) -> Float64
Get ESST1A
Tc1
.
PowerSystems.get_Tf
— Methodget_Tf(value::ESST1A) -> Float64
Get ESST1A
Tf
.
PowerSystems.get_Tr
— Methodget_Tr(value::ESST1A) -> Float64
Get ESST1A
Tr
.
PowerSystems.get_UEL_flags
— Methodget_UEL_flags(value::ESST1A) -> Int64
Get ESST1A
UEL_flags
.
PowerSystems.get_V_ref
— Methodget_V_ref(value::ESST1A) -> Float64
Get ESST1A
V_ref
.
PowerSystems.get_Va_lim
— Methodget_Va_lim(
value::ESST1A
) -> @NamedTuple{min::Float64, max::Float64}
Get ESST1A
Va_lim
.
PowerSystems.get_Vi_lim
— Methodget_Vi_lim(value::ESST1A) -> Tuple{Float64, Float64}
Get ESST1A
Vi_lim
.
PowerSystems.get_Vr_lim
— Methodget_Vr_lim(
value::ESST1A
) -> @NamedTuple{min::Float64, max::Float64}
Get ESST1A
Vr_lim
.
PowerSystems.get_ext
— Methodget_ext(value::ESST1A) -> Dict{String, Any}
Get ESST1A
ext
.
PowerSystems.get_n_states
— Methodget_n_states(value::ESST1A) -> Int64
Get ESST1A
n_states
.
PowerSystems.get_states
— Methodget_states(value::ESST1A) -> Vector{Symbol}
Get ESST1A
states
.
PowerSystems.get_states_types
— Methodget_states_types(value::ESST1A) -> Vector{StateTypes}
Get ESST1A
states_types
.
PowerSystems.set_I_lr!
— Methodset_I_lr!(value::ESST1A, val) -> Any
Set ESST1A
I_lr
.
PowerSystems.set_K_lr!
— Methodset_K_lr!(value::ESST1A, val) -> Any
Set ESST1A
K_lr
.
PowerSystems.set_Ka!
— Methodset_Ka!(value::ESST1A, val) -> Any
Set ESST1A
Ka
.
PowerSystems.set_Kc!
— Methodset_Kc!(value::ESST1A, val) -> Any
Set ESST1A
Kc
.
PowerSystems.set_Kf!
— Methodset_Kf!(value::ESST1A, val) -> Any
Set ESST1A
Kf
.
PowerSystems.set_PSS_flags!
— Methodset_PSS_flags!(value::ESST1A, val) -> Any
Set ESST1A
PSS_flags
.
PowerSystems.set_Ta!
— Methodset_Ta!(value::ESST1A, val) -> Any
Set ESST1A
Ta
.
PowerSystems.set_Tb!
— Methodset_Tb!(value::ESST1A, val) -> Any
Set ESST1A
Tb
.
PowerSystems.set_Tb1!
— Methodset_Tb1!(value::ESST1A, val) -> Any
Set ESST1A
Tb1
.
PowerSystems.set_Tc!
— Methodset_Tc!(value::ESST1A, val) -> Any
Set ESST1A
Tc
.
PowerSystems.set_Tc1!
— Methodset_Tc1!(value::ESST1A, val) -> Any
Set ESST1A
Tc1
.
PowerSystems.set_Tf!
— Methodset_Tf!(value::ESST1A, val) -> Any
Set ESST1A
Tf
.
PowerSystems.set_Tr!
— Methodset_Tr!(value::ESST1A, val) -> Any
Set ESST1A
Tr
.
PowerSystems.set_UEL_flags!
— Methodset_UEL_flags!(value::ESST1A, val) -> Any
Set ESST1A
UEL_flags
.
PowerSystems.set_V_ref!
— Methodset_V_ref!(value::ESST1A, val) -> Any
Set ESST1A
V_ref
.
PowerSystems.set_Va_lim!
— Methodset_Va_lim!(value::ESST1A, val) -> Any
Set ESST1A
Va_lim
.
PowerSystems.set_Vi_lim!
— Methodset_Vi_lim!(value::ESST1A, val) -> Any
Set ESST1A
Vi_lim
.
PowerSystems.set_Vr_lim!
— Methodset_Vr_lim!(value::ESST1A, val) -> Any
Set ESST1A
Vr_lim
.
PowerSystems.set_ext!
— Methodset_ext!(value::ESST1A, val) -> Any
Set ESST1A
ext
.
PowerSystems.set_states_types!
— Methodset_states_types!(value::ESST1A, val) -> Any
Set ESST1A
states_types
.
ESST4B
PowerSystems.ESST4B
— Typemutable struct ESST4B <: AVR
Tr::Float64
K_pr::Float64
K_ir::Float64
Vr_lim::MinMax
Ta::Float64
K_pm::Float64
K_im::Float64
Vm_lim::MinMax
Kg::Float64
Kp::Float64
Ki::Float64
VB_max::Float64
Kc::Float64
Xl::Float64
θp::Float64
V_ref::Float64
θp_rad::Float64
ext::Dict{String, Any}
states::Vector{Symbol}
n_states::Int
states_types::Vector{StateTypes}
internal::InfrastructureSystemsInternal
end
In these excitation systems, voltage (and also current in compounded systems) is transformed to an appropriate level. Rectifiers, either controlled or non-controlled, provide the necessary direct current for the generator field. Parameters of IEEE Std 421.5 Type ST4B Excitacion System. ESST4B in PSSE and PSLF
Arguments
Tr::Float64
: Regulator input filter time constant in s, validation range:(0, 0.5)
K_pr::Float64
: Regulator propotional gain, validation range:(0, 75)
K_ir::Float64
: Regulator integral gain, validation range:(0, 75)
Vr_lim::MinMax
: Voltage regulator limits (Vimin, Vimax)Ta::Float64
: Voltage regulator time constant in s, validation range:(0, 1)
K_pm::Float64
: Voltage regulator proportional gain output, validation range:(0, 1.2)
K_im::Float64
: Voltage regulator integral gain output, validation range:(0, 18)
Vm_lim::MinMax
: Limits for inner loop output(Vm_min, Vm_max)
Kg::Float64
: Feedback gain constant of the inner loop field regulator, validation range:(0, 1.1)
Kp::Float64
: Potential circuit (voltage) gain coefficient, validation range:(0, 10)
Ki::Float64
: Compound circuit (current) gain coefficient, validation range:(0, 1.1)
VB_max::Float64
: Maximum available exciter voltage, validation range:(1, 20)
Kc::Float64
: Rectifier loading factor proportional to commutating reactance, validation range:(0, 1)
Xl::Float64
: Reactance associated with potential source, validation range:(0, 0.5)
θp::Float64
: Potential circuit phase angle (degrees), validation range:(-90, 90)
V_ref::Float64
: (default:1.0
) Reference Voltage Set-point (pu), validation range:(0, nothing)
θp_rad::Float64
: (default:θp*π*inv(180)
) (Do not modify.) Potential circuit phase angle (radians)ext::Dict{String, Any}
: (default:Dict{String, Any}()
) An extra dictionary for users to add metadata that are not used in simulation, such as latitude and longitude.states::Vector{Symbol}
: (Do not modify.) The states are:
Vm: Sensed terminal voltage,
Vt: Sensed Terminal Voltage,
Vr1: Regulator Integrator,
Vr2: Regulator Output,
Vm: Output integrator
n_states::Int
: (Do not modify.) ST4B has 4 statesstates_types::Vector{StateTypes}
: (Do not modify.) ST4B has 4 statesinternal::InfrastructureSystemsInternal
: (Do not modify.) PowerSystems.jl internal reference
PowerSystems.get_K_im
— Methodget_K_im(value::ESST4B) -> Float64
Get ESST4B
K_im
.
PowerSystems.get_K_ir
— Methodget_K_ir(value::ESST4B) -> Float64
Get ESST4B
K_ir
.
PowerSystems.get_K_pm
— Methodget_K_pm(value::ESST4B) -> Float64
Get ESST4B
K_pm
.
PowerSystems.get_K_pr
— Methodget_K_pr(value::ESST4B) -> Float64
Get ESST4B
K_pr
.
PowerSystems.get_Kc
— Methodget_Kc(value::ESST4B) -> Float64
Get ESST4B
Kc
.
PowerSystems.get_Kg
— Methodget_Kg(value::ESST4B) -> Float64
Get ESST4B
Kg
.
PowerSystems.get_Ki
— Methodget_Ki(value::ESST4B) -> Float64
Get ESST4B
Ki
.
PowerSystems.get_Kp
— Methodget_Kp(value::ESST4B) -> Float64
Get ESST4B
Kp
.
PowerSystems.get_Ta
— Methodget_Ta(value::ESST4B) -> Float64
Get ESST4B
Ta
.
PowerSystems.get_Tr
— Methodget_Tr(value::ESST4B) -> Float64
Get ESST4B
Tr
.
PowerSystems.get_VB_max
— Methodget_VB_max(value::ESST4B) -> Float64
Get ESST4B
VB_max
.
PowerSystems.get_V_ref
— Methodget_V_ref(value::ESST4B) -> Float64
Get ESST4B
V_ref
.
PowerSystems.get_Vm_lim
— Methodget_Vm_lim(
value::ESST4B
) -> @NamedTuple{min::Float64, max::Float64}
Get ESST4B
Vm_lim
.
PowerSystems.get_Vr_lim
— Methodget_Vr_lim(
value::ESST4B
) -> @NamedTuple{min::Float64, max::Float64}
Get ESST4B
Vr_lim
.
PowerSystems.get_Xl
— Methodget_Xl(value::ESST4B) -> Float64
Get ESST4B
Xl
.
PowerSystems.get_ext
— Methodget_ext(value::ESST4B) -> Dict{String, Any}
Get ESST4B
ext
.
PowerSystems.get_n_states
— Methodget_n_states(value::ESST4B) -> Int64
Get ESST4B
n_states
.
PowerSystems.get_states
— Methodget_states(value::ESST4B) -> Vector{Symbol}
Get ESST4B
states
.
PowerSystems.get_states_types
— Methodget_states_types(value::ESST4B) -> Vector{StateTypes}
Get ESST4B
states_types
.
PowerSystems.get_θp
— Methodget_θp(value::ESST4B) -> Float64
Get ESST4B
θp
.
PowerSystems.get_θp_rad
— Methodget_θp_rad(value::ESST4B) -> Float64
Get ESST4B
θp_rad
.
PowerSystems.set_K_im!
— Methodset_K_im!(value::ESST4B, val) -> Any
Set ESST4B
K_im
.
PowerSystems.set_K_ir!
— Methodset_K_ir!(value::ESST4B, val) -> Any
Set ESST4B
K_ir
.
PowerSystems.set_K_pm!
— Methodset_K_pm!(value::ESST4B, val) -> Any
Set ESST4B
K_pm
.
PowerSystems.set_K_pr!
— Methodset_K_pr!(value::ESST4B, val) -> Any
Set ESST4B
K_pr
.
PowerSystems.set_Kc!
— Methodset_Kc!(value::ESST4B, val) -> Any
Set ESST4B
Kc
.
PowerSystems.set_Kg!
— Methodset_Kg!(value::ESST4B, val) -> Any
Set ESST4B
Kg
.
PowerSystems.set_Ki!
— Methodset_Ki!(value::ESST4B, val) -> Any
Set ESST4B
Ki
.
PowerSystems.set_Kp!
— Methodset_Kp!(value::ESST4B, val) -> Any
Set ESST4B
Kp
.
PowerSystems.set_Ta!
— Methodset_Ta!(value::ESST4B, val) -> Any
Set ESST4B
Ta
.
PowerSystems.set_Tr!
— Methodset_Tr!(value::ESST4B, val) -> Any
Set ESST4B
Tr
.
PowerSystems.set_VB_max!
— Methodset_VB_max!(value::ESST4B, val) -> Any
Set ESST4B
VB_max
.
PowerSystems.set_V_ref!
— Methodset_V_ref!(value::ESST4B, val) -> Any
Set ESST4B
V_ref
.
PowerSystems.set_Vm_lim!
— Methodset_Vm_lim!(value::ESST4B, val) -> Any
Set ESST4B
Vm_lim
.
PowerSystems.set_Vr_lim!
— Methodset_Vr_lim!(value::ESST4B, val) -> Any
Set ESST4B
Vr_lim
.
PowerSystems.set_Xl!
— Methodset_Xl!(value::ESST4B, val) -> Any
Set ESST4B
Xl
.
PowerSystems.set_ext!
— Methodset_ext!(value::ESST4B, val) -> Any
Set ESST4B
ext
.
PowerSystems.set_states_types!
— Methodset_states_types!(value::ESST4B, val) -> Any
Set ESST4B
states_types
.
PowerSystems.set_θp!
— Methodset_θp!(value::ESST4B, val) -> Any
Set ESST4B
θp
.
PowerSystems.set_θp_rad!
— Methodset_θp_rad!(value::ESST4B, val) -> Any
Set ESST4B
θp_rad
.
EXAC1
PowerSystems.EXAC1
— Typemutable struct EXAC1 <: AVR
Tr::Float64
Tb::Float64
Tc::Float64
Ka::Float64
Ta::Float64
Vr_lim::MinMax
Te::Float64
Kf::Float64
Tf::Float64
Kc::Float64
Kd::Float64
Ke::Float64
E_sat::Tuple{Float64, Float64}
Se::Tuple{Float64, Float64}
V_ref::Float64
saturation_coeffs::Tuple{Float64, Float64}
ext::Dict{String, Any}
states::Vector{Symbol}
n_states::Int
states_types::Vector{StateTypes}
internal::InfrastructureSystemsInternal
end
Modified ESAC1A. This excitation systems consists of an alternator main exciter feeding its output via non-controlled rectifiers. The exciter does not employ self-excitation, and the voltage regulator power is taken from a source that is not affected by external transients. Parameters of IEEE Std 421.5 Type AC1A. EXAC1 in PSSE and PSLF
Arguments
Tr::Float64
: Regulator input filter time constant in s, validation range:(0, 0.5)
Tb::Float64
: Regulator denominator (lag) time constant in s, validation range:(0, 20)
Tc::Float64
: Regulator numerator (lead) time constant in s, validation range:(0, 20)
Ka::Float64
: Regulator output gain, validation range:(0, 1000)
Ta::Float64
: Regulator output time constant in s, validation range:(0, 10)
Vr_lim::MinMax
: Limits for regulator output(Vr_min, Vr_max)
Te::Float64
: Exciter field time constant in s, validation range:(eps(), 2)
Kf::Float64
: Rate feedback excitation system stabilizer gain, validation range:(0, 0.3)
Tf::Float64
: Rate feedback time constant, validation range:(eps(), 1.5)
Kc::Float64
: Rectifier loading factor proportional to commutating reactance, validation range:(0, 1)
Kd::Float64
: Demagnetizing factor, function of exciter alternator reactances, validation range:(0, 1)
Ke::Float64
: Exciter field proportional constant, validation range:(0, 1)
E_sat::Tuple{Float64, Float64}
: Exciter output voltage for saturation factor: (E1, E2)Se::Tuple{Float64, Float64}
: Exciter saturation factor at exciter output voltage: (Se(E1), Se(E2))V_ref::Float64
: (default:1.0
) Reference Voltage Set-point (pu), validation range:(0, nothing)
saturation_coeffs::Tuple{Float64, Float64}
: (default:PowerSystems.get_avr_saturation(E_sat, Se)
) (Do not modify.) Coefficients (A,B) of the function: Se(V) = B(V - A)^2/Vext::Dict{String, Any}
: (default:Dict{String, Any}()
) An extra dictionary for users to add metadata that are not used in simulation, such as latitude and longitude.states::Vector{Symbol}
: (Do not modify.) The states are:
Vm: Sensed terminal voltage,
Vr1: Lead-lag state,
Vr2: Regulator output state,
Ve: Integrator output state,
Vr3: Feedback output state
n_states::Int
: (Do not modify.) EXAC1 has 5 statesstates_types::Vector{StateTypes}
: (Do not modify.) EXAC1 has 5 statesinternal::InfrastructureSystemsInternal
: (Do not modify.) PowerSystems.jl internal reference
PowerSystems.get_E_sat
— Methodget_E_sat(value::EXAC1) -> Tuple{Float64, Float64}
Get EXAC1
E_sat
.
PowerSystems.get_Ka
— Methodget_Ka(value::EXAC1) -> Float64
Get EXAC1
Ka
.
PowerSystems.get_Kc
— Methodget_Kc(value::EXAC1) -> Float64
Get EXAC1
Kc
.
PowerSystems.get_Kd
— Methodget_Kd(value::EXAC1) -> Float64
Get EXAC1
Kd
.
PowerSystems.get_Ke
— Methodget_Ke(value::EXAC1) -> Float64
Get EXAC1
Ke
.
PowerSystems.get_Kf
— Methodget_Kf(value::EXAC1) -> Float64
Get EXAC1
Kf
.
PowerSystems.get_Se
— Methodget_Se(value::EXAC1) -> Tuple{Float64, Float64}
Get EXAC1
Se
.
PowerSystems.get_Ta
— Methodget_Ta(value::EXAC1) -> Float64
Get EXAC1
Ta
.
PowerSystems.get_Tb
— Methodget_Tb(value::EXAC1) -> Float64
Get EXAC1
Tb
.
PowerSystems.get_Tc
— Methodget_Tc(value::EXAC1) -> Float64
Get EXAC1
Tc
.
PowerSystems.get_Te
— Methodget_Te(value::EXAC1) -> Float64
Get EXAC1
Te
.
PowerSystems.get_Tf
— Methodget_Tf(value::EXAC1) -> Float64
Get EXAC1
Tf
.
PowerSystems.get_Tr
— Methodget_Tr(value::EXAC1) -> Float64
Get EXAC1
Tr
.
PowerSystems.get_V_ref
— Methodget_V_ref(value::EXAC1) -> Float64
Get EXAC1
V_ref
.
PowerSystems.get_Vr_lim
— Methodget_Vr_lim(
value::EXAC1
) -> @NamedTuple{min::Float64, max::Float64}
Get EXAC1
Vr_lim
.
PowerSystems.get_ext
— Methodget_ext(value::EXAC1) -> Dict{String, Any}
Get EXAC1
ext
.
PowerSystems.get_n_states
— Methodget_n_states(value::EXAC1) -> Int64
Get EXAC1
n_states
.
PowerSystems.get_saturation_coeffs
— Methodget_saturation_coeffs(
value::EXAC1
) -> Tuple{Float64, Float64}
Get EXAC1
saturation_coeffs
.
PowerSystems.get_states
— Methodget_states(value::EXAC1) -> Vector{Symbol}
Get EXAC1
states
.
PowerSystems.get_states_types
— Methodget_states_types(value::EXAC1) -> Vector{StateTypes}
Get EXAC1
states_types
.
PowerSystems.set_E_sat!
— Methodset_E_sat!(value::EXAC1, val) -> Any
Set EXAC1
E_sat
.
PowerSystems.set_Ka!
— Methodset_Ka!(value::EXAC1, val) -> Any
Set EXAC1
Ka
.
PowerSystems.set_Kc!
— Methodset_Kc!(value::EXAC1, val) -> Any
Set EXAC1
Kc
.
PowerSystems.set_Kd!
— Methodset_Kd!(value::EXAC1, val) -> Any
Set EXAC1
Kd
.
PowerSystems.set_Ke!
— Methodset_Ke!(value::EXAC1, val) -> Any
Set EXAC1
Ke
.
PowerSystems.set_Kf!
— Methodset_Kf!(value::EXAC1, val) -> Any
Set EXAC1
Kf
.
PowerSystems.set_Se!
— Methodset_Se!(value::EXAC1, val) -> Any
Set EXAC1
Se
.
PowerSystems.set_Ta!
— Methodset_Ta!(value::EXAC1, val) -> Any
Set EXAC1
Ta
.
PowerSystems.set_Tb!
— Methodset_Tb!(value::EXAC1, val) -> Any
Set EXAC1
Tb
.
PowerSystems.set_Tc!
— Methodset_Tc!(value::EXAC1, val) -> Any
Set EXAC1
Tc
.
PowerSystems.set_Te!
— Methodset_Te!(value::EXAC1, val) -> Any
Set EXAC1
Te
.
PowerSystems.set_Tf!
— Methodset_Tf!(value::EXAC1, val) -> Any
Set EXAC1
Tf
.
PowerSystems.set_Tr!
— Methodset_Tr!(value::EXAC1, val) -> Any
Set EXAC1
Tr
.
PowerSystems.set_V_ref!
— Methodset_V_ref!(value::EXAC1, val) -> Any
Set EXAC1
V_ref
.
PowerSystems.set_Vr_lim!
— Methodset_Vr_lim!(value::EXAC1, val) -> Any
Set EXAC1
Vr_lim
.
PowerSystems.set_ext!
— Methodset_ext!(value::EXAC1, val) -> Any
Set EXAC1
ext
.
PowerSystems.set_saturation_coeffs!
— Methodset_saturation_coeffs!(value::EXAC1, val) -> Any
Set EXAC1
saturation_coeffs
.
PowerSystems.set_states_types!
— Methodset_states_types!(value::EXAC1, val) -> Any
Set EXAC1
states_types
.
EXAC1A
PowerSystems.EXAC1A
— Typemutable struct EXAC1A <: AVR
Tr::Float64
Tb::Float64
Tc::Float64
Ka::Float64
Ta::Float64
Va_lim::MinMax
Te::Float64
Kf::Float64
Tf::Float64
Kc::Float64
Kd::Float64
Ke::Float64
E_sat::Tuple{Float64, Float64}
Se::Tuple{Float64, Float64}
Vr_lim::MinMax
V_ref::Float64
saturation_coeffs::Tuple{Float64, Float64}
ext::Dict{String, Any}
states::Vector{Symbol}
n_states::Int
states_types::Vector{StateTypes}
internal::InfrastructureSystemsInternal
end
Modified ESAC1A. This excitation systems consists of an alternator main exciter feeding its output via non-controlled rectifiers. The exciter does not employ self-excitation, and the voltage regulator power is taken from a source that is not affected by external transients. Parameters of IEEE Std 421.5 Type AC1A Excitacion System. EXAC1A in PSSE and PSLF
Arguments
Tr::Float64
: Regulator input filter time constant in s, validation range:(0, 0.5)
Tb::Float64
: Regulator denominator (lag) time constant in s, validation range:(0, 20)
Tc::Float64
: Regulator numerator (lead) time constant in s, validation range:(0, 20)
Ka::Float64
: Regulator output gain, validation range:(0, 1000)
Ta::Float64
: Regulator output time constant in s, validation range:(0, 10)
Va_lim::MinMax
: Limits for regulator output(Va_min, Va_max)
Te::Float64
: Exciter field time constant in s, validation range:(eps(), 2)
Kf::Float64
: Rate feedback excitation system stabilizer gain, validation range:(0, 0.3)
Tf::Float64
: Rate feedback time constant, validation range:(eps(), 1.5)
Kc::Float64
: Rectifier loading factor proportional to commutating reactance, validation range:(0, 1)
Kd::Float64
: Demagnetizing factor, function of exciter alternator reactances, validation range:(0, 1)
Ke::Float64
: Exciter field proportional constant, validation range:(0, 1)
E_sat::Tuple{Float64, Float64}
: Exciter output voltage for saturation factor: (E1, E2)Se::Tuple{Float64, Float64}
: Exciter saturation factor at exciter output voltage: (Se(E1), Se(E2))Vr_lim::MinMax
: Limits for exciter field voltage:(Vr_min, Vr_max)
V_ref::Float64
: (default:1.0
) Reference Voltage Set-point (pu), validation range:(0, nothing)
saturation_coeffs::Tuple{Float64, Float64}
: (default:PowerSystems.get_avr_saturation(E_sat, Se)
) (Do not modify.) Coefficients (A,B) of the function: Se(x) = B(x - A)^2/xext::Dict{String, Any}
: (default:Dict{String, Any}()
) An extra dictionary for users to add metadata that are not used in simulation, such as latitude and longitude.states::Vector{Symbol}
: (Do not modify.) The states are:
Vm: Sensed terminal voltage,
Vr1: Lead-lag state,
Vr2: Regulator output state,
Ve: Integrator output state,
Vr3: Feedback output state
n_states::Int
: (Do not modify.) EXAC1A has 5 statesstates_types::Vector{StateTypes}
: (Do not modify.) EXAC1A has 5 statesinternal::InfrastructureSystemsInternal
: (Do not modify.) PowerSystems.jl internal reference
PowerSystems.get_E_sat
— Methodget_E_sat(value::EXAC1A) -> Tuple{Float64, Float64}
Get EXAC1A
E_sat
.
PowerSystems.get_Ka
— Methodget_Ka(value::EXAC1A) -> Float64
Get EXAC1A
Ka
.
PowerSystems.get_Kc
— Methodget_Kc(value::EXAC1A) -> Float64
Get EXAC1A
Kc
.
PowerSystems.get_Kd
— Methodget_Kd(value::EXAC1A) -> Float64
Get EXAC1A
Kd
.
PowerSystems.get_Ke
— Methodget_Ke(value::EXAC1A) -> Float64
Get EXAC1A
Ke
.
PowerSystems.get_Kf
— Methodget_Kf(value::EXAC1A) -> Float64
Get EXAC1A
Kf
.
PowerSystems.get_Se
— Methodget_Se(value::EXAC1A) -> Tuple{Float64, Float64}
Get EXAC1A
Se
.
PowerSystems.get_Ta
— Methodget_Ta(value::EXAC1A) -> Float64
Get EXAC1A
Ta
.
PowerSystems.get_Tb
— Methodget_Tb(value::EXAC1A) -> Float64
Get EXAC1A
Tb
.
PowerSystems.get_Tc
— Methodget_Tc(value::EXAC1A) -> Float64
Get EXAC1A
Tc
.
PowerSystems.get_Te
— Methodget_Te(value::EXAC1A) -> Float64
Get EXAC1A
Te
.
PowerSystems.get_Tf
— Methodget_Tf(value::EXAC1A) -> Float64
Get EXAC1A
Tf
.
PowerSystems.get_Tr
— Methodget_Tr(value::EXAC1A) -> Float64
Get EXAC1A
Tr
.
PowerSystems.get_V_ref
— Methodget_V_ref(value::EXAC1A) -> Float64
Get EXAC1A
V_ref
.
PowerSystems.get_Va_lim
— Methodget_Va_lim(
value::EXAC1A
) -> @NamedTuple{min::Float64, max::Float64}
Get EXAC1A
Va_lim
.
PowerSystems.get_Vr_lim
— Methodget_Vr_lim(
value::EXAC1A
) -> @NamedTuple{min::Float64, max::Float64}
Get EXAC1A
Vr_lim
.
PowerSystems.get_ext
— Methodget_ext(value::EXAC1A) -> Dict{String, Any}
Get EXAC1A
ext
.
PowerSystems.get_n_states
— Methodget_n_states(value::EXAC1A) -> Int64
Get EXAC1A
n_states
.
PowerSystems.get_saturation_coeffs
— Methodget_saturation_coeffs(
value::EXAC1A
) -> Tuple{Float64, Float64}
Get EXAC1A
saturation_coeffs
.
PowerSystems.get_states
— Methodget_states(value::EXAC1A) -> Vector{Symbol}
Get EXAC1A
states
.
PowerSystems.get_states_types
— Methodget_states_types(value::EXAC1A) -> Vector{StateTypes}
Get EXAC1A
states_types
.
PowerSystems.set_E_sat!
— Methodset_E_sat!(value::EXAC1A, val) -> Any
Set EXAC1A
E_sat
.
PowerSystems.set_Ka!
— Methodset_Ka!(value::EXAC1A, val) -> Any
Set EXAC1A
Ka
.
PowerSystems.set_Kc!
— Methodset_Kc!(value::EXAC1A, val) -> Any
Set EXAC1A
Kc
.
PowerSystems.set_Kd!
— Methodset_Kd!(value::EXAC1A, val) -> Any
Set EXAC1A
Kd
.
PowerSystems.set_Ke!
— Methodset_Ke!(value::EXAC1A, val) -> Any
Set EXAC1A
Ke
.
PowerSystems.set_Kf!
— Methodset_Kf!(value::EXAC1A, val) -> Any
Set EXAC1A
Kf
.
PowerSystems.set_Se!
— Methodset_Se!(value::EXAC1A, val) -> Any
Set EXAC1A
Se
.
PowerSystems.set_Ta!
— Methodset_Ta!(value::EXAC1A, val) -> Any
Set EXAC1A
Ta
.
PowerSystems.set_Tb!
— Methodset_Tb!(value::EXAC1A, val) -> Any
Set EXAC1A
Tb
.
PowerSystems.set_Tc!
— Methodset_Tc!(value::EXAC1A, val) -> Any
Set EXAC1A
Tc
.
PowerSystems.set_Te!
— Methodset_Te!(value::EXAC1A, val) -> Any
Set EXAC1A
Te
.
PowerSystems.set_Tf!
— Methodset_Tf!(value::EXAC1A, val) -> Any
Set EXAC1A
Tf
.
PowerSystems.set_Tr!
— Methodset_Tr!(value::EXAC1A, val) -> Any
Set EXAC1A
Tr
.
PowerSystems.set_V_ref!
— Methodset_V_ref!(value::EXAC1A, val) -> Any
Set EXAC1A
V_ref
.
PowerSystems.set_Va_lim!
— Methodset_Va_lim!(value::EXAC1A, val) -> Any
Set EXAC1A
Va_lim
.
PowerSystems.set_Vr_lim!
— Methodset_Vr_lim!(value::EXAC1A, val) -> Any
Set EXAC1A
Vr_lim
.
PowerSystems.set_ext!
— Methodset_ext!(value::EXAC1A, val) -> Any
Set EXAC1A
ext
.
PowerSystems.set_saturation_coeffs!
— Methodset_saturation_coeffs!(value::EXAC1A, val) -> Any
Set EXAC1A
saturation_coeffs
.
PowerSystems.set_states_types!
— Methodset_states_types!(value::EXAC1A, val) -> Any
Set EXAC1A
states_types
.
EXAC2
PowerSystems.EXAC2
— Typemutable struct EXAC2 <: AVR
Tr::Float64
Tb::Float64
Tc::Float64
Ka::Float64
Ta::Float64
Va_lim::MinMax
Kb::Float64
Vr_lim::MinMax
Te::Float64
Kl::Float64
Kh::Float64
Kf::Float64
Tf::Float64
Kc::Float64
Kd::Float64
Ke::Float64
V_lr::Float64
E_sat::Tuple{Float64, Float64}
Se::Tuple{Float64, Float64}
V_ref::Float64
saturation_coeffs::Tuple{Float64, Float64}
ext::Dict{String, Any}
states::Vector{Symbol}
n_states::Int
states_types::Vector{StateTypes}
internal::InfrastructureSystemsInternal
end
Modified AC2. This excitation systems consists of an alternator main exciter feeding its output via non-controlled rectifiers. The exciter does not employ self-excitation, and the voltage regulator power is taken from a source that is not affected by external transients. Parameters of IEEE Std 421.5 Type AC2A Excitacion System. The alternator main exciter is used, feeding its output via non-controlled rectifiers. The Type AC2C model is similar to that of Type AC1C except for the inclusion of exciter time constant compensation and exciter field current limiting elements. EXAC2 in PSSE and PSLF
Arguments
Tr::Float64
: Regulator input filter time constant in s, validation range:(0, 0.5)
Tb::Float64
: Regulator denominator (lag) time constant in s, validation range:(0, 20)
Tc::Float64
: Regulator numerator (lead) time constant in s, validation range:(0, 20)
Ka::Float64
: Regulator output gain, validation range:(0, 1000)
Ta::Float64
: Regulator output time constant in s, validation range:(0, 10)
Va_lim::MinMax
: Limits for regulator output(Va_min, Va_max)
Kb::Float64
: Second Stage regulator gain, validation range:(eps(), 500)
Vr_lim::MinMax
: Limits for exciter field voltage(Vr_min, Vr_max)
Te::Float64
: Exciter field time constant, validation range:(eps(), 2)
Kl::Float64
: Exciter field current limiter gain, validation range:(0, 1.1)
Kh::Float64
: Exciter field current regulator feedback gain, validation range:(0, 1.1)
Kf::Float64
: Rate feedback excitation system stabilizer gain, validation range:(0, 0.3)
Tf::Float64
: Rate feedback time constant, validation range:(eps(), nothing)
Kc::Float64
: Rectifier loading factor proportional to commutating reactance, validation range:(0, 1)
Kd::Float64
: Demagnetizing factor, function of exciter alternator reactances, validation range:(0, 1)
Ke::Float64
: Exciter field proportional constant, validation range:(0, 1)
V_lr::Float64
: Maximum exciter field current, validation range:(0, nothing)
E_sat::Tuple{Float64, Float64}
: Exciter output voltage for saturation factor: (E1, E2)Se::Tuple{Float64, Float64}
: Exciter saturation factor at exciter output voltage: (Se(E1), Se(E2))V_ref::Float64
: (default:1.0
) Reference Voltage Set-point (pu), validation range:(0, nothing)
saturation_coeffs::Tuple{Float64, Float64}
: (default:PowerSystems.get_avr_saturation(E_sat, Se)
) (Do not modify.) Coefficients (A,B) of the function: Se(V) = B(V - A)^2/Vext::Dict{String, Any}
: (default:Dict{String, Any}()
) An extra dictionary for users to add metadata that are not used in simulation, such as latitude and longitude.states::Vector{Symbol}
: (Do not modify.) The states are:
Vm: Sensed terminal voltage,
Vr1: Lead-lag state,
Vr2: Regulator output state,
Ve: Integrator output state,
Vr3: Feedback output state
n_states::Int
: (Do not modify.) EXAC2 has 5 statesstates_types::Vector{StateTypes}
: (Do not modify.) EXAC2 has 5 statesinternal::InfrastructureSystemsInternal
: (Do not modify.) PowerSystems.jl internal reference
PowerSystems.get_E_sat
— Methodget_E_sat(value::EXAC2) -> Tuple{Float64, Float64}
Get EXAC2
E_sat
.
PowerSystems.get_Ka
— Methodget_Ka(value::EXAC2) -> Float64
Get EXAC2
Ka
.
PowerSystems.get_Kb
— Methodget_Kb(value::EXAC2) -> Float64
Get EXAC2
Kb
.
PowerSystems.get_Kc
— Methodget_Kc(value::EXAC2) -> Float64
Get EXAC2
Kc
.
PowerSystems.get_Kd
— Methodget_Kd(value::EXAC2) -> Float64
Get EXAC2
Kd
.
PowerSystems.get_Ke
— Methodget_Ke(value::EXAC2) -> Float64
Get EXAC2
Ke
.
PowerSystems.get_Kf
— Methodget_Kf(value::EXAC2) -> Float64
Get EXAC2
Kf
.
PowerSystems.get_Kh
— Methodget_Kh(value::EXAC2) -> Float64
Get EXAC2
Kh
.
PowerSystems.get_Kl
— Methodget_Kl(value::EXAC2) -> Float64
Get EXAC2
Kl
.
PowerSystems.get_Se
— Methodget_Se(value::EXAC2) -> Tuple{Float64, Float64}
Get EXAC2
Se
.
PowerSystems.get_Ta
— Methodget_Ta(value::EXAC2) -> Float64
Get EXAC2
Ta
.
PowerSystems.get_Tb
— Methodget_Tb(value::EXAC2) -> Float64
Get EXAC2
Tb
.
PowerSystems.get_Tc
— Methodget_Tc(value::EXAC2) -> Float64
Get EXAC2
Tc
.
PowerSystems.get_Te
— Methodget_Te(value::EXAC2) -> Float64
Get EXAC2
Te
.
PowerSystems.get_Tf
— Methodget_Tf(value::EXAC2) -> Float64
Get EXAC2
Tf
.
PowerSystems.get_Tr
— Methodget_Tr(value::EXAC2) -> Float64
Get EXAC2
Tr
.
PowerSystems.get_V_lr
— Methodget_V_lr(value::EXAC2) -> Float64
Get EXAC2
V_lr
.
PowerSystems.get_V_ref
— Methodget_V_ref(value::EXAC2) -> Float64
Get EXAC2
V_ref
.
PowerSystems.get_Va_lim
— Methodget_Va_lim(
value::EXAC2
) -> @NamedTuple{min::Float64, max::Float64}
Get EXAC2
Va_lim
.
PowerSystems.get_Vr_lim
— Methodget_Vr_lim(
value::EXAC2
) -> @NamedTuple{min::Float64, max::Float64}
Get EXAC2
Vr_lim
.
PowerSystems.get_ext
— Methodget_ext(value::EXAC2) -> Dict{String, Any}
Get EXAC2
ext
.
PowerSystems.get_n_states
— Methodget_n_states(value::EXAC2) -> Int64
Get EXAC2
n_states
.
PowerSystems.get_saturation_coeffs
— Methodget_saturation_coeffs(
value::EXAC2
) -> Tuple{Float64, Float64}
Get EXAC2
saturation_coeffs
.
PowerSystems.get_states
— Methodget_states(value::EXAC2) -> Vector{Symbol}
Get EXAC2
states
.
PowerSystems.get_states_types
— Methodget_states_types(value::EXAC2) -> Vector{StateTypes}
Get EXAC2
states_types
.
PowerSystems.set_E_sat!
— Methodset_E_sat!(value::EXAC2, val) -> Any
Set EXAC2
E_sat
.
PowerSystems.set_Ka!
— Methodset_Ka!(value::EXAC2, val) -> Any
Set EXAC2
Ka
.
PowerSystems.set_Kb!
— Methodset_Kb!(value::EXAC2, val) -> Any
Set EXAC2
Kb
.
PowerSystems.set_Kc!
— Methodset_Kc!(value::EXAC2, val) -> Any
Set EXAC2
Kc
.
PowerSystems.set_Kd!
— Methodset_Kd!(value::EXAC2, val) -> Any
Set EXAC2
Kd
.
PowerSystems.set_Ke!
— Methodset_Ke!(value::EXAC2, val) -> Any
Set EXAC2
Ke
.
PowerSystems.set_Kf!
— Methodset_Kf!(value::EXAC2, val) -> Any
Set EXAC2
Kf
.
PowerSystems.set_Kh!
— Methodset_Kh!(value::EXAC2, val) -> Any
Set EXAC2
Kh
.
PowerSystems.set_Kl!
— Methodset_Kl!(value::EXAC2, val) -> Any
Set EXAC2
Kl
.
PowerSystems.set_Se!
— Methodset_Se!(value::EXAC2, val) -> Any
Set EXAC2
Se
.
PowerSystems.set_Ta!
— Methodset_Ta!(value::EXAC2, val) -> Any
Set EXAC2
Ta
.
PowerSystems.set_Tb!
— Methodset_Tb!(value::EXAC2, val) -> Any
Set EXAC2
Tb
.
PowerSystems.set_Tc!
— Methodset_Tc!(value::EXAC2, val) -> Any
Set EXAC2
Tc
.
PowerSystems.set_Te!
— Methodset_Te!(value::EXAC2, val) -> Any
Set EXAC2
Te
.
PowerSystems.set_Tf!
— Methodset_Tf!(value::EXAC2, val) -> Any
Set EXAC2
Tf
.
PowerSystems.set_Tr!
— Methodset_Tr!(value::EXAC2, val) -> Any
Set EXAC2
Tr
.
PowerSystems.set_V_lr!
— Methodset_V_lr!(value::EXAC2, val) -> Any
Set EXAC2
V_lr
.
PowerSystems.set_V_ref!
— Methodset_V_ref!(value::EXAC2, val) -> Any
Set EXAC2
V_ref
.
PowerSystems.set_Va_lim!
— Methodset_Va_lim!(value::EXAC2, val) -> Any
Set EXAC2
Va_lim
.
PowerSystems.set_Vr_lim!
— Methodset_Vr_lim!(value::EXAC2, val) -> Any
Set EXAC2
Vr_lim
.
PowerSystems.set_ext!
— Methodset_ext!(value::EXAC2, val) -> Any
Set EXAC2
ext
.
PowerSystems.set_saturation_coeffs!
— Methodset_saturation_coeffs!(value::EXAC2, val) -> Any
Set EXAC2
saturation_coeffs
.
PowerSystems.set_states_types!
— Methodset_states_types!(value::EXAC2, val) -> Any
Set EXAC2
states_types
.
EXPIC1
PowerSystems.EXPIC1
— Typemutable struct EXPIC1 <: AVR
Tr::Float64
Ka::Float64
Ta::Float64
Va_lim::MinMax
Ta_2::Float64
Ta_3::Float64
Ta_4::Float64
Vr_lim::MinMax
Kf::Float64
Tf_1::Float64
Tf_2::Float64
Efd_lim::MinMax
Ke::Float64
Te::Float64
E_sat::Tuple{Float64, Float64}
Se::Tuple{Float64, Float64}
Kp::Float64
Ki::Float64
Kc::Float64
V_ref::Float64
saturation_coeffs::Tuple{Float64, Float64}
ext::Dict{String, Any}
states::Vector{Symbol}
n_states::Int
states_types::Vector{StateTypes}
internal::InfrastructureSystemsInternal
end
Generic Proportional/Integral Excitation System
Arguments
Tr::Float64
: Regulator input filter time constant in s, validation range:(0, 0.5)
Ka::Float64
: Voltage regulator gain, validation range:(1, 500)
Ta::Float64
: Voltage regulator time constant in s, validation range:(0, 10)
Va_lim::MinMax
: Limits for pi controler(Vr_min, Vr_max)
Ta_2::Float64
: Voltage regulator time constant in s, validation range:(0, nothing)
Ta_3::Float64
: Voltage regulator time constant in s, validation range:(0, nothing)
Ta_4::Float64
: Voltage regulator time constant in s, validation range:(0, nothing)
Vr_lim::MinMax
: Voltage regulator limits (regulator output) (Vimin, Vimax)Kf::Float64
: Rate feedback gain, validation range:(0, 0.3)
Tf_1::Float64
: Rate Feedback time constant in s, validation range:(eps(), 15)
Tf_2::Float64
: Rate Feedback time constant in s, validation range:(0, 5)
Efd_lim::MinMax
: Field Voltage regulator limits (regulator output) (Efdmin, Efdmax)Ke::Float64
: Exciter constant, validation range:(0, 1)
Te::Float64
: Exciter time constant, validation range:(0, 2)
E_sat::Tuple{Float64, Float64}
: Exciter output voltage for saturation factor: (E1, E2)Se::Tuple{Float64, Float64}
: Exciter saturation factor at exciter output voltage: (Se(E1), Se(E2))Kp::Float64
: Potential source gain, validation range:(0, 5)
Ki::Float64
: current source gain, validation range:(0, 1.1)
Kc::Float64
: Exciter regulation factor, validation range:(0, 2)
V_ref::Float64
: (default:1.0
) Reference Voltage Set-point (pu), validation range:(0, nothing)
saturation_coeffs::Tuple{Float64, Float64}
: (default:PowerSystems.get_avr_saturation(E_sat, Se)
) (Do not modify.) Coefficients (A,B) of the function: Se(V) = B(V - A)^2/Vext::Dict{String, Any}
: (default:Dict{String, Any}()
) An extra dictionary for users to add metadata that are not used in simulation, such as latitude and longitude.states::Vector{Symbol}
: (Do not modify.) The states are:
Vm: Sensed terminal voltage,
Vr1: First Lead-lag state,
Vr2: Second regulator lead-lag state,
Vr2: Third regulator lead-lag state
Vf: Exciter output
Vr3: First feedback integrator,
Vr4: second feedback integrator
n_states::Int
: (Do not modify.) EXPIC1 has 6 statesstates_types::Vector{StateTypes}
: (Do not modify.) EXPIC has 6 statesinternal::InfrastructureSystemsInternal
: (Do not modify.) PowerSystems.jl internal reference
PowerSystems.get_E_sat
— Methodget_E_sat(value::EXPIC1) -> Tuple{Float64, Float64}
Get EXPIC1
E_sat
.
PowerSystems.get_Efd_lim
— Methodget_Efd_lim(
value::EXPIC1
) -> @NamedTuple{min::Float64, max::Float64}
Get EXPIC1
Efd_lim
.
PowerSystems.get_Ka
— Methodget_Ka(value::EXPIC1) -> Float64
Get EXPIC1
Ka
.
PowerSystems.get_Kc
— Methodget_Kc(value::EXPIC1) -> Float64
Get EXPIC1
Kc
.
PowerSystems.get_Ke
— Methodget_Ke(value::EXPIC1) -> Float64
Get EXPIC1
Ke
.
PowerSystems.get_Kf
— Methodget_Kf(value::EXPIC1) -> Float64
Get EXPIC1
Kf
.
PowerSystems.get_Ki
— Methodget_Ki(value::EXPIC1) -> Float64
Get EXPIC1
Ki
.
PowerSystems.get_Kp
— Methodget_Kp(value::EXPIC1) -> Float64
Get EXPIC1
Kp
.
PowerSystems.get_Se
— Methodget_Se(value::EXPIC1) -> Tuple{Float64, Float64}
Get EXPIC1
Se
.
PowerSystems.get_Ta
— Methodget_Ta(value::EXPIC1) -> Float64
Get EXPIC1
Ta
.
PowerSystems.get_Ta_2
— Methodget_Ta_2(value::EXPIC1) -> Float64
Get EXPIC1
Ta_2
.
PowerSystems.get_Ta_3
— Methodget_Ta_3(value::EXPIC1) -> Float64
Get EXPIC1
Ta_3
.
PowerSystems.get_Ta_4
— Methodget_Ta_4(value::EXPIC1) -> Float64
Get EXPIC1
Ta_4
.
PowerSystems.get_Te
— Methodget_Te(value::EXPIC1) -> Float64
Get EXPIC1
Te
.
PowerSystems.get_Tf_1
— Methodget_Tf_1(value::EXPIC1) -> Float64
Get EXPIC1
Tf_1
.
PowerSystems.get_Tf_2
— Methodget_Tf_2(value::EXPIC1) -> Float64
Get EXPIC1
Tf_2
.
PowerSystems.get_Tr
— Methodget_Tr(value::EXPIC1) -> Float64
Get EXPIC1
Tr
.
PowerSystems.get_V_ref
— Methodget_V_ref(value::EXPIC1) -> Float64
Get EXPIC1
V_ref
.
PowerSystems.get_Va_lim
— Methodget_Va_lim(
value::EXPIC1
) -> @NamedTuple{min::Float64, max::Float64}
Get EXPIC1
Va_lim
.
PowerSystems.get_Vr_lim
— Methodget_Vr_lim(
value::EXPIC1
) -> @NamedTuple{min::Float64, max::Float64}
Get EXPIC1
Vr_lim
.
PowerSystems.get_ext
— Methodget_ext(value::EXPIC1) -> Dict{String, Any}
Get EXPIC1
ext
.
PowerSystems.get_n_states
— Methodget_n_states(value::EXPIC1) -> Int64
Get EXPIC1
n_states
.
PowerSystems.get_saturation_coeffs
— Methodget_saturation_coeffs(
value::EXPIC1
) -> Tuple{Float64, Float64}
Get EXPIC1
saturation_coeffs
.
PowerSystems.get_states
— Methodget_states(value::EXPIC1) -> Vector{Symbol}
Get EXPIC1
states
.
PowerSystems.get_states_types
— Methodget_states_types(value::EXPIC1) -> Vector{StateTypes}
Get EXPIC1
states_types
.
PowerSystems.set_E_sat!
— Methodset_E_sat!(value::EXPIC1, val) -> Any
Set EXPIC1
E_sat
.
PowerSystems.set_Efd_lim!
— Methodset_Efd_lim!(value::EXPIC1, val) -> Any
Set EXPIC1
Efd_lim
.
PowerSystems.set_Ka!
— Methodset_Ka!(value::EXPIC1, val) -> Any
Set EXPIC1
Ka
.
PowerSystems.set_Kc!
— Methodset_Kc!(value::EXPIC1, val) -> Any
Set EXPIC1
Kc
.
PowerSystems.set_Ke!
— Methodset_Ke!(value::EXPIC1, val) -> Any
Set EXPIC1
Ke
.
PowerSystems.set_Kf!
— Methodset_Kf!(value::EXPIC1, val) -> Any
Set EXPIC1
Kf
.
PowerSystems.set_Ki!
— Methodset_Ki!(value::EXPIC1, val) -> Any
Set EXPIC1
Ki
.
PowerSystems.set_Kp!
— Methodset_Kp!(value::EXPIC1, val) -> Any
Set EXPIC1
Kp
.
PowerSystems.set_Se!
— Methodset_Se!(value::EXPIC1, val) -> Any
Set EXPIC1
Se
.
PowerSystems.set_Ta!
— Methodset_Ta!(value::EXPIC1, val) -> Any
Set EXPIC1
Ta
.
PowerSystems.set_Ta_2!
— Methodset_Ta_2!(value::EXPIC1, val) -> Any
Set EXPIC1
Ta_2
.
PowerSystems.set_Ta_3!
— Methodset_Ta_3!(value::EXPIC1, val) -> Any
Set EXPIC1
Ta_3
.
PowerSystems.set_Ta_4!
— Methodset_Ta_4!(value::EXPIC1, val) -> Any
Set EXPIC1
Ta_4
.
PowerSystems.set_Te!
— Methodset_Te!(value::EXPIC1, val) -> Any
Set EXPIC1
Te
.
PowerSystems.set_Tf_1!
— Methodset_Tf_1!(value::EXPIC1, val) -> Any
Set EXPIC1
Tf_1
.
PowerSystems.set_Tf_2!
— Methodset_Tf_2!(value::EXPIC1, val) -> Any
Set EXPIC1
Tf_2
.
PowerSystems.set_Tr!
— Methodset_Tr!(value::EXPIC1, val) -> Any
Set EXPIC1
Tr
.
PowerSystems.set_V_ref!
— Methodset_V_ref!(value::EXPIC1, val) -> Any
Set EXPIC1
V_ref
.
PowerSystems.set_Va_lim!
— Methodset_Va_lim!(value::EXPIC1, val) -> Any
Set EXPIC1
Va_lim
.
PowerSystems.set_Vr_lim!
— Methodset_Vr_lim!(value::EXPIC1, val) -> Any
Set EXPIC1
Vr_lim
.
PowerSystems.set_ext!
— Methodset_ext!(value::EXPIC1, val) -> Any
Set EXPIC1
ext
.
PowerSystems.set_saturation_coeffs!
— Methodset_saturation_coeffs!(value::EXPIC1, val) -> Any
Set EXPIC1
saturation_coeffs
.
PowerSystems.set_states_types!
— Methodset_states_types!(value::EXPIC1, val) -> Any
Set EXPIC1
states_types
.
IEEET1
PowerSystems.IEEET1
— Typemutable struct IEEET1 <: AVR
Tr::Float64
Ka::Float64
Ta::Float64
Vr_lim::MinMax
Ke::Float64
Te::Float64
Kf::Float64
Tf::Float64
switch::Int
E_sat::Tuple{Float64, Float64}
Se::Tuple{Float64, Float64}
V_ref::Float64
saturation_coeffs::Tuple{Float64, Float64}
ext::Dict{String, Any}
states::Vector{Symbol}
n_states::Int
states_types::Vector{StateTypes}
internal::InfrastructureSystemsInternal
end
1968 IEEE type 1 excitation system model
Arguments
Tr::Float64
: Voltage Measurement Time Constant in s, validation range:(0, 0.5)
Ka::Float64
: Amplifier Gain, validation range:(10, 500)
Ta::Float64
: Amplifier Time Constant in s, validation range:(0, 1)
Vr_lim::MinMax
: Voltage regulator limits (regulator output) (Vimin, Vimax)Ke::Float64
: Exciter constant related to self-excited field, validation range:(-1, 1)
Te::Float64
: Exciter time constant, integration rate associated with exciter control, validation range:(eps(), 1)
Kf::Float64
: Excitation control system stabilizer gain, validation range:(eps(), 0.3)
Tf::Float64
: Excitation control system stabilizer time constant. Appropiate Data: 5 <= Tf/Kf <= 15, validation range:(eps(), nothing)
switch::Int
: Switch, validation range:(0, 1)
E_sat::Tuple{Float64, Float64}
: Exciter output voltage for saturation factor: (E1, E2)Se::Tuple{Float64, Float64}
: Exciter saturation factor at exciter output voltage: (Se(E1), Se(E2))V_ref::Float64
: (default:1.0
) Reference Voltage Set-point (pu), validation range:(0, nothing)
saturation_coeffs::Tuple{Float64, Float64}
: (default:PowerSystems.get_avr_saturation(E_sat, Se)
) (Do not modify.) Coefficients (A,B) of the function: Se(V) = B(V - A)^2/Vext::Dict{String, Any}
: (default:Dict{String, Any}()
) An extra dictionary for users to add metadata that are not used in simulation, such as latitude and longitude.states::Vector{Symbol}
: (Do not modify.) The states are:
Vt: Terminal Voltage,
Vr: Regulator Output,
Vf: Exciter Output,
Vr3: Rate feedback integrator
n_states::Int
: (Do not modify.) The IEEET1 has 4 statesstates_types::Vector{StateTypes}
: (Do not modify.) IEEET1 I has 4 differential statesinternal::InfrastructureSystemsInternal
: (Do not modify.) PowerSystems.jl internal reference
PowerSystems.get_E_sat
— Methodget_E_sat(value::IEEET1) -> Tuple{Float64, Float64}
Get IEEET1
E_sat
.
PowerSystems.get_Ka
— Methodget_Ka(value::IEEET1) -> Float64
Get IEEET1
Ka
.
PowerSystems.get_Ke
— Methodget_Ke(value::IEEET1) -> Float64
Get IEEET1
Ke
.
PowerSystems.get_Kf
— Methodget_Kf(value::IEEET1) -> Float64
Get IEEET1
Kf
.
PowerSystems.get_Se
— Methodget_Se(value::IEEET1) -> Tuple{Float64, Float64}
Get IEEET1
Se
.
PowerSystems.get_Ta
— Methodget_Ta(value::IEEET1) -> Float64
Get IEEET1
Ta
.
PowerSystems.get_Te
— Methodget_Te(value::IEEET1) -> Float64
Get IEEET1
Te
.
PowerSystems.get_Tf
— Methodget_Tf(value::IEEET1) -> Float64
Get IEEET1
Tf
.
PowerSystems.get_Tr
— Methodget_Tr(value::IEEET1) -> Float64
Get IEEET1
Tr
.
PowerSystems.get_V_ref
— Methodget_V_ref(value::IEEET1) -> Float64
Get IEEET1
V_ref
.
PowerSystems.get_Vr_lim
— Methodget_Vr_lim(
value::IEEET1
) -> @NamedTuple{min::Float64, max::Float64}
Get IEEET1
Vr_lim
.
PowerSystems.get_ext
— Methodget_ext(value::IEEET1) -> Dict{String, Any}
Get IEEET1
ext
.
PowerSystems.get_n_states
— Methodget_n_states(value::IEEET1) -> Int64
Get IEEET1
n_states
.
PowerSystems.get_saturation_coeffs
— Methodget_saturation_coeffs(
value::IEEET1
) -> Tuple{Float64, Float64}
Get IEEET1
saturation_coeffs
.
PowerSystems.get_states
— Methodget_states(value::IEEET1) -> Vector{Symbol}
Get IEEET1
states
.
PowerSystems.get_states_types
— Methodget_states_types(value::IEEET1) -> Vector{StateTypes}
Get IEEET1
states_types
.
PowerSystems.get_switch
— Methodget_switch(value::IEEET1) -> Int64
Get IEEET1
switch
.
PowerSystems.set_E_sat!
— Methodset_E_sat!(value::IEEET1, val) -> Any
Set IEEET1
E_sat
.
PowerSystems.set_Ka!
— Methodset_Ka!(value::IEEET1, val) -> Any
Set IEEET1
Ka
.
PowerSystems.set_Ke!
— Methodset_Ke!(value::IEEET1, val) -> Any
Set IEEET1
Ke
.
PowerSystems.set_Kf!
— Methodset_Kf!(value::IEEET1, val) -> Any
Set IEEET1
Kf
.
PowerSystems.set_Se!
— Methodset_Se!(value::IEEET1, val) -> Any
Set IEEET1
Se
.
PowerSystems.set_Ta!
— Methodset_Ta!(value::IEEET1, val) -> Any
Set IEEET1
Ta
.
PowerSystems.set_Te!
— Methodset_Te!(value::IEEET1, val) -> Any
Set IEEET1
Te
.
PowerSystems.set_Tf!
— Methodset_Tf!(value::IEEET1, val) -> Any
Set IEEET1
Tf
.
PowerSystems.set_Tr!
— Methodset_Tr!(value::IEEET1, val) -> Any
Set IEEET1
Tr
.
PowerSystems.set_V_ref!
— Methodset_V_ref!(value::IEEET1, val) -> Any
Set IEEET1
V_ref
.
PowerSystems.set_Vr_lim!
— Methodset_Vr_lim!(value::IEEET1, val) -> Any
Set IEEET1
Vr_lim
.
PowerSystems.set_ext!
— Methodset_ext!(value::IEEET1, val) -> Any
Set IEEET1
ext
.
PowerSystems.set_saturation_coeffs!
— Methodset_saturation_coeffs!(value::IEEET1, val) -> Any
Set IEEET1
saturation_coeffs
.
PowerSystems.set_states_types!
— Methodset_states_types!(value::IEEET1, val) -> Any
Set IEEET1
states_types
.
PowerSystems.set_switch!
— Methodset_switch!(value::IEEET1, val) -> Any
Set IEEET1
switch
.
EX4VSA
PowerSystems.get_E_lim
— Methodget_E_lim(
value::PowerSystems.EX4VSA
) -> @NamedTuple{min::Float64, max::Float64}
Get EX4VSA
E_lim
.
PowerSystems.get_G
— Methodget_G(value::PowerSystems.EX4VSA) -> Float64
Get EX4VSA
G
.
PowerSystems.get_Iflim
— Methodget_Iflim(value::PowerSystems.EX4VSA) -> Float64
Get EX4VSA
Iflim
.
PowerSystems.get_K1
— Methodget_K1(value::PowerSystems.EX4VSA) -> Float64
Get EX4VSA
K1
.
PowerSystems.get_K2
— Methodget_K2(value::PowerSystems.EX4VSA) -> Float64
Get EX4VSA
K2
.
PowerSystems.get_Oel_lim
— Methodget_Oel_lim(
value::PowerSystems.EX4VSA
) -> @NamedTuple{min::Float64, max::Float64}
Get EX4VSA
Oel_lim
.
PowerSystems.get_Spar
— Methodget_Spar(value::PowerSystems.EX4VSA) -> Float64
Get EX4VSA
Spar
.
PowerSystems.get_Ta
— Methodget_Ta(value::PowerSystems.EX4VSA) -> Float64
Get EX4VSA
Ta
.
PowerSystems.get_Tb
— Methodget_Tb(value::PowerSystems.EX4VSA) -> Float64
Get EX4VSA
Tb
.
PowerSystems.get_Te
— Methodget_Te(value::PowerSystems.EX4VSA) -> Float64
Get EX4VSA
Te
.
PowerSystems.get_V_ref
— Methodget_V_ref(value::PowerSystems.EX4VSA) -> Float64
Get EX4VSA
V_ref
.
PowerSystems.get_d
— Methodget_d(value::PowerSystems.EX4VSA) -> Float64
Get EX4VSA
d
.
PowerSystems.get_ext
— Methodget_ext(value::PowerSystems.EX4VSA) -> Dict{String, Any}
Get EX4VSA
ext
.
PowerSystems.get_f
— Methodget_f(value::PowerSystems.EX4VSA) -> Float64
Get EX4VSA
f
.
PowerSystems.get_n_states
— Methodget_n_states(value::PowerSystems.EX4VSA) -> Int64
Get EX4VSA
n_states
.
PowerSystems.get_states
— Methodget_states(value::PowerSystems.EX4VSA) -> Vector{Symbol}
Get EX4VSA
states
.
PowerSystems.set_E_lim!
— Methodset_E_lim!(value::PowerSystems.EX4VSA, val) -> Any
Set EX4VSA
E_lim
.
PowerSystems.set_G!
— Methodset_G!(value::PowerSystems.EX4VSA, val) -> Any
Set EX4VSA
G
.
PowerSystems.set_Iflim!
— Methodset_Iflim!(value::PowerSystems.EX4VSA, val) -> Any
Set EX4VSA
Iflim
.
PowerSystems.set_K1!
— Methodset_K1!(value::PowerSystems.EX4VSA, val) -> Any
Set EX4VSA
K1
.
PowerSystems.set_K2!
— Methodset_K2!(value::PowerSystems.EX4VSA, val) -> Any
Set EX4VSA
K2
.
PowerSystems.set_Oel_lim!
— Methodset_Oel_lim!(value::PowerSystems.EX4VSA, val) -> Any
Set EX4VSA
Oel_lim
.
PowerSystems.set_Spar!
— Methodset_Spar!(value::PowerSystems.EX4VSA, val) -> Any
Set EX4VSA
Spar
.
PowerSystems.set_Ta!
— Methodset_Ta!(value::PowerSystems.EX4VSA, val) -> Any
Set EX4VSA
Ta
.
PowerSystems.set_Tb!
— Methodset_Tb!(value::PowerSystems.EX4VSA, val) -> Any
Set EX4VSA
Tb
.
PowerSystems.set_Te!
— Methodset_Te!(value::PowerSystems.EX4VSA, val) -> Any
Set EX4VSA
Te
.
PowerSystems.set_V_ref!
— Methodset_V_ref!(value::PowerSystems.EX4VSA, val) -> Any
Set EX4VSA
V_ref
.
PowerSystems.set_d!
— Methodset_d!(value::PowerSystems.EX4VSA, val) -> Any
Set EX4VSA
d
.
PowerSystems.set_ext!
— Methodset_ext!(value::PowerSystems.EX4VSA, val) -> Any
Set EX4VSA
ext
.
PowerSystems.set_f!
— Methodset_f!(value::PowerSystems.EX4VSA, val) -> Any
Set EX4VSA
f
.
EXST1
PowerSystems.get_Ka
— Methodget_Ka(value::PowerSystems.EXST1) -> Float64
Get EXST1
Ka
.
PowerSystems.get_Kc
— Methodget_Kc(value::PowerSystems.EXST1) -> Float64
Get EXST1
Kc
.
PowerSystems.get_Kf
— Methodget_Kf(value::PowerSystems.EXST1) -> Float64
Get EXST1
Kf
.
PowerSystems.get_Ta
— Methodget_Ta(value::PowerSystems.EXST1) -> Float64
Get EXST1
Ta
.
PowerSystems.get_Tb
— Methodget_Tb(value::PowerSystems.EXST1) -> Float64
Get EXST1
Tb
.
PowerSystems.get_Tc
— Methodget_Tc(value::PowerSystems.EXST1) -> Float64
Get EXST1
Tc
.
PowerSystems.get_Tf
— Methodget_Tf(value::PowerSystems.EXST1) -> Float64
Get EXST1
Tf
.
PowerSystems.get_Tr
— Methodget_Tr(value::PowerSystems.EXST1) -> Float64
Get EXST1
Tr
.
PowerSystems.get_V_ref
— Methodget_V_ref(value::PowerSystems.EXST1) -> Float64
Get EXST1
V_ref
.
PowerSystems.get_Vi_lim
— Methodget_Vi_lim(
value::PowerSystems.EXST1
) -> @NamedTuple{min::Float64, max::Float64}
Get EXST1
Vi_lim
.
PowerSystems.get_Vr_lim
— Methodget_Vr_lim(
value::PowerSystems.EXST1
) -> @NamedTuple{min::Float64, max::Float64}
Get EXST1
Vr_lim
.
PowerSystems.get_ext
— Methodget_ext(value::PowerSystems.EXST1) -> Dict{String, Any}
Get EXST1
ext
.
PowerSystems.get_n_states
— Methodget_n_states(value::PowerSystems.EXST1) -> Int64
Get EXST1
n_states
.
PowerSystems.get_states
— Methodget_states(value::PowerSystems.EXST1) -> Vector{Symbol}
Get EXST1
states
.
PowerSystems.set_Ka!
— Methodset_Ka!(value::PowerSystems.EXST1, val) -> Any
Set EXST1
Ka
.
PowerSystems.set_Kc!
— Methodset_Kc!(value::PowerSystems.EXST1, val) -> Any
Set EXST1
Kc
.
PowerSystems.set_Kf!
— Methodset_Kf!(value::PowerSystems.EXST1, val) -> Any
Set EXST1
Kf
.
PowerSystems.set_Ta!
— Methodset_Ta!(value::PowerSystems.EXST1, val) -> Any
Set EXST1
Ta
.
PowerSystems.set_Tb!
— Methodset_Tb!(value::PowerSystems.EXST1, val) -> Any
Set EXST1
Tb
.
PowerSystems.set_Tc!
— Methodset_Tc!(value::PowerSystems.EXST1, val) -> Any
Set EXST1
Tc
.
PowerSystems.set_Tf!
— Methodset_Tf!(value::PowerSystems.EXST1, val) -> Any
Set EXST1
Tf
.
PowerSystems.set_Tr!
— Methodset_Tr!(value::PowerSystems.EXST1, val) -> Any
Set EXST1
Tr
.
PowerSystems.set_V_ref!
— Methodset_V_ref!(value::PowerSystems.EXST1, val) -> Any
Set EXST1
V_ref
.
PowerSystems.set_Vi_lim!
— Methodset_Vi_lim!(value::PowerSystems.EXST1, val) -> Any
Set EXST1
Vi_lim
.
PowerSystems.set_Vr_lim!
— Methodset_Vr_lim!(value::PowerSystems.EXST1, val) -> Any
Set EXST1
Vr_lim
.
PowerSystems.set_ext!
— Methodset_ext!(value::PowerSystems.EXST1, val) -> Any
Set EXST1
ext
.
SCRX
PowerSystems.SCRX
— Typemutable struct SCRX <: AVR
Ta_Tb::Float64
Tb::Float64
K::Float64
Te::Float64
Efd_lim::MinMax
switch::Int
rc_rfd::Float64
V_ref::Float64
ext::Dict{String, Any}
states::Vector{Symbol}
n_states::Int
states_types::Vector{StateTypes}
internal::InfrastructureSystemsInternal
end
This exciter is based on an IEEE type SCRX solid state exciter. The output field voltage is varied by a control system to maintain the system voltage at Vref. Please note that this exciter model has no initialization capabilities - this means that it will respond to whatever inputs it receives regardless of the state of the machine model
Arguments
Ta_Tb::Float64
: Lead input constant ratio, validation range:(0.05, 0.3)
Tb::Float64
: Lag input constant in s, validation range:(5, 20)
K::Float64
: Regulator Gain, validation range:(20, 100)
Te::Float64
: Regulator Time Constant, validation range:(0, 1)
Efd_lim::MinMax
: Field Voltage regulator limits (regulator output) (Efdmin, Efdmax)switch::Int
: Switch, validation range:(0, 1)
rc_rfd::Float64
: Field current capability. Set = 0 for negative current capability. Typical value 10, validation range:(0, 10)
V_ref::Float64
: (default:1.0
) Reference Voltage Set-point (pu), validation range:(0, nothing)
ext::Dict{String, Any}
: (default:Dict{String, Any}()
) An extra dictionary for users to add metadata that are not used in simulation, such as latitude and longitude.states::Vector{Symbol}
: (Do not modify.) The states are:
Vr1: First integrator,
Vr2: Second integrator
n_states::Int
: (Do not modify.) SCRX has 2 statesstates_types::Vector{StateTypes}
: (Do not modify.) SCRX has 2 differential statesinternal::InfrastructureSystemsInternal
: (Do not modify.) PowerSystems.jl internal reference
PowerSystems.get_Efd_lim
— Methodget_Efd_lim(
value::SCRX
) -> @NamedTuple{min::Float64, max::Float64}
Get SCRX
Efd_lim
.
PowerSystems.get_K
— Methodget_K(value::SCRX) -> Float64
Get SCRX
K
.
PowerSystems.get_Ta_Tb
— Methodget_Ta_Tb(value::SCRX) -> Float64
Get SCRX
Ta_Tb
.
PowerSystems.get_Tb
— Methodget_Tb(value::SCRX) -> Float64
Get SCRX
Tb
.
PowerSystems.get_Te
— Methodget_Te(value::SCRX) -> Float64
Get SCRX
Te
.
PowerSystems.get_V_ref
— Methodget_V_ref(value::SCRX) -> Float64
Get SCRX
V_ref
.
PowerSystems.get_ext
— Methodget_ext(value::SCRX) -> Dict{String, Any}
Get SCRX
ext
.
PowerSystems.get_n_states
— Methodget_n_states(value::SCRX) -> Int64
Get SCRX
n_states
.
PowerSystems.get_rc_rfd
— Methodget_rc_rfd(value::SCRX) -> Float64
Get SCRX
rc_rfd
.
PowerSystems.get_states
— Methodget_states(value::SCRX) -> Vector{Symbol}
Get SCRX
states
.
PowerSystems.get_states_types
— Methodget_states_types(value::SCRX) -> Vector{StateTypes}
Get SCRX
states_types
.
PowerSystems.get_switch
— Methodget_switch(value::SCRX) -> Int64
Get SCRX
switch
.
PowerSystems.set_Efd_lim!
— Methodset_Efd_lim!(value::SCRX, val) -> Any
Set SCRX
Efd_lim
.
PowerSystems.set_K!
— Methodset_K!(value::SCRX, val) -> Any
Set SCRX
K
.
PowerSystems.set_Ta_Tb!
— Methodset_Ta_Tb!(value::SCRX, val) -> Any
Set SCRX
Ta_Tb
.
PowerSystems.set_Tb!
— Methodset_Tb!(value::SCRX, val) -> Any
Set SCRX
Tb
.
PowerSystems.set_Te!
— Methodset_Te!(value::SCRX, val) -> Any
Set SCRX
Te
.
PowerSystems.set_V_ref!
— Methodset_V_ref!(value::SCRX, val) -> Any
Set SCRX
V_ref
.
PowerSystems.set_ext!
— Methodset_ext!(value::SCRX, val) -> Any
Set SCRX
ext
.
PowerSystems.set_rc_rfd!
— Methodset_rc_rfd!(value::SCRX, val) -> Any
Set SCRX
rc_rfd
.
PowerSystems.set_states_types!
— Methodset_states_types!(value::SCRX, val) -> Any
Set SCRX
states_types
.
PowerSystems.set_switch!
— Methodset_switch!(value::SCRX, val) -> Any
Set SCRX
switch
.
SEXS
PowerSystems.SEXS
— Typemutable struct SEXS <: AVR
Ta_Tb::Float64
Tb::Float64
K::Float64
Te::Float64
V_lim::MinMax
V_ref::Float64
ext::Dict{String, Any}
states::Vector{Symbol}
n_states::Int
states_types::Vector{StateTypes}
internal::InfrastructureSystemsInternal
end
Parameters of Simplified Excitation System Model - SEXS in PSSE
Arguments
Ta_Tb::Float64
: Ratio of lead and lag time constants, validation range:(0, nothing)
Tb::Float64
: Lag time constant, validation range:(eps(), nothing)
K::Float64
: Gain, validation range:(0, nothing)
Te::Float64
: Field circuit time constant in s, validation range:(0, nothing)
V_lim::MinMax
: Field voltage limitsV_ref::Float64
: (default:1.0
) Reference Voltage Set-point (pu), validation range:(0, nothing)
ext::Dict{String, Any}
: (default:Dict{String, Any}()
) An extra dictionary for users to add metadata that are not used in simulation, such as latitude and longitude.states::Vector{Symbol}
: (Do not modify.) The states are: Vf: Voltage field, Vr: Lead-lag staten_states::Int
: (Do not modify.) SEXS has 2 statesstates_types::Vector{StateTypes}
: (Do not modify.) SEXS has 2 differential statesinternal::InfrastructureSystemsInternal
: (Do not modify.) PowerSystems.jl internal reference
PowerSystems.get_K
— Methodget_K(value::SEXS) -> Float64
Get SEXS
K
.
PowerSystems.get_Ta_Tb
— Methodget_Ta_Tb(value::SEXS) -> Float64
Get SEXS
Ta_Tb
.
PowerSystems.get_Tb
— Methodget_Tb(value::SEXS) -> Float64
Get SEXS
Tb
.
PowerSystems.get_Te
— Methodget_Te(value::SEXS) -> Float64
Get SEXS
Te
.
PowerSystems.get_V_lim
— Methodget_V_lim(
value::SEXS
) -> @NamedTuple{min::Float64, max::Float64}
Get SEXS
V_lim
.
PowerSystems.get_V_ref
— Methodget_V_ref(value::SEXS) -> Float64
Get SEXS
V_ref
.
PowerSystems.get_ext
— Methodget_ext(value::SEXS) -> Dict{String, Any}
Get SEXS
ext
.
PowerSystems.get_n_states
— Methodget_n_states(value::SEXS) -> Int64
Get SEXS
n_states
.
PowerSystems.get_states
— Methodget_states(value::SEXS) -> Vector{Symbol}
Get SEXS
states
.
PowerSystems.get_states_types
— Methodget_states_types(value::SEXS) -> Vector{StateTypes}
Get SEXS
states_types
.
PowerSystems.set_K!
— Methodset_K!(value::SEXS, val) -> Any
Set SEXS
K
.
PowerSystems.set_Ta_Tb!
— Methodset_Ta_Tb!(value::SEXS, val) -> Any
Set SEXS
Ta_Tb
.
PowerSystems.set_Tb!
— Methodset_Tb!(value::SEXS, val) -> Any
Set SEXS
Tb
.
PowerSystems.set_Te!
— Methodset_Te!(value::SEXS, val) -> Any
Set SEXS
Te
.
PowerSystems.set_V_lim!
— Methodset_V_lim!(value::SEXS, val) -> Any
Set SEXS
V_lim
.
PowerSystems.set_V_ref!
— Methodset_V_ref!(value::SEXS, val) -> Any
Set SEXS
V_ref
.
PowerSystems.set_ext!
— Methodset_ext!(value::SEXS, val) -> Any
Set SEXS
ext
.
PowerSystems.set_states_types!
— Methodset_states_types!(value::SEXS, val) -> Any
Set SEXS
states_types
.
ST6B
PowerSystems.ST6B
— Typemutable struct ST6B <: AVR
OEL_Flag::Int
Tr::Float64
K_pa::Float64
K_ia::Float64
K_da::Float64
T_da::Float64
Va_lim::MinMax
K_ff::Float64
K_m::Float64
K_ci::Float64
K_lr::Float64
I_lr::Float64
Vr_lim::MinMax
Kg::Float64
Tg::Float64
V_ref::Float64
ext::Dict{String, Any}
states::Vector{Symbol}
n_states::Int
states_types::Vector{StateTypes}
internal::InfrastructureSystemsInternal
end
In these excitation systems, voltage (and also current in compounded systems) is transformed to an appropriate level. Rectifiers, either controlled or non-controlled, provide the necessary direct current for the generator field. Parameters of IEEE Std 421.5 Type ST6B Excitacion System. ST6B in PSSE and PSLF
Arguments
OEL_Flag::Int
: OEL Flag for ST6B: 1: before HV gate, 2: after HV gate, validation range:(0, 2)
Tr::Float64
: Regulator input filter time constant in s, validation range:(0, nothing)
K_pa::Float64
: Regulator proportional gain, validation range:(0, nothing)
K_ia::Float64
: Regulator integral gain, validation range:(0, nothing)
K_da::Float64
: Regulator derivative gain, validation range:(0, nothing)
T_da::Float64
: Voltage regulator derivative channel time constant in s, validation range:(0, nothing)
Va_lim::MinMax
: Regulator output limits (Vimin, Vimax)K_ff::Float64
: Pre-control gain of the inner loop field regulator, validation range:(0, nothing)
K_m::Float64
: Forward gain of the inner loop field regulator, validation range:(0, nothing)
K_ci::Float64
: Exciter output current limit adjustment gain, validation range:(0, nothing)
K_lr::Float64
: Exciter output current limiter gain, validation range:(0, nothing)
I_lr::Float64
: Exciter current limiter reference, validation range:(0, nothing)
Vr_lim::MinMax
: Voltage regulator limits (Vimin, Vimax)Kg::Float64
: Feedback gain constant of the inner loop field regulator, validation range:(0, nothing)
Tg::Float64
: Feedback time constant of the inner loop field voltage regulator in s, validation range:(0, nothing)
V_ref::Float64
: (default:1.0
) Reference Voltage Set-point (pu), validation range:(0, nothing)
ext::Dict{String, Any}
: (default:Dict{String, Any}()
) An extra dictionary for users to add metadata that are not used in simulation, such as latitude and longitude.states::Vector{Symbol}
: (Do not modify.) The states are:
Vm: Sensed terminal voltage,
x_i: Regulator Integrator,
x_d: Regulator Derivative,
Vg: Regulator Feedback
n_states::Int
: (Do not modify.) ST6B has 4 statesstates_types::Vector{StateTypes}
: (Do not modify.) ST6B has 4 statesinternal::InfrastructureSystemsInternal
: (Do not modify.) PowerSystems.jl internal reference
PowerSystems.get_I_lr
— Methodget_I_lr(value::ST6B) -> Float64
Get ST6B
I_lr
.
PowerSystems.get_K_ci
— Methodget_K_ci(value::ST6B) -> Float64
Get ST6B
K_ci
.
PowerSystems.get_K_da
— Methodget_K_da(value::ST6B) -> Float64
Get ST6B
K_da
.
PowerSystems.get_K_ff
— Methodget_K_ff(value::ST6B) -> Float64
Get ST6B
K_ff
.
PowerSystems.get_K_ia
— Methodget_K_ia(value::ST6B) -> Float64
Get ST6B
K_ia
.
PowerSystems.get_K_lr
— Methodget_K_lr(value::ST6B) -> Float64
Get ST6B
K_lr
.
PowerSystems.get_K_m
— Methodget_K_m(value::ST6B) -> Float64
Get ST6B
K_m
.
PowerSystems.get_K_pa
— Methodget_K_pa(value::ST6B) -> Float64
Get ST6B
K_pa
.
PowerSystems.get_Kg
— Methodget_Kg(value::ST6B) -> Float64
Get ST6B
Kg
.
PowerSystems.get_OEL_Flag
— Methodget_OEL_Flag(value::ST6B) -> Int64
Get ST6B
OEL_Flag
.
PowerSystems.get_T_da
— Methodget_T_da(value::ST6B) -> Float64
Get ST6B
T_da
.
PowerSystems.get_Tg
— Methodget_Tg(value::ST6B) -> Float64
Get ST6B
Tg
.
PowerSystems.get_Tr
— Methodget_Tr(value::ST6B) -> Float64
Get ST6B
Tr
.
PowerSystems.get_V_ref
— Methodget_V_ref(value::ST6B) -> Float64
Get ST6B
V_ref
.
PowerSystems.get_Va_lim
— Methodget_Va_lim(
value::ST6B
) -> @NamedTuple{min::Float64, max::Float64}
Get ST6B
Va_lim
.
PowerSystems.get_Vr_lim
— Methodget_Vr_lim(
value::ST6B
) -> @NamedTuple{min::Float64, max::Float64}
Get ST6B
Vr_lim
.
PowerSystems.get_ext
— Methodget_ext(value::ST6B) -> Dict{String, Any}
Get ST6B
ext
.
PowerSystems.get_n_states
— Methodget_n_states(value::ST6B) -> Int64
Get ST6B
n_states
.
PowerSystems.get_states
— Methodget_states(value::ST6B) -> Vector{Symbol}
Get ST6B
states
.
PowerSystems.get_states_types
— Methodget_states_types(value::ST6B) -> Vector{StateTypes}
Get ST6B
states_types
.
PowerSystems.set_I_lr!
— Methodset_I_lr!(value::ST6B, val) -> Any
Set ST6B
I_lr
.
PowerSystems.set_K_ci!
— Methodset_K_ci!(value::ST6B, val) -> Any
Set ST6B
K_ci
.
PowerSystems.set_K_da!
— Methodset_K_da!(value::ST6B, val) -> Any
Set ST6B
K_da
.
PowerSystems.set_K_ff!
— Methodset_K_ff!(value::ST6B, val) -> Any
Set ST6B
K_ff
.
PowerSystems.set_K_ia!
— Methodset_K_ia!(value::ST6B, val) -> Any
Set ST6B
K_ia
.
PowerSystems.set_K_lr!
— Methodset_K_lr!(value::ST6B, val) -> Any
Set ST6B
K_lr
.
PowerSystems.set_K_m!
— Methodset_K_m!(value::ST6B, val) -> Any
Set ST6B
K_m
.
PowerSystems.set_K_pa!
— Methodset_K_pa!(value::ST6B, val) -> Any
Set ST6B
K_pa
.
PowerSystems.set_Kg!
— Methodset_Kg!(value::ST6B, val) -> Any
Set ST6B
Kg
.
PowerSystems.set_OEL_Flag!
— Methodset_OEL_Flag!(value::ST6B, val) -> Any
Set ST6B
OEL_Flag
.
PowerSystems.set_T_da!
— Methodset_T_da!(value::ST6B, val) -> Any
Set ST6B
T_da
.
PowerSystems.set_Tg!
— Methodset_Tg!(value::ST6B, val) -> Any
Set ST6B
Tg
.
PowerSystems.set_Tr!
— Methodset_Tr!(value::ST6B, val) -> Any
Set ST6B
Tr
.
PowerSystems.set_V_ref!
— Methodset_V_ref!(value::ST6B, val) -> Any
Set ST6B
V_ref
.
PowerSystems.set_Va_lim!
— Methodset_Va_lim!(value::ST6B, val) -> Any
Set ST6B
Va_lim
.
PowerSystems.set_Vr_lim!
— Methodset_Vr_lim!(value::ST6B, val) -> Any
Set ST6B
Vr_lim
.
PowerSystems.set_ext!
— Methodset_ext!(value::ST6B, val) -> Any
Set ST6B
ext
.
PowerSystems.set_states_types!
— Methodset_states_types!(value::ST6B, val) -> Any
Set ST6B
states_types
.
ST8C
PowerSystems.ST8C
— Typemutable struct ST8C <: AVR
OEL_Flag::Int
UEL_Flag::Int
SCL_Flag::Int
SW1_Flag::Int
Tr::Float64
K_pr::Float64
K_ir::Float64
Vpi_lim::MinMax
K_pa::Float64
K_ia::Float64
Va_lim::MinMax
K_a::Float64
T_a::Float64
Vr_lim::MinMax
K_f::Float64
T_f::Float64
K_c1::Float64
K_p::Float64
K_i1::Float64
X_l::Float64
θ_p::Float64
VB1_max::Float64
K_c2::Float64
K_i2::Float64
VB2_max::Float64
V_ref::Float64
Ifd_ref::Float64
ext::Dict{String, Any}
states::Vector{Symbol}
n_states::Int
states_types::Vector{StateTypes}
internal::InfrastructureSystemsInternal
end
In these excitation systems, voltage (and also current in compounded systems) is transformed to an appropriate level. Rectifiers, either controlled or non-controlled, provide the necessary direct current for the generator field. Parameters of IEEE Std 421.5 Type ST8C Excitacion System. ST8C in PSSE and PSLF
Arguments
OEL_Flag::Int
: OEL Flag for ST8C: <2: Summation at Voltage Error, 2: OEL takeover at gate, validation range:(0, 2)
UEL_Flag::Int
: UEL Flag for ST8C: <2: Summation at Voltage Error, 2: UEL takeover at gate, validation range:(0, 2)
SCL_Flag::Int
: SCL Flag for ST8C: <2: Summation at Voltage Error, 2: SCL Takeover at UEL and OEL gates, validation range:(0, 2)
SW1_Flag::Int
: SW1 Flag for Power Source Selector for ST8C: <2: Source from generator terminal voltage, 2: Independent power source, validation range:(0, 2)
Tr::Float64
: Regulator input filter time constant in seconds, validation range:(0, nothing)
K_pr::Float64
: Regulator proportional gain (pu), validation range:(0, nothing)
K_ir::Float64
: Regulator integral gain (pu), validation range:(0, nothing)
Vpi_lim::MinMax
: Regulator input limits (Vpimin, Vpimax)K_pa::Float64
: Field current regulator proportional gain (pu), validation range:(0, nothing)
K_ia::Float64
: Field current regulator integral gain (pu), validation range:(0, nothing)
Va_lim::MinMax
: Field current regulator output limits (Vamin, Vamax)K_a::Float64
: Field current regulator proportional gain (pu), validation range:(0, nothing)
T_a::Float64
: Controlled rectifier bridge equivalent time constant in seconds, validation range:(0, nothing)
Vr_lim::MinMax
: Voltage regulator limits (Vrmin, Vrmax)K_f::Float64
: Exciter field current feedback gain (pu), validation range:(0, nothing)
T_f::Float64
: Field current feedback time constant in seconds, validation range:(0, nothing)
K_c1::Float64
: Rectifier loading factor proportional to commutating reactance (pu), validation range:(0, nothing)
K_p::Float64
: Potential circuit (voltage) gain coefficient (pu), validation range:(0, nothing)
K_i1::Float64
: Potential circuit (current) gain coefficient (pu), validation range:(0, nothing)
X_l::Float64
: Reactance associated with potential source (pu), validation range:(0, nothing)
θ_p::Float64
: Potential circuit phase angle (degrees), validation range:(0, nothing)
VB1_max::Float64
: Maximum available exciter voltage (pu), validation range:(0, nothing)
K_c2::Float64
: Rectifier loading factor proportional to commutating reactance (pu), validation range:(0, nothing)
K_i2::Float64
: Potential circuit (current) gain coefficient (pu), validation range:(0, nothing)
VB2_max::Float64
: Maximum available exciter voltage (pu), validation range:(0, nothing)
V_ref::Float64
: (default:1.0
) Reference Voltage Set-point (pu), validation range:(0, nothing)
Ifd_ref::Float64
: (default:1.0
) Reference Field Current Set-point (pu), validation range:(0, nothing)
ext::Dict{String, Any}
: (default:Dict{String, Any}()
) An extra dictionary for users to add metadata that are not used in simulation, such as latitude and longitude.states::Vector{Symbol}
: (Do not modify.) The states are:
Vm: Sensed terminal voltage,
x_a1: Regulator Integrator state,
x_a2: Field Current regulator state,
x_a3: Controller rectifier bridge state,
x_a4: Regulator Feedback state
n_states::Int
: (Do not modify.) ST8C has 5 statesstates_types::Vector{StateTypes}
: (Do not modify.) ST8C has 5 statesinternal::InfrastructureSystemsInternal
: (Do not modify.) PowerSystems.jl internal reference
PowerSystems.get_Ifd_ref
— Methodget_Ifd_ref(value::ST8C) -> Float64
Get ST8C
Ifd_ref
.
PowerSystems.get_K_a
— Methodget_K_a(value::ST8C) -> Float64
Get ST8C
K_a
.
PowerSystems.get_K_c1
— Methodget_K_c1(value::ST8C) -> Float64
Get ST8C
K_c1
.
PowerSystems.get_K_c2
— Methodget_K_c2(value::ST8C) -> Float64
Get ST8C
K_c2
.
PowerSystems.get_K_f
— Methodget_K_f(value::ST8C) -> Float64
Get ST8C
K_f
.
PowerSystems.get_K_i1
— Methodget_K_i1(value::ST8C) -> Float64
Get ST8C
K_i1
.
PowerSystems.get_K_i2
— Methodget_K_i2(value::ST8C) -> Float64
Get ST8C
K_i2
.
PowerSystems.get_K_ia
— Methodget_K_ia(value::ST8C) -> Float64
Get ST8C
K_ia
.
PowerSystems.get_K_ir
— Methodget_K_ir(value::ST8C) -> Float64
Get ST8C
K_ir
.
PowerSystems.get_K_p
— Methodget_K_p(value::ST8C) -> Float64
Get ST8C
K_p
.
PowerSystems.get_K_pa
— Methodget_K_pa(value::ST8C) -> Float64
Get ST8C
K_pa
.
PowerSystems.get_K_pr
— Methodget_K_pr(value::ST8C) -> Float64
Get ST8C
K_pr
.
PowerSystems.get_OEL_Flag
— Methodget_OEL_Flag(value::ST8C) -> Int64
Get ST8C
OEL_Flag
.
PowerSystems.get_SCL_Flag
— Methodget_SCL_Flag(value::ST8C) -> Int64
Get ST8C
SCL_Flag
.
PowerSystems.get_SW1_Flag
— Methodget_SW1_Flag(value::ST8C) -> Int64
Get ST8C
SW1_Flag
.
PowerSystems.get_T_a
— Methodget_T_a(value::ST8C) -> Float64
Get ST8C
T_a
.
PowerSystems.get_T_f
— Methodget_T_f(value::ST8C) -> Float64
Get ST8C
T_f
.
PowerSystems.get_Tr
— Methodget_Tr(value::ST8C) -> Float64
Get ST8C
Tr
.
PowerSystems.get_UEL_Flag
— Methodget_UEL_Flag(value::ST8C) -> Int64
Get ST8C
UEL_Flag
.
PowerSystems.get_VB1_max
— Methodget_VB1_max(value::ST8C) -> Float64
Get ST8C
VB1_max
.
PowerSystems.get_VB2_max
— Methodget_VB2_max(value::ST8C) -> Float64
Get ST8C
VB2_max
.
PowerSystems.get_V_ref
— Methodget_V_ref(value::ST8C) -> Float64
Get ST8C
V_ref
.
PowerSystems.get_Va_lim
— Methodget_Va_lim(
value::ST8C
) -> @NamedTuple{min::Float64, max::Float64}
Get ST8C
Va_lim
.
PowerSystems.get_Vpi_lim
— Methodget_Vpi_lim(
value::ST8C
) -> @NamedTuple{min::Float64, max::Float64}
Get ST8C
Vpi_lim
.
PowerSystems.get_Vr_lim
— Methodget_Vr_lim(
value::ST8C
) -> @NamedTuple{min::Float64, max::Float64}
Get ST8C
Vr_lim
.
PowerSystems.get_X_l
— Methodget_X_l(value::ST8C) -> Float64
Get ST8C
X_l
.
PowerSystems.get_ext
— Methodget_ext(value::ST8C) -> Dict{String, Any}
Get ST8C
ext
.
PowerSystems.get_n_states
— Methodget_n_states(value::ST8C) -> Int64
Get ST8C
n_states
.
PowerSystems.get_states
— Methodget_states(value::ST8C) -> Vector{Symbol}
Get ST8C
states
.
PowerSystems.get_states_types
— Methodget_states_types(value::ST8C) -> Vector{StateTypes}
Get ST8C
states_types
.
PowerSystems.get_θ_p
— Methodget_θ_p(value::ST8C) -> Float64
Get ST8C
θ_p
.
PowerSystems.set_Ifd_ref!
— Methodset_Ifd_ref!(value::ST8C, val) -> Any
Set ST8C
Ifd_ref
.
PowerSystems.set_K_a!
— Methodset_K_a!(value::ST8C, val) -> Any
Set ST8C
K_a
.
PowerSystems.set_K_c1!
— Methodset_K_c1!(value::ST8C, val) -> Any
Set ST8C
K_c1
.
PowerSystems.set_K_c2!
— Methodset_K_c2!(value::ST8C, val) -> Any
Set ST8C
K_c2
.
PowerSystems.set_K_f!
— Methodset_K_f!(value::ST8C, val) -> Any
Set ST8C
K_f
.
PowerSystems.set_K_i1!
— Methodset_K_i1!(value::ST8C, val) -> Any
Set ST8C
K_i1
.
PowerSystems.set_K_i2!
— Methodset_K_i2!(value::ST8C, val) -> Any
Set ST8C
K_i2
.
PowerSystems.set_K_ia!
— Methodset_K_ia!(value::ST8C, val) -> Any
Set ST8C
K_ia
.
PowerSystems.set_K_ir!
— Methodset_K_ir!(value::ST8C, val) -> Any
Set ST8C
K_ir
.
PowerSystems.set_K_p!
— Methodset_K_p!(value::ST8C, val) -> Any
Set ST8C
K_p
.
PowerSystems.set_K_pa!
— Methodset_K_pa!(value::ST8C, val) -> Any
Set ST8C
K_pa
.
PowerSystems.set_K_pr!
— Methodset_K_pr!(value::ST8C, val) -> Any
Set ST8C
K_pr
.
PowerSystems.set_OEL_Flag!
— Methodset_OEL_Flag!(value::ST8C, val) -> Any
Set ST8C
OEL_Flag
.
PowerSystems.set_SCL_Flag!
— Methodset_SCL_Flag!(value::ST8C, val) -> Any
Set ST8C
SCL_Flag
.
PowerSystems.set_SW1_Flag!
— Methodset_SW1_Flag!(value::ST8C, val) -> Any
Set ST8C
SW1_Flag
.
PowerSystems.set_T_a!
— Methodset_T_a!(value::ST8C, val) -> Any
Set ST8C
T_a
.
PowerSystems.set_T_f!
— Methodset_T_f!(value::ST8C, val) -> Any
Set ST8C
T_f
.
PowerSystems.set_Tr!
— Methodset_Tr!(value::ST8C, val) -> Any
Set ST8C
Tr
.
PowerSystems.set_UEL_Flag!
— Methodset_UEL_Flag!(value::ST8C, val) -> Any
Set ST8C
UEL_Flag
.
PowerSystems.set_VB1_max!
— Methodset_VB1_max!(value::ST8C, val) -> Any
Set ST8C
VB1_max
.
PowerSystems.set_VB2_max!
— Methodset_VB2_max!(value::ST8C, val) -> Any
Set ST8C
VB2_max
.
PowerSystems.set_V_ref!
— Methodset_V_ref!(value::ST8C, val) -> Any
Set ST8C
V_ref
.
PowerSystems.set_Va_lim!
— Methodset_Va_lim!(value::ST8C, val) -> Any
Set ST8C
Va_lim
.
PowerSystems.set_Vpi_lim!
— Methodset_Vpi_lim!(value::ST8C, val) -> Any
Set ST8C
Vpi_lim
.
PowerSystems.set_Vr_lim!
— Methodset_Vr_lim!(value::ST8C, val) -> Any
Set ST8C
Vr_lim
.
PowerSystems.set_X_l!
— Methodset_X_l!(value::ST8C, val) -> Any
Set ST8C
X_l
.
PowerSystems.set_ext!
— Methodset_ext!(value::ST8C, val) -> Any
Set ST8C
ext
.
PowerSystems.set_states_types!
— Methodset_states_types!(value::ST8C, val) -> Any
Set ST8C
states_types
.
PowerSystems.set_θ_p!
— Methodset_θ_p!(value::ST8C, val) -> Any
Set ST8C
θ_p
.