ApplicationUtils Namespace Reference

Classes
struct	ConfigOffsets
class	NodeWiseMeshPartitioner
	Mesh partitioner. More...
struct	Partition
	A subdomain mesh. More...
struct	PartitionOffsets

Functions
template<typename ElementType >
int	getNumberOfElementIntegrationPointsGeneral (MeshLib::IntegrationPointMetaData const &ip_meta_data)
int	getNumberOfElementIntegrationPoints (MeshLib::IntegrationPointMetaData const &ip_meta_data, MeshLib::Element const &e)
std::vector< std::size_t >	getIntegrationPointDataOffsetsOfMeshElements (std::vector< MeshLib::Element * > const &mesh_elements, MeshLib::PropertyVectorBase const &pv, MeshLib::Properties const &properties)
void	writeMETIS (std::vector< MeshLib::Element * > const &elements, const std::string &file_name)
std::vector< std::size_t >	readMetisData (const std::string &file_name_base, long const number_of_partitions, std::size_t const number_of_nodes)
void	removeMetisPartitioningFiles (std::string const &file_name_base, long const number_of_partitions)
NodeWiseMeshPartitioner::IntegerType	getNumberOfIntegerVariablesOfElements (std::vector< const MeshLib::Element * > const &elements)
std::size_t	nodeIdBulkMesh (MeshLib::Node const &node, std::vector< std::size_t > const *node_id_mapping=nullptr)
std::size_t	partitionLookup (MeshLib::Node const &node, std::vector< std::size_t > const &partition_ids, std::vector< std::size_t > const *node_id_mapping=nullptr)
std::pair< std::vector< MeshLib::Node * >, std::vector< MeshLib::Node * > >	findRegularNodesInPartition (std::size_t const part_id, std::vector< MeshLib::Node * > const &nodes, std::vector< std::size_t > const &partition_ids, MeshLib::Mesh const &mesh, std::vector< std::size_t > const *node_id_mapping=nullptr)
std::ptrdiff_t	numberOfRegularNodes (MeshLib::Element const &e, std::size_t const part_id, std::vector< std::size_t > const &partition_ids, std::vector< std::size_t > const *node_id_mapping=nullptr)
std::tuple< std::vector< MeshLib::Element const * >, std::vector< MeshLib::Element const * > >	findElementsInPartition (std::size_t const part_id, std::vector< MeshLib::Element * > const &elements, std::vector< std::size_t > const &partition_ids, std::vector< std::size_t > const *node_id_mapping=nullptr)
std::tuple< std::vector< MeshLib::Node * >, std::vector< MeshLib::Node * > >	findGhostNodesInPartition (std::size_t const part_id, std::vector< MeshLib::Node * > const &nodes, std::vector< MeshLib::Element const * > const &ghost_elements, std::vector< std::size_t > const &partition_ids, MeshLib::Mesh const &mesh, std::vector< std::size_t > const *node_id_mapping=nullptr)
template<typename T >
std::size_t	copyNodePropertyVectorValues (Partition const &p, std::size_t const offset, MeshLib::PropertyVector< T > const &pv, MeshLib::PropertyVector< T > &partitioned_pv)
template<typename T >
std::size_t	copyCellPropertyVectorValues (Partition const &p, std::size_t const offset, MeshLib::PropertyVector< T > const &pv, MeshLib::PropertyVector< T > &partitioned_pv)
template<typename T >
std::size_t	copyFieldPropertyDataToPartitions (MeshLib::Properties const &properties, Partition const &p, std::size_t const id_offset_partition, std::vector< std::size_t > const &element_ip_data_offsets, MeshLib::PropertyVector< T > const &pv, MeshLib::PropertyVector< T > &partitioned_pv)
void	setIntegrationPointNumberOfPartition (MeshLib::Properties const &properties, std::vector< Partition > &partitions)
template<typename T >
bool	copyPropertyVector (std::vector< MeshLib::Element * > const &global_mesh_elements, MeshLib::Properties &partitioned_properties, MeshLib::Properties const &properties, std::vector< Partition > const &partitions, MeshLib::PropertyVector< T > const *const pv, std::map< MeshLib::MeshItemType, std::size_t > const &total_number_of_tuples)
void	addVtkGhostTypeProperty (MeshLib::Properties &partitioned_properties, std::vector< Partition > const &partitions, std::size_t const total_number_of_cells)
MeshLib::Properties	partitionProperties (std::unique_ptr< MeshLib::Mesh > const &mesh, std::vector< Partition > &partitions)
	Partition existing properties and add vtkGhostType cell data array property.
void	markDuplicateGhostCells (MeshLib::Mesh const &mesh, std::vector< Partition > &partitions)
void	checkFieldPropertyVectorSize (std::vector< MeshLib::Element * > const &global_mesh_elements, MeshLib::Properties const &properties)
template<typename T >
void	writePropertyVectorValues (std::ostream &os, MeshLib::PropertyVector< T > const &pv)
template<typename T >
bool	writePropertyVector (MeshLib::PropertyVector< T > const *const pv, MeshLib::MeshItemType const mesh_item_type, std::ostream &out_val, std::ostream &out_meta)
void	writeProperties (const std::string &file_name_base, MeshLib::Properties const &partitioned_properties, std::vector< Partition > const &partitions, MeshLib::MeshItemType const mesh_item_type)
PartitionOffsets	computePartitionOffsets (Partition const &partition)
ConfigOffsets	incrementConfigOffsets (ConfigOffsets const &oldConfig, PartitionOffsets const &offsets)
std::tuple< std::vector< long >, std::vector< long > >	writeConfigData (const std::string &file_name_base, std::vector< Partition > const &partitions)
void	getElementIntegerVariables (const MeshLib::Element &elem, const std::unordered_map< std::size_t, long > &local_node_ids, std::vector< long > &elem_info, long &counter)
std::unordered_map< std::size_t, long >	enumerateLocalNodeIds (std::vector< MeshLib::Node * > const &nodes)
	Generates a mapping of given node ids to a new local (renumbered) node ids.
void	writeElements (std::string const &file_name_base, std::vector< Partition > const &partitions, std::vector< long > const &regular_element_offsets, std::vector< long > const &ghost_element_offsets)
void	writeNodes (const std::string &file_name_base, std::vector< Partition > const &partitions, std::vector< std::size_t > const &global_node_ids)

Function Documentation

addVtkGhostTypeProperty()

void ApplicationUtils::addVtkGhostTypeProperty	(	MeshLib::Properties &	partitioned_properties,
		std::vector< Partition > const &	partitions,
		std::size_t const	total_number_of_cells
	)

Definition at line 523 of file NodeWiseMeshPartitioner.cpp.

