OutputCsvTool.h

Go to the documentation of this file.

#ifndef OUTPUT_CSV_TOOL_H
#define OUTPUT_CSV_TOOL_H
 
#define OUTPUT_CSV_TOOL_VERSION "13"
 
#include <algorithm>
#include <cstdint>
#include <ctime>
#include <exception>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <memory>
#include <ostream>
#include <sstream>
#include <string>
#include <valarray>
#include <vector>
 
#include "../../src/GenericManagingModule.h"
#include "../../src/ModuleFactory.h"
 
#ifdef MPI_PRESENT
#include <mpi.h>
 
#endif
 
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::string m_start_time_utc{};
        int64_t m_start_time_seconds{};
        std::vector<int64_t> m_interval_start_times_seconds{};
        std::vector<int64_t> m_interval_end_times_seconds{};
        std::vector<int> m_save_steps{};
        int m_currentIndex{0};
        double m_time_delta;
        double m_time_max;
        std::ofstream output_file;
 
        void _writeData();
        void _writeDataSurface(int period);
        void _utcIntervalToSeconds();
        void _verifyIntervalIntegrity();
        bool _checkInterval();
 
#ifdef MPI_PRESENT
        MPI_File file_handle;
        MPI_Datatype m_dtype;
        MPI_Offset displacement{0};
        MPI_Offset start{0};
        int count{0};
        int type_size, footer_type_size;
        int numerical_layers, local_number_of_facets, global_number_of_facets;
        int64_t data_sizes[2];
        std::string footer{};
        void _writeDataMpi();
        void _writeDataSurfaceMpi(int period);
        MPI_Offset _calcDisplacement(const std::valarray<T>& field);
        void _writeFooter();
#endif
 
    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;
        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 << "[OutputCsvTool]: " << e.what() << '\n';
        throw BadInput(static_cast<std::string>("[OutputCsvTool]: ")
                       + static_cast<std::string>(e.what()));
    }
}
 
template <typename T>
bool OutputCsvTool<T>::setup(std::vector<std::shared_ptr<GenericSubmodule<T>>> all_submodules)
{
#ifdef MPI_PRESENT
    // Get information necessary to calculate byte sizes of output
    numerical_layers = this->sim->m_simulation_config.getIntParameters("numerical_layers");
    local_number_of_facets = this->sim->m_simulation_config.getIntParameters("number_of_facets");
    global_number_of_facets =
        this->sim->m_simulation_config.getIntParameters("global_number_of_facets");
    // Set datatype of field to the one used across this simulation
    m_dtype = mpi_type_of<T>();
    MPI_Type_size(m_dtype, &type_size);
    MPI_Type_size(MPI_UNSIGNED_CHAR, &footer_type_size);
    if (this->sim->my_rank == 0)
    {
        // Flush the file
        std::ofstream file(m_output_filepath);
    }
#else
    // Flush the file
    std::ofstream file(m_output_filepath);
#endif
    if (m_save_mode == "specific_time_steps" || m_save_mode == "specific_time_steps_surface")
    {
        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 << "[OutputCsvTool]: " << e.what() << '\n';
            throw BadInput(static_cast<std::string>("[OutputCsvTool]: ")
                           + static_cast<std::string>(e.what()));
        }
    }
    if (m_save_mode == "time_interval" || m_save_mode == "time_interval_surface")
    {
        try
        {
            m_time_delta = this->sim->m_simulation_config.getDoubleParameters("time_delta");
            m_time_max = this->sim->m_simulation_config.getDoubleParameters("time_max");
            m_start_time_utc = this->ini_file_data.getStringParameters("start_time_utc");
            _utcIntervalToSeconds();
        }
        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>::init()
{
#ifdef MPI_PRESENT
    MPI_File_open(MPI_COMM_WORLD, m_output_filepath.c_str(), MPI_MODE_WRONLY | MPI_MODE_CREATE,
                  MPI_INFO_NULL, &file_handle);
#endif
    return true;
}
 
template <typename T>
bool OutputCsvTool<T>::postTimeStep()
{
    try
    {
        if ((m_save_mode == "specific_time_steps") && (m_currentIndex < m_save_steps.size())
            && (m_save_steps[m_currentIndex] == this->sim->time_step))
        {
#ifdef MPI_PRESENT
            _writeDataMpi();
#else
            _writeData();
#endif
            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))
        {
#ifdef MPI_PRESENT
            _writeDataSurfaceMpi(
                this->sim->m_simulation_config.getIntParameters("numerical_layers"));
#else
            _writeDataSurface(this->sim->m_simulation_config.getIntParameters("numerical_layers"));
#endif
            m_currentIndex++;
        }
        else if ((m_save_mode == "interval")
                 && (this->sim->time_step % this->ini_file_data.getIntParameters("interval") == 0))
        {
#ifdef MPI_PRESENT
            _writeDataMpi();
#else
            _writeData();
#endif
        }
        else if ((m_save_mode == "interval_surface")
                 && (this->sim->time_step % this->ini_file_data.getIntParameters("interval") == 0))
        {
#ifdef MPI_PRESENT
            _writeDataSurfaceMpi(
                this->sim->m_simulation_config.getIntParameters("numerical_layers"));
#else
            _writeDataSurface(this->sim->m_simulation_config.getIntParameters("numerical_layers"));
#endif
        }
        else if ((m_save_mode == "time_interval") && _checkInterval())
        {
#ifdef MPI_PRESENT
            _writeDataMpi();
#else
            _writeData();
#endif
        }
        else if ((m_save_mode == "time_interval_surface") && _checkInterval())
        {
#ifdef MPI_PRESENT
            _writeDataSurfaceMpi(
                this->sim->m_simulation_config.getIntParameters("numerical_layers"));
#else
            _writeDataSurface(this->sim->m_simulation_config.getIntParameters("numerical_layers"));
#endif
        }
    }
    catch (const BadInput& e)
    {
        std::cerr << "[OutputCsvTool]: " << e.what() << '\n';
        throw BadInput(static_cast<std::string>("[OutputCsvTool]: ")
                       + static_cast<std::string>(e.what()));
    }
    return true;
}
 
