All Classes Interface Summary Class Summary Enum Summary
Class |
Description |
AbstractAsymmetricalClosedBranchCoupledFlowEquationTerm |
|
AbstractClosedBranchAcFlowEquationTerm |
|
AbstractClosedBranchDcFlowEquationTerm |
|
AbstractEdgeModification<V,E> |
|
AbstractElement |
|
AbstractElementEquationTerm<T extends LfElement,V extends Enum<V> & Quantity,E extends Enum<E> & Quantity> |
|
AbstractEquationSystemUpdater<V extends Enum<V> & Quantity,E extends Enum<E> & Quantity> |
|
AbstractEquationTerm<V extends Enum<V> & Quantity,E extends Enum<E> & Quantity> |
|
AbstractGraphConnectivity<V,E> |
|
AbstractHvdcAcEmulationFlowEquationTerm |
|
AbstractImpedantLfBranch |
|
AbstractLfBranch |
|
AbstractLfBus |
|
AbstractLfGenerator |
|
AbstractLfNetworkListener |
|
AbstractLfNetworkLoaderPostProcessor |
|
AbstractLfShunt |
|
AbstractLoadFlowContext<V extends Enum<V> & Quantity,E extends Enum<E> & Quantity,P extends AbstractLoadFlowParameters> |
|
AbstractLoadFlowParameters |
|
AbstractLoadFlowResult |
|
AbstractNamedEquationTerm<V extends Enum<V> & Quantity,E extends Enum<E> & Quantity> |
|
AbstractNetworkResult |
|
AbstractOuterLoopContext<V extends Enum<V> & Quantity,E extends Enum<E> & Quantity,P extends AbstractLoadFlowParameters,C extends LoadFlowContext<V,E,P>> |
|
AbstractPhaseControlOuterLoop |
|
AbstractPropertyBag |
|
AbstractSecurityAnalysis<V extends Enum<V> & Quantity,E extends Enum<E> & Quantity,P extends AbstractLoadFlowParameters,C extends LoadFlowContext<V,E,P>> |
|
AbstractSensitivityAnalysis<V extends Enum<V> & Quantity,E extends Enum<E> & Quantity> |
|
AbstractSensitivityAnalysis.SensitivityFactorGroupList<V extends Enum<V> & Quantity,E extends Enum<E> & Quantity> |
|
AbstractShuntCompensatorEquationTerm |
|
AbstractShuntFortescueCurrentEquationTerm |
|
AbstractShuntFortescueEquationTerm |
|
AbstractSlackBusSelector |
|
AbstractTransformerVoltageControlOuterLoop |
|
AbstractVector<V extends Enum<V> & Quantity,E extends Enum<E> & Quantity> |
|
AcEquationSystemCreationParameters |
|
AcEquationSystemCreator |
|
AcEquationSystemUpdater |
|
AcEquationType |
|
AcLoadFlowContext |
|
AcloadFlowEngine |
|
AcLoadFlowFromCache |
|
AcLoadFlowParameters |
|
AcLoadFlowResult |
|
AcOuterLoop |
|
AcOuterLoopConfig |
|
AcOuterLoopContext |
|
AcSecurityAnalysis |
|
AcSensitivityAnalysis |
|
AcTargetVector |
|
ActivePowerDistribution |
|
ActivePowerDistribution.Result |
|
ActivePowerDistribution.Step |
|
AcVariableType |
|
AdmittanceShift |
|
AllowedDirection |
|
AsymmetricalAcEquationSystemCreator |
|
AsymmetricalClosedBranchCoupledCurrentEquationTerm |
We define T(i,j,g,h) = rho_i * rho_j * exp(j(a_j-a_i)) * y*_ij_gh * V_hj
where i,j are line's ends i,j included in {1,2}
where g,h are fortescue sequences g,h included in {z, p, n} = {0,1,2} (z = zero = 0, p = positive = 1, n = negative = 2)
Expanded formula :
T(i,j,g,h) = rho_i * rho_j * V_hj * yx_ij_gh * cos(a_j - a_i + th_hj)
- rho_i * rho_j * V_hj * yy_ij_gh * sin(a_j - a_i + th_hj)
+j( rho_i * rho_j * V_hj * yx_ij_gh * sin(a_j - a_i + th_hj)
+ rho_i * rho_j * V_hj * yy_ij_gh * cos(a_j - a_i + th_hj) )
By construction we have :
[ y_11_zz y_11_zp y_11_zn y_12_zz y_12_zp y_12_zn ]
[ y_11_pz y_11_pp y_11_pn y_12_pz y_12_pp y_12_pn ]
[Yzpn] = [ y_11_nz y_11_np y_11_nn y_12_nz y_12_np y_12_nn ]
[ y_21_zz y_21_zp y_21_zn y_22_zz y_22_zp y_22_zn ]
[ y_21_pz y_21_pp y_21_pn y_22_pz y_22_pp y_22_pn ]
[ y_21_nz y_21_np y_21_nn y_22_nz y_22_np y_22_nn ]
|
AsymmetricalClosedBranchCoupledPowerEquationTerm |
We define T(i,j,g,h) = rho_i * rho_j * exp(j(a_i-a_j)) * y*_ij_gh * V_gi * V*_hj
where i,j are line's ends i,j included in {1,2}
where g,h are fortescue sequences g,h included in {z,p,n} = {0,1,2}
Expanded formula :
T(i,j,g,h) = rho_i * rho_j * V_gi * V_hj * yx_ij_gh * cos(a_i - a_j + th_gi - th_hj)
- rho_i * rho_j * V_gi * V_hj * yy_ij_gh * sin(a_i - a_j + th_gi - th_hj)
-j( rho_i * rho_j * V_gi * V_hj * yx_ij_gh * sin(a_i - a_j + th_gi - th_hj)
+ rho_i * rho_j * V_gi * V_hj * yy_ij_gh * cos(a_i - a_j + th_gi - th_hj) )
By construction we have :
[ y_11_zz y_11_zp y_11_zn y_12_zz y_12_zp y_12_zn ]
[ y_11_pz y_11_pp y_11_pn y_12_pz y_12_pp y_12_pn ]
[Yzpn] = [ y_11_nz y_11_np y_11_nn y_12_nz y_12_np y_12_nn ]
[ y_21_zz y_21_zp y_21_zn y_22_zz y_22_zp y_22_zn ]
[ y_21_pz y_21_pp y_21_pn y_22_pz y_22_pp y_22_pn ]
[ y_21_nz y_21_np y_21_nn y_22_nz y_22_np y_22_nn ]
|
BranchState |
|
BusDcState |
|
BusState |
|
ClosedBranchI1xFlowEquationTerm |
|
ClosedBranchI1yFlowEquationTerm |
|
ClosedBranchI2xFlowEquationTerm |
|
ClosedBranchI2yFlowEquationTerm |
|
ClosedBranchSide1ActiveFlowEquationTerm |
|
ClosedBranchSide1CurrentMagnitudeEquationTerm |
|
ClosedBranchSide1DcFlowEquationTerm |
|
ClosedBranchSide1ReactiveFlowEquationTerm |
|
ClosedBranchSide2ActiveFlowEquationTerm |
|
ClosedBranchSide2CurrentMagnitudeEquationTerm |
|
ClosedBranchSide2DcFlowEquationTerm |
|
ClosedBranchSide2ReactiveFlowEquationTerm |
|
ComplexPart |
|
ContingencyTripping |
|
Control |
|
ControlledSide |
|
DcEquationSystemCreationParameters |
|
DcEquationSystemCreator |
|
DcEquationSystemUpdater |
|
DcEquationType |
|
DcLoadFlowContext |
|
DcLoadFlowEngine |
|
DcLoadFlowParameters |
|
DcLoadFlowResult |
|
DcSecurityAnalysis |
|
DcSensitivityAnalysis |
|
DcTargetVector |
|
DcValueVoltageInitializer |
|
DcVariableType |
|
DebugUtil |
|
DefaultAcOuterLoopConfig |
|
DefaultNewtonRaphsonStoppingCriteria |
|
Direction |
|
DiscreteVoltageControl<T extends LfElement> |
|
DistributedSlackOuterLoop |
|
EdgeAdd<V,E> |
|
EdgeRemove<V,E> |
|
ElementState<T extends LfElement> |
|
ElementType |
|
Equation<V extends Enum<V> & Quantity,E extends Enum<E> & Quantity> |
|
Equation.DerHandler<V extends Enum<V> & Quantity> |
|
EquationEventType |
|
EquationSystem<V extends Enum<V> & Quantity,E extends Enum<E> & Quantity> |
|
EquationSystemIndex<V extends Enum<V> & Quantity,E extends Enum<E> & Quantity> |
|
EquationSystemIndexListener<V extends Enum<V> & Quantity,E extends Enum<E> & Quantity> |
|
EquationSystemIndexListener.ChangeType |
|
EquationSystemListener<V extends Enum<V> & Quantity,E extends Enum<E> & Quantity> |
|
EquationSystemPostProcessor |
|
EquationTerm<V extends Enum<V> & Quantity,E extends Enum<E> & Quantity> |
An equation term, i.e part of the equation sum.
|
EquationTerm.MultiplyByScalarEquationTerm<V extends Enum<V> & Quantity,E extends Enum<E> & Quantity> |
|
EquationTermEventType |
|
EquationVector<V extends Enum<V> & Quantity,E extends Enum<E> & Quantity> |
|
Evaluable |
|
EvaluableConstants |
|
EvenShiloachGraphDecrementalConnectivity<V,E> |
Implementing the Even-Shiloach algorithm (see https://dl.acm.org/doi/10.1145/322234.322235)
Due to time computation optimizations, this current implementation is only for graphs which initially have ONLY ONE
connected component.
|
EvenShiloachGraphDecrementalConnectivityFactory<V,E> |
|
FirstSlackBusSelector |
|
Fortescue |
|
Fortescue.SequenceType |
|
FullVoltageInitializer |
|
GenerationActivePowerDistributionStep |
|
GenerationActivePowerDistributionStep.ParticipationType |
|
GeneratorVoltageControl |
|
GraphConnectivity<V,E> |
Interface for incremental and decremental connectivity computations, through a mechanism which records the
topological changes which later need to be undone.
|
GraphConnectivityFactory<V,E> |
|
GraphModification<V,E> |
|
GraphVizGraphBuilder |
|
HvdcAcEmulationSide1ActiveFlowEquationTerm |
|
HvdcAcEmulationSide2ActiveFlowEquationTerm |
|
HvdcConverterStations |
|
HvdcState |
|
IncrementalPhaseControlOuterLoop |
|
IncrementalPhaseControlOuterLoop.SensitivityContext |
|
IncrementalShuntVoltageControlOuterLoop |
|
IncrementalTransformerVoltageControlOuterLoop |
|
JacobianMatrix<V extends Enum<V> & Quantity,E extends Enum<E> & Quantity> |
|
LargestGeneratorSlackBusSelector |
|
LfAction |
|
LfAction.GeneratorChange |
|
LfAsymBus |
|
LfAsymGenerator |
|
LfAsymLine |
This is an extension to a LfBranch Line to describe the asymmetry of a line to be used for an
unbalanced load flow.
|
LfAsymLineAdmittanceMatrix |
This class is made to build and access the admittance terms that will be used to fill up the Jacobian :
The following formulation approach is used :
side 1 ________ side 2
[ Iz_1 ] [ Vz_1 ] z-----| |-------z
[ Ip_1 ] [ Vp_1 ] p-----| Yzpn |-------p
[ In_1 ] [ Vn_1 ] n-----|________|-------n
[ Iz_2 ] = [Yzpn] * [ Vz_2 ]
[ Ip_2 ] [ Vp_2 ]
[ In_2 ] [ Vn_2 ]
Given that at bus 1 where j is one neighbouring bus, the injection at bus 1 is equal to the sum of Powers from neighboring busses:
Sum[j](S_1j) =Pp_1 + j.Qp_1 = Sum[j](Vp_1.Ip_1j*)
Pz_1 + j.Qz_1 = Sum[j](Vz_1.Iz_1j*)
Pn_1 + j.Qn_1 = Sum[j](Vn_1.In_1j*)
Substituting [I] by [Yzpn]*[V] allows to know the equations terms that will fill the jacobian matrix
Step 1: Get [Yzpn]
------------------
First step is to compute [ Yzpn ] from a 3-phase description because this is how we can describe unbalances of phases for a line:
For each a,b,c phase we know the following relation (only true for lines with no mutual inductances, otherwise we must handle full [Yabc] matrix):
[Ia_1] [ ya_11 ya_12 ] [Va_1]
[Ia_2] = [ ya_21 ya_22 ] * [Va_2]
with (for a line only) : ya_11 = ga1 + j.ba1 + 1/za , ya_12 = -1/za , ya_21 = -1/za , ya_22 = ga2 + j.ba2 + 1/za
From the fortescue transformation we have:
[Ga] [Gz]
[Gb] = [F] * [Gp]
[Gc] [Gn]
where [G] might be [V] or [I]
where [F] is the fortescue transformation matrix
Therefore we have:
[ya_11 0 0 ya_12 0 0 ]
[ 0 yb_11 0 0 yb_12 0 ]
[inv(F) O ] [ 0 0 yc_11 0 0 yc_12] [ F 0 ]
[Yzpn] = [ 0 inv(F)] * [ya_21 0 0 ya_22 0 0 ] * [ 0 F ]
[ 0 yb_21 0 0 yb_22 0 ]
[ 0 0 yc_21 0 0 yc_22]
[Yzpn] is a complex matrix
Step 2: Define the generic term that will be used to make the link between [Yzpn] and S[z,p,n] the apparent power
-----------------------------------------------------------------------------------------------------------------
We define T(i,j,g,h) = rho_i * rho_j * exp(j(a_i-a_j)) * y*_ij_gh * V_gi * V*_hj
where i,j are line's ends included in {1,2}
where g,h are fortescue sequences included in {z,p,n}={0,1,2}
Step 3 : express the expanded value of T(i,j,g,h):
--------------------------------------------------
T(i,j,g,h) = rho_i * rho_j * V_gi * V_hj * yx_ij_gh * cos(a_i - a_j + th_gi - th_hj)
- rho_i * rho_j * V_gi * V_hj * yy_ij_gh * sin(a_i - a_j + th_gi - th_hj)
-j( rho_i * rho_j * V_gi * V_hj * yx_ij_gh * sin(a_i - a_j + th_gi - th_hj)
+ rho_i * rho_j * V_gi * V_hj * yy_ij_gh * cos(a_i - a_j + th_gi - th_hj) )
Step 4 : express the apparent powers with T():
----------------------------------------------
S_z_12 = T(1,1,z,z) + T(1,1,z,p) + T(1,1,z,n) + T(1,2,z,z) + T(1,2,z,p) + T(1,2,z,n)
S_p_12 = T(1,1,p,z) + T(1,1,p,p) + T(1,1,p,n) + T(1,2,p,z) + T(1,2,p,p) + T(1,2,p,n)
S_n_12 = T(1,1,n,z) + T(1,1,n,p) + T(1,1,n,n) + T(1,2,n,z) + T(1,2,n,p) + T(1,2,n,n)
Step 5 : make the link between y_ij_gh in T() and [Yzpn]:
---------------------------------------------------------
By construction we have :
[ y_11_zz y_11_zp y_11_zn y_12_zz y_12_zp y_12_zn ]
[ y_11_pz y_11_pp y_11_pn y_12_pz y_12_pp y_12_pn ]
[Yzpn] = [ y_11_nz y_11_np y_11_nn y_12_nz y_12_np y_12_nn ]
[ y_21_zz y_21_zp y_21_zn y_22_zz y_22_zp y_22_zn ]
[ y_21_pz y_21_pp y_21_pn y_22_pz y_22_pp y_22_pn ]
[ y_21_nz y_21_np y_21_nn y_22_nz y_22_np y_22_nn ]
|
LfBatteryImpl |
|
LfBranch |
|
LfBranch.BranchType |
|
LfBranch.LfLimit |
|
LfBranchImpl |
|
LfBus |
|
LfBusImpl |
|
LfContingency |
|
LfDanglingLineBranch |
|
LfDanglingLineBus |
|
LfDanglingLineGenerator |
|
LfElement |
|
LfGenerator |
|
LfGenerator.GeneratorControlType |
|
LfGenerator.ReactiveRangeMode |
|
LfGeneratorImpl |
|
LfHvdc |
|
LfHvdcImpl |
|
LfLegBranch |
|
LfLoad |
|
LfNetwork |
|
LfNetworkList |
|
LfNetworkList.AbstractVariantCleaner |
|
LfNetworkList.DefaultVariantCleaner |
|
LfNetworkList.VariantCleaner |
|
LfNetworkList.VariantCleanerFactory |
|
LfNetworkList.WorkingVariantReverter |
|
LfNetworkListener |
|
LfNetworkListenerTracer |
|
LfNetworkLoader<T> |
|
LfNetworkLoaderImpl |
|
LfNetworkLoaderPostProcessor |
|
LfNetworkLoaderPostProcessor.LoadingPolicy |
|
LfNetworkParameters |
|
LfNetworkStateUpdateParameters |
|
LfSecondaryVoltageControl |
|
LfShunt |
|
LfShunt.Controller |
|
LfShuntImpl |
|
LfStandbyAutomatonShunt |
|
LfStarBus |
|
LfStaticVarCompensator |
|
LfStaticVarCompensator.StandByAutomaton |
if the static var compensator has an automaton in stand by, this object must be field.
|
LfStaticVarCompensatorImpl |
|
LfSwitch |
|
LfTieLineBranch |
|
LfVscConverterStation |
|
LfVscConverterStationImpl |
|
LfZeroImpedanceNetwork |
|
LimitViolationManager |
Limit violation manager.
|
LineSearchStateVectorScaling |
|
LoadActivePowerDistributionStep |
|
LoadFlowContext<V extends Enum<V> & Quantity,E extends Enum<E> & Quantity,P extends AbstractLoadFlowParameters> |
|
LoadFlowEngine<V extends Enum<V> & Quantity,E extends Enum<E> & Quantity,P extends AbstractLoadFlowParameters,R extends LoadFlowResult> |
|
LoadFlowModel |
|
LoadFlowResult |
|
LoadFortescuePowerEquationTerm |
|
Markers |
|
MatrixUtil |
TODO: move theses features to core.
|
MaxVoltageChangeStateVectorScaling |
Limit voltage magnitude change and voltage angle change between NR iterations
|
MinimumSpanningTreeGraphConnectivity<V,E> |
|
MinimumSpanningTreeGraphConnectivityFactory<V,E> |
|
ModificationsContext<V,E> |
|
MonitoringVoltageOuterLoop |
|
MostMeshedSlackBusSelector |
|
NaiveGraphConnectivity<V,E> |
|
NaiveGraphConnectivityFactory<V,E> |
|
NameSlackBusSelector |
|
NetworkCache |
|
NetworkCache.Entry |
|
Networks |
|
NetworkSlackBusSelector |
|
NetworkState |
|
NewtonRaphson |
|
NewtonRaphsonParameters |
|
NewtonRaphsonResult |
|
NewtonRaphsonStatus |
|
NewtonRaphsonStoppingCriteria |
|
NewtonRaphsonStoppingCriteria.TestResult |
|
NewtonRaphsonStoppingCriteriaType |
|
NodeBreakerTraverser |
|
NoneStateVectorScaling |
|
OlfBranchResult |
|
OpenBranchSide1ActiveFlowEquationTerm |
|
OpenBranchSide1CurrentMagnitudeEquationTerm |
|
OpenBranchSide1ReactiveFlowEquationTerm |
|
OpenBranchSide2ActiveFlowEquationTerm |
|
OpenBranchSide2CurrentMagnitudeEquationTerm |
|
OpenBranchSide2ReactiveFlowEquationTerm |
|
OpenLoadFlowParameterJsonSerializer |
|
OpenLoadFlowParameters |
|
OpenLoadFlowParameters.LowImpedanceBranchMode |
|
OpenLoadFlowParameters.PhaseShifterControlMode |
|
OpenLoadFlowParameters.ReactiveRangeCheckMode |
|
OpenLoadFlowParameters.ReportedFeatures |
|
OpenLoadFlowParameters.ShuntVoltageControlMode |
|
OpenLoadFlowParameters.TransformerVoltageControlMode |
|
OpenLoadFlowParameters.VoltageInitModeOverride |
|
OpenLoadFlowProvider |
|
OpenLoadFlowReportConstants |
|
OpenSecurityAnalysisParameterJsonSerializer |
|
OpenSecurityAnalysisParameters |
|
OpenSecurityAnalysisProvider |
|
OpenSensitivityAnalysisParameterJsonSerializer |
|
OpenSensitivityAnalysisParameters |
|
OpenSensitivityAnalysisProvider |
|
OuterLoop<V extends Enum<V> & Quantity,E extends Enum<E> & Quantity,P extends AbstractLoadFlowParameters,C extends LoadFlowContext<V,E,P>,O extends OuterLoopContext<V,E,P,C>> |
|
OuterLoopContext<V extends Enum<V> & Quantity,E extends Enum<E> & Quantity,P extends AbstractLoadFlowParameters,C extends LoadFlowContext<V,E,P>> |
|
OuterLoopStatus |
|
ParticipatingElement |
|
PerEquationTypeStoppingCriteria |
|
PerUnit |
|
PhaseControlOuterLoop |
|
PiModel |
|
PiModelArray |
|
PlausibleValues |
Network related plausible values.
|
PostContingencyNetworkResult |
|
PowerShift |
|
PowsyblOpenLoadFlowVersion |
|
PreContingencyNetworkResult |
|
PreviousValueVoltageInitializer |
|
PropagatedContingency |
|
PropertyBag |
|
ProviderConstants |
|
Quantity |
|
ReactiveLimitsOuterLoop |
|
ReactivePowerControl |
|
Ref<T> |
|
Reports |
|
SecondaryVoltageControlOuterLoop |
|
SelectedSlackBus |
|
SensitivityFactoryJsonRecorder |
|
ShuntCompensatorActiveFlowEquationTerm |
|
ShuntCompensatorReactiveFlowEquationTerm |
|
ShuntFortescueIxEquationTerm |
|
ShuntFortescueIyEquationTerm |
|
ShuntVoltageControl |
|
ShuntVoltageControlOuterLoop |
|
Side |
|
SimplePiModel |
|
SimpleTransformerVoltageControlOuterLoop |
|
SlackBusSelectionMode |
|
SlackBusSelector |
|
StateVector |
|
StateVectorListener |
|
StateVectorScaling |
State vector scaling.
|
StateVectorScalingMode |
|
TargetVector<V extends Enum<V> & Quantity,E extends Enum<E> & Quantity> |
|
TargetVector.Initializer<V extends Enum<V> & Quantity,E extends Enum<E> & Quantity> |
|
TransformerPhaseControl |
|
TransformerPhaseControl.Mode |
|
TransformerPhaseControl.Unit |
|
Transformers |
|
TransformerVoltageControl |
|
TransformerVoltageControlOuterLoop |
|
UniformValueVoltageInitializer |
|
Variable<V extends Enum<V> & Quantity> |
|
VariableEquationTerm<V extends Enum<V> & Quantity,E extends Enum<E> & Quantity> |
|
VariableSet<V extends Enum<V> & Quantity> |
|
Vector |
|
Vectors |
|
VertexAdd<V,E> |
|
VoltageControl<T extends LfElement> |
|
VoltageControl.MergeStatus |
|
VoltageControl.Type |
|
VoltageInitializer |
|
VoltageMagnitudeInitializer |
This voltage initializer is able to find a voltage magnitude starting point by resolving a linear system
using only voltage set points, branches reactance and branches voltage ratio.
|
VoltageMagnitudeInitializer.InitVmBusEquationTerm |
|
VoltageMagnitudeInitializer.InitVmEquationType |
|
VoltageMagnitudeInitializer.InitVmVariableType |
|
ZeroImpedanceFlows |
|