Link TS generation : splitting into multiple files

src/libs/antares/utils/include/antares/utils/utils.h

@@ -36,9 +36,10 @@ namespace Antares
 */
 template<class StringT>
 void TransformNameIntoID(const AnyString& name, StringT& out);
-
 std::string transformNameIntoID(const std::string& name);
 
+std::string FormattedTime(const std::string& format);
+
 /*!
 ** \brief Beautify a name, for renaming an area for example
 */
@@ -51,11 +52,8 @@ std::vector<std::pair<std::string, std::string>> splitStringIntoPairs(const std:
 
 namespace Utils
 {
-
 bool isZero(double d);
-
 double round(double d, unsigned precision);
-
 } // namespace Utils
 } // namespace Antares
 

src/libs/antares/utils/utils.cpp

@@ -96,6 +96,20 @@ void BeautifyName(std::string& out, const std::string& oldname)
     out = yuniOut.c_str();
 }
 
+std::string FormattedTime(const std::string& format)
+{
+    using namespace std::chrono;
+    auto time = system_clock::to_time_t(system_clock::now());
+    std::tm local_time = *std::localtime(&time);
+
+    char time_buffer[256];
+    std::strftime(time_buffer, sizeof(time_buffer), format.c_str(), &local_time);
+
+    std::string currentTime = time_buffer;
+
+    return currentTime;
+}
+
 std::vector<std::pair<std::string, std::string>> splitStringIntoPairs(const std::string& s,
                                                                       char delimiter1,
                                                                       char delimiter2)

src/solver/application/application.cpp

@@ -429,20 +429,6 @@ void Application::runSimulationInAdequacyMode()
                                         observer);
 }
 
-static std::string timeToString()
-{
-    using namespace std::chrono;
-    auto time = system_clock::to_time_t(system_clock::now());
-    std::tm local_time = *std::localtime(&time);
-
-    char time_buffer[256];
-    std::strftime(time_buffer, sizeof(time_buffer), "%Y%m%d-%H%M%S", &local_time);
-
-    std::string currentTime = time_buffer;
-
-    return currentTime;
-}
-
 void Application::resetLogFilename() const
 {
     fs::path logfile = fs::path(pSettings.studyFolder.c_str()) / "logs";
@@ -454,7 +440,7 @@ void Application::resetLogFilename() const
     }
 
     logfile /= "solver-";               // append the filename
-    logfile += timeToString() + ".log"; // complete filename with timestamp and extension
+    logfile += FormattedTime("%Y%m%d-%H%M%S") + ".log"; // complete filename with timestamp and extension
 
     // Assigning the log filename
     logs.logfile(logfile.string());

src/solver/simulation/include/antares/solver/simulation/solver.hxx

@@ -41,6 +41,7 @@
 
 
 #include "hydro-final-reservoir-level-functions.h"
