MeshFromCsvUtilities.hpp

Go to the documentation of this file.

// _LICENSE_HEADER_
//
// Copyright (C) 2019 - 2025.
// Terms register on the GPL-3.0 license.
//
// This file can be redistributed and/or modified under the license terms.
//
// See top level LICENSE file for more details.
//
// This file can be used citing references in CITATION.cff file.
 
#ifndef __MeshImporterFromCsvUtilities_H
#define __MeshImporterFromCsvUtilities_H
 
#include "IFileTextReader.hpp"
#include "IMeshDAO.hpp"
 
namespace Gedim
{
class MeshFromCsvUtilities final
{
  public:
    struct Configuration
    {
        std::string Folder = "./";
        std::string FileCell0DsName = "Cell0Ds";
        std::string FileCell1DsName = "Cell1Ds";
        std::string FileCell2DsName = "Cell2Ds";
        std::string FileCell3DsName = "Cell3Ds";
        std::string FileCell0DNeighboursName = "Cell0DNeighbours";
        std::string FileCell1DNeighboursName = "Cell1DNeighbours";
        std::string FileCell2DNeighboursName = "Cell2DNeighbours";
        std::string FileCell0DPropertiesName = "Cell0DProperties";
        std::string FileCell1DPropertiesName = "Cell1DProperties";
        std::string FileCell2DPropertiesName = "Cell2DProperties";
        std::string FileCell3DPropertiesName = "Cell3DProperties";
        std::string FileCell2DSubDivisionsName = "Cell2DSubDivisions";
        std::string FileCell0DUpdatedCellsName = "Cell0DUpdatedCells";
        std::string FileCell1DUpdatedCellsName = "Cell1DUpdatedCells";
        std::string FileCell2DUpdatedCellsName = "Cell2DUpdatedCells";
        std::string FileCell3DUpdatedCellsName = "Cell3DUpdatedCells";
        char Separator = ';';
        std::string FileExtension = "csv";
    };
 
    struct CellDoubleProperty
    {
        struct Value
        {
            unsigned int CellId;
            std::vector<double> Values;
        };
 
        std::string Id;
        std::string FilePath;
        std::vector<Gedim::MeshFromCsvUtilities::CellDoubleProperty::Value> Values;
    };
 
    struct Cell0D
    {
        unsigned int Id;
        double X;
        double Y;
        double Z;
        unsigned int Marker;
        bool Active;
    };
 
    struct Cell0DNeighbours
    {
        unsigned int Id;
        std::vector<unsigned int> Cell1DNeighbours;
        std::vector<unsigned int> Cell2DNeighbours;
        std::vector<unsigned int> Cell3DNeighbours;
    };
 
    struct CellUpdatedCells
    {
        unsigned int Id;
        std::vector<unsigned int> UpdatedCells;
    };
 
    struct Cell1D
    {
        unsigned int Id;
        unsigned int Origin;
        unsigned int End;
        unsigned int Marker;
        bool Active;
    };
 
    struct Cell1DNeighbours
    {
        unsigned int Id;
        std::vector<unsigned int> Cell2DNeighbours;
        std::vector<unsigned int> Cell3DNeighbours;
    };
 
    struct Cell2D
    {
        unsigned int Id;
        std::vector<unsigned int> Vertices;
        std::vector<unsigned int> Edges;
        unsigned int Marker;
        bool Active;
    };
 
    struct Cell2DNeighbours
    {
        unsigned int Id;
        std::vector<unsigned int> Cell3DNeighbours;
    };
 
    struct Cell2DSubDivision
    {
        unsigned int Id;
        std::vector<unsigned int> SubDivision;
    };
 
    struct Cell3D
    {
        unsigned int Id;
        std::vector<unsigned int> Vertices;
        std::vector<unsigned int> Edges;
        std::vector<unsigned int> Faces;
        unsigned int Marker;
        bool Active;
    };
 
  private:
    std::vector<Gedim::MeshFromCsvUtilities::CellDoubleProperty::Value> ImportCellProperty(IFileReader &csvFileReader,
                                                                                           const char &separator) const;
 
  public:
    MeshFromCsvUtilities();
    ~MeshFromCsvUtilities();
 
