DensityConstantGundlach2013RegolithSolidAsteroidType.h

Go to the documentation of this file.

#ifndef DENSITY_CONSTANT_GUNDLACH_2013_REGOLITH_SOLID_ASTEROID_TYPE_H
#define DENSITY_CONSTANT_GUNDLACH_2013_REGOLITH_SOLID_ASTEROID_TYPE_H
 
#define DENSITY_CONSTANT_GUNDLACH_2013_REGOLITH_SOLID_ASTEROID_TYPE_VERSION "6"
 
#include <iostream>
#include <memory>
#include <string>
#include <valarray>
 
#include "../../src/GenericSubmodule.h"
#include "../../src/ModuleFactory.h"
 
template <typename T>
class DensityConstantGundlach2013RegolithSolidAsteroidType : public GenericSubmodule<T>
{
    private:
        static bool m_registered;
        std::string m_ini_filepath{
            "density/DensityConstantGundlach2013RegolithSolidAsteroidType.ini"};
        std::string m_asteroid_type{};
        T m_volume_filling_factor{};
 
    public:
        DensityConstantGundlach2013RegolithSolidAsteroidType(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 calculateDensity();
 
        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<DensityConstantGundlach2013RegolithSolidAsteroidType<T>>(sim);
        }
        static std::string getName()
        {
            return "DensityConstantGundlach2013RegolithSolidAsteroidType";
        }
        std::string_view getNameLocal() const override
        {
            return "DensityConstantGundlach2013RegolithSolidAsteroidType";
        };
        std::vector<std::string> getDependencies() const override
        {
            return this->ini_file_data.getStringVectorParameters("dependencies");
        };
};
 
// ================= Implementation =================
 
template <typename T>
DensityConstantGundlach2013RegolithSolidAsteroidType<
    T>::DensityConstantGundlach2013RegolithSolidAsteroidType(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");
        this->m_asteroid_type = this->ini_file_data.getStringParameters("asteroid_type");
        this->m_volume_filling_factor =
            this->ini_file_data.getDoubleParameters("volume_filling_factor");
    }
    catch (const BadInput& e)
    {
        std::cerr << "[DensityConstantGundlach2013RegolithSolidAsteroidType]: " << e.what() << '\n';
        throw BadInput(
            static_cast<std::string>("[DensityConstantGundlach2013RegolithSolidAsteroidType]: ")
            + static_cast<std::string>(e.what()));
    }
}
 
template <typename T>
bool DensityConstantGundlach2013RegolithSolidAsteroidType<T>::setup(
    std::vector<std::shared_ptr<GenericSubmodule<T>>> all_submodules)
{
    std::vector<std::string> implemented_asteroid_types{"S", "Q", "M", "C"};
    if (std::find(implemented_asteroid_types.begin(), implemented_asteroid_types.end(),
                  this->m_asteroid_type)
        == implemented_asteroid_types.end())
    {
        std::cerr << "[DensityConstantGundlach2013RegolithSolidAsteroidType]: Requested asteroid "
                     "type not implemented.\n";
        throw std::runtime_error(static_cast<std::string>(
            "[DensityConstantGundlach2013RegolithSolidAsteroidType]: Requested "
            "asteroid type not implemented."));
    }
 
    return true;
}
 
template <typename T>
void DensityConstantGundlach2013RegolithSolidAsteroidType<T>::calculateDensity()
{
    const std::valarray<T>& temperature{this->sim->getField("Temperature")};
    if ((this->m_asteroid_type) == "S" || (this->m_asteroid_type) == "Q")
    {
        (*this->module_field) = this->m_volume_filling_factor * 3700;
    }
    else if ((this->m_asteroid_type) == "C")
    {
        (*this->module_field) = this->m_volume_filling_factor * 3110;
    }
    else if ((this->m_asteroid_type) == "M")
    {
        (*this->module_field) = this->m_volume_filling_factor * 7800;
    }
    else
    {
        std::cerr << "[DensityConstantGundlach2013RegolithSolidAsteroidType]: Requested asteroid "
                     "type not implemented.\n";
        throw std::runtime_error(
            static_cast<std::string>("[DensityConstantGundlach2013RegolithSolidAsteroidType]: "
                                     "Requested asteroid type not implemented."));
    }
}
 
template <typename T>
bool DensityConstantGundlach2013RegolithSolidAsteroidType<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 DensityConstantGundlach2013RegolithSolidAsteroidType<T>::init()
{
    calculateDensity();
    return true;
}
 
template <typename T>
bool DensityConstantGundlach2013RegolithSolidAsteroidType<T>::preTimeStep()
{
    calculateDensity();
    return true;
}
 
template <typename T>
bool DensityConstantGundlach2013RegolithSolidAsteroidType<T>::m_registered =
    ModuleFactory<T>::registerModule(getName(), createMethode);
 
#endif  // DENSITY_CONSTANT_GUNDLACH_2013_REGOLITH_SOLID_ASTEROID_TYPE_H