spatial-aggregate.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/>.
 */
#pragma once
 
#include "antares/solver/variable/variable.h"
 
// #include <antares/logs/logs.h>   // In case it is needed
 
namespace Antares::Solver::Variable::Common
{
template<int ColumnCountT, class VCardT>
struct MultipleCaptionProxy
{
    static std::string Caption(const uint indx)
    {
        return VCardT::Multiple::Caption(indx);
    }
 
    static std::string Unit(const unsigned int indx)
    {
        return VCardT::Multiple::Unit(indx);
    }
};
 
template<class VCardT>
struct MultipleCaptionProxy<0, VCardT>
{
    static std::string Caption(const uint)
    {
        return "";
    }
 
    static std::string Unit(const uint)
    {
        return "";
    }
};
 
template<class VCardT>
struct MultipleCaptionProxy<1, VCardT>
{
    static std::string Caption(const uint)
    {
        return "";
    }
 
    static std::string Unit(const uint)
    {
        return "";
    }
};
 
template<class VCardT>
struct MultipleCaptionProxy<Category::dynamicColumns, VCardT>
{
    static std::string Caption(const uint)
    {
        return "";
    }
 
    static std::string Unit(const uint)
    {
        return "";
    }
};
 
template<template<class> class V>
struct VCardProxy
{
    typedef typename V<Container::EndOfList>::VCardType VCardOrigin;
 
    static std::string Caption()
    {
        return VCardOrigin::Caption();
    }
 
    static std::string Unit()
    {
        return VCardOrigin::Unit();
    }
 
    static std::string Description()
    {
        return VCardOrigin::Description();
    }
 
    typedef typename VCardOrigin::ResultsType ResultsType;
    typedef typename VCardOrigin::VCardForSpatialAggregate VCardForSpatialAggregate;
 
    typedef typename VCardOrigin::IntermediateValuesType IntermediateValuesType;
    typedef typename VCardOrigin::IntermediateValuesBaseType IntermediateValuesBaseType;
    typedef
      typename VCardOrigin::IntermediateValuesTypeForSpatialAg IntermediateValuesTypeForSpatialAg;
 
    static constexpr uint8_t categoryDataLevel = Category::DataLevel::setOfAreas;
    static constexpr uint8_t categoryFileLevel = VCardOrigin::categoryFileLevel;
    static constexpr uint8_t precision = VCardOrigin::precision;
    static constexpr uint8_t nodeDepthForGUI = +0;
    static constexpr uint8_t decimal = VCardOrigin::decimal;
    static constexpr int columnCount = VCardOrigin::columnCount;
    static constexpr uint8_t spatialAggregate = Category::noSpatialAggregate;
    static constexpr uint8_t spatialAggregateMode = Category::spatialAggregateEachYear;
    static constexpr uint8_t spatialAggregatePostProcessing = 0;
 
    static constexpr uint8_t hasIntermediateValues = 1;
    static constexpr uint8_t isPossiblyNonApplicable = VCardOrigin::isPossiblyNonApplicable;
 
    struct Multiple
    {
        static std::string Caption(const uint indx)
        {
            return MultipleCaptionProxy<columnCount, VCardOrigin>::Caption(indx);
        }
 
