TemperatureSaverIterationsTool.h

Go to the documentation of this file.

#ifndef TEMPERATURE_SAVER_ITERATIONS_TOOL_H
#define TEMPERATURE_SAVER_ITERATIONS_TOOL_H
 
#define TEMPERATURE_SAVER_ITERATIONS_TOOL_VERSION "6"
 
#include <iostream>
#include <memory>
#include <string>
#include <valarray>
 
#include "../../src/GenericManagingModule.h"
#include "../../src/ModuleFactory.h"
 
template <typename T>
class TemperatureSaverIterationsTool : public GenericManagingModule<T>
{
    private:
        static bool m_registered;
        std::string m_ini_filepath{"tools/TemperatureSaverIterationsTool.ini"};
        int m_number_of_facets;
        int m_numerical_layers;
 
    public:
        TemperatureSaverIterationsTool(SimulationClassBase<T>* sim);
        bool setup(std::vector<std::shared_ptr<GenericSubmodule<T>>> all_submodules) override;
        bool exec(std::string_view param) override;  // main functionality of the module
 
        bool init() override { return true; };
        bool preTimeStep() override;
        bool postTimeStep() override { return true; };
        bool output() override { return true; };
        std::vector<std::string> getChainInsertion() const override
        {
            return this->ini_file_data.getStringVectorParameters("chain_insertion");
        };
 
        static std::shared_ptr<GenericManagingModule<T>> createMethode(SimulationClassBase<T>* sim)
        {
            return std::make_shared<TemperatureSaverIterationsTool<T>>(sim);
        };
        static std::string getName() { return "TemperatureSaverIterationsTool"; };
        std::string_view getNameLocal() const override { return "TemperatureSaverIterationsTool"; };
};
 
// ================= Implementation =================
 
template <typename T>
TemperatureSaverIterationsTool<T>::TemperatureSaverIterationsTool(SimulationClassBase<T>* sim)
    : GenericManagingModule<T>(sim)
{
    try
    {
        std::string ini_folder_path{
            this->sim->m_simulation_config.getStringParameters("ini_folder_path")};
        this->ini_file_data.loadUserInput(ini_folder_path + m_ini_filepath);
        this->m_generic_submodules = this->ini_file_data.getStringVectorParameters("submodules");
    }
    catch (const BadInput& e)
    {
        std::cerr << "[TemperatureSaverIterationsTool]: " << e.what() << '\n';
        throw BadInput(static_cast<std::string>("[TemperatureSaverIterationsTool]: ")
                       + static_cast<std::string>(e.what()));
    }
}
 
template <typename T>
bool TemperatureSaverIterationsTool<T>::setup(
    std::vector<std::shared_ptr<GenericSubmodule<T>>> all_submodules)
{
    try
    {
        m_number_of_facets = this->sim->m_simulation_config.getIntParameters("number_of_facets");
        m_numerical_layers = this->sim->m_simulation_config.getIntParameters("numerical_layers");
        this->sim->m_field_map.insert(
            {"TemperatureSaverIterationsTool",
             std::valarray<double>(
                 this->sim->m_simulation_config.getIntParameters("numerical_layers")
                 * this->sim->m_simulation_config.getIntParameters("number_of_facets"))});
        this->module_field = std::make_shared<std::valarray<T>>(
            this->sim->m_simulation_config.getIntParameters("numerical_layers")
            * this->sim->m_simulation_config.getIntParameters("number_of_facets"));
        this->setSubmodules(all_submodules);
    }
    catch (const BadInput& e)
    {
        std::cerr << "[TemperatureSaverIterationsTool]: Failed to insert field map and/or local "
                     "field!\n[TemperatureSaverIterationsTool]: "
                  << e.what() << '\n';
        throw BadInput(
            static_cast<std::string>(
                "[TemperatureSaverIterationsTool]: Failed to insert field map and/or local "
                "field!\n[TemperatureSaverIterationsTool]: ")
            + static_cast<std::string>(e.what()));
    }
    return true;
}
 
template <typename T>
bool TemperatureSaverIterationsTool<T>::exec(std::string_view param)
{
    if (param == "InitChain")
    {
        return init();
    }
    if (param == "PreTimeStepChain")
    {
        return preTimeStep();
    }
    if (param == "PostTimeStepChain")
    {
        return postTimeStep();
    }
    if (param == "OutputChain")
    {
        return output();
    }
    return false;
}
 
template <typename T>
bool TemperatureSaverIterationsTool<T>::preTimeStep()
{
    for (int i{0}; i < m_number_of_facets; i++)
    {
        this->sim->m_field_map["TemperatureSaverIterationsTool"][i] =
            this->sim->getFieldValue("Temperature", i * m_numerical_layers);
    }
    return true;
}
 
template <typename T>
bool TemperatureSaverIterationsTool<T>::m_registered =
    ModuleFactory<T>::registerModule(getName(), createMethode);
 
#endif  // TEMPERATURE_SAVER_ITERATIONS_TOOL_H