[ANT-2300] Short-term storage: penalty for storage control, injection…

… and withdrawal flow gradient (#2491) Co-authored-by: Florian OMNES <[email protected]> Co-authored-by: Florian OMNES <[email protected]>
AntaresSimulatorTeam · Nov 27, 2024 · a7b0702 · a7b0702
1 parent 88c711a
commit a7b0702
Show file tree

Hide file tree

Showing 30 changed files with 944 additions and 86 deletions.
diff --git a/docs/user-guide/04-migration-guides.md b/docs/user-guide/04-migration-guides.md
diff --git a/src/libs/antares/study/include/antares/study/parts/short-term-storage/properties.h b/src/libs/antares/study/include/antares/study/parts/short-term-storage/properties.h
@@ -57,6 +57,9 @@ class Properties
     /// cluster name
     std::string name;
 
+    bool penalizeVariationWithdrawal = false;
+    bool penalizeVariationInjection = false;
+
     /// Enabled ?
     bool enabled = true;
 

diff --git a/src/libs/antares/study/include/antares/study/parts/short-term-storage/series.h b/src/libs/antares/study/include/antares/study/parts/short-term-storage/series.h
@@ -26,9 +26,11 @@
 
 namespace Antares::Data::ShortTermStorage
 {
+
 class Series
 {
 public:
+    Series() = default;
     // check if series values are valid
     bool validate(const std::string& id = "") const;
 
@@ -47,6 +49,8 @@ class Series
     std::vector<double> costInjection;
     std::vector<double> costWithdrawal;
     std::vector<double> costLevel;
+    std::vector<double> costVariationInjection;
+    std::vector<double> costVariationWithdrawal;
 
 private:
     bool validateSizes(const std::string&) const;

diff --git a/src/libs/antares/study/parts/short-term-storage/properties.cpp b/src/libs/antares/study/parts/short-term-storage/properties.cpp
@@ -89,6 +89,16 @@ bool Properties::loadKey(const IniFile::Property* p)
         return true;
     }
 
+    if (p->key == "penalize-variation-withdrawal")
+    {
+        return p->value.to<bool>(this->penalizeVariationWithdrawal);
+    }
+
+    if (p->key == "penalize-variation-injection")
+    {
+        return p->value.to<bool>(this->penalizeVariationInjection);
+    }
+
     if (p->key == "enabled")
     {
         return p->value.to<bool>(this->enabled);
@@ -111,6 +121,8 @@ void Properties::save(IniFile& ini) const
     s->add("efficiency", this->injectionEfficiency);
     s->add("efficiencyWithdrawal", this->withdrawalEfficiency);
     s->add("initialleveloptim", this->initialLevelOptim);
+    s->add("penalize-variation-injection", this->penalizeVariationInjection);
+    s->add("penalize-variation-withdrawal", this->penalizeVariationWithdrawal);
     s->add("enabled", this->enabled);
 }
 

diff --git a/src/libs/antares/study/parts/short-term-storage/series.cpp b/src/libs/antares/study/parts/short-term-storage/series.cpp
@@ -49,6 +49,10 @@ bool Series::loadFromFolder(const fs::path& folder)
     ret = loadFile(folder / "cost-withdrawal.txt", costWithdrawal) && ret;
     ret = loadFile(folder / "cost-level.txt", costLevel) && ret;
 
+    ret = loadFile(folder / "cost-variation-injection.txt", costVariationInjection) && ret;
+
+    ret = loadFile(folder / "cost-variation-withdrawal.txt", costVariationWithdrawal) && ret;
+
     return ret;
 }
 
@@ -122,6 +126,10 @@ void Series::fillDefaultSeriesIfEmpty()
     fillIfEmpty(costInjection, 0.0);
     fillIfEmpty(costWithdrawal, 0.0);
     fillIfEmpty(costLevel, 0.0);
+
+    fillIfEmpty(costVariationInjection, 0.0);
+
+    fillIfEmpty(costVariationWithdrawal, 0.0);
 }
 
 bool Series::saveToFolder(const std::string& folder) const
@@ -148,6 +156,9 @@ bool Series::saveToFolder(const std::string& folder) const
     checkWrite("cost-withdrawal.txt", costWithdrawal);
     checkWrite("cost-level.txt", costLevel);
 
+    checkWrite("cost-variation-injection.txt", costVariationInjection);
+    checkWrite("cost-variation-withdrawal.txt", costVariationWithdrawal);
+
     return ret;
 }
 
@@ -215,7 +226,9 @@ bool Series::validateSizes(const std::string& id) const
            && checkSize("upper-rule-curve.txt", id, upperRuleCurve)
            && checkSize("cost-injection.txt", id, costInjection)
            && checkSize("cost-withdrawal.txt", id, costWithdrawal)
