Skip to content

Commit 70739ca

Browse files
Tristan-WorkGHTristan-WorkGH
committed
refactor voltage limits
1 parent bc03a8f commit 70739ca

File tree

1 file changed

+71
-67
lines changed

1 file changed

+71
-67
lines changed

‎src/main/java/org/gridsuite/voltageinit/server/service/parameters/VoltageInitParametersService.java‎

Lines changed: 71 additions & 67 deletions
Original file line numberDiff line numberDiff line change
@@ -10,6 +10,7 @@
1010
import com.powsybl.iidm.network.VoltageLevel;
1111
import com.powsybl.openreac.parameters.input.OpenReacParameters;
1212
import com.powsybl.openreac.parameters.input.VoltageLimitOverride;
13+
import com.powsybl.openreac.parameters.input.VoltageLimitOverride.VoltageLimitType;
1314
import com.powsybl.openreac.parameters.input.algo.ReactiveSlackBusesMode;
1415
import org.gridsuite.voltageinit.server.dto.parameters.FilterEquipments;
1516
import org.gridsuite.voltageinit.server.dto.parameters.IdentifiableAttributes;
@@ -93,99 +94,102 @@ private Map<String, VoltageLimitEntity> resolveVoltageLevelLimits(VoltageInitRun
9394
return voltageLevelLimits;
9495
}
9596

