MeshLib Namespace Reference

Namespaces
namespace	detail
namespace	details
namespace	IO
namespace	views
	MeshLib specific, lazy, non-owning, non-mutating, composable range views.

Classes
class	CellRule
class	CoordinateSystem
	Coordinate systems. More...
struct	CoordinateSystemType
	Coordinate system type. More...
class	EdgeRule
class	Element
class	ElementCoordinatesMappingLocal
class	ElementSearch
	Element search class. More...
class	ElementStatus
class	FaceRule
class	HexRule
class	HexRule20
class	HexRule8
struct	IntegrationPointMetaData
struct	IntegrationPointWriter
class	LinearEdgeReturn
	Returns linear order edge. More...
class	LineRule
class	LineRule2
class	LineRule3
struct	Location
class	Mesh
class	MeshElementGrid
class	MeshSubset
	A subset of nodes on a single mesh. More...
class	Node
class	NodeAdjacencyTable
class	NodePartitionedMesh
	A subdomain mesh. More...
class	NodeSearch
	Node search class. More...
class	NoEdgeReturn
	Returns always null pointer. More...
class	PointRule1
	A 0d point element. More...
class	PrismRule
class	PrismRule15
class	PrismRule6
class	Properties
	Property manager on mesh items. Class Properties manages scalar, vector or matrix properties. For instance in groundwater flow porosity is a scalar property and permeabilty can be stored as a tensor property. Properties are assigned to mesh items, i.e. Node or Element objects. The createNewPropertyVector() method first creates a PropertyVector of template type T (scalar, vector or matrix). This class stores the PropertyVector, accessible by a combination of the name and the type of the mesh item (Node or Element). More...
class	PropertyVector
class	PropertyVector< T * >
class	PropertyVectorBase
class	PyramidRule
class	PyramidRule13
class	PyramidRule5
class	QuadraticEdgeReturn
	Returns quadratic order edge. More...
class	QuadRule
class	QuadRule4
class	QuadRule8
class	QuadRule9
class	TemplateElement
class	TetRule
class	TetRule10
class	TetRule4
class	TriRule
class	TriRule3
class	TriRule6
class	VertexRule
class	VtkMappedMeshSource
class	VtkMeshConverter
	Converter for VtkUnstructured Grids to OGS meshes. More...
class	VtkMeshNodalCoordinatesTemplate

Typedefs
using	RotationMatrix = Eigen::Matrix< double, 3u, 3u, Eigen::RowMajor >
using	AllElementTypes = std::tuple< Point, Line, Line3, Quad, Quad8, Quad9, Hex, Hex20, Tri, Tri6, Tet, Tet10, Prism, Prism15, Pyramid, Pyramid13 >
using	Hex = TemplateElement< MeshLib::HexRule8 >
using	Hex20 = TemplateElement< MeshLib::HexRule20 >
using	Line = TemplateElement< MeshLib::LineRule2 >
using	Line3 = TemplateElement< MeshLib::LineRule3 >
using	Point = TemplateElement< PointRule1 >
using	Prism = TemplateElement< MeshLib::PrismRule6 >
using	Prism15 = TemplateElement< MeshLib::PrismRule15 >
using	Pyramid = TemplateElement< MeshLib::PyramidRule5 >
using	Pyramid13 = TemplateElement< MeshLib::PyramidRule13 >
using	Quad = TemplateElement< MeshLib::QuadRule4 >
using	Quad8 = TemplateElement< MeshLib::QuadRule8 >
using	Quad9 = TemplateElement< MeshLib::QuadRule9 >
using	Tet = TemplateElement< MeshLib::TetRule4 >
using	Tet10 = TemplateElement< MeshLib::TetRule10 >
using	Tri = TemplateElement< MeshLib::TriRule3 >
using	Tri6 = TemplateElement< MeshLib::TriRule6 >

Enumerations
enum class	MeshItemType {   Node , Edge , Face , Cell ,   IntegrationPoint }
enum class	MeshElemType {   INVALID = 0 , POINT = 1 , LINE = 3 , QUAD = 9 ,   HEXAHEDRON = 12 , TRIANGLE = 5 , TETRAHEDRON = 10 , PRISM = 16 ,   PYRAMID = 14 }
	Types of mesh elements supported by OpenGeoSys. Values are from VTKCellType enum. More...
enum class	CellType {   INVALID = 0 , POINT1 = 1 , LINE2 = 2 , LINE3 = 3 ,   TRI3 = 4 , TRI6 = 5 , QUAD4 = 6 , QUAD8 = 7 ,   QUAD9 = 8 , TET4 = 9 , TET10 = 10 , HEX8 = 11 ,   HEX20 = 12 , HEX27 = 13 , PRISM6 = 14 , PRISM15 = 15 ,   PRISM18 = 16 , PYRAMID5 = 17 , PYRAMID13 = 18 , enum_length }
	Types of mesh elements supported by OpenGeoSys. More...
enum class	MeshQualityType {   INVALID = 0 , ELEMENTSIZE , SIZEDIFFERENCE , EDGERATIO ,   EQUIANGLESKEW , RADIUSEDGERATIO }
	Describes a mesh quality metric. More...
enum class	UseIntensityAs { ELEVATION , MATERIALS , DATAVECTOR , NONE }
	Selection of possible interpretations for intensities. More...

Functions
std::ostream &	operator<< (std::ostream &os, Element const &e)
bool	areNeighbors (Element const *const element, Element const *const other)
	Returns true if elem is a neighbour of this element and false otherwise.
bool	hasZeroVolume (MeshLib::Element const &element)
	Returns true if the element has zero length/area/volume.
MathLib::Point3d	getCenterOfGravity (MeshLib::Element const &element)
	Calculates the center of gravity for the mesh element.
std::pair< double, double >	computeSqrNodeDistanceRange (MeshLib::Element const &element, bool const check_allnodes=true)
	Compute the minimum and maximum node distances for this element.
std::pair< double, double >	computeSqrEdgeLengthRange (Element const &element)
	Compute the minimum and maximum squared edge length for this element.
bool	isPointInElementXY (MathLib::Point3d const &p, Element const &e)
unsigned	getNodeIDinElement (Element const &element, const Node *node)
	Returns the position of the given node in the node array of this element.
std::size_t	getNodeIndex (Element const &element, unsigned const idx)
MathLib::Point3d	getBulkElementPoint (MeshLib::CellType const bulk_element_cell_type, std::size_t const bulk_face_id, MathLib::WeightedPoint const &point_on_face)
MathLib::Point3d	getBulkElementPoint (MeshLib::Element const &bulk_element, std::size_t const bulk_face_id, MathLib::WeightedPoint const &point_on_face)
	Overload provided for convenience.
std::vector< Node * >	getBaseNodes (std::vector< Element * > const &elements)
Eigen::Vector3d	calculateNormalizedSurfaceNormal (MeshLib::Element const &surface_element, MeshLib::Element const &bulk_element)
std::vector< std::size_t >	findElementsWithinRadius (Element const &start_element, double const radius_squared)
std::ostream &	operator<< (std::ostream &os, MeshItemType const &t)
std::ostream &	operator<< (std::ostream &os, Location const &l)
static constexpr char const *	toString (const MeshItemType t)
	Returns a char array for a specific MeshItemType.
bool	operator< (const Location &left, const Location &right)
	Lexicographic order of Location.
std::vector< std::vector< Element const * > >	findElementsConnectedToNodes (Mesh const &mesh)
std::pair< double, double >	minMaxEdgeLength (std::vector< Element * > const &elements)
	Returns the minimum and maximum edge length for given elements.
PropertyVector< int > const *	materialIDs (Mesh const &mesh)
PropertyVector< int > *	materialIDs (Mesh &mesh)
PropertyVector< std::size_t > const *	bulkNodeIDs (Mesh const &mesh)
PropertyVector< std::size_t > const *	bulkElementIDs (Mesh const &mesh)
std::vector< std::vector< Node * > >	calculateNodesConnectedByElements (Mesh const &mesh)
bool	isBaseNode (Node const &node, std::vector< Element const * > const &elements_connected_to_node)
bool	operator== (Mesh const &a, Mesh const &b)
	Meshes are equal if their id's are equal.
bool	operator!= (Mesh const &a, Mesh const &b)
template<typename T >
bool	idsComparator (T const a, T const b)
std::string	MeshElemType2String (const MeshElemType t)
	Given a MeshElemType this returns the appropriate string.
std::string	MeshElemType2StringShort (const MeshElemType t)
	Given a MeshElemType this returns the appropriate string with a short name.
MeshElemType	String2MeshElemType (const std::string &s)
	Given a string of the shortened name of the element type, this returns the corresponding MeshElemType.
std::vector< MeshElemType >	getMeshElemTypes ()
	Returns a vector of all mesh element types.
std::vector< std::string >	getMeshElemTypeStringsShort ()
	Returns a vector of strings of mesh element types.
std::string	CellType2String (const CellType t)
	Given a MeshElemType this returns the appropriate string.
std::string	MeshQualityType2String (const MeshQualityType t)
MeshLib::MeshQualityType	String2MeshQualityType (std::string const &s)
template<typename Container , typename Predicate >
std::vector< std::size_t >	filter (Container const &container, Predicate const &p)
std::vector< Node * >	getUniqueNodes (std::vector< Element * > const &elements)
	Create a vector of unique nodes used by given elements.
std::vector< int >	getEndNodeIDRanks (std::size_t const n_global_nodes, std::vector< std::size_t > const &n_regular_base_nodes_at_rank, std::vector< std::size_t > const &n_regular_high_order_nodes_at_rank)
template<typename Function >
void	applyToPropertyVectors (Properties const &properties, Function f)
constexpr std::string_view	getBulkIDString (MeshItemType mesh_item_type)
template<typename T >
void	addPropertyToMesh (Mesh &mesh, std::string_view name, MeshItemType item_type, std::size_t number_of_components, std::vector< T > const &values)
std::unique_ptr< MeshLib::Mesh >	createMaterialIDsBasedSubMesh (MeshLib::Mesh const &mesh, std::vector< int > const &material_ids, std::string const &name_for_created_mesh)
std::unique_ptr< MeshLib::Mesh >	createMeshFromElementSelection (std::string mesh_name, std::vector< MeshLib::Element * > const &elements)
std::unique_ptr< Mesh >	createMeshFromElementSelection (std::string mesh_name, std::vector< Element * > const &elements)
std::vector< Node * >	copyNodeVector (const std::vector< Node * > &nodes)
	Creates a deep copy of a Node vector.
std::vector< Element * >	copyElementVector (std::vector< Element * > const &elements, std::vector< Node * > const &new_nodes, std::vector< std::size_t > const *const node_id_map)
template<typename E >
Element *	copyElement (Element const *const element, const std::vector< Node * > &nodes, std::vector< std::size_t > const *const id_map)
Element *	copyElement (Element const *const element, const std::vector< Node * > &nodes, std::vector< std::size_t > const *const id_map)
std::vector< Element * >	cloneElements (std::vector< Element * > const &elements)
	Clones a vector of elements using the Element::clone() function.
std::vector< Eigen::MatrixXd >	getElementRotationMatrices (int const space_dimension, int const mesh_dimension, std::vector< Element * > const &elements)
	Element rotation matrix computation.
std::vector< double >	getMaxiumElementEdgeLengths (std::vector< Element * > const &elements)
	Returns the maximum lengths of the edges for each element.
std::vector< MeshLib::Element * >	getMeshElementsForMaterialIDs (MeshLib::Mesh const &mesh, std::vector< int > const &selected_material_ids)
template<typename T >
PropertyVector< T > *	getOrCreateMeshProperty (Mesh &mesh, std::string const &property_name, MeshItemType const item_type, int const number_of_components)
int	getSpaceDimension (std::vector< Node * > const &nodes)
	Computes dimension of the embedding space containing the set of given points.
void	addIntegrationPointDataToMesh (MeshLib::Mesh &mesh, std::vector< std::unique_ptr< IntegrationPointWriter > > const &integration_point_writer)
IntegrationPointMetaData	getIntegrationPointMetaData (MeshLib::Properties const &properties, std::string const &name)
bool	is2DMeshOnRotatedVerticalPlane (Mesh const &mesh)
void	scaleMeshPropertyVector (MeshLib::Mesh &mesh, std::string const &property_name, double factor)
void	setMeshSpaceDimension (std::vector< std::unique_ptr< Mesh > > const &meshes)
std::pair< int, int >	getMPIRankAndSize (MPI_Comm const &mpi_comm)
std::pair< std::vector< Node * >, std::vector< Element * > >	copyNodesAndElements (std::vector< Element * > const &input_elements)
unsigned long	computeNumberOfRegularNodes (NodePartitionedMesh const *bulk_mesh, Mesh const *subdomain_mesh)
std::vector< std::size_t >	computeRegularBaseNodeGlobalNodeIDsOfSubDomainPartition (NodePartitionedMesh const *bulk_mesh, Mesh const *subdomain_mesh)
std::vector< std::size_t >	computeGhostBaseNodeGlobalNodeIDsOfSubDomainPartition (NodePartitionedMesh const *bulk_mesh, Mesh const *subdomain_mesh, std::vector< std::size_t > const &global_regular_base_node_ids)
std::vector< std::size_t >	computeNumberOfRegularBaseNodesAtRank (Mesh const *subdomain_mesh)
std::vector< std::size_t >	computeNumberOfRegularHigherOrderNodesAtRank (Mesh const *subdomain_mesh)
std::vector< std::size_t >	computeGlobalNodeIDsOfSubDomainPartition (NodePartitionedMesh const *bulk_mesh, Mesh const *subdomain_mesh)
unsigned long	getNumberOfGlobalNodes (Mesh const *subdomain_mesh)
std::unique_ptr< NodePartitionedMesh >	transformMeshToNodePartitionedMesh (NodePartitionedMesh const *const bulk_mesh, Mesh const *const subdomain_mesh)
	vtkStandardNewMacro (VtkMappedMeshSource) void VtkMappedMeshSource

Variables
static constexpr char const *	mesh_item_type_strings []
	Char array names for all of MeshItemType values.

Typedef Documentation

AllElementTypes

using MeshLib::AllElementTypes = typedef std::tuple<Point, Line, Line3, Quad, Quad8, Quad9, Hex, Hex20, Tri, Tri6, Tet, Tet10, Prism, Prism15, Pyramid, Pyramid13>

A list of types listing all mesh element types supported by OGS.

This type alias is intended for template metaprogramming et al., not for direct use/instantiation.

Definition at line 32 of file Elements.h.

Hex

using MeshLib::Hex = typedef TemplateElement<MeshLib::HexRule8>

Definition at line 25 of file Hex.h.

Hex20

