FluxSmoothingTool.h

Go to the documentation of this file.

#ifndef FLUX_SMOOTHING_TOOL_H
#define FLUX_SMOOTHING_TOOL_H
 
#define VERSION "5"
 
#include <iostream>
#include <memory>
#include <string>
#include <valarray>
 
#include "../../src/GenericManagingModule.h"
#include "../../src/ModuleFactory.h"
 
template <typename T>
class FluxSmoothingTool : public GenericManagingModule<T>
{
    private:
        static bool m_registered;
        std::string m_ini_filepath{"tools/FluxSmoothingTool.ini"};
        std::valarray<T> m_temp_previous_timestep;
        T m_initial_dt;
        int m_smoothing_counter{0};
        T m_upper_threshold{};
        T m_lower_threshold{};
        bool m_flux_smoothing_active{false};
        bool m_pre_iter{true};
 
        void fluxSmoothing();
 
    public:
        FluxSmoothingTool(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 postNonLinIter() override { return true; };
        bool postTimeStep() override;
        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<FluxSmoothingTool<T>>(sim);
        };
        static std::string getName() { return "FluxSmoothingTool"; };
        std::string_view getNameLocal() const override { return "FluxSmoothingTool"; };
};
 
// ================= Implementation =================
 
template <typename T>
FluxSmoothingTool<T>::FluxSmoothingTool(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 << e.what() << '\n';
    }
}
 
template <typename T>
bool FluxSmoothingTool<T>::setup(std::vector<std::shared_ptr<GenericSubmodule<T>>> all_submodules)
{
    this->m_generic_submodules = this->ini_file_data.getStringVectorParameters("submodules");
    this->setSubmodules(all_submodules);
    m_upper_threshold = this->ini_file_data.getDoubleParameters("upper_threshold");
    m_lower_threshold = this->ini_file_data.getDoubleParameters("lower_threshold");
    m_initial_dt = this->sim->m_simulation_config.getDoubleParameters("time_delta");
 
    return true;
}
 
template <typename T>
bool FluxSmoothingTool<T>::exec(std::string_view param)
{
    if (param == "InitChain")
    {
        return init();
    }
    if (param == "PreTimeStepChain")
    {
        return preTimeStep();
    }
    if (param == "PostNonLinIterChain")
    {
        return postNonLinIter();
    }
    if (param == "PostTimeStepChain")
    {
        return postTimeStep();
    }
    if (param == "OutputChain")
    {
        return output();
    }
    return false;
}
 
template <typename T>
bool FluxSmoothingTool<T>::preTimeStep()
{
    // Get the previous temp in the step here. Since this is within the inner iteration loop
    // (iterations within one time step for non-isothermal/non-linear parameters), we only want to
    // grab the first one
    if (m_pre_iter)
    {
        m_temp_previous_timestep = this->sim->getField("Temperature");
        m_pre_iter = false;
    }
    return true;
}
 
template <typename T>
bool FluxSmoothingTool<T>::postTimeStep()
{
    fluxSmoothing();
    return true;
}
 
template <typename T>
bool FluxSmoothingTool<T>::m_registered =
    ModuleFactory<T>::registerModule(getName(), createMethode);
 
template <typename T>
void FluxSmoothingTool<T>::fluxSmoothing()
{
    // Reset pre_iter bool here, as this is after the inner iteration loop (iterations within one
    // time step for non-isothermal/non-linear parameters)
    m_pre_iter = true;
    if (!m_flux_smoothing_active
        && (this->sim->getFieldValue("Temperature", 0)
                > m_upper_threshold * m_temp_previous_timestep[0]
            || this->sim->getFieldValue("Temperature", 0)
                   < m_lower_threshold * m_temp_previous_timestep[0]))
    {
        if (m_flux_smoothing_active)
        {
            throw std::runtime_error(
                "Double smoothing needed, which is not implemented! Please choose a smaller "
                "timestep.");
        }
        this->sim->m_field_map["Temperature"] = m_temp_previous_timestep;
        this->sim->m_simulation_config.forceValueOverwrite("time_delta",
                                                           std::to_string(m_initial_dt / 5));
        this->sim->elapsed_time -= m_initial_dt;
        this->sim->time_step =
            (this->sim->time_step - 1)
            * 5;  // Map the time steps on the smaller time delta and reset to previous step
        m_flux_smoothing_active = true;
        m_smoothing_counter = 0;
    }
 
    if (m_flux_smoothing_active)
    {
        if (m_smoothing_counter == 5)
        {
            this->sim->m_simulation_config.forceValueOverwrite("time_delta",
                                                               std::to_string(m_initial_dt));
            this->sim->time_step /= 5;
            m_flux_smoothing_active = false;
            m_smoothing_counter = 0;
        }
        m_smoothing_counter++;
    }
}
 
#endif // FLUX_SMOOTHING_TOOL_H