Fix network variant removal issue

src/main/java/com/powsybl/openloadflow/network/impl/LfNetworkList.java

@@ -0,0 +1,69 @@
+/**
+ * Copyright (c) 2022, RTE (http://www.rte-france.com)
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+package com.powsybl.openloadflow.network.impl;
+
+import com.powsybl.iidm.network.Network;
+import com.powsybl.openloadflow.network.LfNetwork;
+
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+
+/**
+ * @author Geoffroy Jamgotchian <geoffroy.jamgotchian at rte-france.com>
+ */
+public class LfNetworkList implements AutoCloseable {
+
+    public static class VariantCleaner {
+
+        private final Network network;
+
+        private final String workingVariantId;
+
+        private final String tmpVariantId;
+
+        public VariantCleaner(Network network, String workingVariantId, String tmpVariantId) {
+            this.network = Objects.requireNonNull(network);
+            this.workingVariantId = Objects.requireNonNull(workingVariantId);
+            this.tmpVariantId = Objects.requireNonNull(tmpVariantId);
+        }
+
+        public void clean() {
+            network.getVariantManager().removeVariant(tmpVariantId);
+            network.getVariantManager().setWorkingVariant(workingVariantId);
+        }
+    }
+
+    // list of networks sorted by descending size
+    private final List<LfNetwork> list;
+
+    private final VariantCleaner variantCleaner;
+
+    public LfNetworkList(List<LfNetwork> list, VariantCleaner variantCleaner) {
+        this.list = Objects.requireNonNull(list);
+        this.variantCleaner = variantCleaner;
+    }
+
+    public LfNetworkList(List<LfNetwork> list) {
+        this(list, null);
+    }
+
+    public List<LfNetwork> getList() {
+        return list;
+    }
+
+    public Optional<LfNetwork> getLargest() {
+        return list.isEmpty() ? Optional.empty() : Optional.of(list.get(0));
+    }
+
+    @Override
+    public void close() {
+        if (variantCleaner != null) {
+            variantCleaner.clean();
+        }
+    }
+}

src/main/java/com/powsybl/openloadflow/network/impl/Networks.java

@@ -106,36 +106,28 @@ public static List<LfNetwork> load(Network network, LfNetworkParameters paramete
         return LfNetwork.load(network, new LfNetworkLoaderImpl(), parameters);
     }
 
-    public static List<LfNetwork> load(Network network, SlackBusSelector slackBusSelector, Reporter reporter) {
-        return LfNetwork.load(network, new LfNetworkLoaderImpl(), slackBusSelector, reporter);
-    }
-
     public static List<LfNetwork> load(Network network, LfNetworkParameters parameters, Reporter reporter) {
         return LfNetwork.load(network, new LfNetworkLoaderImpl(), parameters, reporter);
     }
 
-    public static List<LfNetwork> load(Network network, LfNetworkParameters networkParameters,
-                                       Set<Switch> switchesToOpen, Set<Switch> switchesToClose, Reporter reporter) {
+    public static LfNetworkList load(Network network, LfNetworkParameters networkParameters,
+                                     Set<Switch> switchesToOpen, Set<Switch> switchesToClose, Reporter reporter) {
         if (switchesToOpen.isEmpty() && switchesToClose.isEmpty()) {
-            return load(network, networkParameters, reporter);
+            return new LfNetworkList(load(network, networkParameters, reporter));
         } else {
             String tmpVariantId = "olf-tmp-" + UUID.randomUUID();
-            String variantId = network.getVariantManager().getWorkingVariantId();
+            String workingVariantId = network.getVariantManager().getWorkingVariantId();
             network.getVariantManager().cloneVariant(network.getVariantManager().getWorkingVariantId(), tmpVariantId);
             network.getVariantManager().setWorkingVariant(tmpVariantId);
-            try {
-                network.getSwitchStream().filter(sw -> sw.getVoltageLevel().getTopologyKind() == TopologyKind.NODE_BREAKER)
-                        .forEach(sw -> sw.setRetained(false));
-                switchesToOpen.stream().filter(sw -> sw.getVoltageLevel().getTopologyKind() == TopologyKind.NODE_BREAKER)
-                        .forEach(sw -> sw.setRetained(true));
-                switchesToClose.stream().filter(sw -> sw.getVoltageLevel().getTopologyKind() == TopologyKind.NODE_BREAKER)
-                        .forEach(sw -> sw.setRetained(true));
-                switchesToClose.forEach(sw -> sw.setOpen(false)); // in order to be present in the network.
-                return load(network, networkParameters, reporter);
-            } finally {
-                network.getVariantManager().removeVariant(tmpVariantId);
-                network.getVariantManager().setWorkingVariant(variantId);
-            }
+            network.getSwitchStream().filter(sw -> sw.getVoltageLevel().getTopologyKind() == TopologyKind.NODE_BREAKER)
+                    .forEach(sw -> sw.setRetained(false));
+            switchesToOpen.stream().filter(sw -> sw.getVoltageLevel().getTopologyKind() == TopologyKind.NODE_BREAKER)
+                    .forEach(sw -> sw.setRetained(true));
+            switchesToClose.stream().filter(sw -> sw.getVoltageLevel().getTopologyKind() == TopologyKind.NODE_BREAKER)
+                    .forEach(sw -> sw.setRetained(true));
+            switchesToClose.forEach(sw -> sw.setOpen(false)); // in order to be present in the network.
+            return new LfNetworkList(load(network, networkParameters, reporter),
+                                     new LfNetworkList.VariantCleaner(network, workingVariantId, tmpVariantId));
         }
     }
 }

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

