How to use

getWorkingVariantId

method

in

com.powsybl.iidm.network.VariantManager

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();
  }
}

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

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

@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;
}

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

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);

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

@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)));
}

  @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));
      }
    }
  }
}

String stateId = network.getVariantManager().getWorkingVariantId();
String tmpStateId = "phase-shifter-optim-" + UUID.randomUUID();
network.getVariantManager().cloneVariant(stateId, tmpStateId);