GenericManagingModule.h

Go to the documentation of this file.

#ifndef TPM_SRC_GENERIC_MANAGING_MODULE_H
#define TPM_SRC_GENERIC_MANAGING_MODULE_H
 
#include <fstream>
#include <memory>
#include <string>
#include <unordered_set>
#include <utility>
#include <valarray>
 
#include "ChainManager.h"
#include "GenericSubmodule.h"
#include "IniParser.h"
#include "InputManager.h"
#include "SimulationClassBase.h"
 
template <typename T>
class GenericManagingModule
{
    protected:
        SimulationClassBase<T>* sim{};  // access to simulation class parameters
        std::shared_ptr<std::valarray<T>>
            module_field;  // unique field that is defined by module (not a must)
        ChainManager<GenericSubmodule<T>> sub_module_chain{
            "global"};  // A chain manager to store and execute submodel chains.
        std::vector<std::string> m_generic_submodules;  // The submodules that will be loaded into
                                                        // the chain, set by children.
        InputManager ini_file_data;  // The handler for the data which gets passed through the
                                     // module-specific ini-file
        bool in_snapshot{false};  // should something (default the field) be included in snapshot?
        bool in_output{false};    // should something (default the field) be included in output?
        char field_id{
            '?'};  // the output field character. Also identifies return-call from load_snapshot
 
    public:
        GenericManagingModule() {}
 
        virtual ~GenericManagingModule() = default;
 
        GenericManagingModule(SimulationClassBase<T>* l_sim) : sim{l_sim} {}
 
        virtual bool setup(std::vector<std::shared_ptr<GenericSubmodule<T>>> all_submodules)
        {
            return true;
        };  // loads module into necessary module chains (auto load for calculation chains)
        virtual bool exec(std::string_view param) = 0;  // main functionality of the module
 
        // different implementations for exec function, depending on module chain
        virtual bool init() { return true; };
        virtual bool preTimeStep() { return true; };
        virtual bool postTimeStep() { return true; };
        virtual bool postNonLinIter() { return true; };
        virtual bool output() { return true; };
        // Functions needed to specify auto-load and dependency if needed/wanted.
        virtual std::vector<std::string> getChainInsertion() const
        {
            return {};
        };  // Return empty vector as default
        virtual std::vector<std::string> getDependencies() const
        {
            return {};
        };  // Return empty vector as default
        virtual void setSubmoduleList(std::vector<std::string> submodules)
        {
            m_generic_submodules = std::move(submodules);
        };  // TODO: Replace by ini file
        std::vector<std::string> getSubmoduleList() const { return m_generic_submodules; }
 
        // Function to access the name of the module via the base class
        virtual std::string_view getNameLocal() const = 0;  // return name of module
 
        void setSimPointer(SimulationClassBase<T>* sim) { this->sim = sim; }
 
        void setSubmodules(std::vector<std::shared_ptr<GenericSubmodule<T>>> all_submodules)
        {
            std::vector<std::string> chain_names{sub_module_chain.getChainNames()};
            int successfully_inserted_modules{0};
            for (auto& submodule : all_submodules)
            {
                std::unordered_set<std::string> requested_sub_modules(m_generic_submodules.begin(),
                                                                      m_generic_submodules.end());
                if (requested_sub_modules.find(static_cast<std::string>(submodule->getNameLocal()))
                    != requested_sub_modules.end())
                {
                    for (const auto& key : chain_names)
                    {
                        sub_module_chain.insertModule(key, submodule);
                        submodule->setFieldPtr(module_field);
                    }
                    successfully_inserted_modules++;
                }
            }
            if (successfully_inserted_modules != m_generic_submodules.size())
            {
                std::cerr << "[GenericManagingModule]: " << this->getNameLocal()
                          << ": Not all requested modules found in the registry.\n";
                throw std::runtime_error(static_cast<std::string>("[GenericManagingModule]: ")
                                         + static_cast<std::string>(this->getNameLocal())
                                         + static_cast<std::string>(
                                             ": Not all requested modules found in the registry."));
            }
        }
 
        void writeToGlobalIniContent(std::ofstream& global_stream)
        {
            std::unordered_map<std::string, std::any> ini_file_content{this->ini_file_data.data()};
            for (const auto& [key, map_content] : ini_file_content)
            {
                global_stream << static_cast<std::string>(this->getNameLocal()) << "$" << key
                              << " = " << std::any_cast<std::string>(map_content) << "\n";
            }
        }
 
        void overwriteLocalIniContent(
            const std::unordered_map<std::string, std::any>& global_ini_content)
        {
            for (const auto& [key, map_content] : global_ini_content)
            {
                this->ini_file_data.forceValueOverwrite(key,
                                                        std::any_cast<std::string>(map_content));
            }
        }
};
 
#endif