OutputCsvTool.h

Go to the documentation of this file.

#ifndef OUTPUT_CSV_TOOL_H
#define OUTPUT_CSV_TOOL_H
 
#define VERSION "5"
 
#include <fstream>
#include <iomanip>
#include <iostream>
#include <memory>
#include <ostream>
#include <string>
#include <valarray>
#include <vector>
 
#include "../../src/GenericManagingModule.h"
#include "../../src/ModuleFactory.h"
 
template <typename T>
class OutputCsvTool : public GenericManagingModule<T>
{
    private:
        static bool m_registered;
        std::string m_ini_filepath{"tools/OutputCsvTool.ini"};
        std::string m_output_filepath{};
        std::string m_save_mode{};
        std::vector<std::string>
            m_save_fields;  // Right now this lives only in the local ini, but we make it live in
                            // the sim class, so that the other modules can write their save request
                            // to it.
        std::vector<int> m_save_steps{};
        int m_currentIndex{0};
        std::ofstream output_file;
 
        void _writeData();
        void _writeDataSurface(int period);
 
    public:
        OutputCsvTool(SimulationClassBase<T>* sim);
        bool setup(std::vector<std::shared_ptr<GenericSubmodule<T>>> all_submodules) override;
        bool exec(std::string_view param) override;  // main functionality of the module
 
        bool init() override { return true; };
        bool preTimeStep() override { return true; };
        bool postNonLinIter() override { return true; };
        bool postTimeStep() override;
        bool output() override;
        std::vector<std::string> getChainInsertion() const override
        {
            return this->ini_file_data.getStringVectorParameters("chain_insertion");
        };
 
        static std::shared_ptr<GenericManagingModule<T>> createMethode(SimulationClassBase<T>* sim)
        {
            return std::make_shared<OutputCsvTool<T>>(sim);
        };
        static std::string getName() { return "OutputCsvTool"; };
        std::string_view getNameLocal() const override { return "OutputCsvTool"; };
};
 
// ================= Implementation =================
 
template <typename T>
OutputCsvTool<T>::OutputCsvTool(SimulationClassBase<T>* sim) : GenericManagingModule<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);
        m_output_filepath = this->ini_file_data.getStringParameters("file_path");
        m_save_mode = this->ini_file_data.getStringParameters("save_mode");
        m_save_fields = this->ini_file_data.getStringVectorParameters("save_fields");
        this->m_generic_submodules = this->ini_file_data.getStringVectorParameters("submodules");
    }
    catch (const BadInput& e)
    {
        std::cerr << e.what() << '\n';
    }
}
 
template <typename T>
bool OutputCsvTool<T>::setup(std::vector<std::shared_ptr<GenericSubmodule<T>>> all_submodules)
{
    // Flush the file
    std::ofstream file(m_output_filepath);
 
    if (m_save_mode == "specific_time_steps")
    {
        try
        {
            std::vector<double> save_steps{
                this->ini_file_data.getDoubleVectorParameters("save_time_steps")};
            for (int i{0}; i < save_steps.size(); i++)
            {
                m_save_steps.push_back(static_cast<int>(save_steps[i]));
            }
        }
        catch (const BadInput& e)
        {
            std::cerr << e.what() << '\n';
        }
    }
    return true;
}
 
template <typename T>
bool OutputCsvTool<T>::exec(std::string_view param)
{
    if (param == "InitChain")
    {
        return init();
    }
    if (param == "PreTimeStepChain")
    {
        return preTimeStep();
    }
    if (param == "PostNonLinIterChain")
    {
        return postNonLinIter();
    }
    if (param == "PostTimeStepChain")
    {
        return postTimeStep();
    }
    if (param == "OutputChain")
    {
        return output();
    }
    return false;
}
 
template <typename T>
bool OutputCsvTool<T>::postTimeStep()
{
    if ((m_save_mode == "specific_time_steps") && (m_currentIndex < m_save_steps.size())
        && (m_save_steps[m_currentIndex] == this->sim->time_step))
    {
        _writeData();
        m_currentIndex++;
    }
    else if ((m_save_mode == "specific_time_steps_surface")
             && (m_currentIndex < m_save_steps.size())
             && (m_save_steps[m_currentIndex] == this->sim->time_step))
    {
        _writeDataSurface(this->sim->m_simulation_config.getIntParameters("numerical_layers"));
        m_currentIndex++;
    }
    else if ((m_save_mode == "interval")
             && (this->sim->time_step % this->ini_file_data.getIntParameters("interval") == 0))
    {
        _writeData();
    }
    else if ((m_save_mode == "interval_surface")
             && (this->sim->time_step % this->ini_file_data.getIntParameters("interval") == 0))
    {
        _writeDataSurface(this->sim->m_simulation_config.getIntParameters("numerical_layers"));
    }
    return true;
}
 
template <typename T>
bool OutputCsvTool<T>::output()
{
    if (m_save_mode == "surface")
    {
        _writeDataSurface(this->sim->m_simulation_config.getIntParameters("numerical_layers"));
    }
    else
    {
        _writeData();
    }
    return true;
}
 
template <typename T>
void OutputCsvTool<T>::_writeData()
{
    output_file.open(m_output_filepath, std::ios::app);
 
    for (const auto& field_name : m_save_fields)
    {
        output_file << field_name << "," << this->sim->elapsed_time << ",";
        const std::valarray<T>& field{this->sim->getField(field_name)};
        for (int i{0}; i < field.size() - 1; i++)
        {
            output_file << field[i] << std::setprecision(15) << ",";
        }
        output_file << field[field.size() - 1] << std::setprecision(15) << "\n";
    }
 
    output_file.close();
}
 
template <typename T>
void OutputCsvTool<T>::_writeDataSurface(int period)
{
    output_file.open(m_output_filepath, std::ios::app);
 
    for (const auto& field_name : m_save_fields)
    {
        output_file << field_name << "," << this->sim->elapsed_time << ",";
        const std::valarray<T>& field{this->sim->getField(field_name)};
        for (int i{0}; i < static_cast<int>(field.size() / period) - 1; i++)
        {
            output_file << field[i * period] << std::setprecision(15) << ",";
        }
        output_file << field[field.size() - period] << std::setprecision(15) << "\n";
    }
 
    output_file.close();
}
 
template <typename T>
bool OutputCsvTool<T>::m_registered = ModuleFactory<T>::registerModule(getName(), createMethode);
 
#endif // OUTPUT_CSV_TOOL_H