{
    auto* vtk_ghost_type =
        partitioned_properties.createNewPropertyVector<unsigned char>(
            "vtkGhostType", MeshLib::MeshItemType::Cell);
    if (vtk_ghost_type == nullptr)
    {
        OGS_FATAL("Could not create vtkGhostType cell data array.");
    }
 
    vtk_ghost_type->resize(total_number_of_cells);
    std::size_t offset = 0;
    for (auto const& partition : partitions)
    {
        offset += partition.regular_elements.size();
        for (std::size_t i = 0; i < partition.ghost_elements.size(); ++i)
        {
            if (partition.duplicate_ghost_cell[i])
            {
                (*vtk_ghost_type)[offset + i] |=
                    vtkDataSetAttributes::DUPLICATECELL;
            }
        }
        offset += partition.ghost_elements.size();
    }
}

References MeshLib::Cell, MeshLib::Properties::createNewPropertyVector(), and OGS_FATAL.

Referenced by partitionProperties().

checkFieldPropertyVectorSize()

void ApplicationUtils::checkFieldPropertyVectorSize	(	std::vector< MeshLib::Element * > const &	global_mesh_elements,
		MeshLib::Properties const &	properties
	)

Definition at line 629 of file NodeWiseMeshPartitioner.cpp.

{
    for (auto const& [name, property] : properties)
    {
        auto const item_type = property->getMeshItemType();
 
        if (item_type != MeshLib::MeshItemType::IntegrationPoint)
        {
            continue;
        }
 
        // For special field data such as OGS_VERSION, IntegrationPointMetaData,
        // etc., which are not "real" integration points:
        if (property->getPropertyName().find("_ip") == std::string::npos)
        {
            continue;
        }
 
        std::size_t number_of_total_integration_points = 0;
        auto const ip_meta_data = MeshLib::getIntegrationPointMetaData(
            properties, property->getPropertyName());
        for (auto const element : global_mesh_elements)
        {
            int const number_of_integration_points =
                getNumberOfElementIntegrationPoints(ip_meta_data, *element);
            number_of_total_integration_points += number_of_integration_points;
        }
 
        const auto pv =
            dynamic_cast<MeshLib::PropertyVector<double> const*>(property);
        std::size_t const component_number = pv->getNumberOfGlobalComponents();
        if (pv->size() != number_of_total_integration_points * component_number)
        {
            OGS_FATAL(
                "The property vector's size {:d} for integration point data "
                "{:s} does not match its actual size {:d}. The field data in "
                "the vtu file are wrong.",
                pv->size(), name,
                number_of_total_integration_points * component_number);
        }
    }
}

References MeshLib::getIntegrationPointMetaData(), getNumberOfElementIntegrationPoints(), MeshLib::PropertyVectorBase::getNumberOfGlobalComponents(), MeshLib::IntegrationPoint, and OGS_FATAL.

Referenced by ApplicationUtils::NodeWiseMeshPartitioner::partitionByMETIS().

computePartitionOffsets()

PartitionOffsets ApplicationUtils::computePartitionOffsets

(

Partition const &

partition

)

Definition at line 1008 of file NodeWiseMeshPartitioner.cpp.

{
    return {static_cast<long>(partition.nodes.size()),
            static_cast<long>(partition.regular_elements.size() +
                              getNumberOfIntegerVariablesOfElements(
                                  partition.regular_elements)),
            static_cast<long>(partition.ghost_elements.size() +
                              getNumberOfIntegerVariablesOfElements(
                                  partition.ghost_elements))};
}

References getNumberOfIntegerVariablesOfElements(), ApplicationUtils::Partition::ghost_elements, ApplicationUtils::Partition::nodes, and ApplicationUtils::Partition::regular_elements.

Referenced by writeConfigData().

copyCellPropertyVectorValues()

template<typename T >

std::size_t ApplicationUtils::copyCellPropertyVectorValues	(	Partition const &	p,
		std::size_t const	offset,
		MeshLib::PropertyVector< T > const &	pv,
		MeshLib::PropertyVector< T > &	partitioned_pv
	)

Copies the properties from global property vector pv to the partition-local one partitioned_pv. Regular elements' and ghost elements' values are copied.

Definition at line 326 of file NodeWiseMeshPartitioner.cpp.

{
    std::size_t const n_regular(p.regular_elements.size());
    auto const n_components = pv.getNumberOfGlobalComponents();
    for (std::size_t i = 0; i < n_regular; ++i)
    {
        const auto id = p.regular_elements[i]->getID();
        std::copy_n(&pv[n_components * id], n_components,
                    &partitioned_pv[offset + n_components * i]);
    }
 
    std::size_t const n_ghost(p.ghost_elements.size());
    for (std::size_t i = 0; i < n_ghost; ++i)
    {
        const auto id = p.ghost_elements[i]->getID();
        std::copy_n(&pv[n_components * id], n_components,
                    &partitioned_pv[offset + n_components * (n_regular + i)]);
    }
    return n_components * (n_regular + n_ghost);
}

References MeshLib::PropertyVectorBase::getNumberOfGlobalComponents().

Referenced by copyPropertyVector().

copyFieldPropertyDataToPartitions()

template<typename T >

std::size_t ApplicationUtils::copyFieldPropertyDataToPartitions	(	MeshLib::Properties const &	properties,
		Partition const &	p,
		std::size_t const	id_offset_partition,
		std::vector< std::size_t > const &	element_ip_data_offsets,
		MeshLib::PropertyVector< T > const &	pv,
		MeshLib::PropertyVector< T > &	partitioned_pv
	)

Copies the data from the property vector pv belonging to the given Partition p to the property vector partitioned_pv. partitioned_pv is ordered by partition. Regular elements' and ghost elements' values are copied.

Definition at line 356 of file NodeWiseMeshPartitioner.cpp.

{
    // 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 (pv.getPropertyName().find("_ip") == std::string::npos)
    {
        std::copy_n(&pv[0], pv.size(), &partitioned_pv[id_offset_partition]);
        return pv.size();
    }
 
    auto const n_components = pv.getNumberOfGlobalComponents();
 
    std::size_t id_offset = 0;
 
    auto copyFieldData =
        [&](std::vector<const MeshLib::Element*> const& elements)
    {
        auto const ip_meta_data = MeshLib::getIntegrationPointMetaData(
            properties, pv.getPropertyName());
 
        for (auto const element : elements)
        {
            int const number_of_element_field_data =
                getNumberOfElementIntegrationPoints(ip_meta_data, *element) *
                n_components;
            // The original element ID is not changed.
            auto const element_id = element->getID();
            int const begin_pos = element_ip_data_offsets[element_id];
            int const end_pos = element_ip_data_offsets[element_id + 1];
 
            std::copy(pv.begin() + begin_pos, pv.begin() + end_pos,
                      &partitioned_pv[id_offset + id_offset_partition]);
            id_offset += number_of_element_field_data;
        }
    };
 
    copyFieldData(p.regular_elements);
    copyFieldData(p.ghost_elements);
 
    return id_offset;
}

References MeshLib::getIntegrationPointMetaData(), getNumberOfElementIntegrationPoints(), MeshLib::PropertyVectorBase::getNumberOfGlobalComponents(), MeshLib::PropertyVectorBase::getPropertyName(), and MeshLib::PropertyVector< PROP_VAL_TYPE >::size().

