Data for modeler (epic 4.1)

src/packaging/CMakeLists.txt

@@ -78,6 +78,7 @@ set(TARGET_LIBS #No alias
         # model_antares
         infeasible_problem_analysis
         modeler_api
+        data-series-lib
         modeler-ortools-impl
 
         # solver-lib

src/solver/modeler/CMakeLists.txt

@@ -1,4 +1,5 @@
 add_subdirectory(api)
+add_subdirectory(dataSeries)
 add_subdirectory(ortoolsImpl)
 add_subdirectory(loadFiles)
 add_subdirectory(parameters)
@@ -22,15 +23,16 @@ target_link_libraries(modeler-lib
         INTERFACE
         Antares::loadModelerFiles
         Antares::modelerParameters
-	Antares::optim-model-filler
-	Antares::modeler_api
-	# TODO FIXME don't depend on implementations
-	Antares::modeler-ortools-impl
+        Antares::optim-model-filler
+        Antares::modeler_api
+        # TODO FIXME don't depend on implementations
+        Antares::modeler-ortools-impl
 )
 
 target_link_libraries(antares-modeler
         PRIVATE
         modeler-lib
+        data-series-lib
 )
 
 import_std_libs(antares-modeler)

src/solver/modeler/api/CMakeLists.txt

@@ -8,13 +8,12 @@ set(SRC_API
         include/antares/solver/modeler/api/hasBounds.h
         include/antares/solver/modeler/api/hasName.h
 
+        include/antares/solver/modeler/api/ILinearProblemData.h
         include/antares/solver/modeler/api/linearProblem.h
-        include/antares/solver/modeler/api/linearProblemData.h
         include/antares/solver/modeler/api/linearProblemFiller.h
         include/antares/solver/modeler/api/linearProblemBuilder.h
 
-        linearProblemData.cpp
-		linearProblemBuilder.cpp
+        linearProblemBuilder.cpp
 )
 
 add_library(${PROJ} ${SRC_API})
@@ -24,5 +23,5 @@ set_target_properties(${PROJ} PROPERTIES LINKER_LANGUAGE CXX)
 
 target_include_directories(${PROJ}
         PUBLIC
-	$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
 )

src/solver/modeler/api/include/antares/solver/modeler/api/ILinearProblemData.h

@@ -0,0 +1,18 @@
+
+#pragma once
+
+#include <string>
+
+namespace Antares::Solver::Modeler::Api
+{
+
+class ILinearProblemData
+{
+    virtual double getData(std::string idTimeSeriesSet,
+                           std::string scenarioGroup,
+                           unsigned int scenario,
+                           unsigned int hour)
+      = 0;
+};
+
+} // namespace Antares::Solver::Modeler::Api

src/solver/modeler/api/include/antares/solver/modeler/api/linearProblemBuilder.h

@@ -32,7 +32,7 @@ class LinearProblemBuilder
 {
 public:
     explicit LinearProblemBuilder(const std::vector<LinearProblemFiller*>& fillers);
-    void build(ILinearProblem& pb, LinearProblemData& data, FillContext& ctx);
+    void build(ILinearProblem& pb, ILinearProblemData& data, FillContext& ctx);
 
 private:
     const std::vector<LinearProblemFiller*>& fillers_;

src/solver/modeler/api/include/antares/solver/modeler/api/linearProblemFiller.h

@@ -23,8 +23,8 @@
 
 #include <memory>
 
+#include <antares/solver/modeler/api/ILinearProblemData.h>
 #include <antares/solver/modeler/api/linearProblem.h>
-#include <antares/solver/modeler/api/linearProblemData.h>
 
 namespace Antares::Solver::Modeler::Api
 {
@@ -57,9 +57,9 @@ struct FillContext
 class LinearProblemFiller
 {
 public:
-    virtual void addVariables(ILinearProblem& pb, LinearProblemData& data, FillContext& ctx) = 0;
-    virtual void addConstraints(ILinearProblem& pb, LinearProblemData& data, FillContext& ctx) = 0;
-    virtual void addObjective(ILinearProblem& pb, LinearProblemData& data, FillContext& ctx) = 0;
+    virtual void addVariables(ILinearProblem& pb, ILinearProblemData& data, FillContext& ctx) = 0;
+    virtual void addConstraints(ILinearProblem& pb, ILinearProblemData& data, FillContext& ctx) = 0;
+    virtual void addObjective(ILinearProblem& pb, ILinearProblemData& data, FillContext& ctx) = 0;
     virtual ~LinearProblemFiller() = default;
 };
 

src/solver/modeler/api/linearProblemBuilder.cpp

@@ -31,7 +31,7 @@ LinearProblemBuilder::LinearProblemBuilder(const std::vector<LinearProblemFiller
 {
 }
 
-void LinearProblemBuilder::build(ILinearProblem& pb, LinearProblemData& data, FillContext& ctx)
+void LinearProblemBuilder::build(ILinearProblem& pb, ILinearProblemData& data, FillContext& ctx)
 {
     std::ranges::for_each(fillers_,
                           [&](const auto& filler) { filler->addVariables(pb, data, ctx); });

src/solver/modeler/dataSeries/CMakeLists.txt

@@ -0,0 +1,27 @@
+
+set(SRC_DATA_SERIES
+        include/antares/solver/modeler/dataSeries/dataSeries.h
+        include/antares/solver/modeler/dataSeries/timeSeriesSet.h
+        include/antares/solver/modeler/dataSeries/dataSeriesRepo.h
+        include/antares/solver/modeler/dataSeries/scenarioGroupRepo.h
+        include/antares/solver/modeler/dataSeries/linearProblemData.h
+
+        timeSeriesSet.cpp
+        dataSeriesRepo.cpp
+        scenarioGroupRepo.cpp
+        linearProblemData.cpp
+)
+
+add_library(data-series-lib ${SRC_DATA_SERIES})
+set_target_properties(data-series-lib PROPERTIES LINKER_LANGUAGE CXX)
+
+target_link_libraries(data-series-lib
+        PUBLIC
+        modeler_api
+)
+
+target_include_directories(data-series-lib
+        PUBLIC
+        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+)
+

src/solver/modeler/dataSeries/dataSeriesRepo.cpp

@@ -0,0 +1,28 @@
+#include "antares/solver/modeler/dataSeries/dataSeriesRepo.h"
+
+#include <stdexcept>
+
+namespace Antares::Solver::Modeler::DataSeries
+{
+void DataSeriesRepository::addDataSeries(std::unique_ptr<IDataSeries> dataSeries)
+{
+    std::string name = dataSeries->name();
+    dataSeries_[name] = std::move(dataSeries);
+}
+
+IDataSeries& DataSeriesRepository::getDataSeries(std::string setId)
+{
+    std::string error_message = err_prefix;
+    if (dataSeries_.empty())
+    {
+        error_message += "empty";
+        throw std::invalid_argument(error_message);
+    }
+    if (!dataSeries_.contains(setId))
+    {
+        error_message += "data series '" + setId + "' does not exist";
+        throw std::invalid_argument(error_message);
+    }
+    return *(dataSeries_[setId]);
+}
+} // namespace Antares::Solver::Modeler::DataSeries

src/solver/modeler/dataSeries/include/antares/solver/modeler/dataSeries/dataSeries.h

@@ -0,0 +1,28 @@
+
+#pragma once
+
+#include <string>
+
+namespace Antares::Solver::Modeler::DataSeries
+{
+
+class IDataSeries
+{
+public:
+    IDataSeries(std::string name):
+        name_(name)
+    {
+    }
+
+    virtual double getData(unsigned int rank, unsigned int hour) = 0;
+
+    std::string name()
+    {
+        return name_;
+    }
+
+private:
+    std::string name_;
+};
+
+} // namespace Antares::Solver::Modeler::DataSeries

src/solver/modeler/dataSeries/include/antares/solver/modeler/dataSeries/dataSeriesRepo.h

@@ -0,0 +1,24 @@
+
+#pragma once
+
+#include <map>
+#include <memory>
+#include <string>
+
+#include "dataSeries.h"
+
+namespace Antares::Solver::Modeler::DataSeries
+{
+
+class DataSeriesRepository
+{
+public:
+    void addDataSeries(std::unique_ptr<IDataSeries> dataSeries);
+    IDataSeries& getDataSeries(std::string setId);
+
+private:
+    std::map<std::string, std::unique_ptr<IDataSeries>> dataSeries_;
+    std::string err_prefix = "Data series repo : ";
+};
+
+} // namespace Antares::Solver::Modeler::DataSeries

src/solver/modeler/api/include/antares/solver/modeler/api/linearProblemData.h → src/solver/modeler/dataSeries/include/antares/solver/modeler/dataSeries/linearProblemData.h

@@ -21,27 +21,26 @@
 
 #pragma once
 
-#include <map>
 #include <string>
-#include <vector>
 
-namespace Antares::Solver::Modeler::Api
+#include "antares/solver/modeler/api/ILinearProblemData.h"
+#include "antares/solver/modeler/dataSeries/dataSeriesRepo.h"
+#include "antares/solver/modeler/dataSeries/scenarioGroupRepo.h"
+
+namespace Antares::Solver::Modeler::DataSeries
 {
 
-class LinearProblemData
+class LinearProblemData: public Api::ILinearProblemData
 {
 public:
-    unsigned getTimeResolutionInMinutes();
-    bool hasScalarData(const std::string& key);
-    double getScalarData(const std::string& key, unsigned scenario);
-    bool hasTimedData(const std::string& key);
-    const std::vector<double>& getTimedData(const std::string& key, unsigned scenario);
+    double getData(std::string idTimeSeriesSet,
+                   std::string scenarioGroup,
+                   unsigned int scenario,
+                   unsigned int hour) override;
 
 private:
-    std::vector<int> timeStamps_;
-    unsigned timeResolutionInMinutes_;
-    std::map<std::string, std::vector<double>> scalarData_;
-    std::map<std::string, std::vector<std::vector<double>>> timedData_;
+    DataSeries::DataSeriesRepository dataSeriesRepository_;
+    DataSeries::ScenarioGroupRepository groupRepository_;
 };
 
-} // namespace Antares::Solver::Modeler::Api
+} // namespace Antares::Solver::Modeler::DataSeries

src/solver/modeler/dataSeries/include/antares/solver/modeler/dataSeries/scenarioGroupRepo.h

@@ -0,0 +1,19 @@
+
+#pragma once
+#include <map>
+#include <string>
+
+namespace Antares::Solver::Modeler::DataSeries
+{
+class ScenarioGroupRepository
+{
+public:
+    void addPairScenarioRankToGroup(std::string groupId,
+                                    std::pair<unsigned, unsigned> scenarioToRank);
+
+    unsigned getDataRank(std::string groupId, unsigned scenario);
+
+private:
+    std::map<std::string, std::map<unsigned, unsigned>> scenarioGroups_;
+};
+} // namespace Antares::Solver::Modeler::DataSeries

src/solver/modeler/dataSeries/include/antares/solver/modeler/dataSeries/timeSeriesSet.h

@@ -0,0 +1,21 @@
+#include <string>
+#include <vector>
+
+#include "dataSeries.h"
+
+namespace Antares::Solver::Modeler::DataSeries
+{
+class TimeSeriesSet: public IDataSeries
+{
+public:
+    explicit TimeSeriesSet(std::string name, unsigned height);
+    void add(std::vector<double> ts);
+    double getData(unsigned rank, unsigned hour) override;
+
+private:
+    unsigned height_ = 0;
+    std::vector<std::vector<double>> tsSet_;
+    std::string err_prefix_;
+};
+
+} // namespace Antares::Solver::Modeler::DataSeries

src/solver/modeler/api/linearProblemData.cpp → src/solver/modeler/dataSeries/linearProblemData.cpp

@@ -19,35 +19,16 @@
  * along with Antares_Simulator. If not, see <https://opensource.org/license/mpl-2-0/>.
  */
 
-#include <antares/solver/modeler/api/linearProblemData.h>
+#include "antares/solver/modeler/dataSeries/linearProblemData.h"
 
-namespace Antares::Solver::Modeler::Api
+namespace Antares::Solver::Modeler::DataSeries
 {
-
-unsigned LinearProblemData::getTimeResolutionInMinutes()
-{
-    return timeResolutionInMinutes_;
-}
-
-bool LinearProblemData::hasScalarData(const std::string& key)
-{
-    return scalarData_.contains(key);
-}
-
-double LinearProblemData::getScalarData(const std::string& key, unsigned scenario)
-{
-    return scalarData_.at(key)[scenario];
-}
-
-bool LinearProblemData::hasTimedData(const std::string& key)
-{
-    return timedData_.contains(key);
-}
-
-const std::vector<double>& LinearProblemData::getTimedData(const std::string& key,
-                                                           unsigned scenario)
+double LinearProblemData::getData(std::string idTimeSeriesSet,
+                                  std::string scenarioGroup,
+                                  unsigned int scenario,
+                                  unsigned int hour)
 {
-    return timedData_.at(key)[scenario];
+    return 0.;
 }
 
-} // namespace Antares::Solver::Modeler::Api
+} // namespace Antares::Solver::Modeler::DataSeries

src/solver/modeler/dataSeries/scenarioGroupRepo.cpp

@@ -0,0 +1,31 @@
+#include "include/antares/solver/modeler/dataSeries/scenarioGroupRepo.h"
+
+#include <stdexcept>
+
+namespace Antares::Solver::Modeler::DataSeries
+{
+void ScenarioGroupRepository::addPairScenarioRankToGroup(
+  std::string groupId,
+  std::pair<unsigned, unsigned> scenarioToRank)
+{
+    scenarioGroups_[groupId] = {scenarioToRank};
+}
+
+unsigned ScenarioGroupRepository::getDataRank(std::string groupId, unsigned scenario)
+{
+    if (!scenarioGroups_.contains(groupId))
+    {
+        std::string error_message = "Group '" + groupId + "' does not exist in group repo.";
+        throw std::invalid_argument(error_message);
+    }
+
+    if (!scenarioGroups_.at(groupId).contains(scenario))
+    {
+        std::string error_message = "In scenario group '" + groupId + "', scenario '"
+                                    + std::to_string(scenario) + "' does not exist.";
+        throw std::invalid_argument(error_message);
+    }
+
+    return scenarioGroups_.at(groupId).at(scenario);
+}
+} // namespace Antares::Solver::Modeler::DataSeries