MeshLib::IO::NodePartitionedMeshReader Class Reference

Detailed Description

Class for parallel reading of binary partitioned mesh files into a NodePartitionedMesh via MPI.

Definition at line 37 of file NodePartitionedMeshReader.h.

#include <NodePartitionedMeshReader.h>

Collaboration diagram for MeshLib::IO::NodePartitionedMeshReader:

Classes
struct	PartitionedMeshInfo
	A collection of integers that configure the partitioned mesh data. More...

Public Member Functions
	NodePartitionedMeshReader (MPI_Comm comm)
	~NodePartitionedMeshReader ()
MeshLib::NodePartitionedMesh *	read (const std::string &file_name_base)
	Create a NodePartitionedMesh object, read data to it, and return a pointer to it. Data files are in binary format.

Private Member Functions
void	registerNodeDataMpiType ()
	Define MPI data type for NodeData struct.
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
	Create a new mesh of NodePartitionedMesh after reading and processing the data.
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)
	Create a NodePartitionedMesh object, read binary mesh data in the manner of parallel, and return a pointer to it. Four binary files have to been read in this function named as:
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
template<typename T >
void	createSpecificPropertyVectorPart (std::istream &is, MeshLib::IO::PropertyVectorMetaData const &pvmd, MeshLib::MeshItemType t, unsigned long global_offset, MeshLib::Properties &p) const
void	setNodes (const std::vector< NodeData > &node_data, std::vector< MeshLib::Node * > &mesh_node, std::vector< unsigned long > &glb_node_ids) const
	Set mesh nodes from a temporary array containing node data read from file.
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
	Set mesh elements from a temporary array containing node data read from file.

Private Attributes
MPI_Comm	_mpi_comm
	Pointer to MPI communicator.
int	_mpi_comm_size
	Number of processes in the communicator: _mpi_comm.
int	_mpi_rank
	Rank of compute core.
MPI_Datatype	_mpi_node_type
	MPI data type for struct NodeData.
struct MeshLib::IO::NodePartitionedMeshReader::PartitionedMeshInfo	_mesh_info

Constructor & Destructor Documentation

NodePartitionedMeshReader()

MeshLib::IO::NodePartitionedMeshReader::NodePartitionedMeshReader ( MPI_Comm comm )

explicit

Parameters

comm	MPI communicator.

Definition at line 48 of file NodePartitionedMeshReader.cpp.

    : _mpi_comm(comm)
{
    MPI_Comm_size(_mpi_comm, &_mpi_comm_size);
    MPI_Comm_rank(_mpi_comm, &_mpi_rank);
 
    registerNodeDataMpiType();
}

References _mpi_comm, _mpi_comm_size, _mpi_rank, and registerNodeDataMpiType().

~NodePartitionedMeshReader()

MeshLib::IO::NodePartitionedMeshReader::~NodePartitionedMeshReader

(

)

Definition at line 57 of file NodePartitionedMeshReader.cpp.

{
    MPI_Type_free(&_mpi_node_type);
}

References _mpi_node_type.

Member Function Documentation

createPropertyVectorPart()

template<typename T >

void MeshLib::IO::NodePartitionedMeshReader::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

inlineprivate

Definition at line 188 of file NodePartitionedMeshReader.h.

    {
        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);
    }

References _mpi_rank, MeshLib::IO::PropertyVectorMetaData::number_of_components, MeshLib::IO::PropertyVectorPartitionMetaData::number_of_tuples, MeshLib::IO::PropertyVectorPartitionMetaData::offset, OGS_FATAL, MeshLib::IO::PropertyVectorMetaData::property_name, and MeshLib::PropertyVector< PROP_VAL_TYPE >::size().

Referenced by readDomainSpecificPartOfPropertyVectors().

createSpecificPropertyVectorPart()

template<typename T >

void MeshLib::IO::NodePartitionedMeshReader::createSpecificPropertyVectorPart ( std::istream & is, MeshLib::IO::PropertyVectorMetaData const & pvmd, MeshLib::MeshItemType t, unsigned long global_offset, MeshLib::Properties & p ) const

inlineprivate

Read data for property OGS_VERSION or IntegrationPointMetaData, and create property vector for it.

Definition at line 214 of file NodePartitionedMeshReader.h.

    {
        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_comm_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);
        }
    }