Referenced by copyPropertyVector().

copyNodePropertyVectorValues()

template<typename T >

std::size_t ApplicationUtils::copyNodePropertyVectorValues	(	Partition const &	p,
		std::size_t const	offset,
		MeshLib::PropertyVector< T > const &	pv,
		MeshLib::PropertyVector< T > &	partitioned_pv
	)

Copies the properties from global property vector pv to the partition-local one partitioned_pv.

Definition at line 304 of file NodeWiseMeshPartitioner.cpp.

{
    auto const& nodes = p.nodes;
    auto const nnodes = nodes.size();
    auto const n_components = pv.getNumberOfGlobalComponents();
    for (std::size_t i = 0; i < nnodes; ++i)
    {
        const auto global_id = nodes[i]->getID();
        std::copy_n(&pv[n_components * global_id], n_components,
                    &partitioned_pv[offset + n_components * i]);
    }
    return n_components * nnodes;
}

References MeshLib::PropertyVectorBase::getNumberOfGlobalComponents().

Referenced by copyPropertyVector().

copyPropertyVector()

template<typename T >

bool ApplicationUtils::copyPropertyVector	(	std::vector< MeshLib::Element * > const &	global_mesh_elements,
		MeshLib::Properties &	partitioned_properties,
		MeshLib::Properties const &	properties,
		std::vector< Partition > const &	partitions,
		MeshLib::PropertyVector< T > const *const	pv,
		std::map< MeshLib::MeshItemType, std::size_t > const &	total_number_of_tuples
	)

Definition at line 451 of file NodeWiseMeshPartitioner.cpp.

{
    if (pv == nullptr)
    {
        return false;
    }
    auto const item_type = pv->getMeshItemType();
 
    std::size_t partitioned_pv_size = total_number_of_tuples.at(item_type) *
                                      pv->getNumberOfGlobalComponents();
 
    std::vector<std::size_t> element_ip_data_offsets;
    if (item_type == MeshLib::MeshItemType::IntegrationPoint)
    {
        // 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 (pv->getPropertyName().find("_ip") == std::string::npos)
        {
            partitioned_pv_size = pv->size() * partitions.size();
        }
 
        element_ip_data_offsets = getIntegrationPointDataOffsetsOfMeshElements(
            global_mesh_elements, *pv, properties);
    }
 
    auto partitioned_pv = partitioned_properties.createNewPropertyVector<T>(
        pv->getPropertyName(), pv->getMeshItemType(),
        pv->getNumberOfGlobalComponents());
    partitioned_pv->resize(partitioned_pv_size);
 
    auto copy_property_vector_values =
        [&](Partition const& p, std::size_t offset)
    {
        if (item_type == MeshLib::MeshItemType::IntegrationPoint)
        {
            return copyFieldPropertyDataToPartitions(properties, p, offset,
                                                     element_ip_data_offsets,
                                                     *pv, *partitioned_pv);
        }
 
        if (item_type == MeshLib::MeshItemType::Node)
        {
            return copyNodePropertyVectorValues(p, offset, *pv,
                                                *partitioned_pv);
        }
        if (item_type == MeshLib::MeshItemType::Cell)
        {
            return copyCellPropertyVectorValues(p, offset, *pv,
                                                *partitioned_pv);
        }
 
        OGS_FATAL(
            "Copying of property vector values for mesh item type {:s} is not "
            "implemented.",
            toString(item_type));
    };
 
    std::size_t position_offset(0);
    for (auto p : partitions)
    {
        position_offset += copy_property_vector_values(p, position_offset);
    }
    return true;
}

References MeshLib::Cell, copyCellPropertyVectorValues(), copyFieldPropertyDataToPartitions(), copyNodePropertyVectorValues(), MeshLib::Properties::createNewPropertyVector(), getIntegrationPointDataOffsetsOfMeshElements(), MeshLib::PropertyVectorBase::getMeshItemType(), MeshLib::PropertyVectorBase::getNumberOfGlobalComponents(), MeshLib::PropertyVectorBase::getPropertyName(), MeshLib::IntegrationPoint, MeshLib::Node, OGS_FATAL, and MeshLib::PropertyVector< PROP_VAL_TYPE >::size().

enumerateLocalNodeIds()

std::unordered_map< std::size_t, long > ApplicationUtils::enumerateLocalNodeIds

(

std::vector< MeshLib::Node * > const &

nodes

)

Generates a mapping of given node ids to a new local (renumbered) node ids.

Definition at line 1105 of file NodeWiseMeshPartitioner.cpp.

{
    std::unordered_map<std::size_t, long> local_ids;
    local_ids.reserve(nodes.size());
 
    long local_node_id = 0;
    for (const auto* node : nodes)
    {
        local_ids[node->getID()] = local_node_id++;
    }
    return local_ids;
}

Referenced by writeElements().

findElementsInPartition()

std::tuple< std::vector< MeshLib::Element const * >, std::vector< MeshLib::Element const * > > ApplicationUtils::findElementsInPartition	(	std::size_t const	part_id,
		std::vector< MeshLib::Element * > const &	elements,
		std::vector< std::size_t > const &	partition_ids,
		std::vector< std::size_t > const *	node_id_mapping = nullptr
	)

1 find elements belonging to the partition part_id: fills vector partition.regular_elements 2 find ghost elements belonging to the partition part_id fills vector partition.ghost_elements

Definition at line 182 of file NodeWiseMeshPartitioner.cpp.

{
    std::vector<MeshLib::Element const*> regular_elements;
    std::vector<MeshLib::Element const*> ghost_elements;
 
    for (auto elem : elements)
    {
        auto const regular_nodes = numberOfRegularNodes(
            *elem, part_id, partition_ids, node_id_mapping);
 
        if (regular_nodes == 0)
        {
            continue;
        }
 
        if (regular_nodes ==
            static_cast<std::ptrdiff_t>(elem->getNumberOfNodes()))
        {
            regular_elements.push_back(elem);
        }
        else
        {
            ghost_elements.push_back(elem);
        }
    }
    return std::tuple<std::vector<MeshLib::Element const*>,
                      std::vector<MeshLib::Element const*>>{regular_elements,
                                                            ghost_elements};
}

References numberOfRegularNodes().

Referenced by ApplicationUtils::NodeWiseMeshPartitioner::partitionOtherMesh(), and ApplicationUtils::NodeWiseMeshPartitioner::processPartition().

findGhostNodesInPartition()

std::tuple< std::vector< MeshLib::Node * >, std::vector< MeshLib::Node * > > ApplicationUtils::findGhostNodesInPartition	(	std::size_t const	part_id,
		std::vector< MeshLib::Node * > const &	nodes,
		std::vector< MeshLib::Element const * > const &	ghost_elements,
		std::vector< std::size_t > const &	partition_ids,
		MeshLib::Mesh const &	mesh,
		std::vector< std::size_t > const *	node_id_mapping = nullptr
	)

