ShortCircuitAnalysisTest.java
/**
* Copyright (c) 2021, 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/.
* SPDX-License-Identifier: MPL-2.0
*/
package com.powsybl.shortcircuit;
import com.powsybl.commons.PowsyblException;
import com.powsybl.commons.report.PowsyblCoreReportResourceBundle;
import com.powsybl.commons.test.PowsyblCoreTestReportResourceBundle;
import com.powsybl.commons.report.ReportNode;
import com.powsybl.computation.ComputationManager;
import com.powsybl.iidm.network.Network;
import com.powsybl.iidm.network.ThreeSides;
import com.powsybl.iidm.network.TwoSides;
import com.powsybl.iidm.network.VariantManager;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.Mockito;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import static org.junit.jupiter.api.Assertions.*;
/**
* @author Bertrand Rix {@literal <bertrand.rix at artelys.com>}
*/
class ShortCircuitAnalysisTest {
@Test
void shortCircuitAnalysisWithDummyProvider() {
ShortCircuitAnalysisProvider provider = new ShortCircuitAnalysisProvider() {
@Override
public String getName() {
return "DummyProvider";
}
@Override
public String getVersion() {
return "0.0";
}
@Override
public CompletableFuture<ShortCircuitAnalysisResult> run(Network network,
List<Fault> fault,
ShortCircuitParameters parameters,
ComputationManager computationManager,
List<FaultParameters> faultParameters) {
return CompletableFuture.supplyAsync(() -> new ShortCircuitAnalysisResult(Collections.emptyList()));
}
};
ShortCircuitAnalysisResult res = provider.run(null, null, null, null, null).join();
assertEquals(0, res.getFaultResults().size());
}
private static final String DEFAULT_PROVIDER_NAME = "ShortCircuitAnalysisMock";
private Network network;
private ComputationManager computationManager;
private ShortCircuitParameters shortCircuitParameters;
private List<Fault> faults;
private List<FaultParameters> faultParameters;
@BeforeEach
void setUp() {
network = Mockito.mock(Network.class);
VariantManager variantManager = Mockito.mock(VariantManager.class);
Mockito.when(network.getVariantManager()).thenReturn(variantManager);
Mockito.when(variantManager.getWorkingVariantId()).thenReturn("v");
computationManager = Mockito.mock(ComputationManager.class);
shortCircuitParameters = Mockito.mock(ShortCircuitParameters.class);
faults = Mockito.mock(List.class);
faultParameters = Mockito.mock(List.class);
}
@Test
void test() {
ShortCircuitAnalysisResult result = TestingResultFactory.createResult();
assertNotNull(result.getFaultResult("Fault_ID_1"));
assertEquals(2, result.getFaultResults("BusId").size());
assertEquals(FaultResult.Status.SUCCESS, result.getFaultResult("Fault_ID_1").getStatus());
}
@Test
void testDefaultProvider() {
ShortCircuitAnalysis.Runner defaultShortCircuitAnalysisRunner = ShortCircuitAnalysis.find();
assertEquals(DEFAULT_PROVIDER_NAME, defaultShortCircuitAnalysisRunner.getName());
assertEquals("1.0", defaultShortCircuitAnalysisRunner.getVersion());
}
@Test
void testAsyncDefaultProvider() throws InterruptedException, ExecutionException {
CompletableFuture<ShortCircuitAnalysisResult> result = ShortCircuitAnalysis.runAsync(network, faults, shortCircuitParameters, computationManager, faultParameters);
assertNotNull(result.get());
}
@Test
void testSyncDefaultProvider() {
ShortCircuitAnalysisResult result = ShortCircuitAnalysis.run(network, faults, shortCircuitParameters, computationManager, faultParameters);
assertNotNull(result);
}
@Test
void testSyncDefaultProviderWithoutComputationManager() {
ShortCircuitAnalysisResult result = ShortCircuitAnalysis.run(network, faults, shortCircuitParameters, faultParameters);
assertNotNull(result);
}
@Test
void testSyncDefaultProviderWithoutParameters() {
ShortCircuitAnalysisResult result = ShortCircuitAnalysis.run(network, faults);
assertNotNull(result);
}
@Test
void testWithReportNode() {
ReportNode reportNode = ReportNode.newRootReportNode()
.withResourceBundles(PowsyblCoreTestReportResourceBundle.TEST_BASE_NAME, PowsyblCoreReportResourceBundle.BASE_NAME)
.withMessageTemplate("testReportShortCircuit")
.build();
ShortCircuitAnalysisResult result = ShortCircuitAnalysis.run(network, faults, shortCircuitParameters, computationManager, faultParameters, reportNode);
assertNotNull(result);
List<ReportNode> children = reportNode.getChildren();
assertEquals(1, children.size());
ReportNode reportNodeChild = children.get(0);
assertEquals("MockShortCircuit", reportNodeChild.getMessageKey());
assertEquals("Running mock short circuit", reportNodeChild.getMessage());
assertTrue(reportNodeChild.getChildren().isEmpty());
}
@Test
void testFortescueTransformation() {
// test based on a result given in degrees for both fortescue and phase
double pi = Math.PI;
FortescueValue fortescueValue = new FortescueValue(86.8086319, 0., 0., 1.83823431 * pi / 180, 0., 0.);
FortescueValue.ThreePhaseValue threePhaseValue = fortescueValue.toThreePhaseValue();
assertEquals(50.118988, threePhaseValue.getMagnitudeA(), 0.00001);
assertEquals(50.118988, threePhaseValue.getMagnitudeB(), 0.00001);
assertEquals(50.118988, threePhaseValue.getMagnitudeC(), 0.00001);
assertEquals(1.83823431 * pi / 180, threePhaseValue.getAngleA(), 0.00001);
assertEquals(-118.161751 * pi / 180, threePhaseValue.getAngleB(), 0.00001);
assertEquals(121.838219 * pi / 180, threePhaseValue.getAngleC(), 0.00001);
}
@Test
void testWithMissingVoltageRangesInParameters() {
ShortCircuitParameters invalidShortCircuitParameter = new ShortCircuitParameters()
.setInitialVoltageProfileMode(InitialVoltageProfileMode.CONFIGURED);
Exception e0 = assertThrows(PowsyblException.class, () -> ShortCircuitAnalysis.run(network, faults, invalidShortCircuitParameter, computationManager, faultParameters));
assertEquals("Configured initial voltage profile but nominal voltage ranges with associated coefficients are missing.", e0.getMessage());
}
@Test
void testWithFeederResultsWithoutSide() {
ShortCircuitAnalysisResult result = TestingResultFactory.createWithFeederResults(null);
MagnitudeFeederResult feederResult = (MagnitudeFeederResult) result.getFaultResult("id").getFeederResults().get(0);
assertNotNull(feederResult);
assertEquals("connectableId", feederResult.getConnectableId());
assertEquals(1, feederResult.getCurrent());
assertNull(feederResult.getSide());
}
@Test
void testWithFeederResultsWithSide() {
ShortCircuitAnalysisResult result = TestingResultFactory.createWithFeederResults(ThreeSides.ONE);
MagnitudeFeederResult feederResult = (MagnitudeFeederResult) result.getFaultResult("id").getFeederResults().get(0);
assertNotNull(feederResult);
assertEquals("connectableId", feederResult.getConnectableId());
assertEquals(1, feederResult.getCurrent());
assertEquals(ThreeSides.ONE, feederResult.getSide());
assertEquals(TwoSides.ONE, feederResult.getSideAsTwoSides());
}
}