SensitivityAnalysisResultTest.java
/**
* Copyright (c) 2018, 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.sensitivity;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.powsybl.commons.test.AbstractSerDeTest;
import com.powsybl.commons.PowsyblException;
import com.powsybl.commons.json.JsonUtil;
import com.powsybl.contingency.*;
import com.powsybl.sensitivity.json.SensitivityJsonModule;
import org.junit.jupiter.api.Test;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import static org.junit.jupiter.api.Assertions.*;
/**
* @author Geoffroy Jamgotchian {@literal <geoffroy.jamgotchian at rte-france.com>}
*/
class SensitivityAnalysisResultTest extends AbstractSerDeTest {
@Test
void testSide1() {
SensitivityFactor factor1 = new SensitivityFactor(SensitivityFunctionType.BRANCH_ACTIVE_POWER_1, "l",
SensitivityVariableType.INJECTION_ACTIVE_POWER, "g",
false, ContingencyContext.all());
SensitivityFactor factor2 = new SensitivityFactor(SensitivityFunctionType.BRANCH_ACTIVE_POWER_1, "l2",
SensitivityVariableType.INJECTION_ACTIVE_POWER, "g2",
false, ContingencyContext.none());
SensitivityFactor factor3 = new SensitivityFactor(SensitivityFunctionType.BRANCH_CURRENT_1, "l",
SensitivityVariableType.TRANSFORMER_PHASE_1, "g",
false, ContingencyContext.all());
SensitivityFactor factor4 = new SensitivityFactor(SensitivityFunctionType.BRANCH_CURRENT_1, "l2",
SensitivityVariableType.TRANSFORMER_PHASE_2, "g2",
false, ContingencyContext.none());
SensitivityFactor factor5 = new SensitivityFactor(SensitivityFunctionType.BRANCH_CURRENT_1, "l2",
SensitivityVariableType.TRANSFORMER_PHASE_3, "g2",
false, ContingencyContext.none());
List<SensitivityFactor> factors = List.of(factor1, factor2, factor3, factor4, factor5);
factors.forEach(f -> assertEquals(1, f.getFunctionType().getSide().orElse(0)));
SensitivityValue value1 = new SensitivityValue(0, 0, 1d, 2d);
SensitivityValue value2 = new SensitivityValue(1, -1, 3d, 4d);
SensitivityValue value3 = new SensitivityValue(2, 0, 1d, 2d);
SensitivityValue value4 = new SensitivityValue(3, -1, 3d, 4d);
SensitivityValue value5 = new SensitivityValue(4, -1, 4d, 4d);
List<SensitivityAnalysisResult.SensitivityContingencyStatus> contingencyStatus = new ArrayList<>();
contingencyStatus.add(new SensitivityAnalysisResult.SensitivityContingencyStatus("NHV1_NHV2_2", SensitivityAnalysisResult.Status.SUCCESS));
contingencyStatus.add(new SensitivityAnalysisResult.SensitivityContingencyStatus("NHV2_NHV3", SensitivityAnalysisResult.Status.NO_IMPACT));
List<SensitivityValue> values = List.of(value1, value2, value3, value4, value5);
SensitivityAnalysisResult result = new SensitivityAnalysisResult(factors, contingencyStatus, values);
assertEquals(5, result.getValues().size());
assertEquals(2, result.getValues("NHV1_NHV2_2").size());
assertEquals(1d, result.getSensitivityValue("NHV1_NHV2_2", "g", "l", SensitivityFunctionType.BRANCH_ACTIVE_POWER_1, SensitivityVariableType.INJECTION_ACTIVE_POWER), 0d);
assertEquals(2d, result.getFunctionReferenceValue("NHV1_NHV2_2", "l", SensitivityFunctionType.BRANCH_ACTIVE_POWER_1), 0d);
assertEquals(1d, result.getBranchFlow1SensitivityValue("NHV1_NHV2_2", "g", "l", SensitivityVariableType.INJECTION_ACTIVE_POWER), 0d);
assertEquals(2d, result.getBranchFlow1FunctionReferenceValue("NHV1_NHV2_2", "l"), 0d);
assertEquals(1d, result.getSensitivityValue("NHV1_NHV2_2", "g", "l", SensitivityFunctionType.BRANCH_CURRENT_1, SensitivityVariableType.TRANSFORMER_PHASE_1), 0d);
assertEquals(2d, result.getFunctionReferenceValue("NHV1_NHV2_2", "l", SensitivityFunctionType.BRANCH_CURRENT_1), 0d);
assertEquals(1d, result.getBranchCurrent1SensitivityValue("NHV1_NHV2_2", "g", "l", SensitivityVariableType.TRANSFORMER_PHASE_1), 0d);
assertEquals(2d, result.getBranchCurrent1FunctionReferenceValue("NHV1_NHV2_2", "l"), 0d);
assertThrows(PowsyblException.class, () -> result.getFunctionReferenceValue("NHV1_NHV2_2", "llll", SensitivityFunctionType.BRANCH_ACTIVE_POWER_1));
assertThrows(PowsyblException.class, () -> result.getSensitivityValue("NHV1_NHV2_2", "g", "l1", SensitivityFunctionType.BRANCH_ACTIVE_POWER_1, SensitivityVariableType.INJECTION_ACTIVE_POWER));
assertEquals(3d, result.getSensitivityValue(null, "g2", "l2", SensitivityFunctionType.BRANCH_ACTIVE_POWER_1, SensitivityVariableType.INJECTION_ACTIVE_POWER), 0d);
assertEquals(3d, result.getBranchFlow1SensitivityValue("g2", "l2", SensitivityVariableType.INJECTION_ACTIVE_POWER), 0d);
assertEquals(3d, result.getSensitivityValue("g2", "l2", SensitivityFunctionType.BRANCH_ACTIVE_POWER_1, SensitivityVariableType.INJECTION_ACTIVE_POWER), 0d);
assertEquals(3d, result.getBranchCurrent1SensitivityValue("g2", "l2", SensitivityVariableType.TRANSFORMER_PHASE_2), 0d);
assertEquals(4d, result.getBranchCurrent1SensitivityValue("g2", "l2", SensitivityVariableType.TRANSFORMER_PHASE_3), 0d);
assertEquals(4d, result.getBranchFlow1FunctionReferenceValue("l2"), 0d);
assertEquals(4d, result.getBranchCurrent1FunctionReferenceValue("l2"), 0d);
assertEquals(3, result.getPreContingencyValues().size());
assertEquals(SensitivityAnalysisResult.Status.SUCCESS, result.getContingencyStatus("NHV1_NHV2_2"));
assertEquals(SensitivityAnalysisResult.Status.NO_IMPACT, result.getContingencyStatus("NHV2_NHV3"));
}
@Test
void testSide2() {
SensitivityFactor factor1 = new SensitivityFactor(SensitivityFunctionType.BRANCH_ACTIVE_POWER_2, "l",
SensitivityVariableType.INJECTION_ACTIVE_POWER, "g",
false, ContingencyContext.all());
SensitivityFactor factor2 = new SensitivityFactor(SensitivityFunctionType.BRANCH_ACTIVE_POWER_2, "l2",
SensitivityVariableType.INJECTION_ACTIVE_POWER, "g2",
false, ContingencyContext.none());
SensitivityFactor factor3 = new SensitivityFactor(SensitivityFunctionType.BRANCH_CURRENT_2, "l",
SensitivityVariableType.INJECTION_ACTIVE_POWER, "g",
false, ContingencyContext.all());
SensitivityFactor factor4 = new SensitivityFactor(SensitivityFunctionType.BRANCH_CURRENT_2, "l2",
SensitivityVariableType.INJECTION_ACTIVE_POWER, "g2",
false, ContingencyContext.none());
SensitivityFactor factor5 = new SensitivityFactor(SensitivityFunctionType.BRANCH_CURRENT_2, "l2",
SensitivityVariableType.TRANSFORMER_PHASE_3, "g2",
false, ContingencyContext.none());
List<SensitivityFactor> factors = List.of(factor1, factor2, factor3, factor4, factor5);
factors.forEach(f -> assertEquals(2, f.getFunctionType().getSide().orElse(0)));
List<Contingency> contingencies = List.of(new Contingency("NHV1_NHV2_2", new BranchContingency("NHV1_NHV2_2")));
SensitivityValue value1 = new SensitivityValue(0, 0, 1d, 2d);
SensitivityValue value2 = new SensitivityValue(1, -1, 3d, 4d);
SensitivityValue value3 = new SensitivityValue(2, 0, 1d, 2d);
SensitivityValue value4 = new SensitivityValue(3, -1, 3d, 4d);
SensitivityValue value5 = new SensitivityValue(4, -1, 6d, 4d);
List<SensitivityValue> values = List.of(value1, value2, value3, value4, value5);
List<SensitivityAnalysisResult.SensitivityContingencyStatus> contingencyStatus = new ArrayList<>();
contingencies.forEach(c -> contingencyStatus.add(new SensitivityAnalysisResult.SensitivityContingencyStatus(c.getId(), SensitivityAnalysisResult.Status.SUCCESS)));
SensitivityAnalysisResult result = new SensitivityAnalysisResult(factors, contingencyStatus, values);
assertEquals(5, result.getValues().size());
assertEquals(2, result.getValues("NHV1_NHV2_2").size());
assertEquals(1d, result.getSensitivityValue("NHV1_NHV2_2", "g", "l", SensitivityFunctionType.BRANCH_ACTIVE_POWER_2, SensitivityVariableType.INJECTION_ACTIVE_POWER), 0d);
assertEquals(2d, result.getFunctionReferenceValue("NHV1_NHV2_2", "l", SensitivityFunctionType.BRANCH_ACTIVE_POWER_2), 0d);
assertEquals(1d, result.getBranchFlow2SensitivityValue("NHV1_NHV2_2", "g", "l", SensitivityVariableType.INJECTION_ACTIVE_POWER), 0d);
assertEquals(2d, result.getBranchFlow2FunctionReferenceValue("NHV1_NHV2_2", "l"), 0d);
assertEquals(1d, result.getSensitivityValue("NHV1_NHV2_2", "g", "l", SensitivityFunctionType.BRANCH_CURRENT_2, SensitivityVariableType.INJECTION_ACTIVE_POWER), 0d);
assertEquals(2d, result.getFunctionReferenceValue("NHV1_NHV2_2", "l", SensitivityFunctionType.BRANCH_CURRENT_2), 0d);
assertEquals(1d, result.getBranchCurrent2SensitivityValue("NHV1_NHV2_2", "g", "l", SensitivityVariableType.INJECTION_ACTIVE_POWER), 0d);
assertEquals(2d, result.getBranchCurrent2FunctionReferenceValue("NHV1_NHV2_2", "l"), 0d);
assertThrows(PowsyblException.class, () -> result.getFunctionReferenceValue("NHV1_NHV2_2", "llll", SensitivityFunctionType.BRANCH_ACTIVE_POWER_2));
assertThrows(PowsyblException.class, () -> result.getSensitivityValue("NHV1_NHV2_2", "g", "l1", SensitivityFunctionType.BRANCH_ACTIVE_POWER_2, SensitivityVariableType.INJECTION_ACTIVE_POWER));
assertEquals(3d, result.getSensitivityValue(null, "g2", "l2", SensitivityFunctionType.BRANCH_ACTIVE_POWER_2, SensitivityVariableType.INJECTION_ACTIVE_POWER), 0d);
assertEquals(3d, result.getBranchFlow2SensitivityValue("g2", "l2", SensitivityVariableType.INJECTION_ACTIVE_POWER), 0d);
assertEquals(3d, result.getBranchCurrent2SensitivityValue("g2", "l2", SensitivityVariableType.INJECTION_ACTIVE_POWER), 0d);
assertEquals(6d, result.getBranchCurrent2SensitivityValue("g2", "l2", SensitivityVariableType.TRANSFORMER_PHASE_3), 0d);
assertEquals(4d, result.getBranchFlow2FunctionReferenceValue("l2"), 0d);
assertEquals(4d, result.getBranchCurrent2FunctionReferenceValue("l2"), 0d);
assertEquals(3, result.getPreContingencyValues().size());
}
@Test
void testSide3() {
SensitivityFactor factor1 = new SensitivityFactor(SensitivityFunctionType.BRANCH_ACTIVE_POWER_3, "l",
SensitivityVariableType.INJECTION_ACTIVE_POWER, "g",
false, ContingencyContext.all());
SensitivityFactor factor2 = new SensitivityFactor(SensitivityFunctionType.BRANCH_ACTIVE_POWER_3, "l2",
SensitivityVariableType.INJECTION_ACTIVE_POWER, "g2",
false, ContingencyContext.none());
SensitivityFactor factor3 = new SensitivityFactor(SensitivityFunctionType.BRANCH_CURRENT_3, "l",
SensitivityVariableType.INJECTION_ACTIVE_POWER, "g",
false, ContingencyContext.all());
SensitivityFactor factor4 = new SensitivityFactor(SensitivityFunctionType.BRANCH_CURRENT_3, "l2",
SensitivityVariableType.INJECTION_ACTIVE_POWER, "g2",
false, ContingencyContext.none());
SensitivityFactor factor5 = new SensitivityFactor(SensitivityFunctionType.BRANCH_CURRENT_3, "l2",
SensitivityVariableType.TRANSFORMER_PHASE_1, "g2",
false, ContingencyContext.none());
List<SensitivityFactor> factors = List.of(factor1, factor2, factor3, factor4, factor5);
factors.forEach(f -> assertEquals(3, f.getFunctionType().getSide().orElse(0)));
List<Contingency> contingencies = List.of(new Contingency("NHV1_NHV2_2", new BranchContingency("NHV1_NHV2_2")));
SensitivityValue value1 = new SensitivityValue(0, 0, 2d, 2d);
SensitivityValue value2 = new SensitivityValue(1, -1, 6d, 4d);
SensitivityValue value3 = new SensitivityValue(2, 0, 2d, 2d);
SensitivityValue value4 = new SensitivityValue(3, -1, 6d, 4d);
SensitivityValue value5 = new SensitivityValue(4, -1, 12d, 4d);
List<SensitivityValue> values = List.of(value1, value2, value3, value4, value5);
List<SensitivityAnalysisResult.SensitivityContingencyStatus> contingencyStatus = new ArrayList<>();
contingencies.forEach(c -> contingencyStatus.add(new SensitivityAnalysisResult.SensitivityContingencyStatus(c.getId(), SensitivityAnalysisResult.Status.SUCCESS)));
SensitivityAnalysisResult result = new SensitivityAnalysisResult(factors, contingencyStatus, values);
assertEquals(5, result.getValues().size());
assertEquals(2, result.getValues("NHV1_NHV2_2").size());
assertEquals(2d, result.getSensitivityValue("NHV1_NHV2_2", "g", "l", SensitivityFunctionType.BRANCH_ACTIVE_POWER_3, SensitivityVariableType.INJECTION_ACTIVE_POWER), 0d);
assertEquals(2d, result.getFunctionReferenceValue("NHV1_NHV2_2", "l", SensitivityFunctionType.BRANCH_ACTIVE_POWER_3), 0d);
assertEquals(2d, result.getBranchFlow3SensitivityValue("NHV1_NHV2_2", "g", "l", SensitivityVariableType.INJECTION_ACTIVE_POWER), 0d);
assertEquals(2d, result.getBranchFlow3FunctionReferenceValue("NHV1_NHV2_2", "l"), 0d);
assertEquals(2d, result.getSensitivityValue("NHV1_NHV2_2", "g", "l", SensitivityFunctionType.BRANCH_CURRENT_3, SensitivityVariableType.INJECTION_ACTIVE_POWER), 0d);
assertEquals(2d, result.getFunctionReferenceValue("NHV1_NHV2_2", "l", SensitivityFunctionType.BRANCH_CURRENT_3), 0d);
assertEquals(2d, result.getBranchCurrent3SensitivityValue("NHV1_NHV2_2", "g", "l", SensitivityVariableType.INJECTION_ACTIVE_POWER), 0d);
assertEquals(2d, result.getBranchCurrent3FunctionReferenceValue("NHV1_NHV2_2", "l"), 0d);
assertEquals(4d, result.getFunctionReferenceValue("l2", SensitivityFunctionType.BRANCH_CURRENT_3), 0d);
assertThrows(PowsyblException.class, () -> result.getFunctionReferenceValue("NHV1_NHV2_2", "llll", SensitivityFunctionType.BRANCH_ACTIVE_POWER_3));
assertThrows(PowsyblException.class, () -> result.getSensitivityValue("NHV1_NHV2_2", "g", "l1", SensitivityFunctionType.BRANCH_ACTIVE_POWER_3, SensitivityVariableType.INJECTION_ACTIVE_POWER));
assertEquals(6d, result.getSensitivityValue(null, "g2", "l2", SensitivityFunctionType.BRANCH_ACTIVE_POWER_3, SensitivityVariableType.INJECTION_ACTIVE_POWER), 0d);
assertEquals(6d, result.getBranchFlow3SensitivityValue("g2", "l2", SensitivityVariableType.INJECTION_ACTIVE_POWER), 0d);
assertEquals(6d, result.getBranchCurrent3SensitivityValue("g2", "l2", SensitivityVariableType.INJECTION_ACTIVE_POWER), 0d);
assertEquals(12d, result.getBranchCurrent3SensitivityValue("g2", "l2", SensitivityVariableType.TRANSFORMER_PHASE_1), 0d);
assertEquals(4d, result.getBranchFlow3FunctionReferenceValue("l2"), 0d);
assertEquals(4d, result.getBranchCurrent3FunctionReferenceValue("l2"), 0d);
assertEquals(3, result.getPreContingencyValues().size());
}
@Test
void testBusVoltage() {
SensitivityFactor factor1 = new SensitivityFactor(SensitivityFunctionType.BUS_VOLTAGE, "l",
SensitivityVariableType.BUS_TARGET_VOLTAGE, "g",
false, ContingencyContext.all());
SensitivityFactor factor2 = new SensitivityFactor(SensitivityFunctionType.BUS_VOLTAGE, "l2",
SensitivityVariableType.BUS_TARGET_VOLTAGE, "g2",
false, ContingencyContext.none());
SensitivityFactor factor3 = new SensitivityFactor(SensitivityFunctionType.BUS_VOLTAGE, "l2",
SensitivityVariableType.TRANSFORMER_PHASE_1, "g2",
false, ContingencyContext.none());
SensitivityFactor factor4 = new SensitivityFactor(SensitivityFunctionType.BUS_VOLTAGE, "l3",
SensitivityVariableType.TRANSFORMER_PHASE_2, "g2",
false, ContingencyContext.none());
List<SensitivityFactor> factors = List.of(factor1, factor2, factor3, factor4);
List<Contingency> contingencies = List.of(new Contingency("NHV1_NHV2_2", new BranchContingency("NHV1_NHV2_2")));
SensitivityValue value1 = new SensitivityValue(0, 0, 1d, 2d);
SensitivityValue value2 = new SensitivityValue(1, -1, 3d, 4d);
SensitivityValue value3 = new SensitivityValue(2, -1, 6d, 4d);
SensitivityValue value4 = new SensitivityValue(3, -1, 12d, 6d);
List<SensitivityValue> values = List.of(value1, value2, value3, value4);
List<SensitivityAnalysisResult.SensitivityContingencyStatus> contingencyStatus = new ArrayList<>();
contingencies.forEach(c -> contingencyStatus.add(new SensitivityAnalysisResult.SensitivityContingencyStatus(c.getId(), SensitivityAnalysisResult.Status.SUCCESS)));
SensitivityAnalysisResult result = new SensitivityAnalysisResult(factors, contingencyStatus, values);
assertEquals(4, result.getValues().size());
assertEquals(1, result.getValues("NHV1_NHV2_2").size());
assertEquals(1d, result.getSensitivityValue("NHV1_NHV2_2", "g", "l", SensitivityFunctionType.BUS_VOLTAGE, SensitivityVariableType.BUS_TARGET_VOLTAGE), 0d);
assertEquals(2d, result.getFunctionReferenceValue("NHV1_NHV2_2", "l", SensitivityFunctionType.BUS_VOLTAGE), 0d);
assertEquals(4d, result.getFunctionReferenceValue("l2", SensitivityFunctionType.BUS_VOLTAGE), 0d);
assertEquals(4d, result.getBusVoltageFunctionReferenceValue("l2"), 0d);
assertEquals(1d, result.getBusVoltageSensitivityValue("NHV1_NHV2_2", "g", "l", SensitivityVariableType.BUS_TARGET_VOLTAGE), 0d);
assertEquals(3d, result.getBusVoltageSensitivityValue("g2", "l2", SensitivityVariableType.BUS_TARGET_VOLTAGE), 0d);
assertEquals(6d, result.getBusVoltageSensitivityValue("g2", "l2", SensitivityVariableType.TRANSFORMER_PHASE_1), 0d);
assertEquals(6d, result.getBusVoltageFunctionReferenceValue("l3"), 0d);
assertEquals(12d, result.getBusVoltageSensitivityValue("g2", "l3", SensitivityVariableType.TRANSFORMER_PHASE_2), 0d);
assertEquals(2d, result.getBusVoltageFunctionReferenceValue("NHV1_NHV2_2", "l"), 0d);
}
@Test
void testCompareSensivitiyValueKeysEqualsNotEquals() {
SensitivityValueKey key1 = new SensitivityValueKey(null, "l1", "g1", SensitivityFunctionType.BRANCH_CURRENT_1, SensitivityVariableType.BUS_TARGET_VOLTAGE);
SensitivityValueKey key2 = new SensitivityValueKey("c1", "l1", "g1", SensitivityFunctionType.BRANCH_CURRENT_1, SensitivityVariableType.BUS_TARGET_VOLTAGE);
SensitivityValueKey key3 = new SensitivityValueKey(null, "l1", "g1", SensitivityFunctionType.BRANCH_CURRENT_2, SensitivityVariableType.BUS_TARGET_VOLTAGE);
SensitivityValueKey key4 = new SensitivityValueKey(null, "l2", "g1", SensitivityFunctionType.BRANCH_CURRENT_2, SensitivityVariableType.BUS_TARGET_VOLTAGE);
SensitivityValueKey key5 = new SensitivityValueKey(null, "l2", "g3", SensitivityFunctionType.BRANCH_CURRENT_2, SensitivityVariableType.BUS_TARGET_VOLTAGE);
SensitivityValueKey key6 = new SensitivityValueKey(null, "l2", "g3", SensitivityFunctionType.BRANCH_CURRENT_2, SensitivityVariableType.TRANSFORMER_PHASE);
assertEquals(key1, key1);
assertNotEquals(key1, key2);
assertNotEquals(key2, key3);
assertNotEquals(key3, key4);
assertNotEquals(key4, key5);
assertNotEquals(key5, key6);
String dummy = "dummy";
assertNotEquals(key1, dummy);
}
@Test
void testSerializeDeserialize() throws IOException {
SensitivityFactor factor1 = new SensitivityFactor(SensitivityFunctionType.BRANCH_ACTIVE_POWER_1, "l",
SensitivityVariableType.INJECTION_ACTIVE_POWER, "g",
false, ContingencyContext.all());
SensitivityFactor factor2 = new SensitivityFactor(SensitivityFunctionType.BRANCH_ACTIVE_POWER_1, "l2",
SensitivityVariableType.INJECTION_ACTIVE_POWER, "g2",
false, ContingencyContext.none());
SensitivityFactor factor3 = new SensitivityFactor(SensitivityFunctionType.BRANCH_CURRENT_1, "l",
SensitivityVariableType.INJECTION_ACTIVE_POWER, "g",
false, ContingencyContext.all());
SensitivityFactor factor4 = new SensitivityFactor(SensitivityFunctionType.BRANCH_CURRENT_1, "l2",
SensitivityVariableType.INJECTION_ACTIVE_POWER, "g2",
false, ContingencyContext.none());
List<SensitivityFactor> factors = List.of(factor1, factor2, factor3, factor4);
SensitivityValue value1 = new SensitivityValue(0, 0, 1d, 2d);
SensitivityValue value2 = new SensitivityValue(1, -1, 3d, 4d);
SensitivityValue value3 = new SensitivityValue(2, 0, 1d, 2d);
SensitivityValue value4 = new SensitivityValue(3, -1, 3d, 4d);
List<SensitivityValue> values = List.of(value1, value2, value3, value4);
List<Contingency> contingencies = List.of(new Contingency("NHV1_NHV2_2", new BranchContingency("NHV1_NHV2_2")));
List<SensitivityAnalysisResult.SensitivityContingencyStatus> contingencyStatus = new ArrayList<>();
contingencies.forEach(c -> contingencyStatus.add(new SensitivityAnalysisResult.SensitivityContingencyStatus(c.getId(), SensitivityAnalysisResult.Status.SUCCESS)));
SensitivityAnalysisResult result = new SensitivityAnalysisResult(factors, contingencyStatus, values);
ObjectMapper objectMapper = JsonUtil.createObjectMapper().registerModule(new SensitivityJsonModule());
roundTripTest(result, (result2, jsonFile) -> JsonUtil.writeJson(jsonFile, result, objectMapper),
jsonFile -> JsonUtil.readJson(jsonFile, SensitivityAnalysisResult.class, objectMapper), "/SensitivityAnalysisResultRefV1.json");
}
}