using MeshLib::Hex20 = typedef TemplateElement<MeshLib::HexRule20>

Definition at line 26 of file Hex.h.

Line

using MeshLib::Line = typedef TemplateElement<MeshLib::LineRule2>

Definition at line 25 of file Line.h.

Line3

using MeshLib::Line3 = typedef TemplateElement<MeshLib::LineRule3>

Definition at line 26 of file Line.h.

Point

using MeshLib::Point = typedef TemplateElement<PointRule1>

Definition at line 20 of file Point.h.

Prism

using MeshLib::Prism = typedef TemplateElement<MeshLib::PrismRule6>

Definition at line 25 of file Prism.h.

Prism15

using MeshLib::Prism15 = typedef TemplateElement<MeshLib::PrismRule15>

Definition at line 26 of file Prism.h.

Pyramid

using MeshLib::Pyramid = typedef TemplateElement<MeshLib::PyramidRule5>

Definition at line 25 of file Pyramid.h.

Pyramid13

using MeshLib::Pyramid13 = typedef TemplateElement<MeshLib::PyramidRule13>

Definition at line 26 of file Pyramid.h.

Quad

using MeshLib::Quad = typedef TemplateElement<MeshLib::QuadRule4>

Definition at line 28 of file Quad.h.

Quad8

using MeshLib::Quad8 = typedef TemplateElement<MeshLib::QuadRule8>

Definition at line 29 of file Quad.h.

Quad9

using MeshLib::Quad9 = typedef TemplateElement<MeshLib::QuadRule9>

Definition at line 30 of file Quad.h.

RotationMatrix

using MeshLib::RotationMatrix = typedef Eigen::Matrix<double, 3u, 3u, Eigen::RowMajor>

Definition at line 24 of file ElementCoordinatesMappingLocal.h.

Tet

using MeshLib::Tet = typedef TemplateElement<MeshLib::TetRule4>

Definition at line 25 of file Tet.h.

Tet10

using MeshLib::Tet10 = typedef TemplateElement<MeshLib::TetRule10>

Definition at line 26 of file Tet.h.

Tri

using MeshLib::Tri = typedef TemplateElement<MeshLib::TriRule3>

Definition at line 26 of file Tri.h.

Tri6

using MeshLib::Tri6 = typedef TemplateElement<MeshLib::TriRule6>

Definition at line 27 of file Tri.h.

Enumeration Type Documentation

CellType

enum class MeshLib::CellType

strong

Types of mesh elements supported by OpenGeoSys.

Enumerator
INVALID
POINT1
LINE2
LINE3
TRI3
TRI6
QUAD4
QUAD8
QUAD9
TET4
TET10
HEX8
HEX20
HEX27
PRISM6
PRISM15
PRISM18
PYRAMID5
PYRAMID13
enum_length

Definition at line 42 of file MeshEnums.h.

{
    INVALID = 0,
    POINT1 = 1,
    LINE2 = 2,
    LINE3 = 3,
    TRI3 = 4,
    TRI6 = 5,
    QUAD4 = 6,
    QUAD8 = 7,
    QUAD9 = 8,
    TET4 = 9,
    TET10 = 10,
    HEX8 = 11,
    HEX20 = 12,
    HEX27 = 13,
    PRISM6 = 14,
    PRISM15 = 15,
    PRISM18 = 16,
    PYRAMID5 = 17,
    PYRAMID13 = 18,
    enum_length
};

MeshElemType

enum class MeshLib::MeshElemType

strong

Types of mesh elements supported by OpenGeoSys. Values are from VTKCellType enum.

Enumerator
INVALID
POINT
LINE
QUAD
HEXAHEDRON
TRIANGLE
TETRAHEDRON
PRISM
PYRAMID

Definition at line 26 of file MeshEnums.h.

{
    INVALID = 0,
    POINT = 1,
    LINE = 3,
    QUAD = 9,
    HEXAHEDRON = 12,
    TRIANGLE = 5,
    TETRAHEDRON = 10,
    PRISM = 16,
    PYRAMID = 14
};

MeshItemType

enum class MeshLib::MeshItemType

strong

Enumerator
Node
Edge
Face
Cell
IntegrationPoint

Definition at line 21 of file Location.h.

{ Node, Edge, Face, Cell, IntegrationPoint };

MeshQualityType

enum class MeshLib::MeshQualityType

strong

Describes a mesh quality metric.

Enumerator
INVALID
ELEMENTSIZE
SIZEDIFFERENCE
EDGERATIO
EQUIANGLESKEW
RADIUSEDGERATIO

Definition at line 69 of file MeshEnums.h.

{
    INVALID = 0,
    ELEMENTSIZE,
    SIZEDIFFERENCE,
    EDGERATIO,
    EQUIANGLESKEW,
    RADIUSEDGERATIO
};

UseIntensityAs

enum class MeshLib::UseIntensityAs

strong

Selection of possible interpretations for intensities.

Enumerator
ELEVATION
MATERIALS
DATAVECTOR
NONE

Definition at line 82 of file MeshEnums.h.

{
    ELEVATION,
    MATERIALS,
    DATAVECTOR,
    NONE
};

Function Documentation

addIntegrationPointDataToMesh()

void MeshLib::addIntegrationPointDataToMesh	(	MeshLib::Mesh &	mesh,
		std::vector< std::unique_ptr< IntegrationPointWriter > > const &	integration_point_writer
	)

Add integration point data the the mesh's properties.

Adds all integration point data arrays given by the input vector and the corresponding meta data as VTK's field data. Integration point data stored as field data (contrary to point or cell data), as plain double arrays. The data is supplemented with information in JSON format, which is stored as array of characters.

Definition at line 92 of file IntegrationPointWriter.cpp.

{
    std::vector<IntegrationPointMetaData> meta_data;
    meta_data.reserve(size(integration_point_writer));
    transform(cbegin(integration_point_writer), cend(integration_point_writer),
              back_inserter(meta_data),
              [&](auto const& ip_writer)
              { return addIntegrationPointData(mesh, *ip_writer); });
    if (!meta_data.empty())
    {
        addIntegrationPointMetaData(mesh, meta_data);
    }
}

References addIntegrationPointData(), and addIntegrationPointMetaData().

addPropertyToMesh()

template<typename T >

void MeshLib::addPropertyToMesh	(	Mesh &	mesh,
		std::string_view	name,
		MeshItemType	item_type,
		std::size_t	number_of_components,
		std::vector< T > const &	values
	)

Creates a new PropertyVector in the given mesh and initializes it with the given data. A PropertyVector with the same name must not exist.

Parameters

mesh	A Mesh the new ProperyVector will be created in.
name	A string that contains the name of the new PropertyVector.
item_type	One of the values MeshLib::MeshItemType::Cell or MeshLib::MeshItemType::Node that shows the association of the property values either to Element's / cells or Node's
number_of_components	the number of components of a property
values	A vector containing the values that are used for initialization.

Definition at line 34 of file addPropertyToMesh.h.

{
    if (item_type == MeshItemType::Node)
    {
        if (mesh.getNumberOfNodes() != values.size() / number_of_components)
        {
            OGS_FATAL(
                "Error number of nodes ({:d}) does not match the number of "
                "tuples ({:d}).",
                mesh.getNumberOfNodes(), values.size() / number_of_components);
        }
    }
    if (item_type == MeshItemType::Cell)
    {
        if (mesh.getNumberOfElements() != values.size() / number_of_components)
        {
            OGS_FATAL(
                "Error number of elements ({:d}) does not match the number of "
                "tuples ({:d}).",
                mesh.getNumberOfElements(),
                values.size() / number_of_components);
        }
    }
 
    auto* const property = mesh.getProperties().createNewPropertyVector<T>(
        name, item_type, number_of_components);
    if (!property)
    {
        OGS_FATAL("Error while creating PropertyVector '{:s}'.", name);
    }
    property->reserve(values.size());
    std::copy(values.cbegin(), values.cend(), std::back_inserter(*property));
}

References Cell, MeshLib::Properties::createNewPropertyVector(), MeshLib::Mesh::getNumberOfElements(), MeshLib::Mesh::getNumberOfNodes(), MeshLib::Mesh::getProperties(), Node, and OGS_FATAL.

Referenced by MeshToolsLib::addBulkIDPropertiesToMesh(), createMeshFromElementSelection(), ParameterLib::createRandomFieldMeshElementParameter(), and main().

applyToPropertyVectors()

template<typename Function >

void MeshLib::applyToPropertyVectors	(	Properties const &	properties,
		Function	f
	)

Applies a function of the form f(type, name) -> bool for each of the properties names. The type argument is used to call f<decltype(type)>(name). At least one of the functions must return the 'true' value, but at most one is executed.

areNeighbors()

bool MeshLib::areNeighbors	(	Element const *const	element,
		Element const *const	other
	)

Returns true if elem is a neighbour of this element and false otherwise.

Definition at line 106 of file Element.cpp.

{
    unsigned nNeighbors(element->getNumberOfNeighbors());
    for (unsigned i = 0; i < nNeighbors; i++)
    {
        if (element->getNeighbor(i) == other)
        {
            return true;
        }
    }
    return false;
}

References MeshLib::Element::getNeighbor(), and MeshLib::Element::getNumberOfNeighbors().

Referenced by MeshLib::Element::addNeighbor().

bulkElementIDs()

PropertyVector< std::size_t > const * MeshLib::bulkElementIDs

(

Mesh const &

mesh

)

Definition at line 290 of file Mesh.cpp.

{
    auto const& properties = mesh.getProperties();
    return properties.getPropertyVector<std::size_t>(
        MeshLib::getBulkIDString(MeshLib::MeshItemType::Cell),
        MeshLib::MeshItemType::Cell, 1);
}

References Cell, getBulkIDString(), MeshLib::Mesh::getProperties(), and MeshLib::Properties::getPropertyVector().

Referenced by ProcessLib::ConstraintDirichletBoundaryCondition::ConstraintDirichletBoundaryCondition(), and ProcessLib::DeactivatedSubdomainDirichlet::getEssentialBCValues().

bulkNodeIDs()

PropertyVector< std::size_t > const * MeshLib::bulkNodeIDs

(

Mesh const &

mesh

)

Definition at line 282 of file Mesh.cpp.

{
    auto const& properties = mesh.getProperties();
    return properties.getPropertyVector<std::size_t>(
        MeshLib::getBulkIDString(MeshLib::MeshItemType::Node),
        MeshLib::MeshItemType::Node, 1);
}

References getBulkIDString(), MeshLib::Mesh::getProperties(), MeshLib::Properties::getPropertyVector(), and Node.

Referenced by ProcessLib::ConstraintDirichletBoundaryCondition::ConstraintDirichletBoundaryCondition(), computeGhostBaseNodeGlobalNodeIDsOfSubDomainPartition(), computeNumberOfRegularNodes(), computeRegularBaseNodeGlobalNodeIDsOfSubDomainPartition(), ProcessLib::extractInnerAndOuterNodes(), ProcessLib::DeactivatedSubdomainDirichlet::getEssentialBCValues(), NumLib::MeshComponentMap::getSubset(), anonymous_namespace{IdentifySubdomainMesh.cpp}::identifySubdomainMeshElements(), and main().

calculateNodesConnectedByElements()

std::vector< std::vector< Node * > > MeshLib::calculateNodesConnectedByElements

(

Mesh const &

mesh

)

Computes the element-connectivity of nodes. Two nodes i and j are connected if they are shared by an element.

Definition at line 298 of file Mesh.cpp.

{
    auto const elements_connected_to_nodes = findElementsConnectedToNodes(mesh);
 
    std::vector<std::vector<Node*>> nodes_connected_by_elements;
    auto const& nodes = mesh.getNodes();
    nodes_connected_by_elements.resize(nodes.size());
    for (std::size_t i = 0; i < nodes.size(); ++i)
    {
        auto& adjacent_nodes = nodes_connected_by_elements[i];
        auto const node_id = nodes[i]->getID();
 
        // Get all elements, to which this node is connected.
        auto const& connected_elements = elements_connected_to_nodes[node_id];
 
        // And collect all elements' nodes.
        for (Element const* const element : connected_elements)
        {
            Node* const* const single_elem_nodes = element->getNodes();
            std::size_t const nnodes = element->getNumberOfNodes();
            for (std::size_t n = 0; n < nnodes; n++)
            {
                adjacent_nodes.push_back(single_elem_nodes[n]);
            }
        }
 
        // Make nodes unique and sorted by their ids.
        // This relies on the node's id being equivalent to it's address.
        std::sort(adjacent_nodes.begin(), adjacent_nodes.end(),
                  idsComparator<Node*>);
        auto const last =
            std::unique(adjacent_nodes.begin(), adjacent_nodes.end());
        adjacent_nodes.erase(last, adjacent_nodes.end());
    }
    return nodes_connected_by_elements;
}

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

Referenced by MeshLib::NodeAdjacencyTable::createTable(), MeshLib::NodePartitionedMesh::getMaximumNConnectedNodesToNode(), and main().

calculateNormalizedSurfaceNormal()

Eigen::Vector3d MeshLib::calculateNormalizedSurfaceNormal ( MeshLib::Element const &  surface_element, MeshLib::Element const &  bulk_element  )

inline

Definition at line 42 of file Utils.h.

{
    Eigen::Vector3d surface_element_normal;
 
    switch (surface_element.getDimension())
    {
        case 2:
            surface_element_normal =
                MeshLib::FaceRule::getSurfaceNormal(surface_element);
            break;
        case 1:
        {
            auto const bulk_element_normal =
                MeshLib::FaceRule::getSurfaceNormal(bulk_element);
            auto const& v0 = surface_element.getNode(0)->asEigenVector3d();
            auto const& v1 = surface_element.getNode(1)->asEigenVector3d();
            Eigen::Vector3d const edge_vector = v1 - v0;
            surface_element_normal = -bulk_element_normal.cross(edge_vector);
            break;
        }
        case 0:
        {
            assert(surface_element.getCellType() == CellType::POINT1);
            assert(bulk_element.getCellType() == CellType::LINE2 ||
                   bulk_element.getCellType() == CellType::LINE3);
 
            auto const& x = surface_element.getNode(0)->asEigenVector3d();
 
            // The start of the line element.
            auto const& a = bulk_element.getNode(0)->asEigenVector3d();
 
            // The end of the line element is the 2nd base node of the line,
            // which is the 2nd node.
            auto const& b = bulk_element.getNode(1)->asEigenVector3d();
 
            // x coincides either with the start or with the end of the line.
            // a + b - 2 * x evaluates to a - b or to b - a, respectively.
            // The formula assumes that the line is perfectly straight, even in
            // the LINE3 case.
            surface_element_normal = a + b - 2 * x;
        }
    }
 
    surface_element_normal.normalize();
    // At the moment (2018-04-26) the surface normal is not oriented
    // according to the right hand rule
    // for correct results it is necessary to multiply the normal with
    // -1
    surface_element_normal *= -1;
 
    return surface_element_normal;
}