References _mpi_comm_size, _mpi_rank, MeshLib::IO::PropertyVectorMetaData::number_of_components, MeshLib::IO::PropertyVectorMetaData::number_of_tuples, OGS_FATAL, MeshLib::IO::PropertyVectorMetaData::property_name, and MeshLib::PropertyVector< PROP_VAL_TYPE >::size().

Referenced by readDomainSpecificPartOfPropertyVectors().

newMesh()

MeshLib::NodePartitionedMesh * MeshLib::IO::NodePartitionedMeshReader::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

private

Create a new mesh of NodePartitionedMesh after reading and processing the data.

Parameters

mesh_name	Name assigned to the new mesh.
mesh_nodes	Node data.
glb_node_ids	Global IDs of nodes.
mesh_elems	Element data.
properties	Collection of PropertyVector's assigned to the mesh.

Returns

Returns a pointer to a NodePartitionedMesh

Definition at line 403 of file NodePartitionedMeshReader.cpp.

{
    std::vector<std::size_t> gathered_n_regular_base_nodes(_mpi_comm_size);
 
    MPI_Allgather(&_mesh_info.number_of_regular_base_nodes,
                  1,
                  MPI_UNSIGNED_LONG,
                  gathered_n_regular_base_nodes.data(),
                  1,
                  MPI_UNSIGNED_LONG,
                  _mpi_comm);
 
    std::vector<std::size_t> n_regular_base_nodes_at_rank;
    n_regular_base_nodes_at_rank.push_back(0);
    std::partial_sum(begin(gathered_n_regular_base_nodes),
                     end(gathered_n_regular_base_nodes),
                     back_inserter(n_regular_base_nodes_at_rank));
 
    std::vector<std::size_t> gathered_n_regular_high_order_nodes(
        _mpi_comm_size);
    std::size_t const n_regular_high_order_nodes =
        _mesh_info.number_of_regular_nodes -
        _mesh_info.number_of_regular_base_nodes;
    MPI_Allgather(&n_regular_high_order_nodes,
                  1,
                  MPI_UNSIGNED_LONG,
                  gathered_n_regular_high_order_nodes.data(),
                  1,
                  MPI_UNSIGNED_LONG,
                  _mpi_comm);
 
    std::vector<std::size_t> n_regular_high_order_nodes_at_rank;
    n_regular_high_order_nodes_at_rank.push_back(0);
    std::partial_sum(begin(gathered_n_regular_high_order_nodes),
                     end(gathered_n_regular_high_order_nodes),
                     back_inserter(n_regular_high_order_nodes_at_rank));
 
    return new MeshLib::NodePartitionedMesh(
        mesh_name, mesh_nodes, glb_node_ids, mesh_elems, properties,
        _mesh_info.number_of_global_base_nodes,
        _mesh_info.number_of_global_nodes, _mesh_info.number_of_regular_nodes,
        std::move(n_regular_base_nodes_at_rank),
        std::move(n_regular_high_order_nodes_at_rank));
}

References _mesh_info, _mpi_comm, _mpi_comm_size, MeshLib::IO::NodePartitionedMeshReader::PartitionedMeshInfo::number_of_global_base_nodes, MeshLib::IO::NodePartitionedMeshReader::PartitionedMeshInfo::number_of_global_nodes, MeshLib::IO::NodePartitionedMeshReader::PartitionedMeshInfo::number_of_regular_base_nodes, and MeshLib::IO::NodePartitionedMeshReader::PartitionedMeshInfo::number_of_regular_nodes.

Referenced by readMesh().

read()

MeshLib::NodePartitionedMesh * MeshLib::IO::NodePartitionedMeshReader::read

(

const std::string &

file_name_base

)

Create a NodePartitionedMesh object, read data to it, and return a pointer to it. Data files are in binary format.

Parameters

file_name_base

Name of file to be read, and it must be base name without name extension.

Returns

Pointer to Mesh object. If the creation of mesh object fails, it returns a null pointer.

Definition at line 74 of file NodePartitionedMeshReader.cpp.

