SimulationClassUnitTesting.h

Go to the documentation of this file.

#ifndef SIMULATION_CLASS_UNIT_TESTING_H
#define SIMULATION_CLASS_UNIT_TESTING_H
 
#include <filesystem>
#include <fstream>
#include <iostream>
#include <map>
#include <memory>
#include <string>
#include <valarray>
#include <vector>
 
#include "ChainManager.h"
#include "GridFactory.h"
#include "ModuleFactory.h"
#include "SetupRunner.h"
#include "ShapeFactory.h"
#include "SimulationClassBase.h"
 
template <typename T>
class SimulationClassUnitTesting : public SimulationClassBase<T>
{
    public:
        SimulationClassUnitTesting();
        SimulationClassUnitTesting(const std::string& user_ini);
 
        void setAbsoluteDefaultIniPath();
        void setUserIni(const std::string& user_ini) override;
 
        int run() override;
        int runInitChain();
        bool runModuleCheck(const std::vector<std::string>& managing_modules,
                            const std::vector<std::string>& submodules);
 
        ~SimulationClassUnitTesting() override = default;
 
    private:
        std::string m_init_str{"InitChain"};
        std::string m_preTs_str{"PreTimeStepChain"};
        std::string m_postTs_str{"PostTimeStepChain"};
        std::string m_postNonLinIter_str{"PostNonLinIterChain"};
        std::string m_output_str{"OutputChain"};
        ChainManager<GenericManagingModule<double>> m_global_chain{"global"};
 
        std::vector<std::shared_ptr<GenericManagingModule<T>>> m_all_modules{};
        std::vector<std::shared_ptr<GenericSubmodule<T>>> m_all_submodules{};
};
 
template <typename T>
void SimulationClassUnitTesting<T>::setAbsoluteDefaultIniPath()
{
    // Set absolute paths and load ini file
    std::filesystem::path ini_folder_path =
        (std::filesystem::path(PROJECT_ROOT) / "build/tests/ini_files/");
    std::string default_ini_path =
        std::filesystem::absolute(ini_folder_path / "default.ini").string();
 
    std::vector<std::string> lines;
    std::ifstream infile(default_ini_path);
    std::string line;
 
    while (std::getline(infile, line))
    {
        if (line.rfind("ini_folder_path =", 0) == 0)
        {
            line = "ini_folder_path = \"" + ini_folder_path.string() + "\"";
        }
        lines.push_back(line);
    }
    infile.close();
 
    std::ofstream outfile(default_ini_path, std::ios::trunc);
    for (const auto& l : lines)
    {
        outfile << l << "\n";
    }
    outfile.close();
 
    std::cout << "PATH: " << default_ini_path << "\n";
 
    this->m_simulation_config = InputManager(default_ini_path);
}
 
template <typename T>
void SimulationClassUnitTesting<T>::setUserIni(const std::string& user_ini)
{
    this->m_simulation_config.loadUserInput(
        this->m_simulation_config.getStringParameters("ini_folder_path") + user_ini);
}
 
template <typename T>
SimulationClassUnitTesting<T>::SimulationClassUnitTesting()
{
    this->setAbsoluteDefaultIniPath();
}
 
template <typename T>
SimulationClassUnitTesting<T>::SimulationClassUnitTesting(const std::string& user_ini)
    : SimulationClassBase<T>(user_ini)
{
    // Do not use when working with absolute paths since base constructor will always run first
}
 