        static std::string Unit(const unsigned int indx)
        {
            return MultipleCaptionProxy<columnCount, VCardOrigin>::Unit(indx);
        }
    };
 
}; // class VCard
 
template<template<class> class VarT, class NextT = Container::EndOfList>
class SpatialAggregate
    : public Variable::IVariable<SpatialAggregate<VarT, NextT>, NextT, VCardProxy<VarT>>
{
public:
    typedef NextT NextType;
 
    typedef VCardProxy<VarT> VCardType;
    typedef Variable::IVariable<SpatialAggregate<VarT, NextT>, NextT, VCardType> AncestorType;
 
    typedef typename VCardType::ResultsType ResultsType;
 
    typedef VariableAccessor<ResultsType, VCardType::columnCount> VariableAccessorType;
 
    enum
    {
        count = 1 + NextT::count,
    };
 
    template<int CDataLevel, int CFile>
    struct Statistics
    {
        enum
        {
            count = ((VCardType::categoryDataLevel & CDataLevel
                      && VCardType::categoryFileLevel & CFile)
                       ? (NextType::template Statistics<CDataLevel, CFile>::count
                          + VCardType::columnCount * ResultsType::count)
                       : NextType::template Statistics<CDataLevel, CFile>::count),
        };
    };
 
public:
    void initializeFromStudy(Data::Study& study)
    {
        typedef
          typename VCardType::VCardOrigin::IntermediateValuesBaseType IntermediateValuesBaseType;
        pNbYearsParallel = study.maxNbYearsInParallel;
 
        // Intermediate values
        VarT<Container::EndOfList>::InitializeResultsFromStudy(AncestorType::pResults, study);
        pValuesForTheCurrentYear = std::make_unique<IntermediateValuesBaseType[]>(pNbYearsParallel);
        for (unsigned int numSpace = 0; numSpace < pNbYearsParallel; numSpace++)
        {
            VariableAccessorType::InitializeAndReset(pValuesForTheCurrentYear[numSpace], study);
        }
 
        // Next
        NextType::initializeFromStudy(study);
    }
 
    void initializeFromArea(Data::Study* study, Data::Area* area)
    {
        // Next
        NextType::initializeFromArea(study, area);
    }
 
    void initializeFromLink(Data::Study* study, Data::AreaLink* link)
    {
        // Next
        NextType::initializeFromAreaLink(study, link);
    }
 
    void simulationBegin()
    {
        // Next
        NextType::simulationBegin();
    }
 
    void simulationEnd()
    {
        NextType::simulationEnd();
    }
 
    void yearBegin(uint year)
    {
        // Next variable
        NextType::yearBegin(year);
    }
 
    void yearEndBuildPrepareDataForEachThermalCluster(State& state, uint year)
    {
        // Next variable
        NextType::yearEndBuildPrepareDataForEachThermalCluster(state, year);
    }
 
    void yearEndBuildForEachThermalCluster(State& state, uint year)
    {
        // Next variable
        NextType::yearEndBuildForEachThermalCluster(state, year);
    }
 
    void yearEndBuild(State& state, unsigned int year, unsigned int numSpace)
    {
        // Next variable
        NextType::yearEndBuild(state, year, numSpace);
    }
 
    void yearEnd(uint year)
    {
        // Next variable
        NextType::yearEnd(year);
    }
 
    void weekBegin(State& state)
    {
        // Next variable
        NextType::weekBegin(state);
    }
 
    void weekEnd(State& state)
    {
        // Next variable
        NextType::weekEnd(state);
    }
 
    void hourBegin(uint hourInTheYear)
    {
        // Next variable
        NextType::hourBegin(hourInTheYear);
    }
 
    void hourForEachArea(State& state, unsigned int numSpace)
    {
        // Next variable
        NextType::hourForEachArea(state, numSpace);
    }
 
    template<class V, class SetT>
    void yearEndSpatialAggregates(V& allVars, uint year, const SetT& set, uint numSpace)
    {
        if (VCardType::VCardOrigin::spatialAggregateMode & Category::spatialAggregateEachYear)
        {
            internalSpatialAggregateForCurrentYear(allVars, set, numSpace);
        }
 
        // Next variable
        NextType::yearEndSpatialAggregates(allVars, year, set, numSpace);
    }
 
    template<class V>
    void computeSpatialAggregatesSummary(V& allVars, unsigned int year, unsigned int numSpace)
    {
        if (VCardType::VCardOrigin::spatialAggregateMode & Category::spatialAggregateEachYear)
        {
            internalSpatialAggregateForParallelYears(year, numSpace);
        }
 
        // Next variable
        NextType::computeSpatialAggregatesSummary(allVars, year, numSpace);
    }
 
    template<class V, class SetT>
    void simulationEndSpatialAggregates(V& allVars, const SetT& set)
    {
        if (VCardType::VCardOrigin::spatialAggregateMode & Category::spatialAggregateOnce)
        {
            internalSpatialAggregate(allVars, 0, set);
        }
 
        // Next variable
        NextType::simulationEndSpatialAggregates(allVars, set);
    }
 
    inline void buildDigest(SurveyResults& results, int digestLevel, int dataLevel) const
    {
        // Generate the Digest for the local results (districts part)
        if (VCardType::columnCount != 0
            && (VCardType::categoryDataLevel & Category::DataLevel::setOfAreas))
        {
            // Initializing pointer on variable non applicable and print stati arrays to beginning
            results.isPrinted = AncestorType::isPrinted;
            results.isCurrentVarNA = AncestorType::isNonApplicable;
 
            VariableAccessorType::template BuildDigest<typename VCardType::VCardOrigin>(
              results,
              AncestorType::pResults,
              digestLevel,
              dataLevel);
        }
        // Ask to build the digest to the next variable
        NextType::buildDigest(results, digestLevel, dataLevel);
    }
 
    void localBuildAnnualSurveyReport(SurveyResults& results,
                                      int fileLevel,
                                      int precision,
                                      uint numSpace) const
    {
        if (VCardType::columnCount != 0
            && (VCardType::categoryDataLevel & Category::DataLevel::setOfAreas))
        {
            // Initializing pointer on variable non applicable and print stati arrays to beginning
            results.isPrinted = AncestorType::isPrinted;
            results.isCurrentVarNA = AncestorType::isNonApplicable;
 
            typedef VariableAccessor<typename VCardType::IntermediateValuesBaseType,
                                     VCardType::columnCount>
              VAType;
            VAType::template BuildAnnualSurveyReport<typename VCardType::VCardOrigin>(
              results,
              pValuesForTheCurrentYear[numSpace],
              fileLevel,
              precision);
        }
    }
 
private:
    template<class V, class SetT>
    void internalSpatialAggregate(V& allVars, uint year, const SetT& set)
    {
        typedef typename VCardType::VCardOrigin VCardOrigin;
        // Reset the results
        VariableAccessorType::Reset(pValuesForTheCurrentYear[0]);
 
        // Make the spatial cluster
        if (!set.empty())
        {
            auto end = set.end();
            for (auto i = set.begin(); i != end; ++i)
            {
                allVars.template computeSpatialAggregateWith<
                  typename VCardType::VCardForSpatialAggregate> //<typename VCardType::VCardOrigin>
                  (pValuesForTheCurrentYear[0], *i /* the current area */, 0);
            }
 
            // The spatial cluster may be an average
            if (VCardType::VCardOrigin::spatialAggregate & Category::spatialAggregateAverage)
            {
                VariableAccessorType::MultiplyHourlyResultsBy(pValuesForTheCurrentYear[0],
                                                              1. / set.size());
            }
            // The spatial cluster may be an average
            if (VCardType::VCardOrigin::spatialAggregate
                & Category::spatialAggregateSumThen1IfPositive)
            {
                VariableAccessorType::SetTo1IfPositive(pValuesForTheCurrentYear[0]);
            }
            if (VCardType::VCardOrigin::spatialAggregate & Category::spatialAggregateOr)
            {
                VariableAccessorType::Or(pValuesForTheCurrentYear[0]);
            }
        }
        else
        {
            assert(!set.empty() && "The set should not be empty at this point");
        }
 
        // Compute all statistics for the current year (daily,weekly,monthly,...)
        VariableAccessorType::template ComputeStatistics<VCardOrigin>(pValuesForTheCurrentYear[0]);
        VariableAccessorType::ComputeSummary(pValuesForTheCurrentYear[0],
                                             AncestorType::pResults,
                                             year);
    }
 
    template<class V, class SetT>
    void internalSpatialAggregateForCurrentYear(V& allVars, const SetT& set, uint numSpace)
    {
        typedef typename VCardType::VCardOrigin VCardOrigin;
        // Reset the results
        VariableAccessorType::Reset(pValuesForTheCurrentYear[numSpace]);
 
        // Make the spatial cluster
        if (!set.empty())
        {
            // We compute the district's (or set) hourly values by looping over district's areas
            // and calling computeSpatialAggregateWith on each area.
            // The aggregated results is stored in pValuesForTheCurrentYear[numSpace].
            auto end = set.end();
            for (auto i = set.begin(); i != end; ++i)
            {
                // computeSpatialAggregateWith is called with VCardType::VCardForSpatialAggregate
                // as a template parameter.
                // Note that VCardType represents the vcard of the current spatial aggregate's
                // variable (template parameter VarT).
                // For most variables VCardType::VCardOrigin and
                // VCardType::VCardForSpatialAggregate are identical vcard types.
                // For example : for var OverallCost, VCardOverallCost::VCardForSpatialAggregate
                // is simply VCardOverallCost itself.
                // But var LOLD is different : VCardLOLD::VCardForSpatialAggregate is actually
                // VCardUnsupliedEnergy.
                // This means that, here :
                // - for OverallCost, we sum the hourly values of var OverallCost for each
                //   district's areas.
                allVars.template computeSpatialAggregateWith<
                  typename VCardType::VCardForSpatialAggregate>(pValuesForTheCurrentYear[numSpace],
                                                                *i /* the current area */,
                                                                numSpace);
            }
 
            // The spatial cluster may be an average
            if (VCardType::VCardOrigin::spatialAggregate & Category::spatialAggregateAverage)
            {
                VariableAccessorType::MultiplyHourlyResultsBy(pValuesForTheCurrentYear[numSpace],
                                                              1. / set.size());
            }
            // The spatial cluster may be an average
            if (VCardType::VCardOrigin::spatialAggregate
                & Category::spatialAggregateSumThen1IfPositive)
            {
                VariableAccessorType::SetTo1IfPositive(pValuesForTheCurrentYear[numSpace]);
            }
            if (VCardType::VCardOrigin::spatialAggregate & Category::spatialAggregateOr)
            {
                VariableAccessorType::Or(pValuesForTheCurrentYear[numSpace]);
            }
        }
        else
        {
            assert(!set.empty() && "The set should not be empty at this point");
        }
 
        // Compute all statistics for the current year (daily,weekly,monthly,...)
        VariableAccessorType::template ComputeStatistics<VCardOrigin>(
          pValuesForTheCurrentYear[numSpace]);
    }
 
    void internalSpatialAggregateForParallelYears(unsigned int year, unsigned int numSpace)
    {
        // Merge all those values with the global results
        VariableAccessorType::ComputeSummary(pValuesForTheCurrentYear[numSpace],
                                             AncestorType::pResults,
                                             year);
    }
 
private:
    VCardType::IntermediateValuesTypeForSpatialAg pValuesForTheCurrentYear;
 
    unsigned int pNbYearsParallel;
 
}; // class SpatialAggregate
 
// Variadic meta-template to build nested spatial aggregates
template<template<class> class Head, template<class> class... Tail>
struct SpatialAggregateAll
{
    using type = SpatialAggregate<Head, typename SpatialAggregateAll<Tail...>::type>;
};
 
template<template<class> class Last>
struct SpatialAggregateAll<Last>
{
    using type = SpatialAggregate<Last>;
};
 
} // namespace Antares::Solver::Variable::Common