Add the use of frequency reserve on maxP reduction (#255)

* Add the use of frequency reserve on maxP reduction

Signed-off-by: Franck LECUYER <[email protected]>

Author: FranckLecuyer

src/main/java/org/gridsuite/modification/server/dto/GenerationDispatchInfos.java

@@ -44,6 +44,9 @@ public class GenerationDispatchInfos extends ModificationInfos {
     @Schema(description = "generators with fixed supply")
     private List<GeneratorsFilterInfos> generatorsWithFixedSupply;
 
+    @Schema(description = "generators frequency reserve")
+    private List<GeneratorsFrequencyReserveInfos> generatorsFrequencyReserve;
+
     @Override
     public GenerationDispatchEntity toEntity() {
         return new GenerationDispatchEntity(this);

src/main/java/org/gridsuite/modification/server/dto/GeneratorsFrequencyReserveInfos.java

@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2023, 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.server.dto;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+import lombok.experimental.SuperBuilder;
+
+import java.util.List;
+
+/**
+ * @author Franck Lecuyer <franck.lecuyer at rte-france.com>
+ */
+@SuperBuilder
+@NoArgsConstructor
+@AllArgsConstructor
+@Getter
+@Setter
+@Schema(description = "Generators frequency reserve infos")
+public class GeneratorsFrequencyReserveInfos {
+    @Schema(description = "generators filters")
+    private List<GeneratorsFilterInfos> generatorsFilters;
+
+    @Schema(description = "frequency reserve")
+    Double frequencyReserve;
+}

src/main/java/org/gridsuite/modification/server/entities/equipment/modification/GenerationDispatchEntity.java

@@ -12,13 +12,17 @@
 import lombok.NonNull;
 import org.gridsuite.modification.server.dto.GenerationDispatchInfos;
 import org.gridsuite.modification.server.dto.GeneratorsFilterInfos;
+import org.gridsuite.modification.server.dto.GeneratorsFrequencyReserveInfos;
 import org.gridsuite.modification.server.dto.ModificationInfos;
 import org.gridsuite.modification.server.entities.ModificationEntity;
 
+import javax.persistence.CascadeType;
 import javax.persistence.CollectionTable;
 import javax.persistence.Column;
 import javax.persistence.ElementCollection;
 import javax.persistence.Entity;
+import javax.persistence.FetchType;
+import javax.persistence.OneToMany;
 import javax.persistence.Table;
 import javax.validation.constraints.NotNull;
 import java.util.List;
@@ -47,6 +51,9 @@ public class GenerationDispatchEntity extends ModificationEntity {
     @CollectionTable(name = "generatorsWithFixedSupply")
     private List<GeneratorsFilterEmbeddable> generatorsWithFixedSupply;
 
+    @OneToMany(cascade = CascadeType.ALL, orphanRemoval = true, fetch = FetchType.LAZY)
+    private List<GeneratorsFrequencyReserveEntity> generatorsFrequencyReserve;
+
     public GenerationDispatchEntity(@NotNull GenerationDispatchInfos generationDispatchInfos) {
         super(generationDispatchInfos);
         assignAttributes(generationDispatchInfos);
@@ -61,23 +68,54 @@ public void update(@NonNull ModificationInfos modificationInfos) {
     private void assignAttributes(GenerationDispatchInfos generationDispatchInfos) {
         lossCoefficient = generationDispatchInfos.getLossCoefficient();
         defaultOutageRate = generationDispatchInfos.getDefaultOutageRate();
-        generatorsWithoutOutage = toEmbeddable(generationDispatchInfos.getGeneratorsWithoutOutage());
-        generatorsWithFixedSupply = toEmbeddable(generationDispatchInfos.getGeneratorsWithFixedSupply());
+        generatorsWithoutOutage = toEmbeddableGeneratorsFilters(generationDispatchInfos.getGeneratorsWithoutOutage());
+        generatorsWithFixedSupply = toEmbeddableGeneratorsFilters(generationDispatchInfos.getGeneratorsWithFixedSupply());
+        if (generatorsFrequencyReserve == null) {
+            generatorsFrequencyReserve = toEmbeddableGeneratorsFrequencyReserve(generationDispatchInfos.getGeneratorsFrequencyReserve());
+        } else {
+            generatorsFrequencyReserve.clear();
+            generatorsFrequencyReserve.addAll(toEmbeddableGeneratorsFrequencyReserve(generationDispatchInfos.getGeneratorsFrequencyReserve()));
+        }
     }
 
-    public static List<GeneratorsFilterEmbeddable> toEmbeddable(List<GeneratorsFilterInfos> generators) {
+    public static List<GeneratorsFilterEmbeddable> toEmbeddableGeneratorsFilters(List<GeneratorsFilterInfos> generators) {
         return generators == null ? null : generators.stream()
             .map(generator -> new GeneratorsFilterEmbeddable(generator.getId(), generator.getName()))
             .collect(Collectors.toList());
     }
 
+    public static List<GeneratorsFrequencyReserveEntity> toEmbeddableGeneratorsFrequencyReserve(List<GeneratorsFrequencyReserveInfos> generators) {
+        List<GeneratorsFrequencyReserveEntity> generatorsFrequencyReserveEntities = null;
+        if (generators != null) {
+            generatorsFrequencyReserveEntities = generators.stream().map(generator -> {
+                List<GeneratorsFilterEmbeddable> generatorsFilterEmbeddables = generator.getGeneratorsFilters().stream().map(filter ->
+                    new GeneratorsFilterEmbeddable(filter.getId(), filter.getName())).collect(Collectors.toList());
+                return new GeneratorsFrequencyReserveEntity(generatorsFilterEmbeddables, generator.getFrequencyReserve());
+            }).collect(Collectors.toList());
+        }
+        return generatorsFrequencyReserveEntities;
+    }
+
     private List<GeneratorsFilterInfos> toGeneratorsFilters(List<GeneratorsFilterEmbeddable> generatorsFilters) {
         return generatorsFilters != null ? generatorsFilters
                 .stream()
                 .map(generator -> new GeneratorsFilterInfos(generator.getId(), generator.getName()))
                 .collect(Collectors.toList()) : null;
     }
 
+    private List<GeneratorsFrequencyReserveInfos> toGeneratorsFrequencyReserve(List<GeneratorsFrequencyReserveEntity> generatorsFrequencyReserve) {
+        List<GeneratorsFrequencyReserveInfos> generatorsFrequencyReserveInfos = null;
+        if (generatorsFrequencyReserve != null) {
+            generatorsFrequencyReserveInfos = generatorsFrequencyReserve.stream()
+                .map(generator -> {
+                    List<GeneratorsFilterInfos> generatorsFilterInfos = generator.getGeneratorsFilters().stream().map(filter ->
+                        new GeneratorsFilterInfos(filter.getId(), filter.getName())).collect(Collectors.toList());
+                    return new GeneratorsFrequencyReserveInfos(generatorsFilterInfos, generator.getFrequencyReserve());
+                }).collect(Collectors.toList());
+        }
+        return generatorsFrequencyReserveInfos;
+    }
+
     @Override
     public GenerationDispatchInfos toModificationInfos() {
         return GenerationDispatchInfos.builder()
@@ -87,6 +125,7 @@ public GenerationDispatchInfos toModificationInfos() {
                 .defaultOutageRate(getDefaultOutageRate())
                 .generatorsWithoutOutage(toGeneratorsFilters(generatorsWithoutOutage))
                 .generatorsWithFixedSupply(toGeneratorsFilters(generatorsWithFixedSupply))
+                .generatorsFrequencyReserve(toGeneratorsFrequencyReserve(generatorsFrequencyReserve))
                 .build();
     }
 }

src/main/java/org/gridsuite/modification/server/entities/equipment/modification/GeneratorsFrequencyReserveEntity.java

@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 2023, 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.server.entities.equipment.modification;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+
+import javax.persistence.CollectionTable;
+import javax.persistence.Column;
+import javax.persistence.ElementCollection;
+import javax.persistence.Entity;
+import javax.persistence.GeneratedValue;
+import javax.persistence.GenerationType;
+import javax.persistence.Id;
+import javax.persistence.Table;
+import java.util.List;
+import java.util.UUID;
+
+/**
+ * @author Franck Lecuyer <franck.lecuyer at rte-france.com>
+ */
+@NoArgsConstructor
+@AllArgsConstructor
+@Getter
+@Entity
+@Table(name = "GeneratorsFrequencyReserve")
+public class GeneratorsFrequencyReserveEntity {
+    @Id
+    @GeneratedValue(strategy = GenerationType.AUTO)
+    @Column(name = "id")
+    private UUID id;
+
+    @ElementCollection
+    @CollectionTable(name = "generatorsFrequencyReserveFilters")
+    private List<GeneratorsFilterEmbeddable> generatorsFilters;
+
+    @Column(name = "frequencyReserve")
+    private double frequencyReserve;
+
+    public GeneratorsFrequencyReserveEntity(List<GeneratorsFilterEmbeddable> generatorsFilters, double frequencyReserve) {
+        this.id = null;
+        this.generatorsFilters = generatorsFilters;
+        this.frequencyReserve = frequencyReserve;
+    }
+}

src/main/java/org/gridsuite/modification/server/modifications/GenerationDispatch.java

@@ -24,6 +24,8 @@
 import com.powsybl.iidm.network.Network;
 import com.powsybl.iidm.network.extensions.GeneratorStartup;
 import com.powsybl.network.store.iidm.impl.NetworkImpl;
+import lombok.Builder;
+import lombok.Getter;
 import org.gridsuite.modification.server.NetworkModificationException;
 import org.gridsuite.modification.server.dto.FilterEquipments;
 import org.gridsuite.modification.server.dto.GenerationDispatchInfos;
@@ -42,6 +44,7 @@
 import java.util.Objects;
 import java.util.TreeSet;
 import java.util.UUID;
+import java.util.concurrent.atomic.AtomicReference;
 import java.util.function.Function;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
@@ -92,7 +95,7 @@ private static double computeTotalDemand(Component component, double lossCoeffic
         return totalLoad * (1. + lossCoefficient / 100.);
     }
 
-    private double computeTotalAmountFixedSupply(Network network, Component component, List<String> generatorsWithFixedSupply, Reporter reporter) {
+    private static double computeTotalAmountFixedSupply(Network network, Component component, List<String> generatorsWithFixedSupply, Reporter reporter) {
         double totalAmountFixedSupply = 0.;
 
         totalAmountFixedSupply += generatorsWithFixedSupply.stream().map(network::getGenerator)
@@ -116,7 +119,7 @@ private static Component getSynchronousComponentFrom(HvdcConverterStation<?> sta
         return station.getTerminal().getBusView().getBus().getSynchronousComponent();
     }
 
-    private double computeHvdcBalance(Component component) {
+    private static double computeHvdcBalance(Component component) {
         AtomicDouble balance = new AtomicDouble(0.);
 
         component.getBusStream().forEach(bus -> {
@@ -151,7 +154,7 @@ private double computeHvdcBalance(Component component) {
         return balance.get();
     }
 
-    private List<Generator> computeAdjustableGenerators(Component component, List<String> generatorsWithFixedSupply, Reporter reporter) {
+    private static List<Generator> computeAdjustableGenerators(Component component, List<String> generatorsWithFixedSupply, Reporter reporter) {
         List<Generator> res;
 
         // get all generators in the component
@@ -205,6 +208,13 @@ public void onUpdate(Identifiable identifiable, String attribute, String variant
         }
     }
 
+    @Builder
+    @Getter
+    private static class GeneratorsFrequencyReserve {
+        private final List<String> generators;
+        private final double frequencyReserve;
+    }
+
     @Override
     public void check(Network network) throws NetworkModificationException {
         double lossCoefficient = generationDispatchInfos.getLossCoefficient();
@@ -217,8 +227,8 @@ public void check(Network network) throws NetworkModificationException {
         }
     }
 
-    private List<String> exportFilters(List<GeneratorsFilterInfos> generatorsFilters,
-                                       Network network, Reporter subReporter, ApplicationContext context) {
+    private static List<String> exportFilters(List<GeneratorsFilterInfos> generatorsFilters,
+                                              Network network, Reporter subReporter, ApplicationContext context) {
         if (CollectionUtils.isEmpty(generatorsFilters)) {
             return List.of();
         }
@@ -263,7 +273,27 @@ private List<String> collectGeneratorsWithFixedSupply(Network network, Reporter
         return exportFilters(generationDispatchInfos.getGeneratorsWithFixedSupply(), network, subReporter, context);
     }
 
-    private double reduceGeneratorMaxPValue(Generator generator, List<String> generatorsWithoutOutage) {
+    private List<GeneratorsFrequencyReserve> collectGeneratorsWithFrequencyReserve(Network network, Reporter subReporter, ApplicationContext context) {
+        return generationDispatchInfos.getGeneratorsFrequencyReserve().stream().map(g -> {
+            List<String> generators = exportFilters(g.getGeneratorsFilters(), network, subReporter, context);
+            return GeneratorsFrequencyReserve.builder().generators(generators).frequencyReserve(g.getFrequencyReserve()).build();
+        }).collect(Collectors.toList());
+    }
+
+    private static double computeGenFrequencyReserve(Generator generator,
+                                                     List<GeneratorsFrequencyReserve> generatorsFrequencyReserve) {
+        AtomicReference<Double> freqReserve = new AtomicReference<>(0.);
+        generatorsFrequencyReserve.forEach(g -> {
+            if (g.getGenerators().contains(generator.getId())) {
+                freqReserve.set(g.getFrequencyReserve());
+            }
+        });
+        return freqReserve.get();
+    }
+
+    private double reduceGeneratorMaxPValue(Generator generator,
+                                            List<String> generatorsWithoutOutage,
+                                            List<GeneratorsFrequencyReserve> generatorsFrequencyReserve) {
         double res = generator.getMaxP();
         if (!generatorsWithoutOutage.contains(generator.getId())) {
             GeneratorStartup startupExtension = generator.getExtension(GeneratorStartup.class);
@@ -275,7 +305,8 @@ private double reduceGeneratorMaxPValue(Generator generator, List<String> genera
                 res *= 1. - generationDispatchInfos.getDefaultOutageRate() / 100.;
             }
         }
-        return res;
+        double genFrequencyReserve = computeGenFrequencyReserve(generator, generatorsFrequencyReserve);
+        return res * (1. - genFrequencyReserve / 100.);
     }
 
     @Override
@@ -291,6 +322,9 @@ public void apply(Network network, Reporter subReporter, ApplicationContext cont
         // get generators with fixed supply
         List<String> generatorsWithFixedSupply = collectGeneratorsWithFixedSupply(network, subReporter, context);
 
+        // get generators with frequency reserve
+        List<GeneratorsFrequencyReserve> generatorsWithFrequencyReserve = collectGeneratorsWithFrequencyReserve(network, subReporter, context);
+
         for (Component component : synchronousComponents) {
             int componentNum = component.getNum();
 
@@ -331,7 +365,7 @@ public void apply(Network network, Reporter subReporter, ApplicationContext cont
                 // stacking of adjustable generators to ensure the totalAmountSupplyToBeDispatched
                 List<Scalable> generatorsScalable = adjustableGenerators.stream().map(generator -> {
                     double minValue = generator.getMinP();
-                    double maxValue = reduceGeneratorMaxPValue(generator, generatorsWithoutOutage);
+                    double maxValue = reduceGeneratorMaxPValue(generator, generatorsWithoutOutage, generatorsWithFrequencyReserve);
                     return (Scalable) Scalable.onGenerator(generator.getId(), minValue, maxValue);
                 }).collect(Collectors.toList());
 

src/main/resources/db/changelog/changesets/changelog_20230522T130120Z.xml

@@ -0,0 +1,42 @@
+<?xml version="1.1" encoding="UTF-8" standalone="no"?>
+<databaseChangeLog xmlns="http://www.liquibase.org/xml/ns/dbchangelog" xmlns:ext="http://www.liquibase.org/xml/ns/dbchangelog-ext" xmlns:pro="http://www.liquibase.org/xml/ns/pro" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog-ext http://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-ext.xsd http://www.liquibase.org/xml/ns/pro http://www.liquibase.org/xml/ns/pro/liquibase-pro-4.1.xsd http://www.liquibase.org/xml/ns/dbchangelog http://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-4.1.xsd">
+    <changeSet author="lecuyerfra (generated)" id="1684760502004-5">
+        <createTable tableName="generation_dispatch_generators_frequency_reserve">
+            <column name="generation_dispatch_entity_id" type="UUID">
+                <constraints nullable="false"/>
+            </column>
+            <column name="generators_frequency_reserve_id" type="UUID">
+                <constraints nullable="false"/>
+            </column>
+        </createTable>
+    </changeSet>
+    <changeSet author="lecuyerfra (generated)" id="1684760502004-6">
+        <createTable tableName="generators_frequency_reserve">
+            <column name="id" type="UUID">
+                <constraints nullable="false" primaryKey="true" primaryKeyName="generators_frequency_reservePK"/>
+            </column>
+            <column name="frequency_reserve" type="FLOAT8"/>
+        </createTable>
+    </changeSet>
+    <changeSet author="lecuyerfra (generated)" id="1684760502004-7">
+        <createTable tableName="generators_frequency_reserve_filters">
+            <column name="generators_frequency_reserve_entity_id" type="UUID">
+                <constraints nullable="false"/>
+            </column>
+            <column name="filter_id" type="UUID"/>
+            <column name="filter_name" type="VARCHAR(255)"/>
+        </createTable>
+    </changeSet>
+    <changeSet author="lecuyerfra (generated)" id="1684760502004-8">
+        <addUniqueConstraint columnNames="generators_frequency_reserve_id" constraintName="UK_qsdphctot5lvye9dxd908nxqe" tableName="generation_dispatch_generators_frequency_reserve"/>
+    </changeSet>
+    <changeSet author="lecuyerfra (generated)" id="1684760502004-9">
+        <addForeignKeyConstraint baseColumnNames="generators_frequency_reserve_id" baseTableName="generation_dispatch_generators_frequency_reserve" constraintName="FK3knktj1ylaintk61vnhhkdl08" deferrable="false" initiallyDeferred="false" referencedColumnNames="id" referencedTableName="generators_frequency_reserve" validate="true"/>
+    </changeSet>
+    <changeSet author="lecuyerfra (generated)" id="1684760502004-10">
+        <addForeignKeyConstraint baseColumnNames="generation_dispatch_entity_id" baseTableName="generation_dispatch_generators_frequency_reserve" constraintName="FK6b4as01ter3mb9m8ry5cl7gw8" deferrable="false" initiallyDeferred="false" referencedColumnNames="id" referencedTableName="generation_dispatch" validate="true"/>
+    </changeSet>
+    <changeSet author="lecuyerfra (generated)" id="1684760502004-11">
+        <addForeignKeyConstraint baseColumnNames="generators_frequency_reserve_entity_id" baseTableName="generators_frequency_reserve_filters" constraintName="FKg01bd3thgs9i3pshw8v7igqx6" deferrable="false" initiallyDeferred="false" referencedColumnNames="id" referencedTableName="generators_frequency_reserve" validate="true"/>
+    </changeSet>
+</databaseChangeLog>

src/main/resources/db/changelog/db.changelog-master.yaml

@@ -138,6 +138,9 @@ databaseChangeLog:
   - include:
       file: changesets/changelog_20230512T142024Z.xml
       relativeToChangelogFile: true
+  - include:
+      file: changesets/changelog_20230522T130120Z.xml
+      relativeToChangelogFile: true
   - include:
       file: changesets/changelog_20230515T143336Z.xml
       relativeToChangelogFile: true