Prerequisite: the ghost elements has to be found (using findElementsInPartition). Finds ghost nodes and non-linear element ghost nodes by walking over ghost elements.

Definition at line 221 of file NodeWiseMeshPartitioner.cpp.

{
    std::vector<MeshLib::Node*> base_nodes;
    std::vector<MeshLib::Node*> ghost_nodes;
 
    std::vector<bool> is_ghost_node(nodes.size(), false);
    for (const auto* ghost_elem : ghost_elements)
    {
        for (unsigned i = 0; i < ghost_elem->getNumberOfNodes(); i++)
        {
            auto const& n = ghost_elem->getNode(i);
            if (is_ghost_node[n->getID()])
            {
                continue;
            }
 
            if (partitionLookup(*n, partition_ids, node_id_mapping) != part_id)
            {
                if (isBaseNode(*n, mesh.getElementsConnectedToNode(*n)))
                {
                    base_nodes.push_back(nodes[n->getID()]);
                }
                else
                {
                    ghost_nodes.push_back(nodes[n->getID()]);
                }
                is_ghost_node[n->getID()] = true;
            }
        }
    }
    return std::tuple<std::vector<MeshLib::Node*>, std::vector<MeshLib::Node*>>{
        base_nodes, ghost_nodes};
}

References MeshLib::Mesh::getElementsConnectedToNode(), and partitionLookup().

Referenced by ApplicationUtils::NodeWiseMeshPartitioner::partitionOtherMesh(), and ApplicationUtils::NodeWiseMeshPartitioner::processPartition().

findRegularNodesInPartition()

std::pair< std::vector< MeshLib::Node * >, std::vector< MeshLib::Node * > > ApplicationUtils::findRegularNodesInPartition	(	std::size_t const	part_id,
		std::vector< MeshLib::Node * > const &	nodes,
		std::vector< std::size_t > const &	partition_ids,
		MeshLib::Mesh const &	mesh,
		std::vector< std::size_t > const *	node_id_mapping = nullptr
	)

1 copy pointers to nodes belonging to the partition part_id into base nodes vector, and 2 collect non-linear element nodes belonging to the partition part_id in extra nodes vector. If node_id_mapping is given, it will be used to map the mesh node ids to other ids; used by boundary meshes, for example.

Returns

a pair of base node and extra nodes.

Definition at line 128 of file NodeWiseMeshPartitioner.cpp.

{
    // Find nodes belonging to a given partition id.
    std::vector<MeshLib::Node*> partition_nodes;
    copy_if(begin(nodes), end(nodes), std::back_inserter(partition_nodes),
            [&](auto const& n) {
                return partitionLookup(*n, partition_ids, node_id_mapping) ==
                       part_id;
            });
 
    // Space for resulting vectors.
    std::vector<MeshLib::Node*> base_nodes;
    base_nodes.reserve(partition_nodes.size() /
                       2);  // if linear mesh, then one reallocation, no realloc
                            // for higher order elements meshes.
    std::vector<MeshLib::Node*> higher_order_nodes;
    higher_order_nodes.reserve(
        partition_nodes.size() /
        2);  // if linear mesh, then wasted space, good estimate for quadratic
             // order mesh, and realloc needed for higher order element meshes.
 
    // Split the nodes into base nodes and extra nodes.
    std::partition_copy(
        begin(partition_nodes), end(partition_nodes),
        std::back_inserter(base_nodes), std::back_inserter(higher_order_nodes),
        [&](MeshLib::Node* const n)
        { return isBaseNode(*n, mesh.getElementsConnectedToNode(*n)); });
 
    return {base_nodes, higher_order_nodes};
}

References MeshLib::Mesh::getElementsConnectedToNode(), and partitionLookup().

Referenced by ApplicationUtils::NodeWiseMeshPartitioner::partitionOtherMesh(), and ApplicationUtils::NodeWiseMeshPartitioner::processPartition().

getElementIntegerVariables()

void ApplicationUtils::getElementIntegerVariables	(	const MeshLib::Element &	elem,
		const std::unordered_map< std::size_t, long > &	local_node_ids,
		std::vector< long > &	elem_info,
		long &	counter
	)

Get integer variables, which are used to define an element

Parameters

elem	Element
local_node_ids	Local node indices of a partition
elem_info	A vector holds all integer variables of element definitions
counter	Recorder of the number of integer variables.

Definition at line 1084 of file NodeWiseMeshPartitioner.cpp.

{
    constexpr unsigned mat_id =
        0;  // TODO: Material ID to be set from the mesh data
    const long nn = elem.getNumberOfNodes();
    elem_info[counter++] = mat_id;
    elem_info[counter++] = static_cast<long>(elem.getCellType());
    elem_info[counter++] = nn;
 
    for (long i = 0; i < nn; i++)
    {
        auto const& n = *elem.getNode(i);
        elem_info[counter++] = local_node_ids.at(n.getID());
    }
}

References MeshLib::Element::getCellType(), MeshLib::Element::getNode(), and MeshLib::Element::getNumberOfNodes().

Referenced by writeElements().

getIntegrationPointDataOffsetsOfMeshElements()

std::vector< std::size_t > ApplicationUtils::getIntegrationPointDataOffsetsOfMeshElements	(	std::vector< MeshLib::Element * > const &	mesh_elements,
		MeshLib::PropertyVectorBase const &	pv,
		MeshLib::Properties const &	properties
	)

Definition at line 98 of file IntegrationPointDataTools.cpp.

{
    // For special field data such as OGS_VERSION, IntegrationPointMetaData,
    // etc., which are not "real" integration points:
    if (pv.getPropertyName().find("_ip") == std::string::npos)
    {
        return {};
    }
 
    auto const n_components = pv.getNumberOfGlobalComponents();
 
    std::vector<std::size_t> element_ip_data_offsets(mesh_elements.size() + 1);
    std::size_t counter = 0;
    auto const ip_meta_data =
        MeshLib::getIntegrationPointMetaData(properties, pv.getPropertyName());
    for (std::size_t i = 0; i < mesh_elements.size(); i++)
    {
        auto const element = mesh_elements[i];
 
        // Assuming that the order of elements in mesh_elements is not touched.
        element_ip_data_offsets[i] = counter;
        counter += getNumberOfElementIntegrationPoints(ip_meta_data, *element) *
                   n_components;
    }
    element_ip_data_offsets[mesh_elements.size()] = counter;
 
    return element_ip_data_offsets;
}

References MeshLib::getIntegrationPointMetaData(), getNumberOfElementIntegrationPoints(), MeshLib::PropertyVectorBase::getNumberOfGlobalComponents(), and MeshLib::PropertyVectorBase::getPropertyName().

Referenced by copyPropertyVector(), and createPropertyVector().

getNumberOfElementIntegrationPoints()

