Adding doctrine costs configuration for redispatching, load shedding and losses (#191)

* [IMG-2475] Generator doctrine cost

Signed-off-by: marifunf <[email protected]>

* [IMG-2475] Load doctrine cost

Signed-off-by: marifunf <[email protected]>

* [IMG-2475] Losses doctrine cost

Signed-off-by: marifunf <[email protected]>

* [IMG-2475] Doctrine cost tests

Signed-off-by: marifunf <[email protected]>

* [IMG-2475] MetrixVariable addings

Signed-off-by: marifunf <[email protected]>

* test with no output modification

Signed-off-by: Nicolas Rol <[email protected]>

* add check for non-null object

Signed-off-by: Nicolas Rol <[email protected]>

* [IMG-2475] Add some doc

Signed-off-by: marifunf <[email protected]>

* [IMG-2475] Add some doc

Signed-off-by: marifunf <[email protected]>

* [IMG-2475] add comment on doctrine costs

Signed-off-by: marifunf <[email protected]>

---------

Signed-off-by: marifunf <[email protected]>
Signed-off-by: Nicolas Rol <[email protected]>
Co-authored-by: Nicolas Rol <[email protected]>

Author: marifunf

Diff for: docs/metrix.md

@@ -233,14 +233,18 @@ If no generator is configured to be managed by Metrix, then all generators are i
 Note that Metrix will take into account the Pmin and Pmax values of generators (which can be modified through the mapping script).
 In the same way than most parameters, the value can be a fixed integer/float or a time series name.
 
+Doctrine costs can be defined for postprocessing purpose (up and down redispatching and costs timeseries)
+
 The syntax to define a managed generator is:
 
 ```groovy
 generator(id) { // id of the generator which will be managed by Metrix 
   adequacyDownCosts 'ts_cost_down' // Cost of ramping down for the adequacy phase (here a time series name is used) 
   adequacyUpCosts 'ts_cost_up' // Cost of ramping up for the adequacy phase (here a time series name is used) 
-  redispatchingDownCosts 10 // Cost of ramping down (preventive) for the OPF simulation (here a fixed value is used)
-  redispatchingUpCosts 100 // Cost of ramping up (preventive) for the OPF simulation (here a fixed value is used)
+  redispatchingDownCosts 10 // Cost of ramping down for the OPF simulation (here a fixed value is used)
+  redispatchingUpCosts 100 // Cost of ramping up for the OPF simulation (here a fixed value is used)
+  redispatchingDownDoctrineCosts 10 // Doctrine cost of ramping down for the OPF simulation (fixed value or time series name)
+  redispatchingUpDoctrineCosts 100 // Doctrine cost of ramping up for the OPF simulation (fixed value or time series name)
   onContingencies 'a','b' // list of contingencies where Metrix can use this generator in (curative) remedial actions
 }
 ```
@@ -301,6 +305,8 @@ for (g in network.generators) {
 
 Similarly to generators, loads can be adjusted in the OPF simulation (in preventive and curative mode), but only as a decrease. The cost in preventive action is fixed (default 13000 €/MWh) and can be modified in the global parameters with the keyword `lossOfLoadCost`. We can also override this value for specific loads. The specified cost will automatically be weighted with the contingency probability (default : 10^-3). We can also limit the maximum percentage of load shedding (in preventive and curative mode).
 
+Doctrine costs can be defined for postprocessing purpose (load shedding costs timeseries)
+
 Here is the corresponding syntax:
 ```groovy
 load(load_id) {
@@ -309,6 +315,8 @@ load(load_id) {
     curativeSheddingPercentage 10 // optional shedding max percentage for curative actions
     curativeSheddingCost 40 // optional cost for curative shedding action
     onContingencies 'a', 'b' // optional contingency upon which curative action are operated 
+    preventiveSheddingDoctrineCost 10000 // doctrine cost for preventive shedding action (fixed value or time series name)
+    curativeSheddingDoctrineCost 'ts_doctrine_cost' // doctrine cost for curative shedding action (fixed value or time series name)
 }
 ```
 
@@ -348,6 +356,16 @@ Control types:
 - `OPTIMIZED`: can optimize the p0 target in adequacy phase and preventive (and curative if contingencies were defined)
 - `FIXED`: the target p0 is fixed
 
+### Losses
+
+Doctrine costs can be defined for postprocessing purpose (global losses cost time series)
+
+```groovy
+losses() {
+  costs 'ts_losses_cost' // Losses cost (fixed value or time series name)
+}
+```
+
 ### Monitored sections
 
 It is possible to monitor a constraint on a weighted sum of a set of branch flows:

Diff for: metrix-integration/src/main/groovy/com/powsybl/metrix/integration/GeneratorData.groovy

@@ -22,6 +22,8 @@ class GeneratorData {
     Object adequacyDownCosts
     Object redispatchingUpCosts
     Object redispatchingDownCosts
+    Object redispatchingUpDoctrineCosts
+    Object redispatchingDownDoctrineCosts
 
     void adequacyUpCosts(Object timeSeriesNames) {
         this.adequacyUpCosts = timeSeriesNames
@@ -39,6 +41,14 @@ class GeneratorData {
         this.redispatchingDownCosts = timeSeriesNames
     }
 
+    void redispatchingUpDoctrineCosts(Object timeSeriesNames) {
+        this.redispatchingUpDoctrineCosts = timeSeriesNames
+    }
+
+    void redispatchingDownDoctrineCosts(Object timeSeriesNames) {
+        this.redispatchingDownDoctrineCosts = timeSeriesNames
+    }
+
     void onContingencies(String[] contingencies) {
         this.onContingencies = contingencies
     }
@@ -47,6 +57,62 @@ class GeneratorData {
         this.onContingencies = onContingencies
     }
 
+    /**
+     * Set the generator available for adequacy when up and down adequacy costs are defined
+     */
+    private static generatorForAdequacy(String id, GeneratorData spec, TimeSeriesMappingConfigLoader configLoader, MetrixDslData data, LogDslLoader logDslLoader) {
+        if (spec.adequacyUpCosts != null || spec.adequacyDownCosts != null) {
+            if (spec.adequacyUpCosts != null && spec.adequacyDownCosts != null) {
+                configLoader.addEquipmentTimeSeries(spec.adequacyDownCosts, MetrixVariable.OFF_GRID_COST_DOWN, id)
+                configLoader.addEquipmentTimeSeries(spec.adequacyUpCosts, MetrixVariable.OFF_GRID_COST_UP, id)
+                data.addGeneratorForAdequacy(id)
+            } else if (spec.adequacyUpCosts == null) {
+                logDslLoader.logDebug("generator %s is missing adequacy up-cost time-series to be properly configured", id)
+            } else {
+                logDslLoader.logDebug("generator %s is missing adequacy down-cost time-series to be properly configured", id)
+            }
+        }
+    }
+
+    /**
+     * Set the generator available for redispatching when up and down redispatching costs are defined
+     */
+    private static boolean generatorForRedispatching(String id, GeneratorData spec, TimeSeriesMappingConfigLoader configLoader, MetrixDslData data, LogDslLoader logDslLoader) {
+        if (spec.redispatchingUpCosts != null || spec.redispatchingDownCosts != null) {
+            if (spec.redispatchingUpCosts != null && spec.redispatchingDownCosts != null) {
+                configLoader.addEquipmentTimeSeries(spec.redispatchingDownCosts, MetrixVariable.ON_GRID_COST_DOWN, id)
+                configLoader.addEquipmentTimeSeries(spec.redispatchingUpCosts, MetrixVariable.ON_GRID_COST_UP, id)
+                data.addGeneratorForRedispatching(id, spec.onContingencies)
+                return true
+            } else if (spec.redispatchingUpCosts == null) {
+                logDslLoader.logDebug("generator %s is missing redispatching up-cost time-series to be properly configured", id)
+            } else {
+                logDslLoader.logDebug("generator %s is missing redispatching down-cost time-series to be properly configured", id)
+            }
+        }
+        return false
+    }
+
+    /**
+     * Define up and down redispatching doctrine costs when generator is available for redispatching
+     */
+    private static generatorRedispatchingDoctrineCosts(String id, GeneratorData spec, TimeSeriesMappingConfigLoader configLoader, LogDslLoader logDslLoader) {
+        if (spec.redispatchingUpDoctrineCosts == null && spec.redispatchingDownDoctrineCosts == null) {
+            logDslLoader.logWarn("generator %s is missing redispatching doctrine cost to be properly configured", id)
+            return
+        }
+        if (spec.redispatchingUpDoctrineCosts == null) {
+            logDslLoader.logWarn("generator %s is missing redispatching doctrine up cost to be properly configured", id)
+            return
+        }
+        if (spec.redispatchingDownDoctrineCosts == null) {
+            logDslLoader.logWarn("generator %s is missing redispatching doctrine down cost to be properly configured", id)
+            return
+        }
+        configLoader.addEquipmentTimeSeries(spec.redispatchingDownDoctrineCosts, MetrixVariable.ON_GRID_DOCTRINE_COST_DOWN, id)
+        configLoader.addEquipmentTimeSeries(spec.redispatchingUpDoctrineCosts, MetrixVariable.ON_GRID_DOCTRINE_COST_UP, id)
+    }
+
     protected static generatorData(Closure closure, String id, Network network, TimeSeriesMappingConfigLoader configLoader, MetrixDslData data, LogDslLoader logDslLoader) {
         Identifiable identifiable = network.getGenerator(id)
         if (identifiable == null) {
@@ -57,27 +123,10 @@ class GeneratorData {
         GeneratorData spec = generatorData(closure)
 
         if (spec) {
-            if (spec.adequacyUpCosts != null || spec.adequacyDownCosts != null) {
-                if (spec.adequacyUpCosts != null && spec.adequacyDownCosts != null) {
-                    configLoader.addEquipmentTimeSeries(spec.adequacyDownCosts, MetrixVariable.OFF_GRID_COST_DOWN, id)
-                    configLoader.addEquipmentTimeSeries(spec.adequacyUpCosts, MetrixVariable.OFF_GRID_COST_UP, id)
-                    data.addGeneratorForAdequacy(id)
-                } else if (spec.adequacyUpCosts == null) {
-                    logDslLoader.logDebug("generator %s is missing adequacy up-cost time-series to be properly configured", id)
-                } else {
-                    logDslLoader.logDebug("generator %s is missing adequacy down-cost time-series to be properly configured", id)
-                }
-            }
-            if (spec.redispatchingUpCosts != null || spec.redispatchingDownCosts != null) {
-                if (spec.redispatchingUpCosts != null && spec.redispatchingDownCosts != null) {
-                    configLoader.addEquipmentTimeSeries(spec.redispatchingDownCosts, MetrixVariable.ON_GRID_COST_DOWN, id)
-                    configLoader.addEquipmentTimeSeries(spec.redispatchingUpCosts, MetrixVariable.ON_GRID_COST_UP, id)
-                    data.addGeneratorForRedispatching(id, spec.onContingencies)
-                } else if (spec.redispatchingUpCosts == null) {
-                    logDslLoader.logDebug("generator %s is missing redispatching up-cost time-series to be properly configured", id)
-                } else {
-                    logDslLoader.logDebug("generator %s is missing redispatching down-cost time-series to be properly configured", id)
-                }
+            generatorForAdequacy(id, spec, configLoader, data, logDslLoader)
+            boolean isGeneratorAvailableForRedispatching = generatorForRedispatching(id, spec, configLoader, data, logDslLoader)
+            if (isGeneratorAvailableForRedispatching) {
+                generatorRedispatchingDoctrineCosts(id, spec, configLoader, logDslLoader)
             }
         }
     }

Diff for: metrix-integration/src/main/groovy/com/powsybl/metrix/integration/LoadData.groovy

@@ -20,8 +20,10 @@ class LoadData {
     List<String> onContingencies
     Integer preventiveSheddingPercentage
     Float preventiveSheddingCost
+    Object preventiveSheddingDoctrineCost
     Integer curativeSheddingPercentage
     Object curativeSheddingCost
+    Object curativeSheddingDoctrineCost
 
     void preventiveSheddingPercentage(int percent) {
         this.preventiveSheddingPercentage = percent
@@ -31,6 +33,10 @@ class LoadData {
         this.preventiveSheddingCost = loadSheddingCost
     }
 
+    void preventiveSheddingDoctrineCost(Object timeSeriesNames) {
+        this.preventiveSheddingDoctrineCost = timeSeriesNames
+    }
+
     void curativeSheddingPercentage(int percent) {
         this.curativeSheddingPercentage = percent
     }
@@ -39,6 +45,10 @@ class LoadData {
         this.curativeSheddingCost = timeSeriesName
     }
 
+    void curativeSheddingDoctrineCost(Object timeSeriesName) {
+        this.curativeSheddingDoctrineCost = timeSeriesName
+    }
+
     void onContingencies(String[] onContingencies) {
         this.onContingencies = onContingencies
     }
@@ -47,15 +57,7 @@ class LoadData {
         this.onContingencies = onContingencies
     }
 
-    protected static loadData(Closure closure, String id, Network network, TimeSeriesMappingConfigLoader configLoader, MetrixDslData data, LogDslLoader logDslLoader) {
-        Identifiable identifiable = network.getLoad(id)
-        if (identifiable == null) {
-            logDslLoader.logWarn("load id %s not found in the network", id)
-            return
-        }
-
-        LoadData loadSpec = loadData(closure)
-
+    private static boolean loadForPreventiveShedding(String id, LoadData loadSpec, MetrixDslData data, LogDslLoader logDslLoader) {
         if (loadSpec.preventiveSheddingPercentage != null) {
             if (loadSpec.preventiveSheddingPercentage > 100 || loadSpec.preventiveSheddingPercentage < 0) {
                 logDslLoader.logWarn("preventive shedding percentage for load %s is not valid", id)
@@ -64,21 +66,63 @@ class LoadData {
                 if (loadSpec.preventiveSheddingCost != null) {
                     data.addPreventiveLoadCost(id, loadSpec.preventiveSheddingCost)
                 }
+                return true
             }
         }
+        return false
+    }
+
+    private static void loadPreventiveSheddingDoctrineCosts(String id, LoadData loadSpec, TimeSeriesMappingConfigLoader configLoader, LogDslLoader logDslLoader) {
+        if (loadSpec.preventiveSheddingDoctrineCost == null) {
+            logDslLoader.logWarn("load %s is missing preventive shedding doctrine cost to be properly configured", id)
+            return
+        }
+        configLoader.addEquipmentTimeSeries(loadSpec.preventiveSheddingDoctrineCost, MetrixVariable.PREVENTIVE_DOCTRINE_COST_DOWN, id)
+    }
 
+    private static boolean loadForCurativeShedding(String id, LoadData loadSpec, TimeSeriesMappingConfigLoader configLoader, MetrixDslData data, LogDslLoader logDslLoader) {
         if (loadSpec.curativeSheddingPercentage || loadSpec.curativeSheddingCost != null || loadSpec.onContingencies) {
             if (loadSpec.curativeSheddingPercentage && loadSpec.curativeSheddingCost != null && loadSpec.onContingencies) {
                 if (loadSpec.curativeSheddingPercentage > 100 || loadSpec.curativeSheddingPercentage < 0) {
                     logDslLoader.logWarn("curative shedding percentage for load %s is not valid", id)
                 } else {
                     configLoader.addEquipmentTimeSeries(loadSpec.curativeSheddingCost, MetrixVariable.CURATIVE_COST_DOWN, id)
                     data.addCurativeLoad(id, loadSpec.curativeSheddingPercentage, loadSpec.onContingencies)
+                    return true
                 }
             } else {
                 logDslLoader.logWarn("configuration error for load %s : curative costs, percentage and contingencies list must be set altogether", id)
             }
         }
+        return false
+    }
+
+    private static void loadCurativeSheddingDoctrineCosts(String id, LoadData loadSpec, TimeSeriesMappingConfigLoader configLoader, LogDslLoader logDslLoader) {
+        if (loadSpec.curativeSheddingDoctrineCost == null) {
+            logDslLoader.logWarn("load %s is missing curative shedding doctrine cost to be properly configured", id)
+            return
+        }
+        configLoader.addEquipmentTimeSeries(loadSpec.curativeSheddingDoctrineCost, MetrixVariable.CURATIVE_DOCTRINE_COST_DOWN, id)
+    }
+
+    protected static loadData(Closure closure, String id, Network network, TimeSeriesMappingConfigLoader configLoader, MetrixDslData data, LogDslLoader logDslLoader) {
+        Identifiable identifiable = network.getLoad(id)
+        if (identifiable == null) {
+            logDslLoader.logWarn("load id %s not found in the network", id)
+            return
+        }
+
+        LoadData loadSpec = loadData(closure)
+
+        boolean isLoadAvailableForPreventiveShedding = loadForPreventiveShedding(id, loadSpec, data, logDslLoader)
+        if (isLoadAvailableForPreventiveShedding) {
+            loadPreventiveSheddingDoctrineCosts(id, loadSpec, configLoader, logDslLoader)
+        }
+
+        boolean isLoadAvailableForCurativeShedding = loadForCurativeShedding(id, loadSpec, configLoader, data, logDslLoader)
+        if (isLoadAvailableForCurativeShedding) {
+            loadCurativeSheddingDoctrineCosts(id, loadSpec, configLoader, logDslLoader)
+        }
     }
 
     protected static LoadData loadData(Closure closure) {

Diff for: metrix-integration/src/main/groovy/com/powsybl/metrix/integration/LossesData.groovy

@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) 2020, RTE (http://www.rte-france.com)
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ * SPDX-License-Identifier: MPL-2.0
+ */
+package com.powsybl.metrix.integration
+
+import com.powsybl.iidm.network.Network
+import com.powsybl.metrix.mapping.LogDslLoader
+import com.powsybl.metrix.mapping.TimeSeriesMappingConfigLoader
+
+/**
+ * @author Marianne Funfrock {@literal <marianne.funfrock at rte-france.com>}
+ */
+class LossesData {
+
+    Object costs
+
+    void costs(Object timeSeriesNames) {
+        this.costs = timeSeriesNames
+    }
+
+    private static lossesDoctrineCosts(String id, LossesData spec, TimeSeriesMappingConfigLoader configLoader, LogDslLoader logDslLoader) {
+        if (spec.costs != null) {
+            configLoader.addEquipmentTimeSeries(spec.costs, MetrixVariable.LOSSES_DOCTRINE_COST, id)
+        }
+    }
+
+    protected static lossesData(Closure closure, Network network, TimeSeriesMappingConfigLoader configLoader, LogDslLoader logDslLoader) {
+        LossesData spec = lossesData(closure)
+        if (spec) {
+            lossesDoctrineCosts(network.getId(), spec, configLoader, logDslLoader)
+        }
+    }
+
+    protected static LossesData lossesData(Closure closure) {
+        def cloned = closure.clone()
+        LossesData spec = new LossesData()
+        cloned.delegate = spec
+        cloned()
+        spec
+    }
+}

Diff for: metrix-integration/src/main/groovy/com/powsybl/metrix/integration/MetrixDslDataLoader.groovy

@@ -34,6 +34,7 @@ import static LoadsBindingData.loadsBindingData
 import static ParametersData.parametersData
 import static PhaseShifterData.phaseShifterData
 import static SectionMonitoringData.sectionMonitoringData
+import static LossesData.lossesData
 
 /**
  * @author Paul Bui-Quang {@literal <paul.buiquang at rte-france.com>}
@@ -176,6 +177,11 @@ class MetrixDslDataLoader {
         binding.contingencies = { Closure<Void> closure ->
             contingenciesData(closure, data, logDslLoader)
         }
+
+        // losses
+        binding.losses = { Closure<Void> closure ->
+            lossesData(closure, network, loader, logDslLoader)
+        }
     }
 
     static MetrixDslData load(Reader reader, Network network, MetrixParameters parameters, ReadOnlyTimeSeriesStore store,

Diff for: metrix-integration/src/main/java/com/powsybl/metrix/integration/MetrixVariable.java

@@ -25,6 +25,8 @@ public enum MetrixVariable implements MappingVariable {
     OFF_GRID_COST_UP("offGridCostUp"),
     ON_GRID_COST_DOWN("onGridCostDown"),
     ON_GRID_COST_UP("onGridCostUp"),
+    ON_GRID_DOCTRINE_COST_DOWN("onGridDoctrineCostDown"),
+    ON_GRID_DOCTRINE_COST_UP("onGridDoctrineCostUp"),
     ANALYSIS_THRESHOLD_N("analysisThresholdN"),
     ANALYSIS_THRESHOLD_NK("analysisThresholdNk"),
     ANALYSIS_THRESHOLD_N_END_OR("analysisThresholdNEndOr"),
@@ -39,7 +41,10 @@ public enum MetrixVariable implements MappingVariable {
     THRESHOLD_NK_END_OR("thresholdNkEndOr"),
     THRESHOLD_ITAM_END_OR("thresholdITAMEndOr"),
     THRESHOLD_ITAM_NK_END_OR("thresholdITAMNkEndOr"),
-    CURATIVE_COST_DOWN("curativeCostDown");
+    CURATIVE_COST_DOWN("curativeCostDown"),
+    PREVENTIVE_DOCTRINE_COST_DOWN("preventiveDoctrineCostDown"),
+    CURATIVE_DOCTRINE_COST_DOWN("curativeDoctrineCostDown"),
+    LOSSES_DOCTRINE_COST("lossesDoctrineCost");
 
     protected static final String NAME = "metrix";