template <typename T>
bool OutputCsvTool<T>::output()
{
#ifdef MPI_PRESENT
    // Check to only write footer, if it hasn't already been written (in preTimeStep)
    if (!(footer.empty()))
    {
        _writeFooter();
    }
    MPI_File_close(&file_handle);
#else
    if (m_save_mode == "surface")
    {
        try
        {
            _writeDataSurface(this->sim->m_simulation_config.getIntParameters("numerical_layers"));
        }
        catch (const BadInput& e)
        {
            std::cerr << "[OutputCsvTool]: " << e.what() << '\n';
            throw BadInput(static_cast<std::string>("[OutputCsvTool]: ")
                           + static_cast<std::string>(e.what()));
        }
    }
    else
    {
        _writeData();
    }
#endif
    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 << ",";
        try
        {
            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";
        }
        catch (const BadInput& e)
        {
            std::cerr << "[OutputCsvTool]: " << field_name
                      << " module not "
                         "loaded or accessable!\n "
                         "[OutputCsvTool]:"
                      << e.what() << '\n';
            throw BadInput(static_cast<std::string>("[OutputCsvTool]: ") + field_name
                           + static_cast<std::string>(" module "
                                                      "not loaded or "
                                                      "accessable!\n [OutputCsvTool]: ")
                           + static_cast<std::string>(e.what()));
        }
    }
 
    output_file.close();
}
 
