parameters.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_PARAMETERS_H__
#define __ANTARES_LIBS_STUDY_PARAMETERS_H__
 
#include <cassert>
#include <cstdlib>
#include <vector>
 
#include <yuni/yuni.h>
#include <yuni/core/string.h>
 
#include <antares/date/date.h>
#include <antares/inifile/inifile.h>
#include <antares/optimization-options/options.h>
#include <antares/study/UnfeasibleProblemBehavior.hpp>
#include <antares/writer/result_format.h>
#include "antares/antares/antares.h"
#include "antares/study/fwd.h"
 
#include "parameters/adq-patch-params.h"
#include "variable-print-info.h"
#include "version.h"
 
namespace Antares::Data
{
class Parameters final
{
public:
 
    bool economy() const;
    bool adequacy() const;
 
    void resetPlaylist(uint nbOfYears);
 
    bool loadFromFile(const std::filesystem::path& filename, const StudyVersion& version);
 
    bool loadFromINI(const IniFile& ini, const StudyVersion& version);
 
    void prepareForSimulation(const StudyLoadOptions& options);
 
    bool saveToFile(const AnyString& filename) const;
 
    bool isTSGeneratedByPrepro(const TimeSeriesType ts) const;
 
    void reset();
    void resetSeeds();
 
    void fixBadValues();
 
    void validateOptions(const StudyLoadOptions&);
 
    void fixGenRefreshForNTC();
 
    void resetYearsWeigth();
 
    std::vector<float> getYearsWeight() const;
 
    float getYearsWeightSum() const;
 
    void setYearWeight(uint year, float weight);
 
    // Do we create files in the input folder ?
    bool haveToImport(int tsKind) const;
 
    void saveToINI(IniFile& ini) const;
 
public:
 
    SimulationMode mode;
 
 
    Yuni::String horizon;
 
 
    uint nbYears;
    Date::DayInterval simulationDays;
    DayOfTheWeek dayOfThe1stJanuary;
    DayOfTheWeek firstWeekday;
    MonthName firstMonthInYear;
    bool leapYear;
 
 
    bool yearByYear;
    bool derated;
    bool useCustomScenario;
    bool userPlaylist;
    std::vector<bool> yearsFilter;
 
    bool thematicTrimming;
    mutable AllVariablesPrintInfo variablesPrintInfo;
 
    // Computed automatically from the number of MC years and the playlist
    uint effectiveNbYears;
    bool geographicTrimming;
 
 
    uint nbTimeSeriesLoad;
    uint nbTimeSeriesHydro;
    uint nbTimeSeriesWind;
    uint nbTimeSeriesThermal;
    uint nbTimeSeriesSolar;
 
 
 
    uint timeSeriesToArchive;
 
 
 
    uint timeSeriesToGenerate;
 
 
 
    uint exportTimeSeriesInInput;
 
 
 
    uint intraModal;
 
    uint interModal;
 
 
    bool storeTimeseriesNumbers;
 
    bool readonly;
 
    bool synthesis;
 
    uint timeSeriesAccuracyOnCorrelation;
 
 
 
    struct IncludeOptions
    {
        bool constraints;
        bool hurdleCosts;
 
        struct Reserve
        {
            bool dayAhead;
            bool strategic;
            bool spinning;
            bool primary;
 
        } reserve;
 
        struct Thermal
        {
            // Thermal cluster min stable power
            bool minStablePower;
 
            bool minUPTime;
        } thermal;
 
        mpsExportStatus exportMPS;
 
        bool exportStructure;
 
        UnfeasibleProblemBehavior unfeasibleProblemBehavior;
 
        bool exportSolutions;
    } include;
 
    struct Compatibility
    {
        enum class HydroPmax
        {
            Daily,
            Hourly
        };
        HydroPmax hydroPmax = HydroPmax::Daily;
    };
 
    Compatibility compatibility;
 
    // Shedding
    struct
    {
        SheddingPolicy policy;
    } shedding;
 
    struct
    {
        PowerFluctuations fluctuations;
    } power;
 
    struct UCMode
    {
        UnitCommitmentMode ucMode;
 
        void addExcludedVariables(std::vector<std::string>&) const;
    };
 
    UCMode unitCommitment;
 
    struct
    {
        NumberOfCoresMode ncMode;
    } nbCores;
 
    struct RenewableGeneration
    {
        RenewableGenerationModelling rgModelling;
        void addExcludedVariables(std::vector<std::string>&) const;
        RenewableGenerationModelling operator()() const;
        void toAggregated();
        void toClusters();
        bool isAggregated() const;
        bool isClusters() const;
    };
 
    RenewableGeneration renewableGeneration;
 
    struct
    {
        HydroHeuristicPolicy hhPolicy;
    } hydroHeuristicPolicy;
 
    struct
    {
        HydroPricingMode hpMode;
    } hydroPricing;
 
    bool accurateShavePeaksIncludeShortTermStorage = false;
 
    GlobalTransmissionCapacities transmissionCapacities;
    SimplexOptimization simplexOptimizationRange;
 
    AdequacyPatch::AdqPatchParams adqPatchParams;
 
 
    RulesScenarioName activeRulesScenario;
 
 
    // This variable is not stored within the study but only used by the solver
    bool noOutput = false;
 
    bool hydroDebug;
 
    bool remixStorageDebug = false;
 
 
    uint seed[seedMax];
 
    // Format of results. Currently, only single files or zip archive are supported
    ResultFormat resultFormat = legacyFilesDirectories;
 
    // Naming constraints and variables in problems
    bool namedProblems;
 
    // All options related to linear & quadratic optimization
    Antares::Solver::Optimization::OptimizationOptions optOptions;
 
private:
    void resetPlayedYears(uint nbOfYears);
 
    std::vector<float> yearsWeight;
 
}; // class Parameters
 
const char* SimulationModeToCString(SimulationMode mode);
 
bool StringToSimulationMode(SimulationMode& mode, Yuni::CString<20, false> text);
 
const char* CompatibilityHydroPmaxToCString(const Parameters::Compatibility::HydroPmax);
bool StringToCompatibilityHydroPmax(Parameters::Compatibility::HydroPmax&, const std::string& text);
 
} // namespace Antares::Data
 
#endif // __ANTARES_LIBS_STUDY_PARAMETERS_H__