int ApplicationUtils::getNumberOfElementIntegrationPoints	(	MeshLib::IntegrationPointMetaData const &	ip_meta_data,
		MeshLib::Element const &	e
	)

Definition at line 36 of file IntegrationPointDataTools.cpp.

{
    switch (e.getCellType())
    {
        case MeshLib::CellType::LINE2:
            return getNumberOfElementIntegrationPointsGeneral<MeshLib::Line>(
                ip_meta_data);
        case MeshLib::CellType::LINE3:
            return getNumberOfElementIntegrationPointsGeneral<MeshLib::Line3>(
                ip_meta_data);
        case MeshLib::CellType::TRI3:
            return getNumberOfElementIntegrationPointsGeneral<MeshLib::Tri>(
                ip_meta_data);
        case MeshLib::CellType::TRI6:
            return getNumberOfElementIntegrationPointsGeneral<MeshLib::Tri6>(
                ip_meta_data);
        case MeshLib::CellType::QUAD4:
            return getNumberOfElementIntegrationPointsGeneral<MeshLib::Quad>(
                ip_meta_data);
        case MeshLib::CellType::QUAD8:
            return getNumberOfElementIntegrationPointsGeneral<MeshLib::Quad8>(
                ip_meta_data);
        case MeshLib::CellType::QUAD9:
            return getNumberOfElementIntegrationPointsGeneral<MeshLib::Quad9>(
                ip_meta_data);
        case MeshLib::CellType::TET4:
            return getNumberOfElementIntegrationPointsGeneral<MeshLib::Tet>(
                ip_meta_data);
        case MeshLib::CellType::TET10:
            return getNumberOfElementIntegrationPointsGeneral<MeshLib::Tet10>(
                ip_meta_data);
        case MeshLib::CellType::HEX8:
            return getNumberOfElementIntegrationPointsGeneral<MeshLib::Hex>(
                ip_meta_data);
        case MeshLib::CellType::HEX20:
            return getNumberOfElementIntegrationPointsGeneral<MeshLib::Hex20>(
                ip_meta_data);
        case MeshLib::CellType::PRISM6:
            return getNumberOfElementIntegrationPointsGeneral<MeshLib::Prism>(
                ip_meta_data);
        case MeshLib::CellType::PRISM15:
            return getNumberOfElementIntegrationPointsGeneral<MeshLib::Prism15>(
                ip_meta_data);
        case MeshLib::CellType::PYRAMID5:
            return getNumberOfElementIntegrationPointsGeneral<MeshLib::Pyramid>(
                ip_meta_data);
        case MeshLib::CellType::PYRAMID13:
            return getNumberOfElementIntegrationPointsGeneral<
                MeshLib::Pyramid13>(ip_meta_data);
        case MeshLib::CellType::PRISM18:
        case MeshLib::CellType::HEX27:
            OGS_FATAL("Mesh element type {:s} is not supported",
                      MeshLib::CellType2String(e.getCellType()));
        case MeshLib::CellType::INVALID:
        default:
            OGS_FATAL("Invalid Element Type");
    }
    return 0;
}

References MeshLib::CellType2String(), MeshLib::Element::getCellType(), getNumberOfElementIntegrationPointsGeneral(), MeshLib::HEX20, MeshLib::HEX27, MeshLib::HEX8, MeshLib::INVALID, MeshLib::LINE2, MeshLib::LINE3, OGS_FATAL, MeshLib::PRISM15, MeshLib::PRISM18, MeshLib::PRISM6, MeshLib::PYRAMID13, MeshLib::PYRAMID5, MeshLib::QUAD4, MeshLib::QUAD8, MeshLib::QUAD9, MeshLib::TET10, MeshLib::TET4, MeshLib::TRI3, and MeshLib::TRI6.

Referenced by checkFieldPropertyVectorSize(), copyFieldPropertyDataToPartitions(), createPropertyVector(), getIntegrationPointDataOffsetsOfMeshElements(), and setIntegrationPointNumberOfPartition().

getNumberOfElementIntegrationPointsGeneral()

template<typename ElementType >

int ApplicationUtils::getNumberOfElementIntegrationPointsGeneral

(

MeshLib::IntegrationPointMetaData const &

ip_meta_data

)

Definition at line 24 of file IntegrationPointDataTools.cpp.

{
    using IntegrationPolicy =
        NumLib::GaussLegendreIntegrationPolicy<ElementType>;
    using NonGenericIntegrationMethod =
        typename IntegrationPolicy::IntegrationMethod;
    NonGenericIntegrationMethod int_met{
        (unsigned int)ip_meta_data.integration_order};
    return int_met.getNumberOfPoints();
}

References MeshLib::IntegrationPointMetaData::integration_order.

Referenced by getNumberOfElementIntegrationPoints().

getNumberOfIntegerVariablesOfElements()

NodeWiseMeshPartitioner::IntegerType ApplicationUtils::getNumberOfIntegerVariablesOfElements

(

std::vector< const MeshLib::Element * > const &

elements

)

Calculate the total number of integer variables of an element vector. Each element has three integer variables for element ID, element type, number of nodes of the element. Therefore the total number of the integers in elements is 3 * elements.size() + sum (number of nodes of each element).

Definition at line 73 of file NodeWiseMeshPartitioner.cpp.

{
    return 3 * elements.size() +
           std::accumulate(begin(elements), end(elements), 0,
                           [](auto const nnodes, auto const* e)
                           { return nnodes + e->getNumberOfNodes(); });
}

Referenced by computePartitionOffsets(), and ApplicationUtils::Partition::writeConfig().

incrementConfigOffsets()

ConfigOffsets ApplicationUtils::incrementConfigOffsets	(	ConfigOffsets const &	oldConfig,
		PartitionOffsets const &	offsets
	)

Definition at line 1019 of file NodeWiseMeshPartitioner.cpp.

{
    return {
        static_cast<long>(oldConfig.node_rank_offset +
                          offsets.node * sizeof(MeshLib::IO::NodeData)),
        // Offset the ending entry of the element integer variables of
        // the non-ghost elements of this partition in the vector of elem_info.
        static_cast<long>(oldConfig.element_rank_offset +
                          offsets.regular_elements * sizeof(long)),
 
        // Offset the ending entry of the element integer variables of
        // the ghost elements of this partition in the vector of elem_info.
        static_cast<long>(oldConfig.ghost_element_rank_offset +
                          offsets.ghost_elements * sizeof(long))};
}

References ApplicationUtils::ConfigOffsets::element_rank_offset, ApplicationUtils::ConfigOffsets::ghost_element_rank_offset, ApplicationUtils::PartitionOffsets::ghost_elements, ApplicationUtils::PartitionOffsets::node, ApplicationUtils::ConfigOffsets::node_rank_offset, and ApplicationUtils::PartitionOffsets::regular_elements.

Referenced by writeConfigData().

markDuplicateGhostCells()

void ApplicationUtils::markDuplicateGhostCells	(	MeshLib::Mesh const &	mesh,
		std::vector< Partition > &	partitions
	)

