NodePartitionedMeshReader.h

Go to the documentation of this file.

 
#pragma once
 
#include <iosfwd>
#include <string>
#include <vector>
 
#include <mpi.h>
 
#include "MeshLib/NodePartitionedMesh.h"
#include "MeshLib/Properties.h"
#include "MeshLib/IO/MPI_IO/PropertyVectorMetaData.h"
 
namespace MeshLib
{
class Node;
class Element;
class Properties;
 
namespace IO
{
class NodePartitionedMeshReader final
{
public:
    explicit NodePartitionedMeshReader(MPI_Comm comm);
 
    ~NodePartitionedMeshReader();
 
    MeshLib::NodePartitionedMesh* read(const std::string &file_name_base);
 
private:
    MPI_Comm _mpi_comm;
 
    int _mpi_comm_size;
 
    int _mpi_rank;
 
    MPI_Datatype _mpi_node_type;
 
    struct NodeData
    {
        std::size_t index;     
        double x;
        double y;
        double z;
    };
 
    void registerNodeDataMpiType();
 
    struct PartitionedMeshInfo
    {
        unsigned long nodes;  
        unsigned long base_nodes;        
        unsigned long regular_elements;  
        unsigned long
            ghost_elements;  
        unsigned long active_base_nodes;  
        unsigned long
            active_nodes;  
        unsigned long global_base_nodes;  
        unsigned long global_nodes;  
        unsigned long offset[5];   
        unsigned long extra_flag;  
 
        std::size_t size() const { return 14; }
        unsigned long* data() { return &nodes; }
    } _mesh_info;
 
    MeshLib::NodePartitionedMesh* newMesh(
        std::string const& mesh_name,
        std::vector<MeshLib::Node*> const& mesh_nodes,
        std::vector<unsigned long> const& glb_node_ids,
        std::vector<MeshLib::Element*> const& mesh_elems,
        MeshLib::Properties const& properties) const;
 
    template <typename DATA>
    bool readDataFromFile(std::string const& filename, MPI_Offset offset,
        MPI_Datatype type, DATA& data) const;
 
    MeshLib::NodePartitionedMesh* readMesh(const std::string &file_name_base);
 
    MeshLib::Properties readProperties(
        const std::string& file_name_base) const;
 
    void readProperties(const std::string& file_name_base,
                              MeshLib::MeshItemType t,
                              MeshLib::Properties& p) const;
 
    void readDomainSpecificPartOfPropertyVectors(
        std::vector<std::optional<MeshLib::IO::PropertyVectorMetaData>> const&
            vec_pvmd,
        MeshLib::IO::PropertyVectorPartitionMetaData const& pvpmd,
        MeshLib::MeshItemType t,
        std::istream& is,
        MeshLib::Properties& p) const;
 
    template <typename T>
    void createPropertyVectorPart(
        std::istream& is, MeshLib::IO::PropertyVectorMetaData const& pvmd,
        MeshLib::IO::PropertyVectorPartitionMetaData const& pvpmd,
        MeshLib::MeshItemType t, unsigned long global_offset,
        MeshLib::Properties& p) const
    {
        MeshLib::PropertyVector<T>* pv = p.createNewPropertyVector<T>(
            pvmd.property_name, t, pvmd.number_of_components);
        pv->resize(pvpmd.number_of_tuples * pvmd.number_of_components);
        // jump to the place for reading the specific part of the
        // PropertyVector
        is.seekg(global_offset +
                 pvpmd.offset * pvmd.number_of_components * sizeof(T));
        // read the values
        unsigned long const number_of_bytes = pvmd.data_type_size_in_bytes *
                                              pvpmd.number_of_tuples *
                                              pvmd.number_of_components;
        if (!is.read(reinterpret_cast<char*>(pv->data()), number_of_bytes))
            OGS_FATAL(
                "Error in NodePartitionedMeshReader::readProperties: "
                "Could not read part {:d} of the PropertyVector.",
                _mpi_rank);
    }
 
    void setNodes(const std::vector<NodeData> &node_data,
        std::vector<MeshLib::Node*> &mesh_node,
        std::vector<unsigned long> &glb_node_ids) const;
 
    void setElements(const std::vector<MeshLib::Node*> &mesh_nodes,
        const std::vector<unsigned long> &elem_data,
        std::vector<MeshLib::Element*> &mesh_elems,
        const bool ghost = false) const;
};
}   // end namespace IO
}   // end namespace MeshLib