All Classes and Interfaces
Class
Description
AbstractElementEquationTerm<T extends LfElement,V extends Enum<V> & Quantity,E extends Enum<E> & Quantity>
AbstractIncrementalPhaseControlOuterLoop<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>>
AbstractIncrementalPhaseControlOuterLoop.AbstractSensitivityContext<V extends Enum<V> & Quantity,E extends Enum<E> & Quantity>
AbstractLoadFlowContext<V extends Enum<V> & Quantity,E extends Enum<E> & Quantity,P extends AbstractLoadFlowParameters>
AbstractOuterLoopContext<V extends Enum<V> & Quantity,E extends Enum<E> & Quantity,P extends AbstractLoadFlowParameters,C extends LoadFlowContext<V,E,P>>
AbstractPhaseControlOuterLoop<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>>
AbstractSecurityAnalysis<V extends Enum<V> & Quantity,E extends Enum<E> & Quantity,P extends AbstractLoadFlowParameters<P>,C extends LoadFlowContext<V,E,P>,R extends LoadFlowResult>
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 ]
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 ]
Keeps track of distributed active power
An equation term, i.e part of the equation sum.
EquationTerm.MultiplyByScalarEquationTerm<V extends Enum<V> & Quantity,E extends Enum<E> & Quantity>
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.
A voltage initializer that rely on
VoltageMagnitudeInitializer for magnitude calculation and on
DcValueVoltageInitializer for angle calculation.Interface for incremental and decremental connectivity computations, through a mechanism which records the
topological changes which later need to be undone.
This is an extension to a LfBranch Line to describe the asymmetry of a line to be used for an
unbalanced load flow.
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 ]
Generic load model as a sum of exponential terms: sum_i(ci * v^ni)
A LfLoad is an aggregation of several classical network loads.
if the static var compensator has an automaton in stand by, this object must be field.
Limit violation manager.
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<P>,R extends LoadFlowResult>
TODO: move theses features to core.
Limit voltage magnitude change and voltage angle change between NR iterations
OpenSensitivityAnalysisProvider.ReplayResult<T extends com.powsybl.sensitivity.SensitivityResultWriter>
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>>
Network related plausible values.
State vector scaling.
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.