{
    BaseLib::RunTime timer;
    timer.start();
 
    // Always try binary file first
    std::string const fname_new = file_name_base + "_partitioned_msh_cfg" +
                                  std::to_string(_mpi_comm_size) + ".bin";
 
    if (!BaseLib::IsFileExisting(fname_new))  // binary file does not exist.
    {
        std::string const fname_ascii = file_name_base +
                                        "_partitioned_msh_cfg" +
                                        std::to_string(_mpi_comm_size) + ".msh";
        if (BaseLib::IsFileExisting(fname_ascii))
        {
            ERR("Reading of ASCII mesh file {:s} is not supported since OGS "
                "version 6.3.3.",
                fname_ascii);
        }
        OGS_FATAL("Required binary file {:s} does not exist.\n", fname_new);
    }
 
    INFO("Reading corresponding part of mesh data from binary file {:s} ...",
         file_name_base);
 
    MeshLib::NodePartitionedMesh* mesh = readMesh(file_name_base);
 
    INFO("[time] Reading the mesh took {:f} s.", timer.elapsed());
 
    MPI_Barrier(_mpi_comm);
 
    return mesh;
}

References _mpi_comm, _mpi_comm_size, BaseLib::RunTime::elapsed(), ERR(), INFO(), BaseLib::IsFileExisting(), OGS_FATAL, readMesh(), and BaseLib::RunTime::start().

Referenced by MeshLib::IO::readMeshFromFile().

readDataFromFile()

template<typename DATA >

bool MeshLib::IO::NodePartitionedMeshReader::readDataFromFile ( std::string const & filename, MPI_Offset offset, MPI_Datatype type, DATA & data ) const

private

Parallel reading of a binary file via MPI_File_read, reading mesh data head, nodes, non-ghost elements and ghost elements.

Note

In case of failure during opening of the file, an error message is printed.

If the number of elements in container is larger than MPI_file_read() supports (maximum of current int type), an error is printed.

Parameters

filename	File name containing data.
offset	Displacement of the data accessible from the view. see MPI_File_set_view() documentation.
type	Type of data.
data	A container to be filled with data. Its size is used to determine how many values should be read.

Template Parameters

DATA	A homogeneous container type supporting data() and size().

Returns

True on success and false otherwise.

Definition at line 111 of file NodePartitionedMeshReader.cpp.

{
    // Check container size
    if (!is_safely_convertable<std::size_t, int>(data.size()))
    {
        ERR("The container size is too large for MPI_File_read() call.");
        return false;
    }
 
    // Open file
    MPI_File file;
 
    char* filename_char = const_cast<char*>(filename.data());
    int const file_status = MPI_File_open(
        _mpi_comm, filename_char, MPI_MODE_RDONLY, MPI_INFO_NULL, &file);
 
    if (file_status != 0)
    {
        ERR("Error opening file {:s}. MPI error code {:d}", filename,
            file_status);
        return false;
    }
 
    // Read data
    char file_mode[] = "native";
    MPI_File_set_view(file, offset, type, type, file_mode, MPI_INFO_NULL);
    // The static cast is checked above.
    MPI_File_read(file, data.data(), static_cast<int>(data.size()), type,
                  MPI_STATUS_IGNORE);
    MPI_File_close(&file);
 
    return true;
}

References _mpi_comm, ERR(), and is_safely_convertable().

Referenced by readMesh().

readDomainSpecificPartOfPropertyVectors()

void MeshLib::IO::NodePartitionedMeshReader::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

private

Definition at line 300 of file NodePartitionedMeshReader.cpp.

