Add reports for AC Load Flow voltage initialization

src/main/java/com/powsybl/openloadflow/FullVoltageInitializer.java

@@ -8,12 +8,14 @@
 package com.powsybl.openloadflow;
 
 import com.powsybl.commons.PowsyblException;
+import com.powsybl.commons.report.ReportNode;
 import com.powsybl.openloadflow.ac.VoltageMagnitudeInitializer;
 import com.powsybl.openloadflow.dc.DcValueVoltageInitializer;
 import com.powsybl.openloadflow.network.LfBus;
 import com.powsybl.openloadflow.network.LfDcBus;
 import com.powsybl.openloadflow.network.LfNetwork;
 import com.powsybl.openloadflow.network.util.VoltageInitializer;
+import com.powsybl.openloadflow.util.Reports;
 
 import java.util.Objects;
 
@@ -25,6 +27,8 @@
  */
 public class FullVoltageInitializer implements VoltageInitializer {
 
+    public static final String NAME = "Full Voltage";
+
     private final VoltageMagnitudeInitializer magnitudeInitializer;
 
     private final DcValueVoltageInitializer angleInitializer;
@@ -35,9 +39,10 @@ public FullVoltageInitializer(VoltageMagnitudeInitializer magnitudeInitializer,
     }
 
     @Override
-    public void prepare(LfNetwork network) {
-        magnitudeInitializer.prepare(network);
-        angleInitializer.prepare(network);
+    public void prepare(LfNetwork network, ReportNode reportNode) {
+        ReportNode initReportNode = Reports.reportVoltageInitializer(reportNode, NAME);
+        magnitudeInitializer.prepare(network, initReportNode);
+        angleInitializer.prepare(network, initReportNode);
     }
 
     @Override

src/main/java/com/powsybl/openloadflow/ac/AcLoadFlowParameters.java

@@ -64,6 +64,31 @@ public class AcLoadFlowParameters extends AbstractLoadFlowParameters<AcLoadFlowP
 
     private boolean vectorized = VECTORIZED_DEFAULT_VALUE;
 
+    private boolean voltageInitReport = true;
+
+    public AcLoadFlowParameters() {
+    }
+
+    public AcLoadFlowParameters(AcLoadFlowParameters other) {
+        super(new LfNetworkParameters(other.networkParameters), other.matrixFactory);
+        this.slackDistributionFailureBehavior = other.slackDistributionFailureBehavior;
+        this.equationSystemCreationParameters = other.equationSystemCreationParameters;
+        this.acSolverParameters = other.acSolverParameters;
+        this.outerLoops = other.outerLoops;
+        this.maxOuterLoopIterations = other.maxOuterLoopIterations;
+        this.voltageInitializer = other.voltageInitializer;
+        this.asymmetrical = other.asymmetrical;
+        this.solverFactory = other.solverFactory;
+        this.detailedReport = other.detailedReport;
+        this.voltageRemoteControlRobustMode = other.voltageRemoteControlRobustMode;
+        this.minRealisticVoltage = other.minRealisticVoltage;
+        this.maxRealisticVoltage = other.maxRealisticVoltage;
+        this.minNominalVoltageRealisticVoltageCheck = other.minNominalVoltageRealisticVoltageCheck;
+        this.fixVoltageTargets = other.fixVoltageTargets;
+        this.vectorized = other.vectorized;
+        this.voltageInitReport = other.voltageInitReport;
+    }
+
     public AcEquationSystemCreationParameters getEquationSystemCreationParameters() {
         return equationSystemCreationParameters;
     }
@@ -186,6 +211,15 @@ public AcLoadFlowParameters setVectorized(boolean vectorized) {
         return this;
     }
 
+    public boolean isVoltageInitReport() {
+        return voltageInitReport;
+    }
+
+    public AcLoadFlowParameters setVoltageInitReport(boolean voltageInitReport) {
+        this.voltageInitReport = voltageInitReport;
+        return this;
+    }
+
     @Override
     public String toString() {
         return "AcLoadFlowParameters(" +
@@ -206,6 +240,7 @@ public String toString() {
                 ", minNominalVoltageRealisticVoltageCheck=" + minNominalVoltageRealisticVoltageCheck +
                 ", fixVoltageTargets=" + fixVoltageTargets +
                 ", vectorized=" + vectorized +
+                ", voltageInitReport=" + voltageInitReport +
                 ')';
     }
 }

src/main/java/com/powsybl/openloadflow/ac/AcloadFlowEngine.java

@@ -171,15 +171,18 @@ private AcSolverResult runAcSolverAndCheckRealisticState(AcSolver solver, Voltag
     public AcLoadFlowResult run() {
         LOGGER.info("Start AC loadflow on network {}", context.getNetwork());
 
+        ReportNode reportNode = context.getNetwork().getReportNode();
         VoltageInitializer voltageInitializer = context.getParameters().getVoltageInitializer();
         // in case of a DC voltage initializer, an DC equation system in created and equations are attached
         // to the network. It is important that DC init is done before AC equation system is created by
         // calling ACLoadContext.getEquationSystem to avoid DC equations overwrite AC ones in the network.
-        voltageInitializer.prepare(context.getNetwork());
+        voltageInitializer.prepare(
+                context.getNetwork(),
+                context.getParameters().isVoltageInitReport() ? reportNode : ReportNode.NO_OP
+        );
 
         RunningContext runningContext = new RunningContext();
         double distributedActivePower = 0.0;
-        ReportNode reportNode = context.getNetwork().getReportNode();
 
         // Verify whether a regulated bus voltage exists.
         // If not, then fail immediately with SOLVER_FAILED status.

src/main/java/com/powsybl/openloadflow/ac/VoltageMagnitudeInitializer.java

@@ -9,10 +9,12 @@
 
 import com.google.common.base.Stopwatch;
 import com.powsybl.commons.PowsyblException;
+import com.powsybl.commons.report.ReportNode;
 import com.powsybl.math.matrix.MatrixFactory;
 import com.powsybl.openloadflow.equations.*;
 import com.powsybl.openloadflow.network.*;
 import com.powsybl.openloadflow.network.util.VoltageInitializer;
+import com.powsybl.openloadflow.util.Reports;
 import gnu.trove.list.array.TDoubleArrayList;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -33,6 +35,8 @@
  */
 public class VoltageMagnitudeInitializer implements VoltageInitializer {
 
+    public static final String NAME = "Voltage Magnitude";
+
     private static final Logger LOGGER = LoggerFactory.getLogger(VoltageMagnitudeInitializer.class);
 
     private final double lowImpedanceThreshold;
@@ -185,7 +189,8 @@ private static void initTarget(Equation<InitVmVariableType, InitVmEquationType>
     }
 
     @Override
-    public void prepare(LfNetwork network) {
+    public void prepare(LfNetwork network, ReportNode reportNode) {
+        Reports.reportVoltageInitializer(reportNode, NAME);
         Stopwatch stopwatch = Stopwatch.createStarted();
 
         // create the equation system:

src/main/java/com/powsybl/openloadflow/dc/DcValueVoltageInitializer.java

@@ -8,13 +8,15 @@
 package com.powsybl.openloadflow.dc;
 
 import com.powsybl.commons.PowsyblException;
+import com.powsybl.commons.report.ReportNode;
 import com.powsybl.loadflow.LoadFlowParameters;
 import com.powsybl.math.matrix.MatrixFactory;
 import com.powsybl.openloadflow.OpenLoadFlowParameters;
 import com.powsybl.openloadflow.dc.equations.DcApproximationType;
 import com.powsybl.openloadflow.dc.equations.DcEquationSystemCreationParameters;
 import com.powsybl.openloadflow.network.*;
 import com.powsybl.openloadflow.network.util.VoltageInitializer;
+import com.powsybl.openloadflow.util.Reports;
 
 import java.util.List;
 import java.util.Objects;
@@ -24,6 +26,8 @@
  */
 public class DcValueVoltageInitializer implements VoltageInitializer {
 
+    public static final String NAME = "DC Values";
+
     private final LfNetworkParameters networkParameters;
 
     private final boolean distributedSlack;
@@ -50,7 +54,9 @@ public DcValueVoltageInitializer(LfNetworkParameters networkParameters, boolean
     }
 
     @Override
-    public void prepare(LfNetwork network) {
+    public void prepare(LfNetwork network, ReportNode reportNode) {
+        ReportNode originalReportNode = network.getReportNode();
+        network.setReportNode(Reports.reportVoltageInitializer(reportNode, NAME));
         // in case of distributed slack, we need to save and restore generators and loads target p which might have been
         // modified by slack distribution, so that AC load flow can restart from original state
         List<BusDcState> busStates = distributedSlack ? ElementState.save(network.getBuses(), BusDcState::save) : null;
@@ -83,6 +89,7 @@ public void prepare(LfNetwork network) {
         if (busStates != null) {
             ElementState.restore(busStates);
         }
+        network.setReportNode(originalReportNode);
     }
 
     @Override

src/main/java/com/powsybl/openloadflow/network/util/PreviousValueVoltageInitializer.java

@@ -8,15 +8,19 @@
 package com.powsybl.openloadflow.network.util;
 
 import com.powsybl.commons.PowsyblException;
+import com.powsybl.commons.report.ReportNode;
 import com.powsybl.openloadflow.network.LfBus;
 import com.powsybl.openloadflow.network.LfDcBus;
 import com.powsybl.openloadflow.network.LfNetwork;
+import com.powsybl.openloadflow.util.Reports;
 
 /**
  * @author Geoffroy Jamgotchian {@literal <geoffroy.jamgotchian at rte-france.com>}
  */
 public class PreviousValueVoltageInitializer implements VoltageInitializer {
 
+    public static final String NAME = "Previous Value";
+
     private final UniformValueVoltageInitializer defaultVoltageInitializer = new UniformValueVoltageInitializer();
 
     private final boolean defaultToUniformValue;
@@ -30,8 +34,8 @@ public PreviousValueVoltageInitializer(boolean defaultToUniformValue) {
     }
 
     @Override
-    public void prepare(LfNetwork network) {
-        // nothing to do
+    public void prepare(LfNetwork network, ReportNode reportNode) {
+        Reports.reportVoltageInitializer(reportNode, NAME);
     }
 
     @Override

src/main/java/com/powsybl/openloadflow/network/util/UniformValueVoltageInitializer.java

@@ -7,18 +7,22 @@
  */
 package com.powsybl.openloadflow.network.util;
 
+import com.powsybl.commons.report.ReportNode;
 import com.powsybl.openloadflow.network.LfBus;
 import com.powsybl.openloadflow.network.LfDcBus;
 import com.powsybl.openloadflow.network.LfNetwork;
+import com.powsybl.openloadflow.util.Reports;
 
 /**
  * @author Geoffroy Jamgotchian {@literal <geoffroy.jamgotchian at rte-france.com>}
  */
 public class UniformValueVoltageInitializer implements VoltageInitializer {
 
+    public static final String NAME = "Uniform Values";
+
     @Override
-    public void prepare(LfNetwork network) {
-        // nothing to do
+    public void prepare(LfNetwork network, ReportNode reportNode) {
+        Reports.reportVoltageInitializer(reportNode, NAME);
     }
 
     @Override

src/main/java/com/powsybl/openloadflow/network/util/VoltageInitializer.java

@@ -7,6 +7,7 @@
  */
 package com.powsybl.openloadflow.network.util;
 
+import com.powsybl.commons.report.ReportNode;
 import com.powsybl.openloadflow.network.LfBus;
 import com.powsybl.openloadflow.network.LfDcBus;
 import com.powsybl.openloadflow.network.LfNetwork;
@@ -16,11 +17,12 @@
  */
 public interface VoltageInitializer {
 
-    void prepare(LfNetwork network);
+    void prepare(LfNetwork network, ReportNode reportNode);
 
     double getMagnitude(LfBus bus);
 
     double getAngle(LfBus bus);
 
     double getMagnitude(LfDcBus dcBus);
+
 }

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

@@ -677,7 +677,11 @@ protected List<StateMonitor> extractZeroImpedanceStateMonitors(LfNetwork lfNetwo
         return zeroImpedanceStateMonitors;
     }
 
-    protected void afterPreContingencySimulation(P acParameters) {
+    protected P copyParameters(P parameters) {
+        return parameters;
+    }
+
+    protected void afterPreContingencySimulation(P parameters) {
     }
 
     protected SecurityAnalysisResult runSimulations(LfNetwork lfNetwork, List<PropagatedContingency> propagatedContingencies, P acParameters,
@@ -700,7 +704,9 @@ protected SecurityAnalysisResult runSimulations(LfNetwork lfNetwork, List<Propag
         OpenSecurityAnalysisParameters openSecurityAnalysisParameters = OpenSecurityAnalysisParameters.getOrDefault(securityAnalysisParameters);
         boolean createResultExtension = openSecurityAnalysisParameters.isCreateResultExtension();
 
-        try (C context = createLoadFlowContext(lfNetwork, acParameters)) {
+        P p = copyParameters(acParameters);
+
+        try (C context = createLoadFlowContext(lfNetwork, p)) {
             ReportNode networkReportNode = lfNetwork.getReportNode();
             ReportNode preContSimReportNode = Reports.createPreContingencySimulation(networkReportNode);
             lfNetwork.setReportNode(preContSimReportNode);
@@ -721,7 +727,7 @@ protected SecurityAnalysisResult runSimulations(LfNetwork lfNetwork, List<Propag
 
             // only run post-contingency simulations if pre-contingency simulation is ok
             if (preContingencyComputationOk) {
-                afterPreContingencySimulation(acParameters);
+                afterPreContingencySimulation(p);
 
                 // update network result
                 preContingencyNetworkResult.update();
@@ -733,13 +739,13 @@ protected SecurityAnalysisResult runSimulations(LfNetwork lfNetwork, List<Propag
                 NetworkState networkState = NetworkState.save(lfNetwork);
 
                 // Reset parameters for next component
-                Consumer<P> componentParametersResetter = createParametersResetter(acParameters);
+                Consumer<P> componentParametersResetter = createParametersResetter(p);
 
-                // openLoadFlow parameters can be overriden by security analys parameters - may modify acParameters
-                OpenLoadFlowParameters contingencyOpenLoadFlowParameters = applyGenericContingencyParameters(acParameters, loadFlowParameters, openLoadFlowParameters, openSecurityAnalysisParameters);
+                // openLoadFlow parameters can be overriden by security analys parameters - may modify p
+                OpenLoadFlowParameters contingencyOpenLoadFlowParameters = applyGenericContingencyParameters(p, loadFlowParameters, openLoadFlowParameters, openSecurityAnalysisParameters);
 
                 // Reset parameters between contingencies
-                Consumer<P> contingencyParametersResetter = createParametersResetter(acParameters);
+                Consumer<P> contingencyParametersResetter = createParametersResetter(p);
 
                 // start a simulation for each of the contingency
                 Iterator<PropagatedContingency> contingencyIt = propagatedContingencies.iterator();
@@ -785,7 +791,7 @@ protected SecurityAnalysisResult runSimulations(LfNetwork lfNetwork, List<Propag
                                                 operatorStrategy, preContingencyLimitViolationManager,
                                                 securityAnalysisParameters, lfActionById,
                                                 createResultExtension, lfContingency, postContingencyResult.getLimitViolationsResult(),
-                                                acParameters.getNetworkParameters(), limitReductions)
+                                                p.getNetworkParameters(), limitReductions)
                                                 .ifPresent(operatorStrategyResults::add);
                                     } else {
                                         // multiple operator strategies, save post contingency state for later restoration after action
@@ -797,7 +803,7 @@ protected SecurityAnalysisResult runSimulations(LfNetwork lfNetwork, List<Propag
                                                     operatorStrategy, preContingencyLimitViolationManager,
                                                     securityAnalysisParameters, lfActionById,
                                                     createResultExtension, lfContingency, postContingencyResult.getLimitViolationsResult(),
-                                                    acParameters.getNetworkParameters(), limitReductions)
+                                                    p.getNetworkParameters(), limitReductions)
                                                     .ifPresent(result -> {
                                                         operatorStrategyResults.add(result);
                                                         postContingencyNetworkState.restore();
@@ -818,7 +824,7 @@ protected SecurityAnalysisResult runSimulations(LfNetwork lfNetwork, List<Propag
                 }
 
                 // Restore parameters in case they are used for another component
-                componentParametersResetter.accept(acParameters);
+                componentParametersResetter.accept(p);
             }
 
             return new SecurityAnalysisResult(

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

@@ -86,13 +86,19 @@ protected AcloadFlowEngine createLoadFlowEngine(AcLoadFlowContext context) {
     }
 
     @Override
-    protected void afterPreContingencySimulation(AcLoadFlowParameters acParameters) {
+    protected AcLoadFlowParameters copyParameters(AcLoadFlowParameters parameters) {
+        return new AcLoadFlowParameters(parameters);
+    }
+
+    @Override
+    protected void afterPreContingencySimulation(AcLoadFlowParameters parameters) {
         // in some post-contingency computation, it does not remain elements to participate to slack distribution.
         // in that case, no exception should be thrown. If parameters were configured to throw, reconfigure to FAIL.
         // (the contingency will be marked as not converged)
-        if (OpenLoadFlowParameters.SlackDistributionFailureBehavior.THROW == acParameters.getSlackDistributionFailureBehavior()) {
-            acParameters.setSlackDistributionFailureBehavior(OpenLoadFlowParameters.SlackDistributionFailureBehavior.FAIL);
+        if (OpenLoadFlowParameters.SlackDistributionFailureBehavior.THROW == parameters.getSlackDistributionFailureBehavior()) {
+            parameters.setSlackDistributionFailureBehavior(OpenLoadFlowParameters.SlackDistributionFailureBehavior.FAIL);
         }
+        parameters.setVoltageInitReport(false); // there is no point in reporting the PreviousVoltageValue initializer
     }
 
     public static PostContingencyComputationStatus postContingencyStatusFromAcLoadFlowResult(AcLoadFlowResult result) {

src/main/java/com/powsybl/openloadflow/sensi/AcSensitivityAnalysis.java

@@ -318,6 +318,8 @@ private void analyzeContingencySet(Network network, LfNetworkList lfNetworks, Li
 
             runLoadFlow(context, true);
 
+            acParameters.setVoltageInitReport(false);
+
             // index factors by variable group to compute a minimal number of states
             SensitivityFactorGroupList<AcVariableType, AcEquationType> factorGroups = createFactorGroups(validLfFactors.stream()
                     .filter(factor -> factor.getStatus() == LfSensitivityFactor.Status.VALID).collect(Collectors.toList()));

src/main/java/com/powsybl/openloadflow/util/Reports.java

@@ -1197,4 +1197,11 @@ public static ReportNode reportIncompatibleVoltageTarget(ReportNode reportNode,
                 .add();
     }
 
+    public static ReportNode reportVoltageInitializer(ReportNode reportNode, String initializerName) {
+        return reportNode.newReportNode()
+                .withMessageTemplate("olf.voltageInitializer")
+                .withUntypedValue("initializerName", initializerName)
+                .add();
+    }
+
 }

src/main/resources/com/powsybl/openloadflow/reports.properties

@@ -124,4 +124,5 @@ olf.transformerControlTapLimit = ${numTransformerControlTapLimit} transformers r
 olf.transformerControlTapLimitDetail = Transformer ${transformerId} reached a tap extreme position
 olf.transformersDiscardedFromVoltageControlBecauseTargetVIsInconsistent = ${impactedTransformerCount} transformers have been discarded from voltage control because targetV is inconsistent
 olf.unfreezeHvdc = Setting again HVDC ${ID} in AC emulation mode.
+olf.voltageInitializer = Voltage initialization with method ${initializerName}
 olf.woodburyDcSecurityAnalysis = Woodbury DC security analysis on network '${networkId}'