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
endParameters of a AVR that returns a fixed voltage to the rotor winding
Arguments
Vf::Float64: Fixed voltage field applied to the rotor winding, validation range:(0, nothing)V_ref::Float64: Reference Voltage Set-point, validation range:(0, nothing)ext::Dict{String, Any}states::Vector{Symbol}: Fixed AVR has no statesn_states::Int: Fixed AVR has no statesstates_types::Vector{StateTypes}: Fixed AVR has no statesinternal::InfrastructureSystemsInternal: power system internal reference, do not modify
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
endParameters 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: Reference Voltage Set-point, validation range:(0, nothing)ext::Dict{String, Any}states::Vector{Symbol}: The states are:
Vf: field voltagen_states::Int: Fixed AVR has 1 statesstates_types::Vector{StateTypes}: Simple AVR has 1 differential statesinternal::InfrastructureSystemsInternal: power system internal reference, do not modify
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::NamedTuple{(:min, :max), Tuple{Float64, Float64}}
Ae::Float64
Be::Float64
V_ref::Float64
ext::Dict{String, Any}
states::Vector{Symbol}
n_states::Int
states_types::Vector{StateTypes}
internal::InfrastructureSystemsInternal
endParameters 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::NamedTuple{(:min, :max), Tuple{Float64, Float64}}: 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: Reference Voltage Set-point, validation range:(0, nothing)ext::Dict{String, Any}states::Vector{Symbol}: The states are:
Vf: Voltage field,
Vr1: Amplifier State,
Vr2: Stabilizing Feedback State,
Vm: Measured voltagen_states::Int: The AVR Type I has 4 statesstates_types::Vector{StateTypes}: AVR Type I has 4 differential statesinternal::InfrastructureSystemsInternal: power system internal reference, do not modify
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, :max), Tuple{Float64, 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::NamedTuple{(:min, :max), Tuple{Float64, Float64}}
Ae::Float64
Be::Float64
V_ref::Float64
ext::Dict{String, Any}
states::Vector{Symbol}
n_states::Int
states_types::Vector{StateTypes}
internal::InfrastructureSystemsInternal
endParameters 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::NamedTuple{(:min, :max), Tuple{Float64, Float64}}: 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: Reference Voltage Set-point, validation range:(0, nothing)ext::Dict{String, Any}states::Vector{Symbol}: The states are:
Vf: Voltage field,
Vr1: First Lead-Lag state,
Vr2: Second lead-lag state,
Vm: Measured voltagen_states::Int: AVR Type II has 4 statesstates_types::Vector{StateTypes}: AVR Type II has 4 differential statesinternal::InfrastructureSystemsInternal: power system internal reference, do not modify
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, :max), Tuple{Float64, 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::NamedTuple{(:min, :max), Tuple{Float64, Float64}}
Te::Float64
Kf::Float64
Tf::Float64
Kc::Float64
Kd::Float64
Ke::Float64
E_sat::Tuple{Float64, Float64}
Se::Tuple{Float64, Float64}
Vr_lim::NamedTuple{(:min, :max), 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
endThis 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), action if invalid:warnTb::Float64: Regulator denominator (lag) time constant in s, validation range:(0, 20), action if invalid:warnTc::Float64: Regulator numerator (lead) time constant in s, validation range:(0, 20), action if invalid:warnKa::Float64: Regulator output gain, validation range:(0, 1000), action if invalid:warnTa::Float64: Regulator output time constant in s, validation range:(0, 10)Va_lim::NamedTuple{(:min, :max), Tuple{Float64, Float64}}: Limits for regulator output(Va_min, Va_max)Te::Float64: Exciter field time constant in s, validation range:(eps(), 2), action if invalid:errorKf::Float64: Rate feedback excitation system stabilizer gain, validation range:(0, 0.3), action if invalid:warnTf::Float64: Rate feedback time constant, validation range:(eps(), 1.5), action if invalid:errorKc::Float64: Rectifier loading factor proportional to commutating reactance, validation range:(0, 1), action if invalid:warnKd::Float64: Demagnetizing factor, function of exciter alternator reactances, validation range:(0, 1), action if invalid:warnKe::Float64: Exciter field proportional constant, validation range:(0, 1), action if invalid:warnE_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::NamedTuple{(:min, :max), Tuple{Float64, Float64}}: Limits for exciter field voltage:(Vr_min, Vr_max)V_ref::Float64: Reference Voltage Set-point, validation range:(0, nothing)saturation_coeffs::Tuple{Float64, Float64}: Coefficients (A,B) of the function: Se(x) = B(x - A)^2/xext::Dict{String, Any}states::Vector{Symbol}: The states are:
Vm: Sensed terminal voltage,
Vr1: Lead-lag state,
Vr2: Regulator output state,
Ve: Integrator output state,
Vr3: Feedback output staten_states::Int: ESAC1A has 5 statesstates_types::Vector{StateTypes}: ESAC1A has 5 statesinternal::InfrastructureSystemsInternal: power system internal reference, do not modify
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, :max), Tuple{Float64, Float64}}
Get ESAC1A Va_lim.
PowerSystems.get_Vr_lim — Methodget_Vr_lim(value::ESAC1A) -> NamedTuple{(:min, :max), Tuple{Float64, 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::NamedTuple{(:min, :max), Tuple{Float64, Float64}}
Vr_lim::NamedTuple{(:min, :max), Tuple{Float64, Float64}}
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
endModified 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), action if invalid:warnKa::Float64: Regulator output gain, validation range:(0, 1000), action if invalid:warnTa::Float64: Regulator output lag time constant in s, validation range:(0, 10), action if invalid:warnTk::Float64: Voltage Regulator lead time constant, validation range:(0, 10), action if invalid:warnTb::Float64: Regulator denominator (lag) time constant in s, validation range:(0, 20), action if invalid:warnTc::Float64: Regulator numerator (lead) time constant in s, validation range:(0, 20), action if invalid:warnVa_lim::NamedTuple{(:min, :max), Tuple{Float64, Float64}}: Limits for regulator output(Va_min, Va_max)Vr_lim::NamedTuple{(:min, :max), Tuple{Float64, Float64}}: Limits for exciter field voltage(Vr_min, Vr_max)Te::Float64: Exciter field time constant, validation range:(eps(), 2), action if invalid:errorVFE_lim::Float64: Exciter field current limiter reference, validation range:(-5, 20), action if invalid:warnKh::Float64: Exciter field current regulator feedback gain, validation range:(0, 100), action if invalid:warnVH_max::Float64: Exciter field current limiter maximum output, validation range:(0, 100), action if invalid:warnTh::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), action if invalid:warnKc::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), action if invalid:warnKe::Float64: Exciter field proportional constant, validation range:(0, 2), action if invalid:warnE_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: Reference Voltage Set-point, validation range:(0, nothing)saturation_coeffs::Tuple{Float64, Float64}: Coefficients (A,B) of the function: Se(V) = B(V - A)^2/Vext::Dict{String, Any}states::Vector{Symbol}: The states are:
Vm: Sensed terminal voltage,
Vr1: Lead-lag state,
Vr2: Regulator output state,
Ve: Integrator output state,
Vr3: Feedback output staten_states::Int: ESAC6A has 5 statesstates_types::Vector{StateTypes}: ESAC6A has 5 statesinternal::InfrastructureSystemsInternal: power system internal reference, do not modify
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, :max), Tuple{Float64, Float64}}
Get ESAC6A Va_lim.
PowerSystems.get_Vr_lim — Methodget_Vr_lim(value::ESAC6A) -> NamedTuple{(:min, :max), Tuple{Float64, 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.
ESDC1A
PowerSystems.ESDC1A — Typemutable struct ESDC1A <: AVR
Tr::Float64
Ka::Float64
Ta::Float64
Tb::Float64
Tc::Float64
Vr_lim::NamedTuple{(:min, :max), Tuple{Float64, Float64}}
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
endSelf-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), action if invalid:warnKa::Float64: Amplifier Gain, validation range:(10, 500), action if invalid:warnTa::Float64: Amplifier Time Constant in s, validation range:(0, 1), action if invalid:warnTb::Float64: Regulator input Time Constant in s, validation range:(0, nothing), action if invalid:warnTc::Float64: Regulator input Time Constant in s, validation range:(0, nothing), action if invalid:warnVr_lim::NamedTuple{(:min, :max), Tuple{Float64, Float64}}: 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), action if invalid:errorKf::Float64: Excitation control system stabilizer gain, validation range:(eps(), 0.3), action if invalid:errorTf::Float64: Excitation control system stabilizer time constant, validation range:(eps(), nothing), action if invalid:errorswitch::Int: Switch, validation range:(0, 1), action if invalid:errorE_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: Reference Voltage Set-point, validation range:(0, nothing)saturation_coeffs::Tuple{Float64, Float64}: Coefficients (A,B) of the function: Se(V) = B(V - A)^2/Vext::Dict{String, Any}states::Vector{Symbol}: The states are:
Vt: Terminal Voltage,
Vr1: input lead lag,
Vr2: Regulator Output,
Vf: Exciter Output,
Vr3: Rate feedback integratorn_states::Int: The ESDC1A has 5 statesstates_types::Vector{StateTypes}: ESDC1A has 5 differential statesinternal::InfrastructureSystemsInternal: power system internal reference, do not modify
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, :max), Tuple{Float64, 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::NamedTuple{(:min, :max), Tuple{Float64, Float64}}
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
endIs 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), action if invalid:warnKa::Float64: Amplifier Gain, validation range:(10, 500), action if invalid:warnTa::Float64: Amplifier Time Constant in s, validation range:(0, 1), action if invalid:warnTb::Float64: Regulator input Time Constant in s, validation range:(0, nothing), action if invalid:warnTc::Float64: Regulator input Time Constant in s, validation range:(0, nothing), action if invalid:warnVr_lim::NamedTuple{(:min, :max), Tuple{Float64, Float64}}: Voltage regulator limits (regulator output) (Vimin, Vimax)Ke::Float64: Exciter constant related to self-excited field, validation range:(-1, 1), action if invalid:warnTe::Float64: Exciter time constant, integration rate associated with exciter control, validation range:(eps(), 2), action if invalid:errorKf::Float64: Excitation control system stabilizer gain, validation range:(0, 0.3), action if invalid:warnTf::Float64: Excitation control system stabilizer time constant. Appropiate Data: 5.0 <= Tf/Kf <= 15.0, validation range:(eps(), 1.5), action if invalid:errorswitch::Int: Switch, validation range:(0, 1), action if invalid:errorE_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: Reference Voltage Set-point, validation range:(0, nothing)saturation_coeffs::Tuple{Float64, Float64}: Coefficients (A,B) of the function: Se(V) = B(V - A)^2/Vext::Dict{String, Any}states::Vector{Symbol}: The states are:
Vt: Terminal Voltage,
Vr1: input lead lag,
Vr2: Regulator Output,
Vf: Exciter Output,
Vr3: Rate feedback integratorn_states::Int: The ESDC2A has 5 statesstates_types::Vector{StateTypes}: ESDC2A has 5 differential statesinternal::InfrastructureSystemsInternal: power system internal reference, do not modify
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, :max), Tuple{Float64, 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::NamedTuple{(:min, :max), Tuple{Float64, Float64}}
Vr_lim::NamedTuple{(:min, :max), Tuple{Float64, Float64}}
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
endThis 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), action if invalid:warnPSS_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), action if invalid:warnVi_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), action if invalid:warnTb::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), action if invalid:warnTb1::Float64: Second regulator denominator (lead) time constant in s, validation range:(0, 20), action if invalid:warnKa::Float64: Voltage regulator gain, validation range:(50, 1000), action if invalid:warnTa::Float64: Voltage regulator time constant in s, validation range:(0, 0.5), action if invalid:warnVa_lim::NamedTuple{(:min, :max), Tuple{Float64, Float64}}: Limits for regulator output(Va_min, Va_max)Vr_lim::NamedTuple{(:min, :max), Tuple{Float64, Float64}}: Limits for exciter output(Vr_min, Vr_max)Kc::Float64: Rectifier loading factor proportional to commutating reactance, validation range:(0, 0.3), action if invalid:warnKf::Float64: Rate feedback gain, validation range:(0, 0.3), action if invalid:warnTf::Float64: Rate feedback time constant in s, validation range:(eps(), 1.5), action if invalid:errorK_lr::Float64: Exciter output current limiter gain, validation range:(0, 5), action if invalid:warnI_lr::Float64: Exciter output current limit reference, validation range:(0, 5), action if invalid:warnV_ref::Float64: Reference Voltage Set-point, validation range:(0, nothing)ext::Dict{String, Any}states::Vector{Symbol}: The states are:
Vm: Sensed terminal voltage,
Vr1: First Lead-lag state,
Vr2: Second lead-lag state,
Va: Regulator output state,
Vr3: Feedback output staten_states::Int: ST1A has 5 statesstates_types::Vector{StateTypes}: ST1A has 5 statesinternal::InfrastructureSystemsInternal: power system internal reference, do not modify
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, :max), Tuple{Float64, 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, :max), Tuple{Float64, 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::NamedTuple{(:min, :max), Tuple{Float64, Float64}}
Ta::Float64
K_pm::Float64
K_im::Float64
Vm_lim::NamedTuple{(:min, :max), Tuple{Float64, Float64}}
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
endIn 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), action if invalid:warnK_pr::Float64: Regulator propotional gain, validation range:(0, 75), action if invalid:warnK_ir::Float64: Regulator integral gain, validation range:(0, 75), action if invalid:warnVr_lim::NamedTuple{(:min, :max), Tuple{Float64, Float64}}: Voltage regulator limits (Vimin, Vimax)Ta::Float64: Voltage regulator time constant in s, validation range:(0, 1), action if invalid:warnK_pm::Float64: Voltage regulator proportional gain output, validation range:(0, 1.2), action if invalid:warnK_im::Float64: Voltage regulator integral gain output, validation range:(0, 18), action if invalid:warnVm_lim::NamedTuple{(:min, :max), Tuple{Float64, Float64}}: 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), action if invalid:warnKp::Float64: Potential circuit (voltage) gain coefficient, validation range:(0, 10), action if invalid:warnKi::Float64: Compound circuit (current) gain coefficient, validation range:(0, 1.1), action if invalid:warnVB_max::Float64: Maximum available exciter voltage, validation range:(1, 20), action if invalid:warnKc::Float64: Rectifier loading factor proportional to commutating reactance, validation range:(0, 1), action if invalid:warnXl::Float64: Reactance associated with potential source, validation range:(0, 0.5), action if invalid:warnθp::Float64: Potential circuit phase angle (degrees), validation range:(-90, 90), action if invalid:errorV_ref::Float64: Reference Voltage Set-point, validation range:(0, nothing)θp_rad::Float64: Potential circuit phase angle (radians)ext::Dict{String, Any}states::Vector{Symbol}: The states are:
Vm: Sensed terminal voltage,
Vt: Sensed Terminal Voltage,
Vr1: Regulator Integrator,
Vr2: Regulator Output,
Vm: Output integratorn_states::Int: ST4B has 4 statesstates_types::Vector{StateTypes}: ST4B has 4 statesinternal::InfrastructureSystemsInternal: power system internal reference, do not modify
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, :max), Tuple{Float64, Float64}}
Get ESST4B Vm_lim.
PowerSystems.get_Vr_lim — Methodget_Vr_lim(value::ESST4B) -> NamedTuple{(:min, :max), Tuple{Float64, 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::NamedTuple{(:min, :max), Tuple{Float64, Float64}}
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
endModified 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), action if invalid:warnTb::Float64: Regulator denominator (lag) time constant in s, validation range:(0, 20), action if invalid:warnTc::Float64: Regulator numerator (lead) time constant in s, validation range:(0, 20), action if invalid:warnKa::Float64: Regulator output gain, validation range:(0, 1000)Ta::Float64: Regulator output time constant in s, validation range:(0, 10), action if invalid:warnVr_lim::NamedTuple{(:min, :max), Tuple{Float64, Float64}}: Limits for regulator output(Vr_min, Vr_max)Te::Float64: Exciter field time constant in s, validation range:(eps(), 2), action if invalid:errorKf::Float64: Rate feedback excitation system stabilizer gain, validation range:(0, 0.3), action if invalid:warnTf::Float64: Rate feedback time constant, validation range:(eps(), 1.5), action if invalid:errorKc::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), action if invalid:warnKe::Float64: Exciter field proportional constant, validation range:(0, 1), action if invalid:warnE_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: Reference Voltage Set-point, validation range:(0, nothing)saturation_coeffs::Tuple{Float64, Float64}: Coefficients (A,B) of the function: Se(V) = B(V - A)^2/Vext::Dict{String, Any}states::Vector{Symbol}: The states are:
Vm: Sensed terminal voltage,
Vr1: Lead-lag state,
Vr2: Regulator output state,
Ve: Integrator output state,
Vr3: Feedback output staten_states::Int: EXAC1 has 5 statesstates_types::Vector{StateTypes}: EXAC1 has 5 statesinternal::InfrastructureSystemsInternal: power system internal reference, do not modify
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, :max), Tuple{Float64, 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::NamedTuple{(:min, :max), Tuple{Float64, Float64}}
Te::Float64
Kf::Float64
Tf::Float64
Kc::Float64
Kd::Float64
Ke::Float64
E_sat::Tuple{Float64, Float64}
Se::Tuple{Float64, Float64}
Vr_lim::NamedTuple{(:min, :max), 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
endModified 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), action if invalid:warnTb::Float64: Regulator denominator (lag) time constant in s, validation range:(0, 20), action if invalid:warnTc::Float64: Regulator numerator (lead) time constant in s, validation range:(0, 20), action if invalid:warnKa::Float64: Regulator output gain, validation range:(0, 1000), action if invalid:warnTa::Float64: Regulator output time constant in s, validation range:(0, 10)Va_lim::NamedTuple{(:min, :max), Tuple{Float64, Float64}}: Limits for regulator output(Va_min, Va_max)Te::Float64: Exciter field time constant in s, validation range:(eps(), 2), action if invalid:errorKf::Float64: Rate feedback excitation system stabilizer gain, validation range:(0, 0.3), action if invalid:warnTf::Float64: Rate feedback time constant, validation range:(eps(), 1.5), action if invalid:errorKc::Float64: Rectifier loading factor proportional to commutating reactance, validation range:(0, 1), action if invalid:warnKd::Float64: Demagnetizing factor, function of exciter alternator reactances, validation range:(0, 1), action if invalid:warnKe::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::NamedTuple{(:min, :max), Tuple{Float64, Float64}}: Limits for exciter field voltage:(Vr_min, Vr_max)V_ref::Float64: Reference Voltage Set-point, validation range:(0, nothing)saturation_coeffs::Tuple{Float64, Float64}: Coefficients (A,B) of the function: Se(x) = B(x - A)^2/xext::Dict{String, Any}states::Vector{Symbol}: The states are:
Vm: Sensed terminal voltage,
Vr1: Lead-lag state,
Vr2: Regulator output state,
Ve: Integrator output state,
Vr3: Feedback output staten_states::Int: EXAC1A has 5 statesstates_types::Vector{StateTypes}: EXAC1A has 5 statesinternal::InfrastructureSystemsInternal: power system internal reference, do not modify
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, :max), Tuple{Float64, Float64}}
Get EXAC1A Va_lim.
PowerSystems.get_Vr_lim — Methodget_Vr_lim(value::EXAC1A) -> NamedTuple{(:min, :max), Tuple{Float64, 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::NamedTuple{(:min, :max), Tuple{Float64, Float64}}
Kb::Float64
Vr_lim::NamedTuple{(:min, :max), Tuple{Float64, Float64}}
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
endModified 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), action if invalid:warnTb::Float64: Regulator denominator (lag) time constant in s, validation range:(0, 20), action if invalid:warnTc::Float64: Regulator numerator (lead) time constant in s, validation range:(0, 20), action if invalid:warnKa::Float64: Regulator output gain, validation range:(0, 1000)Ta::Float64: Regulator output time constant in s, validation range:(0, 10), action if invalid:warnVa_lim::NamedTuple{(:min, :max), Tuple{Float64, Float64}}: Limits for regulator output(Va_min, Va_max)Kb::Float64: Second Stage regulator gain, validation range:(eps(), 500), action if invalid:errorVr_lim::NamedTuple{(:min, :max), Tuple{Float64, Float64}}: Limits for exciter field voltage(Vr_min, Vr_max)Te::Float64: Exciter field time constant, validation range:(eps(), 2), action if invalid:errorKl::Float64: Exciter field current limiter gain, validation range:(0, 1.1), action if invalid:warnKh::Float64: Exciter field current regulator feedback gain, validation range:(0, 1.1), action if invalid:warnKf::Float64: Rate feedback excitation system stabilizer gain, validation range:(0, 0.3), action if invalid:warnTf::Float64: Rate feedback time constant, validation range:(eps(), nothing), action if invalid:errorKc::Float64: Rectifier loading factor proportional to commutating reactance, validation range:(0, 1), action if invalid:warnKd::Float64: Demagnetizing factor, function of exciter alternator reactances, validation range:(0, 1), action if invalid:warnKe::Float64: Exciter field proportional constant, validation range:(0, 1), action if invalid:warnV_lr::Float64: Maximum exciter field current, validation range:(0, nothing), action if invalid:warnE_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: Reference Voltage Set-point, validation range:(0, nothing)saturation_coeffs::Tuple{Float64, Float64}: Coefficients (A,B) of the function: Se(V) = B(V - A)^2/Vext::Dict{String, Any}states::Vector{Symbol}: The states are:
Vm: Sensed terminal voltage,
Vr1: Lead-lag state,
Vr2: Regulator output state,
Ve: Integrator output state,
Vr3: Feedback output staten_states::Int: EXAC2 has 5 statesstates_types::Vector{StateTypes}: EXAC2 has 5 statesinternal::InfrastructureSystemsInternal: power system internal reference, do not modify
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, :max), Tuple{Float64, Float64}}
Get EXAC2 Va_lim.
PowerSystems.get_Vr_lim — Methodget_Vr_lim(value::EXAC2) -> NamedTuple{(:min, :max), Tuple{Float64, 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::NamedTuple{(:min, :max), Tuple{Float64, Float64}}
Ta_2::Float64
Ta_3::Float64
Ta_4::Float64
Vr_lim::NamedTuple{(:min, :max), Tuple{Float64, Float64}}
Kf::Float64
Tf_1::Float64
Tf_2::Float64
Efd_lim::NamedTuple{(:min, :max), Tuple{Float64, Float64}}
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
endGeneric Proportional/Integral Excitation System
Arguments
Tr::Float64: Regulator input filter time constant in s, validation range:(0, 0.5), action if invalid:warnKa::Float64: Voltage regulator gain, validation range:(1, 500), action if invalid:warnTa::Float64: Voltage regulator time constant in s, validation range:(0, 10), action if invalid:warnVa_lim::NamedTuple{(:min, :max), Tuple{Float64, Float64}}: 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), action if invalid:warnTa_4::Float64: Voltage regulator time constant in s, validation range:(0, nothing), action if invalid:warnVr_lim::NamedTuple{(:min, :max), Tuple{Float64, Float64}}: Voltage regulator limits (regulator output) (Vimin, Vimax)Kf::Float64: Rate feedback gain, validation range:(0, 0.3), action if invalid:warnTf_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), action if invalid:warnEfd_lim::NamedTuple{(:min, :max), Tuple{Float64, Float64}}: Field Voltage regulator limits (regulator output) (Efdmin, Efdmax)Ke::Float64: Exciter constant, validation range:(0, 1), action if invalid:warnTe::Float64: Exciter time constant, validation range:(0, 2), action if invalid:warnE_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), action if invalid:warnKi::Float64: current source gain, validation range:(0, 1.1)Kc::Float64: Exciter regulation factor, validation range:(0, 2), action if invalid:warnV_ref::Float64: Reference Voltage Set-point, validation range:(0, nothing)saturation_coeffs::Tuple{Float64, Float64}: Coefficients (A,B) of the function: Se(V) = B(V - A)^2/Vext::Dict{String, Any}states::Vector{Symbol}: 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 integratorn_states::Int: EXPIC1 has 6 statesstates_types::Vector{StateTypes}: EXPIC has 6 statesinternal::InfrastructureSystemsInternal: power system internal reference, do not modify
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, :max), Tuple{Float64, 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, :max), Tuple{Float64, Float64}}
Get EXPIC1 Va_lim.
PowerSystems.get_Vr_lim — Methodget_Vr_lim(value::EXPIC1) -> NamedTuple{(:min, :max), Tuple{Float64, 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::NamedTuple{(:min, :max), Tuple{Float64, Float64}}
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
end1968 IEEE type 1 excitation system model
Arguments
Tr::Float64: Voltage Measurement Time Constant in s, validation range:(0, 0.5), action if invalid:warnKa::Float64: Amplifier Gain, validation range:(10, 500), action if invalid:warnTa::Float64: Amplifier Time Constant in s, validation range:(0, 1), action if invalid:warnVr_lim::NamedTuple{(:min, :max), Tuple{Float64, Float64}}: 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), action if invalid:errorKf::Float64: Excitation control system stabilizer gain, validation range:(eps(), 0.3), action if invalid:warnTf::Float64: Excitation control system stabilizer time constant. Appropiate Data: 5 <= Tf/Kf <= 15, validation range:(eps(), nothing), action if invalid:errorswitch::Int: Switch, validation range:(0, 1), action if invalid:errorE_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: Reference Voltage Set-point, validation range:(0, nothing)saturation_coeffs::Tuple{Float64, Float64}: Coefficients (A,B) of the function: Se(V) = B(V - A)^2/Vext::Dict{String, Any}states::Vector{Symbol}: The states are:
Vt: Terminal Voltage,
Vr: Regulator Output,
Vf: Exciter Output,
Vr3: Rate feedback integratorn_states::Int: The IEEET1 has 4 statesstates_types::Vector{StateTypes}: IEEET1 I has 4 differential statesinternal::InfrastructureSystemsInternal: power system internal reference, do not modify
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, :max), Tuple{Float64, 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.
SCRX
PowerSystems.SCRX — Typemutable struct SCRX <: AVR
Ta_Tb::Float64
Tb::Float64
K::Float64
Te::Float64
Efd_lim::NamedTuple{(:min, :max), Tuple{Float64, Float64}}
switch::Int
rc_rfd::Float64
V_ref::Float64
ext::Dict{String, Any}
states::Vector{Symbol}
n_states::Int
states_types::Vector{StateTypes}
internal::InfrastructureSystemsInternal
endThis 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), action if invalid:errorTb::Float64: Lag input constant in s, validation range:(5, 20), action if invalid:errorK::Float64: Regulator Gain, validation range:(20, 100), action if invalid:warnTe::Float64: Regulator Time Constant, validation range:(0, 1), action if invalid:warnEfd_lim::NamedTuple{(:min, :max), Tuple{Float64, Float64}}: Field Voltage regulator limits (regulator output) (Efdmin, Efdmax)switch::Int: Switch, validation range:(0, 1), action if invalid:errorrc_rfd::Float64: Field current capability. Set = 0 for negative current capability. Typical value 10, validation range:(0, 10), action if invalid:warnV_ref::Float64: Reference Voltage Set-point, validation range:(0, nothing)ext::Dict{String, Any}states::Vector{Symbol}: The states are:
Vr1: First integrator,
Vr2: Second integratorn_states::Int: SCRX has 2 statesstates_types::Vector{StateTypes}: SCRX has 2 differential statesinternal::InfrastructureSystemsInternal: power system internal reference, do not modify
PowerSystems.get_Efd_lim — Methodget_Efd_lim(value::SCRX) -> NamedTuple{(:min, :max), Tuple{Float64, 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::NamedTuple{(:min, :max), Tuple{Float64, Float64}}
V_ref::Float64
ext::Dict{String, Any}
states::Vector{Symbol}
n_states::Int
states_types::Vector{StateTypes}
internal::InfrastructureSystemsInternal
endParameters 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::NamedTuple{(:min, :max), Tuple{Float64, Float64}}: Field voltage limitsV_ref::Float64: Reference Voltage Set-point, validation range:(0, nothing)ext::Dict{String, Any}states::Vector{Symbol}: The states are: Vf: Voltage field, Vr: Lead-lag staten_states::Int: SEXS has 2 statesstates_types::Vector{StateTypes}: SEXS has 2 differential statesinternal::InfrastructureSystemsInternal: power system internal reference, do not modify
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, :max), Tuple{Float64, 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.