ApplicationUtils Namespace Reference

Detailed Description

Copyright

Copyright (c) 2012-2025, OpenGeoSys Community (http://www.opengeosys.org) Distributed under a Modified BSD License. See accompanying file LICENSE.txt or http://www.opengeosys.org/project/license

Classes
class	ComputeNaturalCoordsIntermediateResult
struct	ComputeNaturalCoordsResult
class	ComputeNaturalCoordsRootFindingProblem
class	ComputeNaturalCoordsSolverImplementation
class	ComputeNaturalCoordsSolverInterface
struct	ConfigOffsets
class	FindCellsForPoints
class	NodeWiseMeshPartitioner
	Mesh partitioner. More...
struct	Partition
	A subdomain mesh. More...
struct	PartitionOffsets
class	SolverByElementTypeRegistry

Functions
ComputeNaturalCoordsResult	computeNaturalCoords (vtkUnstructuredGrid *const bulk_mesh, Eigen::MatrixXd const &real_coords, double const tolerance, int const max_iter)
template<typename T >
void	addPointData (vtkUnstructuredGrid *grid, std::string const &name, Eigen::MatrixX< T > const &data)
vtkSmartPointer< vtkUnstructuredGrid >	toVTKGrid (ComputeNaturalCoordsResult const &result)
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	partitionLookup (std::size_t const &node_id, std::vector< std::size_t > const &partition_ids, std::vector< std::size_t > const &node_id_mapping)
std::pair< std::vector< MeshLib::Node const * >, std::vector< MeshLib::Node const * > >	splitIntoBaseAndHigherOrderNodes (std::vector< MeshLib::Node const * > const &nodes, MeshLib::Mesh const &mesh)
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)
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)
std::vector< std::vector< std::size_t > >	computePartitionIDPerElement (std::vector< std::size_t > const &node_partition_map, std::vector< MeshLib::Element * > const &elements, std::vector< std::size_t > const &bulk_node_ids)
void	distributeNodesToPartitions (std::vector< Partition > &partitions, std::vector< std::size_t > const &nodes_partition_ids, std::vector< MeshLib::Node * > const &nodes, std::vector< std::size_t > const &bulk_node_ids)
void	reorderNodesIntoBaseAndHigherOrderNodes (Partition &partition, MeshLib::Mesh const &mesh)
void	reorderNodesIntoBaseAndHigherOrderNodesPerPartition (std::vector< Partition > &partitions, MeshLib::Mesh const &mesh)
void	setNumberOfNodesInPartitions (std::vector< Partition > &partitions, MeshLib::Mesh const &mesh)
void	distributeElementsIntoPartitions (std::vector< Partition > &partitions, MeshLib::Mesh const &mesh, std::vector< std::vector< std::size_t > > const &partition_ids_per_element)
void	determineAndAppendGhostNodesToPartitions (std::vector< Partition > &partitions, MeshLib::Mesh const &mesh, std::vector< std::size_t > const &nodes_partition_ids, std::vector< std::size_t > const &node_id_mapping)
void	partitionMesh (std::vector< Partition > &partitions, MeshLib::Mesh const &mesh, std::vector< std::size_t > const &nodes_partition_ids, std::vector< std::size_t > const &bulk_node_ids)
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 * > 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

addPointData()

template<typename T >

void ApplicationUtils::addPointData	(	vtkUnstructuredGrid *	grid,
		std::string const &	name,
		Eigen::MatrixX< T > const &	data )

Definition at line 157 of file ComputeNaturalCoordsAlgorithm.h.

{
    INFO("converting {}", name);
    vtkNew<vtkAOSDataArrayTemplate<T>> array;
    array->SetName(name.c_str());
    array->SetNumberOfComponents(data.cols());
    array->SetNumberOfTuples(grid->GetNumberOfPoints());
 
    if (grid->GetNumberOfPoints() != data.rows())
    {
        OGS_FATAL(
            "Got {} rows in the table but expected {} rows, same as number of "
            "points in the grid.",
            data.rows(), grid->GetNumberOfPoints());
    }
    for (Eigen::Index i = 0; i < data.rows(); ++i)
    {
        // copy to contiguous storage
        Eigen::RowVectorX<T> const row = data.row(i);
 
        array->SetTypedTuple(i, row.data());
        DBUG("> {}", row);
    }
 
    grid->GetPointData()->AddArray(array);
}