{
    unsigned long global_offset = 0;
    std::size_t const number_of_properties = vec_pvmd.size();
    for (std::size_t i(0); i < number_of_properties; ++i)
    {
        DBUG("global offset: {:d}, offset within the PropertyVector: {:d}.",
             global_offset,
             global_offset + pvpmd.offset * vec_pvmd[i]->number_of_components *
                                 vec_pvmd[i]->data_type_size_in_bytes);
 
        // Special field data such as OGS_VERSION, IntegrationPointMetaData,
        // etc., which are not "real" integration points, are copied "as is"
        // (i.e. fully) for every partition.
        if (vec_pvmd[i]->property_name.find("_ip") == std::string::npos &&
            t == MeshLib::MeshItemType::IntegrationPoint)
        {
            createSpecificPropertyVectorPart<char>(is, *vec_pvmd[i], t,
                                                   global_offset, p);
 
            global_offset += vec_pvmd[i]->data_type_size_in_bytes *
                             vec_pvmd[i]->number_of_tuples;
            continue;
        }
 
        if (vec_pvmd[i]->is_int_type)
        {
            if (vec_pvmd[i]->is_data_type_signed)
            {
                if (vec_pvmd[i]->data_type_size_in_bytes == sizeof(char))
                {
                    createPropertyVectorPart<char>(is, *vec_pvmd[i], pvpmd, t,
                                                   global_offset, p);
                }
                else if (vec_pvmd[i]->data_type_size_in_bytes == sizeof(int))
                {
                    createPropertyVectorPart<int>(is, *vec_pvmd[i], pvpmd, t,
                                                  global_offset, p);
                }
                else if (vec_pvmd[i]->data_type_size_in_bytes == sizeof(long))
                    createPropertyVectorPart<long>(is, *vec_pvmd[i], pvpmd, t,
                                                   global_offset, p);
                else
                {
                    WARN(
                        "Implementation for reading signed integer property "
                        "vector '{:s}' is not available.",
                        vec_pvmd[i]->property_name);
                }
            }
            else
            {
                if (vec_pvmd[i]->data_type_size_in_bytes ==
                    sizeof(unsigned char))
                {
                    createPropertyVectorPart<unsigned char>(
                        is, *vec_pvmd[i], pvpmd, t, global_offset, p);
                }
                else if (vec_pvmd[i]->data_type_size_in_bytes ==
                         sizeof(unsigned int))
                    createPropertyVectorPart<unsigned int>(
                        is, *vec_pvmd[i], pvpmd, t, global_offset, p);
                else if (vec_pvmd[i]->data_type_size_in_bytes ==
                         sizeof(unsigned long))
                    createPropertyVectorPart<unsigned long>(
                        is, *vec_pvmd[i], pvpmd, t, global_offset, p);
                else
                {
                    WARN(
                        "Implementation for reading unsigned property vector "
                        "'{:s}' is not available.",
                        vec_pvmd[i]->property_name);
                }
            }
        }
        else
        {
            if (vec_pvmd[i]->data_type_size_in_bytes == sizeof(float))
                createPropertyVectorPart<float>(is, *vec_pvmd[i], pvpmd, t,
                                                global_offset, p);
            else if (vec_pvmd[i]->data_type_size_in_bytes == sizeof(double))
                createPropertyVectorPart<double>(is, *vec_pvmd[i], pvpmd, t,
                                                 global_offset, p);
            else
            {
                WARN(
                    "Implementation for reading floating point property vector "
                    "'{:s}' is not available.",
                    vec_pvmd[i]->property_name);
            }
        }
        global_offset += vec_pvmd[i]->data_type_size_in_bytes *
                         vec_pvmd[i]->number_of_tuples *
                         vec_pvmd[i]->number_of_components;
    }
}

References createPropertyVectorPart(), createSpecificPropertyVectorPart(), DBUG(), MeshLib::IntegrationPoint, MeshLib::IO::PropertyVectorPartitionMetaData::offset, and WARN().

Referenced by readProperties().

readMesh()

MeshLib::NodePartitionedMesh * MeshLib::IO::NodePartitionedMeshReader::readMesh ( const std::string & file_name_base )

private

Create a NodePartitionedMesh object, read binary mesh data in the manner of parallel, and return a pointer to it. Four binary files have to been read in this function named as:

• file_name_base+_partitioned_msh_cfg[number of partitions].bin
• file_name_base+_partitioned_msh_nod[number of partitions].bin
• file_name_base+_partitioned_msh_ele[number of partitions].bin
• file_name_base+_partitioned_msh_ele_g[number of partitions].bin

in which, the first file contains an array of integers for the PartitionMeshInfo for all partitions, the second file contains a struct type (long, double double double) array of nodes information of global IDs and coordinates of all partitions, the third file contains a long type integer array of element information of material ID, element type and node IDs of each non-ghost element of all partitions, and the forth file contains a long type integer array of element information of material ID, element type and node IDs of each ghost element of all partitions.

Parameters

file_name_base

Name of file to be read, which must be a name with the path to the file and without file extension.

Returns

Pointer to Mesh object.

Definition at line 148 of file NodePartitionedMeshReader.cpp.

