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 String getTableTitle(Network network, String tableName) { return tableName + " (" + network.getId() + "/" + network.getVariantManager().getWorkingVariantId() + ")"; }
public static void dumpVariantId(Path workingDir, Network network) throws IOException { dumpVariantId(workingDir, network.getVariantManager().getWorkingVariantId()); }
@Override public List<CommandExecution> before(Path workingDir) throws IOException { network.getVariantManager().setWorkingVariant(workingStateId); copyInputFiles(workingDir); return buildCommandExecution(); }
@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; }
network.getVariantManager().allowVariantMultiThreadAccess(true); 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);
network.getVariantManager().allowVariantMultiThreadAccess(true); securityAnalysis.run(network.getVariantManager().getWorkingVariantId(), parameters, contingencyListProvider) .handleAsync((result, throwable) -> { if (throwable == null) {
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(); });
@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)); } } } }
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); } } }
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 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))); }