References MathLib::Point3d::asEigenVector3d(), MeshLib::Element::getCellType(), MeshLib::Element::getDimension(), MeshLib::Element::getNode(), MeshLib::FaceRule::getSurfaceNormal(), LINE2, LINE3, and POINT1.

CellType2String()

std::string MeshLib::CellType2String

(

const CellType

t

)

Given a MeshElemType this returns the appropriate string.

Definition at line 157 of file MeshEnums.cpp.

{
#define RETURN_CELL_TYPE_STR(t, type) \
    if ((t) == CellType::type)        \
        return #type;
 
    RETURN_CELL_TYPE_STR(t, POINT1);
    RETURN_CELL_TYPE_STR(t, LINE2);
    RETURN_CELL_TYPE_STR(t, LINE3);
    RETURN_CELL_TYPE_STR(t, QUAD4);
    RETURN_CELL_TYPE_STR(t, QUAD8);
    RETURN_CELL_TYPE_STR(t, QUAD9);
    RETURN_CELL_TYPE_STR(t, HEX8);
    RETURN_CELL_TYPE_STR(t, HEX20);
    RETURN_CELL_TYPE_STR(t, HEX27);
    RETURN_CELL_TYPE_STR(t, TRI3);
    RETURN_CELL_TYPE_STR(t, TRI6);
    RETURN_CELL_TYPE_STR(t, TET4);
    RETURN_CELL_TYPE_STR(t, TET10);
    RETURN_CELL_TYPE_STR(t, PRISM6);
    RETURN_CELL_TYPE_STR(t, PRISM15);
    RETURN_CELL_TYPE_STR(t, PYRAMID5);
    RETURN_CELL_TYPE_STR(t, PYRAMID13);
 
    return "none";
 
#undef RETURN_CELL_TYPE_STR
}

References HEX20, HEX27, HEX8, LINE2, LINE3, POINT1, PRISM15, PRISM6, PYRAMID13, PYRAMID5, QUAD4, QUAD8, QUAD9, RETURN_CELL_TYPE_STR, TET10, TET4, TRI3, and TRI6.

Referenced by MeshToolsLib::computeElementVolumeNumerically(), computePointCloudNodes(), MeshToolsLib::convertToLinearMesh(), createElementCoordInterpolatorsForAllElementTypes(), createQuadraticElement(), getBulkElementPoint(), and MeshToolsLib::getNumberOfElementIntegrationPoints().

cloneElements()

std::vector< Element * > MeshLib::cloneElements

(

std::vector< Element * > const &

elements

)

Clones a vector of elements using the Element::clone() function.

Definition at line 117 of file DuplicateMeshComponents.cpp.

{
    std::vector<Element*> cloned_elements;
    cloned_elements.reserve(elements.size());
    std::transform(begin(elements), end(elements),
                   std::back_inserter(cloned_elements),
                   [](Element const* const e) { return e->clone(); });
    return cloned_elements;
}

References MeshLib::Element::clone().

Referenced by MeshGeoToolsLib::constructAdditionalMeshesFromGeometries(), copyNodesAndElements(), ProcessLib::createDeactivatedSubdomainMesh(), and createMaterialIDsBasedSubMesh().

computeGhostBaseNodeGlobalNodeIDsOfSubDomainPartition()

std::vector< std::size_t > MeshLib::computeGhostBaseNodeGlobalNodeIDsOfSubDomainPartition	(	NodePartitionedMesh const *	bulk_mesh,
		Mesh const *	subdomain_mesh,
		std::vector< std::size_t > const &	global_regular_base_node_ids
	)

Definition at line 172 of file transformMeshToNodePartitionedMesh.cpp.

{
    // in the following information exchange with other ranks is required
    MPI_Comm const mpi_comm = MPI_COMM_WORLD;
    auto const [mpi_comm_rank, mpi_comm_size] = getMPIRankAndSize(mpi_comm);
 
    // count regular nodes that is the offset in the mapping
    auto const local_bulk_node_ids_for_subdomain =
        *bulkNodeIDs(*subdomain_mesh);
 
    // compute mapping subdomain ghost node id <-> bulk ghost node id
    std::vector<std::size_t> subdomain_node_id_to_bulk_node_id;
    for (auto const id : subdomain_mesh->getNodes() | MeshLib::views::ids)
    {
        if (!isRegularNode(*bulk_mesh, local_bulk_node_ids_for_subdomain, id))
        {
            auto const bulk_node_id = local_bulk_node_ids_for_subdomain[id];
            // this puts the global bulk node id at pos:
            // subdomain_node->getID() - number_of_regular_nodes
            subdomain_node_id_to_bulk_node_id.push_back(
                bulk_mesh->getGlobalNodeID(bulk_node_id));
        }
    }
 
    // send ids of bulk ghost nodes belonging to the subdomain mesh to all
    // other ranks and at the same time receive from all other ranks
    // first send the sizes to all other to are able to allocate buffer
    auto const size = subdomain_node_id_to_bulk_node_id.size();
    std::size_t global_number_of_subdomain_node_id_to_bulk_node_id = 0;
    MPI_Allreduce(&size, &global_number_of_subdomain_node_id_to_bulk_node_id, 1,
                  MPI_UNSIGNED_LONG, MPI_SUM, mpi_comm);
 
    DBUG("[{}] global_number_of_subdomain_node_id_to_bulk_node_id: '{}' ",
         subdomain_mesh->getName(),
         global_number_of_subdomain_node_id_to_bulk_node_id);
 
    std::vector<int> numbers_of_ids_at_ranks(mpi_comm_size);
    MPI_Allgather(&size, 1, MPI_INT, numbers_of_ids_at_ranks.data(), 1, MPI_INT,
                  mpi_comm);
    std::vector<int> offsets;
    offsets.push_back(0);
    std::partial_sum(begin(numbers_of_ids_at_ranks),
                     end(numbers_of_ids_at_ranks), back_inserter(offsets));
    std::vector<std::size_t> ghost_node_ids_of_all_ranks(
        global_number_of_subdomain_node_id_to_bulk_node_id);
    MPI_Allgatherv(subdomain_node_id_to_bulk_node_id.data(), /* sendbuf */
                   size,                                     /* sendcount */
                   MPI_UNSIGNED_LONG,                        /* sendtype */
                   ghost_node_ids_of_all_ranks.data(),       /* recvbuf (out) */
                   numbers_of_ids_at_ranks.data(),           /* recvcounts */
                   offsets.data(),                           /* displs */
                   MPI_UNSIGNED_LONG,                        /* recvtype */
                   mpi_comm);
 
    // construct a map for fast search of local bulk node ids
    std::map<std::size_t, std::size_t> global_to_local_bulk_node_ids;
    for (auto const id : bulk_mesh->getNodes() | MeshLib::views::ids)
    {
        if (!bulk_mesh->isGhostNode(id))
        {
            global_to_local_bulk_node_ids[bulk_mesh->getGlobalNodeID(id)] = id;
        }
    }
 
    // construct a map for fast search of local sub-domain node ids
    std::map<std::size_t, std::size_t> local_subdomain_node_ids;
    for (auto const id : subdomain_mesh->getNodes() | MeshLib::views::ids)
    {
        local_subdomain_node_ids[local_bulk_node_ids_for_subdomain[id]] = id;
    }
 
    std::vector<std::size_t> local_subdomain_node_ids_of_all_ranks(
        global_number_of_subdomain_node_id_to_bulk_node_id,
        std::numeric_limits<std::size_t>::max());
    // search in all ranks within the bulk ids for the corresponding id
    for (int rank = 0; rank < mpi_comm_size; ++rank)
    {
        if (rank == mpi_comm_rank)
        {
            continue;
        }
        for (int i = offsets[rank]; i < offsets[rank + 1]; ++i)
        {
            auto it = global_to_local_bulk_node_ids.find(
                ghost_node_ids_of_all_ranks[i]);
            if (it == global_to_local_bulk_node_ids.end())
            {
                continue;
            }
            auto const local_bulk_node_id = it->second;
            local_subdomain_node_ids_of_all_ranks[i] =
                global_regular_base_node_ids
                    [local_subdomain_node_ids.find(local_bulk_node_id)->second];
            DBUG(
                "[{}] found global subdomain node id: '{}' for global bulk "
                "node id {} ",
                subdomain_mesh->getName(),
                local_subdomain_node_ids_of_all_ranks[i],
                ghost_node_ids_of_all_ranks[i]);
        }
    }
 
    // send the computed ids back
    std::vector<std::size_t> computed_global_ids_for_subdomain_ghost_nodes(
        global_number_of_subdomain_node_id_to_bulk_node_id);
    MPI_Allreduce(
        local_subdomain_node_ids_of_all_ranks.data(), /* sendbuf */
        computed_global_ids_for_subdomain_ghost_nodes
            .data(),                                        /* recvbuf (out) */
        global_number_of_subdomain_node_id_to_bulk_node_id, /* sendcount */
        MPI_UNSIGNED_LONG,                                  /* sendtype */
        MPI_MAX,                                            /* operation */
        mpi_comm);
 
    std::vector<std::size_t> global_ids_for_subdomain_ghost_nodes(
        computed_global_ids_for_subdomain_ghost_nodes.begin() +
            offsets[mpi_comm_rank],
        computed_global_ids_for_subdomain_ghost_nodes.begin() +
            offsets[mpi_comm_rank + 1]);
    return global_ids_for_subdomain_ghost_nodes;
}

References bulkNodeIDs(), DBUG(), MeshLib::NodePartitionedMesh::getGlobalNodeID(), getMPIRankAndSize(), MeshLib::Mesh::getName(), MeshLib::Mesh::getNodes(), MeshLib::views::ids, and MeshLib::NodePartitionedMesh::isGhostNode().

Referenced by computeGlobalNodeIDsOfSubDomainPartition().

computeGlobalNodeIDsOfSubDomainPartition()

std::vector< std::size_t > MeshLib::computeGlobalNodeIDsOfSubDomainPartition	(	NodePartitionedMesh const *	bulk_mesh,
		Mesh const *	subdomain_mesh
	)

Definition at line 350 of file transformMeshToNodePartitionedMesh.cpp.

{
    auto global_regular_base_node_ids =
        computeRegularBaseNodeGlobalNodeIDsOfSubDomainPartition(bulk_mesh,
                                                                subdomain_mesh);
    auto const local_ids_for_subdomain_ghost_nodes =
        computeGhostBaseNodeGlobalNodeIDsOfSubDomainPartition(
            bulk_mesh, subdomain_mesh, global_regular_base_node_ids);
 
    // At the moment higher order bulk meshes aren't handled correctly.
    // If it should become necessary in the future, the necessary things must be
    // implemented at this point.
    /*
    auto const regular_higher_order_node_global_node_ids =
        computeRegularHigherOrderNodeGlobalNodeIDsofSubDomainPartition(
            bulk_mesh, subdomain_mesh);
    auto const ghost_higher_order_node_global_node_ids =
        computeGhostHigherOrderNodeGlobalNodeIDsofSubDomainPartition(
            bulk_mesh, subdomain_mesh);
    */
 
    std::vector<std::size_t> global_node_ids(
        std::move(global_regular_base_node_ids));
    global_node_ids.insert(global_node_ids.end(),
                           local_ids_for_subdomain_ghost_nodes.begin(),
                           local_ids_for_subdomain_ghost_nodes.end());
 
    return global_node_ids;
}

References computeGhostBaseNodeGlobalNodeIDsOfSubDomainPartition(), and computeRegularBaseNodeGlobalNodeIDsOfSubDomainPartition().

Referenced by transformMeshToNodePartitionedMesh().

computeNumberOfRegularBaseNodesAtRank()

std::vector< std::size_t > MeshLib::computeNumberOfRegularBaseNodesAtRank

(

Mesh const *

subdomain_mesh

)

Definition at line 297 of file transformMeshToNodePartitionedMesh.cpp.

{
    auto const number_of_regular_base_nodes =
        subdomain_mesh->computeNumberOfBaseNodes();
 
    MPI_Comm const mpi_comm = MPI_COMM_WORLD;
    auto const [mpi_comm_rank, mpi_comm_size] = getMPIRankAndSize(mpi_comm);
 
    std::vector<std::size_t> gathered_number_of_regular_base_nodes(
        mpi_comm_size);
    MPI_Allgather(&number_of_regular_base_nodes, 1, MPI_UNSIGNED_LONG,
                  gathered_number_of_regular_base_nodes.data(), 1,
                  MPI_UNSIGNED_LONG, mpi_comm);
 
    std::vector<std::size_t> numbers_of_regular_base_nodes_at_rank;
    numbers_of_regular_base_nodes_at_rank.push_back(0);
    std::partial_sum(begin(gathered_number_of_regular_base_nodes),
                     end(gathered_number_of_regular_base_nodes),
                     back_inserter(numbers_of_regular_base_nodes_at_rank));
 
    return numbers_of_regular_base_nodes_at_rank;
}

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

Referenced by transformMeshToNodePartitionedMesh().

computeNumberOfRegularHigherOrderNodesAtRank()

std::vector< std::size_t > MeshLib::computeNumberOfRegularHigherOrderNodesAtRank

(

Mesh const *

subdomain_mesh

)

Definition at line 322 of file transformMeshToNodePartitionedMesh.cpp.

{
    // in the following information exchange with other ranks is required
    MPI_Comm const mpi_comm = MPI_COMM_WORLD;
    auto [mpi_comm_rank, mpi_comm_size] = getMPIRankAndSize(mpi_comm);
 
    auto const number_of_regular_base_nodes =
        subdomain_mesh->computeNumberOfBaseNodes();
 
    std::vector<std::size_t> gathered_number_of_regular_higher_order_nodes(
        mpi_comm_size);
    auto const number_of_regular_higher_order_nodes =
        subdomain_mesh->getNumberOfNodes() - number_of_regular_base_nodes;
    MPI_Allgather(&number_of_regular_higher_order_nodes, 1, MPI_UNSIGNED_LONG,
                  gathered_number_of_regular_higher_order_nodes.data(), 1,
                  MPI_UNSIGNED_LONG, mpi_comm);
 
    std::vector<std::size_t> numbers_of_regular_higher_order_nodes_at_rank;
    numbers_of_regular_higher_order_nodes_at_rank.push_back(0);
    std::partial_sum(
        begin(gathered_number_of_regular_higher_order_nodes),
        end(gathered_number_of_regular_higher_order_nodes),
        back_inserter(numbers_of_regular_higher_order_nodes_at_rank));
 
    return numbers_of_regular_higher_order_nodes_at_rank;
}

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