    void ConvertMesh2D(const std::vector<Gedim::MeshFromCsvUtilities::Cell0D> &cell0Ds,
                       const std::vector<Gedim::MeshFromCsvUtilities::Cell1D> &cell1Ds,
                       const std::vector<Gedim::MeshFromCsvUtilities::Cell2D> &cell2Ds,
                       Gedim::IMeshDAO &mesh) const;
 
    void ConvertCell0Ds(const std::vector<Gedim::MeshFromCsvUtilities::Cell0D> cell0Ds, Gedim::IMeshDAO &mesh) const;
    void ConvertCell1Ds(const std::vector<Gedim::MeshFromCsvUtilities::Cell1D> cell1Ds, Gedim::IMeshDAO &mesh) const;
    void ConvertCell2Ds(const std::vector<Gedim::MeshFromCsvUtilities::Cell2D> cell2Ds, Gedim::IMeshDAO &mesh) const;
    void ConvertCell3Ds(const std::vector<Gedim::MeshFromCsvUtilities::Cell3D> cell3Ds, Gedim::IMeshDAO &mesh) const;
 
    void ConvertCell0DNeighbours(const std::vector<Gedim::MeshFromCsvUtilities::Cell0DNeighbours> cell0DNeighbours,
                                 Gedim::IMeshDAO &mesh) const;
    void ConvertCell1DNeighbours(const std::vector<Gedim::MeshFromCsvUtilities::Cell1DNeighbours> cell1DNeighbours,
                                 Gedim::IMeshDAO &mesh) const;
    void ConvertCell2DNeighbours(const std::vector<Gedim::MeshFromCsvUtilities::Cell2DNeighbours> cell2DNeighbours,
                                 Gedim::IMeshDAO &mesh) const;
 
    void ConvertCell2DSubDivisions(const std::vector<Gedim::MeshFromCsvUtilities::Cell2DSubDivision> cell2DSubDivisions,
                                   Gedim::IMeshDAO &mesh) const;
 
    void ConvertCell0DDoubleProperties(const std::vector<Gedim::MeshFromCsvUtilities::CellDoubleProperty> cell0DDoubleProperties,
                                       Gedim::IMeshDAO &mesh) const;
    void ConvertCell1DDoubleProperties(const std::vector<Gedim::MeshFromCsvUtilities::CellDoubleProperty> cell1DDoubleProperties,
                                       Gedim::IMeshDAO &mesh) const;
    void ConvertCell2DDoubleProperties(const std::vector<Gedim::MeshFromCsvUtilities::CellDoubleProperty> cell2DDoubleProperties,
                                       Gedim::IMeshDAO &mesh) const;
    void ConvertCell3DDoubleProperties(const std::vector<Gedim::MeshFromCsvUtilities::CellDoubleProperty> cell3DDoubleProperties,
                                       Gedim::IMeshDAO &mesh) const;
 
    void ConvertCell0DUpdatedCells(const std::vector<Gedim::MeshFromCsvUtilities::CellUpdatedCells> cell0DUpdatedCells,
                                   Gedim::IMeshDAO &mesh) const;
    void ConvertCell1DUpdatedCells(const std::vector<Gedim::MeshFromCsvUtilities::CellUpdatedCells> cell1DUpdatedCells,
                                   Gedim::IMeshDAO &mesh) const;
    void ConvertCell2DUpdatedCells(const std::vector<Gedim::MeshFromCsvUtilities::CellUpdatedCells> cell2DUpdatedCells,
                                   Gedim::IMeshDAO &mesh) const;
    void ConvertCell3DUpdatedCells(const std::vector<Gedim::MeshFromCsvUtilities::CellUpdatedCells> cell3DUpdatedCells,
                                   Gedim::IMeshDAO &mesh) const;
 
    std::vector<Cell0D> ImportCell0Ds(IFileReader &csvFileReader, const char &separator) const;
    std::vector<Cell1D> ImportCell1Ds(IFileReader &csvFileReader, const char &separator) const;
    std::vector<Cell2D> ImportCell2Ds(IFileReader &csvFileReader, const char &separator) const;
    std::vector<Cell3D> ImportCell3Ds(IFileReader &csvFileReader, const char &separator) const;
 
