diff --git a/README.md b/README.md index 6e90706b..5511c92f 100644 --- a/README.md +++ b/README.md @@ -4,4 +4,248 @@ [![Coverage Status](https://sonarcloud.io/api/project_badges/measure?project=org.gridsuite%3Anetwork-modification&metric=coverage)](https://sonarcloud.io/component_measures?id=org.gridsuite%3Anetwork-modification&metric=coverage) [![MPL-2.0 License](https://img.shields.io/badge/license-MPL_2.0-blue.svg)](https://www.mozilla.org/en-US/MPL/2.0/) -Library for applying network modifications on a network. +## Architecture + +This library is organized around two distinct responsibilities that must not be confused: + +- **Describing** a modification — the serializable input data exchanged over REST and persisted by the + server (the `dto` package, suffixed `*Infos`). +- **Applying** a modification — the executable logic that mutates a PowSyBl `Network` (the `modifications` + package). + +Keeping these two concerns separated is the central design goal: it lets the *execution* code stand on its +own, ultimately as a standalone library that does not need the server-oriented DTO layer. + +### Package layout + +``` +org.gridsuite.modification +├── (root) Cross-cutting contracts & enums: NetworkModificationException, +│ ModificationType, IFilterService, ILoadFlowService, VariationMode, … +├── modifications The execution layer. One class per modification (e.g. LoadCreation), +│ │ each extending AbstractModification and implementing apply(Network, …). +│ ├── data Plain data holders that belong to the execution layer but are not yet +│ │ moved out of dto (see "Shared data objects" below). +│ ├── byfilter "By filter" / "by formula" modification execution. +│ ├── tabular Tabular (bulk) modification execution — special case, see below. +│ └── olg Operational-limits-group execution helpers. +├── dto The description layer. One *Infos class per modification, all extending +│ │ ModificationInfos. REST contract (Swagger) + JPA/serialization model. +│ ├── annotation DTO annotations (@ModificationErrorTypeName, …). +│ ├── byfilter DTO for by-filter/by-formula modifications. +│ └── tabular DTO for tabular modifications. +├── utils Stateless helpers operating on the network (ModificationUtils, …). +└── report PowSyBl report resource bundle. +``` + +### The two layers and the bridge between them + +Every modification exists as a pair: + +| Layer | Example | Base class | Role | +|--------------|------------------|-----------------------|------------------------------------------------------------| +| `dto` | `LoadCreationInfos` | `ModificationInfos` | Serializable description: REST contract, persistence, Swagger. | +| `modifications` | `LoadCreation` | `AbstractModification` | Executable logic: `check(network)` then `apply(network, …)`. | + +`ModificationInfos` is the polymorphic root of the DTO layer (`@JsonTypeInfo` + `@JsonSubTypes`); it carries +the server-specific fields (`uuid`, `date`, `stashed`, `activated`, `messageType`, `messageValues`, +`description`) and the Swagger annotations. + +The single bridge from description to execution is `ModificationInfos#toModification()`. Each leaf `*Infos` +builds its matching modification from its own fields: + +```java +// LoadCreationInfos +public AbstractModification toModification() { + return LoadCreation.builder() + .equipmentId(getEquipmentId()) + .p0(p0) + .q0(q0) + // … copy every field … + .build(); +} +``` + +This is why the modification classes **redeclare their business fields** instead of inheriting them from the +`*Infos` DTO: it severs the dependency from `modifications` to the server-oriented `ModificationInfos` +hierarchy. The modification is a self-contained, builder-constructed object; the DTO merely knows how to +populate it. + +### Class hierarchy + +Both layers mirror the same equipment taxonomy, but in two independent trees. + +#### Execution layer (`modifications`) + +Every applied modification descends from `AbstractModification` (itself a PowSyBl +`AbstractNetworkModification`). The abstract bases factor out the shared `check`/`apply`/reporting logic: + +``` +AbstractNetworkModification (powsybl) +└── AbstractModification + ├── AbstractEquipmentBase + │ ├── AbstractEquipmentCreation + │ │ ├── AbstractInjectionCreation ........ implements InjectionCreation + │ │ │ ├── LoadCreation + │ │ │ ├── GeneratorCreation ............ implements ReactiveLimitsHolderInfos + │ │ │ ├── BatteryCreation .............. implements ReactiveLimitsHolderInfos + │ │ │ ├── ShuntCompensatorCreation + │ │ │ └── StaticVarCompensatorCreation + │ │ ├── AbstractBranchCreation + │ │ │ ├── LineCreation + │ │ │ └── TwoWindingsTransformerCreation + │ │ ├── SubstationCreation + │ │ ├── VoltageLevelCreation + │ │ ├── LccCreation + │ │ └── VscCreation + │ ├── AbstractEquipmentModification + │ │ ├── AbstractInjectionModification .... implements InjectionModification + │ │ │ ├── LoadModification + │ │ │ ├── GeneratorModification + │ │ │ ├── BatteryModification + │ │ │ └── ShuntCompensatorModification + │ │ ├── AbstractBranchModification + │ │ │ ├── LineModification + │ │ │ └── TwoWindingsTransformerModification + │ │ ├── SubstationModification + │ │ ├── VoltageLevelModification + │ │ ├── LccModification + │ │ └── VscModification + │ ├── EquipmentAttributeModification + │ ├── EquipmentDeletion + │ ├── OperatingStatusModification + │ └── VoltageLevelTopologyModification + ├── AbstractScaling + │ ├── GeneratorScaling + │ └── LoadScaling + └── (standalone) CompositeModification, ModificationReference, GroovyScript, + GenerationDispatch, ByFilterDeletion, VoltageInitModification, … +``` + +#### Shared contracts: `InjectionCreation` / `InjectionModification` + +The `InjectionCreation` and `InjectionModification` **interfaces** (in `modifications`) declare the common +injection field accessors (`equipmentId`, `voltageLevelId`, properties, connection info, …). They are +implemented by **two independent abstract bases**, which is the reason the contract is an interface rather +than a shared superclass: + +- `modifications.AbstractInjectionCreation` — the base for *top-level* injection modifications (above). +- `modifications.data.AbstractInjectionCreation` — a base for *injection data components* that are **not** + modifications themselves. `LccConverterStationCreation` and `VscConverterStationCreation` extend it; they + are sub-objects embedded inside `LccCreation` / `VscCreation` rather than standalone modifications, which + is why they live in `modifications.data` and only implement the interface instead of joining the + `AbstractModification` chain. + +`ReactiveLimitsHolderInfos` is another shared interface (currently in `dto`) implemented by the +reactive-limits-bearing creations (`GeneratorCreation`, `BatteryCreation`, `VscConverterStationCreation`). + +#### Description layer (`dto`) + +The DTO tree parallels the execution tree, rooted at the polymorphic `ModificationInfos`: + +``` +ModificationInfos +├── EquipmentModificationInfos +│ ├── EquipmentCreationInfos +│ │ ├── InjectionCreationInfos +│ │ │ ├── LoadCreationInfos +│ │ │ ├── GeneratorCreationInfos ........... implements ReactiveLimitsHolderInfos +│ │ │ ├── BatteryCreationInfos ............. implements ReactiveLimitsHolderInfos +│ │ │ ├── ShuntCompensatorCreationInfos +│ │ │ ├── StaticVarCompensatorCreationInfos +│ │ │ ├── LccConverterStationCreationInfos +│ │ │ └── ConverterStationCreationInfos .... implements ReactiveLimitsHolderInfos +│ │ ├── BranchCreationInfos +│ │ │ ├── LineCreationInfos +│ │ │ └── TwoWindingsTransformerCreationInfos +│ │ ├── SubstationCreationInfos +│ │ ├── VoltageLevelCreationInfos +│ │ └── LccCreationInfos +│ ├── BasicEquipmentModificationInfos +│ │ ├── InjectionModificationInfos +│ │ │ ├── LoadModificationInfos +│ │ │ ├── GeneratorModificationInfos +│ │ │ └── … (Battery, ShuntCompensator, ConverterStation, Lcc, …) +│ │ ├── BranchModificationInfos +│ │ │ ├── LineModificationInfos +│ │ │ └── TwoWindingsTransformerModificationInfos +│ │ └── SubstationModificationInfos +│ ├── EquipmentAttributeModificationInfos +│ ├── EquipmentDeletionInfos +│ └── OperatingStatusModificationInfos +├── ScalingInfos +│ ├── GeneratorScalingInfos +│ └── LoadScalingInfos +└── (direct) CompositeModificationInfos, ModificationReferenceInfos, GroovyScriptInfos, + TabularModificationInfos, ByFilterDeletionInfos, VoltageInitModificationInfos, … +``` + +Note the two trees are **not** linked by inheritance: a `LoadCreation` is *not* a subclass of +`LoadCreationInfos`. They are connected only through `LoadCreationInfos.toModification()`, which copies the +DTO's fields into a freshly built `LoadCreation`. + +### Dependency rules between packages + +The dependency direction is deliberate and one-way: + +``` + dto ───────────────► modifications ───► utils ───► (root contracts) + (description) (execution) +``` + +- **`dto` depends on `modifications`** — every `*Infos.toModification()` constructs a concrete modification. + This is expected and correct. +- **`modifications` must NOT depend on `ModificationInfos` subclasses.** The execution layer should never + reference a server-oriented DTO. Today, after redeclaring the business fields in the modifications, this + rule holds for the whole creation/modification family. +- The only `dto` types the `modifications` package is still allowed to reference are **plain data objects** + that happen to live in `dto` for now — see below. + +#### Shared data objects (the `dto` types modifications may still use) + +A handful of `dto` classes are *not* modifications: they are simple, reusable value/data objects that do +**not** extend `ModificationInfos`. The execution layer references them legitimately, for example: + +- `FreePropertyInfos`, `AttributeModification`, `ReactiveCapabilityCurvePointsInfos`, + `IdentifiableAttributes`, `ScalingVariationInfos`, `FilterInfos`, `OperationalLimitsGroupInfos`, … + +These currently sit in the `dto` package only for historical reasons. Conceptually they belong to the +execution model and are **intended to move into the `modifications` package** (the `modifications.data` +subpackage already hosts some of them, e.g. the injection creation/modification data holders and the LCC/VSC +converter-station data). Until that move is complete, treat any `dto` type that does **not** extend +`ModificationInfos` as part of the execution model, not as a DTO. + +The same applies to **value types nested inside an `*Infos` class**: a modification that imports an `*Infos` +purely to reach a nested enum or record is *not* depending on a `ModificationInfos` subclass — it is using a +plain data object that simply lives in the wrong place. For example `OperatingStatusModification` references +only `OperatingStatusModificationInfos.ActionType`, a plain enum. Such nested types should be promoted to +top-level data objects and moved alongside the execution layer (`modifications.data`). + +### Special cases: composite, tabular & reference modifications + +A few families break the "modifications never depend on `ModificationInfos`" rule by nature, and are +explicitly **excluded** from it: + +- **`CompositeModification`** aggregates an ordered list of child modifications. +- **Tabular modifications** (`modifications.tabular`) apply the same modification to many equipments in bulk. +- **`ModificationReference`** wraps a single other modification, holding it as a `ModificationInfos` and + delegating to its `toModification()` at apply time. + +All of these are *containers of modifications*, so they intrinsically manipulate the polymorphic +`ModificationInfos` type (and the tabular `*Infos`). They should be understood as a layer *above* the +ordinary modifications rather than peers of them, and they are not expected to satisfy the +"no `ModificationInfos` dependency" constraint that applies to every other modification. + +### Adding a new modification + +1. Create the executable `XxxModification` (or `XxxCreation`) in `modifications`, extending + `AbstractModification`. Declare its own business fields, implement `check(Network)` and + `apply(Network, ReportNode)`, expose a Lombok `@Builder`. +2. Create the `XxxInfos` DTO in `dto`, extending the appropriate `ModificationInfos` subtype, carrying the + Swagger annotations and any persistence concerns. +3. Implement `XxxInfos#toModification()` to build the modification from the DTO's fields. +4. Register the DTO in the `@JsonSubTypes` list of `ModificationInfos` and add its `@JsonTypeName` / + `@ModificationErrorTypeName` annotations. +5. Reuse the shared data objects (`FreePropertyInfos`, `AttributeModification`, …) for common fields; do not + let the modification reference any `ModificationInfos` subclass. + diff --git a/src/main/java/org/gridsuite/modification/dto/BalancesAdjustmentModificationInfos.java b/src/main/java/org/gridsuite/modification/dto/BalancesAdjustmentModificationInfos.java index 398a64fe..e8b35118 100644 --- a/src/main/java/org/gridsuite/modification/dto/BalancesAdjustmentModificationInfos.java +++ b/src/main/java/org/gridsuite/modification/dto/BalancesAdjustmentModificationInfos.java @@ -68,7 +68,17 @@ public class BalancesAdjustmentModificationInfos extends ModificationInfos { @Override public AbstractModification toModification() { - return new BalancesAdjustmentModification(this); + return BalancesAdjustmentModification.builder() + .areas(getAreas()) + .maxNumberIterations(getMaxNumberIterations()) + .thresholdNetPosition(getThresholdNetPosition()) + .countriesToBalance(getCountriesToBalance()) + .balanceType(getBalanceType()) + .withLoadFlow(isWithLoadFlow()) + .loadFlowParametersId(getLoadFlowParametersId()) + .withRatioTapChangers(isWithRatioTapChangers()) + .subtractLoadFlowBalancing(isSubtractLoadFlowBalancing()) + .build(); } @Override diff --git a/src/main/java/org/gridsuite/modification/dto/BatteryCreationInfos.java b/src/main/java/org/gridsuite/modification/dto/BatteryCreationInfos.java index 90251466..9d573710 100644 --- a/src/main/java/org/gridsuite/modification/dto/BatteryCreationInfos.java +++ b/src/main/java/org/gridsuite/modification/dto/BatteryCreationInfos.java @@ -72,7 +72,29 @@ public class BatteryCreationInfos extends InjectionCreationInfos implements Reac @Override public AbstractModification toModification() { - return new BatteryCreation(this); + return BatteryCreation.builder() + .equipmentId(getEquipmentId()) + .properties(getProperties()) + .equipmentName(getEquipmentName()) + .voltageLevelId(getVoltageLevelId()) + .busOrBusbarSectionId(getBusOrBusbarSectionId()) + .connectionName(getConnectionName()) + .connectionDirection(getConnectionDirection()) + .connectionPosition(getConnectionPosition()) + .terminalConnected(isTerminalConnected()) + .minP(getMinP()) + .maxP(getMaxP()) + .minQ(getMinQ()) + .maxQ(getMaxQ()) + .reactiveCapabilityCurvePoints(getReactiveCapabilityCurvePoints()) + .targetP(getTargetP()) + .targetQ(getTargetQ()) + .participate(getParticipate()) + .droop(getDroop()) + .directTransX(getDirectTransX()) + .stepUpTransformerX(getStepUpTransformerX()) + .reactiveCapabilityCurve(getReactiveCapabilityCurve()) + .build(); } @Override diff --git a/src/main/java/org/gridsuite/modification/dto/BatteryModificationInfos.java b/src/main/java/org/gridsuite/modification/dto/BatteryModificationInfos.java index a4189223..7eb1e323 100644 --- a/src/main/java/org/gridsuite/modification/dto/BatteryModificationInfos.java +++ b/src/main/java/org/gridsuite/modification/dto/BatteryModificationInfos.java @@ -68,7 +68,33 @@ public class BatteryModificationInfos extends InjectionModificationInfos { @Override public AbstractModification toModification() { - return new BatteryModification(this); + return BatteryModification.builder() + .equipmentId(getEquipmentId()) + .properties(getProperties()) + .equipmentName(getEquipmentName()) + .voltageLevelId(getVoltageLevelId()) + .busOrBusbarSectionId(getBusOrBusbarSectionId()) + .connectionName(getConnectionName()) + .connectionDirection(getConnectionDirection()) + .connectionPosition(getConnectionPosition()) + .terminalConnected(getTerminalConnected()) + .pMeasurementValue(getPMeasurementValue()) + .pMeasurementValidity(getPMeasurementValidity()) + .qMeasurementValue(getQMeasurementValue()) + .qMeasurementValidity(getQMeasurementValidity()) + .minP(getMinP()) + .maxP(getMaxP()) + .targetP(getTargetP()) + .targetQ(getTargetQ()) + .participate(getParticipate()) + .droop(getDroop()) + .directTransX(getDirectTransX()) + .stepUpTransformerX(getStepUpTransformerX()) + .minQ(getMinQ()) + .maxQ(getMaxQ()) + .reactiveCapabilityCurvePoints(getReactiveCapabilityCurvePoints()) + .reactiveCapabilityCurve(getReactiveCapabilityCurve()) + .build(); } @Override diff --git a/src/main/java/org/gridsuite/modification/dto/ByFilterDeletionInfos.java b/src/main/java/org/gridsuite/modification/dto/ByFilterDeletionInfos.java index 3ef524f7..fd935543 100644 --- a/src/main/java/org/gridsuite/modification/dto/ByFilterDeletionInfos.java +++ b/src/main/java/org/gridsuite/modification/dto/ByFilterDeletionInfos.java @@ -45,7 +45,10 @@ public class ByFilterDeletionInfos extends ModificationInfos { @Override public AbstractModification toModification() { - return new ByFilterDeletion(this); + return ByFilterDeletion.builder() + .equipmentType(getEquipmentType()) + .filters(getFilters()) + .build(); } @Override diff --git a/src/main/java/org/gridsuite/modification/dto/ByFormulaModificationInfos.java b/src/main/java/org/gridsuite/modification/dto/ByFormulaModificationInfos.java index 268008bd..62829518 100644 --- a/src/main/java/org/gridsuite/modification/dto/ByFormulaModificationInfos.java +++ b/src/main/java/org/gridsuite/modification/dto/ByFormulaModificationInfos.java @@ -45,7 +45,10 @@ public class ByFormulaModificationInfos extends ModificationInfos { @Override public ByFormulaModification toModification() { - return new ByFormulaModification(this); + return ByFormulaModification.builder() + .identifiableType(getIdentifiableType()) + .formulaInfosList(getFormulaInfosList()) + .build(); } @Override diff --git a/src/main/java/org/gridsuite/modification/dto/CreateCouplingDeviceInfos.java b/src/main/java/org/gridsuite/modification/dto/CreateCouplingDeviceInfos.java index 5a30e2b2..93f38d8b 100644 --- a/src/main/java/org/gridsuite/modification/dto/CreateCouplingDeviceInfos.java +++ b/src/main/java/org/gridsuite/modification/dto/CreateCouplingDeviceInfos.java @@ -42,7 +42,11 @@ public class CreateCouplingDeviceInfos extends ModificationInfos { @Override public AbstractModification toModification() { - return new CreateCouplingDevice(this); + return CreateCouplingDevice.builder() + .voltageLevelId(getVoltageLevelId()) + .busbarSectionId1(getCouplingDeviceInfos().getBusbarSectionId1()) + .busbarSectionId2(getCouplingDeviceInfos().getBusbarSectionId2()) + .build(); } @Override diff --git a/src/main/java/org/gridsuite/modification/dto/CreateVoltageLevelSectionInfos.java b/src/main/java/org/gridsuite/modification/dto/CreateVoltageLevelSectionInfos.java index 4d7779b3..41cd84a8 100644 --- a/src/main/java/org/gridsuite/modification/dto/CreateVoltageLevelSectionInfos.java +++ b/src/main/java/org/gridsuite/modification/dto/CreateVoltageLevelSectionInfos.java @@ -59,7 +59,16 @@ public class CreateVoltageLevelSectionInfos extends ModificationInfos { @Override public AbstractModification toModification() { - return new CreateVoltageLevelSection(this); + return CreateVoltageLevelSection.builder() + .voltageLevelId(getVoltageLevelId()) + .busbarIndex(getBusbarIndex()) + .afterBusbarSectionId(isAfterBusbarSectionId()) + .leftSwitchKind(getLeftSwitchKind()) + .rightSwitchKind(getRightSwitchKind()) + .allBusbars(isAllBusbars()) + .busbarSectionId(getBusbarSectionId()) + .switchOpen(isSwitchOpen()) + .build(); } @Override diff --git a/src/main/java/org/gridsuite/modification/dto/CreateVoltageLevelTopologyInfos.java b/src/main/java/org/gridsuite/modification/dto/CreateVoltageLevelTopologyInfos.java index fd65446d..ebf6b952 100644 --- a/src/main/java/org/gridsuite/modification/dto/CreateVoltageLevelTopologyInfos.java +++ b/src/main/java/org/gridsuite/modification/dto/CreateVoltageLevelTopologyInfos.java @@ -59,6 +59,10 @@ public Map getMapMessageValues() { @Override public AbstractModification toModification() { - return new CreateVoltageLevelTopology(this); + return CreateVoltageLevelTopology.builder() + .voltageLevelId(getVoltageLevelId()) + .switchKinds(getSwitchKinds()) + .sectionCount(getSectionCount()) + .build(); } } diff --git a/src/main/java/org/gridsuite/modification/dto/DeleteAttachingLineInfos.java b/src/main/java/org/gridsuite/modification/dto/DeleteAttachingLineInfos.java index f797cdbc..5af58c9e 100644 --- a/src/main/java/org/gridsuite/modification/dto/DeleteAttachingLineInfos.java +++ b/src/main/java/org/gridsuite/modification/dto/DeleteAttachingLineInfos.java @@ -53,7 +53,13 @@ public class DeleteAttachingLineInfos extends ModificationInfos { @Override public AbstractModification toModification() { - return new DeleteAttachingLine(this); + return DeleteAttachingLine.builder() + .lineToAttachTo1Id(getLineToAttachTo1Id()) + .lineToAttachTo2Id(getLineToAttachTo2Id()) + .attachedLineId(getAttachedLineId()) + .replacingLine1Id(getReplacingLine1Id()) + .replacingLine1Name(getReplacingLine1Name()) + .build(); } @Override diff --git a/src/main/java/org/gridsuite/modification/dto/DeleteVoltageLevelOnLineInfos.java b/src/main/java/org/gridsuite/modification/dto/DeleteVoltageLevelOnLineInfos.java index 19ae5413..7830738f 100644 --- a/src/main/java/org/gridsuite/modification/dto/DeleteVoltageLevelOnLineInfos.java +++ b/src/main/java/org/gridsuite/modification/dto/DeleteVoltageLevelOnLineInfos.java @@ -46,7 +46,12 @@ public class DeleteVoltageLevelOnLineInfos extends ModificationInfos { @Override public AbstractModification toModification() { - return new DeleteVoltageLevelOnLine(this); + return DeleteVoltageLevelOnLine.builder() + .lineToAttachTo1Id(getLineToAttachTo1Id()) + .lineToAttachTo2Id(getLineToAttachTo2Id()) + .replacingLine1Id(getReplacingLine1Id()) + .replacingLine1Name(getReplacingLine1Name()) + .build(); } @Override diff --git a/src/main/java/org/gridsuite/modification/dto/EquipmentAttributeModificationInfos.java b/src/main/java/org/gridsuite/modification/dto/EquipmentAttributeModificationInfos.java index 3695ff63..c5a93dae 100644 --- a/src/main/java/org/gridsuite/modification/dto/EquipmentAttributeModificationInfos.java +++ b/src/main/java/org/gridsuite/modification/dto/EquipmentAttributeModificationInfos.java @@ -49,7 +49,13 @@ public class EquipmentAttributeModificationInfos extends EquipmentModificationIn @Override public AbstractModification toModification() { - return new EquipmentAttributeModification(this); + return EquipmentAttributeModification.builder() + .equipmentId(getEquipmentId()) + .properties(getProperties()) + .equipmentAttributeName(getEquipmentAttributeName()) + .equipmentAttributeValue(getEquipmentAttributeValue()) + .equipmentType(getEquipmentType()) + .build(); } @Override diff --git a/src/main/java/org/gridsuite/modification/dto/EquipmentDeletionInfos.java b/src/main/java/org/gridsuite/modification/dto/EquipmentDeletionInfos.java index 7c7e8957..6fe76977 100644 --- a/src/main/java/org/gridsuite/modification/dto/EquipmentDeletionInfos.java +++ b/src/main/java/org/gridsuite/modification/dto/EquipmentDeletionInfos.java @@ -41,7 +41,12 @@ public class EquipmentDeletionInfos extends EquipmentModificationInfos { @Override public AbstractModification toModification() { - return new EquipmentDeletion(this); + return EquipmentDeletion.builder() + .equipmentId(getEquipmentId()) + .properties(getProperties()) + .equipmentType(getEquipmentType()) + .equipmentInfos(getEquipmentInfos()) + .build(); } @Override diff --git a/src/main/java/org/gridsuite/modification/dto/GenerationDispatchInfos.java b/src/main/java/org/gridsuite/modification/dto/GenerationDispatchInfos.java index 36e1f3c4..81168eee 100644 --- a/src/main/java/org/gridsuite/modification/dto/GenerationDispatchInfos.java +++ b/src/main/java/org/gridsuite/modification/dto/GenerationDispatchInfos.java @@ -51,7 +51,14 @@ public class GenerationDispatchInfos extends ModificationInfos { @Override public AbstractModification toModification() { - return new GenerationDispatch(this); + return GenerationDispatch.builder() + .lossCoefficient(getLossCoefficient()) + .defaultOutageRate(getDefaultOutageRate()) + .generatorsWithoutOutage(getGeneratorsWithoutOutage()) + .generatorsWithFixedSupply(getGeneratorsWithFixedSupply()) + .generatorsFrequencyReserve(getGeneratorsFrequencyReserve()) + .substationsGeneratorsOrdering(getSubstationsGeneratorsOrdering()) + .build(); } @Override diff --git a/src/main/java/org/gridsuite/modification/dto/GeneratorCreationInfos.java b/src/main/java/org/gridsuite/modification/dto/GeneratorCreationInfos.java index 252efac6..feb39add 100644 --- a/src/main/java/org/gridsuite/modification/dto/GeneratorCreationInfos.java +++ b/src/main/java/org/gridsuite/modification/dto/GeneratorCreationInfos.java @@ -111,7 +111,41 @@ public class GeneratorCreationInfos extends InjectionCreationInfos implements Re @Override public AbstractModification toModification() { - return new GeneratorCreation(this); + return GeneratorCreation.builder() + .equipmentId(getEquipmentId()) + .properties(getProperties()) + .equipmentName(getEquipmentName()) + .voltageLevelId(getVoltageLevelId()) + .busOrBusbarSectionId(getBusOrBusbarSectionId()) + .connectionName(getConnectionName()) + .connectionDirection(getConnectionDirection()) + .connectionPosition(getConnectionPosition()) + .terminalConnected(isTerminalConnected()) + .energySource(getEnergySource()) + .minP(getMinP()) + .maxP(getMaxP()) + .ratedS(getRatedS()) + .targetP(getTargetP()) + .targetQ(getTargetQ()) + .voltageRegulationOn(isVoltageRegulationOn()) + .targetV(getTargetV()) + .plannedActivePowerSetPoint(getPlannedActivePowerSetPoint()) + .marginalCost(getMarginalCost()) + .plannedOutageRate(getPlannedOutageRate()) + .forcedOutageRate(getForcedOutageRate()) + .minQ(getMinQ()) + .maxQ(getMaxQ()) + .reactiveCapabilityCurvePoints(getReactiveCapabilityCurvePoints()) + .participate(getParticipate()) + .droop(getDroop()) + .directTransX(getDirectTransX()) + .stepUpTransformerX(getStepUpTransformerX()) + .regulatingTerminalId(getRegulatingTerminalId()) + .regulatingTerminalType(getRegulatingTerminalType()) + .regulatingTerminalVlId(getRegulatingTerminalVlId()) + .qPercent(getQPercent()) + .reactiveCapabilityCurve(getReactiveCapabilityCurve()) + .build(); } @Override diff --git a/src/main/java/org/gridsuite/modification/dto/GeneratorModificationInfos.java b/src/main/java/org/gridsuite/modification/dto/GeneratorModificationInfos.java index a75809b6..fca1b0e7 100644 --- a/src/main/java/org/gridsuite/modification/dto/GeneratorModificationInfos.java +++ b/src/main/java/org/gridsuite/modification/dto/GeneratorModificationInfos.java @@ -112,7 +112,46 @@ public class GeneratorModificationInfos extends InjectionModificationInfos { @Override public AbstractModification toModification() { - return new GeneratorModification(this); + return GeneratorModification.builder() + .equipmentId(getEquipmentId()) + .properties(getProperties()) + .equipmentName(getEquipmentName()) + .voltageLevelId(getVoltageLevelId()) + .busOrBusbarSectionId(getBusOrBusbarSectionId()) + .connectionName(getConnectionName()) + .connectionDirection(getConnectionDirection()) + .connectionPosition(getConnectionPosition()) + .terminalConnected(getTerminalConnected()) + .pMeasurementValue(getPMeasurementValue()) + .pMeasurementValidity(getPMeasurementValidity()) + .qMeasurementValue(getQMeasurementValue()) + .qMeasurementValidity(getQMeasurementValidity()) + .energySource(getEnergySource()) + .minP(getMinP()) + .maxP(getMaxP()) + .ratedS(getRatedS()) + .targetP(getTargetP()) + .targetQ(getTargetQ()) + .voltageRegulationOn(getVoltageRegulationOn()) + .targetV(getTargetV()) + .plannedActivePowerSetPoint(getPlannedActivePowerSetPoint()) + .marginalCost(getMarginalCost()) + .plannedOutageRate(getPlannedOutageRate()) + .forcedOutageRate(getForcedOutageRate()) + .minQ(getMinQ()) + .maxQ(getMaxQ()) + .reactiveCapabilityCurvePoints(getReactiveCapabilityCurvePoints()) + .participate(getParticipate()) + .droop(getDroop()) + .directTransX(getDirectTransX()) + .stepUpTransformerX(getStepUpTransformerX()) + .voltageRegulationType(getVoltageRegulationType()) + .regulatingTerminalId(getRegulatingTerminalId()) + .regulatingTerminalType(getRegulatingTerminalType()) + .regulatingTerminalVlId(getRegulatingTerminalVlId()) + .qPercent(getQPercent()) + .reactiveCapabilityCurve(getReactiveCapabilityCurve()) + .build(); } @Override diff --git a/src/main/java/org/gridsuite/modification/dto/GeneratorScalingInfos.java b/src/main/java/org/gridsuite/modification/dto/GeneratorScalingInfos.java index f37e6acd..12c87ac6 100644 --- a/src/main/java/org/gridsuite/modification/dto/GeneratorScalingInfos.java +++ b/src/main/java/org/gridsuite/modification/dto/GeneratorScalingInfos.java @@ -33,7 +33,11 @@ public class GeneratorScalingInfos extends ScalingInfos { @Override public AbstractModification toModification() { - return new GeneratorScaling(this); + return GeneratorScaling.builder() + .variations(getVariations()) + .variationType(getVariationType()) + .errorType(getErrorType()) + .build(); } @Override diff --git a/src/main/java/org/gridsuite/modification/dto/GroovyScriptInfos.java b/src/main/java/org/gridsuite/modification/dto/GroovyScriptInfos.java index 2f97e2a0..a1bb054a 100644 --- a/src/main/java/org/gridsuite/modification/dto/GroovyScriptInfos.java +++ b/src/main/java/org/gridsuite/modification/dto/GroovyScriptInfos.java @@ -35,7 +35,9 @@ public class GroovyScriptInfos extends ModificationInfos { @Override public AbstractModification toModification() { - return new GroovyScript(this); + return GroovyScript.builder() + .script(getScript()) + .build(); } @Override diff --git a/src/main/java/org/gridsuite/modification/dto/LccCreationInfos.java b/src/main/java/org/gridsuite/modification/dto/LccCreationInfos.java index 8c841084..1f5abd49 100644 --- a/src/main/java/org/gridsuite/modification/dto/LccCreationInfos.java +++ b/src/main/java/org/gridsuite/modification/dto/LccCreationInfos.java @@ -19,6 +19,7 @@ import org.gridsuite.modification.dto.annotation.ModificationErrorTypeName; import org.gridsuite.modification.modifications.AbstractModification; import org.gridsuite.modification.modifications.LccCreation; +import org.gridsuite.modification.modifications.data.LccConverterStationCreation; /** * @author Ghazwa Rehili @@ -56,7 +57,34 @@ public class LccCreationInfos extends EquipmentCreationInfos { @Override public AbstractModification toModification() { - return new LccCreation(this); + return LccCreation.builder() + .equipmentId(getEquipmentId()) + .properties(getProperties()) + .equipmentName(getEquipmentName()) + .nominalV(getNominalV()) + .r(getR()) + .maxP(getMaxP()) + .convertersMode(getConvertersMode()) + .activePowerSetpoint(getActivePowerSetpoint()) + .converterStation1(converterStationCreation(getConverterStation1())) + .converterStation2(converterStationCreation(getConverterStation2())) + .build(); + } + + private LccConverterStationCreation converterStationCreation(LccConverterStationCreationInfos converterStationCreationInfos) { + return LccConverterStationCreation.builder() + .lossFactor(converterStationCreationInfos.getLossFactor()) + .powerFactor(converterStationCreationInfos.getPowerFactor()) + .shuntCompensatorsOnSide(converterStationCreationInfos.getShuntCompensatorsOnSide()) + .equipmentId(converterStationCreationInfos.getEquipmentId()) + .properties(converterStationCreationInfos.getProperties()) + .equipmentName(converterStationCreationInfos.getEquipmentName()) + .voltageLevelId(converterStationCreationInfos.getVoltageLevelId()) + .busOrBusbarSectionId(converterStationCreationInfos.getBusOrBusbarSectionId()) + .connectionName(converterStationCreationInfos.getConnectionName()) + .connectionDirection(converterStationCreationInfos.getConnectionDirection()) + .connectionPosition(converterStationCreationInfos.getConnectionPosition()) + .terminalConnected(converterStationCreationInfos.isTerminalConnected()).build(); } @Override diff --git a/src/main/java/org/gridsuite/modification/dto/LccModificationInfos.java b/src/main/java/org/gridsuite/modification/dto/LccModificationInfos.java index 721ca72e..387d96ff 100644 --- a/src/main/java/org/gridsuite/modification/dto/LccModificationInfos.java +++ b/src/main/java/org/gridsuite/modification/dto/LccModificationInfos.java @@ -19,6 +19,7 @@ import org.gridsuite.modification.dto.annotation.ModificationErrorTypeName; import org.gridsuite.modification.modifications.AbstractModification; import org.gridsuite.modification.modifications.LccModification; +import org.gridsuite.modification.modifications.data.LccConverterStationModification; @SuperBuilder @NoArgsConstructor @@ -52,7 +53,40 @@ public class LccModificationInfos extends BasicEquipmentModificationInfos { @Override public AbstractModification toModification() { - return new LccModification(this); + return LccModification.builder() + .equipmentId(getEquipmentId()) + .properties(getProperties()) + .equipmentName(getEquipmentName()) + .nominalV(getNominalV()) + .r(getR()) + .maxP(getMaxP()) + .convertersMode(getConvertersMode()) + .activePowerSetpoint(getActivePowerSetpoint()) + .converterStation1(converterStationModification(getConverterStation1())) + .converterStation2(converterStationModification(getConverterStation2())) + .build(); + } + + private LccConverterStationModification converterStationModification(LccConverterStationModificationInfos converterStationModificationInfos) { + if (converterStationModificationInfos == null) { + return null; + } + return LccConverterStationModification.builder().lossFactor(converterStationModificationInfos.getLossFactor()) + .powerFactor(converterStationModificationInfos.getPowerFactor()) + .shuntCompensatorsOnSide(converterStationModificationInfos.getShuntCompensatorsOnSide()) + .equipmentId(converterStationModificationInfos.getEquipmentId()) + .properties(converterStationModificationInfos.getProperties()) + .equipmentName(converterStationModificationInfos.getEquipmentName()) + .voltageLevelId(converterStationModificationInfos.getVoltageLevelId()) + .busOrBusbarSectionId(converterStationModificationInfos.getBusOrBusbarSectionId()) + .connectionName(converterStationModificationInfos.getConnectionName()) + .connectionDirection(converterStationModificationInfos.getConnectionDirection()) + .connectionPosition(converterStationModificationInfos.getConnectionPosition()) + .terminalConnected(converterStationModificationInfos.getTerminalConnected()) + .pMeasurementValue(converterStationModificationInfos.getPMeasurementValue()) + .pMeasurementValidity(converterStationModificationInfos.getPMeasurementValidity()) + .qMeasurementValue(converterStationModificationInfos.getQMeasurementValue()) + .qMeasurementValidity(converterStationModificationInfos.getQMeasurementValidity()).build(); } @Override diff --git a/src/main/java/org/gridsuite/modification/dto/LineAttachToVoltageLevelInfos.java b/src/main/java/org/gridsuite/modification/dto/LineAttachToVoltageLevelInfos.java index 99b03ff2..54733f4f 100644 --- a/src/main/java/org/gridsuite/modification/dto/LineAttachToVoltageLevelInfos.java +++ b/src/main/java/org/gridsuite/modification/dto/LineAttachToVoltageLevelInfos.java @@ -14,7 +14,11 @@ import org.gridsuite.modification.dto.annotation.ModificationErrorTypeName; import org.gridsuite.modification.modifications.AbstractModification; import org.gridsuite.modification.modifications.LineAttachToVoltageLevel; +import org.gridsuite.modification.modifications.LineCreation; +import org.gridsuite.modification.modifications.VoltageLevelCreation; + import java.util.Map; +import java.util.Optional; /** * @author Nicolas NOIR @@ -71,7 +75,21 @@ public class LineAttachToVoltageLevelInfos extends ModificationInfos { @Override public AbstractModification toModification() { - return new LineAttachToVoltageLevel(this); + return LineAttachToVoltageLevel.builder() + .lineToAttachToId(getLineToAttachToId()) + .percent(getPercent()) + .attachmentPointId(getAttachmentPointId()) + .attachmentPointName(getAttachmentPointName()) + .attachmentPointDetailInformation((VoltageLevelCreation) Optional.ofNullable(getAttachmentPointDetailInformation()).map(VoltageLevelCreationInfos::toModification).orElse(null)) + .mayNewVoltageLevel((VoltageLevelCreation) Optional.ofNullable(getMayNewVoltageLevelInfos()).map(VoltageLevelCreationInfos::toModification).orElse(null)) + .existingVoltageLevelId(getExistingVoltageLevelId()) + .bbsOrBusId(getBbsOrBusId()) + .attachmentLine((LineCreation) Optional.ofNullable(getAttachmentLine()).map(LineCreationInfos::toModification).orElse(null)) + .newLine1Id(getNewLine1Id()) + .newLine1Name(getNewLine1Name()) + .newLine2Id(getNewLine2Id()) + .newLine2Name(getNewLine2Name()) + .build(); } @Override diff --git a/src/main/java/org/gridsuite/modification/dto/LineCreationInfos.java b/src/main/java/org/gridsuite/modification/dto/LineCreationInfos.java index 415f39b8..55416e21 100644 --- a/src/main/java/org/gridsuite/modification/dto/LineCreationInfos.java +++ b/src/main/java/org/gridsuite/modification/dto/LineCreationInfos.java @@ -50,7 +50,32 @@ public class LineCreationInfos extends BranchCreationInfos { @Override public AbstractModification toModification() { - return new LineCreation(this); + return LineCreation.builder() + .equipmentId(getEquipmentId()) + .properties(getProperties()) + .equipmentName(getEquipmentName()) + .r(getR()) + .x(getX()) + .voltageLevelId1(getVoltageLevelId1()) + .voltageLevelId2(getVoltageLevelId2()) + .busOrBusbarSectionId1(getBusOrBusbarSectionId1()) + .busOrBusbarSectionId2(getBusOrBusbarSectionId2()) + .operationalLimitsGroups(getOperationalLimitsGroups()) + .selectedOperationalLimitsGroupId1(getSelectedOperationalLimitsGroupId1()) + .selectedOperationalLimitsGroupId2(getSelectedOperationalLimitsGroupId2()) + .connectionName1(getConnectionName1()) + .connectionDirection1(getConnectionDirection1()) + .connectionName2(getConnectionName2()) + .connectionDirection2(getConnectionDirection2()) + .connectionPosition1(getConnectionPosition1()) + .connectionPosition2(getConnectionPosition2()) + .connected1(isConnected1()) + .connected2(isConnected2()) + .g1(getG1()) + .b1(getB1()) + .g2(getG2()) + .b2(getB2()) + .build(); } @Override diff --git a/src/main/java/org/gridsuite/modification/dto/LineModificationInfos.java b/src/main/java/org/gridsuite/modification/dto/LineModificationInfos.java index 2346ce53..7a07b3db 100644 --- a/src/main/java/org/gridsuite/modification/dto/LineModificationInfos.java +++ b/src/main/java/org/gridsuite/modification/dto/LineModificationInfos.java @@ -53,7 +53,42 @@ public class LineModificationInfos extends BranchModificationInfos { @Override public AbstractModification toModification() { - return new LineModification(this); + return LineModification.builder() + .equipmentId(getEquipmentId()) + .properties(getProperties()) + .equipmentName(getEquipmentName()) + .r(getR()) + .x(getX()) + .operationalLimitsGroupsModificationType(getOperationalLimitsGroupsModificationType()) + .enableOLGModification(getEnableOLGModification()) + .operationalLimitsGroups(getOperationalLimitsGroups()) + .selectedOperationalLimitsGroupId1(getSelectedOperationalLimitsGroupId1()) + .selectedOperationalLimitsGroupId2(getSelectedOperationalLimitsGroupId2()) + .voltageLevelId1(getVoltageLevelId1()) + .voltageLevelId2(getVoltageLevelId2()) + .busOrBusbarSectionId1(getBusOrBusbarSectionId1()) + .busOrBusbarSectionId2(getBusOrBusbarSectionId2()) + .connectionName1(getConnectionName1()) + .connectionName2(getConnectionName2()) + .connectionDirection1(getConnectionDirection1()) + .connectionDirection2(getConnectionDirection2()) + .connectionPosition1(getConnectionPosition1()) + .connectionPosition2(getConnectionPosition2()) + .terminal1Connected(getTerminal1Connected()) + .terminal2Connected(getTerminal2Connected()) + .p1MeasurementValue(getP1MeasurementValue()) + .p1MeasurementValidity(getP1MeasurementValidity()) + .p2MeasurementValue(getP2MeasurementValue()) + .p2MeasurementValidity(getP2MeasurementValidity()) + .q1MeasurementValue(getQ1MeasurementValue()) + .q1MeasurementValidity(getQ1MeasurementValidity()) + .q2MeasurementValue(getQ2MeasurementValue()) + .q2MeasurementValidity(getQ2MeasurementValidity()) + .g1(getG1()) + .b1(getB1()) + .g2(getG2()) + .b2(getB2()) + .build(); } @Override diff --git a/src/main/java/org/gridsuite/modification/dto/LineSplitWithVoltageLevelInfos.java b/src/main/java/org/gridsuite/modification/dto/LineSplitWithVoltageLevelInfos.java index 253fee6d..65a4fe64 100644 --- a/src/main/java/org/gridsuite/modification/dto/LineSplitWithVoltageLevelInfos.java +++ b/src/main/java/org/gridsuite/modification/dto/LineSplitWithVoltageLevelInfos.java @@ -14,7 +14,10 @@ import org.gridsuite.modification.dto.annotation.ModificationErrorTypeName; import org.gridsuite.modification.modifications.AbstractModification; import org.gridsuite.modification.modifications.LineSplitWithVoltageLevel; +import org.gridsuite.modification.modifications.VoltageLevelCreation; + import java.util.Map; +import java.util.Optional; /** * @author Laurent GARNIER @@ -59,7 +62,17 @@ public class LineSplitWithVoltageLevelInfos extends ModificationInfos { @Override public AbstractModification toModification() { - return new LineSplitWithVoltageLevel(this); + return LineSplitWithVoltageLevel.builder() + .lineToSplitId(getLineToSplitId()) + .percent(getPercent()) + .mayNewVoltageLevel((VoltageLevelCreation) Optional.ofNullable(getMayNewVoltageLevelInfos()).map(VoltageLevelCreationInfos::toModification).orElse(null)) + .existingVoltageLevelId(getExistingVoltageLevelId()) + .bbsOrBusId(getBbsOrBusId()) + .newLine1Id(getNewLine1Id()) + .newLine1Name(getNewLine1Name()) + .newLine2Id(getNewLine2Id()) + .newLine2Name(getNewLine2Name()) + .build(); } @Override diff --git a/src/main/java/org/gridsuite/modification/dto/LinesAttachToSplitLinesInfos.java b/src/main/java/org/gridsuite/modification/dto/LinesAttachToSplitLinesInfos.java index 9ac1da71..f444433a 100644 --- a/src/main/java/org/gridsuite/modification/dto/LinesAttachToSplitLinesInfos.java +++ b/src/main/java/org/gridsuite/modification/dto/LinesAttachToSplitLinesInfos.java @@ -59,7 +59,17 @@ public class LinesAttachToSplitLinesInfos extends ModificationInfos { @Override public AbstractModification toModification() { - return new LinesAttachToSplitLines(this); + return LinesAttachToSplitLines.builder() + .lineToAttachTo1Id(getLineToAttachTo1Id()) + .lineToAttachTo2Id(getLineToAttachTo2Id()) + .attachedLineId(getAttachedLineId()) + .voltageLevelId(getVoltageLevelId()) + .bbsBusId(getBbsBusId()) + .replacingLine1Id(getReplacingLine1Id()) + .replacingLine1Name(getReplacingLine1Name()) + .replacingLine2Id(getReplacingLine2Id()) + .replacingLine2Name(getReplacingLine2Name()) + .build(); } @Override diff --git a/src/main/java/org/gridsuite/modification/dto/LoadCreationInfos.java b/src/main/java/org/gridsuite/modification/dto/LoadCreationInfos.java index 87bc1d63..26b11cc5 100644 --- a/src/main/java/org/gridsuite/modification/dto/LoadCreationInfos.java +++ b/src/main/java/org/gridsuite/modification/dto/LoadCreationInfos.java @@ -43,7 +43,20 @@ public class LoadCreationInfos extends InjectionCreationInfos { @Override public AbstractModification toModification() { - return new LoadCreation(this); + return LoadCreation.builder() + .equipmentId(getEquipmentId()) + .properties(getProperties()) + .equipmentName(getEquipmentName()) + .voltageLevelId(getVoltageLevelId()) + .busOrBusbarSectionId(getBusOrBusbarSectionId()) + .connectionName(getConnectionName()) + .connectionDirection(getConnectionDirection()) + .connectionPosition(getConnectionPosition()) + .terminalConnected(isTerminalConnected()) + .loadType(getLoadType()) + .p0(getP0()) + .q0(getQ0()) + .build(); } @Override diff --git a/src/main/java/org/gridsuite/modification/dto/LoadModificationInfos.java b/src/main/java/org/gridsuite/modification/dto/LoadModificationInfos.java index e011c36c..9b98bff1 100644 --- a/src/main/java/org/gridsuite/modification/dto/LoadModificationInfos.java +++ b/src/main/java/org/gridsuite/modification/dto/LoadModificationInfos.java @@ -41,7 +41,24 @@ public class LoadModificationInfos extends InjectionModificationInfos { @Override public AbstractModification toModification() { - return new LoadModification(this); + return LoadModification.builder() + .equipmentId(getEquipmentId()) + .properties(getProperties()) + .equipmentName(getEquipmentName()) + .voltageLevelId(getVoltageLevelId()) + .busOrBusbarSectionId(getBusOrBusbarSectionId()) + .connectionName(getConnectionName()) + .connectionDirection(getConnectionDirection()) + .connectionPosition(getConnectionPosition()) + .terminalConnected(getTerminalConnected()) + .pMeasurementValue(getPMeasurementValue()) + .pMeasurementValidity(getPMeasurementValidity()) + .qMeasurementValue(getQMeasurementValue()) + .qMeasurementValidity(getQMeasurementValidity()) + .loadType(getLoadType()) + .p0(getP0()) + .q0(getQ0()) + .build(); } @Override diff --git a/src/main/java/org/gridsuite/modification/dto/LoadScalingInfos.java b/src/main/java/org/gridsuite/modification/dto/LoadScalingInfos.java index 3b178bee..2989e445 100644 --- a/src/main/java/org/gridsuite/modification/dto/LoadScalingInfos.java +++ b/src/main/java/org/gridsuite/modification/dto/LoadScalingInfos.java @@ -33,7 +33,11 @@ public class LoadScalingInfos extends ScalingInfos { @Override public AbstractModification toModification() { - return new LoadScaling(this); + return LoadScaling.builder() + .variations(getVariations()) + .variationType(getVariationType()) + .errorType(getErrorType()) + .build(); } @Override diff --git a/src/main/java/org/gridsuite/modification/dto/ModificationByAssignmentInfos.java b/src/main/java/org/gridsuite/modification/dto/ModificationByAssignmentInfos.java index a77d74e8..57f19cf7 100644 --- a/src/main/java/org/gridsuite/modification/dto/ModificationByAssignmentInfos.java +++ b/src/main/java/org/gridsuite/modification/dto/ModificationByAssignmentInfos.java @@ -42,7 +42,10 @@ public class ModificationByAssignmentInfos extends ModificationInfos { @Override public ModificationByAssignment toModification() { - return new ModificationByAssignment(this); + return ModificationByAssignment.builder() + .equipmentType(getEquipmentType()) + .assignmentInfosList(getAssignmentInfosList()) + .build(); } @Override diff --git a/src/main/java/org/gridsuite/modification/dto/ModificationReferenceInfos.java b/src/main/java/org/gridsuite/modification/dto/ModificationReferenceInfos.java index 5a67bf44..c6dceb51 100644 --- a/src/main/java/org/gridsuite/modification/dto/ModificationReferenceInfos.java +++ b/src/main/java/org/gridsuite/modification/dto/ModificationReferenceInfos.java @@ -55,7 +55,11 @@ public enum Type { @Override public AbstractModification toModification() { - return new ModificationReference(this); + return ModificationReference.builder() + .referenceId(getReferenceId()) + .referenceType(getReferenceType()) + .referenceInfos(getReferenceInfos()) + .build(); } @Override diff --git a/src/main/java/org/gridsuite/modification/dto/MoveVoltageLevelFeederBaysInfos.java b/src/main/java/org/gridsuite/modification/dto/MoveVoltageLevelFeederBaysInfos.java index 21f48dc1..e7054907 100644 --- a/src/main/java/org/gridsuite/modification/dto/MoveVoltageLevelFeederBaysInfos.java +++ b/src/main/java/org/gridsuite/modification/dto/MoveVoltageLevelFeederBaysInfos.java @@ -40,7 +40,10 @@ public class MoveVoltageLevelFeederBaysInfos extends ModificationInfos { @Override public AbstractModification toModification() { - return new MoveVoltageLevelFeederBays(this); + return MoveVoltageLevelFeederBays.builder() + .voltageLevelId(getVoltageLevelId()) + .feederBays(getFeederBays()) + .build(); } @Override diff --git a/src/main/java/org/gridsuite/modification/dto/OperatingStatusModificationInfos.java b/src/main/java/org/gridsuite/modification/dto/OperatingStatusModificationInfos.java index b09f33d3..e6d11d6a 100644 --- a/src/main/java/org/gridsuite/modification/dto/OperatingStatusModificationInfos.java +++ b/src/main/java/org/gridsuite/modification/dto/OperatingStatusModificationInfos.java @@ -51,7 +51,12 @@ public enum ActionType { @Override public AbstractModification toModification() { - return new OperatingStatusModification(this); + return OperatingStatusModification.builder() + .equipmentId(getEquipmentId()) + .properties(getProperties()) + .action(getAction()) + .energizedVoltageLevelId(getEnergizedVoltageLevelId()) + .build(); } @Override diff --git a/src/main/java/org/gridsuite/modification/dto/ShuntCompensatorCreationInfos.java b/src/main/java/org/gridsuite/modification/dto/ShuntCompensatorCreationInfos.java index 402b808a..f8c24d72 100644 --- a/src/main/java/org/gridsuite/modification/dto/ShuntCompensatorCreationInfos.java +++ b/src/main/java/org/gridsuite/modification/dto/ShuntCompensatorCreationInfos.java @@ -48,7 +48,22 @@ public class ShuntCompensatorCreationInfos extends InjectionCreationInfos { @Override public AbstractModification toModification() { - return new ShuntCompensatorCreation(this); + return ShuntCompensatorCreation.builder() + .equipmentId(getEquipmentId()) + .properties(getProperties()) + .equipmentName(getEquipmentName()) + .voltageLevelId(getVoltageLevelId()) + .busOrBusbarSectionId(getBusOrBusbarSectionId()) + .connectionName(getConnectionName()) + .connectionDirection(getConnectionDirection()) + .connectionPosition(getConnectionPosition()) + .terminalConnected(isTerminalConnected()) + .maximumSectionCount(getMaximumSectionCount()) + .sectionCount(getSectionCount()) + .maxSusceptance(getMaxSusceptance()) + .maxQAtNominalV(getMaxQAtNominalV()) + .shuntCompensatorType(getShuntCompensatorType()) + .build(); } @Override diff --git a/src/main/java/org/gridsuite/modification/dto/ShuntCompensatorModificationInfos.java b/src/main/java/org/gridsuite/modification/dto/ShuntCompensatorModificationInfos.java index 789f6592..f8c39b77 100644 --- a/src/main/java/org/gridsuite/modification/dto/ShuntCompensatorModificationInfos.java +++ b/src/main/java/org/gridsuite/modification/dto/ShuntCompensatorModificationInfos.java @@ -50,7 +50,26 @@ public class ShuntCompensatorModificationInfos extends InjectionModificationInfo @Override public AbstractModification toModification() { - return new ShuntCompensatorModification(this); + return ShuntCompensatorModification.builder() + .equipmentId(getEquipmentId()) + .properties(getProperties()) + .equipmentName(getEquipmentName()) + .voltageLevelId(getVoltageLevelId()) + .busOrBusbarSectionId(getBusOrBusbarSectionId()) + .connectionName(getConnectionName()) + .connectionDirection(getConnectionDirection()) + .connectionPosition(getConnectionPosition()) + .terminalConnected(getTerminalConnected()) + .pMeasurementValue(getPMeasurementValue()) + .pMeasurementValidity(getPMeasurementValidity()) + .qMeasurementValue(getQMeasurementValue()) + .qMeasurementValidity(getQMeasurementValidity()) + .maximumSectionCount(getMaximumSectionCount()) + .sectionCount(getSectionCount()) + .maxSusceptance(getMaxSusceptance()) + .maxQAtNominalV(getMaxQAtNominalV()) + .shuntCompensatorType(getShuntCompensatorType()) + .build(); } @Override diff --git a/src/main/java/org/gridsuite/modification/dto/StaticVarCompensatorCreationInfos.java b/src/main/java/org/gridsuite/modification/dto/StaticVarCompensatorCreationInfos.java index 2e4cbf12..4083617c 100644 --- a/src/main/java/org/gridsuite/modification/dto/StaticVarCompensatorCreationInfos.java +++ b/src/main/java/org/gridsuite/modification/dto/StaticVarCompensatorCreationInfos.java @@ -96,7 +96,37 @@ public class StaticVarCompensatorCreationInfos extends InjectionCreationInfos { @Override public AbstractModification toModification() { - return new StaticVarCompensatorCreation(this); + return StaticVarCompensatorCreation.builder() + .equipmentId(getEquipmentId()) + .properties(getProperties()) + .equipmentName(getEquipmentName()) + .voltageLevelId(getVoltageLevelId()) + .busOrBusbarSectionId(getBusOrBusbarSectionId()) + .connectionName(getConnectionName()) + .connectionDirection(getConnectionDirection()) + .connectionPosition(getConnectionPosition()) + .terminalConnected(isTerminalConnected()) + .maxSusceptance(getMaxSusceptance()) + .minSusceptance(getMinSusceptance()) + .maxQAtNominalV(getMaxQAtNominalV()) + .minQAtNominalV(getMinQAtNominalV()) + .regulationMode(getRegulationMode()) + .voltageSetpoint(getVoltageSetpoint()) + .reactivePowerSetpoint(getReactivePowerSetpoint()) + .voltageRegulationType(getVoltageRegulationType()) + .regulatingTerminalId(getRegulatingTerminalId()) + .regulatingTerminalType(getRegulatingTerminalType()) + .regulatingTerminalVlId(getRegulatingTerminalVlId()) + .regulating(isRegulating()) + .standbyAutomatonOn(isStandbyAutomatonOn()) + .standby(isStandby()) + .b0(getB0()) + .q0(getQ0()) + .lowVoltageSetpoint(getLowVoltageSetpoint()) + .highVoltageSetpoint(getHighVoltageSetpoint()) + .lowVoltageThreshold(getLowVoltageThreshold()) + .highVoltageThreshold(getHighVoltageThreshold()) + .build(); } @Override diff --git a/src/main/java/org/gridsuite/modification/dto/SubstationCreationInfos.java b/src/main/java/org/gridsuite/modification/dto/SubstationCreationInfos.java index ea7fc843..8bfbe410 100644 --- a/src/main/java/org/gridsuite/modification/dto/SubstationCreationInfos.java +++ b/src/main/java/org/gridsuite/modification/dto/SubstationCreationInfos.java @@ -38,7 +38,12 @@ public class SubstationCreationInfos extends EquipmentCreationInfos { @Override public AbstractModification toModification() { - return new SubstationCreation(this); + return SubstationCreation.builder() + .equipmentId(getEquipmentId()) + .properties(getProperties()) + .equipmentName(getEquipmentName()) + .country(getCountry()) + .build(); } @Override diff --git a/src/main/java/org/gridsuite/modification/dto/SubstationModificationInfos.java b/src/main/java/org/gridsuite/modification/dto/SubstationModificationInfos.java index 2aedfaad..02e0dca7 100644 --- a/src/main/java/org/gridsuite/modification/dto/SubstationModificationInfos.java +++ b/src/main/java/org/gridsuite/modification/dto/SubstationModificationInfos.java @@ -38,7 +38,12 @@ public class SubstationModificationInfos extends BasicEquipmentModificationInfos @Override public AbstractModification toModification() { - return new SubstationModification(this); + return SubstationModification.builder() + .equipmentId(getEquipmentId()) + .properties(getProperties()) + .equipmentName(getEquipmentName()) + .country(getCountry()) + .build(); } @Override diff --git a/src/main/java/org/gridsuite/modification/dto/TwoWindingsTransformerCreationInfos.java b/src/main/java/org/gridsuite/modification/dto/TwoWindingsTransformerCreationInfos.java index 0a9796d2..6d578380 100644 --- a/src/main/java/org/gridsuite/modification/dto/TwoWindingsTransformerCreationInfos.java +++ b/src/main/java/org/gridsuite/modification/dto/TwoWindingsTransformerCreationInfos.java @@ -55,7 +55,35 @@ public class TwoWindingsTransformerCreationInfos extends BranchCreationInfos { @Override public AbstractModification toModification() { - return new TwoWindingsTransformerCreation(this); + return TwoWindingsTransformerCreation.builder() + .equipmentId(getEquipmentId()) + .properties(getProperties()) + .equipmentName(getEquipmentName()) + .r(getR()) + .x(getX()) + .voltageLevelId1(getVoltageLevelId1()) + .voltageLevelId2(getVoltageLevelId2()) + .busOrBusbarSectionId1(getBusOrBusbarSectionId1()) + .busOrBusbarSectionId2(getBusOrBusbarSectionId2()) + .operationalLimitsGroups(getOperationalLimitsGroups()) + .selectedOperationalLimitsGroupId1(getSelectedOperationalLimitsGroupId1()) + .selectedOperationalLimitsGroupId2(getSelectedOperationalLimitsGroupId2()) + .connectionName1(getConnectionName1()) + .connectionDirection1(getConnectionDirection1()) + .connectionName2(getConnectionName2()) + .connectionDirection2(getConnectionDirection2()) + .connectionPosition1(getConnectionPosition1()) + .connectionPosition2(getConnectionPosition2()) + .connected1(isConnected1()) + .connected2(isConnected2()) + .g(getG()) + .b(getB()) + .ratedU1(getRatedU1()) + .ratedU2(getRatedU2()) + .ratedS(getRatedS()) + .ratioTapChanger(getRatioTapChanger()) + .phaseTapChanger(getPhaseTapChanger()) + .build(); } @Override diff --git a/src/main/java/org/gridsuite/modification/dto/TwoWindingsTransformerModificationInfos.java b/src/main/java/org/gridsuite/modification/dto/TwoWindingsTransformerModificationInfos.java index 7c67f3e8..7521692d 100644 --- a/src/main/java/org/gridsuite/modification/dto/TwoWindingsTransformerModificationInfos.java +++ b/src/main/java/org/gridsuite/modification/dto/TwoWindingsTransformerModificationInfos.java @@ -59,7 +59,47 @@ public class TwoWindingsTransformerModificationInfos extends BranchModificationI @Override public AbstractModification toModification() { - return new TwoWindingsTransformerModification(this); + return TwoWindingsTransformerModification.builder() + .equipmentId(getEquipmentId()) + .properties(getProperties()) + .equipmentName(getEquipmentName()) + .r(getR()) + .x(getX()) + .operationalLimitsGroupsModificationType(getOperationalLimitsGroupsModificationType()) + .enableOLGModification(getEnableOLGModification()) + .operationalLimitsGroups(getOperationalLimitsGroups()) + .selectedOperationalLimitsGroupId1(getSelectedOperationalLimitsGroupId1()) + .selectedOperationalLimitsGroupId2(getSelectedOperationalLimitsGroupId2()) + .voltageLevelId1(getVoltageLevelId1()) + .voltageLevelId2(getVoltageLevelId2()) + .busOrBusbarSectionId1(getBusOrBusbarSectionId1()) + .busOrBusbarSectionId2(getBusOrBusbarSectionId2()) + .connectionName1(getConnectionName1()) + .connectionName2(getConnectionName2()) + .connectionDirection1(getConnectionDirection1()) + .connectionDirection2(getConnectionDirection2()) + .connectionPosition1(getConnectionPosition1()) + .connectionPosition2(getConnectionPosition2()) + .terminal1Connected(getTerminal1Connected()) + .terminal2Connected(getTerminal2Connected()) + .p1MeasurementValue(getP1MeasurementValue()) + .p1MeasurementValidity(getP1MeasurementValidity()) + .p2MeasurementValue(getP2MeasurementValue()) + .p2MeasurementValidity(getP2MeasurementValidity()) + .q1MeasurementValue(getQ1MeasurementValue()) + .q1MeasurementValidity(getQ1MeasurementValidity()) + .q2MeasurementValue(getQ2MeasurementValue()) + .q2MeasurementValidity(getQ2MeasurementValidity()) + .g(getG()) + .b(getB()) + .ratedU1(getRatedU1()) + .ratedU2(getRatedU2()) + .ratedS(getRatedS()) + .ratioTapChanger(getRatioTapChanger()) + .phaseTapChanger(getPhaseTapChanger()) + .ratioTapChangerToBeEstimated(getRatioTapChangerToBeEstimated()) + .phaseTapChangerToBeEstimated(getPhaseTapChangerToBeEstimated()) + .build(); } @Override diff --git a/src/main/java/org/gridsuite/modification/dto/VoltageInitModificationInfos.java b/src/main/java/org/gridsuite/modification/dto/VoltageInitModificationInfos.java index 39ac1288..ceb92e60 100644 --- a/src/main/java/org/gridsuite/modification/dto/VoltageInitModificationInfos.java +++ b/src/main/java/org/gridsuite/modification/dto/VoltageInitModificationInfos.java @@ -62,7 +62,14 @@ public class VoltageInitModificationInfos extends ModificationInfos { @Override public AbstractModification toModification() { - return new VoltageInitModification(this); + return VoltageInitModification.builder() + .generators(getGenerators()) + .transformers(getTransformers()) + .staticVarCompensators(getStaticVarCompensators()) + .vscConverterStations(getVscConverterStations()) + .shuntCompensators(getShuntCompensators()) + .buses(getBuses()) + .build(); } @Override diff --git a/src/main/java/org/gridsuite/modification/dto/VoltageLevelCreationInfos.java b/src/main/java/org/gridsuite/modification/dto/VoltageLevelCreationInfos.java index d007d7c7..bbc39d0a 100644 --- a/src/main/java/org/gridsuite/modification/dto/VoltageLevelCreationInfos.java +++ b/src/main/java/org/gridsuite/modification/dto/VoltageLevelCreationInfos.java @@ -17,11 +17,13 @@ import lombok.experimental.SuperBuilder; import org.gridsuite.modification.dto.annotation.ModificationErrorTypeName; import org.gridsuite.modification.modifications.AbstractModification; +import org.gridsuite.modification.modifications.SubstationCreation; import org.gridsuite.modification.modifications.VoltageLevelCreation; import java.util.HashMap; import java.util.List; import java.util.Map; +import java.util.Optional; /** * @author Laurent GARNIER @@ -71,7 +73,22 @@ public class VoltageLevelCreationInfos extends EquipmentCreationInfos { @Override public AbstractModification toModification() { - return new VoltageLevelCreation(this); + return VoltageLevelCreation.builder() + .equipmentId(getEquipmentId()) + .properties(getProperties()) + .equipmentName(getEquipmentName()) + .substationId(getSubstationId()) + .nominalV(getNominalV()) + .lowVoltageLimit(getLowVoltageLimit()) + .highVoltageLimit(getHighVoltageLimit()) + .ipMin(getIpMin()) + .ipMax(getIpMax()) + .busbarCount(getBusbarCount()) + .sectionCount(getSectionCount()) + .switchKinds(getSwitchKinds()) + .couplingDevices(getCouplingDevices()) + .substationCreation((SubstationCreation) Optional.ofNullable(getSubstationCreation()).map(SubstationCreationInfos::toModification).orElse(null)) + .build(); } @Override diff --git a/src/main/java/org/gridsuite/modification/dto/VoltageLevelModificationInfos.java b/src/main/java/org/gridsuite/modification/dto/VoltageLevelModificationInfos.java index c2c81537..89b1020d 100644 --- a/src/main/java/org/gridsuite/modification/dto/VoltageLevelModificationInfos.java +++ b/src/main/java/org/gridsuite/modification/dto/VoltageLevelModificationInfos.java @@ -52,7 +52,17 @@ public class VoltageLevelModificationInfos extends BasicEquipmentModificationInf @Override public AbstractModification toModification() { - return new VoltageLevelModification(this); + return VoltageLevelModification.builder() + .equipmentId(getEquipmentId()) + .properties(getProperties()) + .equipmentName(getEquipmentName()) + .nominalV(getNominalV()) + .lowVoltageLimit(getLowVoltageLimit()) + .highVoltageLimit(getHighVoltageLimit()) + .ipMin(getIpMin()) + .ipMax(getIpMax()) + .busbarSectionVMeasurements(getBusbarSectionVMeasurements()) + .build(); } @Override diff --git a/src/main/java/org/gridsuite/modification/dto/VoltageLevelTopologyModificationInfos.java b/src/main/java/org/gridsuite/modification/dto/VoltageLevelTopologyModificationInfos.java index b7110a56..1e5357d6 100644 --- a/src/main/java/org/gridsuite/modification/dto/VoltageLevelTopologyModificationInfos.java +++ b/src/main/java/org/gridsuite/modification/dto/VoltageLevelTopologyModificationInfos.java @@ -16,6 +16,7 @@ import lombok.experimental.SuperBuilder; import org.gridsuite.modification.dto.annotation.ModificationErrorTypeName; import org.gridsuite.modification.modifications.AbstractModification; +import org.gridsuite.modification.modifications.EquipmentAttributeModification; import org.gridsuite.modification.modifications.VoltageLevelTopologyModification; import java.util.List; @@ -38,7 +39,13 @@ public class VoltageLevelTopologyModificationInfos extends EquipmentModification @Override public AbstractModification toModification() { - return new VoltageLevelTopologyModification(this); + return VoltageLevelTopologyModification.builder() + .equipmentId(getEquipmentId()) + .properties(getProperties()) + .equipmentAttributeModificationList(getEquipmentAttributeModificationList().stream() + .map(EquipmentAttributeModificationInfos::toModification) + .map(m -> (EquipmentAttributeModification) m).toList()) + .build(); } @Override diff --git a/src/main/java/org/gridsuite/modification/dto/VscCreationInfos.java b/src/main/java/org/gridsuite/modification/dto/VscCreationInfos.java index 842638be..4987c6f1 100644 --- a/src/main/java/org/gridsuite/modification/dto/VscCreationInfos.java +++ b/src/main/java/org/gridsuite/modification/dto/VscCreationInfos.java @@ -19,6 +19,7 @@ import org.gridsuite.modification.dto.annotation.ModificationErrorTypeName; import org.gridsuite.modification.modifications.AbstractModification; import org.gridsuite.modification.modifications.VscCreation; +import org.gridsuite.modification.modifications.data.VscConverterStationCreation; /** * @author Seddik Yengui @@ -71,7 +72,42 @@ public class VscCreationInfos extends EquipmentCreationInfos { @Override public AbstractModification toModification() { - return new VscCreation(this); + return VscCreation.builder() + .equipmentId(getEquipmentId()) + .properties(getProperties()) + .equipmentName(getEquipmentName()) + .nominalV(getNominalV()) + .r(getR()) + .maxP(getMaxP()) + .operatorActivePowerLimitFromSide1ToSide2(getOperatorActivePowerLimitFromSide1ToSide2()) + .operatorActivePowerLimitFromSide2ToSide1(getOperatorActivePowerLimitFromSide2ToSide1()) + .convertersMode(getConvertersMode()) + .activePowerSetpoint(getActivePowerSetpoint()) + .angleDroopActivePowerControl(getAngleDroopActivePowerControl()) + .p0(getP0()) + .droop(getDroop()) + .converterStation1(converterStationCreation(getConverterStation1())) + .converterStation2(converterStationCreation(getConverterStation2())) + .build(); + } + + private VscConverterStationCreation converterStationCreation(ConverterStationCreationInfos converterStationCreationInfos) { + return VscConverterStationCreation.builder().lossFactor(converterStationCreationInfos.getLossFactor()) + .reactivePowerSetpoint(converterStationCreationInfos.getReactivePowerSetpoint()) + .voltageRegulationOn(converterStationCreationInfos.getVoltageRegulationOn()) + .voltageSetpoint(converterStationCreationInfos.getVoltageSetpoint()) + .reactiveCapabilityCurve(converterStationCreationInfos.getReactiveCapabilityCurve()) + .minQ(converterStationCreationInfos.getMinQ()).maxQ(converterStationCreationInfos.getMaxQ()) + .reactiveCapabilityCurvePoints(converterStationCreationInfos.getReactiveCapabilityCurvePoints()) + .equipmentId(converterStationCreationInfos.getEquipmentId()).properties(converterStationCreationInfos.getProperties()) + .equipmentName(converterStationCreationInfos.getEquipmentName()) + .voltageLevelId(converterStationCreationInfos.getVoltageLevelId()) + .busOrBusbarSectionId(converterStationCreationInfos.getBusOrBusbarSectionId()) + .connectionName(converterStationCreationInfos.getConnectionName()) + .connectionDirection(converterStationCreationInfos.getConnectionDirection()) + .connectionPosition(converterStationCreationInfos.getConnectionPosition()) + .terminalConnected(converterStationCreationInfos.isTerminalConnected()) + .build(); } @Override diff --git a/src/main/java/org/gridsuite/modification/dto/VscModificationInfos.java b/src/main/java/org/gridsuite/modification/dto/VscModificationInfos.java index e964d234..e22a9c1b 100644 --- a/src/main/java/org/gridsuite/modification/dto/VscModificationInfos.java +++ b/src/main/java/org/gridsuite/modification/dto/VscModificationInfos.java @@ -9,6 +9,7 @@ import org.gridsuite.modification.dto.annotation.ModificationErrorTypeName; import org.gridsuite.modification.modifications.AbstractModification; import org.gridsuite.modification.modifications.VscModification; +import org.gridsuite.modification.modifications.data.VscConverterStationModification; /** * @author jamal kheyyad @@ -60,7 +61,50 @@ public class VscModificationInfos extends BasicEquipmentModificationInfos { @Override public AbstractModification toModification() { - return new VscModification(this); + return VscModification.builder() + .equipmentId(getEquipmentId()) + .properties(getProperties()) + .equipmentName(getEquipmentName()) + .nominalV(getNominalV()) + .r(getR()) + .maxP(getMaxP()) + .operatorActivePowerLimitFromSide1ToSide2(getOperatorActivePowerLimitFromSide1ToSide2()) + .operatorActivePowerLimitFromSide2ToSide1(getOperatorActivePowerLimitFromSide2ToSide1()) + .convertersMode(getConvertersMode()) + .activePowerSetpoint(getActivePowerSetpoint()) + .angleDroopActivePowerControl(getAngleDroopActivePowerControl()) + .p0(getP0()) + .droop(getDroop()) + .converterStation1(converterStationModification(getConverterStation1())) + .converterStation2(converterStationModification(getConverterStation2())) + .build(); + } + + private VscConverterStationModification converterStationModification(ConverterStationModificationInfos converterStationModificationInfos) { + if (converterStationModificationInfos == null) { + return null; + } + return VscConverterStationModification.builder().lossFactor(converterStationModificationInfos.getLossFactor()) + .reactivePowerSetpoint(converterStationModificationInfos.getReactivePowerSetpoint()) + .voltageRegulationOn(converterStationModificationInfos.getVoltageRegulationOn()) + .voltageSetpoint(converterStationModificationInfos.getVoltageSetpoint()) + .reactiveCapabilityCurve(converterStationModificationInfos.getReactiveCapabilityCurve()) + .minQ(converterStationModificationInfos.getMinQ()).maxQ(converterStationModificationInfos.getMaxQ()) + .reactiveCapabilityCurvePoints(converterStationModificationInfos.getReactiveCapabilityCurvePoints()) + .equipmentId(converterStationModificationInfos.getEquipmentId()) + .properties(converterStationModificationInfos.getProperties()) + .equipmentName(converterStationModificationInfos.getEquipmentName()) + .voltageLevelId(converterStationModificationInfos.getVoltageLevelId()) + .busOrBusbarSectionId(converterStationModificationInfos.getBusOrBusbarSectionId()) + .connectionName(converterStationModificationInfos.getConnectionName()) + .connectionDirection(converterStationModificationInfos.getConnectionDirection()) + .connectionPosition(converterStationModificationInfos.getConnectionPosition()) + .terminalConnected(converterStationModificationInfos.getTerminalConnected()) + .pMeasurementValue(converterStationModificationInfos.getPMeasurementValue()) + .pMeasurementValidity(converterStationModificationInfos.getPMeasurementValidity()) + .qMeasurementValue(converterStationModificationInfos.getQMeasurementValue()) + .qMeasurementValidity(converterStationModificationInfos.getQMeasurementValidity()) + .build(); } @Override diff --git a/src/main/java/org/gridsuite/modification/modifications/AbstractBranchCreation.java b/src/main/java/org/gridsuite/modification/modifications/AbstractBranchCreation.java new file mode 100644 index 00000000..af2666b1 --- /dev/null +++ b/src/main/java/org/gridsuite/modification/modifications/AbstractBranchCreation.java @@ -0,0 +1,70 @@ +/* + Copyright (c) 2026, 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/. + */ +package org.gridsuite.modification.modifications; + +import com.powsybl.iidm.network.extensions.ConnectablePosition; +import lombok.Getter; +import lombok.Setter; +import org.gridsuite.modification.dto.FreePropertyInfos; +import org.gridsuite.modification.dto.OperationalLimitsGroupInfos; + +import java.util.List; + +/** + * @author Joris Mancini + */ +@Setter +@Getter +public abstract class AbstractBranchCreation extends AbstractEquipmentCreation { + + protected double r; + protected double x; + protected String voltageLevelId1; + protected String voltageLevelId2; + protected String busOrBusbarSectionId1; + protected String busOrBusbarSectionId2; + protected List operationalLimitsGroups; + protected String selectedOperationalLimitsGroupId1; + protected String selectedOperationalLimitsGroupId2; + protected String connectionName1; + protected ConnectablePosition.Direction connectionDirection1; + protected String connectionName2; + protected ConnectablePosition.Direction connectionDirection2; + protected Integer connectionPosition1; + protected Integer connectionPosition2; + protected boolean connected1; + protected boolean connected2; + + protected AbstractBranchCreation(String equipmentId, List properties, String equipmentName, + double r, double x, String voltageLevelId1, String voltageLevelId2, + String busOrBusbarSectionId1, String busOrBusbarSectionId2, + List operationalLimitsGroups, + String selectedOperationalLimitsGroupId1, String selectedOperationalLimitsGroupId2, + String connectionName1, ConnectablePosition.Direction connectionDirection1, + String connectionName2, ConnectablePosition.Direction connectionDirection2, + Integer connectionPosition1, Integer connectionPosition2, boolean connected1, + boolean connected2) { + super(equipmentId, properties, equipmentName); + this.r = r; + this.x = x; + this.voltageLevelId1 = voltageLevelId1; + this.voltageLevelId2 = voltageLevelId2; + this.busOrBusbarSectionId1 = busOrBusbarSectionId1; + this.busOrBusbarSectionId2 = busOrBusbarSectionId2; + this.operationalLimitsGroups = operationalLimitsGroups; + this.selectedOperationalLimitsGroupId1 = selectedOperationalLimitsGroupId1; + this.selectedOperationalLimitsGroupId2 = selectedOperationalLimitsGroupId2; + this.connectionName1 = connectionName1; + this.connectionDirection1 = connectionDirection1; + this.connectionName2 = connectionName2; + this.connectionDirection2 = connectionDirection2; + this.connectionPosition1 = connectionPosition1; + this.connectionPosition2 = connectionPosition2; + this.connected1 = connected1; + this.connected2 = connected2; + } +} diff --git a/src/main/java/org/gridsuite/modification/modifications/AbstractBranchModification.java b/src/main/java/org/gridsuite/modification/modifications/AbstractBranchModification.java index 0b4e3065..2d89f063 100644 --- a/src/main/java/org/gridsuite/modification/modifications/AbstractBranchModification.java +++ b/src/main/java/org/gridsuite/modification/modifications/AbstractBranchModification.java @@ -10,13 +10,18 @@ import com.powsybl.commons.report.TypedValue; import com.powsybl.iidm.network.*; import com.powsybl.iidm.network.extensions.*; +import lombok.Getter; +import lombok.NoArgsConstructor; +import lombok.Setter; import org.gridsuite.modification.NetworkModificationException; import org.gridsuite.modification.dto.*; import org.gridsuite.modification.modifications.olg.OperationalLimitsGroupsModification; import org.gridsuite.modification.utils.ModificationUtils; import org.springframework.util.StringUtils; -import java.util.*; +import java.util.ArrayList; +import java.util.List; +import java.util.Objects; import java.util.stream.Collectors; import static org.gridsuite.modification.NetworkModificationException.Type.BRANCH_MODIFICATION_ERROR; @@ -26,7 +31,10 @@ /** * @author Florent MILLOT */ -public abstract class AbstractBranchModification extends AbstractModification { +@Setter +@Getter +@NoArgsConstructor +public abstract class AbstractBranchModification extends AbstractEquipmentModification { public static final String DURATION = "duration"; public static final String NAME = "name"; @@ -36,50 +44,128 @@ public abstract class AbstractBranchModification extends AbstractModification { public static final String SIDE = "side"; public static final String APPLICABILITY = "applicability"; - protected final BranchModificationInfos modificationInfos; + protected AttributeModification r; + protected AttributeModification x; + protected OperationalLimitsGroupsModificationType operationalLimitsGroupsModificationType; + protected Boolean enableOLGModification; + protected List operationalLimitsGroups; + protected AttributeModification selectedOperationalLimitsGroupId1; + protected AttributeModification selectedOperationalLimitsGroupId2; + protected AttributeModification voltageLevelId1; + protected AttributeModification voltageLevelId2; + protected AttributeModification busOrBusbarSectionId1; + protected AttributeModification busOrBusbarSectionId2; + protected AttributeModification connectionName1; + protected AttributeModification connectionName2; + protected AttributeModification connectionDirection1; + protected AttributeModification connectionDirection2; + protected AttributeModification connectionPosition1; + protected AttributeModification connectionPosition2; + protected AttributeModification terminal1Connected; + protected AttributeModification terminal2Connected; + protected AttributeModification p1MeasurementValue; + protected AttributeModification p1MeasurementValidity; + protected AttributeModification p2MeasurementValue; + protected AttributeModification p2MeasurementValidity; + protected AttributeModification q1MeasurementValue; + protected AttributeModification q1MeasurementValidity; + protected AttributeModification q2MeasurementValue; + protected AttributeModification q2MeasurementValidity; - protected AbstractBranchModification(BranchModificationInfos modificationInfos) { - this.modificationInfos = modificationInfos; + protected AbstractBranchModification(String equipmentId, List properties, + AttributeModification equipmentName, AttributeModification r, + AttributeModification x, + OperationalLimitsGroupsModificationType operationalLimitsGroupsModificationType, + Boolean enableOLGModification, List operationalLimitsGroups, + AttributeModification selectedOperationalLimitsGroupId1, + AttributeModification selectedOperationalLimitsGroupId2, + AttributeModification voltageLevelId1, + AttributeModification voltageLevelId2, + AttributeModification busOrBusbarSectionId1, + AttributeModification busOrBusbarSectionId2, + AttributeModification connectionName1, + AttributeModification connectionName2, + AttributeModification connectionDirection1, + AttributeModification connectionDirection2, + AttributeModification connectionPosition1, + AttributeModification connectionPosition2, + AttributeModification terminal1Connected, + AttributeModification terminal2Connected, + AttributeModification p1MeasurementValue, + AttributeModification p1MeasurementValidity, + AttributeModification p2MeasurementValue, + AttributeModification p2MeasurementValidity, + AttributeModification q1MeasurementValue, + AttributeModification q1MeasurementValidity, + AttributeModification q2MeasurementValue, + AttributeModification q2MeasurementValidity) { + super(equipmentId, properties, equipmentName); + this.r = r; + this.x = x; + this.operationalLimitsGroupsModificationType = operationalLimitsGroupsModificationType; + this.enableOLGModification = enableOLGModification; + this.operationalLimitsGroups = operationalLimitsGroups; + this.selectedOperationalLimitsGroupId1 = selectedOperationalLimitsGroupId1; + this.selectedOperationalLimitsGroupId2 = selectedOperationalLimitsGroupId2; + this.voltageLevelId1 = voltageLevelId1; + this.voltageLevelId2 = voltageLevelId2; + this.busOrBusbarSectionId1 = busOrBusbarSectionId1; + this.busOrBusbarSectionId2 = busOrBusbarSectionId2; + this.connectionName1 = connectionName1; + this.connectionName2 = connectionName2; + this.connectionDirection1 = connectionDirection1; + this.connectionDirection2 = connectionDirection2; + this.connectionPosition1 = connectionPosition1; + this.connectionPosition2 = connectionPosition2; + this.terminal1Connected = terminal1Connected; + this.terminal2Connected = terminal2Connected; + this.p1MeasurementValue = p1MeasurementValue; + this.p1MeasurementValidity = p1MeasurementValidity; + this.p2MeasurementValue = p2MeasurementValue; + this.p2MeasurementValidity = p2MeasurementValidity; + this.q1MeasurementValue = q1MeasurementValue; + this.q1MeasurementValidity = q1MeasurementValidity; + this.q2MeasurementValue = q2MeasurementValue; + this.q2MeasurementValidity = q2MeasurementValidity; } - protected void modifyBranch(Branch branch, BranchModificationInfos branchModificationInfos, ReportNode subReportNode, String reporterKey) { + protected void modifyBranch(Branch branch, ReportNode subReportNode, String reporterKey) { subReportNode.newReportNode() - .withMessageTemplate(reporterKey) - .withUntypedValue("id", branchModificationInfos.getEquipmentId()) - .withSeverity(TypedValue.INFO_SEVERITY) - .add(); - if (branchModificationInfos.getEquipmentName() != null && modificationInfos.getEquipmentName().getValue() != null) { + .withMessageTemplate(reporterKey) + .withUntypedValue("id", equipmentId) + .withSeverity(TypedValue.INFO_SEVERITY) + .add(); + if (equipmentName != null && equipmentName.getValue() != null) { ModificationUtils.getInstance().applyElementaryModifications( - branch::setName, - () -> branch.getOptionalName().orElse(NO_VALUE), - modificationInfos.getEquipmentName(), - subReportNode, - "Name" + branch::setName, + () -> branch.getOptionalName().orElse(NO_VALUE), + equipmentName, + subReportNode, + "Name" ); } - modifyBranchVoltageLevelBusOrBusBarSectionAttributesSide1(modificationInfos, branch, subReportNode); - modifyBranchVoltageLevelBusOrBusBarSectionAttributesSide2(modificationInfos, branch, subReportNode); - modifyBranchConnectivityAttributes(branchModificationInfos, branch, subReportNode); + modifyBranchVoltageLevelBusOrBusBarSectionAttributesSide1(branch, subReportNode); + modifyBranchVoltageLevelBusOrBusBarSectionAttributesSide2(branch, subReportNode); + modifyBranchConnectivityAttributes(branch, subReportNode); - if (characteristicsModified(branchModificationInfos)) { - modifyCharacteristics(branch, branchModificationInfos, subReportNode); + if (characteristicsModified()) { + modifyCharacteristics(branch, subReportNode); } List activeOLGReports = new ArrayList<>(); ReportNode limitsReportNode = null; - boolean modifyOLG = branchModificationInfos.getEnableOLGModification() == null - || branchModificationInfos.getEnableOLGModification(); + boolean modifyOLG = enableOLGModification == null || enableOLGModification; if (modifyOLG) { limitsReportNode = subReportNode.newReportNode().withMessageTemplate("network.modification.limits").add(); ReportNode limitSetsReportNode = limitsReportNode.newReportNode().withMessageTemplate("network.modification.limitsSets").add(); new OperationalLimitsGroupsModification( - branch, - branchModificationInfos.getOperationalLimitsGroups(), - limitSetsReportNode - ).modifyOperationalLimitsGroups(branchModificationInfos.getOperationalLimitsGroupsModificationType()); + branch, + operationalLimitsGroups, + limitSetsReportNode + ).modifyOperationalLimitsGroups(operationalLimitsGroupsModificationType); } applySelectedOLGs(branch, activeOLGReports); @@ -90,24 +176,24 @@ protected void modifyBranch(Branch branch, BranchModificationInfos branchModi } ModificationUtils.getInstance().reportModifications(limitsReportNode, activeOLGReports, "network.modification.activeLimitsSets"); } - updateConnections(branch, branchModificationInfos); + updateConnections(branch); } private void applySelectedOLGs(Branch branch, List activeOLGReports) { - if (modificationInfos.getSelectedOperationalLimitsGroupId1() != null) { + if (selectedOperationalLimitsGroupId1 != null) { modifySelectedOperationalLimitsGroup( - branch, - modificationInfos.getSelectedOperationalLimitsGroupId1(), - TwoSides.ONE, - activeOLGReports + branch, + selectedOperationalLimitsGroupId1, + TwoSides.ONE, + activeOLGReports ); } - if (modificationInfos.getSelectedOperationalLimitsGroupId2() != null) { + if (selectedOperationalLimitsGroupId2 != null) { modifySelectedOperationalLimitsGroup( - branch, - modificationInfos.getSelectedOperationalLimitsGroupId2(), - TwoSides.TWO, - activeOLGReports); + branch, + selectedOperationalLimitsGroupId2, + TwoSides.TWO, + activeOLGReports); } } @@ -116,26 +202,26 @@ private static void applySelectedOLGOnSide1(Branch branch, AttributeModificat branch.cancelSelectedOperationalLimitsGroup1(); if (reportNode != null) { reportNode.add(ReportNode.newRootReportNode() - .withMessageTemplate("network.modification.noLimitSetSelectedOnSide1") - .withSeverity(TypedValue.INFO_SEVERITY) - .build()); + .withMessageTemplate("network.modification.noLimitSetSelectedOnSide1") + .withSeverity(TypedValue.INFO_SEVERITY) + .build()); } } else { if (StringUtils.hasText(newSelectedOLG) && branch.getOperationalLimitsGroup1(newSelectedOLG).isEmpty() && reportNode != null) { reportNode.add(ReportNode.newRootReportNode() - .withMessageTemplate("network.modification.limitSetAbsentOnSide1") - .withUntypedValue("selectedOperationalLimitsGroup", newSelectedOLG) - .withSeverity(TypedValue.WARN_SEVERITY) - .build()); + .withMessageTemplate("network.modification.limitSetAbsentOnSide1") + .withUntypedValue("selectedOperationalLimitsGroup", newSelectedOLG) + .withSeverity(TypedValue.WARN_SEVERITY) + .build()); } else { branch.setSelectedOperationalLimitsGroup1(newSelectedOLG); if (reportNode != null) { reportNode.add(ReportNode.newRootReportNode() - .withMessageTemplate("network.modification.limitSetSelectedOnSide1") - .withUntypedValue("selectedOperationalLimitsGroup1", newSelectedOLG) - .withSeverity(TypedValue.INFO_SEVERITY) - .build()); + .withMessageTemplate("network.modification.limitSetSelectedOnSide1") + .withUntypedValue("selectedOperationalLimitsGroup1", newSelectedOLG) + .withSeverity(TypedValue.INFO_SEVERITY) + .build()); } } } @@ -146,40 +232,40 @@ private static void applySelectedOLGOnSide2(Branch branch, AttributeModificat branch.cancelSelectedOperationalLimitsGroup2(); if (reportNode != null) { reportNode.add(ReportNode.newRootReportNode() - .withMessageTemplate("network.modification.noLimitSetSelectedOnSide2") - .withSeverity(TypedValue.INFO_SEVERITY) - .build()); + .withMessageTemplate("network.modification.noLimitSetSelectedOnSide2") + .withSeverity(TypedValue.INFO_SEVERITY) + .build()); } } else { if (StringUtils.hasText(newSelectedOLG) && branch.getOperationalLimitsGroup2(newSelectedOLG).isEmpty() && reportNode != null) { reportNode.add(ReportNode.newRootReportNode() - .withMessageTemplate("network.modification.limitSetAbsentOnSide2") - .withUntypedValue("selectedOperationalLimitsGroup", newSelectedOLG) - .withSeverity(TypedValue.WARN_SEVERITY) - .build()); + .withMessageTemplate("network.modification.limitSetAbsentOnSide2") + .withUntypedValue("selectedOperationalLimitsGroup", newSelectedOLG) + .withSeverity(TypedValue.WARN_SEVERITY) + .build()); } else { branch.setSelectedOperationalLimitsGroup2(newSelectedOLG); if (reportNode != null) { reportNode.add(ReportNode.newRootReportNode() - .withMessageTemplate("network.modification.limitSetSelectedOnSide2") - .withUntypedValue("selectedOperationalLimitsGroup2", newSelectedOLG) - .withSeverity(TypedValue.INFO_SEVERITY) - .build()); + .withMessageTemplate("network.modification.limitSetSelectedOnSide2") + .withUntypedValue("selectedOperationalLimitsGroup2", newSelectedOLG) + .withSeverity(TypedValue.INFO_SEVERITY) + .build()); } } } } - public ReportNode updateMeasurements(Branch branch, BranchModificationInfos branchModificationInfos, ReportNode subReportNode) { - Double p1Value = branchModificationInfos.getP1MeasurementValue() != null ? branchModificationInfos.getP1MeasurementValue().getValue() : null; - Double q1Value = branchModificationInfos.getQ1MeasurementValue() != null ? branchModificationInfos.getQ1MeasurementValue().getValue() : null; - Double p2Value = branchModificationInfos.getP2MeasurementValue() != null ? branchModificationInfos.getP2MeasurementValue().getValue() : null; - Double q2Value = branchModificationInfos.getQ2MeasurementValue() != null ? branchModificationInfos.getQ2MeasurementValue().getValue() : null; - Boolean p1Validity = branchModificationInfos.getP1MeasurementValidity() != null ? branchModificationInfos.getP1MeasurementValidity().getValue() : null; - Boolean q1Validity = branchModificationInfos.getQ1MeasurementValidity() != null ? branchModificationInfos.getQ1MeasurementValidity().getValue() : null; - Boolean p2Validity = branchModificationInfos.getP2MeasurementValidity() != null ? branchModificationInfos.getP2MeasurementValidity().getValue() : null; - Boolean q2Validity = branchModificationInfos.getQ2MeasurementValidity() != null ? branchModificationInfos.getQ2MeasurementValidity().getValue() : null; + public ReportNode updateMeasurements(Branch branch, ReportNode subReportNode) { + Double p1Value = p1MeasurementValue != null ? p1MeasurementValue.getValue() : null; + Double q1Value = q1MeasurementValue != null ? q1MeasurementValue.getValue() : null; + Double p2Value = p2MeasurementValue != null ? p2MeasurementValue.getValue() : null; + Double q2Value = q2MeasurementValue != null ? q2MeasurementValue.getValue() : null; + Boolean p1Validity = p1MeasurementValidity != null ? p1MeasurementValidity.getValue() : null; + Boolean q1Validity = q1MeasurementValidity != null ? q1MeasurementValidity.getValue() : null; + Boolean p2Validity = p2MeasurementValidity != null ? p2MeasurementValidity.getValue() : null; + Boolean q2Validity = q2MeasurementValidity != null ? q2MeasurementValidity.getValue() : null; if (p1Value == null && p1Validity == null && q1Value == null && q1Validity == null && p2Value == null && p2Validity == null && q2Value == null && q2Validity == null) { // no measurement modification requested return null; @@ -211,23 +297,23 @@ public ReportNode updateMeasurements(Branch branch, BranchModificationInfos b return estimSubReportNode; } - private void updateConnections(Branch branch, BranchModificationInfos branchModificationInfos) { + private void updateConnections(Branch branch) { List errorSides = new ArrayList<>(); List errorTypes = new ArrayList<>(); - if (branchModificationInfos.getTerminal1Connected() != null && !updateConnection(branch, TwoSides.ONE, modificationInfos.getTerminal1Connected().getValue())) { + if (terminal1Connected != null && !updateConnection(branch, TwoSides.ONE, terminal1Connected.getValue())) { errorSides.add(TwoSides.ONE); - errorTypes.add(Boolean.TRUE.equals(modificationInfos.getTerminal1Connected().getValue()) ? "connect" : "disconnect"); + errorTypes.add(Boolean.TRUE.equals(terminal1Connected.getValue()) ? "connect" : "disconnect"); } - if (branchModificationInfos.getTerminal2Connected() != null && !updateConnection(branch, TwoSides.TWO, modificationInfos.getTerminal2Connected().getValue())) { + if (terminal2Connected != null && !updateConnection(branch, TwoSides.TWO, terminal2Connected.getValue())) { errorSides.add(TwoSides.TWO); - errorTypes.add(Boolean.TRUE.equals(modificationInfos.getTerminal2Connected().getValue()) ? "connect" : "disconnect"); + errorTypes.add(Boolean.TRUE.equals(terminal2Connected.getValue()) ? "connect" : "disconnect"); } if (!errorSides.isEmpty()) { throw new NetworkModificationException(BRANCH_MODIFICATION_ERROR, - String.format("Could not %s equipment '%s' on side %s", - errorTypes.stream().distinct().collect(Collectors.joining("/")), - branch.getId(), - errorSides.stream().map(Enum::toString).collect(Collectors.joining("/")))); + String.format("Could not %s equipment '%s' on side %s", + errorTypes.stream().distinct().collect(Collectors.joining("/")), + branch.getId(), + errorSides.stream().map(Enum::toString).collect(Collectors.joining("/")))); } } @@ -249,61 +335,57 @@ private boolean updateConnection(Branch branch, TwoSides side, Boolean connec public static boolean mayCreateLimit(TemporaryLimitModificationType modificationType) { return modificationType == TemporaryLimitModificationType.ADD - || modificationType == TemporaryLimitModificationType.REPLACE - || modificationType == TemporaryLimitModificationType.MODIFY_OR_ADD; + || modificationType == TemporaryLimitModificationType.REPLACE + || modificationType == TemporaryLimitModificationType.MODIFY_OR_ADD; } public static void addTemporaryLimit(CurrentLimitsAdder limitsAdder, String limit, double limitValue, int limitAcceptableDuration) { limitsAdder - .beginTemporaryLimit() - .setName(limit) - .setValue(limitValue) - .setAcceptableDuration(limitAcceptableDuration) - .endTemporaryLimit(); + .beginTemporaryLimit() + .setName(limit) + .setValue(limitValue) + .setAcceptableDuration(limitAcceptableDuration) + .endTemporaryLimit(); } - protected boolean characteristicsModified(BranchModificationInfos branchModificationInfos) { - return branchModificationInfos.getX() != null - && branchModificationInfos.getX().getValue() != null - || branchModificationInfos.getR() != null - && branchModificationInfos.getR().getValue() != null; + protected boolean characteristicsModified() { + return x != null + && x.getValue() != null + || r != null + && r.getValue() != null; } - protected abstract void modifyCharacteristics(Branch branch, BranchModificationInfos branchModificationInfos, - ReportNode subReportNode); + protected abstract void modifyCharacteristics(Branch branch, ReportNode subReportNode); - private ReportNode modifyBranchConnectivityAttributes(BranchModificationInfos branchModificationInfos, - Branch branch, ReportNode subReportNode) { + private ReportNode modifyBranchConnectivityAttributes(Branch branch, ReportNode subReportNode) { ConnectablePosition connectablePosition = (ConnectablePosition) branch.getExtension(ConnectablePosition.class); ConnectablePositionAdder connectablePositionAdder = branch.newExtension(ConnectablePositionAdder.class); - return ModificationUtils.getInstance().modifyBranchConnectivityAttributes(connectablePosition, connectablePositionAdder, branch, branchModificationInfos, subReportNode); + return ModificationUtils.getInstance().modifyBranchConnectivityAttributes(connectablePosition, connectablePositionAdder, branch, this, subReportNode); } - private void modifyBranchVoltageLevelBusOrBusBarSectionAttributesSide1(BranchModificationInfos modificationInfos, - Branch branch, ReportNode subReportNode) { + private void modifyBranchVoltageLevelBusOrBusBarSectionAttributesSide1(Branch branch, ReportNode subReportNode) { ModificationUtils.getInstance().moveFeederBay( - (Connectable) branch, branch.getTerminal1(), - modificationInfos.getVoltageLevelId1(), - modificationInfos.getBusOrBusbarSectionId1(), - subReportNode + (Connectable) branch, branch.getTerminal1(), + voltageLevelId1, + busOrBusbarSectionId1, + subReportNode ); } - private void modifyBranchVoltageLevelBusOrBusBarSectionAttributesSide2(BranchModificationInfos modificationInfos, - Branch branch, ReportNode subReportNode) { + private void modifyBranchVoltageLevelBusOrBusBarSectionAttributesSide2(Branch branch, ReportNode subReportNode) { ModificationUtils.getInstance().moveFeederBay( - (Connectable) branch, branch.getTerminal2(), - modificationInfos.getVoltageLevelId2(), - modificationInfos.getBusOrBusbarSectionId2(), - subReportNode + (Connectable) branch, branch.getTerminal2(), + voltageLevelId2, + busOrBusbarSectionId2, + subReportNode ); } public static void modifySelectedOperationalLimitsGroup( - Branch branch, - AttributeModification modifOperationalLimitsGroup, - TwoSides side, - List reportNode) { + Branch branch, + AttributeModification modifOperationalLimitsGroup, + TwoSides side, + List reportNode) { Objects.requireNonNull(side); if (modifOperationalLimitsGroup != null) { String newSelectedOLG = modifOperationalLimitsGroup.getValue(); diff --git a/src/main/java/org/gridsuite/modification/modifications/AbstractEquipmentBase.java b/src/main/java/org/gridsuite/modification/modifications/AbstractEquipmentBase.java new file mode 100644 index 00000000..5cddffb6 --- /dev/null +++ b/src/main/java/org/gridsuite/modification/modifications/AbstractEquipmentBase.java @@ -0,0 +1,31 @@ +/* + Copyright (c) 2026, 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/. + */ +package org.gridsuite.modification.modifications; + +import lombok.Getter; +import lombok.NoArgsConstructor; +import lombok.Setter; +import org.gridsuite.modification.dto.FreePropertyInfos; + +import java.util.List; + +/** + * @author Joris Mancini + */ +@Setter +@Getter +@NoArgsConstructor +public abstract class AbstractEquipmentBase extends AbstractModification { + + protected String equipmentId; + protected List properties; + + protected AbstractEquipmentBase(String equipmentId, List properties) { + this.equipmentId = equipmentId; + this.properties = properties; + } +} diff --git a/src/main/java/org/gridsuite/modification/modifications/AbstractEquipmentCreation.java b/src/main/java/org/gridsuite/modification/modifications/AbstractEquipmentCreation.java new file mode 100644 index 00000000..eb59b5b3 --- /dev/null +++ b/src/main/java/org/gridsuite/modification/modifications/AbstractEquipmentCreation.java @@ -0,0 +1,28 @@ +/* + Copyright (c) 2026, 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/. + */ +package org.gridsuite.modification.modifications; + +import lombok.Getter; +import lombok.Setter; +import org.gridsuite.modification.dto.FreePropertyInfos; + +import java.util.List; + +/** + * @author Joris Mancini + */ +@Setter +@Getter +public abstract class AbstractEquipmentCreation extends AbstractEquipmentBase { + + protected String equipmentName; + + protected AbstractEquipmentCreation(String equipmentId, List properties, String equipmentName) { + super(equipmentId, properties); + this.equipmentName = equipmentName; + } +} diff --git a/src/main/java/org/gridsuite/modification/modifications/AbstractEquipmentModification.java b/src/main/java/org/gridsuite/modification/modifications/AbstractEquipmentModification.java new file mode 100644 index 00000000..8b75bf6c --- /dev/null +++ b/src/main/java/org/gridsuite/modification/modifications/AbstractEquipmentModification.java @@ -0,0 +1,31 @@ +/* + Copyright (c) 2026, 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/. + */ +package org.gridsuite.modification.modifications; + +import lombok.Getter; +import lombok.NoArgsConstructor; +import lombok.Setter; +import org.gridsuite.modification.dto.AttributeModification; +import org.gridsuite.modification.dto.FreePropertyInfos; + +import java.util.List; + +/** + * @author Joris Mancini + */ +@Setter +@Getter +@NoArgsConstructor +public abstract class AbstractEquipmentModification extends AbstractEquipmentBase { + + protected AttributeModification equipmentName; + + protected AbstractEquipmentModification(String equipmentId, List properties, AttributeModification equipmentName) { + super(equipmentId, properties); + this.equipmentName = equipmentName; + } +} diff --git a/src/main/java/org/gridsuite/modification/modifications/AbstractInjectionCreation.java b/src/main/java/org/gridsuite/modification/modifications/AbstractInjectionCreation.java new file mode 100644 index 00000000..c5a7f2f1 --- /dev/null +++ b/src/main/java/org/gridsuite/modification/modifications/AbstractInjectionCreation.java @@ -0,0 +1,42 @@ +/* + Copyright (c) 2026, 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/. + */ +package org.gridsuite.modification.modifications; + +import com.powsybl.iidm.network.extensions.ConnectablePosition; +import lombok.Getter; +import lombok.Setter; +import org.gridsuite.modification.dto.FreePropertyInfos; + +import java.util.List; + +/** + * @author Joris Mancini + */ +@Setter +@Getter +public abstract class AbstractInjectionCreation extends AbstractEquipmentCreation implements InjectionCreation { + + protected String voltageLevelId; + protected String busOrBusbarSectionId; + protected String connectionName; + protected ConnectablePosition.Direction connectionDirection; + protected Integer connectionPosition; + protected boolean terminalConnected; + + protected AbstractInjectionCreation(String equipmentId, List properties, String equipmentName, + String voltageLevelId, String busOrBusbarSectionId, String connectionName, + ConnectablePosition.Direction connectionDirection, Integer connectionPosition, + boolean terminalConnected) { + super(equipmentId, properties, equipmentName); + this.voltageLevelId = voltageLevelId; + this.busOrBusbarSectionId = busOrBusbarSectionId; + this.connectionName = connectionName; + this.connectionDirection = connectionDirection; + this.connectionPosition = connectionPosition; + this.terminalConnected = terminalConnected; + } +} diff --git a/src/main/java/org/gridsuite/modification/modifications/AbstractInjectionModification.java b/src/main/java/org/gridsuite/modification/modifications/AbstractInjectionModification.java index a678be86..2a7a09d6 100644 --- a/src/main/java/org/gridsuite/modification/modifications/AbstractInjectionModification.java +++ b/src/main/java/org/gridsuite/modification/modifications/AbstractInjectionModification.java @@ -8,21 +8,61 @@ import com.powsybl.commons.report.ReportNode; import com.powsybl.iidm.network.Injection; -import org.gridsuite.modification.dto.InjectionModificationInfos; +import com.powsybl.iidm.network.extensions.ConnectablePosition; +import lombok.Getter; +import lombok.NoArgsConstructor; +import lombok.Setter; +import org.gridsuite.modification.dto.AttributeModification; +import org.gridsuite.modification.dto.FreePropertyInfos; import org.gridsuite.modification.utils.MeasurementUtils; +import java.util.List; + /** - * @author Ayoub LABIDI + * @author Joris Mancini */ -public abstract class AbstractInjectionModification extends AbstractModification { +@Getter +@Setter +@NoArgsConstructor +public abstract class AbstractInjectionModification extends AbstractEquipmentModification implements InjectionModification { - protected final InjectionModificationInfos modificationInfos; + protected AttributeModification voltageLevelId; + protected AttributeModification busOrBusbarSectionId; + protected AttributeModification connectionName; + protected AttributeModification connectionDirection; + protected AttributeModification connectionPosition; + protected AttributeModification terminalConnected; + protected AttributeModification pMeasurementValue; + protected AttributeModification pMeasurementValidity; + protected AttributeModification qMeasurementValue; + protected AttributeModification qMeasurementValidity; - protected AbstractInjectionModification(InjectionModificationInfos modificationInfos) { - this.modificationInfos = modificationInfos; + protected AbstractInjectionModification(String equipmentId, List properties, + AttributeModification equipmentName, + AttributeModification voltageLevelId, + AttributeModification busOrBusbarSectionId, + AttributeModification connectionName, + AttributeModification connectionDirection, + AttributeModification connectionPosition, + AttributeModification terminalConnected, + AttributeModification pMeasurementValue, + AttributeModification pMeasurementValidity, + AttributeModification qMeasurementValue, + AttributeModification qMeasurementValidity) { + super(equipmentId, properties, equipmentName); + this.voltageLevelId = voltageLevelId; + this.busOrBusbarSectionId = busOrBusbarSectionId; + this.connectionName = connectionName; + this.connectionDirection = connectionDirection; + this.connectionPosition = connectionPosition; + this.terminalConnected = terminalConnected; + this.pMeasurementValue = pMeasurementValue; + this.pMeasurementValidity = pMeasurementValidity; + this.qMeasurementValue = qMeasurementValue; + this.qMeasurementValidity = qMeasurementValidity; } protected ReportNode updateMeasurements(Injection injection, ReportNode subReportNode) { - return MeasurementUtils.applyAndBuildModificationReport(injection, modificationInfos, subReportNode); + return MeasurementUtils.applyAndBuildModificationReport(injection, this, subReportNode); } } diff --git a/src/main/java/org/gridsuite/modification/modifications/AbstractModification.java b/src/main/java/org/gridsuite/modification/modifications/AbstractModification.java index fa235b6c..8bdf9cb8 100644 --- a/src/main/java/org/gridsuite/modification/modifications/AbstractModification.java +++ b/src/main/java/org/gridsuite/modification/modifications/AbstractModification.java @@ -11,6 +11,7 @@ import com.powsybl.iidm.modification.AbstractNetworkModification; import com.powsybl.iidm.modification.topology.NamingStrategy; import com.powsybl.iidm.network.Network; +import lombok.NoArgsConstructor; import org.gridsuite.modification.IFilterService; import org.gridsuite.modification.ILoadFlowService; import org.gridsuite.modification.NetworkModificationException; @@ -18,6 +19,7 @@ /** * @author Slimane Amar */ +@NoArgsConstructor public abstract class AbstractModification extends AbstractNetworkModification { @Override diff --git a/src/main/java/org/gridsuite/modification/modifications/AbstractScaling.java b/src/main/java/org/gridsuite/modification/modifications/AbstractScaling.java index 8ff35f5f..010a227a 100644 --- a/src/main/java/org/gridsuite/modification/modifications/AbstractScaling.java +++ b/src/main/java/org/gridsuite/modification/modifications/AbstractScaling.java @@ -10,12 +10,16 @@ import com.powsybl.commons.report.TypedValue; import com.powsybl.iidm.modification.scalable.Scalable; import com.powsybl.iidm.network.Network; +import lombok.Getter; +import lombok.Setter; import org.gridsuite.modification.IFilterService; import org.gridsuite.modification.ILoadFlowService; import org.gridsuite.modification.NetworkModificationException; +import org.gridsuite.modification.VariationType; import org.gridsuite.modification.dto.*; import org.gridsuite.modification.utils.ModificationUtils; import org.springframework.util.CollectionUtils; +import java.util.List; import java.util.Map; import java.util.Set; import java.util.UUID; @@ -27,13 +31,19 @@ /** * @author bendaamerahm */ +@Setter +@Getter public abstract class AbstractScaling extends AbstractModification { - protected final ScalingInfos scalingInfos; + protected List variations; + protected VariationType variationType; + protected NetworkModificationException.Type errorType; protected IFilterService filterService; - protected AbstractScaling(ScalingInfos scalingInfos) { - this.scalingInfos = scalingInfos; + protected AbstractScaling(List variations, VariationType variationType, NetworkModificationException.Type errorType) { + this.variations = variations; + this.variationType = variationType; + this.errorType = errorType; } @Override @@ -44,17 +54,17 @@ public void initApplicationContext(IFilterService filterService, ILoadFlowServic @Override public void apply(Network network, ReportNode subReportNode) { // collect all filters from all variations - var filters = scalingInfos.getVariations().stream() + var filters = variations.stream() .flatMap(v -> v.getFilters().stream()) .filter(distinctByKey(FilterInfos::getId)) .collect(Collectors.toMap(FilterInfos::getId, FilterInfos::getName)); - Map exportFilters = ModificationUtils.getUuidFilterEquipmentsMap(filterService, network, subReportNode, filters, scalingInfos.getErrorType()); + Map exportFilters = ModificationUtils.getUuidFilterEquipmentsMap(filterService, network, subReportNode, filters, errorType); if (exportFilters != null) { ModificationUtils.logWrongEquipmentsIdsFilters(subReportNode, exportFilters, filters); // apply variations - scalingInfos.getVariations().forEach(variation -> { + variations.forEach(variation -> { Set identifiableAttributes = ModificationUtils.getIdentifiableAttributes(exportFilters, variation.getFilters(), subReportNode); if (CollectionUtils.isEmpty(identifiableAttributes)) { @@ -89,7 +99,7 @@ private void applyVariation(Network network, applyStackingUpVariation(network, subReportNode, identifiableAttributes, variation); break; default: - throw new NetworkModificationException(scalingInfos.getErrorType(), String.format("This variation mode is not supported : %s", variation.getVariationMode().name())); + throw new NetworkModificationException(errorType, String.format("This variation mode is not supported : %s", variation.getVariationMode().name())); } } diff --git a/src/main/java/org/gridsuite/modification/modifications/BalancesAdjustmentModification.java b/src/main/java/org/gridsuite/modification/modifications/BalancesAdjustmentModification.java index 7fd8ebad..3d4e8f53 100644 --- a/src/main/java/org/gridsuite/modification/modifications/BalancesAdjustmentModification.java +++ b/src/main/java/org/gridsuite/modification/modifications/BalancesAdjustmentModification.java @@ -19,7 +19,7 @@ import com.powsybl.loadflow.LoadFlow; import com.powsybl.loadflow.LoadFlowParameters; import com.powsybl.openloadflow.OpenLoadFlowParameters; -import lombok.SneakyThrows; +import lombok.*; import org.gridsuite.modification.IFilterService; import org.gridsuite.modification.ILoadFlowService; import org.gridsuite.modification.dto.*; @@ -28,6 +28,7 @@ import java.util.HashSet; import java.util.List; +import java.util.UUID; import java.util.stream.Collectors; import java.util.stream.Stream; @@ -36,15 +37,42 @@ /** * @author Joris Mancini */ +@Getter +@Setter public class BalancesAdjustmentModification extends AbstractModification { private static final Logger LOGGER = LoggerFactory.getLogger(BalancesAdjustmentModification.class); - private final BalancesAdjustmentModificationInfos balancesAdjustmentModificationInfos; + private List areas; + private int maxNumberIterations; + private double thresholdNetPosition; + private List countriesToBalance; + private LoadFlowParameters.BalanceType balanceType; + private boolean withLoadFlow; + private UUID loadFlowParametersId; + private boolean withRatioTapChangers; + private boolean subtractLoadFlowBalancing; protected ILoadFlowService loadFlowService; - public BalancesAdjustmentModification(BalancesAdjustmentModificationInfos balancesAdjustmentModificationInfos) { - this.balancesAdjustmentModificationInfos = balancesAdjustmentModificationInfos; + @Builder + public BalancesAdjustmentModification(List areas, + int maxNumberIterations, + double thresholdNetPosition, + List countriesToBalance, + LoadFlowParameters.BalanceType balanceType, + boolean withLoadFlow, + UUID loadFlowParametersId, + boolean withRatioTapChangers, + boolean subtractLoadFlowBalancing) { + this.areas = areas; + this.maxNumberIterations = maxNumberIterations; + this.thresholdNetPosition = thresholdNetPosition; + this.countriesToBalance = countriesToBalance; + this.balanceType = balanceType; + this.withLoadFlow = withLoadFlow; + this.loadFlowParametersId = loadFlowParametersId; + this.withRatioTapChangers = withRatioTapChangers; + this.subtractLoadFlowBalancing = subtractLoadFlowBalancing; } @Override @@ -60,9 +88,9 @@ public String getName() { private BalanceComputationParameters createBalanceComputationParameters(ReportNode reportNode) { BalanceComputationParameters parameters = BalanceComputationParameters.load(); parameters.getScalingParameters().setPriority(ScalingParameters.Priority.RESPECT_OF_VOLUME_ASKED); - parameters.setWithLoadFlow(balancesAdjustmentModificationInfos.isWithLoadFlow()); + parameters.setWithLoadFlow(withLoadFlow); - if (!balancesAdjustmentModificationInfos.isWithLoadFlow()) { + if (!withLoadFlow) { return parameters; } @@ -80,24 +108,24 @@ private BalanceComputationParameters createBalanceComputationParameters(ReportNo } private LoadFlowParametersInfos getLoadFlowParametersInfos(ReportNode reportNode) { - if (balancesAdjustmentModificationInfos.getLoadFlowParametersId() == null) { + if (loadFlowParametersId == null) { reportUsingDefaultParameters(reportNode, "Load flow parameters ID is null"); return null; } LoadFlowParametersInfos loadFlowParametersInfos = loadFlowService.getLoadFlowParametersInfos( - balancesAdjustmentModificationInfos.getLoadFlowParametersId() + loadFlowParametersId ); if (loadFlowParametersInfos == null) { reportUsingDefaultParameters(reportNode, - "Load flow parameters with id " + balancesAdjustmentModificationInfos.getLoadFlowParametersId() + " not found"); + "Load flow parameters with id " + loadFlowParametersId + " not found"); return null; } if (loadFlowParametersInfos.getProvider() == null) { reportUsingDefaultParameters(reportNode, - "Load flow provider is null in parameters with id " + balancesAdjustmentModificationInfos.getLoadFlowParametersId()); + "Load flow provider is null in parameters with id " + loadFlowParametersId); return null; } @@ -115,15 +143,15 @@ private void reportUsingDefaultParameters(ReportNode reportNode, String reason) } private void overrideBalanceComputationParameters(BalanceComputationParameters parameters) { - parameters.setMaxNumberIterations(balancesAdjustmentModificationInfos.getMaxNumberIterations()); - parameters.setThresholdNetPosition(balancesAdjustmentModificationInfos.getThresholdNetPosition()); + parameters.setMaxNumberIterations(maxNumberIterations); + parameters.setThresholdNetPosition(thresholdNetPosition); parameters.setMismatchMode(BalanceComputationParameters.MismatchMode.MAX); - parameters.setSubtractLoadFlowBalancing(balancesAdjustmentModificationInfos.isSubtractLoadFlowBalancing()); + parameters.setSubtractLoadFlowBalancing(subtractLoadFlowBalancing); parameters.getLoadFlowParameters().setCountriesToBalance( - new HashSet<>(balancesAdjustmentModificationInfos.getCountriesToBalance()) + new HashSet<>(countriesToBalance) ); - parameters.getLoadFlowParameters().setBalanceType(balancesAdjustmentModificationInfos.getBalanceType()); - parameters.getLoadFlowParameters().setTransformerVoltageControlOn(balancesAdjustmentModificationInfos.isWithRatioTapChangers()); + parameters.getLoadFlowParameters().setBalanceType(balanceType); + parameters.getLoadFlowParameters().setTransformerVoltageControlOn(withRatioTapChangers); parameters.getLoadFlowParameters().getExtension(OpenLoadFlowParameters.class) .setSlackDistributionFailureBehavior(OpenLoadFlowParameters.SlackDistributionFailureBehavior.FAIL); @@ -135,10 +163,10 @@ public void apply(Network network, NamingStrategy namingStrategy, ReportNode rep BalanceComputationParameters parameters = createBalanceComputationParameters(reportNode); - List areas = createBalanceComputationAreas(network, reportNode); + List balanceComputationAreas = createBalanceComputationAreas(network, reportNode); BalanceComputation balanceComputation = new BalanceComputationFactoryImpl() - .create(areas, LoadFlow.find(), new LocalComputationManager(Runnable::run)); + .create(balanceComputationAreas, LoadFlow.find(), new LocalComputationManager(Runnable::run)); balanceComputation .run(network, network.getVariantManager().getWorkingVariantId(), parameters, reportNode) @@ -146,8 +174,7 @@ public void apply(Network network, NamingStrategy namingStrategy, ReportNode rep } private List createBalanceComputationAreas(Network network, ReportNode reportNode) { - return balancesAdjustmentModificationInfos - .getAreas() + return areas .stream() .map(areaInfos -> new BalanceComputationArea( diff --git a/src/main/java/org/gridsuite/modification/modifications/BatteryCreation.java b/src/main/java/org/gridsuite/modification/modifications/BatteryCreation.java index c3eea688..de9f89e3 100644 --- a/src/main/java/org/gridsuite/modification/modifications/BatteryCreation.java +++ b/src/main/java/org/gridsuite/modification/modifications/BatteryCreation.java @@ -11,8 +11,10 @@ import com.powsybl.iidm.network.*; import com.powsybl.iidm.network.extensions.ActivePowerControlAdder; import com.powsybl.iidm.network.extensions.BatteryShortCircuitAdder; +import com.powsybl.iidm.network.extensions.ConnectablePosition; +import lombok.*; import org.gridsuite.modification.NetworkModificationException; -import org.gridsuite.modification.dto.BatteryCreationInfos; +import org.gridsuite.modification.dto.*; import org.gridsuite.modification.utils.ModificationUtils; import org.gridsuite.modification.utils.PropertiesUtils; @@ -27,52 +29,83 @@ /** * @author Ghazwa Rehili */ -public class BatteryCreation extends AbstractModification { - - private final BatteryCreationInfos modificationInfos; - - public BatteryCreation(BatteryCreationInfos modificationInfos) { - this.modificationInfos = modificationInfos; +@Setter +@Getter +public class BatteryCreation extends AbstractInjectionCreation implements ReactiveLimitsHolderInfos { + + private double minP; + private double maxP; + private Double minQ; + private Double maxQ; + private List reactiveCapabilityCurvePoints; + private double targetP; + private Double targetQ; + private Boolean participate; + private Float droop; + private Double directTransX; + private Double stepUpTransformerX; + private Boolean reactiveCapabilityCurve; + + @Builder + public BatteryCreation(String equipmentId, List properties, String equipmentName, + String voltageLevelId, String busOrBusbarSectionId, String connectionName, + ConnectablePosition.Direction connectionDirection, Integer connectionPosition, + boolean terminalConnected, double minP, double maxP, Double minQ, Double maxQ, + List reactiveCapabilityCurvePoints, + double targetP, Double targetQ, Boolean participate, Float droop, Double directTransX, + Double stepUpTransformerX, Boolean reactiveCapabilityCurve) { + super(equipmentId, properties, equipmentName, voltageLevelId, busOrBusbarSectionId, connectionName, connectionDirection, connectionPosition, terminalConnected); + this.minP = minP; + this.maxP = maxP; + this.minQ = minQ; + this.maxQ = maxQ; + this.reactiveCapabilityCurvePoints = reactiveCapabilityCurvePoints; + this.targetP = targetP; + this.targetQ = targetQ; + this.participate = participate; + this.droop = droop; + this.directTransX = directTransX; + this.stepUpTransformerX = stepUpTransformerX; + this.reactiveCapabilityCurve = reactiveCapabilityCurve; } @Override public void check(Network network) throws NetworkModificationException { - if (network.getBattery(modificationInfos.getEquipmentId()) != null) { - throw new NetworkModificationException(BATTERY_ALREADY_EXISTS, modificationInfos.getEquipmentId()); + if (network.getBattery(equipmentId) != null) { + throw new NetworkModificationException(BATTERY_ALREADY_EXISTS, equipmentId); } - String errorMessage = "Battery '" + modificationInfos.getEquipmentId() + "' : "; + String errorMessage = "Battery '" + equipmentId + "' : "; // check connectivity ModificationUtils.getInstance() - .controlConnectivity(network, modificationInfos.getVoltageLevelId(), - modificationInfos.getBusOrBusbarSectionId()); + .controlConnectivity(network, voltageLevelId, busOrBusbarSectionId); // check reactive limits - ModificationUtils.getInstance().checkReactiveLimitsCreation(modificationInfos, - modificationInfos.getErrorType(), - modificationInfos.getEquipmentId(), + ModificationUtils.getInstance().checkReactiveLimitsCreation(this, + CREATE_BATTERY_ERROR, + equipmentId, "Battery"); - ModificationUtils.getInstance().checkActivePowerControl(modificationInfos.getParticipate(), - modificationInfos.getDroop(), CREATE_BATTERY_ERROR, String.format(ERROR_MESSAGE, modificationInfos.getEquipmentId())); - checkIsPercentage(errorMessage, modificationInfos.getDroop(), CREATE_BATTERY_ERROR, "Droop"); + ModificationUtils.getInstance().checkActivePowerControl(participate, + droop, CREATE_BATTERY_ERROR, String.format(ERROR_MESSAGE, equipmentId)); + checkIsPercentage(errorMessage, droop, CREATE_BATTERY_ERROR, "Droop"); } @Override public void apply(Network network, ReportNode subReportNode) { // create the battery in the network - VoltageLevel voltageLevel = ModificationUtils.getInstance().getVoltageLevel(network, modificationInfos.getVoltageLevelId()); + VoltageLevel voltageLevel = ModificationUtils.getInstance().getVoltageLevel(network, voltageLevelId); if (voltageLevel.getTopologyKind() == TopologyKind.NODE_BREAKER) { - createBatteryInNodeBreaker(voltageLevel, modificationInfos, network, subReportNode); + createBatteryInNodeBreaker(voltageLevel, network, subReportNode); } else { - createBatteryInBusBreaker(voltageLevel, modificationInfos, subReportNode); + createBatteryInBusBreaker(voltageLevel, subReportNode); } - if (!modificationInfos.isTerminalConnected()) { - network.getBattery(modificationInfos.getEquipmentId()).getTerminal().disconnect(); + if (!terminalConnected) { + network.getBattery(equipmentId).getTerminal().disconnect(); } // properties - Battery battery = network.getBattery(modificationInfos.getEquipmentId()); - PropertiesUtils.applyProperties(battery, subReportNode, modificationInfos.getProperties(), "network.modification.BatteryProperties"); + Battery battery = network.getBattery(equipmentId); + PropertiesUtils.applyProperties(battery, subReportNode, properties, "network.modification.BatteryProperties"); } @Override @@ -80,83 +113,83 @@ public String getName() { return "BatteryCreation"; } - private void createBatteryInNodeBreaker(VoltageLevel voltageLevel, BatteryCreationInfos batteryCreationInfos, Network network, ReportNode subReportNode) { - BatteryAdder batteryAdder = createBatteryAdderInNodeBreaker(voltageLevel, batteryCreationInfos); - createInjectionInNodeBreaker(voltageLevel, batteryCreationInfos, network, batteryAdder, subReportNode); - var battery = ModificationUtils.getInstance().getBattery(network, batteryCreationInfos.getEquipmentId()); - addExtensionsToBattery(batteryCreationInfos, battery, subReportNode); + private void createBatteryInNodeBreaker(VoltageLevel voltageLevel, Network network, ReportNode subReportNode) { + BatteryAdder batteryAdder = createBatteryAdderInNodeBreaker(voltageLevel); + createInjectionInNodeBreaker(voltageLevel, this, network, batteryAdder, subReportNode); + var battery = ModificationUtils.getInstance().getBattery(network, equipmentId); + addExtensionsToBattery(battery, subReportNode); } - private BatteryAdder createBatteryAdderInNodeBreaker(VoltageLevel voltageLevel, BatteryCreationInfos batteryCreationInfos) { + private BatteryAdder createBatteryAdderInNodeBreaker(VoltageLevel voltageLevel) { return voltageLevel.newBattery() - .setId(batteryCreationInfos.getEquipmentId()) - .setName(batteryCreationInfos.getEquipmentName()) - .setMinP(batteryCreationInfos.getMinP()) - .setMaxP(batteryCreationInfos.getMaxP()) - .setTargetP(batteryCreationInfos.getTargetP()) - .setTargetQ(nanIfNull(batteryCreationInfos.getTargetQ())); + .setId(equipmentId) + .setName(equipmentName) + .setMinP(minP) + .setMaxP(maxP) + .setTargetP(targetP) + .setTargetQ(nanIfNull(targetQ)); } - private void createBatteryInBusBreaker(VoltageLevel voltageLevel, BatteryCreationInfos batteryCreationInfos, ReportNode subReportNode) { - Bus bus = ModificationUtils.getInstance().getBusBreakerBus(voltageLevel, batteryCreationInfos.getBusOrBusbarSectionId()); + private void createBatteryInBusBreaker(VoltageLevel voltageLevel, ReportNode subReportNode) { + Bus bus = ModificationUtils.getInstance().getBusBreakerBus(voltageLevel, busOrBusbarSectionId); // creating the battery Battery battery = voltageLevel.newBattery() .setBus(bus.getId()) .setConnectableBus(bus.getId()) - .setId(batteryCreationInfos.getEquipmentId()) - .setName(batteryCreationInfos.getEquipmentName()) - .setMinP(batteryCreationInfos.getMinP()) - .setMaxP(batteryCreationInfos.getMaxP()) - .setTargetP(batteryCreationInfos.getTargetP()) - .setTargetQ(nanIfNull(batteryCreationInfos.getTargetQ())) + .setId(equipmentId) + .setName(equipmentName) + .setMinP(minP) + .setMaxP(maxP) + .setTargetP(targetP) + .setTargetQ(nanIfNull(targetQ)) .add(); - addExtensionsToBattery(batteryCreationInfos, battery, subReportNode); + addExtensionsToBattery(battery, subReportNode); subReportNode.newReportNode() .withMessageTemplate("network.modification.batteryCreated") - .withUntypedValue("id", modificationInfos.getEquipmentId()) + .withUntypedValue("id", equipmentId) .withSeverity(TypedValue.INFO_SEVERITY) .add(); } - private void addExtensionsToBattery(BatteryCreationInfos batteryCreationInfos, Battery battery, ReportNode subReportNode) { - if (batteryCreationInfos.getEquipmentName() != null) { - ModificationUtils.getInstance().reportElementaryCreation(subReportNode, batteryCreationInfos.getEquipmentName(), "Name"); + private void addExtensionsToBattery(Battery battery, ReportNode subReportNode) { + if (equipmentName != null) { + ModificationUtils.getInstance().reportElementaryCreation(subReportNode, equipmentName, "Name"); } - reportInjectionCreationConnectivity(batteryCreationInfos, subReportNode); - ReportNode subReportNodeLimits = reportBatteryActiveLimits(batteryCreationInfos, subReportNode); - ModificationUtils.getInstance().createReactiveLimits(batteryCreationInfos, battery, subReportNodeLimits); - ReportNode subReportNodeSetpoints = reportBatterySetPoints(batteryCreationInfos, subReportNode); + reportInjectionCreationConnectivity(this, subReportNode); + ReportNode subReportNodeLimits = reportBatteryActiveLimits(subReportNode); + ModificationUtils.getInstance().createReactiveLimits(this, battery, subReportNodeLimits); + ReportNode subReportNodeSetpoints = reportBatterySetPoints(subReportNode); ModificationUtils.getInstance().createNewActivePowerControlForInjectionCreation(battery.newExtension(ActivePowerControlAdder.class), - batteryCreationInfos.getParticipate(), - batteryCreationInfos.getDroop(), + participate, + droop, subReportNodeSetpoints); - ModificationUtils.getInstance().createShortCircuitExtension(batteryCreationInfos.getStepUpTransformerX(), - batteryCreationInfos.getDirectTransX(), batteryCreationInfos.getEquipmentId(), + ModificationUtils.getInstance().createShortCircuitExtension(stepUpTransformerX, + directTransX, equipmentId, battery.newExtension(BatteryShortCircuitAdder.class), subReportNode, "battery"); } - private ReportNode reportBatterySetPoints(BatteryCreationInfos batteryCreationInfos, ReportNode subReportNode) { + private ReportNode reportBatterySetPoints(ReportNode subReportNode) { List setPointReports = new ArrayList<>(); setPointReports.add(ModificationUtils.getInstance() - .buildCreationReport(batteryCreationInfos.getTargetP(), "Active power")); - if (batteryCreationInfos.getTargetQ() != null) { + .buildCreationReport(targetP, "Active power")); + if (targetQ != null) { setPointReports.add(ModificationUtils.getInstance() - .buildCreationReport(batteryCreationInfos.getTargetQ(), "Reactive power")); + .buildCreationReport(targetQ, "Reactive power")); } return ModificationUtils.getInstance().reportModifications(subReportNode, setPointReports, "network.modification.SetPointCreated"); } - private ReportNode reportBatteryActiveLimits(BatteryCreationInfos batteryCreationInfos, ReportNode subReportNode) { + private ReportNode reportBatteryActiveLimits(ReportNode subReportNode) { ReportNode subReportNodeLimits = subReportNode.newReportNode().withMessageTemplate("network.modification.limits").add(); List limitsReports = new ArrayList<>(); limitsReports.add(ModificationUtils.getInstance().buildCreationReport( - batteryCreationInfos.getMinP(), "Min active power")); + minP, "Min active power")); limitsReports.add(ModificationUtils.getInstance().buildCreationReport( - batteryCreationInfos.getMaxP(), "Max active power")); + maxP, "Max active power")); ModificationUtils.getInstance().reportModifications(subReportNodeLimits, limitsReports, "network.modification.ActiveLimitsCreated"); return subReportNodeLimits; } diff --git a/src/main/java/org/gridsuite/modification/modifications/BatteryModification.java b/src/main/java/org/gridsuite/modification/modifications/BatteryModification.java index 144e9092..fd8c2009 100644 --- a/src/main/java/org/gridsuite/modification/modifications/BatteryModification.java +++ b/src/main/java/org/gridsuite/modification/modifications/BatteryModification.java @@ -10,9 +10,12 @@ import com.powsybl.commons.report.TypedValue; import com.powsybl.iidm.network.*; import com.powsybl.iidm.network.extensions.*; +import lombok.Builder; +import lombok.Getter; +import lombok.Setter; import org.gridsuite.modification.NetworkModificationException; import org.gridsuite.modification.dto.AttributeModification; -import org.gridsuite.modification.dto.BatteryModificationInfos; +import org.gridsuite.modification.dto.FreePropertyInfos; import org.gridsuite.modification.dto.ReactiveCapabilityCurvePointsInfos; import org.gridsuite.modification.utils.ModificationUtils; import org.gridsuite.modification.utils.PropertiesUtils; @@ -27,39 +30,86 @@ /** * @author Ghazwa Rehili */ +@Getter +@Setter public class BatteryModification extends AbstractInjectionModification { public static final String ERROR_MESSAGE = "Battery '%s' : "; - public BatteryModification(BatteryModificationInfos modificationInfos) { - super(modificationInfos); + private AttributeModification minP; + private AttributeModification maxP; + private AttributeModification targetP; + private AttributeModification targetQ; + private AttributeModification participate; + private AttributeModification droop; + private AttributeModification directTransX; + private AttributeModification stepUpTransformerX; + private AttributeModification minQ; + private AttributeModification maxQ; + private List reactiveCapabilityCurvePoints; + private AttributeModification reactiveCapabilityCurve; + + @Builder + public BatteryModification(String equipmentId, List properties, + AttributeModification equipmentName, + AttributeModification voltageLevelId, + AttributeModification busOrBusbarSectionId, + AttributeModification connectionName, + AttributeModification connectionDirection, + AttributeModification connectionPosition, + AttributeModification terminalConnected, + AttributeModification pMeasurementValue, + AttributeModification pMeasurementValidity, + AttributeModification qMeasurementValue, + AttributeModification qMeasurementValidity, AttributeModification minP, + AttributeModification maxP, AttributeModification targetP, + AttributeModification targetQ, AttributeModification participate, + AttributeModification droop, AttributeModification directTransX, + AttributeModification stepUpTransformerX, AttributeModification minQ, + AttributeModification maxQ, + List reactiveCapabilityCurvePoints, + AttributeModification reactiveCapabilityCurve) { + super(equipmentId, properties, equipmentName, voltageLevelId, busOrBusbarSectionId, connectionName, + connectionDirection, connectionPosition, terminalConnected, pMeasurementValue, pMeasurementValidity, + qMeasurementValue, qMeasurementValidity); + this.minP = minP; + this.maxP = maxP; + this.targetP = targetP; + this.targetQ = targetQ; + this.participate = participate; + this.droop = droop; + this.directTransX = directTransX; + this.stepUpTransformerX = stepUpTransformerX; + this.minQ = minQ; + this.maxQ = maxQ; + this.reactiveCapabilityCurvePoints = reactiveCapabilityCurvePoints; + this.reactiveCapabilityCurve = reactiveCapabilityCurve; } @Override public void check(Network network) throws NetworkModificationException { - if (modificationInfos == null) { + if (equipmentId == null) { throw new NetworkModificationException(MODIFY_BATTERY_ERROR, "Missing required attributes to modify the equipment"); } - BatteryModificationInfos batteryModificationInfos = (BatteryModificationInfos) modificationInfos; - Battery battery = ModificationUtils.getInstance().getBattery(network, batteryModificationInfos.getEquipmentId()); - String errorMessage = "Battery '" + batteryModificationInfos.getEquipmentId() + "' : "; - ModificationUtils.getInstance().checkVoltageLevelModification(network, batteryModificationInfos.getVoltageLevelId(), - batteryModificationInfos.getBusOrBusbarSectionId(), battery.getTerminal()); - ModificationUtils.getInstance().checkReactiveLimit(battery, batteryModificationInfos.getMinQ(), batteryModificationInfos.getMaxQ(), - batteryModificationInfos.getReactiveCapabilityCurvePoints(), MODIFY_BATTERY_ERROR, errorMessage); - checkActivePowerZeroOrBetweenMinAndMaxActivePowerBattery(batteryModificationInfos, battery, MODIFY_BATTERY_ERROR, errorMessage); - if (batteryModificationInfos.getDroop() != null) { - checkIsPercentage(errorMessage, batteryModificationInfos.getDroop().getValue(), MODIFY_BATTERY_ERROR, "Droop"); + Battery battery = ModificationUtils.getInstance().getBattery(network, equipmentId); + String errorMessage = "Battery '" + equipmentId + "' : "; + ModificationUtils.getInstance().checkVoltageLevelModification(network, voltageLevelId, + busOrBusbarSectionId, battery.getTerminal()); + ModificationUtils.getInstance().checkReactiveLimit(battery, minQ, maxQ, + reactiveCapabilityCurvePoints, MODIFY_BATTERY_ERROR, errorMessage); + checkActivePowerZeroOrBetweenMinAndMaxActivePowerBattery(battery, MODIFY_BATTERY_ERROR, errorMessage); + if (droop != null) { + checkIsPercentage(errorMessage, droop.getValue(), MODIFY_BATTERY_ERROR, "Droop"); } } - private void checkActivePowerZeroOrBetweenMinAndMaxActivePowerBattery(BatteryModificationInfos modificationInfos, Battery battery, NetworkModificationException.Type exceptionType, + private void checkActivePowerZeroOrBetweenMinAndMaxActivePowerBattery(Battery battery, NetworkModificationException.Type exceptionType, String errorMessage) { ModificationUtils.getInstance().checkActivePowerZeroOrBetweenMinAndMaxActivePower( - modificationInfos.getTargetP(), - modificationInfos.getMinP(), - modificationInfos.getMaxP(), + targetP, + minP, + maxP, battery.getMinP(), battery.getMaxP(), battery.getTargetP(), @@ -70,7 +120,7 @@ private void checkActivePowerZeroOrBetweenMinAndMaxActivePowerBattery(BatteryMod @Override public void apply(Network network, ReportNode subReportNode) { - Battery battery = ModificationUtils.getInstance().getBattery(network, modificationInfos.getEquipmentId()); + Battery battery = ModificationUtils.getInstance().getBattery(network, equipmentId); // modify the battery in the network modifyBattery(battery, subReportNode); } @@ -81,31 +131,30 @@ public String getName() { } private void modifyBattery(Battery battery, ReportNode subReportNode) { - BatteryModificationInfos batteryModificationInfos = (BatteryModificationInfos) modificationInfos; subReportNode.newReportNode() .withMessageTemplate("network.modification.batteryModification") - .withUntypedValue("id", batteryModificationInfos.getEquipmentId()) + .withUntypedValue("id", equipmentId) .withSeverity(TypedValue.INFO_SEVERITY) .add(); - if (batteryModificationInfos.getEquipmentName() != null && batteryModificationInfos.getEquipmentName().getValue() != null) { - ModificationUtils.getInstance().applyElementaryModifications(battery::setName, () -> battery.getOptionalName().orElse("No value"), batteryModificationInfos.getEquipmentName(), + if (equipmentName != null && equipmentName.getValue() != null) { + ModificationUtils.getInstance().applyElementaryModifications(battery::setName, () -> battery.getOptionalName().orElse("No value"), equipmentName, subReportNode, "Name"); } - modifyBatteryVoltageLevelBusOrBusBarSectionAttributes(batteryModificationInfos, battery, subReportNode); - modifyBatteryLimitsAttributes(batteryModificationInfos, battery, subReportNode); + modifyBatteryVoltageLevelBusOrBusBarSectionAttributes(battery, subReportNode); + modifyBatteryLimitsAttributes(battery, subReportNode); modifyBatterySetpointsAttributes( - batteryModificationInfos.getTargetP(), batteryModificationInfos.getTargetQ(), - batteryModificationInfos.getParticipate(), batteryModificationInfos.getDroop(), + targetP, targetQ, + participate, droop, battery, subReportNode); - modifyBatteryConnectivityAttributes(batteryModificationInfos, battery, subReportNode); + modifyBatteryConnectivityAttributes(battery, subReportNode); updateMeasurements(battery, subReportNode); - ModificationUtils.getInstance().modifyShortCircuitExtension(batteryModificationInfos.getDirectTransX(), - batteryModificationInfos.getStepUpTransformerX(), + ModificationUtils.getInstance().modifyShortCircuitExtension(directTransX, + stepUpTransformerX, battery.getExtension(BatteryShortCircuit.class), () -> battery.newExtension(BatteryShortCircuitAdder.class), subReportNode); - PropertiesUtils.applyProperties(battery, subReportNode, batteryModificationInfos.getProperties(), "network.modification.BatteryProperties"); + PropertiesUtils.applyProperties(battery, subReportNode, properties, "network.modification.BatteryProperties"); } public static void modifyBatterySetpointsAttributes(AttributeModification targetP, @@ -129,30 +178,26 @@ public static void modifyBatterySetpointsAttributes(AttributeModification modificationPoints = modificationInfos.getReactiveCapabilityCurvePoints(); Collection points = battery.getReactiveLimits().getKind() == ReactiveLimitsKind.CURVE ? battery.getReactiveLimits(ReactiveCapabilityCurve.class).getPoints( ) : List.of(); - ModificationUtils.getInstance().modifyReactiveCapabilityCurvePoints(points, modificationPoints, adder, subReportNode, subReportNodeLimits); + ModificationUtils.getInstance().modifyReactiveCapabilityCurvePoints(points, reactiveCapabilityCurvePoints, adder, subReportNode, subReportNodeLimits); } public static ReportNode modifyBatteryActiveLimitsAttributes(AttributeModification maxP, @@ -174,16 +219,15 @@ public static ReportNode modifyBatteryActiveLimitsAttributes(AttributeModificati return subReportNodeLimits; } - private void modifyBatteryReactiveLimitsAttributes(BatteryModificationInfos modificationInfos, - Battery battery, ReportNode subReportNode, ReportNode subReportNodeLimits) { + private void modifyBatteryReactiveLimitsAttributes(Battery battery, ReportNode subReportNode, ReportNode subReportNodeLimits) { - if (modificationInfos.getReactiveCapabilityCurve() != null) { - if (Boolean.TRUE.equals(modificationInfos.getReactiveCapabilityCurve().getValue() - && modificationInfos.getReactiveCapabilityCurvePoints() != null - && !modificationInfos.getReactiveCapabilityCurvePoints().isEmpty())) { - modifyBatteryReactiveCapabilityCurvePoints(modificationInfos, battery, subReportNode, subReportNodeLimits); - } else if (Boolean.FALSE.equals(modificationInfos.getReactiveCapabilityCurve().getValue())) { - ModificationUtils.getInstance().modifyMinMaxReactiveLimits(modificationInfos.getMinQ(), modificationInfos.getMaxQ(), battery, subReportNode, subReportNodeLimits); + if (reactiveCapabilityCurve != null) { + if (Boolean.TRUE.equals(reactiveCapabilityCurve.getValue() + && reactiveCapabilityCurvePoints != null + && !reactiveCapabilityCurvePoints.isEmpty())) { + modifyBatteryReactiveCapabilityCurvePoints(battery, subReportNode, subReportNodeLimits); + } else if (Boolean.FALSE.equals(reactiveCapabilityCurve.getValue())) { + ModificationUtils.getInstance().modifyMinMaxReactiveLimits(minQ, maxQ, battery, subReportNode, subReportNodeLimits); } } } @@ -199,11 +243,9 @@ public static ReportNode modifyBatteryActivePowerControlAttributes(AttributeModi participate, droop, subReportNode, subReportNodeSetpoints, MODIFY_BATTERY_ERROR, String.format(ERROR_MESSAGE, battery.getId())); } - private ReportNode modifyBatteryConnectivityAttributes(BatteryModificationInfos modificationInfos, - Battery battery, ReportNode subReportNode) { + private ReportNode modifyBatteryConnectivityAttributes(Battery battery, ReportNode subReportNode) { ConnectablePosition connectablePosition = battery.getExtension(ConnectablePosition.class); ConnectablePositionAdder connectablePositionAdder = battery.newExtension(ConnectablePositionAdder.class); - return ModificationUtils.getInstance().modifyInjectionConnectivityAttributes(connectablePosition, connectablePositionAdder, battery, modificationInfos, subReportNode); + return ModificationUtils.getInstance().modifyInjectionConnectivityAttributes(connectablePosition, connectablePositionAdder, battery, this, subReportNode); } } - diff --git a/src/main/java/org/gridsuite/modification/modifications/ByFilterDeletion.java b/src/main/java/org/gridsuite/modification/modifications/ByFilterDeletion.java index 0aa73061..5b9cc0ab 100644 --- a/src/main/java/org/gridsuite/modification/modifications/ByFilterDeletion.java +++ b/src/main/java/org/gridsuite/modification/modifications/ByFilterDeletion.java @@ -16,10 +16,12 @@ import com.powsybl.iidm.network.HvdcLine; import com.powsybl.iidm.network.IdentifiableType; import com.powsybl.iidm.network.Network; +import lombok.Builder; +import lombok.Getter; +import lombok.Setter; import org.gridsuite.modification.IFilterService; import org.gridsuite.modification.ILoadFlowService; import org.gridsuite.modification.NetworkModificationException; -import org.gridsuite.modification.dto.ByFilterDeletionInfos; import org.gridsuite.modification.dto.FilterEquipments; import org.gridsuite.modification.dto.FilterInfos; import org.gridsuite.modification.dto.IdentifiableAttributes; @@ -27,15 +29,19 @@ import org.springframework.util.CollectionUtils; import java.util.*; import java.util.stream.Collectors; +import static org.gridsuite.modification.NetworkModificationException.Type.BY_FILTER_DELETION_ERROR; import static org.gridsuite.modification.utils.ModificationUtils.createReport; import static org.gridsuite.modification.utils.ModificationUtils.distinctByKey; /** * @author Antoine Bouhours */ +@Getter +@Setter public class ByFilterDeletion extends AbstractModification { - private final ByFilterDeletionInfos modificationInfos; + private IdentifiableType equipmentType; + private List filters; protected IFilterService filterService; @@ -51,8 +57,10 @@ public class ByFilterDeletion extends AbstractModification { IdentifiableType.STATIC_VAR_COMPENSATOR ); - public ByFilterDeletion(ByFilterDeletionInfos modificationInfos) { - this.modificationInfos = modificationInfos; + @Builder + public ByFilterDeletion(IdentifiableType equipmentType, List filters) { + this.equipmentType = equipmentType; + this.filters = filters; } @Override @@ -62,23 +70,23 @@ public void initApplicationContext(IFilterService filterService, ILoadFlowServic @Override public void apply(Network network, ReportNode subReportNode) { - var filters = modificationInfos.getFilters().stream() + var distinctFilters = filters.stream() .filter(distinctByKey(FilterInfos::getId)) .collect(Collectors.toMap(FilterInfos::getId, FilterInfos::getName)); - Map exportFilters = ModificationUtils.getUuidFilterEquipmentsMap(filterService, network, subReportNode, filters, modificationInfos.getErrorType()); + Map exportFilters = ModificationUtils.getUuidFilterEquipmentsMap(filterService, network, subReportNode, distinctFilters, BY_FILTER_DELETION_ERROR); if (exportFilters != null) { - ModificationUtils.logWrongEquipmentsIdsFilters(subReportNode, exportFilters, filters); - Set identifiableAttributes = ModificationUtils.getIdentifiableAttributes(exportFilters, modificationInfos.getFilters(), subReportNode); + ModificationUtils.logWrongEquipmentsIdsFilters(subReportNode, exportFilters, distinctFilters); + Set identifiableAttributes = ModificationUtils.getIdentifiableAttributes(exportFilters, filters, subReportNode); if (CollectionUtils.isEmpty(identifiableAttributes)) { - String filterNames = modificationInfos.getFilters().stream().map(FilterInfos::getName).collect(Collectors.joining(", ")); + String filterNames = filters.stream().map(FilterInfos::getName).collect(Collectors.joining(", ")); createReport(subReportNode, "network.modification.allFiltersWrong", Map.of("filterNames", filterNames), TypedValue.WARN_SEVERITY); } else { subReportNode.newReportNode() .withMessageTemplate("network.modification.equipmentByFilterDeleted") .withUntypedValue("nbEquipments", (long) identifiableAttributes.size()) - .withUntypedValue("type", modificationInfos.getEquipmentType().name()) + .withUntypedValue("type", equipmentType.name()) .withSeverity(TypedValue.INFO_SEVERITY) .add(); // Report node is pushed to network instance to allow deletion logs from other libraries to be added @@ -94,7 +102,7 @@ public String getName() { } private void applyFilterDeletion(Network network, ReportNode subReportNode, Set identifiableAttributes) { - IdentifiableType identifiableType = modificationInfos.getEquipmentType(); + IdentifiableType identifiableType = equipmentType; if (CONNECTABLE_TYPES.contains(identifiableType)) { identifiableAttributes.forEach(identifiableAttribute -> new RemoveFeederBay(identifiableAttribute.getId()).apply(network, true, subReportNode)); } else if (identifiableType == IdentifiableType.VOLTAGE_LEVEL) { @@ -109,7 +117,7 @@ private void applyFilterDeletion(Network network, ReportNode subReportNode, Set< } private void removeHvdcLine(Network network, ReportNode subReportNode, IdentifiableAttributes identifiableAttribute) { - HvdcLine hvdcLine = (HvdcLine) ModificationUtils.getInstance().getEquipmentByIdentifiableType(network, modificationInfos.getEquipmentType(), identifiableAttribute.getId()); + HvdcLine hvdcLine = (HvdcLine) ModificationUtils.getInstance().getEquipmentByIdentifiableType(network, equipmentType, identifiableAttribute.getId()); if (hvdcLine != null) { HvdcConverterStation converterStation1 = hvdcLine.getConverterStation1(); HvdcConverterStation converterStation2 = hvdcLine.getConverterStation2(); diff --git a/src/main/java/org/gridsuite/modification/modifications/CreateCouplingDevice.java b/src/main/java/org/gridsuite/modification/modifications/CreateCouplingDevice.java index 6c12a44e..32451026 100644 --- a/src/main/java/org/gridsuite/modification/modifications/CreateCouplingDevice.java +++ b/src/main/java/org/gridsuite/modification/modifications/CreateCouplingDevice.java @@ -7,21 +7,22 @@ package org.gridsuite.modification.modifications; import com.powsybl.commons.report.ReportNode; -import com.powsybl.iidm.modification.topology.CreateCouplingDeviceBuilder; import com.powsybl.iidm.network.Network; +import lombok.*; import org.gridsuite.modification.ModificationType; -import org.gridsuite.modification.dto.CreateCouplingDeviceInfos; /** * @author Etienne Lesot */ +@Getter +@Setter +@AllArgsConstructor +@Builder public class CreateCouplingDevice extends AbstractModification { - private final CreateCouplingDeviceInfos createCouplingDeviceInfos; - - public CreateCouplingDevice(CreateCouplingDeviceInfos createCouplingDeviceInfos) { - this.createCouplingDeviceInfos = createCouplingDeviceInfos; - } + private String voltageLevelId; + private String busbarSectionId1; + private String busbarSectionId2; /** * @param network @@ -29,9 +30,9 @@ public CreateCouplingDevice(CreateCouplingDeviceInfos createCouplingDeviceInfos) */ @Override public void apply(Network network, ReportNode subReportNode) { - new CreateCouplingDeviceBuilder() - .withBusOrBusbarSectionId1(createCouplingDeviceInfos.getCouplingDeviceInfos().getBusbarSectionId1()) - .withBusOrBusbarSectionId2(createCouplingDeviceInfos.getCouplingDeviceInfos().getBusbarSectionId2()) + new com.powsybl.iidm.modification.topology.CreateCouplingDeviceBuilder() + .withBusOrBusbarSectionId1(busbarSectionId1) + .withBusOrBusbarSectionId2(busbarSectionId2) .build().apply(network, false, subReportNode); } diff --git a/src/main/java/org/gridsuite/modification/modifications/CreateVoltageLevelSection.java b/src/main/java/org/gridsuite/modification/modifications/CreateVoltageLevelSection.java index 4e539d8b..1cb8d066 100644 --- a/src/main/java/org/gridsuite/modification/modifications/CreateVoltageLevelSection.java +++ b/src/main/java/org/gridsuite/modification/modifications/CreateVoltageLevelSection.java @@ -18,9 +18,9 @@ import com.powsybl.iidm.network.SwitchKind; import com.powsybl.iidm.network.VoltageLevel; import com.powsybl.iidm.network.extensions.BusbarSectionPosition; +import lombok.*; import org.gridsuite.modification.ModificationType; import org.gridsuite.modification.NetworkModificationException; -import org.gridsuite.modification.dto.CreateVoltageLevelSectionInfos; import java.util.ArrayList; import java.util.List; @@ -31,36 +31,43 @@ /** * @author Ghazwa Rehili */ +@Getter +@Setter +@AllArgsConstructor +@Builder public class CreateVoltageLevelSection extends AbstractModification { - private final CreateVoltageLevelSectionInfos modificationInfos; - - public CreateVoltageLevelSection(CreateVoltageLevelSectionInfos modificationInfos) { - this.modificationInfos = modificationInfos; - } + private String voltageLevelId; + private int busbarIndex; + private boolean afterBusbarSectionId; + private String leftSwitchKind; + private String rightSwitchKind; + private boolean allBusbars; + private String busbarSectionId; + private boolean switchOpen; @Override public void check(Network network) throws NetworkModificationException { - var voltageLevel = network.getVoltageLevel(modificationInfos.getVoltageLevelId()); + var voltageLevel = network.getVoltageLevel(voltageLevelId); if (voltageLevel == null) { - throw new NetworkModificationException(CREATE_VOLTAGE_LEVEL_ERROR, "Voltage level not found: " + modificationInfos.getVoltageLevelId()); + throw new NetworkModificationException(CREATE_VOLTAGE_LEVEL_ERROR, "Voltage level not found: " + voltageLevelId); } - var bbs = network.getBusbarSection(modificationInfos.getBusbarSectionId()); + var bbs = network.getBusbarSection(busbarSectionId); if (bbs == null) { throw new NetworkModificationException(BUSBAR_SECTION_NOT_FOUND, String.format("%s not found in voltage level %s", - modificationInfos.getBusbarSectionId(), + busbarSectionId, voltageLevel.getId())); } if (bbs.getExtension(BusbarSectionPosition.class) == null) { throw new PowsyblException(String.format("busbar section position extension are not available on this busbar section %s, can not create a new busbar section", - modificationInfos.getBusbarSectionId())); + busbarSectionId)); } - var busbarIndex = bbs.getExtension(BusbarSectionPosition.class).getBusbarIndex(); - if (busbarIndex != modificationInfos.getBusbarIndex()) { + var currentBusbarIndex = bbs.getExtension(BusbarSectionPosition.class).getBusbarIndex(); + if (currentBusbarIndex != busbarIndex) { throw new NetworkModificationException(BUSBAR_SECTION_NOT_FOUND, String.format("%s is not the busbar index of the busbar section %s in voltage level %s", - modificationInfos.getBusbarIndex(), + busbarIndex, bbs.getId(), voltageLevel.getId())); } @@ -73,25 +80,25 @@ public void apply(Network network, ReportNode subReportNode) { @Override public void apply(Network network, NamingStrategy namingStrategy, ReportNode subReportNode) { - VoltageLevel voltageLevel = network.getVoltageLevel(modificationInfos.getVoltageLevelId()); - BusbarSection busbarSection = network.getBusbarSection(modificationInfos.getBusbarSectionId()); + VoltageLevel voltageLevel = network.getVoltageLevel(voltageLevelId); + BusbarSection busbarSection = network.getBusbarSection(busbarSectionId); List busBarIds = new ArrayList<>(); voltageLevel.getNodeBreakerView().getBusbarSections().forEach(bbs -> busBarIds.add(bbs.getId())); CreateVoltageLevelSections modification = new CreateVoltageLevelSectionsBuilder() .withReferenceBusbarSectionId(busbarSection.getId()) - .withCreateTheBusbarSectionsAfterTheReferenceBusbarSection(modificationInfos.isAfterBusbarSectionId()) - .withAllBusbars(modificationInfos.isAllBusbars()) - .withLeftSwitchOpen(modificationInfos.isSwitchOpen()) - .withRightSwitchOpen(modificationInfos.isSwitchOpen()) - .withLeftSwitchKind(modificationInfos.getLeftSwitchKind() != null ? SwitchKind.valueOf(modificationInfos.getLeftSwitchKind()) : SwitchKind.DISCONNECTOR) - .withRightSwitchKind(modificationInfos.getRightSwitchKind() != null ? SwitchKind.valueOf(modificationInfos.getRightSwitchKind()) : SwitchKind.DISCONNECTOR) + .withCreateTheBusbarSectionsAfterTheReferenceBusbarSection(afterBusbarSectionId) + .withAllBusbars(allBusbars) + .withLeftSwitchOpen(switchOpen) + .withRightSwitchOpen(switchOpen) + .withLeftSwitchKind(leftSwitchKind != null ? SwitchKind.valueOf(leftSwitchKind) : SwitchKind.DISCONNECTOR) + .withRightSwitchKind(rightSwitchKind != null ? SwitchKind.valueOf(rightSwitchKind) : SwitchKind.DISCONNECTOR) .withSwitchPrefixId(voltageLevel.getId()) .withBusbarSectionPrefixId(voltageLevel.getId()) .build(); modification.apply(network, namingStrategy, true, subReportNode); - if (modificationInfos.isAllBusbars()) { + if (allBusbars) { List newBusbarSections = new ArrayList<>(); for (BusbarSection bbs : voltageLevel.getNodeBreakerView().getBusbarSections()) { if (!busBarIds.contains(bbs.getId())) { diff --git a/src/main/java/org/gridsuite/modification/modifications/CreateVoltageLevelTopology.java b/src/main/java/org/gridsuite/modification/modifications/CreateVoltageLevelTopology.java index e3cc67bd..a78e50eb 100644 --- a/src/main/java/org/gridsuite/modification/modifications/CreateVoltageLevelTopology.java +++ b/src/main/java/org/gridsuite/modification/modifications/CreateVoltageLevelTopology.java @@ -12,11 +12,12 @@ import com.powsybl.iidm.modification.topology.NamingStrategy; import com.powsybl.iidm.network.BusbarSection; import com.powsybl.iidm.network.Network; +import com.powsybl.iidm.network.SwitchKind; import com.powsybl.iidm.network.VoltageLevel; import com.powsybl.iidm.network.extensions.BusbarSectionPosition; +import lombok.*; import org.gridsuite.modification.ModificationType; import org.gridsuite.modification.NetworkModificationException; -import org.gridsuite.modification.dto.CreateVoltageLevelTopologyInfos; import java.util.Comparator; import java.util.List; @@ -28,28 +29,27 @@ /** * @author Etienne Lesot */ +@Getter +@Setter +@AllArgsConstructor +@Builder public class CreateVoltageLevelTopology extends AbstractModification { - private final CreateVoltageLevelTopologyInfos createVoltageLevelTopologyInfos; - - public CreateVoltageLevelTopology(CreateVoltageLevelTopologyInfos createVoltageLevelTopology) { - this.createVoltageLevelTopologyInfos = createVoltageLevelTopology; - } + private String voltageLevelId; + private List switchKinds; + private Integer sectionCount; @Override public void check(Network network) { - if (createVoltageLevelTopologyInfos == null - || createVoltageLevelTopologyInfos.getVoltageLevelId() == null - || createVoltageLevelTopologyInfos.getSwitchKinds() == null - || createVoltageLevelTopologyInfos.getSectionCount() == null) { + if (voltageLevelId == null || switchKinds == null || sectionCount == null) { throw new NetworkModificationException(CREATE_VOLTAGE_LEVEL_TOPOLOGY_ERROR, "Missing required attributes to modify the equipment"); } - if (createVoltageLevelTopologyInfos.getSwitchKinds().size() != createVoltageLevelTopologyInfos.getSectionCount() - 1) { + if (switchKinds.size() != sectionCount - 1) { throw new NetworkModificationException(CREATE_VOLTAGE_LEVEL_TOPOLOGY_ERROR, "The switch kinds list must have a size equal to the section count minus one"); } - if (network.getVoltageLevel(createVoltageLevelTopologyInfos.getVoltageLevelId()) == null) { + if (network.getVoltageLevel(voltageLevelId) == null) { throw new NetworkModificationException(CREATE_VOLTAGE_LEVEL_TOPOLOGY_ERROR, "voltage level " + - createVoltageLevelTopologyInfos.getVoltageLevelId() + " is not found"); + voltageLevelId + " is not found"); } } @@ -60,18 +60,18 @@ public void apply(Network network, ReportNode subReportNode) { @Override public void apply(Network network, NamingStrategy namingStrategy, ReportNode subReportNode) { - VoltageLevel voltageLevel = network.getVoltageLevel(createVoltageLevelTopologyInfos.getVoltageLevelId()); + VoltageLevel voltageLevel = network.getVoltageLevel(voltageLevelId); createVoltageLevelBusBarSection(network, namingStrategy, subReportNode, voltageLevel); } private void createVoltageLevelBusBarSection(Network network, NamingStrategy namingStrategy, ReportNode subReportNode, VoltageLevel voltageLevel) { int lowBusOrBusbarIndex = findLowBusOrBusbarIndex(voltageLevel); new com.powsybl.iidm.modification.topology.CreateVoltageLevelTopologyBuilder() - .withVoltageLevelId(createVoltageLevelTopologyInfos.getVoltageLevelId()) - .withSectionCount(createVoltageLevelTopologyInfos.getSectionCount()) + .withVoltageLevelId(voltageLevelId) + .withSectionCount(sectionCount) .withAlignedBusesOrBusbarCount(1) .withLowBusOrBusbarIndex(lowBusOrBusbarIndex) - .withSwitchKinds(createVoltageLevelTopologyInfos.getSwitchKinds()) + .withSwitchKinds(switchKinds) .withConnectExistingConnectables(true) .build().apply(network, namingStrategy, true, subReportNode); } diff --git a/src/main/java/org/gridsuite/modification/modifications/DeleteAttachingLine.java b/src/main/java/org/gridsuite/modification/modifications/DeleteAttachingLine.java index d1b35632..11de0c33 100644 --- a/src/main/java/org/gridsuite/modification/modifications/DeleteAttachingLine.java +++ b/src/main/java/org/gridsuite/modification/modifications/DeleteAttachingLine.java @@ -10,8 +10,8 @@ import com.powsybl.iidm.modification.topology.RevertCreateLineOnLine; import com.powsybl.iidm.modification.topology.RevertCreateLineOnLineBuilder; import com.powsybl.iidm.network.Network; +import lombok.*; import org.gridsuite.modification.NetworkModificationException; -import org.gridsuite.modification.dto.DeleteAttachingLineInfos; import static org.gridsuite.modification.NetworkModificationException.Type.LINE_ALREADY_EXISTS; import static org.gridsuite.modification.NetworkModificationException.Type.LINE_NOT_FOUND; @@ -20,46 +20,50 @@ /** * @author bendaamerahm */ +@Getter +@Setter +@AllArgsConstructor +@Builder public class DeleteAttachingLine extends AbstractModification { - private final DeleteAttachingLineInfos modificationInfos; - - public DeleteAttachingLine(DeleteAttachingLineInfos modificationInfos) { - this.modificationInfos = modificationInfos; - } + private String lineToAttachTo1Id; + private String lineToAttachTo2Id; + private String attachedLineId; + private String replacingLine1Id; + private String replacingLine1Name; @Override public void check(Network network) throws NetworkModificationException { // check existing lines - if (network.getLine(modificationInfos.getLineToAttachTo1Id()) == null) { - throw new NetworkModificationException(LINE_NOT_FOUND, modificationInfos.getLineToAttachTo1Id()); + if (network.getLine(lineToAttachTo1Id) == null) { + throw new NetworkModificationException(LINE_NOT_FOUND, lineToAttachTo1Id); } - if (network.getLine(modificationInfos.getLineToAttachTo2Id()) == null) { - throw new NetworkModificationException(LINE_NOT_FOUND, modificationInfos.getLineToAttachTo2Id()); + if (network.getLine(lineToAttachTo2Id) == null) { + throw new NetworkModificationException(LINE_NOT_FOUND, lineToAttachTo2Id); } - if (network.getLine(modificationInfos.getAttachedLineId()) == null) { - throw new NetworkModificationException(LINE_NOT_FOUND, modificationInfos.getAttachedLineId()); + if (network.getLine(attachedLineId) == null) { + throw new NetworkModificationException(LINE_NOT_FOUND, attachedLineId); } // check future line does not exist - if (network.getLine(modificationInfos.getReplacingLine1Id()) != null) { - throw new NetworkModificationException(LINE_ALREADY_EXISTS, modificationInfos.getReplacingLine1Id()); + if (network.getLine(replacingLine1Id) != null) { + throw new NetworkModificationException(LINE_ALREADY_EXISTS, replacingLine1Id); } } @Override public void apply(Network network, ReportNode subReportNode) { RevertCreateLineOnLineBuilder builder = new RevertCreateLineOnLineBuilder(); - RevertCreateLineOnLine algo = builder.withLineToBeMerged1Id(modificationInfos.getLineToAttachTo1Id()) - .withLineToBeMerged2Id(modificationInfos.getLineToAttachTo2Id()) - .withLineToBeDeletedId(modificationInfos.getAttachedLineId()) - .withMergedLineId(modificationInfos.getReplacingLine1Id()) - .withMergedLineName(modificationInfos.getReplacingLine1Name()) + RevertCreateLineOnLine algo = builder.withLineToBeMerged1Id(lineToAttachTo1Id) + .withLineToBeMerged2Id(lineToAttachTo2Id) + .withLineToBeDeletedId(attachedLineId) + .withMergedLineId(replacingLine1Id) + .withMergedLineName(replacingLine1Name) .build(); applyRevertModificationWithMergingOfLimits(network, - modificationInfos.getLineToAttachTo1Id(), - modificationInfos.getLineToAttachTo2Id(), - modificationInfos.getReplacingLine1Id(), + lineToAttachTo1Id, + lineToAttachTo2Id, + replacingLine1Id, algo, subReportNode); } diff --git a/src/main/java/org/gridsuite/modification/modifications/DeleteVoltageLevelOnLine.java b/src/main/java/org/gridsuite/modification/modifications/DeleteVoltageLevelOnLine.java index 605e3f4b..2827f255 100644 --- a/src/main/java/org/gridsuite/modification/modifications/DeleteVoltageLevelOnLine.java +++ b/src/main/java/org/gridsuite/modification/modifications/DeleteVoltageLevelOnLine.java @@ -10,8 +10,8 @@ import com.powsybl.iidm.modification.topology.RevertConnectVoltageLevelOnLine; import com.powsybl.iidm.modification.topology.RevertConnectVoltageLevelOnLineBuilder; import com.powsybl.iidm.network.Network; +import lombok.*; import org.gridsuite.modification.NetworkModificationException; -import org.gridsuite.modification.dto.DeleteVoltageLevelOnLineInfos; import static org.gridsuite.modification.NetworkModificationException.Type.LINE_ALREADY_EXISTS; import static org.gridsuite.modification.NetworkModificationException.Type.LINE_NOT_FOUND; @@ -20,42 +20,45 @@ /** * @author bendaamerahm */ +@Getter +@Setter +@AllArgsConstructor +@Builder public class DeleteVoltageLevelOnLine extends AbstractModification { - private final DeleteVoltageLevelOnLineInfos modificationInfos; - - public DeleteVoltageLevelOnLine(DeleteVoltageLevelOnLineInfos modificationInfos) { - this.modificationInfos = modificationInfos; - } + private String lineToAttachTo1Id; + private String lineToAttachTo2Id; + private String replacingLine1Id; + private String replacingLine1Name; @Override public void check(Network network) throws NetworkModificationException { // check existing lines - if (network.getLine(modificationInfos.getLineToAttachTo1Id()) == null) { - throw new NetworkModificationException(LINE_NOT_FOUND, modificationInfos.getLineToAttachTo1Id()); + if (network.getLine(lineToAttachTo1Id) == null) { + throw new NetworkModificationException(LINE_NOT_FOUND, lineToAttachTo1Id); } - if (network.getLine(modificationInfos.getLineToAttachTo2Id()) == null) { - throw new NetworkModificationException(LINE_NOT_FOUND, modificationInfos.getLineToAttachTo2Id()); + if (network.getLine(lineToAttachTo2Id) == null) { + throw new NetworkModificationException(LINE_NOT_FOUND, lineToAttachTo2Id); } // check future line does not exist - if (network.getLine(modificationInfos.getReplacingLine1Id()) != null) { - throw new NetworkModificationException(LINE_ALREADY_EXISTS, modificationInfos.getReplacingLine1Id()); + if (network.getLine(replacingLine1Id) != null) { + throw new NetworkModificationException(LINE_ALREADY_EXISTS, replacingLine1Id); } } @Override public void apply(Network network, ReportNode subReportNode) { RevertConnectVoltageLevelOnLineBuilder builder = new RevertConnectVoltageLevelOnLineBuilder(); - RevertConnectVoltageLevelOnLine algo = builder.withLine1Id(modificationInfos.getLineToAttachTo1Id()) - .withLine2Id(modificationInfos.getLineToAttachTo2Id()) - .withLineId(modificationInfos.getReplacingLine1Id()) - .withLineName(modificationInfos.getReplacingLine1Name()) + RevertConnectVoltageLevelOnLine algo = builder.withLine1Id(lineToAttachTo1Id) + .withLine2Id(lineToAttachTo2Id) + .withLineId(replacingLine1Id) + .withLineName(replacingLine1Name) .build(); applyRevertModificationWithMergingOfLimits(network, - modificationInfos.getLineToAttachTo1Id(), - modificationInfos.getLineToAttachTo2Id(), - modificationInfos.getReplacingLine1Id(), + lineToAttachTo1Id, + lineToAttachTo2Id, + replacingLine1Id, algo, subReportNode); } diff --git a/src/main/java/org/gridsuite/modification/modifications/EquipmentAttributeModification.java b/src/main/java/org/gridsuite/modification/modifications/EquipmentAttributeModification.java index e64805ca..59b6de9e 100644 --- a/src/main/java/org/gridsuite/modification/modifications/EquipmentAttributeModification.java +++ b/src/main/java/org/gridsuite/modification/modifications/EquipmentAttributeModification.java @@ -11,8 +11,11 @@ import com.powsybl.iidm.network.*; import com.powsybl.iidm.network.extensions.OperatingStatus; import com.powsybl.iidm.network.extensions.OperatingStatusAdder; +import lombok.*; import org.gridsuite.modification.NetworkModificationException; -import org.gridsuite.modification.dto.EquipmentAttributeModificationInfos; +import org.gridsuite.modification.dto.FreePropertyInfos; + +import java.util.List; import static org.gridsuite.modification.NetworkModificationException.Type.EQUIPMENT_NOT_FOUND; import static org.gridsuite.modification.NetworkModificationException.Type.WRONG_EQUIPMENT_TYPE; @@ -20,44 +23,54 @@ /** * @author Slimane Amar */ -public class EquipmentAttributeModification extends AbstractModification { - - private final EquipmentAttributeModificationInfos modificationInfos; - - public EquipmentAttributeModification(EquipmentAttributeModificationInfos modificationInfos) { - this.modificationInfos = modificationInfos; +@Getter +@Setter +public class EquipmentAttributeModification extends AbstractEquipmentBase { + + private String equipmentAttributeName; + private Object equipmentAttributeValue; + private IdentifiableType equipmentType; + + @Builder + public EquipmentAttributeModification(String equipmentId, List properties, + String equipmentAttributeName, Object equipmentAttributeValue, + IdentifiableType equipmentType) { + super(equipmentId, properties); + this.equipmentAttributeName = equipmentAttributeName; + this.equipmentAttributeValue = equipmentAttributeValue; + this.equipmentType = equipmentType; } @Override public void check(Network network) throws NetworkModificationException { - Identifiable identifiable = network.getIdentifiable(modificationInfos.getEquipmentId()); + Identifiable identifiable = network.getIdentifiable(equipmentId); if (identifiable == null) { - throw new NetworkModificationException(EQUIPMENT_NOT_FOUND, modificationInfos.getEquipmentId()); + throw new NetworkModificationException(EQUIPMENT_NOT_FOUND, equipmentId); } - if (identifiable.getType() != modificationInfos.getEquipmentType()) { - throw new NetworkModificationException(WRONG_EQUIPMENT_TYPE, String.format("Type of '%s' is not %s but %s", modificationInfos.getEquipmentId(), modificationInfos.getEquipmentType(), + if (identifiable.getType() != equipmentType) { + throw new NetworkModificationException(WRONG_EQUIPMENT_TYPE, String.format("Type of '%s' is not %s but %s", equipmentId, equipmentType, identifiable.getType())); } } @Override public void apply(Network network, ReportNode subReportNode) { - Identifiable identifiable = network.getIdentifiable(modificationInfos.getEquipmentId()); + Identifiable identifiable = network.getIdentifiable(equipmentId); if (identifiable instanceof Switch) { - changeSwitchAttribute((Switch) identifiable, modificationInfos.getEquipmentAttributeName(), modificationInfos.getEquipmentAttributeValue(), subReportNode); + changeSwitchAttribute((Switch) identifiable, equipmentAttributeName, equipmentAttributeValue, subReportNode); } else if (identifiable instanceof Injection) { if (identifiable instanceof Generator) { - changeGeneratorAttribute((Generator) identifiable, modificationInfos.getEquipmentAttributeName(), modificationInfos.getEquipmentAttributeValue(), subReportNode); + changeGeneratorAttribute((Generator) identifiable, equipmentAttributeName, equipmentAttributeValue, subReportNode); } } else if (identifiable instanceof Branch) { if (identifiable instanceof Line) { - changeLineAttribute((Line) identifiable, modificationInfos.getEquipmentAttributeName(), modificationInfos.getEquipmentAttributeValue(), subReportNode); + changeLineAttribute((Line) identifiable, equipmentAttributeName, equipmentAttributeValue, subReportNode); } else if (identifiable instanceof TwoWindingsTransformer) { - changeTwoWindingsTransformerAttribute((TwoWindingsTransformer) identifiable, modificationInfos.getEquipmentAttributeName(), modificationInfos.getEquipmentAttributeValue(), + changeTwoWindingsTransformerAttribute((TwoWindingsTransformer) identifiable, equipmentAttributeName, equipmentAttributeValue, subReportNode); } } else if (identifiable instanceof ThreeWindingsTransformer) { - changeThreeWindingsTransformerAttribute((ThreeWindingsTransformer) identifiable, modificationInfos.getEquipmentAttributeName(), modificationInfos.getEquipmentAttributeValue(), + changeThreeWindingsTransformerAttribute((ThreeWindingsTransformer) identifiable, equipmentAttributeName, equipmentAttributeValue, subReportNode); } else if (identifiable instanceof HvdcLine) { // no hvdc line modifications yet diff --git a/src/main/java/org/gridsuite/modification/modifications/EquipmentDeletion.java b/src/main/java/org/gridsuite/modification/modifications/EquipmentDeletion.java index 61873f18..219e8d50 100644 --- a/src/main/java/org/gridsuite/modification/modifications/EquipmentDeletion.java +++ b/src/main/java/org/gridsuite/modification/modifications/EquipmentDeletion.java @@ -10,8 +10,10 @@ import com.powsybl.commons.report.TypedValue; import com.powsybl.iidm.modification.topology.*; import com.powsybl.iidm.network.*; +import lombok.*; import org.gridsuite.modification.NetworkModificationException; -import org.gridsuite.modification.dto.EquipmentDeletionInfos; +import org.gridsuite.modification.dto.AbstractEquipmentDeletionInfos; +import org.gridsuite.modification.dto.FreePropertyInfos; import org.gridsuite.modification.dto.HvdcLccDeletionInfos; import org.gridsuite.modification.utils.ModificationUtils; @@ -24,42 +26,49 @@ /** * @author Ayoub Labidi */ -public class EquipmentDeletion extends AbstractModification { +@Getter +@Setter +public class EquipmentDeletion extends AbstractEquipmentBase { - private final EquipmentDeletionInfos modificationInfos; + private IdentifiableType equipmentType; + private AbstractEquipmentDeletionInfos equipmentInfos; - public EquipmentDeletion(EquipmentDeletionInfos modificationInfos) { - this.modificationInfos = modificationInfos; + @Builder + public EquipmentDeletion(String equipmentId, List properties, IdentifiableType equipmentType, + AbstractEquipmentDeletionInfos equipmentInfos) { + super(equipmentId, properties); + this.equipmentType = equipmentType; + this.equipmentInfos = equipmentInfos; } @Override public void check(Network network) throws NetworkModificationException { - Identifiable identifiable = ModificationUtils.getInstance().getEquipmentByIdentifiableType(network, modificationInfos.getEquipmentType(), modificationInfos.getEquipmentId()); + Identifiable identifiable = ModificationUtils.getInstance().getEquipmentByIdentifiableType(network, equipmentType, equipmentId); if (identifiable == null) { - throw new NetworkModificationException(EQUIPMENT_NOT_FOUND, "Equipment with id=" + modificationInfos.getEquipmentId() + " not found or of bad type"); + throw new NetworkModificationException(EQUIPMENT_NOT_FOUND, "Equipment with id=" + equipmentId + " not found or of bad type"); } } @Override public void apply(Network network, ReportNode subReportNode) { - Identifiable identifiable = ModificationUtils.getInstance().getEquipmentByIdentifiableType(network, modificationInfos.getEquipmentType(), modificationInfos.getEquipmentId()); + Identifiable identifiable = ModificationUtils.getInstance().getEquipmentByIdentifiableType(network, equipmentType, equipmentId); // Report node is pushed to network instance to allow deletion logs from other libraries to be added network.getReportNodeContext().pushReportNode(subReportNode); if (identifiable instanceof Connectable) { - new RemoveFeederBay(modificationInfos.getEquipmentId()).apply(network, true, subReportNode); + new RemoveFeederBay(equipmentId).apply(network, true, subReportNode); } else if (identifiable instanceof HvdcLine) { removeHvdcLine(network, subReportNode); } else if (identifiable instanceof VoltageLevel) { - new RemoveVoltageLevel(modificationInfos.getEquipmentId()).apply(network, true, subReportNode); + new RemoveVoltageLevel(equipmentId).apply(network, true, subReportNode); } else if (identifiable instanceof Substation) { - RemoveSubstation rs = new RemoveSubstationBuilder().withSubstationId(modificationInfos.getEquipmentId()).build(); + RemoveSubstation rs = new RemoveSubstationBuilder().withSubstationId(equipmentId).build(); rs.apply(network, true, subReportNode); } subReportNode.newReportNode() .withMessageTemplate("network.modification.equipmentDeleted") - .withUntypedValue("type", modificationInfos.getEquipmentType().name()) - .withUntypedValue("id", modificationInfos.getEquipmentId()) + .withUntypedValue("type", equipmentType.name()) + .withUntypedValue("id", equipmentId) .withSeverity(TypedValue.INFO_SEVERITY) .add(); } @@ -70,7 +79,7 @@ public String getName() { } private void removeHvdcLine(Network network, ReportNode subReportNode) { - HvdcLccDeletionInfos specificInfos = (HvdcLccDeletionInfos) modificationInfos.getEquipmentInfos(); + HvdcLccDeletionInfos specificInfos = (HvdcLccDeletionInfos) equipmentInfos; List shuntCompensatorIds = List.of(); if (specificInfos != null) { shuntCompensatorIds = Stream.concat( @@ -93,7 +102,7 @@ private void removeHvdcLine(Network network, ReportNode subReportNode) { .collect(Collectors.toList()); } RemoveHvdcLine algo = new RemoveHvdcLineBuilder() - .withHvdcLineId(modificationInfos.getEquipmentId()) + .withHvdcLineId(equipmentId) .withShuntCompensatorIds(shuntCompensatorIds) .build(); algo.apply(network, true, subReportNode); diff --git a/src/main/java/org/gridsuite/modification/modifications/GenerationDispatch.java b/src/main/java/org/gridsuite/modification/modifications/GenerationDispatch.java index af52f329..2550b892 100644 --- a/src/main/java/org/gridsuite/modification/modifications/GenerationDispatch.java +++ b/src/main/java/org/gridsuite/modification/modifications/GenerationDispatch.java @@ -13,8 +13,7 @@ import com.powsybl.iidm.modification.scalable.ScalingParameters; import com.powsybl.iidm.network.*; import com.powsybl.iidm.network.extensions.GeneratorStartup; -import lombok.Builder; -import lombok.Getter; +import lombok.*; import org.gridsuite.filter.AbstractFilter; import org.gridsuite.modification.IFilterService; import org.gridsuite.modification.ILoadFlowService; @@ -38,6 +37,8 @@ * @author Franck Lecuyer */ @SuppressWarnings("checkstyle:LambdaBodyLength") +@Getter +@Setter public class GenerationDispatch extends AbstractModification { private static final String POWER_TO_DISPATCH = "network.modification.PowerToDispatch"; private static final String STACKING = "network.modification.Stacking"; @@ -52,12 +53,28 @@ public class GenerationDispatch extends AbstractModification { private static final String GENERATORS_WITHOUT_OUTAGE = "generatorsWithoutOutage"; private static final String GENERATORS_FREQUENCY_RESERVE = "generatorsFrequencyReserve"; - private final GenerationDispatchInfos generationDispatchInfos; + private Double lossCoefficient; + private Double defaultOutageRate; + private List generatorsWithoutOutage; + private List generatorsWithFixedSupply; + private List generatorsFrequencyReserve; + private List substationsGeneratorsOrdering; protected IFilterService filterService; - public GenerationDispatch(GenerationDispatchInfos generationDispatchInfos) { - this.generationDispatchInfos = generationDispatchInfos; + @Builder + public GenerationDispatch(@NonNull Double lossCoefficient, + @NonNull Double defaultOutageRate, + List generatorsWithoutOutage, + List generatorsWithFixedSupply, + List generatorsFrequencyReserve, + List substationsGeneratorsOrdering) { + this.lossCoefficient = lossCoefficient; + this.defaultOutageRate = defaultOutageRate; + this.generatorsWithoutOutage = generatorsWithoutOutage == null ? List.of() : generatorsWithoutOutage; + this.generatorsWithFixedSupply = generatorsWithFixedSupply == null ? List.of() : generatorsWithFixedSupply; + this.generatorsFrequencyReserve = generatorsFrequencyReserve == null ? List.of() : generatorsFrequencyReserve; + this.substationsGeneratorsOrdering = substationsGeneratorsOrdering == null ? List.of() : substationsGeneratorsOrdering; } private static void report(ReportNode reportNode, String key, Map values, TypedValue severity) { @@ -347,11 +364,9 @@ public void initApplicationContext(IFilterService filterService, ILoadFlowServic @Override public void check(Network network) throws NetworkModificationException { - double lossCoefficient = generationDispatchInfos.getLossCoefficient(); if (lossCoefficient < 0. || lossCoefficient > 100.) { throw new NetworkModificationException(GENERATION_DISPATCH_ERROR, "The loss coefficient must be between 0 and 100"); } - double defaultOutageRate = generationDispatchInfos.getDefaultOutageRate(); if (defaultOutageRate < 0. || defaultOutageRate > 100.) { throw new NetworkModificationException(GENERATION_DISPATCH_ERROR, "The default outage rate must be between 0 and 100"); } @@ -394,15 +409,15 @@ private List exportFilters(List generatorsFilters } private List collectGeneratorsWithoutOutage(Network network, ReportNode subReportNode) { - return exportFilters(generationDispatchInfos.getGeneratorsWithoutOutage(), network, subReportNode, GENERATORS_WITHOUT_OUTAGE); + return exportFilters(generatorsWithoutOutage, network, subReportNode, GENERATORS_WITHOUT_OUTAGE); } private List collectGeneratorsWithFixedSupply(Network network, ReportNode subReportNode) { - return exportFilters(generationDispatchInfos.getGeneratorsWithFixedSupply(), network, subReportNode, GENERATORS_WITH_FIXED_SUPPLY); + return exportFilters(generatorsWithFixedSupply, network, subReportNode, GENERATORS_WITH_FIXED_SUPPLY); } private List collectGeneratorsWithFrequencyReserve(Network network, ReportNode subReportNode) { - return generationDispatchInfos.getGeneratorsFrequencyReserve().stream().map(g -> { + return generatorsFrequencyReserve.stream().map(g -> { List generators = exportFilters(g.getGeneratorsFilters(), network, subReportNode, GENERATORS_FREQUENCY_RESERVE); return GeneratorsFrequencyReserve.builder().generators(generators).frequencyReserve(g.getFrequencyReserve()).build(); }).collect(Collectors.toList()); @@ -430,7 +445,7 @@ private double reduceGeneratorMaxPValue(Generator generator, !Double.isNaN(startupExtension.getPlannedOutageRate())) { res *= (1. - startupExtension.getForcedOutageRate()) * (1. - startupExtension.getPlannedOutageRate()); } else { - res *= 1. - generationDispatchInfos.getDefaultOutageRate() / 100.; + res *= 1. - defaultOutageRate / 100.; } } double genFrequencyReserve = computeGenFrequencyReserve(generator, generatorsFrequencyReserve); @@ -456,9 +471,9 @@ private void reportDisconnectedGenerators(List globalDisconnectedGene private boolean checkMissingFilters(ReportNode subReportNode) { Map filterNamesByUuid = new LinkedHashMap<>(); - generationDispatchInfos.getGeneratorsWithoutOutage().forEach(filterInfos -> filterNamesByUuid.put(filterInfos.getId(), filterInfos.getName())); - generationDispatchInfos.getGeneratorsWithFixedSupply().forEach(filterInfos -> filterNamesByUuid.put(filterInfos.getId(), filterInfos.getName())); - generationDispatchInfos.getGeneratorsFrequencyReserve().forEach(frequencyReserveInfos -> + generatorsWithoutOutage.forEach(filterInfos -> filterNamesByUuid.put(filterInfos.getId(), filterInfos.getName())); + generatorsWithFixedSupply.forEach(filterInfos -> filterNamesByUuid.put(filterInfos.getId(), filterInfos.getName())); + generatorsFrequencyReserve.forEach(frequencyReserveInfos -> frequencyReserveInfos.getGeneratorsFilters().forEach(filterInfos -> filterNamesByUuid.put(filterInfos.getId(), filterInfos.getName())) ); if (!filterNamesByUuid.isEmpty()) { @@ -501,10 +516,10 @@ public void apply(Network network, ReportNode subReportNode) { .toList(); // get generators for which there will be no reduction of maximal power - List generatorsWithoutOutage = collectGeneratorsWithoutOutage(network, subReportNode); + List generatorsWithoutOutageIds = collectGeneratorsWithoutOutage(network, subReportNode); // get generators with fixed supply - List generatorsWithFixedSupply = collectGeneratorsWithFixedSupply(network, subReportNode); + List generatorsWithFixedSupplyIds = collectGeneratorsWithFixedSupply(network, subReportNode); // get generators with frequency reserve List generatorsWithFrequencyReserve = collectGeneratorsWithFrequencyReserve(network, subReportNode); @@ -525,12 +540,12 @@ public void apply(Network network, ReportNode subReportNode) { reportDisconnectedGenerators(disconnectedGenerators, componentNum, powerToDispatchReportNode); // get total value of connected loads in the connected component - double totalDemand = computeTotalDemand(component, generationDispatchInfos.getLossCoefficient()); + double totalDemand = computeTotalDemand(component, lossCoefficient); report(powerToDispatchReportNode, "network.modification.TotalDemand", Map.of("totalDemand", round(totalDemand)), TypedValue.INFO_SEVERITY); // get total supply value for generators with fixed supply - double totalAmountFixedSupply = computeTotalAmountFixedSupply(network, component, generatorsWithFixedSupply, powerToDispatchReportNode); + double totalAmountFixedSupply = computeTotalAmountFixedSupply(network, component, generatorsWithFixedSupplyIds, powerToDispatchReportNode); report(powerToDispatchReportNode, "network.modification.TotalAmountFixedSupply", Map.of("totalAmountFixedSupply", round(totalAmountFixedSupply)), TypedValue.INFO_SEVERITY); @@ -554,8 +569,8 @@ public void apply(Network network, ReportNode subReportNode) { } // get adjustable generators in the component - List adjustableGenerators = computeAdjustableGenerators(network, component, generatorsWithFixedSupply, - generationDispatchInfos.getSubstationsGeneratorsOrdering(), + List adjustableGenerators = computeAdjustableGenerators(network, component, generatorsWithFixedSupplyIds, + substationsGeneratorsOrdering, powerToDispatchReportNode); double realized = 0.; @@ -563,7 +578,7 @@ public void apply(Network network, ReportNode subReportNode) { // stacking of adjustable generators to ensure the totalAmountSupplyToBeDispatched List generatorsScalable = adjustableGenerators.stream().map(generator -> { double minValue = generator.getMinP(); - double maxValue = reduceGeneratorMaxPValue(generator, generatorsWithoutOutage, generatorsWithFrequencyReserve); + double maxValue = reduceGeneratorMaxPValue(generator, generatorsWithoutOutageIds, generatorsWithFrequencyReserve); return (Scalable) Scalable.onGenerator(generator.getId(), minValue, maxValue); }).toList(); diff --git a/src/main/java/org/gridsuite/modification/modifications/GeneratorCreation.java b/src/main/java/org/gridsuite/modification/modifications/GeneratorCreation.java index c9c4a4df..00e3b35a 100644 --- a/src/main/java/org/gridsuite/modification/modifications/GeneratorCreation.java +++ b/src/main/java/org/gridsuite/modification/modifications/GeneratorCreation.java @@ -11,11 +11,13 @@ import com.powsybl.commons.report.TypedValue; import com.powsybl.iidm.network.*; import com.powsybl.iidm.network.extensions.ActivePowerControlAdder; +import com.powsybl.iidm.network.extensions.ConnectablePosition; import com.powsybl.iidm.network.extensions.CoordinatedReactiveControlAdder; import com.powsybl.iidm.network.extensions.GeneratorShortCircuitAdder; import com.powsybl.iidm.network.extensions.GeneratorStartupAdder; +import lombok.*; import org.gridsuite.modification.NetworkModificationException; -import org.gridsuite.modification.dto.GeneratorCreationInfos; +import org.gridsuite.modification.dto.*; import org.gridsuite.modification.report.NetworkModificationReportResourceBundle; import org.gridsuite.modification.utils.ModificationUtils; import org.gridsuite.modification.utils.PropertiesUtils; @@ -31,63 +33,122 @@ /** * @author Ayoub Labidi */ -public class GeneratorCreation extends AbstractModification { +@Setter +@Getter +public class GeneratorCreation extends AbstractInjectionCreation implements ReactiveLimitsHolderInfos { - private final GeneratorCreationInfos modificationInfos; + private EnergySource energySource; + private double minP; + private double maxP; + private Double ratedS; + private double targetP; + private Double targetQ; + private boolean voltageRegulationOn; + private Double targetV; + private Double plannedActivePowerSetPoint; + private Double marginalCost; + private Double plannedOutageRate; + private Double forcedOutageRate; + private Double minQ; + private Double maxQ; + private List reactiveCapabilityCurvePoints; + private Boolean participate; + private Float droop; + private Double directTransX; + private Double stepUpTransformerX; + private String regulatingTerminalId; + private String regulatingTerminalType; + private String regulatingTerminalVlId; + private Double qPercent; + private Boolean reactiveCapabilityCurve; - public GeneratorCreation(GeneratorCreationInfos modificationInfos) { - this.modificationInfos = modificationInfos; + @Builder + public GeneratorCreation(String equipmentId, List properties, String equipmentName, + String voltageLevelId, String busOrBusbarSectionId, String connectionName, + ConnectablePosition.Direction connectionDirection, Integer connectionPosition, + boolean terminalConnected, EnergySource energySource, double minP, double maxP, + Double ratedS, double targetP, Double targetQ, boolean voltageRegulationOn, Double targetV, + Double plannedActivePowerSetPoint, Double marginalCost, Double plannedOutageRate, + Double forcedOutageRate, Double minQ, Double maxQ, + List reactiveCapabilityCurvePoints, + Boolean participate, Float droop, Double directTransX, Double stepUpTransformerX, + String regulatingTerminalId, String regulatingTerminalType, String regulatingTerminalVlId, + Double qPercent, Boolean reactiveCapabilityCurve) { + super(equipmentId, properties, equipmentName, voltageLevelId, busOrBusbarSectionId, connectionName, + connectionDirection, connectionPosition, terminalConnected); + this.energySource = energySource; + this.minP = minP; + this.maxP = maxP; + this.ratedS = ratedS; + this.targetP = targetP; + this.targetQ = targetQ; + this.voltageRegulationOn = voltageRegulationOn; + this.targetV = targetV; + this.plannedActivePowerSetPoint = plannedActivePowerSetPoint; + this.marginalCost = marginalCost; + this.plannedOutageRate = plannedOutageRate; + this.forcedOutageRate = forcedOutageRate; + this.minQ = minQ; + this.maxQ = maxQ; + this.reactiveCapabilityCurvePoints = reactiveCapabilityCurvePoints; + this.participate = participate; + this.droop = droop; + this.directTransX = directTransX; + this.stepUpTransformerX = stepUpTransformerX; + this.regulatingTerminalId = regulatingTerminalId; + this.regulatingTerminalType = regulatingTerminalType; + this.regulatingTerminalVlId = regulatingTerminalVlId; + this.qPercent = qPercent; + this.reactiveCapabilityCurve = reactiveCapabilityCurve; } @Override public void check(Network network) throws NetworkModificationException { - if (network.getGenerator(modificationInfos.getEquipmentId()) != null) { - throw new NetworkModificationException(GENERATOR_ALREADY_EXISTS, modificationInfos.getEquipmentId()); + if (network.getGenerator(equipmentId) != null) { + throw new NetworkModificationException(GENERATOR_ALREADY_EXISTS, equipmentId); } - String errorMessage = "Generator '" + modificationInfos.getEquipmentId() + "' : "; + String errorMessage = "Generator '" + equipmentId + "' : "; // check connectivity - ModificationUtils.getInstance().controlConnectivity(network, modificationInfos.getVoltageLevelId(), - modificationInfos.getBusOrBusbarSectionId()); + ModificationUtils.getInstance().controlConnectivity(network, voltageLevelId, busOrBusbarSectionId); // check reactive limits - ModificationUtils.getInstance().checkReactiveLimitsCreation(modificationInfos, - modificationInfos.getErrorType(), - modificationInfos.getEquipmentId(), + ModificationUtils.getInstance().checkReactiveLimitsCreation(this, + CREATE_GENERATOR_ERROR, + equipmentId, "Generator"); // check regulated terminal - VoltageLevel voltageLevel = ModificationUtils.getInstance().getVoltageLevel(network, modificationInfos.getVoltageLevelId()); + VoltageLevel voltageLevel = ModificationUtils.getInstance().getVoltageLevel(network, voltageLevelId); ModificationUtils.getInstance().getTerminalFromIdentifiable(voltageLevel.getNetwork(), - modificationInfos.getRegulatingTerminalId(), - modificationInfos.getRegulatingTerminalType(), - modificationInfos.getRegulatingTerminalVlId()); - - ModificationUtils.getInstance().checkActivePowerControl(modificationInfos.getParticipate(), - modificationInfos.getDroop(), CREATE_GENERATOR_ERROR, String.format(ERROR_MESSAGE, modificationInfos.getEquipmentId())); - - checkIsNotNegativeValue(errorMessage, modificationInfos.getTargetV(), CREATE_GENERATOR_ERROR, "Target Voltage"); - checkIsPercentage(errorMessage, modificationInfos.getDroop(), CREATE_GENERATOR_ERROR, "Droop"); - checkIsNotNegativeValue(errorMessage, modificationInfos.getRatedS(), CREATE_GENERATOR_ERROR, "Rated apparent power"); - checkPowerValues(errorMessage, modificationInfos.getMinP(), modificationInfos.getMaxP(), modificationInfos.getTargetP(), - modificationInfos.getPlannedActivePowerSetPoint(), CREATE_GENERATOR_ERROR); + regulatingTerminalId, + regulatingTerminalType, + regulatingTerminalVlId); + + ModificationUtils.getInstance().checkActivePowerControl(participate, + droop, CREATE_GENERATOR_ERROR, String.format(ERROR_MESSAGE, equipmentId)); + + checkIsNotNegativeValue(errorMessage, targetV, CREATE_GENERATOR_ERROR, "Target Voltage"); + checkIsPercentage(errorMessage, droop, CREATE_GENERATOR_ERROR, "Droop"); + checkIsNotNegativeValue(errorMessage, ratedS, CREATE_GENERATOR_ERROR, "Rated apparent power"); + checkPowerValues(errorMessage, minP, maxP, targetP, plannedActivePowerSetPoint, CREATE_GENERATOR_ERROR); } @Override public void apply(Network network, ReportNode subReportNode) { // create the generator in the network - VoltageLevel voltageLevel = ModificationUtils.getInstance().getVoltageLevel(network, modificationInfos.getVoltageLevelId()); + VoltageLevel voltageLevel = ModificationUtils.getInstance().getVoltageLevel(network, voltageLevelId); if (voltageLevel.getTopologyKind() == TopologyKind.NODE_BREAKER) { - createGeneratorInNodeBreaker(voltageLevel, modificationInfos, network, subReportNode); + createGeneratorInNodeBreaker(voltageLevel, network, subReportNode); } else { - createGeneratorInBusBreaker(voltageLevel, modificationInfos, subReportNode); + createGeneratorInBusBreaker(voltageLevel, subReportNode); } - if (!modificationInfos.isTerminalConnected()) { - network.getGenerator(modificationInfos.getEquipmentId()).getTerminal().disconnect(); + if (!terminalConnected) { + network.getGenerator(equipmentId).getTerminal().disconnect(); } // apply the properties - Generator generator = network.getGenerator(modificationInfos.getEquipmentId()); - PropertiesUtils.applyProperties(generator, subReportNode, modificationInfos.getProperties(), "network.modification.GeneratorProperties"); + Generator generator = network.getGenerator(equipmentId); + PropertiesUtils.applyProperties(generator, subReportNode, properties, "network.modification.GeneratorProperties"); } @Override @@ -95,34 +156,34 @@ public String getName() { return "GeneratorCreation"; } - private void createGeneratorInNodeBreaker(VoltageLevel voltageLevel, GeneratorCreationInfos generatorCreationInfos, Network network, ReportNode subReportNode) { - GeneratorAdder generatorAdder = createGeneratorAdderInNodeBreaker(voltageLevel, generatorCreationInfos); - createInjectionInNodeBreaker(voltageLevel, generatorCreationInfos, network, generatorAdder, subReportNode); + private void createGeneratorInNodeBreaker(VoltageLevel voltageLevel, Network network, ReportNode subReportNode) { + GeneratorAdder generatorAdder = createGeneratorAdderInNodeBreaker(voltageLevel); + createInjectionInNodeBreaker(voltageLevel, this, network, generatorAdder, subReportNode); // CreateFeederBayBuilder already create the generator using // (withInjectionAdder(generatorAdder)) so then we can add the additional informations and extensions - var generator = ModificationUtils.getInstance().getGenerator(network, generatorCreationInfos.getEquipmentId()); - addExtensionsToGenerator(generatorCreationInfos, generator, voltageLevel, subReportNode); + var generator = ModificationUtils.getInstance().getGenerator(network, equipmentId); + addExtensionsToGenerator(generator, voltageLevel, subReportNode); } - private GeneratorAdder createGeneratorAdderInNodeBreaker(VoltageLevel voltageLevel, GeneratorCreationInfos generatorCreationInfos) { + private GeneratorAdder createGeneratorAdderInNodeBreaker(VoltageLevel voltageLevel) { Terminal terminal = ModificationUtils.getInstance().getTerminalFromIdentifiable(voltageLevel.getNetwork(), - generatorCreationInfos.getRegulatingTerminalId(), - generatorCreationInfos.getRegulatingTerminalType(), - generatorCreationInfos.getRegulatingTerminalVlId()); + regulatingTerminalId, + regulatingTerminalType, + regulatingTerminalVlId); // creating the generator adder GeneratorAdder generatorAdder = voltageLevel.newGenerator() - .setId(generatorCreationInfos.getEquipmentId()) - .setName(generatorCreationInfos.getEquipmentName()) - .setEnergySource(generatorCreationInfos.getEnergySource()) - .setMinP(generatorCreationInfos.getMinP()) - .setMaxP(generatorCreationInfos.getMaxP()) - .setRatedS(nanIfNull(generatorCreationInfos.getRatedS())) - .setTargetP(generatorCreationInfos.getTargetP()) - .setTargetQ(nanIfNull(generatorCreationInfos.getTargetQ())) - .setVoltageRegulatorOn(generatorCreationInfos.isVoltageRegulationOn()) - .setTargetV(nanIfNull(generatorCreationInfos.getTargetV())); + .setId(equipmentId) + .setName(equipmentName) + .setEnergySource(energySource) + .setMinP(minP) + .setMaxP(maxP) + .setRatedS(nanIfNull(ratedS)) + .setTargetP(targetP) + .setTargetQ(nanIfNull(targetQ)) + .setVoltageRegulatorOn(voltageRegulationOn) + .setTargetV(nanIfNull(targetV)); if (terminal != null) { generatorAdder.setRegulatingTerminal(terminal); @@ -131,93 +192,91 @@ private GeneratorAdder createGeneratorAdderInNodeBreaker(VoltageLevel voltageLev return generatorAdder; } - private void addExtensionsToGenerator(GeneratorCreationInfos generatorCreationInfos, Generator generator, - VoltageLevel voltageLevel, ReportNode subReportNode) { - if (generatorCreationInfos.getEquipmentName() != null) { - ModificationUtils.getInstance().reportElementaryCreation(subReportNode, generatorCreationInfos.getEquipmentName(), "Name"); + private void addExtensionsToGenerator(Generator generator, VoltageLevel voltageLevel, ReportNode subReportNode) { + if (equipmentName != null) { + ModificationUtils.getInstance().reportElementaryCreation(subReportNode, equipmentName, "Name"); } - if (generatorCreationInfos.getEnergySource() != null) { - ModificationUtils.getInstance().reportElementaryCreation(subReportNode, generatorCreationInfos.getEnergySource(), "Energy source"); + if (energySource != null) { + ModificationUtils.getInstance().reportElementaryCreation(subReportNode, energySource, "Energy source"); } - reportInjectionCreationConnectivity(generatorCreationInfos, subReportNode); - ReportNode subReporterLimits = reportGeneratorActiveLimits(generatorCreationInfos, subReportNode); - ModificationUtils.getInstance().createReactiveLimits(generatorCreationInfos, generator, subReporterLimits); - ReportNode subReporterSetpoints = reportGeneratorSetPoints(generatorCreationInfos, subReportNode); - createGeneratorVoltageRegulation(generatorCreationInfos, generator, voltageLevel, subReporterSetpoints); + reportInjectionCreationConnectivity(this, subReportNode); + ReportNode subReporterLimits = reportGeneratorActiveLimits(subReportNode); + ModificationUtils.getInstance().createReactiveLimits(this, generator, subReporterLimits); + ReportNode subReporterSetpoints = reportGeneratorSetPoints(subReportNode); + createGeneratorVoltageRegulation(generator, voltageLevel, subReporterSetpoints); ModificationUtils.getInstance().createNewActivePowerControlForInjectionCreation(generator.newExtension(ActivePowerControlAdder.class), - generatorCreationInfos.getParticipate(), - generatorCreationInfos.getDroop(), + participate, + droop, subReporterSetpoints); - ModificationUtils.getInstance().createShortCircuitExtension(generatorCreationInfos.getStepUpTransformerX(), - generatorCreationInfos.getDirectTransX(), generatorCreationInfos.getEquipmentId(), + ModificationUtils.getInstance().createShortCircuitExtension(stepUpTransformerX, + directTransX, equipmentId, generator.newExtension(GeneratorShortCircuitAdder.class), subReportNode, "generator"); - createGeneratorStartUp(generatorCreationInfos, generator, subReportNode); + createGeneratorStartUp(generator, subReportNode); } - private void createGeneratorInBusBreaker(VoltageLevel voltageLevel, GeneratorCreationInfos generatorCreationInfos, ReportNode subReportNode) { - Bus bus = ModificationUtils.getInstance().getBusBreakerBus(voltageLevel, generatorCreationInfos.getBusOrBusbarSectionId()); + private void createGeneratorInBusBreaker(VoltageLevel voltageLevel, ReportNode subReportNode) { + Bus bus = ModificationUtils.getInstance().getBusBreakerBus(voltageLevel, busOrBusbarSectionId); // creating the generator Generator generator = voltageLevel.newGenerator() - .setId(generatorCreationInfos.getEquipmentId()) - .setName(generatorCreationInfos.getEquipmentName()) - .setEnergySource(generatorCreationInfos.getEnergySource()) + .setId(equipmentId) + .setName(equipmentName) + .setEnergySource(energySource) .setBus(bus.getId()) .setConnectableBus(bus.getId()) - .setMinP(generatorCreationInfos.getMinP()) - .setMaxP(generatorCreationInfos.getMaxP()) - .setRatedS(nanIfNull(generatorCreationInfos.getRatedS())) - .setTargetP(generatorCreationInfos.getTargetP()) - .setTargetQ(nanIfNull(generatorCreationInfos.getTargetQ())) - .setVoltageRegulatorOn(generatorCreationInfos.isVoltageRegulationOn()) - .setTargetV(nanIfNull(generatorCreationInfos.getTargetV())) + .setMinP(minP) + .setMaxP(maxP) + .setRatedS(nanIfNull(ratedS)) + .setTargetP(targetP) + .setTargetQ(nanIfNull(targetQ)) + .setVoltageRegulatorOn(voltageRegulationOn) + .setTargetV(nanIfNull(targetV)) .add(); - addExtensionsToGenerator(generatorCreationInfos, generator, voltageLevel, subReportNode); + addExtensionsToGenerator(generator, voltageLevel, subReportNode); subReportNode.newReportNode() .withMessageTemplate("network.modification.generatorCreated") - .withUntypedValue("id", modificationInfos.getEquipmentId()) + .withUntypedValue("id", equipmentId) .withSeverity(TypedValue.INFO_SEVERITY) .add(); } - private ReportNode reportGeneratorSetPoints(GeneratorCreationInfos generatorCreationInfos, ReportNode subReportNode) { + private ReportNode reportGeneratorSetPoints(ReportNode subReportNode) { List setPointReports = new ArrayList<>(); setPointReports.add(ModificationUtils.getInstance() - .buildCreationReport(generatorCreationInfos.getTargetP(), "Active power")); - if (generatorCreationInfos.getTargetQ() != null) { + .buildCreationReport(targetP, "Active power")); + if (targetQ != null) { setPointReports.add(ModificationUtils.getInstance() - .buildCreationReport(generatorCreationInfos.getTargetQ(), "Reactive power")); + .buildCreationReport(targetQ, "Reactive power")); } return ModificationUtils.getInstance().reportModifications(subReportNode, setPointReports, "network.modification.SetPointCreated"); } - private void createGeneratorVoltageRegulation(GeneratorCreationInfos generatorCreationInfos, Generator generator, VoltageLevel voltageLevel, ReportNode subReportNode) { + private void createGeneratorVoltageRegulation(Generator generator, VoltageLevel voltageLevel, ReportNode subReportNode) { List voltageReports = new ArrayList<>(); voltageReports.add(ModificationUtils.getInstance() - .createEnabledDisabledReport("network.modification.VoltageRegulationOn", modificationInfos.isVoltageRegulationOn())); - voltageReports.add(ModificationUtils.getInstance().buildCreationReport(generatorCreationInfos.getTargetV(), "Voltage")); - if (generatorCreationInfos.getRegulatingTerminalVlId() != null && generatorCreationInfos.getRegulatingTerminalId() != null && - generatorCreationInfos.getRegulatingTerminalType() != null) { + .createEnabledDisabledReport("network.modification.VoltageRegulationOn", voltageRegulationOn)); + voltageReports.add(ModificationUtils.getInstance().buildCreationReport(targetV, "Voltage")); + if (regulatingTerminalVlId != null && regulatingTerminalId != null && regulatingTerminalType != null) { Terminal terminal = ModificationUtils.getInstance().getTerminalFromIdentifiable(voltageLevel.getNetwork(), - generatorCreationInfos.getRegulatingTerminalId(), - generatorCreationInfos.getRegulatingTerminalType(), - generatorCreationInfos.getRegulatingTerminalVlId()); + regulatingTerminalId, + regulatingTerminalType, + regulatingTerminalVlId); if (terminal != null) { - updateGeneratorRegulatingTerminal(generatorCreationInfos, generator, terminal, voltageReports); + updateGeneratorRegulatingTerminal(generator, terminal, voltageReports); } } - if (generatorCreationInfos.getQPercent() != null) { + if (qPercent != null) { try { generator.newExtension(CoordinatedReactiveControlAdder.class) - .withQPercent(generatorCreationInfos.getQPercent()).add(); - voltageReports.add(ModificationUtils.getInstance().buildCreationReport(generatorCreationInfos.getQPercent(), "Reactive percentage")); + .withQPercent(qPercent).add(); + voltageReports.add(ModificationUtils.getInstance().buildCreationReport(qPercent, "Reactive percentage")); } catch (PowsyblException e) { voltageReports.add(ReportNode.newRootReportNode() .withResourceBundles(NetworkModificationReportResourceBundle.BASE_NAME) .withMessageTemplate("network.modification.ReactivePercentageError") - .withUntypedValue("id", generatorCreationInfos.getEquipmentId()) + .withUntypedValue("id", equipmentId) .withUntypedValue("message", e.getMessage()) .withSeverity(TypedValue.ERROR_SEVERITY) .build()); @@ -227,71 +286,64 @@ private void createGeneratorVoltageRegulation(GeneratorCreationInfos generatorCr } - private void updateGeneratorRegulatingTerminal(GeneratorCreationInfos generatorCreationInfos, Generator generator, - Terminal terminal, List voltageReports) { - if (generatorCreationInfos.getRegulatingTerminalId() != null - && generatorCreationInfos.getRegulatingTerminalType() != null - && generatorCreationInfos.getRegulatingTerminalVlId() != null) { + private void updateGeneratorRegulatingTerminal(Generator generator, Terminal terminal, List voltageReports) { + if (regulatingTerminalId != null && regulatingTerminalType != null && regulatingTerminalVlId != null) { generator.setRegulatingTerminal(terminal); voltageReports.add(ModificationUtils.getInstance().buildCreationReport( - generatorCreationInfos.getRegulatingTerminalVlId(), + regulatingTerminalVlId, "Voltage level")); voltageReports.add(ModificationUtils.getInstance().buildCreationReport( - generatorCreationInfos.getRegulatingTerminalType() + ":" - + generatorCreationInfos.getRegulatingTerminalId(), + regulatingTerminalType + ":" + regulatingTerminalId, "Equipment")); } } - private ReportNode reportGeneratorActiveLimits(GeneratorCreationInfos generatorCreationInfos, ReportNode subReportNode) { + private ReportNode reportGeneratorActiveLimits(ReportNode subReportNode) { ReportNode subReportNodeLimits = subReportNode.newReportNode().withMessageTemplate("network.modification.limits").add(); List limitsReports = new ArrayList<>(); limitsReports.add(ModificationUtils.getInstance().buildCreationReport( - generatorCreationInfos.getMinP(), "Min active power")); + minP, "Min active power")); limitsReports.add(ModificationUtils.getInstance().buildCreationReport( - generatorCreationInfos.getMaxP(), "Max active power")); - if (generatorCreationInfos.getRatedS() != null) { + maxP, "Max active power")); + if (ratedS != null) { limitsReports.add(ModificationUtils.getInstance().buildCreationReport( - generatorCreationInfos.getRatedS(), "Rated nominal power")); + ratedS, "Rated nominal power")); } ModificationUtils.getInstance().reportModifications(subReportNodeLimits, limitsReports, "network.modification.ActiveLimitsCreated"); return subReportNodeLimits; } - private void createGeneratorStartUp(GeneratorCreationInfos generatorCreationInfos, Generator generator, ReportNode subReportNode) { - if (generatorCreationInfos.getPlannedActivePowerSetPoint() != null - || generatorCreationInfos.getMarginalCost() != null - || generatorCreationInfos.getPlannedOutageRate() != null - || generatorCreationInfos.getForcedOutageRate() != null) { + private void createGeneratorStartUp(Generator generator, ReportNode subReportNode) { + if (plannedActivePowerSetPoint != null || marginalCost != null || plannedOutageRate != null || forcedOutageRate != null) { List startupReports = new ArrayList<>(); try { generator.newExtension(GeneratorStartupAdder.class) - .withPlannedActivePowerSetpoint(nanIfNull(generatorCreationInfos.getPlannedActivePowerSetPoint())) - .withMarginalCost(nanIfNull(generatorCreationInfos.getMarginalCost())) - .withPlannedOutageRate(nanIfNull(generatorCreationInfos.getPlannedOutageRate())) - .withForcedOutageRate(nanIfNull(generatorCreationInfos.getForcedOutageRate())) + .withPlannedActivePowerSetpoint(nanIfNull(plannedActivePowerSetPoint)) + .withMarginalCost(nanIfNull(marginalCost)) + .withPlannedOutageRate(nanIfNull(plannedOutageRate)) + .withForcedOutageRate(nanIfNull(forcedOutageRate)) .add(); - if (generatorCreationInfos.getPlannedActivePowerSetPoint() != null) { + if (plannedActivePowerSetPoint != null) { startupReports.add(ModificationUtils.getInstance().buildCreationReport( - generatorCreationInfos.getPlannedActivePowerSetPoint(), "Planning active power set point")); + plannedActivePowerSetPoint, "Planning active power set point")); } - if (generatorCreationInfos.getMarginalCost() != null) { + if (marginalCost != null) { startupReports.add(ModificationUtils.getInstance().buildCreationReport( - generatorCreationInfos.getMarginalCost(), "Marginal cost")); + marginalCost, "Marginal cost")); } - if (generatorCreationInfos.getPlannedOutageRate() != null) { + if (plannedOutageRate != null) { startupReports.add(ModificationUtils.getInstance().buildCreationReport( - generatorCreationInfos.getPlannedOutageRate(), "Planning outage rate")); + plannedOutageRate, "Planning outage rate")); } - if (generatorCreationInfos.getForcedOutageRate() != null) { + if (forcedOutageRate != null) { startupReports.add(ModificationUtils.getInstance().buildCreationReport( - generatorCreationInfos.getForcedOutageRate(), "Forced outage rate")); + forcedOutageRate, "Forced outage rate")); } } catch (PowsyblException e) { startupReports.add(ReportNode.newRootReportNode() .withResourceBundles(NetworkModificationReportResourceBundle.BASE_NAME) .withMessageTemplate("network.modification.StartupExtensionAddError") - .withUntypedValue("id", generatorCreationInfos.getEquipmentId()) + .withUntypedValue("id", equipmentId) .withUntypedValue("message", e.getMessage()) .withSeverity(TypedValue.ERROR_SEVERITY) .build()); @@ -299,4 +351,5 @@ private void createGeneratorStartUp(GeneratorCreationInfos generatorCreationInfo ModificationUtils.getInstance().reportModifications(subReportNode, startupReports, "network.modification.startUpAttributesCreated"); } } + } diff --git a/src/main/java/org/gridsuite/modification/modifications/GeneratorModification.java b/src/main/java/org/gridsuite/modification/modifications/GeneratorModification.java index 4396e2c8..4afd6efc 100644 --- a/src/main/java/org/gridsuite/modification/modifications/GeneratorModification.java +++ b/src/main/java/org/gridsuite/modification/modifications/GeneratorModification.java @@ -10,6 +10,9 @@ import com.powsybl.commons.report.TypedValue; import com.powsybl.iidm.network.*; import com.powsybl.iidm.network.extensions.*; +import lombok.Builder; +import lombok.Getter; +import lombok.Setter; import org.gridsuite.modification.NetworkModificationException; import org.gridsuite.modification.dto.*; import org.gridsuite.modification.utils.ModificationUtils; @@ -25,6 +28,8 @@ /** * @author Ayoub Labidi */ +@Getter +@Setter public class GeneratorModification extends AbstractInjectionModification { private static final String LIMITS = "network.modification.limits"; @@ -33,75 +38,158 @@ public class GeneratorModification extends AbstractInjectionModification { private static final String TARGET_VOLTAGE = "Target Voltage"; public static final String ERROR_MESSAGE = "Generator '%s' : "; - public GeneratorModification(GeneratorModificationInfos modificationInfos) { - super(modificationInfos); + private AttributeModification energySource; + private AttributeModification minP; + private AttributeModification maxP; + private AttributeModification ratedS; + private AttributeModification targetP; + private AttributeModification targetQ; + private AttributeModification voltageRegulationOn; + private AttributeModification targetV; + private AttributeModification plannedActivePowerSetPoint; + private AttributeModification marginalCost; + private AttributeModification plannedOutageRate; + private AttributeModification forcedOutageRate; + private AttributeModification minQ; + private AttributeModification maxQ; + private List reactiveCapabilityCurvePoints; + private AttributeModification participate; + private AttributeModification droop; + private AttributeModification directTransX; + private AttributeModification stepUpTransformerX; + private AttributeModification voltageRegulationType; + private AttributeModification regulatingTerminalId; + private AttributeModification regulatingTerminalType; + private AttributeModification regulatingTerminalVlId; + private AttributeModification qPercent; + private AttributeModification reactiveCapabilityCurve; + + @Builder + public GeneratorModification(String equipmentId, List properties, + AttributeModification equipmentName, + AttributeModification voltageLevelId, + AttributeModification busOrBusbarSectionId, + AttributeModification connectionName, + AttributeModification connectionDirection, + AttributeModification connectionPosition, + AttributeModification terminalConnected, + AttributeModification pMeasurementValue, + AttributeModification pMeasurementValidity, + AttributeModification qMeasurementValue, + AttributeModification qMeasurementValidity, + AttributeModification energySource, AttributeModification minP, + AttributeModification maxP, AttributeModification ratedS, + AttributeModification targetP, AttributeModification targetQ, + AttributeModification voltageRegulationOn, + AttributeModification targetV, + AttributeModification plannedActivePowerSetPoint, + AttributeModification marginalCost, + AttributeModification plannedOutageRate, + AttributeModification forcedOutageRate, AttributeModification minQ, + AttributeModification maxQ, + List reactiveCapabilityCurvePoints, + AttributeModification participate, AttributeModification droop, + AttributeModification directTransX, + AttributeModification stepUpTransformerX, + AttributeModification voltageRegulationType, + AttributeModification regulatingTerminalId, + AttributeModification regulatingTerminalType, + AttributeModification regulatingTerminalVlId, + AttributeModification qPercent, + AttributeModification reactiveCapabilityCurve) { + super(equipmentId, properties, equipmentName, voltageLevelId, busOrBusbarSectionId, connectionName, + connectionDirection, connectionPosition, terminalConnected, pMeasurementValue, pMeasurementValidity, + qMeasurementValue, qMeasurementValidity); + this.energySource = energySource; + this.minP = minP; + this.maxP = maxP; + this.ratedS = ratedS; + this.targetP = targetP; + this.targetQ = targetQ; + this.voltageRegulationOn = voltageRegulationOn; + this.targetV = targetV; + this.plannedActivePowerSetPoint = plannedActivePowerSetPoint; + this.marginalCost = marginalCost; + this.plannedOutageRate = plannedOutageRate; + this.forcedOutageRate = forcedOutageRate; + this.minQ = minQ; + this.maxQ = maxQ; + this.reactiveCapabilityCurvePoints = reactiveCapabilityCurvePoints; + this.participate = participate; + this.droop = droop; + this.directTransX = directTransX; + this.stepUpTransformerX = stepUpTransformerX; + this.voltageRegulationType = voltageRegulationType; + this.regulatingTerminalId = regulatingTerminalId; + this.regulatingTerminalType = regulatingTerminalType; + this.regulatingTerminalVlId = regulatingTerminalVlId; + this.qPercent = qPercent; + this.reactiveCapabilityCurve = reactiveCapabilityCurve; } @Override public void check(Network network) throws NetworkModificationException { - if (modificationInfos == null) { + if (equipmentId == null) { throw new NetworkModificationException(MODIFY_GENERATOR_ERROR, "Missing required attributes to modify the equipment"); } - GeneratorModificationInfos generatorModificationInfos = (GeneratorModificationInfos) modificationInfos; - Generator generator = ModificationUtils.getInstance().getGenerator(network, generatorModificationInfos.getEquipmentId()); + Generator generator = ModificationUtils.getInstance().getGenerator(network, equipmentId); // check min max reactive limits - String errorMessage = "Generator '" + generatorModificationInfos.getEquipmentId() + "' : "; - ModificationUtils.getInstance().checkVoltageLevelModification(network, generatorModificationInfos.getVoltageLevelId(), - generatorModificationInfos.getBusOrBusbarSectionId(), generator.getTerminal()); - ModificationUtils.getInstance().checkReactiveLimit(generator, generatorModificationInfos.getMinQ(), generatorModificationInfos.getMaxQ(), - generatorModificationInfos.getReactiveCapabilityCurvePoints(), MODIFY_GENERATOR_ERROR, errorMessage); + String errorMessage = "Generator '" + equipmentId + "' : "; + ModificationUtils.getInstance().checkVoltageLevelModification(network, voltageLevelId, + busOrBusbarSectionId, generator.getTerminal()); + ModificationUtils.getInstance().checkReactiveLimit(generator, minQ, maxQ, + reactiveCapabilityCurvePoints, MODIFY_GENERATOR_ERROR, errorMessage); // check regulated terminal ModificationUtils.getInstance().checkEnableRegulation( - generatorModificationInfos.getVoltageRegulationType(), - generatorModificationInfos.getRegulatingTerminalId(), - generatorModificationInfos.getRegulatingTerminalType(), - generatorModificationInfos.getRegulatingTerminalVlId(), + voltageRegulationType, + regulatingTerminalId, + regulatingTerminalType, + regulatingTerminalVlId, generator.getTerminal(), generator.getRegulatingTerminal(), network, MODIFY_GENERATOR_ERROR, errorMessage); - checkActivePowerZeroOrBetweenMinAndMaxActivePowerGenerator(generatorModificationInfos, generator, MODIFY_GENERATOR_ERROR, errorMessage); - if (generatorModificationInfos.getRatedS() != null) { - checkIsNotNegativeValue(errorMessage, generatorModificationInfos.getRatedS().getValue(), MODIFY_GENERATOR_ERROR, "Rated apparent power"); + checkActivePowerZeroOrBetweenMinAndMaxActivePowerGenerator(generator, MODIFY_GENERATOR_ERROR, errorMessage); + if (ratedS != null) { + checkIsNotNegativeValue(errorMessage, ratedS.getValue(), MODIFY_GENERATOR_ERROR, "Rated apparent power"); } - if (generatorModificationInfos.getDroop() != null) { - checkIsPercentage(errorMessage, generatorModificationInfos.getDroop().getValue(), MODIFY_GENERATOR_ERROR, "Droop"); + if (droop != null) { + checkIsPercentage(errorMessage, droop.getValue(), MODIFY_GENERATOR_ERROR, "Droop"); } - if (generatorModificationInfos.getTargetV() != null) { - checkIsNotNegativeValue(errorMessage, generatorModificationInfos.getTargetV().getValue(), MODIFY_GENERATOR_ERROR, TARGET_VOLTAGE); + if (targetV != null) { + checkIsNotNegativeValue(errorMessage, targetV.getValue(), MODIFY_GENERATOR_ERROR, TARGET_VOLTAGE); } checkPowerValues(errorMessage, generator); } private void checkPowerValues(String errorMessage, Generator generator) { - GeneratorModificationInfos generatorModificationInfos = (GeneratorModificationInfos) modificationInfos; GeneratorStartup generatorStartup = generator.getExtension(GeneratorStartup.class); Double oldValue = generatorStartup != null && !Double.isNaN(generatorStartup.getPlannedActivePowerSetpoint()) ? generatorStartup.getPlannedActivePowerSetpoint() : null; - double minP = generatorModificationInfos.getMinP() != null ? generatorModificationInfos.getMinP().getValue() : generator.getMinP(); - double maxP = generatorModificationInfos.getMaxP() != null ? generatorModificationInfos.getMaxP().getValue() : generator.getMaxP(); - double targetP = generatorModificationInfos.getTargetP() != null ? generatorModificationInfos.getTargetP().getValue() : generator.getTargetP(); - Double plannedActivePowerSetPoint = generatorModificationInfos.getPlannedActivePowerSetPoint() != null ? - generatorModificationInfos.getPlannedActivePowerSetPoint().applyModification(oldValue) : null; - - if (generatorModificationInfos.getPlannedActivePowerSetPoint() != null) { - checkActivePowerValue(errorMessage, FIELD_PLANNED_ACTIVE_POWER_SET_POINT, plannedActivePowerSetPoint, minP, maxP, MODIFY_GENERATOR_ERROR); + double newMinP = minP != null ? minP.getValue() : generator.getMinP(); + double newMaxP = maxP != null ? maxP.getValue() : generator.getMaxP(); + double newTargetP = targetP != null ? targetP.getValue() : generator.getTargetP(); + Double plannedActivePowerSetPointValue = plannedActivePowerSetPoint != null ? + plannedActivePowerSetPoint.applyModification(oldValue) : null; + + if (plannedActivePowerSetPoint != null) { + checkActivePowerValue(errorMessage, FIELD_PLANNED_ACTIVE_POWER_SET_POINT, plannedActivePowerSetPointValue, newMinP, newMaxP, MODIFY_GENERATOR_ERROR); } - if (generatorModificationInfos.getMaxP() != null) { - checkMaximumActivePower(errorMessage, minP, targetP, plannedActivePowerSetPoint, maxP, MODIFY_GENERATOR_ERROR); + if (maxP != null) { + checkMaximumActivePower(errorMessage, newMinP, newTargetP, plannedActivePowerSetPointValue, newMaxP, MODIFY_GENERATOR_ERROR); } - if (generatorModificationInfos.getMinP() != null) { - checkMinimumActivePower(errorMessage, maxP, targetP, plannedActivePowerSetPoint, minP, MODIFY_GENERATOR_ERROR); + if (minP != null) { + checkMinimumActivePower(errorMessage, newMaxP, newTargetP, plannedActivePowerSetPointValue, newMinP, MODIFY_GENERATOR_ERROR); } } - private void checkActivePowerZeroOrBetweenMinAndMaxActivePowerGenerator(GeneratorModificationInfos modificationInfos, Generator generator, NetworkModificationException.Type exceptionType, + private void checkActivePowerZeroOrBetweenMinAndMaxActivePowerGenerator(Generator generator, NetworkModificationException.Type exceptionType, String errorMessage) { ModificationUtils.getInstance().checkActivePowerZeroOrBetweenMinAndMaxActivePower( - modificationInfos.getTargetP(), - modificationInfos.getMinP(), - modificationInfos.getMaxP(), + targetP, + minP, + maxP, generator.getMinP(), generator.getMaxP(), generator.getTargetP(), @@ -112,9 +200,9 @@ private void checkActivePowerZeroOrBetweenMinAndMaxActivePowerGenerator(Generato @Override public void apply(Network network, ReportNode subReportNode) { - Generator generator = ModificationUtils.getInstance().getGenerator(network, modificationInfos.getEquipmentId()); + Generator generator = ModificationUtils.getInstance().getGenerator(network, equipmentId); // modify the generator in the network - modifyGenerator(generator, (GeneratorModificationInfos) modificationInfos, subReportNode); + modifyGenerator(generator, subReportNode); } @Override @@ -122,39 +210,37 @@ public String getName() { return "GeneratorModification"; } - private void modifyGenerator(Generator generator, GeneratorModificationInfos modificationInfos, ReportNode subReportNode) { + private void modifyGenerator(Generator generator, ReportNode subReportNode) { subReportNode.newReportNode() .withMessageTemplate("network.modification.generatorModification") - .withUntypedValue("id", modificationInfos.getEquipmentId()) + .withUntypedValue("id", equipmentId) .withSeverity(TypedValue.INFO_SEVERITY) .add(); - if (modificationInfos.getEquipmentName() != null && modificationInfos.getEquipmentName().getValue() != null) { - ModificationUtils.getInstance().applyElementaryModifications(generator::setName, () -> generator.getOptionalName().orElse("No value"), modificationInfos.getEquipmentName(), subReportNode, + if (equipmentName != null && equipmentName.getValue() != null) { + ModificationUtils.getInstance().applyElementaryModifications(generator::setName, () -> generator.getOptionalName().orElse("No value"), equipmentName, subReportNode, "Name"); } - ModificationUtils.getInstance().applyElementaryModifications(generator::setEnergySource, generator::getEnergySource, modificationInfos.getEnergySource(), subReportNode, "Energy source"); - modifyGeneratorVoltageLevelBusOrBusBarSectionAttributes(modificationInfos, generator, subReportNode); - modifyGeneratorConnectivityAttributes(modificationInfos, generator, subReportNode); - modifyGeneratorLimitsAttributes(modificationInfos, generator, subReportNode); - modifyGeneratorSetpointsAttributes(modificationInfos, generator, subReportNode); - ModificationUtils.getInstance().modifyShortCircuitExtension(modificationInfos.getDirectTransX(), - modificationInfos.getStepUpTransformerX(), + ModificationUtils.getInstance().applyElementaryModifications(generator::setEnergySource, generator::getEnergySource, energySource, subReportNode, "Energy source"); + modifyGeneratorVoltageLevelBusOrBusBarSectionAttributes(generator, subReportNode); + modifyGeneratorConnectivityAttributes(generator, subReportNode); + modifyGeneratorLimitsAttributes(generator, subReportNode); + modifyGeneratorSetpointsAttributes(generator, subReportNode); + ModificationUtils.getInstance().modifyShortCircuitExtension(directTransX, + stepUpTransformerX, generator.getExtension(GeneratorShortCircuit.class), () -> generator.newExtension(GeneratorShortCircuitAdder.class), subReportNode); - modifyGeneratorStartUpAttributes(modificationInfos, generator, subReportNode); + modifyGeneratorStartUpAttributes(generator, subReportNode); updateMeasurements(generator, subReportNode); - PropertiesUtils.applyProperties(generator, subReportNode, modificationInfos.getProperties(), "network.modification.GeneratorProperties"); + PropertiesUtils.applyProperties(generator, subReportNode, properties, "network.modification.GeneratorProperties"); } - private void modifyGeneratorReactiveCapabilityCurvePoints(GeneratorModificationInfos modificationInfos, - Generator generator, ReportNode subReportNode, ReportNode subReportNodeLimits) { + private void modifyGeneratorReactiveCapabilityCurvePoints(Generator generator, ReportNode subReportNode, ReportNode subReportNodeLimits) { ReactiveCapabilityCurveAdder adder = generator.newReactiveCapabilityCurve(); - List modificationPoints = modificationInfos.getReactiveCapabilityCurvePoints(); Collection points = generator.getReactiveLimits().getKind() == ReactiveLimitsKind.CURVE ? generator.getReactiveLimits(ReactiveCapabilityCurve.class).getPoints( ) : List.of(); - ModificationUtils.getInstance().modifyReactiveCapabilityCurvePoints(points, modificationPoints, adder, subReportNode, subReportNodeLimits); + ModificationUtils.getInstance().modifyReactiveCapabilityCurvePoints(points, reactiveCapabilityCurvePoints, adder, subReportNode, subReportNodeLimits); } public static ReportNode modifyGeneratorActiveLimitsAttributes(AttributeModification maxP, @@ -191,41 +277,38 @@ public static ReportNode modifyGeneratorActiveLimitsAttributes(AttributeModifica return subReporterLimits; } - private void modifyGeneratorReactiveLimitsAttributes(GeneratorModificationInfos modificationInfos, - Generator generator, ReportNode subReportNode, ReportNode subReportNodeLimits) { + private void modifyGeneratorReactiveLimitsAttributes(Generator generator, ReportNode subReportNode, ReportNode subReportNodeLimits) { // if reactive capability curve is true and there was modifications on the // reactive capability curve points, // then we have to apply the reactive capability curve modifications // else if reactive capability curve is false we have to apply the min and max // reactive limits modifications - if (modificationInfos.getReactiveCapabilityCurve() != null) { - if (Boolean.TRUE.equals(modificationInfos.getReactiveCapabilityCurve().getValue() - && modificationInfos.getReactiveCapabilityCurvePoints() != null - && !modificationInfos.getReactiveCapabilityCurvePoints().isEmpty())) { - modifyGeneratorReactiveCapabilityCurvePoints(modificationInfos, generator, subReportNode, subReportNodeLimits); - } else if (Boolean.FALSE.equals(modificationInfos.getReactiveCapabilityCurve().getValue())) { - ModificationUtils.getInstance().modifyMinMaxReactiveLimits(modificationInfos.getMinQ(), modificationInfos.getMaxQ(), generator, subReportNode, subReportNodeLimits); + if (reactiveCapabilityCurve != null) { + if (Boolean.TRUE.equals(reactiveCapabilityCurve.getValue() + && reactiveCapabilityCurvePoints != null + && !reactiveCapabilityCurvePoints.isEmpty())) { + modifyGeneratorReactiveCapabilityCurvePoints(generator, subReportNode, subReportNodeLimits); + } else if (Boolean.FALSE.equals(reactiveCapabilityCurve.getValue())) { + ModificationUtils.getInstance().modifyMinMaxReactiveLimits(minQ, maxQ, generator, subReportNode, subReportNodeLimits); } } } - private ReportNode modifyGeneratorActivePowerControlAttributes(GeneratorModificationInfos modificationInfos, - Generator generator, ReportNode subReportNode, ReportNode subReportNodeSetpoints) { + private ReportNode modifyGeneratorActivePowerControlAttributes(Generator generator, ReportNode subReportNode, ReportNode subReportNodeSetpoints) { ActivePowerControl activePowerControl = generator.getExtension(ActivePowerControl.class); ActivePowerControlAdder activePowerControlAdder = generator.newExtension(ActivePowerControlAdder.class); return ModificationUtils.getInstance().modifyActivePowerControlAttributes(activePowerControl, activePowerControlAdder, - modificationInfos.getParticipate(), modificationInfos.getDroop(), subReportNode, subReportNodeSetpoints, - MODIFY_GENERATOR_ERROR, String.format(ERROR_MESSAGE, modificationInfos.getEquipmentId())); + participate, droop, subReportNode, subReportNodeSetpoints, + MODIFY_GENERATOR_ERROR, String.format(ERROR_MESSAGE, equipmentId)); } - private void modifyGeneratorStartUpAttributes(GeneratorModificationInfos modificationInfos, Generator generator, - ReportNode subReportNode) { + private void modifyGeneratorStartUpAttributes(Generator generator, ReportNode subReportNode) { List reports = new ArrayList<>(); - modifyGeneratorStartUpAttributes(modificationInfos.getPlannedActivePowerSetPoint(), - modificationInfos.getMarginalCost(), - modificationInfos.getPlannedOutageRate(), - modificationInfos.getForcedOutageRate(), + modifyGeneratorStartUpAttributes(plannedActivePowerSetPoint, + marginalCost, + plannedOutageRate, + forcedOutageRate, generator, subReportNode, reports); @@ -334,7 +417,7 @@ private static boolean addPlannedActivePowerSetPoint(AttributeModification modificationReports) { + private void modifyGeneratorRegulatingTerminal(Generator generator, List modificationReports) { Terminal regulatingTerminal = generator.getRegulatingTerminal(); String oldVoltageLevel = null; @@ -348,28 +431,28 @@ private void modifyGeneratorRegulatingTerminal(GeneratorModificationInfos modifi + regulatingTerminal.getConnectable().getId(); } - if (modificationInfos.getRegulatingTerminalId() != null - && modificationInfos.getRegulatingTerminalType() != null - && modificationInfos.getRegulatingTerminalVlId() != null) { + if (regulatingTerminalId != null + && regulatingTerminalType != null + && regulatingTerminalVlId != null) { Terminal terminal = ModificationUtils.getInstance().getTerminalFromIdentifiable(generator.getNetwork(), - modificationInfos.getRegulatingTerminalId().getValue(), - modificationInfos.getRegulatingTerminalType().getValue(), - modificationInfos.getRegulatingTerminalVlId().getValue()); + regulatingTerminalId.getValue(), + regulatingTerminalType.getValue(), + regulatingTerminalVlId.getValue()); generator.setRegulatingTerminal(terminal); modificationReports.add(ModificationUtils.getInstance().buildModificationReport(oldVoltageLevel, - modificationInfos.getRegulatingTerminalVlId().getValue(), + regulatingTerminalVlId.getValue(), "Voltage level")); modificationReports.add(ModificationUtils.getInstance().buildModificationReport(oldEquipment, - modificationInfos.getRegulatingTerminalType().getValue() + ":" - + modificationInfos.getRegulatingTerminalId().getValue(), + regulatingTerminalType.getValue() + ":" + + regulatingTerminalId.getValue(), "Equipment")); } // if the voltageRegulationType is set to LOCAL, we set the regulatingTerminal // to null - if (modificationInfos.getVoltageRegulationType() != null - && modificationInfos.getVoltageRegulationType().getValue() == VoltageRegulationType.LOCAL + if (voltageRegulationType != null + && voltageRegulationType.getValue() == VoltageRegulationType.LOCAL && oldEquipment != null && oldVoltageLevel != null) { generator.setRegulatingTerminal(null); modificationReports.add(ModificationUtils.getInstance().buildModificationReport(oldVoltageLevel, @@ -381,44 +464,43 @@ private void modifyGeneratorRegulatingTerminal(GeneratorModificationInfos modifi } } - private ReportNode modifyGeneratorVoltageRegulatorAttributes(GeneratorModificationInfos modificationInfos, - Generator generator, ReportNode subReportNode, ReportNode subReportNodeSetpoints) { + private ReportNode modifyGeneratorVoltageRegulatorAttributes(Generator generator, ReportNode subReportNode, ReportNode subReportNodeSetpoints) { List voltageRegulationReports = new ArrayList<>(); - ReportNode reportVoltageSetpoint = modifyTargetV(generator, modificationInfos.getTargetV()); + ReportNode reportVoltageSetpoint = modifyTargetV(generator, targetV); if (reportVoltageSetpoint != null) { voltageRegulationReports.add(reportVoltageSetpoint); } // must be done after setting targetV - ReportNode voltageRegulationOn = ModificationUtils.getInstance().applyElementaryModificationsAndReturnReport(generator::setVoltageRegulatorOn, generator::isVoltageRegulatorOn, - modificationInfos.getVoltageRegulationOn(), "VoltageRegulationOn"); - if (voltageRegulationOn != null) { - voltageRegulationReports.add(voltageRegulationOn); + ReportNode voltageRegulationOnReportNode = ModificationUtils.getInstance().applyElementaryModificationsAndReturnReport(generator::setVoltageRegulatorOn, generator::isVoltageRegulatorOn, + this.voltageRegulationOn, "VoltageRegulationOn"); + if (voltageRegulationOnReportNode != null) { + voltageRegulationReports.add(voltageRegulationOnReportNode); } // We apply modifications to regulatingTerminal and QPercent // we apply modifications to the reactivepower setpoint - modifyGeneratorRegulatingTerminal(modificationInfos, generator, voltageRegulationReports); + modifyGeneratorRegulatingTerminal(generator, voltageRegulationReports); - if (modificationInfos.getQPercent() != null) { + if (qPercent != null) { CoordinatedReactiveControl coordinatedReactiveControl = generator .getExtension(CoordinatedReactiveControl.class); Double oldQPercent = coordinatedReactiveControl != null ? coordinatedReactiveControl.getQPercent() : Double.NaN; generator.newExtension(CoordinatedReactiveControlAdder.class) - .withQPercent(modificationInfos.getQPercent().getValue()) + .withQPercent(qPercent.getValue()) .add(); voltageRegulationReports.add(ModificationUtils.getInstance().buildModificationReport( oldQPercent, - modificationInfos.getQPercent().getValue(), "Reactive percentage")); + qPercent.getValue(), "Reactive percentage")); } //TargetQ and TargetV are unset after voltage regulation have been dealt with otherwise it can cause unwanted validations exceptions - if (modificationInfos.getTargetV() != null && modificationInfos.getTargetV().getOp() == OperationType.UNSET) { + if (targetV != null && targetV.getOp() == OperationType.UNSET) { generator.setTargetV(Double.NaN); } - if (modificationInfos.getTargetQ() != null && modificationInfos.getTargetQ().getOp() == OperationType.UNSET) { + if (targetQ != null && targetQ.getOp() == OperationType.UNSET) { generator.setTargetQ(Double.NaN); } @@ -448,12 +530,11 @@ public static ReportNode modifyTargetV(Generator generator, AttributeModificatio return reportVoltageSetpoint; } - private void modifyGeneratorSetpointsAttributes(GeneratorModificationInfos modificationInfos, - Generator generator, ReportNode subReportNode) { - ReportNode reportActivePower = ModificationUtils.getInstance().applyElementaryModificationsAndReturnReport(generator::setTargetP, generator::getTargetP, modificationInfos.getTargetP(), + private void modifyGeneratorSetpointsAttributes(Generator generator, ReportNode subReportNode) { + ReportNode reportActivePower = ModificationUtils.getInstance().applyElementaryModificationsAndReturnReport(generator::setTargetP, generator::getTargetP, targetP, "Active power"); - ReportNode reportReactivePower = modifyTargetQ(generator, modificationInfos.getTargetQ()); + ReportNode reportReactivePower = modifyTargetQ(generator, targetQ); ReportNode subReporterSetpoints = null; if (reportActivePower != null || reportReactivePower != null) { @@ -465,8 +546,8 @@ private void modifyGeneratorSetpointsAttributes(GeneratorModificationInfos modif insertReportNode(subReporterSetpoints, reportReactivePower); } } - subReporterSetpoints = modifyGeneratorVoltageRegulatorAttributes(modificationInfos, generator, subReportNode, subReporterSetpoints); - modifyGeneratorActivePowerControlAttributes(modificationInfos, generator, subReportNode, subReporterSetpoints); + subReporterSetpoints = modifyGeneratorVoltageRegulatorAttributes(generator, subReportNode, subReporterSetpoints); + modifyGeneratorActivePowerControlAttributes(generator, subReportNode, subReporterSetpoints); } public static ReportNode modifyTargetQ(Generator generator, AttributeModification modifTargetQ) { @@ -481,30 +562,27 @@ public static ReportNode modifyTargetQ(Generator generator, AttributeModificatio return reportReactivePower; } - private void modifyGeneratorLimitsAttributes(GeneratorModificationInfos modificationInfos, - Generator generator, ReportNode subReportNode) { - ReportNode subReportNodeLimits = modifyGeneratorActiveLimitsAttributes(modificationInfos.getMaxP(), - modificationInfos.getMinP(), - modificationInfos.getRatedS(), + private void modifyGeneratorLimitsAttributes(Generator generator, ReportNode subReportNode) { + ReportNode subReportNodeLimits = modifyGeneratorActiveLimitsAttributes(maxP, + minP, + ratedS, generator, subReportNode); - modifyGeneratorReactiveLimitsAttributes(modificationInfos, generator, subReportNode, subReportNodeLimits); + modifyGeneratorReactiveLimitsAttributes(generator, subReportNode, subReportNodeLimits); } - private void modifyGeneratorVoltageLevelBusOrBusBarSectionAttributes(GeneratorModificationInfos modificationInfos, - Generator generator, ReportNode subReportNode) { + private void modifyGeneratorVoltageLevelBusOrBusBarSectionAttributes(Generator generator, ReportNode subReportNode) { ModificationUtils.getInstance().moveFeederBay( generator, generator.getTerminal(), - modificationInfos.getVoltageLevelId(), - modificationInfos.getBusOrBusbarSectionId(), + voltageLevelId, + busOrBusbarSectionId, subReportNode ); } - private ReportNode modifyGeneratorConnectivityAttributes(GeneratorModificationInfos modificationInfos, - Generator generator, ReportNode subReportNode) { + private ReportNode modifyGeneratorConnectivityAttributes(Generator generator, ReportNode subReportNode) { ConnectablePosition connectablePosition = generator.getExtension(ConnectablePosition.class); ConnectablePositionAdder connectablePositionAdder = generator.newExtension(ConnectablePositionAdder.class); - return ModificationUtils.getInstance().modifyInjectionConnectivityAttributes(connectablePosition, connectablePositionAdder, generator, modificationInfos, subReportNode); + return ModificationUtils.getInstance().modifyInjectionConnectivityAttributes(connectablePosition, connectablePositionAdder, generator, this, subReportNode); } } diff --git a/src/main/java/org/gridsuite/modification/modifications/GeneratorScaling.java b/src/main/java/org/gridsuite/modification/modifications/GeneratorScaling.java index cc95c1f6..1bdb16ce 100644 --- a/src/main/java/org/gridsuite/modification/modifications/GeneratorScaling.java +++ b/src/main/java/org/gridsuite/modification/modifications/GeneratorScaling.java @@ -13,8 +13,11 @@ import com.powsybl.iidm.modification.scalable.ScalingParameters; import com.powsybl.iidm.network.Generator; import com.powsybl.iidm.network.Network; +import lombok.Builder; +import lombok.Getter; +import lombok.Setter; +import org.gridsuite.modification.NetworkModificationException; import org.gridsuite.modification.VariationType; -import org.gridsuite.modification.dto.GeneratorScalingInfos; import org.gridsuite.modification.dto.IdentifiableAttributes; import org.gridsuite.modification.dto.ScalingVariationInfos; import org.gridsuite.modification.utils.ModificationUtils; @@ -28,11 +31,13 @@ /** * @author Seddik Yengui */ - +@Getter +@Setter public class GeneratorScaling extends AbstractScaling { - public GeneratorScaling(GeneratorScalingInfos generatorScalableInfos) { - super(generatorScalableInfos); + @Builder + public GeneratorScaling(List variations, VariationType variationType, NetworkModificationException.Type errorType) { + super(variations, variationType, errorType); } @Override @@ -179,7 +184,7 @@ private void scale(Network network, ReportNode subReportNode, ScalingVariationIn @Override protected double getAsked(ScalingVariationInfos generatorScalingVariation, AtomicReference sum) { - return scalingInfos.getVariationType() == VariationType.DELTA_P + return variationType == VariationType.DELTA_P ? generatorScalingVariation.getVariationValue() : generatorScalingVariation.getVariationValue() - sum.get(); } diff --git a/src/main/java/org/gridsuite/modification/modifications/GroovyScript.java b/src/main/java/org/gridsuite/modification/modifications/GroovyScript.java index 0403dbbd..320de769 100644 --- a/src/main/java/org/gridsuite/modification/modifications/GroovyScript.java +++ b/src/main/java/org/gridsuite/modification/modifications/GroovyScript.java @@ -11,26 +11,27 @@ import com.powsybl.iidm.network.*; import groovy.lang.Binding; import groovy.lang.GroovyShell; +import lombok.*; import org.apache.commons.lang3.StringUtils; import org.codehaus.groovy.control.CompilerConfiguration; import org.gridsuite.modification.NetworkModificationException; -import org.gridsuite.modification.dto.GroovyScriptInfos; + import static org.gridsuite.modification.NetworkModificationException.Type.GROOVY_SCRIPT_EMPTY; /** * @author Ayoub Labidi */ +@Getter +@Setter +@AllArgsConstructor +@Builder public class GroovyScript extends AbstractModification { - private final GroovyScriptInfos modificationInfos; - - public GroovyScript(GroovyScriptInfos modificationInfos) { - this.modificationInfos = modificationInfos; - } + private String script; @Override public void check(Network network) throws NetworkModificationException { - if (StringUtils.isBlank(modificationInfos.getScript())) { + if (StringUtils.isBlank(script)) { throw new NetworkModificationException(GROOVY_SCRIPT_EMPTY); } } @@ -41,7 +42,7 @@ public void apply(Network network, ReportNode subReportNode) { var binding = new Binding(); binding.setProperty("network", network); var shell = new GroovyShell(binding, conf); - shell.evaluate(modificationInfos.getScript()); + shell.evaluate(script); subReportNode.newReportNode() .withMessageTemplate("network.modification.groovyScriptApplied") diff --git a/src/main/java/org/gridsuite/modification/modifications/InjectionCreation.java b/src/main/java/org/gridsuite/modification/modifications/InjectionCreation.java new file mode 100644 index 00000000..4ddb7faf --- /dev/null +++ b/src/main/java/org/gridsuite/modification/modifications/InjectionCreation.java @@ -0,0 +1,36 @@ +/* + Copyright (c) 2026, 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/. + */ +package org.gridsuite.modification.modifications; + +import com.powsybl.iidm.network.extensions.ConnectablePosition; +import org.gridsuite.modification.dto.FreePropertyInfos; + +import java.util.List; + +/** + * @author Joris Mancini + */ +public interface InjectionCreation { + + String getEquipmentId(); + + List getProperties(); + + String getEquipmentName(); + + String getVoltageLevelId(); + + String getBusOrBusbarSectionId(); + + String getConnectionName(); + + ConnectablePosition.Direction getConnectionDirection(); + + Integer getConnectionPosition(); + + boolean isTerminalConnected(); +} diff --git a/src/main/java/org/gridsuite/modification/modifications/InjectionModification.java b/src/main/java/org/gridsuite/modification/modifications/InjectionModification.java new file mode 100644 index 00000000..eb89b4ef --- /dev/null +++ b/src/main/java/org/gridsuite/modification/modifications/InjectionModification.java @@ -0,0 +1,45 @@ +/* + Copyright (c) 2026, 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/. + */ +package org.gridsuite.modification.modifications; + +import com.powsybl.iidm.network.extensions.ConnectablePosition; +import org.gridsuite.modification.dto.AttributeModification; +import org.gridsuite.modification.dto.FreePropertyInfos; + +import java.util.List; + +/** + * @author Joris Mancini + */ +public interface InjectionModification { + + String getEquipmentId(); + + List getProperties(); + + AttributeModification getEquipmentName(); + + AttributeModification getVoltageLevelId(); + + AttributeModification getBusOrBusbarSectionId(); + + AttributeModification getConnectionName(); + + AttributeModification getConnectionDirection(); + + AttributeModification getConnectionPosition(); + + AttributeModification getTerminalConnected(); + + AttributeModification getPMeasurementValue(); + + AttributeModification getPMeasurementValidity(); + + AttributeModification getQMeasurementValue(); + + AttributeModification getQMeasurementValidity(); +} diff --git a/src/main/java/org/gridsuite/modification/modifications/LccCreation.java b/src/main/java/org/gridsuite/modification/modifications/LccCreation.java index 37190b43..05eacff9 100644 --- a/src/main/java/org/gridsuite/modification/modifications/LccCreation.java +++ b/src/main/java/org/gridsuite/modification/modifications/LccCreation.java @@ -12,11 +12,12 @@ import com.powsybl.iidm.modification.topology.CreateFeederBay; import com.powsybl.iidm.modification.topology.CreateFeederBayBuilder; import com.powsybl.iidm.network.*; +import lombok.*; import org.apache.commons.lang3.StringUtils; import org.gridsuite.modification.NetworkModificationException; -import org.gridsuite.modification.dto.LccConverterStationCreationInfos; -import org.gridsuite.modification.dto.LccCreationInfos; +import org.gridsuite.modification.dto.FreePropertyInfos; import org.gridsuite.modification.dto.LccShuntCompensatorInfos; +import org.gridsuite.modification.modifications.data.LccConverterStationCreation; import org.gridsuite.modification.utils.ModificationUtils; import org.gridsuite.modification.utils.PropertiesUtils; @@ -34,28 +35,47 @@ * @author Rehili Ghazwa */ -public class LccCreation extends AbstractModification { +@Getter +@Setter +public class LccCreation extends AbstractEquipmentCreation { public static final String EQUIPMENT_CONNECTED_TO_HVDC = "network.modification.equipmentConnectedToHvdc"; public static final String EQUIPMENT_NOT_CONNECTED_TO_HVDC = "network.modification.equipmentNotConnectedToHvdc"; - private final LccCreationInfos modificationInfos; + private Double nominalV; + private Double r; + private Double maxP; + private HvdcLine.ConvertersMode convertersMode; + private Double activePowerSetpoint; + private LccConverterStationCreation converterStation1; + private LccConverterStationCreation converterStation2; - public LccCreation(LccCreationInfos modificationInfos) { - this.modificationInfos = modificationInfos; + @Builder + public LccCreation(String equipmentId, List properties, String equipmentName, Double nominalV, + Double r, Double maxP, HvdcLine.ConvertersMode convertersMode, Double activePowerSetpoint, + LccConverterStationCreation converterStation1, + LccConverterStationCreation converterStation2) { + super(equipmentId, properties, equipmentName); + this.nominalV = nominalV; + this.r = r; + this.maxP = maxP; + this.convertersMode = convertersMode; + this.activePowerSetpoint = activePowerSetpoint; + this.converterStation1 = converterStation1; + this.converterStation2 = converterStation2; } @Override public void check(Network network) throws NetworkModificationException { - if (network.getHvdcLine(modificationInfos.getEquipmentId()) != null) { - throw new NetworkModificationException(HVDC_LINE_ALREADY_EXISTS, modificationInfos.getEquipmentId()); + if (network.getHvdcLine(equipmentId) != null) { + throw new NetworkModificationException(HVDC_LINE_ALREADY_EXISTS, equipmentId); } - checkLccConverterStation(network, modificationInfos.getConverterStation1()); - checkLccConverterStation(network, modificationInfos.getConverterStation2()); + checkLccConverterStation(network, converterStation1); + checkLccConverterStation(network, converterStation2); } - private void checkLccConverterStation(Network network, LccConverterStationCreationInfos converterStation) { + private void checkLccConverterStation(Network network, LccConverterStationCreation converterStation) { if (converterStation == null) { - throw new NetworkModificationException(CREATE_LCC_ERROR, modificationInfos.getEquipmentId() + "Missing required converter station"); + throw new NetworkModificationException(CREATE_LCC_ERROR, equipmentId + "Missing required converter station"); } if (converterStation.getPowerFactor() > 1) { throw new NetworkModificationException(CREATE_LCC_ERROR, "Loss factor should be less or equal to 1"); @@ -69,34 +89,34 @@ private void checkLccConverterStation(Network network, LccConverterStationCreati @Override public void apply(Network network, ReportNode subReportNode) { - LccConverterStation converterStation1 = createConverterStation(network, modificationInfos.getConverterStation1(), subReportNode); - LccConverterStation converterStation2 = createConverterStation(network, modificationInfos.getConverterStation2(), subReportNode); - if (!modificationInfos.getConverterStation1().isTerminalConnected()) { - network.getLccConverterStation(modificationInfos.getConverterStation1().getEquipmentId()).getTerminal().disconnect(); + LccConverterStation createdConverterStation1 = createConverterStation(network, converterStation1, subReportNode); + LccConverterStation createdConverterStation2 = createConverterStation(network, converterStation2, subReportNode); + if (!converterStation1.isTerminalConnected()) { + network.getLccConverterStation(converterStation1.getEquipmentId()).getTerminal().disconnect(); } - if (!modificationInfos.getConverterStation2().isTerminalConnected()) { - network.getLccConverterStation(modificationInfos.getConverterStation2().getEquipmentId()).getTerminal().disconnect(); + if (!converterStation2.isTerminalConnected()) { + network.getLccConverterStation(converterStation2.getEquipmentId()).getTerminal().disconnect(); } HvdcLine hvdcLine = network.newHvdcLine() - .setId(modificationInfos.getEquipmentId()) - .setName(modificationInfos.getEquipmentName()) - .setNominalV(modificationInfos.getNominalV()) - .setR(modificationInfos.getR()) - .setMaxP(modificationInfos.getMaxP()) - .setActivePowerSetpoint(modificationInfos.getActivePowerSetpoint()) - .setConvertersMode(modificationInfos.getConvertersMode()) - .setConverterStationId1(converterStation1 != null ? converterStation1.getId() : null) - .setConverterStationId2(converterStation2 != null ? converterStation2.getId() : null) + .setId(equipmentId) + .setName(equipmentName) + .setNominalV(nominalV) + .setR(r) + .setMaxP(maxP) + .setActivePowerSetpoint(activePowerSetpoint) + .setConvertersMode(convertersMode) + .setConverterStationId1(createdConverterStation1 != null ? createdConverterStation1.getId() : null) + .setConverterStationId2(createdConverterStation2 != null ? createdConverterStation2.getId() : null) .add(); subReportNode.newReportNode() .withMessageTemplate("network.modification.lccCreated") - .withUntypedValue("id", modificationInfos.getEquipmentId()) + .withUntypedValue("id", equipmentId) .withSeverity(TypedValue.INFO_SEVERITY) .add(); reportHvdcLineInfos(hvdcLine, subReportNode); - addReportConverterStationLcc(modificationInfos.getConverterStation1(), "1", subReportNode); - addReportConverterStationLcc(modificationInfos.getConverterStation2(), "2", subReportNode); + addReportConverterStationLcc(converterStation1, "1", subReportNode); + addReportConverterStationLcc(converterStation2, "2", subReportNode); } @Override @@ -105,12 +125,12 @@ public String getName() { } private LccConverterStation createConverterStation(Network network, - LccConverterStationCreationInfos lccConverterStationCreationInfos, + LccConverterStationCreation lccConverterStationCreation, ReportNode subReportNode) { - VoltageLevel voltageLevel = ModificationUtils.getInstance().getVoltageLevel(network, lccConverterStationCreationInfos.getVoltageLevelId()); + VoltageLevel voltageLevel = ModificationUtils.getInstance().getVoltageLevel(network, lccConverterStationCreation.getVoltageLevelId()); return voltageLevel.getTopologyKind() == TopologyKind.NODE_BREAKER ? - createConverterStationInNodeBreaker(network, voltageLevel, lccConverterStationCreationInfos, subReportNode) : - createConverterStationInBusBreaker(network, voltageLevel, lccConverterStationCreationInfos, subReportNode); + createConverterStationInNodeBreaker(network, voltageLevel, lccConverterStationCreation, subReportNode) : + createConverterStationInBusBreaker(network, voltageLevel, lccConverterStationCreation, subReportNode); } private ShuntCompensatorAdder createShuntCompensatorInNodeBreaker(VoltageLevel voltageLevel, LccShuntCompensatorInfos shuntCompensatorInfos) { @@ -157,14 +177,14 @@ public void shuntCompensatorConnectedToHvdc(Boolean connectedToHvdc, Injection injectionAdder, LccShuntCompensatorInfos shuntCompensatorOnSide, ReportNode subReportNode) { - int position = ModificationUtils.getInstance().getPosition(lccConverterStationCreationInfos.getBusOrBusbarSectionId(), network, voltageLevel); + int position = ModificationUtils.getInstance().getPosition(lccConverterStationCreation.getBusOrBusbarSectionId(), network, voltageLevel); CreateFeederBay algo = new CreateFeederBayBuilder() - .withBusOrBusbarSectionId(lccConverterStationCreationInfos.getBusOrBusbarSectionId()) - .withInjectionDirection(lccConverterStationCreationInfos.getConnectionDirection()) + .withBusOrBusbarSectionId(lccConverterStationCreation.getBusOrBusbarSectionId()) + .withInjectionDirection(lccConverterStationCreation.getConnectionDirection()) .withInjectionFeederName(StringUtils.isBlank(shuntCompensatorOnSide.getName()) ? shuntCompensatorOnSide.getId() : shuntCompensatorOnSide.getName()) @@ -176,44 +196,44 @@ private void createShuntCompensatorOnSideInNodeBreaker(VoltageLevel voltageLevel private LccConverterStation createConverterStationInNodeBreaker(Network network, VoltageLevel voltageLevel, - LccConverterStationCreationInfos lccConverterStationCreationInfos, + LccConverterStationCreation lccConverterStationCreation, ReportNode subReportNode) { LccConverterStationAdder converterStationAdder = voltageLevel.newLccConverterStation() - .setId(lccConverterStationCreationInfos.getEquipmentId()) - .setName(lccConverterStationCreationInfos.getEquipmentName()); - if (lccConverterStationCreationInfos.getLossFactor() != null) { - converterStationAdder.setLossFactor(lccConverterStationCreationInfos.getLossFactor()); + .setId(lccConverterStationCreation.getEquipmentId()) + .setName(lccConverterStationCreation.getEquipmentName()); + if (lccConverterStationCreation.getLossFactor() != null) { + converterStationAdder.setLossFactor(lccConverterStationCreation.getLossFactor()); } - if (lccConverterStationCreationInfos.getPowerFactor() != null) { - converterStationAdder.setPowerFactor(lccConverterStationCreationInfos.getPowerFactor()); + if (lccConverterStationCreation.getPowerFactor() != null) { + converterStationAdder.setPowerFactor(lccConverterStationCreation.getPowerFactor()); } - createInjectionInNodeBreaker(voltageLevel, lccConverterStationCreationInfos, network, converterStationAdder, subReportNode); - Optional.ofNullable(lccConverterStationCreationInfos.getShuntCompensatorsOnSide()) + createInjectionInNodeBreaker(voltageLevel, lccConverterStationCreation, network, converterStationAdder, subReportNode); + Optional.ofNullable(lccConverterStationCreation.getShuntCompensatorsOnSide()) .ifPresent(shuntCompensators -> shuntCompensators.forEach(shuntCompensatorOnSide -> { ShuntCompensatorAdder shuntCompensatorAdder = createShuntCompensatorInNodeBreaker(voltageLevel, shuntCompensatorOnSide); - createShuntCompensatorOnSideInNodeBreaker(voltageLevel, network, lccConverterStationCreationInfos, + createShuntCompensatorOnSideInNodeBreaker(voltageLevel, network, lccConverterStationCreation, shuntCompensatorAdder, shuntCompensatorOnSide, subReportNode); shuntCompensatorConnectedToHvdc(shuntCompensatorOnSide.getConnectedToHvdc(), network.getShuntCompensator(shuntCompensatorOnSide.getId()), subReportNode); })); return ModificationUtils.getInstance().getLccConverterStation(network, - lccConverterStationCreationInfos.getEquipmentId()); + lccConverterStationCreation.getEquipmentId()); } private LccConverterStation createConverterStationInBusBreaker(Network network, VoltageLevel voltageLevel, - LccConverterStationCreationInfos lccConverterStationCreationInfos, + LccConverterStationCreation lccConverterStationCreation, ReportNode subReportNode) { - Bus bus = ModificationUtils.getInstance().getBusBreakerBus(voltageLevel, lccConverterStationCreationInfos.getBusOrBusbarSectionId()); + Bus bus = ModificationUtils.getInstance().getBusBreakerBus(voltageLevel, lccConverterStationCreation.getBusOrBusbarSectionId()); LccConverterStation lccConverterStation = voltageLevel.newLccConverterStation() - .setId(lccConverterStationCreationInfos.getEquipmentId()) - .setName(lccConverterStationCreationInfos.getEquipmentName()) + .setId(lccConverterStationCreation.getEquipmentId()) + .setName(lccConverterStationCreation.getEquipmentName()) .setBus(bus.getId()) - .setLossFactor(lccConverterStationCreationInfos.getLossFactor()) - .setPowerFactor(lccConverterStationCreationInfos.getPowerFactor()) + .setLossFactor(lccConverterStationCreation.getLossFactor()) + .setPowerFactor(lccConverterStationCreation.getPowerFactor()) .add(); - Optional.ofNullable(lccConverterStationCreationInfos.getShuntCompensatorsOnSide()) + Optional.ofNullable(lccConverterStationCreation.getShuntCompensatorsOnSide()) .ifPresent(shuntCompensators -> shuntCompensators.forEach(shuntCompensatorOnSide -> { createShuntCompensatorInBusBreaker(voltageLevel, bus, shuntCompensatorOnSide); shuntCompensatorConnectedToHvdc( @@ -225,32 +245,32 @@ private LccConverterStation createConverterStationInBusBreaker(Network network, } private void reportHvdcLineInfos(HvdcLine hvdcLine, ReportNode subReportNode) { - if (modificationInfos.getEquipmentName() != null) { + if (equipmentName != null) { ModificationUtils.getInstance() - .reportElementaryCreation(subReportNode, modificationInfos.getEquipmentName(), "Name"); + .reportElementaryCreation(subReportNode, equipmentName, "Name"); } List characteristicsReport = new ArrayList<>(); - characteristicsReport.add(ModificationUtils.getInstance().buildCreationReport(modificationInfos.getNominalV(), "DC nominal voltage")); - characteristicsReport.add(ModificationUtils.getInstance().buildCreationReport(modificationInfos.getR(), "DC resistance")); - characteristicsReport.add(ModificationUtils.getInstance().buildCreationReport(modificationInfos.getMaxP(), "Pmax")); + characteristicsReport.add(ModificationUtils.getInstance().buildCreationReport(nominalV, "DC nominal voltage")); + characteristicsReport.add(ModificationUtils.getInstance().buildCreationReport(r, "DC resistance")); + characteristicsReport.add(ModificationUtils.getInstance().buildCreationReport(maxP, "Pmax")); ModificationUtils.getInstance().reportModifications(subReportNode, characteristicsReport, "network.modification.lccCharacteristics"); List setPointsReports = new ArrayList<>(); - setPointsReports.add(ModificationUtils.getInstance().buildCreationReport(modificationInfos.getConvertersMode(), "Converters mode")); - setPointsReports.add(ModificationUtils.getInstance().buildCreationReport(modificationInfos.getActivePowerSetpoint(), "Active power")); + setPointsReports.add(ModificationUtils.getInstance().buildCreationReport(convertersMode, "Converters mode")); + setPointsReports.add(ModificationUtils.getInstance().buildCreationReport(activePowerSetpoint, "Active power")); ModificationUtils.getInstance().reportModifications(subReportNode, setPointsReports, "network.modification.LccSetPoints"); - PropertiesUtils.applyProperties(hvdcLine, subReportNode, modificationInfos.getProperties(), "network.modification.LCC_Properties"); + PropertiesUtils.applyProperties(hvdcLine, subReportNode, properties, "network.modification.LCC_Properties"); } - private void addReportConverterStationLcc(LccConverterStationCreationInfos lccConverterStationCreationInfos, + private void addReportConverterStationLcc(LccConverterStationCreation lccConverterStationCreation, String logFieldName, ReportNode subReporter) { ReportNode reportConverterStationNode = subReporter.newReportNode() .withMessageTemplate("network.modification.lccConverterStationCreated") .withUntypedValue("fieldName", logFieldName) - .withUntypedValue("id", lccConverterStationCreationInfos.getEquipmentId()).add(); + .withUntypedValue("id", lccConverterStationCreation.getEquipmentId()).add(); - List characteristicsReport = List.of(ModificationUtils.getInstance().buildCreationReport(lccConverterStationCreationInfos.getLossFactor(), "Loss Factor"), - ModificationUtils.getInstance().buildCreationReport(lccConverterStationCreationInfos.getPowerFactor(), "Power Factor")); - List shuntCompensatorsOnSide = Optional.ofNullable(lccConverterStationCreationInfos.getShuntCompensatorsOnSide()) + List characteristicsReport = List.of(ModificationUtils.getInstance().buildCreationReport(lccConverterStationCreation.getLossFactor(), "Loss Factor"), + ModificationUtils.getInstance().buildCreationReport(lccConverterStationCreation.getPowerFactor(), "Power Factor")); + List shuntCompensatorsOnSide = Optional.ofNullable(lccConverterStationCreation.getShuntCompensatorsOnSide()) .orElse(List.of()) .stream() .flatMap(shuntCompensatorOnSide -> Stream.of( @@ -262,7 +282,7 @@ private void addReportConverterStationLcc(LccConverterStationCreationInfos lccCo .toList(); ModificationUtils.getInstance().reportModifications(reportConverterStationNode, characteristicsReport, "network.modification.converterStationCharacteristics"); - reportInjectionCreationConnectivity(lccConverterStationCreationInfos, reportConverterStationNode); + reportInjectionCreationConnectivity(lccConverterStationCreation, reportConverterStationNode); ModificationUtils.getInstance().reportModifications(reportConverterStationNode, shuntCompensatorsOnSide, "network.modification.converterStationFilters"); } diff --git a/src/main/java/org/gridsuite/modification/modifications/LccModification.java b/src/main/java/org/gridsuite/modification/modifications/LccModification.java index 7afe1836..07e8fcd7 100644 --- a/src/main/java/org/gridsuite/modification/modifications/LccModification.java +++ b/src/main/java/org/gridsuite/modification/modifications/LccModification.java @@ -10,11 +10,13 @@ import com.powsybl.commons.report.ReportNode; import com.powsybl.commons.report.TypedValue; import com.powsybl.iidm.network.*; +import lombok.*; import org.apache.commons.math3.util.Pair; import org.gridsuite.modification.NetworkModificationException; -import org.gridsuite.modification.dto.LccConverterStationModificationInfos; -import org.gridsuite.modification.dto.LccModificationInfos; +import org.gridsuite.modification.dto.AttributeModification; +import org.gridsuite.modification.dto.FreePropertyInfos; import org.gridsuite.modification.dto.LccShuntCompensatorModificationInfos; +import org.gridsuite.modification.modifications.data.LccConverterStationModification; import org.gridsuite.modification.report.NetworkModificationReportResourceBundle; import org.gridsuite.modification.utils.ModificationUtils; import org.gridsuite.modification.utils.PropertiesUtils; @@ -27,12 +29,34 @@ import static org.gridsuite.modification.utils.ModificationUtils.NO_VALUE; -public class LccModification extends AbstractModification { - - private final LccModificationInfos modificationInfos; - - public LccModification(LccModificationInfos lccModificationInfos) { - this.modificationInfos = lccModificationInfos; +@Getter +@Setter +public class LccModification extends AbstractEquipmentModification { + + private AttributeModification nominalV; + private AttributeModification r; + private AttributeModification maxP; + private AttributeModification convertersMode; + private AttributeModification activePowerSetpoint; + private LccConverterStationModification converterStation1; + private LccConverterStationModification converterStation2; + + @Builder + public LccModification(String equipmentId, List properties, + AttributeModification equipmentName, AttributeModification nominalV, + AttributeModification r, AttributeModification maxP, + AttributeModification convertersMode, + AttributeModification activePowerSetpoint, + LccConverterStationModification converterStation1, + LccConverterStationModification converterStation2) { + super(equipmentId, properties, equipmentName); + this.nominalV = nominalV; + this.r = r; + this.maxP = maxP; + this.convertersMode = convertersMode; + this.activePowerSetpoint = activePowerSetpoint; + this.converterStation1 = converterStation1; + this.converterStation2 = converterStation2; } @Override @@ -42,51 +66,51 @@ public String getName() { @Override public void apply(Network network, ReportNode subReportNode) { - HvdcLine hvdcLine = ModificationUtils.getInstance().getHvdcLine(network, modificationInfos.getEquipmentId()); - modifyLcc(network, hvdcLine, modificationInfos, subReportNode); + HvdcLine hvdcLine = ModificationUtils.getInstance().getHvdcLine(network, equipmentId); + modifyLcc(network, hvdcLine, subReportNode); } - private static void modifyCharacteristics(HvdcLine hvdcLine, LccModificationInfos modificationInfos, ReportNode subReportNode) { + private void modifyCharacteristics(HvdcLine hvdcLine, ReportNode subReportNode) { List characteristicsReportsContainer = new ArrayList<>(); - String errorMessage = "Lcc '" + modificationInfos.getEquipmentId() + "' : "; + String errorMessage = "Lcc '" + equipmentId + "' : "; //Name - if (modificationInfos.getEquipmentName() != null) { + if (equipmentName != null) { characteristicsReportsContainer.add(ModificationUtils.getInstance().applyAndBuildModificationReport(hvdcLine::setName, () -> hvdcLine.getOptionalName().orElse(NO_VALUE), - modificationInfos.getEquipmentName(), "Name")); + equipmentName, "Name")); } // Nominal Voltage - if (modificationInfos.getNominalV() != null) { - ModificationUtils.checkIsNotNegativeValue(errorMessage, modificationInfos.getNominalV().getValue(), NetworkModificationException.Type.MODIFY_LCC_ERROR, "Nominal voltage"); + if (nominalV != null) { + ModificationUtils.checkIsNotNegativeValue(errorMessage, nominalV.getValue(), NetworkModificationException.Type.MODIFY_LCC_ERROR, "Nominal voltage"); characteristicsReportsContainer.add(ModificationUtils.getInstance().applyAndBuildModificationReport(hvdcLine::setNominalV, - hvdcLine::getNominalV, modificationInfos.getNominalV(), "DC nominal voltage")); + hvdcLine::getNominalV, nominalV, "DC nominal voltage")); } // DC resistance - if (modificationInfos.getR() != null) { - ModificationUtils.checkIsNotNegativeValue(errorMessage, modificationInfos.getR().getValue(), NetworkModificationException.Type.MODIFY_LCC_ERROR, "DC resistance"); + if (r != null) { + ModificationUtils.checkIsNotNegativeValue(errorMessage, r.getValue(), NetworkModificationException.Type.MODIFY_LCC_ERROR, "DC resistance"); characteristicsReportsContainer.add(ModificationUtils.getInstance().applyAndBuildModificationReport(hvdcLine::setR, - hvdcLine::getR, modificationInfos.getR(), "DC resistance")); + hvdcLine::getR, r, "DC resistance")); } // Maximum active power - if (modificationInfos.getMaxP() != null) { + if (maxP != null) { characteristicsReportsContainer.add(ModificationUtils.getInstance().applyAndBuildModificationReport(hvdcLine::setMaxP, - hvdcLine::getMaxP, modificationInfos.getMaxP(), "Power max")); + hvdcLine::getMaxP, maxP, "Power max")); } // Converters mode - if (modificationInfos.getConvertersMode() != null) { + if (convertersMode != null) { characteristicsReportsContainer.add(ModificationUtils.getInstance().applyAndBuildModificationReport(hvdcLine::setConvertersMode, - hvdcLine::getConvertersMode, modificationInfos.getConvertersMode(), "Converters Mode")); + hvdcLine::getConvertersMode, convertersMode, "Converters Mode")); } // Active power setpoint - if (modificationInfos.getActivePowerSetpoint() != null) { + if (activePowerSetpoint != null) { characteristicsReportsContainer.add(ModificationUtils.getInstance().applyAndBuildModificationReport(hvdcLine::setActivePowerSetpoint, - hvdcLine::getActivePowerSetpoint, modificationInfos.getActivePowerSetpoint(), "Active Power Set Point")); + hvdcLine::getActivePowerSetpoint, activePowerSetpoint, "Active Power Set Point")); } if (!characteristicsReportsContainer.isEmpty()) { @@ -95,79 +119,79 @@ private static void modifyCharacteristics(HvdcLine hvdcLine, LccModificationInfo } - private void modifyLcc(@Nonnull Network network, @Nonnull HvdcLine hvdcLine, LccModificationInfos modificationInfos, ReportNode subReportNode) { + private void modifyLcc(@Nonnull Network network, @Nonnull HvdcLine hvdcLine, ReportNode subReportNode) { - modifyCharacteristics(hvdcLine, modificationInfos, subReportNode); + modifyCharacteristics(hvdcLine, subReportNode); // Properties - PropertiesUtils.applyProperties(hvdcLine, subReportNode, modificationInfos.getProperties(), "network.modification.LCC_Properties"); + PropertiesUtils.applyProperties(hvdcLine, subReportNode, properties, "network.modification.LCC_Properties"); // stations - if (modificationInfos.getConverterStation1() != null) { - modifyConverterStation(network, modificationInfos.getConverterStation1(), "1", subReportNode); + if (converterStation1 != null) { + modifyConverterStation(network, converterStation1, "1", subReportNode); } - if (modificationInfos.getConverterStation2() != null) { - modifyConverterStation(network, modificationInfos.getConverterStation2(), "2", subReportNode); + if (converterStation2 != null) { + modifyConverterStation(network, converterStation2, "2", subReportNode); } } private void modifyConverterStation(@Nonnull Network network, - @Nonnull LccConverterStationModificationInfos converterStationModificationInfos, + @Nonnull LccConverterStationModification lccConverterStationModification, String logFieldName, ReportNode subReportNode) { - String errorMessage = "Lcc converter station '" + converterStationModificationInfos.getEquipmentId() + "' : "; - LccConverterStation converterStation = network.getLccConverterStation(converterStationModificationInfos.getEquipmentId()); - if (!converterStationModificationInfos.hasModifications() || converterStation == null) { + String errorMessage = "Lcc converter station '" + lccConverterStationModification.getEquipmentId() + "' : "; + LccConverterStation converterStation = network.getLccConverterStation(lccConverterStationModification.getEquipmentId()); + if (!lccConverterStationModification.hasModifications() || converterStation == null) { return; } ReportNode converterStationReportNode = subReportNode.newReportNode() .withMessageTemplate("network.modification.lccConverterStationModified") .withUntypedValue("fieldName", logFieldName) - .withUntypedValue("id", converterStationModificationInfos.getEquipmentId()) + .withUntypedValue("id", lccConverterStationModification.getEquipmentId()) .withSeverity(TypedValue.INFO_SEVERITY) .add(); // Characteristics List characteristicsReports = new ArrayList<>(); - if (converterStationModificationInfos.getEquipmentName() != null) { + if (lccConverterStationModification.getEquipmentName() != null) { characteristicsReports.add(ModificationUtils.getInstance().applyAndBuildModificationReport(converterStation::setName, - () -> converterStation.getOptionalName().orElse(NO_VALUE), converterStationModificationInfos.getEquipmentName(), "Equipment name")); + () -> converterStation.getOptionalName().orElse(NO_VALUE), lccConverterStationModification.getEquipmentName(), "Equipment name")); } - if (converterStationModificationInfos.getLossFactor() != null) { - ModificationUtils.checkIsPercentage(errorMessage, converterStationModificationInfos.getLossFactor().getValue(), NetworkModificationException.Type.MODIFY_LCC_ERROR, "Loss factor"); + if (lccConverterStationModification.getLossFactor() != null) { + ModificationUtils.checkIsPercentage(errorMessage, lccConverterStationModification.getLossFactor().getValue(), NetworkModificationException.Type.MODIFY_LCC_ERROR, "Loss factor"); characteristicsReports.add(ModificationUtils.getInstance().applyAndBuildModificationReport(converterStation::setLossFactor, - converterStation::getLossFactor, converterStationModificationInfos.getLossFactor(), "Loss factor")); + converterStation::getLossFactor, lccConverterStationModification.getLossFactor(), "Loss factor")); } - if (converterStationModificationInfos.getPowerFactor() != null) { - ModificationUtils.checkIsInInterval(errorMessage, converterStationModificationInfos.getPowerFactor().getValue(), new Pair<>(0.f, 1.f), NetworkModificationException.Type.MODIFY_LCC_ERROR, + if (lccConverterStationModification.getPowerFactor() != null) { + ModificationUtils.checkIsInInterval(errorMessage, lccConverterStationModification.getPowerFactor().getValue(), new Pair<>(0.f, 1.f), NetworkModificationException.Type.MODIFY_LCC_ERROR, "Power factor"); characteristicsReports.add(ModificationUtils.getInstance().applyAndBuildModificationReport(converterStation::setPowerFactor, - converterStation::getPowerFactor, converterStationModificationInfos.getPowerFactor(), "Power factor")); + converterStation::getPowerFactor, lccConverterStationModification.getPowerFactor(), "Power factor")); } ModificationUtils.getInstance().reportModifications(converterStationReportNode, characteristicsReports, "network.modification.Characteristics"); - if (!converterStationModificationInfos.getShuntCompensatorsOnSide().isEmpty()) { + if (lccConverterStationModification.getShuntCompensatorsOnSide() != null && !lccConverterStationModification.getShuntCompensatorsOnSide().isEmpty()) { ReportNode shuntCompensatorReportNode = converterStationReportNode.newReportNode() .withMessageTemplate("network.modification.converterStationFilters") .withSeverity(TypedValue.INFO_SEVERITY) .add(); modifyShuntCompensatorsOnSide(network, converterStation.getTerminal().getVoltageLevel(), - converterStationModificationInfos, shuntCompensatorReportNode); + lccConverterStationModification, shuntCompensatorReportNode); } } private void modifyShuntCompensatorsOnSide(Network network, VoltageLevel voltageLevel, - @Nonnull LccConverterStationModificationInfos converterStationInfos, ReportNode reportNode) { + @Nonnull LccConverterStationModification lccConverterStationModification, ReportNode reportNode) { - List shuntCompensatorsOnSide = converterStationInfos.getShuntCompensatorsOnSide(); + List shuntCompensatorsOnSide = lccConverterStationModification.getShuntCompensatorsOnSide(); Optional.ofNullable(shuntCompensatorsOnSide).ifPresent(shuntCompensators -> shuntCompensators.forEach(infos -> { diff --git a/src/main/java/org/gridsuite/modification/modifications/LineAttachToVoltageLevel.java b/src/main/java/org/gridsuite/modification/modifications/LineAttachToVoltageLevel.java index 2f06bdbf..c0b6887d 100644 --- a/src/main/java/org/gridsuite/modification/modifications/LineAttachToVoltageLevel.java +++ b/src/main/java/org/gridsuite/modification/modifications/LineAttachToVoltageLevel.java @@ -14,11 +14,8 @@ import com.powsybl.iidm.network.*; import com.powsybl.iidm.network.extensions.IdentifiableShortCircuitAdder; import groovyjarjarantlr4.v4.runtime.misc.NotNull; +import lombok.*; import org.gridsuite.modification.NetworkModificationException; -import org.gridsuite.modification.dto.LineAttachToVoltageLevelInfos; -import org.gridsuite.modification.dto.LineCreationInfos; -import org.gridsuite.modification.dto.SubstationCreationInfos; -import org.gridsuite.modification.dto.VoltageLevelCreationInfos; import org.gridsuite.modification.utils.ModificationUtils; import org.gridsuite.modification.utils.PropertiesUtils; @@ -28,35 +25,46 @@ /** * @author David Braquart */ +@Getter +@Setter +@AllArgsConstructor +@Builder public class LineAttachToVoltageLevel extends AbstractModification { - private final LineAttachToVoltageLevelInfos modificationInfos; - - public LineAttachToVoltageLevel(LineAttachToVoltageLevelInfos modificationInfos) { - this.modificationInfos = modificationInfos; - } + private String lineToAttachToId; + private double percent; + private String attachmentPointId; + private String attachmentPointName; + private VoltageLevelCreation attachmentPointDetailInformation; + private VoltageLevelCreation mayNewVoltageLevel; + private String existingVoltageLevelId; + private String bbsOrBusId; + private LineCreation attachmentLine; + private String newLine1Id; + private String newLine1Name; + private String newLine2Id; + private String newLine2Name; @Override public void check(Network network) throws NetworkModificationException { - if (network.getLine(modificationInfos.getLineToAttachToId()) == null) { - throw new NetworkModificationException(LINE_NOT_FOUND, modificationInfos.getLineToAttachToId()); + if (network.getLine(lineToAttachToId) == null) { + throw new NetworkModificationException(LINE_NOT_FOUND, lineToAttachToId); } - LineCreationInfos attachmentLineInfos = modificationInfos.getAttachmentLine(); - ModificationUtils.getInstance().controlNewOrExistingVoltageLevel(modificationInfos.getMayNewVoltageLevelInfos(), - modificationInfos.getExistingVoltageLevelId(), modificationInfos.getBbsOrBusId(), network); + ModificationUtils.getInstance().controlNewOrExistingVoltageLevel(mayNewVoltageLevel, + existingVoltageLevelId, bbsOrBusId, network); // new fictitious VL - if (network.getVoltageLevel(modificationInfos.getAttachmentPointId()) != null) { - throw new NetworkModificationException(VOLTAGE_LEVEL_ALREADY_EXISTS, modificationInfos.getAttachmentPointId()); + if (network.getVoltageLevel(attachmentPointId) != null) { + throw new NetworkModificationException(VOLTAGE_LEVEL_ALREADY_EXISTS, attachmentPointId); } // check future lines don't exist - if (network.getLine(attachmentLineInfos.getEquipmentId()) != null) { - throw new NetworkModificationException(LINE_ALREADY_EXISTS, attachmentLineInfos.getEquipmentId()); + if (network.getLine(attachmentLine.getEquipmentId()) != null) { + throw new NetworkModificationException(LINE_ALREADY_EXISTS, attachmentLine.getEquipmentId()); } - if (network.getLine(modificationInfos.getNewLine1Id()) != null) { - throw new NetworkModificationException(LINE_ALREADY_EXISTS, modificationInfos.getNewLine1Id()); + if (network.getLine(newLine1Id) != null) { + throw new NetworkModificationException(LINE_ALREADY_EXISTS, newLine1Id); } - if (network.getLine(modificationInfos.getNewLine2Id()) != null) { - throw new NetworkModificationException(LINE_ALREADY_EXISTS, modificationInfos.getNewLine2Id()); + if (network.getLine(newLine2Id) != null) { + throw new NetworkModificationException(LINE_ALREADY_EXISTS, newLine2Id); } } @@ -67,55 +75,54 @@ public void apply(Network network, ReportNode subReportNode) { @Override public void apply(Network network, NamingStrategy namingStrategy, ReportNode subReportNode) { - VoltageLevelCreationInfos mayNewVL = modificationInfos.getMayNewVoltageLevelInfos(); - if (mayNewVL != null) { - ModificationUtils.getInstance().createVoltageLevel(mayNewVL, subReportNode, network, namingStrategy); + if (mayNewVoltageLevel != null) { + ModificationUtils.getInstance().createVoltageLevel(mayNewVoltageLevel, subReportNode, network, namingStrategy); } - LineCreationInfos attachmentLineInfos = modificationInfos.getAttachmentLine(); LineAdder lineAdder = network.newLine() - .setId(attachmentLineInfos.getEquipmentId()) - .setName(attachmentLineInfos.getEquipmentName()) - .setR(attachmentLineInfos.getR()) - .setX(attachmentLineInfos.getX()) - .setG1(ModificationUtils.getInstance().zeroIfNull(attachmentLineInfos.getG1())) - .setB1(ModificationUtils.getInstance().zeroIfNull(attachmentLineInfos.getB1())) - .setG2(ModificationUtils.getInstance().zeroIfNull(attachmentLineInfos.getG2())) - .setB2(ModificationUtils.getInstance().zeroIfNull(attachmentLineInfos.getB2())); - String newSubstationId = modificationInfos.getAttachmentPointDetailInformation() != null && - modificationInfos.getAttachmentPointDetailInformation().getSubstationCreation() != null ? - modificationInfos.getAttachmentPointDetailInformation().getSubstationCreation().getEquipmentId() : - modificationInfos.getAttachmentPointId() + "_substation"; + .setId(attachmentLine.getEquipmentId()) + .setName(attachmentLine.getEquipmentName()) + .setR(attachmentLine.getR()) + .setX(attachmentLine.getX()) + .setG1(ModificationUtils.getInstance().zeroIfNull(attachmentLine.getG1())) + .setB1(ModificationUtils.getInstance().zeroIfNull(attachmentLine.getB1())) + .setG2(ModificationUtils.getInstance().zeroIfNull(attachmentLine.getG2())) + .setB2(ModificationUtils.getInstance().zeroIfNull(attachmentLine.getB2())); + String newSubstationId = attachmentPointDetailInformation != null && + attachmentPointDetailInformation.getSubstationCreation() != null ? + attachmentPointDetailInformation.getSubstationCreation().getEquipmentId() : + attachmentPointId + "_substation"; CreateLineOnLine algo = new CreateLineOnLineBuilder() - .withPositionPercent(modificationInfos.getPercent()) - .withBusbarSectionOrBusId(modificationInfos.getBbsOrBusId()) - .withFictitiousVoltageLevelId(modificationInfos.getAttachmentPointId()) - .withFictitiousVoltageLevelName(modificationInfos.getAttachmentPointName()) + .withPositionPercent(percent) + .withBusbarSectionOrBusId(bbsOrBusId) + .withFictitiousVoltageLevelId(attachmentPointId) + .withFictitiousVoltageLevelName(attachmentPointName) .withCreateFictitiousSubstation(true) .withFictitiousSubstationId(newSubstationId) - .withLine1Id(modificationInfos.getNewLine1Id()) - .withLine1Name(modificationInfos.getNewLine1Name()) - .withLine2Id(modificationInfos.getNewLine2Id()) - .withLine2Name(modificationInfos.getNewLine2Name()) - .withLine(network.getLine(modificationInfos.getLineToAttachToId())) + .withLine1Id(newLine1Id) + .withLine1Name(newLine1Name) + .withLine2Id(newLine2Id) + .withLine2Name(newLine2Name) + .withLine(network.getLine(lineToAttachToId)) .withLineAdder(lineAdder) .build(); algo.apply(network, true, subReportNode); // add extra information on attachment line TODO remove when powsybl core fixes it - Line createdAttachmentLine = network.getLine(attachmentLineInfos.getEquipmentId()); - addLimits(attachmentLineInfos, subReportNode, createdAttachmentLine); - PropertiesUtils.applyProperties(createdAttachmentLine, subReportNode, attachmentLineInfos.getProperties(), "network.modification.LineProperties"); + Line createdAttachmentLine = network.getLine(attachmentLine.getEquipmentId()); + addLimits(attachmentLine.getOperationalLimitsGroups(), attachmentLine.getSelectedOperationalLimitsGroupId1(), + attachmentLine.getSelectedOperationalLimitsGroupId2(), subReportNode, createdAttachmentLine); + PropertiesUtils.applyProperties(createdAttachmentLine, subReportNode, attachmentLine.getProperties(), "network.modification.LineProperties"); // override attachment point - if (modificationInfos.getAttachmentPointDetailInformation() != null) { + if (attachmentPointDetailInformation != null) { // override voltage level - updateAttachmentVoltageLevel(network, modificationInfos.getAttachmentPointDetailInformation()); + updateAttachmentVoltageLevel(network, attachmentPointDetailInformation); } } - private void updateAttachmentVoltageLevel(Network network, @NotNull VoltageLevelCreationInfos attachmentPointDetailInformation) { - VoltageLevel voltageLevel = network.getVoltageLevel(modificationInfos.getAttachmentPointId()); + private void updateAttachmentVoltageLevel(Network network, @NotNull VoltageLevelCreation attachmentPointDetailInformation) { + VoltageLevel voltageLevel = network.getVoltageLevel(attachmentPointId); if (attachmentPointDetailInformation.getHighVoltageLimit() != null) { voltageLevel.setHighVoltageLimit(attachmentPointDetailInformation.getHighVoltageLimit()); } @@ -134,21 +141,21 @@ private void updateAttachmentVoltageLevel(Network network, @NotNull VoltageLevel } PropertiesUtils.applyProperties(voltageLevel, attachmentPointDetailInformation.getProperties()); // override substation - SubstationCreationInfos substationCreationInfos = attachmentPointDetailInformation.getSubstationCreation(); + SubstationCreation substationCreationInfos = attachmentPointDetailInformation.getSubstationCreation(); if (substationCreationInfos != null) { updateAttachmentSubstation(network, substationCreationInfos); } } - private void updateAttachmentSubstation(Network network, @NotNull SubstationCreationInfos substationCreationInfos) { - final Substation substation = network.getSubstation(substationCreationInfos.getEquipmentId()); - if (substationCreationInfos.getEquipmentName() != null) { - substation.setName(substationCreationInfos.getEquipmentName()); + private void updateAttachmentSubstation(Network network, @NotNull SubstationCreation substationCreation) { + final Substation substation = network.getSubstation(substationCreation.getEquipmentId()); + if (substationCreation.getEquipmentName() != null) { + substation.setName(substationCreation.getEquipmentName()); } - if (substationCreationInfos.getCountry() != null) { - substation.setCountry(substationCreationInfos.getCountry()); + if (substationCreation.getCountry() != null) { + substation.setCountry(substationCreation.getCountry()); } - PropertiesUtils.applyProperties(substation, substationCreationInfos.getProperties()); + PropertiesUtils.applyProperties(substation, substationCreation.getProperties()); } @Override diff --git a/src/main/java/org/gridsuite/modification/modifications/LineCreation.java b/src/main/java/org/gridsuite/modification/modifications/LineCreation.java index 49962007..7dbe5d07 100644 --- a/src/main/java/org/gridsuite/modification/modifications/LineCreation.java +++ b/src/main/java/org/gridsuite/modification/modifications/LineCreation.java @@ -9,10 +9,11 @@ import com.powsybl.commons.report.ReportNode; import com.powsybl.commons.report.TypedValue; import com.powsybl.iidm.network.*; +import com.powsybl.iidm.network.extensions.ConnectablePosition; +import lombok.*; import org.apache.commons.collections4.CollectionUtils; import org.gridsuite.modification.NetworkModificationException; -import org.gridsuite.modification.dto.LineCreationInfos; -import org.gridsuite.modification.dto.OperationalLimitsGroupInfos; +import org.gridsuite.modification.dto.*; import org.gridsuite.modification.dto.OperationalLimitsGroupInfos.Applicability; import org.gridsuite.modification.utils.ModificationUtils; import org.gridsuite.modification.utils.PropertiesUtils; @@ -30,61 +31,83 @@ /** * @author Slimane Amar */ -public class LineCreation extends AbstractModification { - - private final LineCreationInfos modificationInfos; - - public LineCreation(LineCreationInfos modificationInfos) { - this.modificationInfos = modificationInfos; +@Getter +@Setter +public class LineCreation extends AbstractBranchCreation { + + private Double g1; + private Double b1; + private Double g2; + private Double b2; + + @Builder + public LineCreation(String equipmentId, List properties, String equipmentName, double r, + double x, + String voltageLevelId1, String voltageLevelId2, String busOrBusbarSectionId1, + String busOrBusbarSectionId2, List operationalLimitsGroups, + String selectedOperationalLimitsGroupId1, String selectedOperationalLimitsGroupId2, + String connectionName1, ConnectablePosition.Direction connectionDirection1, + String connectionName2, + ConnectablePosition.Direction connectionDirection2, Integer connectionPosition1, + Integer connectionPosition2, boolean connected1, boolean connected2, Double g1, Double b1, + Double g2, Double b2) { + super(equipmentId, properties, equipmentName, r, x, voltageLevelId1, voltageLevelId2, busOrBusbarSectionId1, + busOrBusbarSectionId2, operationalLimitsGroups, selectedOperationalLimitsGroupId1, + selectedOperationalLimitsGroupId2, connectionName1, connectionDirection1, connectionName2, + connectionDirection2, connectionPosition1, connectionPosition2, connected1, connected2); + this.g1 = g1; + this.b1 = b1; + this.g2 = g2; + this.b2 = b2; } @Override public void check(Network network) throws NetworkModificationException { - if (network.getLine(modificationInfos.getEquipmentId()) != null) { - throw new NetworkModificationException(LINE_ALREADY_EXISTS, modificationInfos.getEquipmentId()); + if (network.getLine(equipmentId) != null) { + throw new NetworkModificationException(LINE_ALREADY_EXISTS, equipmentId); } - String errorMessage = "Line '" + modificationInfos.getEquipmentId() + "' : "; + String errorMessage = "Line '" + equipmentId + "' : "; ModificationUtils.getInstance().controlBranchCreation(network, - modificationInfos.getVoltageLevelId1(), modificationInfos.getBusOrBusbarSectionId1(), - modificationInfos.getVoltageLevelId2(), modificationInfos.getBusOrBusbarSectionId2()); - checkIsNotNegativeValue(errorMessage, modificationInfos.getR(), CREATE_LINE_ERROR, "Resistance R"); - checkIsNotNegativeValue(errorMessage, modificationInfos.getG1(), CREATE_LINE_ERROR, "Conductance on side 1 G1"); - checkIsNotNegativeValue(errorMessage, modificationInfos.getG2(), CREATE_LINE_ERROR, "Conductance on side 2 G2"); + voltageLevelId1, busOrBusbarSectionId1, voltageLevelId2, busOrBusbarSectionId2); + checkIsNotNegativeValue(errorMessage, r, CREATE_LINE_ERROR, "Resistance R"); + checkIsNotNegativeValue(errorMessage, g1, CREATE_LINE_ERROR, "Conductance on side 1 G1"); + checkIsNotNegativeValue(errorMessage, g2, CREATE_LINE_ERROR, "Conductance on side 2 G2"); } @Override public void apply(Network network, ReportNode subReportNode) { - VoltageLevel voltageLevel1 = ModificationUtils.getInstance().getVoltageLevel(network, modificationInfos.getVoltageLevelId1()); - VoltageLevel voltageLevel2 = ModificationUtils.getInstance().getVoltageLevel(network, modificationInfos.getVoltageLevelId2()); + VoltageLevel voltageLevel1 = ModificationUtils.getInstance().getVoltageLevel(network, voltageLevelId1); + VoltageLevel voltageLevel2 = ModificationUtils.getInstance().getVoltageLevel(network, voltageLevelId2); ReportNode characteristicsReporter = subReportNode.newReportNode().withMessageTemplate("network.modification.Characteristics").add(); if (voltageLevel1.getTopologyKind() == TopologyKind.NODE_BREAKER && voltageLevel2.getTopologyKind() == TopologyKind.NODE_BREAKER) { - LineAdder lineAdder = ModificationUtils.getInstance().createLineAdder(network, voltageLevel1, voltageLevel2, modificationInfos, false, false); - createBranchInNodeBreaker(voltageLevel1, voltageLevel2, modificationInfos, network, lineAdder, characteristicsReporter); + LineAdder lineAdder = ModificationUtils.getInstance().createLineAdder(network, voltageLevel1, voltageLevel2, this, false, false); + createBranchInNodeBreaker(voltageLevel1, voltageLevel2, this, network, lineAdder, characteristicsReporter); } else { - addLine(network, voltageLevel1, voltageLevel2, modificationInfos, true, true, characteristicsReporter); + addLine(network, voltageLevel1, voltageLevel2, true, true, characteristicsReporter); } - ModificationUtils.getInstance().disconnectBranch(modificationInfos, network.getLine(modificationInfos.getEquipmentId()), characteristicsReporter); - Line line = network.getLine(modificationInfos.getEquipmentId()); + ModificationUtils.getInstance().disconnectBranch(this, network.getLine(equipmentId), characteristicsReporter); + Line line = network.getLine(equipmentId); - addLimits(modificationInfos, subReportNode, line); + addLimits(operationalLimitsGroups, selectedOperationalLimitsGroupId1, selectedOperationalLimitsGroupId2, subReportNode, line); // properties - PropertiesUtils.applyProperties(line, characteristicsReporter, modificationInfos.getProperties(), "network.modification.LineProperties"); + PropertiesUtils.applyProperties(line, characteristicsReporter, properties, "network.modification.LineProperties"); } - public static void addLimits(LineCreationInfos modificationInfos, ReportNode subReportNode, Line line) { + public static void addLimits(List operationalLimitsGroups, String selectedOperationalLimitsGroupId1, + String selectedOperationalLimitsGroupId2, ReportNode subReportNode, Line line) { // Set permanent and temporary current limits ReportNode limitsReporter = null; - List opLimitsGroupSide1 = ModificationUtils.getOperationalLimitsGroupsOnSide(modificationInfos.getOperationalLimitsGroups(), Applicability.SIDE1); - List opLimitsGroupSide2 = ModificationUtils.getOperationalLimitsGroupsOnSide(modificationInfos.getOperationalLimitsGroups(), Applicability.SIDE2); + List opLimitsGroupSide1 = ModificationUtils.getOperationalLimitsGroupsOnSide(operationalLimitsGroups, Applicability.SIDE1); + List opLimitsGroupSide2 = ModificationUtils.getOperationalLimitsGroupsOnSide(operationalLimitsGroups, Applicability.SIDE2); ReportNode reportNode; - if (!CollectionUtils.isEmpty(modificationInfos.getOperationalLimitsGroups())) { + if (!CollectionUtils.isEmpty(operationalLimitsGroups)) { limitsReporter = subReportNode.newReportNode().withMessageTemplate("network.modification.limitsCreated").add(); reportNode = addLimitSetReportNode(limitsReporter); - for (OperationalLimitsGroupInfos olgInfos : modificationInfos.getOperationalLimitsGroups()) { + for (OperationalLimitsGroupInfos olgInfos : operationalLimitsGroups) { ReportNode limitSetNode = reportNode.newReportNode() .withMessageTemplate("network.modification.limitSetAdded") .withUntypedValue("name", olgInfos.getId()) @@ -101,34 +124,34 @@ public static void addLimits(LineCreationInfos modificationInfos, ReportNode sub } List limitSetsOnSideReportNodes = new ArrayList<>(); - if (modificationInfos.getSelectedOperationalLimitsGroupId1() != null) { - if (!ModificationUtils.hasLimitSet(opLimitsGroupSide1, modificationInfos.getSelectedOperationalLimitsGroupId1())) { + if (selectedOperationalLimitsGroupId1 != null) { + if (!ModificationUtils.hasLimitSet(opLimitsGroupSide1, selectedOperationalLimitsGroupId1)) { limitSetsOnSideReportNodes.add(ReportNode.newRootReportNode() .withMessageTemplate("network.modification.limitSetAbsentOnSide1") - .withUntypedValue("selectedOperationalLimitsGroup", modificationInfos.getSelectedOperationalLimitsGroupId1()) + .withUntypedValue("selectedOperationalLimitsGroup", selectedOperationalLimitsGroupId1) .withSeverity(TypedValue.WARN_SEVERITY) .build()); } else { - line.setSelectedOperationalLimitsGroup1(modificationInfos.getSelectedOperationalLimitsGroupId1()); + line.setSelectedOperationalLimitsGroup1(selectedOperationalLimitsGroupId1); limitSetsOnSideReportNodes.add(ReportNode.newRootReportNode() .withMessageTemplate("network.modification.limitSetSelectedOnSide1") - .withUntypedValue("selectedOperationalLimitsGroup1", modificationInfos.getSelectedOperationalLimitsGroupId1()) + .withUntypedValue("selectedOperationalLimitsGroup1", selectedOperationalLimitsGroupId1) .withSeverity(TypedValue.INFO_SEVERITY) .build()); } } - if (modificationInfos.getSelectedOperationalLimitsGroupId2() != null) { - if (!ModificationUtils.hasLimitSet(opLimitsGroupSide2, modificationInfos.getSelectedOperationalLimitsGroupId2())) { + if (selectedOperationalLimitsGroupId2 != null) { + if (!ModificationUtils.hasLimitSet(opLimitsGroupSide2, selectedOperationalLimitsGroupId2)) { limitSetsOnSideReportNodes.add(ReportNode.newRootReportNode() .withMessageTemplate("network.modification.limitSetAbsentOnSide2") - .withUntypedValue("selectedOperationalLimitsGroup", modificationInfos.getSelectedOperationalLimitsGroupId2()) + .withUntypedValue("selectedOperationalLimitsGroup", selectedOperationalLimitsGroupId2) .withSeverity(TypedValue.WARN_SEVERITY) .build()); } else { - line.setSelectedOperationalLimitsGroup2(modificationInfos.getSelectedOperationalLimitsGroupId2()); + line.setSelectedOperationalLimitsGroup2(selectedOperationalLimitsGroupId2); limitSetsOnSideReportNodes.add(ReportNode.newRootReportNode() .withMessageTemplate("network.modification.limitSetSelectedOnSide2") - .withUntypedValue("selectedOperationalLimitsGroup2", modificationInfos.getSelectedOperationalLimitsGroupId2()) + .withUntypedValue("selectedOperationalLimitsGroup2", selectedOperationalLimitsGroupId2) .withSeverity(TypedValue.INFO_SEVERITY) .build()); } @@ -155,13 +178,13 @@ public String getName() { return "LineCreation"; } - private void addLine(Network network, VoltageLevel voltageLevel1, VoltageLevel voltageLevel2, LineCreationInfos lineCreationInfos, boolean withSwitch1, boolean withSwitch2, + private void addLine(Network network, VoltageLevel voltageLevel1, VoltageLevel voltageLevel2, boolean withSwitch1, boolean withSwitch2, ReportNode subReportNode) { - ModificationUtils.getInstance().createLineAdder(network, voltageLevel1, voltageLevel2, lineCreationInfos, withSwitch1, withSwitch2).add(); + ModificationUtils.getInstance().createLineAdder(network, voltageLevel1, voltageLevel2, this, withSwitch1, withSwitch2).add(); subReportNode.newReportNode() .withMessageTemplate("network.modification.lineCreated") - .withUntypedValue("id", lineCreationInfos.getEquipmentId()) + .withUntypedValue("id", equipmentId) .withSeverity(TypedValue.INFO_SEVERITY) .add(); } diff --git a/src/main/java/org/gridsuite/modification/modifications/LineModification.java b/src/main/java/org/gridsuite/modification/modifications/LineModification.java index 3560c627..557eaa0c 100644 --- a/src/main/java/org/gridsuite/modification/modifications/LineModification.java +++ b/src/main/java/org/gridsuite/modification/modifications/LineModification.java @@ -10,13 +10,20 @@ import com.powsybl.iidm.network.Branch; import com.powsybl.iidm.network.Line; import com.powsybl.iidm.network.Network; +import com.powsybl.iidm.network.extensions.ConnectablePosition; +import lombok.Builder; +import lombok.Getter; +import lombok.Setter; import org.gridsuite.modification.NetworkModificationException; import org.gridsuite.modification.dto.AttributeModification; -import org.gridsuite.modification.dto.BranchModificationInfos; -import org.gridsuite.modification.dto.LineModificationInfos; +import org.gridsuite.modification.dto.FreePropertyInfos; +import org.gridsuite.modification.dto.OperationalLimitsGroupModificationInfos; +import org.gridsuite.modification.dto.OperationalLimitsGroupsModificationType; import org.gridsuite.modification.utils.ModificationUtils; import org.gridsuite.modification.utils.PropertiesUtils; +import java.util.List; + import static org.gridsuite.modification.NetworkModificationException.Type.LINE_NOT_FOUND; import static org.gridsuite.modification.NetworkModificationException.Type.MODIFY_LINE_ERROR; import static org.gridsuite.modification.utils.ModificationUtils.checkIsNotNegativeValue; @@ -25,44 +32,90 @@ /** * @author Ayoub Labidi */ +@Getter +@Setter public class LineModification extends AbstractBranchModification { private static final String MAGNETIZING_SUSCEPTANCE_MESSAGE = "Magnetizing susceptance"; private static final String MAGNETIZING_CONDUCTANCE_MESSAGE = "Magnetizing conductance"; public static final String ERROR_MESSAGE = "Line '%s' : "; - - public LineModification(LineModificationInfos modificationInfos) { - super(modificationInfos); + private AttributeModification g1; + private AttributeModification b1; + private AttributeModification g2; + private AttributeModification b2; + + @Builder + public LineModification(String equipmentId, List properties, + AttributeModification equipmentName, AttributeModification r, + AttributeModification x, + OperationalLimitsGroupsModificationType operationalLimitsGroupsModificationType, + Boolean enableOLGModification, + List operationalLimitsGroups, + AttributeModification selectedOperationalLimitsGroupId1, + AttributeModification selectedOperationalLimitsGroupId2, + AttributeModification voltageLevelId1, + AttributeModification voltageLevelId2, + AttributeModification busOrBusbarSectionId1, + AttributeModification busOrBusbarSectionId2, + AttributeModification connectionName1, + AttributeModification connectionName2, + AttributeModification connectionDirection1, + AttributeModification connectionDirection2, + AttributeModification connectionPosition1, + AttributeModification connectionPosition2, + AttributeModification terminal1Connected, + AttributeModification terminal2Connected, + AttributeModification p1MeasurementValue, + AttributeModification p1MeasurementValidity, + AttributeModification p2MeasurementValue, + AttributeModification p2MeasurementValidity, + AttributeModification q1MeasurementValue, + AttributeModification q1MeasurementValidity, + AttributeModification q2MeasurementValue, + AttributeModification q2MeasurementValidity, AttributeModification g1, + AttributeModification b1, AttributeModification g2, + AttributeModification b2) { + super(equipmentId, properties, equipmentName, r, x, operationalLimitsGroupsModificationType, + enableOLGModification, + operationalLimitsGroups, selectedOperationalLimitsGroupId1, selectedOperationalLimitsGroupId2, + voltageLevelId1, + voltageLevelId2, busOrBusbarSectionId1, busOrBusbarSectionId2, connectionName1, connectionName2, + connectionDirection1, connectionDirection2, connectionPosition1, connectionPosition2, terminal1Connected, + terminal2Connected, p1MeasurementValue, p1MeasurementValidity, p2MeasurementValue, p2MeasurementValidity, + q1MeasurementValue, q1MeasurementValidity, q2MeasurementValue, q2MeasurementValidity); + this.g1 = g1; + this.b1 = b1; + this.g2 = g2; + this.b2 = b2; } @Override public void check(Network network) throws NetworkModificationException { - Line line = network.getLine(modificationInfos.getEquipmentId()); - String errorMessage = "Line '" + modificationInfos.getEquipmentId() + "' : "; + Line line = network.getLine(equipmentId); + String errorMessage = "Line '" + equipmentId + "' : "; if (line == null) { throw new NetworkModificationException(LINE_NOT_FOUND, errorMessage + "does not exist in network"); } - ModificationUtils.getInstance().checkVoltageLevelModification(network, modificationInfos.getVoltageLevelId1(), - modificationInfos.getBusOrBusbarSectionId1(), line.getTerminal1()); - ModificationUtils.getInstance().checkVoltageLevelModification(network, modificationInfos.getVoltageLevelId2(), - modificationInfos.getBusOrBusbarSectionId2(), line.getTerminal2()); - LineModificationInfos lineModificationInfos = (LineModificationInfos) modificationInfos; - if (lineModificationInfos.getR() != null) { - checkIsNotNegativeValue(errorMessage, lineModificationInfos.getR().getValue(), MODIFY_LINE_ERROR, "Resistance R"); + ModificationUtils.getInstance().checkVoltageLevelModification(network, voltageLevelId1, + busOrBusbarSectionId1, line.getTerminal1()); + ModificationUtils.getInstance().checkVoltageLevelModification(network, voltageLevelId2, + busOrBusbarSectionId2, line.getTerminal2()); + if (r != null) { + checkIsNotNegativeValue(errorMessage, r.getValue(), MODIFY_LINE_ERROR, "Resistance R"); } - if (lineModificationInfos.getG1() != null) { - checkIsNotNegativeValue(errorMessage, lineModificationInfos.getG1().getValue(), MODIFY_LINE_ERROR, "Conductance on side 1 G1"); + if (g1 != null) { + checkIsNotNegativeValue(errorMessage, g1.getValue(), MODIFY_LINE_ERROR, "Conductance on side 1 G1"); } - if (lineModificationInfos.getG2() != null) { - checkIsNotNegativeValue(errorMessage, lineModificationInfos.getG2().getValue(), MODIFY_LINE_ERROR, "Conductance on side 2 G2"); + if (g2 != null) { + checkIsNotNegativeValue(errorMessage, g2.getValue(), MODIFY_LINE_ERROR, "Conductance on side 2 G2"); } } @Override public void apply(Network network, ReportNode subReportNode) { - Line line = network.getLine(modificationInfos.getEquipmentId()); + Line line = network.getLine(equipmentId); // modify the line in the network - modifyLine(line, modificationInfos, subReportNode); + modifyLine(line, subReportNode); } @Override @@ -70,57 +123,53 @@ public String getName() { return "LineModification"; } - private void modifyLine(Line line, BranchModificationInfos lineModificationInfos, ReportNode subReportNode) { - modifyBranch(line, lineModificationInfos, subReportNode, "network.modification.lineModification"); - updateMeasurements(line, lineModificationInfos, subReportNode); - PropertiesUtils.applyProperties(line, subReportNode, modificationInfos.getProperties(), "network.modification.LineProperties"); + private void modifyLine(Line line, ReportNode subReportNode) { + modifyBranch(line, subReportNode, "network.modification.lineModification"); + updateMeasurements(line, subReportNode); + PropertiesUtils.applyProperties(line, subReportNode, properties, "network.modification.LineProperties"); } @Override - protected void modifyCharacteristics(Branch branch, BranchModificationInfos branchModificationInfos, ReportNode subReportNode) { + protected void modifyCharacteristics(Branch branch, ReportNode subReportNode) { Line line = (Line) branch; ReportNode characteristicsReporter = subReportNode.newReportNode().withMessageTemplate("network.modification.characteristics").add(); - modifyR(line, branchModificationInfos.getR(), characteristicsReporter); - modifyX(line, branchModificationInfos.getX(), characteristicsReporter); + modifyR(line, r, characteristicsReporter); + modifyX(line, x, characteristicsReporter); - LineModificationInfos lineModificationInfos = (LineModificationInfos) branchModificationInfos; - modifySide1Characteristics(line, lineModificationInfos, characteristicsReporter); - modifySide2Characteristics(line, lineModificationInfos, characteristicsReporter); + modifySide1Characteristics(line, characteristicsReporter); + modifySide2Characteristics(line, characteristicsReporter); } - private void modifySide1Characteristics(Line line, LineModificationInfos lineModificationInfos, - ReportNode characteristicsReportNode) { - if (lineModificationInfos.getG1() != null && lineModificationInfos.getG1().getValue() != null - || lineModificationInfos.getB1() != null && lineModificationInfos.getB1().getValue() != null) { + private void modifySide1Characteristics(Line line, ReportNode characteristicsReportNode) { + if (g1 != null && g1.getValue() != null + || b1 != null && b1.getValue() != null) { ReportNode side1ReportNode = characteristicsReportNode.newReportNode().withMessageTemplate("network.modification.side1Characteristics").add(); - modifyG1(line, lineModificationInfos.getG1(), side1ReportNode); - modifyB1(line, lineModificationInfos.getB1(), side1ReportNode); + modifyG1(line, g1, side1ReportNode); + modifyB1(line, b1, side1ReportNode); } } - private void modifySide2Characteristics(Line line, LineModificationInfos lineModificationInfos, - ReportNode characteristicsReportNode) { - if (lineModificationInfos.getG2() != null && lineModificationInfos.getG2().getValue() != null - || lineModificationInfos.getB2() != null && lineModificationInfos.getB2().getValue() != null) { + private void modifySide2Characteristics(Line line, ReportNode characteristicsReportNode) { + if (g2 != null && g2.getValue() != null + || b2 != null && b2.getValue() != null) { ReportNode side2Reporter = characteristicsReportNode.newReportNode().withMessageTemplate("network.modification.side2Characteristics").add(); - modifyG2(line, lineModificationInfos.getG2(), side2Reporter); - modifyB2(line, lineModificationInfos.getB2(), side2Reporter); + modifyG2(line, g2, side2Reporter); + modifyB2(line, b2, side2Reporter); } } @Override - protected boolean characteristicsModified(BranchModificationInfos branchModificationInfos) { - LineModificationInfos lineModificationInfos = (LineModificationInfos) branchModificationInfos; - return super.characteristicsModified(branchModificationInfos) - || lineModificationInfos.getG1() != null - && lineModificationInfos.getG1().getValue() != null - || lineModificationInfos.getB1() != null - && lineModificationInfos.getB1().getValue() != null - || lineModificationInfos.getG2() != null - && lineModificationInfos.getG2().getValue() != null - || lineModificationInfos.getB2() != null - && lineModificationInfos.getB2().getValue() != null; + protected boolean characteristicsModified() { + return super.characteristicsModified() + || g1 != null + && g1.getValue() != null + || b1 != null + && b1.getValue() != null + || g2 != null + && g2.getValue() != null + || b2 != null + && b2.getValue() != null; } public static void modifyX(Line line, AttributeModification modifX, ReportNode reportNode) { diff --git a/src/main/java/org/gridsuite/modification/modifications/LineSplitWithVoltageLevel.java b/src/main/java/org/gridsuite/modification/modifications/LineSplitWithVoltageLevel.java index 091b14af..e8329e79 100644 --- a/src/main/java/org/gridsuite/modification/modifications/LineSplitWithVoltageLevel.java +++ b/src/main/java/org/gridsuite/modification/modifications/LineSplitWithVoltageLevel.java @@ -12,9 +12,8 @@ import com.powsybl.iidm.modification.topology.DefaultNamingStrategy; import com.powsybl.iidm.modification.topology.NamingStrategy; import com.powsybl.iidm.network.Network; +import lombok.*; import org.gridsuite.modification.NetworkModificationException; -import org.gridsuite.modification.dto.LineSplitWithVoltageLevelInfos; -import org.gridsuite.modification.dto.VoltageLevelCreationInfos; import org.gridsuite.modification.utils.ModificationUtils; import org.springframework.lang.NonNull; @@ -24,27 +23,35 @@ /** * @author Slimane Amar */ +@Getter +@Setter +@AllArgsConstructor +@Builder public class LineSplitWithVoltageLevel extends AbstractModification { - private final LineSplitWithVoltageLevelInfos modificationInfos; - - public LineSplitWithVoltageLevel(LineSplitWithVoltageLevelInfos modificationInfos) { - this.modificationInfos = modificationInfos; - } + private String lineToSplitId; + private double percent; + private VoltageLevelCreation mayNewVoltageLevel; + private String existingVoltageLevelId; + private String bbsOrBusId; + private String newLine1Id; + private String newLine1Name; + private String newLine2Id; + private String newLine2Name; @Override public void check(@NonNull Network network) throws NetworkModificationException { - if (network.getLine(modificationInfos.getLineToSplitId()) == null) { - throw new NetworkModificationException(LINE_NOT_FOUND, modificationInfos.getLineToSplitId()); + if (network.getLine(lineToSplitId) == null) { + throw new NetworkModificationException(LINE_NOT_FOUND, lineToSplitId); } - ModificationUtils.getInstance().controlNewOrExistingVoltageLevel(modificationInfos.getMayNewVoltageLevelInfos(), - modificationInfos.getExistingVoltageLevelId(), modificationInfos.getBbsOrBusId(), network); + ModificationUtils.getInstance().controlNewOrExistingVoltageLevel(mayNewVoltageLevel, + existingVoltageLevelId, bbsOrBusId, network); // check future lines don't exist - if (network.getLine(modificationInfos.getNewLine1Id()) != null) { - throw new NetworkModificationException(LINE_ALREADY_EXISTS, modificationInfos.getNewLine1Id()); + if (network.getLine(newLine1Id) != null) { + throw new NetworkModificationException(LINE_ALREADY_EXISTS, newLine1Id); } - if (network.getLine(modificationInfos.getNewLine2Id()) != null) { - throw new NetworkModificationException(LINE_ALREADY_EXISTS, modificationInfos.getNewLine2Id()); + if (network.getLine(newLine2Id) != null) { + throw new NetworkModificationException(LINE_ALREADY_EXISTS, newLine2Id); } } @@ -55,18 +62,17 @@ public void apply(Network network, ReportNode subReportNode) { @Override public void apply(Network network, NamingStrategy namingStrategy, ReportNode subReportNode) { - VoltageLevelCreationInfos mayNewVL = modificationInfos.getMayNewVoltageLevelInfos(); - if (mayNewVL != null) { - ModificationUtils.getInstance().createVoltageLevel(mayNewVL, subReportNode, network, namingStrategy); + if (mayNewVoltageLevel != null) { + ModificationUtils.getInstance().createVoltageLevel(mayNewVoltageLevel, subReportNode, network, namingStrategy); } ConnectVoltageLevelOnLine algo = new ConnectVoltageLevelOnLineBuilder() - .withPositionPercent(modificationInfos.getPercent()) - .withBusbarSectionOrBusId(modificationInfos.getBbsOrBusId()) - .withLine1Id(modificationInfos.getNewLine1Id()) - .withLine1Name(modificationInfos.getNewLine1Name()) - .withLine2Id(modificationInfos.getNewLine2Id()) - .withLine2Name(modificationInfos.getNewLine2Name()) - .withLine(network.getLine(modificationInfos.getLineToSplitId())) + .withPositionPercent(percent) + .withBusbarSectionOrBusId(bbsOrBusId) + .withLine1Id(newLine1Id) + .withLine1Name(newLine1Name) + .withLine2Id(newLine2Id) + .withLine2Name(newLine2Name) + .withLine(network.getLine(lineToSplitId)) .build(); algo.apply(network, true, subReportNode); diff --git a/src/main/java/org/gridsuite/modification/modifications/LinesAttachToSplitLines.java b/src/main/java/org/gridsuite/modification/modifications/LinesAttachToSplitLines.java index 4dac7b5b..ca6a44a6 100644 --- a/src/main/java/org/gridsuite/modification/modifications/LinesAttachToSplitLines.java +++ b/src/main/java/org/gridsuite/modification/modifications/LinesAttachToSplitLines.java @@ -11,8 +11,8 @@ import com.powsybl.iidm.modification.topology.ReplaceTeePointByVoltageLevelOnLineBuilder; import com.powsybl.iidm.network.Network; import com.powsybl.iidm.network.VoltageLevel; +import lombok.*; import org.gridsuite.modification.NetworkModificationException; -import org.gridsuite.modification.dto.LinesAttachToSplitLinesInfos; import org.gridsuite.modification.utils.ModificationUtils; import static org.gridsuite.modification.NetworkModificationException.Type.LINE_ALREADY_EXISTS; @@ -21,48 +21,56 @@ /** * @author David Braquart */ +@Getter +@Setter +@AllArgsConstructor +@Builder public class LinesAttachToSplitLines extends AbstractModification { - private final LinesAttachToSplitLinesInfos modificationInfos; - - public LinesAttachToSplitLines(LinesAttachToSplitLinesInfos modificationInfos) { - this.modificationInfos = modificationInfos; - } + private String lineToAttachTo1Id; + private String lineToAttachTo2Id; + private String attachedLineId; + private String voltageLevelId; + private String bbsBusId; + private String replacingLine1Id; + private String replacingLine1Name; + private String replacingLine2Id; + private String replacingLine2Name; @Override public void check(Network network) throws NetworkModificationException { // check existing lines, vl and busbar - if (network.getLine(modificationInfos.getLineToAttachTo1Id()) == null) { - throw new NetworkModificationException(LINE_NOT_FOUND, modificationInfos.getLineToAttachTo1Id()); + if (network.getLine(lineToAttachTo1Id) == null) { + throw new NetworkModificationException(LINE_NOT_FOUND, lineToAttachTo1Id); } - if (network.getLine(modificationInfos.getLineToAttachTo2Id()) == null) { - throw new NetworkModificationException(LINE_NOT_FOUND, modificationInfos.getLineToAttachTo2Id()); + if (network.getLine(lineToAttachTo2Id) == null) { + throw new NetworkModificationException(LINE_NOT_FOUND, lineToAttachTo2Id); } - if (network.getLine(modificationInfos.getAttachedLineId()) == null) { - throw new NetworkModificationException(LINE_NOT_FOUND, modificationInfos.getAttachedLineId()); + if (network.getLine(attachedLineId) == null) { + throw new NetworkModificationException(LINE_NOT_FOUND, attachedLineId); } - VoltageLevel vl = ModificationUtils.getInstance().getVoltageLevel(network, modificationInfos.getVoltageLevelId()); - ModificationUtils.getInstance().controlBus(vl, modificationInfos.getBbsBusId()); + VoltageLevel vl = ModificationUtils.getInstance().getVoltageLevel(network, voltageLevelId); + ModificationUtils.getInstance().controlBus(vl, bbsBusId); // check future lines don't exist - if (network.getLine(modificationInfos.getReplacingLine1Id()) != null) { - throw new NetworkModificationException(LINE_ALREADY_EXISTS, modificationInfos.getReplacingLine1Id()); + if (network.getLine(replacingLine1Id) != null) { + throw new NetworkModificationException(LINE_ALREADY_EXISTS, replacingLine1Id); } - if (network.getLine(modificationInfos.getReplacingLine2Id()) != null) { - throw new NetworkModificationException(LINE_ALREADY_EXISTS, modificationInfos.getReplacingLine2Id()); + if (network.getLine(replacingLine2Id) != null) { + throw new NetworkModificationException(LINE_ALREADY_EXISTS, replacingLine2Id); } } @Override public void apply(Network network, ReportNode subReportNode) { ReplaceTeePointByVoltageLevelOnLine algo = new ReplaceTeePointByVoltageLevelOnLineBuilder() - .withTeePointLine1(modificationInfos.getLineToAttachTo1Id()) - .withTeePointLine2(modificationInfos.getLineToAttachTo2Id()) - .withTeePointLineToRemove(modificationInfos.getAttachedLineId()) - .withBbsOrBusId(modificationInfos.getBbsBusId()) - .withNewLine1Id(modificationInfos.getReplacingLine1Id()) - .withNewLine1Name(modificationInfos.getReplacingLine1Name()) - .withNewLine2Id(modificationInfos.getReplacingLine2Id()) - .withNewLine2Name(modificationInfos.getReplacingLine2Name()) + .withTeePointLine1(lineToAttachTo1Id) + .withTeePointLine2(lineToAttachTo2Id) + .withTeePointLineToRemove(attachedLineId) + .withBbsOrBusId(bbsBusId) + .withNewLine1Id(replacingLine1Id) + .withNewLine1Name(replacingLine1Name) + .withNewLine2Id(replacingLine2Id) + .withNewLine2Name(replacingLine2Name) .build(); algo.apply(network, true, subReportNode); } diff --git a/src/main/java/org/gridsuite/modification/modifications/LoadCreation.java b/src/main/java/org/gridsuite/modification/modifications/LoadCreation.java index 821fe26b..53d827cf 100644 --- a/src/main/java/org/gridsuite/modification/modifications/LoadCreation.java +++ b/src/main/java/org/gridsuite/modification/modifications/LoadCreation.java @@ -9,55 +9,72 @@ import com.powsybl.commons.report.ReportNode; import com.powsybl.commons.report.TypedValue; import com.powsybl.iidm.network.*; +import com.powsybl.iidm.network.extensions.ConnectablePosition; +import lombok.*; import org.gridsuite.modification.NetworkModificationException; -import org.gridsuite.modification.dto.LoadCreationInfos; +import org.gridsuite.modification.dto.FreePropertyInfos; import org.gridsuite.modification.utils.ModificationUtils; import org.gridsuite.modification.utils.PropertiesUtils; +import java.util.List; + import static org.gridsuite.modification.NetworkModificationException.Type.LOAD_ALREADY_EXISTS; import static org.gridsuite.modification.utils.ModificationUtils.createInjectionInNodeBreaker; /** * @author Slimane Amar */ -public class LoadCreation extends AbstractModification { - - private final LoadCreationInfos modificationInfos; - - public LoadCreation(LoadCreationInfos modificationInfos) { - this.modificationInfos = modificationInfos; +@Getter +@Setter +public class LoadCreation extends AbstractInjectionCreation { + + private LoadType loadType; + private double p0; + private double q0; + + @Builder + public LoadCreation(String equipmentId, List properties, String equipmentName, + String voltageLevelId, + String busOrBusbarSectionId, String connectionName, + ConnectablePosition.Direction connectionDirection, Integer connectionPosition, + boolean terminalConnected, LoadType loadType, double p0, double q0) { + super(equipmentId, properties, equipmentName, voltageLevelId, busOrBusbarSectionId, connectionName, + connectionDirection, connectionPosition, terminalConnected); + this.loadType = loadType; + this.p0 = p0; + this.q0 = q0; } @Override public void check(Network network) throws NetworkModificationException { - if (network.getLoad(modificationInfos.getEquipmentId()) != null) { - throw new NetworkModificationException(LOAD_ALREADY_EXISTS, modificationInfos.getEquipmentId()); + if (network.getLoad(equipmentId) != null) { + throw new NetworkModificationException(LOAD_ALREADY_EXISTS, equipmentId); } - ModificationUtils.getInstance().controlConnectivity(network, modificationInfos.getVoltageLevelId(), - modificationInfos.getBusOrBusbarSectionId()); + ModificationUtils.getInstance().controlConnectivity(network, voltageLevelId, + busOrBusbarSectionId); } @Override public void apply(Network network, ReportNode subReporter) { // create the load in the network - VoltageLevel voltageLevel = ModificationUtils.getInstance().getVoltageLevel(network, modificationInfos.getVoltageLevelId()); + VoltageLevel voltageLevel = ModificationUtils.getInstance().getVoltageLevel(network, voltageLevelId); if (voltageLevel.getTopologyKind() == TopologyKind.NODE_BREAKER) { - LoadAdder loadAdder = createLoadAdderInNodeBreaker(voltageLevel, modificationInfos); - createInjectionInNodeBreaker(voltageLevel, modificationInfos, network, loadAdder, subReporter); + LoadAdder loadAdder = createLoadAdderInNodeBreaker(voltageLevel); + createInjectionInNodeBreaker(voltageLevel, this, network, loadAdder, subReporter); } else { - createLoadInBusBreaker(voltageLevel, modificationInfos); + createLoadInBusBreaker(voltageLevel); subReporter.newReportNode() .withMessageTemplate("network.modification.loadCreated") - .withUntypedValue("id", modificationInfos.getEquipmentId()) + .withUntypedValue("id", equipmentId) .withSeverity(TypedValue.INFO_SEVERITY) .add(); } reportElementaryCreations(subReporter); - ModificationUtils.getInstance().disconnectCreatedInjection(modificationInfos, network.getLoad(modificationInfos.getEquipmentId()), subReporter); + ModificationUtils.getInstance().disconnectCreatedInjection(this, network.getLoad(equipmentId), subReporter); // properties - Load load = network.getLoad(modificationInfos.getEquipmentId()); - PropertiesUtils.applyProperties(load, subReporter, modificationInfos.getProperties(), "network.modification.LoadProperties"); + Load load = network.getLoad(equipmentId); + PropertiesUtils.applyProperties(load, subReporter, properties, "network.modification.LoadProperties"); } @Override @@ -66,44 +83,45 @@ public String getName() { } private void reportElementaryCreations(ReportNode subReportNode) { - if (modificationInfos.getEquipmentName() != null) { + if (equipmentName != null) { ModificationUtils.getInstance() - .reportElementaryCreation(subReportNode, modificationInfos.getEquipmentName(), "Name"); + .reportElementaryCreation(subReportNode, equipmentName, "Name"); } - if (modificationInfos.getLoadType() != null) { + if (loadType != null) { ModificationUtils.getInstance() - .reportElementaryCreation(subReportNode, modificationInfos.getLoadType(), "Type"); + .reportElementaryCreation(subReportNode, loadType, "Type"); } ModificationUtils.getInstance() - .reportElementaryCreation(subReportNode, modificationInfos.getP0(), "Active power"); + .reportElementaryCreation(subReportNode, p0, "Active power"); ModificationUtils.getInstance() - .reportElementaryCreation(subReportNode, modificationInfos.getQ0(), "Reactive power"); + .reportElementaryCreation(subReportNode, q0, "Reactive power"); } - private LoadAdder createLoadAdderInNodeBreaker(VoltageLevel voltageLevel, LoadCreationInfos loadCreationInfos) { + private LoadAdder createLoadAdderInNodeBreaker(VoltageLevel voltageLevel) { // creating the load adder return voltageLevel.newLoad() - .setId(loadCreationInfos.getEquipmentId()) - .setName(loadCreationInfos.getEquipmentName()) - .setLoadType(loadCreationInfos.getLoadType()) - .setP0(loadCreationInfos.getP0()) - .setQ0(loadCreationInfos.getQ0()); + .setId(equipmentId) + .setName(equipmentName) + .setLoadType(loadType) + .setP0(p0) + .setQ0(q0); } - private Load createLoadInBusBreaker(VoltageLevel voltageLevel, LoadCreationInfos loadCreationInfos) { - Bus bus = ModificationUtils.getInstance().getBusBreakerBus(voltageLevel, loadCreationInfos.getBusOrBusbarSectionId()); + private Load createLoadInBusBreaker(VoltageLevel voltageLevel) { + Bus bus = ModificationUtils.getInstance().getBusBreakerBus(voltageLevel, busOrBusbarSectionId); // creating the load return voltageLevel.newLoad() - .setId(loadCreationInfos.getEquipmentId()) - .setName(loadCreationInfos.getEquipmentName()) - .setLoadType(loadCreationInfos.getLoadType()) + .setId(equipmentId) + .setName(equipmentName) + .setLoadType(loadType) .setBus(bus.getId()) .setConnectableBus(bus.getId()) - .setP0(loadCreationInfos.getP0()) - .setQ0(loadCreationInfos.getQ0()).add(); + .setP0(p0) + .setQ0(q0).add(); } + } diff --git a/src/main/java/org/gridsuite/modification/modifications/LoadModification.java b/src/main/java/org/gridsuite/modification/modifications/LoadModification.java index 8b2cb015..d1055ca9 100644 --- a/src/main/java/org/gridsuite/modification/modifications/LoadModification.java +++ b/src/main/java/org/gridsuite/modification/modifications/LoadModification.java @@ -9,40 +9,70 @@ import com.powsybl.commons.report.ReportNode; import com.powsybl.commons.report.TypedValue; import com.powsybl.iidm.network.Load; +import com.powsybl.iidm.network.LoadType; import com.powsybl.iidm.network.Network; import com.powsybl.iidm.network.extensions.ConnectablePosition; import com.powsybl.iidm.network.extensions.ConnectablePositionAdder; +import lombok.Builder; +import lombok.Getter; +import lombok.Setter; import org.gridsuite.modification.NetworkModificationException; import org.gridsuite.modification.dto.AttributeModification; -import org.gridsuite.modification.dto.LoadModificationInfos; +import org.gridsuite.modification.dto.FreePropertyInfos; import org.gridsuite.modification.utils.ModificationUtils; import org.gridsuite.modification.utils.PropertiesUtils; +import java.util.List; + import static org.gridsuite.modification.NetworkModificationException.Type.LOAD_NOT_FOUND; /** * @author Ayoub Labidi */ +@Getter +@Setter public class LoadModification extends AbstractInjectionModification { - public LoadModification(LoadModificationInfos modificationInfos) { - super(modificationInfos); + private AttributeModification loadType; + private AttributeModification p0; + private AttributeModification q0; + + @Builder + public LoadModification(String equipmentId, List properties, + AttributeModification equipmentName, AttributeModification voltageLevelId, + AttributeModification busOrBusbarSectionId, + AttributeModification connectionName, + AttributeModification connectionDirection, + AttributeModification connectionPosition, + AttributeModification terminalConnected, + AttributeModification pMeasurementValue, + AttributeModification pMeasurementValidity, + AttributeModification qMeasurementValue, + AttributeModification qMeasurementValidity, + AttributeModification loadType, + AttributeModification p0, AttributeModification q0) { + super(equipmentId, properties, equipmentName, voltageLevelId, busOrBusbarSectionId, connectionName, + connectionDirection, connectionPosition, terminalConnected, pMeasurementValue, pMeasurementValidity, + qMeasurementValue, qMeasurementValidity); + this.loadType = loadType; + this.p0 = p0; + this.q0 = q0; } @Override public void check(Network network) throws NetworkModificationException { - Load load = network.getLoad(modificationInfos.getEquipmentId()); + Load load = network.getLoad(equipmentId); if (load == null) { throw new NetworkModificationException(LOAD_NOT_FOUND, - "Load " + modificationInfos.getEquipmentId() + " does not exist in network"); + "Load " + equipmentId + " does not exist in network"); } - ModificationUtils.getInstance().checkVoltageLevelModification(network, modificationInfos.getVoltageLevelId(), - modificationInfos.getBusOrBusbarSectionId(), load.getTerminal()); + ModificationUtils.getInstance().checkVoltageLevelModification(network, voltageLevelId, + busOrBusbarSectionId, load.getTerminal()); } @Override public void apply(Network network, ReportNode subReportNode) { - Load load = network.getLoad(modificationInfos.getEquipmentId()); + Load load = network.getLoad(equipmentId); // modify the load in the network modifyLoad(load, subReportNode); } @@ -53,23 +83,22 @@ public String getName() { } private void modifyLoad(Load load, ReportNode subReportNode) { - LoadModificationInfos loadModificationInfos = (LoadModificationInfos) modificationInfos; subReportNode.newReportNode() .withMessageTemplate("network.modification.loadModification") - .withUntypedValue("id", loadModificationInfos.getEquipmentId()) + .withUntypedValue("id", equipmentId) .withSeverity(TypedValue.INFO_SEVERITY) .add(); - ModificationUtils.getInstance().applyElementaryModifications(load::setName, () -> load.getOptionalName().orElse("No value"), loadModificationInfos.getEquipmentName(), subReportNode, "Name"); - ModificationUtils.getInstance().applyElementaryModifications(load::setLoadType, load::getLoadType, loadModificationInfos.getLoadType(), subReportNode, "Type"); - modifyLoadVoltageLevelBusOrBusBarSectionAttributes(loadModificationInfos, load, subReportNode); - modifyLoadConnectivityAttributes(loadModificationInfos, load, subReportNode); - modifyP0(load, loadModificationInfos.getP0(), subReportNode); - modifyQ0(load, loadModificationInfos.getQ0(), subReportNode); + ModificationUtils.getInstance().applyElementaryModifications(load::setName, () -> load.getOptionalName().orElse("No value"), equipmentName, subReportNode, "Name"); + ModificationUtils.getInstance().applyElementaryModifications(load::setLoadType, load::getLoadType, loadType, subReportNode, "Type"); + modifyLoadVoltageLevelBusOrBusBarSectionAttributes(load, subReportNode); + modifyLoadConnectivityAttributes(load, subReportNode); + modifyP0(load, p0, subReportNode); + modifyQ0(load, q0, subReportNode); // measurements updateMeasurements(load, subReportNode); // properties - PropertiesUtils.applyProperties(load, subReportNode, loadModificationInfos.getProperties(), "network.modification.LoadProperties"); + PropertiesUtils.applyProperties(load, subReportNode, properties, "network.modification.LoadProperties"); } public static void modifyQ0(Load load, AttributeModification q0, ReportNode subReportNode) { @@ -80,21 +109,19 @@ public static void modifyP0(Load load, AttributeModification p0, ReportN ModificationUtils.getInstance().applyElementaryModifications(load::setP0, load::getP0, p0, subReportNode, "Constant active power"); } - private void modifyLoadVoltageLevelBusOrBusBarSectionAttributes(LoadModificationInfos modificationInfos, - Load load, ReportNode subReportNode) { + private void modifyLoadVoltageLevelBusOrBusBarSectionAttributes(Load load, ReportNode subReportNode) { ModificationUtils.getInstance().moveFeederBay( load, load.getTerminal(), - modificationInfos.getVoltageLevelId(), - modificationInfos.getBusOrBusbarSectionId(), + voltageLevelId, + busOrBusbarSectionId, subReportNode ); } - private ReportNode modifyLoadConnectivityAttributes(LoadModificationInfos loadModificationInfos, - Load load, ReportNode subReportNode) { + private ReportNode modifyLoadConnectivityAttributes(Load load, ReportNode subReportNode) { ConnectablePosition connectablePosition = load.getExtension(ConnectablePosition.class); ConnectablePositionAdder connectablePositionAdder = load.newExtension(ConnectablePositionAdder.class); - return ModificationUtils.getInstance().modifyInjectionConnectivityAttributes(connectablePosition, connectablePositionAdder, load, loadModificationInfos, subReportNode); + return ModificationUtils.getInstance().modifyInjectionConnectivityAttributes(connectablePosition, connectablePositionAdder, load, this, subReportNode); } } diff --git a/src/main/java/org/gridsuite/modification/modifications/LoadScaling.java b/src/main/java/org/gridsuite/modification/modifications/LoadScaling.java index 09e7c506..cd7745ca 100644 --- a/src/main/java/org/gridsuite/modification/modifications/LoadScaling.java +++ b/src/main/java/org/gridsuite/modification/modifications/LoadScaling.java @@ -12,11 +12,13 @@ import com.powsybl.iidm.modification.scalable.ScalingParameters; import com.powsybl.iidm.network.Load; import com.powsybl.iidm.network.Network; +import lombok.Builder; +import lombok.Getter; +import lombok.Setter; import org.gridsuite.modification.NetworkModificationException; import org.gridsuite.modification.VariationMode; import org.gridsuite.modification.VariationType; import org.gridsuite.modification.dto.IdentifiableAttributes; -import org.gridsuite.modification.dto.LoadScalingInfos; import org.gridsuite.modification.dto.ScalingVariationInfos; import org.gridsuite.modification.utils.ModificationUtils; @@ -27,10 +29,13 @@ /** * @author bendaamerahm */ +@Getter +@Setter public class LoadScaling extends AbstractScaling { - public LoadScaling(LoadScalingInfos loadScalableInfos) { - super(loadScalableInfos); + @Builder + public LoadScaling(List variations, VariationType variationType, NetworkModificationException.Type errorType) { + super(variations, variationType, errorType); } @Override @@ -107,13 +112,13 @@ protected void applyProportionalVariation(Network network, ReportNode subReportN @Override protected void applyProportionalToPmaxVariation(Network network, ReportNode subReportNode, Set identifiableAttributes, ScalingVariationInfos scalingVariationInfos) { // no implementation for load scaling - throw new NetworkModificationException(scalingInfos.getErrorType(), String.format("This variation mode is not supported : %s", scalingVariationInfos.getVariationMode().name())); + throw new NetworkModificationException(errorType, String.format("This variation mode is not supported : %s", scalingVariationInfos.getVariationMode().name())); } @Override protected void applyStackingUpVariation(Network network, ReportNode subReportNode, Set identifiableAttributes, ScalingVariationInfos scalingVariationInfos) { // no implementation for load scaling - throw new NetworkModificationException(scalingInfos.getErrorType(), String.format("This variation mode is not supported : %s", scalingVariationInfos.getVariationMode().name())); + throw new NetworkModificationException(errorType, String.format("This variation mode is not supported : %s", scalingVariationInfos.getVariationMode().name())); } private double scale(Network network, ScalingVariationInfos scalingVariationInfos, double asked, Scalable proportionalScalable) { @@ -127,7 +132,7 @@ private double scale(Network network, ScalingVariationInfos scalingVariationInfo @Override public double getAsked(ScalingVariationInfos scalingVariationInfos, AtomicReference sum) { - return scalingInfos.getVariationType() == VariationType.DELTA_P + return variationType == VariationType.DELTA_P ? scalingVariationInfos.getVariationValue() : scalingVariationInfos.getVariationValue() - sum.get(); } diff --git a/src/main/java/org/gridsuite/modification/modifications/ModificationReference.java b/src/main/java/org/gridsuite/modification/modifications/ModificationReference.java index 0ffa6d32..112e11b2 100644 --- a/src/main/java/org/gridsuite/modification/modifications/ModificationReference.java +++ b/src/main/java/org/gridsuite/modification/modifications/ModificationReference.java @@ -10,23 +10,39 @@ import com.powsybl.iidm.modification.topology.DefaultNamingStrategy; import com.powsybl.iidm.modification.topology.NamingStrategy; import com.powsybl.iidm.network.Network; +import lombok.Builder; +import lombok.Getter; +import lombok.Setter; import org.gridsuite.modification.IFilterService; import org.gridsuite.modification.ILoadFlowService; import org.gridsuite.modification.ModificationType; +import org.gridsuite.modification.dto.ModificationInfos; import org.gridsuite.modification.dto.ModificationReferenceInfos; +import java.util.Objects; +import java.util.UUID; + /** * @author Slimane Amar */ +@Getter +@Setter public class ModificationReference extends AbstractModification { - private final ModificationReferenceInfos modificationReferenceInfos; + private UUID referenceId; + private ModificationReferenceInfos.Type referenceType; + private ModificationInfos referenceInfos; protected IFilterService filterService; protected ILoadFlowService loadFlowService; - public ModificationReference(ModificationReferenceInfos modificationReferenceInfos) { - this.modificationReferenceInfos = modificationReferenceInfos; + @Builder + public ModificationReference(UUID referenceId, + ModificationReferenceInfos.Type referenceType, + ModificationInfos referenceInfos) { + this.referenceId = referenceId; + this.referenceType = referenceType; + this.referenceInfos = referenceInfos; } @Override @@ -38,7 +54,10 @@ public void initApplicationContext(IFilterService filterService, ILoadFlowServic @Override public void check(Network network) { super.check(network); - modificationReferenceInfos.check(); + Objects.requireNonNull(referenceId, "referenceId is required"); + Objects.requireNonNull(referenceType, "referenceType is required"); + Objects.requireNonNull(referenceInfos, "referenceInfos is required"); + referenceInfos.check(); } @Override @@ -48,10 +67,10 @@ public void apply(Network network, ReportNode subReportNode) { @Override public void apply(Network network, NamingStrategy namingStrategy, ReportNode subReportNode) { - AbstractModification modification = modificationReferenceInfos.getReferenceInfos().toModification(); + AbstractModification modification = referenceInfos.toModification(); modification.check(network); modification.initApplicationContext(filterService, loadFlowService); - modification.apply(network, namingStrategy, modificationReferenceInfos.getReferenceInfos().createSubReportNode(subReportNode)); + modification.apply(network, namingStrategy, referenceInfos.createSubReportNode(subReportNode)); } @Override diff --git a/src/main/java/org/gridsuite/modification/modifications/MoveVoltageLevelFeederBays.java b/src/main/java/org/gridsuite/modification/modifications/MoveVoltageLevelFeederBays.java index 305b01d8..51d7446e 100644 --- a/src/main/java/org/gridsuite/modification/modifications/MoveVoltageLevelFeederBays.java +++ b/src/main/java/org/gridsuite/modification/modifications/MoveVoltageLevelFeederBays.java @@ -11,11 +11,13 @@ import com.powsybl.iidm.network.*; import com.powsybl.iidm.network.extensions.ConnectablePosition; import com.powsybl.iidm.network.extensions.ConnectablePositionAdder; +import lombok.*; import org.gridsuite.modification.ModificationType; import org.gridsuite.modification.NetworkModificationException; import org.gridsuite.modification.dto.*; import org.gridsuite.modification.utils.ModificationUtils; +import java.util.List; import java.util.function.Consumer; import static org.gridsuite.modification.NetworkModificationException.Type.MOVE_VOLTAGE_LEVEL_FEEDER_BAYS_ERROR; @@ -23,22 +25,23 @@ /** * @author Etienne Lesot */ +@Getter +@Setter +@AllArgsConstructor +@Builder public class MoveVoltageLevelFeederBays extends AbstractModification { private static final String VOLTAGE_LEVEL_NOT_FOUND = "Voltage level %s is not found"; private static final String BUSBAR_NOT_FOUND = "Bus or busbar section %s where connectable %s is supposed to be is not found in voltage level %s"; private static final String UNSUPPORTED_CONNECTABLE = "MoveVoltageLevelFeederBays is not implemented for %s"; private static final String INVALID_CONNECTION_SIDE = "Invalid connection side: %s for branch %s"; - private final MoveVoltageLevelFeederBaysInfos modificationInfos; - - public MoveVoltageLevelFeederBays(MoveVoltageLevelFeederBaysInfos modificationInfos) { - this.modificationInfos = modificationInfos; - } + private String voltageLevelId; + private List feederBays; @Override public void check(Network network) throws NetworkModificationException { - VoltageLevel voltageLevel = getVoltageLevelOrThrow(network, modificationInfos.getVoltageLevelId()); - for (MoveFeederBayInfos info : modificationInfos.getFeederBays()) { + VoltageLevel voltageLevel = getVoltageLevelOrThrow(network, voltageLevelId); + for (MoveFeederBayInfos info : feederBays) { checkBusOrBusbarSectionExist(voltageLevel, info); checkConnectable(network, info); } @@ -58,7 +61,7 @@ private void checkBusOrBusbarSectionExist(VoltageLevel voltageLevel, MoveFeederB : voltageLevel.getBusBreakerView().getBus(info.getBusbarSectionId()) != null; if (!busOrBusbarSectionExists) { throw new NetworkModificationException(MOVE_VOLTAGE_LEVEL_FEEDER_BAYS_ERROR, String.format(BUSBAR_NOT_FOUND, - info.getBusbarSectionId(), info.getEquipmentId(), modificationInfos.getVoltageLevelId())); + info.getBusbarSectionId(), info.getEquipmentId(), voltageLevelId)); } } @@ -71,7 +74,7 @@ private void checkConnectable(Network network, MoveFeederBayInfos info) { @Override public void apply(Network network, ReportNode subReportNode) { - for (MoveFeederBayInfos info : modificationInfos.getFeederBays()) { + for (MoveFeederBayInfos info : feederBays) { Connectable connectable = network.getConnectable(info.getEquipmentId()); if (connectable != null) { modifyConnectablePosition(network, connectable, info, subReportNode); @@ -96,44 +99,61 @@ private void modifyConnectablePosition(Network network, Connectable connectab switch (connectable) { case Injection injection -> { - InjectionModificationInfos injectionModificationInfos = buildInjectionModificationInfos(newConnectablePositionInfos); - ModificationUtils.getInstance().modifyInjectionConnectivityAttributes(oldConnectablePosition, connectablePositionAdder, injection, injectionModificationInfos, subReportNode); + AbstractInjectionModification injectionModification = buildInjectionModification(newConnectablePositionInfos); + ModificationUtils.getInstance().modifyInjectionConnectivityAttributes(oldConnectablePosition, connectablePositionAdder, injection, injectionModification, subReportNode); } case Branch branch -> { - BranchModificationInfos branchModificationInfos = buildBranchModificationInfos(newConnectablePositionInfos); - ModificationUtils.getInstance().modifyBranchConnectivityAttributes(oldConnectablePosition, connectablePositionAdder, branch, branchModificationInfos, subReportNode); + AbstractBranchModification branchModification = buildBranchModification(newConnectablePositionInfos); + ModificationUtils.getInstance().modifyBranchConnectivityAttributes(oldConnectablePosition, connectablePositionAdder, branch, branchModification, subReportNode); } default -> throw new NetworkModificationException(MOVE_VOLTAGE_LEVEL_FEEDER_BAYS_ERROR, String.format(UNSUPPORTED_CONNECTABLE, connectable.getClass())); } moveFeederBay(network, connectable, newConnectablePositionInfos, subReportNode); } - private InjectionModificationInfos buildInjectionModificationInfos(MoveFeederBayInfos newConnectablePositionInfos) { - InjectionModificationInfos injectionInfos = new InjectionModificationInfos(); - injectionInfos.setEquipmentId(newConnectablePositionInfos.getEquipmentId()); - setConnectionAttributes(injectionInfos::setConnectionPosition, - injectionInfos::setConnectionName, - injectionInfos::setConnectionDirection, - newConnectablePositionInfos); - return injectionInfos; + private AbstractInjectionModification buildInjectionModification(MoveFeederBayInfos newConnectablePositionInfos) { + AbstractInjectionModification injectionModification = new AbstractInjectionModification() { + @Override + public String getName() { + return ""; + } + }; + injectionModification.setEquipmentId(newConnectablePositionInfos.getEquipmentId()); + setConnectionAttributes(injectionModification::setConnectionPosition, + injectionModification::setConnectionName, + injectionModification::setConnectionDirection, + newConnectablePositionInfos); + return injectionModification; } - private BranchModificationInfos buildBranchModificationInfos(MoveFeederBayInfos info) { - BranchModificationInfos branchInfos = new BranchModificationInfos(); - branchInfos.setEquipmentId(info.getEquipmentId()); + private AbstractBranchModification buildBranchModification(MoveFeederBayInfos info) { + AbstractBranchModification branchModification = new AbstractBranchModification() { + @Override + protected void modifyCharacteristics(Branch branch, ReportNode subReportNode) { + throw new UnsupportedOperationException("For this locally defined AbstractBranchModification, modifyCharacteristics should not be called"); + } + + @Override + public String getName() { + return "Local branch modification for feeders bay move"; + } + }; + branchModification.setEquipmentId(info.getEquipmentId()); ThreeSides connectionSide = ThreeSides.valueOf(info.getConnectionSide()); switch (connectionSide) { - case ONE -> setConnectionAttributes(branchInfos::setConnectionPosition1, - branchInfos::setConnectionName1, - branchInfos::setConnectionDirection1, + case ONE -> setConnectionAttributes(branchModification::setConnectionPosition1, + branchModification::setConnectionName1, + branchModification::setConnectionDirection1, info); - case TWO -> setConnectionAttributes(branchInfos::setConnectionPosition2, - branchInfos::setConnectionName2, - branchInfos::setConnectionDirection2, + case TWO -> setConnectionAttributes(branchModification::setConnectionPosition2, + branchModification::setConnectionName2, + branchModification::setConnectionDirection2, info); - default -> throw new NetworkModificationException(MOVE_VOLTAGE_LEVEL_FEEDER_BAYS_ERROR, String.format(INVALID_CONNECTION_SIDE, info.getConnectionSide(), branchInfos.getEquipmentId())); + default -> throw new NetworkModificationException( + MOVE_VOLTAGE_LEVEL_FEEDER_BAYS_ERROR, + String.format(INVALID_CONNECTION_SIDE, info.getConnectionSide(), branchModification.getEquipmentId())); } - return branchInfos; + return branchModification; } private void setConnectionAttributes(java.util.function.Consumer> setPosition, @@ -158,7 +178,7 @@ private void moveFeederBay(Network network, Connectable connectable, MoveFeed if (!currentBusbarId.equals(targetBusbarId)) { ModificationUtils.getInstance().moveFeederBay( connectable, terminal, - new AttributeModification<>(modificationInfos.getVoltageLevelId(), OperationType.SET), + new AttributeModification<>(voltageLevelId, OperationType.SET), new AttributeModification<>(targetBusbarId, OperationType.SET), subReportNode); } diff --git a/src/main/java/org/gridsuite/modification/modifications/OperatingStatusModification.java b/src/main/java/org/gridsuite/modification/modifications/OperatingStatusModification.java index 80949790..f5e990a9 100644 --- a/src/main/java/org/gridsuite/modification/modifications/OperatingStatusModification.java +++ b/src/main/java/org/gridsuite/modification/modifications/OperatingStatusModification.java @@ -17,13 +17,16 @@ import com.powsybl.iidm.network.extensions.OperatingStatus; import com.powsybl.iidm.network.extensions.OperatingStatusAdder; import com.powsybl.iidm.network.util.SwitchPredicates; +import lombok.*; import org.gridsuite.modification.NetworkModificationException; +import org.gridsuite.modification.dto.FreePropertyInfos; import org.gridsuite.modification.dto.OperatingStatusModificationInfos; import org.gridsuite.modification.utils.ModificationUtils; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import java.util.HashSet; +import java.util.List; import java.util.Objects; import java.util.function.Predicate; @@ -34,20 +37,27 @@ /** * @author Ghazwa REHILI */ -public class OperatingStatusModification extends AbstractModification { +@Getter +@Setter +public class OperatingStatusModification extends AbstractEquipmentBase { - private final OperatingStatusModificationInfos modificationInfos; private static final Logger LOGGER = LoggerFactory.getLogger(OperatingStatusModification.class); - private static final String EQUIPMENT_TYPE = "equipmentType"; - public OperatingStatusModification(OperatingStatusModificationInfos modificationInfos) { - this.modificationInfos = modificationInfos; + private OperatingStatusModificationInfos.ActionType action; + private String energizedVoltageLevelId; + + @Builder + public OperatingStatusModification(String equipmentId, List properties, + OperatingStatusModificationInfos.ActionType action, + String energizedVoltageLevelId) { + super(equipmentId, properties); + this.action = action; + this.energizedVoltageLevelId = energizedVoltageLevelId; } @Override public void check(Network network) throws NetworkModificationException { - String equipmentId = modificationInfos.getEquipmentId(); Identifiable equipment = network.getIdentifiable(equipmentId); if (equipment == null) { throw new NetworkModificationException(EQUIPMENT_NOT_FOUND, equipmentId); @@ -56,14 +66,13 @@ public void check(Network network) throws NetworkModificationException { @Override public void apply(Network network, ReportNode subReportNode) { - String equipmentId = modificationInfos.getEquipmentId(); Identifiable equipment = network.getIdentifiable(equipmentId); if (equipment == null) { throw new NetworkModificationException(EQUIPMENT_NOT_FOUND, equipmentId); } String equipmentType = String.valueOf(equipment.getType()); - switch (modificationInfos.getAction()) { + switch (action) { case LOCKOUT -> applyLockoutEquipment(subReportNode, equipment, equipmentType); case TRIP -> applyTripEquipment(subReportNode, equipment, equipmentType, network); case SWITCH_ON -> applySwitchOnEquipment(subReportNode, equipment, equipmentType); @@ -72,7 +81,7 @@ public void apply(Network network, ReportNode subReportNode) { case ENERGISE_END_TWO -> applyEnergiseEquipmentEnd(subReportNode, equipment, equipmentType, TwoSides.TWO); default -> - throw NetworkModificationException.createOperatingActionTypeUnsupported(modificationInfos.getAction()); + throw NetworkModificationException.createOperatingActionTypeUnsupported(action); } } diff --git a/src/main/java/org/gridsuite/modification/modifications/ShuntCompensatorCreation.java b/src/main/java/org/gridsuite/modification/modifications/ShuntCompensatorCreation.java index 7931eed2..35070e50 100644 --- a/src/main/java/org/gridsuite/modification/modifications/ShuntCompensatorCreation.java +++ b/src/main/java/org/gridsuite/modification/modifications/ShuntCompensatorCreation.java @@ -9,12 +9,16 @@ import com.powsybl.commons.report.ReportNode; import com.powsybl.commons.report.TypedValue; import com.powsybl.iidm.network.*; +import com.powsybl.iidm.network.extensions.ConnectablePosition; +import lombok.*; import org.gridsuite.modification.NetworkModificationException; -import org.gridsuite.modification.dto.ShuntCompensatorCreationInfos; +import org.gridsuite.modification.dto.FreePropertyInfos; import org.gridsuite.modification.dto.ShuntCompensatorType; import org.gridsuite.modification.utils.ModificationUtils; import org.gridsuite.modification.utils.PropertiesUtils; +import java.util.List; + import static org.gridsuite.modification.NetworkModificationException.Type.CREATE_SHUNT_COMPENSATOR_ERROR; import static org.gridsuite.modification.NetworkModificationException.Type.SHUNT_COMPENSATOR_ALREADY_EXISTS; import static org.gridsuite.modification.utils.ModificationUtils.createInjectionInNodeBreaker; @@ -22,59 +26,78 @@ /** * @author Slimane Amar */ -public class ShuntCompensatorCreation extends AbstractModification { +@Getter +@Setter +public class ShuntCompensatorCreation extends AbstractInjectionCreation { - private final ShuntCompensatorCreationInfos modificationInfos; + private Integer maximumSectionCount; + private Integer sectionCount; + private Double maxSusceptance; + private Double maxQAtNominalV; + private ShuntCompensatorType shuntCompensatorType; - public ShuntCompensatorCreation(ShuntCompensatorCreationInfos modificationInfos) { - this.modificationInfos = modificationInfos; + @Builder + public ShuntCompensatorCreation(String equipmentId, List properties, String equipmentName, + String voltageLevelId, String busOrBusbarSectionId, String connectionName, + ConnectablePosition.Direction connectionDirection, Integer connectionPosition, + boolean terminalConnected, + @NonNull Integer maximumSectionCount, + @NonNull Integer sectionCount, + Double maxSusceptance, Double maxQAtNominalV, + ShuntCompensatorType shuntCompensatorType) { + super(equipmentId, properties, equipmentName, voltageLevelId, busOrBusbarSectionId, connectionName, + connectionDirection, connectionPosition, terminalConnected); + this.maximumSectionCount = maximumSectionCount; + this.sectionCount = sectionCount; + this.maxSusceptance = maxSusceptance; + this.maxQAtNominalV = maxQAtNominalV; + this.shuntCompensatorType = shuntCompensatorType; } @Override public void check(Network network) throws NetworkModificationException { - if (network.getShuntCompensator(modificationInfos.getEquipmentId()) != null) { - throw new NetworkModificationException(SHUNT_COMPENSATOR_ALREADY_EXISTS, modificationInfos.getEquipmentId()); + if (network.getShuntCompensator(equipmentId) != null) { + throw new NetworkModificationException(SHUNT_COMPENSATOR_ALREADY_EXISTS, equipmentId); } - if (modificationInfos.getMaximumSectionCount() < 1) { + if (maximumSectionCount < 1) { throw new NetworkModificationException(CREATE_SHUNT_COMPENSATOR_ERROR, "Maximum section count should be greater or equal to 1"); } - if (modificationInfos.getSectionCount() < 0 || modificationInfos.getSectionCount() > modificationInfos.getMaximumSectionCount()) { + if (sectionCount < 0 || sectionCount > maximumSectionCount) { throw new NetworkModificationException(CREATE_SHUNT_COMPENSATOR_ERROR, String.format("Section count should be between 0 and Maximum section count (%d), actual : %d", - modificationInfos.getMaximumSectionCount(), - modificationInfos.getSectionCount())); + maximumSectionCount, + sectionCount)); } - ModificationUtils.getInstance().controlConnectivity(network, modificationInfos.getVoltageLevelId(), - modificationInfos.getBusOrBusbarSectionId()); + ModificationUtils.getInstance().controlConnectivity(network, voltageLevelId, + busOrBusbarSectionId); } @Override public void apply(Network network, ReportNode subReportNode) { // create the shunt compensator in the network - VoltageLevel voltageLevel = ModificationUtils.getInstance().getVoltageLevel(network, modificationInfos.getVoltageLevelId()); - if (modificationInfos.getMaxQAtNominalV() != null && modificationInfos.getShuntCompensatorType() != null) { - double maxSusceptance = (modificationInfos.getMaxQAtNominalV()) / Math.pow(voltageLevel.getNominalV(), 2); - modificationInfos.setMaxSusceptance( - modificationInfos.getShuntCompensatorType() == ShuntCompensatorType.CAPACITOR - ? maxSusceptance - : -maxSusceptance); + VoltageLevel voltageLevel = ModificationUtils.getInstance().getVoltageLevel(network, voltageLevelId); + if (maxQAtNominalV != null && shuntCompensatorType != null) { + double computedMaxSusceptance = maxQAtNominalV / Math.pow(voltageLevel.getNominalV(), 2); + maxSusceptance = shuntCompensatorType == ShuntCompensatorType.CAPACITOR + ? computedMaxSusceptance + : -computedMaxSusceptance; } if (voltageLevel.getTopologyKind() == TopologyKind.NODE_BREAKER) { - ShuntCompensatorAdder shuntCompensatorAdder = createShuntAdderInNodeBreaker(voltageLevel, modificationInfos); - createInjectionInNodeBreaker(voltageLevel, modificationInfos, network, shuntCompensatorAdder, subReportNode); + ShuntCompensatorAdder shuntCompensatorAdder = createShuntAdderInNodeBreaker(voltageLevel); + createInjectionInNodeBreaker(voltageLevel, this, network, shuntCompensatorAdder, subReportNode); } else { - createShuntInBusBreaker(voltageLevel, modificationInfos); + createShuntInBusBreaker(voltageLevel); subReportNode.newReportNode() .withMessageTemplate("network.modification.shuntCompensatorCreated") - .withUntypedValue("id", modificationInfos.getEquipmentId()) + .withUntypedValue("id", equipmentId) .withSeverity(TypedValue.INFO_SEVERITY) .add(); } - ModificationUtils.getInstance().disconnectCreatedInjection(modificationInfos, network.getShuntCompensator(modificationInfos.getEquipmentId()), subReportNode); + ModificationUtils.getInstance().disconnectCreatedInjection(this, network.getShuntCompensator(equipmentId), subReportNode); // properties - ShuntCompensator shuntCompensator = network.getShuntCompensator(modificationInfos.getEquipmentId()); - PropertiesUtils.applyProperties(shuntCompensator, subReportNode, modificationInfos.getProperties(), "network.modification.ShuntCompensatorProperties"); + ShuntCompensator shuntCompensator = network.getShuntCompensator(equipmentId); + PropertiesUtils.applyProperties(shuntCompensator, subReportNode, properties, "network.modification.ShuntCompensatorProperties"); } @Override @@ -82,35 +105,36 @@ public String getName() { return "ShuntCompensatorCreation"; } - private ShuntCompensatorAdder createShuntAdderInNodeBreaker(VoltageLevel voltageLevel, ShuntCompensatorCreationInfos shuntCompensatorInfos) { + private ShuntCompensatorAdder createShuntAdderInNodeBreaker(VoltageLevel voltageLevel) { // creating the shunt compensator ShuntCompensatorAdder shuntAdder = voltageLevel.newShuntCompensator() - .setId(shuntCompensatorInfos.getEquipmentId()) - .setName(shuntCompensatorInfos.getEquipmentName()) - .setSectionCount(shuntCompensatorInfos.getSectionCount()); + .setId(equipmentId) + .setName(equipmentName) + .setSectionCount(sectionCount); /* when we create non-linear shunt, this is where we branch ;) */ shuntAdder.newLinearModel() - .setBPerSection(shuntCompensatorInfos.getMaxSusceptance() / shuntCompensatorInfos.getMaximumSectionCount()) - .setMaximumSectionCount(shuntCompensatorInfos.getMaximumSectionCount()) + .setBPerSection(maxSusceptance / maximumSectionCount) + .setMaximumSectionCount(maximumSectionCount) .add(); return shuntAdder; } - private void createShuntInBusBreaker(VoltageLevel voltageLevel, ShuntCompensatorCreationInfos shuntCompensatorInfos) { - Bus bus = ModificationUtils.getInstance().getBusBreakerBus(voltageLevel, shuntCompensatorInfos.getBusOrBusbarSectionId()); + private void createShuntInBusBreaker(VoltageLevel voltageLevel) { + Bus bus = ModificationUtils.getInstance().getBusBreakerBus(voltageLevel, busOrBusbarSectionId); /* creating the shunt compensator */ voltageLevel.newShuntCompensator() - .setId(shuntCompensatorInfos.getEquipmentId()) - .setName(shuntCompensatorInfos.getEquipmentName()) - .setSectionCount(shuntCompensatorInfos.getSectionCount()) + .setId(equipmentId) + .setName(equipmentName) + .setSectionCount(sectionCount) .setBus(bus.getId()) .setConnectableBus(bus.getId()) .newLinearModel() - .setBPerSection(shuntCompensatorInfos.getMaxSusceptance() / shuntCompensatorInfos.getMaximumSectionCount()) - .setMaximumSectionCount(shuntCompensatorInfos.getMaximumSectionCount()) + .setBPerSection(maxSusceptance / maximumSectionCount) + .setMaximumSectionCount(maximumSectionCount) .add() .add(); } + } diff --git a/src/main/java/org/gridsuite/modification/modifications/ShuntCompensatorModification.java b/src/main/java/org/gridsuite/modification/modifications/ShuntCompensatorModification.java index 9f97015e..caf0df96 100644 --- a/src/main/java/org/gridsuite/modification/modifications/ShuntCompensatorModification.java +++ b/src/main/java/org/gridsuite/modification/modifications/ShuntCompensatorModification.java @@ -12,9 +12,12 @@ import com.powsybl.iidm.network.*; import com.powsybl.iidm.network.extensions.ConnectablePosition; import com.powsybl.iidm.network.extensions.ConnectablePositionAdder; +import lombok.Builder; +import lombok.Getter; +import lombok.Setter; import org.gridsuite.modification.NetworkModificationException; import org.gridsuite.modification.dto.AttributeModification; -import org.gridsuite.modification.dto.ShuntCompensatorModificationInfos; +import org.gridsuite.modification.dto.FreePropertyInfos; import org.gridsuite.modification.dto.ShuntCompensatorType; import org.gridsuite.modification.utils.ModificationUtils; import org.gridsuite.modification.utils.PropertiesUtils; @@ -29,64 +32,95 @@ /** * @author Seddik Yengui */ - +@Getter +@Setter public class ShuntCompensatorModification extends AbstractInjectionModification { + private static final String SWITCHED_ON_Q_AT_NOMINALV_LOG_MESSAGE = "Switched-on Q at nominal voltage"; - public ShuntCompensatorModification(ShuntCompensatorModificationInfos shuntCompensatorModificationInfos) { - super(shuntCompensatorModificationInfos); + private AttributeModification maximumSectionCount; + private AttributeModification sectionCount; + private AttributeModification maxSusceptance; + private AttributeModification maxQAtNominalV; + private AttributeModification shuntCompensatorType; + + @Builder + public ShuntCompensatorModification(String equipmentId, List properties, + AttributeModification equipmentName, + AttributeModification voltageLevelId, + AttributeModification busOrBusbarSectionId, + AttributeModification connectionName, + AttributeModification connectionDirection, + AttributeModification connectionPosition, + AttributeModification terminalConnected, + AttributeModification pMeasurementValue, + AttributeModification pMeasurementValidity, + AttributeModification qMeasurementValue, + AttributeModification qMeasurementValidity, + AttributeModification maximumSectionCount, + AttributeModification sectionCount, + AttributeModification maxSusceptance, + AttributeModification maxQAtNominalV, + AttributeModification shuntCompensatorType) { + super(equipmentId, properties, equipmentName, voltageLevelId, busOrBusbarSectionId, connectionName, + connectionDirection, connectionPosition, terminalConnected, pMeasurementValue, pMeasurementValidity, + qMeasurementValue, qMeasurementValidity); + this.maximumSectionCount = maximumSectionCount; + this.sectionCount = sectionCount; + this.maxSusceptance = maxSusceptance; + this.maxQAtNominalV = maxQAtNominalV; + this.shuntCompensatorType = shuntCompensatorType; } @Override public void check(Network network) throws NetworkModificationException { - ShuntCompensatorModificationInfos shuntCompensatorModificationInfos = (ShuntCompensatorModificationInfos) modificationInfos; - ShuntCompensator shuntCompensator = network.getShuntCompensator(shuntCompensatorModificationInfos.getEquipmentId()); + ShuntCompensator shuntCompensator = network.getShuntCompensator(equipmentId); if (shuntCompensator == null) { throw new NetworkModificationException(SHUNT_COMPENSATOR_NOT_FOUND, - String.format("Shunt compensator %s does not exist in network", shuntCompensatorModificationInfos.getEquipmentId())); + String.format("Shunt compensator %s does not exist in network", equipmentId)); } - ModificationUtils.getInstance().checkVoltageLevelModification(network, shuntCompensatorModificationInfos.getVoltageLevelId(), - shuntCompensatorModificationInfos.getBusOrBusbarSectionId(), shuntCompensator.getTerminal()); - int maximumSectionCount = shuntCompensatorModificationInfos.getMaximumSectionCount() != null - ? shuntCompensatorModificationInfos.getMaximumSectionCount().getValue() + ModificationUtils.getInstance().checkVoltageLevelModification(network, voltageLevelId, + busOrBusbarSectionId, shuntCompensator.getTerminal()); + int newMaximumSectionCount = maximumSectionCount != null + ? maximumSectionCount.getValue() : shuntCompensator.getMaximumSectionCount(); - int sectionCount = shuntCompensatorModificationInfos.getSectionCount() != null - ? shuntCompensatorModificationInfos.getSectionCount().getValue() + int newSectionCount = sectionCount != null + ? sectionCount.getValue() : shuntCompensator.getSectionCount(); - if (shuntCompensatorModificationInfos.getMaximumSectionCount() != null && shuntCompensatorModificationInfos.getMaximumSectionCount().getValue() < 1) { + if (maximumSectionCount != null && maximumSectionCount.getValue() < 1) { throw new NetworkModificationException(MODIFY_SHUNT_COMPENSATOR_ERROR, "Maximum section count should be greater or equal to 1"); } - if (sectionCount < 0 || maximumSectionCount < 1 || sectionCount > maximumSectionCount) { - throw new NetworkModificationException(MODIFY_SHUNT_COMPENSATOR_ERROR, String.format("Section count should be between 0 and Maximum section count (%d), actual : %d", maximumSectionCount, - sectionCount)); + if (newSectionCount < 0 || newMaximumSectionCount < 1 || newSectionCount > newMaximumSectionCount) { + throw new NetworkModificationException(MODIFY_SHUNT_COMPENSATOR_ERROR, String.format( + "Section count should be between 0 and Maximum section count (%d), actual : %d", newMaximumSectionCount, + newSectionCount)); } } @Override public void apply(Network network, ReportNode subReportNode) { - ShuntCompensatorModificationInfos shuntCompensatorModificationInfos = (ShuntCompensatorModificationInfos) modificationInfos; - ShuntCompensator shuntCompensator = network.getShuntCompensator(shuntCompensatorModificationInfos.getEquipmentId()); + ShuntCompensator shuntCompensator = network.getShuntCompensator(equipmentId); VoltageLevel voltageLevel = shuntCompensator.getTerminal().getVoltageLevel(); subReportNode.newReportNode() .withMessageTemplate("network.modification.shuntCompensatorModification.withId") - .withUntypedValue("id", shuntCompensatorModificationInfos.getEquipmentId()) + .withUntypedValue("id", equipmentId) .withSeverity(TypedValue.INFO_SEVERITY) .add(); - ModificationUtils.getInstance().applyElementaryModifications(shuntCompensator::setName, () -> shuntCompensator.getOptionalName().orElse("No value"), modificationInfos.getEquipmentName(), + ModificationUtils.getInstance().applyElementaryModifications(shuntCompensator::setName, () -> shuntCompensator.getOptionalName().orElse("No value"), equipmentName, subReportNode, "Name"); if (shuntCompensator.getModelType() == ShuntCompensatorModelType.LINEAR) { applyModificationOnLinearModel(subReportNode, shuntCompensator, voltageLevel); } - modifyShuntCompensatorVoltageLevelBusOrBusBarSectionAttributes(shuntCompensatorModificationInfos, shuntCompensator, subReportNode); - modifyShuntCompensatorConnectivityAttributes(shuntCompensatorModificationInfos, shuntCompensator, subReportNode); + modifyShuntCompensatorVoltageLevelBusOrBusBarSectionAttributes(shuntCompensator, subReportNode); + modifyShuntCompensatorConnectivityAttributes(shuntCompensator, subReportNode); updateMeasurements(shuntCompensator, subReportNode); - PropertiesUtils.applyProperties(shuntCompensator, subReportNode, shuntCompensatorModificationInfos.getProperties(), "network.modification.ShuntCompensatorProperties"); + PropertiesUtils.applyProperties(shuntCompensator, subReportNode, properties, "network.modification.ShuntCompensatorProperties"); } @Override @@ -123,60 +157,59 @@ public static void modifySectionCount(AttributeModification sectionCoun } private void applyModificationOnLinearModel(ReportNode subReportNode, ShuntCompensator shuntCompensator, VoltageLevel voltageLevel) { - ShuntCompensatorModificationInfos shuntCompensatorModificationInfos = (ShuntCompensatorModificationInfos) modificationInfos; List reports = new ArrayList<>(); ShuntCompensatorLinearModel model = shuntCompensator.getModel(ShuntCompensatorLinearModel.class); - var shuntCompensatorType = model.getBPerSection() > 0 ? ShuntCompensatorType.CAPACITOR : ShuntCompensatorType.REACTOR; + var shuntCompensatorTypeFromNetwork = model.getBPerSection() > 0 ? ShuntCompensatorType.CAPACITOR : ShuntCompensatorType.REACTOR; double oldSusceptancePerSection = model.getBPerSection(); double oldQAtNominalV = Math.abs(Math.pow(voltageLevel.getNominalV(), 2) * oldSusceptancePerSection); double oldMaxQAtNominalV = oldQAtNominalV * shuntCompensator.getMaximumSectionCount(); double oldSwitchedOnSusceptance = oldSusceptancePerSection * shuntCompensator.getSectionCount(); double oldSwitchedOnQAtNominalV = oldQAtNominalV * shuntCompensator.getSectionCount(); - if (shuntCompensatorModificationInfos.getShuntCompensatorType() != null || shuntCompensatorModificationInfos.getMaxQAtNominalV() != null) { - shuntCompensatorModificationInfos.setMaxSusceptance(null); + if (this.shuntCompensatorType != null || maxQAtNominalV != null) { + maxSusceptance = null; } // 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 (shuntCompensatorModificationInfos.getMaximumSectionCount() != null && shuntCompensatorModificationInfos.getMaximumSectionCount().getValue() < shuntCompensator.getMaximumSectionCount()) { - modifySectionCount(shuntCompensatorModificationInfos.getSectionCount(), reports, shuntCompensator); - modifyMaximumSectionCount(shuntCompensatorModificationInfos.getMaximumSectionCount(), - shuntCompensatorModificationInfos.getMaxSusceptance(), - shuntCompensatorModificationInfos.getMaxQAtNominalV(), + if (maximumSectionCount != null && maximumSectionCount.getValue() < shuntCompensator.getMaximumSectionCount()) { + modifySectionCount(sectionCount, reports, shuntCompensator); + modifyMaximumSectionCount(maximumSectionCount, + maxSusceptance, + maxQAtNominalV, reports, shuntCompensator, model); } else { - modifyMaximumSectionCount(shuntCompensatorModificationInfos.getMaximumSectionCount(), - shuntCompensatorModificationInfos.getMaxSusceptance(), - shuntCompensatorModificationInfos.getMaxQAtNominalV(), + modifyMaximumSectionCount(maximumSectionCount, + maxSusceptance, + maxQAtNominalV, reports, shuntCompensator, model); - modifySectionCount(shuntCompensatorModificationInfos.getSectionCount(), reports, shuntCompensator); + modifySectionCount(sectionCount, reports, shuntCompensator); } - int maximumSectionCount = shuntCompensatorModificationInfos.getMaximumSectionCount() != null ? shuntCompensatorModificationInfos.getMaximumSectionCount().getValue( + int newMaximumSectionCount = maximumSectionCount != null ? maximumSectionCount.getValue( ) : shuntCompensator.getMaximumSectionCount(); - int sectionCount = shuntCompensatorModificationInfos.getSectionCount() != null ? shuntCompensatorModificationInfos.getSectionCount().getValue() : shuntCompensator.getSectionCount(); + int newSectionCount = sectionCount != null ? sectionCount.getValue() : shuntCompensator.getSectionCount(); - if (shuntCompensatorModificationInfos.getShuntCompensatorType() != null) { - reports.add(ModificationUtils.getInstance().buildModificationReport(shuntCompensatorType, shuntCompensatorModificationInfos.getShuntCompensatorType().getValue(), "Type")); - shuntCompensatorType = shuntCompensatorModificationInfos.getShuntCompensatorType().getValue(); - if (shuntCompensatorModificationInfos.getMaxQAtNominalV() == null) { + if (this.shuntCompensatorType != null) { + reports.add(ModificationUtils.getInstance().buildModificationReport(shuntCompensatorTypeFromNetwork, this.shuntCompensatorType.getValue(), "Type")); + shuntCompensatorTypeFromNetwork = this.shuntCompensatorType.getValue(); + if (maxQAtNominalV == null) { // we retrieve the absolute value of susceptance per section, then we determine the sign using the type double bPerSectionAbsoluteValue = Math.abs(oldSusceptancePerSection); - double newBPerSection = shuntCompensatorType == ShuntCompensatorType.CAPACITOR ? bPerSectionAbsoluteValue : -bPerSectionAbsoluteValue; + double newBPerSection = shuntCompensatorTypeFromNetwork == ShuntCompensatorType.CAPACITOR ? bPerSectionAbsoluteValue : -bPerSectionAbsoluteValue; model.setBPerSection(newBPerSection); } } - if (shuntCompensatorModificationInfos.getMaxQAtNominalV() != null) { - modifyMaximumQAtNominalVoltage(shuntCompensatorModificationInfos.getMaxQAtNominalV(), voltageLevel, maximumSectionCount, reports, model, shuntCompensatorType); + if (maxQAtNominalV != null) { + modifyMaximumQAtNominalVoltage(maxQAtNominalV, voltageLevel, newMaximumSectionCount, reports, model, shuntCompensatorTypeFromNetwork); } - if (shuntCompensatorModificationInfos.getMaxSusceptance() != null) { - modifyMaxSusceptance(shuntCompensatorModificationInfos.getMaxSusceptance(), maximumSectionCount, reports, model); + if (maxSusceptance != null) { + modifyMaxSusceptance(maxSusceptance, newMaximumSectionCount, reports, model); } - reportSwitchedOnAndPerSectionValues(reports, oldQAtNominalV, oldSwitchedOnQAtNominalV, oldSusceptancePerSection, oldSwitchedOnSusceptance, oldMaxQAtNominalV, sectionCount, - maximumSectionCount); + reportSwitchedOnAndPerSectionValues(reports, oldQAtNominalV, oldSwitchedOnQAtNominalV, oldSusceptancePerSection, oldSwitchedOnSusceptance, oldMaxQAtNominalV, newSectionCount, + newMaximumSectionCount); reports.forEach(report -> insertReportNode(subReportNode, report)); } @@ -218,42 +251,39 @@ public static void modifyMaximumQAtNominalVoltage(AttributeModification private void reportSwitchedOnAndPerSectionValues(List reports, double oldQAtNominalV, double oldSwitchedOnQAtNominalV, double oldSusceptancePerSection, double oldSwitchedOnSusceptance, double oldMaxQAtNominalV, int sectionCount, int maximumSectionCount) { - ShuntCompensatorModificationInfos shuntCompensatorModificationInfos = (ShuntCompensatorModificationInfos) modificationInfos; - if (shuntCompensatorModificationInfos.getMaxQAtNominalV() != null) { - double newQatNominalV = shuntCompensatorModificationInfos.getMaxQAtNominalV().getValue() / maximumSectionCount; + if (maxQAtNominalV != null) { + double newQatNominalV = maxQAtNominalV.getValue() / maximumSectionCount; double newSwitchedOnQAtNominalV = newQatNominalV * sectionCount; reports.add(ModificationUtils.getInstance().buildModificationReport(oldQAtNominalV, newQatNominalV, "Q at nominal voltage per section")); reports.add(ModificationUtils.getInstance().buildModificationReport(oldSwitchedOnQAtNominalV, newSwitchedOnQAtNominalV, SWITCHED_ON_Q_AT_NOMINALV_LOG_MESSAGE)); - } else if (shuntCompensatorModificationInfos.getMaxSusceptance() != null) { - double newSusceptancePerSection = shuntCompensatorModificationInfos.getMaxSusceptance().getValue() / maximumSectionCount; + } else if (maxSusceptance != null) { + double newSusceptancePerSection = maxSusceptance.getValue() / maximumSectionCount; double newSwitchedOnSusceptance = newSusceptancePerSection * sectionCount; reports.add(ModificationUtils.getInstance().buildModificationReport(oldSusceptancePerSection, newSusceptancePerSection, "Susceptance per section")); reports.add(ModificationUtils.getInstance().buildModificationReport(oldSwitchedOnSusceptance, newSwitchedOnSusceptance, "Switched-on susceptance")); - } else if (shuntCompensatorModificationInfos.getMaximumSectionCount() != null) { + } else if (this.maximumSectionCount != null) { double newQatNominalV = oldMaxQAtNominalV / maximumSectionCount; double newSwitchedOnQAtNominalV = newQatNominalV * sectionCount; reports.add(ModificationUtils.getInstance().buildModificationReport(oldQAtNominalV, newQatNominalV, "Q at nominal voltage per section")); reports.add(ModificationUtils.getInstance().buildModificationReport(oldSwitchedOnQAtNominalV, newSwitchedOnQAtNominalV, SWITCHED_ON_Q_AT_NOMINALV_LOG_MESSAGE)); - } else if (shuntCompensatorModificationInfos.getSectionCount() != null) { + } else if (this.sectionCount != null) { double newSwitchedOnQAtNominalV = oldQAtNominalV * sectionCount; reports.add(ModificationUtils.getInstance().buildModificationReport(oldSwitchedOnQAtNominalV, newSwitchedOnQAtNominalV, SWITCHED_ON_Q_AT_NOMINALV_LOG_MESSAGE)); } } - private void modifyShuntCompensatorVoltageLevelBusOrBusBarSectionAttributes(ShuntCompensatorModificationInfos modificationInfos, - ShuntCompensator shuntCompensator, ReportNode subReportNode) { + private void modifyShuntCompensatorVoltageLevelBusOrBusBarSectionAttributes(ShuntCompensator shuntCompensator, ReportNode subReportNode) { ModificationUtils.getInstance().moveFeederBay( shuntCompensator, shuntCompensator.getTerminal(), - modificationInfos.getVoltageLevelId(), - modificationInfos.getBusOrBusbarSectionId(), + voltageLevelId, + busOrBusbarSectionId, subReportNode ); } - private ReportNode modifyShuntCompensatorConnectivityAttributes(ShuntCompensatorModificationInfos modificationInfos, - ShuntCompensator shuntCompensator, ReportNode subReportNode) { + private ReportNode modifyShuntCompensatorConnectivityAttributes(ShuntCompensator shuntCompensator, ReportNode subReportNode) { ConnectablePosition connectablePosition = shuntCompensator.getExtension(ConnectablePosition.class); ConnectablePositionAdder connectablePositionAdder = shuntCompensator.newExtension(ConnectablePositionAdder.class); - return ModificationUtils.getInstance().modifyInjectionConnectivityAttributes(connectablePosition, connectablePositionAdder, shuntCompensator, modificationInfos, subReportNode); + return ModificationUtils.getInstance().modifyInjectionConnectivityAttributes(connectablePosition, connectablePositionAdder, shuntCompensator, this, subReportNode); } } diff --git a/src/main/java/org/gridsuite/modification/modifications/StaticVarCompensatorCreation.java b/src/main/java/org/gridsuite/modification/modifications/StaticVarCompensatorCreation.java index 4fa0abc1..4fbb9e1c 100644 --- a/src/main/java/org/gridsuite/modification/modifications/StaticVarCompensatorCreation.java +++ b/src/main/java/org/gridsuite/modification/modifications/StaticVarCompensatorCreation.java @@ -10,9 +10,12 @@ import com.powsybl.commons.report.ReportNode; import com.powsybl.commons.report.TypedValue; import com.powsybl.iidm.network.*; +import com.powsybl.iidm.network.extensions.ConnectablePosition; import com.powsybl.iidm.network.extensions.StandbyAutomatonAdder; +import lombok.*; import org.gridsuite.modification.NetworkModificationException; -import org.gridsuite.modification.dto.StaticVarCompensatorCreationInfos; +import org.gridsuite.modification.dto.FreePropertyInfos; +import org.gridsuite.modification.dto.VoltageRegulationType; import org.gridsuite.modification.report.NetworkModificationReportResourceBundle; import org.gridsuite.modification.utils.ModificationUtils; import org.gridsuite.modification.utils.PropertiesUtils; @@ -28,59 +31,113 @@ /** * @author Ghazwa Rehili */ -public class StaticVarCompensatorCreation extends AbstractModification { +@Getter +@Setter +public class StaticVarCompensatorCreation extends AbstractInjectionCreation { - private final StaticVarCompensatorCreationInfos modificationInfos; + private Double maxSusceptance; + private Double minSusceptance; + private Double maxQAtNominalV; + private Double minQAtNominalV; + private StaticVarCompensator.RegulationMode regulationMode; + private Double voltageSetpoint; + private Double reactivePowerSetpoint; + private VoltageRegulationType voltageRegulationType; + private String regulatingTerminalId; + private String regulatingTerminalType; + private String regulatingTerminalVlId; + private boolean regulating; + private boolean standbyAutomatonOn; + private boolean standby; + private Double b0; + private Double q0; + private Double lowVoltageSetpoint; + private Double highVoltageSetpoint; + private Double lowVoltageThreshold; + private Double highVoltageThreshold; - public StaticVarCompensatorCreation(StaticVarCompensatorCreationInfos modificationInfos) { - this.modificationInfos = modificationInfos; + @Builder + public StaticVarCompensatorCreation(String equipmentId, List properties, String equipmentName, + String voltageLevelId, String busOrBusbarSectionId, String connectionName, + ConnectablePosition.Direction connectionDirection, Integer connectionPosition, + boolean terminalConnected, Double maxSusceptance, Double minSusceptance, + Double maxQAtNominalV, Double minQAtNominalV, + StaticVarCompensator.RegulationMode regulationMode, Double voltageSetpoint, + Double reactivePowerSetpoint, VoltageRegulationType voltageRegulationType, + String regulatingTerminalId, String regulatingTerminalType, + String regulatingTerminalVlId, boolean regulating, boolean standbyAutomatonOn, + boolean standby, Double b0, Double q0, Double lowVoltageSetpoint, + Double highVoltageSetpoint, Double lowVoltageThreshold, + Double highVoltageThreshold) { + super(equipmentId, properties, equipmentName, voltageLevelId, busOrBusbarSectionId, connectionName, + connectionDirection, connectionPosition, terminalConnected); + this.maxSusceptance = maxSusceptance; + this.minSusceptance = minSusceptance; + this.maxQAtNominalV = maxQAtNominalV; + this.minQAtNominalV = minQAtNominalV; + this.regulationMode = regulationMode; + this.voltageSetpoint = voltageSetpoint; + this.reactivePowerSetpoint = reactivePowerSetpoint; + this.voltageRegulationType = voltageRegulationType; + this.regulatingTerminalId = regulatingTerminalId; + this.regulatingTerminalType = regulatingTerminalType; + this.regulatingTerminalVlId = regulatingTerminalVlId; + this.regulating = regulating; + this.standbyAutomatonOn = standbyAutomatonOn; + this.standby = standby; + this.b0 = b0; + this.q0 = q0; + this.lowVoltageSetpoint = lowVoltageSetpoint; + this.highVoltageSetpoint = highVoltageSetpoint; + this.lowVoltageThreshold = lowVoltageThreshold; + this.highVoltageThreshold = highVoltageThreshold; } @Override public void check(Network network) throws NetworkModificationException { - if (network.getStaticVarCompensator(modificationInfos.getEquipmentId()) != null) { - throw new NetworkModificationException(STATIC_VAR_COMPENSATOR_ALREADY_EXISTS, modificationInfos.getEquipmentId()); + if (network.getStaticVarCompensator(equipmentId) != null) { + throw new NetworkModificationException(STATIC_VAR_COMPENSATOR_ALREADY_EXISTS, equipmentId); } - String errorMessage = "Static var compensator '" + modificationInfos.getEquipmentId() + "' : "; + String errorMessage = "Static var compensator '" + equipmentId + "' : "; // check connectivity ModificationUtils.getInstance() - .controlConnectivity(network, modificationInfos.getVoltageLevelId(), - modificationInfos.getBusOrBusbarSectionId()); + .controlConnectivity(network, voltageLevelId, + busOrBusbarSectionId); // check reactive power limits and set points - ModificationUtils.getInstance().checkReactivePowerLimitsAndSetPointsCreation(modificationInfos); + ModificationUtils.getInstance().checkReactivePowerLimitsAndSetPointsCreation(this); // check regulated terminal - VoltageLevel voltageLevel = ModificationUtils.getInstance().getVoltageLevel(network, modificationInfos.getVoltageLevelId()); - ModificationUtils.getInstance().getTerminalFromIdentifiable(voltageLevel.getNetwork(), modificationInfos.getRegulatingTerminalId(), - modificationInfos.getRegulatingTerminalType(), modificationInfos.getRegulatingTerminalVlId()); + VoltageLevel voltageLevel = ModificationUtils.getInstance().getVoltageLevel(network, voltageLevelId); + ModificationUtils.getInstance().getTerminalFromIdentifiable(voltageLevel.getNetwork(), regulatingTerminalId, + regulatingTerminalType, regulatingTerminalVlId); // check standby automaton - ModificationUtils.getInstance().checkStandbyAutomatonCreation(modificationInfos); - checkIsNotNegativeValue(errorMessage, modificationInfos.getVoltageSetpoint(), CREATE_STATIC_VAR_COMPENSATOR_ERROR, "voltage set point"); - checkIsNotNegativeValue(errorMessage, modificationInfos.getHighVoltageSetpoint(), CREATE_STATIC_VAR_COMPENSATOR_ERROR, "high voltage set point"); - checkIsNotNegativeValue(errorMessage, modificationInfos.getLowVoltageSetpoint(), CREATE_STATIC_VAR_COMPENSATOR_ERROR, "low voltage set point"); - checkIsNotNegativeValue(errorMessage, modificationInfos.getHighVoltageThreshold(), CREATE_STATIC_VAR_COMPENSATOR_ERROR, "high voltage threshold"); - checkIsNotNegativeValue(errorMessage, modificationInfos.getLowVoltageThreshold(), CREATE_STATIC_VAR_COMPENSATOR_ERROR, "low voltage threshold"); + ModificationUtils.getInstance().checkStandbyAutomatonCreation(this); + checkIsNotNegativeValue(errorMessage, voltageSetpoint, CREATE_STATIC_VAR_COMPENSATOR_ERROR, "voltage set point"); + checkIsNotNegativeValue(errorMessage, highVoltageSetpoint, CREATE_STATIC_VAR_COMPENSATOR_ERROR, "high voltage set point"); + checkIsNotNegativeValue(errorMessage, lowVoltageSetpoint, CREATE_STATIC_VAR_COMPENSATOR_ERROR, "low voltage set point"); + checkIsNotNegativeValue(errorMessage, highVoltageThreshold, CREATE_STATIC_VAR_COMPENSATOR_ERROR, "high voltage threshold"); + checkIsNotNegativeValue(errorMessage, lowVoltageThreshold, CREATE_STATIC_VAR_COMPENSATOR_ERROR, "low voltage threshold"); } @Override public void apply(Network network, ReportNode subReportNode) { // create the static var compensator in the network - VoltageLevel voltageLevel = ModificationUtils.getInstance().getVoltageLevel(network, modificationInfos.getVoltageLevelId()); + VoltageLevel voltageLevel = ModificationUtils.getInstance().getVoltageLevel(network, voltageLevelId); if (voltageLevel.getTopologyKind() == TopologyKind.NODE_BREAKER) { - createStaticVarCompensatorInNodeBreaker(voltageLevel, modificationInfos, network, subReportNode); + createStaticVarCompensatorInNodeBreaker(voltageLevel, network, subReportNode); } else { - createStaticVarCompensatorInBusBreaker(voltageLevel, modificationInfos, subReportNode); + createStaticVarCompensatorInBusBreaker(voltageLevel, subReportNode); } - ModificationUtils.getInstance().disconnectCreatedInjection(modificationInfos, network.getStaticVarCompensator(modificationInfos.getEquipmentId()), subReportNode); + ModificationUtils.getInstance().disconnectCreatedInjection(this, network.getStaticVarCompensator(equipmentId), subReportNode); // properties - StaticVarCompensator staticVarCompensator = network.getStaticVarCompensator(modificationInfos.getEquipmentId()); - PropertiesUtils.applyProperties(staticVarCompensator, subReportNode, modificationInfos.getProperties(), "network.modification.StaticVarCompensatorProperties"); + StaticVarCompensator staticVarCompensator = network.getStaticVarCompensator(equipmentId); + PropertiesUtils.applyProperties(staticVarCompensator, subReportNode, properties, "network.modification.StaticVarCompensatorProperties"); subReportNode.newReportNode() .withMessageTemplate("network.modification.staticVarCompensatorCreated") - .withUntypedValue("id", modificationInfos.getEquipmentId()) + .withUntypedValue("id", equipmentId) .withSeverity(TypedValue.INFO_SEVERITY) .add(); } @@ -90,33 +147,32 @@ public String getName() { return "StaticVarCompensatorCreation"; } - private void createStaticVarCompensatorInNodeBreaker(VoltageLevel voltageLevel, StaticVarCompensatorCreationInfos staticVarCompensatorCreationInfos, - Network network, ReportNode subReportNode) { - StaticVarCompensatorAdder staticVarCompensatorAdder = createStaticVarCompensatorAdderInNodeBreaker(voltageLevel, staticVarCompensatorCreationInfos); - createInjectionInNodeBreaker(voltageLevel, staticVarCompensatorCreationInfos, network, staticVarCompensatorAdder, subReportNode); - var staticVarCompensator = ModificationUtils.getInstance().getStaticVarCompensator(network, staticVarCompensatorCreationInfos.getEquipmentId()); - addExtensionsToStaticVarCompensator(staticVarCompensatorCreationInfos, staticVarCompensator, voltageLevel, subReportNode); + private void createStaticVarCompensatorInNodeBreaker(VoltageLevel voltageLevel, Network network, ReportNode subReportNode) { + StaticVarCompensatorAdder staticVarCompensatorAdder = createStaticVarCompensatorAdderInNodeBreaker(voltageLevel); + createInjectionInNodeBreaker(voltageLevel, this, network, staticVarCompensatorAdder, subReportNode); + var staticVarCompensator = ModificationUtils.getInstance().getStaticVarCompensator(network, equipmentId); + addExtensionsToStaticVarCompensator(staticVarCompensator, voltageLevel, subReportNode); } - private StaticVarCompensatorAdder createStaticVarCompensatorAdderInNodeBreaker(VoltageLevel voltageLevel, StaticVarCompensatorCreationInfos staticVarCompensatorCreationInfos) { + private StaticVarCompensatorAdder createStaticVarCompensatorAdderInNodeBreaker(VoltageLevel voltageLevel) { Terminal terminal = ModificationUtils.getInstance().getTerminalFromIdentifiable(voltageLevel.getNetwork(), - staticVarCompensatorCreationInfos.getRegulatingTerminalId(), - staticVarCompensatorCreationInfos.getRegulatingTerminalType(), - staticVarCompensatorCreationInfos.getRegulatingTerminalVlId()); - double bMax = Objects.isNull(staticVarCompensatorCreationInfos.getMaxSusceptance()) && Objects.nonNull(staticVarCompensatorCreationInfos.getMaxQAtNominalV()) ? - (staticVarCompensatorCreationInfos.getMaxQAtNominalV()) / Math.pow(voltageLevel.getNominalV(), 2) : staticVarCompensatorCreationInfos.getMaxSusceptance(); - double bMin = Objects.isNull(staticVarCompensatorCreationInfos.getMinSusceptance()) && Objects.nonNull(staticVarCompensatorCreationInfos.getMinQAtNominalV()) ? - (staticVarCompensatorCreationInfos.getMinQAtNominalV()) / Math.pow(voltageLevel.getNominalV(), 2) : staticVarCompensatorCreationInfos.getMinSusceptance(); + regulatingTerminalId, + regulatingTerminalType, + regulatingTerminalVlId); + double bMax = Objects.isNull(maxSusceptance) && Objects.nonNull(maxQAtNominalV) ? + maxQAtNominalV / Math.pow(voltageLevel.getNominalV(), 2) : maxSusceptance; + double bMin = Objects.isNull(minSusceptance) && Objects.nonNull(minQAtNominalV) ? + minQAtNominalV / Math.pow(voltageLevel.getNominalV(), 2) : minSusceptance; StaticVarCompensatorAdder staticVarCompensatorAdder = voltageLevel.newStaticVarCompensator() - .setId(staticVarCompensatorCreationInfos.getEquipmentId()) - .setName(staticVarCompensatorCreationInfos.getEquipmentName()) + .setId(equipmentId) + .setName(equipmentName) .setBmax(bMax) .setBmin(bMin) - .setVoltageSetpoint(nanIfNull(staticVarCompensatorCreationInfos.getVoltageSetpoint())) - .setReactivePowerSetpoint(nanIfNull(staticVarCompensatorCreationInfos.getReactivePowerSetpoint())) - .setRegulating(staticVarCompensatorCreationInfos.isRegulating()); - if (staticVarCompensatorCreationInfos.isRegulating()) { - staticVarCompensatorAdder.setRegulationMode(staticVarCompensatorCreationInfos.getRegulationMode()); + .setVoltageSetpoint(nanIfNull(voltageSetpoint)) + .setReactivePowerSetpoint(nanIfNull(reactivePowerSetpoint)) + .setRegulating(regulating); + if (regulating) { + staticVarCompensatorAdder.setRegulationMode(regulationMode); } if (terminal != null) { @@ -126,58 +182,56 @@ private StaticVarCompensatorAdder createStaticVarCompensatorAdderInNodeBreaker(V return staticVarCompensatorAdder; } - private void addExtensionsToStaticVarCompensator(StaticVarCompensatorCreationInfos staticVarCompensatorCreationInfos, - StaticVarCompensator staticVarCompensator, + private void addExtensionsToStaticVarCompensator(StaticVarCompensator staticVarCompensator, VoltageLevel voltageLevel, ReportNode subReportNode) { - if (staticVarCompensatorCreationInfos.getEquipmentName() != null) { - ModificationUtils.getInstance().reportElementaryCreation(subReportNode, staticVarCompensatorCreationInfos.getEquipmentName(), "Name"); + if (equipmentName != null) { + ModificationUtils.getInstance().reportElementaryCreation(subReportNode, equipmentName, "Name"); } - reportInjectionCreationConnectivity(staticVarCompensatorCreationInfos, subReportNode); - reportStaticVarCompensatorLimitsAndSetpoints(staticVarCompensatorCreationInfos, staticVarCompensator, voltageLevel, subReportNode); - reportStaticVarCompensatorStandbyAutomaton(staticVarCompensatorCreationInfos, staticVarCompensator, voltageLevel, subReportNode); + reportInjectionCreationConnectivity(this, subReportNode); + reportStaticVarCompensatorLimitsAndSetpoints(staticVarCompensator, voltageLevel, subReportNode); + reportStaticVarCompensatorStandbyAutomaton(staticVarCompensator, voltageLevel, subReportNode); } - private void reportStaticVarCompensatorStandbyAutomaton(StaticVarCompensatorCreationInfos staticVarCompensatorCreationInfos, - StaticVarCompensator staticVarCompensator, VoltageLevel voltageLevel, ReportNode subReportNode) { - if (Boolean.TRUE.equals(staticVarCompensatorCreationInfos.isStandbyAutomatonOn())) { + private void reportStaticVarCompensatorStandbyAutomaton(StaticVarCompensator staticVarCompensator, VoltageLevel voltageLevel, ReportNode subReportNode) { + if (standbyAutomatonOn) { List standbyAutomatonReports = new ArrayList<>(); - double b0 = Objects.isNull(staticVarCompensatorCreationInfos.getB0()) && Objects.nonNull(staticVarCompensatorCreationInfos.getQ0()) ? - (staticVarCompensatorCreationInfos.getQ0()) / Math.pow(voltageLevel.getNominalV(), 2) : staticVarCompensatorCreationInfos.getB0(); + double computedB0 = Objects.isNull(b0) && Objects.nonNull(q0) ? + q0 / Math.pow(voltageLevel.getNominalV(), 2) : b0; try { staticVarCompensator.newExtension(StandbyAutomatonAdder.class) - .withStandbyStatus(staticVarCompensatorCreationInfos.isStandby()) - .withB0(b0) - .withLowVoltageSetpoint(staticVarCompensatorCreationInfos.getLowVoltageSetpoint()) - .withHighVoltageSetpoint(staticVarCompensatorCreationInfos.getHighVoltageSetpoint()) - .withLowVoltageThreshold(staticVarCompensatorCreationInfos.getLowVoltageThreshold()) - .withHighVoltageThreshold(staticVarCompensatorCreationInfos.getHighVoltageThreshold()) + .withStandbyStatus(standby) + .withB0(computedB0) + .withLowVoltageSetpoint(lowVoltageSetpoint) + .withHighVoltageSetpoint(highVoltageSetpoint) + .withLowVoltageThreshold(lowVoltageThreshold) + .withHighVoltageThreshold(highVoltageThreshold) .add(); standbyAutomatonReports.add(ModificationUtils.getInstance().buildCreationReport( - staticVarCompensatorCreationInfos.isStandby(), + standby, "Standby")); - if (Objects.nonNull(staticVarCompensatorCreationInfos.getB0())) { + if (Objects.nonNull(b0)) { standbyAutomatonReports.add(ModificationUtils.getInstance().buildCreationReport( - staticVarCompensatorCreationInfos.getB0(), + b0, "Fixed part of susceptance")); } - if (Objects.nonNull(staticVarCompensatorCreationInfos.getQ0())) { + if (Objects.nonNull(q0)) { standbyAutomatonReports.add(ModificationUtils.getInstance().buildCreationReport( - staticVarCompensatorCreationInfos.getQ0(), + q0, "Fixed part of Q at nominal voltage")); } standbyAutomatonReports.add(ModificationUtils.getInstance().buildCreationReport( - staticVarCompensatorCreationInfos.getLowVoltageSetpoint(), + lowVoltageSetpoint, "Low voltage set point")); standbyAutomatonReports.add(ModificationUtils.getInstance().buildCreationReport( - staticVarCompensatorCreationInfos.getHighVoltageSetpoint(), + highVoltageSetpoint, "High voltage set point")); standbyAutomatonReports.add(ModificationUtils.getInstance().buildCreationReport( - staticVarCompensatorCreationInfos.getHighVoltageThreshold(), + highVoltageThreshold, "High voltage threshold")); standbyAutomatonReports.add(ModificationUtils.getInstance().buildCreationReport( - staticVarCompensatorCreationInfos.getLowVoltageThreshold(), + lowVoltageThreshold, "Low voltage threshold")); } catch (PowsyblException e) { standbyAutomatonReports.add(ReportNode.newRootReportNode() @@ -192,85 +246,83 @@ private void reportStaticVarCompensatorStandbyAutomaton(StaticVarCompensatorCrea } } - private void createStaticVarCompensatorInBusBreaker(VoltageLevel voltageLevel, StaticVarCompensatorCreationInfos staticVarCompensatorCreationInfos, - ReportNode subReportNode) { + private void createStaticVarCompensatorInBusBreaker(VoltageLevel voltageLevel, ReportNode subReportNode) { - Bus bus = ModificationUtils.getInstance().getBusBreakerBus(voltageLevel, staticVarCompensatorCreationInfos.getBusOrBusbarSectionId()); - double bMax = Objects.isNull(staticVarCompensatorCreationInfos.getMaxSusceptance()) && Objects.nonNull(staticVarCompensatorCreationInfos.getMaxQAtNominalV()) ? - (staticVarCompensatorCreationInfos.getMaxQAtNominalV()) / Math.pow(voltageLevel.getNominalV(), 2) : staticVarCompensatorCreationInfos.getMaxSusceptance(); - double bMin = Objects.isNull(staticVarCompensatorCreationInfos.getMinSusceptance()) && Objects.nonNull(staticVarCompensatorCreationInfos.getMinQAtNominalV()) ? - (staticVarCompensatorCreationInfos.getMinQAtNominalV()) / Math.pow(voltageLevel.getNominalV(), 2) : staticVarCompensatorCreationInfos.getMinSusceptance(); + Bus bus = ModificationUtils.getInstance().getBusBreakerBus(voltageLevel, busOrBusbarSectionId); + double bMax = Objects.isNull(maxSusceptance) && Objects.nonNull(maxQAtNominalV) ? + maxQAtNominalV / Math.pow(voltageLevel.getNominalV(), 2) : maxSusceptance; + double bMin = Objects.isNull(minSusceptance) && Objects.nonNull(minQAtNominalV) ? + minQAtNominalV / Math.pow(voltageLevel.getNominalV(), 2) : minSusceptance; /* creating the static var compensator */ StaticVarCompensatorAdder staticVarCompensatorAdder = voltageLevel.newStaticVarCompensator() - .setId(staticVarCompensatorCreationInfos.getEquipmentId()) - .setName(staticVarCompensatorCreationInfos.getEquipmentName()) + .setId(equipmentId) + .setName(equipmentName) .setBus(bus.getId()) .setConnectableBus(bus.getId()) .setBmax(bMax) .setBmin(bMin) - .setVoltageSetpoint(staticVarCompensatorCreationInfos.getVoltageSetpoint()) - .setReactivePowerSetpoint(staticVarCompensatorCreationInfos.getReactivePowerSetpoint()) - .setRegulating(staticVarCompensatorCreationInfos.isRegulating()); - if (staticVarCompensatorCreationInfos.isRegulating()) { - staticVarCompensatorAdder.setRegulationMode(staticVarCompensatorCreationInfos.getRegulationMode()); + .setVoltageSetpoint(voltageSetpoint) + .setReactivePowerSetpoint(reactivePowerSetpoint) + .setRegulating(regulating); + if (regulating) { + staticVarCompensatorAdder.setRegulationMode(regulationMode); } StaticVarCompensator staticVarCompensator = staticVarCompensatorAdder.add(); - addExtensionsToStaticVarCompensator(staticVarCompensatorCreationInfos, staticVarCompensator, voltageLevel, subReportNode); + addExtensionsToStaticVarCompensator(staticVarCompensator, voltageLevel, subReportNode); } - private void reportStaticVarCompensatorLimitsAndSetpoints(StaticVarCompensatorCreationInfos staticVarCompensatorCreationInfos, - StaticVarCompensator staticVarCompensator, VoltageLevel voltageLevel, ReportNode subReportNode) { + private void reportStaticVarCompensatorLimitsAndSetpoints(StaticVarCompensator staticVarCompensator, VoltageLevel voltageLevel, ReportNode subReportNode) { List voltageReports = new ArrayList<>(); - if (Objects.nonNull(staticVarCompensatorCreationInfos.getMinSusceptance())) { - voltageReports.add(ModificationUtils.getInstance().buildCreationReport(staticVarCompensatorCreationInfos.getMinSusceptance(), "Susceptance min")); + if (Objects.nonNull(minSusceptance)) { + voltageReports.add(ModificationUtils.getInstance().buildCreationReport(minSusceptance, "Susceptance min")); } - if (Objects.nonNull(staticVarCompensatorCreationInfos.getMaxSusceptance())) { - voltageReports.add(ModificationUtils.getInstance().buildCreationReport(staticVarCompensatorCreationInfos.getMaxSusceptance(), "Susceptance max")); + if (Objects.nonNull(maxSusceptance)) { + voltageReports.add(ModificationUtils.getInstance().buildCreationReport(maxSusceptance, "Susceptance max")); } - if (Objects.nonNull(staticVarCompensatorCreationInfos.getMinQAtNominalV())) { - voltageReports.add(ModificationUtils.getInstance().buildCreationReport(staticVarCompensatorCreationInfos.getMinQAtNominalV(), "Q min at nominal voltage")); + if (Objects.nonNull(minQAtNominalV)) { + voltageReports.add(ModificationUtils.getInstance().buildCreationReport(minQAtNominalV, "Q min at nominal voltage")); } - if (Objects.nonNull(staticVarCompensatorCreationInfos.getMaxQAtNominalV())) { - voltageReports.add(ModificationUtils.getInstance().buildCreationReport(staticVarCompensatorCreationInfos.getMaxQAtNominalV(), "Q max at nominal voltage")); + if (Objects.nonNull(maxQAtNominalV)) { + voltageReports.add(ModificationUtils.getInstance().buildCreationReport(maxQAtNominalV, "Q max at nominal voltage")); } - if (Objects.nonNull(staticVarCompensatorCreationInfos.getRegulationMode())) { - voltageReports.add(ModificationUtils.getInstance().buildCreationReport(staticVarCompensatorCreationInfos.getRegulationMode(), "regulation mode")); + if (Objects.nonNull(regulationMode)) { + voltageReports.add(ModificationUtils.getInstance().buildCreationReport(regulationMode, "regulation mode")); } - if (Objects.nonNull(staticVarCompensatorCreationInfos.getVoltageSetpoint())) { - voltageReports.add(ModificationUtils.getInstance().buildCreationReport(staticVarCompensatorCreationInfos.getVoltageSetpoint(), "Voltage set point")); + if (Objects.nonNull(voltageSetpoint)) { + voltageReports.add(ModificationUtils.getInstance().buildCreationReport(voltageSetpoint, "Voltage set point")); } - if (Objects.nonNull(staticVarCompensatorCreationInfos.getReactivePowerSetpoint())) { - voltageReports.add(ModificationUtils.getInstance().buildCreationReport(staticVarCompensatorCreationInfos.getReactivePowerSetpoint(), "Reactive power set point")); + if (Objects.nonNull(reactivePowerSetpoint)) { + voltageReports.add(ModificationUtils.getInstance().buildCreationReport(reactivePowerSetpoint, "Reactive power set point")); } - if (Objects.nonNull(staticVarCompensatorCreationInfos.getVoltageRegulationType())) { - voltageReports.add(ModificationUtils.getInstance().buildCreationReport(staticVarCompensatorCreationInfos.getVoltageRegulationType(), "Voltage Regulation type")); + if (Objects.nonNull(voltageRegulationType)) { + voltageReports.add(ModificationUtils.getInstance().buildCreationReport(voltageRegulationType, "Voltage Regulation type")); } - if (staticVarCompensatorCreationInfos.getRegulatingTerminalVlId() != null && staticVarCompensatorCreationInfos.getRegulatingTerminalId() != null && - staticVarCompensatorCreationInfos.getRegulatingTerminalType() != null) { + if (regulatingTerminalVlId != null && regulatingTerminalId != null && + regulatingTerminalType != null) { Terminal terminal = ModificationUtils.getInstance().getTerminalFromIdentifiable(voltageLevel.getNetwork(), - staticVarCompensatorCreationInfos.getRegulatingTerminalId(), - staticVarCompensatorCreationInfos.getRegulatingTerminalType(), - staticVarCompensatorCreationInfos.getRegulatingTerminalVlId()); + regulatingTerminalId, + regulatingTerminalType, + regulatingTerminalVlId); if (terminal != null) { - updateCompensatorRegulatingTerminal(staticVarCompensatorCreationInfos, staticVarCompensator, terminal, voltageReports); + updateCompensatorRegulatingTerminal(staticVarCompensator, terminal, voltageReports); } } ModificationUtils.getInstance().reportModifications(subReportNode, voltageReports, "network.modification.LimitsAndSetpointsCreated"); } - private void updateCompensatorRegulatingTerminal(StaticVarCompensatorCreationInfos staticVarCompensatorCreationInfos, StaticVarCompensator staticVarCompensator, + private void updateCompensatorRegulatingTerminal(StaticVarCompensator staticVarCompensator, Terminal terminal, List voltageReports) { - if (staticVarCompensatorCreationInfos.getRegulatingTerminalId() != null - && staticVarCompensatorCreationInfos.getRegulatingTerminalType() != null - && staticVarCompensatorCreationInfos.getRegulatingTerminalVlId() != null) { + if (regulatingTerminalId != null + && regulatingTerminalType != null + && regulatingTerminalVlId != null) { staticVarCompensator.setRegulatingTerminal(terminal); voltageReports.add(ModificationUtils.getInstance().buildCreationReport( - staticVarCompensatorCreationInfos.getRegulatingTerminalVlId(), + regulatingTerminalVlId, "Voltage level")); voltageReports.add(ModificationUtils.getInstance().buildCreationReport( - staticVarCompensatorCreationInfos.getRegulatingTerminalType() + ":" - + staticVarCompensatorCreationInfos.getRegulatingTerminalId(), + regulatingTerminalType + ":" + + regulatingTerminalId, "Equipment")); } } diff --git a/src/main/java/org/gridsuite/modification/modifications/SubstationCreation.java b/src/main/java/org/gridsuite/modification/modifications/SubstationCreation.java index 1ed63588..beb1491a 100644 --- a/src/main/java/org/gridsuite/modification/modifications/SubstationCreation.java +++ b/src/main/java/org/gridsuite/modification/modifications/SubstationCreation.java @@ -1,30 +1,49 @@ +/** + * Copyright (c) 2026, 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/. + */ package org.gridsuite.modification.modifications; import com.powsybl.commons.report.ReportNode; +import com.powsybl.iidm.network.Country; import com.powsybl.iidm.network.Network; import com.powsybl.iidm.network.Substation; -import org.gridsuite.modification.dto.SubstationCreationInfos; +import lombok.*; +import org.gridsuite.modification.dto.FreePropertyInfos; import org.gridsuite.modification.utils.ModificationUtils; import org.gridsuite.modification.utils.PropertiesUtils; -public class SubstationCreation extends AbstractModification { +import java.util.List; - private final SubstationCreationInfos modificationInfos; +/** + * @author Joris Mancini + */ +@Getter +@Setter +public class SubstationCreation extends AbstractEquipmentCreation { - public SubstationCreation(SubstationCreationInfos modificationInfos) { - this.modificationInfos = modificationInfos; + private Country country; + + @Builder + public SubstationCreation(String equipmentId, List properties, String equipmentName, + Country country) { + super(equipmentId, properties, equipmentName); + this.country = country; } @Override public void apply(Network network, ReportNode subReportNode) { - ModificationUtils.getInstance().createSubstation(modificationInfos, subReportNode, network); - Substation substation = network.getSubstation(modificationInfos.getEquipmentId()); + ModificationUtils.getInstance().createSubstation(this, subReportNode, network); + Substation substation = network.getSubstation(equipmentId); // properties - PropertiesUtils.applyProperties(substation, subReportNode, modificationInfos.getProperties(), "network.modification.SubstationProperties"); + PropertiesUtils.applyProperties(substation, subReportNode, properties, "network.modification.SubstationProperties"); } @Override public String getName() { return "SubstationCreation"; } + } diff --git a/src/main/java/org/gridsuite/modification/modifications/SubstationModification.java b/src/main/java/org/gridsuite/modification/modifications/SubstationModification.java index 223ec884..f9aa2112 100644 --- a/src/main/java/org/gridsuite/modification/modifications/SubstationModification.java +++ b/src/main/java/org/gridsuite/modification/modifications/SubstationModification.java @@ -8,50 +8,60 @@ import com.powsybl.commons.report.ReportNode; import com.powsybl.commons.report.TypedValue; +import com.powsybl.iidm.network.Country; import com.powsybl.iidm.network.Network; import com.powsybl.iidm.network.Substation; +import lombok.*; import org.gridsuite.modification.NetworkModificationException; -import org.gridsuite.modification.dto.SubstationModificationInfos; +import org.gridsuite.modification.dto.AttributeModification; +import org.gridsuite.modification.dto.FreePropertyInfos; import org.gridsuite.modification.utils.ModificationUtils; import org.gridsuite.modification.utils.PropertiesUtils; +import java.util.List; + import static org.gridsuite.modification.NetworkModificationException.Type.SUBSTATION_NOT_FOUND; /* * @author David Braquart */ -public class SubstationModification extends AbstractModification { +@Getter +@Setter +public class SubstationModification extends AbstractEquipmentModification { - private final SubstationModificationInfos modificationInfos; + private AttributeModification country; - public SubstationModification(SubstationModificationInfos modificationInfos) { - this.modificationInfos = modificationInfos; + @Builder + public SubstationModification(String equipmentId, List properties, + AttributeModification equipmentName, AttributeModification country) { + super(equipmentId, properties, equipmentName); + this.country = country; } @Override public void check(Network network) throws NetworkModificationException { - Substation station = network.getSubstation(modificationInfos.getEquipmentId()); + Substation station = network.getSubstation(equipmentId); if (station == null) { throw new NetworkModificationException(SUBSTATION_NOT_FOUND, - "Substation " + modificationInfos.getEquipmentId() + " does not exist in network"); + "Substation " + equipmentId + " does not exist in network"); } } @Override public void apply(Network network, ReportNode subReportNode) { - Substation station = network.getSubstation(modificationInfos.getEquipmentId()); + Substation station = network.getSubstation(equipmentId); // modify the substation in the network subReportNode.newReportNode() .withMessageTemplate("network.modification.substationModification") - .withUntypedValue("id", modificationInfos.getEquipmentId()) + .withUntypedValue("id", equipmentId) .withSeverity(TypedValue.INFO_SEVERITY) .add(); // name and country - ModificationUtils.getInstance().applyElementaryModifications(station::setName, () -> station.getOptionalName().orElse("No value"), modificationInfos.getEquipmentName(), subReportNode, "Name"); - ModificationUtils.getInstance().applyElementaryModifications(station::setCountry, station::getNullableCountry, modificationInfos.getCountry(), subReportNode, "Country"); + ModificationUtils.getInstance().applyElementaryModifications(station::setName, () -> station.getOptionalName().orElse("No value"), equipmentName, subReportNode, "Name"); + ModificationUtils.getInstance().applyElementaryModifications(station::setCountry, station::getNullableCountry, country, subReportNode, "Country"); // properties - PropertiesUtils.applyProperties(station, subReportNode, modificationInfos.getProperties(), "network.modification.SubstationProperties"); + PropertiesUtils.applyProperties(station, subReportNode, properties, "network.modification.SubstationProperties"); } @Override diff --git a/src/main/java/org/gridsuite/modification/modifications/TwoWindingsTransformerCreation.java b/src/main/java/org/gridsuite/modification/modifications/TwoWindingsTransformerCreation.java index 5303ce1c..c5f561bc 100644 --- a/src/main/java/org/gridsuite/modification/modifications/TwoWindingsTransformerCreation.java +++ b/src/main/java/org/gridsuite/modification/modifications/TwoWindingsTransformerCreation.java @@ -9,6 +9,8 @@ import com.powsybl.commons.report.ReportNode; import com.powsybl.commons.report.TypedValue; import com.powsybl.iidm.network.*; +import com.powsybl.iidm.network.extensions.ConnectablePosition; +import lombok.*; import org.apache.commons.collections4.CollectionUtils; import org.gridsuite.filter.utils.expertfilter.RatioRegulationModeType; import org.gridsuite.modification.NetworkModificationException; @@ -27,29 +29,63 @@ import static org.gridsuite.modification.dto.OperationalLimitsGroupInfos.Applicability.SIDE2; import static org.gridsuite.modification.utils.ModificationUtils.*; -public class TwoWindingsTransformerCreation extends AbstractModification { - private final TwoWindingsTransformerCreationInfos modificationInfos; - - public TwoWindingsTransformerCreation(TwoWindingsTransformerCreationInfos modificationInfos) { - this.modificationInfos = modificationInfos; +/** + * @author Joris Mancini + */ +@Getter +@Setter +public class TwoWindingsTransformerCreation extends AbstractBranchCreation { + + private double g; + private double b; + private double ratedU1; + private double ratedU2; + private Double ratedS; + private RatioTapChangerCreationInfos ratioTapChanger; + private PhaseTapChangerCreationInfos phaseTapChanger; + + @Builder + public TwoWindingsTransformerCreation(String equipmentId, List properties, String equipmentName, + double r, double x, String voltageLevelId1, String voltageLevelId2, + String busOrBusbarSectionId1, String busOrBusbarSectionId2, + List operationalLimitsGroups, + String selectedOperationalLimitsGroupId1, + String selectedOperationalLimitsGroupId2, String connectionName1, + ConnectablePosition.Direction connectionDirection1, String connectionName2, + ConnectablePosition.Direction connectionDirection2, + Integer connectionPosition1, Integer connectionPosition2, boolean connected1, + boolean connected2, double g, double b, double ratedU1, double ratedU2, + Double ratedS, RatioTapChangerCreationInfos ratioTapChanger, + PhaseTapChangerCreationInfos phaseTapChanger) { + super(equipmentId, properties, equipmentName, r, x, voltageLevelId1, voltageLevelId2, busOrBusbarSectionId1, + busOrBusbarSectionId2, operationalLimitsGroups, selectedOperationalLimitsGroupId1, + selectedOperationalLimitsGroupId2, connectionName1, connectionDirection1, connectionName2, + connectionDirection2, connectionPosition1, connectionPosition2, connected1, connected2); + this.g = g; + this.b = b; + this.ratedU1 = ratedU1; + this.ratedU2 = ratedU2; + this.ratedS = ratedS; + this.ratioTapChanger = ratioTapChanger; + this.phaseTapChanger = phaseTapChanger; } @Override public void check(Network network) throws NetworkModificationException { - if (network.getTwoWindingsTransformer(modificationInfos.getEquipmentId()) != null) { - throw new NetworkModificationException(TWO_WINDINGS_TRANSFORMER_ALREADY_EXISTS, modificationInfos.getEquipmentId()); + if (network.getTwoWindingsTransformer(equipmentId) != null) { + throw new NetworkModificationException(TWO_WINDINGS_TRANSFORMER_ALREADY_EXISTS, equipmentId); } - String errorMessage = "Two windings transformer '" + modificationInfos.getEquipmentId() + "' : "; + String errorMessage = "Two windings transformer '" + equipmentId + "' : "; getInstance().controlBranchCreation(network, - modificationInfos.getVoltageLevelId1(), modificationInfos.getBusOrBusbarSectionId1(), - modificationInfos.getVoltageLevelId2(), modificationInfos.getBusOrBusbarSectionId2()); - checkIsNotNegativeValue(errorMessage, modificationInfos.getR(), CREATE_TWO_WINDINGS_TRANSFORMER_ERROR, "Resistance R"); - checkIsNotNegativeValue(errorMessage, modificationInfos.getG(), CREATE_TWO_WINDINGS_TRANSFORMER_ERROR, "Conductance G"); - checkIsNotNegativeValue(errorMessage, modificationInfos.getRatedU1(), CREATE_TWO_WINDINGS_TRANSFORMER_ERROR, "Rated Voltage on side 1"); - checkIsNotNegativeValue(errorMessage, modificationInfos.getRatedU2(), CREATE_TWO_WINDINGS_TRANSFORMER_ERROR, "Rated Voltage on side 2"); - checkIsNotNegativeValue(errorMessage, modificationInfos.getRatedS(), CREATE_TWO_WINDINGS_TRANSFORMER_ERROR, "Rated nominal power"); - if (modificationInfos.getRatioTapChanger() != null) { - checkIsNotNegativeValue(errorMessage, modificationInfos.getRatioTapChanger().getTargetV(), + voltageLevelId1, busOrBusbarSectionId1, + voltageLevelId2, busOrBusbarSectionId2); + checkIsNotNegativeValue(errorMessage, r, CREATE_TWO_WINDINGS_TRANSFORMER_ERROR, "Resistance R"); + checkIsNotNegativeValue(errorMessage, g, CREATE_TWO_WINDINGS_TRANSFORMER_ERROR, "Conductance G"); + checkIsNotNegativeValue(errorMessage, ratedU1, CREATE_TWO_WINDINGS_TRANSFORMER_ERROR, "Rated Voltage on side 1"); + checkIsNotNegativeValue(errorMessage, ratedU2, CREATE_TWO_WINDINGS_TRANSFORMER_ERROR, "Rated Voltage on side 2"); + checkIsNotNegativeValue(errorMessage, ratedS, CREATE_TWO_WINDINGS_TRANSFORMER_ERROR, "Rated nominal power"); + if (ratioTapChanger != null) { + checkIsNotNegativeValue(errorMessage, ratioTapChanger.getTargetV(), CREATE_TWO_WINDINGS_TRANSFORMER_ERROR, "Target voltage for ratio tap changer"); } } @@ -57,19 +93,19 @@ public void check(Network network) throws NetworkModificationException { @Override public void apply(Network network, ReportNode subReportNode) { // create the 2wt in the network - VoltageLevel voltageLevel1 = getInstance().getVoltageLevel(network, modificationInfos.getVoltageLevelId1()); - VoltageLevel voltageLevel2 = getInstance().getVoltageLevel(network, modificationInfos.getVoltageLevelId2()); + VoltageLevel voltageLevel1 = getInstance().getVoltageLevel(network, voltageLevelId1); + VoltageLevel voltageLevel2 = getInstance().getVoltageLevel(network, voltageLevelId2); if (voltageLevel1.getTopologyKind() == TopologyKind.NODE_BREAKER && voltageLevel2.getTopologyKind() == TopologyKind.NODE_BREAKER) { create2WTInNodeBreaker(network, voltageLevel1, voltageLevel2, subReportNode); } else { // Create 2wt in bus/mixed breaker - create2WTInOtherBreaker(network, voltageLevel1, voltageLevel2, modificationInfos, true, true, subReportNode); + create2WTInOtherBreaker(network, voltageLevel1, voltageLevel2, true, true, subReportNode); } - getInstance().disconnectBranch(modificationInfos, network.getTwoWindingsTransformer(modificationInfos.getEquipmentId()), subReportNode); + getInstance().disconnectBranch(this, network.getTwoWindingsTransformer(equipmentId), subReportNode); subReportNode.newReportNode() .withMessageTemplate("network.modification.twoWindingsTransformerCreated") - .withUntypedValue("id", modificationInfos.getEquipmentId()) + .withUntypedValue("id", equipmentId) .withSeverity(TypedValue.INFO_SEVERITY) .add(); } @@ -80,14 +116,14 @@ public String getName() { } private void create2WTInNodeBreaker(Network network, VoltageLevel voltageLevel1, VoltageLevel voltageLevel2, ReportNode subReportNode) { - var twoWindingsTransformerAdder = createTwoWindingsTransformerAdder(voltageLevel1, voltageLevel2, modificationInfos, false, false); - createBranchInNodeBreaker(voltageLevel1, voltageLevel2, modificationInfos, network, twoWindingsTransformerAdder, subReportNode); - var twoWindingsTransformer = network.getTwoWindingsTransformer(modificationInfos.getEquipmentId()); - completeTwoWindingsTransformerCreation(network, twoWindingsTransformer, modificationInfos, subReportNode); + var twoWindingsTransformerAdder = createTwoWindingsTransformerAdder(voltageLevel1, voltageLevel2, false, false); + createBranchInNodeBreaker(voltageLevel1, voltageLevel2, this, network, twoWindingsTransformerAdder, subReportNode); + var twoWindingsTransformer = network.getTwoWindingsTransformer(equipmentId); + completeTwoWindingsTransformerCreation(network, twoWindingsTransformer, subReportNode); } private TwoWindingsTransformerAdder createTwoWindingsTransformerAdder(VoltageLevel voltageLevel1, VoltageLevel voltageLevel2, - TwoWindingsTransformerCreationInfos twoWindingsTransformerCreationInfos, boolean withSwitch1, boolean withSwitch2) { + boolean withSwitch1, boolean withSwitch2) { Optional optS1 = voltageLevel1.getSubstation(); Optional optS2 = voltageLevel2.getSubstation(); Substation s1 = optS1.orElse(null); @@ -102,46 +138,46 @@ private TwoWindingsTransformerAdder createTwoWindingsTransformerAdder(VoltageLev throw new NetworkModificationException(TWO_WINDINGS_TRANSFORMER_CREATION_ERROR, "The two windings transformer should belong to a substation"); } // common settings - TwoWindingsTransformerAdder twoWindingsTransformerAdder = branchAdder.setId(twoWindingsTransformerCreationInfos.getEquipmentId()) - .setName(twoWindingsTransformerCreationInfos.getEquipmentName()) - .setVoltageLevel1(twoWindingsTransformerCreationInfos.getVoltageLevelId1()) - .setVoltageLevel2(twoWindingsTransformerCreationInfos.getVoltageLevelId2()) - .setG(twoWindingsTransformerCreationInfos.getG()) - .setB(twoWindingsTransformerCreationInfos.getB()) - .setR(twoWindingsTransformerCreationInfos.getR()) - .setX(twoWindingsTransformerCreationInfos.getX()) - .setRatedU1(twoWindingsTransformerCreationInfos.getRatedU1()) - .setRatedU2(twoWindingsTransformerCreationInfos.getRatedU2()); - - if (twoWindingsTransformerCreationInfos.getRatedS() != null) { - twoWindingsTransformerAdder.setRatedS(twoWindingsTransformerCreationInfos.getRatedS()); + TwoWindingsTransformerAdder twoWindingsTransformerAdder = branchAdder.setId(equipmentId) + .setName(equipmentName) + .setVoltageLevel1(voltageLevelId1) + .setVoltageLevel2(voltageLevelId2) + .setG(g) + .setB(b) + .setR(r) + .setX(x) + .setRatedU1(ratedU1) + .setRatedU2(ratedU2); + + if (ratedS != null) { + twoWindingsTransformerAdder.setRatedS(ratedS); } // BranchAdder completion by topology - getInstance().setBranchAdderNodeOrBus(branchAdder, voltageLevel1, twoWindingsTransformerCreationInfos, TwoSides.ONE, withSwitch1); - getInstance().setBranchAdderNodeOrBus(branchAdder, voltageLevel2, twoWindingsTransformerCreationInfos, TwoSides.TWO, withSwitch2); + getInstance().setBranchAdderNodeOrBus(branchAdder, voltageLevel1, this, TwoSides.ONE, withSwitch1); + getInstance().setBranchAdderNodeOrBus(branchAdder, voltageLevel2, this, TwoSides.TWO, withSwitch2); return twoWindingsTransformerAdder; } - private void addTapChangersToTwoWindingsTransformer(Network network, TwoWindingsTransformerCreationInfos twoWindingsTransformerCreationInfos, TwoWindingsTransformer twt, - ReportNode subReportNode) { - if (twoWindingsTransformerCreationInfos.getRatioTapChanger() != null) { - addRatioTapChangersToTwoWindingsTransformer(network, twoWindingsTransformerCreationInfos, twt, subReportNode); + private void addTapChangersToTwoWindingsTransformer(Network network, TwoWindingsTransformer twt, + ReportNode subReportNode) { + if (ratioTapChanger != null) { + addRatioTapChangersToTwoWindingsTransformer(network, twt, subReportNode); } - if (twoWindingsTransformerCreationInfos.getPhaseTapChanger() != null) { - addPhaseTapChangersToTwoWindingsTransformer(network, twoWindingsTransformerCreationInfos, twt, subReportNode); + if (phaseTapChanger != null) { + addPhaseTapChangersToTwoWindingsTransformer(network, twt, subReportNode); } } - private void addPhaseTapChangersToTwoWindingsTransformer(Network network, TwoWindingsTransformerCreationInfos twoWindingsTransformerCreationInfos, TwoWindingsTransformer twt, + private void addPhaseTapChangersToTwoWindingsTransformer(Network network, TwoWindingsTransformer twt, ReportNode subReportNode) { List regulatedTerminalReports = new ArrayList<>(); List regulationReports = new ArrayList<>(); List tapsReports = new ArrayList<>(); - PhaseTapChangerCreationInfos phaseTapChangerInfos = twoWindingsTransformerCreationInfos.getPhaseTapChanger(); + PhaseTapChangerCreationInfos phaseTapChangerInfos = phaseTapChanger; PhaseTapChangerAdder phaseTapChangerAdder = twt.newPhaseTapChanger(); double targetDeadband = phaseTapChangerInfos.getTargetDeadband() != null ? phaseTapChangerInfos.getTargetDeadband() : 0.; if (phaseTapChangerInfos.isRegulating()) { @@ -188,12 +224,12 @@ private void addPhaseTapChangersToTwoWindingsTransformer(Network network, TwoWin } } - private void addRatioTapChangersToTwoWindingsTransformer(Network network, TwoWindingsTransformerCreationInfos twoWindingsTransformerCreationInfos, TwoWindingsTransformer twt, + private void addRatioTapChangersToTwoWindingsTransformer(Network network, TwoWindingsTransformer twt, ReportNode subReportNode) { List regulatedTerminalReports = new ArrayList<>(); List regulationReports = new ArrayList<>(); List tapsReports = new ArrayList<>(); - RatioTapChangerCreationInfos ratioTapChangerInfos = twoWindingsTransformerCreationInfos.getRatioTapChanger(); + RatioTapChangerCreationInfos ratioTapChangerInfos = ratioTapChanger; RatioTapChangerAdder ratioTapChangerAdder = twt.newRatioTapChanger(); Terminal terminal = getInstance().getTerminalFromIdentifiable(network, ratioTapChangerInfos.getTerminalRefConnectableId(), @@ -242,39 +278,38 @@ private void addRatioTapChangersToTwoWindingsTransformer(Network network, TwoWin } } - private void create2WTInOtherBreaker(Network network, VoltageLevel voltageLevel1, VoltageLevel voltageLevel2, TwoWindingsTransformerCreationInfos twoWindingsTransformerCreationInfos, + private void create2WTInOtherBreaker(Network network, VoltageLevel voltageLevel1, VoltageLevel voltageLevel2, boolean withSwitch1, boolean withSwitch2, ReportNode subReportNode) { - var twoWindingsTransformer = createTwoWindingsTransformerAdder(voltageLevel1, voltageLevel2, twoWindingsTransformerCreationInfos, withSwitch1, withSwitch2).add(); - completeTwoWindingsTransformerCreation(network, twoWindingsTransformer, modificationInfos, subReportNode); + var twoWindingsTransformer = createTwoWindingsTransformerAdder(voltageLevel1, voltageLevel2, withSwitch1, withSwitch2).add(); + completeTwoWindingsTransformerCreation(network, twoWindingsTransformer, subReportNode); } private void completeTwoWindingsTransformerCreation(Network network, TwoWindingsTransformer twoWindingsTransformer, - TwoWindingsTransformerCreationInfos modificationInfos, ReportNode subReportNode) { ReportNode characteristicsReporter = subReportNode.newReportNode().withMessageTemplate("network.modification.Characteristics").add(); // Connectivity - reportBranchCreationConnectivity(modificationInfos, characteristicsReporter); + reportBranchCreationConnectivity(this, characteristicsReporter); // properties - PropertiesUtils.applyProperties(twoWindingsTransformer, characteristicsReporter, modificationInfos.getProperties(), "network.modification.TwoWindingsTransformerProperties"); + PropertiesUtils.applyProperties(twoWindingsTransformer, characteristicsReporter, properties, "network.modification.TwoWindingsTransformerProperties"); // Set permanent and temporary current limits ReportNode limitsReporter = null; - List operationalLimitsGroups1 = ModificationUtils.getOperationalLimitsGroupsOnSide(modificationInfos.getOperationalLimitsGroups(), SIDE1); - List operationalLimitsGroups2 = ModificationUtils.getOperationalLimitsGroupsOnSide(modificationInfos.getOperationalLimitsGroups(), SIDE2); + List operationalLimitsGroups1 = ModificationUtils.getOperationalLimitsGroupsOnSide(operationalLimitsGroups, SIDE1); + List operationalLimitsGroups2 = ModificationUtils.getOperationalLimitsGroupsOnSide(operationalLimitsGroups, SIDE2); List limitSetsOnSideReportNodes = new ArrayList<>(); - if (!CollectionUtils.isEmpty(modificationInfos.getOperationalLimitsGroups())) { + if (!CollectionUtils.isEmpty(operationalLimitsGroups)) { limitsReporter = subReportNode.newReportNode().withMessageTemplate("network.modification.limitsCreated").add(); ReportNode reportNode = limitsReporter.newReportNode() .withSeverity(TypedValue.INFO_SEVERITY) .withMessageTemplate("network.modification.LimitSets") .add(); - for (OperationalLimitsGroupInfos olgInfos : modificationInfos.getOperationalLimitsGroups()) { + for (OperationalLimitsGroupInfos olgInfos : operationalLimitsGroups) { ReportNode limitSetNode = reportNode.newReportNode() .withMessageTemplate("network.modification.limitSetAdded") .withUntypedValue("name", olgInfos.getId()) @@ -290,34 +325,34 @@ private void completeTwoWindingsTransformerCreation(Network network, } } - if (modificationInfos.getSelectedOperationalLimitsGroupId1() != null) { - if (!ModificationUtils.hasLimitSet(operationalLimitsGroups1, modificationInfos.getSelectedOperationalLimitsGroupId1())) { + if (selectedOperationalLimitsGroupId1 != null) { + if (!ModificationUtils.hasLimitSet(operationalLimitsGroups1, selectedOperationalLimitsGroupId1)) { limitSetsOnSideReportNodes.add(ReportNode.newRootReportNode() .withMessageTemplate("network.modification.limitSetAbsentOnSide1") - .withUntypedValue("selectedOperationalLimitsGroup", modificationInfos.getSelectedOperationalLimitsGroupId1()) + .withUntypedValue("selectedOperationalLimitsGroup", selectedOperationalLimitsGroupId1) .withSeverity(TypedValue.WARN_SEVERITY) .build()); } else { - twoWindingsTransformer.setSelectedOperationalLimitsGroup1(modificationInfos.getSelectedOperationalLimitsGroupId1()); + twoWindingsTransformer.setSelectedOperationalLimitsGroup1(selectedOperationalLimitsGroupId1); limitSetsOnSideReportNodes.add(ReportNode.newRootReportNode() .withMessageTemplate("network.modification.limitSetSelectedOnSide1") - .withUntypedValue("selectedOperationalLimitsGroup1", modificationInfos.getSelectedOperationalLimitsGroupId1()) + .withUntypedValue("selectedOperationalLimitsGroup1", selectedOperationalLimitsGroupId1) .withSeverity(TypedValue.INFO_SEVERITY) .build()); } } - if (modificationInfos.getSelectedOperationalLimitsGroupId2() != null) { - if (!ModificationUtils.hasLimitSet(operationalLimitsGroups2, modificationInfos.getSelectedOperationalLimitsGroupId2())) { + if (selectedOperationalLimitsGroupId2 != null) { + if (!ModificationUtils.hasLimitSet(operationalLimitsGroups2, selectedOperationalLimitsGroupId2)) { limitSetsOnSideReportNodes.add(ReportNode.newRootReportNode() .withMessageTemplate("network.modification.limitSetAbsentOnSide2") - .withUntypedValue("selectedOperationalLimitsGroup", modificationInfos.getSelectedOperationalLimitsGroupId2()) + .withUntypedValue("selectedOperationalLimitsGroup", selectedOperationalLimitsGroupId2) .withSeverity(TypedValue.WARN_SEVERITY) .build()); } else { - twoWindingsTransformer.setSelectedOperationalLimitsGroup2(modificationInfos.getSelectedOperationalLimitsGroupId2()); + twoWindingsTransformer.setSelectedOperationalLimitsGroup2(selectedOperationalLimitsGroupId2); limitSetsOnSideReportNodes.add(ReportNode.newRootReportNode() .withMessageTemplate("network.modification.limitSetSelectedOnSide2") - .withUntypedValue("selectedOperationalLimitsGroup2", modificationInfos.getSelectedOperationalLimitsGroupId2()) + .withUntypedValue("selectedOperationalLimitsGroup2", selectedOperationalLimitsGroupId2) .withSeverity(TypedValue.INFO_SEVERITY) .build()); } @@ -331,6 +366,7 @@ private void completeTwoWindingsTransformerCreation(Network network, "network.modification.ActiveLimitSets"); } // tap changer - addTapChangersToTwoWindingsTransformer(network, modificationInfos, twoWindingsTransformer, characteristicsReporter); + addTapChangersToTwoWindingsTransformer(network, twoWindingsTransformer, characteristicsReporter); } + } diff --git a/src/main/java/org/gridsuite/modification/modifications/TwoWindingsTransformerModification.java b/src/main/java/org/gridsuite/modification/modifications/TwoWindingsTransformerModification.java index 9751940a..77c8bd3f 100644 --- a/src/main/java/org/gridsuite/modification/modifications/TwoWindingsTransformerModification.java +++ b/src/main/java/org/gridsuite/modification/modifications/TwoWindingsTransformerModification.java @@ -9,8 +9,12 @@ import com.powsybl.commons.report.ReportNode; import com.powsybl.commons.report.TypedValue; import com.powsybl.iidm.network.*; +import com.powsybl.iidm.network.extensions.ConnectablePosition; import com.powsybl.iidm.network.extensions.TwoWindingsTransformerToBeEstimated; import com.powsybl.iidm.network.extensions.TwoWindingsTransformerToBeEstimatedAdder; +import lombok.Builder; +import lombok.Getter; +import lombok.Setter; import org.apache.commons.lang3.BooleanUtils; import org.gridsuite.modification.NetworkModificationException; import org.gridsuite.modification.dto.*; @@ -29,47 +33,111 @@ /** * @author Florent MILLOT */ +@Getter +@Setter public class TwoWindingsTransformerModification extends AbstractBranchModification { public static final String MAGNETIZING_CONDUCTANCE_FIELD_NAME = "Magnetizing conductance"; private static final String TARGET_DEADBAND = "Target deadband"; public static final String ERROR_MESSAGE = "Two windings transformer '%s' : "; - public TwoWindingsTransformerModification(TwoWindingsTransformerModificationInfos modificationInfos) { - super(modificationInfos); + private AttributeModification g; + private AttributeModification b; + private AttributeModification ratedU1; + private AttributeModification ratedU2; + private AttributeModification ratedS; + private RatioTapChangerModificationInfos ratioTapChanger; + private PhaseTapChangerModificationInfos phaseTapChanger; + private AttributeModification ratioTapChangerToBeEstimated; + private AttributeModification phaseTapChangerToBeEstimated; + + @Builder + public TwoWindingsTransformerModification(String equipmentId, List properties, + AttributeModification equipmentName, + AttributeModification r, + AttributeModification x, + OperationalLimitsGroupsModificationType operationalLimitsGroupsModificationType, + Boolean enableOLGModification, + List operationalLimitsGroups, + AttributeModification selectedOperationalLimitsGroupId1, + AttributeModification selectedOperationalLimitsGroupId2, + AttributeModification voltageLevelId1, + AttributeModification voltageLevelId2, + AttributeModification busOrBusbarSectionId1, + AttributeModification busOrBusbarSectionId2, + AttributeModification connectionName1, + AttributeModification connectionName2, + AttributeModification connectionDirection1, + AttributeModification connectionDirection2, + AttributeModification connectionPosition1, + AttributeModification connectionPosition2, + AttributeModification terminal1Connected, + AttributeModification terminal2Connected, + AttributeModification p1MeasurementValue, + AttributeModification p1MeasurementValidity, + AttributeModification p2MeasurementValue, + AttributeModification p2MeasurementValidity, + AttributeModification q1MeasurementValue, + AttributeModification q1MeasurementValidity, + AttributeModification q2MeasurementValue, + AttributeModification q2MeasurementValidity, + AttributeModification g, AttributeModification b, + AttributeModification ratedU1, + AttributeModification ratedU2, + AttributeModification ratedS, + RatioTapChangerModificationInfos ratioTapChanger, + PhaseTapChangerModificationInfos phaseTapChanger, + AttributeModification ratioTapChangerToBeEstimated, + AttributeModification phaseTapChangerToBeEstimated) { + super(equipmentId, properties, equipmentName, r, x, operationalLimitsGroupsModificationType, + enableOLGModification, + operationalLimitsGroups, selectedOperationalLimitsGroupId1, selectedOperationalLimitsGroupId2, + voltageLevelId1, + voltageLevelId2, busOrBusbarSectionId1, busOrBusbarSectionId2, connectionName1, connectionName2, + connectionDirection1, connectionDirection2, connectionPosition1, connectionPosition2, terminal1Connected, + terminal2Connected, p1MeasurementValue, p1MeasurementValidity, p2MeasurementValue, p2MeasurementValidity, + q1MeasurementValue, q1MeasurementValidity, q2MeasurementValue, q2MeasurementValidity); + this.g = g; + this.b = b; + this.ratedU1 = ratedU1; + this.ratedU2 = ratedU2; + this.ratedS = ratedS; + this.ratioTapChanger = ratioTapChanger == null ? new RatioTapChangerModificationInfos() : ratioTapChanger; + this.phaseTapChanger = phaseTapChanger == null ? new PhaseTapChangerModificationInfos() : phaseTapChanger; + this.ratioTapChangerToBeEstimated = ratioTapChangerToBeEstimated; + this.phaseTapChangerToBeEstimated = phaseTapChangerToBeEstimated; } @Override public void check(Network network) throws NetworkModificationException { - String errorMessage = String.format(ERROR_MESSAGE, modificationInfos.getEquipmentId()); - TwoWindingsTransformer transformer = network.getTwoWindingsTransformer(modificationInfos.getEquipmentId()); + String errorMessage = String.format(ERROR_MESSAGE, equipmentId); + TwoWindingsTransformer transformer = network.getTwoWindingsTransformer(equipmentId); if (transformer == null) { throw new NetworkModificationException(TWO_WINDINGS_TRANSFORMER_NOT_FOUND, errorMessage + "it does not exist in the network"); } - ModificationUtils.getInstance().checkVoltageLevelModification(network, modificationInfos.getVoltageLevelId1(), - modificationInfos.getBusOrBusbarSectionId1(), transformer.getTerminal1()); - ModificationUtils.getInstance().checkVoltageLevelModification(network, modificationInfos.getVoltageLevelId2(), - modificationInfos.getBusOrBusbarSectionId2(), transformer.getTerminal2()); - TwoWindingsTransformerModificationInfos twtModificationInfos = (TwoWindingsTransformerModificationInfos) modificationInfos; - checkAndModifyTapChanger(network, twtModificationInfos.getRatioTapChanger(), transformer.getRatioTapChanger(), errorMessage); - checkAndModifyTapChanger(network, twtModificationInfos.getPhaseTapChanger(), transformer.getPhaseTapChanger(), errorMessage); - if (twtModificationInfos.getR() != null) { - checkIsNotNegativeValue(errorMessage, twtModificationInfos.getR().getValue(), MODIFY_TWO_WINDINGS_TRANSFORMER_ERROR, "Resistance R"); + ModificationUtils.getInstance().checkVoltageLevelModification(network, voltageLevelId1, + busOrBusbarSectionId1, transformer.getTerminal1()); + ModificationUtils.getInstance().checkVoltageLevelModification(network, voltageLevelId2, + busOrBusbarSectionId2, transformer.getTerminal2()); + checkAndModifyTapChanger(network, ratioTapChanger, transformer.getRatioTapChanger(), errorMessage); + checkAndModifyTapChanger(network, phaseTapChanger, transformer.getPhaseTapChanger(), errorMessage); + if (r != null) { + checkIsNotNegativeValue(errorMessage, r.getValue(), MODIFY_TWO_WINDINGS_TRANSFORMER_ERROR, "Resistance R"); } - if (twtModificationInfos.getG() != null) { - checkIsNotNegativeValue(errorMessage, twtModificationInfos.getG().getValue(), MODIFY_TWO_WINDINGS_TRANSFORMER_ERROR, "Conductance G"); + if (g != null) { + checkIsNotNegativeValue(errorMessage, g.getValue(), MODIFY_TWO_WINDINGS_TRANSFORMER_ERROR, "Conductance G"); } - if (twtModificationInfos.getRatedU1() != null) { - checkIsNotNegativeValue(errorMessage, twtModificationInfos.getRatedU1().getValue(), MODIFY_TWO_WINDINGS_TRANSFORMER_ERROR, "Rated Voltage on side 1"); + if (ratedU1 != null) { + checkIsNotNegativeValue(errorMessage, ratedU1.getValue(), MODIFY_TWO_WINDINGS_TRANSFORMER_ERROR, "Rated Voltage on side 1"); } - if (twtModificationInfos.getRatedU2() != null) { - checkIsNotNegativeValue(errorMessage, twtModificationInfos.getRatedU2().getValue(), MODIFY_TWO_WINDINGS_TRANSFORMER_ERROR, "Rated Voltage on side 2"); + if (ratedU2 != null) { + checkIsNotNegativeValue(errorMessage, ratedU2.getValue(), MODIFY_TWO_WINDINGS_TRANSFORMER_ERROR, "Rated Voltage on side 2"); } - if (twtModificationInfos.getRatedS() != null) { - checkIsNotNegativeValue(errorMessage, twtModificationInfos.getRatedS().getValue(), MODIFY_TWO_WINDINGS_TRANSFORMER_ERROR, "Rated nominal power"); + if (ratedS != null) { + checkIsNotNegativeValue(errorMessage, ratedS.getValue(), MODIFY_TWO_WINDINGS_TRANSFORMER_ERROR, "Rated nominal power"); } - if (twtModificationInfos.getRatioTapChanger() != null && twtModificationInfos.getRatioTapChanger().getTargetV() != null) { - checkIsNotNegativeValue(errorMessage, twtModificationInfos.getRatioTapChanger().getTargetV().getValue(), + if (ratioTapChanger != null && ratioTapChanger.getTargetV() != null) { + checkIsNotNegativeValue(errorMessage, ratioTapChanger.getTargetV().getValue(), MODIFY_TWO_WINDINGS_TRANSFORMER_ERROR, "Target voltage for ratio tap changer"); } } @@ -93,9 +161,9 @@ private void checkTapChangerModification(Network network, TapChangerModification @Override public void apply(Network network, ReportNode subReportNode) { - TwoWindingsTransformer twoWindingsTransformer = network.getTwoWindingsTransformer(modificationInfos.getEquipmentId()); + TwoWindingsTransformer twoWindingsTransformer = network.getTwoWindingsTransformer(equipmentId); // modify the 2wt in the network - modifyTwoWindingsTransformer(twoWindingsTransformer, modificationInfos, subReportNode, network); + modifyTwoWindingsTransformer(twoWindingsTransformer, subReportNode, network); } @Override @@ -103,31 +171,29 @@ public String getName() { return "TwoWindingsTransformerModification"; } - private void modifyTwoWindingsTransformer(TwoWindingsTransformer twoWindingsTransformer, BranchModificationInfos twoWindingsTransformerModificationInfos, ReportNode subReportNode, - Network network) { - modifyBranch(twoWindingsTransformer, twoWindingsTransformerModificationInfos, subReportNode, "network.modification.twoWindingsTransformerModification.modified"); - updateStateEstimationData((TwoWindingsTransformerModificationInfos) twoWindingsTransformerModificationInfos, twoWindingsTransformer, subReportNode); - addTapChangersToTwoWindingsTransformer(network, (TwoWindingsTransformerModificationInfos) twoWindingsTransformerModificationInfos, twoWindingsTransformer, subReportNode); - PropertiesUtils.applyProperties(twoWindingsTransformer, subReportNode, twoWindingsTransformerModificationInfos.getProperties(), "network.modification.TwoWindingsTransformerProperties"); + private void modifyTwoWindingsTransformer(TwoWindingsTransformer twoWindingsTransformer, ReportNode subReportNode, Network network) { + modifyBranch(twoWindingsTransformer, subReportNode, "network.modification.twoWindingsTransformerModification.modified"); + updateStateEstimationData(twoWindingsTransformer, subReportNode); + addTapChangersToTwoWindingsTransformer(network, twoWindingsTransformer, subReportNode); + PropertiesUtils.applyProperties(twoWindingsTransformer, subReportNode, properties, "network.modification.TwoWindingsTransformerProperties"); } @Override - protected void modifyCharacteristics(Branch branch, BranchModificationInfos branchModificationInfos, ReportNode subReportNode) { + protected void modifyCharacteristics(Branch branch, ReportNode subReportNode) { TwoWindingsTransformer twoWindingsTransformer = (TwoWindingsTransformer) branch; ReportNode characteristicsReporter = subReportNode.newReportNode().withMessageTemplate("network.modification.characteristics").add(); // Branch specific fields - modifyR(twoWindingsTransformer, branchModificationInfos.getR(), characteristicsReporter); - modifyX(twoWindingsTransformer, branchModificationInfos.getX(), characteristicsReporter); + modifyR(twoWindingsTransformer, r, characteristicsReporter); + modifyX(twoWindingsTransformer, x, characteristicsReporter); // Transformer specific fields - TwoWindingsTransformerModificationInfos twoWindingsTransformerModificationInfos = (TwoWindingsTransformerModificationInfos) branchModificationInfos; modifyTransformerFields(twoWindingsTransformer, - twoWindingsTransformerModificationInfos.getG(), - twoWindingsTransformerModificationInfos.getB(), - twoWindingsTransformerModificationInfos.getRatedS(), - twoWindingsTransformerModificationInfos.getRatedU1(), - twoWindingsTransformerModificationInfos.getRatedU2(), + g, + b, + ratedS, + ratedU1, + ratedU2, characteristicsReporter); } @@ -224,15 +290,13 @@ public static void modifyR(TwoWindingsTransformer twt, AttributeModification regulationReports = new ArrayList<>(); List regulatedTerminalReports = new ArrayList<>(); - processPhaseTapRegulation(phaseTapChanger, phaseTapChangerAdder, isModification, phaseTapChangerInfos.getRegulationMode(), + processPhaseTapRegulation(phaseTapChangerToModify, phaseTapChangerAdder, isModification, phaseTapChangerInfos.getRegulationMode(), phaseTapChangerInfos.getRegulationValue(), phaseTapChangerInfos.getTargetDeadband(), phaseTapChangerInfos.getRegulating(), regulationReports); - processRegulatingTerminal(phaseTapChangerInfos, phaseTapChanger, phaseTapChangerAdder, regulatedTerminalReports, + processRegulatingTerminal(phaseTapChangerInfos, phaseTapChangerToModify, phaseTapChangerAdder, regulatedTerminalReports, network, twt, isModification); List positionsAndStepsReports = new ArrayList<>(); - processTapChangerPositionsAndSteps(phaseTapChanger, phaseTapChangerAdder, isModification, phaseTapChangerInfos.getLowTapPosition(), phaseTapChangerInfos.getTapPosition(), + processTapChangerPositionsAndSteps(phaseTapChangerToModify, phaseTapChangerAdder, isModification, phaseTapChangerInfos.getLowTapPosition(), phaseTapChangerInfos.getTapPosition(), phaseTapChangerInfos.getSteps(), positionsAndStepsReports); if (!isModification) { @@ -434,12 +495,11 @@ private static void setPhaseTapChangerRegulationAttributes(PhaseTapChanger phase } private void processRatioTapChanger(Network network, - TwoWindingsTransformerModificationInfos twoWindingsTransformerModificationInfos, TwoWindingsTransformer twt, ReportNode subReporter, boolean isModification) { - RatioTapChangerModificationInfos ratioTapChangerInfos = twoWindingsTransformerModificationInfos.getRatioTapChanger(); - RatioTapChanger ratioTapChanger = isModification ? twt.getRatioTapChanger() : null; + RatioTapChangerModificationInfos ratioTapChangerInfos = ratioTapChanger; + RatioTapChanger ratioTapChangerToModify = isModification ? twt.getRatioTapChanger() : null; RatioTapChangerAdder ratioTapChangerAdder = isModification ? null : twt.newRatioTapChanger(); List ratioTapChangerReports = new ArrayList<>(); List regulationReports = new ArrayList<>(); @@ -451,47 +511,47 @@ private void processRatioTapChanger(Network network, boolean regulationReset = false; if (isModification && ratioTapChangerInfos.getLoadTapChangingCapabilities() != null && BooleanUtils.isFalse(ratioTapChangerInfos.getLoadTapChangingCapabilities().getValue()) && - ratioTapChanger.isRegulating()) { - boolean oldRegulating = ratioTapChanger.isRegulating(); - ratioTapChanger.setRegulating(false); + ratioTapChangerToModify.isRegulating()) { + boolean oldRegulating = ratioTapChangerToModify.isRegulating(); + ratioTapChangerToModify.setRegulating(false); regulationReports.add(ModificationUtils.buildModificationReport(oldRegulating, false, "regulating", TypedValue.DETAIL_SEVERITY)); - Terminal oldTerminal = ratioTapChanger.getRegulationTerminal(); - ratioTapChanger.setRegulationTerminal(null); + Terminal oldTerminal = ratioTapChangerToModify.getRegulationTerminal(); + ratioTapChangerToModify.setRegulationTerminal(null); if (oldTerminal != null) { String oldEquipment = oldTerminal.getConnectable().getType().name() + ":" + oldTerminal.getConnectable().getId(); regulatedTerminalReports.add(ModificationUtils.buildModificationReport(oldTerminal.getVoltageLevel().getId(), null, "Voltage level", TypedValue.DETAIL_SEVERITY)); regulatedTerminalReports.add(ModificationUtils.buildModificationReport(oldEquipment, null, "Equipment", TypedValue.DETAIL_SEVERITY)); } - double oldTargetV = ratioTapChanger.getTargetV(); - ratioTapChanger.setTargetV(Double.NaN); + double oldTargetV = ratioTapChangerToModify.getTargetV(); + ratioTapChangerToModify.setTargetV(Double.NaN); regulationReports.add(ModificationUtils.buildModificationReport(oldTargetV, Double.NaN, "target voltage", TypedValue.DETAIL_SEVERITY)); - double oldTargetDeadband = ratioTapChanger.getTargetDeadband(); - ratioTapChanger.setTargetDeadband(Double.NaN); + double oldTargetDeadband = ratioTapChangerToModify.getTargetDeadband(); + ratioTapChangerToModify.setTargetDeadband(Double.NaN); regulationReports.add(ModificationUtils.buildModificationReport(oldTargetDeadband, Double.NaN, TARGET_DEADBAND, TypedValue.DETAIL_SEVERITY)); regulationReset = true; } ReportNode tapChangingReport = ModificationUtils.getInstance().applyElementaryModificationsAndReturnReport( - isModification ? ratioTapChanger::setLoadTapChangingCapabilities + isModification ? ratioTapChangerToModify::setLoadTapChangingCapabilities : ratioTapChangerAdder::setLoadTapChangingCapabilities, - isModification ? ratioTapChanger::hasLoadTapChangingCapabilities : () -> null, + isModification ? ratioTapChangerToModify::hasLoadTapChangingCapabilities : () -> null, ratioTapChangerInfos.getLoadTapChangingCapabilities(), "Load tap changing capabilities"); if (tapChangingReport != null) { ratioTapChangerReports.add(tapChangingReport); } if (!regulationReset) { - processRatioVoltageRegulation(ratioTapChangerInfos, twt, ratioTapChanger, ratioTapChangerAdder, regulationReports, regulatedTerminalReports, network, isModification); + processRatioVoltageRegulation(ratioTapChangerInfos, twt, ratioTapChangerToModify, ratioTapChangerAdder, regulationReports, regulatedTerminalReports, network, isModification); // regulating must be set after target value, regulating mode and regulating terminal are set - processRegulating(ratioTapChangerInfos, ratioTapChanger, ratioTapChangerAdder, regulationReports, isModification); + processRegulating(ratioTapChangerInfos, ratioTapChangerToModify, ratioTapChangerAdder, regulationReports, isModification); } List positionsAndStepsReports = new ArrayList<>(); - processTapChangerPositionsAndSteps(ratioTapChanger, ratioTapChangerAdder, isModification, ratioTapChangerInfos.getLowTapPosition(), ratioTapChangerInfos.getTapPosition(), + processTapChangerPositionsAndSteps(ratioTapChangerToModify, ratioTapChangerAdder, isModification, ratioTapChangerInfos.getLowTapPosition(), ratioTapChangerInfos.getTapPosition(), ratioTapChangerInfos.getSteps(), positionsAndStepsReports ); @@ -804,19 +864,18 @@ private boolean positionsAndStepsModified(TapChangerModificationInfos tapChanger } @Override - protected boolean characteristicsModified(BranchModificationInfos branchModificationInfos) { - TwoWindingsTransformerModificationInfos twoWindingsTransformerModificationInfos = (TwoWindingsTransformerModificationInfos) branchModificationInfos; - return super.characteristicsModified(branchModificationInfos) - || twoWindingsTransformerModificationInfos.getG() != null - && twoWindingsTransformerModificationInfos.getG().getValue() != null - || twoWindingsTransformerModificationInfos.getB() != null - && twoWindingsTransformerModificationInfos.getB().getValue() != null - || twoWindingsTransformerModificationInfos.getRatedU1() != null - && twoWindingsTransformerModificationInfos.getRatedU1().getValue() != null - || twoWindingsTransformerModificationInfos.getRatedU2() != null - && twoWindingsTransformerModificationInfos.getRatedU2().getValue() != null - || twoWindingsTransformerModificationInfos.getRatedS() != null - && twoWindingsTransformerModificationInfos.getRatedS().getValue() != null; + protected boolean characteristicsModified() { + return super.characteristicsModified() + || g != null + && g.getValue() != null + || b != null + && b.getValue() != null + || ratedU1 != null + && ratedU1.getValue() != null + || ratedU2 != null + && ratedU2.getValue() != null + || ratedS != null + && ratedS.getValue() != null; } } diff --git a/src/main/java/org/gridsuite/modification/modifications/VoltageInitModification.java b/src/main/java/org/gridsuite/modification/modifications/VoltageInitModification.java index ed2a5bf3..6ef09dd8 100644 --- a/src/main/java/org/gridsuite/modification/modifications/VoltageInitModification.java +++ b/src/main/java/org/gridsuite/modification/modifications/VoltageInitModification.java @@ -10,7 +10,9 @@ import com.powsybl.commons.report.ReportNode; import com.powsybl.commons.report.TypedValue; import com.powsybl.iidm.network.*; -import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Getter; +import lombok.Setter; import org.gridsuite.modification.NetworkModificationException; import org.gridsuite.modification.NetworkModificationException.Type; import org.gridsuite.modification.dto.*; @@ -23,9 +25,9 @@ /** * @author Franck Lecuyer */ -@AllArgsConstructor +@Getter +@Setter public class VoltageInitModification extends AbstractModification { - private final VoltageInitModificationInfos voltageInitModificationInfos; private static final String GENERATORS_KEY = "network.modification.GeneratorsModifications"; private static final String TWO_WINDINGS_TRANSFORMERS_KEY = "network.modification.2WindingsTransformersModifications"; @@ -41,9 +43,32 @@ public class VoltageInitModification extends AbstractModification { private static final String SECTION_COUNT = "Section count"; private static final String COUNT = "count"; + private List generators; + private List transformers; + private List staticVarCompensators; + private List vscConverterStations; + private List shuntCompensators; + private List buses; + + @Builder + public VoltageInitModification(List generators, + List transformers, + List staticVarCompensators, + List vscConverterStations, + List shuntCompensators, + List buses) { + this.generators = generators == null ? List.of() : generators; + this.transformers = transformers == null ? List.of() : transformers; + this.staticVarCompensators = staticVarCompensators == null ? List.of() : staticVarCompensators; + this.vscConverterStations = vscConverterStations == null ? List.of() : vscConverterStations; + this.shuntCompensators = shuntCompensators == null ? List.of() : shuntCompensators; + this.buses = buses == null ? List.of() : buses; + } + @Override public void check(Network network) throws NetworkModificationException { - if (voltageInitModificationInfos == null) { + if (generators.isEmpty() && transformers.isEmpty() && staticVarCompensators.isEmpty() + && vscConverterStations.isEmpty() && shuntCompensators.isEmpty() && buses.isEmpty()) { throw new NetworkModificationException(Type.VOLTAGE_INIT_MODIFICATION_ERROR, "No voltage init modification to apply !!"); } } @@ -77,7 +102,7 @@ public String getName() { private void applyBusModification(Network network, ReportNode subReportNode) { int modificationsCount = 0; List reports = new ArrayList<>(); - for (VoltageInitBusModificationInfos m : voltageInitModificationInfos.getBuses()) { + for (VoltageInitBusModificationInfos m : buses) { String voltageLevelId = m.getVoltageLevelId(); Bus bus = null; if (voltageLevelId != null) { @@ -133,7 +158,7 @@ private void applyBusModification(Network network, ReportNode subReportNode) { private void applyGeneratorModification(Network network, ReportNode subReportNode) { int modificationsCount = 0; List reports = new ArrayList<>(); - for (final VoltageInitGeneratorModificationInfos m : voltageInitModificationInfos.getGenerators()) { + for (final VoltageInitGeneratorModificationInfos m : generators) { final Generator generator = network.getGenerator(m.getGeneratorId()); if (generator == null) { reports.add(ReportNode.newRootReportNode() @@ -179,7 +204,7 @@ private void applyTransformerModification(Network network, ReportNode subReportN int modificationsCount = 0; List reports2WT = new ArrayList<>(); List reports3WT = new ArrayList<>(); - for (final VoltageInitTransformerModificationInfos t : voltageInitModificationInfos.getTransformers()) { + for (final VoltageInitTransformerModificationInfos t : transformers) { if (t.getLegSide() != null) { final ThreeWindingsTransformer threeWindingsTransformer = network.getThreeWindingsTransformer(t.getTransformerId()); if (threeWindingsTransformer == null) { @@ -275,7 +300,7 @@ private void applyTransformerModification(Network network, ReportNode subReportN private void applyStaticVarCompensatorModification(Network network, ReportNode subReportNode) { int modificationsCount = 0; List reports = new ArrayList<>(); - for (VoltageInitStaticVarCompensatorModificationInfos s : voltageInitModificationInfos.getStaticVarCompensators()) { + for (VoltageInitStaticVarCompensatorModificationInfos s : staticVarCompensators) { final StaticVarCompensator staticVarCompensator = network.getStaticVarCompensator(s.getStaticVarCompensatorId()); if (staticVarCompensator == null) { reports.add(ReportNode.newRootReportNode() @@ -320,7 +345,7 @@ private void applyStaticVarCompensatorModification(Network network, ReportNode s private void applyVscConverterStationModification(Network network, ReportNode subReportNode) { int modificationsCount = 0; List reports = new ArrayList<>(); - for (VoltageInitVscConverterStationModificationInfos v : voltageInitModificationInfos.getVscConverterStations()) { + for (VoltageInitVscConverterStationModificationInfos v : vscConverterStations) { final VscConverterStation vscConverterStation = network.getVscConverterStation(v.getVscConverterStationId()); if (vscConverterStation == null) { reports.add(ReportNode.newRootReportNode() @@ -365,7 +390,7 @@ private void applyVscConverterStationModification(Network network, ReportNode su private void applyShuntCompensatorModification(Network network, ReportNode subReportNode) { int modificationsCount = 0; List reports = new ArrayList<>(); - for (VoltageInitShuntCompensatorModificationInfos m : voltageInitModificationInfos.getShuntCompensators()) { + for (VoltageInitShuntCompensatorModificationInfos m : shuntCompensators) { final ShuntCompensator shuntCompensator = network.getShuntCompensator(m.getShuntCompensatorId()); if (shuntCompensator == null) { reports.add(ReportNode.newRootReportNode() diff --git a/src/main/java/org/gridsuite/modification/modifications/VoltageLevelCreation.java b/src/main/java/org/gridsuite/modification/modifications/VoltageLevelCreation.java index ffd3b38d..8b27da24 100644 --- a/src/main/java/org/gridsuite/modification/modifications/VoltageLevelCreation.java +++ b/src/main/java/org/gridsuite/modification/modifications/VoltageLevelCreation.java @@ -10,31 +10,63 @@ import com.powsybl.iidm.modification.topology.DefaultNamingStrategy; import com.powsybl.iidm.modification.topology.NamingStrategy; import com.powsybl.iidm.network.Network; +import com.powsybl.iidm.network.SwitchKind; +import lombok.*; import org.gridsuite.modification.NetworkModificationException; -import org.gridsuite.modification.dto.VoltageLevelCreationInfos; +import org.gridsuite.modification.dto.*; import org.gridsuite.modification.utils.ModificationUtils; +import java.util.List; + import static org.gridsuite.modification.NetworkModificationException.Type.CREATE_VOLTAGE_LEVEL_ERROR; import static org.gridsuite.modification.utils.ModificationUtils.checkIsNotNegativeValue; /** * @author walid Sahnoun */ -public class VoltageLevelCreation extends AbstractModification { +@Getter +@Setter +public class VoltageLevelCreation extends AbstractEquipmentCreation { - private final VoltageLevelCreationInfos modificationInfos; + private String substationId; + private double nominalV; + private Double lowVoltageLimit; + private Double highVoltageLimit; + private Double ipMin; + private Double ipMax; + private int busbarCount; + private int sectionCount; + private List switchKinds; + private List couplingDevices; + private SubstationCreation substationCreation; - public VoltageLevelCreation(VoltageLevelCreationInfos modificationInfos) { - this.modificationInfos = modificationInfos; + @Builder + public VoltageLevelCreation(String equipmentId, List properties, String equipmentName, + String substationId, double nominalV, Double lowVoltageLimit, Double highVoltageLimit, + Double ipMin, Double ipMax, int busbarCount, int sectionCount, + List switchKinds, + List couplingDevices, SubstationCreation substationCreation) { + super(equipmentId, properties, equipmentName); + this.substationId = substationId; + this.nominalV = nominalV; + this.lowVoltageLimit = lowVoltageLimit; + this.highVoltageLimit = highVoltageLimit; + this.ipMin = ipMin; + this.ipMax = ipMax; + this.busbarCount = busbarCount; + this.sectionCount = sectionCount; + this.switchKinds = switchKinds; + this.couplingDevices = couplingDevices; + this.substationCreation = substationCreation; } @Override public void check(Network network) throws NetworkModificationException { - String errorMessage = "Voltage level '" + modificationInfos.getEquipmentId() + "' : "; - ModificationUtils.getInstance().controlVoltageLevelCreation(modificationInfos, network); - checkIsNotNegativeValue(errorMessage, modificationInfos.getNominalV(), CREATE_VOLTAGE_LEVEL_ERROR, "Nominal Voltage"); - checkIsNotNegativeValue(errorMessage, modificationInfos.getLowVoltageLimit(), CREATE_VOLTAGE_LEVEL_ERROR, "Low voltage limit"); - checkIsNotNegativeValue(errorMessage, modificationInfos.getHighVoltageLimit(), CREATE_VOLTAGE_LEVEL_ERROR, "High voltage limit"); + String errorMessage = "Voltage level '" + equipmentId + "' : "; + ModificationUtils.getInstance().controlVoltageLevelCreation(this, network); + checkIsNotNegativeValue(errorMessage, nominalV, CREATE_VOLTAGE_LEVEL_ERROR, "Nominal Voltage"); + checkIsNotNegativeValue(errorMessage, lowVoltageLimit, CREATE_VOLTAGE_LEVEL_ERROR, "Low voltage limit"); + checkIsNotNegativeValue(errorMessage, highVoltageLimit, CREATE_VOLTAGE_LEVEL_ERROR, "High voltage limit"); } @Override @@ -44,11 +76,12 @@ public void apply(Network network, ReportNode subReportNode) { @Override public void apply(Network network, NamingStrategy namingStrategy, ReportNode subReportNode) { - ModificationUtils.getInstance().createVoltageLevel(modificationInfos, subReportNode, network, namingStrategy); + ModificationUtils.getInstance().createVoltageLevel(this, subReportNode, network, namingStrategy); } @Override public String getName() { return "VoltageLevelCreation"; } + } diff --git a/src/main/java/org/gridsuite/modification/modifications/VoltageLevelModification.java b/src/main/java/org/gridsuite/modification/modifications/VoltageLevelModification.java index d8b92c99..c3a9b8dd 100644 --- a/src/main/java/org/gridsuite/modification/modifications/VoltageLevelModification.java +++ b/src/main/java/org/gridsuite/modification/modifications/VoltageLevelModification.java @@ -17,10 +17,11 @@ import com.powsybl.iidm.network.extensions.Measurement; import com.powsybl.iidm.network.extensions.Measurements; import com.powsybl.iidm.network.extensions.MeasurementsAdder; +import lombok.*; import org.gridsuite.modification.NetworkModificationException; import org.gridsuite.modification.dto.AttributeModification; import org.gridsuite.modification.dto.BusbarSectionVMeasurementInfos; -import org.gridsuite.modification.dto.VoltageLevelModificationInfos; +import org.gridsuite.modification.dto.FreePropertyInfos; import org.gridsuite.modification.utils.ModificationUtils; import org.gridsuite.modification.utils.PropertiesUtils; import org.springframework.util.CollectionUtils; @@ -39,61 +40,81 @@ * @author Seddik Yengui */ -public class VoltageLevelModification extends AbstractModification { +@Getter +@Setter +public class VoltageLevelModification extends AbstractEquipmentModification { public static final String ERROR_MESSAGE = "Voltage level '%s' : "; - private final VoltageLevelModificationInfos modificationInfos; - public VoltageLevelModification(VoltageLevelModificationInfos voltageLevelModificationInfos) { - this.modificationInfos = voltageLevelModificationInfos; + private AttributeModification nominalV; + private AttributeModification lowVoltageLimit; + private AttributeModification highVoltageLimit; + private AttributeModification ipMin; + private AttributeModification ipMax; + private List busbarSectionVMeasurements; + + @Builder + public VoltageLevelModification(String equipmentId, List properties, + AttributeModification equipmentName, AttributeModification nominalV, + AttributeModification lowVoltageLimit, + AttributeModification highVoltageLimit, AttributeModification ipMin, + AttributeModification ipMax, + List busbarSectionVMeasurements) { + super(equipmentId, properties, equipmentName); + this.nominalV = nominalV; + this.lowVoltageLimit = lowVoltageLimit; + this.highVoltageLimit = highVoltageLimit; + this.ipMin = ipMin; + this.ipMax = ipMax; + this.busbarSectionVMeasurements = busbarSectionVMeasurements; } @Override public void check(Network network) throws NetworkModificationException { boolean ipMinSet = false; boolean ipMaxSet = false; - String errorMessage = String.format(ERROR_MESSAGE, modificationInfos.getEquipmentId()); - if (Objects.nonNull(modificationInfos.getIpMin())) { + String errorMessage = String.format(ERROR_MESSAGE, equipmentId); + if (Objects.nonNull(ipMin)) { ipMinSet = true; - if (modificationInfos.getIpMin().getValue() < 0) { + if (ipMin.getValue() < 0) { throw new NetworkModificationException(MODIFY_VOLTAGE_LEVEL_ERROR, "IpMin must be positive"); } } - if (Objects.nonNull(modificationInfos.getIpMax())) { + if (Objects.nonNull(ipMax)) { ipMaxSet = true; - if (modificationInfos.getIpMax().getValue() < 0) { + if (ipMax.getValue() < 0) { throw new NetworkModificationException(MODIFY_VOLTAGE_LEVEL_ERROR, "IpMax must be positive"); } } if (ipMinSet && ipMaxSet) { - if (modificationInfos.getIpMin().getValue() > modificationInfos.getIpMax().getValue()) { + if (ipMin.getValue() > ipMax.getValue()) { throw new NetworkModificationException(MODIFY_VOLTAGE_LEVEL_ERROR, "IpMin cannot be greater than IpMax"); } } else if (ipMinSet || ipMaxSet) { // only one Icc set: check with existing VL attributes checkIccValuesAgainstEquipmentInNetwork(network, ipMinSet, ipMaxSet); } - if (modificationInfos.getNominalV() != null) { - checkIsNotNegativeValue(errorMessage, modificationInfos.getNominalV().getValue(), MODIFY_VOLTAGE_LEVEL_ERROR, "Nominal Voltage"); + if (nominalV != null) { + checkIsNotNegativeValue(errorMessage, nominalV.getValue(), MODIFY_VOLTAGE_LEVEL_ERROR, "Nominal Voltage"); } - if (modificationInfos.getLowVoltageLimit() != null) { - checkIsNotNegativeValue(errorMessage, modificationInfos.getLowVoltageLimit().getValue(), MODIFY_VOLTAGE_LEVEL_ERROR, "Low voltage limit"); + if (lowVoltageLimit != null) { + checkIsNotNegativeValue(errorMessage, lowVoltageLimit.getValue(), MODIFY_VOLTAGE_LEVEL_ERROR, "Low voltage limit"); } - if (modificationInfos.getHighVoltageLimit() != null) { - checkIsNotNegativeValue(errorMessage, modificationInfos.getHighVoltageLimit().getValue(), MODIFY_VOLTAGE_LEVEL_ERROR, "High voltage limit"); + if (highVoltageLimit != null) { + checkIsNotNegativeValue(errorMessage, highVoltageLimit.getValue(), MODIFY_VOLTAGE_LEVEL_ERROR, "High voltage limit"); } } private void checkIccValuesAgainstEquipmentInNetwork(Network network, boolean ipMinSet, boolean ipMaxSet) { - VoltageLevel existingVoltageLevel = ModificationUtils.getInstance().getVoltageLevel(network, modificationInfos.getEquipmentId()); + VoltageLevel existingVoltageLevel = ModificationUtils.getInstance().getVoltageLevel(network, equipmentId); IdentifiableShortCircuit identifiableShortCircuit = existingVoltageLevel.getExtension(IdentifiableShortCircuit.class); if (Objects.isNull(identifiableShortCircuit)) { if (ipMinSet) { throw new NetworkModificationException(MODIFY_VOLTAGE_LEVEL_ERROR, "IpMax is required"); } } else { - if (ipMinSet && modificationInfos.getIpMin().getValue() > identifiableShortCircuit.getIpMax() || - ipMaxSet && identifiableShortCircuit.getIpMin() > modificationInfos.getIpMax().getValue()) { + if (ipMinSet && ipMin.getValue() > identifiableShortCircuit.getIpMax() || + ipMaxSet && identifiableShortCircuit.getIpMin() > ipMax.getValue()) { throw new NetworkModificationException(MODIFY_VOLTAGE_LEVEL_ERROR, "IpMin cannot be greater than IpMax"); } } @@ -101,28 +122,28 @@ private void checkIccValuesAgainstEquipmentInNetwork(Network network, boolean ip @Override public void apply(Network network, ReportNode subReportNode) { - VoltageLevel voltageLevel = ModificationUtils.getInstance().getVoltageLevel(network, modificationInfos.getEquipmentId()); + VoltageLevel voltageLevel = ModificationUtils.getInstance().getVoltageLevel(network, equipmentId); subReportNode.newReportNode() .withMessageTemplate("network.modification.voltageLevelModification") - .withUntypedValue("id", modificationInfos.getEquipmentId()) + .withUntypedValue("id", equipmentId) .withSeverity(TypedValue.INFO_SEVERITY) .add(); - ModificationUtils.getInstance().applyElementaryModifications(voltageLevel::setName, () -> voltageLevel.getOptionalName().orElse("No value"), modificationInfos.getEquipmentName(), + ModificationUtils.getInstance().applyElementaryModifications(voltageLevel::setName, () -> voltageLevel.getOptionalName().orElse("No value"), equipmentName, subReportNode, "Name"); - modifyNominalV(voltageLevel, modificationInfos.getNominalV(), subReportNode); - modifLowVoltageLimit(voltageLevel, modificationInfos.getLowVoltageLimit(), subReportNode); - modifyHighVoltageLimit(voltageLevel, modificationInfos.getHighVoltageLimit(), subReportNode); + modifyNominalV(voltageLevel, nominalV, subReportNode); + modifLowVoltageLimit(voltageLevel, lowVoltageLimit, subReportNode); + modifyHighVoltageLimit(voltageLevel, highVoltageLimit, subReportNode); - modifyVoltageLevelShortCircuit(modificationInfos.getIpMin(), modificationInfos.getIpMax(), subReportNode, voltageLevel); - PropertiesUtils.applyProperties(voltageLevel, subReportNode, modificationInfos.getProperties(), "network.modification.VlProperties"); + modifyVoltageLevelShortCircuit(ipMin, ipMax, subReportNode, voltageLevel); + PropertiesUtils.applyProperties(voltageLevel, subReportNode, properties, "network.modification.VlProperties"); // busbar section voltage measurements - if (!CollectionUtils.isEmpty(modificationInfos.getBusbarSectionVMeasurements())) { + if (!CollectionUtils.isEmpty(busbarSectionVMeasurements)) { ReportNode bbsReportNode = subReportNode.newReportNode() .withMessageTemplate("network.modification.stateEstimationData") .add(); - modificationInfos.getBusbarSectionVMeasurements().forEach(vMeas -> { + busbarSectionVMeasurements.forEach(vMeas -> { BusbarSection bbs = network.getBusbarSection(vMeas.getBusbarSectionId()); if (bbs != null) { List measurementReports = new ArrayList<>(); @@ -221,4 +242,3 @@ private static Double convertToKiloAmps(Double value) { return (value != null) ? value * 0.001 : null; } } - diff --git a/src/main/java/org/gridsuite/modification/modifications/VoltageLevelTopologyModification.java b/src/main/java/org/gridsuite/modification/modifications/VoltageLevelTopologyModification.java index 9c9e07d1..c84952df 100644 --- a/src/main/java/org/gridsuite/modification/modifications/VoltageLevelTopologyModification.java +++ b/src/main/java/org/gridsuite/modification/modifications/VoltageLevelTopologyModification.java @@ -11,10 +11,12 @@ import com.powsybl.commons.report.TypedValue; import com.powsybl.iidm.network.Network; import com.powsybl.iidm.network.VoltageLevel; +import lombok.*; import org.gridsuite.modification.ModificationType; import org.gridsuite.modification.NetworkModificationException; -import org.gridsuite.modification.dto.EquipmentAttributeModificationInfos; -import org.gridsuite.modification.dto.VoltageLevelTopologyModificationInfos; +import org.gridsuite.modification.dto.FreePropertyInfos; + +import java.util.List; import static org.gridsuite.modification.NetworkModificationException.Type.MODIFY_VOLTAGE_LEVEL_TOPOLOGY_ERROR; import static org.gridsuite.modification.NetworkModificationException.Type.VOLTAGE_LEVEL_NOT_FOUND; @@ -23,22 +25,27 @@ * @author REHILI Ghazwa */ -public class VoltageLevelTopologyModification extends AbstractModification { - private final VoltageLevelTopologyModificationInfos modificationInfos; +@Getter +@Setter +public class VoltageLevelTopologyModification extends AbstractEquipmentBase { + + private List equipmentAttributeModificationList; - public VoltageLevelTopologyModification(VoltageLevelTopologyModificationInfos voltageLevelTopologyModificationInfos) { - this.modificationInfos = voltageLevelTopologyModificationInfos; + @Builder + public VoltageLevelTopologyModification(String equipmentId, List properties, + List equipmentAttributeModificationList) { + super(equipmentId, properties); + this.equipmentAttributeModificationList = equipmentAttributeModificationList; } @Override public void check(Network network) throws NetworkModificationException { - VoltageLevel voltageLevel = network.getVoltageLevel(modificationInfos.getEquipmentId()); + VoltageLevel voltageLevel = network.getVoltageLevel(equipmentId); if (voltageLevel == null) { - throw new NetworkModificationException(VOLTAGE_LEVEL_NOT_FOUND, modificationInfos.getEquipmentId()); + throw new NetworkModificationException(VOLTAGE_LEVEL_NOT_FOUND, equipmentId); } - if (!modificationInfos.getEquipmentAttributeModificationList().isEmpty()) { - for (EquipmentAttributeModificationInfos equipmentAttributeModificationInfos : modificationInfos.getEquipmentAttributeModificationList()) { - EquipmentAttributeModification equipmentAttributeModification = new EquipmentAttributeModification(equipmentAttributeModificationInfos); + if (!equipmentAttributeModificationList.isEmpty()) { + for (EquipmentAttributeModification equipmentAttributeModification : equipmentAttributeModificationList) { equipmentAttributeModification.check(network); } } else { @@ -48,13 +55,12 @@ public void check(Network network) throws NetworkModificationException { @Override public void apply(Network network, ReportNode subReportNode) { - for (EquipmentAttributeModificationInfos equipmentAttributeModificationInfos : modificationInfos.getEquipmentAttributeModificationList()) { - EquipmentAttributeModification equipmentAttributeModification = new EquipmentAttributeModification(equipmentAttributeModificationInfos); + for (EquipmentAttributeModification equipmentAttributeModification : equipmentAttributeModificationList) { equipmentAttributeModification.apply(network, subReportNode); } subReportNode.newReportNode() .withMessageTemplate("network.modification.voltageLevelTopologyModified") - .withUntypedValue("id", modificationInfos.getEquipmentId()) + .withUntypedValue("id", equipmentId) .withSeverity(TypedValue.DEBUG_SEVERITY) .add(); } @@ -64,4 +70,3 @@ public String getName() { return ModificationType.VOLTAGE_LEVEL_TOPOLOGY_MODIFICATION.toString(); } } - diff --git a/src/main/java/org/gridsuite/modification/modifications/VscCreation.java b/src/main/java/org/gridsuite/modification/modifications/VscCreation.java index 5a5c19b6..29eff796 100644 --- a/src/main/java/org/gridsuite/modification/modifications/VscCreation.java +++ b/src/main/java/org/gridsuite/modification/modifications/VscCreation.java @@ -12,9 +12,10 @@ import com.powsybl.iidm.network.*; import com.powsybl.iidm.network.extensions.HvdcAngleDroopActivePowerControlAdder; import com.powsybl.iidm.network.extensions.HvdcOperatorActivePowerRangeAdder; +import lombok.*; import org.gridsuite.modification.NetworkModificationException; -import org.gridsuite.modification.dto.ConverterStationCreationInfos; -import org.gridsuite.modification.dto.VscCreationInfos; +import org.gridsuite.modification.dto.FreePropertyInfos; +import org.gridsuite.modification.modifications.data.VscConverterStationCreation; import org.gridsuite.modification.utils.ModificationUtils; import org.gridsuite.modification.utils.PropertiesUtils; @@ -28,44 +29,75 @@ * @author Seddik Yengui */ -public class VscCreation extends AbstractModification { +@Getter +@Setter +public class VscCreation extends AbstractEquipmentCreation { public static final String VSC_SETPOINTS = "network.modification.vscSetPoints"; public static final String VSC_CHARACTERISTICS = "network.modification.vscCharacteristics"; - private final VscCreationInfos modificationInfos; - - public VscCreation(VscCreationInfos modificationInfos) { - this.modificationInfos = modificationInfos; + private Double nominalV; + private Double r; + private Double maxP; + private Float operatorActivePowerLimitFromSide1ToSide2; + private Float operatorActivePowerLimitFromSide2ToSide1; + private HvdcLine.ConvertersMode convertersMode; + private Double activePowerSetpoint; + private Boolean angleDroopActivePowerControl; + private Float p0; + private Float droop; + private VscConverterStationCreation converterStation1; + private VscConverterStationCreation converterStation2; + + @Builder + public VscCreation(String equipmentId, List properties, String equipmentName, Double nominalV, + Double r, Double maxP, Float operatorActivePowerLimitFromSide1ToSide2, + Float operatorActivePowerLimitFromSide2ToSide1, HvdcLine.ConvertersMode convertersMode, + Double activePowerSetpoint, Boolean angleDroopActivePowerControl, Float p0, Float droop, + VscConverterStationCreation converterStation1, + VscConverterStationCreation converterStation2) { + super(equipmentId, properties, equipmentName); + this.nominalV = nominalV; + this.r = r; + this.maxP = maxP; + this.operatorActivePowerLimitFromSide1ToSide2 = operatorActivePowerLimitFromSide1ToSide2; + this.operatorActivePowerLimitFromSide2ToSide1 = operatorActivePowerLimitFromSide2ToSide1; + this.convertersMode = convertersMode; + this.activePowerSetpoint = activePowerSetpoint; + this.angleDroopActivePowerControl = angleDroopActivePowerControl; + this.p0 = p0; + this.droop = droop; + this.converterStation1 = converterStation1; + this.converterStation2 = converterStation2; } @Override public void check(Network network) throws NetworkModificationException { - if (network.getHvdcLine(modificationInfos.getEquipmentId()) != null) { - throw new NetworkModificationException(HVDC_LINE_ALREADY_EXISTS, modificationInfos.getEquipmentId()); + if (network.getHvdcLine(equipmentId) != null) { + throw new NetworkModificationException(HVDC_LINE_ALREADY_EXISTS, equipmentId); } - String errorMessage = "HVDC vsc '" + modificationInfos.getEquipmentId() + "' : "; - checkConverterStation(network, modificationInfos.getConverterStation1()); - checkConverterStation(network, modificationInfos.getConverterStation2()); + String errorMessage = "HVDC vsc '" + equipmentId + "' : "; + checkConverterStation(network, converterStation1); + checkConverterStation(network, converterStation2); checkDroop(); - checkIsNotNegativeValue(errorMessage, modificationInfos.getR(), CREATE_VSC_ERROR, "Resistance R"); - checkIsNotNegativeValue(errorMessage, modificationInfos.getNominalV(), CREATE_VSC_ERROR, "Nominal voltage"); - checkIsNotNegativeValue(errorMessage, modificationInfos.getConverterStation1().getVoltageSetpoint(), CREATE_VSC_ERROR, "voltage set point side 1"); - checkIsNotNegativeValue(errorMessage, modificationInfos.getConverterStation2().getVoltageSetpoint(), CREATE_VSC_ERROR, "voltage set point side 2"); - checkIsPercentage(errorMessage, modificationInfos.getConverterStation1().getLossFactor(), CREATE_VSC_ERROR, "loss factor side 1"); - checkIsPercentage(errorMessage, modificationInfos.getConverterStation2().getLossFactor(), CREATE_VSC_ERROR, "loss factor side 2"); + checkIsNotNegativeValue(errorMessage, r, CREATE_VSC_ERROR, "Resistance R"); + checkIsNotNegativeValue(errorMessage, nominalV, CREATE_VSC_ERROR, "Nominal voltage"); + checkIsNotNegativeValue(errorMessage, converterStation1.getVoltageSetpoint(), CREATE_VSC_ERROR, "voltage set point side 1"); + checkIsNotNegativeValue(errorMessage, converterStation2.getVoltageSetpoint(), CREATE_VSC_ERROR, "voltage set point side 2"); + checkIsPercentage(errorMessage, converterStation1.getLossFactor(), CREATE_VSC_ERROR, "loss factor side 1"); + checkIsPercentage(errorMessage, converterStation2.getLossFactor(), CREATE_VSC_ERROR, "loss factor side 2"); } private void checkDroop() { - boolean isPresentAngleDroopActivePowerControl = modificationInfos.getAngleDroopActivePowerControl() != null; - boolean isPresentDroop = modificationInfos.getDroop() != null; - boolean isPresentP0 = modificationInfos.getP0() != null; + boolean isPresentAngleDroopActivePowerControl = angleDroopActivePowerControl != null; + boolean isPresentDroop = droop != null; + boolean isPresentP0 = p0 != null; // all fields are provided => OK extension will be created if (isPresentAngleDroopActivePowerControl && isPresentDroop && isPresentP0) { return; } // particular case, not enabling extension and others fields are not provided => OK extension will not be created - if (Boolean.FALSE.equals(modificationInfos.getAngleDroopActivePowerControl()) && !isPresentDroop && !isPresentP0) { + if (Boolean.FALSE.equals(angleDroopActivePowerControl) && !isPresentDroop && !isPresentP0) { return; } // at least one field is provided but not for the others => NOT OK @@ -76,9 +108,9 @@ private void checkDroop() { } private void checkConverterStation(Network network, - ConverterStationCreationInfos converterStation) { + VscConverterStationCreation converterStation) { if (converterStation == null) { - throw new NetworkModificationException(CREATE_VSC_ERROR, modificationInfos.getEquipmentId() + "Missing required converter station"); + throw new NetworkModificationException(CREATE_VSC_ERROR, equipmentId + "Missing required converter station"); } // check connectivity ModificationUtils.getInstance().controlConnectivity(network, @@ -89,41 +121,41 @@ private void checkConverterStation(Network network, // check reactive limits ModificationUtils.getInstance().checkReactiveLimitsCreation(converterStation, CREATE_VSC_ERROR, - modificationInfos.getEquipmentId(), + equipmentId, "Vsc"); } @Override public void apply(Network network, ReportNode subReportNode) { - VscConverterStation converterStation1 = createConverterStation(network, modificationInfos.getConverterStation1(), subReportNode, "1"); + VscConverterStation createdConverterStation1 = createConverterStation(network, converterStation1, subReportNode, "1"); - VscConverterStation converterStation2 = createConverterStation(network, modificationInfos.getConverterStation2(), subReportNode, "2"); + VscConverterStation createdConverterStation2 = createConverterStation(network, converterStation2, subReportNode, "2"); HvdcLine hvdcLine = network.newHvdcLine() - .setId(modificationInfos.getEquipmentId()) - .setName(modificationInfos.getEquipmentName()) - .setNominalV(modificationInfos.getNominalV()) - .setR(modificationInfos.getR()) - .setMaxP(modificationInfos.getMaxP()) - .setActivePowerSetpoint(modificationInfos.getActivePowerSetpoint()) - .setConvertersMode(modificationInfos.getConvertersMode()) - .setConverterStationId1(converterStation1 != null ? converterStation1.getId() : null) - .setConverterStationId2(converterStation2 != null ? converterStation2.getId() : null) + .setId(equipmentId) + .setName(equipmentName) + .setNominalV(nominalV) + .setR(r) + .setMaxP(maxP) + .setActivePowerSetpoint(activePowerSetpoint) + .setConvertersMode(convertersMode) + .setConverterStationId1(createdConverterStation1 != null ? createdConverterStation1.getId() : null) + .setConverterStationId2(createdConverterStation2 != null ? createdConverterStation2.getId() : null) .add(); - if (modificationInfos.getOperatorActivePowerLimitFromSide1ToSide2() != null || - modificationInfos.getOperatorActivePowerLimitFromSide2ToSide1() != null) { + if (operatorActivePowerLimitFromSide1ToSide2 != null || + operatorActivePowerLimitFromSide2ToSide1 != null) { hvdcLine.newExtension(HvdcOperatorActivePowerRangeAdder.class) - .withOprFromCS1toCS2(modificationInfos.getOperatorActivePowerLimitFromSide1ToSide2()) - .withOprFromCS2toCS1(modificationInfos.getOperatorActivePowerLimitFromSide2ToSide1()) + .withOprFromCS1toCS2(operatorActivePowerLimitFromSide1ToSide2) + .withOprFromCS2toCS1(operatorActivePowerLimitFromSide2ToSide1) .add(); } if (shouldCreateDroopActivePowerControlExtension()) { var activePowerControlExtension = hvdcLine.newExtension(HvdcAngleDroopActivePowerControlAdder.class) - .withEnabled(modificationInfos.getAngleDroopActivePowerControl()); - activePowerControlExtension.withP0(modificationInfos.getP0()); - activePowerControlExtension.withDroop(modificationInfos.getDroop()); + .withEnabled(angleDroopActivePowerControl); + activePowerControlExtension.withP0(p0); + activePowerControlExtension.withDroop(droop); activePowerControlExtension.add(); } @@ -132,16 +164,16 @@ public void apply(Network network, ReportNode subReportNode) { subReportNode.newReportNode() .withMessageTemplate("network.modification.vscCreated") - .withUntypedValue("id", modificationInfos.getEquipmentId()) + .withUntypedValue("id", equipmentId) .withSeverity(TypedValue.INFO_SEVERITY) .add(); - if (modificationInfos.getEquipmentName() != null) { + if (equipmentName != null) { ModificationUtils.getInstance() - .reportElementaryCreation(subReportNode, modificationInfos.getEquipmentName(), "Name"); + .reportElementaryCreation(subReportNode, equipmentName, "Name"); } - PropertiesUtils.applyProperties(hvdcLine, subReportNode, modificationInfos.getProperties(), "network.modification.VscProperties"); + PropertiesUtils.applyProperties(hvdcLine, subReportNode, properties, "network.modification.VscProperties"); } @Override @@ -151,53 +183,53 @@ public String getName() { private boolean shouldCreateDroopActivePowerControlExtension() { return VscModification.shouldCreateDroopActivePowerControlExtension( - modificationInfos.getAngleDroopActivePowerControl() != null, modificationInfos.getDroop() != null, modificationInfos.getP0() != null); + angleDroopActivePowerControl != null, droop != null, p0 != null); } private void reportHvdcLineInfos(ReportNode subReportNode) { List characteristicsReports = new ArrayList<>(); - characteristicsReports.add(ModificationUtils.getInstance().buildCreationReport(modificationInfos.getNominalV(), "DC nominal voltage")); - characteristicsReports.add(ModificationUtils.getInstance().buildCreationReport(modificationInfos.getR(), "DC resistance")); - characteristicsReports.add(ModificationUtils.getInstance().buildCreationReport(modificationInfos.getMaxP(), "Pmax")); + characteristicsReports.add(ModificationUtils.getInstance().buildCreationReport(nominalV, "DC nominal voltage")); + characteristicsReports.add(ModificationUtils.getInstance().buildCreationReport(r, "DC resistance")); + characteristicsReports.add(ModificationUtils.getInstance().buildCreationReport(maxP, "Pmax")); ModificationUtils.getInstance().reportModifications(subReportNode, characteristicsReports, VSC_CHARACTERISTICS); List limitsReports = new ArrayList<>(); - limitsReports.add(ModificationUtils.getInstance().buildCreationReport(modificationInfos.getOperatorActivePowerLimitFromSide1ToSide2(), "Operator active power limit (Side1 -> Side 2)")); - limitsReports.add(ModificationUtils.getInstance().buildCreationReport(modificationInfos.getOperatorActivePowerLimitFromSide2ToSide1(), "Operator active power limit (Side2 -> Side 1)")); + limitsReports.add(ModificationUtils.getInstance().buildCreationReport(operatorActivePowerLimitFromSide1ToSide2, "Operator active power limit (Side1 -> Side 2)")); + limitsReports.add(ModificationUtils.getInstance().buildCreationReport(operatorActivePowerLimitFromSide2ToSide1, "Operator active power limit (Side2 -> Side 1)")); ModificationUtils.getInstance().reportModifications(subReportNode, limitsReports, "network.modification.vscLimits"); List setPointsReports = new ArrayList<>(); - setPointsReports.add(ModificationUtils.getInstance().buildCreationReport(modificationInfos.getConvertersMode(), "Converters mode")); - setPointsReports.add(ModificationUtils.getInstance().buildCreationReport(modificationInfos.getActivePowerSetpoint(), "Active power")); + setPointsReports.add(ModificationUtils.getInstance().buildCreationReport(convertersMode, "Converters mode")); + setPointsReports.add(ModificationUtils.getInstance().buildCreationReport(activePowerSetpoint, "Active power")); ReportNode setPointsReporter = ModificationUtils.getInstance().reportModifications(subReportNode, setPointsReports, VSC_SETPOINTS); List angleDroopActivePowerControlReports = new ArrayList<>(); angleDroopActivePowerControlReports.add(ModificationUtils.getInstance() - .createEnabledDisabledReport("network.modification.angleDroopActivePowerControl", modificationInfos.getAngleDroopActivePowerControl())); - if (modificationInfos.getP0() != null) { - angleDroopActivePowerControlReports.add(ModificationUtils.getInstance().buildCreationReport(modificationInfos.getP0(), "P0")); + .createEnabledDisabledReport("network.modification.angleDroopActivePowerControl", angleDroopActivePowerControl)); + if (p0 != null) { + angleDroopActivePowerControlReports.add(ModificationUtils.getInstance().buildCreationReport(p0, "P0")); } - if (modificationInfos.getDroop() != null) { - angleDroopActivePowerControlReports.add(ModificationUtils.getInstance().buildCreationReport(modificationInfos.getDroop(), "Droop")); + if (droop != null) { + angleDroopActivePowerControlReports.add(ModificationUtils.getInstance().buildCreationReport(droop, "Droop")); } ModificationUtils.getInstance().reportModifications(setPointsReporter, angleDroopActivePowerControlReports, "network.modification.vscAngleDroop"); } private VscConverterStation createConverterStation(Network network, - ConverterStationCreationInfos converterStationCreationInfos, + VscConverterStationCreation vscConverterStationCreation, ReportNode subReportNode, String logFieldName) { ReportNode converterStationReporter = subReportNode.newReportNode() .withMessageTemplate("network.modification.vscConverterStationCreated") .withUntypedValue("fieldName", logFieldName) - .withUntypedValue("id", converterStationCreationInfos.getEquipmentId()) + .withUntypedValue("id", vscConverterStationCreation.getEquipmentId()) .add(); - VoltageLevel voltageLevel = ModificationUtils.getInstance().getVoltageLevel(network, converterStationCreationInfos.getVoltageLevelId()); + VoltageLevel voltageLevel = ModificationUtils.getInstance().getVoltageLevel(network, vscConverterStationCreation.getVoltageLevelId()); VscConverterStation vscConverterStation = voltageLevel.getTopologyKind() == TopologyKind.NODE_BREAKER ? - createConverterStationInNodeBreaker(network, voltageLevel, converterStationCreationInfos, converterStationReporter) : - createConverterStationInBusBreaker(voltageLevel, converterStationCreationInfos, converterStationReporter); + createConverterStationInNodeBreaker(network, voltageLevel, vscConverterStationCreation, converterStationReporter) : + createConverterStationInBusBreaker(voltageLevel, vscConverterStationCreation, converterStationReporter); - if (!converterStationCreationInfos.isTerminalConnected()) { + if (!vscConverterStationCreation.isTerminalConnected()) { vscConverterStation.getTerminal().disconnect(); } @@ -206,30 +238,31 @@ private VscConverterStation createConverterStation(Network network, private VscConverterStation createConverterStationInNodeBreaker(Network network, VoltageLevel voltageLevel, - ConverterStationCreationInfos converterStationCreationInfos, + VscConverterStationCreation vscConverterStationCreation, ReportNode subReportNode) { VscConverterStationAdder converterStationAdder = voltageLevel.newVscConverterStation() - .setId(converterStationCreationInfos.getEquipmentId()) - .setName(converterStationCreationInfos.getEquipmentName()) - .setVoltageRegulatorOn(converterStationCreationInfos.getVoltageRegulationOn()); + .setId(vscConverterStationCreation.getEquipmentId()) + .setName(vscConverterStationCreation.getEquipmentName()) + .setVoltageRegulatorOn(vscConverterStationCreation.getVoltageRegulationOn()); - if (converterStationCreationInfos.getReactivePowerSetpoint() != null) { - converterStationAdder.setReactivePowerSetpoint(converterStationCreationInfos.getReactivePowerSetpoint()); + if (vscConverterStationCreation.getReactivePowerSetpoint() != null) { + converterStationAdder.setReactivePowerSetpoint(vscConverterStationCreation.getReactivePowerSetpoint()); } - if (converterStationCreationInfos.getLossFactor() != null) { - converterStationAdder.setLossFactor(converterStationCreationInfos.getLossFactor()); + if (vscConverterStationCreation.getLossFactor() != null) { + converterStationAdder.setLossFactor(vscConverterStationCreation.getLossFactor()); } - if (converterStationCreationInfos.getVoltageSetpoint() != null) { - converterStationAdder.setVoltageSetpoint(converterStationCreationInfos.getVoltageSetpoint()); + if (vscConverterStationCreation.getVoltageSetpoint() != null) { + converterStationAdder.setVoltageSetpoint(vscConverterStationCreation.getVoltageSetpoint()); } - createInjectionInNodeBreaker(voltageLevel, converterStationCreationInfos, network, converterStationAdder, subReportNode); + createInjectionInNodeBreaker(voltageLevel, vscConverterStationCreation, + network, converterStationAdder, subReportNode); VscConverterStation vscConverterStation = ModificationUtils.getInstance() - .getVscConverterStation(network, converterStationCreationInfos.getEquipmentId()); + .getVscConverterStation(network, vscConverterStationCreation.getEquipmentId()); addExtensionsAndReports(vscConverterStation, - converterStationCreationInfos, + vscConverterStationCreation, subReportNode); return vscConverterStation; @@ -237,52 +270,52 @@ private VscConverterStation createConverterStationInNodeBreaker(Network network, } private VscConverterStation createConverterStationInBusBreaker(VoltageLevel voltageLevel, - ConverterStationCreationInfos converterStationCreationInfos, + VscConverterStationCreation vscConverterStationCreation, ReportNode subReportNode) { - Bus bus = ModificationUtils.getInstance().getBusBreakerBus(voltageLevel, converterStationCreationInfos.getBusOrBusbarSectionId()); + Bus bus = ModificationUtils.getInstance().getBusBreakerBus(voltageLevel, vscConverterStationCreation.getBusOrBusbarSectionId()); VscConverterStation vscConverterStation = voltageLevel.newVscConverterStation() - .setId(converterStationCreationInfos.getEquipmentId()) - .setName(converterStationCreationInfos.getEquipmentName()) - .setVoltageRegulatorOn(converterStationCreationInfos.getVoltageRegulationOn()) - .setReactivePowerSetpoint(converterStationCreationInfos.getReactivePowerSetpoint()) + .setId(vscConverterStationCreation.getEquipmentId()) + .setName(vscConverterStationCreation.getEquipmentName()) + .setVoltageRegulatorOn(vscConverterStationCreation.getVoltageRegulationOn()) + .setReactivePowerSetpoint(vscConverterStationCreation.getReactivePowerSetpoint()) .setBus(bus.getId()) - .setLossFactor(converterStationCreationInfos.getLossFactor()) - .setVoltageSetpoint(converterStationCreationInfos.getVoltageSetpoint()) + .setLossFactor(vscConverterStationCreation.getLossFactor()) + .setVoltageSetpoint(vscConverterStationCreation.getVoltageSetpoint()) .add(); - addExtensionsAndReports(vscConverterStation, converterStationCreationInfos, subReportNode); + addExtensionsAndReports(vscConverterStation, vscConverterStationCreation, subReportNode); return vscConverterStation; } private void addExtensionsAndReports(VscConverterStation vscConverterStation, - ConverterStationCreationInfos converterStationCreationInfos, + VscConverterStationCreation vscConverterStationCreation, ReportNode subReporter) { - reportInjectionCreationConnectivity(converterStationCreationInfos, subReporter); + reportInjectionCreationConnectivity(vscConverterStationCreation, subReporter); ModificationUtils.getInstance().reportModifications(subReporter, - List.of(ModificationUtils.getInstance().buildCreationReport(converterStationCreationInfos.getLossFactor(), "Loss Factor")), + List.of(ModificationUtils.getInstance().buildCreationReport(vscConverterStationCreation.getLossFactor(), "Loss Factor")), "network.modification.converterStationCharacteristics"); - ModificationUtils.getInstance().createReactiveLimits(converterStationCreationInfos, vscConverterStation, subReporter); + ModificationUtils.getInstance().createReactiveLimits(vscConverterStationCreation, vscConverterStation, subReporter); - reportConverterStationSetPoints(converterStationCreationInfos, subReporter); + reportConverterStationSetPoints(vscConverterStationCreation, subReporter); } - private void reportConverterStationSetPoints(ConverterStationCreationInfos converterStationCreationInfos, ReportNode subReportNode) { + private void reportConverterStationSetPoints(VscConverterStationCreation vscConverterStationCreation, ReportNode subReportNode) { ReportNode setPointReporter = subReportNode.newReportNode().withMessageTemplate("network.modification.converterStationSetPoint").add(); - if (converterStationCreationInfos.getReactivePowerSetpoint() != null) { + if (vscConverterStationCreation.getReactivePowerSetpoint() != null) { ModificationUtils.getInstance().reportElementaryCreation(setPointReporter, - converterStationCreationInfos.getReactivePowerSetpoint(), + vscConverterStationCreation.getReactivePowerSetpoint(), "Reactive power"); } List setPointsVoltageReports = new ArrayList<>(); setPointsVoltageReports.add(ModificationUtils.getInstance().createEnabledDisabledReport("network.modification.voltageRegulationOn", - converterStationCreationInfos.getVoltageRegulationOn())); - if (converterStationCreationInfos.getVoltageSetpoint() != null) { - setPointsVoltageReports.add(ModificationUtils.getInstance().buildCreationReport(converterStationCreationInfos.getReactivePowerSetpoint(), "Voltage")); + vscConverterStationCreation.getVoltageRegulationOn())); + if (vscConverterStationCreation.getVoltageSetpoint() != null) { + setPointsVoltageReports.add(ModificationUtils.getInstance().buildCreationReport(vscConverterStationCreation.getVoltageSetpoint(), "Voltage")); } ModificationUtils.getInstance().reportModifications(setPointReporter, diff --git a/src/main/java/org/gridsuite/modification/modifications/VscModification.java b/src/main/java/org/gridsuite/modification/modifications/VscModification.java index fdacea14..40d2ac33 100644 --- a/src/main/java/org/gridsuite/modification/modifications/VscModification.java +++ b/src/main/java/org/gridsuite/modification/modifications/VscModification.java @@ -13,10 +13,12 @@ import com.powsybl.iidm.network.extensions.HvdcAngleDroopActivePowerControlAdder; import com.powsybl.iidm.network.extensions.HvdcOperatorActivePowerRange; import com.powsybl.iidm.network.extensions.HvdcOperatorActivePowerRangeAdder; +import lombok.*; import org.gridsuite.modification.NetworkModificationException; -import org.gridsuite.modification.dto.ConverterStationModificationInfos; +import org.gridsuite.modification.dto.AttributeModification; +import org.gridsuite.modification.dto.FreePropertyInfos; import org.gridsuite.modification.dto.ReactiveCapabilityCurvePointsInfos; -import org.gridsuite.modification.dto.VscModificationInfos; +import org.gridsuite.modification.modifications.data.VscConverterStationModification; import org.gridsuite.modification.utils.MeasurementUtils; import org.gridsuite.modification.utils.ModificationUtils; import org.gridsuite.modification.utils.PropertiesUtils; @@ -37,65 +39,97 @@ /** * @author jamal kheyyad */ - -public class VscModification extends AbstractModification { +@Getter +@Setter +public class VscModification extends AbstractEquipmentModification { public static final String NO_VALUE = "No value"; public static final String ANGLE_DROOP_ACTIVE_POWER_CONTROL_FIELD = "AngleDroopActivePowerControl"; public static final String DROOP_FIELD = "Droop"; public static final String P0_FIELD = "P0"; public static final String ACTIVE_POWER_CONTROL_DROOP_P0_REQUIRED_ERROR_MSG = "Angle droop active power control, Droop and P0 must be all provided or none"; - private final VscModificationInfos modificationInfos; - - public VscModification(VscModificationInfos vscModificationInfos) { - this.modificationInfos = vscModificationInfos; + private AttributeModification nominalV; + private AttributeModification r; + private AttributeModification maxP; + private AttributeModification operatorActivePowerLimitFromSide1ToSide2; + private AttributeModification operatorActivePowerLimitFromSide2ToSide1; + private AttributeModification convertersMode; + private AttributeModification activePowerSetpoint; + private AttributeModification angleDroopActivePowerControl; + private AttributeModification p0; + private AttributeModification droop; + private VscConverterStationModification converterStation1; + private VscConverterStationModification converterStation2; + + @Builder + public VscModification(String equipmentId, List properties, + AttributeModification equipmentName, AttributeModification nominalV, + AttributeModification r, AttributeModification maxP, + AttributeModification operatorActivePowerLimitFromSide1ToSide2, + AttributeModification operatorActivePowerLimitFromSide2ToSide1, + AttributeModification convertersMode, + AttributeModification activePowerSetpoint, + AttributeModification angleDroopActivePowerControl, AttributeModification p0, + AttributeModification droop, VscConverterStationModification converterStation1, + VscConverterStationModification converterStation2) { + super(equipmentId, properties, equipmentName); + this.nominalV = nominalV; + this.r = r; + this.maxP = maxP; + this.operatorActivePowerLimitFromSide1ToSide2 = operatorActivePowerLimitFromSide1ToSide2; + this.operatorActivePowerLimitFromSide2ToSide1 = operatorActivePowerLimitFromSide2ToSide1; + this.convertersMode = convertersMode; + this.activePowerSetpoint = activePowerSetpoint; + this.angleDroopActivePowerControl = angleDroopActivePowerControl; + this.p0 = p0; + this.droop = droop; + this.converterStation1 = converterStation1; + this.converterStation2 = converterStation2; } public static boolean shouldCreateDroopActivePowerControlExtension(boolean isPresentAngleDroopActivePowerControl, boolean isPresentDroop, boolean isPresentP0) { return isPresentAngleDroopActivePowerControl && isPresentDroop && isPresentP0; } - protected void checkConverterStation(@Nonnull ConverterStationModificationInfos converterStationModificationInfos, @Nonnull VscConverterStation vscConverterStation) { - String errorMessage = "Converter station '" + converterStationModificationInfos.getEquipmentId() + "' : "; - ModificationUtils.getInstance().checkReactiveLimit(vscConverterStation, converterStationModificationInfos.getMinQ(), converterStationModificationInfos.getMaxQ(), - converterStationModificationInfos.getReactiveCapabilityCurvePoints(), MODIFY_VSC_ERROR, errorMessage); + protected void checkConverterStation(@Nonnull VscConverterStationModification vscConverterStationModification, @Nonnull VscConverterStation vscConverterStation) { + String errorMessage = "Converter station '" + vscConverterStationModification.getEquipmentId() + "' : "; + ModificationUtils.getInstance().checkReactiveLimit(vscConverterStation, vscConverterStationModification.getMinQ(), vscConverterStationModification.getMaxQ(), + vscConverterStationModification.getReactiveCapabilityCurvePoints(), MODIFY_VSC_ERROR, errorMessage); } @Override public void check(Network network) throws NetworkModificationException { - if (modificationInfos == null - || modificationInfos.getConverterStation1() == null - || modificationInfos.getConverterStation2() == null) { + if (converterStation1 == null || converterStation2 == null) { throw new NetworkModificationException(MODIFY_VSC_ERROR, "Missing required attributes to modify the equipment"); } - HvdcLine hvdcLine = ModificationUtils.getInstance().getHvdcLine(network, modificationInfos.getEquipmentId()); - String errorMessage = "HVDC vsc '" + modificationInfos.getEquipmentId() + "' : "; + HvdcLine hvdcLine = ModificationUtils.getInstance().getHvdcLine(network, equipmentId); + String errorMessage = "HVDC vsc '" + equipmentId + "' : "; - VscConverterStation converterStation1 = ModificationUtils.getInstance().getVscConverterStation(network, hvdcLine.getConverterStation1().getId()); - VscConverterStation converterStation2 = ModificationUtils.getInstance().getVscConverterStation(network, hvdcLine.getConverterStation2().getId()); - checkConverterStation(modificationInfos.getConverterStation1(), converterStation1); - checkConverterStation(modificationInfos.getConverterStation2(), converterStation2); + VscConverterStation converterStation1FromNetwork = ModificationUtils.getInstance().getVscConverterStation(network, hvdcLine.getConverterStation1().getId()); + VscConverterStation converterStation2FromNetwork = ModificationUtils.getInstance().getVscConverterStation(network, hvdcLine.getConverterStation2().getId()); + checkConverterStation(this.converterStation1, converterStation1FromNetwork); + checkConverterStation(this.converterStation2, converterStation2FromNetwork); checkDroop(hvdcLine); - if (modificationInfos.getR() != null) { - checkIsNotNegativeValue(errorMessage, modificationInfos.getR().getValue(), MODIFY_VSC_ERROR, "Resistance R"); + if (r != null) { + checkIsNotNegativeValue(errorMessage, r.getValue(), MODIFY_VSC_ERROR, "Resistance R"); } - if (modificationInfos.getNominalV() != null) { - checkIsNotNegativeValue(errorMessage, modificationInfos.getNominalV().getValue(), MODIFY_VSC_ERROR, "Nominal voltage"); + if (nominalV != null) { + checkIsNotNegativeValue(errorMessage, nominalV.getValue(), MODIFY_VSC_ERROR, "Nominal voltage"); } - if (modificationInfos.getConverterStation1().getVoltageSetpoint() != null) { - checkIsNotNegativeValue(errorMessage, modificationInfos.getConverterStation1().getVoltageSetpoint().getValue(), + if (this.converterStation1.getVoltageSetpoint() != null) { + checkIsNotNegativeValue(errorMessage, this.converterStation1.getVoltageSetpoint().getValue(), MODIFY_VSC_ERROR, "voltage set point side 1"); } - if (modificationInfos.getConverterStation2().getVoltageSetpoint() != null) { - checkIsNotNegativeValue(errorMessage, modificationInfos.getConverterStation2().getVoltageSetpoint().getValue(), + if (this.converterStation2.getVoltageSetpoint() != null) { + checkIsNotNegativeValue(errorMessage, this.converterStation2.getVoltageSetpoint().getValue(), MODIFY_VSC_ERROR, "voltage set point side 2"); } - if (modificationInfos.getConverterStation1().getLossFactor() != null) { - checkIsPercentage(errorMessage, modificationInfos.getConverterStation1().getLossFactor().getValue(), + if (this.converterStation1.getLossFactor() != null) { + checkIsPercentage(errorMessage, this.converterStation1.getLossFactor().getValue(), MODIFY_VSC_ERROR, "loss factor side 1"); } - if (modificationInfos.getConverterStation2().getLossFactor() != null) { - checkIsPercentage(errorMessage, modificationInfos.getConverterStation2().getLossFactor().getValue(), + if (this.converterStation2.getLossFactor() != null) { + checkIsPercentage(errorMessage, this.converterStation2.getLossFactor().getValue(), MODIFY_VSC_ERROR, "loss factor side 2"); } } @@ -108,9 +142,9 @@ private void checkDroop(HvdcLine hvdcLine) { } //--- the extension doesn't exist yet ---// - boolean isPresentAngleDroopActivePowerControl = modificationInfos.getAngleDroopActivePowerControl() != null && modificationInfos.getAngleDroopActivePowerControl().getValue() != null; - boolean isPresentDroop = modificationInfos.getDroop() != null && modificationInfos.getDroop().getValue() != null; - boolean isPresentP0 = modificationInfos.getP0() != null && modificationInfos.getP0().getValue() != null; + boolean isPresentAngleDroopActivePowerControl = angleDroopActivePowerControl != null && angleDroopActivePowerControl.getValue() != null; + boolean isPresentDroop = droop != null && droop.getValue() != null; + boolean isPresentP0 = p0 != null && p0.getValue() != null; // all fields are provided => OK extension will be created if (isPresentAngleDroopActivePowerControl && isPresentDroop && isPresentP0) { return; @@ -124,8 +158,8 @@ private void checkDroop(HvdcLine hvdcLine) { @Override public void apply(Network network, ReportNode subReportNode) { - HvdcLine hvdcLine = ModificationUtils.getInstance().getHvdcLine(network, modificationInfos.getEquipmentId()); - modifyVsc(network, hvdcLine, modificationInfos, subReportNode); + HvdcLine hvdcLine = ModificationUtils.getInstance().getHvdcLine(network, equipmentId); + modifyVsc(network, hvdcLine, subReportNode); } @Override @@ -133,14 +167,14 @@ public String getName() { return "VscModification"; } - private void modifyVsc(@Nonnull Network network, @Nonnull HvdcLine hvdcLine, VscModificationInfos modificationInfos, ReportNode subReportNode) { + private void modifyVsc(@Nonnull Network network, @Nonnull HvdcLine hvdcLine, ReportNode subReportNode) { subReportNode.newReportNode() .withMessageTemplate("network.modification.VscModification") - .withUntypedValue("id", modificationInfos.getEquipmentId()) + .withUntypedValue("id", equipmentId) .withSeverity(TypedValue.INFO_SEVERITY) .add(); // Characteristics - characteristics(hvdcLine, modificationInfos, subReportNode); + characteristics(hvdcLine, subReportNode); // Set Points List setPointsReports = setPoints(hvdcLine); @@ -162,31 +196,31 @@ private void modifyVsc(@Nonnull Network network, @Nonnull HvdcLine hvdcLine, Vsc } // limits - operatorActivePowerLimit(hvdcLine, modificationInfos, subReportNode); + operatorActivePowerLimit(hvdcLine, subReportNode); // stations - modifyConverterStation(ModificationUtils.getInstance().getVscConverterStation(network, hvdcLine.getConverterStation1().getId()), modificationInfos.getConverterStation1(), subReportNode, "1"); - modifyConverterStation(ModificationUtils.getInstance().getVscConverterStation(network, hvdcLine.getConverterStation2().getId()), modificationInfos.getConverterStation2(), subReportNode, "2"); + modifyConverterStation(ModificationUtils.getInstance().getVscConverterStation(network, hvdcLine.getConverterStation1().getId()), converterStation1, subReportNode, "1"); + modifyConverterStation(ModificationUtils.getInstance().getVscConverterStation(network, hvdcLine.getConverterStation2().getId()), converterStation2, subReportNode, "2"); - PropertiesUtils.applyProperties(hvdcLine, subReportNode, modificationInfos.getProperties(), "network.modification.VscProperties"); + PropertiesUtils.applyProperties(hvdcLine, subReportNode, properties, "network.modification.VscProperties"); } - private static void characteristics(HvdcLine hvdcLine, VscModificationInfos modificationInfos, ReportNode subReportNode) { + private void characteristics(HvdcLine hvdcLine, ReportNode subReportNode) { List characteristicsReportsContainer = new ArrayList<>(); - if (modificationInfos.getEquipmentName() != null && modificationInfos.getEquipmentName().getValue() != null) { + if (equipmentName != null && equipmentName.getValue() != null) { characteristicsReportsContainer.add(ModificationUtils.getInstance().applyAndBuildModificationReport(hvdcLine::setName, () -> hvdcLine.getOptionalName().orElse(NO_VALUE), - modificationInfos.getEquipmentName(), "Name")); + equipmentName, "Name")); } - if (modificationInfos.getNominalV() != null) { - characteristicsReportsContainer.add(ModificationUtils.getInstance().applyAndBuildModificationReport(hvdcLine::setNominalV, hvdcLine::getNominalV, modificationInfos.getNominalV(), + if (nominalV != null) { + characteristicsReportsContainer.add(ModificationUtils.getInstance().applyAndBuildModificationReport(hvdcLine::setNominalV, hvdcLine::getNominalV, nominalV, "DC nominal voltage")); } - if (modificationInfos.getR() != null) { - characteristicsReportsContainer.add(ModificationUtils.getInstance().applyAndBuildModificationReport(hvdcLine::setR, hvdcLine::getR, modificationInfos.getR(), "DC resistance")); + if (r != null) { + characteristicsReportsContainer.add(ModificationUtils.getInstance().applyAndBuildModificationReport(hvdcLine::setR, hvdcLine::getR, r, "DC resistance")); } - if (modificationInfos.getMaxP() != null) { - characteristicsReportsContainer.add(ModificationUtils.getInstance().applyAndBuildModificationReport(hvdcLine::setMaxP, hvdcLine::getMaxP, modificationInfos.getMaxP(), "Power max")); + if (maxP != null) { + characteristicsReportsContainer.add(ModificationUtils.getInstance().applyAndBuildModificationReport(hvdcLine::setMaxP, hvdcLine::getMaxP, maxP, "Power max")); } if (!characteristicsReportsContainer.isEmpty()) { ModificationUtils.getInstance().reportModifications(subReportNode, characteristicsReportsContainer, VSC_CHARACTERISTICS); @@ -196,28 +230,28 @@ private static void characteristics(HvdcLine hvdcLine, VscModificationInfos modi private List setPoints(HvdcLine hvdcLine) { List setPointsReports = new ArrayList<>(); - if (modificationInfos.getActivePowerSetpoint() != null) { + if (activePowerSetpoint != null) { setPointsReports.add(ModificationUtils.getInstance().applyAndBuildModificationReport(hvdcLine::setActivePowerSetpoint, hvdcLine::getActivePowerSetpoint, - modificationInfos.getActivePowerSetpoint(), "ActivePowerSetpoint")); + activePowerSetpoint, "ActivePowerSetpoint")); } - if (modificationInfos.getConvertersMode() != null) { - setPointsReports.add(ModificationUtils.getInstance().applyAndBuildModificationReport(hvdcLine::setConvertersMode, hvdcLine::getConvertersMode, modificationInfos.getConvertersMode(), + if (convertersMode != null) { + setPointsReports.add(ModificationUtils.getInstance().applyAndBuildModificationReport(hvdcLine::setConvertersMode, hvdcLine::getConvertersMode, convertersMode, "Converters mode")); } return setPointsReports; } - private static void operatorActivePowerLimit(HvdcLine hvdcLine, VscModificationInfos modificationInfos, ReportNode subReportNode) { + private void operatorActivePowerLimit(HvdcLine hvdcLine, ReportNode subReportNode) { List reports = new ArrayList<>(); - if (modificationInfos.getOperatorActivePowerLimitFromSide1ToSide2() != null || - modificationInfos.getOperatorActivePowerLimitFromSide2ToSide1() != null) { + if (operatorActivePowerLimitFromSide1ToSide2 != null || + operatorActivePowerLimitFromSide2ToSide1 != null) { var operatorActivePowerRange = hvdcLine.getExtension(HvdcOperatorActivePowerRange.class); if (operatorActivePowerRange != null) { - modifyOperatorActiveRange(modificationInfos, operatorActivePowerRange, reports); + modifyOperatorActiveRange(operatorActivePowerRange, reports); } else { - createOperatorActiveRangeExt(hvdcLine, modificationInfos, reports); + createOperatorActiveRangeExt(hvdcLine, reports); } } if (!reports.isEmpty()) { @@ -225,16 +259,16 @@ private static void operatorActivePowerLimit(HvdcLine hvdcLine, VscModificationI } } - private static void modifyOperatorActiveRange(VscModificationInfos modificationInfos, HvdcOperatorActivePowerRange operatorActivePowerRange, List reports) { + private void modifyOperatorActiveRange(HvdcOperatorActivePowerRange operatorActivePowerRange, List reports) { var oldCs1ToCs2 = operatorActivePowerRange.getOprFromCS1toCS2(); var oldCs2ToCs1 = operatorActivePowerRange.getOprFromCS2toCS1(); - Optional.ofNullable(modificationInfos.getOperatorActivePowerLimitFromSide1ToSide2()).ifPresent(info -> { + Optional.ofNullable(operatorActivePowerLimitFromSide1ToSide2).ifPresent(info -> { if (info.getValue() != null) { operatorActivePowerRange.setOprFromCS1toCS2(info.getValue()); reports.add(ModificationUtils.getInstance().buildModificationReport(oldCs1ToCs2, info.getValue(), "Operator active power limit (Side1 -> Side 2)")); } }); - Optional.ofNullable(modificationInfos.getOperatorActivePowerLimitFromSide2ToSide1()).ifPresent(info -> { + Optional.ofNullable(operatorActivePowerLimitFromSide2ToSide1).ifPresent(info -> { if (info.getValue() != null) { operatorActivePowerRange.setOprFromCS2toCS1(info.getValue()); reports.add(ModificationUtils.getInstance().buildModificationReport(oldCs2ToCs1, info.getValue(), "Operator active power limit (Side2 -> Side 1)")); @@ -242,17 +276,17 @@ private static void modifyOperatorActiveRange(VscModificationInfos modificationI }); } - private static void createOperatorActiveRangeExt(HvdcLine hvdcLine, VscModificationInfos modificationInfos, List reports) { + private void createOperatorActiveRangeExt(HvdcLine hvdcLine, List reports) { var hvdcOperatorActivePowerRangeAddr = hvdcLine.newExtension(HvdcOperatorActivePowerRangeAdder.class); - Optional.ofNullable(modificationInfos.getOperatorActivePowerLimitFromSide1ToSide2()).ifPresent(info -> { + Optional.ofNullable(operatorActivePowerLimitFromSide1ToSide2).ifPresent(info -> { if (info.getValue() != null) { - hvdcOperatorActivePowerRangeAddr.withOprFromCS1toCS2(modificationInfos.getOperatorActivePowerLimitFromSide1ToSide2().getValue()); + hvdcOperatorActivePowerRangeAddr.withOprFromCS1toCS2(operatorActivePowerLimitFromSide1ToSide2.getValue()); reports.add(ModificationUtils.getInstance().buildModificationReport(null, info.getValue(), "Operator active power limit (Side1 -> Side 2)")); } }); - Optional.ofNullable(modificationInfos.getOperatorActivePowerLimitFromSide2ToSide1()).ifPresent(info -> { + Optional.ofNullable(operatorActivePowerLimitFromSide2ToSide1).ifPresent(info -> { if (info.getValue() != null) { - hvdcOperatorActivePowerRangeAddr.withOprFromCS2toCS1(modificationInfos.getOperatorActivePowerLimitFromSide2ToSide1().getValue()); + hvdcOperatorActivePowerRangeAddr.withOprFromCS2toCS1(operatorActivePowerLimitFromSide2ToSide1.getValue()); reports.add(ModificationUtils.getInstance().buildModificationReport(null, info.getValue(), "Operator active power limit (Side2 -> Side 1)")); } }); @@ -260,21 +294,21 @@ private static void createOperatorActiveRangeExt(HvdcLine hvdcLine, VscModificat } private void modifyExistingHvdcAngleDroopActivePowerControl(HvdcAngleDroopActivePowerControl hvdcAngleDroopActivePowerControl, List reports) { - Optional.ofNullable(modificationInfos.getAngleDroopActivePowerControl()).ifPresent(modification -> + Optional.ofNullable(angleDroopActivePowerControl).ifPresent(modification -> reports.add(ModificationUtils.getInstance().applyAndBuildModificationReport( hvdcAngleDroopActivePowerControl::setEnabled, hvdcAngleDroopActivePowerControl::isEnabled, modification, ANGLE_DROOP_ACTIVE_POWER_CONTROL_FIELD))); - Optional.ofNullable(modificationInfos.getDroop()).ifPresent(modification -> + Optional.ofNullable(droop).ifPresent(modification -> reports.add(ModificationUtils.getInstance().applyAndBuildModificationReport( hvdcAngleDroopActivePowerControl::setDroop, hvdcAngleDroopActivePowerControl::getDroop, modification, DROOP_FIELD))); - Optional.ofNullable(modificationInfos.getP0()).ifPresent(modification -> + Optional.ofNullable(p0).ifPresent(modification -> reports.add(ModificationUtils.getInstance().applyAndBuildModificationReport( hvdcAngleDroopActivePowerControl::setP0, hvdcAngleDroopActivePowerControl::getP0, @@ -284,10 +318,9 @@ private void modifyExistingHvdcAngleDroopActivePowerControl(HvdcAngleDroopActive private boolean shouldCreateDroopActivePowerControlExtension() { return shouldCreateDroopActivePowerControlExtension( - modificationInfos.getAngleDroopActivePowerControl() != null && - modificationInfos.getAngleDroopActivePowerControl().getValue() != null, - modificationInfos.getDroop() != null && modificationInfos.getDroop().getValue() != null, - modificationInfos.getP0() != null && modificationInfos.getP0().getValue() != null); + angleDroopActivePowerControl != null && angleDroopActivePowerControl.getValue() != null, + droop != null && droop.getValue() != null, + p0 != null && p0.getValue() != null); } private List hvdcAngleDroopActivePowerControlAdder(HvdcLine hvdcLine) { @@ -299,25 +332,25 @@ private List hvdcAngleDroopActivePowerControlAdder(HvdcLine hvdcLine HvdcAngleDroopActivePowerControlAdder hvdcAngleDroopActivePowerControlAdder = hvdcLine.newExtension(HvdcAngleDroopActivePowerControlAdder.class); - Boolean isEnabled = modificationInfos.getAngleDroopActivePowerControl().getValue(); + Boolean isEnabled = angleDroopActivePowerControl.getValue(); hvdcAngleDroopActivePowerControlAdder.withEnabled(isEnabled); reports.add(ModificationUtils.getInstance().buildModificationReport(null, isEnabled, ANGLE_DROOP_ACTIVE_POWER_CONTROL_FIELD)); - Float droop = modificationInfos.getDroop().getValue(); - hvdcAngleDroopActivePowerControlAdder.withDroop(droop); - reports.add(ModificationUtils.getInstance().buildModificationReport(Float.NaN, droop, DROOP_FIELD)); + Float droopValue = droop.getValue(); + hvdcAngleDroopActivePowerControlAdder.withDroop(droopValue); + reports.add(ModificationUtils.getInstance().buildModificationReport(Float.NaN, droopValue, DROOP_FIELD)); - Float p0 = modificationInfos.getP0().getValue(); - hvdcAngleDroopActivePowerControlAdder.withP0(p0); - reports.add(ModificationUtils.getInstance().buildModificationReport(Float.NaN, p0, P0_FIELD)); + Float p0Value = p0.getValue(); + hvdcAngleDroopActivePowerControlAdder.withP0(p0Value); + reports.add(ModificationUtils.getInstance().buildModificationReport(Float.NaN, p0Value, P0_FIELD)); hvdcAngleDroopActivePowerControlAdder.add(); } return reports; } - private void modifyConverterStation(VscConverterStation converterStation, ConverterStationModificationInfos converterStationModificationInfos, ReportNode subReportNode, String logFieldName) { - if (converterStationModificationInfos == null || !isConverterStationModified(converterStationModificationInfos)) { + private void modifyConverterStation(VscConverterStation converterStation, VscConverterStationModification vscConverterStationModification, ReportNode subReportNode, String logFieldName) { + if (vscConverterStationModification == null || !isConverterStationModified(vscConverterStationModification)) { return; } @@ -330,14 +363,14 @@ private void modifyConverterStation(VscConverterStation converterStation, Conver // characteristic List characteristicReports = new ArrayList<>(); - if (converterStationModificationInfos.getEquipmentName() != null && converterStationModificationInfos.getEquipmentName().getValue() != null) { + if (vscConverterStationModification.getEquipmentName() != null && vscConverterStationModification.getEquipmentName().getValue() != null) { characteristicReports.add(ModificationUtils.getInstance().applyAndBuildModificationReport(converterStation::setName, - () -> converterStation.getOptionalName().orElse(NO_VALUE), converterStationModificationInfos.getEquipmentName(), "Name")); + () -> converterStation.getOptionalName().orElse(NO_VALUE), vscConverterStationModification.getEquipmentName(), "Name")); } - if (converterStationModificationInfos.getLossFactor() != null) { + if (vscConverterStationModification.getLossFactor() != null) { characteristicReports.add(ModificationUtils.getInstance().applyAndBuildModificationReport(converterStation::setLossFactor, - converterStation::getLossFactor, converterStationModificationInfos.getLossFactor(), "LossFactor")); + converterStation::getLossFactor, vscConverterStationModification.getLossFactor(), "LossFactor")); } if (!characteristicReports.isEmpty()) { @@ -347,19 +380,19 @@ private void modifyConverterStation(VscConverterStation converterStation, Conver // set points List setPointsReports = new ArrayList<>(); - if (converterStationModificationInfos.getReactivePowerSetpoint() != null) { + if (vscConverterStationModification.getReactivePowerSetpoint() != null) { setPointsReports.add(ModificationUtils.getInstance().applyAndBuildModificationReport(converterStation::setReactivePowerSetpoint, - converterStation::getReactivePowerSetpoint, converterStationModificationInfos.getReactivePowerSetpoint(), "Reactive Power")); + converterStation::getReactivePowerSetpoint, vscConverterStationModification.getReactivePowerSetpoint(), "Reactive Power")); } - if (converterStationModificationInfos.getVoltageRegulationOn() != null) { + if (vscConverterStationModification.getVoltageRegulationOn() != null) { setPointsReports.add(ModificationUtils.getInstance().applyAndBuildModificationReport(converterStation::setVoltageRegulatorOn, - converterStation::isVoltageRegulatorOn, converterStationModificationInfos.getVoltageRegulationOn(), "VoltageRegulationOn")); + converterStation::isVoltageRegulatorOn, vscConverterStationModification.getVoltageRegulationOn(), "VoltageRegulationOn")); } - if (converterStationModificationInfos.getVoltageSetpoint() != null) { + if (vscConverterStationModification.getVoltageSetpoint() != null) { setPointsReports.add(ModificationUtils.getInstance().applyAndBuildModificationReport(converterStation::setVoltageSetpoint, - converterStation::getVoltageSetpoint, converterStationModificationInfos.getVoltageSetpoint(), "Voltage")); + converterStation::getVoltageSetpoint, vscConverterStationModification.getVoltageSetpoint(), "Voltage")); } if (!setPointsReports.isEmpty()) { ModificationUtils.getInstance().reportModifications(converterStationReportNode, @@ -367,43 +400,45 @@ private void modifyConverterStation(VscConverterStation converterStation, Conver } // measurements - MeasurementUtils.applyAndBuildModificationReport(converterStation, converterStationModificationInfos, converterStationReportNode); + MeasurementUtils.applyAndBuildModificationReport(converterStation, vscConverterStationModification, converterStationReportNode); // limits - modifyVscReactiveLimitsAttributes(converterStationModificationInfos, converterStation, converterStationReportNode, converterStationReportNode); + modifyVscReactiveLimitsAttributes(vscConverterStationModification, converterStation, converterStationReportNode, converterStationReportNode); } - private static boolean isConverterStationModified(ConverterStationModificationInfos converterStationModificationInfos) { - return converterStationModificationInfos.getEquipmentName() != null && converterStationModificationInfos.getEquipmentName().getValue() != null - || converterStationModificationInfos.getLossFactor() != null - || converterStationModificationInfos.getReactivePowerSetpoint() != null - || converterStationModificationInfos.getVoltageRegulationOn() != null - || converterStationModificationInfos.getVoltageSetpoint() != null || converterStationModificationInfos.getReactiveCapabilityCurvePoints() != null - || converterStationModificationInfos.getMinQ() != null || converterStationModificationInfos.getMaxQ() != null - || converterStationModificationInfos.getPMeasurementValue() != null || converterStationModificationInfos.getPMeasurementValidity() != null - || converterStationModificationInfos.getQMeasurementValue() != null || converterStationModificationInfos.getQMeasurementValidity() != null; + private static boolean isConverterStationModified(VscConverterStationModification vscConverterStationModification) { + return vscConverterStationModification.getEquipmentName() != null && vscConverterStationModification.getEquipmentName().getValue() != null + || vscConverterStationModification.getLossFactor() != null + || vscConverterStationModification.getReactivePowerSetpoint() != null + || vscConverterStationModification.getVoltageRegulationOn() != null + || vscConverterStationModification.getVoltageSetpoint() != null || vscConverterStationModification.getReactiveCapabilityCurvePoints() != null + || vscConverterStationModification.getMinQ() != null || vscConverterStationModification.getMaxQ() != null + || vscConverterStationModification.getPMeasurementValue() != null || vscConverterStationModification.getPMeasurementValidity() != null + || vscConverterStationModification.getQMeasurementValue() != null || vscConverterStationModification.getQMeasurementValidity() != null; } - private void modifyVscReactiveCapabilityCurvePoints(ConverterStationModificationInfos modificationInfos, + private void modifyVscReactiveCapabilityCurvePoints(VscConverterStationModification vscConverterStationModification, VscConverterStation vscConverterStation, ReportNode subReporter, ReportNode subReportNodeLimits) { ReactiveCapabilityCurveAdder adder = vscConverterStation.newReactiveCapabilityCurve(); - List modificationPoints = modificationInfos.getReactiveCapabilityCurvePoints(); + List modificationPoints = vscConverterStationModification.getReactiveCapabilityCurvePoints(); Collection points = vscConverterStation.getReactiveLimits().getKind() == ReactiveLimitsKind.CURVE ? vscConverterStation.getReactiveLimits( ReactiveCapabilityCurve.class).getPoints() : List.of(); ModificationUtils.getInstance().modifyReactiveCapabilityCurvePoints(points, modificationPoints, adder, subReporter, subReportNodeLimits); } - private void modifyVscReactiveLimitsAttributes(ConverterStationModificationInfos modificationInfos, + private void modifyVscReactiveLimitsAttributes(VscConverterStationModification vscConverterStationModification, VscConverterStation vscConverterStation, ReportNode subReportNode, ReportNode subReportNodeLimits) { - if (modificationInfos.getReactiveCapabilityCurve() != null) { - if (Boolean.TRUE.equals(modificationInfos.getReactiveCapabilityCurve().getValue() - && modificationInfos.getReactiveCapabilityCurvePoints() != null - && !modificationInfos.getReactiveCapabilityCurvePoints().isEmpty())) { - modifyVscReactiveCapabilityCurvePoints(modificationInfos, vscConverterStation, subReportNode, subReportNodeLimits); - } else if (Boolean.FALSE.equals(modificationInfos.getReactiveCapabilityCurve().getValue())) { - ModificationUtils.getInstance().modifyMinMaxReactiveLimits(modificationInfos.getMinQ(), modificationInfos.getMaxQ(), vscConverterStation, subReportNode, subReportNodeLimits); + if (vscConverterStationModification.getReactiveCapabilityCurve() != null) { + if (Boolean.TRUE.equals(vscConverterStationModification.getReactiveCapabilityCurve().getValue() + && vscConverterStationModification.getReactiveCapabilityCurvePoints() != null + && !vscConverterStationModification.getReactiveCapabilityCurvePoints().isEmpty())) { + modifyVscReactiveCapabilityCurvePoints(vscConverterStationModification, vscConverterStation, + subReportNode, subReportNodeLimits); + } else if (Boolean.FALSE.equals(vscConverterStationModification.getReactiveCapabilityCurve().getValue())) { + ModificationUtils.getInstance().modifyMinMaxReactiveLimits(vscConverterStationModification.getMinQ(), + vscConverterStationModification.getMaxQ(), vscConverterStation, subReportNode, subReportNodeLimits); } } } diff --git a/src/main/java/org/gridsuite/modification/modifications/byfilter/AbstractModificationByAssignment.java b/src/main/java/org/gridsuite/modification/modifications/byfilter/AbstractModificationByAssignment.java index c3b3311a..c5eb6256 100644 --- a/src/main/java/org/gridsuite/modification/modifications/byfilter/AbstractModificationByAssignment.java +++ b/src/main/java/org/gridsuite/modification/modifications/byfilter/AbstractModificationByAssignment.java @@ -19,7 +19,6 @@ import org.gridsuite.modification.NetworkModificationException; import org.gridsuite.modification.dto.FilterEquipments; import org.gridsuite.modification.dto.FilterInfos; -import org.gridsuite.modification.dto.ModificationInfos; import org.gridsuite.modification.dto.byfilter.AbstractAssignmentInfos; import org.gridsuite.modification.dto.byfilter.equipmentfield.FieldUtils; import org.gridsuite.modification.modifications.AbstractModification; @@ -96,8 +95,6 @@ private String getEditedFieldLabel(AbstractAssignmentInfos modificationByFilterI return modificationByFilterInfos.getEditedFieldLabel(); } - public abstract ModificationInfos getModificationInfos(); - public abstract IdentifiableType getEquipmentType(); public abstract NetworkModificationException.Type getExceptionType(); @@ -149,10 +146,6 @@ public void initApplicationContext(IFilterService filterService, ILoadFlowServic @Override public void check(Network network) throws NetworkModificationException { - if (getModificationInfos() == null) { - throw new NetworkModificationException(getExceptionType(), "Missing required attributes to modify the equipment"); - } - if (CollectionUtils.isEmpty(getAssignmentInfosList())) { throw new NetworkModificationException(getExceptionType(), String.format("At least one %s is required", getModificationTypeLabel())); } @@ -167,7 +160,7 @@ public void apply(Network network, ReportNode subReportNode) { // collect all filters from all variations Map filters = getFilters(); - Map filterUuidEquipmentsMap = ModificationUtils.getUuidFilterEquipmentsMap(filterService, network, subReportNode, filters, getModificationInfos().getErrorType()); + Map filterUuidEquipmentsMap = ModificationUtils.getUuidFilterEquipmentsMap(filterService, network, subReportNode, filters, getExceptionType()); if (filterUuidEquipmentsMap != null) { ReportNode subReporter = subReportNode.newReportNode() diff --git a/src/main/java/org/gridsuite/modification/modifications/byfilter/ByFormulaModification.java b/src/main/java/org/gridsuite/modification/modifications/byfilter/ByFormulaModification.java index 32b79b27..c5afc35c 100644 --- a/src/main/java/org/gridsuite/modification/modifications/byfilter/ByFormulaModification.java +++ b/src/main/java/org/gridsuite/modification/modifications/byfilter/ByFormulaModification.java @@ -11,9 +11,10 @@ import com.powsybl.commons.report.TypedValue; import com.powsybl.iidm.network.Identifiable; import com.powsybl.iidm.network.IdentifiableType; +import lombok.Builder; +import lombok.Getter; +import lombok.Setter; import org.gridsuite.modification.NetworkModificationException; -import org.gridsuite.modification.dto.ByFormulaModificationInfos; -import org.gridsuite.modification.dto.ModificationInfos; import org.gridsuite.modification.dto.byfilter.AbstractAssignmentInfos; import org.gridsuite.modification.dto.byfilter.formula.FormulaInfos; import org.gridsuite.modification.dto.byfilter.formula.Operator; @@ -30,12 +31,17 @@ /** * @author Thang PHAM */ +@Getter +@Setter public class ByFormulaModification extends AbstractModificationByAssignment { - private final ByFormulaModificationInfos modificationInfos; + private IdentifiableType identifiableType; + private List formulaInfosList; - public ByFormulaModification(ByFormulaModificationInfos modificationInfos) { + @Builder + public ByFormulaModification(IdentifiableType identifiableType, List formulaInfosList) { super(); - this.modificationInfos = modificationInfos; + this.identifiableType = identifiableType; + this.formulaInfosList = formulaInfosList; } @Override @@ -43,19 +49,14 @@ public String getModificationTypeLabel() { return "formula"; } - @Override - public ModificationInfos getModificationInfos() { - return modificationInfos; - } - @Override public IdentifiableType getEquipmentType() { - return modificationInfos.getIdentifiableType(); + return identifiableType; } @Override public List getAssignmentInfosList() { - return Collections.unmodifiableList(modificationInfos.getFormulaInfosList()); + return Collections.unmodifiableList(formulaInfosList); } @Override diff --git a/src/main/java/org/gridsuite/modification/modifications/byfilter/ModificationByAssignment.java b/src/main/java/org/gridsuite/modification/modifications/byfilter/ModificationByAssignment.java index deae7f9d..0fe30504 100644 --- a/src/main/java/org/gridsuite/modification/modifications/byfilter/ModificationByAssignment.java +++ b/src/main/java/org/gridsuite/modification/modifications/byfilter/ModificationByAssignment.java @@ -10,9 +10,10 @@ import com.powsybl.commons.report.ReportNode; import com.powsybl.iidm.network.Identifiable; import com.powsybl.iidm.network.IdentifiableType; +import lombok.Builder; +import lombok.Getter; +import lombok.Setter; import org.gridsuite.modification.NetworkModificationException; -import org.gridsuite.modification.dto.ModificationByAssignmentInfos; -import org.gridsuite.modification.dto.ModificationInfos; import org.gridsuite.modification.dto.byfilter.AbstractAssignmentInfos; import org.gridsuite.modification.dto.byfilter.DataType; import org.gridsuite.modification.dto.byfilter.assignment.AssignmentInfos; @@ -29,13 +30,18 @@ /** * @author Thang PHAM */ +@Getter +@Setter public class ModificationByAssignment extends AbstractModificationByAssignment { - private final ModificationByAssignmentInfos modificationInfos; + private IdentifiableType equipmentType; + private List> assignmentInfosList; - public ModificationByAssignment(ModificationByAssignmentInfos modificationInfos) { + @Builder + public ModificationByAssignment(IdentifiableType equipmentType, List> assignmentInfosList) { super(); - this.modificationInfos = modificationInfos; + this.equipmentType = equipmentType; + this.assignmentInfosList = assignmentInfosList; } @Override @@ -43,19 +49,14 @@ public String getModificationTypeLabel() { return "assignment"; } - @Override - public ModificationInfos getModificationInfos() { - return modificationInfos; - } - @Override public IdentifiableType getEquipmentType() { - return modificationInfos.getEquipmentType(); + return equipmentType; } @Override public List getAssignmentInfosList() { - return Collections.unmodifiableList(modificationInfos.getAssignmentInfosList()); + return Collections.unmodifiableList(assignmentInfosList); } @Override diff --git a/src/main/java/org/gridsuite/modification/modifications/data/AbstractInjectionCreation.java b/src/main/java/org/gridsuite/modification/modifications/data/AbstractInjectionCreation.java new file mode 100644 index 00000000..dc9f3f84 --- /dev/null +++ b/src/main/java/org/gridsuite/modification/modifications/data/AbstractInjectionCreation.java @@ -0,0 +1,35 @@ +/* + Copyright (c) 2026, 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/. + */ +package org.gridsuite.modification.modifications.data; + +import com.powsybl.iidm.network.extensions.ConnectablePosition; +import lombok.Getter; +import lombok.Setter; +import lombok.experimental.SuperBuilder; +import org.gridsuite.modification.dto.FreePropertyInfos; +import org.gridsuite.modification.modifications.InjectionCreation; + +import java.util.List; + +/** + * @author Joris Mancini + */ +@Getter +@Setter +@SuperBuilder +public abstract class AbstractInjectionCreation implements InjectionCreation { + + private String equipmentId; + private List properties; + private String equipmentName; + private String voltageLevelId; + private String busOrBusbarSectionId; + private String connectionName; + private ConnectablePosition.Direction connectionDirection; + private Integer connectionPosition; + private boolean terminalConnected; +} diff --git a/src/main/java/org/gridsuite/modification/modifications/data/AbstractInjectionModification.java b/src/main/java/org/gridsuite/modification/modifications/data/AbstractInjectionModification.java new file mode 100644 index 00000000..69187a17 --- /dev/null +++ b/src/main/java/org/gridsuite/modification/modifications/data/AbstractInjectionModification.java @@ -0,0 +1,40 @@ +/* + Copyright (c) 2026, 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/. + */ +package org.gridsuite.modification.modifications.data; + +import com.powsybl.iidm.network.extensions.ConnectablePosition; +import lombok.Getter; +import lombok.Setter; +import lombok.experimental.SuperBuilder; +import org.gridsuite.modification.dto.AttributeModification; +import org.gridsuite.modification.dto.FreePropertyInfos; +import org.gridsuite.modification.modifications.InjectionModification; + +import java.util.List; + +/** + * @author Joris Mancini + */ +@Getter +@Setter +@SuperBuilder +public abstract class AbstractInjectionModification implements InjectionModification { + + private String equipmentId; + private List properties; + private AttributeModification equipmentName; + private AttributeModification voltageLevelId; + private AttributeModification busOrBusbarSectionId; + private AttributeModification connectionName; + private AttributeModification connectionDirection; + private AttributeModification connectionPosition; + private AttributeModification terminalConnected; + private AttributeModification pMeasurementValue; + private AttributeModification pMeasurementValidity; + private AttributeModification qMeasurementValue; + private AttributeModification qMeasurementValidity; +} diff --git a/src/main/java/org/gridsuite/modification/modifications/data/LccConverterStationCreation.java b/src/main/java/org/gridsuite/modification/modifications/data/LccConverterStationCreation.java new file mode 100644 index 00000000..f0291ed0 --- /dev/null +++ b/src/main/java/org/gridsuite/modification/modifications/data/LccConverterStationCreation.java @@ -0,0 +1,27 @@ +/* + Copyright (c) 2026, 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/. + */ +package org.gridsuite.modification.modifications.data; + +import lombok.Getter; +import lombok.Setter; +import lombok.experimental.SuperBuilder; +import org.gridsuite.modification.dto.LccShuntCompensatorInfos; + +import java.util.List; + +/** + * @author Joris Mancini + */ +@Getter +@Setter +@SuperBuilder +public class LccConverterStationCreation extends AbstractInjectionCreation { + + private Float lossFactor; + private Float powerFactor; + private List shuntCompensatorsOnSide; +} diff --git a/src/main/java/org/gridsuite/modification/modifications/data/LccConverterStationModification.java b/src/main/java/org/gridsuite/modification/modifications/data/LccConverterStationModification.java new file mode 100644 index 00000000..1fe72cad --- /dev/null +++ b/src/main/java/org/gridsuite/modification/modifications/data/LccConverterStationModification.java @@ -0,0 +1,33 @@ +/* + Copyright (c) 2026, 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/. + */ +package org.gridsuite.modification.modifications.data; + +import lombok.Getter; +import lombok.Setter; +import lombok.experimental.SuperBuilder; +import org.gridsuite.modification.dto.AttributeModification; +import org.gridsuite.modification.dto.LccShuntCompensatorModificationInfos; +import org.springframework.util.CollectionUtils; + +import java.util.List; + +/** + * @author Joris Mancini + */ +@Getter +@Setter +@SuperBuilder +public class LccConverterStationModification extends AbstractInjectionModification { + + private AttributeModification lossFactor; + private AttributeModification powerFactor; + private List shuntCompensatorsOnSide; + + public boolean hasModifications() { + return getEquipmentName() != null || lossFactor != null || powerFactor != null || !CollectionUtils.isEmpty(shuntCompensatorsOnSide); + } +} diff --git a/src/main/java/org/gridsuite/modification/modifications/data/VscConverterStationCreation.java b/src/main/java/org/gridsuite/modification/modifications/data/VscConverterStationCreation.java new file mode 100644 index 00000000..16876e71 --- /dev/null +++ b/src/main/java/org/gridsuite/modification/modifications/data/VscConverterStationCreation.java @@ -0,0 +1,33 @@ +/* + Copyright (c) 2026, 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/. + */ +package org.gridsuite.modification.modifications.data; + +import lombok.Getter; +import lombok.Setter; +import lombok.experimental.SuperBuilder; +import org.gridsuite.modification.dto.ReactiveCapabilityCurvePointsInfos; +import org.gridsuite.modification.dto.ReactiveLimitsHolderInfos; + +import java.util.List; + +/** + * @author Joris Mancini + */ +@Getter +@Setter +@SuperBuilder +public class VscConverterStationCreation extends AbstractInjectionCreation implements ReactiveLimitsHolderInfos { + + private Float lossFactor; + private Double reactivePowerSetpoint; + private Boolean voltageRegulationOn; + private Double voltageSetpoint; + private Boolean reactiveCapabilityCurve; + private Double minQ; + private Double maxQ; + private List reactiveCapabilityCurvePoints; +} diff --git a/src/main/java/org/gridsuite/modification/modifications/data/VscConverterStationModification.java b/src/main/java/org/gridsuite/modification/modifications/data/VscConverterStationModification.java new file mode 100644 index 00000000..e752de52 --- /dev/null +++ b/src/main/java/org/gridsuite/modification/modifications/data/VscConverterStationModification.java @@ -0,0 +1,33 @@ +/* + Copyright (c) 2026, 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/. + */ +package org.gridsuite.modification.modifications.data; + +import lombok.Getter; +import lombok.Setter; +import lombok.experimental.SuperBuilder; +import org.gridsuite.modification.dto.AttributeModification; +import org.gridsuite.modification.dto.ReactiveCapabilityCurvePointsInfos; + +import java.util.List; + +/** + * @author Joris Mancini + */ +@Getter +@Setter +@SuperBuilder +public class VscConverterStationModification extends AbstractInjectionModification { + + private AttributeModification lossFactor; + private AttributeModification reactivePowerSetpoint; + private AttributeModification voltageRegulationOn; + private AttributeModification voltageSetpoint; + private AttributeModification reactiveCapabilityCurve; + private AttributeModification minQ; + private AttributeModification maxQ; + private List reactiveCapabilityCurvePoints; +} diff --git a/src/main/java/org/gridsuite/modification/utils/MeasurementUtils.java b/src/main/java/org/gridsuite/modification/utils/MeasurementUtils.java index 43fc9cef..5b828754 100644 --- a/src/main/java/org/gridsuite/modification/utils/MeasurementUtils.java +++ b/src/main/java/org/gridsuite/modification/utils/MeasurementUtils.java @@ -13,7 +13,7 @@ import com.powsybl.iidm.network.extensions.Measurement; import com.powsybl.iidm.network.extensions.Measurements; import com.powsybl.iidm.network.extensions.MeasurementsAdder; -import org.gridsuite.modification.dto.InjectionModificationInfos; +import org.gridsuite.modification.modifications.InjectionModification; import java.util.ArrayList; import java.util.List; @@ -50,11 +50,11 @@ public static Measurement getExistingSideMeasurement(Measurements measurement return measurements.getMeasurements(type).stream().filter(m -> m.getSide() == side).findFirst().orElse(null); } - public static ReportNode applyAndBuildModificationReport(Injection injection, InjectionModificationInfos injectionModificationInfos, ReportNode subReportNode) { - Double pValue = injectionModificationInfos.getPMeasurementValue() != null ? injectionModificationInfos.getPMeasurementValue().getValue() : null; - Double qValue = injectionModificationInfos.getQMeasurementValue() != null ? injectionModificationInfos.getQMeasurementValue().getValue() : null; - Boolean pValidity = injectionModificationInfos.getPMeasurementValidity() != null ? injectionModificationInfos.getPMeasurementValidity().getValue() : null; - Boolean qValidity = injectionModificationInfos.getQMeasurementValidity() != null ? injectionModificationInfos.getQMeasurementValidity().getValue() : null; + public static ReportNode applyAndBuildModificationReport(Injection injection, InjectionModification injectionModification, ReportNode subReportNode) { + Double pValue = injectionModification.getPMeasurementValue() != null ? injectionModification.getPMeasurementValue().getValue() : null; + Double qValue = injectionModification.getQMeasurementValue() != null ? injectionModification.getQMeasurementValue().getValue() : null; + Boolean pValidity = injectionModification.getPMeasurementValidity() != null ? injectionModification.getPMeasurementValidity().getValue() : null; + Boolean qValidity = injectionModification.getQMeasurementValidity() != null ? injectionModification.getQMeasurementValidity().getValue() : null; if (pValue == null && pValidity == null && qValue == null && qValidity == null) { // no measurement modification requested diff --git a/src/main/java/org/gridsuite/modification/utils/ModificationUtils.java b/src/main/java/org/gridsuite/modification/utils/ModificationUtils.java index bfc3afaa..fbca129e 100644 --- a/src/main/java/org/gridsuite/modification/utils/ModificationUtils.java +++ b/src/main/java/org/gridsuite/modification/utils/ModificationUtils.java @@ -16,7 +16,7 @@ import org.gridsuite.modification.IFilterService; import org.gridsuite.modification.NetworkModificationException; import org.gridsuite.modification.dto.*; -import org.gridsuite.modification.modifications.AbstractBranchModification; +import org.gridsuite.modification.modifications.*; import org.gridsuite.modification.report.NetworkModificationReportResourceBundle; import org.springframework.util.CollectionUtils; import org.springframework.util.StringUtils; @@ -292,7 +292,7 @@ public int createNodeBreakerCellSwitches(VoltageLevel voltageLevel, String busBa return newNode + 2; } - public void controlNewOrExistingVoltageLevel(VoltageLevelCreationInfos mayNewVL, + public void controlNewOrExistingVoltageLevel(VoltageLevelCreation mayNewVL, String existingVoltageLevelId, String bbsOrBusId, Network network) { if (mayNewVL != null) { controlVoltageLevelCreation(mayNewVL, network); @@ -307,26 +307,26 @@ public void controlNewOrExistingVoltageLevel(VoltageLevelCreationInfos mayNewVL, } } - public void controlVoltageLevelCreation(VoltageLevelCreationInfos voltageLevelCreationInfos, Network network) { - if (network.getVoltageLevel(voltageLevelCreationInfos.getEquipmentId()) != null) { - throw new NetworkModificationException(VOLTAGE_LEVEL_ALREADY_EXISTS, voltageLevelCreationInfos.getEquipmentId()); + public void controlVoltageLevelCreation(VoltageLevelCreation voltageLevelCreation, Network network) { + if (network.getVoltageLevel(voltageLevelCreation.getEquipmentId()) != null) { + throw new NetworkModificationException(VOLTAGE_LEVEL_ALREADY_EXISTS, voltageLevelCreation.getEquipmentId()); } - if (voltageLevelCreationInfos.getCouplingDevices().stream() + if (voltageLevelCreation.getCouplingDevices().stream() .anyMatch(cd -> cd.getBusbarSectionId1().equals(cd.getBusbarSectionId2()))) { throw new NetworkModificationException(CREATE_VOLTAGE_LEVEL_ERROR, "Coupling between same bus bar section is not allowed"); } - if (Objects.nonNull(voltageLevelCreationInfos.getIpMin()) && voltageLevelCreationInfos.getIpMin() < 0) { + if (Objects.nonNull(voltageLevelCreation.getIpMin()) && voltageLevelCreation.getIpMin() < 0) { throw new NetworkModificationException(CREATE_VOLTAGE_LEVEL_ERROR, "IpMin must be positive"); } - if (Objects.nonNull(voltageLevelCreationInfos.getIpMax()) && voltageLevelCreationInfos.getIpMax() < 0) { + if (Objects.nonNull(voltageLevelCreation.getIpMax()) && voltageLevelCreation.getIpMax() < 0) { throw new NetworkModificationException(CREATE_VOLTAGE_LEVEL_ERROR, "IpMax must be positive"); } - if (Objects.nonNull(voltageLevelCreationInfos.getIpMin()) && Objects.isNull(voltageLevelCreationInfos.getIpMax())) { + if (Objects.nonNull(voltageLevelCreation.getIpMin()) && Objects.isNull(voltageLevelCreation.getIpMax())) { throw new NetworkModificationException(CREATE_VOLTAGE_LEVEL_ERROR, "IpMax is required"); } - if (Objects.nonNull(voltageLevelCreationInfos.getIpMin()) && Objects.nonNull(voltageLevelCreationInfos.getIpMax()) - && voltageLevelCreationInfos.getIpMin() > voltageLevelCreationInfos.getIpMax()) { + if (Objects.nonNull(voltageLevelCreation.getIpMin()) && Objects.nonNull(voltageLevelCreation.getIpMax()) + && voltageLevelCreation.getIpMin() > voltageLevelCreation.getIpMax()) { throw new NetworkModificationException(CREATE_VOLTAGE_LEVEL_ERROR, "IpMin cannot be greater than IpMax"); } } @@ -353,35 +353,35 @@ private boolean checkBbs(Network network, String busbarSectionId1, String busbar return true; } - public void createSubstation(SubstationCreationInfos substationCreationInfos, + public void createSubstation(SubstationCreation substationCreation, ReportNode subReportNode, Network network) { network.newSubstation() - .setId(substationCreationInfos.getEquipmentId()) - .setName(substationCreationInfos.getEquipmentName()) - .setCountry(substationCreationInfos.getCountry()) + .setId(substationCreation.getEquipmentId()) + .setName(substationCreation.getEquipmentName()) + .setCountry(substationCreation.getCountry()) .add(); subReportNode.newReportNode() .withMessageTemplate("network.modification.substationCreated") - .withUntypedValue("id", substationCreationInfos.getEquipmentId()) + .withUntypedValue("id", substationCreation.getEquipmentId()) .withSeverity(TypedValue.INFO_SEVERITY) .add(); // name and country - if (substationCreationInfos.getEquipmentName() != null) { + if (substationCreation.getEquipmentName() != null) { ModificationUtils.getInstance() - .reportElementaryCreation(subReportNode, substationCreationInfos.getEquipmentName(), "Name"); + .reportElementaryCreation(subReportNode, substationCreation.getEquipmentName(), "Name"); } - if (substationCreationInfos.getCountry() != null) { + if (substationCreation.getCountry() != null) { ModificationUtils.getInstance() - .reportElementaryCreation(subReportNode, substationCreationInfos.getCountry(), "Country"); + .reportElementaryCreation(subReportNode, substationCreation.getCountry(), "Country"); } } - public void createVoltageLevel(VoltageLevelCreationInfos voltageLevelCreationInfos, + public void createVoltageLevel(VoltageLevelCreation voltageLevelCreation, ReportNode subReportNode, Network network, NamingStrategy namingStrategy) { - String substationId = voltageLevelCreationInfos.getSubstationId(); - SubstationCreationInfos substationCreation = voltageLevelCreationInfos.getSubstationCreation(); + String substationId = voltageLevelCreation.getSubstationId(); + SubstationCreation substationCreation = voltageLevelCreation.getSubstationCreation(); Substation substation; if (substationCreation != null) { substationId = substationCreation.getEquipmentId(); @@ -395,90 +395,90 @@ public void createVoltageLevel(VoltageLevelCreationInfos voltageLevelCreationInf throw new NetworkModificationException(SUBSTATION_NOT_FOUND, substationId); } VoltageLevel voltageLevel = substation.newVoltageLevel() - .setId(voltageLevelCreationInfos.getEquipmentId()) - .setName(voltageLevelCreationInfos.getEquipmentName()) + .setId(voltageLevelCreation.getEquipmentId()) + .setName(voltageLevelCreation.getEquipmentName()) .setTopologyKind(TopologyKind.NODE_BREAKER) - .setNominalV(voltageLevelCreationInfos.getNominalV()) + .setNominalV(voltageLevelCreation.getNominalV()) .add(); - if (voltageLevelCreationInfos.getLowVoltageLimit() != null) { - voltageLevel.setLowVoltageLimit(voltageLevelCreationInfos.getLowVoltageLimit()); + if (voltageLevelCreation.getLowVoltageLimit() != null) { + voltageLevel.setLowVoltageLimit(voltageLevelCreation.getLowVoltageLimit()); } - if (voltageLevelCreationInfos.getHighVoltageLimit() != null) { - voltageLevel.setHighVoltageLimit(voltageLevelCreationInfos.getHighVoltageLimit()); + if (voltageLevelCreation.getHighVoltageLimit() != null) { + voltageLevel.setHighVoltageLimit(voltageLevelCreation.getHighVoltageLimit()); } - if (voltageLevelCreationInfos.getIpMax() != null && voltageLevelCreationInfos.getIpMin() != null) { + if (voltageLevelCreation.getIpMax() != null && voltageLevelCreation.getIpMin() != null) { voltageLevel.newExtension(IdentifiableShortCircuitAdder.class) - .withIpMin(voltageLevelCreationInfos.getIpMin()) - .withIpMax(voltageLevelCreationInfos.getIpMax()) + .withIpMin(voltageLevelCreation.getIpMin()) + .withIpMax(voltageLevelCreation.getIpMax()) .add(); - } else if (voltageLevelCreationInfos.getIpMax() != null && voltageLevelCreationInfos.getIpMin() == null) { + } else if (voltageLevelCreation.getIpMax() != null && voltageLevelCreation.getIpMin() == null) { voltageLevel.newExtension(IdentifiableShortCircuitAdder.class) - .withIpMax(voltageLevelCreationInfos.getIpMax()) + .withIpMax(voltageLevelCreation.getIpMax()) .add(); - } else if (voltageLevelCreationInfos.getIpMax() == null && voltageLevelCreationInfos.getIpMin() != null) { + } else if (voltageLevelCreation.getIpMax() == null && voltageLevelCreation.getIpMin() != null) { voltageLevel.newExtension(IdentifiableShortCircuitAdder.class) - .withIpMin(voltageLevelCreationInfos.getIpMin()) + .withIpMin(voltageLevelCreation.getIpMin()) .add(); } CreateVoltageLevelTopologyBuilder voltageLevelTopologyBuilder = new CreateVoltageLevelTopologyBuilder(); - voltageLevelTopologyBuilder.withVoltageLevelId(voltageLevelCreationInfos.getEquipmentId()) - .withAlignedBusesOrBusbarCount(voltageLevelCreationInfos.getBusbarCount()) - .withSectionCount(voltageLevelCreationInfos.getSectionCount()) - .withSwitchKinds(voltageLevelCreationInfos.getSwitchKinds()) + voltageLevelTopologyBuilder.withVoltageLevelId(voltageLevelCreation.getEquipmentId()) + .withAlignedBusesOrBusbarCount(voltageLevelCreation.getBusbarCount()) + .withSectionCount(voltageLevelCreation.getSectionCount()) + .withSwitchKinds(voltageLevelCreation.getSwitchKinds()) .build().apply(network, namingStrategy); - voltageLevelCreationInfos.getCouplingDevices().forEach(couplingDevice -> { + voltageLevelCreation.getCouplingDevices().forEach(couplingDevice -> { if (!checkBbs(network, couplingDevice.getBusbarSectionId1(), couplingDevice.getBusbarSectionId2(), subReportNode)) { return; } CreateCouplingDeviceBuilder couplingDeviceBuilder = new CreateCouplingDeviceBuilder(); couplingDeviceBuilder.withBusOrBusbarSectionId1(couplingDevice.getBusbarSectionId1()) .withBusOrBusbarSectionId2(couplingDevice.getBusbarSectionId2()) - .withSwitchPrefixId(voltageLevelCreationInfos.getEquipmentId() + "_COUPL") + .withSwitchPrefixId(voltageLevelCreation.getEquipmentId() + "_COUPL") .build().apply(network, namingStrategy, subReportNode); }); subReportNode.newReportNode() .withMessageTemplate("network.modification.voltageLevelCreated") - .withUntypedValue("id", voltageLevelCreationInfos.getEquipmentId()) + .withUntypedValue("id", voltageLevelCreation.getEquipmentId()) .withSeverity(TypedValue.INFO_SEVERITY) .add(); - PropertiesUtils.applyProperties(voltageLevel, subReportNode, voltageLevelCreationInfos.getProperties(), "network.modification.VlProperties"); + PropertiesUtils.applyProperties(voltageLevel, subReportNode, voltageLevelCreation.getProperties(), "network.modification.VlProperties"); } - public LineAdder createLineAdder(Network network, VoltageLevel voltageLevel1, VoltageLevel voltageLevel2, LineCreationInfos lineCreationInfos, boolean withSwitch1, boolean withSwitch2) { + public LineAdder createLineAdder(Network network, VoltageLevel voltageLevel1, VoltageLevel voltageLevel2, LineCreation lineCreation, boolean withSwitch1, boolean withSwitch2) { // common settings LineAdder lineAdder = network.newLine() - .setId(lineCreationInfos.getEquipmentId()) - .setName(lineCreationInfos.getEquipmentName()) - .setVoltageLevel1(lineCreationInfos.getVoltageLevelId1()) - .setVoltageLevel2(lineCreationInfos.getVoltageLevelId2()) - .setR(lineCreationInfos.getR()) - .setX(lineCreationInfos.getX()) - .setG1(lineCreationInfos.getG1() != null ? lineCreationInfos.getG1() : 0.0) - .setB1(lineCreationInfos.getB1() != null ? lineCreationInfos.getB1() : 0.0) - .setG2(lineCreationInfos.getG2() != null ? lineCreationInfos.getG2() : 0.0) - .setB2(lineCreationInfos.getB2() != null ? lineCreationInfos.getB2() : 0.0); + .setId(lineCreation.getEquipmentId()) + .setName(lineCreation.getEquipmentName()) + .setVoltageLevel1(lineCreation.getVoltageLevelId1()) + .setVoltageLevel2(lineCreation.getVoltageLevelId2()) + .setR(lineCreation.getR()) + .setX(lineCreation.getX()) + .setG1(lineCreation.getG1() != null ? lineCreation.getG1() : 0.0) + .setB1(lineCreation.getB1() != null ? lineCreation.getB1() : 0.0) + .setG2(lineCreation.getG2() != null ? lineCreation.getG2() : 0.0) + .setB2(lineCreation.getB2() != null ? lineCreation.getB2() : 0.0); // lineAdder completion by topology - setBranchAdderNodeOrBus(lineAdder, voltageLevel1, lineCreationInfos, ONE, withSwitch1); - setBranchAdderNodeOrBus(lineAdder, voltageLevel2, lineCreationInfos, TwoSides.TWO, withSwitch2); + setBranchAdderNodeOrBus(lineAdder, voltageLevel1, lineCreation, ONE, withSwitch1); + setBranchAdderNodeOrBus(lineAdder, voltageLevel2, lineCreation, TwoSides.TWO, withSwitch2); return lineAdder; } - public void setBranchAdderNodeOrBus(BranchAdder branchAdder, VoltageLevel voltageLevel, BranchCreationInfos branchCreationInfos, + public void setBranchAdderNodeOrBus(BranchAdder branchAdder, VoltageLevel voltageLevel, AbstractBranchCreation branchCreation, TwoSides side, boolean withSwitch) { - String busOrBusbarSectionId = (side == ONE) ? branchCreationInfos.getBusOrBusbarSectionId1() : branchCreationInfos.getBusOrBusbarSectionId2(); + String busOrBusbarSectionId = (side == ONE) ? branchCreation.getBusOrBusbarSectionId1() : branchCreation.getBusOrBusbarSectionId2(); if (voltageLevel.getTopologyKind() == TopologyKind.BUS_BREAKER) { setBranchAdderBusBreaker(branchAdder, voltageLevel, side, busOrBusbarSectionId); } else { if (withSwitch) { // NODE_BREAKER - setBranchAdderNodeBreaker(branchAdder, voltageLevel, branchCreationInfos, side, busOrBusbarSectionId); + setBranchAdderNodeBreaker(branchAdder, voltageLevel, branchCreation, side, busOrBusbarSectionId); } } } @@ -495,14 +495,14 @@ private void setBranchAdderBusBreaker(BranchAdder branchAdder, VoltageLeve } private void setBranchAdderNodeBreaker(BranchAdder branchAdder, VoltageLevel voltageLevel, - BranchCreationInfos branchCreationInfos, TwoSides side, + AbstractBranchCreation branchCreation, TwoSides side, String currentBusBarSectionId) { // create cell switches String sideSuffix = side != null ? "_" + side.name() : ""; int nodeNum = createNodeBreakerCellSwitches(voltageLevel, currentBusBarSectionId, - branchCreationInfos.getEquipmentId(), - branchCreationInfos.getEquipmentName(), + branchCreation.getEquipmentId(), + branchCreation.getEquipmentName(), sideSuffix); // complete the lineAdder @@ -681,13 +681,13 @@ public static boolean isInjectionConnected(Injection injection) { return injection != null && injection.getTerminal().isConnected(); } - public void disconnectCreatedInjection(InjectionCreationInfos modificationInfos, Injection injection, ReportNode subReportNode) { + public void disconnectCreatedInjection(InjectionCreation injectionCreation, Injection injection, ReportNode subReportNode) { // A newly created injection is connected by default, unless we choose not to do - if (!modificationInfos.isTerminalConnected()) { + if (!injectionCreation.isTerminalConnected()) { injection.getTerminal().disconnect(); subReportNode.newReportNode() .withMessageTemplate(EQUIPMENT_DISCONNECTED) - .withUntypedValue("id", modificationInfos.getEquipmentId()) + .withUntypedValue("id", injectionCreation.getEquipmentId()) .withSeverity(TypedValue.INFO_SEVERITY) .add(); } @@ -696,11 +696,11 @@ public void disconnectCreatedInjection(InjectionCreationInfos modificationInfos, public ReportNode modifyInjectionConnectivityAttributes(ConnectablePosition connectablePosition, ConnectablePositionAdder connectablePositionAdder, Injection injection, - InjectionModificationInfos modificationInfos, + AbstractInjectionModification injectionModification, ReportNode connectivityReports) { List reports = new ArrayList<>(); - processConnectivityPosition(connectablePosition, connectablePositionAdder, modificationInfos, injection.getNetwork(), reports); - modifyConnection(modificationInfos.getTerminalConnected(), injection, injection.getTerminal(), reports); + processConnectivityPosition(connectablePosition, connectablePositionAdder, injectionModification, injection.getNetwork(), reports); + modifyConnection(injectionModification.getTerminalConnected(), injection, injection.getTerminal(), reports); return reportModifications(connectivityReports, reports, "network.modification.ConnectivityModified"); } @@ -708,17 +708,17 @@ public ReportNode modifyInjectionConnectivityAttributes(ConnectablePosition c public ReportNode modifyBranchConnectivityAttributes(ConnectablePosition connectablePosition, ConnectablePositionAdder connectablePositionAdder, Branch branch, - BranchModificationInfos modificationInfos, + AbstractBranchModification branchModification, ReportNode connectivityReports) { List reports = new ArrayList<>(); - processConnectivityPosition(connectablePosition, connectablePositionAdder, modificationInfos, branch.getNetwork(), reports); + processConnectivityPosition(connectablePosition, connectablePositionAdder, branchModification, branch.getNetwork(), reports); List exceptions = new ArrayList<>(); // Pair for Side and Pair for update and terminal List, Terminal>>> modificationsBySides = List.of( - Pair.create(ThreeSides.ONE, Pair.create(modificationInfos.getTerminal1Connected(), branch.getTerminal1())), - Pair.create(ThreeSides.TWO, Pair.create(modificationInfos.getTerminal2Connected(), branch.getTerminal2())) + Pair.create(ThreeSides.ONE, Pair.create(branchModification.getTerminal1Connected(), branch.getTerminal1())), + Pair.create(ThreeSides.TWO, Pair.create(branchModification.getTerminal2Connected(), branch.getTerminal2())) ); // We want information for the both sides, not only the first in error for (Pair, Terminal>> side : modificationsBySides) { @@ -748,69 +748,69 @@ public ReportNode modifyBranchConnectivityAttributes(ConnectablePosition conn private void processConnectivityPosition(ConnectablePosition connectablePosition, ConnectablePositionAdder connectablePositionAdder, - BasicEquipmentModificationInfos modificationInfos, + AbstractEquipmentModification equipmentModification, Network network, List reports) { if (connectablePosition != null) { - modifyExistingConnectivityPosition(connectablePosition, modificationInfos, reports); + modifyExistingConnectivityPosition(connectablePosition, equipmentModification, reports); } else { - createNewConnectivityPosition(connectablePositionAdder, modificationInfos, network, reports); + createNewConnectivityPosition(connectablePositionAdder, equipmentModification, network, reports); } } private void modifyExistingConnectivityPosition(ConnectablePosition connectablePosition, - BasicEquipmentModificationInfos modificationInfos, + AbstractEquipmentModification equipmentModification, List reports) { - if (modificationInfos instanceof BranchModificationInfos) { - modifyConnectablePosition(connectablePosition.getFeeder1(), modificationInfos, reports, FeederSide.BRANCH_SIDE_ONE); - modifyConnectablePosition(connectablePosition.getFeeder2(), modificationInfos, reports, FeederSide.BRANCH_SIDE_TWO); - } else if (modificationInfos instanceof InjectionModificationInfos) { - modifyConnectablePosition(connectablePosition.getFeeder(), modificationInfos, reports, FeederSide.INJECTION_SINGLE_SIDE); + if (equipmentModification instanceof AbstractBranchModification) { + modifyConnectablePosition(connectablePosition.getFeeder1(), equipmentModification, reports, FeederSide.BRANCH_SIDE_ONE); + modifyConnectablePosition(connectablePosition.getFeeder2(), equipmentModification, reports, FeederSide.BRANCH_SIDE_TWO); + } else if (equipmentModification instanceof AbstractInjectionModification) { + modifyConnectablePosition(connectablePosition.getFeeder(), equipmentModification, reports, FeederSide.INJECTION_SINGLE_SIDE); } } private void createNewConnectivityPosition(ConnectablePositionAdder adder, - BasicEquipmentModificationInfos modificationInfos, + AbstractEquipmentModification equipmentModification, Network network, List reports) { - if (modificationInfos instanceof BranchModificationInfos) { - addConnectablePosition(adder, modificationInfos, network, reports, FeederSide.BRANCH_SIDE_ONE); - addConnectablePosition(adder, modificationInfos, network, reports, FeederSide.BRANCH_SIDE_TWO); - } else if (modificationInfos instanceof InjectionModificationInfos) { - addConnectablePosition(adder, modificationInfos, network, reports, FeederSide.INJECTION_SINGLE_SIDE); + if (equipmentModification instanceof AbstractBranchModification) { + addConnectablePosition(adder, equipmentModification, network, reports, FeederSide.BRANCH_SIDE_ONE); + addConnectablePosition(adder, equipmentModification, network, reports, FeederSide.BRANCH_SIDE_TWO); + } else if (equipmentModification instanceof AbstractInjectionModification) { + addConnectablePosition(adder, equipmentModification, network, reports, FeederSide.INJECTION_SINGLE_SIDE); } } private void modifyConnectablePosition(ConnectablePosition.Feeder feeder, - BasicEquipmentModificationInfos modificationInfos, + AbstractEquipmentModification equipmentModification, List reports, FeederSide feederSide) { if (feeder != null) { - applyModifications(feeder, modificationInfos, reports, feederSide); + applyModifications(feeder, equipmentModification, reports, feederSide); } } private void applyModifications(ConnectablePosition.Feeder feeder, - BasicEquipmentModificationInfos modificationInfos, + AbstractEquipmentModification equipmentModification, List reports, FeederSide feederSide) { ReportNode connectionNameReport = applyElementaryModificationsAndReturnReport(feeder::setName, feeder.getName()::get, - getConnectionName(modificationInfos, feederSide), + getConnectionName(equipmentModification, feederSide), getConnectionNameField(feederSide)); if (connectionNameReport != null) { reports.add(connectionNameReport); } ReportNode connectionDirectionReport = applyElementaryModificationsAndReturnReport(feeder::setDirection, feeder::getDirection, - getConnectionDirection(modificationInfos, feederSide), + getConnectionDirection(equipmentModification, feederSide), getConnectionDirectionField(feederSide)); if (connectionDirectionReport != null) { reports.add(connectionDirectionReport); } ReportNode connectionPositionReport = applyElementaryModificationsAndReturnReport(feeder::setOrder, feeder.getOrder()::get, - getConnectionPosition(modificationInfos, feederSide), + getConnectionPosition(equipmentModification, feederSide), getConnectionPositionField(feederSide)); if (connectionPositionReport != null) { reports.add(connectionPositionReport); @@ -818,19 +818,19 @@ private void applyModifications(ConnectablePosition.Feeder feeder, } private void addConnectablePosition(ConnectablePositionAdder adder, - BasicEquipmentModificationInfos modificationInfos, + AbstractEquipmentModification equipmentModification, Network network, List reports, FeederSide feederSide) { - AttributeModification connectionName = getConnectionName(modificationInfos, feederSide); - AttributeModification connectionDirection = getConnectionDirection(modificationInfos, feederSide); - AttributeModification connectionPosition = getConnectionPosition(modificationInfos, feederSide); + AttributeModification connectionName = getConnectionName(equipmentModification, feederSide); + AttributeModification connectionDirection = getConnectionDirection(equipmentModification, feederSide); + AttributeModification connectionPosition = getConnectionPosition(equipmentModification, feederSide); if (Objects.isNull(connectionName) && Objects.isNull(connectionDirection) && Objects.isNull(connectionPosition)) { return; } - AttributeModification equipmentId = getEquipmentId(modificationInfos); - AttributeModification voltageLevelId = getVoltageLevelId(modificationInfos, feederSide); - AttributeModification busOrBusbarSectionId = getBusOrBusbarSectionId(modificationInfos, feederSide); + AttributeModification equipmentId = getEquipmentId(equipmentModification); + AttributeModification voltageLevelId = getVoltageLevelId(equipmentModification, feederSide); + AttributeModification busOrBusbarSectionId = getBusOrBusbarSectionId(equipmentModification, feederSide); int position = getPosition(connectionPosition, busOrBusbarSectionId, voltageLevelId, equipmentId, feederSide, network); ConnectablePositionAdder.FeederAdder feeder; switch (feederSide) { @@ -888,18 +888,18 @@ private boolean isAnyAttributesNonNull(AttributeModification... attributes) { return Arrays.stream(attributes).anyMatch(Objects::nonNull); } - private T getConnectionDetail(BasicEquipmentModificationInfos modificationInfos, FeederSide feederSide, - Function branchFunc1, - Function branchFunc2, - Function injectionFunc) { - if (modificationInfos instanceof BranchModificationInfos branchInfo) { + private T getConnectionDetail(AbstractEquipmentModification equipmentModification, FeederSide feederSide, + Function branchFunc1, + Function branchFunc2, + Function injectionFunc) { + if (equipmentModification instanceof AbstractBranchModification branchModification) { if (Objects.requireNonNull(feederSide) == FeederSide.BRANCH_SIDE_ONE) { - return branchFunc1.apply(branchInfo); + return branchFunc1.apply(branchModification); } else if (feederSide == FeederSide.BRANCH_SIDE_TWO) { - return branchFunc2.apply(branchInfo); + return branchFunc2.apply(branchModification); } - } else if (modificationInfos instanceof InjectionModificationInfos injectionInfo) { - return injectionFunc.apply(injectionInfo); + } else if (equipmentModification instanceof AbstractInjectionModification injectionModification) { + return injectionFunc.apply(injectionModification); } return null; } @@ -912,26 +912,26 @@ static String getConnectionFieldName(FeederSide feederSide, String baseFieldName }; } - private AttributeModification getVoltageLevelId(BasicEquipmentModificationInfos modificationInfos, FeederSide feederSide) { - return getConnectionDetail(modificationInfos, feederSide, - BranchModificationInfos::getVoltageLevelId1, BranchModificationInfos::getVoltageLevelId2, - InjectionModificationInfos::getVoltageLevelId); + private AttributeModification getVoltageLevelId(AbstractEquipmentModification equipmentModification, FeederSide feederSide) { + return getConnectionDetail(equipmentModification, feederSide, + AbstractBranchModification::getVoltageLevelId1, AbstractBranchModification::getVoltageLevelId2, + AbstractInjectionModification::getVoltageLevelId); } - private AttributeModification getBusOrBusbarSectionId(BasicEquipmentModificationInfos modificationInfos, FeederSide feederSide) { - return getConnectionDetail(modificationInfos, feederSide, - BranchModificationInfos::getBusOrBusbarSectionId1, BranchModificationInfos::getBusOrBusbarSectionId2, - InjectionModificationInfos::getBusOrBusbarSectionId); + private AttributeModification getBusOrBusbarSectionId(AbstractEquipmentModification equipmentModification, FeederSide feederSide) { + return getConnectionDetail(equipmentModification, feederSide, + AbstractBranchModification::getBusOrBusbarSectionId1, AbstractBranchModification::getBusOrBusbarSectionId2, + AbstractInjectionModification::getBusOrBusbarSectionId); } - private AttributeModification getEquipmentId(BasicEquipmentModificationInfos modificationInfos) { - return AttributeModification.toAttributeModification(modificationInfos.getEquipmentId(), OperationType.SET); + private AttributeModification getEquipmentId(AbstractEquipmentModification equipmentModification) { + return AttributeModification.toAttributeModification(equipmentModification.getEquipmentId(), OperationType.SET); } - private AttributeModification getConnectionName(BasicEquipmentModificationInfos modificationInfos, FeederSide feederSide) { - return getConnectionDetail(modificationInfos, feederSide, - BranchModificationInfos::getConnectionName1, BranchModificationInfos::getConnectionName2, - InjectionModificationInfos::getConnectionName); + private AttributeModification getConnectionName(AbstractEquipmentModification equipmentModification, FeederSide feederSide) { + return getConnectionDetail(equipmentModification, feederSide, + AbstractBranchModification::getConnectionName1, AbstractBranchModification::getConnectionName2, + AbstractInjectionModification::getConnectionName); } private static String getConnectionNameField(FeederSide feederSide) { @@ -946,16 +946,16 @@ private static String getConnectionPositionField(FeederSide feederSide) { return getConnectionFieldName(feederSide, CONNECTION_POSITION_FIELD_NAME); } - private AttributeModification getConnectionDirection(BasicEquipmentModificationInfos modificationInfos, FeederSide feederSide) { - return getConnectionDetail(modificationInfos, feederSide, - BranchModificationInfos::getConnectionDirection1, BranchModificationInfos::getConnectionDirection2, - InjectionModificationInfos::getConnectionDirection); + private AttributeModification getConnectionDirection(AbstractEquipmentModification equipmentModification, FeederSide feederSide) { + return getConnectionDetail(equipmentModification, feederSide, + AbstractBranchModification::getConnectionDirection1, AbstractBranchModification::getConnectionDirection2, + AbstractInjectionModification::getConnectionDirection); } - private AttributeModification getConnectionPosition(BasicEquipmentModificationInfos modificationInfos, FeederSide feederSide) { - return getConnectionDetail(modificationInfos, feederSide, - BranchModificationInfos::getConnectionPosition1, BranchModificationInfos::getConnectionPosition2, - InjectionModificationInfos::getConnectionPosition); + private AttributeModification getConnectionPosition(AbstractEquipmentModification equipmentModification, FeederSide feederSide) { + return getConnectionDetail(equipmentModification, feederSide, + AbstractBranchModification::getConnectionPosition1, AbstractBranchModification::getConnectionPosition2, + AbstractInjectionModification::getConnectionPosition); } public String getBusOrBusbarSection(Terminal terminal) { @@ -1040,21 +1040,21 @@ private String capitalize(String input) { return input.substring(0, 1).toUpperCase() + input.substring(1); } - public void disconnectBranch(BranchCreationInfos modificationInfos, Branch branch, ReportNode subReportNode) { + public void disconnectBranch(AbstractBranchCreation branchCreation, Branch branch, ReportNode subReportNode) { // A newly created branch is connected by default on both sides, unless we choose not to do - if (!modificationInfos.isConnected1()) { + if (!branchCreation.isConnected1()) { branch.getTerminal1().disconnect(); subReportNode.newReportNode() .withMessageTemplate("network.modification.terminal1Disconnected") - .withUntypedValue("id", modificationInfos.getEquipmentId()) + .withUntypedValue("id", branchCreation.getEquipmentId()) .withSeverity(TypedValue.INFO_SEVERITY) .add(); } - if (!modificationInfos.isConnected2()) { + if (!branchCreation.isConnected2()) { branch.getTerminal2().disconnect(); subReportNode.newReportNode() .withMessageTemplate("network.modification.terminal2Disconnected") - .withUntypedValue("id", modificationInfos.getEquipmentId()) + .withUntypedValue("id", branchCreation.getEquipmentId()) .withSeverity(TypedValue.INFO_SEVERITY) .add(); } @@ -1573,47 +1573,67 @@ public void checkReactiveLimitsCreation(ReactiveLimitsHolderInfos modificationIn } } - public void checkReactivePowerLimitsAndSetPointsCreation(StaticVarCompensatorCreationInfos creationInfos) { + public void checkReactivePowerLimitsAndSetPointsCreation( + StaticVarCompensatorCreation staticVarCompensatorCreation) { String equipmentName = "StaticVarCompensator"; // check min max reactive limits - if (Objects.isNull(creationInfos.getMinSusceptance()) && Objects.isNull(creationInfos.getMinQAtNominalV())) { - throw makeEquipmentException(creationInfos.getErrorType(), creationInfos.getEquipmentId(), equipmentName, "minimum susceptance is not set"); + if (Objects.isNull(staticVarCompensatorCreation.getMinSusceptance()) && Objects.isNull( + staticVarCompensatorCreation.getMinQAtNominalV())) { + throw makeEquipmentException(CREATE_STATIC_VAR_COMPENSATOR_ERROR, + staticVarCompensatorCreation.getEquipmentId(), equipmentName, "minimum susceptance is not set"); } - if (Objects.isNull(creationInfos.getMaxSusceptance()) && Objects.isNull(creationInfos.getMaxQAtNominalV())) { - throw makeEquipmentException(creationInfos.getErrorType(), creationInfos.getEquipmentId(), equipmentName, "maximum susceptance is not set"); + if (Objects.isNull(staticVarCompensatorCreation.getMaxSusceptance()) && Objects.isNull( + staticVarCompensatorCreation.getMaxQAtNominalV())) { + throw makeEquipmentException(CREATE_STATIC_VAR_COMPENSATOR_ERROR, + staticVarCompensatorCreation.getEquipmentId(), equipmentName, "maximum susceptance is not set"); } - if (Objects.nonNull(creationInfos.getMaxSusceptance()) && Objects.nonNull(creationInfos.getMinSusceptance()) && creationInfos.getMaxSusceptance() < creationInfos.getMinSusceptance()) { - throw makeEquipmentException(creationInfos.getErrorType(), creationInfos.getEquipmentId(), equipmentName, - "maximum susceptance is expected to be greater than or equal to minimum susceptance"); + if (Objects.nonNull(staticVarCompensatorCreation.getMaxSusceptance()) && Objects.nonNull( + staticVarCompensatorCreation.getMinSusceptance()) && staticVarCompensatorCreation.getMaxSusceptance() < staticVarCompensatorCreation.getMinSusceptance()) { + throw makeEquipmentException(CREATE_STATIC_VAR_COMPENSATOR_ERROR, + staticVarCompensatorCreation.getEquipmentId(), equipmentName, + "maximum susceptance is expected to be greater than or equal to minimum susceptance"); } - if (Objects.nonNull(creationInfos.getMaxQAtNominalV()) && Objects.nonNull(creationInfos.getMinQAtNominalV()) && creationInfos.getMaxQAtNominalV() < creationInfos.getMinQAtNominalV()) { - throw makeEquipmentException(creationInfos.getErrorType(), creationInfos.getEquipmentId(), equipmentName, - "maximum Q at nominal voltage is expected to be greater than or equal to minimum Q"); + if (Objects.nonNull(staticVarCompensatorCreation.getMaxQAtNominalV()) && Objects.nonNull( + staticVarCompensatorCreation.getMinQAtNominalV()) && staticVarCompensatorCreation.getMaxQAtNominalV() < staticVarCompensatorCreation.getMinQAtNominalV()) { + throw makeEquipmentException(CREATE_STATIC_VAR_COMPENSATOR_ERROR, + staticVarCompensatorCreation.getEquipmentId(), equipmentName, + "maximum Q at nominal voltage is expected to be greater than or equal to minimum Q"); } // check set points - if (creationInfos.getRegulationMode() == StaticVarCompensator.RegulationMode.VOLTAGE && creationInfos.getVoltageSetpoint() == null) { - throw makeEquipmentException(creationInfos.getErrorType(), creationInfos.getEquipmentId(), equipmentName, "Voltage setpoint is not set"); + if (staticVarCompensatorCreation.getRegulationMode() == StaticVarCompensator.RegulationMode.VOLTAGE && staticVarCompensatorCreation.getVoltageSetpoint() == null) { + throw makeEquipmentException(CREATE_STATIC_VAR_COMPENSATOR_ERROR, + staticVarCompensatorCreation.getEquipmentId(), equipmentName, "Voltage setpoint is not set"); } - if (creationInfos.getRegulationMode() == StaticVarCompensator.RegulationMode.REACTIVE_POWER && creationInfos.getReactivePowerSetpoint() == null) { - throw makeEquipmentException(creationInfos.getErrorType(), creationInfos.getEquipmentId(), equipmentName, "Reactive power setpoint is not set"); + if (staticVarCompensatorCreation.getRegulationMode() == StaticVarCompensator.RegulationMode.REACTIVE_POWER && staticVarCompensatorCreation.getReactivePowerSetpoint() == null) { + throw makeEquipmentException(CREATE_STATIC_VAR_COMPENSATOR_ERROR, + staticVarCompensatorCreation.getEquipmentId(), equipmentName, "Reactive power setpoint is not set"); } } - public void checkStandbyAutomatonCreation(StaticVarCompensatorCreationInfos creationInfos) { + public void checkStandbyAutomatonCreation(StaticVarCompensatorCreation staticVarCompensatorCreation) { String equipmentName = "StaticVarCompensator"; - if (creationInfos.isStandby() && creationInfos.getRegulationMode() != StaticVarCompensator.RegulationMode.VOLTAGE && !creationInfos.isRegulating()) { - throw makeEquipmentException(creationInfos.getErrorType(), creationInfos.getEquipmentId(), equipmentName, "Standby is only supported in Voltage Regulation mode"); - } - if (Objects.nonNull(creationInfos.getB0()) && Objects.nonNull(creationInfos.getMinSusceptance()) && Objects.nonNull(creationInfos.getMaxSusceptance()) && - (creationInfos.getB0() < creationInfos.getMinSusceptance() || creationInfos.getB0() > creationInfos.getMaxSusceptance())) { - throw makeEquipmentException(creationInfos.getErrorType(), creationInfos.getEquipmentId(), equipmentName, - "b0 must be within the range of minimum susceptance and maximum susceptance"); - } - if (Objects.nonNull(creationInfos.getQ0()) && Objects.nonNull(creationInfos.getMinQAtNominalV()) && Objects.nonNull(creationInfos.getMaxQAtNominalV()) && - (creationInfos.getQ0() < creationInfos.getMinQAtNominalV() || creationInfos.getQ0() > creationInfos.getMaxQAtNominalV())) { - throw makeEquipmentException(creationInfos.getErrorType(), creationInfos.getEquipmentId(), equipmentName, - "q0 must be within the range of minimum Q and maximum Q"); + if (staticVarCompensatorCreation.isStandby() && staticVarCompensatorCreation.getRegulationMode() != StaticVarCompensator.RegulationMode.VOLTAGE + && !staticVarCompensatorCreation.isRegulating()) { + throw makeEquipmentException(CREATE_STATIC_VAR_COMPENSATOR_ERROR, + staticVarCompensatorCreation.getEquipmentId(), equipmentName, + "Standby is only supported in Voltage Regulation mode"); + } + if (Objects.nonNull(staticVarCompensatorCreation.getB0()) && Objects.nonNull( + staticVarCompensatorCreation.getMinSusceptance()) && Objects.nonNull( + staticVarCompensatorCreation.getMaxSusceptance()) && + (staticVarCompensatorCreation.getB0() < staticVarCompensatorCreation.getMinSusceptance() || staticVarCompensatorCreation.getB0() > staticVarCompensatorCreation.getMaxSusceptance())) { + throw makeEquipmentException(CREATE_STATIC_VAR_COMPENSATOR_ERROR, + staticVarCompensatorCreation.getEquipmentId(), equipmentName, + "b0 must be within the range of minimum susceptance and maximum susceptance"); + } + if (Objects.nonNull(staticVarCompensatorCreation.getQ0()) && Objects.nonNull( + staticVarCompensatorCreation.getMinQAtNominalV()) && Objects.nonNull( + staticVarCompensatorCreation.getMaxQAtNominalV()) && + (staticVarCompensatorCreation.getQ0() < staticVarCompensatorCreation.getMinQAtNominalV() || staticVarCompensatorCreation.getQ0() > staticVarCompensatorCreation.getMaxQAtNominalV())) { + throw makeEquipmentException(CREATE_STATIC_VAR_COMPENSATOR_ERROR, + staticVarCompensatorCreation.getEquipmentId(), equipmentName, + "q0 must be within the range of minimum Q and maximum Q"); } } @@ -1757,16 +1777,16 @@ public static void insertReportNode(ReportNode parent, ReportNode child) { } } - public static void createInjectionInNodeBreaker(VoltageLevel voltageLevel, InjectionCreationInfos injectionCreationInfos, + public static void createInjectionInNodeBreaker(VoltageLevel voltageLevel, InjectionCreation injectionCreation, Network network, InjectionAdder injectionAdder, ReportNode subReportNode) { - int position = ModificationUtils.getInstance().getPosition(injectionCreationInfos.getConnectionPosition(), - injectionCreationInfos.getBusOrBusbarSectionId(), network, voltageLevel); + int position = ModificationUtils.getInstance().getPosition(injectionCreation.getConnectionPosition(), + injectionCreation.getBusOrBusbarSectionId(), network, voltageLevel); CreateFeederBay algo = new CreateFeederBayBuilder() - .withBusOrBusbarSectionId(injectionCreationInfos.getBusOrBusbarSectionId()) - .withInjectionDirection(injectionCreationInfos.getConnectionDirection()) - .withInjectionFeederName(injectionCreationInfos.getConnectionName() != null - ? injectionCreationInfos.getConnectionName() - : injectionCreationInfos.getEquipmentId()) + .withBusOrBusbarSectionId(injectionCreation.getBusOrBusbarSectionId()) + .withInjectionDirection(injectionCreation.getConnectionDirection()) + .withInjectionFeederName(injectionCreation.getConnectionName() != null + ? injectionCreation.getConnectionName() + : injectionCreation.getEquipmentId()) .withInjectionPositionOrder(position) .withInjectionAdder(injectionAdder) .withLogOrThrowIfIncorrectPositionOrder(false) @@ -1774,35 +1794,35 @@ public static void createInjectionInNodeBreaker(VoltageLevel voltageLevel, Injec algo.apply(network, true, subReportNode); } - public static void createBranchInNodeBreaker(VoltageLevel voltageLevel1, VoltageLevel voltageLevel2, BranchCreationInfos branchCreationInfos, + public static void createBranchInNodeBreaker(VoltageLevel voltageLevel1, VoltageLevel voltageLevel2, AbstractBranchCreation branchCreation, Network network, BranchAdder branchAdder, ReportNode subReportNode) { - var position1 = ModificationUtils.getInstance().getPosition(branchCreationInfos.getConnectionPosition1(), branchCreationInfos.getBusOrBusbarSectionId1(), network, voltageLevel1); - var position2 = ModificationUtils.getInstance().getPosition(branchCreationInfos.getConnectionPosition2(), branchCreationInfos.getBusOrBusbarSectionId2(), network, voltageLevel2); + var position1 = ModificationUtils.getInstance().getPosition(branchCreation.getConnectionPosition1(), branchCreation.getBusOrBusbarSectionId1(), network, voltageLevel1); + var position2 = ModificationUtils.getInstance().getPosition(branchCreation.getConnectionPosition2(), branchCreation.getBusOrBusbarSectionId2(), network, voltageLevel2); CreateBranchFeederBays algo = new CreateBranchFeederBaysBuilder() - .withBusOrBusbarSectionId1(branchCreationInfos.getBusOrBusbarSectionId1()) - .withBusOrBusbarSectionId2(branchCreationInfos.getBusOrBusbarSectionId2()) - .withFeederName1(branchCreationInfos.getConnectionName1() != null ? branchCreationInfos.getConnectionName1() : branchCreationInfos.getEquipmentId()) - .withFeederName2(branchCreationInfos.getConnectionName2() != null ? branchCreationInfos.getConnectionName2() : branchCreationInfos.getEquipmentId()) - .withDirection1(branchCreationInfos.getConnectionDirection1()) - .withDirection2(branchCreationInfos.getConnectionDirection2()) + .withBusOrBusbarSectionId1(branchCreation.getBusOrBusbarSectionId1()) + .withBusOrBusbarSectionId2(branchCreation.getBusOrBusbarSectionId2()) + .withFeederName1(branchCreation.getConnectionName1() != null ? branchCreation.getConnectionName1() : branchCreation.getEquipmentId()) + .withFeederName2(branchCreation.getConnectionName2() != null ? branchCreation.getConnectionName2() : branchCreation.getEquipmentId()) + .withDirection1(branchCreation.getConnectionDirection1()) + .withDirection2(branchCreation.getConnectionDirection2()) .withPositionOrder1(position1) .withPositionOrder2(position2) .withBranchAdder(branchAdder).build(); algo.apply(network, true, subReportNode); } - public static void reportInjectionCreationConnectivity(InjectionCreationInfos injectionCreationInfos, ReportNode subReporter) { - if (Objects.isNull(injectionCreationInfos.getVoltageLevelId()) || Objects.isNull(injectionCreationInfos.getBusOrBusbarSectionId())) { + public static void reportInjectionCreationConnectivity(InjectionCreation injectionCreation, ReportNode subReporter) { + if (Objects.isNull(injectionCreation.getVoltageLevelId()) || Objects.isNull(injectionCreation.getBusOrBusbarSectionId())) { return; } List connectivityReports = buildConnectivityReports( - injectionCreationInfos.getConnectionName(), - injectionCreationInfos.getConnectionDirection(), - injectionCreationInfos.getConnectionPosition(), - injectionCreationInfos.isTerminalConnected(), - injectionCreationInfos.getEquipmentId(), + injectionCreation.getConnectionName(), + injectionCreation.getConnectionDirection(), + injectionCreation.getConnectionPosition(), + injectionCreation.isTerminalConnected(), + injectionCreation.getEquipmentId(), FeederSide.INJECTION_SINGLE_SIDE ); @@ -1811,31 +1831,31 @@ public static void reportInjectionCreationConnectivity(InjectionCreationInfos in } } - public static void reportBranchCreationConnectivity(BranchCreationInfos branchCreationInfos, ReportNode subReporter) { + public static void reportBranchCreationConnectivity(AbstractBranchCreation branchCreation, ReportNode subReporter) { List connectivityReports = new ArrayList<>(); - if (Objects.isNull(branchCreationInfos.getVoltageLevelId1()) || Objects.isNull(branchCreationInfos.getBusOrBusbarSectionId1())) { + if (Objects.isNull(branchCreation.getVoltageLevelId1()) || Objects.isNull(branchCreation.getBusOrBusbarSectionId1())) { return; } connectivityReports.addAll(buildConnectivityReports( - branchCreationInfos.getConnectionName1(), - branchCreationInfos.getConnectionDirection1(), - branchCreationInfos.getConnectionPosition1(), - branchCreationInfos.isConnected1(), - branchCreationInfos.getEquipmentId(), + branchCreation.getConnectionName1(), + branchCreation.getConnectionDirection1(), + branchCreation.getConnectionPosition1(), + branchCreation.isConnected1(), + branchCreation.getEquipmentId(), FeederSide.BRANCH_SIDE_ONE )); - if (Objects.isNull(branchCreationInfos.getVoltageLevelId2()) || Objects.isNull(branchCreationInfos.getBusOrBusbarSectionId2())) { + if (Objects.isNull(branchCreation.getVoltageLevelId2()) || Objects.isNull(branchCreation.getBusOrBusbarSectionId2())) { return; } - if (!Objects.isNull(branchCreationInfos.getVoltageLevelId2()) && !Objects.isNull(branchCreationInfos.getBusOrBusbarSectionId2())) { + if (!Objects.isNull(branchCreation.getVoltageLevelId2()) && !Objects.isNull(branchCreation.getBusOrBusbarSectionId2())) { connectivityReports.addAll(buildConnectivityReports( - branchCreationInfos.getConnectionName2(), - branchCreationInfos.getConnectionDirection2(), - branchCreationInfos.getConnectionPosition2(), - branchCreationInfos.isConnected2(), - branchCreationInfos.getEquipmentId(), + branchCreation.getConnectionName2(), + branchCreation.getConnectionDirection2(), + branchCreation.getConnectionPosition2(), + branchCreation.isConnected2(), + branchCreation.getEquipmentId(), FeederSide.BRANCH_SIDE_TWO )); } diff --git a/src/test/java/org/gridsuite/modification/modifications/CreateVoltageLevelSectionTest.java b/src/test/java/org/gridsuite/modification/modifications/CreateVoltageLevelSectionTest.java index 0cafb8fa..00b3cd27 100644 --- a/src/test/java/org/gridsuite/modification/modifications/CreateVoltageLevelSectionTest.java +++ b/src/test/java/org/gridsuite/modification/modifications/CreateVoltageLevelSectionTest.java @@ -50,25 +50,24 @@ protected ModificationInfos buildModification() { @Override public void checkModification() { Network network = getNetwork(); - CreateVoltageLevelSectionInfos voltageLevelSectionInfos = (CreateVoltageLevelSectionInfos) buildModification(); - voltageLevelSectionInfos.setBusbarIndex(1); - AbstractModification modification = voltageLevelSectionInfos.toModification(); + CreateVoltageLevelSection voltageLevelSection = (CreateVoltageLevelSection) buildModification().toModification(); + voltageLevelSection.setBusbarIndex(1); - assertEquals("CREATE_VOLTAGE_LEVEL_SECTION", modification.getName()); - String message = assertThrows(NetworkModificationException.class, () -> modification.check(network)).getMessage(); + assertEquals("CREATE_VOLTAGE_LEVEL_SECTION", voltageLevelSection.getName()); + String message = assertThrows(NetworkModificationException.class, () -> voltageLevelSection.check(network)).getMessage(); assertEquals("BUSBAR_SECTION_NOT_FOUND : 1 is not the busbar index of the busbar section bbs1 in voltage level v1", message); - voltageLevelSectionInfos.setVoltageLevelId("notFoundVoltageLevel"); - voltageLevelSectionInfos.setBusbarSectionId("bbs1"); - voltageLevelSectionInfos.setBusbarIndex(1); + voltageLevelSection.setVoltageLevelId("notFoundVoltageLevel"); + voltageLevelSection.setBusbarSectionId("bbs1"); + voltageLevelSection.setBusbarIndex(1); message = assertThrows(NetworkModificationException.class, - () -> modification.check(network)).getMessage(); + () -> voltageLevelSection.check(network)).getMessage(); assertEquals("CREATE_VOLTAGE_LEVEL_ERROR : Voltage level not found: notFoundVoltageLevel", message); - voltageLevelSectionInfos.setVoltageLevelId("v1"); - voltageLevelSectionInfos.setBusbarSectionId("notFoundBusbar"); + voltageLevelSection.setVoltageLevelId("v1"); + voltageLevelSection.setBusbarSectionId("notFoundBusbar"); message = assertThrows(NetworkModificationException.class, - () -> modification.check(network)).getMessage(); + () -> voltageLevelSection.check(network)).getMessage(); assertEquals("BUSBAR_SECTION_NOT_FOUND : notFoundBusbar not found in voltage level v1", message); } diff --git a/src/test/java/org/gridsuite/modification/modifications/CreateVoltageLevelTopologyTest.java b/src/test/java/org/gridsuite/modification/modifications/CreateVoltageLevelTopologyTest.java index 5c5d0dc2..f7ca06aa 100644 --- a/src/test/java/org/gridsuite/modification/modifications/CreateVoltageLevelTopologyTest.java +++ b/src/test/java/org/gridsuite/modification/modifications/CreateVoltageLevelTopologyTest.java @@ -29,23 +29,22 @@ class CreateVoltageLevelTopologyTest extends AbstractNetworkModificationTest { @Override public void checkModification() { - CreateVoltageLevelTopologyInfos createVoltageLevelTopologyInfos = new CreateVoltageLevelTopologyInfos(); - AbstractModification modification = createVoltageLevelTopologyInfos.toModification(); + CreateVoltageLevelTopology createVoltageLevelTopology = (CreateVoltageLevelTopology) new CreateVoltageLevelTopologyInfos().toModification(); Network network = getNetwork(); String message = assertThrows(NetworkModificationException.class, - () -> modification.check(network)).getMessage(); + () -> createVoltageLevelTopology.check(network)).getMessage(); assertEquals("CREATE_VOLTAGE_LEVEL_TOPOLOGY_ERROR : Missing required attributes to modify the equipment", message); - createVoltageLevelTopologyInfos.setVoltageLevelId("notFoundVoltageLevel"); - createVoltageLevelTopologyInfos.setSectionCount(3); - createVoltageLevelTopologyInfos.setSwitchKinds(List.of(SwitchKind.DISCONNECTOR)); + createVoltageLevelTopology.setVoltageLevelId("notFoundVoltageLevel"); + createVoltageLevelTopology.setSectionCount(3); + createVoltageLevelTopology.setSwitchKinds(List.of(SwitchKind.DISCONNECTOR)); message = assertThrows(NetworkModificationException.class, - () -> modification.check(network)).getMessage(); + () -> createVoltageLevelTopology.check(network)).getMessage(); assertEquals("CREATE_VOLTAGE_LEVEL_TOPOLOGY_ERROR : The switch kinds list must have a size equal to the section count minus one", message); - createVoltageLevelTopologyInfos.setSectionCount(2); + createVoltageLevelTopology.setSectionCount(2); message = assertThrows(NetworkModificationException.class, - () -> modification.check(network)).getMessage(); + () -> createVoltageLevelTopology.check(network)).getMessage(); assertEquals("CREATE_VOLTAGE_LEVEL_TOPOLOGY_ERROR : " + "voltage level notFoundVoltageLevel is not found", message); } diff --git a/src/test/java/org/gridsuite/modification/modifications/GenerationDispatchTest.java b/src/test/java/org/gridsuite/modification/modifications/GenerationDispatchTest.java index b8173284..7055a43e 100644 --- a/src/test/java/org/gridsuite/modification/modifications/GenerationDispatchTest.java +++ b/src/test/java/org/gridsuite/modification/modifications/GenerationDispatchTest.java @@ -658,11 +658,11 @@ void testGenerationDispatchErrorCheck() { setNetwork(network); GenerationDispatchInfos modification = GenerationDispatchInfos.builder().lossCoefficient(150.).defaultOutageRate(0.).build(); - final GenerationDispatch generationDispatch1 = new GenerationDispatch(modification); + final GenerationDispatch generationDispatch1 = (GenerationDispatch) modification.toModification(); assertThrows(NetworkModificationException.class, () -> generationDispatch1.check(network), "GENERATION_DISPATCH_ERROR : The loss coefficient must be between 0 and 100"); modification = GenerationDispatchInfos.builder().lossCoefficient(20.).defaultOutageRate(140.).build(); - final GenerationDispatch generationDispatch2 = new GenerationDispatch(modification); + final GenerationDispatch generationDispatch2 = (GenerationDispatch) modification.toModification(); assertThrows(NetworkModificationException.class, () -> generationDispatch2.check(network), "GENERATION_DISPATCH_ERROR : The default outage rate must be between 0 and 100"); } diff --git a/src/test/java/org/gridsuite/modification/modifications/LccModificationTest.java b/src/test/java/org/gridsuite/modification/modifications/LccModificationTest.java index 40a66d0c..0a2591fc 100644 --- a/src/test/java/org/gridsuite/modification/modifications/LccModificationTest.java +++ b/src/test/java/org/gridsuite/modification/modifications/LccModificationTest.java @@ -156,7 +156,7 @@ private void buildAndApplyLccCreationWithShuntCompensator(Network network) { .properties(List.of(FreePropertyInfos.builder().name(PROPERTY_NAME).value(PROPERTY_VALUE).build())) .build(); - LccCreation lccCreation = new LccCreation(creationInfos); + LccCreation lccCreation = (LccCreation) creationInfos.toModification(); lccCreation.apply(network); } @@ -195,7 +195,7 @@ void testModificationWithNullValues() throws Exception { LccConverterStationModificationInfos converterStationModificationInfos = buildLccConverterStationModificationInfos2WithNullInfos(); modificationInfos.setConverterStation2(converterStationModificationInfos); - LccModification lccModification = new LccModification(modificationInfos); + LccModification lccModification = (LccModification) modificationInfos.toModification(); assertEquals("LCC_Modification", lccModification.getName()); ReportNode subReporter = ReportNode.NO_OP; ComputationManager computationManager = new LocalComputationManager(); @@ -245,7 +245,7 @@ void testModificationWithShuntCompensatorsOnSide() { buildLccConverterStationModificationInfosWithShunts(List.of(shuntInfos, shuntInfos2, shuntInfos3)); modificationInfos.setConverterStation1(converterStationModificationInfos); - LccModification lccModification = new LccModification(modificationInfos); + LccModification lccModification = (LccModification) modificationInfos.toModification(); lccModification.apply(networkWithoutExt); ShuntCompensator shuntCompensator1 = networkWithoutExt.getShuntCompensator("shuntId1"); diff --git a/src/test/java/org/gridsuite/modification/modifications/MoveVoltageLevelFeederBaysTest.java b/src/test/java/org/gridsuite/modification/modifications/MoveVoltageLevelFeederBaysTest.java index 28ae58d9..f6190e74 100644 --- a/src/test/java/org/gridsuite/modification/modifications/MoveVoltageLevelFeederBaysTest.java +++ b/src/test/java/org/gridsuite/modification/modifications/MoveVoltageLevelFeederBaysTest.java @@ -270,10 +270,10 @@ void testConnectablePositionModificationOnSide1() { .connectionPosition(21) .connectionDirection(ConnectablePosition.Direction.BOTTOM) .build(); - MoveVoltageLevelFeederBays moveVoltageLevelFeederBays = new MoveVoltageLevelFeederBays(MoveVoltageLevelFeederBaysInfos.builder() + MoveVoltageLevelFeederBays moveVoltageLevelFeederBays = (MoveVoltageLevelFeederBays) MoveVoltageLevelFeederBaysInfos.builder() .voltageLevelId("v1") .feederBays(List.of(moveFeederBayInfos)) - .build()); + .build().toModification(); moveVoltageLevelFeederBays.apply(network); Line line = network.getLine("line2"); assertNotNull(line); diff --git a/src/test/java/org/gridsuite/modification/modifications/TwoWindingsTransformerModificationTest.java b/src/test/java/org/gridsuite/modification/modifications/TwoWindingsTransformerModificationTest.java index aa3896ab..bc569f5e 100644 --- a/src/test/java/org/gridsuite/modification/modifications/TwoWindingsTransformerModificationTest.java +++ b/src/test/java/org/gridsuite/modification/modifications/TwoWindingsTransformerModificationTest.java @@ -256,7 +256,7 @@ protected void checkModification() { twtModificationInfos6.getRatioTapChanger().setTerminalRefConnectableVlId(new AttributeModification<>(null, OperationType.UNSET)); twtModificationInfos6.getRatioTapChanger().setTerminalRefConnectableType(new AttributeModification<>(null, OperationType.UNSET)); assertDoesNotThrow(() -> twtModificationInfos6.toModification().check(getNetwork())); - assertTrue(((TwoWindingsTransformerModification) twtModificationInfos6.toModification()).characteristicsModified(twtModificationInfos6)); + assertTrue(((TwoWindingsTransformerModification) twtModificationInfos6.toModification()).characteristicsModified()); // do not throw TwoWindingsTransformerModificationInfos twtModificationInfos7 = (TwoWindingsTransformerModificationInfos) buildModification(); @@ -529,7 +529,7 @@ private void changeConnectionState(TwoWindingsTransformer existingEquipment, Two // change not applied assertThat(terminal.isConnected()).isNotEqualTo(expectedState); assertThat(exception.getMessage()).isEqualTo(errorMessage); - assertFalse(twoWindingsTransformerModification.characteristicsModified(modificationInfos)); + assertFalse(twoWindingsTransformerModification.characteristicsModified()); } else { modificationInfos.toModification().apply(getNetwork()); // connection state has changed as expected @@ -1116,4 +1116,3 @@ void testMeasurementValidityPropertyForTransformer() { assertEquals("1", reactivePowerMeasurement.getProperty("validity")); } } - diff --git a/src/test/java/org/gridsuite/modification/modifications/VoltageLevelTopologyModificationTest.java b/src/test/java/org/gridsuite/modification/modifications/VoltageLevelTopologyModificationTest.java index 8db2e49f..295cc8d1 100644 --- a/src/test/java/org/gridsuite/modification/modifications/VoltageLevelTopologyModificationTest.java +++ b/src/test/java/org/gridsuite/modification/modifications/VoltageLevelTopologyModificationTest.java @@ -112,7 +112,7 @@ private void testCheckWithVoltageLevelNotFound() { .equipmentAttributeModificationList(List.of()) .build(); - VoltageLevelTopologyModification voltageLevelTopologyModification = new VoltageLevelTopologyModification(modificationInfos); + VoltageLevelTopologyModification voltageLevelTopologyModification = (VoltageLevelTopologyModification) modificationInfos.toModification(); applyModification(voltageLevelTopologyModification); Network network = getNetwork(); NetworkModificationException exception = assertThrows(NetworkModificationException.class, () -> voltageLevelTopologyModification.check(network)); @@ -128,7 +128,7 @@ private void testCheckWithEmptyEquipmentAttributeModifications() { .equipmentAttributeModificationList(emptyEquipmentAttributeModifications) .build(); - VoltageLevelTopologyModification voltageLevelTopologyModification = new VoltageLevelTopologyModification(modificationInfos); + VoltageLevelTopologyModification voltageLevelTopologyModification = (VoltageLevelTopologyModification) modificationInfos.toModification(); Network network = getNetwork(); NetworkModificationException exception = assertThrows(NetworkModificationException.class, () -> voltageLevelTopologyModification.check(network)); @@ -152,7 +152,7 @@ private void testCheckWithEquipmentAttributeNotFound() { .equipmentAttributeModificationList(equipmentAttributeModifications) .build(); - VoltageLevelTopologyModification voltageLevelTopologyModification = new VoltageLevelTopologyModification(modificationInfos); + VoltageLevelTopologyModification voltageLevelTopologyModification = (VoltageLevelTopologyModification) modificationInfos.toModification(); Network network = getNetwork(); NetworkModificationException exception = assertThrows(NetworkModificationException.class, () -> voltageLevelTopologyModification.check(network)); diff --git a/src/test/java/org/gridsuite/modification/modifications/VscModificationTest.java b/src/test/java/org/gridsuite/modification/modifications/VscModificationTest.java index 2d929e6e..7bb0afc5 100644 --- a/src/test/java/org/gridsuite/modification/modifications/VscModificationTest.java +++ b/src/test/java/org/gridsuite/modification/modifications/VscModificationTest.java @@ -205,7 +205,7 @@ void testCreateAngleDroopActivePowerControlWithEnabling() throws Exception { Network networkWithoutExt = NetworkCreation.createWithVSC(networkuuid, false); VscModificationInfos modificationInfos = (VscModificationInfos) buildModification(); modificationInfos.setAngleDroopActivePowerControl(new AttributeModification<>(true, OperationType.SET)); - VscModification vscModification = new VscModification(modificationInfos); + VscModification vscModification = (VscModification) modificationInfos.toModification(); ReportNode subReporter = ReportNode.NO_OP; ComputationManager computationManager = new LocalComputationManager(); assertDoesNotThrow(() -> vscModification.check(networkWithoutExt)); @@ -257,7 +257,7 @@ private VscModificationInfos buildModificationWithDroopAbsentInfos(boolean isPre } private static void checkDroopWithAbsentInfos(VscModificationInfos modificationInfos, Network networkWithoutExt) { - VscModification vscModification = new VscModification(modificationInfos); + VscModification vscModification = (VscModification) modificationInfos.toModification(); String message = assertThrows(NetworkModificationException.class, () -> vscModification.check(networkWithoutExt)) .getMessage(); @@ -273,7 +273,7 @@ void testNotCreateAngleDroopActivePowerControl() throws Exception { modificationInfos.setAngleDroopActivePowerControl(null); modificationInfos.setDroop(null); modificationInfos.setP0(null); - VscModification vscModification = new VscModification(modificationInfos); + VscModification vscModification = (VscModification) modificationInfos.toModification(); ReportNode subReporter = ReportNode.NO_OP; ComputationManager computationManager = new LocalComputationManager(); assertDoesNotThrow(() -> vscModification.check(networkWithExt)); @@ -292,7 +292,7 @@ void testNotChangeAngleDroopActivePowerControl() throws Exception { modificationInfos.setAngleDroopActivePowerControl(null); modificationInfos.setDroop(null); modificationInfos.setP0(null); - VscModification vscModification = new VscModification(modificationInfos); + VscModification vscModification = (VscModification) modificationInfos.toModification(); ReportNode subReporter = ReportNode.NO_OP; ComputationManager computationManager = new LocalComputationManager(); assertDoesNotThrow(() -> vscModification.check(networkWithExt)); @@ -313,7 +313,7 @@ void testChangeAngleDroopActivePowerControl() throws Exception { modificationInfos.setAngleDroopActivePowerControl(new AttributeModification<>(false, OperationType.SET)); modificationInfos.setDroop(new AttributeModification<>(2.F, OperationType.SET)); modificationInfos.setP0(new AttributeModification<>(6F, OperationType.SET)); - VscModification vscModification = new VscModification(modificationInfos); + VscModification vscModification = (VscModification) modificationInfos.toModification(); ReportNode subReporter = ReportNode.NO_OP; ComputationManager computationManager = new LocalComputationManager(); assertDoesNotThrow(() -> vscModification.check(networkWithExt)); @@ -335,7 +335,7 @@ void testDtoContainRequiredData() { var networkuuid = UUID.randomUUID(); Network networkWitoutExt = NetworkCreation.createWithVSC(networkuuid, true); - VscModification vscModification = new VscModification(modificationInfos); + VscModification vscModification = (VscModification) modificationInfos.toModification(); assertThrows(NetworkModificationException.class, () -> vscModification.check(networkWitoutExt)); } @@ -359,7 +359,7 @@ void testModifyOperatorActiveRange() throws Exception { .add(); ReportNode subReporter = ReportNode.NO_OP; ComputationManager computationManager = new LocalComputationManager(); - VscModification vscModification = new VscModification(modificationInfos); + VscModification vscModification = (VscModification) modificationInfos.toModification(); assertDoesNotThrow(() -> vscModification.check(networkWithExt)); vscModification.apply(networkWithExt, true, computationManager, subReporter); var hvdcOperatorActivePowerRange = hvdcLine.getExtension(HvdcOperatorActivePowerRange.class); @@ -374,7 +374,7 @@ void testNoChangeOnConverterStation() throws Exception { Network networkWithExt = NetworkCreation.createWithVSC(networkuuid, true); VscModificationInfos modificationInfos = (VscModificationInfos) buildModification(); modificationInfos.setConverterStation1(emptyConverterStation); // no change on converter station - VscModification vscModification = new VscModification(modificationInfos); + VscModification vscModification = (VscModification) modificationInfos.toModification(); ReportNode subReporter = ReportNode.NO_OP; ComputationManager computationManager = new LocalComputationManager(); assertDoesNotThrow(() -> vscModification.check(networkWithExt));