SolarFluxVariablePotter2023Radiosity.h

Go to the documentation of this file.

#ifndef SOLAR_FLUX_VARIABLE_POTTER_2023_RADIOSITY_H
#define SOLAR_FLUX_VARIABLE_POTTER_2023_RADIOSITY_H
 
#define VERSION "4"
 
#ifdef VTK_PRESENT
#include <cmath>
#include <iostream>
#include <memory>
#include <numbers>
#include <string>
#include <valarray>
 
#include "../../src/GenericSubmodule.h"
#include "../../src/ModuleFactory.h"
#include "../../src/PhysicalConstants.h"
#include "../../src/VtkRayCasting.h"
 
template <typename T>
class SolarFluxVariablePotter2023Radiosity : public GenericSubmodule<T>
{
    private:
        static bool m_registered;
        std::string m_ini_filepath{"solar_flux/SolarFluxVariablePotter2023Radiosity.ini"};
 
        std::unique_ptr<VtkRayCasting> m_ray_caster;
        int m_num_facets;
        int m_numerical_layers;
        int m_check_timestep{0};
        std::string m_shape_model_path;
        std::vector<std::vector<double>> m_viewfactor_matrix;
        std::valarray<T> m_flux_sol;
        std::valarray<T> m_albedo;
        std::valarray<T> m_emissivity;
        std::valarray<T> m_flux_radiative;
        std::valarray<T> m_flux_reflected;
        std::valarray<T> m_flux_infrared;
        std::valarray<T> m_flux_reflected_temp;
        std::valarray<T> m_flux_infrared_temp;
        std::valarray<T> m_heat_conduction_flux;
        T m_stefan_boltzmann_const;
        T m_solar_const;
        void calculateViewfactorMatrix();
        void calculateFluxTotal(const std::valarray<T>& sol_vec, T initial_flux);
        void radiosityCalcFirstTimeStep(const std::vector<T>& direct_solar_flux);
        void radiosityCalc(const std::vector<T>& direct_solar_flux);
 
    public:
        SolarFluxVariablePotter2023Radiosity(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 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<SolarFluxVariablePotter2023Radiosity<T>>(sim);
        }
        static std::string getName() { return "SolarFluxVariablePotter2023Radiosity"; }
        std::string_view getNameLocal() const override
        {
            return "SolarFluxVariablePotter2023Radiosity";
        };
        std::vector<std::string> getDependencies() const override
        {
            return this->ini_file_data.getStringVectorParameters("dependencies");
        };
};
 
// ================= Implementation =================
 