Definition at line 607 of file NodeWiseMeshPartitioner.cpp.

{
    std::vector<bool> cell_visited(mesh.getElements().size(), false);
 
    for (auto& partition : partitions)
    {
        partition.duplicate_ghost_cell.resize(partition.ghost_elements.size(),
                                              true);
 
        for (std::size_t i = 0; i < partition.ghost_elements.size(); i++)
        {
            const auto& ghost_element = *partition.ghost_elements[i];
            if (!cell_visited[ghost_element.getID()])
            {
                cell_visited[ghost_element.getID()] = true;
                partition.duplicate_ghost_cell[i] = false;
            }
        }
    }
}

References MeshLib::Mesh::getElements().

Referenced by ApplicationUtils::NodeWiseMeshPartitioner::partitionByMETIS(), and ApplicationUtils::NodeWiseMeshPartitioner::partitionOtherMesh().

nodeIdBulkMesh()

std::size_t ApplicationUtils::nodeIdBulkMesh	(	MeshLib::Node const &	node,
		std::vector< std::size_t > const *	node_id_mapping = nullptr
	)

Definition at line 102 of file NodeWiseMeshPartitioner.cpp.

{
    return node_id_mapping ? (*node_id_mapping)[node.getID()] : node.getID();
}

References MathLib::Point3dWithID::getID().

Referenced by partitionLookup().

numberOfRegularNodes()

std::ptrdiff_t ApplicationUtils::numberOfRegularNodes	(	MeshLib::Element const &	e,
		std::size_t const	part_id,
		std::vector< std::size_t > const &	partition_ids,
		std::vector< std::size_t > const *	node_id_mapping = nullptr
	)

Definition at line 164 of file NodeWiseMeshPartitioner.cpp.

{
    return std::count_if(e.getNodes(), e.getNodes() + e.getNumberOfNodes(),
                         [&](MeshLib::Node* const n) {
                             return partitionLookup(*n, partition_ids,
                                                    node_id_mapping) == part_id;
                         });
}

References MeshLib::Element::getNodes(), and MeshLib::Element::getNumberOfNodes().

Referenced by findElementsInPartition().

partitionLookup()

std::size_t ApplicationUtils::partitionLookup	(	MeshLib::Node const &	node,
		std::vector< std::size_t > const &	partition_ids,
		std::vector< std::size_t > const *	node_id_mapping = nullptr
	)

Definition at line 109 of file NodeWiseMeshPartitioner.cpp.

{
    auto node_id = [&node_id_mapping](MeshLib::Node const& n)
    { return nodeIdBulkMesh(n, node_id_mapping); };
 
    return partition_ids[node_id(node)];
}

References nodeIdBulkMesh().

Referenced by findGhostNodesInPartition(), and findRegularNodesInPartition().

partitionProperties()

MeshLib::Properties ApplicationUtils::partitionProperties	(	std::unique_ptr< MeshLib::Mesh > const &	mesh,
		std::vector< Partition > &	partitions
	)

Partition existing properties and add vtkGhostType cell data array property.

Creates partitioned mesh properties for nodes and cells.

Definition at line 553 of file NodeWiseMeshPartitioner.cpp.

{
    using namespace MeshLib;
 
    MeshLib::Properties const& properties = mesh->getProperties();
 
    // Count the number of integration point data of all partitions:
    setIntegrationPointNumberOfPartition(properties, partitions);
 
    Properties partitioned_properties;
    auto count_tuples = [&](MeshItemType const mesh_item_type)
    {
        return std::accumulate(
            begin(partitions), end(partitions), 0,
            [&](std::size_t const sum, Partition const& p)
            { return sum + p.numberOfMeshItems(mesh_item_type); });
    };
 
    std::map<MeshItemType, std::size_t> const total_number_of_tuples = {
        {MeshItemType::Cell, count_tuples(MeshItemType::Cell)},
        {MeshItemType::Node, count_tuples(MeshItemType::Node)},
        {MeshItemType::IntegrationPoint,
         count_tuples(MeshItemType::IntegrationPoint)}};
 
    DBUG(
        "total number of tuples after partitioning defined for cells is {:d} "
        "and for nodes {:d} and for integration points {:d}.",
        total_number_of_tuples.at(MeshItemType::Cell),
        total_number_of_tuples.at(MeshItemType::Node),
        total_number_of_tuples.at(MeshItemType::IntegrationPoint));
 
    //  1 create new PV
    //  2 resize the PV with total_number_of_tuples
    //  3 copy the values according to the partition info
    applyToPropertyVectors(
        properties,
        [&](auto type, auto const property)
        {
            return copyPropertyVector<decltype(type)>(
                mesh->getElements(), partitioned_properties, properties,
                partitions,
                dynamic_cast<PropertyVector<decltype(type)> const*>(property),
                total_number_of_tuples);
        });
 
    addVtkGhostTypeProperty(partitioned_properties,
                            partitions,
                            total_number_of_tuples.at(MeshItemType::Cell));
 
    return partitioned_properties;
}

References addVtkGhostTypeProperty(), applyToPropertyVectors(), DBUG(), and setIntegrationPointNumberOfPartition().

Referenced by main(), and ApplicationUtils::NodeWiseMeshPartitioner::partitionByMETIS().

readMetisData()

std::vector< std::size_t > ApplicationUtils::readMetisData	(	const std::string &	file_name_base,
		long	number_of_partitions,
		std::size_t	number_of_nodes
	)

Read metis data

Parameters

file_name_base	The prefix of the filename.
number_of_partitions	The number is used to compose the full filename and forms the postfix.
number_of_nodes	Expected/required number of nodes to be read.

Definition at line 45 of file Metis.cpp.

{
    const std::string npartitions_str = std::to_string(number_of_partitions);
 
    // Read partitioned mesh data from METIS
    const std::string fname_parts =
        file_name_base + ".mesh.npart." + npartitions_str;
 
    std::ifstream npart_in(fname_parts);
    if (!npart_in.is_open())
    {
        OGS_FATAL(
            "Error: cannot open file {:s}. It may not exist!\n"
            "Run mpmetis beforehand or use option -m",
            fname_parts.data());
    }
 
    std::vector<std::size_t> partition_ids(number_of_nodes);
 
    std::size_t counter = 0;
    while (!npart_in.eof())
    {
        npart_in >> partition_ids[counter++] >> std::ws;
        if (counter == number_of_nodes)
        {
            break;
        }
    }
 
    if (npart_in.bad())
    {
        OGS_FATAL("Error while reading file {:s}.", fname_parts.data());
    }
 
    if (counter != number_of_nodes)
    {
        OGS_FATAL("Error: data in {:s} are less than expected.",
                  fname_parts.data());
    }
 
    return partition_ids;
}

References OGS_FATAL.

Referenced by main().

removeMetisPartitioningFiles()

void ApplicationUtils::removeMetisPartitioningFiles	(	std::string const &	file_name_base,
		long	number_of_partitions
	)

