csv_mesh_writer.h

Go to the documentation of this file.

#ifndef CSV_MESH_WRITER_H
#define CSV_MESH_WRITER_H
 
#include "kernel/base/types.h"
#include "kernel/discretization/mesh_predicates.h"
#include "kernel/discretization/node_mesh_iterator.h"
#include "kernel/utilities/csv_file_writer.h"
 
#include <initializer_list>
#include <tuple>
#include <vector>
 
namespace kernel
{
 
namespace numerics
{
template <int dim> class LineMesh;
}
 
class CSVMeshWriter
{
 
  public:
    static char default_delimiter() { return ','; }
 
    CSVMeshWriter(const std::string &filename,
                  char delim = kernel::utilities::CSVWriter::default_delimiter(),
                  bool open_file = false, const std::ios_base::openmode mode = std::ios_base::out);
 
    void write_column_names(const std::vector<std::string> &col_names, bool write_header = true);
 
    void write_column_names(const std::vector<std::string_view> &col_names,
                            bool write_header = true);
 
    void write_column_names(const std::initializer_list<std::string_view> &col_names,
                            bool write_header = true);
 
    template <typename T> void write_row(const std::vector<T> &vals);
 
    template <typename T> void write_row(const DynVec<T> &vals);
 
    template <typename... T> void write_row(const std::tuple<T...> &row);
 
    void set_delimiter(char delim) noexcept { writer_.set_delimiter(delim); }
 
    char get_delimiter() const noexcept { return writer_.get_delimiter(); }
 
    bool is_open() const { return writer_.is_open(); }
 
    void write_mesh(const numerics::LineMesh<2> &mesh);
 
    template <typename MeshTp> void write_mesh_nodes(const MeshTp &mesh);
 
  private:
    kernel::utilities::CSVWriter writer_;
};
 
inline void CSVMeshWriter::write_column_names(const std::vector<std::string> &col_names,
                                              bool write_header)
{
 
    writer_.write_column_names(col_names, write_header);
}
 
inline void CSVMeshWriter::write_column_names(const std::vector<std::string_view> &col_names,
                                              bool write_header)
{
 
    writer_.write_column_names(col_names, write_header);
}
 
inline void
CSVMeshWriter::write_column_names(const std::initializer_list<std::string_view> &col_names,
                                  bool write_header)
{
 
    std::vector<std::string_view> names(col_names);
    write_column_names(names, write_header);
}
 
template <typename T> void CSVMeshWriter::write_row(const std::vector<T> &vals)
{
    writer_.write_row(vals);
}
 
template <typename T> void CSVMeshWriter::write_row(const DynVec<T> &vals)
{
 
    writer_.write_row(vals);
}
 
template <typename MeshTp> void CSVMeshWriter::write_mesh_nodes(const MeshTp &mesh)
{
 
    if (!is_open())
    {
        throw std::logic_error("File " + writer_.get_filename() + " is not open");
    }
 
    numerics::ConstNodeMeshIterator<numerics::Active, MeshTp> filter(mesh);
    auto &file_stream = writer_.get_file_stream();
 
    auto begin = filter.begin();
    auto end = filter.end();
 
    for (; begin != end; ++begin)
    {
        auto *node = *begin;
 
        for (uint_t d = 0; d < MeshTp::dimension; ++d)
        {
 
            file_stream << (*node)[d];
 
            if (d == MeshTp::dimension - 1)
            {
                file_stream << std::endl;
            }
            else
            {
                file_stream << ",";
            }
        }
    }
 
    file_stream.flush();
    file_stream.close();
}
 
template <typename... T> void CSVMeshWriter::write_row(const std::tuple<T...> &row)
{
    writer_.write_row(row);
}
 
} // namespace kernel
 
#endif // CSV_FILE_WRITER_H