References DBUG(), INFO(), and OGS_FATAL.

Referenced by toVTKGrid().

addVtkGhostTypeProperty()

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

Definition at line 412 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 518 of file NodeWiseMeshPartitioner.cpp.

{
    auto const& opt_ip_meta_data_all =
        MeshLib::getIntegrationPointMetaData(properties);
    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::getIntegrationPointMetaDataSingleField(
                opt_ip_meta_data_all, property->getPropertyName());
        for (auto const element : global_mesh_elements)
        {
            int const number_of_integration_points =
                MeshToolsLib::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(), MeshLib::getIntegrationPointMetaDataSingleField(), MeshToolsLib::getNumberOfElementIntegrationPoints(), MeshLib::PropertyVectorBase::getNumberOfGlobalComponents(), MeshLib::IntegrationPoint, and OGS_FATAL.

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

computeNaturalCoords()

ComputeNaturalCoordsResult ApplicationUtils::computeNaturalCoords	(	vtkUnstructuredGrid *const	bulk_mesh,
		Eigen::MatrixXd const &	real_coords,
		double const	tolerance,
		int const	max_iter )

Definition at line 78 of file ComputeNaturalCoordsAlgorithm.h.

{
    // Check inputs ------------------------------------------------------------
 
    if (real_coords.cols() != 3)
    {
        OGS_FATAL("Wrong number of input coordinates");
    }
 
    // General definitions -----------------------------------------------------
    using SolverRegistry =
        SolverByElementTypeRegistry<ComputeNaturalCoordsSolverInterface,
                                    ComputeNaturalCoordsSolverImplementation>;
 
    double const real_coords_tolerance = tolerance;
 
    // Initialization ----------------------------------------------------------
    FindCellsForPoints findCellsForPoints;
    findCellsForPoints.initialize(bulk_mesh);
 
    ComputeNaturalCoordsIntermediateResult result;
 
    // Do computation for each point ------------------------------------------
    for (Eigen::Index rc_idx = 0; rc_idx < real_coords.rows(); ++rc_idx)
    {
        Eigen::RowVector3d const real_coords_single_point =
            real_coords.row(rc_idx);
 
        // Find cells for point
        auto const filtered_bulk_mesh =
            findCellsForPoints.find(real_coords_single_point, tolerance);
 
        // Check multiplicity
        int const actual_multiplicity = filtered_bulk_mesh->GetNumberOfCells();
        if (actual_multiplicity == 0)
        {
            OGS_FATAL(
                "Did not find any cell for the point {} (coordinates: {})",
                rc_idx, real_coords_single_point);
        }
        assert(actual_multiplicity > 0);
        if (actual_multiplicity != 1)
        {
            INFO(
                "Found more then one cell (namely {}) for point #{} "
                "(coordinates: {})",
                actual_multiplicity, rc_idx, real_coords_single_point);
        }
 
        // Convert to OGS
        std::unique_ptr<MeshLib::Mesh> ogs_mesh(
            MeshLib::VtkMeshConverter::convertUnstructuredGrid(
                filtered_bulk_mesh, "filtered_bulk_mesh"));
 
        auto const* bulk_element_ids = MeshLib::bulkElementIDs(*ogs_mesh);
 
        auto const& elements = ogs_mesh->getElements();
 
        // Compute natural coordinates
        // Found a solution, no need to test other elements ignoring
        // multiplicity.
        constexpr std::size_t elt_idx = 0;
        auto const& element = *elements[elt_idx];
        auto const bulk_element_id = bulk_element_ids->getComponent(elt_idx, 0);
 
        auto const& solver = SolverRegistry::getFor(element);
        auto const opt_natural_coords = solver.solve(
            element, real_coords_single_point, max_iter, real_coords_tolerance);
 
        result.append(opt_natural_coords, real_coords_single_point,
                      bulk_element_id, rc_idx);
    }
 
    return result.finished();
}

References ApplicationUtils::ComputeNaturalCoordsIntermediateResult::append(), MeshLib::bulkElementIDs(), MeshLib::VtkMeshConverter::convertUnstructuredGrid(), ApplicationUtils::FindCellsForPoints::find(), ApplicationUtils::ComputeNaturalCoordsIntermediateResult::finished(), INFO(), ApplicationUtils::FindCellsForPoints::initialize(), and OGS_FATAL.

computePartitionIDPerElement()

std::vector< std::vector< std::size_t > > ApplicationUtils::computePartitionIDPerElement	(	std::vector< std::size_t > const &	node_partition_map,
		std::vector< MeshLib::Element * > const &	elements,
		std::vector< std::size_t > const &	bulk_node_ids )

Definition at line 567 of file NodeWiseMeshPartitioner.cpp.

{
    auto node_partition_ids = ranges::views::transform(
        [&](MeshLib::Element const* const element)
        {
            auto node_lookup = ranges::views::transform(
                [&](std::size_t const i)
                { return node_partition_map[bulk_node_ids[i]]; });
 
            return element->nodes() | MeshLib::views::ids | node_lookup |
                   ranges::to<std::vector>;
        });
 
    return elements | node_partition_ids | ranges::to<std::vector>;
}

References MeshLib::views::ids, and MeshLib::Element::nodes().

Referenced by partitionMesh().

computePartitionOffsets()

PartitionOffsets ApplicationUtils::computePartitionOffsets

(

Partition const &

partition

)

Definition at line 1037 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 204 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 234 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 const ip_meta_data = MeshLib::getIntegrationPointMetaDataSingleField(
        MeshLib::getIntegrationPointMetaData(properties), pv.getPropertyName());
    auto copyFieldData =
        [&](std::vector<const MeshLib::Element*> const& elements)
    {
        for (auto const element : elements)
        {
            int const number_of_element_field_data =
                MeshToolsLib::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(), MeshLib::getIntegrationPointMetaDataSingleField(), MeshToolsLib::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 182 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 332 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 =
            MeshToolsLib::getIntegrationPointDataOffsetsOfMeshElements(
                global_mesh_elements, *pv, properties);
    }
 
    auto partitioned_pv = partitioned_properties.createNewPropertyVector<T>(
        pv->getPropertyName(), pv->getMeshItemType(),
        pv->getNumberOfGlobalComponents());
    if (partitioned_pv == nullptr)
    {
        OGS_FATAL(
            "Could not create partitioned property vector {:s} for {} data "
            "array.",
            pv->getPropertyName(), MeshLib::toString(pv->getMeshItemType()));
    }
    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(), MeshToolsLib::getIntegrationPointDataOffsetsOfMeshElements(), MeshLib::PropertyVectorBase::getMeshItemType(), MeshLib::PropertyVectorBase::getNumberOfGlobalComponents(), MeshLib::PropertyVectorBase::getPropertyName(), MeshLib::IntegrationPoint, MeshLib::Node, OGS_FATAL, MeshLib::PropertyVector< PROP_VAL_TYPE >::size(), and MeshLib::toString().

Referenced by partitionProperties().

determineAndAppendGhostNodesToPartitions()

void ApplicationUtils::determineAndAppendGhostNodesToPartitions	(	std::vector< Partition > &	partitions,
		MeshLib::Mesh const &	mesh,
		std::vector< std::size_t > const &	nodes_partition_ids,
		std::vector< std::size_t > const &	node_id_mapping )

Definition at line 669 of file NodeWiseMeshPartitioner.cpp.

{
    for (std::size_t part_id = 0; part_id < partitions.size(); part_id++)
    {
        auto& partition = partitions[part_id];
        std::vector<MeshLib::Node*> base_ghost_nodes;
        std::vector<MeshLib::Node*> higher_order_ghost_nodes;
        std::tie(base_ghost_nodes, higher_order_ghost_nodes) =
            findGhostNodesInPartition(
                part_id, mesh.getNodes(), partition.ghost_elements,
                nodes_partition_ids, mesh, node_id_mapping);
 
        std::copy(begin(base_ghost_nodes), end(base_ghost_nodes),
                  std::back_inserter(partition.nodes));
 
        partition.number_of_base_nodes =
            partition.number_of_regular_base_nodes + base_ghost_nodes.size();
 
        std::copy(begin(higher_order_ghost_nodes),
                  end(higher_order_ghost_nodes),
                  std::back_inserter(partition.nodes));
    }
}

References findGhostNodesInPartition(), and MeshLib::Mesh::getNodes().

Referenced by partitionMesh().

distributeElementsIntoPartitions()

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

Definition at line 635 of file NodeWiseMeshPartitioner.cpp.

{
    for (auto const& element : mesh.getElements())
    {
        auto const element_id = element->getID();
        auto node_partition_ids = partition_ids_per_element[element_id];
        // make partition ids unique
        std::sort(node_partition_ids.begin(), node_partition_ids.end());
        auto last =
            std::unique(node_partition_ids.begin(), node_partition_ids.end());
        node_partition_ids.erase(last, node_partition_ids.end());
 
        // all element nodes belong to the same partition => regular element
        if (node_partition_ids.size() == 1)
        {
            partitions[node_partition_ids[0]].regular_elements.push_back(
                element);
        }
        else
        {
            for (auto const partition_id : node_partition_ids)
            {
                partitions[partition_id].ghost_elements.push_back(element);
            }
        }
    }
}

References MeshLib::Mesh::getElements().

Referenced by partitionMesh().

distributeNodesToPartitions()

void ApplicationUtils::distributeNodesToPartitions	(	std::vector< Partition > &	partitions,
		std::vector< std::size_t > const &	nodes_partition_ids,
		std::vector< MeshLib::Node * > const &	nodes,
		std::vector< std::size_t > const &	bulk_node_ids )

Definition at line 586 of file NodeWiseMeshPartitioner.cpp.

{
    for (auto const* const node : nodes)
    {
        partitions[nodes_partition_ids[bulk_node_ids[node->getID()]]]
            .nodes.push_back(node);
    }
}

Referenced by partitionMesh().

enumerateLocalNodeIds()

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

(

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

nodes

)

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

Definition at line 1134 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().

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 )

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

Definition at line 137 of file NodeWiseMeshPartitioner.cpp.

{
    std::vector<MeshLib::Node*> base_ghost_nodes;
    std::vector<MeshLib::Node*> higher_order_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);
            auto const node_id = n->getID();
            if (is_ghost_node[node_id])
            {
                continue;
            }
 
            if (partitionLookup(node_id, partition_ids, node_id_mapping) !=
                part_id)
            {
                if (isBaseNode(*n, mesh.getElementsConnectedToNode(*n)))
                {
                    base_ghost_nodes.push_back(nodes[node_id]);
                }
                else
                {
                    higher_order_ghost_nodes.push_back(nodes[node_id]);
                }
                is_ghost_node[node_id] = true;
            }
        }
    }
    return std::tuple<std::vector<MeshLib::Node*>, std::vector<MeshLib::Node*>>{
        base_ghost_nodes, higher_order_ghost_nodes};
}

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