Removes the F.mesh.npart.P and F.mesh.epart.P files, where F is file name base and P is the number of partitions.

Definition at line 90 of file Metis.cpp.

{
    const std::string npartitions_str = std::to_string(number_of_partitions);
 
    std::remove((file_name_base + ".mesh.npart." + npartitions_str).c_str());
    std::remove((file_name_base + ".mesh.epart." + npartitions_str).c_str());
}

Referenced by main().

setIntegrationPointNumberOfPartition()

void ApplicationUtils::setIntegrationPointNumberOfPartition	(	MeshLib::Properties const &	properties,
		std::vector< Partition > &	partitions
	)

Definition at line 405 of file NodeWiseMeshPartitioner.cpp.

{
    for (auto const& [name, property] : properties)
    {
        auto const item_type = property->getMeshItemType();
 
        if (item_type != MeshLib::MeshItemType::IntegrationPoint)
        {
            continue;
        }
 
        // For special field data such as OGS_VERSION, IntegrationPointMetaData,
        // etc., which are not "real" integration points:
        if (property->getPropertyName().find("_ip") == std::string::npos)
        {
            continue;
        }
 
        std::string const property_name = property->getPropertyName();
        auto countIntegrationPoints =
            [&](std::vector<const MeshLib::Element*> const& elements)
        {
            auto const ip_meta_data =
                MeshLib::getIntegrationPointMetaData(properties, property_name);
            std::size_t counter = 0;
            for (auto const element : elements)
            {
                int const number_of_integration_points =
                    getNumberOfElementIntegrationPoints(ip_meta_data, *element);
                counter += number_of_integration_points;
            }
            return counter;
        };
 
        for (auto& p : partitions)
        {
            p.number_of_integration_points =
                countIntegrationPoints(p.regular_elements) +
                countIntegrationPoints(p.ghost_elements);
        }
        return;
    }
}

References MeshLib::getIntegrationPointMetaData(), getNumberOfElementIntegrationPoints(), and MeshLib::IntegrationPoint.

Referenced by partitionProperties().

writeConfigData()

std::tuple< std::vector< long >, std::vector< long > > ApplicationUtils::writeConfigData	(	const std::string &	file_name_base,
		std::vector< Partition > const &	partitions
	)

Write the configuration data of the partition data in binary files.

Returns

a pair of vectors for:

1. The number of all non-ghost element integer variables for each partition.
2. The number of all ghost element integer variables for each partition.

Definition at line 1041 of file NodeWiseMeshPartitioner.cpp.

{
    auto const file_name_cfg = file_name_base + "_partitioned_msh_cfg" +
                               std::to_string(partitions.size()) + ".bin";
    std::ofstream of_bin_cfg(file_name_cfg, std::ios::binary);
    if (!of_bin_cfg)
    {
        OGS_FATAL("Could not open file '{:s}' for output.", file_name_cfg);
    }
 
    std::vector<long> partitions_element_offsets;
    partitions_element_offsets.reserve(partitions.size());
    std::vector<long> partitions_ghost_element_offsets;
    partitions_ghost_element_offsets.reserve(partitions.size());
 
    ConfigOffsets config_offsets = {0, 0, 0};  // 0 for first partition.
    for (const auto& partition : partitions)
    {
        partition.writeConfig(of_bin_cfg);
 
        config_offsets.writeConfig(of_bin_cfg);
        auto const& partition_offsets = computePartitionOffsets(partition);
        config_offsets =
            incrementConfigOffsets(config_offsets, partition_offsets);
 
        partitions_element_offsets.push_back(
            partition_offsets.regular_elements);
        partitions_ghost_element_offsets.push_back(
            partition_offsets.ghost_elements);
    }
 
    return std::make_tuple(partitions_element_offsets,
                           partitions_ghost_element_offsets);
}

References computePartitionOffsets(), incrementConfigOffsets(), OGS_FATAL, and ApplicationUtils::ConfigOffsets::writeConfig().

Referenced by ApplicationUtils::NodeWiseMeshPartitioner::write(), and ApplicationUtils::NodeWiseMeshPartitioner::writeOtherMesh().

writeElements()

void ApplicationUtils::writeElements	(	std::string const &	file_name_base,
		std::vector< Partition > const &	partitions,
		std::vector< long > const &	regular_element_offsets,
		std::vector< long > const &	ghost_element_offsets
	)

Write the element integer variables of all partitions into binary files.

Parameters

file_name_base	The prefix of the file name.
partitions	Partitions vector.
regular_element_offsets	The numbers of all non-ghost element integer variables of each partitions.
ghost_element_offsets	The numbers of all ghost element

Definition at line 1125 of file NodeWiseMeshPartitioner.cpp.

{
    const std::string npartitions_str = std::to_string(partitions.size());
 
    auto const file_name_ele =
        file_name_base + "_partitioned_msh_ele" + npartitions_str + ".bin";
    std::ofstream element_info_os(file_name_ele, std::ios::binary);
    if (!element_info_os)
    {
        OGS_FATAL("Could not open file '{:s}' for output.", file_name_ele);
    }
 
    auto const file_name_ele_g =
        file_name_base + "_partitioned_msh_ele_g" + npartitions_str + ".bin";
    std::ofstream ghost_element_info_os(file_name_ele_g, std::ios::binary);
    if (!ghost_element_info_os)
    {
        OGS_FATAL("Could not open file '{:s}' for output.", file_name_ele_g);
    }
 
    for (std::size_t i = 0; i < partitions.size(); i++)
    {
        const auto& partition = partitions[i];
        auto const local_node_ids = enumerateLocalNodeIds(partition.nodes);
 
        // Vector containing the offsets of the regular elements of this
        // partition
        std::vector<long> ele_info(regular_element_offsets[i]);
 
        auto writeElementData =
            [&local_node_ids](
                std::vector<MeshLib::Element const*> const& elements,
                long const element_offsets,
                std::ofstream& output_stream)
        {
            long counter = elements.size();
            std::vector<long> ele_info(element_offsets);
 
            for (std::size_t j = 0; j < elements.size(); j++)
            {
                const auto* elem = elements[j];
                ele_info[j] = counter;
                getElementIntegerVariables(*elem, local_node_ids, ele_info,
                                           counter);
            }
            // Write vector data of regular elements
            output_stream.write(reinterpret_cast<const char*>(ele_info.data()),
                                ele_info.size() * sizeof(long));
        };
 
        // regular elements.
        writeElementData(partition.regular_elements, regular_element_offsets[i],
                         element_info_os);
        // Ghost elements
        writeElementData(partition.ghost_elements, ghost_element_offsets[i],
                         ghost_element_info_os);
    }
}

References enumerateLocalNodeIds(), getElementIntegerVariables(), and OGS_FATAL.

Referenced by ApplicationUtils::NodeWiseMeshPartitioner::write(), and ApplicationUtils::NodeWiseMeshPartitioner::writeOtherMesh().

