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,80 @@ static bool AreaListLoadFromFolderSingleArea(Study& study,
         }
     }
 
+    // Reserves
+    {
+        buffer.clear() << study.folderInput << SEP << "reserves" << SEP << area.id << SEP
+                       << "reserves.ini";
+        if (ini.open(buffer, 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 +1013,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 +1042,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,121 @@
+/*
+** 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<Data::ReserveName, CapacityReservation> areaCapacityReservationsUp;
+    std::map<Data::ReserveName, 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(Data::ReserveName 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 Get the number of capacityReservations in the area
+    /// @return the number of capacityReservations in the area
+    size_t size(){
+        return areaCapacityReservationsUp.size() + areaCapacityReservationsDown.size();
+    }
+
+    /// @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/fwd.h

@@ -62,6 +62,8 @@ using AreaName = Yuni::CString<ant_k_area_name_max_length, false>;
 using AreaLinkName = Yuni::CString<ant_k_area_name_max_length * 2 + 1, false>;
 //! Name of a single thermal
 using ClusterName = std::string;
+//! Name of a reserve
+using ReserveName = std::string;
 
 using ConstraintName = Yuni::CString<ant_k_constraint_name_max_length, false>;
 

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,34 @@ class Cluster
     */
     Matrix<> modulation;
 
+    //! \brief Returns true if cluster participates in a reserve with this name
+    bool isParticipatingInReserve(Data::ReserveName name);
+
+    //! \brief Returns an array of all reserves the cluster is participating in
+    std::vector<Data::ReserveName> listOfParticipatingReserves();
+
+    //! \brief Returns max power for a reserve if participating, -1 otherwise
+    float reserveMaxPower(Data::ReserveName name);
+
+    //! \brief Returns participating cost for a reserve if participating, -1 otherwise
+    float reserveCost(Data::ReserveName name);
+
+    //! \brief Returns the number of reserves linked to this cluster
+    unsigned int reserveParticipationsCount();
+
+
 protected:
     Data::ClusterName pName;
     Data::ClusterName pID;
     Data::ClusterName pGroup;
+    //! reserve
+    std::map<Data::ReserveName, ClusterReserveParticipation> clusterReservesParticipations;
 
 private:
     virtual unsigned int precision() const = 0;
+    //! @brief Stores the reserves Participations for each reserve, the key is the name of the
+
+
 };
 } // namespace Data
 } // namespace Antares