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.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 AVRFixedV_ref.
PowerSystems.get_Vf — Methodget_Vf(value::AVRFixed) -> Float64
Get AVRFixedVf.
PowerSystems.get_ext — Methodget_ext(value::AVRFixed) -> Dict{String, Any}
Get AVRFixedext.
PowerSystems.get_n_states — Methodget_n_states(value::AVRFixed) -> Int64
Get AVRFixedn_states.
PowerSystems.get_states — Methodget_states(value::AVRFixed) -> Vector{Symbol}
Get AVRFixedstates.
PowerSystems.get_states_types — Methodget_states_types(value::AVRFixed) -> Vector{StateTypes}
Get AVRFixedstates_types.
PowerSystems.set_V_ref! — Methodset_V_ref!(value::AVRFixed, val) -> Any
Set AVRFixedV_ref.
PowerSystems.set_Vf! — Methodset_Vf!(value::AVRFixed, val) -> Any
Set AVRFixedVf.
PowerSystems.set_ext! — Methodset_ext!(value::AVRFixed, val) -> Any
Set AVRFixedext.
PowerSystems.set_states_types! — Methodset_states_types!(value::AVRFixed, val) -> Any
Set AVRFixedstates_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.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 differentialstatesinternal::InfrastructureSystemsInternal: (Do not modify.) PowerSystems.jl internal reference
PowerSystems.get_Kv — Methodget_Kv(value::AVRSimple) -> Float64
Get AVRSimpleKv.
PowerSystems.get_V_ref — Methodget_V_ref(value::AVRSimple) -> Float64
Get AVRSimpleV_ref.
PowerSystems.get_ext — Methodget_ext(value::AVRSimple) -> Dict{String, Any}
Get AVRSimpleext.
PowerSystems.get_n_states — Methodget_n_states(value::AVRSimple) -> Int64
Get AVRSimplen_states.
PowerSystems.get_states — Methodget_states(value::AVRSimple) -> Vector{Symbol}
Get AVRSimplestates.
PowerSystems.get_states_types — Methodget_states_types(value::AVRSimple) -> Vector{StateTypes}
Get AVRSimplestates_types.
PowerSystems.set_Kv! — Methodset_Kv!(value::AVRSimple, val) -> Any
Set AVRSimpleKv.
PowerSystems.set_V_ref! — Methodset_V_ref!(value::AVRSimple, val) -> Any
Set AVRSimpleV_ref.
PowerSystems.set_ext! — Methodset_ext!(value::AVRSimple, val) -> Any
Set AVRSimpleext.
PowerSystems.set_states_types! — Methodset_states_types!(value::AVRSimple, val) -> Any
Set AVRSimplestates_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.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 differentialstatesinternal::InfrastructureSystemsInternal: (Do not modify.) PowerSystems.jl internal reference
PowerSystems.get_Ae — Methodget_Ae(value::AVRTypeI) -> Float64
Get AVRTypeIAe.
PowerSystems.get_Be — Methodget_Be(value::AVRTypeI) -> Float64
Get AVRTypeIBe.
PowerSystems.get_Ka — Methodget_Ka(value::AVRTypeI) -> Float64
Get AVRTypeIKa.
PowerSystems.get_Ke — Methodget_Ke(value::AVRTypeI) -> Float64
Get AVRTypeIKe.
PowerSystems.get_Kf — Methodget_Kf(value::AVRTypeI) -> Float64
Get AVRTypeIKf.
PowerSystems.get_Ta — Methodget_Ta(value::AVRTypeI) -> Float64
Get AVRTypeITa.
PowerSystems.get_Te — Methodget_Te(value::AVRTypeI) -> Float64
Get AVRTypeITe.
PowerSystems.get_Tf — Methodget_Tf(value::AVRTypeI) -> Float64
Get AVRTypeITf.
PowerSystems.get_Tr — Methodget_Tr(value::AVRTypeI) -> Float64
Get AVRTypeITr.
PowerSystems.get_V_ref — Methodget_V_ref(value::AVRTypeI) -> Float64
Get AVRTypeIV_ref.
PowerSystems.get_Va_lim — Methodget_Va_lim(
value::AVRTypeI
) -> @NamedTuple{min::Float64, max::Float64}
Get AVRTypeIVa_lim.
PowerSystems.get_ext — Methodget_ext(value::AVRTypeI) -> Dict{String, Any}
Get AVRTypeIext.
PowerSystems.get_n_states — Methodget_n_states(value::AVRTypeI) -> Int64
Get AVRTypeIn_states.
PowerSystems.get_states — Methodget_states(value::AVRTypeI) -> Vector{Symbol}
Get AVRTypeIstates.
PowerSystems.get_states_types — Methodget_states_types(value::AVRTypeI) -> Vector{StateTypes}
Get AVRTypeIstates_types.
PowerSystems.set_Ae! — Methodset_Ae!(value::AVRTypeI, val) -> Any
Set AVRTypeIAe.
PowerSystems.set_Be! — Methodset_Be!(value::AVRTypeI, val) -> Any
Set AVRTypeIBe.
PowerSystems.set_Ka! — Methodset_Ka!(value::AVRTypeI, val) -> Any
Set AVRTypeIKa.
PowerSystems.set_Ke! — Methodset_Ke!(value::AVRTypeI, val) -> Any
Set AVRTypeIKe.
PowerSystems.set_Kf! — Methodset_Kf!(value::AVRTypeI, val) -> Any
Set AVRTypeIKf.
PowerSystems.set_Ta! — Methodset_Ta!(value::AVRTypeI, val) -> Any
Set AVRTypeITa.
PowerSystems.set_Te! — Methodset_Te!(value::AVRTypeI, val) -> Any
Set AVRTypeITe.
PowerSystems.set_Tf! — Methodset_Tf!(value::AVRTypeI, val) -> Any
Set AVRTypeITf.
PowerSystems.set_Tr! — Methodset_Tr!(value::AVRTypeI, val) -> Any
Set AVRTypeITr.
PowerSystems.set_V_ref! — Methodset_V_ref!(value::AVRTypeI, val) -> Any
Set AVRTypeIV_ref.
PowerSystems.set_Va_lim! — Methodset_Va_lim!(value::AVRTypeI, val) -> Any
Set AVRTypeIVa_lim.
PowerSystems.set_ext! — Methodset_ext!(value::AVRTypeI, val) -> Any
Set AVRTypeIext.
PowerSystems.set_states_types! — Methodset_states_types!(value::AVRTypeI, val) -> Any
Set AVRTypeIstates_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.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 differentialstatesinternal::InfrastructureSystemsInternal: (Do not modify.) PowerSystems.jl internal reference
PowerSystems.get_Ae — Methodget_Ae(value::AVRTypeII) -> Float64
Get AVRTypeIIAe.
PowerSystems.get_Be — Methodget_Be(value::AVRTypeII) -> Float64
Get AVRTypeIIBe.
PowerSystems.get_K0 — Methodget_K0(value::AVRTypeII) -> Float64
Get AVRTypeIIK0.
PowerSystems.get_T1 — Methodget_T1(value::AVRTypeII) -> Float64
Get AVRTypeIIT1.
PowerSystems.get_T2 — Methodget_T2(value::AVRTypeII) -> Float64
Get AVRTypeIIT2.
PowerSystems.get_T3 — Methodget_T3(value::AVRTypeII) -> Float64
Get AVRTypeIIT3.
PowerSystems.get_T4 — Methodget_T4(value::AVRTypeII) -> Float64
Get AVRTypeIIT4.
PowerSystems.get_Te — Methodget_Te(value::AVRTypeII) -> Float64
Get AVRTypeIITe.
PowerSystems.get_Tr — Methodget_Tr(value::AVRTypeII) -> Float64
Get AVRTypeIITr.
PowerSystems.get_V_ref — Methodget_V_ref(value::AVRTypeII) -> Float64
Get AVRTypeIIV_ref.
PowerSystems.get_Va_lim — Methodget_Va_lim(
value::AVRTypeII
) -> @NamedTuple{min::Float64, max::Float64}
Get AVRTypeIIVa_lim.
PowerSystems.get_ext — Methodget_ext(value::AVRTypeII) -> Dict{String, Any}
Get AVRTypeIIext.
PowerSystems.get_n_states — Methodget_n_states(value::AVRTypeII) -> Int64
Get AVRTypeIIn_states.
PowerSystems.get_states — Methodget_states(value::AVRTypeII) -> Vector{Symbol}
Get AVRTypeIIstates.
PowerSystems.get_states_types — Methodget_states_types(value::AVRTypeII) -> Vector{StateTypes}
Get AVRTypeIIstates_types.
PowerSystems.set_Ae! — Methodset_Ae!(value::AVRTypeII, val) -> Any
Set AVRTypeIIAe.
PowerSystems.set_Be! — Methodset_Be!(value::AVRTypeII, val) -> Any
Set AVRTypeIIBe.
PowerSystems.set_K0! — Methodset_K0!(value::AVRTypeII, val) -> Any
Set AVRTypeIIK0.
PowerSystems.set_T1! — Methodset_T1!(value::AVRTypeII, val) -> Any
Set AVRTypeIIT1.
PowerSystems.set_T2! — Methodset_T2!(value::AVRTypeII, val) -> Any
Set AVRTypeIIT2.
PowerSystems.set_T3! — Methodset_T3!(value::AVRTypeII, val) -> Any
Set AVRTypeIIT3.
PowerSystems.set_T4! — Methodset_T4!(value::AVRTypeII, val) -> Any
Set AVRTypeIIT4.
PowerSystems.set_Te! — Methodset_Te!(value::AVRTypeII, val) -> Any
Set AVRTypeIITe.
PowerSystems.set_Tr! — Methodset_Tr!(value::AVRTypeII, val) -> Any
Set AVRTypeIITr.
PowerSystems.set_V_ref! — Methodset_V_ref!(value::AVRTypeII, val) -> Any
Set AVRTypeIIV_ref.
PowerSystems.set_Va_lim! — Methodset_Va_lim!(value::AVRTypeII, val) -> Any
Set AVRTypeIIVa_lim.
PowerSystems.set_ext! — Methodset_ext!(value::AVRTypeII, val) -> Any
Set AVRTypeIIext.
PowerSystems.set_states_types! — Methodset_states_types!(value::AVRTypeII, val) -> Any
Set AVRTypeIIstates_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.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 ESAC1AE_sat.
PowerSystems.get_Ka — Methodget_Ka(value::ESAC1A) -> Float64
Get ESAC1AKa.
PowerSystems.get_Kc — Methodget_Kc(value::ESAC1A) -> Float64
Get ESAC1AKc.
PowerSystems.get_Kd — Methodget_Kd(value::ESAC1A) -> Float64
Get ESAC1AKd.
PowerSystems.get_Ke — Methodget_Ke(value::ESAC1A) -> Float64
Get ESAC1AKe.
PowerSystems.get_Kf — Methodget_Kf(value::ESAC1A) -> Float64
Get ESAC1AKf.
PowerSystems.get_Se — Methodget_Se(value::ESAC1A) -> Tuple{Float64, Float64}
Get ESAC1ASe.
PowerSystems.get_Ta — Methodget_Ta(value::ESAC1A) -> Float64
Get ESAC1ATa.
PowerSystems.get_Tb — Methodget_Tb(value::ESAC1A) -> Float64
Get ESAC1ATb.
PowerSystems.get_Tc — Methodget_Tc(value::ESAC1A) -> Float64
Get ESAC1ATc.
PowerSystems.get_Te — Methodget_Te(value::ESAC1A) -> Float64
Get ESAC1ATe.
PowerSystems.get_Tf — Methodget_Tf(value::ESAC1A) -> Float64
Get ESAC1ATf.
PowerSystems.get_Tr — Methodget_Tr(value::ESAC1A) -> Float64
Get ESAC1ATr.
PowerSystems.get_V_ref — Methodget_V_ref(value::ESAC1A) -> Float64
Get ESAC1AV_ref.
PowerSystems.get_Va_lim — Methodget_Va_lim(
value::ESAC1A
) -> @NamedTuple{min::Float64, max::Float64}
Get ESAC1AVa_lim.
PowerSystems.get_Vr_lim — Methodget_Vr_lim(
value::ESAC1A
) -> @NamedTuple{min::Float64, max::Float64}
Get ESAC1AVr_lim.
PowerSystems.get_ext — Methodget_ext(value::ESAC1A) -> Dict{String, Any}
Get ESAC1Aext.
PowerSystems.get_n_states — Methodget_n_states(value::ESAC1A) -> Int64
Get ESAC1An_states.
PowerSystems.get_saturation_coeffs — Methodget_saturation_coeffs(
value::ESAC1A
) -> Tuple{Float64, Float64}
Get ESAC1Asaturation_coeffs.
PowerSystems.get_states — Methodget_states(value::ESAC1A) -> Vector{Symbol}
Get ESAC1Astates.
PowerSystems.get_states_types — Methodget_states_types(value::ESAC1A) -> Vector{StateTypes}
Get ESAC1Astates_types.
PowerSystems.set_E_sat! — Methodset_E_sat!(value::ESAC1A, val) -> Any
Set ESAC1AE_sat.
PowerSystems.set_Ka! — Methodset_Ka!(value::ESAC1A, val) -> Any
Set ESAC1AKa.
PowerSystems.set_Kc! — Methodset_Kc!(value::ESAC1A, val) -> Any
Set ESAC1AKc.
PowerSystems.set_Kd! — Methodset_Kd!(value::ESAC1A, val) -> Any
Set ESAC1AKd.
PowerSystems.set_Ke! — Methodset_Ke!(value::ESAC1A, val) -> Any
Set ESAC1AKe.
PowerSystems.set_Kf! — Methodset_Kf!(value::ESAC1A, val) -> Any
Set ESAC1AKf.
PowerSystems.set_Se! — Methodset_Se!(value::ESAC1A, val) -> Any
Set ESAC1ASe.
PowerSystems.set_Ta! — Methodset_Ta!(value::ESAC1A, val) -> Any
Set ESAC1ATa.
PowerSystems.set_Tb! — Methodset_Tb!(value::ESAC1A, val) -> Any
Set ESAC1ATb.
PowerSystems.set_Tc! — Methodset_Tc!(value::ESAC1A, val) -> Any
Set ESAC1ATc.
PowerSystems.set_Te! — Methodset_Te!(value::ESAC1A, val) -> Any
Set ESAC1ATe.
PowerSystems.set_Tf! — Methodset_Tf!(value::ESAC1A, val) -> Any
Set ESAC1ATf.
PowerSystems.set_Tr! — Methodset_Tr!(value::ESAC1A, val) -> Any
Set ESAC1ATr.
PowerSystems.set_V_ref! — Methodset_V_ref!(value::ESAC1A, val) -> Any
Set ESAC1AV_ref.
PowerSystems.set_Va_lim! — Methodset_Va_lim!(value::ESAC1A, val) -> Any
Set ESAC1AVa_lim.
PowerSystems.set_Vr_lim! — Methodset_Vr_lim!(value::ESAC1A, val) -> Any
Set ESAC1AVr_lim.
PowerSystems.set_ext! — Methodset_ext!(value::ESAC1A, val) -> Any
Set ESAC1Aext.
PowerSystems.set_saturation_coeffs! — Methodset_saturation_coeffs!(value::ESAC1A, val) -> Any
Set ESAC1Asaturation_coeffs.
PowerSystems.set_states_types! — Methodset_states_types!(value::ESAC1A, val) -> Any
Set ESAC1Astates_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.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 ESAC6AE_sat.
PowerSystems.get_Ka — Methodget_Ka(value::ESAC6A) -> Float64
Get ESAC6AKa.
PowerSystems.get_Kc — Methodget_Kc(value::ESAC6A) -> Float64
Get ESAC6AKc.
PowerSystems.get_Kd — Methodget_Kd(value::ESAC6A) -> Float64
Get ESAC6AKd.
PowerSystems.get_Ke — Methodget_Ke(value::ESAC6A) -> Float64
Get ESAC6AKe.
PowerSystems.get_Kh — Methodget_Kh(value::ESAC6A) -> Float64
Get ESAC6AKh.
PowerSystems.get_Se — Methodget_Se(value::ESAC6A) -> Tuple{Float64, Float64}
Get ESAC6ASe.
PowerSystems.get_Ta — Methodget_Ta(value::ESAC6A) -> Float64
Get ESAC6ATa.
PowerSystems.get_Tb — Methodget_Tb(value::ESAC6A) -> Float64
Get ESAC6ATb.
PowerSystems.get_Tc — Methodget_Tc(value::ESAC6A) -> Float64
Get ESAC6ATc.
PowerSystems.get_Te — Methodget_Te(value::ESAC6A) -> Float64
Get ESAC6ATe.
PowerSystems.get_Th — Methodget_Th(value::ESAC6A) -> Float64
Get ESAC6ATh.
PowerSystems.get_Tj — Methodget_Tj(value::ESAC6A) -> Float64
Get ESAC6ATj.
PowerSystems.get_Tk — Methodget_Tk(value::ESAC6A) -> Float64
Get ESAC6ATk.
PowerSystems.get_Tr — Methodget_Tr(value::ESAC6A) -> Float64
Get ESAC6ATr.
PowerSystems.get_VFE_lim — Methodget_VFE_lim(value::ESAC6A) -> Float64
Get ESAC6AVFE_lim.
PowerSystems.get_VH_max — Methodget_VH_max(value::ESAC6A) -> Float64
Get ESAC6AVH_max.
PowerSystems.get_V_ref — Methodget_V_ref(value::ESAC6A) -> Float64
Get ESAC6AV_ref.
PowerSystems.get_Va_lim — Methodget_Va_lim(
value::ESAC6A
) -> @NamedTuple{min::Float64, max::Float64}
Get ESAC6AVa_lim.
PowerSystems.get_Vr_lim — Methodget_Vr_lim(
value::ESAC6A
) -> @NamedTuple{min::Float64, max::Float64}
Get ESAC6AVr_lim.
PowerSystems.get_ext — Methodget_ext(value::ESAC6A) -> Dict{String, Any}
Get ESAC6Aext.
PowerSystems.get_n_states — Methodget_n_states(value::ESAC6A) -> Int64
Get ESAC6An_states.
PowerSystems.get_saturation_coeffs — Methodget_saturation_coeffs(
value::ESAC6A
) -> Tuple{Float64, Float64}
Get ESAC6Asaturation_coeffs.
PowerSystems.get_states — Methodget_states(value::ESAC6A) -> Vector{Symbol}
Get ESAC6Astates.
PowerSystems.get_states_types — Methodget_states_types(value::ESAC6A) -> Vector{StateTypes}
Get ESAC6Astates_types.
PowerSystems.set_E_sat! — Methodset_E_sat!(value::ESAC6A, val) -> Any
Set ESAC6AE_sat.
PowerSystems.set_Ka! — Methodset_Ka!(value::ESAC6A, val) -> Any
Set ESAC6AKa.
PowerSystems.set_Kc! — Methodset_Kc!(value::ESAC6A, val) -> Any
Set ESAC6AKc.
PowerSystems.set_Kd! — Methodset_Kd!(value::ESAC6A, val) -> Any
Set ESAC6AKd.
PowerSystems.set_Ke! — Methodset_Ke!(value::ESAC6A, val) -> Any
Set ESAC6AKe.
PowerSystems.set_Kh! — Methodset_Kh!(value::ESAC6A, val) -> Any
Set ESAC6AKh.
PowerSystems.set_Se! — Methodset_Se!(value::ESAC6A, val) -> Any
Set ESAC6ASe.
PowerSystems.set_Ta! — Methodset_Ta!(value::ESAC6A, val) -> Any
Set ESAC6ATa.
PowerSystems.set_Tb! — Methodset_Tb!(value::ESAC6A, val) -> Any
Set ESAC6ATb.
PowerSystems.set_Tc! — Methodset_Tc!(value::ESAC6A, val) -> Any
Set ESAC6ATc.
PowerSystems.set_Te! — Methodset_Te!(value::ESAC6A, val) -> Any
Set ESAC6ATe.
PowerSystems.set_Th! — Methodset_Th!(value::ESAC6A, val) -> Any
Set ESAC6ATh.
PowerSystems.set_Tj! — Methodset_Tj!(value::ESAC6A, val) -> Any
Set ESAC6ATj.
PowerSystems.set_Tk! — Methodset_Tk!(value::ESAC6A, val) -> Any
Set ESAC6ATk.
PowerSystems.set_Tr! — Methodset_Tr!(value::ESAC6A, val) -> Any
Set ESAC6ATr.
PowerSystems.set_VFE_lim! — Methodset_VFE_lim!(value::ESAC6A, val) -> Any
Set ESAC6AVFE_lim.
PowerSystems.set_VH_max! — Methodset_VH_max!(value::ESAC6A, val) -> Any
Set ESAC6AVH_max.
PowerSystems.set_V_ref! — Methodset_V_ref!(value::ESAC6A, val) -> Any
Set ESAC6AV_ref.
PowerSystems.set_Va_lim! — Methodset_Va_lim!(value::ESAC6A, val) -> Any
Set ESAC6AVa_lim.
PowerSystems.set_Vr_lim! — Methodset_Vr_lim!(value::ESAC6A, val) -> Any
Set ESAC6AVr_lim.
PowerSystems.set_ext! — Methodset_ext!(value::ESAC6A, val) -> Any
Set ESAC6Aext.
PowerSystems.set_saturation_coeffs! — Methodset_saturation_coeffs!(value::ESAC6A, val) -> Any
Set ESAC6Asaturation_coeffs.
PowerSystems.set_states_types! — Methodset_states_types!(value::ESAC6A, val) -> Any
Set ESAC6Astates_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.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 ESAC8BE_sat.
PowerSystems.get_Ka — Methodget_Ka(value::ESAC8B) -> Float64
Get ESAC8BKa.
PowerSystems.get_Kd — Methodget_Kd(value::ESAC8B) -> Float64
Get ESAC8BKd.
PowerSystems.get_Ke — Methodget_Ke(value::ESAC8B) -> Float64
Get ESAC8BKe.
PowerSystems.get_Ki — Methodget_Ki(value::ESAC8B) -> Float64
Get ESAC8BKi.
PowerSystems.get_Kp — Methodget_Kp(value::ESAC8B) -> Float64
Get ESAC8BKp.
PowerSystems.get_Se — Methodget_Se(value::ESAC8B) -> Tuple{Float64, Float64}
Get ESAC8BSe.
PowerSystems.get_Ta — Methodget_Ta(value::ESAC8B) -> Float64
Get ESAC8BTa.
PowerSystems.get_Td — Methodget_Td(value::ESAC8B) -> Float64
Get ESAC8BTd.
PowerSystems.get_Te — Methodget_Te(value::ESAC8B) -> Float64
Get ESAC8BTe.
PowerSystems.get_Tr — Methodget_Tr(value::ESAC8B) -> Float64
Get ESAC8BTr.
PowerSystems.get_V_ref — Methodget_V_ref(value::ESAC8B) -> Float64
Get ESAC8BV_ref.
PowerSystems.get_Vr_lim — Methodget_Vr_lim(
value::ESAC8B
) -> @NamedTuple{min::Float64, max::Float64}
Get ESAC8BVr_lim.
PowerSystems.get_ext — Methodget_ext(value::ESAC8B) -> Dict{String, Any}
Get ESAC8Bext.
PowerSystems.get_n_states — Methodget_n_states(value::ESAC8B) -> Int64
Get ESAC8Bn_states.
PowerSystems.get_saturation_coeffs — Methodget_saturation_coeffs(
value::ESAC8B
) -> Tuple{Float64, Float64}
Get ESAC8Bsaturation_coeffs.
PowerSystems.get_states — Methodget_states(value::ESAC8B) -> Vector{Symbol}
Get ESAC8Bstates.
PowerSystems.get_states_types — Methodget_states_types(value::ESAC8B) -> Vector{StateTypes}
Get ESAC8Bstates_types.
PowerSystems.set_E_sat! — Methodset_E_sat!(value::ESAC8B, val) -> Any
Set ESAC8BE_sat.
PowerSystems.set_Ka! — Methodset_Ka!(value::ESAC8B, val) -> Any
Set ESAC8BKa.
PowerSystems.set_Kd! — Methodset_Kd!(value::ESAC8B, val) -> Any
Set ESAC8BKd.
PowerSystems.set_Ke! — Methodset_Ke!(value::ESAC8B, val) -> Any
Set ESAC8BKe.
PowerSystems.set_Ki! — Methodset_Ki!(value::ESAC8B, val) -> Any
Set ESAC8BKi.
PowerSystems.set_Kp! — Methodset_Kp!(value::ESAC8B, val) -> Any
Set ESAC8BKp.
PowerSystems.set_Se! — Methodset_Se!(value::ESAC8B, val) -> Any
Set ESAC8BSe.
PowerSystems.set_Ta! — Methodset_Ta!(value::ESAC8B, val) -> Any
Set ESAC8BTa.
PowerSystems.set_Td! — Methodset_Td!(value::ESAC8B, val) -> Any
Set ESAC8BTd.
PowerSystems.set_Te! — Methodset_Te!(value::ESAC8B, val) -> Any
Set ESAC8BTe.
PowerSystems.set_Tr! — Methodset_Tr!(value::ESAC8B, val) -> Any
Set ESAC8BTr.
PowerSystems.set_V_ref! — Methodset_V_ref!(value::ESAC8B, val) -> Any
Set ESAC8BV_ref.
PowerSystems.set_Vr_lim! — Methodset_Vr_lim!(value::ESAC8B, val) -> Any
Set ESAC8BVr_lim.
PowerSystems.set_ext! — Methodset_ext!(value::ESAC8B, val) -> Any
Set ESAC8Bext.
PowerSystems.set_saturation_coeffs! — Methodset_saturation_coeffs!(value::ESAC8B, val) -> Any
Set ESAC8Bsaturation_coeffs.
PowerSystems.set_states_types! — Methodset_states_types!(value::ESAC8B, val) -> Any
Set ESAC8Bstates_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.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 differentialstatesinternal::InfrastructureSystemsInternal: (Do not modify.) PowerSystems.jl internal reference
PowerSystems.get_E_sat — Methodget_E_sat(value::ESDC1A) -> Tuple{Float64, Float64}
Get ESDC1AE_sat.
PowerSystems.get_Ka — Methodget_Ka(value::ESDC1A) -> Float64
Get ESDC1AKa.
PowerSystems.get_Ke — Methodget_Ke(value::ESDC1A) -> Float64
Get ESDC1AKe.
PowerSystems.get_Kf — Methodget_Kf(value::ESDC1A) -> Float64
Get ESDC1AKf.
PowerSystems.get_Se — Methodget_Se(value::ESDC1A) -> Tuple{Float64, Float64}
Get ESDC1ASe.
PowerSystems.get_Ta — Methodget_Ta(value::ESDC1A) -> Float64
Get ESDC1ATa.
PowerSystems.get_Tb — Methodget_Tb(value::ESDC1A) -> Float64
Get ESDC1ATb.
PowerSystems.get_Tc — Methodget_Tc(value::ESDC1A) -> Float64
Get ESDC1ATc.
PowerSystems.get_Te — Methodget_Te(value::ESDC1A) -> Float64
Get ESDC1ATe.
PowerSystems.get_Tf — Methodget_Tf(value::ESDC1A) -> Float64
Get ESDC1ATf.
PowerSystems.get_Tr — Methodget_Tr(value::ESDC1A) -> Float64
Get ESDC1ATr.
PowerSystems.get_V_ref — Methodget_V_ref(value::ESDC1A) -> Float64
Get ESDC1AV_ref.
PowerSystems.get_Vr_lim — Methodget_Vr_lim(
value::ESDC1A
) -> @NamedTuple{min::Float64, max::Float64}
Get ESDC1AVr_lim.
PowerSystems.get_ext — Methodget_ext(value::ESDC1A) -> Dict{String, Any}
Get ESDC1Aext.
PowerSystems.get_n_states — Methodget_n_states(value::ESDC1A) -> Int64
Get ESDC1An_states.
PowerSystems.get_saturation_coeffs — Methodget_saturation_coeffs(
value::ESDC1A
) -> Tuple{Float64, Float64}
Get ESDC1Asaturation_coeffs.
PowerSystems.get_states — Methodget_states(value::ESDC1A) -> Vector{Symbol}
Get ESDC1Astates.
PowerSystems.get_states_types — Methodget_states_types(value::ESDC1A) -> Vector{StateTypes}
Get ESDC1Astates_types.
PowerSystems.get_switch — Methodget_switch(value::ESDC1A) -> Int64
Get ESDC1Aswitch.
PowerSystems.set_E_sat! — Methodset_E_sat!(value::ESDC1A, val) -> Any
Set ESDC1AE_sat.
PowerSystems.set_Ka! — Methodset_Ka!(value::ESDC1A, val) -> Any
Set ESDC1AKa.
PowerSystems.set_Ke! — Methodset_Ke!(value::ESDC1A, val) -> Any
Set ESDC1AKe.
PowerSystems.set_Kf! — Methodset_Kf!(value::ESDC1A, val) -> Any
Set ESDC1AKf.
PowerSystems.set_Se! — Methodset_Se!(value::ESDC1A, val) -> Any
Set ESDC1ASe.
PowerSystems.set_Ta! — Methodset_Ta!(value::ESDC1A, val) -> Any
Set ESDC1ATa.
PowerSystems.set_Tb! — Methodset_Tb!(value::ESDC1A, val) -> Any
Set ESDC1ATb.
PowerSystems.set_Tc! — Methodset_Tc!(value::ESDC1A, val) -> Any
Set ESDC1ATc.
PowerSystems.set_Te! — Methodset_Te!(value::ESDC1A, val) -> Any
Set ESDC1ATe.
PowerSystems.set_Tf! — Methodset_Tf!(value::ESDC1A, val) -> Any
Set ESDC1ATf.
PowerSystems.set_Tr! — Methodset_Tr!(value::ESDC1A, val) -> Any
Set ESDC1ATr.
PowerSystems.set_V_ref! — Methodset_V_ref!(value::ESDC1A, val) -> Any
Set ESDC1AV_ref.
PowerSystems.set_Vr_lim! — Methodset_Vr_lim!(value::ESDC1A, val) -> Any
Set ESDC1AVr_lim.
PowerSystems.set_ext! — Methodset_ext!(value::ESDC1A, val) -> Any
Set ESDC1Aext.
PowerSystems.set_saturation_coeffs! — Methodset_saturation_coeffs!(value::ESDC1A, val) -> Any
Set ESDC1Asaturation_coeffs.
PowerSystems.set_states_types! — Methodset_states_types!(value::ESDC1A, val) -> Any
Set ESDC1Astates_types.
PowerSystems.set_switch! — Methodset_switch!(value::ESDC1A, val) -> Any
Set ESDC1Aswitch.
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.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 differentialstatesinternal::InfrastructureSystemsInternal: (Do not modify.) PowerSystems.jl internal reference
PowerSystems.get_E_sat — Methodget_E_sat(value::ESDC2A) -> Tuple{Float64, Float64}
Get ESDC2AE_sat.
PowerSystems.get_Ka — Methodget_Ka(value::ESDC2A) -> Float64
Get ESDC2AKa.
PowerSystems.get_Ke — Methodget_Ke(value::ESDC2A) -> Float64
Get ESDC2AKe.
PowerSystems.get_Kf — Methodget_Kf(value::ESDC2A) -> Float64
Get ESDC2AKf.
PowerSystems.get_Se — Methodget_Se(value::ESDC2A) -> Tuple{Float64, Float64}
Get ESDC2ASe.
PowerSystems.get_Ta — Methodget_Ta(value::ESDC2A) -> Float64
Get ESDC2ATa.
PowerSystems.get_Tb — Methodget_Tb(value::ESDC2A) -> Float64
Get ESDC2ATb.
PowerSystems.get_Tc — Methodget_Tc(value::ESDC2A) -> Float64
Get ESDC2ATc.
PowerSystems.get_Te — Methodget_Te(value::ESDC2A) -> Float64
Get ESDC2ATe.
PowerSystems.get_Tf — Methodget_Tf(value::ESDC2A) -> Float64
Get ESDC2ATf.
PowerSystems.get_Tr — Methodget_Tr(value::ESDC2A) -> Float64
Get ESDC2ATr.
PowerSystems.get_V_ref — Methodget_V_ref(value::ESDC2A) -> Float64
Get ESDC2AV_ref.
PowerSystems.get_Vr_lim — Methodget_Vr_lim(
value::ESDC2A
) -> @NamedTuple{min::Float64, max::Float64}
Get ESDC2AVr_lim.
PowerSystems.get_ext — Methodget_ext(value::ESDC2A) -> Dict{String, Any}
Get ESDC2Aext.
PowerSystems.get_n_states — Methodget_n_states(value::ESDC2A) -> Int64
Get ESDC2An_states.
PowerSystems.get_saturation_coeffs — Methodget_saturation_coeffs(
value::ESDC2A
) -> Tuple{Float64, Float64}
Get ESDC2Asaturation_coeffs.
PowerSystems.get_states — Methodget_states(value::ESDC2A) -> Vector{Symbol}
Get ESDC2Astates.
PowerSystems.get_states_types — Methodget_states_types(value::ESDC2A) -> Vector{StateTypes}
Get ESDC2Astates_types.
PowerSystems.get_switch — Methodget_switch(value::ESDC2A) -> Int64
Get ESDC2Aswitch.
PowerSystems.set_E_sat! — Methodset_E_sat!(value::ESDC2A, val) -> Any
Set ESDC2AE_sat.
PowerSystems.set_Ka! — Methodset_Ka!(value::ESDC2A, val) -> Any
Set ESDC2AKa.
PowerSystems.set_Ke! — Methodset_Ke!(value::ESDC2A, val) -> Any
Set ESDC2AKe.
PowerSystems.set_Kf! — Methodset_Kf!(value::ESDC2A, val) -> Any
Set ESDC2AKf.
PowerSystems.set_Se! — Methodset_Se!(value::ESDC2A, val) -> Any
Set ESDC2ASe.
PowerSystems.set_Ta! — Methodset_Ta!(value::ESDC2A, val) -> Any
Set ESDC2ATa.
PowerSystems.set_Tb! — Methodset_Tb!(value::ESDC2A, val) -> Any
Set ESDC2ATb.
PowerSystems.set_Tc! — Methodset_Tc!(value::ESDC2A, val) -> Any
Set ESDC2ATc.
PowerSystems.set_Te! — Methodset_Te!(value::ESDC2A, val) -> Any
Set ESDC2ATe.
PowerSystems.set_Tf! — Methodset_Tf!(value::ESDC2A, val) -> Any
Set ESDC2ATf.
PowerSystems.set_Tr! — Methodset_Tr!(value::ESDC2A, val) -> Any
Set ESDC2ATr.
PowerSystems.set_V_ref! — Methodset_V_ref!(value::ESDC2A, val) -> Any
Set ESDC2AV_ref.
PowerSystems.set_Vr_lim! — Methodset_Vr_lim!(value::ESDC2A, val) -> Any
Set ESDC2AVr_lim.
PowerSystems.set_ext! — Methodset_ext!(value::ESDC2A, val) -> Any
Set ESDC2Aext.
PowerSystems.set_saturation_coeffs! — Methodset_saturation_coeffs!(value::ESDC2A, val) -> Any
Set ESDC2Asaturation_coeffs.
PowerSystems.set_states_types! — Methodset_states_types!(value::ESDC2A, val) -> Any
Set ESDC2Astates_types.
PowerSystems.set_switch! — Methodset_switch!(value::ESDC2A, val) -> Any
Set ESDC2Aswitch.
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.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 ESST1AI_lr.
PowerSystems.get_K_lr — Methodget_K_lr(value::ESST1A) -> Float64
Get ESST1AK_lr.
PowerSystems.get_Ka — Methodget_Ka(value::ESST1A) -> Float64
Get ESST1AKa.
PowerSystems.get_Kc — Methodget_Kc(value::ESST1A) -> Float64
Get ESST1AKc.
PowerSystems.get_Kf — Methodget_Kf(value::ESST1A) -> Float64
Get ESST1AKf.
PowerSystems.get_PSS_flags — Methodget_PSS_flags(value::ESST1A) -> Int64
Get ESST1APSS_flags.
PowerSystems.get_Ta — Methodget_Ta(value::ESST1A) -> Float64
Get ESST1ATa.
PowerSystems.get_Tb — Methodget_Tb(value::ESST1A) -> Float64
Get ESST1ATb.
PowerSystems.get_Tb1 — Methodget_Tb1(value::ESST1A) -> Float64
Get ESST1ATb1.
PowerSystems.get_Tc — Methodget_Tc(value::ESST1A) -> Float64
Get ESST1ATc.
PowerSystems.get_Tc1 — Methodget_Tc1(value::ESST1A) -> Float64
Get ESST1ATc1.
PowerSystems.get_Tf — Methodget_Tf(value::ESST1A) -> Float64
Get ESST1ATf.
PowerSystems.get_Tr — Methodget_Tr(value::ESST1A) -> Float64
Get ESST1ATr.
PowerSystems.get_UEL_flags — Methodget_UEL_flags(value::ESST1A) -> Int64
Get ESST1AUEL_flags.
PowerSystems.get_V_ref — Methodget_V_ref(value::ESST1A) -> Float64
Get ESST1AV_ref.
PowerSystems.get_Va_lim — Methodget_Va_lim(
value::ESST1A
) -> @NamedTuple{min::Float64, max::Float64}
Get ESST1AVa_lim.
PowerSystems.get_Vi_lim — Methodget_Vi_lim(value::ESST1A) -> Tuple{Float64, Float64}
Get ESST1AVi_lim.
PowerSystems.get_Vr_lim — Methodget_Vr_lim(
value::ESST1A
) -> @NamedTuple{min::Float64, max::Float64}
Get ESST1AVr_lim.
PowerSystems.get_ext — Methodget_ext(value::ESST1A) -> Dict{String, Any}
Get ESST1Aext.
PowerSystems.get_n_states — Methodget_n_states(value::ESST1A) -> Int64
Get ESST1An_states.
PowerSystems.get_states — Methodget_states(value::ESST1A) -> Vector{Symbol}
Get ESST1Astates.
PowerSystems.get_states_types — Methodget_states_types(value::ESST1A) -> Vector{StateTypes}
Get ESST1Astates_types.
PowerSystems.set_I_lr! — Methodset_I_lr!(value::ESST1A, val) -> Any
Set ESST1AI_lr.
PowerSystems.set_K_lr! — Methodset_K_lr!(value::ESST1A, val) -> Any
Set ESST1AK_lr.
PowerSystems.set_Ka! — Methodset_Ka!(value::ESST1A, val) -> Any
Set ESST1AKa.
PowerSystems.set_Kc! — Methodset_Kc!(value::ESST1A, val) -> Any
Set ESST1AKc.
PowerSystems.set_Kf! — Methodset_Kf!(value::ESST1A, val) -> Any
Set ESST1AKf.
PowerSystems.set_PSS_flags! — Methodset_PSS_flags!(value::ESST1A, val) -> Any
Set ESST1APSS_flags.
PowerSystems.set_Ta! — Methodset_Ta!(value::ESST1A, val) -> Any
Set ESST1ATa.
PowerSystems.set_Tb! — Methodset_Tb!(value::ESST1A, val) -> Any
Set ESST1ATb.
PowerSystems.set_Tb1! — Methodset_Tb1!(value::ESST1A, val) -> Any
Set ESST1ATb1.
PowerSystems.set_Tc! — Methodset_Tc!(value::ESST1A, val) -> Any
Set ESST1ATc.
PowerSystems.set_Tc1! — Methodset_Tc1!(value::ESST1A, val) -> Any
Set ESST1ATc1.
PowerSystems.set_Tf! — Methodset_Tf!(value::ESST1A, val) -> Any
Set ESST1ATf.
PowerSystems.set_Tr! — Methodset_Tr!(value::ESST1A, val) -> Any
Set ESST1ATr.
PowerSystems.set_UEL_flags! — Methodset_UEL_flags!(value::ESST1A, val) -> Any
Set ESST1AUEL_flags.
PowerSystems.set_V_ref! — Methodset_V_ref!(value::ESST1A, val) -> Any
Set ESST1AV_ref.
PowerSystems.set_Va_lim! — Methodset_Va_lim!(value::ESST1A, val) -> Any
Set ESST1AVa_lim.
PowerSystems.set_Vi_lim! — Methodset_Vi_lim!(value::ESST1A, val) -> Any
Set ESST1AVi_lim.
PowerSystems.set_Vr_lim! — Methodset_Vr_lim!(value::ESST1A, val) -> Any
Set ESST1AVr_lim.
PowerSystems.set_ext! — Methodset_ext!(value::ESST1A, val) -> Any
Set ESST1Aext.
PowerSystems.set_states_types! — Methodset_states_types!(value::ESST1A, val) -> Any
Set ESST1Astates_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.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 ESST4BK_im.
PowerSystems.get_K_ir — Methodget_K_ir(value::ESST4B) -> Float64
Get ESST4BK_ir.
PowerSystems.get_K_pm — Methodget_K_pm(value::ESST4B) -> Float64
Get ESST4BK_pm.
PowerSystems.get_K_pr — Methodget_K_pr(value::ESST4B) -> Float64
Get ESST4BK_pr.
PowerSystems.get_Kc — Methodget_Kc(value::ESST4B) -> Float64
Get ESST4BKc.
PowerSystems.get_Kg — Methodget_Kg(value::ESST4B) -> Float64
Get ESST4BKg.
PowerSystems.get_Ki — Methodget_Ki(value::ESST4B) -> Float64
Get ESST4BKi.
PowerSystems.get_Kp — Methodget_Kp(value::ESST4B) -> Float64
Get ESST4BKp.
PowerSystems.get_Ta — Methodget_Ta(value::ESST4B) -> Float64
Get ESST4BTa.
PowerSystems.get_Tr — Methodget_Tr(value::ESST4B) -> Float64
Get ESST4BTr.
PowerSystems.get_VB_max — Methodget_VB_max(value::ESST4B) -> Float64
Get ESST4BVB_max.
PowerSystems.get_V_ref — Methodget_V_ref(value::ESST4B) -> Float64
Get ESST4BV_ref.
PowerSystems.get_Vm_lim — Methodget_Vm_lim(
value::ESST4B
) -> @NamedTuple{min::Float64, max::Float64}
Get ESST4BVm_lim.
PowerSystems.get_Vr_lim — Methodget_Vr_lim(
value::ESST4B
) -> @NamedTuple{min::Float64, max::Float64}
Get ESST4BVr_lim.
PowerSystems.get_Xl — Methodget_Xl(value::ESST4B) -> Float64
Get ESST4BXl.
PowerSystems.get_ext — Methodget_ext(value::ESST4B) -> Dict{String, Any}
Get ESST4Bext.
PowerSystems.get_n_states — Methodget_n_states(value::ESST4B) -> Int64
Get ESST4Bn_states.
PowerSystems.get_states — Methodget_states(value::ESST4B) -> Vector{Symbol}
Get ESST4Bstates.
PowerSystems.get_states_types — Methodget_states_types(value::ESST4B) -> Vector{StateTypes}
Get ESST4Bstates_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 ESST4BK_im.
PowerSystems.set_K_ir! — Methodset_K_ir!(value::ESST4B, val) -> Any
Set ESST4BK_ir.
PowerSystems.set_K_pm! — Methodset_K_pm!(value::ESST4B, val) -> Any
Set ESST4BK_pm.
PowerSystems.set_K_pr! — Methodset_K_pr!(value::ESST4B, val) -> Any
Set ESST4BK_pr.
PowerSystems.set_Kc! — Methodset_Kc!(value::ESST4B, val) -> Any
Set ESST4BKc.
PowerSystems.set_Kg! — Methodset_Kg!(value::ESST4B, val) -> Any
Set ESST4BKg.
PowerSystems.set_Ki! — Methodset_Ki!(value::ESST4B, val) -> Any
Set ESST4BKi.
PowerSystems.set_Kp! — Methodset_Kp!(value::ESST4B, val) -> Any
Set ESST4BKp.
PowerSystems.set_Ta! — Methodset_Ta!(value::ESST4B, val) -> Any
Set ESST4BTa.
PowerSystems.set_Tr! — Methodset_Tr!(value::ESST4B, val) -> Any
Set ESST4BTr.
PowerSystems.set_VB_max! — Methodset_VB_max!(value::ESST4B, val) -> Any
Set ESST4BVB_max.
PowerSystems.set_V_ref! — Methodset_V_ref!(value::ESST4B, val) -> Any
Set ESST4BV_ref.
PowerSystems.set_Vm_lim! — Methodset_Vm_lim!(value::ESST4B, val) -> Any
Set ESST4BVm_lim.
PowerSystems.set_Vr_lim! — Methodset_Vr_lim!(value::ESST4B, val) -> Any
Set ESST4BVr_lim.
PowerSystems.set_Xl! — Methodset_Xl!(value::ESST4B, val) -> Any
Set ESST4BXl.
PowerSystems.set_ext! — Methodset_ext!(value::ESST4B, val) -> Any
Set ESST4Bext.
PowerSystems.set_states_types! — Methodset_states_types!(value::ESST4B, val) -> Any
Set ESST4Bstates_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.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 EXAC1E_sat.
PowerSystems.get_Ka — Methodget_Ka(value::EXAC1) -> Float64
Get EXAC1Ka.
PowerSystems.get_Kc — Methodget_Kc(value::EXAC1) -> Float64
Get EXAC1Kc.
PowerSystems.get_Kd — Methodget_Kd(value::EXAC1) -> Float64
Get EXAC1Kd.
PowerSystems.get_Ke — Methodget_Ke(value::EXAC1) -> Float64
Get EXAC1Ke.
PowerSystems.get_Kf — Methodget_Kf(value::EXAC1) -> Float64
Get EXAC1Kf.
PowerSystems.get_Se — Methodget_Se(value::EXAC1) -> Tuple{Float64, Float64}
Get EXAC1Se.
PowerSystems.get_Ta — Methodget_Ta(value::EXAC1) -> Float64
Get EXAC1Ta.
PowerSystems.get_Tb — Methodget_Tb(value::EXAC1) -> Float64
Get EXAC1Tb.
PowerSystems.get_Tc — Methodget_Tc(value::EXAC1) -> Float64
Get EXAC1Tc.
PowerSystems.get_Te — Methodget_Te(value::EXAC1) -> Float64
Get EXAC1Te.
PowerSystems.get_Tf — Methodget_Tf(value::EXAC1) -> Float64
Get EXAC1Tf.
PowerSystems.get_Tr — Methodget_Tr(value::EXAC1) -> Float64
Get EXAC1Tr.
PowerSystems.get_V_ref — Methodget_V_ref(value::EXAC1) -> Float64
Get EXAC1V_ref.
PowerSystems.get_Vr_lim — Methodget_Vr_lim(
value::EXAC1
) -> @NamedTuple{min::Float64, max::Float64}
Get EXAC1Vr_lim.
PowerSystems.get_ext — Methodget_ext(value::EXAC1) -> Dict{String, Any}
Get EXAC1ext.
PowerSystems.get_n_states — Methodget_n_states(value::EXAC1) -> Int64
Get EXAC1n_states.
PowerSystems.get_saturation_coeffs — Methodget_saturation_coeffs(
value::EXAC1
) -> Tuple{Float64, Float64}
Get EXAC1saturation_coeffs.
PowerSystems.get_states — Methodget_states(value::EXAC1) -> Vector{Symbol}
Get EXAC1states.
PowerSystems.get_states_types — Methodget_states_types(value::EXAC1) -> Vector{StateTypes}
Get EXAC1states_types.
PowerSystems.set_E_sat! — Methodset_E_sat!(value::EXAC1, val) -> Any
Set EXAC1E_sat.
PowerSystems.set_Ka! — Methodset_Ka!(value::EXAC1, val) -> Any
Set EXAC1Ka.
PowerSystems.set_Kc! — Methodset_Kc!(value::EXAC1, val) -> Any
Set EXAC1Kc.
PowerSystems.set_Kd! — Methodset_Kd!(value::EXAC1, val) -> Any
Set EXAC1Kd.
PowerSystems.set_Ke! — Methodset_Ke!(value::EXAC1, val) -> Any
Set EXAC1Ke.
PowerSystems.set_Kf! — Methodset_Kf!(value::EXAC1, val) -> Any
Set EXAC1Kf.
PowerSystems.set_Se! — Methodset_Se!(value::EXAC1, val) -> Any
Set EXAC1Se.
PowerSystems.set_Ta! — Methodset_Ta!(value::EXAC1, val) -> Any
Set EXAC1Ta.
PowerSystems.set_Tb! — Methodset_Tb!(value::EXAC1, val) -> Any
Set EXAC1Tb.
PowerSystems.set_Tc! — Methodset_Tc!(value::EXAC1, val) -> Any
Set EXAC1Tc.
PowerSystems.set_Te! — Methodset_Te!(value::EXAC1, val) -> Any
Set EXAC1Te.
PowerSystems.set_Tf! — Methodset_Tf!(value::EXAC1, val) -> Any
Set EXAC1Tf.
PowerSystems.set_Tr! — Methodset_Tr!(value::EXAC1, val) -> Any
Set EXAC1Tr.
PowerSystems.set_V_ref! — Methodset_V_ref!(value::EXAC1, val) -> Any
Set EXAC1V_ref.
PowerSystems.set_Vr_lim! — Methodset_Vr_lim!(value::EXAC1, val) -> Any
Set EXAC1Vr_lim.
PowerSystems.set_ext! — Methodset_ext!(value::EXAC1, val) -> Any
Set EXAC1ext.
PowerSystems.set_saturation_coeffs! — Methodset_saturation_coeffs!(value::EXAC1, val) -> Any
Set EXAC1saturation_coeffs.
PowerSystems.set_states_types! — Methodset_states_types!(value::EXAC1, val) -> Any
Set EXAC1states_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.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 EXAC1AE_sat.
PowerSystems.get_Ka — Methodget_Ka(value::EXAC1A) -> Float64
Get EXAC1AKa.
PowerSystems.get_Kc — Methodget_Kc(value::EXAC1A) -> Float64
Get EXAC1AKc.
PowerSystems.get_Kd — Methodget_Kd(value::EXAC1A) -> Float64
Get EXAC1AKd.
PowerSystems.get_Ke — Methodget_Ke(value::EXAC1A) -> Float64
Get EXAC1AKe.
PowerSystems.get_Kf — Methodget_Kf(value::EXAC1A) -> Float64
Get EXAC1AKf.
PowerSystems.get_Se — Methodget_Se(value::EXAC1A) -> Tuple{Float64, Float64}
Get EXAC1ASe.
PowerSystems.get_Ta — Methodget_Ta(value::EXAC1A) -> Float64
Get EXAC1ATa.
PowerSystems.get_Tb — Methodget_Tb(value::EXAC1A) -> Float64
Get EXAC1ATb.
PowerSystems.get_Tc — Methodget_Tc(value::EXAC1A) -> Float64
Get EXAC1ATc.
PowerSystems.get_Te — Methodget_Te(value::EXAC1A) -> Float64
Get EXAC1ATe.
PowerSystems.get_Tf — Methodget_Tf(value::EXAC1A) -> Float64
Get EXAC1ATf.
PowerSystems.get_Tr — Methodget_Tr(value::EXAC1A) -> Float64
Get EXAC1ATr.
PowerSystems.get_V_ref — Methodget_V_ref(value::EXAC1A) -> Float64
Get EXAC1AV_ref.
PowerSystems.get_Va_lim — Methodget_Va_lim(
value::EXAC1A
) -> @NamedTuple{min::Float64, max::Float64}
Get EXAC1AVa_lim.
PowerSystems.get_Vr_lim — Methodget_Vr_lim(
value::EXAC1A
) -> @NamedTuple{min::Float64, max::Float64}
Get EXAC1AVr_lim.
PowerSystems.get_ext — Methodget_ext(value::EXAC1A) -> Dict{String, Any}
Get EXAC1Aext.
PowerSystems.get_n_states — Methodget_n_states(value::EXAC1A) -> Int64
Get EXAC1An_states.
PowerSystems.get_saturation_coeffs — Methodget_saturation_coeffs(
value::EXAC1A
) -> Tuple{Float64, Float64}
Get EXAC1Asaturation_coeffs.
PowerSystems.get_states — Methodget_states(value::EXAC1A) -> Vector{Symbol}
Get EXAC1Astates.
PowerSystems.get_states_types — Methodget_states_types(value::EXAC1A) -> Vector{StateTypes}
Get EXAC1Astates_types.
PowerSystems.set_E_sat! — Methodset_E_sat!(value::EXAC1A, val) -> Any
Set EXAC1AE_sat.
PowerSystems.set_Ka! — Methodset_Ka!(value::EXAC1A, val) -> Any
Set EXAC1AKa.
PowerSystems.set_Kc! — Methodset_Kc!(value::EXAC1A, val) -> Any
Set EXAC1AKc.
PowerSystems.set_Kd! — Methodset_Kd!(value::EXAC1A, val) -> Any
Set EXAC1AKd.
PowerSystems.set_Ke! — Methodset_Ke!(value::EXAC1A, val) -> Any
Set EXAC1AKe.
PowerSystems.set_Kf! — Methodset_Kf!(value::EXAC1A, val) -> Any
Set EXAC1AKf.
PowerSystems.set_Se! — Methodset_Se!(value::EXAC1A, val) -> Any
Set EXAC1ASe.
PowerSystems.set_Ta! — Methodset_Ta!(value::EXAC1A, val) -> Any
Set EXAC1ATa.
PowerSystems.set_Tb! — Methodset_Tb!(value::EXAC1A, val) -> Any
Set EXAC1ATb.
PowerSystems.set_Tc! — Methodset_Tc!(value::EXAC1A, val) -> Any
Set EXAC1ATc.
PowerSystems.set_Te! — Methodset_Te!(value::EXAC1A, val) -> Any
Set EXAC1ATe.
PowerSystems.set_Tf! — Methodset_Tf!(value::EXAC1A, val) -> Any
Set EXAC1ATf.
PowerSystems.set_Tr! — Methodset_Tr!(value::EXAC1A, val) -> Any
Set EXAC1ATr.
PowerSystems.set_V_ref! — Methodset_V_ref!(value::EXAC1A, val) -> Any
Set EXAC1AV_ref.
PowerSystems.set_Va_lim! — Methodset_Va_lim!(value::EXAC1A, val) -> Any
Set EXAC1AVa_lim.
PowerSystems.set_Vr_lim! — Methodset_Vr_lim!(value::EXAC1A, val) -> Any
Set EXAC1AVr_lim.
PowerSystems.set_ext! — Methodset_ext!(value::EXAC1A, val) -> Any
Set EXAC1Aext.
PowerSystems.set_saturation_coeffs! — Methodset_saturation_coeffs!(value::EXAC1A, val) -> Any
Set EXAC1Asaturation_coeffs.
PowerSystems.set_states_types! — Methodset_states_types!(value::EXAC1A, val) -> Any
Set EXAC1Astates_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.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 EXAC2E_sat.
PowerSystems.get_Ka — Methodget_Ka(value::EXAC2) -> Float64
Get EXAC2Ka.
PowerSystems.get_Kb — Methodget_Kb(value::EXAC2) -> Float64
Get EXAC2Kb.
PowerSystems.get_Kc — Methodget_Kc(value::EXAC2) -> Float64
Get EXAC2Kc.
PowerSystems.get_Kd — Methodget_Kd(value::EXAC2) -> Float64
Get EXAC2Kd.
PowerSystems.get_Ke — Methodget_Ke(value::EXAC2) -> Float64
Get EXAC2Ke.
PowerSystems.get_Kf — Methodget_Kf(value::EXAC2) -> Float64
Get EXAC2Kf.
PowerSystems.get_Kh — Methodget_Kh(value::EXAC2) -> Float64
Get EXAC2Kh.
PowerSystems.get_Kl — Methodget_Kl(value::EXAC2) -> Float64
Get EXAC2Kl.
PowerSystems.get_Se — Methodget_Se(value::EXAC2) -> Tuple{Float64, Float64}
Get EXAC2Se.
PowerSystems.get_Ta — Methodget_Ta(value::EXAC2) -> Float64
Get EXAC2Ta.
PowerSystems.get_Tb — Methodget_Tb(value::EXAC2) -> Float64
Get EXAC2Tb.
PowerSystems.get_Tc — Methodget_Tc(value::EXAC2) -> Float64
Get EXAC2Tc.
PowerSystems.get_Te — Methodget_Te(value::EXAC2) -> Float64
Get EXAC2Te.
PowerSystems.get_Tf — Methodget_Tf(value::EXAC2) -> Float64
Get EXAC2Tf.
PowerSystems.get_Tr — Methodget_Tr(value::EXAC2) -> Float64
Get EXAC2Tr.
PowerSystems.get_V_lr — Methodget_V_lr(value::EXAC2) -> Float64
Get EXAC2V_lr.
PowerSystems.get_V_ref — Methodget_V_ref(value::EXAC2) -> Float64
Get EXAC2V_ref.
PowerSystems.get_Va_lim — Methodget_Va_lim(
value::EXAC2
) -> @NamedTuple{min::Float64, max::Float64}
Get EXAC2Va_lim.
PowerSystems.get_Vr_lim — Methodget_Vr_lim(
value::EXAC2
) -> @NamedTuple{min::Float64, max::Float64}
Get EXAC2Vr_lim.
PowerSystems.get_ext — Methodget_ext(value::EXAC2) -> Dict{String, Any}
Get EXAC2ext.
PowerSystems.get_n_states — Methodget_n_states(value::EXAC2) -> Int64
Get EXAC2n_states.
PowerSystems.get_saturation_coeffs — Methodget_saturation_coeffs(
value::EXAC2
) -> Tuple{Float64, Float64}
Get EXAC2saturation_coeffs.
PowerSystems.get_states — Methodget_states(value::EXAC2) -> Vector{Symbol}
Get EXAC2states.
PowerSystems.get_states_types — Methodget_states_types(value::EXAC2) -> Vector{StateTypes}
Get EXAC2states_types.
PowerSystems.set_E_sat! — Methodset_E_sat!(value::EXAC2, val) -> Any
Set EXAC2E_sat.
PowerSystems.set_Ka! — Methodset_Ka!(value::EXAC2, val) -> Any
Set EXAC2Ka.
PowerSystems.set_Kb! — Methodset_Kb!(value::EXAC2, val) -> Any
Set EXAC2Kb.
PowerSystems.set_Kc! — Methodset_Kc!(value::EXAC2, val) -> Any
Set EXAC2Kc.
PowerSystems.set_Kd! — Methodset_Kd!(value::EXAC2, val) -> Any
Set EXAC2Kd.
PowerSystems.set_Ke! — Methodset_Ke!(value::EXAC2, val) -> Any
Set EXAC2Ke.
PowerSystems.set_Kf! — Methodset_Kf!(value::EXAC2, val) -> Any
Set EXAC2Kf.
PowerSystems.set_Kh! — Methodset_Kh!(value::EXAC2, val) -> Any
Set EXAC2Kh.
PowerSystems.set_Kl! — Methodset_Kl!(value::EXAC2, val) -> Any
Set EXAC2Kl.
PowerSystems.set_Se! — Methodset_Se!(value::EXAC2, val) -> Any
Set EXAC2Se.
PowerSystems.set_Ta! — Methodset_Ta!(value::EXAC2, val) -> Any
Set EXAC2Ta.
PowerSystems.set_Tb! — Methodset_Tb!(value::EXAC2, val) -> Any
Set EXAC2Tb.
PowerSystems.set_Tc! — Methodset_Tc!(value::EXAC2, val) -> Any
Set EXAC2Tc.
PowerSystems.set_Te! — Methodset_Te!(value::EXAC2, val) -> Any
Set EXAC2Te.
PowerSystems.set_Tf! — Methodset_Tf!(value::EXAC2, val) -> Any
Set EXAC2Tf.
PowerSystems.set_Tr! — Methodset_Tr!(value::EXAC2, val) -> Any
Set EXAC2Tr.
PowerSystems.set_V_lr! — Methodset_V_lr!(value::EXAC2, val) -> Any
Set EXAC2V_lr.
PowerSystems.set_V_ref! — Methodset_V_ref!(value::EXAC2, val) -> Any
Set EXAC2V_ref.
PowerSystems.set_Va_lim! — Methodset_Va_lim!(value::EXAC2, val) -> Any
Set EXAC2Va_lim.
PowerSystems.set_Vr_lim! — Methodset_Vr_lim!(value::EXAC2, val) -> Any
Set EXAC2Vr_lim.
PowerSystems.set_ext! — Methodset_ext!(value::EXAC2, val) -> Any
Set EXAC2ext.
PowerSystems.set_saturation_coeffs! — Methodset_saturation_coeffs!(value::EXAC2, val) -> Any
Set EXAC2saturation_coeffs.
PowerSystems.set_states_types! — Methodset_states_types!(value::EXAC2, val) -> Any
Set EXAC2states_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.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 EXPIC1E_sat.
PowerSystems.get_Efd_lim — Methodget_Efd_lim(
value::EXPIC1
) -> @NamedTuple{min::Float64, max::Float64}
Get EXPIC1Efd_lim.
PowerSystems.get_Ka — Methodget_Ka(value::EXPIC1) -> Float64
Get EXPIC1Ka.
PowerSystems.get_Kc — Methodget_Kc(value::EXPIC1) -> Float64
Get EXPIC1Kc.
PowerSystems.get_Ke — Methodget_Ke(value::EXPIC1) -> Float64
Get EXPIC1Ke.
PowerSystems.get_Kf — Methodget_Kf(value::EXPIC1) -> Float64
Get EXPIC1Kf.
PowerSystems.get_Ki — Methodget_Ki(value::EXPIC1) -> Float64
Get EXPIC1Ki.
PowerSystems.get_Kp — Methodget_Kp(value::EXPIC1) -> Float64
Get EXPIC1Kp.
PowerSystems.get_Se — Methodget_Se(value::EXPIC1) -> Tuple{Float64, Float64}
Get EXPIC1Se.
PowerSystems.get_Ta — Methodget_Ta(value::EXPIC1) -> Float64
Get EXPIC1Ta.
PowerSystems.get_Ta_2 — Methodget_Ta_2(value::EXPIC1) -> Float64
Get EXPIC1Ta_2.
PowerSystems.get_Ta_3 — Methodget_Ta_3(value::EXPIC1) -> Float64
Get EXPIC1Ta_3.
PowerSystems.get_Ta_4 — Methodget_Ta_4(value::EXPIC1) -> Float64
Get EXPIC1Ta_4.
PowerSystems.get_Te — Methodget_Te(value::EXPIC1) -> Float64
Get EXPIC1Te.
PowerSystems.get_Tf_1 — Methodget_Tf_1(value::EXPIC1) -> Float64
Get EXPIC1Tf_1.
PowerSystems.get_Tf_2 — Methodget_Tf_2(value::EXPIC1) -> Float64
Get EXPIC1Tf_2.
PowerSystems.get_Tr — Methodget_Tr(value::EXPIC1) -> Float64
Get EXPIC1Tr.
PowerSystems.get_V_ref — Methodget_V_ref(value::EXPIC1) -> Float64
Get EXPIC1V_ref.
PowerSystems.get_Va_lim — Methodget_Va_lim(
value::EXPIC1
) -> @NamedTuple{min::Float64, max::Float64}
Get EXPIC1Va_lim.
PowerSystems.get_Vr_lim — Methodget_Vr_lim(
value::EXPIC1
) -> @NamedTuple{min::Float64, max::Float64}
Get EXPIC1Vr_lim.
PowerSystems.get_ext — Methodget_ext(value::EXPIC1) -> Dict{String, Any}
Get EXPIC1ext.
PowerSystems.get_n_states — Methodget_n_states(value::EXPIC1) -> Int64
Get EXPIC1n_states.
PowerSystems.get_saturation_coeffs — Methodget_saturation_coeffs(
value::EXPIC1
) -> Tuple{Float64, Float64}
Get EXPIC1saturation_coeffs.
PowerSystems.get_states — Methodget_states(value::EXPIC1) -> Vector{Symbol}
Get EXPIC1states.
PowerSystems.get_states_types — Methodget_states_types(value::EXPIC1) -> Vector{StateTypes}
Get EXPIC1states_types.
PowerSystems.set_E_sat! — Methodset_E_sat!(value::EXPIC1, val) -> Any
Set EXPIC1E_sat.
PowerSystems.set_Efd_lim! — Methodset_Efd_lim!(value::EXPIC1, val) -> Any
Set EXPIC1Efd_lim.
PowerSystems.set_Ka! — Methodset_Ka!(value::EXPIC1, val) -> Any
Set EXPIC1Ka.
PowerSystems.set_Kc! — Methodset_Kc!(value::EXPIC1, val) -> Any
Set EXPIC1Kc.
PowerSystems.set_Ke! — Methodset_Ke!(value::EXPIC1, val) -> Any
Set EXPIC1Ke.
PowerSystems.set_Kf! — Methodset_Kf!(value::EXPIC1, val) -> Any
Set EXPIC1Kf.
PowerSystems.set_Ki! — Methodset_Ki!(value::EXPIC1, val) -> Any
Set EXPIC1Ki.
PowerSystems.set_Kp! — Methodset_Kp!(value::EXPIC1, val) -> Any
Set EXPIC1Kp.
PowerSystems.set_Se! — Methodset_Se!(value::EXPIC1, val) -> Any
Set EXPIC1Se.
PowerSystems.set_Ta! — Methodset_Ta!(value::EXPIC1, val) -> Any
Set EXPIC1Ta.
PowerSystems.set_Ta_2! — Methodset_Ta_2!(value::EXPIC1, val) -> Any
Set EXPIC1Ta_2.
PowerSystems.set_Ta_3! — Methodset_Ta_3!(value::EXPIC1, val) -> Any
Set EXPIC1Ta_3.
PowerSystems.set_Ta_4! — Methodset_Ta_4!(value::EXPIC1, val) -> Any
Set EXPIC1Ta_4.
PowerSystems.set_Te! — Methodset_Te!(value::EXPIC1, val) -> Any
Set EXPIC1Te.
PowerSystems.set_Tf_1! — Methodset_Tf_1!(value::EXPIC1, val) -> Any
Set EXPIC1Tf_1.
PowerSystems.set_Tf_2! — Methodset_Tf_2!(value::EXPIC1, val) -> Any
Set EXPIC1Tf_2.
PowerSystems.set_Tr! — Methodset_Tr!(value::EXPIC1, val) -> Any
Set EXPIC1Tr.
PowerSystems.set_V_ref! — Methodset_V_ref!(value::EXPIC1, val) -> Any
Set EXPIC1V_ref.
PowerSystems.set_Va_lim! — Methodset_Va_lim!(value::EXPIC1, val) -> Any
Set EXPIC1Va_lim.
PowerSystems.set_Vr_lim! — Methodset_Vr_lim!(value::EXPIC1, val) -> Any
Set EXPIC1Vr_lim.
PowerSystems.set_ext! — Methodset_ext!(value::EXPIC1, val) -> Any
Set EXPIC1ext.
PowerSystems.set_saturation_coeffs! — Methodset_saturation_coeffs!(value::EXPIC1, val) -> Any
Set EXPIC1saturation_coeffs.
PowerSystems.set_states_types! — Methodset_states_types!(value::EXPIC1, val) -> Any
Set EXPIC1states_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.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 differentialstatesinternal::InfrastructureSystemsInternal: (Do not modify.) PowerSystems.jl internal reference
PowerSystems.get_E_sat — Methodget_E_sat(value::IEEET1) -> Tuple{Float64, Float64}
Get IEEET1E_sat.
PowerSystems.get_Ka — Methodget_Ka(value::IEEET1) -> Float64
Get IEEET1Ka.
PowerSystems.get_Ke — Methodget_Ke(value::IEEET1) -> Float64
Get IEEET1Ke.
PowerSystems.get_Kf — Methodget_Kf(value::IEEET1) -> Float64
Get IEEET1Kf.
PowerSystems.get_Se — Methodget_Se(value::IEEET1) -> Tuple{Float64, Float64}
Get IEEET1Se.
PowerSystems.get_Ta — Methodget_Ta(value::IEEET1) -> Float64
Get IEEET1Ta.
PowerSystems.get_Te — Methodget_Te(value::IEEET1) -> Float64
Get IEEET1Te.
PowerSystems.get_Tf — Methodget_Tf(value::IEEET1) -> Float64
Get IEEET1Tf.
PowerSystems.get_Tr — Methodget_Tr(value::IEEET1) -> Float64
Get IEEET1Tr.
PowerSystems.get_V_ref — Methodget_V_ref(value::IEEET1) -> Float64
Get IEEET1V_ref.
PowerSystems.get_Vr_lim — Methodget_Vr_lim(
value::IEEET1
) -> @NamedTuple{min::Float64, max::Float64}
Get IEEET1Vr_lim.
PowerSystems.get_ext — Methodget_ext(value::IEEET1) -> Dict{String, Any}
Get IEEET1ext.
PowerSystems.get_n_states — Methodget_n_states(value::IEEET1) -> Int64
Get IEEET1n_states.
PowerSystems.get_saturation_coeffs — Methodget_saturation_coeffs(
value::IEEET1
) -> Tuple{Float64, Float64}
Get IEEET1saturation_coeffs.
PowerSystems.get_states — Methodget_states(value::IEEET1) -> Vector{Symbol}
Get IEEET1states.
PowerSystems.get_states_types — Methodget_states_types(value::IEEET1) -> Vector{StateTypes}
Get IEEET1states_types.
PowerSystems.get_switch — Methodget_switch(value::IEEET1) -> Int64
Get IEEET1switch.
PowerSystems.set_E_sat! — Methodset_E_sat!(value::IEEET1, val) -> Any
Set IEEET1E_sat.
PowerSystems.set_Ka! — Methodset_Ka!(value::IEEET1, val) -> Any
Set IEEET1Ka.
PowerSystems.set_Ke! — Methodset_Ke!(value::IEEET1, val) -> Any
Set IEEET1Ke.
PowerSystems.set_Kf! — Methodset_Kf!(value::IEEET1, val) -> Any
Set IEEET1Kf.
PowerSystems.set_Se! — Methodset_Se!(value::IEEET1, val) -> Any
Set IEEET1Se.
PowerSystems.set_Ta! — Methodset_Ta!(value::IEEET1, val) -> Any
Set IEEET1Ta.
PowerSystems.set_Te! — Methodset_Te!(value::IEEET1, val) -> Any
Set IEEET1Te.
PowerSystems.set_Tf! — Methodset_Tf!(value::IEEET1, val) -> Any
Set IEEET1Tf.
PowerSystems.set_Tr! — Methodset_Tr!(value::IEEET1, val) -> Any
Set IEEET1Tr.
PowerSystems.set_V_ref! — Methodset_V_ref!(value::IEEET1, val) -> Any
Set IEEET1V_ref.
PowerSystems.set_Vr_lim! — Methodset_Vr_lim!(value::IEEET1, val) -> Any
Set IEEET1Vr_lim.
PowerSystems.set_ext! — Methodset_ext!(value::IEEET1, val) -> Any
Set IEEET1ext.
PowerSystems.set_saturation_coeffs! — Methodset_saturation_coeffs!(value::IEEET1, val) -> Any
Set IEEET1saturation_coeffs.
PowerSystems.set_states_types! — Methodset_states_types!(value::IEEET1, val) -> Any
Set IEEET1states_types.
PowerSystems.set_switch! — Methodset_switch!(value::IEEET1, val) -> Any
Set IEEET1switch.
EX4VSA
PowerSystems.get_E_lim — Methodget_E_lim(
value::PowerSystems.EX4VSA
) -> @NamedTuple{min::Float64, max::Float64}
Get EX4VSAE_lim.
PowerSystems.get_G — Methodget_G(value::PowerSystems.EX4VSA) -> Float64
Get EX4VSAG.
PowerSystems.get_Iflim — Methodget_Iflim(value::PowerSystems.EX4VSA) -> Float64
Get EX4VSAIflim.
PowerSystems.get_K1 — Methodget_K1(value::PowerSystems.EX4VSA) -> Float64
Get EX4VSAK1.
PowerSystems.get_K2 — Methodget_K2(value::PowerSystems.EX4VSA) -> Float64
Get EX4VSAK2.
PowerSystems.get_Oel_lim — Methodget_Oel_lim(
value::PowerSystems.EX4VSA
) -> @NamedTuple{min::Float64, max::Float64}
Get EX4VSAOel_lim.
PowerSystems.get_Spar — Methodget_Spar(value::PowerSystems.EX4VSA) -> Float64
Get EX4VSASpar.
PowerSystems.get_Ta — Methodget_Ta(value::PowerSystems.EX4VSA) -> Float64
Get EX4VSATa.
PowerSystems.get_Tb — Methodget_Tb(value::PowerSystems.EX4VSA) -> Float64
Get EX4VSATb.
PowerSystems.get_Te — Methodget_Te(value::PowerSystems.EX4VSA) -> Float64
Get EX4VSATe.
PowerSystems.get_V_ref — Methodget_V_ref(value::PowerSystems.EX4VSA) -> Float64
Get EX4VSAV_ref.
PowerSystems.get_d — Methodget_d(value::PowerSystems.EX4VSA) -> Float64
Get EX4VSAd.
PowerSystems.get_ext — Methodget_ext(value::PowerSystems.EX4VSA) -> Dict{String, Any}
Get EX4VSAext.
PowerSystems.get_f — Methodget_f(value::PowerSystems.EX4VSA) -> Float64
Get EX4VSAf.
PowerSystems.get_n_states — Methodget_n_states(value::PowerSystems.EX4VSA) -> Int64
Get EX4VSAn_states.
PowerSystems.get_states — Methodget_states(value::PowerSystems.EX4VSA) -> Vector{Symbol}
Get EX4VSAstates.
PowerSystems.set_E_lim! — Methodset_E_lim!(value::PowerSystems.EX4VSA, val) -> Any
Set EX4VSAE_lim.
PowerSystems.set_G! — Methodset_G!(value::PowerSystems.EX4VSA, val) -> Any
Set EX4VSAG.
PowerSystems.set_Iflim! — Methodset_Iflim!(value::PowerSystems.EX4VSA, val) -> Any
Set EX4VSAIflim.
PowerSystems.set_K1! — Methodset_K1!(value::PowerSystems.EX4VSA, val) -> Any
Set EX4VSAK1.
PowerSystems.set_K2! — Methodset_K2!(value::PowerSystems.EX4VSA, val) -> Any
Set EX4VSAK2.
PowerSystems.set_Oel_lim! — Methodset_Oel_lim!(value::PowerSystems.EX4VSA, val) -> Any
Set EX4VSAOel_lim.
PowerSystems.set_Spar! — Methodset_Spar!(value::PowerSystems.EX4VSA, val) -> Any
Set EX4VSASpar.
PowerSystems.set_Ta! — Methodset_Ta!(value::PowerSystems.EX4VSA, val) -> Any
Set EX4VSATa.
PowerSystems.set_Tb! — Methodset_Tb!(value::PowerSystems.EX4VSA, val) -> Any
Set EX4VSATb.
PowerSystems.set_Te! — Methodset_Te!(value::PowerSystems.EX4VSA, val) -> Any
Set EX4VSATe.
PowerSystems.set_V_ref! — Methodset_V_ref!(value::PowerSystems.EX4VSA, val) -> Any
Set EX4VSAV_ref.
PowerSystems.set_d! — Methodset_d!(value::PowerSystems.EX4VSA, val) -> Any
Set EX4VSAd.
PowerSystems.set_ext! — Methodset_ext!(value::PowerSystems.EX4VSA, val) -> Any
Set EX4VSAext.
PowerSystems.set_f! — Methodset_f!(value::PowerSystems.EX4VSA, val) -> Any
Set EX4VSAf.
EXST1
PowerSystems.get_Ka — Methodget_Ka(value::PowerSystems.EXST1) -> Float64
Get EXST1Ka.
PowerSystems.get_Kc — Methodget_Kc(value::PowerSystems.EXST1) -> Float64
Get EXST1Kc.
PowerSystems.get_Kf — Methodget_Kf(value::PowerSystems.EXST1) -> Float64
Get EXST1Kf.
PowerSystems.get_Ta — Methodget_Ta(value::PowerSystems.EXST1) -> Float64
Get EXST1Ta.
PowerSystems.get_Tb — Methodget_Tb(value::PowerSystems.EXST1) -> Float64
Get EXST1Tb.
PowerSystems.get_Tc — Methodget_Tc(value::PowerSystems.EXST1) -> Float64
Get EXST1Tc.
PowerSystems.get_Tf — Methodget_Tf(value::PowerSystems.EXST1) -> Float64
Get EXST1Tf.
PowerSystems.get_Tr — Methodget_Tr(value::PowerSystems.EXST1) -> Float64
Get EXST1Tr.
PowerSystems.get_V_ref — Methodget_V_ref(value::PowerSystems.EXST1) -> Float64
Get EXST1V_ref.
PowerSystems.get_Vi_lim — Methodget_Vi_lim(
value::PowerSystems.EXST1
) -> @NamedTuple{min::Float64, max::Float64}
Get EXST1Vi_lim.
PowerSystems.get_Vr_lim — Methodget_Vr_lim(
value::PowerSystems.EXST1
) -> @NamedTuple{min::Float64, max::Float64}
Get EXST1Vr_lim.
PowerSystems.get_ext — Methodget_ext(value::PowerSystems.EXST1) -> Dict{String, Any}
Get EXST1ext.
PowerSystems.get_n_states — Methodget_n_states(value::PowerSystems.EXST1) -> Int64
Get EXST1n_states.
PowerSystems.get_states — Methodget_states(value::PowerSystems.EXST1) -> Vector{Symbol}
Get EXST1states.
PowerSystems.set_Ka! — Methodset_Ka!(value::PowerSystems.EXST1, val) -> Any
Set EXST1Ka.
PowerSystems.set_Kc! — Methodset_Kc!(value::PowerSystems.EXST1, val) -> Any
Set EXST1Kc.
PowerSystems.set_Kf! — Methodset_Kf!(value::PowerSystems.EXST1, val) -> Any
Set EXST1Kf.
PowerSystems.set_Ta! — Methodset_Ta!(value::PowerSystems.EXST1, val) -> Any
Set EXST1Ta.
PowerSystems.set_Tb! — Methodset_Tb!(value::PowerSystems.EXST1, val) -> Any
Set EXST1Tb.
PowerSystems.set_Tc! — Methodset_Tc!(value::PowerSystems.EXST1, val) -> Any
Set EXST1Tc.
PowerSystems.set_Tf! — Methodset_Tf!(value::PowerSystems.EXST1, val) -> Any
Set EXST1Tf.
PowerSystems.set_Tr! — Methodset_Tr!(value::PowerSystems.EXST1, val) -> Any
Set EXST1Tr.
PowerSystems.set_V_ref! — Methodset_V_ref!(value::PowerSystems.EXST1, val) -> Any
Set EXST1V_ref.
PowerSystems.set_Vi_lim! — Methodset_Vi_lim!(value::PowerSystems.EXST1, val) -> Any
Set EXST1Vi_lim.
PowerSystems.set_Vr_lim! — Methodset_Vr_lim!(value::PowerSystems.EXST1, val) -> Any
Set EXST1Vr_lim.
PowerSystems.set_ext! — Methodset_ext!(value::PowerSystems.EXST1, val) -> Any
Set EXST1ext.
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.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 differentialstatesinternal::InfrastructureSystemsInternal: (Do not modify.) PowerSystems.jl internal reference
PowerSystems.get_Efd_lim — Methodget_Efd_lim(
value::SCRX
) -> @NamedTuple{min::Float64, max::Float64}
Get SCRXEfd_lim.
PowerSystems.get_K — Methodget_K(value::SCRX) -> Float64
Get SCRXK.
PowerSystems.get_Ta_Tb — Methodget_Ta_Tb(value::SCRX) -> Float64
Get SCRXTa_Tb.
PowerSystems.get_Tb — Methodget_Tb(value::SCRX) -> Float64
Get SCRXTb.
PowerSystems.get_Te — Methodget_Te(value::SCRX) -> Float64
Get SCRXTe.
PowerSystems.get_V_ref — Methodget_V_ref(value::SCRX) -> Float64
Get SCRXV_ref.
PowerSystems.get_ext — Methodget_ext(value::SCRX) -> Dict{String, Any}
Get SCRXext.
PowerSystems.get_n_states — Methodget_n_states(value::SCRX) -> Int64
Get SCRXn_states.
PowerSystems.get_rc_rfd — Methodget_rc_rfd(value::SCRX) -> Float64
Get SCRXrc_rfd.
PowerSystems.get_states — Methodget_states(value::SCRX) -> Vector{Symbol}
Get SCRXstates.
PowerSystems.get_states_types — Methodget_states_types(value::SCRX) -> Vector{StateTypes}
Get SCRXstates_types.
PowerSystems.get_switch — Methodget_switch(value::SCRX) -> Int64
Get SCRXswitch.
PowerSystems.set_Efd_lim! — Methodset_Efd_lim!(value::SCRX, val) -> Any
Set SCRXEfd_lim.
PowerSystems.set_K! — Methodset_K!(value::SCRX, val) -> Any
Set SCRXK.
PowerSystems.set_Ta_Tb! — Methodset_Ta_Tb!(value::SCRX, val) -> Any
Set SCRXTa_Tb.
PowerSystems.set_Tb! — Methodset_Tb!(value::SCRX, val) -> Any
Set SCRXTb.
PowerSystems.set_Te! — Methodset_Te!(value::SCRX, val) -> Any
Set SCRXTe.
PowerSystems.set_V_ref! — Methodset_V_ref!(value::SCRX, val) -> Any
Set SCRXV_ref.
PowerSystems.set_ext! — Methodset_ext!(value::SCRX, val) -> Any
Set SCRXext.
PowerSystems.set_rc_rfd! — Methodset_rc_rfd!(value::SCRX, val) -> Any
Set SCRXrc_rfd.
PowerSystems.set_states_types! — Methodset_states_types!(value::SCRX, val) -> Any
Set SCRXstates_types.
PowerSystems.set_switch! — Methodset_switch!(value::SCRX, val) -> Any
Set SCRXswitch.
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.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 differentialstatesinternal::InfrastructureSystemsInternal: (Do not modify.) PowerSystems.jl internal reference
PowerSystems.get_K — Methodget_K(value::SEXS) -> Float64
Get SEXSK.
PowerSystems.get_Ta_Tb — Methodget_Ta_Tb(value::SEXS) -> Float64
Get SEXSTa_Tb.
PowerSystems.get_Tb — Methodget_Tb(value::SEXS) -> Float64
Get SEXSTb.
PowerSystems.get_Te — Methodget_Te(value::SEXS) -> Float64
Get SEXSTe.
PowerSystems.get_V_lim — Methodget_V_lim(
value::SEXS
) -> @NamedTuple{min::Float64, max::Float64}
Get SEXSV_lim.
PowerSystems.get_V_ref — Methodget_V_ref(value::SEXS) -> Float64
Get SEXSV_ref.
PowerSystems.get_ext — Methodget_ext(value::SEXS) -> Dict{String, Any}
Get SEXSext.
PowerSystems.get_n_states — Methodget_n_states(value::SEXS) -> Int64
Get SEXSn_states.
PowerSystems.get_states — Methodget_states(value::SEXS) -> Vector{Symbol}
Get SEXSstates.
PowerSystems.get_states_types — Methodget_states_types(value::SEXS) -> Vector{StateTypes}
Get SEXSstates_types.
PowerSystems.set_K! — Methodset_K!(value::SEXS, val) -> Any
Set SEXSK.
PowerSystems.set_Ta_Tb! — Methodset_Ta_Tb!(value::SEXS, val) -> Any
Set SEXSTa_Tb.
PowerSystems.set_Tb! — Methodset_Tb!(value::SEXS, val) -> Any
Set SEXSTb.
PowerSystems.set_Te! — Methodset_Te!(value::SEXS, val) -> Any
Set SEXSTe.
PowerSystems.set_V_lim! — Methodset_V_lim!(value::SEXS, val) -> Any
Set SEXSV_lim.
PowerSystems.set_V_ref! — Methodset_V_ref!(value::SEXS, val) -> Any
Set SEXSV_ref.
PowerSystems.set_ext! — Methodset_ext!(value::SEXS, val) -> Any
Set SEXSext.
PowerSystems.set_states_types! — Methodset_states_types!(value::SEXS, val) -> Any
Set SEXSstates_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.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 ST6BI_lr.
PowerSystems.get_K_ci — Methodget_K_ci(value::ST6B) -> Float64
Get ST6BK_ci.
PowerSystems.get_K_da — Methodget_K_da(value::ST6B) -> Float64
Get ST6BK_da.
PowerSystems.get_K_ff — Methodget_K_ff(value::ST6B) -> Float64
Get ST6BK_ff.
PowerSystems.get_K_ia — Methodget_K_ia(value::ST6B) -> Float64
Get ST6BK_ia.
PowerSystems.get_K_lr — Methodget_K_lr(value::ST6B) -> Float64
Get ST6BK_lr.
PowerSystems.get_K_m — Methodget_K_m(value::ST6B) -> Float64
Get ST6BK_m.
PowerSystems.get_K_pa — Methodget_K_pa(value::ST6B) -> Float64
Get ST6BK_pa.
PowerSystems.get_Kg — Methodget_Kg(value::ST6B) -> Float64
Get ST6BKg.
PowerSystems.get_OEL_Flag — Methodget_OEL_Flag(value::ST6B) -> Int64
Get ST6BOEL_Flag.
PowerSystems.get_T_da — Methodget_T_da(value::ST6B) -> Float64
Get ST6BT_da.
PowerSystems.get_Tg — Methodget_Tg(value::ST6B) -> Float64
Get ST6BTg.
PowerSystems.get_Tr — Methodget_Tr(value::ST6B) -> Float64
Get ST6BTr.
PowerSystems.get_V_ref — Methodget_V_ref(value::ST6B) -> Float64
Get ST6BV_ref.
PowerSystems.get_Va_lim — Methodget_Va_lim(
value::ST6B
) -> @NamedTuple{min::Float64, max::Float64}
Get ST6BVa_lim.
PowerSystems.get_Vr_lim — Methodget_Vr_lim(
value::ST6B
) -> @NamedTuple{min::Float64, max::Float64}
Get ST6BVr_lim.
PowerSystems.get_ext — Methodget_ext(value::ST6B) -> Dict{String, Any}
Get ST6Bext.
PowerSystems.get_n_states — Methodget_n_states(value::ST6B) -> Int64
Get ST6Bn_states.
PowerSystems.get_states — Methodget_states(value::ST6B) -> Vector{Symbol}
Get ST6Bstates.
PowerSystems.get_states_types — Methodget_states_types(value::ST6B) -> Vector{StateTypes}
Get ST6Bstates_types.
PowerSystems.set_I_lr! — Methodset_I_lr!(value::ST6B, val) -> Any
Set ST6BI_lr.
PowerSystems.set_K_ci! — Methodset_K_ci!(value::ST6B, val) -> Any
Set ST6BK_ci.
PowerSystems.set_K_da! — Methodset_K_da!(value::ST6B, val) -> Any
Set ST6BK_da.
PowerSystems.set_K_ff! — Methodset_K_ff!(value::ST6B, val) -> Any
Set ST6BK_ff.
PowerSystems.set_K_ia! — Methodset_K_ia!(value::ST6B, val) -> Any
Set ST6BK_ia.
PowerSystems.set_K_lr! — Methodset_K_lr!(value::ST6B, val) -> Any
Set ST6BK_lr.
PowerSystems.set_K_m! — Methodset_K_m!(value::ST6B, val) -> Any
Set ST6BK_m.
PowerSystems.set_K_pa! — Methodset_K_pa!(value::ST6B, val) -> Any
Set ST6BK_pa.
PowerSystems.set_Kg! — Methodset_Kg!(value::ST6B, val) -> Any
Set ST6BKg.
PowerSystems.set_OEL_Flag! — Methodset_OEL_Flag!(value::ST6B, val) -> Any
Set ST6BOEL_Flag.
PowerSystems.set_T_da! — Methodset_T_da!(value::ST6B, val) -> Any
Set ST6BT_da.
PowerSystems.set_Tg! — Methodset_Tg!(value::ST6B, val) -> Any
Set ST6BTg.
PowerSystems.set_Tr! — Methodset_Tr!(value::ST6B, val) -> Any
Set ST6BTr.
PowerSystems.set_V_ref! — Methodset_V_ref!(value::ST6B, val) -> Any
Set ST6BV_ref.
PowerSystems.set_Va_lim! — Methodset_Va_lim!(value::ST6B, val) -> Any
Set ST6BVa_lim.
PowerSystems.set_Vr_lim! — Methodset_Vr_lim!(value::ST6B, val) -> Any
Set ST6BVr_lim.
PowerSystems.set_ext! — Methodset_ext!(value::ST6B, val) -> Any
Set ST6Bext.
PowerSystems.set_states_types! — Methodset_states_types!(value::ST6B, val) -> Any
Set ST6Bstates_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.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 ST8CIfd_ref.
PowerSystems.get_K_a — Methodget_K_a(value::ST8C) -> Float64
Get ST8CK_a.
PowerSystems.get_K_c1 — Methodget_K_c1(value::ST8C) -> Float64
Get ST8CK_c1.
PowerSystems.get_K_c2 — Methodget_K_c2(value::ST8C) -> Float64
Get ST8CK_c2.
PowerSystems.get_K_f — Methodget_K_f(value::ST8C) -> Float64
Get ST8CK_f.
PowerSystems.get_K_i1 — Methodget_K_i1(value::ST8C) -> Float64
Get ST8CK_i1.
PowerSystems.get_K_i2 — Methodget_K_i2(value::ST8C) -> Float64
Get ST8CK_i2.
PowerSystems.get_K_ia — Methodget_K_ia(value::ST8C) -> Float64
Get ST8CK_ia.
PowerSystems.get_K_ir — Methodget_K_ir(value::ST8C) -> Float64
Get ST8CK_ir.
PowerSystems.get_K_p — Methodget_K_p(value::ST8C) -> Float64
Get ST8CK_p.
PowerSystems.get_K_pa — Methodget_K_pa(value::ST8C) -> Float64
Get ST8CK_pa.
PowerSystems.get_K_pr — Methodget_K_pr(value::ST8C) -> Float64
Get ST8CK_pr.
PowerSystems.get_OEL_Flag — Methodget_OEL_Flag(value::ST8C) -> Int64
Get ST8COEL_Flag.
PowerSystems.get_SCL_Flag — Methodget_SCL_Flag(value::ST8C) -> Int64
Get ST8CSCL_Flag.
PowerSystems.get_SW1_Flag — Methodget_SW1_Flag(value::ST8C) -> Int64
Get ST8CSW1_Flag.
PowerSystems.get_T_a — Methodget_T_a(value::ST8C) -> Float64
Get ST8CT_a.
PowerSystems.get_T_f — Methodget_T_f(value::ST8C) -> Float64
Get ST8CT_f.
PowerSystems.get_Tr — Methodget_Tr(value::ST8C) -> Float64
Get ST8CTr.
PowerSystems.get_UEL_Flag — Methodget_UEL_Flag(value::ST8C) -> Int64
Get ST8CUEL_Flag.
PowerSystems.get_VB1_max — Methodget_VB1_max(value::ST8C) -> Float64
Get ST8CVB1_max.
PowerSystems.get_VB2_max — Methodget_VB2_max(value::ST8C) -> Float64
Get ST8CVB2_max.
PowerSystems.get_V_ref — Methodget_V_ref(value::ST8C) -> Float64
Get ST8CV_ref.
PowerSystems.get_Va_lim — Methodget_Va_lim(
value::ST8C
) -> @NamedTuple{min::Float64, max::Float64}
Get ST8CVa_lim.
PowerSystems.get_Vpi_lim — Methodget_Vpi_lim(
value::ST8C
) -> @NamedTuple{min::Float64, max::Float64}
Get ST8CVpi_lim.
PowerSystems.get_Vr_lim — Methodget_Vr_lim(
value::ST8C
) -> @NamedTuple{min::Float64, max::Float64}
Get ST8CVr_lim.
PowerSystems.get_X_l — Methodget_X_l(value::ST8C) -> Float64
Get ST8CX_l.
PowerSystems.get_ext — Methodget_ext(value::ST8C) -> Dict{String, Any}
Get ST8Cext.
PowerSystems.get_n_states — Methodget_n_states(value::ST8C) -> Int64
Get ST8Cn_states.
PowerSystems.get_states — Methodget_states(value::ST8C) -> Vector{Symbol}
Get ST8Cstates.
PowerSystems.get_states_types — Methodget_states_types(value::ST8C) -> Vector{StateTypes}
Get ST8Cstates_types.
PowerSystems.get_θ_p — Methodget_θ_p(value::ST8C) -> Float64
Get ST8Cθ_p.
PowerSystems.set_Ifd_ref! — Methodset_Ifd_ref!(value::ST8C, val) -> Any
Set ST8CIfd_ref.
PowerSystems.set_K_a! — Methodset_K_a!(value::ST8C, val) -> Any
Set ST8CK_a.
PowerSystems.set_K_c1! — Methodset_K_c1!(value::ST8C, val) -> Any
Set ST8CK_c1.
PowerSystems.set_K_c2! — Methodset_K_c2!(value::ST8C, val) -> Any
Set ST8CK_c2.
PowerSystems.set_K_f! — Methodset_K_f!(value::ST8C, val) -> Any
Set ST8CK_f.
PowerSystems.set_K_i1! — Methodset_K_i1!(value::ST8C, val) -> Any
Set ST8CK_i1.
PowerSystems.set_K_i2! — Methodset_K_i2!(value::ST8C, val) -> Any
Set ST8CK_i2.
PowerSystems.set_K_ia! — Methodset_K_ia!(value::ST8C, val) -> Any
Set ST8CK_ia.
PowerSystems.set_K_ir! — Methodset_K_ir!(value::ST8C, val) -> Any
Set ST8CK_ir.
PowerSystems.set_K_p! — Methodset_K_p!(value::ST8C, val) -> Any
Set ST8CK_p.
PowerSystems.set_K_pa! — Methodset_K_pa!(value::ST8C, val) -> Any
Set ST8CK_pa.
PowerSystems.set_K_pr! — Methodset_K_pr!(value::ST8C, val) -> Any
Set ST8CK_pr.
PowerSystems.set_OEL_Flag! — Methodset_OEL_Flag!(value::ST8C, val) -> Any
Set ST8COEL_Flag.
PowerSystems.set_SCL_Flag! — Methodset_SCL_Flag!(value::ST8C, val) -> Any
Set ST8CSCL_Flag.
PowerSystems.set_SW1_Flag! — Methodset_SW1_Flag!(value::ST8C, val) -> Any
Set ST8CSW1_Flag.
PowerSystems.set_T_a! — Methodset_T_a!(value::ST8C, val) -> Any
Set ST8CT_a.
PowerSystems.set_T_f! — Methodset_T_f!(value::ST8C, val) -> Any
Set ST8CT_f.
PowerSystems.set_Tr! — Methodset_Tr!(value::ST8C, val) -> Any
Set ST8CTr.
PowerSystems.set_UEL_Flag! — Methodset_UEL_Flag!(value::ST8C, val) -> Any
Set ST8CUEL_Flag.
PowerSystems.set_VB1_max! — Methodset_VB1_max!(value::ST8C, val) -> Any
Set ST8CVB1_max.
PowerSystems.set_VB2_max! — Methodset_VB2_max!(value::ST8C, val) -> Any
Set ST8CVB2_max.
PowerSystems.set_V_ref! — Methodset_V_ref!(value::ST8C, val) -> Any
Set ST8CV_ref.
PowerSystems.set_Va_lim! — Methodset_Va_lim!(value::ST8C, val) -> Any
Set ST8CVa_lim.
PowerSystems.set_Vpi_lim! — Methodset_Vpi_lim!(value::ST8C, val) -> Any
Set ST8CVpi_lim.
PowerSystems.set_Vr_lim! — Methodset_Vr_lim!(value::ST8C, val) -> Any
Set ST8CVr_lim.
PowerSystems.set_X_l! — Methodset_X_l!(value::ST8C, val) -> Any
Set ST8CX_l.
PowerSystems.set_ext! — Methodset_ext!(value::ST8C, val) -> Any
Set ST8Cext.
PowerSystems.set_states_types! — Methodset_states_types!(value::ST8C, val) -> Any
Set ST8Cstates_types.
PowerSystems.set_θ_p! — Methodset_θ_p!(value::ST8C, val) -> Any
Set ST8Cθ_p.