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();
 
        ~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"};
};
 
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"))});
 
    std::vector<std::shared_ptr<GenericManagingModule<double>>> all_modules{
        ModuleFactory<double>::createAllManagingModules(this)};
    std::vector<std::shared_ptr<GenericSubmodule<double>>> all_submodules{
        ModuleFactory<double>::createAllSubmodules(this)};
    m_global_chain.autoLoader(all_modules);
 
    runSetup<T>(all_modules, all_submodules, m_global_chain.getManagingModuleNames());
    return 0;
}
 
template <typename T>
int SimulationClassUnitTesting<T>::runInitChain()
{
    this->setInitChainStr();
    m_global_chain.runChain(this->m_current_position);
    return 0;
}
 
#endif