{
    //----------------------------------------------------------------------------------
    // Read headers
    const std::string fname_header = file_name_base + "_partitioned_msh_";
    const std::string fname_num_p_ext = std::to_string(_mpi_comm_size) + ".bin";
 
    // Read the config meta data from *cfg* file into struct PartitionedMeshInfo
    // _mesh_info
    if (!readDataFromFile(
            fname_header + "cfg" + fname_num_p_ext,
            static_cast<MPI_Offset>(static_cast<unsigned>(_mpi_rank) *
                                    sizeof(_mesh_info)),
            MPI_LONG, _mesh_info))
        return nullptr;
 
    //----------------------------------------------------------------------------------
    // Read Nodes
    std::vector<NodeData> nodes(_mesh_info.number_of_nodes);
 
    if (!readDataFromFile(fname_header + "nod" + fname_num_p_ext,
                          static_cast<MPI_Offset>(_mesh_info.offset[2]),
                          _mpi_node_type, nodes))
        return nullptr;
 
    std::vector<MeshLib::Node*> mesh_nodes;
    std::vector<unsigned long> glb_node_ids;
    setNodes(nodes, mesh_nodes, glb_node_ids);
 
    //----------------------------------------------------------------------------------
    // Read non-ghost elements
    std::vector<unsigned long> elem_data(_mesh_info.number_of_regular_elements +
                                         _mesh_info.offset[0]);
    if (!readDataFromFile(fname_header + "ele" + fname_num_p_ext,
                          static_cast<MPI_Offset>(_mesh_info.offset[3]),
                          MPI_LONG, elem_data))
        return nullptr;
 
    std::vector<MeshLib::Element*> mesh_elems(
        _mesh_info.number_of_regular_elements +
        _mesh_info.number_of_ghost_elements);
    setElements(mesh_nodes, elem_data, mesh_elems);
 
    //----------------------------------------------------------------------------------
    // Read ghost element
    std::vector<unsigned long> ghost_elem_data(
        _mesh_info.number_of_ghost_elements + _mesh_info.offset[1]);
 
    if (!readDataFromFile(fname_header + "ele_g" + fname_num_p_ext,
                          static_cast<MPI_Offset>(_mesh_info.offset[4]),
                          MPI_LONG, ghost_elem_data))
        return nullptr;
 
    const bool process_ghost = true;
    setElements(mesh_nodes, ghost_elem_data, mesh_elems, process_ghost);
 
    //----------------------------------------------------------------------------------
    // read the properties
    MeshLib::Properties p(readProperties(file_name_base));
 
    return newMesh(BaseLib::extractBaseName(file_name_base), mesh_nodes,
                   glb_node_ids, mesh_elems, p);
}

References _mesh_info, _mpi_comm_size, _mpi_node_type, _mpi_rank, BaseLib::extractBaseName(), newMesh(), MeshLib::IO::NodePartitionedMeshReader::PartitionedMeshInfo::number_of_ghost_elements, MeshLib::IO::NodePartitionedMeshReader::PartitionedMeshInfo::number_of_nodes, MeshLib::IO::NodePartitionedMeshReader::PartitionedMeshInfo::number_of_regular_elements, MeshLib::IO::NodePartitionedMeshReader::PartitionedMeshInfo::offset, readDataFromFile(), readProperties(), setElements(), and setNodes().

Referenced by read().

readProperties() [1/2]

MeshLib::Properties MeshLib::IO::NodePartitionedMeshReader::readProperties ( const std::string & file_name_base ) const

private

Definition at line 213 of file NodePartitionedMeshReader.cpp.

{
    MeshLib::Properties p;
    readProperties(file_name_base, MeshLib::MeshItemType::Node, p);
    readProperties(file_name_base, MeshLib::MeshItemType::Cell, p);
    readProperties(file_name_base, MeshLib::MeshItemType::IntegrationPoint, p);
    return p;
}

References MeshLib::Cell, MeshLib::IntegrationPoint, MeshLib::Node, and readProperties().

Referenced by readMesh(), and readProperties().

readProperties() [2/2]

void MeshLib::IO::NodePartitionedMeshReader::readProperties ( const std::string & file_name_base, MeshLib::MeshItemType t, MeshLib::Properties & p ) const

private

