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 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
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: (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 voltagen_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
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::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 voltagen_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
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::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 voltagen_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
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)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 staten_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
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)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 staten_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
endExcitation 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 staten_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
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)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 integratorn_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
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)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 integratorn_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
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)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 staten_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
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)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 integratorn_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
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)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 staten_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
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)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 staten_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
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)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 staten_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
endGeneric 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 integratorn_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
end1968 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 integratorn_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
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)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 integratorn_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
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::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
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 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 Feedbackn_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
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 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 staten_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.