@@ -25,6 +25,7 @@
 import com.powsybl.openloadflow.ac.outerloop.AcloadFlowEngine;
 import com.powsybl.openloadflow.graph.GraphConnectivityFactory;
 import com.powsybl.openloadflow.network.*;
+import com.powsybl.openloadflow.network.impl.LfNetworkList;
 import com.powsybl.openloadflow.network.impl.Networks;
 import com.powsybl.openloadflow.network.impl.PropagatedContingency;
 import com.powsybl.openloadflow.network.util.ActivePowerDistribution;
@@ -91,28 +92,29 @@ SecurityAnalysisReport runSync(String workingVariantId, SecurityAnalysisParamete
         AcLoadFlowParameters acParameters = OpenLoadFlowParameters.createAcParameters(network, lfParameters, lfParametersExt, matrixFactory, connectivityFactory, saReporter, breakers, false);
 
         // create networks including all necessary switches
-        List<LfNetwork> lfNetworks = Networks.load(network, acParameters.getNetworkParameters(), allSwitchesToOpen, allSwitchesToClose, saReporter);
-
-        // run simulation on largest network
-        SecurityAnalysisResult result;
-        if (lfNetworks.isEmpty()) {
-            result = createNoResult();
-        } else {
-            LfNetwork largestNetwork = lfNetworks.get(0);
-            if (largestNetwork.isValid()) {
-                Map<String, LfAction> lfActionsById = createLfActions(largestNetwork, actions);
-                Map<String, List<OperatorStrategy>> operatorStrategiesByContingencyId = indexOperatorStrategiesByContingencyId(propagatedContingencies, operatorStrategies);
-                result = runSimulations(largestNetwork, propagatedContingencies, acParameters, securityAnalysisParameters, operatorStrategiesByContingencyId, lfActionsById, allSwitchesToClose);
-            } else {
+        try (LfNetworkList lfNetworks = Networks.load(network, acParameters.getNetworkParameters(), allSwitchesToOpen, allSwitchesToClose, saReporter)) {
+
+            // run simulation on largest network
+            SecurityAnalysisResult result;
+            LfNetwork largestNetwork = lfNetworks.getLargest().orElse(null);
+            if (largestNetwork == null) {
                 result = createNoResult();
+            } else {
+                if (largestNetwork.isValid()) {
+                    Map<String, LfAction> lfActionsById = createLfActions(largestNetwork, actions);
+                    Map<String, List<OperatorStrategy>> operatorStrategiesByContingencyId = indexOperatorStrategiesByContingencyId(propagatedContingencies, operatorStrategies);
+                    result = runSimulations(largestNetwork, propagatedContingencies, acParameters, securityAnalysisParameters, operatorStrategiesByContingencyId, lfActionsById, allSwitchesToClose);
+                } else {
+                    result = createNoResult();
+                }
             }
-        }
 
-        stopwatch.stop();
-        LOGGER.info("Security analysis {} in {} ms", Thread.currentThread().isInterrupted() ? "cancelled" : "done",
-                stopwatch.elapsed(TimeUnit.MILLISECONDS));
+            stopwatch.stop();
+            LOGGER.info("Security analysis {} in {} ms", Thread.currentThread().isInterrupted() ? "cancelled" : "done",
+                    stopwatch.elapsed(TimeUnit.MILLISECONDS));
 
-        return new SecurityAnalysisReport(result);
+            return new SecurityAnalysisReport(result);
+        }
     }
 
     public static void distributedMismatch(LfNetwork network, double mismatch, LoadFlowParameters loadFlowParameters,