GenericSubmodule.h

Go to the documentation of this file.

#ifndef TPM_SRC_GENERIC_SUBMODULE_H
#define TPM_SRC_GENERIC_SUBMODULE_H
 
#include <fstream>
#include <functional>
#include <string>
#include <unordered_set>
#include <valarray>
 
#include "ChainManager.h"
#include "IniParser.h"
#include "InputManager.h"
#include "SimulationClassBase.h"
 
template <typename T>
class GenericSubmodule
{
    protected:
        ChainManager<GenericSubmodule<T>> sub_module_chain{
            "global"};  // A chain manager to store and execute submodel chains.
        std::shared_ptr<std::valarray<T>> module_field;  // pointer to the field that is defined by
                                                         // module managing module (not a must)
        const SimulationClassBase<T>*
            sim{};  // const access to simulation class parameters --> pointer (shared pointer) or
                    // reference? Dummy here as no Simulation class exists so far.
        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
        bool is_set_up{false};
 
    public:
        GenericSubmodule() {}
 
        virtual ~GenericSubmodule() = default;
 
        GenericSubmodule(const 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; };
 
        virtual std::vector<std::string> getDependencies() const
        {
            return {};
        };  // Return empty vector as default
        std::vector<std::string> getSubmoduleList() const { return m_generic_submodules; }
 
        bool isSetUp() { return this->is_set_up; }
        void submodulesSetUp() { this->is_set_up = true; }
 
        // Function to access the name of the submodule via the base class
        virtual std::string_view getNameLocal() const = 0;  // return name of module
 
        virtual void setFieldPtr(std::shared_ptr<std::valarray<T>> field_ptr) {};
 
        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);
                        if (module_field)
                        {
                            submodule->setFieldPtr(module_field);
                        }
                    }
                    successfully_inserted_modules++;
                }
            }
            if (successfully_inserted_modules != m_generic_submodules.size())
            {
                std::cerr << "[GenericSubmodule]: " << this->getNameLocal()
                          << ": Not all requested modules found in the registry.\n";
                throw std::runtime_error(static_cast<std::string>("[GenericSubmodule]: ")
                                         + static_cast<std::string>(this->getNameLocal())
                                         + static_cast<std::string>(
                                             ": Not all requested modules found in the registry."));
            }
            sub_module_chain.resolveDependencies();
        }
 
        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