state.h

/*
** Copyright 2007-2024, 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 __SOLVER_VARIABLE_STATE_H__
#define __SOLVER_VARIABLE_STATE_H__
 
#include <array>
#include <vector>
 
#include <yuni/yuni.h>
 
#include <antares/study/area/scratchpad.h>
#include <antares/study/fwd.h>
#include "antares/solver/simulation/sim_structure_donnees.h"
#include "antares/solver/simulation/sim_structure_probleme_economique.h"
 
namespace Antares::Solver::Variable
{
class ThermalState
{
public:
    explicit ThermalState(const Data::AreaList& areas);
 
    class StateForAnArea
    {
    public:
        void initializeFromArea(const Data::Area& area);
        std::vector<double> thermalClustersProductions;
 
        std::vector<double> thermalClustersOperatingCost;
 
        std::vector<uint> numberOfUnitsONbyCluster;
 
        std::vector<double> PMinOfClusters;
 
        std::vector<unsigned int> unitCountLastHour;
        std::vector<double> productionLastHour;
        std::vector<double> pminOfAGroup;
    };
 
    StateForAnArea& operator[](size_t areaIndex);
 
private:
    std::vector<StateForAnArea> thermal;
};
 
class State
{
public:
    explicit State(Data::Study& s);
 
    void initFromAreaIndex(const unsigned int areaIndex, uint numSpace);
 
    void initFromThermalClusterIndex(const unsigned int clusterEnabledIndex);
 
    void yearEndBuildFromThermalClusterIndex(const unsigned int clusterEnabledIndex);
 
private:
    void initFromThermalClusterIndexProduction(const unsigned int clusterEnabledIndex);
 
    void yearEndBuildThermalClusterCalculateStartupCosts(
      const uint& maxDurationON,
      const std::array<uint, HOURS_PER_YEAR>& ON_min,
      const std::array<uint, HOURS_PER_YEAR>& ON_opt,
      const Data::ThermalCluster* currentCluster);
 
    std::array<uint, HOURS_PER_YEAR> computeEconomicallyOptimalNbClustersONforEachHour(
      const uint& maxDurationON,
      const std::array<uint, HOURS_PER_YEAR>& ON_min,
      const std::array<uint, HOURS_PER_YEAR>& ON_max) const;
 
    void yearEndSmoothDispatchedUnitsCount(const unsigned int clusterEnabledIndex, uint numSpace);
 
public:
    void startANewYear();
 
    void yearEndResetThermal();
 
    unsigned int year;
    unsigned int weekInTheYear;
    unsigned int hourInTheYear;
    unsigned int hourInTheWeek;
    unsigned int hourInTheSimulation;
 
    Data::Area* area;
 
    Data::ThermalCluster* thermalCluster;
 
    Data::RenewableCluster* renewableCluster;
    Data::AreaScratchpad* scratchpad;
    Data::AreaLink* link;
 
 
 
    Matrix<> resSpilled;
 
 
    RESULTATS_HORAIRES* hourlyResults;
    VALEURS_DE_NTC_ET_RESISTANCES ntc;
 
    double thermalClusterProductionForYear[HOURS_PER_YEAR];
    uint thermalClusterDispatchedUnitsCountForYear[HOURS_PER_YEAR];
 
    double thermalClusterOperatingCostForYear[HOURS_PER_YEAR];
    double thermalClusterNonProportionalCostForYear[HOURS_PER_YEAR];
    double thermalClusterPMinOfTheClusterForYear[HOURS_PER_YEAR];
 
    double renewableClusterProduction;
 
    const double* dispatchableMargin;
 
    PROBLEME_HEBDO* problemeHebdo;
 
    Data::SimulationMode simulationMode;
    Data::UnitCommitmentMode unitCommitmentMode;
    Data::Study& study;
    // Thermal data, used to compute overall cost, etc.
    ThermalState thermal;
    unsigned int numSpace;
    bool simplexRunNeeded;
 
    // Annual costs to be printed in output into separate files
    // -----------------------------------------------------------------
    // Sum over all year's hours of  :
    // - sum over all areas of variable "overall cost"
    // - sum over all links of variable "hurdle cost".
    // That is : Somme(h in Y)[ Somme(a in areas)(OV. COST[h,a])  +  Somme(l in links)(HURDLE
    // COST[h,l]) ]
    double annualSystemCost = 0.;
    double optimalSolutionCost1 = 0.;
    double optimalSolutionCost2 = 0.;
    double averageOptimizationTime1 = 0.;
    double averageOptimizationTime2 = 0.;
    double averageUpdateTime = 0.;
    // -----------------------------------------------------------------
}; // class State
 
} // namespace Antares::Solver::Variable
 
#include "state.hxx"
 
#endif // __SOLVER_VARIABLE_STATE_H__