HeatConductivityTwoLayers.h

Go to the documentation of this file.

#ifndef HEAT_CONDUCTIVITY_TWO_LAYERS_H
#define HEAT_CONDUCTIVITY_TWO_LAYERS_H
 
#define VERSION "4"
 
#include <iostream>
#include <memory>
#include <string>
#include <valarray>
 
#include "../../src/GenericSubmodule.h"
#include "../../src/ModuleFactory.h"
 
template <typename T>
class HeatConductivityTwoLayers : public GenericSubmodule<T>
{
    private:
        static bool m_registered;
        std::string m_ini_filepath{"heat_conductivity/HeatConductivityTwoLayers.ini"};
        std::valarray<T> m_temporary_field;
        double m_transition_depth;
        int m_transition_node;
        int m_numerical_layers;
        int m_upper_hc_on_node{0};
 
    public:
        HeatConductivityTwoLayers(SimulationClassBase<T>* sim);
        bool setup(std::vector<std::shared_ptr<GenericSubmodule<T>>> all_submodules)
            override;  // loads module into necessary module chains (auto load for calculation
                       // chains)
        bool exec(std::string_view param) override;  // main functionality of the module
 
        // different implementations for exec function, depending on module chain
        bool init() override;
        bool preTimeStep() override;
        // bool postOuter() {};
        bool postTimeStep() override;
        // bool rheology(){};
        // bool energy() {};
        bool output() override;
 
        void calculateHeatConductivity();
        bool floatingCompare(T f1, T f2, T epsilon);
 
        void calculateTransitionRegion();
 
        void setFieldPtr(std::shared_ptr<std::valarray<T>> field_ptr) override
        {
            this->module_field = field_ptr;
        }
 
        // These static functions are needed for self registration
        static std::shared_ptr<GenericSubmodule<T>> createMethode(SimulationClassBase<T>* sim)
        {
            return std::make_shared<HeatConductivityTwoLayers<T>>(sim);
        }
        // Replace this string with the module name for the registry
        static std::string getName() { return "HeatConductivityTwoLayers"; }
        std::string_view getNameLocal() const override { return "HeatConductivityTwoLayers"; };
        std::vector<std::string> getDependencies() const override
        {
            return this->ini_file_data.getStringVectorParameters("dependencies");
        };
};
 
// ================= Implementation =================
 
template <typename T>
HeatConductivityTwoLayers<T>::HeatConductivityTwoLayers(SimulationClassBase<T>* sim)
    : GenericSubmodule<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 HeatConductivityTwoLayers<T>::setup(
    std::vector<std::shared_ptr<GenericSubmodule<T>>> all_submodules)
{
    this->setSubmodules(all_submodules);
    // This would also be set by the general options within the sim class:
    m_numerical_layers = this->sim->m_simulation_config.getIntParameters("numerical_layers");
    m_temporary_field.resize(m_numerical_layers
                             * this->sim->m_simulation_config.getIntParameters("number_of_facets"));
    m_transition_depth = this->ini_file_data.getDoubleParameters("transition_depth");
    // If the upper heat conductivity value should be used when the transition depth is exactly on a
    // node Set the parameter added to the transition node to 1.
    if (this->ini_file_data.getBoolParameters("use_upper_hc_on_node"))
    {
        m_upper_hc_on_node = 1;
    }
    calculateTransitionRegion();
    return true;
}
 
template <typename T>
bool HeatConductivityTwoLayers<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>
void HeatConductivityTwoLayers<T>::calculateTransitionRegion()
{
    double sum{0.0};
    const std::valarray<T>& cell_lengths{this->sim->getField("CellLength")};
    if (m_transition_depth <= 0.0)
    {
        std::cerr
            << "[HeatConductivityTwoLayers] Negative or zero transition depth chosen. The model "
               "will only represent the second layer heat capacity and no layering will occur.\n";
        m_transition_node = -1;
        return;
    }
    for (int i{0}; i < cell_lengths.size(); i++)
    {
        sum += cell_lengths[i];
        if (floatingCompare(sum, m_transition_depth, 1e-8))
        {
            m_transition_node = i + m_upper_hc_on_node;
            return;
        }
        else if (sum > m_transition_depth)
        {
            m_transition_node = i;
            return;
        }
    }
    std::cerr
        << "[HeatConductivityTwoLayers] Chosen transition depth larger than 1D domain size. The "
           "model will only represent the first layer heat capacity and no layering will occur.\n";
    m_transition_node = m_numerical_layers + 1;
}
 
template <typename T>
bool HeatConductivityTwoLayers<T>::floatingCompare(T f1, T f2, T epsilon)
{
    if (std::abs(f1 - f2) < epsilon)
    {
        return true;
    }
    else
    {
        return std::abs(f1 - f2) < epsilon * std::max(std::abs(f1), std::abs(f2));
    }
}
 
template <typename T>
void HeatConductivityTwoLayers<T>::calculateHeatConductivity()
{
    this->sub_module_chain.runSingleModuleInChain(
        "PreTimeStepChain", this->ini_file_data.getStringVectorParameters("submodules")[0]);
    // for( auto& heat_conductivity : (*this->module_field) )
    m_temporary_field = *(this->module_field);
    this->sub_module_chain.runSingleModuleInChain(
        "PreTimeStepChain", this->ini_file_data.getStringVectorParameters("submodules")[1]);
    for (int i{0}; i < m_temporary_field.size(); i++)
    {
        // Check if the layer within the current facet is above the transition region (in terms of
        // depth)
        if ((i % m_numerical_layers) <= m_transition_node)
        {
            (*this->module_field)[i] = m_temporary_field[i];
        }
    }
}
 
template <typename T>
bool HeatConductivityTwoLayers<T>::init()
{
    std::cout << "I am the init function of the HeatConductivityTwoLayers!\n";
    calculateHeatConductivity();
    return true;
}
 
template <typename T>
bool HeatConductivityTwoLayers<T>::preTimeStep()
{
    std::cout << "I am the preTS function of the HeatConductivityTwoLayers!\n";
    calculateHeatConductivity();
    return true;
}
 
template <typename T>
bool HeatConductivityTwoLayers<T>::postTimeStep()
{
    std::cout << "I am the postTS function of the HeatConductivityTwoLayers!\n";
    return true;
}
 
template <typename T>
bool HeatConductivityTwoLayers<T>::output()
{
    std::cout << "I am the output function of the HeatConductivityTwoLayers!\n";
    return true;
}
 
template <typename T>
bool HeatConductivityTwoLayers<T>::m_registered =
    ModuleFactory<T>::registerModule(getName(), createMethode);
 
#endif // HEAT_CONDUCTIVITY_TWO_LAYERS_H