fwd.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_FWD_H__
#define __ANTARES_LIBS_STUDY_FWD_H__
 
#include <bit>
#include <map>
 
#include <yuni/yuni.h>
#include <yuni/core/string.h>
 
#include "antares/antares/constants.h"
#include "antares/enums/Enum.hpp"
 
namespace Antares
{
class IniFile;
 
namespace Data
{
// Forward declarations
class Study;
class StudyLoadOptions;
class Area;
class AreaLink;
class AreaList;
class AreaUI;
class ThermalCluster;
class RenewableCluster;
 
class AreaScratchpad;
 
class Parameters;
 
class BindingConstraint;
class BindingConstraintsRepository;
 
class StudyRuntimeInfos;
 
class UIRuntimeInfo;
 
class Correlation;
 
using AreaName = Yuni::CString<ant_k_area_name_max_length, false>;
using AreaLinkName = Yuni::CString<ant_k_area_name_max_length * 2 + 1, false>;
 
using ConstraintName = Yuni::CString<ant_k_constraint_name_max_length, false>;
 
using RulesScenarioName = Yuni::CString<64, false>;
 
using AreaNameMapping = std::map<AreaName, AreaName>;
 
enum StudyError
{
    stErrNone = 0,
    stErrHourOutOfBounds = 1,
    stErrFinalHourMustBeAMultipleOf168,
    stErrInvalidDayOfWeek,
    stErrTooMuchAreas,
    stErrTooMuchInterconnections,
    stErrTooMuchBindingConstraints,
    
};
 
enum class SimulationMode
{
    Economy,
    Adequacy,
    Expansion,
    Unknown
};
 
/*
** \brief Simplex optimizations
*/
enum SimplexOptimization
{
    sorUnknown = 0,
    sorDay,
    sorWeek,
 
}; // enum SimplexOptimization
 
enum class GlobalTransmissionCapacities
{
    localValuesForAllLinks = 0,
    nullForAllLinks,
    infiniteForAllLinks,
    nullForPhysicalLinks,
    infiniteForPhysicalLinks
}; // enum TransmissionCapacities
 
std::string GlobalTransmissionCapacitiesToString(
  GlobalTransmissionCapacities transmissionCapacities);
std::string GlobalTransmissionCapacitiesToString_Display(
  GlobalTransmissionCapacities transmissionCapacities);
bool stringToGlobalTransmissionCapacities(const AnyString& value,
                                          GlobalTransmissionCapacities& out);
 
enum class LocalTransmissionCapacities
{
    enabled,
    null,
    infinite
};
 
std::string transmissionCapacitiesToString(const LocalTransmissionCapacities& tc);
 
enum AssetType
{
    atAC = 0,
    atDC,
    atGas,
    atVirt,
    atOther,
 
}; // enum AssetType
 
std::string assetTypeToString(const AssetType& assetType);
 
enum StyleType
{
    stPlain = 0,
    stDot,
    stDash,
    stDotDash,
 
}; // enum StyleType
 
std::string styleToString(const StyleType& style);
 
enum TimeSeriesType : unsigned int
{
    timeSeriesLoad = 1u << 0,
    timeSeriesHydro = 1u << 1,
    timeSeriesWind = 1u << 2,
    timeSeriesThermal = 1u << 3,
    timeSeriesSolar = 1u << 4,
    timeSeriesRenewable = 1u << 5,
    timeSeriesTransmissionCapacities = 1u << 6,
    timeSeriesShortTermInflows = 1u << 7,
    timeSeriesShortTermAdditionalConstraints = 1u << 8,
    // ***********************************************************************
    // Please update the constant allTimeSeriesMask if you add / remove an item
    // ***********************************************************************
}; // enum TimeSeries
 
// Automatically count the number of time series by OR-ing them together:
constexpr unsigned int allTimeSeriesMask = static_cast<unsigned int>(timeSeriesLoad)
                                           | static_cast<unsigned int>(timeSeriesHydro)
                                           | static_cast<unsigned int>(timeSeriesWind)
                                           | static_cast<unsigned int>(timeSeriesThermal)
                                           | static_cast<unsigned int>(timeSeriesSolar)
                                           | static_cast<unsigned int>(timeSeriesRenewable)
                                           | static_cast<unsigned int>(
                                             timeSeriesTransmissionCapacities)
                                           | static_cast<unsigned int>(timeSeriesShortTermInflows)
                                           | static_cast<unsigned int>(
                                             timeSeriesShortTermAdditionalConstraints);
constexpr unsigned int timeSeriesCount = std::popcount(allTimeSeriesMask);
 
template<unsigned int T>
requires(T > 0 && (T & (T - 1)) == 0) // T must be power of two
struct TimeSeriesBitPatternIntoIndex
{
    static constexpr int value = std::countr_zero(T);
};
 
template<int T>
struct TimeSeriesToCStr;
 
template<>
struct TimeSeriesToCStr<1>
{
    static const char* Value()
    {
        return "load";
    }
};
 
template<>
struct TimeSeriesToCStr<2>
{
    static const char* Value()
    {
        return "hydro";
    }
};
 
template<>
struct TimeSeriesToCStr<4>
{
    static const char* Value()
    {
        return "wind";
    }
};
 
template<>
struct TimeSeriesToCStr<8>
{
    static const char* Value()
    {
        return "thermal";
    }
};
 
template<>
struct TimeSeriesToCStr<16>
{
    static const char* Value()
    {
        return "solar";
    }
};
 
template<>
struct TimeSeriesToCStr<32>
{
    static const char* Value()
    {
        return "renewable";
    }
};
 
enum SeedIndex
{
    seedTsGenWind = 0,
    seedTsGenLoad,
    seedTsGenHydro,
    seedTsGenThermal,
    seedTsGenSolar,
    seedTimeseriesNumbers,
    seedUnsuppliedEnergyCosts,
    seedSpilledEnergyCosts,
    seedThermalCosts,
    seedHydroCosts,
    seedHydroManagement,
    seedMax,
};
 
constexpr unsigned antaresSeedDefaultValue = 5489;
constexpr unsigned antaresSeedIncrement = 1000000; // arbitrary value
 
const char* SeedToCString(SeedIndex seed);
 
const char* SeedToID(SeedIndex seed);
 
// ... Hydro heuristic policy ...
enum HydroHeuristicPolicy
{
    hhpAccommodateRuleCurves = 0,
    hhpMaximizeGeneration,
    hhpUnknown,
};
 
HydroHeuristicPolicy StringToHydroHeuristicPolicy(const AnyString& text);
 
const char* HydroHeuristicPolicyToCString(HydroHeuristicPolicy hhPolicy);
 
// ... Hydro Pricing ...
enum HydroPricingMode
{
    hpHeuristic = 0,
    hpMILP, // mixed integer linear problem
    hpUnknown,
};
 
const char* HydroPricingModeToCString(HydroPricingMode hpm);
 
HydroPricingMode StringToHydroPricingMode(const AnyString& text);
 
// ... Power fluctuations ...
enum PowerFluctuations
{
    lssFreeModulations = 0,
    lssMinimizeRamping,
    lssMinimizeExcursions,
    lssUnknown,
};
 
const char* PowerFluctuationsToCString(PowerFluctuations fluctuations);
 
PowerFluctuations StringToPowerFluctuations(const AnyString& text);
 
enum SheddingPolicy
{
    shpShavePeaks = 0,
    shpAccurateShavePeaks,
    shpMinimizeDuration,
    shpUnknown,
};
 
const char* SheddingPolicyToCString(SheddingPolicy strategy);
 
SheddingPolicy StringToSheddingPolicy(const AnyString& text);
 
enum UnitCommitmentMode
{
    ucHeuristicFast = 0,
    ucHeuristicAccurate,
    ucMILP,
    ucUnknown,
};
 
const char* UnitCommitmentModeToCString(UnitCommitmentMode ucommitment);
 
UnitCommitmentMode StringToUnitCommitmentMode(const AnyString& text);
 
enum NumberOfCoresMode
{
    ncMin = 0,
    ncLow,
    ncAvg,
    ncHigh,
    ncMax,
    ncUnknown
};
 
const char* NumberOfCoresModeToCString(NumberOfCoresMode ncores);
 
NumberOfCoresMode StringToNumberOfCoresMode(const AnyString& text);
 
/*
 * Renewable generation modelling
 */
enum RenewableGenerationModelling
{
    rgAggregated = 0, // Default
    rgClusters,       // Using renewable clusters
    rgUnknown,
};
 
const char* RenewableGenerationModellingToCString(RenewableGenerationModelling rgModelling);
 
RenewableGenerationModelling StringToRenewableGenerationModelling(const AnyString& text);
 
// ------------------------
// MPS export status
// ------------------------
enum class mpsExportStatus : int
{
    NO_EXPORT = 0,
    EXPORT_FIRST_OPTIM = 1,
    EXPORT_SECOND_OPTIM = 2,
    EXPORT_BOTH_OPTIMS = 3,
    UNKNOWN_EXPORT = 4
};
 
std::string mpsExportStatusToString(const mpsExportStatus& mps_export_status);
mpsExportStatus stringToMPSexportStatus(const AnyString& value);
} // namespace Data
} // namespace Antares
 
namespace Antares::Data::ScenarioBuilder
{
class Rules;
class TSNumberRules;
class Sets;
 
} // namespace Antares::Data::ScenarioBuilder
 
namespace Benchmarking
{
class DurationCollector;
}
 
#endif // __ANTARES_LIBS_STUDY_FWD_H__