Referenced by transformMeshToNodePartitionedMesh().

computeNumberOfRegularNodes()

unsigned long MeshLib::computeNumberOfRegularNodes	(	NodePartitionedMesh const *	bulk_mesh,
		Mesh const *	subdomain_mesh
	)

Definition at line 97 of file transformMeshToNodePartitionedMesh.cpp.

{
    auto const subdomain_nodes = subdomain_mesh->getNodes();
    auto const local_bulk_node_ids_for_subdomain =
        *bulkNodeIDs(*subdomain_mesh);
    auto const subdomain_node_ids =
        subdomain_nodes | MeshLib::views::ids | ranges::to<std::vector>;
    unsigned long const number_of_regular_nodes =
        std::count_if(subdomain_node_ids.begin(), subdomain_node_ids.end(),
                      std::bind_front(isRegularNode, *bulk_mesh,
                                      local_bulk_node_ids_for_subdomain));
 
    DBUG("[{}] number of regular nodes: {}", subdomain_mesh->getName(),
         number_of_regular_nodes);
    return number_of_regular_nodes;
}

References bulkNodeIDs(), DBUG(), MeshLib::Mesh::getName(), MeshLib::Mesh::getNodes(), and MeshLib::views::ids.

Referenced by computeRegularBaseNodeGlobalNodeIDsOfSubDomainPartition(), and transformMeshToNodePartitionedMesh().

computeRegularBaseNodeGlobalNodeIDsOfSubDomainPartition()

std::vector< std::size_t > MeshLib::computeRegularBaseNodeGlobalNodeIDsOfSubDomainPartition	(	NodePartitionedMesh const *	bulk_mesh,
		Mesh const *	subdomain_mesh
	)

Definition at line 116 of file transformMeshToNodePartitionedMesh.cpp.

{
    // create/fill global nodes information of the sub-domain partition
    auto const subdomain_nodes = subdomain_mesh->getNodes();
    auto const local_bulk_node_ids_for_subdomain =
        *bulkNodeIDs(*subdomain_mesh);
 
    // global node ids for the sub-domain:
    // | regular base node ids | ghost base node ids | regular higher
    // order node ids | ghost higher order node ids |
    // | partition offset + local ids | regular node ids from other
    // partitions |
 
    // In order to compute the global node ids for the subdomain mesh nodes the
    // sum of the number of regular nodes of the previous partitions is required
    // first.
    // Count the local regular base nodes to compute offset for other subsequent
    // partitions
    std::size_t const number_of_regular_nodes =
        computeNumberOfRegularNodes(bulk_mesh, subdomain_mesh);
 
    // in the following information exchange with other ranks is required
    MPI_Comm mpi_comm = MPI_COMM_WORLD;
    auto const [mpi_comm_rank, mpi_comm_size] = getMPIRankAndSize(mpi_comm);
 
    // send own number of regular nodes to all others
    std::vector<std::size_t> gathered_number_of_regular_nodes(mpi_comm_size);
    MPI_Allgather(&number_of_regular_nodes, 1, MPI_UNSIGNED_LONG,
                  gathered_number_of_regular_nodes.data(), 1, MPI_UNSIGNED_LONG,
                  mpi_comm);
    // compute the 'offset' in the global_node_ids
    std::vector<std::size_t> numbers_of_regular_nodes_at_rank;
    numbers_of_regular_nodes_at_rank.push_back(0);
    std::partial_sum(begin(gathered_number_of_regular_nodes),
                     end(gathered_number_of_regular_nodes),
                     back_inserter(numbers_of_regular_nodes_at_rank));
 
    // add the offset to the partitioned-owned subdomain
    std::vector<std::size_t> subdomain_global_node_ids;
    subdomain_global_node_ids.reserve(subdomain_nodes.size());
    auto const partition_offset =
        numbers_of_regular_nodes_at_rank[mpi_comm_rank];
    DBUG("[{}] partition offset: {}", subdomain_mesh->getName(),
         partition_offset);
    // set the global id for the regular base nodes
    for (auto const id : subdomain_nodes | MeshLib::views::ids)
    {
        if (isRegularNode(*bulk_mesh, local_bulk_node_ids_for_subdomain, id))
        {
            subdomain_global_node_ids.emplace_back(partition_offset + id);
        }
    }
    return subdomain_global_node_ids;
}

References bulkNodeIDs(), computeNumberOfRegularNodes(), DBUG(), getMPIRankAndSize(), MeshLib::Mesh::getName(), MeshLib::Mesh::getNodes(), and MeshLib::views::ids.

Referenced by computeGlobalNodeIDsOfSubDomainPartition().

computeSqrEdgeLengthRange()

std::pair< double, double > MeshLib::computeSqrEdgeLengthRange

(

Element const &

element

)

Compute the minimum and maximum squared edge length for this element.

Definition at line 156 of file Element.cpp.

{
    double min = std::numeric_limits<double>::max();
    double max = 0;
    const unsigned nEdges(element.getNumberOfEdges());
    for (unsigned i = 0; i < nEdges; i++)
    {
        const double dist(MathLib::sqrDist(*element.getEdgeNode(i, 0),
                                           *element.getEdgeNode(i, 1)));
        min = std::min(dist, min);
        max = std::max(dist, max);
    }
    return {min, max};
}

References MeshLib::Element::getEdgeNode(), MeshLib::Element::getNumberOfEdges(), and MathLib::sqrDist().

Referenced by getMaxiumElementEdgeLengths(), and minMaxEdgeLength().

computeSqrNodeDistanceRange()

std::pair< double, double > MeshLib::computeSqrNodeDistanceRange	(	MeshLib::Element const &	element,
		bool const	check_allnodes
	)

Compute the minimum and maximum node distances for this element.

Definition at line 136 of file Element.cpp.

{
    double min = std::numeric_limits<double>::max();
    double max = 0;
    const unsigned nnodes = check_allnodes ? element.getNumberOfNodes()
                                           : element.getNumberOfBaseNodes();
    for (unsigned i = 0; i < nnodes; i++)
    {
        for (unsigned j = i + 1; j < nnodes; j++)
        {
            const double dist(
                MathLib::sqrDist(*element.getNode(i), *element.getNode(j)));
            min = std::min(dist, min);
            max = std::max(dist, max);
        }
    }
    return {min, max};
}

References MeshLib::Element::getNode(), MeshLib::Element::getNumberOfBaseNodes(), MeshLib::Element::getNumberOfNodes(), and MathLib::sqrDist().

Referenced by MeshGeoToolsLib::HeuristicSearchLength::HeuristicSearchLength(), and MeshGeoToolsLib::snapPointToElementNode().

copyElement() [1/2]

template<typename E >

Element * MeshLib::copyElement	(	Element const *const	element,
		const std::vector< Node * > &	nodes,
		std::vector< std::size_t > const *const	id_map
	)

Copies an element without change, using the nodes vector from the result mesh.

Copies an element without change, using the nodes vector from the result mesh and an optional mapping from the nodes the 'old' elements.

Definition at line 50 of file DuplicateMeshComponents.cpp.

{
    unsigned const number_of_element_nodes(element->getNumberOfNodes());
    auto** new_nodes = new Node*[number_of_element_nodes];
    if (id_map)
    {
        for (unsigned i = 0; i < number_of_element_nodes; ++i)
        {
            new_nodes[i] = nodes[(*id_map)[element->getNode(i)->getID()]];
        }
    }
    else
    {
        for (unsigned i = 0; i < number_of_element_nodes; ++i)
        {
            new_nodes[i] = nodes[element->getNode(i)->getID()];
        }
    }
    return new E(new_nodes);
}

References MathLib::Point3dWithID::getID(), MeshLib::Element::getNode(), and MeshLib::Element::getNumberOfNodes().

Referenced by MeshToolsLib::MeshRevision::simplifyMesh().

copyElement() [2/2]

Element * MeshLib::copyElement	(	Element const *const	element,
		const std::vector< Node * > &	nodes,
		std::vector< std::size_t > const *const	id_map = nullptr
	)

Copies an element without change, using the nodes vector from the result mesh and an optional mapping from the nodes the 'old' elements.

Definition at line 73 of file DuplicateMeshComponents.cpp.

{
    switch (element->getCellType())
    {
        case CellType::LINE2:
            return copyElement<Line>(element, nodes, id_map);
        case CellType::LINE3:
            return copyElement<Line3>(element, nodes, id_map);
        case CellType::TRI3:
            return copyElement<Tri>(element, nodes, id_map);
        case CellType::TRI6:
            return copyElement<Tri6>(element, nodes, id_map);
        case CellType::QUAD4:
            return copyElement<Quad>(element, nodes, id_map);
        case CellType::QUAD8:
            return copyElement<Quad8>(element, nodes, id_map);
        case CellType::QUAD9:
            return copyElement<Quad9>(element, nodes, id_map);
        case CellType::TET4:
            return copyElement<Tet>(element, nodes, id_map);
        case CellType::TET10:
            return copyElement<Tet10>(element, nodes, id_map);
        case CellType::HEX8:
            return copyElement<Hex>(element, nodes, id_map);
        case CellType::HEX20:
            return copyElement<Hex20>(element, nodes, id_map);
        case CellType::PYRAMID5:
            return copyElement<Pyramid>(element, nodes, id_map);
        case CellType::PYRAMID13:
            return copyElement<Pyramid13>(element, nodes, id_map);
        case CellType::PRISM6:
            return copyElement<Prism>(element, nodes, id_map);
        case CellType::PRISM15:
            return copyElement<Prism15>(element, nodes, id_map);
        default:
        {
            ERR("Error: Unknown cell type.");
            return nullptr;
        }
    }
}

References ERR(), MeshLib::Element::getCellType(), HEX20, HEX8, LINE2, LINE3, PRISM15, PRISM6, PYRAMID13, PYRAMID5, QUAD4, QUAD8, QUAD9, TET10, TET4, TRI3, and TRI6.

copyElementVector()

std::vector< Element * > MeshLib::copyElementVector	(	std::vector< Element * > const &	elements,
		std::vector< Node * > const &	new_nodes,
		std::vector< std::size_t > const *const	node_id_map = nullptr
	)

Creates a deep copy of an element vector using the given Node vector.

Parameters

elements	The element vector that should be duplicated.
new_nodes	The new node vector used for the duplicated element vector.
node_id_map	An optional mapping from the nodes the 'old' elements based on to the new nodes. This should be consistent with the original node vector.

Returns

A deep copy of the elements vector using the new nodes vector.

Definition at line 33 of file DuplicateMeshComponents.cpp.

{
    std::vector<Element*> new_elements;
    new_elements.reserve(elements.size());
    std::transform(elements.begin(), elements.end(),
                   std::back_inserter(new_elements),
                   [&new_nodes, &node_id_map](auto const& element)
                   { return copyElement(element, new_nodes, node_id_map); });
    return new_elements;
}

Referenced by ProcessLib::LIE::PostProcessTool::PostProcessTool(), MeshToolsLib::addLayerToMesh(), MeshGeoToolsLib::appendLinesAlongPolylines(), LayeredVolume::createRasterLayers(), MeshToolsLib::BoundaryExtraction::getBoundaryElementsAsMesh(), MeshToolsLib::MeshSurfaceExtraction::getMeshSurface(), main(), MeshToolsLib::removeElements(), and MeshToolsLib::removeNodes().

copyNodesAndElements()

std::pair< std::vector< Node * >, std::vector< Element * > > MeshLib::copyNodesAndElements

(

std::vector< Element * > const &

input_elements

)

Definition at line 53 of file transformMeshToNodePartitionedMesh.cpp.

{
    auto elements = cloneElements(input_elements);
 
    // original node ids to newly created nodes.
    std::unordered_map<std::size_t, Node*> id_node_hash_map;
    id_node_hash_map.reserve(
        elements.size());  // There will be at least one node per element.
 
    for (auto& e : elements)
    {
        // For each node find a cloned node in map or create if there is none.
        unsigned const n_nodes = e->getNumberOfNodes();
        for (unsigned i = 0; i < n_nodes; ++i)
        {
            Node const* n = e->getNode(i);
            auto const it = id_node_hash_map.find(n->getID());
            if (it == id_node_hash_map.end())
            {
                auto new_node_in_map = id_node_hash_map[n->getID()] =
                    new Node(*n);
                e->setNode(i, new_node_in_map);
            }
            else
            {
                e->setNode(i, it->second);
            }
        }
    }
 
    std::map<std::size_t, Node*> nodes_map;
    for (auto const& n : id_node_hash_map)
    {
        nodes_map[n.first] = n.second;
    }
 
    // Copy the unique nodes pointers.
    auto element_nodes =
        nodes_map | ranges::views::values | ranges::to<std::vector>;
 
    return std::make_pair(element_nodes, elements);
}

References cloneElements(), and MathLib::Point3dWithID::getID().

Referenced by transformMeshToNodePartitionedMesh().

copyNodeVector()

std::vector< Node * > MeshLib::copyNodeVector

(

const std::vector< Node * > &

nodes

)

Creates a deep copy of a Node vector.

Definition at line 21 of file DuplicateMeshComponents.cpp.

{
    const std::size_t nNodes(nodes.size());
    std::vector<Node*> new_nodes;
    new_nodes.reserve(nNodes);
    for (std::size_t k = 0; k < nNodes; ++k)
    {
        new_nodes.push_back(new Node(nodes[k]->data(), new_nodes.size()));
    }
    return new_nodes;
}

Referenced by ProcessLib::LIE::PostProcessTool::PostProcessTool(), MeshToolsLib::addLayerToMesh(), MeshGeoToolsLib::appendLinesAlongPolylines(), MeshToolsLib::createQuadraticOrderMesh(), LayeredVolume::createRasterLayers(), main(), MeshToolsLib::removeElements(), and MeshToolsLib::removeNodes().

createMaterialIDsBasedSubMesh()

std::unique_ptr< MeshLib::Mesh > MeshLib::createMaterialIDsBasedSubMesh	(	MeshLib::Mesh const &	mesh,
		std::vector< int > const &	material_ids,
		std::string const &	name_for_created_mesh
	)

Definition at line 24 of file createMaterialIDsBasedSubMesh.cpp.

{
    auto const elements =
        MeshLib::getMeshElementsForMaterialIDs(mesh, material_ids);
    return MeshLib::createMeshFromElementSelection(
        name_for_created_mesh, MeshLib::cloneElements(elements));
}

References cloneElements(), createMeshFromElementSelection(), and getMeshElementsForMaterialIDs().

Referenced by parseOutputMeshConfig().