Referenced by determineAndAppendGhostNodesToPartitions().

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 1113 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().

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 1048 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 496 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 partitionMesh().

partitionLookup()

std::size_t ApplicationUtils::partitionLookup	(	std::size_t const &	node_id,
		std::vector< std::size_t > const &	partition_ids,
		std::vector< std::size_t > const &	node_id_mapping )

Definition at line 102 of file NodeWiseMeshPartitioner.cpp.

{
    return partition_ids[node_id_mapping[node_id]];
}

Referenced by findGhostNodesInPartition().

partitionMesh()

void ApplicationUtils::partitionMesh	(	std::vector< Partition > &	partitions,
		MeshLib::Mesh const &	mesh,
		std::vector< std::size_t > const &	nodes_partition_ids,
		std::vector< std::size_t > const &	bulk_node_ids )

Definition at line 696 of file NodeWiseMeshPartitioner.cpp.

{
    BaseLib::RunTime run_timer;
    run_timer.start();
    auto const partition_ids_per_element = computePartitionIDPerElement(
        nodes_partition_ids, mesh.getElements(), bulk_node_ids);
    INFO("partitionMesh(): Partition IDs per element computed in {:g} s",
         run_timer.elapsed());
 
    run_timer.start();
    distributeNodesToPartitions(partitions, nodes_partition_ids,
                                mesh.getNodes(), bulk_node_ids);
    INFO("partitionMesh(): distribute nodes to partitions took {:g} s",
         run_timer.elapsed());
 
    run_timer.start();
    reorderNodesIntoBaseAndHigherOrderNodesPerPartition(partitions, mesh);
    INFO(
        "partitionMesh(): sorting [base nodes | higher order nodes] took {:g} "
        "s",
        run_timer.elapsed());
 
    run_timer.start();
    setNumberOfNodesInPartitions(partitions, mesh);
    INFO(
        "partitionMesh(): setting number of nodes and of all mesh base nodes "
        "took {:g} s",
        run_timer.elapsed());
 
    run_timer.start();
    distributeElementsIntoPartitions(partitions, mesh,
                                     partition_ids_per_element);
    INFO("partitionMesh(): distribute elements into partitions took {:g} s",
         run_timer.elapsed());
 
    run_timer.start();
    determineAndAppendGhostNodesToPartitions(
        partitions, mesh, nodes_partition_ids, bulk_node_ids);
    INFO("partitionMesh(): determine / append ghost nodes took {:g} s",
         run_timer.elapsed());
 
    run_timer.start();
    markDuplicateGhostCells(mesh, partitions);
    INFO("partitionMesh(): markDuplicateGhostCells took {:g} s",
         run_timer.elapsed());
}

