HeatConductivityVariableGundlach2013RegolithSolid.h

Go to the documentation of this file.

#ifndef HEAT_CONDUCTIVITY_VARIABLE_GUNDLACH_2013_REGOLITH_SOLID_H
#define HEAT_CONDUCTIVITY_VARIABLE_GUNDLACH_2013_REGOLITH_SOLID_H
 
#define HEAT_CONDUCTIVITY_VARIABLE_GUNDLACH_2013_REGOLITH_SOLID_VERSION "7"
 
#include <iostream>
#include <memory>
#include <numbers>
#include <string>
#include <valarray>
 
#include "../../src/GenericSubmodule.h"
#include "../../src/ModuleFactory.h"
 
template <typename T>
class HeatConductivityVariableGundlach2013RegolithSolid : public GenericSubmodule<T>
{
    private:
        static bool m_registered;
        std::string m_ini_filepath{
            "heat_conductivity/HeatConductivityVariableGundlach2013RegolithSolid.ini"};
        T m_stefan_boltzmann_const{};
        T m_boltzmann_const{};
        T m_solar_const{};
        T m_gas_const{};
        T m_poissons_ratio{};
        T m_youngs_modulus{};
        T m_f1{};
        T m_f2{};
        T m_chi{};
        T m_e1{};
        T m_grain_radius{};
        T m_volume_filling_factor{};
        T m_emissivity{};
 
    public:
        HeatConductivityVariableGundlach2013RegolithSolid(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
 
        bool init() override;
        bool preTimeStep() override;
        bool postTimeStep() override { return true; };
        bool output() override { return true; };
 
        void calculateHeatConductivity();
 
        void setFieldPtr(std::shared_ptr<std::valarray<T>> field_ptr) override
        {
            this->module_field = field_ptr;
        }
 
        static std::shared_ptr<GenericSubmodule<T>> createMethode(SimulationClassBase<T>* sim)
        {
            return std::make_shared<HeatConductivityVariableGundlach2013RegolithSolid<T>>(sim);
        }
        static std::string getName() { return "HeatConductivityVariableGundlach2013RegolithSolid"; }
        std::string_view getNameLocal() const override
        {
            return "HeatConductivityVariableGundlach2013RegolithSolid";
        };
        std::vector<std::string> getDependencies() const override
        {
            return this->ini_file_data.getStringVectorParameters("dependencies");
        };
};
 
// ================= Implementation =================
 
template <typename T>
HeatConductivityVariableGundlach2013RegolithSolid<
    T>::HeatConductivityVariableGundlach2013RegolithSolid(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 << "[HeatConductivityVariableGundlach2013RegolithSolid]: " << e.what() << '\n';
        throw BadInput(
            static_cast<std::string>("[HeatConductivityVariableGundlach2013RegolithSolid]: ")
            + static_cast<std::string>(e.what()));
    }
}
 
template <typename T>
bool HeatConductivityVariableGundlach2013RegolithSolid<T>::setup(
    std::vector<std::shared_ptr<GenericSubmodule<T>>> all_submodules)
{
    try
    {
        m_stefan_boltzmann_const =
            this->ini_file_data.getDoubleParameters("stefan_boltzmann_const");
        m_boltzmann_const = this->ini_file_data.getDoubleParameters("boltzmann_const");
        m_solar_const = this->ini_file_data.getDoubleParameters("solar_const");
        m_gas_const = this->ini_file_data.getDoubleParameters("gas_const");
        m_poissons_ratio = this->ini_file_data.getDoubleParameters("poissons_ratio");
        m_youngs_modulus = this->ini_file_data.getDoubleParameters("youngs_modulus");
        m_f1 = this->ini_file_data.getDoubleParameters("f1");
        m_f2 = this->ini_file_data.getDoubleParameters("f2");
        m_chi = this->ini_file_data.getDoubleParameters("chi");
        m_e1 = this->ini_file_data.getDoubleParameters("e1");
        m_grain_radius = this->ini_file_data.getDoubleParameters("grain_radius");
        m_volume_filling_factor = this->ini_file_data.getDoubleParameters("volume_filling_factor");
 
        this->setSubmodules(all_submodules);
 
        this->is_set_up = true;
    }
    catch (const BadInput& e)
    {
        std::cerr << "[HeatConductivityVariableGundlach2013RegolithSolid]: " << e.what() << '\n';
        throw BadInput(
            static_cast<std::string>("[HeatConductivityVariableGundlach2013RegolithSolid]: ")
            + static_cast<std::string>(e.what()));
    }
    return true;
}
 
template <typename T>
bool HeatConductivityVariableGundlach2013RegolithSolid<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 HeatConductivityVariableGundlach2013RegolithSolid<T>::calculateHeatConductivity()
{
    try
    {
        m_emissivity = this->sim->getField("Emissivity")[0];
    }
    catch (const BadInput& e)
    {
        std::cerr << "[HeatConductivityVariableGundlach2013RegolithSolid]: Emissivity module not "
                     "loaded or accessable!\n [HeatConductivityVariableGundlach2013RegolithSolid]:"
                  << e.what() << '\n';
        throw BadInput(static_cast<std::string>(
                           "[HeatConductivityVariableGundlach2013RegolithSolid]: Emissivity module "
                           "not loaded or "
                           "accessable!\n [HeatConductivityVariableGundlach2013RegolithSolid]:")
                       + static_cast<std::string>(e.what()));
    }
    const std::valarray<T>& temperature{this->sim->getField("Temperature")};
    this->sub_module_chain.runChain("PreTimeStepChain");  // Solid heat conductivity
    for (int i = 0; i < temperature.size(); ++i)
    {
        (*this->module_field)[i] =
            8 * (this->m_stefan_boltzmann_const) * (this->m_emissivity)
                * std::pow(temperature[i], 3.) * (this->m_e1)
                * (1 - (this->m_volume_filling_factor)) / (this->m_volume_filling_factor)
                * (this->m_grain_radius)
            + (*this->module_field)[i]
                  * std::pow(
                      (9. * std::numbers::pi / 4.)
                          * ((1. - std::pow(this->m_poissons_ratio, 2)) / (this->m_youngs_modulus))
                          * (6.67e-5 * temperature[i]) / (this->m_grain_radius),
                      (1. / 3.))
                  * (this->m_f1)
                  * std::pow((this->m_f2) * (this->m_volume_filling_factor), std::numbers::e)
                  * (this->m_chi);
    }
}
 
template <typename T>
bool HeatConductivityVariableGundlach2013RegolithSolid<T>::preTimeStep()
{
    calculateHeatConductivity();
    return true;
}
 
template <typename T>
bool HeatConductivityVariableGundlach2013RegolithSolid<T>::init()
{
    calculateHeatConductivity();
    return true;
}
 
template <typename T>
bool HeatConductivityVariableGundlach2013RegolithSolid<T>::m_registered =
    ModuleFactory<T>::registerModule(getName(), createMethode);
 
#endif  // HEAT_CONDUCTIVITY_VARIABLE_GUNDLACH_2013_REGOLITH_SOLID_H