-           && checkSize("cost-level.txt", id, costLevel);
+           && checkSize("cost-level.txt", id, costLevel)
+           && checkSize("cost-variation-injection.txt", id, costVariationInjection)
+           && checkSize("cost-variation-withdrawal.txt", id, costVariationWithdrawal);
 }
 
 bool Series::validateMaxInjection(const std::string& id) const

diff --git a/src/solver/optimisation/CMakeLists.txt b/src/solver/optimisation/CMakeLists.txt
@@ -81,6 +81,12 @@ set(RTESOLVER_OPT
         constraints/FictitiousLoad.cpp
         include/antares/solver/optimisation/constraints/ShortTermStorageLevel.h
         constraints/ShortTermStorageLevel.cpp
+        include/antares/solver/optimisation/constraints/ShortTermStorageCostVariation.h
+        constraints/ShortTermStorageCostVariation.cpp
+        constraints/ShortTermStorageCostVariationInjectionForward.cpp
+        constraints/ShortTermStorageCostVariationInjectionBackward.cpp
+        constraints/ShortTermStorageCostVariationWithdrawalForward.cpp
+        constraints/ShortTermStorageCostVariationWithdrawalBackward.cpp
         include/antares/solver/optimisation/constraints/FlowDissociation.h
         constraints/FlowDissociation.cpp
         include/antares/solver/optimisation/constraints/BindingConstraintHour.h

diff --git a/src/solver/optimisation/constraints/ConstraintBuilder.cpp b/src/solver/optimisation/constraints/ConstraintBuilder.cpp
@@ -97,15 +97,23 @@ ConstraintBuilder& ConstraintBuilder::IntercoIndirectCost(unsigned int index, do
     return *this;
 }
 
-ConstraintBuilder& ConstraintBuilder::ShortTermStorageInjection(unsigned int index, double coeff)
+ConstraintBuilder& ConstraintBuilder::ShortTermStorageInjection(unsigned int index,
+                                                                double coeff,
+                                                                int offset,
+                                                                int delta)
 {
-    AddVariable(variableManager_.ShortTermStorageInjection(index, hourInWeek_), coeff);
+    AddVariable(variableManager_.ShortTermStorageInjection(index, hourInWeek_, offset, delta),
+                coeff);
     return *this;
 }
 
-ConstraintBuilder& ConstraintBuilder::ShortTermStorageWithdrawal(unsigned int index, double coeff)
+ConstraintBuilder& ConstraintBuilder::ShortTermStorageWithdrawal(unsigned int index,
+                                                                 double coeff,
+                                                                 int offset,
+                                                                 int delta)
 {
-    AddVariable(variableManager_.ShortTermStorageWithdrawal(index, hourInWeek_), coeff);
+    AddVariable(variableManager_.ShortTermStorageWithdrawal(index, hourInWeek_, offset, delta),
+                coeff);
     return *this;
 }
 
@@ -118,6 +126,28 @@ ConstraintBuilder& ConstraintBuilder::ShortTermStorageLevel(unsigned int index,
     return *this;
 }
 
+ConstraintBuilder& ConstraintBuilder::ShortTermCostVariationInjection(unsigned int index,
+                                                                      double coeff,
+                                                                      int offset,
+                                                                      int delta)
+{
+    AddVariable(
+      variableManager_.ShortTermStorageCostVariationInjection(index, hourInWeek_, offset, delta),
+      coeff);
+    return *this;
+}
+
+ConstraintBuilder& ConstraintBuilder::ShortTermCostVariationWithdrawal(unsigned int index,
+                                                                       double coeff,
+                                                                       int offset,
+                                                                       int delta)
+{
+    AddVariable(
+      variableManager_.ShortTermStorageCostVariationWithdrawal(index, hourInWeek_, offset, delta),
+      coeff);
+    return *this;
+}
+
 ConstraintBuilder& ConstraintBuilder::HydProd(unsigned int index, double coeff)
 {
     AddVariable(variableManager_.HydProd(index, hourInWeek_), coeff);

diff --git a/src/solver/optimisation/constraints/Group1.cpp b/src/solver/optimisation/constraints/Group1.cpp
@@ -21,6 +21,8 @@
 
 #include "antares/solver/optimisation/constraints/Group1.h"
 
+#include "antares/solver/optimisation/constraints/ShortTermStorageCostVariation.h"
+
 AreaBalanceData Group1::GetAreaBalanceData()
 {
     return {.CorrespondanceCntNativesCntOptim = problemeHebdo_->CorrespondanceCntNativesCntOptim,
@@ -39,7 +41,7 @@ FictitiousLoadData Group1::GetFictitiousLoadData()
             .DefaillanceNegativeUtiliserHydro = problemeHebdo_->DefaillanceNegativeUtiliserHydro};
 }
 
-ShortTermStorageLevelData Group1::GetShortTermStorageLevelData()
+ShortTermStorageData Group1::GetShortTermStorageData()
 {
     return {
       .CorrespondanceCntNativesCntOptim = problemeHebdo_->CorrespondanceCntNativesCntOptim,
@@ -72,9 +74,21 @@ void Group1::BuildConstraints()
     auto fictitiousLoadData = GetFictitiousLoadData();
     FictitiousLoad fictitiousLoad(builder_, fictitiousLoadData);
 
-    auto shortTermStorageLevelData = GetShortTermStorageLevelData();
-    ShortTermStorageLevel shortTermStorageLevel(builder_, shortTermStorageLevelData);
-
+    auto shortTermStorageData = GetShortTermStorageData();
+    ShortTermStorageLevel shortTermStorageLevel(builder_, shortTermStorageData);
+
+    ShortTermStorageCostVariationInjectionBackward shortTermStorageCostVariationInjectionBackward(
+      builder_,
+      shortTermStorageData);
+    ShortTermStorageCostVariationInjectionForward shortTermStorageCostVariationInjectionForward(
+      builder_,
+      shortTermStorageData);
+    ShortTermStorageCostVariationWithdrawalBackward shortTermStorageCostVariationWithdrawalBackward(
+      builder_,
+      shortTermStorageData);
+    ShortTermStorageCostVariationWithdrawalForward shortTermStorageCostVariationWithdrawalForward(
+      builder_,
+      shortTermStorageData);
     auto flowDissociationData = GetFlowDissociationData();
     FlowDissociation flowDissociation(builder_, flowDissociationData);
 
@@ -91,6 +105,10 @@ void Group1::BuildConstraints()
             areaBalance.add(pdt, pays);
             fictitiousLoad.add(pdt, pays);
             shortTermStorageLevel.add(pdt, pays);
+            shortTermStorageCostVariationInjectionBackward.add(pdt, pays);
+            shortTermStorageCostVariationInjectionForward.add(pdt, pays);
+            shortTermStorageCostVariationWithdrawalBackward.add(pdt, pays);
+            shortTermStorageCostVariationWithdrawalForward.add(pdt, pays);
         }
 
         for (uint32_t interco = 0; interco < problemeHebdo_->NombreDInterconnexions; interco++)

diff --git a/src/solver/optimisation/constraints/ShortTermStorageCostVariation.cpp b/src/solver/optimisation/constraints/ShortTermStorageCostVariation.cpp
@@ -0,0 +1,48 @@
+/*
+ * Copyright 2007-2024, RTE (https://www.rte-france.com)
+ * See AUTHORS.txt
+ * SPDX-License-Identifier: MPL-2.0
+ * This file is part of Antares-Simulator,
+ * Adequacy and Performance assessment for interconnected energy networks.
+ *
+ * Antares_Simulator is free software: you can redistribute it and/or modify
+ * it under the terms of the Mozilla Public Licence 2.0 as published by
+ * the Mozilla Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * Antares_Simulator is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * Mozilla Public Licence 2.0 for more details.
+ *
+ * You should have received a copy of the Mozilla Public Licence 2.0
+ * along with Antares_Simulator. If not, see <https://opensource.org/license/mpl-2-0/>.
+ */
+
+#include "antares/solver/optimisation/constraints/ShortTermStorageCostVariation.h"
+
+void ShortTermStorageCostVariation::addStorageConstraint(const std::string& constraintName,
+                                                         int pdt,
+                                                         int pays)
+{
+    ConstraintNamer namer(builder.data.NomDesContraintes);
+    const int hourInTheYear = builder.data.weekInTheYear * 168 + pdt;
+    namer.UpdateTimeStep(hourInTheYear);
+    namer.UpdateArea(builder.data.NomsDesPays[pays]);
+
+    builder.updateHourWithinWeek(pdt);
+    for (const auto& storage: data.ShortTermStorage[pays])
+    {
+        if (IsConstraintEnabled(storage))
+        {
+            namer.ShortTermStorageCostVariation(constraintName,
+                                                builder.data.nombreDeContraintes,
+                                                storage.name);
+            const auto index = storage.clusterGlobalIndex;
+
+            TargetConstraintIndex(pdt, index) = builder.data.nombreDeContraintes;
+
+            buildConstraint(index);
+        }
+    }
+}
diff --git a/src/solver/optimisation/constraints/ShortTermStorageCostVariationInjectionBackward.cpp b/src/solver/optimisation/constraints/ShortTermStorageCostVariationInjectionBackward.cpp
@@ -0,0 +1,50 @@
+/*
+** Copyright 2007-2024, RTE (https://www.rte-france.com)
+** See AUTHORS.txt
+** SPDX-License-Identifier: MPL-2.0
+** This file is part of Antares-Simulator,
+** Adequacy and Performance assessment for interconnected energy networks.
+**
+** Antares_Simulator is free software: you can redistribute it and/or modify
+** it under the terms of the Mozilla Public Licence 2.0 as published by
+** the Mozilla Foundation, either version 2 of the License, or
+** (at your option) any later version.
+**
+** Antares_Simulator is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+** Mozilla Public Licence 2.0 for more details.
+**
+** You should have received a copy of the Mozilla Public Licence 2.0
+** along with Antares_Simulator. If not, see <https://opensource.org/license/mpl-2-0/>.
+*/
+
+#include "antares/solver/optimisation/constraints/ShortTermStorageCostVariation.h"
+
+// CostVariationInjection[h] + Injection[h+1] - Injection[h]  >= 0
+void ShortTermStorageCostVariationInjectionBackward::buildConstraint(int index)
+{
+    builder.ShortTermCostVariationInjection(index, 1.0)
+      .ShortTermStorageInjection(index, -1.0)
+      .ShortTermStorageInjection(index, 1.0, 1, builder.data.NombreDePasDeTempsPourUneOptimisation)
+      .greaterThan()
+      .build();
+}
+
+void ShortTermStorageCostVariationInjectionBackward::add(unsigned int pdt, unsigned int pays)
+{
+    addStorageConstraint("ShortTermStorageCostVariationInjectionBackward", pdt, pays);
+}
+
+int& ShortTermStorageCostVariationInjectionBackward::
+  ShortTermStorageCostVariationInjectionBackward::TargetConstraintIndex(int pdt, int index)
+{
+    return data.CorrespondanceCntNativesCntOptim[pdt]
+      .ShortTermStorageCostVariationInjectionBackward[index];
+}
+
+bool ShortTermStorageCostVariationInjectionBackward::IsConstraintEnabled(
+  const ShortTermStorage::PROPERTIES& properties)
+{
+    return properties.penalizeVariationInjection;
+}
diff --git a/src/solver/optimisation/constraints/ShortTermStorageCostVariationInjectionForward.cpp b/src/solver/optimisation/constraints/ShortTermStorageCostVariationInjectionForward.cpp
@@ -0,0 +1,50 @@
+/*
+** Copyright 2007-2024, RTE (https://www.rte-france.com)
+** See AUTHORS.txt
+** SPDX-License-Identifier: MPL-2.0
+** This file is part of Antares-Simulator,
+** Adequacy and Performance assessment for interconnected energy networks.
+**
+** Antares_Simulator is free software: you can redistribute it and/or modify
+** it under the terms of the Mozilla Public Licence 2.0 as published by
+** the Mozilla Foundation, either version 2 of the License, or
+** (at your option) any later version.
+**
+** Antares_Simulator is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+** Mozilla Public Licence 2.0 for more details.
+**
+** You should have received a copy of the Mozilla Public Licence 2.0
+** along with Antares_Simulator. If not, see <https://opensource.org/license/mpl-2-0/>.
+*/
+
+#include "antares/solver/optimisation/constraints/ShortTermStorageCostVariation.h"
+
+// CostVariationInjection[h] - Injection[h+1] + Injection[h]  >= 0
+void ShortTermStorageCostVariationInjectionForward::buildConstraint(int index)
+{
+    builder.ShortTermCostVariationInjection(index, 1.0)
+      .ShortTermStorageInjection(index, 1.0)
+      .ShortTermStorageInjection(index, -1.0, 1, builder.data.NombreDePasDeTempsPourUneOptimisation)
+      .greaterThan()
+      .build();
+}
+
+void ShortTermStorageCostVariationInjectionForward::add(unsigned int pdt, unsigned int pays)
+{
+    addStorageConstraint("ShortTermStorageCostVariationInjectionForward", pdt, pays);
+}
+
+int& ShortTermStorageCostVariationInjectionForward::ShortTermStorageCostVariationInjectionForward::
+  TargetConstraintIndex(int pdt, int index)
+{
+    return data.CorrespondanceCntNativesCntOptim[pdt]
+      .ShortTermStorageCostVariationInjectionForward[index];
+}
+
+bool ShortTermStorageCostVariationInjectionForward::IsConstraintEnabled(
+  const ShortTermStorage::PROPERTIES& properties)
+{
+    return properties.penalizeVariationInjection;
+}