study.h

/*
 * Copyright 2007-2025, 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_STUDY_H__
#define __ANTARES_LIBS_STUDY_STUDY_H__
 
#include <memory>
 
#include <yuni/yuni.h>
#include <yuni/core/noncopyable.h>
#include <yuni/job/queue/service.h>
 
#include <antares/correlation/correlation.h>
#include <antares/date/date.h>
#include <antares/solver/modeler/data.h>
#include <antares/study/runtime/runtime.h>
#include <antares/writer/i_writer.h>
#include "antares/study/binding_constraint/BindingConstraintGroupRepository.h"
#include "antares/study/binding_constraint/BindingConstraintsRepository.h"
 
#include "area/store-timeseries-numbers.h"
#include "binding_constraint/BindingConstraint.h"
#include "fwd.h"
#include "header.h"
#include "layerdata.h"
#include "parameters.h"
#include "progression/progression.h"
#include "sets.h"
#include "simulation.h"
 
namespace Antares::Data
{
class UIRuntimeInfo;
 
class Study: public Yuni::NonCopyable<Study>, public LayerData
{
public:
    using Ptr = std::shared_ptr<Study>;
    using Set = std::set<Ptr>;
    using List = std::list<Ptr>;
 
    using SetsOfAreas = Antares::Data::Sets;
 
    using FileExtension = std::string;
 
    static bool TitleFromStudyFolder(const AnyString& folder, YString& out, bool warnings = false);
 
    static bool IsRootStudy(const AnyString& folder);
 
    static bool IsRootStudy(const AnyString& folder, YString& buffer);
 
    static bool IsInsideStudyFolder(const AnyString& path, YString& location, YString& title);
 
 
 
    Study(bool forTheSolver = false);
    virtual ~Study();
 
 
 
    void createAsNew();
 
    void relocate(const std::filesystem::path& newFolder);
 
    bool loadFromFolder(const std::string& path, const StudyLoadOptions& options);
 
    void clear();
 
    void reloadCorrelation();
 
    bool reloadXCastData();
 
    bool saveToFolder(const AnyString& newfolder);
 
    bool resetFolderIcon() const;
 
 
 
    bool forceReload(bool reload = false) const;
 
    void markAsModified() const;
 
 
 
    bool modifyAreaNameIfAlreadyTaken(AreaName& out, const AreaName& basename);
 
    // TODO no need for the 2nd argument, remove it after the GUI has been removed, keeping the
    // default value
    Area* areaAdd(const AreaName& name, bool update = false);
 
#ifdef BUILD_UI
    bool areaRename(Area* area, AreaName newName);
 
    bool areaDelete(Area* area);
 
    void areaDelete(Area::Vector& area);
 
 
 
    bool linkDelete(AreaLink* lnk);
 
 
 
    bool clusterRename(Cluster* cluster, std::string newName);
 
 
 
    bool readonly() const;
 
#endif
 
 
 
    void resizeAllTimeseriesNumbers(uint n);
 
    template<TimeSeriesType TimeSeriesT>
    void storeTimeSeriesNumbers(Solver::IResultWriter& resultWriter) const
    {
        storeTimeseriesNumbers<TimeSeriesT>(resultWriter, areas);
    }
 
 
 
 
    void performTransformationsBeforeLaunchingSimulation();
 
    bool initializeRuntimeInfos();
 
    void prepareOutput();
 
    void saveAboutTheStudy(Solver::IResultWriter& resultWriter);
 
    void initializeProgressMeter(bool tsGeneratorOnly);
 
 
 
 
    template<TimeSeriesType TS>
    inline void destroyTSGeneratorData()
    {
    }
 
    bool importTimeseriesIntoInput();
 
 
 
    void scenarioRulesLoadIfNotAvailable();
    void scenarioRulesCreate();
 
    void scenarioRulesDestroy();
 
 
 
    unsigned getNumberOfCoresPerMode(unsigned nbLogicalCores, int ncMode);
 
    void getNumberOfCores(const bool forceParallel, const uint nbYearsParallelForced);
 
    void removeTimeseriesIfTSGeneratorEnabled();
 
 
 
    bool checkForFilenameLimits(bool output, const YString& chfolder = nullptr) const;
 
 
 
    void ensureDataAreLoadedForAllBindingConstraints();
 
 
 
    void importLogsToOutputFolder(Solver::IResultWriter& resultWriter) const;
 
 
    void computePThetaInfForThermalClusters() const;
 
    StudyHeader header;
 
 
    std::filesystem::path folder;
    std::filesystem::path folderInput;
    std::filesystem::path folderOutput;
    std::filesystem::path folderSettings;
 
 
    // TODO VP: remove with GUI
    SimulationComments simulationComments;
 
    int64_t pStartTime;
    // Used in GUI and solver
    // ----------------------
    // Maximum number of years in a set of parallel years.
    // It is a possible reduction of the raw number of cores set by user (simulation cores level).
    // This raw number of cores is possibly reduced by the smallest TS refresh span or the total
    // number of MC years. In GUI, used for RAM estimation only. In solver, it is the max number of
    // years (actually run, not skipped) a set of parallel years can contain.
    uint maxNbYearsInParallel = 1;
 
    // Used in GUI only.
    // ----------------
    // Allows storing the maximum number of years in a set of parallel years.
    // Useful to estimate the RAM when the run window's parallel mode is chosen.
    uint maxNbYearsInParallel_save = 0;
 
    // Used in GUI and solver.
    // ----------------------
    // Raw numbers of cores (== nb of MC years run in parallel) based on the number
    // of cores level (see advanced parameters).
    uint nbYearsParallelRaw = 1;
 
    // Used in GUI only.
    // -----------------
    // Minimum number of years in a set of parallel years.
    // It is a possible reduction of the raw number of cores set by user (simulation cores level).
    // This raw number of cores can be reduced :
    //  - by the smallest TS refresh span
    //  - by the smallest interval between TS refreshes
    //  - In the Run window, if either Default or swap support mode is enabled, then parallel
    //    computation is disabled, and the number of cores is 1
    // Useful to populate the run window's simulation cores field.
    uint minNbYearsInParallel = 0;
 
    // Used in GUI only.
    // ----------------
    // Allows storing the minimum number of years in a set of parallel years.
    // Useful to populate the run window's simulation cores field.
    uint minNbYearsInParallel_save = 0;
 
    Parameters parameters;
 
    Date::Calendar calendar;
    Date::Calendar calendarOutput;
 
 
    AreaList areas;
 
 
    BindingConstraintsRepository bindingConstraints;
    BindingConstraintGroupRepository bindingConstraintsGroups;
 
 
    Correlation preproLoadCorrelation;
    Correlation preproSolarCorrelation;
    Correlation preproWindCorrelation;
    Correlation preproHydroCorrelation;
 
 
    SetsOfAreas setsOfAreas;
 
 
    std::unique_ptr<ScenarioBuilder::Sets> scenarioRules;
 
    TimeSeries::TS scenarioInitialHydroLevels;
    // Hydro Final Levels
    TimeSeries::TS scenarioFinalHydroLevels;
    StudyRuntimeInfos runtime;
 
    // Antares::Solver::Variable::State* state;
 
    UIRuntimeInfo* uiinfo = nullptr;
 
    FileExtension inputExtension = "txt";
 
    mutable Solver::Progression progression;
 
    mutable YString buffer;
    mutable Matrix<>::BufferType dataBuffer;
    mutable YString bufferLoadingTS;
 
    std::shared_ptr<Yuni::Job::QueueService> pQueueService;
 
 
 
    void* cacheTSGenerator[timeSeriesCount];
 
    const bool usedByTheSolver;
 
    Antares::Modeler::Data* getModelerData() const
    {
        return modelerInput_.get();
    }
 
protected:
 
    bool internalLoadFromFolder(const std::filesystem::path& path, const StudyLoadOptions& options);
    bool internalLoadHeader(const std::filesystem::path& folder);
    bool internalLoadCorrelationMatrices(const StudyLoadOptions& options);
    virtual bool internalLoadBindingConstraints(const StudyLoadOptions& options);
    bool internalLoadSets();
 
    bool internalLoadIni(const std::filesystem::path& path, const StudyLoadOptions& options);
 
    void loadModelerComponents();
    void checkModelerDataCompatibility() const;
 
    void parameterFiller(const StudyLoadOptions& options);
 
 
    void reduceMemoryUsage();
 
private:
    std::unique_ptr<Modeler::Data> modelerInput_;
}; // class Study
 
extern YString StudyIconFile;
 
std::filesystem::path StudyCreateOutputPath(SimulationMode mode,
                                            ResultFormat fmt,
                                            const std::filesystem::path& folder,
                                            const std::string& label,
                                            const std::tm& startTime);
} // namespace Antares::Data
 
#endif /* __ANTARES_LIBS_STUDY_STUDY_H__ */