template <typename T>
SolarFluxVariablePotter2023Radiosity<T>::SolarFluxVariablePotter2023Radiosity(
    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 SolarFluxVariablePotter2023Radiosity<T>::setup(
    std::vector<std::shared_ptr<GenericSubmodule<T>>> all_submodules)
{
    m_shape_model_path = this->sim->m_simulation_config.getStringParameters("shape_model_path");
    m_ray_caster = std::make_unique<VtkRayCasting>(m_shape_model_path.c_str());
    m_num_facets = m_ray_caster->getFacetNumber();
    if (m_num_facets != this->sim->m_simulation_config.getIntParameters("number_of_facets"))
    {
        throw std::runtime_error(
            "Number of facets does not match the number of facets on the shape model!\n The "
            "supplied number of facets is "
            + std::to_string(this->sim->m_simulation_config.getIntParameters("number_of_facets"))
            + ", while the number of facets on the shape model is " + std::to_string(m_num_facets)
            + ".\n");
    }
    m_numerical_layers = this->sim->m_simulation_config.getIntParameters("numerical_layers");
    m_flux_sol.resize(m_num_facets);
    m_albedo.resize(m_num_facets);
    m_emissivity.resize(m_num_facets);
    m_flux_radiative.resize(m_num_facets);
    m_flux_reflected.resize(m_num_facets);
    m_flux_infrared.resize(m_num_facets);
    m_flux_reflected_temp.resize(m_num_facets);
    m_flux_infrared_temp.resize(m_num_facets);
    m_heat_conduction_flux.resize(m_num_facets);
    m_solar_const = PhysicalConstants::solar_const;
    m_stefan_boltzmann_const = PhysicalConstants::stefan_boltzmann_const;
    return true;
}
 
template <typename T>
bool SolarFluxVariablePotter2023Radiosity<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 SolarFluxVariablePotter2023Radiosity<T>::radiosityCalcFirstTimeStep(
    const std::vector<T>& direct_solar_flux)
{
    for (int i{0}; i < m_num_facets; i++)
    {
        m_flux_sol[i] = (1 - m_albedo[i]) * direct_solar_flux[i] + m_heat_conduction_flux[i];
        m_flux_infrared[i] = 0;
        m_flux_reflected[i] = 0;
    }
}
 
template <typename T>
void SolarFluxVariablePotter2023Radiosity<T>::radiosityCalc(const std::vector<T>& direct_solar_flux)
{
    for (int i{0}; i < m_num_facets; i++)
    {
        m_flux_reflected_temp[i] = direct_solar_flux[i] + m_flux_reflected[i];
        m_flux_infrared_temp[i] = m_flux_radiative[i] + (1 - m_emissivity[i]) * m_flux_infrared[i];
        m_flux_reflected[i] = 0;
        m_flux_infrared[i] = 0;
    }
    for (int i{0}; i < m_num_facets; i++)
    {
        for (int j{0}; j < m_num_facets; j++)
        {
            m_flux_reflected[i] +=
                m_viewfactor_matrix[i][j] * m_albedo[i] * m_flux_reflected_temp[j];
            m_flux_infrared[i] += m_viewfactor_matrix[i][j] * m_flux_infrared_temp[j];
        }
 
        m_flux_sol[i] = (1 - m_albedo[i]) * (direct_solar_flux[i] + m_flux_reflected[i])
                        + m_emissivity[i] * m_flux_infrared[i];
    }
}
 
template <typename T>
void SolarFluxVariablePotter2023Radiosity<T>::calculateFluxTotal(const std::valarray<T>& sol_vec,
                                                                 T initial_flux)
{
    double sol_vec_c[3] = {sol_vec[0], sol_vec[1], sol_vec[2]};
    std::vector<double> direct_solar_flux =
        m_ray_caster->getSolarIrradiation(sol_vec_c, initial_flux);
    const std::valarray<T>& temperature_field{this->sim->getField("Temperature")};
    const std::valarray<T>& heat_conductivity_field{this->sim->getField("HeatConductivity")};
    T top_cell_length{this->sim->getFieldValue("CellLength", 0)};
    for (int i{0}; i < m_num_facets; i++)
    {
        m_flux_radiative[i] = m_emissivity[i] * m_stefan_boltzmann_const
                              * pow(temperature_field[i * m_numerical_layers], 4);
    }
    if (this->sim->time_step == 1)
    {
        for (int i{0}; i < m_num_facets; i++)
        {
            m_heat_conduction_flux[i] = heat_conductivity_field[i * m_numerical_layers]
                                        * (temperature_field[i * m_numerical_layers]
                                           - temperature_field[i * m_numerical_layers + 1])
                                        / top_cell_length;
        }
        radiosityCalcFirstTimeStep(direct_solar_flux);
    }
    else
    {
        radiosityCalc(direct_solar_flux);
    }
}
 
template <typename T>
void SolarFluxVariablePotter2023Radiosity<T>::calculateViewfactorMatrix()
{
    m_viewfactor_matrix = m_ray_caster->getViewfactorMatrix();
}
 
template <typename T>
bool SolarFluxVariablePotter2023Radiosity<T>::init()
{
    calculateViewfactorMatrix();
    m_albedo = this->sim->getField("Albedo");
    m_emissivity = this->sim->getField("Emissivity");
    return true;
}
 
template <typename T>
bool SolarFluxVariablePotter2023Radiosity<T>::preTimeStep()
{
    if (this->sim->time_step > m_check_timestep)
    {
        m_check_timestep = this->sim->time_step;
        const std::valarray<T>& sol_vec{this->sim->getField("SolarVector")};
        const std::valarray<T>& heliocentric_distance{this->sim->getField("HeliocentricDistance")};
        T initial_flux{m_solar_const / std::pow(heliocentric_distance[0], 2)};
 
        calculateFluxTotal(sol_vec, initial_flux);
    }
    (*this->module_field) = m_flux_sol;
    return true;
}
 
template <typename T>
bool SolarFluxVariablePotter2023Radiosity<T>::m_registered =
    ModuleFactory<T>::registerModule(getName(), createMethode);
 
#endif // VTK_PRESENT
 
#endif // SOLAR_FLUX_VARIABLE_POTTER_2023_RADIOSITY_H