Definition at line 223 of file NodePartitionedMeshReader.cpp.

{
    const std::string item_type = MeshLib::toString(t);
 
    const std::string fname_cfg = file_name_base + "_partitioned_" + item_type +
                                  "_properties_cfg" +
                                  std::to_string(_mpi_comm_size) + ".bin";
    std::ifstream is(fname_cfg.c_str(), std::ios::binary | std::ios::in);
    if (!is)
    {
        WARN(
            "Could not open file '{:s}'.\n"
            "\tYou can ignore this warning if the mesh does not contain {:s}-"
            "wise property data.",
            fname_cfg, item_type.data());
        return;
    }
    std::size_t number_of_properties = 0;
    is.read(reinterpret_cast<char*>(&number_of_properties),
            sizeof(std::size_t));
    std::vector<std::optional<MeshLib::IO::PropertyVectorMetaData>> vec_pvmd(
        number_of_properties);
    for (std::size_t i(0); i < number_of_properties; ++i)
    {
        vec_pvmd[i] = MeshLib::IO::readPropertyVectorMetaData(is);
        if (!vec_pvmd[i])
        {
            OGS_FATAL(
                "Error in NodePartitionedMeshReader::readProperties: "
                "Could not read the meta data for the PropertyVector {:d}",
                i);
        }
    }
    for (std::size_t i(0); i < number_of_properties; ++i)
    {
        MeshLib::IO::writePropertyVectorMetaData(*(vec_pvmd[i]));
    }
    auto pos = is.tellg();
    auto offset =
        static_cast<long>(pos) +
        static_cast<long>(_mpi_rank *
                          sizeof(MeshLib::IO::PropertyVectorPartitionMetaData));
    is.seekg(offset);
    std::optional<MeshLib::IO::PropertyVectorPartitionMetaData> pvpmd(
        MeshLib::IO::readPropertyVectorPartitionMetaData(is));
    bool pvpmd_read_ok = static_cast<bool>(pvpmd);
    bool all_pvpmd_read_ok;
    MPI_Allreduce(&pvpmd_read_ok, &all_pvpmd_read_ok, 1, MPI_C_BOOL, MPI_LOR,
                  _mpi_comm);
    if (!all_pvpmd_read_ok)
    {
        OGS_FATAL(
            "Error in NodePartitionedMeshReader::readProperties: "
            "Could not read the partition meta data for the mpi process {:d}",
            _mpi_rank);
    }
    DBUG("offset in the PropertyVector: {:d}", pvpmd->offset);
    DBUG("{:d} tuples in partition.", pvpmd->number_of_tuples);
    is.close();
 
    const std::string fname_val = file_name_base + "_partitioned_" + item_type +
                                  "_properties_val" +
                                  std::to_string(_mpi_comm_size) + ".bin";
    is.open(fname_val.c_str(), std::ios::binary | std::ios::in);
    if (!is)
    {
        ERR("Could not open file '{:s}'\n."
            "\tYou can ignore this warning if the mesh does not contain {:s}-"
            "wise property data.",
            fname_val, item_type.data());
    }
 
    readDomainSpecificPartOfPropertyVectors(vec_pvmd, *pvpmd, t, is, p);
}

References _mpi_comm, _mpi_comm_size, _mpi_rank, DBUG(), ERR(), OGS_FATAL, readDomainSpecificPartOfPropertyVectors(), MeshLib::IO::readPropertyVectorMetaData(), MeshLib::IO::readPropertyVectorPartitionMetaData(), MeshLib::toString(), WARN(), and MeshLib::IO::writePropertyVectorMetaData().

registerNodeDataMpiType()

void MeshLib::IO::NodePartitionedMeshReader::registerNodeDataMpiType ( )

private

Define MPI data type for NodeData struct.

Definition at line 62 of file NodePartitionedMeshReader.cpp.

{
    int const count = 2;
    int blocks[count] = {1, 3};
    MPI_Datatype types[count] = {MPI_UNSIGNED_LONG, MPI_DOUBLE};
    MPI_Aint displacements[count] = {0, sizeof(NodeData::index)};
 
    MPI_Type_create_struct(count, blocks, displacements, types,
                           &_mpi_node_type);
    MPI_Type_commit(&_mpi_node_type);
}