createMeshFromElementSelection() [1/2]

std::unique_ptr< Mesh > MeshLib::createMeshFromElementSelection	(	std::string	mesh_name,
		std::vector< Element * > const &	elements
	)

Creates a new mesh from a vector of elements.

Note

The elements are owned by the returned mesh object as well as the nodes and will be destructed together with the mesh.

Definition at line 28 of file createMeshFromElementSelection.cpp.

{
    auto ids_vector = views::ids | ranges::to<std::vector>();
 
    DBUG("Found {:d} elements in the mesh", elements.size());
 
    // Store bulk element ids for each of the new elements.
    auto bulk_element_ids = elements | ids_vector;
 
    // original node ids to newly created nodes.
    std::unordered_map<std::size_t, MeshLib::Node*> id_node_hash_map;
    id_node_hash_map.reserve(
        elements.size());  // There will be at least one node per element.
 
    for (auto& e : elements)
    {
        // For each node find a cloned node in map or create if there is none.
        unsigned const n_nodes = e->getNumberOfNodes();
        for (unsigned i = 0; i < n_nodes; ++i)
        {
            const MeshLib::Node* n = e->getNode(i);
            auto const it = id_node_hash_map.find(n->getID());
            if (it == id_node_hash_map.end())
            {
                auto new_node_in_map = id_node_hash_map[n->getID()] =
                    new MeshLib::Node(*n);
                e->setNode(i, new_node_in_map);
            }
            else
            {
                e->setNode(i, it->second);
            }
        }
    }
 
    std::map<std::size_t, MeshLib::Node*> nodes_map;
    for (const auto& n : id_node_hash_map)
    {
        nodes_map[n.first] = n.second;
    }
 
    // Copy the unique nodes pointers.
    auto element_nodes =
        nodes_map | ranges::views::values | ranges::to<std::vector>;
 
    // Store bulk node ids for each of the new nodes.
    auto bulk_node_ids =
        nodes_map | ranges::views::keys | ranges::to<std::vector>;
 
    auto mesh = std::make_unique<MeshLib::Mesh>(
        std::move(mesh_name), std::move(element_nodes), std::move(elements));
    assert(mesh != nullptr);
 
    addPropertyToMesh(*mesh, getBulkIDString(MeshLib::MeshItemType::Cell),
                      MeshLib::MeshItemType::Cell, 1, bulk_element_ids);
    addPropertyToMesh(*mesh, getBulkIDString(MeshLib::MeshItemType::Node),
                      MeshLib::MeshItemType::Node, 1, bulk_node_ids);
 
    return mesh;
}

References addPropertyToMesh(), Cell, DBUG(), getBulkIDString(), MathLib::Point3dWithID::getID(), MeshLib::views::ids, and Node.

Referenced by ProcessLib::createDeactivatedSubdomainMesh(), and createMaterialIDsBasedSubMesh().

createMeshFromElementSelection() [2/2]

std::unique_ptr< MeshLib::Mesh > MeshLib::createMeshFromElementSelection	(	std::string	mesh_name,
		std::vector< Element * > const &	elements
	)

Creates a new mesh from a vector of elements.

Note

The elements are owned by the returned mesh object as well as the nodes and will be destructed together with the mesh.

Definition at line 28 of file createMeshFromElementSelection.cpp.

{
    auto ids_vector = views::ids | ranges::to<std::vector>();
 
    DBUG("Found {:d} elements in the mesh", elements.size());
 
    // Store bulk element ids for each of the new elements.
    auto bulk_element_ids = elements | ids_vector;
 
    // original node ids to newly created nodes.
    std::unordered_map<std::size_t, MeshLib::Node*> id_node_hash_map;
    id_node_hash_map.reserve(
        elements.size());  // There will be at least one node per element.
 
    for (auto& e : elements)
    {
        // For each node find a cloned node in map or create if there is none.
        unsigned const n_nodes = e->getNumberOfNodes();
        for (unsigned i = 0; i < n_nodes; ++i)
        {
            const MeshLib::Node* n = e->getNode(i);
            auto const it = id_node_hash_map.find(n->getID());
            if (it == id_node_hash_map.end())
            {
                auto new_node_in_map = id_node_hash_map[n->getID()] =
                    new MeshLib::Node(*n);
                e->setNode(i, new_node_in_map);
            }
            else
            {
                e->setNode(i, it->second);
            }
        }
    }
 
    std::map<std::size_t, MeshLib::Node*> nodes_map;
    for (const auto& n : id_node_hash_map)
    {
        nodes_map[n.first] = n.second;
    }
 
    // Copy the unique nodes pointers.
    auto element_nodes =
        nodes_map | ranges::views::values | ranges::to<std::vector>;
 
    // Store bulk node ids for each of the new nodes.
    auto bulk_node_ids =
        nodes_map | ranges::views::keys | ranges::to<std::vector>;
 
    auto mesh = std::make_unique<MeshLib::Mesh>(
        std::move(mesh_name), std::move(element_nodes), std::move(elements));
    assert(mesh != nullptr);
 
    addPropertyToMesh(*mesh, getBulkIDString(MeshLib::MeshItemType::Cell),
                      MeshLib::MeshItemType::Cell, 1, bulk_element_ids);
    addPropertyToMesh(*mesh, getBulkIDString(MeshLib::MeshItemType::Node),
                      MeshLib::MeshItemType::Node, 1, bulk_node_ids);
 
    return mesh;
}

References addPropertyToMesh(), Cell, DBUG(), getBulkIDString(), MathLib::Point3dWithID::getID(), MeshLib::views::ids, and Node.

Referenced by ProcessLib::createDeactivatedSubdomainMesh(), and createMaterialIDsBasedSubMesh().

filter()

template<typename Container , typename Predicate >

std::vector< std::size_t > MeshLib::filter	(	Container const &	container,
		Predicate const &	p
	)

Definition at line 27 of file ElementSearch.cpp.

{
    return ranges::views::filter(container, p) | views::ids |
           ranges::to<std::vector>;
}

References MeshLib::views::ids.

Referenced by MeshLib::ElementSearch::searchByBoundingBox(), MeshLib::ElementSearch::searchByContent(), and MeshLib::ElementSearch::searchByElementType().

findElementsConnectedToNodes()

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

(

Mesh const &

mesh

)

Definition at line 45 of file Mesh.cpp.

{
    std::vector<std::vector<Element const*>> elements_connected_to_nodes;
    auto const& nodes = mesh.getNodes();
    elements_connected_to_nodes.resize(nodes.size());
 
    for (auto const* element : mesh.getElements())
    {
        for (auto const node_id : element->nodes() | views::ids)
        {
            elements_connected_to_nodes[node_id].push_back(element);
        }
    }
    return elements_connected_to_nodes;
}

References MeshLib::Mesh::getElements(), MeshLib::Mesh::getNodes(), and MeshLib::views::ids.

Referenced by MeshLib::Mesh::Mesh(), and calculateNodesConnectedByElements().

findElementsWithinRadius()

std::vector< std::size_t > MeshLib::findElementsWithinRadius	(	Element const &	start_element,
		double const	radius_squared
	)

Find neighbor elements in given radius of the element.

Returns

ids of elements for which at least one node lies inside the radius of any node of the given element.

Note

There are corner-cases not correctly handled by this algorithm: Elements where an edge, but not the edge' nodes, fall inside the search radius are not included. The algorithm is only considering node to node distances and does not take into account if there is a part of an element (an edge or a face) but not the nodes falls inside the search radius.

For radius 0 only the given element's id is returned.

Definition at line 23 of file findElementsWithinRadius.cpp.

{
    // Special case for 0 radius. All other radii will include at least one
    // neighbor of the start element.
    if (radius_squared == 0.)
    {
        return {start_element.getID()};
    }
 
    // Collect start element node coordinates into local contigiuos memory.
    std::vector<MathLib::Point3d> start_element_nodes;
    {
        auto const start_element_n_nodes = start_element.getNumberOfNodes();
        start_element_nodes.reserve(start_element_n_nodes);
        for (unsigned n = 0; n < start_element_n_nodes; ++n)
        {
            start_element_nodes.push_back(*start_element.getNode(n));
        }
    }
 
    // Returns true if the test node is inside the radius of any of the
    // element's nodes.
    auto node_inside_radius =
        [&start_element_nodes, radius_squared](Node const* test_node)
    {
        return std::any_of(
            start_element_nodes.begin(), start_element_nodes.end(),
            [test_node, &radius_squared](auto const node)
            { return MathLib::sqrDist(*test_node, node) <= radius_squared; });
    };
 
    // Returns true if any of the test element's nodes is inside the start
    // element's radius.
    auto element_in_radius = [&node_inside_radius](Element const& element)
    {
        auto const n_nodes = element.getNumberOfNodes();
        for (unsigned i = 0; i < n_nodes; ++i)
        {
            if (node_inside_radius(element.getNode(i)))
            {
                return true;
            }
        }
        return false;
    };
 
    std::set<std::size_t> found_elements;
    std::vector<Element const*> neighbors_to_visit;
    std::unordered_set<std::size_t> visited_elements;
 
    auto mark_visited_and_add_neighbors =
        [&found_elements, &neighbors_to_visit, &visited_elements](
            Element const& element)
    {
        found_elements.insert(element.getID());
        visited_elements.insert(element.getID());
        auto const n_neighbors = element.getNumberOfNeighbors();
        for (unsigned n = 0; n < n_neighbors; ++n)
        {
            auto neighbor = element.getNeighbor(n);
            if (neighbor == nullptr)
            {
                continue;
            }
            auto x = visited_elements.find(neighbor->getID());
            if (x != visited_elements.end())
            {
                continue;
            }
 
            neighbors_to_visit.push_back(neighbor);
 
            visited_elements.insert(neighbor->getID());
        }
    };
 
    // The result always contains the starting element.
    mark_visited_and_add_neighbors(start_element);
 
    while (!neighbors_to_visit.empty())
    {
        auto const& current_element = *neighbors_to_visit.back();
        neighbors_to_visit.pop_back();
 
        // If any node is inside the radius, all neighbors are visited.
        if (element_in_radius(current_element))
        {
            mark_visited_and_add_neighbors(current_element);
        }
    }
 
    return {std::begin(found_elements), std::end(found_elements)};
}

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

Referenced by ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, DisplacementDim >::nonlocal().

getBaseNodes()

std::vector< Node * > MeshLib::getBaseNodes ( std::vector< Element * > const &  elements )

inline

Returns a vector of node pointers containing the base nodes of the elements input vector.

Definition at line 26 of file Utils.h.

{
    std::vector<Node*> base_nodes;
    base_nodes.reserve(elements.size() * 2);  // Save some of the realloctions.
 
    for (auto* const e : elements)
    {
        std::copy(e->getNodes(), e->getNodes() + e->getNumberOfBaseNodes(),
                  std::back_inserter(base_nodes));
    }
 
    BaseLib::makeVectorUnique(base_nodes, MeshLib::idsComparator<Node*>);
 
    return base_nodes;
}

References BaseLib::makeVectorUnique().

Referenced by ProcessLib::HydroMechanics::HydroMechanicsProcess< DisplacementDim >::constructDofTable(), ProcessLib::LIE::HydroMechanics::HydroMechanicsProcess< GlobalDim >::constructDofTable(), ProcessLib::RichardsMechanics::RichardsMechanicsProcess< DisplacementDim >::constructDofTable(), ProcessLib::StokesFlow::StokesFlowProcess< GlobalDim >::constructDofTable(), ProcessLib::TH2M::TH2MProcess< DisplacementDim >::constructDofTable(), ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsProcess< DisplacementDim >::constructDofTable(), and ProcessLib::ThermoRichardsMechanics::ThermoRichardsMechanicsProcess< DisplacementDim, ConstitutiveTraits >::constructDofTable().

getBulkElementPoint() [1/2]

MathLib::Point3d MeshLib::getBulkElementPoint	(	MeshLib::CellType const	bulk_element_cell_type,
		std::size_t const	bulk_face_id,
		MathLib::WeightedPoint const &	point_on_face
	)

Maps the given point_on_face on the face a bulk element of type bulk_element_cell_type to the given point in the bulk element.

The input and output coordinates are natural coordinates of the surface and bulk element, respectively. I.e., the output point has one coordinate more than the input point.

Definition at line 219 of file MapBulkElementPoint.cpp.

{
    if (point_on_face.getDimension() == 3)
    {
        // TODO disable the 3d elements in the local assembler creator
        return MathLib::ORIGIN;
    }
 
    switch (bulk_element_cell_type)
    {
            // 3D bulk elements
        case CellType::HEX8:
            return getBulkElementPointHex(bulk_face_id, point_on_face);
        case CellType::PRISM6:
            return getBulkElementPointPrism(bulk_face_id, point_on_face);
        case CellType::PYRAMID5:
            return getBulkElementPointPyramid(bulk_face_id, point_on_face);
        case CellType::TET4:
            return getBulkElementPointTet(bulk_face_id, point_on_face);
            // 2D bulk elements
        case CellType::QUAD4:
            return getBulkElementPointQuad(bulk_face_id, point_on_face);
        case CellType::TRI3:
            return getBulkElementPointTri(bulk_face_id, point_on_face);
            // 1D bulk elements
        case CellType::LINE2:
            return getBulkElementPointLine(bulk_face_id);
        default:
            OGS_FATAL(
                "Wrong cell type '{:s}' or functionality not yet implemented.",
                CellType2String(bulk_element_cell_type));
    }
}

References CellType2String(), MathLib::WeightedPoint::getDimension(), HEX8, LINE2, OGS_FATAL, MathLib::ORIGIN, PRISM6, PYRAMID5, QUAD4, TET4, and TRI3.

Referenced by ProcessLib::ConstraintDirichletBoundaryConditionLocalAssembler< ShapeFunction, GlobalDim >::ConstraintDirichletBoundaryConditionLocalAssembler(), ProcessLib::HCNonAdvectiveFreeComponentFlowBoundaryConditionLocalAssembler< ShapeFunction, GlobalDim >::assemble(), getBulkElementPoint(), and ProcessLib::SurfaceFluxLocalAssembler< ShapeFunction, GlobalDim >::integrate().

getBulkElementPoint() [2/2]

MathLib::Point3d MeshLib::getBulkElementPoint ( MeshLib::Element const &  bulk_element, std::size_t const  bulk_face_id, MathLib::WeightedPoint const &  point_on_face  )

inline

Overload provided for convenience.

Definition at line 36 of file MapBulkElementPoint.h.

{
    return getBulkElementPoint(
        bulk_element.getCellType(), bulk_face_id, point_on_face);
}

References getBulkElementPoint(), and MeshLib::Element::getCellType().

