How to use

VariantManager

in

com.powsybl.iidm.network

public static Map<String, String> getExecutionTags(Network network) {
  return ImmutableMap.of("variant", network.getVariantManager().getWorkingVariantId());
}

  public SecurityAnalysisResult analyze(Network network, ContingenciesProvider contingenciesProvider, SecurityAnalysisParameters parameters) {
    Objects.requireNonNull(network);
    Objects.requireNonNull(contingenciesProvider);
    Objects.requireNonNull(parameters);

    network.getVariantManager().allowVariantMultiThreadAccess(true);

    SecurityAnalysis securityAnalysis = securityAnalysisFactory.create(network, filter, computationManager, priority);
    interceptors.forEach(securityAnalysis::addInterceptor);

    return securityAnalysis.run(network.getVariantManager().getWorkingVariantId(), parameters, contingenciesProvider).join();
  }
}

@Override
public List<CommandExecution> before(Path workingDir) throws IOException {
  network.getVariantManager().setWorkingVariant(workingStateId);
  copyInputFiles(workingDir);
  return buildCommandExecution();
}

String stateId = network.getVariantManager().getWorkingVariantId();
String tmpStateId = "phase-shifter-optim-" + UUID.randomUUID();
network.getVariantManager().cloneVariant(stateId, tmpStateId);
try {
  network.getVariantManager().setWorkingVariant(tmpStateId);
  LoadFlowFactory loadFlowFactory = config.getLoadFlowFactoryClass().newInstance();
  LoadFlow loadFlow = loadFlowFactory.create(network, computationManager, 0);
} finally {
  network.getVariantManager().removeVariant(tmpStateId);
  network.getVariantManager().setWorkingVariant(stateId);

  @Override
  public void onPostContingencyResult(RunningContext context, PostContingencyResult postContingencyResult) {
    String workingStateId = context.getNetwork().getVariantManager().getWorkingVariantId();

    for (LimitViolation limitViolation : postContingencyResult.getLimitViolationsResult().getLimitViolations()) {
      if (limitViolation.getLimitType() == LimitViolationType.CURRENT) {
        Branch branch = context.getNetwork().getBranch(limitViolation.getSubjectId());

        context.getNetwork().getVariantManager().setWorkingVariant(context.getInitialStateId());
        limitViolation.addExtension(CurrentExtension.class, new CurrentExtension(branch.getTerminal(limitViolation.getSide()).getI()));
        double preContingencyValue = branch.getTerminal(limitViolation.getSide()).getP();

        context.getNetwork().getVariantManager().setWorkingVariant(workingStateId);
        double postContingencyValue = branch.getTerminal(limitViolation.getSide()).getP();

        limitViolation.addExtension(ActivePowerExtension.class, new ActivePowerExtension(preContingencyValue, postContingencyValue));
      }
    }
  }
}

network.getVariantManager().setWorkingVariant(workingStateId);
          network.getVariantManager().cloneVariant(VariantManagerConstants.INITIAL_VARIANT_ID, postContStateId);
          network.getVariantManager().setWorkingVariant(postContStateId);
        .thenComposeAsync(aVoid -> loadFlow.run(postContStateId, postContParameters), computationManager.getExecutor())
        .handleAsync((lfResult, throwable) -> {
          network.getVariantManager().setWorkingVariant(postContStateId);
          violationDetector.checkAll(network, resultBuilder::addViolation);
          resultBuilder.endContingency();
          network.getVariantManager().removeVariant(postContStateId);
    network.getVariantManager().setWorkingVariant(workingStateId);
    return resultBuilder.build();
  });