References _mpi_node_type, and MeshLib::IO::NodeData::index.

Referenced by NodePartitionedMeshReader().

setElements()

void MeshLib::IO::NodePartitionedMeshReader::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

private

Set mesh elements from a temporary array containing node data read from file.

Parameters

mesh_nodes	Vector of mesh nodes used to set element nodes.
elem_data	Vector containing element data read from file.
mesh_elems	Vector of mesh elements to be set.
ghost	Flag of processing ghost elements.

Definition at line 469 of file NodePartitionedMeshReader.cpp.

{
    // Number of elements, either ghost or regular
    unsigned long const ne = ghost ? _mesh_info.number_of_ghost_elements
                                   : _mesh_info.number_of_regular_elements;
    unsigned long const id_offset_ghost =
        ghost ? _mesh_info.number_of_regular_elements : 0;
 
    for (unsigned long i = 0; i < ne; i++)
    {
        unsigned long id_offset_elem = elem_data[i];
 
        // Unused for now, keep for elem_data documentation purpose here.
        {
            const unsigned mat_idx =
                static_cast<unsigned>(elem_data[id_offset_elem++]);
            (void)mat_idx;
        }
        const unsigned long e_type = elem_data[id_offset_elem++];
        unsigned long const nnodes = elem_data[id_offset_elem++];
 
        MeshLib::Node** elem_nodes = new MeshLib::Node*[nnodes];
        for (unsigned long k = 0; k < nnodes; k++)
            elem_nodes[k] = mesh_nodes[elem_data[id_offset_elem++]];
 
        // The element types below are defined by the MeshLib::CellType.
        switch (static_cast<CellType>(e_type))
        {
            case CellType::POINT1:
                mesh_elems[i + id_offset_ghost] =
                    new MeshLib::Point(elem_nodes);
                break;
            case CellType::LINE2:
                mesh_elems[i + id_offset_ghost] = new MeshLib::Line(elem_nodes);
                break;
            case CellType::LINE3:
                mesh_elems[i + id_offset_ghost] =
                    new MeshLib::Line3(elem_nodes);
                break;
            case CellType::QUAD4:
                mesh_elems[i + id_offset_ghost] = new MeshLib::Quad(elem_nodes);
                break;
            case CellType::QUAD8:
                mesh_elems[i + id_offset_ghost] =
                    new MeshLib::Quad8(elem_nodes);
                break;
            case CellType::QUAD9:
                mesh_elems[i + id_offset_ghost] =
                    new MeshLib::Quad9(elem_nodes);
                break;
            case CellType::HEX8:
                mesh_elems[i + id_offset_ghost] = new MeshLib::Hex(elem_nodes);
                break;
            case CellType::HEX20:
                mesh_elems[i + id_offset_ghost] =
                    new MeshLib::Hex20(elem_nodes);
                break;
            case CellType::HEX27:
                OGS_FATAL(
                    "NodePartitionedMeshReader: construction of HEX27 element "
                    "with id {:d} is not implemented.",
                    i);
                break;
            case CellType::TRI3:
                mesh_elems[i + id_offset_ghost] = new MeshLib::Tri(elem_nodes);
                break;
            case CellType::TRI6:
                mesh_elems[i + id_offset_ghost] = new MeshLib::Tri6(elem_nodes);
                break;
            case CellType::TET4:
                mesh_elems[i + id_offset_ghost] = new MeshLib::Tet(elem_nodes);
                break;
            case CellType::TET10:
                mesh_elems[i + id_offset_ghost] =
                    new MeshLib::Tet10(elem_nodes);
                break;
            case CellType::PRISM6:
                mesh_elems[i + id_offset_ghost] =
                    new MeshLib::Prism(elem_nodes);
                break;
            case CellType::PRISM15:
                mesh_elems[i + id_offset_ghost] =
                    new MeshLib::Prism15(elem_nodes);
                break;
            case CellType::PYRAMID5:
                mesh_elems[i + id_offset_ghost] =
                    new MeshLib::Pyramid(elem_nodes);
                break;
            case CellType::PYRAMID13:
                mesh_elems[i + id_offset_ghost] =
                    new MeshLib::Pyramid13(elem_nodes);
                break;
            case CellType::INVALID:
                OGS_FATAL(
                    "NodePartitionedMeshReader: construction of INVALID "
                    "element type with id {:d} is not possible.",
                    i);
                break;
            default:
                OGS_FATAL(
                    "NodePartitionedMeshReader: construction of element type "
                    "{:d} is not implemented.",
                    e_type);
        }
    }
}