#ifdef MPI_PRESENT
template <typename T>
void OutputCsvTool<T>::_writeDataMpi()
{
    if (file_handle == MPI_FILE_NULL)
    {
        std::cerr << "[OutputCsvTool]: Trying to access an unopened file. Please also use init and "
                     "output chains "
                     "when using MPI I/O.\n";
        throw std::runtime_error(
            "[OutputCsvTool]: Trying to access an unopened file. Please also use init and output "
            "chains when using "
            "MPI I/O.");
    }
    for (const auto& field_name : m_save_fields)
    {
        try
        {
            const std::valarray<T>& field{this->sim->getField(field_name)};
            displacement = _calcDisplacement(field) + start;
            MPI_File_write_at_all(file_handle, displacement, &field[0],
                                  static_cast<int>(field.size()), m_dtype, MPI_STATUS_IGNORE);
            // Update the starting position (in bytes) for the next write
            // Each process from the first k can write at position rank * size of its array.
            // Each process > k needs to account for the larger k processes to determine its pointer
            // start.
            if (field.size() == numerical_layers * local_number_of_facets)
            {
                start += type_size * numerical_layers * global_number_of_facets;
                footer += field_name + "," + std::to_string(this->sim->elapsed_time) + ","
                          + std::to_string(numerical_layers * global_number_of_facets) + ",";
            }
            else if (field.size() == local_number_of_facets)
            {
                start += type_size * global_number_of_facets;
                footer += field_name + "," + std::to_string(this->sim->elapsed_time) + ","
                          + std::to_string(global_number_of_facets) + ",";
            }
            else
            {
                start += type_size * static_cast<MPI_Offset>(field.size()) * this->sim->world_size;
                footer += field_name + "," + std::to_string(this->sim->elapsed_time) + ","
                          + std::to_string(field.size() * this->sim->world_size) + ",";
            }
        }
        catch (const BadInput& e)
        {
            std::cerr << "[OutputCsvTool]: " << field_name
                      << " module not "
                         "loaded or accessable!\n "
                         "[OutputCsvTool]:"
                      << e.what() << '\n';
            throw BadInput(static_cast<std::string>("[OutputCsvTool]: ") + field_name
                           + static_cast<std::string>(" module "
                                                      "not loaded or "
                                                      "accessable!\n [OutputCsvTool]: ")
                           + static_cast<std::string>(e.what()));
        }
    }
}
#endif
 
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 << ",";
        try
        {
            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";
        }
        catch (const BadInput& e)
        {
            std::cerr << "[OutputCsvTool]: " << field_name
                      << " module not "
                         "loaded or accessable!\n "
                         "[OutputCsvTool]:"
                      << e.what() << '\n';
            throw BadInput(static_cast<std::string>("[OutputCsvTool]: ") + field_name
                           + static_cast<std::string>(" module "
                                                      "not loaded or "
                                                      "accessable!\n [OutputCsvTool]:")
                           + static_cast<std::string>(e.what()));
        }
    }
 
    output_file.close();
}
 
#ifdef MPI_PRESENT
template <typename T>
void OutputCsvTool<T>::_writeDataSurfaceMpi(int period)
{
    if (file_handle == MPI_FILE_NULL)
    {
        std::cerr << "[OutputCsvTool]: Trying to access an unopened file. Please also use init and "
                     "output chains "
                     "when using MPI I/O.\n";
        throw std::runtime_error(
            "[OutputCsvTool]: Trying to access an unopened file. Please also use init and output "
            "chains when using "
            "MPI I/O.");
    }
    for (const auto& field_name : m_save_fields)
    {
        // Get only the surface values of the field variable.
        try
        {
            const std::valarray<T>& field{this->sim->getField(field_name)};
            std::valarray<T> field_surface(field.size() / period);
            for (int i{0}; i < field_surface.size(); i++)
            {
                field_surface[i] = field[i * period];
            }
            // Update the starting position (in bytes) for the next write
            // Each process from the first k can write at position rank * size of its array.
            // Each process > k needs to account for the larger k processes to determine its pointer
            // start.
            displacement = _calcDisplacement(field) / period + start;
            MPI_File_write_at_all(file_handle, displacement, &field_surface[0],
                                  static_cast<int>(field_surface.size()), m_dtype,
                                  MPI_STATUS_IGNORE);
            // Update the starting position (in bytes) for the next write
            if (field.size() == numerical_layers * local_number_of_facets)
            {
                start += type_size * numerical_layers * global_number_of_facets / period;
                footer += field_name + "," + std::to_string(this->sim->elapsed_time) + ","
                          + std::to_string(numerical_layers * global_number_of_facets / period)
                          + ",";
            }
        }
        catch (const BadInput& e)
        {
            std::cerr << "[OutputCsvTool]: " << field_name
                      << " module not "
                         "loaded or accessable!\n "
                         "[OutputCsvTool]:"
                      << e.what() << '\n';
            throw BadInput(static_cast<std::string>("[OutputCsvTool]: ") + field_name
                           + static_cast<std::string>(" module "
                                                      "not loaded or "
                                                      "accessable!\n [OutputCsvTool]: ")
                           + static_cast<std::string>(e.what()));
        }
    }
}
 
