NodePartitionedMeshReader.h

Go to the documentation of this file.

 
#pragma once
 
#include <mpi.h>
 
#include <iosfwd>
#include <string>
#include <vector>
 
#include "BaseLib/MPI.h"
#include "MeshLib/IO/MPI_IO/PropertyVectorMetaData.h"
#include "MeshLib/IO/NodeData.h"
#include "MeshLib/NodePartitionedMesh.h"
#include "MeshLib/Properties.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:
    BaseLib::MPI::Mpi mpi_;
 
    MPI_Datatype _mpi_node_type;
 
    void registerNodeDataMpiType();
 
    struct PartitionedMeshInfo
    {
        unsigned long
            number_of_nodes;  
        unsigned long number_of_base_nodes;  
        unsigned long
            number_of_regular_elements;  
        unsigned long
            number_of_ghost_elements;  
        unsigned long
            number_of_regular_base_nodes;  
        unsigned long
            number_of_regular_nodes;  
        unsigned long
            number_of_global_base_nodes;  
        unsigned long
            number_of_global_nodes;  
        unsigned long offset[5];   
        unsigned long extra_flag;  
 
        std::size_t size() const { return 14; }
        unsigned long* data() { return &number_of_nodes; }
    } _mesh_info;
    struct PartitionedMeshInfo {…};
 
    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);
 
        // Locate the start position of the data in the file for the current
        // rank.
        is.seekg(global_offset +
                 pvpmd.offset * pvmd.number_of_components * sizeof(T));
        // read the values
        if (!is.read(reinterpret_cast<char*>(pv->data()),
                     pv->size() * sizeof(T)))
            OGS_FATAL(
                "Error in NodePartitionedMeshReader::readProperties: "
                "Could not read part {:d} of the PropertyVector.",
                mpi_.rank);
    }
    void createPropertyVectorPart( {…}
 
    template <typename T>
    void createSpecificPropertyVectorPart(
        std::istream& is, MeshLib::IO::PropertyVectorMetaData const& pvmd,
        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);
 
        std::size_t const property_vector_size =
            pvmd.number_of_tuples / mpi_.size;
        pv->resize(property_vector_size);
 
        // Locate the start position of the data in the file for the current
        // rank.
        is.seekg(global_offset + property_vector_size * sizeof(T) * mpi_.rank);
 
        // read the values
        if (!is.read(reinterpret_cast<char*>(pv->data()),
                     pv->size() * sizeof(T)))
        {
            OGS_FATAL(
                "Error in NodePartitionedMeshReader::readProperties: "
                "Could not read part {:d} of the PropertyVector.",
                mpi_.rank);
        }
    }
    void createSpecificPropertyVectorPart( {…}
 
    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;
};
class NodePartitionedMeshReader final {…};
}  // end namespace IO
}  // end namespace MeshLib