getBulkIDString()

constexpr std::string_view MeshLib::getBulkIDString ( MeshItemType  mesh_item_type )

constexpr

Returns the mapping MeshItemType -> bulk ID property name, i.e. MeshItemType::Node -> bulk_node_ids MeshItemType::Cell -> bulk_element_ids MeshItemType::Face -> bulk_face_ids

Definition at line 188 of file Properties.h.

{
    switch (mesh_item_type)
    {
        case MeshItemType::Node:
            return "bulk_node_ids";
            break;
        case MeshItemType::Cell:
            return "bulk_element_ids";
            break;
        case MeshItemType::Edge:
            return "bulk_edge_ids";
            break;
        case MeshItemType::Face:
            return "bulk_face_ids";
            break;
        case MeshItemType::IntegrationPoint:
            OGS_FATAL("MeshItemType::IntegrationPoint is not handled.");
            return "";
            break;
        default:
            OGS_FATAL(
                "Unknown mesh item type. At the moment only for mesh item "
                "types 'Node', 'Cell', and 'Face' mapping names are "
                "specified.");
            return "";
    }
}

References Cell, Edge, Face, IntegrationPoint, Node, and OGS_FATAL.

Referenced by ProcessLib::GenericNaturalBoundaryCondition< BoundaryConditionData, LocalAssemblerImplementation >::GenericNaturalBoundaryCondition(), ProcessLib::SurfaceFlux::SurfaceFlux(), ProcessLib::addBulkMeshPropertyToSubMesh(), MeshToolsLib::addLayerToMesh(), bulkElementIDs(), bulkNodeIDs(), anonymous_namespace{SubmeshResiduumOutputConfig.cpp}::checkBulkIDMappingsPresent(), ProcessLib::checkParametersOfDirichletBoundaryCondition(), ProcessLib::createHCNonAdvectiveFreeComponentFlowBoundaryCondition(), createMeshFromElementSelection(), ProcessLib::createSourceTerm(), MeshToolsLib::MeshValidation::detectHoles(), DirectConditionGenerator::directWithSurfaceIntegration(), extractBoundaries(), ProcessLib::extractElementsAlongOuterNodes(), getBulkNodeIdMapForPetscIfNecessary(), MeshGeoToolsLib::identifySubdomainMesh(), MeshLib::IO::isVariableAttribute(), main(), ApplicationUtils::NodeWiseMeshPartitioner::partitionOtherMesh(), and ApplicationUtils::NodeWiseMeshPartitioner::renumberBulkIdsProperty().

getCenterOfGravity()

MathLib::Point3d MeshLib::getCenterOfGravity

(

Element const &

element

)

Calculates the center of gravity for the mesh element.

Definition at line 124 of file Element.cpp.

{
    const unsigned nNodes(element.getNumberOfBaseNodes());
    MathLib::Point3d center{{0, 0, 0}};
    for (unsigned i = 0; i < nNodes; ++i)
    {
        center.asEigenVector3d() += element.getNode(i)->asEigenVector3d();
    }
    center.asEigenVector3d() /= nNodes;
    return center;
}

References MathLib::Point3d::asEigenVector3d(), MeshLib::Element::getNode(), and MeshLib::Element::getNumberOfBaseNodes().

Referenced by MeshToolsLib::MeshGenerator::AddFaultToVoxelGrid::addFaultToVoxelGrid(), ProcessLib::LIE::HydroMechanics::HydroMechanicsProcess< GlobalDim >::initializeConcreteProcess(), anonymous_namespace{AddFaultToVoxelGrid.cpp}::markFaults(), LayeredVolume::removeCongruentElements(), FileIO::FEFLOWMeshInterface::setMaterialIDs(), setMaterialIDs(), MeshLib::CellRule::testElementNodeOrder(), and FileIO::TetGenInterface::write3dElements().

getElementRotationMatrices()

std::vector< Eigen::MatrixXd > MeshLib::getElementRotationMatrices	(	int const	space_dimension,
		int const	mesh_dimension,
		std::vector< Element * > const &	elements
	)

Element rotation matrix computation.

This function returns a vector containing the rotation matrices of given elements. The rotation matrix of an element is used to map the local vector to the global coordinate system. If an element is not inclined, the identity matrix is used as its rotation matrix.

Parameters

space_dimension	The space dimension.
mesh_dimension	The mesh dimension.
elements	The mesh elements.

Returns

A vector of rotation matrices of given elements.

Definition at line 21 of file GetElementRotationMatrices.cpp.

{
    std::vector<Eigen::MatrixXd> element_rotation_matrices;
    element_rotation_matrices.reserve(elements.size());
    for (auto const* const element : elements)
    {
        int const element_dimension = static_cast<int>(element->getDimension());
        if (element_dimension == space_dimension)
        {
            element_rotation_matrices.emplace_back(Eigen::MatrixXd::Identity(
                element_dimension, element_dimension));
        }
        else
        {
            MeshLib::ElementCoordinatesMappingLocal coordinates_mapping(
                *element, mesh_dimension);
 
            element_rotation_matrices.emplace_back(
                coordinates_mapping.getRotationMatrixToGlobal().topLeftCorner(
                    space_dimension, element_dimension));
        }
    }
 
    return element_rotation_matrices;
}

References MeshLib::ElementCoordinatesMappingLocal::getRotationMatrixToGlobal().

Referenced by ProcessLib::ComponentTransport::createComponentTransportProcess(), ProcessLib::HT::createHTProcess(), and ProcessLib::LiquidFlow::createLiquidFlowProcess().

getEndNodeIDRanks()

std::vector< int > MeshLib::getEndNodeIDRanks	(	std::size_t const	n_global_nodes,
		std::vector< std::size_t > const &	n_regular_base_nodes_at_rank,
		std::vector< std::size_t > const &	n_regular_high_order_nodes_at_rank
	)

Definition at line 16 of file NodePartitionedMesh.cpp.

{
    std::vector<int> data;
 
    std::transform(n_regular_base_nodes_at_rank.begin() + 1,
                   n_regular_base_nodes_at_rank.end(),
                   n_regular_high_order_nodes_at_rank.begin() + 1,
                   std::back_inserter(data), std::plus<int>());
 
    data.push_back(n_global_nodes);
 
    return data;
}

getIntegrationPointMetaData()

IntegrationPointMetaData MeshLib::getIntegrationPointMetaData	(	MeshLib::Properties const &	properties,
		std::string const &	name
	)

Returns integration point meta data for the given field name.

The data is read from a JSON encoded string stored in field data array.

Definition at line 109 of file IntegrationPointWriter.cpp.

{
    if (!properties.existsPropertyVector<char>("IntegrationPointMetaData"))
    {
        OGS_FATAL(
            "Integration point data '{:s}' is present in the vtk field data "
            "but the required 'IntegrationPointMetaData' array is not "
            "available.",
            name);
    }
    auto const& mesh_property_ip_meta_data =
        *properties.template getPropertyVector<char>(
            "IntegrationPointMetaData");
 
    if (mesh_property_ip_meta_data.getMeshItemType() !=
        MeshLib::MeshItemType::IntegrationPoint)
    {
        OGS_FATAL("IntegrationPointMetaData array must be field data.");
    }
 
    // Find the current integration point data entry and extract the
    // meta data.
    auto const ip_meta_data = extractIntegrationPointMetaData(
        json::parse(mesh_property_ip_meta_data.begin(),
                    mesh_property_ip_meta_data.end()),
        name);
 
    return ip_meta_data;
}

References MeshLib::Properties::existsPropertyVector(), extractIntegrationPointMetaData(), IntegrationPoint, and OGS_FATAL.

Referenced by ApplicationUtils::checkFieldPropertyVectorSize(), ApplicationUtils::copyFieldPropertyDataToPartitions(), createPropertyVector(), determineIntegrationOrder(), MeshToolsLib::getIntegrationPointDataOffsetsOfMeshElements(), and ApplicationUtils::setIntegrationPointNumberOfPartition().

getMaxiumElementEdgeLengths()

std::vector< double > MeshLib::getMaxiumElementEdgeLengths

(

std::vector< Element * > const &

elements

)

Returns the maximum lengths of the edges for each element.

Definition at line 19 of file getMaxiumElementEdgeLengths.cpp.

{
    std::vector<double> element_edge_lengths(elements.size());
    for (auto const element : elements)
    {
        assert(element->getGeomType() != MeshElemType::POINT);
 
        auto const& [min_edge_length, max_edge_length] =
            MeshLib::computeSqrEdgeLengthRange(*element);
        (void)min_edge_length;
 
        element_edge_lengths[element->getID()] = std::sqrt(max_edge_length);
    }
 
    return element_edge_lengths;
}

References computeSqrEdgeLengthRange(), and POINT.

Referenced by NumLib::createNumericalStabilization().

getMeshElementsForMaterialIDs()

std::vector< MeshLib::Element * > MeshLib::getMeshElementsForMaterialIDs	(	MeshLib::Mesh const &	mesh,
		std::vector< int > const &	selected_material_ids
	)

Definition at line 21 of file getMeshElementsForMaterialIDs.cpp.

{
    auto const material_ids = *materialIDs(mesh);
    auto const& elements = mesh.getElements();
    std::vector<MeshLib::Element*> selected_elements;
 
    for (std::size_t i = 0; i < material_ids.size(); ++i)
    {
        if (ranges::contains(selected_material_ids, material_ids[i]))
        {
            selected_elements.push_back(elements[i]);
        }
    }
    return selected_elements;
}

References MeshLib::Mesh::getElements(), and materialIDs().

Referenced by createMaterialIDsBasedSubMesh().

getMeshElemTypes()

std::vector< MeshElemType > MeshLib::getMeshElemTypes

(

)

Returns a vector of all mesh element types.

Definition at line 132 of file MeshEnums.cpp.

{
    std::vector<MeshElemType> vec;
    vec.push_back(MeshElemType::POINT);
    vec.push_back(MeshElemType::LINE);
    vec.push_back(MeshElemType::QUAD);
    vec.push_back(MeshElemType::HEXAHEDRON);
    vec.push_back(MeshElemType::TRIANGLE);
    vec.push_back(MeshElemType::TETRAHEDRON);
    vec.push_back(MeshElemType::PRISM);
    vec.push_back(MeshElemType::PYRAMID);
    return vec;
}

References HEXAHEDRON, LINE, POINT, PRISM, PYRAMID, QUAD, TETRAHEDRON, and TRIANGLE.

Referenced by MeshModel::createMeshElemTypeMap(), and getMeshElemTypeStringsShort().

getMeshElemTypeStringsShort()

std::vector< std::string > MeshLib::getMeshElemTypeStringsShort

(

)

Returns a vector of strings of mesh element types.

Definition at line 146 of file MeshEnums.cpp.

{
    std::vector<std::string> vec;
    auto const& mesh_elem_types = getMeshElemTypes();
    std::transform(mesh_elem_types.begin(), mesh_elem_types.end(),
                   std::back_inserter(vec),
                   [](auto const& element_type)
                   { return MeshElemType2StringShort(element_type); });
    return vec;
}

References getMeshElemTypes().

Referenced by main().

getMPIRankAndSize()

std::pair< int, int > MeshLib::getMPIRankAndSize

(

MPI_Comm const &

mpi_comm

)

Definition at line 44 of file transformMeshToNodePartitionedMesh.cpp.

{
    int mpi_comm_size;
    MPI_Comm_size(mpi_comm, &mpi_comm_size);
    int mpi_comm_rank;
    MPI_Comm_rank(mpi_comm, &mpi_comm_rank);
    return {mpi_comm_rank, mpi_comm_size};
}

Referenced by computeGhostBaseNodeGlobalNodeIDsOfSubDomainPartition(), computeNumberOfRegularBaseNodesAtRank(), computeNumberOfRegularHigherOrderNodesAtRank(), and computeRegularBaseNodeGlobalNodeIDsOfSubDomainPartition().

getNodeIDinElement()

unsigned MeshLib::getNodeIDinElement	(	Element const &	element,
		const MeshLib::Node *	node
	)

Returns the position of the given node in the node array of this element.

Definition at line 206 of file Element.cpp.

{
    const unsigned nNodes(element.getNumberOfNodes());
    for (unsigned i(0); i < nNodes; i++)
    {
        if (node == element.getNode(i))
        {
            return i;
        }
    }
    return std::numeric_limits<unsigned>::max();
}

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

Referenced by isBaseNode().

getNodeIndex()

std::size_t MeshLib::getNodeIndex	(	Element const &	element,
		unsigned	idx
	)

Get the global node index of the node with the local index idx within the element. The index should be at most the number of nodes of the element.

Parameters

element	The element object that will be searched for the index.
idx	Local index of Node, at most the number of nodes of the element that you can obtain with Element::getNumberOfBaseNodes().

Returns

the global index if idx < Element::getNumberOfBaseNodes. Otherwise in debug mode the value std::numeric_limits<unsigned>::max(). In release mode the behaviour is undefined.

See also

Element::getNode()

Definition at line 219 of file Element.cpp.

{
#ifndef NDEBUG
    if (idx >= element.getNumberOfNodes())
    {
        ERR("Error in MeshLib::getNodeIndex() - Index does not "
            "exist.");
        return std::numeric_limits<std::size_t>::max();
    }
#endif
    return element.getNode(idx)->getID();
}

References ERR(), MathLib::Point3dWithID::getID(), MeshLib::Element::getNode(), and MeshLib::Element::getNumberOfNodes().

Referenced by anonymous_namespace{IdentifySubdomainMesh.cpp}::identifySubdomainMeshElements(), and MeshLib::NodeSearch::searchNodesConnectedToOnlyGivenElements().

getNumberOfGlobalNodes()

unsigned long MeshLib::getNumberOfGlobalNodes

(

Mesh const *

subdomain_mesh

)

Definition at line 381 of file transformMeshToNodePartitionedMesh.cpp.

{
    // sum all nodes over all partitions in number_of_global_nodes
    unsigned long number_of_local_nodes = subdomain_mesh->getNodes().size();
    unsigned long number_of_global_nodes = 0;
 
    MPI_Comm mpi_comm = MPI_COMM_WORLD;
 
    MPI_Allreduce(&number_of_local_nodes, &number_of_global_nodes, 1,
                  MPI_UNSIGNED_LONG, MPI_SUM, mpi_comm);
    DBUG("[{}] number_of_global_nodes: {}'", subdomain_mesh->getName(),
         number_of_global_nodes);
    return number_of_global_nodes;
}

References DBUG(), MeshLib::Mesh::getName(), and MeshLib::Mesh::getNodes().

Referenced by transformMeshToNodePartitionedMesh().

getOrCreateMeshProperty()

template<typename T >