96-
private void fillSpecificVoltageLimits(List<VoltageLimitOverride> specificVoltageLimits, Map<String, VoltageLimitEntity> voltageLevelModificationLimits, Map<String, VoltageLimitEntity> voltageLevelDefaultLimits, VoltageLevel voltageLevel, Map<String, Double> voltageLevelsIdsRestricted) {
97-
boolean isLowVoltageLimitModificationSet = voltageLevelModificationLimits.containsKey(voltageLevel.getId()) && voltageLevelModificationLimits.get(voltageLevel.getId()).getLowVoltageLimit() != null;
98-
boolean isHighVoltageLimitModificationSet = voltageLevelModificationLimits.containsKey(voltageLevel.getId()) && voltageLevelModificationLimits.get(voltageLevel.getId()).getHighVoltageLimit() != null;
99-
boolean isLowVoltageLimitDefaultSet = voltageLevelDefaultLimits.containsKey(voltageLevel.getId()) && voltageLevelDefaultLimits.get(voltageLevel.getId()).getLowVoltageLimit() != null;
100-
boolean isHighVoltageLimitDefaultSet = voltageLevelDefaultLimits.containsKey(voltageLevel.getId()) && voltageLevelDefaultLimits.get(voltageLevel.getId()).getHighVoltageLimit() != null;
101-
102-
setLowVoltageLimit(specificVoltageLimits, voltageLevelModificationLimits, voltageLevelDefaultLimits, isLowVoltageLimitModificationSet, isLowVoltageLimitDefaultSet, voltageLevel, voltageLevelsIdsRestricted);
103-
setHighVoltageLimit(specificVoltageLimits, voltageLevelModificationLimits, voltageLevelDefaultLimits, isHighVoltageLimitModificationSet, isHighVoltageLimitDefaultSet, voltageLevel);
97+
private static void fillSpecificVoltageLimits(List<VoltageLimitOverride> specificVoltageLimits,
98+
Map<String, VoltageLimitEntity> voltageLevelModificationLimits,
99+
Map<String, VoltageLimitEntity> voltageLevelDefaultLimits,
100+
VoltageLevel voltageLevel,
101+
Map<String, Double> voltageLevelsIdsRestricted) {
102+
if (voltageLevelDefaultLimits.containsKey(voltageLevel.getId()) || voltageLevelModificationLimits.containsKey(voltageLevel.getId())) {
103+
setLowVoltageLimit(specificVoltageLimits, voltageLevelModificationLimits, voltageLevelDefaultLimits, voltageLevel, voltageLevelsIdsRestricted);
104+
setHighVoltageLimit(specificVoltageLimits, voltageLevelModificationLimits, voltageLevelDefaultLimits, voltageLevel);
105+
}
104106
}
105107

106-
private void setLowVoltageLimit(List<VoltageLimitOverride> specificVoltageLimits,
107-
Map<String, VoltageLimitEntity> voltageLevelModificationLimits,
108-
Map<String, VoltageLimitEntity> voltageLevelDefaultLimits,
109-
boolean isLowVoltageLimitModificationSet,
110-
boolean isLowVoltageLimitDefaultSet,
111-
VoltageLevel voltageLevel,
112-
Map<String, Double> voltageLevelsIdsRestricted) {
108+
private static void setLowVoltageLimit(List<VoltageLimitOverride> specificVoltageLimits,
109+
Map<String, VoltageLimitEntity> voltageLevelModificationLimits,
110+
Map<String, VoltageLimitEntity> voltageLevelDefaultLimits,
111+
VoltageLevel voltageLevel,
112+
Map<String, Double> voltageLevelsIdsRestricted) {
113+
final String voltageLevelId = voltageLevel.getId();
114+
final boolean isLowVoltageLimitModificationSet = voltageLevelModificationLimits.containsKey(voltageLevelId) && voltageLevelModificationLimits.get(voltageLevelId).getLowVoltageLimit() != null;
115+
final double lowVoltageLimit = voltageLevel.getLowVoltageLimit();
113116
double newLowVoltageLimit;
114-
double lowVoltageLimit = voltageLevel.getLowVoltageLimit();
115117
if (!Double.isNaN(lowVoltageLimit) && isLowVoltageLimitModificationSet) {
116-
double lowVoltageLimitModification = voltageLevelModificationLimits.get(voltageLevel.getId()).getLowVoltageLimit();
117-
118+
double lowVoltageLimitModification = voltageLevelModificationLimits.get(voltageLevelId).getLowVoltageLimit();
118119
if (lowVoltageLimit + lowVoltageLimitModification < 0) {
119120
newLowVoltageLimit = lowVoltageLimit * -1;
120-
voltageLevelsIdsRestricted.put(voltageLevel.getId(), newLowVoltageLimit);
121+
voltageLevelsIdsRestricted.put(voltageLevelId, newLowVoltageLimit);
121122
} else {
122123
newLowVoltageLimit = lowVoltageLimitModification;
123124
}
124-
specificVoltageLimits.add(new VoltageLimitOverride(voltageLevel.getId(), VoltageLimitOverride.VoltageLimitType.LOW_VOLTAGE_LIMIT, true, newLowVoltageLimit));
125+
specificVoltageLimits.add(new VoltageLimitOverride(voltageLevelId, VoltageLimitType.LOW_VOLTAGE_LIMIT, true, newLowVoltageLimit));
125126

126-
} else if (Double.isNaN(lowVoltageLimit) && isLowVoltageLimitDefaultSet) {
127-
double voltageLimit = voltageLevelDefaultLimits.get(voltageLevel.getId()).getLowVoltageLimit() + (isLowVoltageLimitModificationSet ? voltageLevelModificationLimits.get(voltageLevel.getId()).getLowVoltageLimit() : 0.);
127+
} else if (Double.isNaN(lowVoltageLimit)
128+
&& voltageLevelDefaultLimits.containsKey(voltageLevelId)
129+
&& voltageLevelDefaultLimits.get(voltageLevelId).getLowVoltageLimit() != null) {
130+
double voltageLimit = voltageLevelDefaultLimits.get(voltageLevelId).getLowVoltageLimit() + (isLowVoltageLimitModificationSet ? voltageLevelModificationLimits.get(voltageLevelId).getLowVoltageLimit() : 0.);
128131
if (voltageLimit < 0) {
129132
newLowVoltageLimit = 0.0;
130-
voltageLevelsIdsRestricted.put(voltageLevel.getId(), newLowVoltageLimit);
133+
voltageLevelsIdsRestricted.put(voltageLevelId, newLowVoltageLimit);
131134
} else {
132135
newLowVoltageLimit = voltageLimit;
133136
}
134-
specificVoltageLimits.add(
135-
new VoltageLimitOverride(voltageLevel.getId(),
136-
VoltageLimitOverride.VoltageLimitType.LOW_VOLTAGE_LIMIT,
137-
false,
138-
newLowVoltageLimit
139-
));
137+
specificVoltageLimits.add(new VoltageLimitOverride(voltageLevelId, VoltageLimitType.LOW_VOLTAGE_LIMIT, false, newLowVoltageLimit));
140138
}
141139
}
142140

143-
private void setHighVoltageLimit(List<VoltageLimitOverride> specificVoltageLimits, Map<String, VoltageLimitEntity> voltageLevelModificationLimits, Map<String, VoltageLimitEntity> voltageLevelDefaultLimits, boolean isHighVoltageLimitModificationSet, boolean isHighVoltageLimitDefaultSet, VoltageLevel voltageLevel) {
144-
if (!Double.isNaN(voltageLevel.getHighVoltageLimit()) && isHighVoltageLimitModificationSet) {
145-
specificVoltageLimits.add(new VoltageLimitOverride(voltageLevel.getId(), VoltageLimitOverride.VoltageLimitType.HIGH_VOLTAGE_LIMIT, true, voltageLevelModificationLimits.get(voltageLevel.getId()).getHighVoltageLimit()));
146-
} else if (Double.isNaN(voltageLevel.getHighVoltageLimit()) && isHighVoltageLimitDefaultSet) {
147-
specificVoltageLimits.add(new VoltageLimitOverride(voltageLevel.getId(), VoltageLimitOverride.VoltageLimitType.HIGH_VOLTAGE_LIMIT, false, voltageLevelDefaultLimits.get(voltageLevel.getId()).getHighVoltageLimit() + (isHighVoltageLimitModificationSet ? voltageLevelModificationLimits.get(voltageLevel.getId()).getHighVoltageLimit() : 0.)));
141+
private static void setHighVoltageLimit(List<VoltageLimitOverride> specificVoltageLimits,
142+
Map<String, VoltageLimitEntity> voltageLevelModificationLimits,
143+
Map<String, VoltageLimitEntity> voltageLevelDefaultLimits,
144+
VoltageLevel voltageLevel) {
145+
final String voltageLevelId = voltageLevel.getId();
146+
final boolean isHighVoltageLimitModificationSet = voltageLevelModificationLimits.containsKey(voltageLevelId) && voltageLevelModificationLimits.get(voltageLevelId).getHighVoltageLimit() != null;
147+
final double highVoltageLimit = voltageLevel.getHighVoltageLimit();
148+
if (!Double.isNaN(highVoltageLimit) && isHighVoltageLimitModificationSet) {
149+
specificVoltageLimits.add(new VoltageLimitOverride(
150+
voltageLevelId,
151+
VoltageLimitType.HIGH_VOLTAGE_LIMIT,
152+
true,
153+
voltageLevelModificationLimits.get(voltageLevelId).getHighVoltageLimit()
154+
));
155+
} else if (Double.isNaN(highVoltageLimit)
156+
&& voltageLevelDefaultLimits.containsKey(voltageLevelId)
157+
&& voltageLevelDefaultLimits.get(voltageLevelId).getHighVoltageLimit() != null) {
158+
specificVoltageLimits.add(new VoltageLimitOverride(
159+
voltageLevelId,
160+
VoltageLimitType.HIGH_VOLTAGE_LIMIT,
161+
false,
162+
voltageLevelDefaultLimits.get(voltageLevelId).getHighVoltageLimit() + (isHighVoltageLimitModificationSet ? voltageLevelModificationLimits.get(voltageLevelId).getHighVoltageLimit() : 0.)
163+
));
148164
}
149165
}
150166

151167
@Transactional(readOnly = true)
152168
public OpenReacParameters buildOpenReacParameters(VoltageInitRunContext context, Network network) {
153169
final long startTime = System.nanoTime();
154-
155-
Optional<VoltageInitParametersEntity> voltageInitParametersEntity = Optional.empty();
156-
if (context.getParametersUuid() != null) {
157-
voltageInitParametersEntity = voltageInitParametersRepository.findById(context.getParametersUuid());
158-
}
159-
160170
OpenReacParameters parameters = new OpenReacParameters();
161-
List<VoltageLimitOverride> specificVoltageLimits = new ArrayList<>();
162-
List<String> constantQGenerators = new ArrayList<>();
163-
List<String> variableTwoWindingsTransformers = new ArrayList<>();
164-
List<String> variableShuntCompensators = new ArrayList<>();
165-
166-
voltageInitParametersEntity.ifPresent(voltageInitParameters -> {
167-
if (voltageInitParameters.getVoltageLimits() != null) {
168-
Map<String, VoltageLimitEntity> voltageLevelDefaultLimits = resolveVoltageLevelLimits(context, voltageInitParameters.getVoltageLimits().stream()
169-
.filter(voltageLimit -> VoltageLimitParameterType.DEFAULT.equals(voltageLimit.getVoltageLimitParameterType()))
170-
.toList());
171-
172-
Map<String, VoltageLimitEntity> voltageLevelModificationLimits = resolveVoltageLevelLimits(context, voltageInitParameters.getVoltageLimits().stream()
173-
.filter(voltageLimit -> VoltageLimitParameterType.MODIFICATION.equals(voltageLimit.getVoltageLimitParameterType()))
174-
.toList());
175-
176-
network.getVoltageLevelStream()
177-
.filter(voltageLevel -> voltageLevelDefaultLimits.keySet().contains(voltageLevel.getId()) || voltageLevelModificationLimits.keySet().contains(voltageLevel.getId()))
178-
.forEach(voltageLevel -> fillSpecificVoltageLimits(specificVoltageLimits, voltageLevelModificationLimits, voltageLevelDefaultLimits, voltageLevel, context.getVoltageLevelsIdsRestricted()));
179-
}
180171

181-
constantQGenerators.addAll(toEquipmentIdsList(context.getNetworkUuid(), context.getVariantId(), voltageInitParameters.getConstantQGenerators()));
182-
variableTwoWindingsTransformers.addAll(toEquipmentIdsList(context.getNetworkUuid(), context.getVariantId(), voltageInitParameters.getVariableTwoWindingsTransformers()));
183-
variableShuntCompensators.addAll(toEquipmentIdsList(context.getNetworkUuid(), context.getVariantId(), voltageInitParameters.getVariableShuntCompensators()));
184-
});
185-
parameters.addSpecificVoltageLimits(specificVoltageLimits)
186-
.addConstantQGenerators(constantQGenerators)
187-
.addVariableTwoWindingsTransformers(variableTwoWindingsTransformers)
188-
.addVariableShuntCompensators(variableShuntCompensators);
172+
Optional.ofNullable(context.getParametersUuid())
173+
.flatMap(voltageInitParametersRepository::findById)
174+
.ifPresent(voltageInitParameters -> {
175+
if (voltageInitParameters.getVoltageLimits() != null) {
176+
final Map<String, VoltageLimitEntity> voltageLevelDefaultLimits = resolveVoltageLevelLimits(context, voltageInitParameters.getVoltageLimits()
177+
.stream()
178+
.filter(voltageLimit -> VoltageLimitParameterType.DEFAULT.equals(voltageLimit.getVoltageLimitParameterType()))
179+
.toList());
180+
final Map<String, VoltageLimitEntity> voltageLevelModificationLimits = resolveVoltageLevelLimits(context, voltageInitParameters.getVoltageLimits()
181+
.stream()
182+
.filter(voltageLimit -> VoltageLimitParameterType.MODIFICATION.equals(voltageLimit.getVoltageLimitParameterType()))
183+
.toList());
184+
List<VoltageLimitOverride> specificVoltageLimits = new LinkedList<>();
185+
network.getVoltageLevelStream()
186+
.forEach(voltageLevel -> fillSpecificVoltageLimits(specificVoltageLimits, voltageLevelModificationLimits, voltageLevelDefaultLimits, voltageLevel, context.getVoltageLevelsIdsRestricted()));
187+
parameters.addSpecificVoltageLimits(specificVoltageLimits);
188+
}
189+
parameters.addConstantQGenerators(toEquipmentIdsList(context.getNetworkUuid(), context.getVariantId(), voltageInitParameters.getConstantQGenerators()))
190+
.addVariableTwoWindingsTransformers(toEquipmentIdsList(context.getNetworkUuid(), context.getVariantId(), voltageInitParameters.getVariableTwoWindingsTransformers()))
191+
.addVariableShuntCompensators(toEquipmentIdsList(context.getNetworkUuid(), context.getVariantId(), voltageInitParameters.getVariableShuntCompensators()));
192+
});
189193

190194
//The optimizer will attach reactive slack variables to all buses
191195
parameters.setReactiveSlackBusesMode(ReactiveSlackBusesMode.ALL);

0 commit comments

Comments
 (0)