Skip to content

Commit

Permalink
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
Merge branch 'main' into update_gridsuite-dependencies_34
Browse files Browse the repository at this point in the history
antoinebhs authored Sep 26, 2024
2 parents d8f0d8b + bc45748 commit ef248d1
Showing 15 changed files with 666 additions and 429 deletions.
Original file line number Diff line number Diff line change
@@ -10,6 +10,14 @@
import com.powsybl.iidm.network.Battery;
import com.powsybl.iidm.network.extensions.ActivePowerControl;
import com.powsybl.iidm.network.extensions.ActivePowerControlAdder;
import jakarta.validation.constraints.NotNull;
import org.gridsuite.modification.server.dto.AttributeModification;
import org.gridsuite.modification.server.dto.OperationType;
import org.gridsuite.modification.server.modifications.ModificationUtils;

import static org.gridsuite.modification.server.NetworkModificationException.Type.MODIFY_BATTERY_ERROR;
import static org.gridsuite.modification.server.modifications.BatteryModification.modifyBatteryActiveLimitsAttributes;
import static org.gridsuite.modification.server.modifications.BatteryModification.modifyBatterySetpointsAttributes;

/**
* @author Seddik Yengui <Seddik.yengui at rte-france.com>
@@ -34,16 +42,30 @@ public static Double getReferenceValue(Battery battery, String batteryField) {
};
}

public static void setNewValue(Battery battery, String batteryField, Double newValue) {
public static void setNewValue(Battery battery, String batteryField, @NotNull Double newValue) {
BatteryField field = BatteryField.valueOf(batteryField);
final AttributeModification<Double> attributeModification = new AttributeModification<>(newValue, OperationType.SET);
switch (field) {
case MINIMUM_ACTIVE_POWER -> battery.setMinP(newValue);
case MAXIMUM_ACTIVE_POWER -> battery.setMaxP(newValue);
case ACTIVE_POWER_SET_POINT -> battery.setTargetP(newValue);
case REACTIVE_POWER_SET_POINT -> battery.setTargetQ(newValue);
case DROOP -> battery.newExtension(ActivePowerControlAdder.class)
.withDroop(newValue)
.add();
case MINIMUM_ACTIVE_POWER ->
modifyBatteryActiveLimitsAttributes(null, attributeModification, battery, null);
case MAXIMUM_ACTIVE_POWER ->
modifyBatteryActiveLimitsAttributes(attributeModification, null, battery, null);
case ACTIVE_POWER_SET_POINT -> {
ModificationUtils.getInstance().checkActivePowerZeroOrBetweenMinAndMaxActivePower(
attributeModification, null, null, battery.getMinP(),
battery.getMaxP(), battery.getTargetP(), MODIFY_BATTERY_ERROR, "Battery '" + battery.getId() + "' : "
);
modifyBatterySetpointsAttributes(attributeModification, null, null, null, battery, null);
}
case REACTIVE_POWER_SET_POINT -> modifyBatterySetpointsAttributes(
null, attributeModification, null, null, battery, null);
case DROOP -> {
ActivePowerControl<Battery> activePowerControl = battery.getExtension(ActivePowerControl.class);
ActivePowerControlAdder<Battery> activePowerControlAdder = battery.newExtension(ActivePowerControlAdder.class);
ModificationUtils.getInstance().modifyActivePowerControlAttributes(
activePowerControl, activePowerControlAdder, null,
new AttributeModification<>(newValue.floatValue(), OperationType.SET), null, null);
}
}
}
}
Original file line number Diff line number Diff line change
@@ -11,11 +11,15 @@
import com.powsybl.iidm.network.extensions.ActivePowerControl;
import com.powsybl.iidm.network.extensions.ActivePowerControlAdder;
import com.powsybl.iidm.network.extensions.CoordinatedReactiveControl;
import com.powsybl.iidm.network.extensions.CoordinatedReactiveControlAdder;
import com.powsybl.iidm.network.extensions.GeneratorShortCircuit;
import com.powsybl.iidm.network.extensions.GeneratorShortCircuitAdder;
import com.powsybl.iidm.network.extensions.GeneratorStartup;
import com.powsybl.iidm.network.extensions.GeneratorStartupAdder;
import com.powsybl.network.store.iidm.impl.extensions.CoordinatedReactiveControlAdderImpl;
import org.gridsuite.modification.server.dto.AttributeModification;
import org.gridsuite.modification.server.dto.OperationType;
import org.gridsuite.modification.server.modifications.ModificationUtils;

import static org.gridsuite.modification.server.NetworkModificationException.Type.MODIFY_GENERATOR_ERROR;
import static org.gridsuite.modification.server.modifications.GeneratorModification.*;

/**
* @author Seddik Yengui <Seddik.yengui at rte-france.com>
@@ -61,86 +65,42 @@ public static Double getReferenceValue(Generator generator, String generatorFiel
};
}

public static void setNewValue(Generator generator, String generatorField, Double newValue) {
public static void setNewValue(Generator generator, String generatorField, double newValue) {
if (!Double.isNaN(newValue)) {
GeneratorStartup generatorStartup = generator.getExtension(GeneratorStartup.class);
GeneratorShortCircuit generatorShortCircuit = generator.getExtension(GeneratorShortCircuit.class);
GeneratorField field = GeneratorField.valueOf(generatorField);
final AttributeModification<Double> attributeModification = new AttributeModification<>(newValue, OperationType.SET);
switch (field) {
case MAXIMUM_ACTIVE_POWER -> generator.setMaxP(newValue);
case MINIMUM_ACTIVE_POWER -> generator.setMinP(newValue);
case ACTIVE_POWER_SET_POINT -> generator.setTargetP(newValue);
case RATED_NOMINAL_POWER -> generator.setRatedS(newValue);
case REACTIVE_POWER_SET_POINT -> generator.setTargetQ(newValue);
case VOLTAGE_SET_POINT -> generator.setTargetV(newValue);
case PLANNED_ACTIVE_POWER_SET_POINT -> {
if (generatorStartup == null) {
generator.newExtension(GeneratorStartupAdder.class)
.withPlannedActivePowerSetpoint(newValue)
.add();
} else {
generator.newExtension(GeneratorStartupAdder.class)
.withMarginalCost(generatorStartup.getMarginalCost())
.withPlannedActivePowerSetpoint(newValue)
.withPlannedOutageRate(generatorStartup.getPlannedOutageRate())
.withForcedOutageRate(generatorStartup.getForcedOutageRate())
.add();
}
}
case MARGINAL_COST -> {
if (generatorStartup == null) {
generator.newExtension(GeneratorStartupAdder.class)
.withMarginalCost(newValue)
.add();
} else {
generator.newExtension(GeneratorStartupAdder.class)
.withMarginalCost(newValue)
.withPlannedActivePowerSetpoint(generatorStartup.getPlannedActivePowerSetpoint())
.withPlannedOutageRate(generatorStartup.getPlannedOutageRate())
.withForcedOutageRate(generatorStartup.getForcedOutageRate())
.add();
}
}
case PLANNED_OUTAGE_RATE -> {
if (generatorStartup == null) {
generator.newExtension(GeneratorStartupAdder.class)
.withPlannedOutageRate(newValue)
.add();
} else {
generator.newExtension(GeneratorStartupAdder.class)
.withMarginalCost(generatorStartup.getMarginalCost())
.withPlannedActivePowerSetpoint(generatorStartup.getPlannedActivePowerSetpoint())
.withPlannedOutageRate(newValue)
.withForcedOutageRate(generatorStartup.getForcedOutageRate())
.add();
}
case MAXIMUM_ACTIVE_POWER -> modifyGeneratorActiveLimitsAttributes(
attributeModification, null, null, generator, null);
case MINIMUM_ACTIVE_POWER -> modifyGeneratorActiveLimitsAttributes(null, attributeModification, null, generator, null);
case ACTIVE_POWER_SET_POINT -> {
ModificationUtils.getInstance().checkActivePowerZeroOrBetweenMinAndMaxActivePower(
attributeModification, null, null,
generator.getMinP(), generator.getMaxP(), generator.getTargetP(),
MODIFY_GENERATOR_ERROR, "Generator '" + generator.getId() + "' : "
);
generator.setTargetP(newValue);
}
case FORCED_OUTAGE_RATE -> {
if (generatorStartup == null) {
generator.newExtension(GeneratorStartupAdder.class)
.withForcedOutageRate(newValue)
.add();
} else {
generator.newExtension(GeneratorStartupAdder.class)
.withMarginalCost(generatorStartup.getMarginalCost())
.withPlannedActivePowerSetpoint(generatorStartup.getPlannedActivePowerSetpoint())
.withPlannedOutageRate(generatorStartup.getForcedOutageRate())
.withForcedOutageRate(newValue)
.add();
}
case RATED_NOMINAL_POWER -> modifyGeneratorActiveLimitsAttributes(null, null, attributeModification, generator, null);
case REACTIVE_POWER_SET_POINT -> modifyTargetQ(generator, attributeModification);
case VOLTAGE_SET_POINT -> modifyTargetV(generator, attributeModification);
case PLANNED_ACTIVE_POWER_SET_POINT ->
modifyGeneratorStartUpAttributes(attributeModification, null, null, null, generator, null, null);
case MARGINAL_COST ->
modifyGeneratorStartUpAttributes(null, attributeModification, null, null, generator, null, null);
case PLANNED_OUTAGE_RATE ->
modifyGeneratorStartUpAttributes(null, null, attributeModification, null, generator, null, null);
case FORCED_OUTAGE_RATE ->
modifyGeneratorStartUpAttributes(null, null, null, attributeModification, generator, null, null);
case DROOP -> {
ActivePowerControl<Generator> activePowerControl = generator.getExtension(ActivePowerControl.class);
ActivePowerControlAdder<Generator> activePowerControlAdder = generator.newExtension(ActivePowerControlAdder.class);
ModificationUtils.getInstance().modifyActivePowerControlAttributes(activePowerControl, activePowerControlAdder, null,
new AttributeModification<>((float) newValue, OperationType.SET), null, null);
}
case DROOP -> generator.newExtension(ActivePowerControlAdder.class)
.withDroop(newValue)
.add();
case TRANSIENT_REACTANCE -> generator.newExtension(GeneratorShortCircuitAdder.class)
.withDirectTransX(newValue)
.withStepUpTransformerX(generatorShortCircuit == null ? Double.NaN : generatorShortCircuit.getStepUpTransformerX())
.add();
case STEP_UP_TRANSFORMER_REACTANCE -> generator.newExtension(GeneratorShortCircuitAdder.class)
.withDirectTransX(generatorShortCircuit == null ? 0.0D : generatorShortCircuit.getDirectTransX())
.withStepUpTransformerX(newValue)
.add();
case Q_PERCENT -> generator.newExtension(CoordinatedReactiveControlAdder.class)
case TRANSIENT_REACTANCE -> modifyGeneratorShortCircuitAttributes(attributeModification, null, generator, null);
case STEP_UP_TRANSFORMER_REACTANCE -> modifyGeneratorShortCircuitAttributes(null, attributeModification, generator, null);
case Q_PERCENT -> generator.newExtension(CoordinatedReactiveControlAdderImpl.class)
.withQPercent(newValue)
.add();
}
Original file line number Diff line number Diff line change
@@ -8,6 +8,11 @@
package org.gridsuite.modification.server.dto.formula.equipmentfield;

import com.powsybl.iidm.network.Load;
import org.gridsuite.modification.server.dto.AttributeModification;
import org.gridsuite.modification.server.dto.OperationType;

import static org.gridsuite.modification.server.modifications.LoadModification.modifyP0;
import static org.gridsuite.modification.server.modifications.LoadModification.modifyQ0;

/**
* @author Seddik Yengui <Seddik.yengui at rte-france.com>
@@ -28,8 +33,8 @@ public static Double getReferenceValue(Load load, String loadField) {
public static void setNewValue(Load load, String loadField, Double newValue) {
LoadField field = LoadField.valueOf(loadField);
switch (field) {
case ACTIVE_POWER -> load.setP0(newValue);
case REACTIVE_POWER -> load.setQ0(newValue);
case ACTIVE_POWER -> modifyP0(load, new AttributeModification<>(newValue, OperationType.SET), null);
case REACTIVE_POWER -> modifyQ0(load, new AttributeModification<>(newValue, OperationType.SET), null);
}
}
}
Original file line number Diff line number Diff line change
@@ -12,6 +12,11 @@
import com.powsybl.iidm.network.ShuntCompensatorModelType;
import com.powsybl.iidm.network.VoltageLevel;
import org.gridsuite.modification.server.NetworkModificationException;
import org.gridsuite.modification.server.dto.AttributeModification;
import org.gridsuite.modification.server.dto.OperationType;
import org.gridsuite.modification.server.dto.ShuntCompensatorType;

import static org.gridsuite.modification.server.modifications.ShuntCompensatorModification.*;

/**
* @author Seddik Yengui <Seddik.yengui at rte-france.com>
@@ -42,19 +47,18 @@ public static void setNewValue(ShuntCompensator shuntCompensator, String shuntCo
ShuntCompensatorLinearModel model = shuntCompensator.getModel(ShuntCompensatorLinearModel.class);
ShuntCompensatorField field = ShuntCompensatorField.valueOf(shuntCompensatorField);
VoltageLevel voltageLevel = shuntCompensator.getTerminal().getVoltageLevel();
var shuntCompensatorType = ShuntCompensatorType.REACTOR;
if (model != null && model.getBPerSection() > 0) {
shuntCompensatorType = ShuntCompensatorType.CAPACITOR;
}
switch (field) {
case MAXIMUM_SECTION_COUNT -> {
int maximumSectionCount = newValue.intValue();
model.setBPerSection(model.getBPerSection() * shuntCompensator.getMaximumSectionCount() / maximumSectionCount);
model.setMaximumSectionCount(maximumSectionCount);
}
case SECTION_COUNT -> shuntCompensator.setSectionCount(newValue.intValue());
case MAXIMUM_SUSCEPTANCE -> model.setBPerSection(newValue / shuntCompensator.getMaximumSectionCount());
case MAXIMUM_Q_AT_NOMINAL_VOLTAGE -> {
double newQatNominalV = newValue / shuntCompensator.getMaximumSectionCount();
double newSusceptancePerSection = newQatNominalV / Math.pow(voltageLevel.getNominalV(), 2);
model.setBPerSection(newSusceptancePerSection);
}
case MAXIMUM_SECTION_COUNT -> modifyMaximumSectionCount(new AttributeModification<>(newValue.intValue(), OperationType.SET),
null, null, null, shuntCompensator, model);
case SECTION_COUNT -> modifySectionCount(new AttributeModification<>(newValue.intValue(), OperationType.SET), null, shuntCompensator);
case MAXIMUM_SUSCEPTANCE -> modifyMaxSusceptance(new AttributeModification<>(newValue, OperationType.SET),
shuntCompensator.getMaximumSectionCount(), null, model);
case MAXIMUM_Q_AT_NOMINAL_VOLTAGE -> modifyMaximumQAtNominalVoltage(new AttributeModification<>(newValue, OperationType.SET),
voltageLevel, shuntCompensator.getMaximumSectionCount(), null, model, shuntCompensatorType);
}
}
}
Original file line number Diff line number Diff line change
@@ -3,6 +3,9 @@
import com.powsybl.iidm.network.PhaseTapChanger;
import com.powsybl.iidm.network.RatioTapChanger;
import com.powsybl.iidm.network.TwoWindingsTransformer;
import org.gridsuite.modification.server.dto.AttributeModification;
import org.gridsuite.modification.server.dto.OperationType;
import static org.gridsuite.modification.server.modifications.TwoWindingsTransformerModification.*;

public enum TwoWindingsTransformerField {
R,
@@ -48,23 +51,33 @@ public static void setNewValue(TwoWindingsTransformer transformer, String twoWin
TwoWindingsTransformerField field = TwoWindingsTransformerField.valueOf(twoWindingsTransformerField);
final PhaseTapChanger phaseTapChanger = transformer.getPhaseTapChanger();
final RatioTapChanger ratioTapChanger = transformer.getRatioTapChanger();
final PhaseTapChanger.RegulationMode regulationMode = phaseTapChanger != null ? phaseTapChanger.getRegulationMode() : null;
final AttributeModification<Double> attributeModification = new AttributeModification<>(newValue, OperationType.SET);

switch (field) {
case R -> transformer.setR(newValue);
case X -> transformer.setX(newValue);
case G -> transformer.setG(newValue);
case B -> transformer.setB(newValue);
case RATED_U1 -> transformer.setRatedU1(newValue);
case RATED_U2 -> transformer.setRatedU2(newValue);
case RATED_S -> transformer.setRatedS(newValue);
case TARGET_V -> ratioTapChanger.setTargetV(newValue);
case RATIO_LOW_TAP_POSITION -> ratioTapChanger.setLowTapPosition(newValue.intValue());
case RATIO_TAP_POSITION -> ratioTapChanger.setTapPosition(newValue.intValue());
case RATIO_TARGET_DEADBAND -> ratioTapChanger.setTargetDeadband(newValue);
case REGULATION_VALUE -> phaseTapChanger.setRegulationValue(newValue);
case PHASE_LOW_TAP_POSITION -> phaseTapChanger.setLowTapPosition(newValue.intValue());
case PHASE_TAP_POSITION -> phaseTapChanger.setTapPosition(newValue.intValue());
case PHASE_TARGET_DEADBAND -> phaseTapChanger.setTargetDeadband(newValue);
case R -> modifyR(transformer, attributeModification, null);
case X -> modifyX(transformer, attributeModification, null);
case G -> modifyG(transformer, attributeModification, null);
case B -> modifyB(transformer, attributeModification, null);
case RATED_U1 -> modifyRatedU1(transformer, attributeModification, null);
case RATED_U2 -> modifyRatedU2(transformer, attributeModification, null);
case RATED_S -> modifyRatedS(transformer, attributeModification, null);
case TARGET_V -> modifyTargets(ratioTapChanger, null, true, attributeModification, null, null);
case RATIO_LOW_TAP_POSITION -> processTapChangerPositionsAndSteps(ratioTapChanger, null, true,
new AttributeModification<>(newValue.intValue(), OperationType.SET), null, null, null);
case RATIO_TAP_POSITION -> processTapChangerPositionsAndSteps(ratioTapChanger, null, true,
null, new AttributeModification<>(newValue.intValue(), OperationType.SET), null, null);
case RATIO_TARGET_DEADBAND -> modifyTargets(ratioTapChanger, null, true, null, attributeModification, null);
case REGULATION_VALUE -> processPhaseTapRegulation(
phaseTapChanger, null, regulationMode, true, attributeModification, null, null
);
case PHASE_LOW_TAP_POSITION -> processTapChangerPositionsAndSteps(phaseTapChanger, null, true,
new AttributeModification<>(newValue.intValue(), OperationType.SET), null, null, null);
case PHASE_TAP_POSITION -> processTapChangerPositionsAndSteps(phaseTapChanger, null, true,
null, new AttributeModification<>(newValue.intValue(), OperationType.SET), null, null);
case PHASE_TARGET_DEADBAND -> processPhaseTapRegulation(
phaseTapChanger, null, null, true, null, attributeModification, null
);
}
}
}
Original file line number Diff line number Diff line change
@@ -9,7 +9,10 @@

import com.powsybl.iidm.network.VoltageLevel;
import com.powsybl.iidm.network.extensions.IdentifiableShortCircuit;
import com.powsybl.iidm.network.extensions.IdentifiableShortCircuitAdder;
import org.gridsuite.modification.server.dto.AttributeModification;
import org.gridsuite.modification.server.dto.OperationType;

import static org.gridsuite.modification.server.modifications.VoltageLevelModification.*;

/**
* @author Seddik Yengui <Seddik.yengui at rte-france.com>
@@ -35,26 +38,15 @@ public static Double getReferenceValue(VoltageLevel voltageLevel, String voltage
}

public static void setNewValue(VoltageLevel voltageLevel, String voltageLevelField, Double newValue) {
IdentifiableShortCircuit<VoltageLevel> identifiableShortCircuit = voltageLevel.getExtension(IdentifiableShortCircuit.class);
VoltageLevelField field = VoltageLevelField.valueOf(voltageLevelField);
switch (field) {
case NOMINAL_VOLTAGE -> voltageLevel.setNominalV(newValue);
case LOW_VOLTAGE_LIMIT -> voltageLevel.setLowVoltageLimit(newValue);
case HIGH_VOLTAGE_LIMIT -> voltageLevel.setHighVoltageLimit(newValue);
case LOW_SHORT_CIRCUIT_CURRENT_LIMIT -> {
IdentifiableShortCircuitAdder<VoltageLevel> adder = voltageLevel.newExtension(IdentifiableShortCircuitAdder.class).withIpMin(newValue);
if (identifiableShortCircuit != null) {
adder.withIpMax(identifiableShortCircuit.getIpMax());
}
adder.add();
}
case HIGH_SHORT_CIRCUIT_CURRENT_LIMIT -> {
IdentifiableShortCircuitAdder<VoltageLevel> adder = voltageLevel.newExtension(IdentifiableShortCircuitAdder.class).withIpMax(newValue);
if (identifiableShortCircuit != null) {
adder.withIpMin(identifiableShortCircuit.getIpMin());
}
adder.add();
}
case NOMINAL_VOLTAGE -> modifyNominalV(voltageLevel, new AttributeModification<>(newValue, OperationType.SET), null);
case LOW_VOLTAGE_LIMIT -> modifLowVoltageLimit(voltageLevel, new AttributeModification<>(newValue, OperationType.SET), null);
case HIGH_VOLTAGE_LIMIT -> modifyHighVoltageLimit(voltageLevel, new AttributeModification<>(newValue, OperationType.SET), null);
case LOW_SHORT_CIRCUIT_CURRENT_LIMIT -> modifyVoltageLevelShortCircuit(
new AttributeModification<>(newValue, OperationType.SET), null, null, voltageLevel);
case HIGH_SHORT_CIRCUIT_CURRENT_LIMIT -> modifyVoltageLevelShortCircuit(
null, new AttributeModification<>(newValue, OperationType.SET), null, voltageLevel);
}
}
}
Original file line number Diff line number Diff line change
@@ -18,6 +18,7 @@
import com.powsybl.iidm.network.extensions.ConnectablePosition;
import com.powsybl.iidm.network.extensions.ConnectablePositionAdder;
import org.gridsuite.modification.server.NetworkModificationException;
import org.gridsuite.modification.server.dto.AttributeModification;
import org.gridsuite.modification.server.dto.BatteryModificationInfos;
import org.gridsuite.modification.server.dto.ReactiveCapabilityCurveModificationInfos;

@@ -86,17 +87,24 @@ private void modifyBattery(Battery battery, BatteryModificationInfos modificatio
}

modifyBatteryLimitsAttributes(modificationInfos, battery, subReportNode);
modifyBatterySetpointsAttributes(modificationInfos, battery, subReportNode);
modifyBatterySetpointsAttributes(
modificationInfos.getTargetP(), modificationInfos.getTargetQ(),
modificationInfos.getParticipate(), modificationInfos.getDroop(),
battery, subReportNode);
modifyBatteryConnectivityAttributes(modificationInfos, battery, subReportNode);
PropertiesUtils.applyProperties(battery, subReportNode, modificationInfos.getProperties(), "BatteryProperties");
}

private void modifyBatterySetpointsAttributes(BatteryModificationInfos modificationInfos,
Battery battery, ReportNode subReportNode) {
ReportNode reportActivePower = ModificationUtils.getInstance().applyElementaryModificationsAndReturnReport(battery::setTargetP, battery::getTargetP, modificationInfos.getTargetP(), "Active power");
ReportNode reportReactivePower = ModificationUtils.getInstance().applyElementaryModificationsAndReturnReport(battery::setTargetQ, battery::getTargetQ, modificationInfos.getTargetQ(), "Reactive power");
public static void modifyBatterySetpointsAttributes(AttributeModification<Double> targetP,
AttributeModification<Double> targetQ,
AttributeModification<Boolean> participate,
AttributeModification<Float> droop,
Battery battery,
ReportNode subReportNode) {
ReportNode reportActivePower = ModificationUtils.getInstance().applyElementaryModificationsAndReturnReport(battery::setTargetP, battery::getTargetP, targetP, "Active power");
ReportNode reportReactivePower = ModificationUtils.getInstance().applyElementaryModificationsAndReturnReport(battery::setTargetQ, battery::getTargetQ, targetQ, "Reactive power");
ReportNode subReporterSetpoints = null;
if (reportActivePower != null || reportReactivePower != null) {
if (subReportNode != null && (reportActivePower != null || reportReactivePower != null)) {
subReporterSetpoints = subReportNode.newReportNode().withMessageTemplate(SETPOINTS, SETPOINTS).add();
if (reportActivePower != null) {
insertReportNode(subReporterSetpoints, reportActivePower);
@@ -105,12 +113,12 @@ private void modifyBatterySetpointsAttributes(BatteryModificationInfos modificat
insertReportNode(subReporterSetpoints, reportReactivePower);
}
}
modifyBatteryActivePowerControlAttributes(modificationInfos, battery, subReportNode, subReporterSetpoints);
modifyBatteryActivePowerControlAttributes(participate, droop, battery, subReportNode, subReporterSetpoints);
}

private void modifyBatteryLimitsAttributes(BatteryModificationInfos modificationInfos,
Battery battery, ReportNode subReportNode) {
ReportNode subReportNodeLimits = modifyBatteryActiveLimitsAttributes(modificationInfos, battery, subReportNode);
ReportNode subReportNodeLimits = modifyBatteryActiveLimitsAttributes(modificationInfos.getMaxP(), modificationInfos.getMinP(), battery, subReportNode);
modifyBatteryReactiveLimitsAttributes(modificationInfos, battery, subReportNode, subReportNodeLimits);
}

@@ -123,12 +131,13 @@ private void modifyBatteryReactiveCapabilityCurvePoints(BatteryModificationInfos
ModificationUtils.getInstance().modifyReactiveCapabilityCurvePoints(points, modificationPoints, adder, subReportNode, subReportNodeLimits);
}

private ReportNode modifyBatteryActiveLimitsAttributes(BatteryModificationInfos modificationInfos,
Battery battery, ReportNode subReportNode) {
public static ReportNode modifyBatteryActiveLimitsAttributes(AttributeModification<Double> maxP,
AttributeModification<Double> minP,
Battery battery, ReportNode subReportNode) {
ReportNode subReportNodeLimits = null;
ReportNode reportMaxActivePower = ModificationUtils.getInstance().applyElementaryModificationsAndReturnReport(battery::setMaxP, battery::getMaxP, modificationInfos.getMaxP(), "Max active power");
ReportNode reportMinActivePower = ModificationUtils.getInstance().applyElementaryModificationsAndReturnReport(battery::setMinP, battery::getMinP, modificationInfos.getMinP(), "Min active power");
if (reportMaxActivePower != null || reportMinActivePower != null) {
ReportNode reportMaxActivePower = ModificationUtils.getInstance().applyElementaryModificationsAndReturnReport(battery::setMaxP, battery::getMaxP, maxP, "Max active power");
ReportNode reportMinActivePower = ModificationUtils.getInstance().applyElementaryModificationsAndReturnReport(battery::setMinP, battery::getMinP, minP, "Min active power");
if (subReportNode != null && (reportMaxActivePower != null || reportMinActivePower != null)) {
subReportNodeLimits = subReportNode.newReportNode().withMessageTemplate(LIMITS, LIMITS).add();
ReportNode subReporterActiveLimits = subReportNodeLimits.newReportNode().withMessageTemplate(ACTIVE_LIMITS, ACTIVE_LIMITS).add();
if (reportMaxActivePower != null) {
@@ -155,11 +164,14 @@ private void modifyBatteryReactiveLimitsAttributes(BatteryModificationInfos modi
}
}

private ReportNode modifyBatteryActivePowerControlAttributes(BatteryModificationInfos modificationInfos,
Battery battery, ReportNode subReportNode, ReportNode subReportNodeSetpoints) {
public static ReportNode modifyBatteryActivePowerControlAttributes(AttributeModification<Boolean> participate,
AttributeModification<Float> droop,
Battery battery,
ReportNode subReportNode,
ReportNode subReportNodeSetpoints) {
ActivePowerControl<Battery> activePowerControl = battery.getExtension(ActivePowerControl.class);
ActivePowerControlAdder<Battery> activePowerControlAdder = battery.newExtension(ActivePowerControlAdder.class);
return ModificationUtils.getInstance().modifyActivePowerControlAttributes(activePowerControl, activePowerControlAdder, modificationInfos.getParticipate(), modificationInfos.getDroop(), subReportNode, subReportNodeSetpoints);
return ModificationUtils.getInstance().modifyActivePowerControlAttributes(activePowerControl, activePowerControlAdder, participate, droop, subReportNode, subReportNodeSetpoints);
}

private ReportNode modifyBatteryConnectivityAttributes(BatteryModificationInfos modificationInfos,
Original file line number Diff line number Diff line change
@@ -98,7 +98,6 @@ public void apply(Network network, ReportNode subReportNode) {
.withUntypedValue(KEY_VALUE, equipmentCount)
.withSeverity(TypedValue.INFO_SEVERITY)
.add();
report(formulaSubReporter, formulaReports);
} else {
if (equipmentNotModifiedCount == equipmentCount) {
createReport(subReportNode, "byFormulaModificationNone",
@@ -111,9 +110,9 @@ public void apply(Network network, ReportNode subReportNode) {
.withUntypedValue(KEY_NB_UNCHANGED, equipmentNotModifiedCount + equipmentNotFoundCount)
.withSeverity(TypedValue.WARN_SEVERITY)
.add();
report(formulaSubReporter, formulaReports);
}
}
report(formulaSubReporter, formulaReports);
}
}

@@ -267,7 +266,7 @@ private void applyFormula(Identifiable<?> identifiable,
try {
final Double newValue = applyOperation(formulaInfos.getOperator(), value1, value2);
switch (identifiable.getType()) {
case GENERATOR -> GeneratorField.setNewValue((Generator) identifiable, formulaInfos.getEditedField(), newValue);
case GENERATOR -> GeneratorField.setNewValue((Generator) identifiable, formulaInfos.getEditedField(), newValue.doubleValue());
case BATTERY -> BatteryField.setNewValue((Battery) identifiable, formulaInfos.getEditedField(), newValue);
case SHUNT_COMPENSATOR -> ShuntCompensatorField.setNewValue((ShuntCompensator) identifiable, formulaInfos.getEditedField(), newValue);
case VOLTAGE_LEVEL -> VoltageLevelField.setNewValue((VoltageLevel) identifiable, formulaInfos.getEditedField(), newValue);

Large diffs are not rendered by default.

Original file line number Diff line number Diff line change
@@ -13,6 +13,7 @@
import com.powsybl.iidm.network.extensions.ConnectablePosition;
import com.powsybl.iidm.network.extensions.ConnectablePositionAdder;
import org.gridsuite.modification.server.NetworkModificationException;
import org.gridsuite.modification.server.dto.AttributeModification;
import org.gridsuite.modification.server.dto.LoadModificationInfos;

import static org.gridsuite.modification.server.NetworkModificationException.Type.LOAD_NOT_FOUND;
@@ -53,13 +54,21 @@ private void modifyLoad(Load load, ReportNode subReportNode) {

ModificationUtils.getInstance().applyElementaryModifications(load::setName, () -> load.getOptionalName().orElse("No value"), modificationInfos.getEquipmentName(), subReportNode, "Name");
ModificationUtils.getInstance().applyElementaryModifications(load::setLoadType, load::getLoadType, modificationInfos.getLoadType(), subReportNode, "Type");
ModificationUtils.getInstance().applyElementaryModifications(load::setP0, load::getP0, modificationInfos.getP0(), subReportNode, "Constant active power");
ModificationUtils.getInstance().applyElementaryModifications(load::setQ0, load::getQ0, modificationInfos.getQ0(), subReportNode, "Constant reactive power");
modifyP0(load, modificationInfos.getP0(), subReportNode);
modifyQ0(load, modificationInfos.getQ0(), subReportNode);
modifyLoadConnectivityAttributes(modificationInfos, load, subReportNode);
// properties
PropertiesUtils.applyProperties(load, subReportNode, modificationInfos.getProperties(), "LoadProperties");
}

public static void modifyQ0(Load load, AttributeModification<Double> q0, ReportNode subReportNode) {
ModificationUtils.getInstance().applyElementaryModifications(load::setQ0, load::getQ0, q0, subReportNode, "Constant reactive power");
}

public static void modifyP0(Load load, AttributeModification<Double> p0, ReportNode subReportNode) {
ModificationUtils.getInstance().applyElementaryModifications(load::setP0, load::getP0, p0, subReportNode, "Constant active power");
}

private ReportNode modifyLoadConnectivityAttributes(LoadModificationInfos modificationInfos,
Load load, ReportNode subReportNode) {
ConnectablePosition<Load> connectablePosition = load.getExtension(ConnectablePosition.class);
Original file line number Diff line number Diff line change
@@ -509,7 +509,9 @@ public <T> void applyElementaryModifications(Consumer<T> setter, Supplier<T> get
T newValue = modification.applyModification(oldValue);
setter.accept(newValue);

insertReportNode(subReportNode, buildModificationReport(oldValue, newValue, fieldName));
if (subReportNode != null) {
insertReportNode(subReportNode, buildModificationReport(oldValue, newValue, fieldName));
}
}
}

@@ -1073,12 +1075,16 @@ private void modifyExistingActivePowerControl(ActivePowerControl<?> activePowerC

Optional.ofNullable(participateInfo).ifPresent(info -> {
activePowerControl.setParticipate(info.getValue());
reports.add(buildModificationReport(oldParticipate, info.getValue(), "Participate"));
if (reports != null) {
reports.add(buildModificationReport(oldParticipate, info.getValue(), "Participate"));
}
});

Optional.ofNullable(droopInfo).ifPresent(info -> {
activePowerControl.setDroop(info.getValue());
reports.add(buildModificationReport(oldDroop, info.getValue(), "Droop"));
if (reports != null) {
reports.add(buildModificationReport(oldDroop, info.getValue(), "Droop"));
}
});
}

@@ -1088,36 +1094,38 @@ private void createNewActivePowerControl(ActivePowerControlAdder<?> adder,
List<ReportNode> reports) {
boolean participate = participateInfo != null ? participateInfo.getValue() : false;
adder.withParticipate(participate);
if (participateInfo != null) {
if (participateInfo != null && reports != null) {
reports.add(buildModificationReport(null, participate, "Participate"));
}
double droop = droopInfo != null ? droopInfo.getValue() : Double.NaN;
adder.withDroop(droop);
if (droopInfo != null) {
if (droopInfo != null && reports != null) {
reports.add(buildModificationReport(Double.NaN, droop, "Droop"));
}
adder.add();
}

public ReportNode modifyActivePowerControlAttributes(ActivePowerControl<?> activePowerControl,
ActivePowerControlAdder<?> activePowerControlAdder,
AttributeModification<Boolean> participateInfo,
AttributeModification<Float> droopInfo,
ReportNode subReportNode,
ActivePowerControlAdder<?> activePowerControlAdder,
AttributeModification<Boolean> participateInfo,
AttributeModification<Float> droopInfo,
ReportNode subReportNode,
ReportNode subReporterSetpoints) {
List<ReportNode> reports = new ArrayList<>();
if (activePowerControl != null) {
modifyExistingActivePowerControl(activePowerControl, participateInfo, droopInfo, reports);
} else {
createNewActivePowerControl(activePowerControlAdder, participateInfo, droopInfo, reports);
}

ReportNode subReportNodeSetpoints2 = subReporterSetpoints;
if (subReporterSetpoints == null && !reports.isEmpty()) {
subReportNodeSetpoints2 = subReportNode.newReportNode().withMessageTemplate(SETPOINTS, SETPOINTS).add();
if (subReportNode != null) {
ReportNode subReportNodeSetpoints2 = subReporterSetpoints;
if (subReporterSetpoints == null && !reports.isEmpty()) {
subReportNodeSetpoints2 = subReportNode.newReportNode().withMessageTemplate(SETPOINTS, SETPOINTS).add();
}
reportModifications(subReportNodeSetpoints2, reports, "activePowerRegulationModified", "Active power regulation");
return subReportNodeSetpoints2;
}
reportModifications(subReportNodeSetpoints2, reports, "activePowerRegulationModified", "Active power regulation");
return subReportNodeSetpoints2;
return null;
}

public void checkMaxQGreaterThanMinQ(
Original file line number Diff line number Diff line change
@@ -13,6 +13,7 @@
import com.powsybl.iidm.network.extensions.ConnectablePosition;
import com.powsybl.iidm.network.extensions.ConnectablePositionAdder;
import org.gridsuite.modification.server.NetworkModificationException;
import org.gridsuite.modification.server.dto.AttributeModification;
import org.gridsuite.modification.server.dto.ShuntCompensatorModificationInfos;
import org.gridsuite.modification.server.dto.ShuntCompensatorType;

@@ -81,21 +82,30 @@ public void apply(Network network, ReportNode subReportNode) {
PropertiesUtils.applyProperties(shuntCompensator, subReportNode, modificationInfos.getProperties(), "ShuntCompensatorProperties");
}

private void modifyMaximumSectionCount(List<ReportNode> reports, ShuntCompensator shuntCompensator, ShuntCompensatorLinearModel model) {
if (modificationInfos.getMaximumSectionCount() != null) {
var maximumSectionCount = modificationInfos.getMaximumSectionCount().getValue();
if (modificationInfos.getMaxSusceptance() == null && modificationInfos.getMaxQAtNominalV() == null) {
public static void modifyMaximumSectionCount(AttributeModification<Integer> maximumSectionCountModif,
AttributeModification<Double> maxSusceptance,
AttributeModification<Double> maxQAtNominalV,
List<ReportNode> reports,
ShuntCompensator shuntCompensator,
ShuntCompensatorLinearModel model) {
if (maximumSectionCountModif != null) {
var maximumSectionCount = maximumSectionCountModif.getValue();
if (maxSusceptance == null && maxQAtNominalV == null) {
model.setBPerSection(model.getBPerSection() * shuntCompensator.getMaximumSectionCount() / maximumSectionCount);
}
reports.add(ModificationUtils.getInstance().buildModificationReport(shuntCompensator.getMaximumSectionCount(), maximumSectionCount, "Maximum section count"));
if (reports != null) {
reports.add(ModificationUtils.getInstance().buildModificationReport(shuntCompensator.getMaximumSectionCount(), maximumSectionCount, "Maximum section count"));
}
model.setMaximumSectionCount(maximumSectionCount);
}
}

private void modifySectionCount(List<ReportNode> reports, ShuntCompensator shuntCompensator) {
if (modificationInfos.getSectionCount() != null) {
var newSectionCount = modificationInfos.getSectionCount().getValue();
reports.add(ModificationUtils.getInstance().buildModificationReport(shuntCompensator.getSectionCount(), newSectionCount, "Section count"));
public static void modifySectionCount(AttributeModification<Integer> sectionCount, List<ReportNode> reports, ShuntCompensator shuntCompensator) {
if (sectionCount != null) {
var newSectionCount = sectionCount.getValue();
if (reports != null) {
reports.add(ModificationUtils.getInstance().buildModificationReport(shuntCompensator.getSectionCount(), newSectionCount, "Section count"));
}
shuntCompensator.setSectionCount(newSectionCount);
}
}
@@ -106,7 +116,6 @@ private void applyModificationOnLinearModel(ReportNode subReportNode, ShuntCompe
var shuntCompensatorType = model.getBPerSection() > 0 ? ShuntCompensatorType.CAPACITOR : ShuntCompensatorType.REACTOR;
double oldSusceptancePerSection = model.getBPerSection();
double oldQAtNominalV = Math.abs(Math.pow(voltageLevel.getNominalV(), 2) * oldSusceptancePerSection);
double oldMaxSusceptance = oldSusceptancePerSection * shuntCompensator.getMaximumSectionCount();
double oldMaxQAtNominalV = oldQAtNominalV * shuntCompensator.getMaximumSectionCount();
double oldSwitchedOnSusceptance = oldSusceptancePerSection * shuntCompensator.getSectionCount();
double oldSwitchedOnQAtNominalV = oldQAtNominalV * shuntCompensator.getSectionCount();
@@ -118,11 +127,17 @@ private void applyModificationOnLinearModel(ReportNode subReportNode, ShuntCompe
// due to cross validation between maximum section count and section count, we need to modify section count first
// when maximum section count old value is greater than the new one
if (modificationInfos.getMaximumSectionCount() != null && modificationInfos.getMaximumSectionCount().getValue() < shuntCompensator.getMaximumSectionCount()) {
modifySectionCount(reports, shuntCompensator);
modifyMaximumSectionCount(reports, shuntCompensator, model);
modifySectionCount(modificationInfos.getSectionCount(), reports, shuntCompensator);
modifyMaximumSectionCount(modificationInfos.getMaximumSectionCount(),
modificationInfos.getMaxSusceptance(),
modificationInfos.getMaxQAtNominalV(),
reports, shuntCompensator, model);
} else {
modifyMaximumSectionCount(reports, shuntCompensator, model);
modifySectionCount(reports, shuntCompensator);
modifyMaximumSectionCount(modificationInfos.getMaximumSectionCount(),
modificationInfos.getMaxSusceptance(),
modificationInfos.getMaxQAtNominalV(),
reports, shuntCompensator, model);
modifySectionCount(modificationInfos.getSectionCount(), reports, shuntCompensator);
}

int maximumSectionCount = modificationInfos.getMaximumSectionCount() != null ? modificationInfos.getMaximumSectionCount().getValue() : shuntCompensator.getMaximumSectionCount();
@@ -140,29 +155,52 @@ private void applyModificationOnLinearModel(ReportNode subReportNode, ShuntCompe
}

if (modificationInfos.getMaxQAtNominalV() != null) {
if (modificationInfos.getMaxQAtNominalV().getValue() < 0) {
throw new NetworkModificationException(NetworkModificationException.Type.MODIFY_SHUNT_COMPENSATOR_ERROR,
"Qmax at nominal voltage should be greater or equal to 0");
}
double newQatNominalV = modificationInfos.getMaxQAtNominalV().getValue() / maximumSectionCount;
double newSusceptancePerSection = newQatNominalV / Math.pow(voltageLevel.getNominalV(), 2);
reports.add(ModificationUtils.getInstance().buildModificationReport(oldMaxQAtNominalV, modificationInfos.getMaxQAtNominalV().getValue(), "Qmax available at nominal voltage"));

model.setBPerSection(shuntCompensatorType == ShuntCompensatorType.CAPACITOR ? newSusceptancePerSection : -newSusceptancePerSection);
modifyMaximumQAtNominalVoltage(modificationInfos.getMaxQAtNominalV(), voltageLevel, maximumSectionCount, reports, model, shuntCompensatorType);
}

if (modificationInfos.getMaxSusceptance() != null) {
double newSusceptancePerSection = modificationInfos.getMaxSusceptance().getValue() / maximumSectionCount;
reports.add(ModificationUtils.getInstance().buildModificationReport(oldMaxSusceptance, modificationInfos.getMaxSusceptance().getValue(), "Maximal susceptance available"));

model.setBPerSection(newSusceptancePerSection);
modifyMaxSusceptance(modificationInfos.getMaxSusceptance(), maximumSectionCount, reports, model);
}

reportSwitchedOnAndPerSectionValues(reports, oldQAtNominalV, oldSwitchedOnQAtNominalV, oldSusceptancePerSection, oldSwitchedOnSusceptance, oldMaxQAtNominalV, sectionCount, maximumSectionCount);

reports.forEach(report -> insertReportNode(subReportNode, report));
}

public static void modifyMaxSusceptance(AttributeModification<Double> maxSusceptance,
int maximumSectionCount,
List<ReportNode> reports,
ShuntCompensatorLinearModel model) {
double newSusceptancePerSection = maxSusceptance.getValue() / maximumSectionCount;
if (reports != null) {
double oldSusceptancePerSection = model.getBPerSection();
double oldMaxSusceptance = oldSusceptancePerSection * maximumSectionCount;
reports.add(ModificationUtils.getInstance().buildModificationReport(oldMaxSusceptance, maxSusceptance.getValue(), "Maximal susceptance available"));
}
model.setBPerSection(newSusceptancePerSection);
}

public static void modifyMaximumQAtNominalVoltage(AttributeModification<Double> maxQAtNominalV,
VoltageLevel voltageLevel,
int maximumSectionCount,
List<ReportNode> reports,
ShuntCompensatorLinearModel model,
ShuntCompensatorType shuntCompensatorType) {
if (maxQAtNominalV.getValue() < 0) {
throw new NetworkModificationException(NetworkModificationException.Type.MODIFY_SHUNT_COMPENSATOR_ERROR,
"Qmax at nominal voltage should be greater or equal to 0");
}
double newQatNominalV = maxQAtNominalV.getValue() / maximumSectionCount;
double newSusceptancePerSection = newQatNominalV / Math.pow(voltageLevel.getNominalV(), 2);
if (reports != null) {
double oldSusceptancePerSection = model.getBPerSection();
double oldQAtNominalV = Math.abs(Math.pow(voltageLevel.getNominalV(), 2) * oldSusceptancePerSection);
double oldMaxQAtNominalV = oldQAtNominalV * maximumSectionCount;
reports.add(ModificationUtils.getInstance().buildModificationReport(oldMaxQAtNominalV, maxQAtNominalV.getValue(), "Qmax available at nominal voltage"));
}

model.setBPerSection(shuntCompensatorType == ShuntCompensatorType.CAPACITOR ? newSusceptancePerSection : -newSusceptancePerSection);
}

private void reportSwitchedOnAndPerSectionValues(List<ReportNode> reports, double oldQAtNominalV, double oldSwitchedOnQAtNominalV, double oldSusceptancePerSection, double oldSwitchedOnSusceptance, double oldMaxQAtNominalV, int sectionCount, int maximumSectionCount) {
if (modificationInfos.getMaxQAtNominalV() != null) {
double newQatNominalV = modificationInfos.getMaxQAtNominalV().getValue() / maximumSectionCount;

Large diffs are not rendered by default.

Original file line number Diff line number Diff line change
@@ -13,7 +13,9 @@
import com.powsybl.iidm.network.extensions.IdentifiableShortCircuit;
import com.powsybl.iidm.network.extensions.IdentifiableShortCircuitAdder;
import org.gridsuite.modification.server.NetworkModificationException;
import org.gridsuite.modification.server.dto.AttributeModification;
import org.gridsuite.modification.server.dto.VoltageLevelModificationInfos;

import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
@@ -84,52 +86,79 @@ public void apply(Network network, ReportNode subReportNode) {
.add();

ModificationUtils.getInstance().applyElementaryModifications(voltageLevel::setName, () -> voltageLevel.getOptionalName().orElse("No value"), modificationInfos.getEquipmentName(), subReportNode, "Name");
ModificationUtils.getInstance().applyElementaryModifications(voltageLevel::setNominalV, voltageLevel::getNominalV, modificationInfos.getNominalV(), subReportNode, "Nominal voltage");
ModificationUtils.getInstance().applyElementaryModifications(voltageLevel::setLowVoltageLimit, voltageLevel::getLowVoltageLimit, modificationInfos.getLowVoltageLimit(), subReportNode, "Low voltage limit");
ModificationUtils.getInstance().applyElementaryModifications(voltageLevel::setHighVoltageLimit, voltageLevel::getHighVoltageLimit, modificationInfos.getHighVoltageLimit(), subReportNode, "High voltage limit");
modifyNominalV(voltageLevel, modificationInfos.getNominalV(), subReportNode);
modifLowVoltageLimit(voltageLevel, modificationInfos.getLowVoltageLimit(), subReportNode);
modifyHighVoltageLimit(voltageLevel, modificationInfos.getHighVoltageLimit(), subReportNode);

modifyVoltageLevelShortCircuit(subReportNode, voltageLevel);
modifyVoltageLevelShortCircuit(modificationInfos.getIpMin(), modificationInfos.getIpMax(), subReportNode, voltageLevel);
PropertiesUtils.applyProperties(voltageLevel, subReportNode, modificationInfos.getProperties(), "VlProperties");
}

private void modifyVoltageLevelShortCircuit(ReportNode subReportNode, VoltageLevel voltageLevel) {
if (modificationInfos.getIpMin() != null || modificationInfos.getIpMax() != null) {
List<ReportNode> reports = new ArrayList<>();
IdentifiableShortCircuit<VoltageLevel> identifiableShortCircuit = voltageLevel.getExtension(IdentifiableShortCircuit.class);
IdentifiableShortCircuitAdder<VoltageLevel> identifiableShortCircuitAdder = voltageLevel.newExtension(IdentifiableShortCircuitAdder.class);
var oldIpMin = identifiableShortCircuit == null ? null : identifiableShortCircuit.getIpMin();
var oldIpMax = identifiableShortCircuit == null ? null : identifiableShortCircuit.getIpMax();
public static void modifyHighVoltageLimit(VoltageLevel voltageLevel, AttributeModification<Double> highVoltageLimit, ReportNode subReportNode) {
ModificationUtils.getInstance().applyElementaryModifications(voltageLevel::setHighVoltageLimit, voltageLevel::getHighVoltageLimit, highVoltageLimit, subReportNode, "High voltage limit");
}

if (modificationInfos.getIpMin() != null) {
var newIpMin = modificationInfos.getIpMin().getValue();
public static void modifLowVoltageLimit(VoltageLevel voltageLevel, AttributeModification<Double> lowVoltageLimit, ReportNode subReportNode) {
ModificationUtils.getInstance().applyElementaryModifications(voltageLevel::setLowVoltageLimit, voltageLevel::getLowVoltageLimit, lowVoltageLimit, subReportNode, "Low voltage limit");
}

identifiableShortCircuitAdder.withIpMin(newIpMin);
public static void modifyNominalV(VoltageLevel voltageLevel, AttributeModification<Double> modifNominalV, ReportNode subReportNode) {
ModificationUtils.getInstance().applyElementaryModifications(voltageLevel::setNominalV, voltageLevel::getNominalV, modifNominalV, subReportNode, "Nominal voltage");
}

//convert to kA to report it like the user set it.
var oldIpMinToReport = oldIpMin != null ? oldIpMin * 0.001 : null;
var newIpMinToReport = newIpMin * 0.001;
public static void modifyVoltageLevelShortCircuit(AttributeModification<Double> ipMin,
AttributeModification<Double> ipMax,
ReportNode subReportNode,
VoltageLevel voltageLevel) {
if (ipMin == null && ipMax == null) {
return;
}

reports.add(ModificationUtils.getInstance()
.buildModificationReport(oldIpMinToReport, newIpMinToReport, "Low short circuit current limit"));
} else if (oldIpMin != null) {
identifiableShortCircuitAdder.withIpMin(oldIpMin);
}
List<ReportNode> reports = new ArrayList<>();
IdentifiableShortCircuitAdder<VoltageLevel> identifiableShortCircuitAdder = voltageLevel.newExtension(IdentifiableShortCircuitAdder.class);
Double oldIpMin = null;
Double oldIpMax = null;
IdentifiableShortCircuit<VoltageLevel> identifiableShortCircuit = voltageLevel.getExtension(IdentifiableShortCircuit.class);
if (identifiableShortCircuit != null) {
oldIpMin = identifiableShortCircuit.getIpMin();
oldIpMax = identifiableShortCircuit.getIpMax();
}

if (modificationInfos.getIpMax() != null) {
var newIpMax = modificationInfos.getIpMax().getValue();
identifiableShortCircuitAdder.withIpMax(newIpMax);

//Convert to kA to report it like the user set it.
var oldIpMaxToReport = oldIpMax != null ? oldIpMax * 0.001 : null;
var newIpMaxToReport = newIpMax * 0.001;
reports.add(ModificationUtils.getInstance()
.buildModificationReport(oldIpMaxToReport, newIpMaxToReport, "High short circuit current limit"));
} else if (oldIpMax != null) {
identifiableShortCircuitAdder.withIpMax(oldIpMax);
}
if (ipMin != null) {
var newIpMin = ipMin.getValue();

identifiableShortCircuitAdder.add();
identifiableShortCircuitAdder.withIpMin(newIpMin);

//convert to kA to report it like the user set it.
var oldIpMinToReport = convertToKiloAmps(oldIpMin);
var newIpMinToReport = convertToKiloAmps(newIpMin);
reports.add(ModificationUtils.getInstance()
.buildModificationReport(oldIpMinToReport, newIpMinToReport, "Low short circuit current limit"));
} else if (oldIpMin != null) {
identifiableShortCircuitAdder.withIpMin(oldIpMin);
}

if (ipMax != null) {
var newIpMax = ipMax.getValue();
identifiableShortCircuitAdder.withIpMax(newIpMax);

//Convert to kA to report it like the user set it.
var oldIpMaxToReport = convertToKiloAmps(oldIpMax);
var newIpMaxToReport = convertToKiloAmps(newIpMax);
reports.add(ModificationUtils.getInstance()
.buildModificationReport(oldIpMaxToReport, newIpMaxToReport, "High short circuit current limit"));
} else if (oldIpMax != null) {
identifiableShortCircuitAdder.withIpMax(oldIpMax);
}

identifiableShortCircuitAdder.add();
if (subReportNode != null) {
reports.forEach(report -> insertReportNode(subReportNode, report));
}
}

private static Double convertToKiloAmps(Double value) {
return (value != null) ? value * 0.001 : null;
}
}

Original file line number Diff line number Diff line change
@@ -299,7 +299,7 @@ protected void assertAfterNetworkModificationCreation() {
assertNotNull(generatorStartup1);
assertEquals(50, generator1.getTargetP(), 0);
assertEquals(15, generatorStartup1.getMarginalCost(), 0);
assertEquals(55, generatorStartup1.getPlannedOutageRate(), 0);
assertEquals(2.5, generatorStartup1.getPlannedOutageRate(), 0);
assertEquals(1100, generatorStartup1.getForcedOutageRate(), 0);
assertEquals(50, generatorStartup1.getPlannedActivePowerSetpoint(), 0);
assertEquals(502, generator1.getMaxP(), 0);
@@ -310,7 +310,7 @@ protected void assertAfterNetworkModificationCreation() {
assertNotNull(generatorStartup2);
assertEquals(100, generator2.getTargetP(), 0);
assertEquals(15, generatorStartup2.getMarginalCost(), 0);
assertEquals(55, generatorStartup2.getPlannedOutageRate(), 0);
assertEquals(2.5, generatorStartup2.getPlannedOutageRate(), 0);
assertEquals(1100, generatorStartup2.getForcedOutageRate(), 0);
assertEquals(50, generatorStartup2.getPlannedActivePowerSetpoint(), 0);
assertEquals(2002, generator2.getMaxP(), 0);

0 comments on commit ef248d1

Please sign in to comment.