Add comments

Signed-off-by: p-arvy <[email protected]>

Author: p-arvy

src/main/java/com/powsybl/openloadflow/network/LfContingency.java

@@ -147,30 +147,35 @@ public void apply(LoadFlowParameters.BalanceType balanceType) {
             shunt.setG(shunt.getG() - e.getValue().getG());
             shunt.setB(shunt.getB() - e.getValue().getB());
         }
-        processPowerShifts(balanceType, true);
+        processLostPowerChanges(balanceType, true);
     }
 
-    public void processPowerShifts(LoadFlowParameters.BalanceType balanceType, boolean updateAc) {
-        processLostLoads(balanceType, updateAc);
-        processLostGenerators(updateAc);
+    /**
+     * Process the power shifts due to the loss of loads, generators, and HVDCs.
+     * @param balanceType the property defining how to manage active distribution.
+     * @param updateAcParameters a boolean to indicate if voltage/reactive dependent parameters should be updated or not.
+     */
+    public void processLostPowerChanges(LoadFlowParameters.BalanceType balanceType, boolean updateAcParameters) {
+        processLostLoads(balanceType, updateAcParameters);
+        processLostGenerators(updateAcParameters);
         processHvdcsWithoutPower();
     }
 
-    private void processLostLoads(LoadFlowParameters.BalanceType balanceType, boolean updateAc) {
+    private void processLostLoads(LoadFlowParameters.BalanceType balanceType, boolean updateAcParameters) {
         for (var e : lostLoads.entrySet()) {
             LfLoad load = e.getKey();
             LfLostLoad lostLoad = e.getValue();
             PowerShift shift = lostLoad.getPowerShift();
             load.setTargetP(load.getTargetP() - getUpdatedLoadP0(load, balanceType, shift.getActive(), shift.getVariableActive(), lostLoad.getNotParticipatingLoadP0()));
-            if (updateAc) {
+            if (updateAcParameters) {
                 load.setTargetQ(load.getTargetQ() - shift.getReactive());
             }
             load.setAbsVariableTargetP(load.getAbsVariableTargetP() - Math.abs(shift.getVariableActive()));
             lostLoad.getOriginalIds().forEach(loadId -> load.setOriginalLoadDisabled(loadId, true));
         }
     }
 
-    private void processLostGenerators(boolean updateAc) {
+    private void processLostGenerators(boolean updateAcParameters) {
         Set<LfBus> generatorBuses = new HashSet<>();
         for (LfGenerator generator : lostGenerators) {
             generator.setTargetP(0);
@@ -179,7 +184,7 @@ private void processLostGenerators(boolean updateAc) {
             generatorBuses.add(bus);
             generator.setParticipating(false);
             generator.setDisabled(true);
-            if (updateAc) {
+            if (updateAcParameters) {
                 if (generator.getGeneratorControlType() != LfGenerator.GeneratorControlType.OFF) {
                     generator.setGeneratorControlType(LfGenerator.GeneratorControlType.OFF);
                     bus.getGeneratorVoltageControl().ifPresent(GeneratorVoltageControl::updateReactiveKeys);
@@ -196,7 +201,7 @@ private void processLostGenerators(boolean updateAc) {
                 }
             }
         }
-        if (updateAc) {
+        if (updateAcParameters) {
             for (LfBus bus : generatorBuses) {
                 if (bus.getGenerators().stream().noneMatch(gen -> gen.getGeneratorControlType() == LfGenerator.GeneratorControlType.VOLTAGE)) {
                     bus.setGeneratorVoltageControlEnabled(false);

src/main/java/com/powsybl/openloadflow/sa/WoodburyDcSecurityAnalysis.java

@@ -167,11 +167,13 @@ private double[] calculatePostContingencyAndOperatorStrategyStates(DcLoadFlowCon
             engine.toPostContingencyAndOperatorStrategyStates(newFlowStates);
         } else {
             // if we have a contingency including the loss of a DC line or a generator or a load
-            // save base state for later restoration after each contingency
+            // save dc buses' base state for later restoration after processing lost power changes
             DcLoadFlowParameters lfParameters = loadFlowContext.getParameters();
             List<BusDcState> busStates = ElementState.save(lfNetwork.getBuses(), BusDcState::save);
             connectivityAnalysisResult.toLfContingency()
-                    .ifPresent(lfContingency -> lfContingency.processPowerShifts(lfParameters.getBalanceType(), false));
+                    // only process the power shifts due to the loss of loads, generators, and HVDCs
+                    // the loss of buses and phase shifts are taken into account in the override of the flow states
+                    .ifPresent(lfContingency -> lfContingency.processLostPowerChanges(lfParameters.getBalanceType(), false));
             newFlowStates = WoodburyEngine.runDcLoadFlowWithModifiedTargetVector(loadFlowContext, disabledNetwork, reportNode, operatorStrategyLfActions);
             engine.toPostContingencyAndOperatorStrategyStates(newFlowStates);
             ElementState.restore(busStates);