References computePartitionIDPerElement(), determineAndAppendGhostNodesToPartitions(), distributeElementsIntoPartitions(), distributeNodesToPartitions(), BaseLib::RunTime::elapsed(), MeshLib::Mesh::getElements(), MeshLib::Mesh::getNodes(), INFO(), markDuplicateGhostCells(), reorderNodesIntoBaseAndHigherOrderNodesPerPartition(), setNumberOfNodesInPartitions(), and BaseLib::RunTime::start().

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

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 442 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(), copyPropertyVector(), 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().

reorderNodesIntoBaseAndHigherOrderNodes()

void ApplicationUtils::reorderNodesIntoBaseAndHigherOrderNodes	(	Partition &	partition,
		MeshLib::Mesh const &	mesh )

Definition at line 599 of file NodeWiseMeshPartitioner.cpp.

{
    std::vector<MeshLib::Node const*> higher_order_nodes;
    // after splitIntoBaseAndHigherOrderNodes() partition.nodes contains only
    // base nodes
    std::tie(partition.nodes, higher_order_nodes) =
        splitIntoBaseAndHigherOrderNodes(partition.nodes, mesh);
    partition.number_of_regular_base_nodes = partition.nodes.size();
    std::copy(begin(higher_order_nodes), end(higher_order_nodes),
              std::back_inserter(partition.nodes));
    partition.number_of_regular_nodes = partition.nodes.size();
}