    std::vector<Cell0DNeighbours> ImportCell0DNeighbours(IFileReader &csvFileReader, const char &separator) const;
    std::vector<Cell1DNeighbours> ImportCell1DNeighbours(IFileReader &csvFileReader, const char &separator) const;
 
    std::vector<Cell2DNeighbours> ImportCell2DNeighbours(IFileReader &csvFileReader, const char &separator) const;
 
    std::vector<Cell2DSubDivision> ImportCell2DSubDivision(IFileReader &csvFileReader, const char &separator) const;
 
    std::vector<CellDoubleProperty> ImportCellDoubleProperties(IFileReader &csvFileReader, const char &separator) const;
 
    std::vector<CellUpdatedCells> ImportCellUpdatedCells(IFileReader &csvFileReader, const char &separator) const;
 
    void ExportCell0Ds(const std::string &filePath, const char &separator, const Gedim::IMeshDAO &mesh) const;
    void ExportCell1Ds(const std::string &filePath, const char &separator, const Gedim::IMeshDAO &mesh) const;
    void ExportCell2Ds(const std::string &filePath, const char &separator, const Gedim::IMeshDAO &mesh) const;
    void ExportCell3Ds(const std::string &filePath, const char &separator, const Gedim::IMeshDAO &mesh) const;
 
    void ExportCell0DProperties(const std::string &exportFolder,
                                const std::string &propertyFileName,
                                const std::string &propertyFileExtension,
                                const char &separator,
                                const Gedim::IMeshDAO &mesh) const;
 
    void ExportCell0DProperty(const unsigned int &propertyIndex,
                              const std::string &filePath,
                              const char &separator,
                              const Gedim::IMeshDAO &mesh) const;
 
    void ExportCell1DProperties(const std::string &exportFolder,
                                const std::string &propertyFileName,
                                const std::string &propertyFileExtension,
                                const char &separator,
                                const Gedim::IMeshDAO &mesh) const;
 
    void ExportCell1DProperty(const unsigned int &propertyIndex,
                              const std::string &filePath,
                              const char &separator,
                              const Gedim::IMeshDAO &mesh) const;
 
    void ExportCell2DProperties(const std::string &exportFolder,
                                const std::string &propertyFileName,
                                const std::string &propertyFileExtension,
                                const char &separator,
                                const Gedim::IMeshDAO &mesh) const;
 
    void ExportCell2DProperty(const unsigned int &propertyIndex,
                              const std::string &filePath,
                              const char &separator,
                              const Gedim::IMeshDAO &mesh) const;
 
    void ExportCell3DProperties(const std::string &exportFolder,
                                const std::string &propertyFileName,
                                const std::string &propertyFileExtension,
                                const char &separator,
                                const Gedim::IMeshDAO &mesh) const;
 
    void ExportCell3DProperty(const unsigned int &propertyIndex,
                              const std::string &filePath,
                              const char &separator,
                              const Gedim::IMeshDAO &mesh) const;
 
    void ExportCell0DNeighbours(const std::string &filePath, const char &separator, const Gedim::IMeshDAO &mesh) const;
    void ExportCell1DNeighbours(const std::string &filePath, const char &separator, const Gedim::IMeshDAO &mesh) const;
    void ExportCell2DNeighbours(const std::string &filePath, const char &separator, const Gedim::IMeshDAO &mesh) const;
    void ExportCell2DSubDivisions(const std::string &filePath, const char &separator, const Gedim::IMeshDAO &mesh) const;
 
    void ExportCell0DUpdatedCells(const std::string &filePath, const char &separator, const Gedim::IMeshDAO &mesh) const;
    void ExportCell1DUpdatedCells(const std::string &filePath, const char &separator, const Gedim::IMeshDAO &mesh) const;
    void ExportCell2DUpdatedCells(const std::string &filePath, const char &separator, const Gedim::IMeshDAO &mesh) const;
    void ExportCell3DUpdatedCells(const std::string &filePath, const char &separator, const Gedim::IMeshDAO &mesh) const;
};
 
} // namespace Gedim
 
#endif // __MeshImporterFromCsvUtilities_H