Detailed Description

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

Definition at line 28 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
BaseLib::MPI::Mpi	mpi_
	Pointer to MPI communicator, the rank and the size.
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 37 of file NodePartitionedMeshReader.cpp.

                                                                  : mpi_(comm)
{
    registerNodeDataMpiType();
}

References mpi_, and registerNodeDataMpiType().

◆ ~NodePartitionedMeshReader()

MeshLib::IO::NodePartitionedMeshReader::~NodePartitionedMeshReader ( )

Definition at line 42 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 173 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 MeshLib::Properties::createNewPropertyVector(), MeshLib::PropertyVector< PROP_VAL_TYPE >::data(), mpi_, MeshLib::IO::PropertyVectorMetaData::number_of_components, MeshLib::IO::PropertyVectorPartitionMetaData::number_of_tuples, MeshLib::IO::PropertyVectorPartitionMetaData::offset, OGS_FATAL, MeshLib::IO::PropertyVectorMetaData::property_name, MeshLib::PropertyVector< PROP_VAL_TYPE >::resize(), 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 199 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_.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 MeshLib::Properties::createNewPropertyVector(), MeshLib::PropertyVector< PROP_VAL_TYPE >::data(), mpi_, MeshLib::IO::PropertyVectorMetaData::number_of_components, MeshLib::IO::PropertyVectorMetaData::number_of_tuples, OGS_FATAL, MeshLib::IO::PropertyVectorMetaData::property_name, MeshLib::PropertyVector< PROP_VAL_TYPE >::resize(), 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 387 of file NodePartitionedMeshReader.cpp.

{
    std::vector<std::size_t> const gathered_n_regular_base_nodes =
        BaseLib::MPI::allgather(_mesh_info.number_of_regular_base_nodes, mpi_);
 
    std::vector<std::size_t> n_regular_base_nodes_at_rank =
        BaseLib::sizesToOffsets(gathered_n_regular_base_nodes);
 
    std::size_t const n_regular_high_order_nodes =
        _mesh_info.number_of_regular_nodes -
        _mesh_info.number_of_regular_base_nodes;
    std::vector<std::size_t> const gathered_n_regular_high_order_nodes =
        BaseLib::MPI::allgather(n_regular_high_order_nodes, mpi_);
 
    std::vector<std::size_t> n_regular_high_order_nodes_at_rank =
        BaseLib::sizesToOffsets(gathered_n_regular_high_order_nodes);
 
    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, BaseLib::MPI::allgather(), mpi_, and BaseLib::sizesToOffsets().

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 59 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_.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_.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_.communicator);
 
    return mesh;
}

References BaseLib::RunTime::elapsed(), ERR(), INFO(), BaseLib::IsFileExisting(), mpi_, 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 96 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_.communicator, 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 ERR(), is_safely_convertable(), and mpi_.

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 284 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 134 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_.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_node_type, BaseLib::extractBaseName(), mpi_, newMesh(), 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 199 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 209 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_.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 const all_pvpmd_read_ok =
        BaseLib::MPI::allreduce(static_cast<bool>(pvpmd), MPI_LOR, mpi_);
    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_.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 BaseLib::MPI::allreduce(), DBUG(), ERR(), mpi_, 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 47 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 433 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, 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 417 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);
    }
}