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()
{
    // Construct the path to the ini_files folder under the current build (TEST_RUNTIME_DIR)
    std::filesystem::path ini_folder_path = std::filesystem::path(TEST_RUNTIME_DIR) / "ini_files";
 
    // Construct the absolute path to the default.ini
    std::filesystem::path default_ini_path = ini_folder_path / "default.ini";
 
    // Read the existing INI lines
    std::vector<std::string> lines;
    {
        std::ifstream infile(default_ini_path);
        if (!infile.is_open())
        {
            throw std::runtime_error("Could not open default.ini at: " + default_ini_path.string());
        }
 
        std::string line;
        while (std::getline(infile, line))
        {
            // Replace ini_folder_path line with the absolute path
            if (line.rfind("ini_folder_path =", 0) == 0)
            {
                // Use std::filesystem::path / operator to ensure proper slash
                line = "ini_folder_path = \"" + (ini_folder_path / "").string() + "\"";
            }
            lines.push_back(line);
        }
    }
 
    // Write back the modified INI
    {
        std::ofstream outfile(default_ini_path, std::ios::trunc);
        for (const auto& l : lines)
        {
            outfile << l << "\n";
        }
    }
 
    std::cout << "PATH: " << default_ini_path << "\n";
 
    // Load the INI
    this->m_simulation_config = InputManager(default_ini_path.string());
}
 
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::shared_ptr<ShapeBase<T>> simulation_shape;
    try
    {
        shape_creator = std::make_unique<ShapeFactory<T>>(
            this, this->m_simulation_config.getBoolParameters("use_shape_file"),
            this->m_simulation_config.getStringParameters("spatial_dimension"));
        simulation_shape = shape_creator->getShapePtr();
    }
    catch (const BadInput& e)
    {
        // Map access errors.
        std::cerr
            << "[SimulationClassUnitTesting]: Failed creating ShapeBase object from ShapeFactory "
            << e.what() << '\n';
        throw BadInput(
            static_cast<std::string>(
                "[SimulationClassUnitTesting]: Failed creating ShapeBase object from ShapeFactory ")
            + static_cast<std::string>(e.what()));
    }
    catch (const std::runtime_error& e)
    {
        // ShapeFactory internal errors.
        std::cerr
            << "[SimulationClassUnitTesting]: Failed creating ShapeBase object from ShapeFactory "
            << e.what() << '\n';
        throw std::runtime_error(
            static_cast<std::string>(
                "[SimulationClassUnitTesting]: Failed creating ShapeBase object from ShapeFactory ")
            + static_cast<std::string>(e.what()));
    }
 
    std::unique_ptr<GridFactory<T>> grid_creator;
    std::shared_ptr<GridBase<T>> simulation_grid;
    try
    {
        grid_creator = std::make_unique<GridFactory<T>>(
            this, simulation_shape,
            this->m_simulation_config.getStringParameters("spatial_dimension"));
        simulation_grid = grid_creator->getGridPtr();
    }
    catch (const BadInput& e)
    {
        // Map access errors or GridBase internal errors.
        std::cerr
            << "[SimulationClassUnitTesting]: Failed creating GridBase object from GridFactory "
            << e.what() << '\n';
        throw BadInput(
            static_cast<std::string>(
                "[SimulationClassUnitTesting]: Failed creating GridBase object from GridFactory ")
            + static_cast<std::string>(e.what()));
    }
    catch (const std::runtime_error& e)
    {
        // GridFactory internal errors.
        std::cerr
            << "[SimulationClassUnitTesting]: Failed creating GridBase object from GridFactory "
            << e.what() << '\n';
        throw std::runtime_error(
            static_cast<std::string>(
                "[SimulationClassUnitTesting]: Failed creating GridBase object from GridFactory ")
            + static_cast<std::string>(e.what()));
    }
 
    try
    {
        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"))});
    }
    catch (const BadInput& e)
    {
        std::cerr
            << "[SimulationClassUnitTesting]: Failed to create main independent variable field "
               "(usually temperature) "
            << e.what() << '\n';
        throw BadInput(
            static_cast<std::string>("[SimulationClassUnitTesting]: Failed to create main "
                                     "independent variable field (usually temperature) ")
            + static_cast<std::string>(e.what()));
    }
 
    try
    {
        m_all_modules = ModuleFactory<T>::createAllSelectedManagingModules(
            this, this->m_simulation_config.getStringVectorParameters("managing_modules"));
    }
    catch (const BadInput&)
    {
        try
        {
            m_all_modules = ModuleFactory<T>::createAllManagingModules(this);
        }
        catch (const std::runtime_error& e)
        {
            std::cerr << "[SimulationClassUnitTesting]: Failed at module creation step " << e.what()
                      << '\n';
            throw std::runtime_error(
                static_cast<std::string>(
                    "[SimulationClassUnitTesting]: Failed at module creation step ")
                + static_cast<std::string>(e.what()));
        }
    }
    catch (const std::runtime_error& e)
    {
        std::cerr << "[SimulationClassUnitTesting]: Failed at module creation step " << e.what()
                  << '\n';
        throw std::runtime_error(
            static_cast<std::string>(
                "[SimulationClassUnitTesting]: Failed at module creation step ")
            + static_cast<std::string>(e.what()));
    }
 
    try
    {
        m_all_submodules = ModuleFactory<T>::createAllSelectedSubmodules(this, m_all_modules);
    }
    catch (const std::runtime_error& e)
    {
        std::cerr << "[SimulationClassUnitTesting]: Failed at submodule creation step " << e.what()
                  << '\n';
        throw std::runtime_error(
            static_cast<std::string>(
                "[SimulationClassUnitTesting]: Failed at submodule creation step ")
            + static_cast<std::string>(e.what()));
    }
 
    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 << "[SimulationClassUnitTesting]: 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);
    }
 
    try
    {
        runSetup<T>(m_all_modules, m_all_submodules, m_global_chain.getManagingModuleNames());
    }
    catch (const BadInput& e)
    {
        // runSetup itself does not throw an error but has a high chance to trigger a BadInput
        // within the setup functions of the modules.
        std::cerr << "[SimulationClassDefault]: Failed at setting up the modules " << e.what()
                  << '\n';
        throw std::runtime_error(
            static_cast<std::string>("[SimulationClassDefault]: Failed at setting up the modules ")
            + static_cast<std::string>(e.what()));
    }
    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::shared_ptr<ShapeBase<T>> simulation_shape;
    try
    {
        shape_creator = std::make_unique<ShapeFactory<T>>(
            this, this->m_simulation_config.getBoolParameters("use_shape_file"),
            this->m_simulation_config.getStringParameters("spatial_dimension"));
        simulation_shape = shape_creator->getShapePtr();
    }
    catch (const BadInput& e)
    {
        // Map access errors.
        std::cerr
            << "[SimulationClassUnitTesting]: Failed creating ShapeBase object from ShapeFactory "
            << e.what() << '\n';
        throw BadInput(
            static_cast<std::string>(
                "[SimulationClassUnitTesting]: Failed creating ShapeBase object from ShapeFactory ")
            + static_cast<std::string>(e.what()));
    }
    catch (const std::runtime_error& e)
    {
        // ShapeFactory internal errors.
        std::cerr
            << "[SimulationClassUnitTesting]: Failed creating ShapeBase object from ShapeFactory "
            << e.what() << '\n';
        throw std::runtime_error(
            static_cast<std::string>(
                "[SimulationClassUnitTesting]: Failed creating ShapeBase object from ShapeFactory ")
            + static_cast<std::string>(e.what()));
    }
 
    std::unique_ptr<GridFactory<T>> grid_creator;
    std::shared_ptr<GridBase<T>> simulation_grid;
    try
    {
        grid_creator = std::make_unique<GridFactory<T>>(
            this, simulation_shape,
            this->m_simulation_config.getStringParameters("spatial_dimension"));
        simulation_grid = grid_creator->getGridPtr();
    }
    catch (const BadInput& e)
    {
        // Map access errors or GridBase internal errors.
        std::cerr
            << "[SimulationClassUnitTesting]: Failed creating GridBase object from GridFactory "
            << e.what() << '\n';
        throw BadInput(
            static_cast<std::string>(
                "[SimulationClassUnitTesting]: Failed creating GridBase object from GridFactory ")
            + static_cast<std::string>(e.what()));
    }
    catch (const std::runtime_error& e)
    {
        // GridFactory internal errors.
        std::cerr
            << "[SimulationClassUnitTesting]: Failed creating GridBase object from GridFactory "
            << e.what() << '\n';
        throw std::runtime_error(
            static_cast<std::string>(
                "[SimulationClassUnitTesting]: Failed creating GridBase object from GridFactory ")
            + static_cast<std::string>(e.what()));
    }
 
    try
    {
        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"))});
    }
    catch (const BadInput& e)
    {
        std::cerr
            << "[SimulationClassUnitTesting]: Failed to create main independent variable field "
               "(usually temperature) "
            << e.what() << '\n';
        throw BadInput(
            static_cast<std::string>("[SimulationClassUnitTesting]: Failed to create main "
                                     "independent variable field (usually temperature) ")
            + static_cast<std::string>(e.what()));
    }
 
    try
    {
        m_all_modules = ModuleFactory<T>::createAllSelectedManagingModules(
            this, this->m_simulation_config.getStringVectorParameters("managing_modules"));
    }
    catch (const BadInput&)
    {
        try
        {
            m_all_modules = ModuleFactory<T>::createAllManagingModules(this);
        }
        catch (const std::runtime_error& e)
        {
            std::cerr << "[SimulationClassUnitTesting]: Failed at module creation step " << e.what()
                      << '\n';
            throw std::runtime_error(
                static_cast<std::string>(
                    "[SimulationClassUnitTesting]: Failed at module creation step ")
                + static_cast<std::string>(e.what()));
        }
    }
    catch (const std::runtime_error& e)
    {
        std::cerr << "[SimulationClassUnitTesting]: Failed at module creation step " << e.what()
                  << '\n';
        throw std::runtime_error(
            static_cast<std::string>(
                "[SimulationClassUnitTesting]: Failed at module creation step ")
            + static_cast<std::string>(e.what()));
    }
 
    try
    {
        m_all_submodules = ModuleFactory<T>::createAllSelectedSubmodules(this, m_all_modules);
    }
    catch (const std::runtime_error& e)
    {
        std::cerr << "[SimulationClassUnitTesting]: Failed at submodule creation step " << e.what()
                  << '\n';
        throw std::runtime_error(
            static_cast<std::string>(
                "[SimulationClassUnitTesting]: Failed at submodule creation step ")
            + static_cast<std::string>(e.what()));
    }
 
    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 << "[SimulationClassUnitTesting]: 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);
    }
 
    try
    {
        runSetup<T>(m_all_modules, m_all_submodules, m_global_chain.getManagingModuleNames());
    }
    catch (const BadInput& e)
    {
        // runSetup itself does not throw an error but has a high chance to trigger a BadInput
        // within the setup functions of the modules.
        std::cerr << "[SimulationClassDefault]: Failed at setting up the modules " << e.what()
                  << '\n';
        throw std::runtime_error(
            static_cast<std::string>("[SimulationClassDefault]: Failed at setting up the modules ")
            + static_cast<std::string>(e.what()));
    }
 
    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