PropertyVector< T > * MeshLib::getOrCreateMeshProperty	(	Mesh &	mesh,
		std::string const &	property_name,
		MeshItemType const	item_type,
		int const	number_of_components
	)

Returns

a PropertyVector of the corresponding type, name on nodes, or cells, or integration points if such exists, or creates a new one.

Attention

For the integration points the result's size is zero.

See also

MeshLib::addPropertyToMesh()

Definition at line 25 of file getOrCreateMeshProperty.h.

{
    if (property_name.empty())
    {
        OGS_FATAL(
            "Trying to get or to create a mesh property with empty name.");
    }
 
    auto numberOfMeshItems = [&mesh, &item_type]() -> std::size_t
    {
        switch (item_type)
        {
            case MeshItemType::Cell:
                return mesh.getNumberOfElements();
            case MeshItemType::Node:
                return mesh.getNumberOfNodes();
            case MeshItemType::IntegrationPoint:
                return 0;  // For the integration point data the size is
                           // variable
            default:
                OGS_FATAL(
                    "getOrCreateMeshProperty cannot handle other "
                    "types than Node, Cell, or IntegrationPoint.");
        }
        return 0;
    };
 
    if (mesh.getProperties().existsPropertyVector<T>(property_name))
    {
        auto result =
            mesh.getProperties().template getPropertyVector<T>(property_name);
        assert(result);
        if (item_type != MeshItemType::IntegrationPoint)
        {
            // Test the size if number of mesh items is known, which is not the
            // case for the integration point data.
            assert(result->size() ==
                   numberOfMeshItems() * number_of_components);
        }
        return result;
    }
 
    auto result = mesh.getProperties().template createNewPropertyVector<T>(
        property_name, item_type, number_of_components);
    assert(result);
    result->resize(numberOfMeshItems() * number_of_components);
    return result;
}

References Cell, MeshLib::Properties::existsPropertyVector(), MeshLib::Mesh::getNumberOfElements(), MeshLib::Mesh::getNumberOfNodes(), MeshLib::Mesh::getProperties(), IntegrationPoint, Node, and OGS_FATAL.

getSpaceDimension()

int MeshLib::getSpaceDimension

(

std::vector< Node * > const &

nodes

)

Computes dimension of the embedding space containing the set of given points.

The space dimension is computed by accounting the non-zero norms of \(\mathbf x\), \(\mathbf y\), \(\mathbf z\), which are the coordinates of all nodes of the mesh. With this concept, the space dimension is:

• 1, if all nodes are on a line that is parallel to \(x\) axis.
• 2, if all nodes are on a line that is parallel to \(y\) axis.
• 3, if all nodes are on a line that is parallel to \(z\) axis.
• 2, if all nodes are distributed on a plane that is parallel to the origin coordinate plane of \(x-y\) (including the case of mesh with 1D inclined elements).
• 3, if all nodes are distributed on a plane that is parallel to the origin coordinate plane of \(y-z\) or \(x-z\) (including the case of mesh with 1D inclined elements)..
• 3, if all nodes are scattered in 3D space (e.g. mesh with inclined 1D, 2D elements, 3D elements).

Definition at line 23 of file GetSpaceDimension.cpp.

{
    Eigen::Vector3d x_magnitude = Eigen::Vector3d::Zero();
    auto const x_ref = nodes[0]->asEigenVector3d();
 
    for (auto const& node : nodes)
    {
        auto const x = node->asEigenVector3d();
        x_magnitude += (x - x_ref).cwiseAbs();
    }
 
    // Z coordinate norm is not zero whichever 1D, 2D or 3D mesh:
    if (x_magnitude[2] > 0)
    {
        return 3;
    }
 
    const auto computed_dimension = std::count_if(
        x_magnitude.begin(), x_magnitude.end(),
        [](const double x_i_magnitude)
        { return x_i_magnitude > std::numeric_limits<double>::epsilon(); });
 
    // 1D mesh in y direction:
    if (computed_dimension == 1 && x_magnitude[1] > 0)
    {
        return 2;
    }
 
    return static_cast<int>(computed_dimension);
}

Referenced by ProcessLib::ComponentTransport::createComponentTransportProcess(), ProcessLib::HeatConduction::createHeatConductionProcess(), ProcessLib::HT::createHTProcess(), ProcessLib::LiquidFlow::createLiquidFlowProcess(), and setMeshSpaceDimension().

getUniqueNodes()

std::vector< Node * > MeshLib::getUniqueNodes

(

std::vector< Element * > const &

elements

)

Create a vector of unique nodes used by given elements.

Definition at line 163 of file NodeSearch.cpp.

{
    std::set<Node*> nodes_set;
    for (auto e : elements)
    {
        Node* const* nodes = e->getNodes();
        unsigned const nnodes = e->getNumberOfNodes();
        nodes_set.insert(nodes, nodes + nnodes);
    }
 
    std::vector<Node*> nodes;
    nodes.reserve(nodes_set.size());
 
    std::move(nodes_set.cbegin(), nodes_set.cend(), std::back_inserter(nodes));
 
    return nodes;
}

hasZeroVolume()

bool MeshLib::hasZeroVolume

(

MeshLib::Element const &

element

)

Returns true if the element has zero length/area/volume.

Definition at line 119 of file Element.cpp.

{
    return element.getContent() < std::numeric_limits<double>::epsilon();
}

References MeshLib::Element::getContent().

Referenced by MeshLib::HexRule::validate(), MeshLib::LineRule::validate(), MeshLib::PointRule1::validate(), MeshLib::PrismRule::validate(), MeshLib::PyramidRule::validate(), MeshLib::QuadRule::validate(), MeshLib::TetRule::validate(), and MeshLib::TriRule::validate().

idsComparator()

template<typename T >

bool MeshLib::idsComparator	(	T const	a,
		T const	b
	)

Lexicographic comparison of ids of two objects of type T. T can be a pointer or a value type.

Definition at line 201 of file Mesh.h.

{
    if constexpr (std::is_pointer_v<T>)
    {
        return a->getID() < b->getID();
    }
    else
    {
        return a.getID() < b.getID();
    }
}

is2DMeshOnRotatedVerticalPlane()

bool MeshLib::is2DMeshOnRotatedVerticalPlane

(

Mesh const &

mesh

)

Definition at line 24 of file Is2DMeshOnRotatedVerticalPlane.cpp.

{
    auto const mesh_dimension = mesh.getDimension();
    if (mesh_dimension != 2)
    {
        OGS_FATAL(
            "A 2D mesh is required for this computation but the provided mesh, "
            "mesh {:s}, has {:d}D elements.",
            mesh.getName(), mesh_dimension);
    }
 
    auto const& elements = mesh.getElements();
 
    bool const has_inclined_element =
        std::any_of(elements.begin(), elements.end(),
                    [&mesh_dimension](auto const& element)
                    { return element->space_dimension_ != mesh_dimension; });
 
    if (!has_inclined_element)
    {
        return false;
    }
 
    const bool is_rotated_around_y_axis = std::all_of(
        elements.cbegin(), elements.cend(),
        [](auto const& element)
        {
            // 3 nodes are enough to make up a plane.
            auto const x1 = element->getNode(0)->data();
            auto const x2 = element->getNode(1)->data();
            auto const x3 = element->getNode(2)->data();
 
            double const a0 = x2[0] - x1[0];
            double const a2 = x2[2] - x1[2];
 
            double const b0 = x3[0] - x1[0];
            double const b2 = x3[2] - x1[2];
 
            double const e_n_1 = -a0 * b2 + a2 * b0;
            return std::fabs(e_n_1) < std::numeric_limits<double>::epsilon();
        });
 
    const bool is_rotated_around_z_axis = std::all_of(
        elements.cbegin(), elements.cend(),
        [](auto const& element)
        {
            // 3 nodes are enough to make up a plane.
            auto const x1 = element->getNode(0)->data();
            auto const x2 = element->getNode(1)->data();
            auto const x3 = element->getNode(2)->data();
 
            double const a0 = x2[0] - x1[0];
            double const a1 = x2[1] - x1[1];
 
            double const b0 = x3[0] - x1[0];
            double const b1 = x3[1] - x1[1];
 
            double const e_n_2 = a0 * b1 - a1 * b0;
            return std::fabs(e_n_2) < std::numeric_limits<double>::epsilon();
        });
 
    if (!(is_rotated_around_y_axis || is_rotated_around_z_axis))
    {
        OGS_FATAL(
            "2D Mesh {:s} is on an inclined plane, which is neither a vertical "
            "nor horizontal plane that is required for the present "
            "computation.",
            mesh.getName());
    }
 
    return true;
}

References MeshLib::Mesh::getDimension(), MeshLib::Mesh::getElements(), MeshLib::Mesh::getName(), and OGS_FATAL.

Referenced by ProcessLib::HydroMechanics::createHydroMechanicsProcess().

isBaseNode()

bool MeshLib::isBaseNode	(	Node const &	node,
		std::vector< Element const * > const &	elements_connected_to_node
	)

Returns true if the given node is a base node of a (first) element, or if it is not connected to any element i.e. an unconnected node.

Definition at line 336 of file Mesh.cpp.

{
    // Check if node is connected.
    if (elements_connected_to_node.empty())
    {
        return true;
    }
 
    // In a mesh a node always belongs to at least one element.
    auto const e = elements_connected_to_node[0];
 
    auto const n_base_nodes = e->getNumberOfBaseNodes();
    auto const local_index = getNodeIDinElement(*e, &node);
    return local_index < n_base_nodes;
}

References getNodeIDinElement().

Referenced by MeshGeoToolsLib::MeshNodesOnPoint::MeshNodesOnPoint(), MeshLib::Mesh::computeNumberOfBaseNodes(), NumLib::MeshComponentMap::createParallelMeshComponentMap(), and NumLib::MeshComponentMap::getSubset().

isPointInElementXY()

bool MeshLib::isPointInElementXY	(	MathLib::Point3d const &	p,
		Element const &	e
	)

Let \(p'\) the orthogonal projection to the \(x\)- \(y\) plane of the point p and \(e'\) the orthogonal projection to the \(x\)- \(y\) plane of the element e. The method checks if \(p'\) is located in \(e'\).

Todo:

At the moment the test works only for triangle and quad elements.

Parameters

p	MathLib::Point3d is the test point
e	the element that is used for the request

Returns

true if the \(p' \in e'\) and false if \(p' \notin e'\)

Definition at line 171 of file Element.cpp.

{
    for (std::size_t i(0); i < e.getNumberOfBaseNodes(); ++i)
    {
        if (MathLib::sqrDist2d(p, *e.getNode(i)) <
            std::numeric_limits<double>::epsilon())
        {
            return true;
        }
    }
 
    if (e.getGeomType() == MeshElemType::TRIANGLE)
    {
        MathLib::Point3d const& n0(*e.getNode(0));
        MathLib::Point3d const& n1(*e.getNode(1));
        MathLib::Point3d const& n2(*e.getNode(2));
 
        return MathLib::isPointInTriangleXY(p, n0, n1, n2);
    }
    if (e.getGeomType() == MeshElemType::QUAD)
    {
        MathLib::Point3d const& n0(*e.getNode(0));
        MathLib::Point3d const& n1(*e.getNode(1));
        MathLib::Point3d const& n2(*e.getNode(2));
        MathLib::Point3d const& n3(*e.getNode(3));
 
        return MathLib::isPointInTriangleXY(p, n0, n1, n2) ||
               MathLib::isPointInTriangleXY(p, n0, n2, n3);
    }
 
    WARN("isPointInElementXY: element type '{:s}' is not supported.",
         MeshLib::MeshElemType2String(e.getGeomType()));
    return false;
}

References MeshLib::Element::getGeomType(), MeshLib::Element::getNode(), MeshLib::Element::getNumberOfBaseNodes(), MathLib::isPointInTriangleXY(), MeshElemType2String(), QUAD, MathLib::sqrDist2d(), TRIANGLE, and WARN().

Referenced by MeshToolsLib::Mesh2MeshPropertyInterpolation::interpolatePropertiesForMesh().

materialIDs() [1/2]

PropertyVector< int > * MeshLib::materialIDs

(

Mesh &

mesh

)

Definition at line 276 of file Mesh.cpp.

{
    return const_cast<PropertyVector<int>*>(
        MeshLib::materialIDs(std::as_const(mesh)));
}

References materialIDs().

materialIDs() [2/2]

PropertyVector< int > const * MeshLib::materialIDs

(

Mesh const &

mesh

)

Returns the material ids property vector defined on the mesh.

The material ids are always an int property named "MaterialIDs". If the property does not exists (or is of different type), a nullptr is returned.

Definition at line 258 of file Mesh.cpp.

{
    auto const& properties = mesh.getProperties();
    if (properties.existsPropertyVector<int>("MaterialIDs",
                                             MeshLib::MeshItemType::Cell, 1))
    {
        return properties.getPropertyVector<int>(
            "MaterialIDs", MeshLib::MeshItemType::Cell, 1);
    }
    if (properties.hasPropertyVector("MaterialIDs"))
    {
        WARN(
            "The 'MaterialIDs' mesh property exists but is either of wrong "
            "type (must be int), or it is not defined on element / cell data.");
    }
    return nullptr;
}

References Cell, MeshLib::Mesh::getProperties(), MeshLib::Properties::getPropertyVector(), and WARN().

Referenced by ProcessLib::HeatTransportBHE::HeatTransportBHEProcess::HeatTransportBHEProcess(), AddFaultsToVoxelGridDialog::accept(), ProcessLib::LIE::anonymous_namespace{MeshUtils.cpp}::findFracutreIntersections(), ProcessLib::HeatTransportBHE::getBHEDataInMesh(), MeshToolsLib::MeshInformation::getMaterialIDs(), getMeshElementsForMaterialIDs(), main(), anonymous_namespace{AddFaultToVoxelGrid.cpp}::markFaults(), markSpecificElements(), and materialIDs().

MeshElemType2String()

std::string MeshLib::MeshElemType2String

(

const MeshElemType

t

)

Given a MeshElemType this returns the appropriate string.

Definition at line 21 of file MeshEnums.cpp.

{
    if (t == MeshElemType::POINT)
    {
        return "Point";
    }
    if (t == MeshElemType::LINE)
    {
        return "Line";
    }
    if (t == MeshElemType::QUAD)
    {
        return "Quad";
    }
    if (t == MeshElemType::HEXAHEDRON)
    {
        return "Hexahedron";
    }
    if (t == MeshElemType::TRIANGLE)
    {
        return "Triangle";
    }
    if (t == MeshElemType::TETRAHEDRON)
    {
        return "Tetrahedron";
    }
    if (t == MeshElemType::PRISM)
    {
        return "Prism";
    }
    if (t == MeshElemType::PYRAMID)
    {
        return "Pyramid";
    }
    return "none";
}