writeMETIS()

void ApplicationUtils::writeMETIS	(	std::vector< MeshLib::Element * > const &	elements,
		const std::string &	file_name
	)

Write elements as METIS graph file

Parameters

elements	The mesh elements.
file_name	File name with an extension of mesh.

Definition at line 19 of file Metis.cpp.

{
    std::ofstream os(file_name, std::ios::trunc);
    if (!os.is_open())
    {
        OGS_FATAL("Error: cannot open file {:s}.", file_name.data());
    }
 
    if (!os.good())
    {
        OGS_FATAL("Error: Cannot write in file {:s}.", file_name.data());
    }
 
    os << elements.size() << " \n";
    for (const auto* elem : elements)
    {
        os << getNodeIndex(*elem, 0) + 1;
        for (unsigned j = 1; j < elem->getNumberOfNodes(); j++)
        {
            os << " " << getNodeIndex(*elem, j) + 1;
        }
        os << "\n";
    }
}

References OGS_FATAL.

Referenced by main().

writeNodes()

void ApplicationUtils::writeNodes	(	const std::string &	file_name_base,
		std::vector< Partition > const &	partitions,
		std::vector< std::size_t > const &	global_node_ids
	)

Write the nodes of all partitions into a binary file.

Parameters

file_name_base	The prefix of the file name.
partitions	the list of partitions
global_node_ids	global numbering of nodes

Definition at line 1191 of file NodeWiseMeshPartitioner.cpp.

{
    auto const file_name = file_name_base + "_partitioned_msh_nod" +
                           std::to_string(partitions.size()) + ".bin";
    std::ofstream os(file_name, std::ios::binary);
    if (!os)
    {
        OGS_FATAL("Could not open file '{:s}' for output.", file_name);
    }
 
    for (const auto& partition : partitions)
    {
        partition.writeNodes(os, global_node_ids);
    }
}

References OGS_FATAL.

Referenced by ApplicationUtils::NodeWiseMeshPartitioner::write(), and ApplicationUtils::NodeWiseMeshPartitioner::writeOtherMesh().

writeProperties()

void ApplicationUtils::writeProperties	(	const std::string &	file_name_base,
		MeshLib::Properties const &	partitioned_properties,
		std::vector< Partition > const &	partitions,
		MeshLib::MeshItemType const	mesh_item_type
	)

Definition at line 924 of file NodeWiseMeshPartitioner.cpp.

{
    auto const number_of_properties =
        partitioned_properties.size(mesh_item_type);
    if (number_of_properties == 0)
    {
        return;
    }
 
    auto const file_name_infix = toString(mesh_item_type);
 
    auto const file_name_cfg = file_name_base + "_partitioned_" +
                               file_name_infix + "_properties_cfg" +
                               std::to_string(partitions.size()) + ".bin";
    std::ofstream out(file_name_cfg, std::ios::binary);
    if (!out)
    {
        OGS_FATAL("Could not open file '{:s}' for output.", file_name_cfg);
    }
 
    auto const file_name_val = file_name_base + "_partitioned_" +
                               file_name_infix + "_properties_val" +
                               std::to_string(partitions.size()) + ".bin";
    std::ofstream out_val(file_name_val, std::ios::binary);
    if (!out_val)
    {
        OGS_FATAL("Could not open file '{:s}' for output.", file_name_val);
    }
 
    BaseLib::writeValueBinary(out, number_of_properties);
 
    applyToPropertyVectors(
        partitioned_properties,
        [&](auto type, auto const& property)
        {
            return writePropertyVector<decltype(type)>(
                dynamic_cast<MeshLib::PropertyVector<decltype(type)> const*>(
                    property),
                mesh_item_type, out_val, out);
        });
 
    unsigned long offset = 0;
    for (const auto& partition : partitions)
    {
        MeshLib::IO::PropertyVectorPartitionMetaData pvpmd{
            offset, static_cast<unsigned long>(
                        partition.numberOfMeshItems(mesh_item_type))};
        DBUG(
            "Write meta data for node-based PropertyVector: global offset "
            "{:d}, number of tuples {:d}",
            pvpmd.offset, pvpmd.number_of_tuples);
        MeshLib::IO::writePropertyVectorPartitionMetaData(out, pvpmd);
        offset += pvpmd.number_of_tuples;
    }
}

References applyToPropertyVectors(), DBUG(), OGS_FATAL, MeshLib::Properties::size(), MeshLib::IO::writePropertyVectorPartitionMetaData(), and BaseLib::writeValueBinary().

Referenced by ApplicationUtils::NodeWiseMeshPartitioner::write(), and ApplicationUtils::NodeWiseMeshPartitioner::writeOtherMesh().

writePropertyVector()

template<typename T >

bool ApplicationUtils::writePropertyVector	(	MeshLib::PropertyVector< T > const *const	pv,
		MeshLib::MeshItemType const	mesh_item_type,
		std::ostream &	out_val,
		std::ostream &	out_meta
	)

Definition at line 899 of file NodeWiseMeshPartitioner.cpp.

{
    if (pv == nullptr)
    {
        return false;
    }
    // skip property of different mesh item type. Return true, because this
    // operation was successful.
    if (pv->getMeshItemType() != mesh_item_type)
    {
        return true;
    }
 
    MeshLib::IO::PropertyVectorMetaData pvmd;
    pvmd.property_name = pv->getPropertyName();
    pvmd.fillPropertyVectorMetaDataTypeInfo<T>();
    pvmd.number_of_components = pv->getNumberOfGlobalComponents();
    pvmd.number_of_tuples = pv->getNumberOfTuples();
    writePropertyVectorValues(out_val, *pv);
    MeshLib::IO::writePropertyVectorMetaData(out_meta, pvmd);
    return true;
}

References MeshLib::IO::PropertyVectorMetaData::fillPropertyVectorMetaDataTypeInfo(), MeshLib::PropertyVectorBase::getMeshItemType(), MeshLib::PropertyVectorBase::getNumberOfGlobalComponents(), MeshLib::PropertyVector< PROP_VAL_TYPE >::getNumberOfTuples(), MeshLib::PropertyVectorBase::getPropertyName(), MeshLib::IO::PropertyVectorMetaData::number_of_components, MeshLib::IO::PropertyVectorMetaData::number_of_tuples, MeshLib::IO::PropertyVectorMetaData::property_name, MeshLib::IO::writePropertyVectorMetaData(), and writePropertyVectorValues().

writePropertyVectorValues()

template<typename T >

void ApplicationUtils::writePropertyVectorValues	(	std::ostream &	os,
		MeshLib::PropertyVector< T > const &	pv
	)

Definition at line 892 of file NodeWiseMeshPartitioner.cpp.

{
    os.write(reinterpret_cast<const char*>(pv.data()), pv.size() * sizeof(T));
}

References MeshLib::PropertyVector< PROP_VAL_TYPE >::size().

Referenced by writePropertyVector().