template <typename T>
MPI_Offset OutputCsvTool<T>::_calcDisplacement(const std::valarray<T>& field)
{
    MPI_Offset proc_displacement;
    if (field.size() == numerical_layers * local_number_of_facets)
    {
        // For the block of same size processes, displacement is rank * local_field_size *
        // data_type_byte_size.
        if (this->sim->my_rank < this->sim->number_of_larger_procs)
        {
            proc_displacement =
                this->sim->my_rank * static_cast<MPI_Offset>(field.size()) * type_size;
        }
        // For the second block, add the first block displacement and count how many second block
        // processes are between the targeted position and the first block.
        // local_field_size_large_proc = local_field_size_small_proc + numerical_layers.
        else
        {
            proc_displacement =
                (this->sim->number_of_larger_procs * (field.size() + numerical_layers)
                 + (this->sim->my_rank - this->sim->number_of_larger_procs)
                       * static_cast<MPI_Offset>(field.size()))
                * type_size;
        }
    }
    else if (field.size() == local_number_of_facets)
    {
        // For the block of same size processes, displacement is rank * local_field_size *
        // data_type_byte_size.
        if (this->sim->my_rank < this->sim->number_of_larger_procs)
        {
            proc_displacement =
                this->sim->my_rank * static_cast<MPI_Offset>(field.size()) * type_size;
        }
        // For the second block, add the first block displacement and count how many second block
        // processes are between the targeted position and the first block.
        // local_field_size_large_proc = local_field_size_small_proc + 1.
        else
        {
            proc_displacement =
                (this->sim->number_of_larger_procs * (field.size() + 1)
                 + (this->sim->my_rank - this->sim->number_of_larger_procs) * field.size())
                * type_size;
        }
    }
    else
    {
        proc_displacement = type_size * static_cast<MPI_Offset>(field.size());
    }
    return proc_displacement;
}
 
template <typename T>
void OutputCsvTool<T>::_writeFooter()
{
    MPI_Offset footer_displacement{start};
    MPI_Offset data_size_displacement{
        static_cast<MPI_Offset>(start + footer_type_size * footer.size())};
    if (this->sim->my_rank == 0)
    {
        MPI_File_write_at(file_handle, footer_displacement, footer.c_str(),
                          static_cast<int>(footer.size()), MPI_UNSIGNED_CHAR, MPI_STATUS_IGNORE);
        data_sizes[0] = start / type_size;
        data_sizes[1] = footer.size();
        MPI_File_write_at(file_handle, data_size_displacement, data_sizes, 2, MPI_INT64_T,
                          MPI_STATUS_IGNORE);
    }
}
#endif
 
template <typename T>
void OutputCsvTool<T>::_utcIntervalToSeconds()
{
    std::vector<std::string> m_interval_start_times_utc{
        this->ini_file_data.getStringVectorParameters("interval_start_times_utc")};
    std::vector<std::string> m_interval_end_times_utc{
        this->ini_file_data.getStringVectorParameters("interval_end_times_utc")};
    const std::string format = "%Y-%m-%dT%H:%M:%S";
    std::tm tm_struct{};  // Always zero-initialize this type.
    tm_struct.tm_isdst = -1;
    std::istringstream sstream{};
    std::time_t time_point{};
 
    sstream.str(m_start_time_utc);
    sstream >> std::get_time(&tm_struct, format.c_str());
    time_point = std::mktime(&tm_struct);
    m_start_time_seconds = static_cast<int64_t>(time_point);
    if (sstream.fail())
    {
        std::cerr << "[OutputCsvTool]: Could not parse the start time stamp: " << m_start_time_utc
                  << "!\nPlease use the format YYYY-MM-DDThh:mm:ss\n";
        throw std::runtime_error("[OutputCsvTool]: Could not parse the start time stamp: "
                                 + m_start_time_utc
                                 + "!\nPlease use the format YYYY-MM-DDThh:mm:ss\n");
    }
    sstream.clear();
 
    for (int i{0}; i < m_interval_start_times_utc.size(); i++)
    {
        sstream.str(m_interval_start_times_utc[i]);
        sstream >> std::get_time(&tm_struct, format.c_str());
        time_point = std::mktime(&tm_struct);
        m_interval_start_times_seconds.push_back(static_cast<int64_t>(time_point));
        if (sstream.fail())
        {
            std::cerr << "[OutputCsvTool]: Could not parse the starting interval time stamp: "
                      << m_interval_start_times_utc[i]
                      << "!\nPlease use the format YYYY-MM-DDThh:mm:ss\n";
            throw std::runtime_error(
                "[OutputCsvTool]: Could not parse the starting interval time stamp: "
                + m_interval_start_times_utc[i] + "!\nPlease use the format YYYY-MM-DDThh:mm:ss\n");
        }
        sstream.clear();
    }
 
    for (int i{0}; i < m_interval_end_times_utc.size(); i++)
    {
        sstream.str(m_interval_end_times_utc[i]);
        sstream >> std::get_time(&tm_struct, format.c_str());
        time_point = std::mktime(&tm_struct);
        m_interval_end_times_seconds.push_back(static_cast<int64_t>(time_point));
        if (sstream.fail())
        {
            std::cerr << "[OutputCsvTool]: Could not parse the starting interval time stamp: "
                      << m_interval_end_times_utc[i]
                      << "!\nPlease use the format YYYY-MM-DDThh:mm:ss\n";
            throw std::runtime_error(
                "[OutputCsvTool]: Could not parse the starting interval time stamp: "
                + m_interval_end_times_utc[i] + "!\nPlease use the format YYYY-MM-DDThh:mm:ss\n");
        }
        sstream.clear();
    }
 
    // I do this test here and not in checkIntervalIntegrity to not have them sorted yet so I can
    // give the utc time stamps back to the user.
    for (int i{0}; i < m_interval_end_times_utc.size(); i++)
    {
        if (m_interval_start_times_seconds[i] > m_interval_end_times_seconds[i])
        {
            std::cerr << "[OutputCsvTool]: Starting time of interval "
                      << m_interval_start_times_utc[i] << " is after the end time of the interval "
                      << m_interval_end_times_utc[i]
                      << "! Please ensure that interval start time < interval end time.\n";
            throw std::runtime_error(
                "[OutputCsvTool]: Starting time of interval " + m_interval_start_times_utc[i]
                + " is after the end time of the interval " + m_interval_end_times_utc[i]
                + "! Please ensure that interval start time < interval end time.\n");
        }
 
        // I sort here, because I expect the user to give disjoint intervals. If I didn't and the
        // user did not sort the intervals in ascending order themself, the code would lock up and
        // might skip intervals, so sorting here should do what the user wants more often than not
        // sorting.
        std::sort(m_interval_start_times_seconds.begin(), m_interval_start_times_seconds.end());
        std::sort(m_interval_end_times_seconds.begin(), m_interval_end_times_seconds.end());
 
        _verifyIntervalIntegrity();
    }
}
 