References HEXAHEDRON, LINE, POINT, PRISM, PYRAMID, QUAD, TETRAHEDRON, and TRIANGLE.

Referenced by MeshModel::createMeshElemTypeMap(), MeshLib::TemplateElement< ELEMENT_RULE >::getNode(), isPointInElementXY(), ElementTreeModel::setMesh(), and MeshToolsLib::MeshInformation::writeAllNumbersOfElementTypes().

MeshElemType2StringShort()

std::string MeshLib::MeshElemType2StringShort

(

const MeshElemType

t

)

Given a MeshElemType this returns the appropriate string with a short name.

Definition at line 58 of file MeshEnums.cpp.

{
    if (t == MeshElemType::POINT)
    {
        return "point";
    }
    if (t == MeshElemType::LINE)
    {
        return "line";
    }
    if (t == MeshElemType::QUAD)
    {
        return "quad";
    }
    if (t == MeshElemType::HEXAHEDRON)
    {
        return "hex";
    }
    if (t == MeshElemType::TRIANGLE)
    {
        return "tri";
    }
    if (t == MeshElemType::TETRAHEDRON)
    {
        return "tet";
    }
    if (t == MeshElemType::PRISM)
    {
        return "pris";
    }
    if (t == MeshElemType::PYRAMID)
    {
        return "pyra";
    }
    return "none";
}

References HEXAHEDRON, LINE, POINT, PRISM, PYRAMID, QUAD, TETRAHEDRON, and TRIANGLE.

MeshQualityType2String()

std::string MeshLib::MeshQualityType2String

(

const MeshQualityType

t

)

Definition at line 186 of file MeshEnums.cpp.

{
    if (t == MeshQualityType::ELEMENTSIZE)
    {
        return "ElementSize";
    }
    if (t == MeshQualityType::EDGERATIO)
    {
        return "EdgeRatio";
    }
    if (t == MeshQualityType::EQUIANGLESKEW)
    {
        return "EquiAngleSkew";
    }
    if (t == MeshQualityType::RADIUSEDGERATIO)
    {
        return "RadiusEdgeRatio";
    }
    if (t == MeshQualityType::SIZEDIFFERENCE)
    {
        return "SizeDifference";
    }
    return "none";
}

References EDGERATIO, ELEMENTSIZE, EQUIANGLESKEW, RADIUSEDGERATIO, and SIZEDIFFERENCE.

minMaxEdgeLength()

std::pair< double, double > MeshLib::minMaxEdgeLength

(

std::vector< Element * > const &

elements

)

Returns the minimum and maximum edge length for given elements.

Definition at line 179 of file Mesh.cpp.

{
    auto min_max = [](auto const a, auto const b) -> std::pair<double, double> {
        return {std::min(a.first, b.first), std::max(a.second, b.second)};
    };
 
    using limits = std::numeric_limits<double>;
    auto const bounds = ranges::accumulate(
        elements, std::pair{limits::infinity(), -limits::infinity()}, min_max,
        [](Element const* const e) { return computeSqrEdgeLengthRange(*e); });
 
    return {std::sqrt(bounds.first), std::sqrt(bounds.second)};
}

References computeSqrEdgeLengthRange().

operator!=()

bool MeshLib::operator!= ( Mesh const &  a, Mesh const &  b  )

inline

Definition at line 174 of file Mesh.h.

{
    return !(a == b);
}

operator<()

bool MeshLib::operator< ( const Location &  left, const Location &  right  )

inline

Lexicographic order of Location.

Definition at line 51 of file Location.h.

{
    if (left.mesh_id != right.mesh_id)
    {
        return left.mesh_id < right.mesh_id;
    }
    if (left.item_type != right.item_type)
    {
        return left.item_type < right.item_type;
    }
    return left.item_id < right.item_id;
}

References MeshLib::Location::item_id, MeshLib::Location::item_type, and MeshLib::Location::mesh_id.

operator<<() [1/3]

std::ostream & MeshLib::operator<<	(	std::ostream &	os,
		Element const &	e
	)

Definition at line 88 of file Element.cpp.

{
    os << "Element #" << e._id << " @ " << &e << " with "
       << e.getNumberOfNeighbors() << " neighbours\n";
 
    unsigned const nnodes = e.getNumberOfNodes();
    MeshLib::Node* const* const nodes = e.getNodes();
    os << "MeshElemType: "
       << static_cast<std::underlying_type<MeshElemType>::type>(e.getGeomType())
       << " with " << nnodes << " nodes: {\n";
    for (unsigned n = 0; n < nnodes; ++n)
    {
        os << "  #" << nodes[n]->getID() << " @ " << nodes[n] << " coords ["
           << *nodes[n] << "]\n";
    }
    return os << '}';
}

operator<<() [2/3]

std::ostream & MeshLib::operator<<	(	std::ostream &	os,
		Location const &	l
	)

Definition at line 35 of file Location.cpp.

{
    return os << "(" << l.mesh_id << ", " << l.item_type << ", " << l.item_id
              << ")";
}

References MeshLib::Location::item_id, MeshLib::Location::item_type, and MeshLib::Location::mesh_id.

operator<<() [3/3]

std::ostream & MeshLib::operator<<	(	std::ostream &	os,
		MeshItemType const &	t
	)

Definition at line 17 of file Location.cpp.

{
    switch (t)
    {
        case MeshItemType::Node:
            return os << "N";
        case MeshItemType::Edge:
            return os << "E";
        case MeshItemType::Face:
            return os << "F";
        case MeshItemType::Cell:
            return os << "C";
        case MeshItemType::IntegrationPoint:
            return os << "I";
    };
    return os;
}

References Cell, Edge, Face, IntegrationPoint, and Node.

operator==()

bool MeshLib::operator== ( Mesh const &  a, Mesh const &  b  )

inline

Meshes are equal if their id's are equal.

Definition at line 169 of file Mesh.h.

{
    return a.getID() == b.getID();
}

References MeshLib::Mesh::getID().

scaleMeshPropertyVector()

void MeshLib::scaleMeshPropertyVector	(	Mesh &	mesh,
		std::string const &	property_name,
		double	factor
	)

Scales the mesh property with name property_name by given factor.

Note

The property must be a "double" property.

Definition at line 18 of file scaleMeshPropertyVector.cpp.

{
    if (!mesh.getProperties().existsPropertyVector<double>(property_name))
    {
        WARN("Did not find PropertyVector '{:s}' for scaling.", property_name);
        return;
    }
    auto& pv = *mesh.getProperties().getPropertyVector<double>(property_name);
    std::transform(pv.begin(), pv.end(), pv.begin(),
                   [factor](auto const& v) { return v * factor; });
}

References MeshLib::Properties::existsPropertyVector(), MeshLib::Mesh::getProperties(), MeshLib::Properties::getPropertyVector(), and WARN().

Referenced by main().

setMeshSpaceDimension()

void MeshLib::setMeshSpaceDimension

(

std::vector< std::unique_ptr< Mesh > > const &

meshes

)

In this function, the dimension of the space, which contains all nodes of the bulk mesh, is computed, and it is then set as a member of the elements of all meshes.

The space dimension is needed for the numerical simulations with a bulk mesh with elements with different dimensions. For example, in a bulk mesh for the numerical simulation of the liquid flow in the fractured porous media, the 1D or 2D elements can be used to represent the fractures, while the elements with higher dimension can be used to discretise the porous medium matrix domain.

Parameters

meshes

All meshes include the bulk mesh and the meshes for boundary conditions.

Definition at line 22 of file SetMeshSpaceDimension.cpp.

{
    // Get the space dimension from the bulk mesh:
    auto const d = getSpaceDimension(meshes[0]->getNodes());
    for (auto const& mesh : meshes)
    {
        ranges::for_each(mesh->getElements(),
                         [d](Element* const e) { e->space_dimension_ = d; });
    }
}

References getNodes(), and getSpaceDimension().

Referenced by anonymous_namespace{ProjectData.cpp}::readMeshes().

String2MeshElemType()

MeshElemType MeshLib::String2MeshElemType

(

const std::string &

s

)

Given a string of the shortened name of the element type, this returns the corresponding MeshElemType.

Definition at line 95 of file MeshEnums.cpp.

{
    if (boost::iequals(s, "point"))
    {
        return MeshElemType::POINT;
    }
    if (boost::iequals(s, "line"))
    {
        return MeshElemType::LINE;
    }
    if (boost::iequals(s, "quad") || boost::iequals(s, "Quadrilateral"))
    {
        return MeshElemType::QUAD;
    }
    if (boost::iequals(s, "hex") || boost::iequals(s, "Hexahedron"))
    {
        return MeshElemType::HEXAHEDRON;
    }
    if (boost::iequals(s, "tri") || boost::iequals(s, "Triangle"))
    {
        return MeshElemType::TRIANGLE;
    }
    if (boost::iequals(s, "tet") || boost::iequals(s, "Tetrahedron"))
    {
        return MeshElemType::TETRAHEDRON;
    }
    if (boost::iequals(s, "pris") || boost::iequals(s, "Prism"))
    {
        return MeshElemType::PRISM;
    }
    if (boost::iequals(s, "pyra") || boost::iequals(s, "Pyramid"))
    {
        return MeshElemType::PYRAMID;
    }
    return MeshElemType::INVALID;
}

References HEXAHEDRON, INVALID, LINE, POINT, PRISM, PYRAMID, QUAD, TETRAHEDRON, and TRIANGLE.

Referenced by MeshElementRemovalDialog::accept(), main(), and anonymous_namespace{MeshIO.cpp}::readElement().

String2MeshQualityType()

MeshLib::MeshQualityType MeshLib::String2MeshQualityType

(

std::string const &

s

)

Definition at line 211 of file MeshEnums.cpp.

{
    if (boost::iequals(s, "ElementSize"))
    {
        return MeshQualityType::ELEMENTSIZE;
    }
    if (boost::iequals(s, "EdgeRatio"))
    {
        return MeshQualityType::EDGERATIO;
    }
    if (boost::iequals(s, "EquiAngleSkew"))
    {
        return MeshQualityType::EQUIANGLESKEW;
    }
    if (boost::iequals(s, "RadiusEdgeRatio"))
    {
        return MeshQualityType::RADIUSEDGERATIO;
    }
    if (boost::iequals(s, "SizeDifference"))
    {
        return MeshQualityType::SIZEDIFFERENCE;
    }
    return MeshQualityType::INVALID;
}

References EDGERATIO, ELEMENTSIZE, EQUIANGLESKEW, INVALID, RADIUSEDGERATIO, and SIZEDIFFERENCE.

Referenced by main().

toString()

static constexpr char const * MeshLib::toString ( const MeshItemType  t )

staticconstexpr

Returns a char array for a specific MeshItemType.

Definition at line 28 of file Location.h.

{
    return mesh_item_type_strings[static_cast<int>(t)];
}

References mesh_item_type_strings.

Referenced by MeshLib::IO::NodePartitionedMeshReader::readProperties().

transformMeshToNodePartitionedMesh()

std::unique_ptr< MeshLib::NodePartitionedMesh > MeshLib::transformMeshToNodePartitionedMesh	(	NodePartitionedMesh const *const	bulk_mesh,
		Mesh const *const	subdomain_mesh
	)

Function computes all information necessary to transform the MeshLib::Mesh mesh into a NodePartitionedMesh subdomain mesh. Additional to the usual name, nodes and elements, the following information is computed:

• a vector of global node ids of the subdomain mesh,
• the number of global nodes (the sum of number of nodes of all subdomain meshes)
• the number of regular nodes (the sum of number of non-ghost nodes of all subdomain meshes)
• a vector containing the number of regular base nodes per rank
• a vector containing the number of regular higher order nodes per rank

Definition at line 396 of file transformMeshToNodePartitionedMesh.cpp.

{
    DBUG("Creating NodePartitionedMesh from '{}'", subdomain_mesh->getName());
 
    auto const subdomain_global_node_ids =
        computeGlobalNodeIDsOfSubDomainPartition(bulk_mesh, subdomain_mesh);
 
    // according to comment in struct PartitionedMeshInfo this value
    // is unused
    unsigned long number_of_global_base_nodes = 0;
 
    unsigned long const number_of_global_nodes =
        getNumberOfGlobalNodes(subdomain_mesh);
    auto numbers_of_regular_base_nodes_at_rank =
        computeNumberOfRegularBaseNodesAtRank(subdomain_mesh);
    auto numbers_of_regular_higher_order_nodes_at_rank =
        computeNumberOfRegularHigherOrderNodesAtRank(subdomain_mesh);
 
    auto const number_of_regular_nodes =
        computeNumberOfRegularNodes(bulk_mesh, subdomain_mesh);
    DBUG("[{}] number_of_regular_nodes: {}", subdomain_mesh->getName(),
         number_of_regular_nodes);
    auto const [nodes, elements] =
        copyNodesAndElements(subdomain_mesh->getElements());
 
    return std::make_unique<NodePartitionedMesh>(
        subdomain_mesh->getName(), nodes, subdomain_global_node_ids, elements,
        subdomain_mesh->getProperties(), number_of_global_base_nodes,
        number_of_global_nodes, number_of_regular_nodes,
        std::move(numbers_of_regular_base_nodes_at_rank),
        std::move(numbers_of_regular_higher_order_nodes_at_rank));
}

References computeGlobalNodeIDsOfSubDomainPartition(), computeNumberOfRegularBaseNodesAtRank(), computeNumberOfRegularHigherOrderNodesAtRank(), computeNumberOfRegularNodes(), copyNodesAndElements(), DBUG(), MeshLib::Mesh::getElements(), MeshLib::Mesh::getName(), getNumberOfGlobalNodes(), and MeshLib::Mesh::getProperties().

Referenced by MeshGeoToolsLib::constructAdditionalMeshesFromGeometries(), and parseOutputMeshConfig().

vtkStandardNewMacro()

MeshLib::vtkStandardNewMacro

(

VtkMappedMeshSource

)

Definition at line 32 of file VtkMappedMeshSource.cpp.

{
    this->Superclass::PrintSelf(os, indent);
    os << indent << "Mesh: " << (_mesh ? _mesh->getName() : "(none)") << endl;
}

References MeshLib::VtkMappedMeshSource::_mesh, and MeshLib::Mesh::getName().

Variable Documentation

mesh_item_type_strings

constexpr char const* MeshLib::mesh_item_type_strings[]

staticconstexpr

Initial value:

= {
    "node", "edge", "face", "cell", "integration_point"}

Char array names for all of MeshItemType values.

Definition at line 24 of file Location.h.

Referenced by toString().