SolarVectorVariableSpice.h

Go to the documentation of this file.

#ifndef SOLAR_VECTOR_VARIABLE_SPICE_H
#define SOLAR_VECTOR_VARIABLE_SPICE_H
 
#define SOLAR_VECTOR_VARIABLE_SPICE_VERSION "7"
 
#ifdef SPICE_PRESENT
 
extern "C"
{
#include "SpiceUsr.h"
}
 
#include <iostream>
#include <memory>
#include <string>
#include <valarray>
 
#include "../../src/GenericSubmodule.h"
#include "../../src/ModuleFactory.h"
 
template <typename T>
class SolarVectorVariableSpice : public GenericSubmodule<T>
{
    private:
        static bool m_registered;
        std::string m_ini_filepath{"solar_vector/SolarVectorVariableSpice.ini"};
        std::valarray<T> m_solar_vector;
        std::string m_start_time_utc;
        std::string m_observer_id;
        std::string m_reference_frame_id;
        std::string m_rotating_frame_id;
        std::string m_abcorr;
        ConstSpiceChar* m_target = "SUN";
        SpiceDouble m_et;
        SpiceDouble m_start_time_et;
        SpiceDouble m_light_time;
        SpiceDouble m_body_center_to_sun_vector_rotating[3];
 
    public:
        SolarVectorVariableSpice(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 calculateSolarVector();
 
        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<SolarVectorVariableSpice<T>>(sim);
        }
        static std::string getName() { return "SolarVectorVariableSpice"; }
        std::string_view getNameLocal() const override { return "SolarVectorVariableSpice"; };
        std::vector<std::string> getDependencies() const override
        {
            return this->ini_file_data.getStringVectorParameters("dependencies");
        };
};
 
// ================= Implementation =================
 
template <typename T>
SolarVectorVariableSpice<T>::SolarVectorVariableSpice(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 SolarVectorVariableSpice<T>::setup(
    std::vector<std::shared_ptr<GenericSubmodule<T>>> all_submodules)
{
    m_solar_vector.resize(3);
 
    return true;
}
 
template <typename T>
bool SolarVectorVariableSpice<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 SolarVectorVariableSpice<T>::calculateSolarVector()
{
    // Calculate current ephemerides times from current timestep
    this->m_et = this->m_start_time_et + this->sim->elapsed_time;
 
    spkpos_c(this->m_target, this->m_et, this->m_rotating_frame_id.c_str(), this->m_abcorr.c_str(),
             this->m_observer_id.c_str(), this->m_body_center_to_sun_vector_rotating,
             &this->m_light_time);
 
    // Change unit from km to m and save in module field
    for (int i{0}; i < 3; i++)
    {
        (*this->module_field)[i] = this->m_body_center_to_sun_vector_rotating[i] * 1000;
    }
}
 
template <typename T>
bool SolarVectorVariableSpice<T>::preTimeStep()
{
    calculateSolarVector();
    return true;
}
 
template <typename T>
bool SolarVectorVariableSpice<T>::init()
{
    // Load metadata kernel (can be done multiple times for different modules)
    if (this->sim->my_rank == 0)
    {
        std::cout << "[SolarVectorVariableSpice] Loading SPICE kernels.\n";
    }
    furnsh_c(this->ini_file_data.getStringParameters("spice_metakernel_path").c_str());
    if (this->sim->my_rank == 0)
    {
        std::cout << "[SolarVectorVariableSpice] Done.\n";
    }
 
    // Read ini file for correct IDs
    this->m_start_time_utc = this->ini_file_data.getStringParameters("start_time_utc");
    str2et_c(this->m_start_time_utc.c_str(), &this->m_start_time_et);
    this->m_et = this->m_start_time_et;
    this->m_observer_id = this->ini_file_data.getStringParameters("object_id");
    this->m_reference_frame_id = this->ini_file_data.getStringParameters("reference_frame_id");
    this->m_rotating_frame_id = this->ini_file_data.getStringParameters("rotating_frame_id");
    this->m_abcorr = this->ini_file_data.getStringParameters("abcorr");
    if (this->sim->my_rank == 0)
    {
        std::cout << "[SolarVectorVariableSpice] Loaded parameters.\n";
    }
 
    calculateSolarVector();
 
    return true;
}
 
template <typename T>
bool SolarVectorVariableSpice<T>::m_registered =
    ModuleFactory<T>::registerModule(getName(), createMethode);
 
#endif  // SPICE_PRESENT
 
#endif  // SOLAR_VECTOR_VARIABLE_SPICE_H