template <typename T>
void OutputCsvTool<T>::_verifyIntervalIntegrity()
{
    if (m_interval_start_times_seconds.size() != m_interval_end_times_seconds.size())
    {
        std::cerr << "[OutputCsvTool]: Start and end intervalls have different amount of time "
                     "stamps!\n";
        throw std::runtime_error(
            "[OutputCsvTool]: Start and end intervalls have different amount of time "
            "stamps!\n");
    }
 
    int intervals_out_of_range{0};
    double sim_end_time{m_start_time_seconds + m_time_max};
    for (int i{0}; i < m_interval_start_times_seconds.size(); i++)
    {
        if (m_interval_start_times_seconds[i] > sim_end_time
            || m_interval_end_times_seconds[i] < m_start_time_seconds)
        {
            intervals_out_of_range++;
        }
    }
    if (intervals_out_of_range == m_interval_start_times_seconds.size())
    {
        std::cerr << "[OutputCsvTool]: None of the given intervals are within the simulation "
                     "time span! Please provide at least one valid interval.\n";
        throw std::runtime_error(
            "[OutputCsvTool]: None of the given intervals are within the simulation time span! "
            "Please provide at least one valid interval.\n");
    }
    else if (intervals_out_of_range > 0)
    {
        std::cerr << "[OutputCsvTool]: " << intervals_out_of_range << " out of "
                  << m_interval_start_times_seconds.size()
                  << " intervals are outside of the simulation time span and will be ignored\n";
    }
}
 
template <typename T>
bool OutputCsvTool<T>::_checkInterval()
{
    while (m_currentIndex < m_interval_start_times_seconds.size())
    {
        // If we are within an time interval, check if we are also within a time step interval and
        // return true or false.
        if (m_interval_start_times_seconds[m_currentIndex]
                <= m_start_time_seconds + this->sim->time_step * m_time_delta
            && m_interval_end_times_seconds[m_currentIndex]
                   >= m_start_time_seconds + this->sim->time_step * m_time_delta)
        {
            if (this->sim->time_step % this->ini_file_data.getIntParameters("interval") == 0)
            {
                return true;
            }
            else
            {
                return false;
            }
        }
        // If we have passed an interval, go to the next one (don't return yet, for there might be
        // multiple intervals out of the time span).
        else if (m_interval_end_times_seconds[m_currentIndex]
                 < m_start_time_seconds + this->sim->time_step * m_time_delta)
        {
            m_currentIndex++;
        }
        // Otherwise, we are currently outside of an interval and return false.
        else
        {
            return false;
        }
    }
    // If the while loop exits, we have passed the final interval and can always return false.
    return false;
}
 
template <typename T>
bool OutputCsvTool<T>::m_registered = ModuleFactory<T>::registerModule(getName(), createMethode);
 
#endif  // OUTPUT_CSV_TOOL_H