template <typename T>
int SimulationClassUnitTesting<T>::run()
{
    // Loading of the shape model so that all the mesh info is available at grid creation.
    std::unique_ptr<ShapeFactory<T>> shape_creator{std::make_unique<ShapeFactory<T>>(
        this, this->m_simulation_config.getBoolParameters("use_shape_file"),
        this->m_simulation_config.getStringParameters("spatial_dimension"))};
    std::shared_ptr<ShapeBase<T>> simulation_shape = shape_creator->getShapePtr();
    std::unique_ptr<GridFactory<T>> grid_creator{std::make_unique<GridFactory<T>>(
        this, simulation_shape,
        this->m_simulation_config.getStringParameters("spatial_dimension"))};
    std::shared_ptr<GridBase<T>> simulation_grid = grid_creator->getGridPtr();
 
    this->m_field_map.insert(
        {"Temperature", std::valarray<double>(
                            this->m_simulation_config.getDoubleParameters("initial_temperature"),
                            this->m_simulation_config.getIntParameters("numerical_layers")
                                * this->m_simulation_config.getIntParameters("number_of_facets"))});
 
    try
    {
        m_all_modules = ModuleFactory<T>::createAllSelectedManagingModules(
            this, this->m_simulation_config.getStringVectorParameters("managing_modules"));
    }
    catch (const BadInput&)
    {
        m_all_modules = ModuleFactory<T>::createAllManagingModules(this);
    }
    m_all_submodules = ModuleFactory<T>::createAllSelectedSubmodules(this, m_all_modules);
    try
    {
        // If a user supplied managing module list is present, use this
        m_global_chain.autoLoader(
            m_all_modules, this->m_simulation_config.getStringVectorParameters("managing_modules"));
    }
    catch (const std::exception& e)
    {
        std::cerr << "[Warning] Failed to load managing modules from config: " << e.what() << "\n"
                  << "Falling back to loading all modules.\n";
        m_global_chain.autoLoader(m_all_modules);
    }
 
    runSetup<T>(m_all_modules, m_all_submodules, m_global_chain.getManagingModuleNames());
    return 0;
}
 
template <typename T>
bool SimulationClassUnitTesting<T>::runModuleCheck(const std::vector<std::string>& managing_modules,
                                                   const std::vector<std::string>& submodules)
{
    // Loading of the shape model so that all the mesh info is available at grid creation.
    std::unique_ptr<ShapeFactory<T>> shape_creator{std::make_unique<ShapeFactory<T>>(
        this, this->m_simulation_config.getBoolParameters("use_shape_file"),
        this->m_simulation_config.getStringParameters("spatial_dimension"))};
    std::shared_ptr<ShapeBase<T>> simulation_shape = shape_creator->getShapePtr();
    std::unique_ptr<GridFactory<T>> grid_creator{std::make_unique<GridFactory<T>>(
        this, simulation_shape,
        this->m_simulation_config.getStringParameters("spatial_dimension"))};
    std::shared_ptr<GridBase<T>> simulation_grid = grid_creator->getGridPtr();
 
    this->m_field_map.insert(
        {"Temperature", std::valarray<double>(
                            this->m_simulation_config.getDoubleParameters("initial_temperature"),
                            this->m_simulation_config.getIntParameters("numerical_layers")
                                * this->m_simulation_config.getIntParameters("number_of_facets"))});
 
    try
    {
        m_all_modules = ModuleFactory<T>::createAllSelectedManagingModules(
            this, this->m_simulation_config.getStringVectorParameters("managing_modules"));
    }
    catch (const BadInput&)
    {
        m_all_modules = ModuleFactory<T>::createAllManagingModules(this);
    }
    m_all_submodules = ModuleFactory<T>::createAllSelectedSubmodules(this, m_all_modules);
    try
    {
        // If a user supplied managing module list is present, use this
        m_global_chain.autoLoader(
            m_all_modules, this->m_simulation_config.getStringVectorParameters("managing_modules"));
    }
    catch (const std::exception& e)
    {
        std::cerr << "[Warning] Failed to load managing modules from config: " << e.what() << "\n"
                  << "Falling back to loading all modules.\n";
        m_global_chain.autoLoader(m_all_modules);
    }
 
    runSetup<T>(m_all_modules, m_all_submodules, m_global_chain.getManagingModuleNames());
 
    bool result{true};
    std::unordered_set<std::string> set_mm(managing_modules.begin(), managing_modules.end());
    for (const auto& module_pointer : m_all_modules)
    {
        std::string module_name{module_pointer->getNameLocal()};
        if (!(set_mm.contains(module_name)))
        {
            result = false;
        }
    }
    std::unordered_set<std::string> set_sm(submodules.begin(), submodules.end());
    for (const auto& submodule_pointer : m_all_submodules)
    {
        std::string submodule_name{submodule_pointer->getNameLocal()};
        if (!(set_sm.contains(submodule_name)))
        {
            result = false;
        }
    }
    if ((m_all_modules.size() != managing_modules.size())
        || (m_all_submodules.size() != submodules.size()))
    {
        result = false;
    }
    return result;
}
 
template <typename T>
int SimulationClassUnitTesting<T>::runInitChain()
{
    this->setInitChainStr();
    m_global_chain.runChain(this->m_current_position);
    return 0;
}
#endif