Feature/reserve model lot1 scalian

src/libs/antares/study/CMakeLists.txt

@@ -38,6 +38,7 @@ source_group("study\\scenario builder" FILES ${SRC_MATRIX})
 set(SRC_AREAS
         include/antares/study/area/constants.h
         include/antares/study/area/area.h
+        include/antares/study/area/capacityReservation.h
         include/antares/study/area/area.hxx
         include/antares/study/area/scratchpad.h
         area/scratchpad.cpp

src/libs/antares/study/area/list.cpp

@@ -31,6 +31,7 @@
 #include "antares/study/parts/parts.h"
 #include "antares/study/parts/load/prepro.h"
 #include <antares/study/area/scratchpad.h>
+#include <antares/study/area/capacityReservation.h>
 
 #define SEP IO::Separator
 
@@ -778,6 +779,7 @@ static bool AreaListLoadFromFolderSingleArea(Study& study,
     area.spreadSpilledEnergyCost = 0.;
 
     bool ret = true;
+    IniFile ini;
 
     // DSM, Reserves, D-1
     buffer.clear() << study.folderInput << SEP << "reserves" << SEP << area.id << ".txt";
@@ -842,6 +844,78 @@ static bool AreaListLoadFromFolderSingleArea(Study& study,
         }
     }
 
+    // Reserves
+    {
+        buffer.clear() << study.folderInput << SEP << "reserves" << SEP << area.id << SEP
+                       << "reserves.ini";
+        if (!ini.open(buffer))
+        {
+            logs.warning() << study.folderInput << SEP << "reserves" << SEP << area.id << SEP
+                           << "reserves.ini";
+            return false;
+        }
+        ini.each(
+          [&](const IniFile::Section& section)
+          {
+              if (area.allCapacityReservations.contains(section.name))
+              {
+                  logs.warning() << area.name << ": reserve name already exists for reserve "
+                                 << section.name;
+              }
+              else
+              {
+                  CapacityReservation tmpCapacityReservation;
+                  std::string file_name = AllCapacityReservations::toFilename(section.name);
+                  int type = -1;
+                  for (auto* p = section.firstProperty; p; p = p->next)
+                  {
+                      CString<30, false> tmp;
+                      tmp = p->key;
+                      tmp.toLower();
+
+                      if (tmp == "failure-cost")
+                      {
+                          if (!p->value.to<float>(tmpCapacityReservation.failureCost))
+                          {
+                              logs.warning() << area.name << ": invalid failure cost for reserve "
+                                             << section.name;
+                          }
+                      }
+                      else if (tmp == "spillage-cost")
+                      {
+                          if (!p->value.to<float>(tmpCapacityReservation.spillageCost))
+                          {
+                              logs.warning() << area.name << ": invalid spillage cost for reserve "
+                                             << section.name;
+                          }
+                      }
+                      else if (tmp == "type")
+                      {
+                          if (p->value == "up")
+                              type = 0;
+                          else if (p->value == "down")
+                              type = 1;
+                          else
+                              logs.warning()
+                                << area.name << ": invalid type for reserve " << section.name;
+                      }
+                      else
+                          logs.warning()
+                            << area.name << ": invalid key " << tmp << " in file " << buffer;
+                  }
+                  buffer.clear() << study.folderInput << SEP << "reserves" << SEP << area.id << SEP
+                                 << file_name << ".txt";
+                  ret = tmpCapacityReservation.need.loadFromFile(buffer, false) && ret;
+                  if (type == 0)
+                      area.allCapacityReservations.areaCapacityReservationsUp.emplace(section.name, tmpCapacityReservation);
+                  else if (type == 1)
+                      area.allCapacityReservations.areaCapacityReservationsDown.emplace(section.name, tmpCapacityReservation);
+                  else
+                      logs.warning() << area.name << ": invalid type for reserve " << section.name;
+              }
+          });
+    }
+
     // Solar
     {
         if (area.solar.prepro) // Prepro
@@ -937,6 +1011,10 @@ static bool AreaListLoadFromFolderSingleArea(Study& study,
         // In adequacy mode, all thermal clusters must be in 'mustrun' mode
         if (study.usedByTheSolver && study.parameters.mode == SimulationMode::Adequacy)
             area.thermal.list.enableMustrunForEveryone();
+
+        buffer.clear() << study.folderInput << SEP << "thermal" << SEP << "clusters" << SEP
+                       << area.id << SEP << "reserves.ini";
+        ret = area.thermal.list.loadReserveParticipations(area, buffer) && ret;
     }
 
     // Short term storage
@@ -962,7 +1040,6 @@ static bool AreaListLoadFromFolderSingleArea(Study& study,
     // Nodal Optimization
     buffer.clear() << study.folderInput << SEP << "areas" << SEP << area.id << SEP
                    << "optimization.ini";
-    IniFile ini;
     if (!ini.open(buffer))
         return false;
 

src/libs/antares/study/include/antares/study/area/area.h

@@ -34,6 +34,7 @@
 #include "ui.h"
 #include "constants.h"
 #include "antares/study/filter.h"
+#include <antares/study/area/capacityReservation.h>
 
 namespace Antares
 {
@@ -293,6 +294,9 @@ class Area final : private Yuni::NonCopyable<Area>
     double spreadSpilledEnergyCost = 0.;
     //@}
 
+    /// \name AllCapacityReservations structure to keep track of the added capacity reservations
+    AllCapacityReservations allCapacityReservations;
+
     //! \name Output filtering
     //@{
     //! Print results for the area in the simulation synthesis

src/libs/antares/study/include/antares/study/area/capacityReservation.h

@@ -0,0 +1,115 @@
+/*
+** 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/>.
+*/
+#ifndef __ANTARES_LIBS_STUDY_NEW_RESERVES_H__
+#define __ANTARES_LIBS_STUDY_NEW_RESERVES_H__
+
+#include <yuni/yuni.h>
+#include <yuni/core/noncopyable.h>
+#include <yuni/core/string.h>
+#include <vector>
+#include <optional>
+#include <antares/series/series.h>
+#include <antares/array/matrix.h>
+
+/// @brief Represents an area capacity reservation using it's name, it's failure cost and it's spillage cost
+struct CapacityReservation
+{
+    CapacityReservation() : failureCost(0), spillageCost(0), need(timeseriesNumbers) {}
+    float failureCost;
+    float spillageCost;
+    Antares::Data::TimeSeries need;
+
+private:
+    Matrix<uint32_t> timeseriesNumbers;
+};
+
+/// @brief Stores all the Capacity reservations in two vectors for the up and down reserves
+struct AllCapacityReservations
+{
+    std::map<std::string, CapacityReservation> areaCapacityReservationsUp;
+    std::map<std::string, CapacityReservation> areaCapacityReservationsDown;
+
+    /// @brief Check if the capacity reservation name already exist in both the up and down reserves
+    /// @param name
+    /// @return true if the capacity reservation already existed
+    bool contains(std::string name)
+    {
+        return areaCapacityReservationsUp.contains(name) || areaCapacityReservationsDown.contains(name);
+    }
+
+    /// @brief Get a capacity reservation from both the up and down reserves using its name
+    /// @param name
+    /// @return an optional of the capacity reservation reference if the reserve was found, and a nullopt
+    /// otherwise
+    std::optional<std::reference_wrapper<CapacityReservation>> getReserveByName(Yuni::ShortString256 name)
+    {
+        if (areaCapacityReservationsUp.contains(name))
+        {
+            return areaCapacityReservationsUp.at(name);
+        }
+        else if (areaCapacityReservationsDown.contains(name))
+        {
+            return areaCapacityReservationsDown.at(name);
+        }
+        return std::nullopt;
+    }
+
+    /// @brief Returns lower case, no space string
+    /// @param name
+    /// @return A string usable for file naming
+    static std::string toFilename(std::string name)
+    {
+        std::string file_name = name;
+        std::replace(file_name.begin(), file_name.end(), ' ', '_');
+        std::transform(file_name.begin(), file_name.end(), file_name.begin(), ::tolower);
+        return file_name;
+    }
+};
+
+/// @brief Represents the cluster reserve participation to a given reserve
+struct ClusterReserveParticipation
+{
+    std::reference_wrapper<CapacityReservation> capacityReservation;
+    float maxPower = 0;
+    float participationCost = 0;
+
+    ClusterReserveParticipation(std::reference_wrapper<CapacityReservation> reserve,
+                                float power,
+                                float cost) :
+     capacityReservation(reserve), maxPower(power), participationCost(cost)
+    {
+    }
+
+    ClusterReserveParticipation& operator=(const ClusterReserveParticipation& other)
+    {
+        // Check for self-assignment
+        if (this != &other)
+        {
+            // Copy the values from the other object
+            capacityReservation = other.capacityReservation;
+            maxPower = other.maxPower;
+            participationCost = other.participationCost;
+        }
+        return *this;
+    }
+};
+
+#endif // __ANTARES_LIBS_STUDY_LINKS_H__

src/libs/antares/study/include/antares/study/parts/common/cluster.h

@@ -26,6 +26,7 @@
 #include <antares/array/matrix.h>
 #include <antares/series/series.h>
 #include "../../fwd.h"
+#include <antares/study/area/capacityReservation.h>
 
 #include <set>
 #include <map>
@@ -104,6 +105,12 @@ class Cluster
     bool saveDataSeriesToFolder(const AnyString& folder) const;
     bool loadDataSeriesFromFolder(Study& s, const AnyString& folder);
 
+    //! @brief Add the reserve participation to the current clusterReservesParticipations map
+    //! @param name the name of the reserve to add
+    //! @param reserveParticipation the reserve participation to add
+    void addReserveParticipation(std::string name,
+                                 ClusterReserveParticipation reserveParticipation);
+
     uint unitCount = 0;
 
     bool isEnabled() const { return enabled; }
@@ -133,13 +140,30 @@ class Cluster
     */
     Matrix<> modulation;
 
+    //! \brief Returns true if cluster participates in a reserve with this name
+    bool isParticipatingInReserve(std::string name);
+
+    //! \brief Returns max power for a reserve if participating, -1 otherwise
+    float reserveMaxPower(std::string name);
+
+    //! \brief Returns participating cost for a reserve if participating, -1 otherwise
+    float reserveCost(std::string name);
+
+    //! \brief Returns the number of reserves linked to this cluster
+    unsigned int reservesCount();
+
+
 protected:
     Data::ClusterName pName;
     Data::ClusterName pID;
     Data::ClusterName pGroup;
 
 private:
     virtual unsigned int precision() const = 0;
+    //! @brief Stores the reserves Participations for each reserve, the key is the name of the
+    //! reserve
+    std::map<std::string, ClusterReserveParticipation> clusterReservesParticipations;
+
 };
 } // namespace Data
 } // namespace Antares

src/libs/antares/study/include/antares/study/parts/common/cluster_list.h

@@ -25,6 +25,8 @@
 #include "../../fwd.h"
 
 #include <antares/writer/i_writer.h>
+#include <antares/study/area/capacityReservation.h>
+#include <antares/study/parts/common/cluster.h>
 
 #include <algorithm>
 #include <vector>
@@ -127,6 +129,14 @@ class ClusterList
     bool loadDataSeriesFromFolder(Study& study,
                                  const AnyString& folder);
 
+    /// @brief Load the reserve participation. For each entry, it checks if the reserve has been
+    /// added to area.allCapacityReservations, if not then log the name of the reserve that has not been found.
+    /// @tparam ClusterT Type of the Cluster list
+    /// @param area Reference to area
+    /// @param file File to read the reserve participations entries
+    /// @return false if the file opening failed, true otherwise
+    bool loadReserveParticipations(Area& area, const AnyString& folder);
+
     bool saveDataSeriesToFolder(const AnyString& folder) const;
 
     virtual bool saveToFolder(const AnyString& folder) const = 0;
@@ -148,6 +158,10 @@ class ClusterList
     unsigned int allClustersCount() const;
     void addToCompleteList(std::shared_ptr<ClusterT> cluster);
     void sortCompleteList();
+    /// @brief Get the cluster from the vector allClusters_ using it's name
+    /// @param clusterName
+    /// @return nullopt if no clusters found else a pointer to the cluster
+    std::optional<std::shared_ptr<Cluster>> getClusterByName(std::string clusterName);
 
 protected:
     std::vector<std::shared_ptr<ClusterT>> allClusters_;

src/libs/antares/study/include/antares/study/parts/thermal/cluster_list.h

@@ -123,6 +123,8 @@ class ThermalClusterList : public ClusterList<ThermalCluster>
     unsigned int enabledAndMustRunCount() const;
     unsigned int enabledAndNotMustRunCount() const;
 
+    unsigned int reservesCount() const;
+
 private:
     // Give a special index to enbled and not must-run THERMAL clusters
     void rebuildIndex() const;

src/libs/antares/study/include/antares/study/runtime/runtime.h

@@ -105,6 +105,7 @@ class StudyRuntimeInfos
     //! Total
     uint thermalPlantTotalCount;
     uint thermalPlantTotalCountMustRun;
+    uint capacityReservationCount = 0;
 
     uint shortTermStorageCount = 0;