References ApplicationUtils::Partition::nodes, ApplicationUtils::Partition::number_of_regular_base_nodes, ApplicationUtils::Partition::number_of_regular_nodes, and splitIntoBaseAndHigherOrderNodes().

Referenced by reorderNodesIntoBaseAndHigherOrderNodesPerPartition().

reorderNodesIntoBaseAndHigherOrderNodesPerPartition()

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

Definition at line 613 of file NodeWiseMeshPartitioner.cpp.

{
    for (auto& partition : partitions)
    {
        reorderNodesIntoBaseAndHigherOrderNodes(partition, mesh);
    }
}

References reorderNodesIntoBaseAndHigherOrderNodes().

Referenced by partitionMesh().

setIntegrationPointNumberOfPartition()

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

Definition at line 283 of file NodeWiseMeshPartitioner.cpp.

{
    auto const& opt_ip_meta_data_all =
        MeshLib::getIntegrationPointMetaData(properties);
    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;
        }
 
        auto const& ip_meta_data =
            MeshLib::getIntegrationPointMetaDataSingleField(
                opt_ip_meta_data_all, property->getPropertyName());
        auto countIntegrationPoints =
            [&](std::vector<const MeshLib::Element*> const& elements)
        {
            std::size_t counter = 0;
            for (auto const element : elements)
            {
                int const number_of_integration_points =
                    MeshToolsLib::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(), MeshLib::getIntegrationPointMetaDataSingleField(), MeshToolsLib::getNumberOfElementIntegrationPoints(), and MeshLib::IntegrationPoint.

Referenced by partitionProperties().

setNumberOfNodesInPartitions()

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

Definition at line 622 of file NodeWiseMeshPartitioner.cpp.

{
    auto const number_of_mesh_base_nodes = mesh.computeNumberOfBaseNodes();
    auto const number_of_mesh_all_nodes = mesh.getNumberOfNodes();
    for (auto& partition : partitions)
    {
        partition.number_of_regular_nodes = partition.nodes.size();
        partition.number_of_mesh_base_nodes = number_of_mesh_base_nodes;
        partition.number_of_mesh_all_nodes = number_of_mesh_all_nodes;
    }
}

References MeshLib::Mesh::computeNumberOfBaseNodes(), and MeshLib::Mesh::getNumberOfNodes().

Referenced by partitionMesh().

splitIntoBaseAndHigherOrderNodes()

std::pair< std::vector< MeshLib::Node const * >, std::vector< MeshLib::Node const * > > ApplicationUtils::splitIntoBaseAndHigherOrderNodes	(	std::vector< MeshLib::Node const * > const &	nodes,
		MeshLib::Mesh const &	mesh )

Definition at line 110 of file NodeWiseMeshPartitioner.cpp.

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

References MeshLib::Mesh::getElementsConnectedToNode().

Referenced by reorderNodesIntoBaseAndHigherOrderNodes().

toVTKGrid()

vtkSmartPointer< vtkUnstructuredGrid > ApplicationUtils::toVTKGrid

(

ComputeNaturalCoordsResult const &

result

)

Creates a mesh from the points described by the passed result.

The points 2n and 2n+1 will be connected by a line element that could represent an anchor in an FEM model for instance.

Definition at line 191 of file ComputeNaturalCoordsAlgorithm.h.

{
    INFO("converting points");
    auto const n_pts = result.natural_coords.rows();
    if (n_pts == 0)
    {
        OGS_FATAL(
            "No point was found in the mesh. Please check whether all anchors "
            "are within the model region.");
    }
    else if (n_pts == 1)
    {
        OGS_FATAL(
            "Only one point was found in the mesh. Please check whether all "
            "anchors are within the model region.");
    }
    else if (n_pts % 2 != 0)
    {
        // number should be even if multiplicity is ignored
        OGS_FATAL(
            "Number of points is not even. Anchors are believed to consist of "
            "a start and an end point.");
    }
 
    vtkNew<vtkUnstructuredGrid> grid;
 
    // Points ------------------------------------------------------------------
    vtkNew<vtkPoints> points;
    points->SetNumberOfPoints(n_pts);
 
    auto const& css = result.real_coords;
    for (Eigen::Index i = 0; i < css.rows(); ++i)
    {
        points->SetPoint(i, css(i, 0), css(i, 1), css(i, 2));
 
        if ((i % 2) == 1)
        {
            vtkNew<vtkLine> line;
            line->GetPointIds()->SetId(0, i - 1);
            line->GetPointIds()->SetId(1, i);
            grid->InsertNextCell(line->GetCellType(), line->GetPointIds());
        }
    }
 
    grid->SetPoints(points);
 
    // Point data --------------------------------------------------------------
    addPointData<double>(grid, "natural_coordinates", result.natural_coords);
    addPointData<std::size_t>(grid, "bulk_element_ids",
                              result.bulk_element_ids.cast<std::size_t>());
    addPointData<std::size_t>(grid, "point_cloud_node_ids",
                              result.point_cloud_node_ids.cast<std::size_t>());
 
    return grid;
}

References addPointData(), ApplicationUtils::ComputeNaturalCoordsResult::bulk_element_ids, INFO(), ApplicationUtils::ComputeNaturalCoordsResult::natural_coords, OGS_FATAL, ApplicationUtils::ComputeNaturalCoordsResult::point_cloud_node_ids, and ApplicationUtils::ComputeNaturalCoordsResult::real_coords.

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 1070 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 1154 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 1220 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 953 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(), writePropertyVector(), 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 928 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().

Referenced by writeProperties().

writePropertyVectorValues()

template<typename T >

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

Definition at line 921 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().