References _mesh_info, MeshLib::HEX20, MeshLib::HEX27, MeshLib::HEX8, MeshLib::INVALID, MeshLib::LINE2, MeshLib::LINE3, MeshLib::IO::NodePartitionedMeshReader::PartitionedMeshInfo::number_of_ghost_elements, MeshLib::IO::NodePartitionedMeshReader::PartitionedMeshInfo::number_of_regular_elements, OGS_FATAL, MeshLib::POINT1, MeshLib::PRISM15, MeshLib::PRISM6, MeshLib::PYRAMID13, MeshLib::PYRAMID5, MeshLib::QUAD4, MeshLib::QUAD8, MeshLib::QUAD9, MeshLib::TET10, MeshLib::TET4, MeshLib::TRI3, and MeshLib::TRI6.

Referenced by readMesh().

setNodes()

void MeshLib::IO::NodePartitionedMeshReader::setNodes ( const std::vector< NodeData > & node_data, std::vector< MeshLib::Node * > & mesh_node, std::vector< unsigned long > & glb_node_ids ) const

private

Set mesh nodes from a temporary array containing node data read from file.

Parameters

node_data	Vector containing node data read from file.
mesh_node	Vector of mesh nodes to be set.
glb_node_ids	Global IDs of nodes of a partition.

Definition at line 453 of file NodePartitionedMeshReader.cpp.

{
    mesh_node.resize(_mesh_info.number_of_nodes);
    glb_node_ids.resize(_mesh_info.number_of_nodes);
 
    for (std::size_t i = 0; i < mesh_node.size(); i++)
    {
        NodeData const& nd = node_data[i];
        glb_node_ids[i] = nd.index;
        mesh_node[i] = new MeshLib::Node(nd.x, nd.y, nd.z, i);
    }
}

References _mesh_info, MeshLib::IO::NodeData::index, MeshLib::Node, MeshLib::IO::NodePartitionedMeshReader::PartitionedMeshInfo::number_of_nodes, MeshLib::IO::NodeData::x, MeshLib::IO::NodeData::y, and MeshLib::IO::NodeData::z.

Referenced by readMesh().

Member Data Documentation

_mesh_info

struct MeshLib::IO::NodePartitionedMeshReader::PartitionedMeshInfo MeshLib::IO::NodePartitionedMeshReader::_mesh_info

private

Referenced by newMesh(), readMesh(), setElements(), and setNodes().

_mpi_comm

MPI_Comm MeshLib::IO::NodePartitionedMeshReader::_mpi_comm

private

Pointer to MPI communicator.

Definition at line 57 of file NodePartitionedMeshReader.h.

Referenced by NodePartitionedMeshReader(), newMesh(), read(), readDataFromFile(), and readProperties().

_mpi_comm_size

int MeshLib::IO::NodePartitionedMeshReader::_mpi_comm_size

private

Number of processes in the communicator: _mpi_comm.

Definition at line 60 of file NodePartitionedMeshReader.h.

Referenced by NodePartitionedMeshReader(), createSpecificPropertyVectorPart(), newMesh(), read(), readMesh(), and readProperties().

_mpi_node_type

MPI_Datatype MeshLib::IO::NodePartitionedMeshReader::_mpi_node_type

private

MPI data type for struct NodeData.

Definition at line 66 of file NodePartitionedMeshReader.h.

Referenced by ~NodePartitionedMeshReader(), readMesh(), and registerNodeDataMpiType().

_mpi_rank

int MeshLib::IO::NodePartitionedMeshReader::_mpi_rank

private

Rank of compute core.

Definition at line 63 of file NodePartitionedMeshReader.h.

Referenced by NodePartitionedMeshReader(), createPropertyVectorPart(), createSpecificPropertyVectorPart(), readMesh(), and readProperties().

---

The documentation for this class was generated from the following files:

• MeshLib/IO/MPI_IO/NodePartitionedMeshReader.h
• MeshLib/IO/MPI_IO/NodePartitionedMeshReader.cpp