+namespace fs = std::filesystem;
 
 namespace Antares::Solver::Simulation
 {
@@ -490,11 +491,9 @@ void ISimulation<ImplementationType>::regenerateTimeSeries(uint year)
         if (refreshTSonCurrentYear)
         {
             auto clusters = getAllClustersToGen(study.areas, pData.haveToRefreshTSThermal);
-#define SEP Yuni::IO::Separator
-            const std::string savePath = std::string("ts-generator") + SEP + "thermal" + SEP + "mc-"
-                                         + std::to_string(year);
-#undef SEP
-            generateThermalTimeSeries(study, clusters, pResultWriter, savePath);
+            fs::path savePath = fs::path(study.folderOutput.to<std::string>()) / "ts-generator"
+                                / "thermal" / "mc-" / std::to_string(year);
+            generateThermalTimeSeries(study, clusters, savePath.string());
 
             // apply the spinning if we generated some in memory clusters
             for (auto* cluster: clusters)

src/solver/ts-generator/availability.cpp

@@ -32,6 +32,7 @@
 #include "antares/study/simulation.h"
 
 #define SEP Yuni::IO::Separator
+namespace fs = std::filesystem;
 
 constexpr double FAILURE_RATE_EQ_1 = 0.999;
 
@@ -70,13 +71,13 @@ AvailabilityTSGeneratorData::AvailabilityTSGeneratorData(LinkTSgenerationParams&
 
 namespace
 {
-class GeneratorTempData final
+class AvailabilityTSgenerator final
 {
 public:
-    explicit GeneratorTempData(Data::Study&, unsigned, MersenneTwister&);
-    explicit GeneratorTempData(bool, unsigned, MersenneTwister&);
+    explicit AvailabilityTSgenerator(Data::Study&, unsigned, MersenneTwister&);
+    explicit AvailabilityTSgenerator(bool, unsigned, MersenneTwister&);
 
-    void generateTS(AvailabilityTSGeneratorData&) const;
+    void run(AvailabilityTSGeneratorData&) const;
 
 private:
     bool derated;
@@ -101,26 +102,30 @@ class GeneratorTempData final
                                const T& duration) const;
 };
 
-GeneratorTempData::GeneratorTempData(Data::Study& study, unsigned nbOfSeriesToGen, MersenneTwister& rndGenerator):
+AvailabilityTSgenerator::AvailabilityTSgenerator(Data::Study& study,
+                                                 unsigned nbOfSeriesToGen,
+                                                 MersenneTwister& rndGenerator):
     derated(study.parameters.derated),
     nbOfSeriesToGen_(nbOfSeriesToGen),
     rndgenerator(rndGenerator)
 {
 }
 
-GeneratorTempData::GeneratorTempData(bool derated, unsigned int nbOfSeriesToGen, MersenneTwister& rndGenerator):
+AvailabilityTSgenerator::AvailabilityTSgenerator(bool derated,
+                                                 unsigned int nbOfSeriesToGen,
+                                                 MersenneTwister& rndGenerator):
     derated(derated),
     nbOfSeriesToGen_(nbOfSeriesToGen),
     rndgenerator(rndGenerator)
 {
 }
 
 template<class T>
-void GeneratorTempData::prepareIndispoFromLaw(Data::StatisticalLaw law,
-                                              double volatility,
-                                              std::array<double, 366>& A,
-                                              std::array<double, 366>& B,
-                                              const T& duration) const
+void AvailabilityTSgenerator::prepareIndispoFromLaw(Data::StatisticalLaw law,
+                                                    double volatility,
+                                                    std::array<double, 366>& A,
+                                                    std::array<double, 366>& B,
+                                                    const T& duration) const
 {
     switch (law)
     {
@@ -161,11 +166,11 @@ void GeneratorTempData::prepareIndispoFromLaw(Data::StatisticalLaw law,
     }
 }
 
-int GeneratorTempData::durationGenerator(Data::StatisticalLaw law,
-                                         int expec,
-                                         double volat,
-                                         double a,
-                                         double b) const
+int AvailabilityTSgenerator::durationGenerator(Data::StatisticalLaw law,
+                                               int expec,
+                                               double volat,
+                                               double a,
+                                               double b) const
 {
     if (volat == 0 || expec == 1)
     {
@@ -193,7 +198,7 @@ int GeneratorTempData::durationGenerator(Data::StatisticalLaw law,
     return 0;
 }
 
-void GeneratorTempData::generateTS(AvailabilityTSGeneratorData& tsGenerationData) const
+void AvailabilityTSgenerator::run(AvailabilityTSGeneratorData& tsGenerationData) const
 {
     assert(tsGenerationData.prepro);
 
@@ -608,23 +613,8 @@ std::vector<Data::ThermalCluster*> getAllClustersToGen(const Data::AreaList& are
     return clusters;
 }
 
-void writeResultsToDisk(const Data::Study& study,
-                        Solver::IResultWriter& writer,
-                        const Matrix<>& series,
-                        const std::string& savePath)
-{
-    if (study.parameters.noOutput)
-    {
-        return;
-    }
-
-    std::string buffer;
-    series.saveToBuffer(buffer, 0);
-    writer.addEntryFromBuffer(savePath, buffer);
-}
-
-void writeResultsToDisk(const Matrix<>& series,
-                        const std::filesystem::path savePath)
+void writeTStoDisk(const Matrix<>& series,
+                   const std::filesystem::path savePath)
 {
     std::string buffer;
     series.saveToBuffer(buffer, 0);
@@ -639,29 +629,37 @@ void writeResultsToDisk(const Matrix<>& series,
 
 bool generateThermalTimeSeries(Data::Study& study,
                                const std::vector<Data::ThermalCluster*>& clusters,
-                               Solver::IResultWriter& writer,
                                const std::string& savePath)
 {
     logs.info();
     logs.info() << "Generating the thermal time-series";
 
-    bool archive = study.parameters.timeSeriesToArchive & Data::timeSeriesThermal;
-
-    auto generator = GeneratorTempData(study,
-                                       study.parameters.nbTimeSeriesThermal,
-                                       study.runtime->random[Data::seedTsGenThermal]);
+    auto generator = AvailabilityTSgenerator(study,
+                                             study.parameters.nbTimeSeriesThermal,
+                                             study.runtime->random[Data::seedTsGenThermal]);
 
     for (auto* cluster: clusters)
     {
+        cluster->series.timeSeries.reset(study.parameters.nbTimeSeriesThermal, HOURS_PER_YEAR);
         AvailabilityTSGeneratorData tsGenerationData(cluster);
-        generator.generateTS(tsGenerationData);
+        generator.run(tsGenerationData);
+    }
 
-        if (archive) // For compatibilty with in memory thermal TS generation
-        {
-            std::string filePath = savePath + SEP + cluster->parentArea->id + SEP + cluster->id()
-                                   + ".txt";
-            writeResultsToDisk(study, writer, cluster->series.timeSeries, filePath);
-        }
+    bool archive = study.parameters.timeSeriesToArchive & Data::timeSeriesThermal;
+    bool doWeWrite = archive && !study.parameters.noOutput;
+    if (! doWeWrite)
+    {
+        logs.info() << "Study parameters forbid writing thermal TS.";
+        return true;
+    }
+
+    for (auto* cluster: clusters)
+    {
+        auto areaName = cluster->parentArea->id.to<std::string>();
+        auto clusterName = cluster->id();
+        auto filePath = fs::path(savePath) / areaName / clusterName += ".txt";
+
+        writeTStoDisk(cluster->series.timeSeries, filePath.string());
     }
 
     return true;
@@ -675,9 +673,9 @@ bool generateLinkTimeSeries(std::vector<LinkTSgenerationParams>& links,
     logs.info();
     logs.info() << "Generation of links time-series";
 
-    auto generator = GeneratorTempData(generalParams.derated,
-                                       generalParams.nbLinkTStoGenerate,
-                                       generalParams.random);
+    auto generator = AvailabilityTSgenerator(generalParams.derated,
+                                             generalParams.nbLinkTStoGenerate,
+                                             generalParams.random);
     for (auto& link: links)
     {
         if (! link.hasValidData)
@@ -696,20 +694,20 @@ bool generateLinkTimeSeries(std::vector<LinkTSgenerationParams>& links,
         // DIRECT
         AvailabilityTSGeneratorData tsConfigDataDirect(link, ts, link.modulationCapacityDirect, link.namesPair.second);
 
-        generator.generateTS(tsConfigDataDirect);
+        generator.run(tsConfigDataDirect);
 
         std::string filePath = savePath + SEP + link.namesPair.first + SEP + link.namesPair.second
                                + "_direct.txt";
-        writeResultsToDisk(ts.timeSeries, filePath);
+        writeTStoDisk(ts.timeSeries, filePath);
 
         // INDIRECT
         AvailabilityTSGeneratorData tsConfigDataIndirect(link, ts, link.modulationCapacityIndirect, link.namesPair.second);
 
-        generator.generateTS(tsConfigDataIndirect);
+        generator.run(tsConfigDataIndirect);
 
         filePath = savePath + SEP + link.namesPair.first + SEP + link.namesPair.second
                                + "_indirect.txt";
-        writeResultsToDisk(ts.timeSeries, filePath);
+        writeTStoDisk(ts.timeSeries, filePath);
     }
 
     return true;

src/solver/ts-generator/include/antares/solver/ts-generator/generator.h

@@ -111,7 +111,6 @@ bool GenerateTimeSeries(Data::Study& study, uint year, IResultWriter& writer);
 
 bool generateThermalTimeSeries(Data::Study& study,
                                const std::vector<Data::ThermalCluster*>& clusters,
-                               Solver::IResultWriter& writer,
                                const std::string& savePath);
 
 bool generateLinkTimeSeries(std::vector<LinkTSgenerationParams>& links,

src/tools/ts-generator/CMakeLists.txt

@@ -1,5 +1,9 @@
 set(SRCS
         main.cpp
+		include/antares/tools/ts-generator/linksTSgenerator.h
+		include/antares/tools/ts-generator/tsGenerationOptions.h
+		tsGenerationOptions.cpp
+		linksTSgenerator.cpp
 )
 
 set(execname "antares-ts-generator")
@@ -13,15 +17,15 @@ INSTALL(EXPORT ${execname}
 
 target_link_libraries(${execname}
                       PRIVATE
-                      Antares::utils
-                      antares-solver-ts-generator
-                      Antares::study
-		      Antares::checks
+						Antares::utils
+						antares-solver-ts-generator
+						Antares::study
+						Antares::checks
 )
 
 target_include_directories(${execname}
         PRIVATE
-        "${CMAKE_CURRENT_SOURCE_DIR}/include"
+			"${CMAKE_CURRENT_SOURCE_DIR}/include"
 )
 
 import_std_libs(${execname})

src/tools/ts-generator/include/antares/tools/ts-generator/linksTSgenerator.h

@@ -0,0 +1,31 @@
+
+#pragma once
+
+#include "antares/tools/ts-generator/tsGenerationOptions.h"
+#include <antares/solver/ts-generator/generator.h>
+
+namespace fs = std::filesystem;
+
+namespace Antares::TSGenerator {
+
+class LinksTSgenerator
+{
+public:
+    LinksTSgenerator(Settings&);
+    void extractData();
+    bool generate();
+
+private:
+    LinkPairs extractLinkNamesFromStudy();
+    LinkPairs extractLinkNamesFromCmdLine(const LinkPairs&);
+    StudyParamsForLinkTS readGeneralParamsForLinksTS();
+    void extractLinksSpecificTSparameters();
+
+    std::string linksFromCmdLineOptions_;
+    fs::path studyFolder_;
+    bool generateTSforAllLinks_ = false;
+    std::vector<LinkTSgenerationParams> linkList_;
+    StudyParamsForLinkTS generalParams_;
+};
+
+} // End Antares::TSGenerator