LoadFlowParametersTest.java
/**
* Copyright (c) 2017, 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.loadflow;
import com.google.common.jimfs.Configuration;
import com.google.common.jimfs.Jimfs;
import com.powsybl.commons.config.InMemoryPlatformConfig;
import com.powsybl.commons.config.MapModuleConfig;
import com.powsybl.commons.extensions.Extension;
import com.powsybl.iidm.network.Country;
import com.powsybl.loadflow.json.JsonLoadFlowParametersTest.DummyExtension;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import java.nio.file.FileSystem;
import java.util.HashSet;
import java.util.Set;
import static org.junit.jupiter.api.Assertions.*;
/**
* @author Christian Biasuzzi {@literal <christian.biasuzzi@techrain.it>}
*/
class LoadFlowParametersTest {
InMemoryPlatformConfig platformConfig;
FileSystem fileSystem;
@BeforeEach
void setUp() {
fileSystem = Jimfs.newFileSystem(Configuration.unix());
platformConfig = new InMemoryPlatformConfig(fileSystem);
}
@AfterEach
void tearDown() throws Exception {
fileSystem.close();
}
private void checkValues(LoadFlowParameters parameters, LoadFlowParameters.VoltageInitMode voltageInitMode,
boolean transformerVoltageControlOn, boolean useReactiveLimits,
boolean phaseShifterRegulationOn, boolean twtSplitShuntAdmittance,
boolean simulShunt, boolean readSlackBus, boolean writeSlackBus,
boolean dc, boolean distributedSlack, LoadFlowParameters.BalanceType balanceType,
boolean dcUseTransformerRatio, Set<Country> countriesToBalance,
LoadFlowParameters.ConnectedComponentMode computedConnectedComponent,
boolean hvdcAcEmulation, double dcPowerFactor) {
assertEquals(parameters.getVoltageInitMode(), voltageInitMode);
assertEquals(parameters.isTransformerVoltageControlOn(), transformerVoltageControlOn);
assertEquals(parameters.isPhaseShifterRegulationOn(), phaseShifterRegulationOn);
assertEquals(parameters.isUseReactiveLimits(), useReactiveLimits);
assertEquals(parameters.isTwtSplitShuntAdmittance(), twtSplitShuntAdmittance);
assertEquals(parameters.isShuntCompensatorVoltageControlOn(), simulShunt);
assertEquals(parameters.isReadSlackBus(), readSlackBus);
assertEquals(parameters.isWriteSlackBus(), writeSlackBus);
assertEquals(parameters.isDc(), dc);
assertEquals(parameters.isDistributedSlack(), distributedSlack);
assertEquals(parameters.getBalanceType(), balanceType);
assertEquals(parameters.isDcUseTransformerRatio(), dcUseTransformerRatio);
assertEquals(parameters.getCountriesToBalance(), countriesToBalance);
assertEquals(parameters.getConnectedComponentMode(), computedConnectedComponent);
assertEquals(parameters.isHvdcAcEmulation(), hvdcAcEmulation);
assertEquals(parameters.getDcPowerFactor(), dcPowerFactor);
}
@Test
void testNoConfig() {
LoadFlowParameters parameters = new LoadFlowParameters();
LoadFlowParameters.load(parameters, platformConfig);
checkValues(parameters, LoadFlowParameters.DEFAULT_VOLTAGE_INIT_MODE,
LoadFlowParameters.DEFAULT_TRANSFORMER_VOLTAGE_CONTROL_ON,
LoadFlowParameters.DEFAULT_USE_REACTIVE_LIMITS,
LoadFlowParameters.DEFAULT_PHASE_SHIFTER_REGULATION_ON,
LoadFlowParameters.DEFAULT_TWT_SPLIT_SHUNT_ADMITTANCE,
LoadFlowParameters.DEFAULT_SHUNT_COMPENSATOR_VOLTAGE_CONTROL_ON,
LoadFlowParameters.DEFAULT_READ_SLACK_BUS,
LoadFlowParameters.DEFAULT_WRITE_SLACK_BUS,
LoadFlowParameters.DEFAULT_DC,
LoadFlowParameters.DEFAULT_DISTRIBUTED_SLACK,
LoadFlowParameters.DEFAULT_BALANCE_TYPE,
LoadFlowParameters.DEFAULT_DC_USE_TRANSFORMER_RATIO_DEFAULT,
LoadFlowParameters.DEFAULT_COUNTRIES_TO_BALANCE,
LoadFlowParameters.DEFAULT_CONNECTED_COMPONENT_MODE,
LoadFlowParameters.DEFAULT_HVDC_AC_EMULATION_ON,
LoadFlowParameters.DEFAULT_DC_POWER_FACTOR);
}
@Test
void checkIncompleteConfig() {
boolean transformerVoltageControlOn = true;
MapModuleConfig moduleConfig = platformConfig.createModuleConfig("load-flow-default-parameters");
moduleConfig.setStringProperty("transformerVoltageControlOn", Boolean.toString(transformerVoltageControlOn));
LoadFlowParameters parameters = new LoadFlowParameters();
LoadFlowParameters.load(parameters, platformConfig);
checkValues(parameters, LoadFlowParameters.DEFAULT_VOLTAGE_INIT_MODE,
transformerVoltageControlOn, LoadFlowParameters.DEFAULT_USE_REACTIVE_LIMITS,
LoadFlowParameters.DEFAULT_PHASE_SHIFTER_REGULATION_ON, LoadFlowParameters.DEFAULT_TWT_SPLIT_SHUNT_ADMITTANCE,
LoadFlowParameters.DEFAULT_SHUNT_COMPENSATOR_VOLTAGE_CONTROL_ON, LoadFlowParameters.DEFAULT_READ_SLACK_BUS, LoadFlowParameters.DEFAULT_WRITE_SLACK_BUS,
LoadFlowParameters.DEFAULT_DC, LoadFlowParameters.DEFAULT_DISTRIBUTED_SLACK, LoadFlowParameters.DEFAULT_BALANCE_TYPE,
LoadFlowParameters.DEFAULT_DC_USE_TRANSFORMER_RATIO_DEFAULT, LoadFlowParameters.DEFAULT_COUNTRIES_TO_BALANCE,
LoadFlowParameters.DEFAULT_CONNECTED_COMPONENT_MODE, LoadFlowParameters.DEFAULT_HVDC_AC_EMULATION_ON,
LoadFlowParameters.DEFAULT_DC_POWER_FACTOR);
}
@Test
void checkDefaultPlatformConfig() {
LoadFlowParameters parameters = new LoadFlowParameters();
LoadFlowParameters.load(parameters);
checkValues(parameters, LoadFlowParameters.DEFAULT_VOLTAGE_INIT_MODE,
LoadFlowParameters.DEFAULT_TRANSFORMER_VOLTAGE_CONTROL_ON, LoadFlowParameters.DEFAULT_USE_REACTIVE_LIMITS,
LoadFlowParameters.DEFAULT_PHASE_SHIFTER_REGULATION_ON, LoadFlowParameters.DEFAULT_TWT_SPLIT_SHUNT_ADMITTANCE,
LoadFlowParameters.DEFAULT_SHUNT_COMPENSATOR_VOLTAGE_CONTROL_ON, LoadFlowParameters.DEFAULT_READ_SLACK_BUS, LoadFlowParameters.DEFAULT_WRITE_SLACK_BUS,
LoadFlowParameters.DEFAULT_DC, LoadFlowParameters.DEFAULT_DISTRIBUTED_SLACK, LoadFlowParameters.DEFAULT_BALANCE_TYPE,
LoadFlowParameters.DEFAULT_DC_USE_TRANSFORMER_RATIO_DEFAULT, LoadFlowParameters.DEFAULT_COUNTRIES_TO_BALANCE,
LoadFlowParameters.DEFAULT_CONNECTED_COMPONENT_MODE, LoadFlowParameters.DEFAULT_HVDC_AC_EMULATION_ON,
LoadFlowParameters.DEFAULT_DC_POWER_FACTOR);
}
@Test
void checkConstructorByVoltageInitMode() {
LoadFlowParameters.VoltageInitMode voltageInitMode = LoadFlowParameters.VoltageInitMode.DC_VALUES;
LoadFlowParameters parameters = new LoadFlowParameters()
.setVoltageInitMode(voltageInitMode);
checkValues(parameters, voltageInitMode, LoadFlowParameters.DEFAULT_TRANSFORMER_VOLTAGE_CONTROL_ON,
LoadFlowParameters.DEFAULT_USE_REACTIVE_LIMITS,
LoadFlowParameters.DEFAULT_PHASE_SHIFTER_REGULATION_ON, LoadFlowParameters.DEFAULT_TWT_SPLIT_SHUNT_ADMITTANCE,
LoadFlowParameters.DEFAULT_SHUNT_COMPENSATOR_VOLTAGE_CONTROL_ON, LoadFlowParameters.DEFAULT_READ_SLACK_BUS, LoadFlowParameters.DEFAULT_WRITE_SLACK_BUS,
LoadFlowParameters.DEFAULT_DC, LoadFlowParameters.DEFAULT_DISTRIBUTED_SLACK, LoadFlowParameters.DEFAULT_BALANCE_TYPE,
LoadFlowParameters.DEFAULT_DC_USE_TRANSFORMER_RATIO_DEFAULT, LoadFlowParameters.DEFAULT_COUNTRIES_TO_BALANCE,
LoadFlowParameters.DEFAULT_CONNECTED_COMPONENT_MODE, LoadFlowParameters.DEFAULT_HVDC_AC_EMULATION_ON,
LoadFlowParameters.DEFAULT_DC_POWER_FACTOR);
}
@Test
void checkConstructorByVoltageInitModeAndTransformerVoltageControlOn() {
LoadFlowParameters.VoltageInitMode voltageInitMode = LoadFlowParameters.VoltageInitMode.DC_VALUES;
boolean transformerVoltageControlOn = true;
LoadFlowParameters parameters = new LoadFlowParameters()
.setVoltageInitMode(voltageInitMode)
.setTransformerVoltageControlOn(transformerVoltageControlOn);
checkValues(parameters, voltageInitMode, true, LoadFlowParameters.DEFAULT_USE_REACTIVE_LIMITS,
LoadFlowParameters.DEFAULT_PHASE_SHIFTER_REGULATION_ON,
LoadFlowParameters.DEFAULT_TWT_SPLIT_SHUNT_ADMITTANCE,
LoadFlowParameters.DEFAULT_SHUNT_COMPENSATOR_VOLTAGE_CONTROL_ON,
LoadFlowParameters.DEFAULT_READ_SLACK_BUS,
LoadFlowParameters.DEFAULT_WRITE_SLACK_BUS,
LoadFlowParameters.DEFAULT_DC,
LoadFlowParameters.DEFAULT_DISTRIBUTED_SLACK,
LoadFlowParameters.DEFAULT_BALANCE_TYPE,
LoadFlowParameters.DEFAULT_DC_USE_TRANSFORMER_RATIO_DEFAULT,
LoadFlowParameters.DEFAULT_COUNTRIES_TO_BALANCE,
LoadFlowParameters.DEFAULT_CONNECTED_COMPONENT_MODE,
LoadFlowParameters.DEFAULT_HVDC_AC_EMULATION_ON,
LoadFlowParameters.DEFAULT_DC_POWER_FACTOR);
}
@Test
void checkConstructorByLoadFlowParameters() {
LoadFlowParameters.VoltageInitMode voltageInitMode = LoadFlowParameters.VoltageInitMode.DC_VALUES;
LoadFlowParameters parameters = new LoadFlowParameters()
.setVoltageInitMode(voltageInitMode);
checkValues(parameters, voltageInitMode, LoadFlowParameters.DEFAULT_TRANSFORMER_VOLTAGE_CONTROL_ON,
LoadFlowParameters.DEFAULT_USE_REACTIVE_LIMITS,
LoadFlowParameters.DEFAULT_PHASE_SHIFTER_REGULATION_ON,
LoadFlowParameters.DEFAULT_TWT_SPLIT_SHUNT_ADMITTANCE,
LoadFlowParameters.DEFAULT_SHUNT_COMPENSATOR_VOLTAGE_CONTROL_ON,
LoadFlowParameters.DEFAULT_READ_SLACK_BUS,
LoadFlowParameters.DEFAULT_WRITE_SLACK_BUS,
LoadFlowParameters.DEFAULT_DC,
LoadFlowParameters.DEFAULT_DISTRIBUTED_SLACK,
LoadFlowParameters.DEFAULT_BALANCE_TYPE,
LoadFlowParameters.DEFAULT_DC_USE_TRANSFORMER_RATIO_DEFAULT,
LoadFlowParameters.DEFAULT_COUNTRIES_TO_BALANCE,
LoadFlowParameters.DEFAULT_CONNECTED_COMPONENT_MODE,
LoadFlowParameters.DEFAULT_HVDC_AC_EMULATION_ON,
LoadFlowParameters.DEFAULT_DC_POWER_FACTOR);
LoadFlowParameters parameters1 = new LoadFlowParameters(parameters);
parameters1.setDc(true);
parameters1.setDistributedSlack(false);
parameters1.setBalanceType(LoadFlowParameters.BalanceType.PROPORTIONAL_TO_LOAD);
checkValues(parameters1, voltageInitMode,
LoadFlowParameters.DEFAULT_TRANSFORMER_VOLTAGE_CONTROL_ON,
LoadFlowParameters.DEFAULT_USE_REACTIVE_LIMITS,
LoadFlowParameters.DEFAULT_PHASE_SHIFTER_REGULATION_ON,
LoadFlowParameters.DEFAULT_TWT_SPLIT_SHUNT_ADMITTANCE,
LoadFlowParameters.DEFAULT_SHUNT_COMPENSATOR_VOLTAGE_CONTROL_ON,
LoadFlowParameters.DEFAULT_READ_SLACK_BUS,
LoadFlowParameters.DEFAULT_WRITE_SLACK_BUS,
true,
false,
LoadFlowParameters.BalanceType.PROPORTIONAL_TO_LOAD,
LoadFlowParameters.DEFAULT_DC_USE_TRANSFORMER_RATIO_DEFAULT,
LoadFlowParameters.DEFAULT_COUNTRIES_TO_BALANCE,
LoadFlowParameters.DEFAULT_CONNECTED_COMPONENT_MODE,
LoadFlowParameters.DEFAULT_HVDC_AC_EMULATION_ON,
LoadFlowParameters.DEFAULT_DC_POWER_FACTOR);
}
@Test
void checkSetters() {
boolean transformerVoltageControlOn = true;
boolean useReactiveLimits = false;
boolean phaseShifterRegulationOn = true;
boolean twtSplitShuntAdmittance = true;
boolean simulShunt = true;
boolean readSlackBus = true;
boolean writeSlackBus = true;
boolean dc = true;
boolean distributedSlack = false;
LoadFlowParameters.BalanceType balanceType = LoadFlowParameters.BalanceType.PROPORTIONAL_TO_LOAD;
LoadFlowParameters.VoltageInitMode voltageInitMode = LoadFlowParameters.VoltageInitMode.DC_VALUES;
boolean dcUseTransformerRatio = true;
Set<Country> countriesToBalance = new HashSet<>();
LoadFlowParameters.ConnectedComponentMode computedConnectedComponent = LoadFlowParameters.ConnectedComponentMode.MAIN;
boolean hvdcAcEmulation = false;
double dcPowerFactor = 0.95;
LoadFlowParameters parameters = new LoadFlowParameters();
LoadFlowParameters.load(parameters, platformConfig);
parameters.setUseReactiveLimits(useReactiveLimits)
.setPhaseShifterRegulationOn(phaseShifterRegulationOn)
.setTransformerVoltageControlOn(transformerVoltageControlOn)
.setVoltageInitMode(voltageInitMode)
.setTwtSplitShuntAdmittance(twtSplitShuntAdmittance)
.setShuntCompensatorVoltageControlOn(simulShunt)
.setReadSlackBus(readSlackBus)
.setWriteSlackBus(writeSlackBus)
.setDc(dc)
.setDistributedSlack(distributedSlack)
.setBalanceType(balanceType)
.setHvdcAcEmulation(hvdcAcEmulation)
.setDcPowerFactor(dcPowerFactor);
checkValues(parameters, voltageInitMode, transformerVoltageControlOn, useReactiveLimits,
phaseShifterRegulationOn, twtSplitShuntAdmittance, simulShunt, readSlackBus, writeSlackBus,
dc, distributedSlack, balanceType, dcUseTransformerRatio, countriesToBalance, computedConnectedComponent, hvdcAcEmulation, dcPowerFactor);
}
@Test
void checkClone() {
boolean transformerVoltageControlOn = true;
boolean useReactiveLimits = false;
boolean phaseShifterRegulationOn = true;
boolean twtSplitShuntAdmittance = true;
boolean simulShunt = true;
boolean readSlackBus = true;
boolean writeSlackBus = true;
boolean dc = true;
boolean distributedSlack = false;
LoadFlowParameters.BalanceType balanceType = LoadFlowParameters.BalanceType.PROPORTIONAL_TO_LOAD;
LoadFlowParameters.VoltageInitMode voltageInitMode = LoadFlowParameters.VoltageInitMode.UNIFORM_VALUES;
boolean dcUseTransformerRatio = true;
Set<Country> countriesToBalance = new HashSet<>();
LoadFlowParameters.ConnectedComponentMode computedConnectedComponent = LoadFlowParameters.ConnectedComponentMode.MAIN;
boolean hvdcAcEmulation = false;
double dcPowerFactor = 0.95;
LoadFlowParameters parameters = new LoadFlowParameters()
.setVoltageInitMode(voltageInitMode)
.setTransformerVoltageControlOn(transformerVoltageControlOn)
.setUseReactiveLimits(useReactiveLimits)
.setPhaseShifterRegulationOn(phaseShifterRegulationOn)
.setTwtSplitShuntAdmittance(twtSplitShuntAdmittance)
.setShuntCompensatorVoltageControlOn(simulShunt)
.setReadSlackBus(readSlackBus)
.setWriteSlackBus(writeSlackBus)
.setDc(dc)
.setDistributedSlack(distributedSlack)
.setBalanceType(balanceType)
.setDcUseTransformerRatio(dcUseTransformerRatio)
.setCountriesToBalance(countriesToBalance)
.setConnectedComponentMode(computedConnectedComponent)
.setHvdcAcEmulation(hvdcAcEmulation)
.setDcPowerFactor(dcPowerFactor);
LoadFlowParameters parametersCloned = parameters.copy();
checkValues(parametersCloned, parameters.getVoltageInitMode(), parameters.isTransformerVoltageControlOn(),
parameters.isUseReactiveLimits(), parameters.isPhaseShifterRegulationOn(), parameters.isTwtSplitShuntAdmittance(),
parameters.isShuntCompensatorVoltageControlOn(), parameters.isReadSlackBus(), parameters.isWriteSlackBus(),
parameters.isDc(), parameters.isDistributedSlack(), parameters.getBalanceType(), parameters.isDcUseTransformerRatio(),
parameters.getCountriesToBalance(), parameters.getConnectedComponentMode(), parameters.isHvdcAcEmulation(), parameters.getDcPowerFactor());
}
@Test
void testExtensions() {
LoadFlowParameters parameters = new LoadFlowParameters();
DummyExtension dummyExtension = new DummyExtension();
parameters.addExtension(DummyExtension.class, dummyExtension);
assertEquals(1, parameters.getExtensions().size());
assertTrue(parameters.getExtensions().contains(dummyExtension));
assertInstanceOf(DummyExtension.class, parameters.getExtensionByName("dummy-extension"));
assertNotNull(parameters.getExtension(DummyExtension.class));
}
@Test
void testCopyWithExtension() {
LoadFlowParameters parameters = new LoadFlowParameters();
DummyExtension dummyExtension = new DummyExtension();
parameters.addExtension(DummyExtension.class, dummyExtension);
LoadFlowParameters copy = parameters.copy();
assertEquals(1, copy.getExtensions().size());
Extension<LoadFlowParameters> copiedExt = copy.getExtensionByName("dummy-extension");
assertSame(parameters, dummyExtension.getExtendable());
assertSame(copy, copiedExt.getExtendable());
}
@Test
void testNoExtensions() {
LoadFlowParameters parameters = new LoadFlowParameters();
assertEquals(0, parameters.getExtensions().size());
assertFalse(parameters.getExtensions().contains(new DummyExtension()));
assertFalse(parameters.getExtensionByName("dummy-extension") instanceof DummyExtension);
assertNull(parameters.getExtension(DummyExtension.class));
}
@Test
void testExtensionFromConfig() {
LoadFlowParameters parameters = LoadFlowParameters.load(platformConfig);
assertEquals(1, parameters.getExtensions().size());
assertInstanceOf(DummyExtension.class, parameters.getExtensionByName("dummy-extension"));
assertNotNull(parameters.getExtension(DummyExtension.class));
}
@Test
void checkAllValuesNonDefault() {
LoadFlowParameters.VoltageInitMode voltageInitMode = LoadFlowParameters.VoltageInitMode.DC_VALUES;
boolean transformerVoltageControlOn = true;
boolean useReactiveLimits = false;
boolean phaseShifterRegulationOn = true;
boolean twtSplitShuntAdmittance = true;
boolean shuntCompensatorVoltageControlOn = true;
boolean readSlackBus = false;
boolean writeSlackBus = false;
boolean dc = true;
boolean distributedSlack = false;
LoadFlowParameters.BalanceType balanceType = LoadFlowParameters.BalanceType.PROPORTIONAL_TO_LOAD;
boolean dcUseTransformerRatio = false;
Set<Country> countriesToBalance = Set.of(Country.FR);
LoadFlowParameters.ConnectedComponentMode connectedComponentMode = LoadFlowParameters.ConnectedComponentMode.ALL;
boolean hvdcAcEmulation = false;
double dcPowerFactor = 0.95;
MapModuleConfig moduleConfig = platformConfig.createModuleConfig("load-flow-default-parameters");
moduleConfig.setStringProperty("voltageInitMode", voltageInitMode.name());
moduleConfig.setStringProperty("transformerVoltageControlOn", Boolean.toString(transformerVoltageControlOn));
moduleConfig.setStringProperty("useReactiveLimits", Boolean.toString(useReactiveLimits));
moduleConfig.setStringProperty("phaseShifterRegulationOn", Boolean.toString(phaseShifterRegulationOn));
moduleConfig.setStringProperty("twtSplitShuntAdmittance", Boolean.toString(twtSplitShuntAdmittance));
moduleConfig.setStringProperty("shuntCompensatorVoltageControlOn", Boolean.toString(shuntCompensatorVoltageControlOn));
moduleConfig.setStringProperty("readSlackBus", Boolean.toString(readSlackBus));
moduleConfig.setStringProperty("writeSlackBus", Boolean.toString(writeSlackBus));
moduleConfig.setStringProperty("dc", Boolean.toString(dc));
moduleConfig.setStringProperty("distributedSlack", Boolean.toString(distributedSlack));
moduleConfig.setStringProperty("balanceType", balanceType.name());
moduleConfig.setStringProperty("dcUseTransformerRatio", Boolean.toString(dcUseTransformerRatio));
moduleConfig.setStringListProperty("countriesToBalance", countriesToBalance.stream().map(Enum::name).toList());
moduleConfig.setStringProperty("connectedComponentMode", connectedComponentMode.name());
moduleConfig.setStringProperty("hvdcAcEmulation", Boolean.toString(hvdcAcEmulation));
moduleConfig.setStringProperty("dcPowerFactor", Double.toString(dcPowerFactor));
LoadFlowParameters parameters = new LoadFlowParameters();
LoadFlowParameters.load(parameters, platformConfig);
checkValues(parameters, voltageInitMode, transformerVoltageControlOn, useReactiveLimits, phaseShifterRegulationOn,
twtSplitShuntAdmittance, shuntCompensatorVoltageControlOn, readSlackBus, writeSlackBus, dc, distributedSlack,
balanceType, dcUseTransformerRatio, countriesToBalance, connectedComponentMode, hvdcAcEmulation, dcPowerFactor);
}
@Test
void checkSecondaryNamesNonDefault() {
LoadFlowParameters.VoltageInitMode voltageInitMode = LoadFlowParameters.VoltageInitMode.DC_VALUES;
boolean transformerVoltageControlOn = true;
boolean useReactiveLimits = false;
boolean phaseShifterRegulationOn = true;
boolean twtSplitShuntAdmittance = true;
boolean shuntCompensatorVoltageControlOn = true;
boolean readSlackBus = false;
boolean writeSlackBus = false;
boolean dc = true;
boolean distributedSlack = false;
LoadFlowParameters.BalanceType balanceType = LoadFlowParameters.BalanceType.PROPORTIONAL_TO_LOAD;
boolean dcUseTransformerRatio = false;
Set<Country> countriesToBalance = Set.of(Country.FR);
LoadFlowParameters.ConnectedComponentMode connectedComponentMode = LoadFlowParameters.ConnectedComponentMode.ALL;
boolean hvdcAcEmulation = false;
double dcPowerFactor = 0.95;
MapModuleConfig moduleConfig = platformConfig.createModuleConfig("load-flow-default-parameters");
moduleConfig.setStringProperty("voltageInitMode", voltageInitMode.name());
moduleConfig.setStringProperty("transformerVoltageControlOn", Boolean.toString(transformerVoltageControlOn));
// useReactiveLimits can be replaced by noGeneratorReactiveLimits (inverted)
moduleConfig.setStringProperty("noGeneratorReactiveLimits", Boolean.toString(!useReactiveLimits));
moduleConfig.setStringProperty("phaseShifterRegulationOn", Boolean.toString(phaseShifterRegulationOn));
// twtSplitShuntAdmittance can be replaced by specificCompatibility
moduleConfig.setStringProperty("specificCompatibility", Boolean.toString(twtSplitShuntAdmittance));
// shuntCompensatorVoltageControlOn can be replaced by simulShunt
moduleConfig.setStringProperty("simulShunt", Boolean.toString(shuntCompensatorVoltageControlOn));
moduleConfig.setStringProperty("readSlackBus", Boolean.toString(readSlackBus));
moduleConfig.setStringProperty("writeSlackBus", Boolean.toString(writeSlackBus));
moduleConfig.setStringProperty("dc", Boolean.toString(dc));
moduleConfig.setStringProperty("distributedSlack", Boolean.toString(distributedSlack));
moduleConfig.setStringProperty("balanceType", balanceType.name());
moduleConfig.setStringProperty("dcUseTransformerRatio", Boolean.toString(dcUseTransformerRatio));
moduleConfig.setStringListProperty("countriesToBalance", countriesToBalance.stream().map(Enum::name).toList());
moduleConfig.setStringProperty("connectedComponentMode", connectedComponentMode.name());
moduleConfig.setStringProperty("hvdcAcEmulation", Boolean.toString(hvdcAcEmulation));
moduleConfig.setStringProperty("dcPowerFactor", Double.toString(dcPowerFactor));
LoadFlowParameters parameters = new LoadFlowParameters();
LoadFlowParameters.load(parameters, platformConfig);
checkValues(parameters, voltageInitMode, transformerVoltageControlOn, useReactiveLimits, phaseShifterRegulationOn,
twtSplitShuntAdmittance, shuntCompensatorVoltageControlOn, readSlackBus, writeSlackBus, dc, distributedSlack,
balanceType, dcUseTransformerRatio, countriesToBalance, connectedComponentMode, hvdcAcEmulation, dcPowerFactor);
}
}