private void runSingleAnalysis(ToolRunningContext context, Path caseFile, Path outputCsvFile, Set<String> contingencyIds, ContingenciesProvider contingenciesProvider,
                SimulatorFactory simulatorFactory) throws Exception {
  context.getOutputStream().println("loading case " + caseFile + "...");
  // load the network
  Network network = Importers.loadNetwork(caseFile);
  if (network == null) {
    throw new PowsyblException("Case '" + caseFile + "' not found");
  }
  network.getVariantManager().allowVariantMultiThreadAccess(true);
  Multimap<String, SecurityIndex> securityIndexesPerContingency
      = runImpactAnalysis(network, contingencyIds, context.getShortTimeExecutionComputationManager(),
      simulatorFactory, contingenciesProvider, context.getOutputStream());
  if (securityIndexesPerContingency != null) {
    if (outputCsvFile == null) {
      prettyPrint(securityIndexesPerContingency, context.getOutputStream());
    } else {
      writeCsv(securityIndexesPerContingency, outputCsvFile);
    }
  }
}

public static String getTableTitle(Network network, String tableName) {
  return tableName + " (" + network.getId() + "/" + network.getVariantManager().getWorkingVariantId() + ")";
}

network.getVariantManager().allowVariantMultiThreadAccess(true);
String currentState = network.getVariantManager().getWorkingVariantId();

public static void dumpVariantId(Path workingDir, Network network) throws IOException {
  dumpVariantId(workingDir, network.getVariantManager().getWorkingVariantId());
}

network.getVariantManager().allowVariantMultiThreadAccess(true);
securityAnalysis.run(network.getVariantManager().getWorkingVariantId(), parameters, contingencyListProvider)
    .handleAsync((result, throwable) -> {
      if (throwable == null) {

@Override
public Network importData(ReadOnlyDataSource dataSource, Properties parameters) {
  Network network = Mockito.mock(Network.class);
  VariantManager variantManager = Mockito.mock(VariantManager.class);
  Mockito.when(variantManager.getWorkingVariantId()).thenReturn("s1");
  Mockito.when(network.getVariantManager()).thenReturn(variantManager);
  return network;
}

LoadFlowResult result = loadFlow.run(network.getVariantManager().getWorkingVariantId(), params).join();

String workingStateId = network.getVariantManager().getWorkingVariantId();
SensitivityFactorsProviderFactory factorsProviderFactory = defaultConfig.newFactoryImpl(SensitivityFactorsProviderFactory.class);
SensitivityFactorsProvider factorsProvider = factorsProviderFactory.create(sensitivityFactorsFile);

@Override
public void run(Network network, ComputationManager computationManager) {
  Objects.requireNonNull(network);
  LOGGER.info("Running {} on network {}, state {}", getName(), network.getId(), network.getVariantManager().getWorkingVariantId());
  LOGGER.info("LoadFlowResultsCompletionParameters={}", parameters);
  LOGGER.info("LoadFlowParameters={}", lfParameters);

new RunningContext(network, network.getVariantManager().getWorkingVariantId()));

@Test
public void failedResult() {
  SecurityAnalysisResultBuilder builder = new SecurityAnalysisResultBuilder(new LimitViolationFilter(),
      new RunningContext(network, network.getVariantManager().getWorkingVariantId()));
  SecurityAnalysisResult res = builder.preContingency().setComputationOk(false).endPreContingency().build();
  assertFalse(res.getPreContingencyResult().isComputationOk());
  assertTrue(res.getPreContingencyResult().getLimitViolations().isEmpty());
  assertTrue(res.getPostContingencyResults().isEmpty());
}

@Test
public void exceptions() {
  SecurityAnalysisResultBuilder builder = new SecurityAnalysisResultBuilder(new LimitViolationFilter(),
      new RunningContext(network, network.getVariantManager().getWorkingVariantId()));
  assertThatIllegalStateException().isThrownBy(() -> builder.build());
  List<LimitViolation> violations = Security.checkLimits(network);
  assertThatIllegalStateException().isThrownBy(() -> builder.addViolation(violations.get(0)));
  builder.preContingency()
      .endPreContingency();
  assertThatIllegalStateException().isThrownBy(() -> builder.addViolation(violations.get(0)));
  builder.contingency(new Contingency("contingency"))
      .endContingency();
  assertThatIllegalStateException().isThrownBy(() -> builder.addViolation(violations.get(0)));
}