MeshLib Namespace Reference

Detailed Description

Author

Karsten Rink

Date

2010-08-25

Copyright

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

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

Contains all functionality concerned with defining and obtaining information about meshes and their components (nodes, elements). Also includes additional algorithms for generating and modifying meshes and elements.

See also

MeshGenerator

Namespaces
	anonymous_namespace{AngleSkewMetric.cpp}
	anonymous_namespace{ConvertToLinearMesh.cpp}
	BoundaryExtraction
	detail
	details
	IO
	MeshGenerator
	ProjectPointOnMesh
	RasterDataToMesh
	Adding pixel values from a raster onto nodes or cells of a mesh.

Classes
class	PropertyVector
struct	CoordinateSystemType
	Coordinate system type. More...
class	CoordinateSystem
	Coordinate systems. More...
class	ElementCoordinatesMappingLocal
class	CellRule
class	NoEdgeReturn
	Returns always null pointer. More...
class	LinearEdgeReturn
	Returns linear order edge. More...
class	QuadraticEdgeReturn
	Returns quadratic order edge. More...
class	EdgeRule
class	Element
class	FaceRule
class	HexRule20
class	HexRule8
class	LineRule2
class	LineRule3
class	PointRule1
	A 0d point element. More...
class	PrismRule15
class	PrismRule6
class	PyramidRule13
class	PyramidRule5
class	QuadRule4
class	QuadRule8
class	QuadRule9
class	TemplateElement
class	TetRule10
class	TetRule4
class	TriRule3
class	TriRule6
class	VertexRule
class	ElementStatus
struct	Location
class	Mesh
class	ElementValueModification
	A set of methods for manipulating mesh element values. More...
class	Mesh2MeshPropertyInterpolation
class	MeshRevision
class	MeshLayerMapper
	Manipulating and adding prism element layers to an existing 2D mesh. More...
class	RasterToMesh
	Converts raster data into an OGS mesh. More...
class	VtkMeshConverter
	Converter for VtkUnstructured Grids to OGS meshes. More...
class	MeshInformation
	A set of tools for extracting information from a mesh. More...
struct	AngleSkewMetric
struct	EdgeRatioMetric
class	ElementQualityInterface
class	ElementQualityMetric
class	ElementSizeMetric
struct	MeshValidation
	A collection of methods for testing mesh quality and correctness. More...
struct	RadiusEdgeRatioMetric
struct	SizeDifferenceMetric
class	ElementSearch
	Element search class. More...
class	MeshElementGrid
class	NodeSearch
	Node search class. More...
class	MeshSubset
	A subset of nodes on a single mesh. More...
class	MeshSurfaceExtraction
	A set of tools concerned with extracting nodes and elements from a mesh surface. More...
class	Node
class	NodeAdjacencyTable
class	NodePartitionedMesh
	A subdomain mesh. More...
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	PropertyVectorBase
class	PropertyVector< T * >
class	VtkMappedMeshSource
class	VtkMeshNodalCoordinatesTemplate

Typedefs
using	RotationMatrix = Eigen::Matrix< double, 3u, 3u, Eigen::RowMajor >
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
bool	convertMeshToGeo (const MeshLib::Mesh &mesh, GeoLib::GEOObjects &geo_objects, double const eps)
MeshLib::Mesh *	convertSurfaceToMesh (const GeoLib::Surface &sfc, const std::string &mesh_name, double eps)
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. More...
bool	hasZeroVolume (MeshLib::Element const &element)
	Returns true if the element has zero length/area/volume. More...
MeshLib::Node	getCenterOfGravity (MeshLib::Element const &element)
	Calculates the center of gravity for the mesh element. More...
std::pair< double, double >	computeSqrNodeDistanceRange (MeshLib::Element const &element, bool const check_allnodes=true)
	Compute the minimum and maximum node distances for this element. More...
std::pair< double, double >	computeSqrEdgeLengthRange (Element const &element)
	Compute the minimum and maximum squared edge length for this element. More...
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. More...
std::size_t	getNodeIndex (Element const &element, unsigned const idx)
MathLib::Point3d	getBulkElementPoint (Tri const &, std::size_t const face_id, MathLib::WeightedPoint1D const &wp)
MathLib::Point3d	getBulkElementPoint (Hex const &, std::size_t const face_id, MathLib::WeightedPoint2D const &wp)
MathLib::Point3d	getBulkElementPoint (Mesh const &mesh, std::size_t const bulk_element_id, std::size_t const bulk_face_id, MathLib::WeightedPoint1D const &wp)
MathLib::Point3d	getBulkElementPoint (Mesh const &mesh, std::size_t bulk_element_id, std::size_t bulk_face_id, MathLib::WeightedPoint2D const &wp)
MathLib::Point3d	getBulkElementPoint (Mesh const &, std::size_t, std::size_t, MathLib::WeightedPoint3D const &)
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. More...
bool	operator< (const Location &left, const Location &right)
	Lexicographic order of Location. More...
std::vector< std::vector< Element const * > >	findElementsConnectedToNodes (Mesh const &mesh)
void	scaleMeshPropertyVector (MeshLib::Mesh &mesh, std::string const &property_name, double factor)
PropertyVector< int > const *	materialIDs (Mesh const &mesh)
std::unique_ptr< MeshLib::Mesh >	createMeshFromElementSelection (std::string mesh_name, std::vector< MeshLib::Element * > const &elements)
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. More...
bool	operator!= (Mesh const &a, Mesh const &b)
template<typename T >
void	addPropertyToMesh (Mesh &mesh, std::string const &name, MeshItemType item_type, std::size_t number_of_components, std::vector< T > const &values)
template<typename T >
PropertyVector< T > *	getOrCreateMeshProperty (Mesh &mesh, std::string const &property_name, MeshItemType const item_type, int const number_of_components)
std::unique_ptr< Mesh >	createMeshFromElementSelection (std::string mesh_name, std::vector< Element * > const &elements)
MeshLib::Element *	extrudeElement (std::vector< MeshLib::Node * > const &subsfc_nodes, MeshLib::Element const &sfc_elem, MeshLib::PropertyVector< std::size_t > const &sfc_to_subsfc_id_map, std::map< std::size_t, std::size_t > const &subsfc_sfc_id_map)
MeshLib::Mesh *	addLayerToMesh (MeshLib::Mesh const &mesh, double thickness, std::string const &name, bool on_top, bool copy_material_ids)
std::unique_ptr< MeshLib::Mesh >	convertToLinearMesh (MeshLib::Mesh const &org_mesh, std::string const &new_mesh_name)
std::vector< Node * >	copyNodeVector (const std::vector< Node * > &nodes)
	Creates a deep copy of a Node vector. More...
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)
std::vector< Element * >	cloneElements (std::vector< Element * > const &elements)
	Clones a vector of elements using the Element::clone() function. More...
std::unique_ptr< Element >	createFlippedElement (Element const &elem, std::vector< Node * > const &nodes)
std::unique_ptr< Mesh >	createFlippedMesh (Mesh const &mesh)
template<typename T >
void	fillNodeProperty (std::vector< T > &new_prop, std::vector< T > const &old_prop, std::vector< size_t > node_ids)
template<typename T >
void	fillElemProperty (std::vector< T > &new_prop, std::vector< T > const &old_prop, std::vector< size_t > elem_ids)
template<typename Iterator >
void	moveMeshNodes (Iterator begin, Iterator end, MeshLib::Node const &displacement)
MeshLib::Mesh *	removeElements (const MeshLib::Mesh &mesh, const std::vector< std::size_t > &removed_element_ids, const std::string &new_mesh_name)
std::vector< bool >	markUnusedNodes (std::vector< Element * > const &elements, std::vector< Node * > const &nodes)
	Marks nodes not used by any of the elements. More...
void	removeMarkedNodes (std::vector< bool > const &nodes_to_delete, std::vector< Node * > &nodes)
	Deallocates and removes nodes marked true. More...
MeshLib::Mesh *	removeNodes (const MeshLib::Mesh &mesh, const std::vector< std::size_t > &del_nodes_idx, const std::string &new_mesh_name)
std::string	MeshElemType2String (const MeshElemType t)
	Given a MeshElemType this returns the appropriate string. More...
std::string	MeshElemType2StringShort (const MeshElemType t)
	Given a MeshElemType this returns the appropriate string with a short name. More...
MeshElemType	String2MeshElemType (const std::string &s)
	Given a string of the shortened name of the element type, this returns the corresponding MeshElemType. More...
std::vector< MeshElemType >	getMeshElemTypes ()
	Returns a vector of all mesh element types. More...
std::vector< std::string >	getMeshElemTypeStringsShort ()
	Returns a vector of strings of mesh element types. More...
std::string	CellType2String (const CellType t)
	Given a MeshElemType this returns the appropriate string. More...
std::string	MeshQualityType2String (const MeshQualityType t)
MeshLib::MeshQualityType	String2MeshQualityType (std::string const &s)
std::unique_ptr< Mesh >	createQuadraticOrderMesh (Mesh const &linear_mesh, bool const add_centre_node)
static void	trackSurface (MeshLib::Element const *const element, std::vector< unsigned > &sfc_idx, unsigned const current_index)
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. More...
template<typename T >
void	processPropertyVector (MeshLib::PropertyVector< T > const &property, std::vector< std::size_t > const &id_map, MeshLib::Mesh &sfc_mesh)
bool	createSfcMeshProperties (MeshLib::Mesh &sfc_mesh, MeshLib::Properties const &properties, std::vector< std::size_t > const &node_ids_map, std::vector< std::size_t > const &element_ids_map)
std::tuple< std::vector< MeshLib::Node * >, std::vector< std::size_t > >	createNodesAndIDMapFromElements (std::vector< MeshLib::Element * > const &elements, std::size_t const n_all_nodes)
void	createSurfaceElementsFromElement (MeshLib::Element const &surface_element, std::vector< MeshLib::Element * > &surface_elements, std::vector< std::size_t > &element_to_bulk_element_id_map, std::vector< std::size_t > &element_to_bulk_face_id_map)
std::tuple< std::vector< MeshLib::Element * >, std::vector< std::size_t >, std::vector< std::size_t > >	createBoundaryElements (MeshLib::Mesh const &bulk_mesh)
void	addBulkIDPropertiesToMesh (MeshLib::Mesh &surface_mesh, std::string const &node_to_bulk_node_id_map_name, std::vector< std::size_t > const &node_to_bulk_node_id_map, std::string const &element_to_bulk_element_id_map_name, std::vector< std::size_t > const &element_to_bulk_element_id_map, std::string const &element_to_bulk_face_id_map_name, std::vector< std::size_t > const &element_to_bulk_face_id_map)
std::vector< Eigen::MatrixXd >	getElementRotationMatrices (int const space_dimension, int const mesh_dimension, std::vector< Element * > const &elements)
	Element rotation matrix computation. More...
int	getSpaceDimension (std::vector< Node * > const &nodes)
	Computes dimension of the embedding space containing the set of given points. More...
bool	is2DMeshOnRotatedVerticalPlane (Mesh const &mesh)
void	setMeshSpaceDimension (std::vector< std::unique_ptr< Mesh >> const &meshes)
	vtkStandardNewMacro (VtkMappedMeshSource) void VtkMappedMeshSource

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

Typedef Documentation

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 23 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 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 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 MeshLib::MeshItemType

strong

Enumerator
Node
Edge
Face
Cell
IntegrationPoint

Definition at line 21 of file Location.h.

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

MeshQualityType

enum 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 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

addBulkIDPropertiesToMesh()

void MeshLib::addBulkIDPropertiesToMesh	(	MeshLib::Mesh &	surface_mesh,
		std::string const &	node_to_bulk_node_id_map_name,
		std::vector< std::size_t > const &	node_to_bulk_node_id_map,
		std::string const &	element_to_bulk_element_id_map_name,
		std::vector< std::size_t > const &	element_to_bulk_element_id_map,
		std::string const &	element_to_bulk_face_id_map_name,
		std::vector< std::size_t > const &	element_to_bulk_face_id_map
	)

Definition at line 498 of file MeshSurfaceExtraction.cpp.

{
    // transmit the original node ids of the bulk mesh as a property
    if (!node_to_bulk_node_id_map_name.empty())
    {
        MeshLib::addPropertyToMesh(surface_mesh, node_to_bulk_node_id_map_name,
                                   MeshLib::MeshItemType::Node, 1,
                                   node_to_bulk_node_id_map);
    }
 
    // transmit the original bulk element ids as a property
    if (!element_to_bulk_element_id_map_name.empty())
    {
        MeshLib::addPropertyToMesh(
            surface_mesh, element_to_bulk_element_id_map_name,
            MeshLib::MeshItemType::Cell, 1, element_to_bulk_element_id_map);
    }
 
    // transmit the face id of the original bulk element as a property
    if (!element_to_bulk_face_id_map_name.empty())
    {
        MeshLib::addPropertyToMesh(
            surface_mesh, element_to_bulk_face_id_map_name,
            MeshLib::MeshItemType::Cell, 1, element_to_bulk_face_id_map);
    }
}

References addPropertyToMesh(), Cell, and Node.

Referenced by MeshLib::BoundaryExtraction::getBoundaryElementsAsMesh(), and MeshLib::MeshSurfaceExtraction::getMeshSurface().

addLayerToMesh()

MeshLib::Mesh * MeshLib::addLayerToMesh	(	MeshLib::Mesh const &	mesh,
		double	thickness,
		std::string const &	name,
		bool	on_top,
		bool	copy_material_ids
	)

Adds a layer to the mesh. If on_top is true, the layer is added on top, if it is false, the layer is added at the bottom.

Definition at line 85 of file AddLayerToMesh.cpp.

{
    INFO("Extracting top surface of mesh '{:s}' ... ", mesh.getName());
    double const flag = on_top ? -1.0 : 1.0;
    Eigen::Vector3d const dir({0, 0, flag});
    double const angle(90);
    std::unique_ptr<MeshLib::Mesh> sfc_mesh(nullptr);
 
    std::string const prop_name("bulk_node_ids");
 
    if (mesh.getDimension() == 3)
    {
        sfc_mesh.reset(MeshLib::MeshSurfaceExtraction::getMeshSurface(
            mesh, dir, angle, prop_name));
    }
    else
    {
        sfc_mesh = (on_top) ? std::make_unique<MeshLib::Mesh>(mesh)
                            : std::unique_ptr<MeshLib::Mesh>(
                                  MeshLib::createFlippedMesh(mesh));
        // add property storing node ids
        auto* const pv =
            sfc_mesh->getProperties().createNewPropertyVector<std::size_t>(
                prop_name, MeshLib::MeshItemType::Node, 1);
        if (pv)
        {
            pv->resize(sfc_mesh->getNumberOfNodes());
            std::iota(pv->begin(), pv->end(), 0);
        }
        else
        {
            ERR("Could not create and initialize property '{%s}'.", prop_name);
            return nullptr;
        }
    }
    INFO("done.");
 
    // *** add new surface nodes
    std::vector<MeshLib::Node*> subsfc_nodes =
        MeshLib::copyNodeVector(mesh.getNodes());
    std::vector<MeshLib::Element*> subsfc_elements =
        MeshLib::copyElementVector(mesh.getElements(), subsfc_nodes);
 
    std::size_t const n_subsfc_nodes(subsfc_nodes.size());
 
    std::vector<MeshLib::Node*> const& sfc_nodes(sfc_mesh->getNodes());
    std::size_t const n_sfc_nodes(sfc_nodes.size());
 
    if (!sfc_mesh->getProperties().existsPropertyVector<std::size_t>(prop_name))
    {
        ERR("Need subsurface node ids, but the property '{:s}' is not "
            "available.",
            prop_name);
        return nullptr;
    }
    // fetch subsurface node ids PropertyVector
    auto const* const node_id_pv =
        sfc_mesh->getProperties().getPropertyVector<std::size_t>(prop_name);
 
    // *** copy sfc nodes to subsfc mesh node
    std::map<std::size_t, std::size_t> subsfc_sfc_id_map;
    for (std::size_t k(0); k < n_sfc_nodes; ++k)
    {
        std::size_t const subsfc_id((*node_id_pv)[k]);
        std::size_t const sfc_id(k + n_subsfc_nodes);
        subsfc_sfc_id_map.insert(std::make_pair(subsfc_id, sfc_id));
        MeshLib::Node const& node(*sfc_nodes[k]);
        subsfc_nodes.push_back(new MeshLib::Node(
            node[0], node[1], node[2] - (flag * thickness), sfc_id));
    }
 
    // *** insert new layer elements into subsfc_mesh
    std::vector<MeshLib::Element*> const& sfc_elements(sfc_mesh->getElements());
    std::size_t const n_sfc_elements(sfc_elements.size());
    for (std::size_t k(0); k < n_sfc_elements; ++k)
    {
        subsfc_elements.push_back(extrudeElement(
            subsfc_nodes, *sfc_elements[k], *node_id_pv, subsfc_sfc_id_map));
    }
 
    auto new_mesh = new MeshLib::Mesh(name, subsfc_nodes, subsfc_elements);
 
    if (!mesh.getProperties().existsPropertyVector<int>("MaterialIDs"))
    {
        ERR("Could not copy the property 'MaterialIDs' since the original mesh "
            "does not contain such a property.");
        return new_mesh;
    }
    auto const* const materials =
        mesh.getProperties().getPropertyVector<int>("MaterialIDs");
 
    auto* const new_materials =
        new_mesh->getProperties().createNewPropertyVector<int>(
            "MaterialIDs", MeshLib::MeshItemType::Cell, 1);
    if (!new_materials)
    {
        ERR("Can not set material properties for new layer");
        return new_mesh;
    }
 
    new_materials->reserve(subsfc_elements.size());
    std::copy(materials->cbegin(), materials->cend(),
              std::back_inserter(*new_materials));
 
    if (copy_material_ids &&
        sfc_mesh->getProperties().existsPropertyVector<int>("MaterialIDs"))
    {
        auto const& sfc_material_ids =
            *sfc_mesh->getProperties().getPropertyVector<int>("MaterialIDs");
        std::copy(sfc_material_ids.cbegin(), sfc_material_ids.cend(),
                  std::back_inserter(*new_materials));
    }
    else
    {
        int const new_layer_id(
            *(std::max_element(materials->cbegin(), materials->cend())) + 1);
        auto const n_new_props(subsfc_elements.size() -
                               mesh.getNumberOfElements());
        std::fill_n(std::back_inserter(*new_materials), n_new_props,
                    new_layer_id);
    }
 
    return new_mesh;
}

References Cell, MathLib::LinAlg::copy(), copyElementVector(), copyNodeVector(), createFlippedMesh(), ERR(), MeshLib::Properties::existsPropertyVector(), extrudeElement(), MeshLib::Mesh::getDimension(), MeshLib::Mesh::getElements(), MeshLib::MeshSurfaceExtraction::getMeshSurface(), MeshLib::Mesh::getName(), MeshLib::Mesh::getNodes(), MeshLib::Mesh::getNumberOfElements(), MeshLib::Mesh::getProperties(), MeshLib::Properties::getPropertyVector(), INFO(), MaterialPropertyLib::name, and Node.

Referenced by MeshLib::MeshGenerator::generateRegularPrismMesh(), main(), and MeshView::openAddLayerDialog().

addPropertyToMesh()

template<typename T >

void MeshLib::addPropertyToMesh	(	Mesh &	mesh,
		std::string const &	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 193 of file Mesh.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, MathLib::LinAlg::copy(), MeshLib::Properties::createNewPropertyVector(), MeshLib::Mesh::getNumberOfElements(), MeshLib::Mesh::getNumberOfNodes(), MeshLib::Mesh::getProperties(), ApplicationUtils::NodeWiseMeshPartitioner::mesh(), MaterialPropertyLib::name, Node, and OGS_FATAL.

Referenced by addBulkIDPropertiesToMesh(), createMeshFromElementSelection(), ParameterLib::createRandomFieldMeshElementParameter(), main(), and anonymous_namespace{IdentifySubdomainMesh.cpp}::updateOrCheckExistingSubdomainProperty().

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

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 331 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 = nodes[i];
 
        // Get all elements, to which this node is connected.
        auto const& connected_elements =
            elements_connected_to_nodes[node->getID()];
 
        // 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(),
                  [](Node* a, Node* b) { return a->getID() < b->getID(); });
        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 44 of file Utils.h.

{
    Eigen::Vector3d surface_element_normal;
    if (surface_element.getDimension() < 2)
    {
        auto const bulk_element_normal =
            MeshLib::FaceRule::getSurfaceNormal(bulk_element);
        auto const v0 = Eigen::Map<Eigen::Vector3d const>(
            surface_element.getNode(0)->getCoords());
        auto const v1 = Eigen::Map<Eigen::Vector3d const>(
            surface_element.getNode(1)->getCoords());
        Eigen::Vector3d const edge_vector = v1 - v0;
        surface_element_normal = bulk_element_normal.cross(edge_vector);
    }
    else
    {
        surface_element_normal =
            MeshLib::FaceRule::getSurfaceNormal(surface_element);
    }
 
    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::TemplatePoint< T, DIM >::getCoords(), MeshLib::Element::getDimension(), MeshLib::Element::getNode(), and MeshLib::FaceRule::getSurfaceNormal().

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 convertToLinearMesh(), createQuadraticElement(), getBulkElementPoint(), and main().

cloneElements()

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

(

std::vector< Element * > const &

elements

)

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

Definition at line 118 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 e) { return e->clone(); });
    return cloned_elements;
}

References MeshLib::Element::clone().

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

computeSqrEdgeLengthRange()

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

(

Element const &

element

)

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

Definition at line 162 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 MeshLib::Mesh::calcEdgeLengthRange(), and MeshLib::RadiusEdgeRatioMetric::calculateQuality().

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

convertMeshToGeo()

bool MeshLib::convertMeshToGeo	(	const MeshLib::Mesh &	mesh,
		GeoLib::GEOObjects &	geo_objects,
		double	eps = std::numeric_limits< double >::epsilon()
	)

Converts a 2D mesh into a geometry. A new geometry with the name of the mesh will be inserted into geo_objects, consisting of points identical with mesh nodes and one surface representing the mesh. Triangles are converted to geometric triangles, quads are split into two triangles, all other elements are ignored.

Definition at line 77 of file convertMeshToGeo.cpp.

{
    if (mesh.getDimension() != 2)
    {
        ERR("Mesh to geometry conversion is only working for 2D meshes.");
        return false;
    }
 
    // Special handling of the bounds in case there are no materialIDs present.
    auto get_material_ids_and_bounds = [&]()
        -> std::tuple<MeshLib::PropertyVector<int> const*, std::pair<int, int>>
    {
        auto const materialIds = materialIDs(mesh);
        if (!materialIds)
        {
            return std::make_tuple(nullptr, std::make_pair(0, 0));
        }
 
        auto const bounds = MeshInformation::getValueBounds(*materialIds);
        if (!bounds)
        {
            OGS_FATAL(
                "Could not get minimum/maximum ranges values for the "
                "MaterialIDs property in the mesh '{:s}'.",
                mesh.getName());
        }
        return std::make_tuple(materialIds, *bounds);
    };
 
    auto const [materialIds, bounds] = get_material_ids_and_bounds();
    // elements to surface triangles conversion
    const unsigned nMatGroups(bounds.second - bounds.first + 1);
    auto sfcs = std::make_unique<std::vector<GeoLib::Surface*>>();
    sfcs->reserve(nMatGroups);
    std::string const geoobject_name =
        convertMeshNodesToGeoPoints(mesh, eps, geo_objects);
    auto const& points = *geo_objects.getPointVec(geoobject_name);
    for (unsigned i = 0; i < nMatGroups; ++i)
    {
        sfcs->push_back(new GeoLib::Surface(points));
    }
 
    const std::vector<std::size_t>& id_map(
        geo_objects.getPointVecObj(geoobject_name)->getIDMap());
    const std::vector<MeshLib::Element*>& elements = mesh.getElements();
    const std::size_t nElems(mesh.getNumberOfElements());
 
    for (unsigned i = 0; i < nElems; ++i)
    {
        auto surfaceId = !materialIds ? 0 : ((*materialIds)[i] - bounds.first);
        addElementToSurface(*elements[i], id_map, *(*sfcs)[surfaceId]);
    }
 
    std::for_each(sfcs->begin(), sfcs->end(),
                  [](GeoLib::Surface*& sfc)
                  {
                      if (sfc->getNumberOfTriangles() == 0)
                      {
                          delete sfc;
                          sfc = nullptr;
                      }
                  });
    auto sfcs_end = std::remove(sfcs->begin(), sfcs->end(), nullptr);
    sfcs->erase(sfcs_end, sfcs->end());
 
    geo_objects.addSurfaceVec(std::move(sfcs), geoobject_name);
    return true;
}

References anonymous_namespace{convertMeshToGeo.cpp}::addElementToSurface(), anonymous_namespace{convertMeshToGeo.cpp}::convertMeshNodesToGeoPoints(), ERR(), MeshLib::Mesh::getDimension(), MeshLib::Mesh::getElements(), GeoLib::PointVec::getIDMap(), MeshLib::Mesh::getName(), MeshLib::Mesh::getNumberOfElements(), GeoLib::GEOObjects::getPointVec(), GeoLib::GEOObjects::getPointVecObj(), MeshLib::MeshInformation::getValueBounds(), materialIDs(), and OGS_FATAL.

Referenced by MainWindow::convertMeshToGeometry(), FileIO::createSurface(), and main().

convertSurfaceToMesh()

MeshLib::Mesh * MeshLib::convertSurfaceToMesh	(	const GeoLib::Surface &	sfc,
		const std::string &	mesh_name,
		double	eps = std::numeric_limits< double >::epsilon()
	)

Converts a surface into a triangular mesh

Parameters

sfc	Surface object
mesh_name	New mesh name
eps	Minimum distance for nodes not to be collapsed

Returns

a pointer to a converted mesh object. nullptr is returned if the conversion fails.

Definition at line 148 of file convertMeshToGeo.cpp.

{
    // convert to a mesh including duplicated nodes
    std::vector<MeshLib::Node*> nodes;
    std::vector<MeshLib::Element*> elements;
    std::size_t nodeId = 0;
    for (std::size_t i = 0; i < sfc.getNumberOfTriangles(); i++)
    {
        auto* tri = sfc[i];
        auto** tri_nodes = new MeshLib::Node*[3];
        for (unsigned j = 0; j < 3; j++)
        {
            tri_nodes[j] =
                new MeshLib::Node(tri->getPoint(j)->getCoords(), nodeId++);
        }
        elements.push_back(new MeshLib::Tri(tri_nodes, i));
        for (unsigned j = 0; j < 3; j++)
        {
            nodes.push_back(tri_nodes[j]);
        }
    }
    MeshLib::Mesh mesh_with_duplicated_nodes(mesh_name, nodes, elements);
 
    // remove duplicated nodes
    MeshLib::MeshRevision rev(mesh_with_duplicated_nodes);
    return rev.simplifyMesh(mesh_with_duplicated_nodes.getName(), eps);
}

References MeshLib::Mesh::getName(), GeoLib::Surface::getNumberOfTriangles(), and MeshLib::MeshRevision::simplifyMesh().

Referenced by main().

convertToLinearMesh()

std::unique_ptr< MeshLib::Mesh > MeshLib::convertToLinearMesh	(	const MeshLib::Mesh &	mesh,
		const std::string &	new_mesh_name
	)

Converts a non-linear mesh to a linear mesh. All the mesh properties will be copied except for entries for non-linear nodes.

Definition at line 59 of file ConvertToLinearMesh.cpp.

{
    std::vector<MeshLib::Node*> vec_new_nodes =
        MeshLib::copyNodeVector(MeshLib::getBaseNodes(org_mesh.getElements()));
 
    // create new elements with the quadratic nodes
    std::vector<MeshLib::Element*> vec_new_eles;
    for (MeshLib::Element const* e : org_mesh.getElements())
    {
        if (e->getCellType() == MeshLib::CellType::LINE3)
        {
            vec_new_eles.push_back(
                createLinearElement<MeshLib::Line>(e, vec_new_nodes));
        }
        else if (e->getCellType() == MeshLib::CellType::QUAD8)
        {
            vec_new_eles.push_back(
                createLinearElement<MeshLib::Quad>(e, vec_new_nodes));
        }
        else if (e->getCellType() == MeshLib::CellType::TRI6)
        {
            vec_new_eles.push_back(
                createLinearElement<MeshLib::Tri>(e, vec_new_nodes));
        }
        else if (e->getCellType() == MeshLib::CellType::HEX20)
        {
            vec_new_eles.push_back(
                createLinearElement<MeshLib::Hex>(e, vec_new_nodes));
        }
        else if (e->getCellType() == MeshLib::CellType::TET10)
        {
            vec_new_eles.push_back(
                createLinearElement<MeshLib::Tet>(e, vec_new_nodes));
        }
        else
        {
            OGS_FATAL("Mesh element type {:s} is not supported",
                      MeshLib::CellType2String(e->getCellType()));
        }
    }
 
    auto new_mesh = std::make_unique<MeshLib::Mesh>(
        new_mesh_name, vec_new_nodes, vec_new_eles,
        org_mesh.getProperties().excludeCopyProperties(
            std::vector<MeshLib::MeshItemType>(1,
                                               MeshLib::MeshItemType::Node)));
 
    // copy property vectors for nodes
    for (auto [name, property] : org_mesh.getProperties())
    {
        if (property->getMeshItemType() != MeshLib::MeshItemType::Node)
        {
            continue;
        }
        auto double_property = dynamic_cast<PropertyVector<double>*>(property);
        if (double_property == nullptr)
        {
            continue;
        }
        auto const n_src_comp = double_property->getNumberOfGlobalComponents();
        auto new_prop =
            new_mesh->getProperties().createNewPropertyVector<double>(
                name, MeshLib::MeshItemType::Node, n_src_comp);
        new_prop->resize(new_mesh->getNumberOfNodes() * n_src_comp);
 
        // copy only base node values
        for (unsigned i = 0; i < org_mesh.getNumberOfBaseNodes(); i++)
        {
            for (int j = 0; j < n_src_comp; j++)
            {
                (*new_prop)[i * n_src_comp + j] =
                    (*double_property)[i * n_src_comp + j];
            }
        }
    }
 
    return new_mesh;
}

References CellType2String(), copyNodeVector(), MeshLib::Properties::excludeCopyProperties(), getBaseNodes(), MeshLib::Mesh::getElements(), MeshLib::Mesh::getNumberOfBaseNodes(), MeshLib::PropertyVectorBase::getNumberOfGlobalComponents(), MeshLib::Mesh::getProperties(), HEX20, LINE3, MaterialPropertyLib::name, Node, OGS_FATAL, QUAD8, TET10, and TRI6.

Referenced by main(), and anonymous_namespace{postLIE.cpp}::postVTU().

copyElement()

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 51 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 MeshLib::MeshRevision::simplifyMesh().

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 34 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(), addLayerToMesh(), MeshGeoToolsLib::appendLinesAlongPolylines(), createMeshFromElements(), LayeredVolume::createRasterLayers(), MeshLib::BoundaryExtraction::getBoundaryElementsAsMesh(), MeshLib::MeshSurfaceExtraction::getMeshSurface(), main(), removeElements(), and removeNodes().

copyNodeVector()

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

(

const std::vector< Node * > &

nodes

)

Creates a deep copy of a Node vector.

Definition at line 22 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]->getCoords(), new_nodes.size()));
    }
    return new_nodes;
}

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

createBoundaryElements()

std::tuple<std::vector<MeshLib::Element*>, std::vector<std::size_t>, std::vector<std::size_t> > MeshLib::createBoundaryElements

(

MeshLib::Mesh const &

bulk_mesh

)

Definition at line 413 of file MeshSurfaceExtraction.cpp.

{
    std::vector<std::size_t> element_to_bulk_element_id_map;
    std::vector<std::size_t> element_to_bulk_face_id_map;
    std::vector<MeshLib::Element*> surface_elements;
 
    auto const& bulk_elements = bulk_mesh.getElements();
    auto const mesh_dimension = bulk_mesh.getDimension();
 
    for (auto const* elem : bulk_elements)
    {
        const unsigned element_dimension(elem->getDimension());
        if (element_dimension < mesh_dimension)
        {
            continue;
        }
 
        if (!elem->isBoundaryElement())
        {
            continue;
        }
        createSurfaceElementsFromElement(*elem, surface_elements,
                                         element_to_bulk_element_id_map,
                                         element_to_bulk_face_id_map);
    }
    return {surface_elements, element_to_bulk_element_id_map,
            element_to_bulk_face_id_map};
}

References createSurfaceElementsFromElement(), MeshLib::Mesh::getDimension(), and MeshLib::Mesh::getElements().

Referenced by MeshLib::BoundaryExtraction::getBoundaryElementsAsMesh().

createFlippedElement()

std::unique_ptr< Element > MeshLib::createFlippedElement	(	Element const &	elem,
		std::vector< Node * > const &	nodes
	)

Creates a copy of an 1d / 2d element where the node order is reversed, such that the direction of a line changes and normals of 2D elements changes its sign.

Parameters

elem	original element
nodes	node vector used for the copy of the element

Returns

a flipped copy of the element

Definition at line 22 of file FlipElements.cpp.

{
    if (elem.getDimension() > 2)
    {
        return nullptr;
    }
 
    unsigned const n_nodes(elem.getNumberOfNodes());
    auto elem_nodes = std::make_unique<Node*[]>(n_nodes);
    for (unsigned i = 0; i < n_nodes; ++i)
    {
        elem_nodes[i] = nodes[elem.getNode(i)->getID()];
    }
    std::swap(elem_nodes[0], elem_nodes[1]);
 
    if (elem.getGeomType() == MeshElemType::LINE)
    {
        return std::make_unique<Line>(elem_nodes.release(), elem.getID());
    }
    if (elem.getGeomType() == MeshElemType::TRIANGLE)
    {
        return std::make_unique<Tri>(elem_nodes.release(), elem.getID());
    }
    if (elem.getGeomType() == MeshElemType::QUAD)
    {
        std::swap(elem_nodes[2], elem_nodes[3]);
        return std::make_unique<Quad>(elem_nodes.release(), elem.getID());
    }
    return nullptr;
}

References MeshLib::Element::getDimension(), MeshLib::Element::getGeomType(), MathLib::Point3dWithID::getID(), MeshLib::Element::getID(), MeshLib::Element::getNode(), MeshLib::Element::getNumberOfNodes(), LINE, QUAD, and TRIANGLE.

Referenced by createFlippedMesh().

createFlippedMesh()

std::unique_ptr< Mesh > MeshLib::createFlippedMesh

(

Mesh const &

mesh

)

Creates a copy of a 1d / 2d mesh where the node order of all elements is reversed such that the direction of lines changes and normals of 2D elements changes their sign.

Parameters

mesh	input mesh

Returns

a flipped copy of the input mesh

Definition at line 54 of file FlipElements.cpp.

{
    if (mesh.getDimension() > 2)
    {
        return nullptr;
    }
 
    std::vector<Node*> new_nodes(copyNodeVector(mesh.getNodes()));
    std::vector<Element*> const& elems(mesh.getElements());
    std::vector<Element*> new_elems;
    std::size_t n_elems(mesh.getNumberOfElements());
    new_elems.reserve(n_elems);
 
    for (std::size_t i = 0; i < n_elems; ++i)
    {
        new_elems.push_back(
            createFlippedElement(*elems[i], new_nodes).release());
    }
 
    return std::make_unique<Mesh>("FlippedElementMesh", new_nodes, new_elems,
                                  mesh.getProperties());
}

References copyNodeVector(), createFlippedElement(), MeshLib::Mesh::getDimension(), MeshLib::Mesh::getElements(), MeshLib::Mesh::getNodes(), MeshLib::Mesh::getNumberOfElements(), and MeshLib::Mesh::getProperties().

Referenced by addLayerToMesh().

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 268 of file Mesh.cpp.

{
    DBUG("Found {:d} elements in the mesh", elements.size());
 
    // Store bulk element ids for each of the new elements.
    std::vector<std::size_t> bulk_element_ids;
    bulk_element_ids.reserve(elements.size());
    std::transform(begin(elements), end(elements),
                   std::back_inserter(bulk_element_ids),
                   [&](auto const& e) { return e->getID(); });
 
    // original node pointers to newly created nodes.
    std::unordered_map<const MeshLib::Node*, MeshLib::Node*> nodes_map;
    nodes_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 = nodes_map.find(n);
            if (it == nodes_map.end())
            {
                auto new_node_in_map = nodes_map[n] = new MeshLib::Node(*n);
                e->setNode(i, new_node_in_map);
            }
            else
            {
                e->setNode(i, it->second);
            }
        }
    }
 
    // Copy the unique nodes pointers.
    std::vector<MeshLib::Node*> element_nodes;
    element_nodes.reserve(nodes_map.size());
    std::transform(begin(nodes_map), end(nodes_map),
                   std::back_inserter(element_nodes),
                   [](auto const& pair) { return pair.second; });
 
    // Store bulk node ids for each of the new nodes.
    std::vector<std::size_t> bulk_node_ids;
    bulk_node_ids.reserve(nodes_map.size());
    std::transform(begin(nodes_map), end(nodes_map),
                   std::back_inserter(bulk_node_ids),
                   [](auto const& pair) { return pair.first->getID(); });
 
    auto mesh = std::make_unique<MeshLib::Mesh>(
        std::move(mesh_name), std::move(element_nodes), std::move(elements));
    assert(mesh != nullptr);
 
    addPropertyToMesh(*mesh, "bulk_element_ids", MeshLib::MeshItemType::Cell, 1,
                      bulk_element_ids);
    addPropertyToMesh(*mesh, "bulk_node_ids", MeshLib::MeshItemType::Node, 1,
                      bulk_node_ids);
 
    return mesh;
}

References addPropertyToMesh(), Cell, DBUG(), and Node.

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

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 268 of file Mesh.cpp.

{
    DBUG("Found {:d} elements in the mesh", elements.size());
 
    // Store bulk element ids for each of the new elements.
    std::vector<std::size_t> bulk_element_ids;
    bulk_element_ids.reserve(elements.size());
    std::transform(begin(elements), end(elements),
                   std::back_inserter(bulk_element_ids),
                   [&](auto const& e) { return e->getID(); });
 
    // original node pointers to newly created nodes.
    std::unordered_map<const MeshLib::Node*, MeshLib::Node*> nodes_map;
    nodes_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 = nodes_map.find(n);
            if (it == nodes_map.end())
            {
                auto new_node_in_map = nodes_map[n] = new MeshLib::Node(*n);
                e->setNode(i, new_node_in_map);
            }
            else
            {
                e->setNode(i, it->second);
            }
        }
    }
 
    // Copy the unique nodes pointers.
    std::vector<MeshLib::Node*> element_nodes;
    element_nodes.reserve(nodes_map.size());
    std::transform(begin(nodes_map), end(nodes_map),
                   std::back_inserter(element_nodes),
                   [](auto const& pair) { return pair.second; });
 
    // Store bulk node ids for each of the new nodes.
    std::vector<std::size_t> bulk_node_ids;
    bulk_node_ids.reserve(nodes_map.size());
    std::transform(begin(nodes_map), end(nodes_map),
                   std::back_inserter(bulk_node_ids),
                   [](auto const& pair) { return pair.first->getID(); });
 
    auto mesh = std::make_unique<MeshLib::Mesh>(
        std::move(mesh_name), std::move(element_nodes), std::move(elements));
    assert(mesh != nullptr);
 
    addPropertyToMesh(*mesh, "bulk_element_ids", MeshLib::MeshItemType::Cell, 1,
                      bulk_element_ids);
    addPropertyToMesh(*mesh, "bulk_node_ids", MeshLib::MeshItemType::Node, 1,
                      bulk_node_ids);
 
    return mesh;
}

References addPropertyToMesh(), Cell, DBUG(), and Node.

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

createNodesAndIDMapFromElements()

std::tuple<std::vector<MeshLib::Node*>, std::vector<std::size_t> > MeshLib::createNodesAndIDMapFromElements	(	std::vector< MeshLib::Element * > const &	elements,
		std::size_t const	n_all_nodes
	)

Definition at line 161 of file MeshSurfaceExtraction.cpp.

{
    std::vector<MeshLib::Node const*> tmp_nodes(n_all_nodes, nullptr);
    for (auto const* elem : elements)
    {
        auto const n_nodes = elem->getNumberOfNodes();
        for (unsigned j = 0; j < n_nodes; ++j)
        {
            const MeshLib::Node* node(elem->getNode(j));
            tmp_nodes[node->getID()] = node;
        }
    }
 
    std::vector<MeshLib::Node*> nodes;
    std::vector<std::size_t> node_id_map(n_all_nodes);
    for (unsigned i = 0; i < n_all_nodes; ++i)
    {
        if (tmp_nodes[i])
        {
            node_id_map[i] = nodes.size();
            nodes.push_back(new MeshLib::Node(*tmp_nodes[i]));
        }
    }
    return {nodes, node_id_map};
}

References MathLib::Point3dWithID::getID().

Referenced by MeshLib::BoundaryExtraction::getBoundaryElementsAsMesh(), MeshLib::MeshSurfaceExtraction::getMeshSurface(), and MeshLib::MeshSurfaceExtraction::getSurfaceNodes().

createQuadraticOrderMesh()

std::unique_ptr< Mesh > MeshLib::createQuadraticOrderMesh	(	Mesh const &	linear_mesh,
		bool const	add_centre_node
	)

Create a quadratic order mesh from the linear order mesh. For some element types like Quad-4, a centre node might be added if the add_centre_node flag is set, yielding a Quad-9.

Definition at line 139 of file QuadraticMeshGenerator.cpp.

{
    // Clone the linear mesh nodes.
    auto quadratic_mesh_nodes = MeshLib::copyNodeVector(linear_mesh.getNodes());
 
    // Temporary container for unique quadratic nodes with O(log(n)) search.
    std::set<MeshLib::Node*, nodeByCoordinatesComparator> unique_nodes;
 
    // Create new elements with the quadratic nodes
    std::vector<MeshLib::Element*> quadratic_elements;
    auto const& linear_mesh_elements = linear_mesh.getElements();
    for (MeshLib::Element const* e : linear_mesh_elements)
    {
        auto quadratic_element = createQuadraticElement(*e, add_centre_node);
 
        // Replace the base nodes with cloned linear nodes.
        int const number_base_nodes = quadratic_element->getNumberOfBaseNodes();
        for (int i = 0; i < number_base_nodes; ++i)
        {
            quadratic_element->setNode(
                i, quadratic_mesh_nodes[getNodeIndex(*quadratic_element, i)]);
        }
 
        // Make the new (middle-edge) nodes unique.
        int const number_all_nodes = quadratic_element->getNumberOfNodes();
        for (int i = number_base_nodes; i < number_all_nodes; ++i)
        {
            Node* original_node =
                const_cast<Node*>(quadratic_element->getNode(i));
 
            auto it = unique_nodes.insert(original_node);
            if (!it.second)  // same node was already inserted before, no
                             // insertion
            {
                // Replace the element's node with the unique node.
                quadratic_element->setNode(i, *it.first);
                // And delete the original node
                delete original_node;
            }
        }
 
        quadratic_elements.push_back(quadratic_element.release());
    }
 
    // Add the unique quadratic nodes to the cloned linear nodes.
    quadratic_mesh_nodes.reserve(linear_mesh.getNodes().size() +
                                 unique_nodes.size());
    std::copy(unique_nodes.begin(), unique_nodes.end(),
              std::back_inserter(quadratic_mesh_nodes));
 
    return std::make_unique<MeshLib::Mesh>(
        linear_mesh.getName(), quadratic_mesh_nodes, quadratic_elements,
        linear_mesh.getProperties().excludeCopyProperties(
            std::vector<MeshLib::MeshItemType>(1,
                                               MeshLib::MeshItemType::Node)));
}

References MathLib::LinAlg::copy(), copyNodeVector(), createQuadraticElement(), MeshLib::Properties::excludeCopyProperties(), MeshLib::Mesh::getElements(), MeshLib::Mesh::getName(), getNodeIndex(), MeshLib::Mesh::getNodes(), MeshLib::Mesh::getProperties(), and Node.

Referenced by main().

createSfcMeshProperties()

bool MeshLib::createSfcMeshProperties	(	MeshLib::Mesh &	sfc_mesh,
		MeshLib::Properties const &	properties,
		std::vector< std::size_t > const &	node_ids_map,
		std::vector< std::size_t > const &	element_ids_map
	)

Definition at line 52 of file MeshSurfaceExtraction.cpp.

{
    std::size_t const n_elems(sfc_mesh.getNumberOfElements());
    std::size_t const n_nodes(sfc_mesh.getNumberOfNodes());
    if (node_ids_map.size() != n_nodes)
    {
        ERR("createSfcMeshProperties() - Incorrect number of node IDs ({:d}) "
            "compared to actual number of surface nodes ({:d}).",
            node_ids_map.size(), n_nodes);
        return false;
    }
 
    if (element_ids_map.size() != n_elems)
    {
        ERR("createSfcMeshProperties() - Incorrect number of element IDs "
            "({:d}) compared to actual number of surface elements ({:d}).",
            element_ids_map.size(), n_elems);
        return false;
    }
    std::map<MeshLib::MeshItemType, std::vector<std::size_t> const*> const
        id_maps = {{MeshItemType::Cell, &element_ids_map},
                   {MeshItemType::Node, &node_ids_map}};
 
    std::size_t vectors_copied(0);
    std::size_t vectors_skipped(0);
    for (auto [name, property] : properties)
    {
        if (property->getMeshItemType() != MeshItemType::Cell &&
            property->getMeshItemType() != MeshItemType::Node)
        {
            WARN(
                "Skipping property vector '{:s}' - not defined on cells or "
                "nodes.",
                name);
            vectors_skipped++;
            continue;
        }
 
        auto const& id_map = *id_maps.at(property->getMeshItemType());
        if (auto p = dynamic_cast<PropertyVector<double>*>(property))
        {
            processPropertyVector(*p, id_map, sfc_mesh);
            vectors_copied++;
        }
        else if (auto p = dynamic_cast<PropertyVector<float>*>(property))
        {
            processPropertyVector(*p, id_map, sfc_mesh);
            vectors_copied++;
        }
        else if (auto p = dynamic_cast<PropertyVector<int>*>(property))
        {
            processPropertyVector(*p, id_map, sfc_mesh);
            vectors_copied++;
        }
        else if (auto p = dynamic_cast<PropertyVector<unsigned>*>(property))
        {
            processPropertyVector(*p, id_map, sfc_mesh);
            vectors_copied++;
        }
        else if (auto p = dynamic_cast<PropertyVector<long>*>(property))
        {
            processPropertyVector(*p, id_map, sfc_mesh);
            vectors_copied++;
        }
        else if (auto p = dynamic_cast<PropertyVector<long long>*>(property))
        {
            processPropertyVector(*p, id_map, sfc_mesh);
            vectors_copied++;
        }
        else if (auto p =
                     dynamic_cast<PropertyVector<unsigned long>*>(property))
        {
            processPropertyVector(*p, id_map, sfc_mesh);
            vectors_copied++;
        }
        else if (auto p = dynamic_cast<PropertyVector<unsigned long long>*>(
                     property))
        {
            processPropertyVector(*p, id_map, sfc_mesh);
            vectors_copied++;
        }
        else if (auto p = dynamic_cast<PropertyVector<std::size_t>*>(property))
        {
            processPropertyVector(*p, id_map, sfc_mesh);
            vectors_copied++;
        }
        else if (auto p = dynamic_cast<PropertyVector<char>*>(property))
        {
            processPropertyVector(*p, id_map, sfc_mesh);
            vectors_copied++;
        }
        else
        {
            WARN(
                "Skipping property vector '{:s}' - no matching data type "
                "'{:s}' found.",
                name, typeid(*property).name());
            vectors_skipped++;
        }
    }
    INFO("{:d} property vectors copied, {:d} vectors skipped.", vectors_copied,
         vectors_skipped);
    return true;
}

References Cell, ERR(), MeshLib::Mesh::getNumberOfElements(), MeshLib::Mesh::getNumberOfNodes(), INFO(), MaterialPropertyLib::name, Node, processPropertyVector(), and WARN().

Referenced by MeshLib::BoundaryExtraction::getBoundaryElementsAsMesh(), and MeshLib::MeshSurfaceExtraction::getMeshSurface().

createSurfaceElementsFromElement()

void MeshLib::createSurfaceElementsFromElement	(	MeshLib::Element const &	surface_element,
		std::vector< MeshLib::Element * > &	surface_elements,
		std::vector< std::size_t > &	element_to_bulk_element_id_map,
		std::vector< std::size_t > &	element_to_bulk_face_id_map
	)

Definition at line 390 of file MeshSurfaceExtraction.cpp.

{
    const unsigned n_faces(surface_element.getNumberOfBoundaries());
    for (unsigned j = 0; j < n_faces; ++j)
    {
        if (surface_element.getNeighbor(j) != nullptr)
        {
            continue;
        }
 
        surface_elements.push_back(
            const_cast<MeshLib::Element*>(surface_element.getBoundary(j)));
        element_to_bulk_face_id_map.push_back(j);
        element_to_bulk_element_id_map.push_back(surface_element.getID());
    }
}

References MeshLib::Element::getBoundary(), MeshLib::Element::getID(), MeshLib::Element::getNeighbor(), and MeshLib::Element::getNumberOfBoundaries().

Referenced by createBoundaryElements().

extrudeElement()

MeshLib::Element* MeshLib::extrudeElement	(	std::vector< MeshLib::Node * > const &	subsfc_nodes,
		MeshLib::Element const &	sfc_elem,
		MeshLib::PropertyVector< std::size_t > const &	sfc_to_subsfc_id_map,
		std::map< std::size_t, std::size_t > const &	subsfc_sfc_id_map
	)

Extrudes point, line, triangle or quad elements to its higher dimensional versions, i.e. line, quad, prism, hexahedron.

Parameters

subsfc_nodes	the nodes the elements are based on
sfc_elem	the element of the surface that will be extruded
sfc_to_subsfc_id_map	relation between the surface nodes of the surface element and the ids of the nodes of the subsurface mesh
subsfc_sfc_id_map	mapping of the surface nodes of the current mesh to the surface nodes of the extruded mesh

Returns

extruded element (point -> line, line -> quad, tri -> prism, quad -> hexahedron)

Definition at line 44 of file AddLayerToMesh.cpp.

{
    if (sfc_elem.getDimension() > 2)
    {
        return nullptr;
    }
 
    const unsigned nElemNodes(sfc_elem.getNumberOfBaseNodes());
    auto new_nodes = std::unique_ptr<MeshLib::Node* []> {
        new MeshLib::Node*[2 * nElemNodes]
    };
 
    for (unsigned j = 0; j < nElemNodes; ++j)
    {
        std::size_t const subsfc_id(
            sfc_to_subsfc_id_map[sfc_elem.getNode(j)->getID()]);
        new_nodes[j] = subsfc_nodes[subsfc_id];
        std::size_t new_idx = (nElemNodes == 2) ? (3 - j) : (nElemNodes + j);
        new_nodes[new_idx] = subsfc_nodes[subsfc_sfc_id_map.at(subsfc_id)];
    }
 
    if (sfc_elem.getGeomType() == MeshLib::MeshElemType::LINE)
    {
        return new MeshLib::Quad(new_nodes.release());
    }
    if (sfc_elem.getGeomType() == MeshLib::MeshElemType::TRIANGLE)
    {
        return new MeshLib::Prism(new_nodes.release());
    }
    if (sfc_elem.getGeomType() == MeshLib::MeshElemType::QUAD)
    {
        return new MeshLib::Hex(new_nodes.release());
    }
 
    return nullptr;
}

References MeshLib::Element::getDimension(), MeshLib::Element::getGeomType(), MathLib::Point3dWithID::getID(), MeshLib::Element::getNode(), MeshLib::Element::getNumberOfBaseNodes(), LINE, QUAD, and TRIANGLE.

Referenced by addLayerToMesh().

fillElemProperty()

template<typename T >

void MeshLib::fillElemProperty	(	std::vector< T > &	new_prop,
		std::vector< T > const &	old_prop,
		std::vector< size_t >	elem_ids
	)

Definition at line 242 of file MeshRevision.cpp.

{
    std::transform(elem_ids.cbegin(), elem_ids.cend(),
                   std::back_inserter(new_prop),
                   [&](std::size_t const i) { return old_prop[i]; });
}

Referenced by MeshLib::MeshRevision::copyProperties().

fillNodeProperty()

template<typename T >

void MeshLib::fillNodeProperty	(	std::vector< T > &	new_prop,
		std::vector< T > const &	old_prop,
		std::vector< size_t >	node_ids
	)

Definition at line 225 of file MeshRevision.cpp.

{
    std::size_t const n_nodes = node_ids.size();
    for (std::size_t i = 0; i < n_nodes; ++i)
    {
        if (node_ids[i] != i)
        {
            continue;
        }
        new_prop.push_back(old_prop[i]);
    }
}

Referenced by MeshLib::MeshRevision::copyProperties().

filter()

template<typename Container , typename Predicate >

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

Definition at line 22 of file ElementSearch.cpp.

{
    std::vector<std::size_t> matchedIDs;
    std::size_t i = 0;
    for (auto value : container)
    {
        if (p(value))
        {
            matchedIDs.push_back(i);
        }
        i++;
    }
    return matchedIDs;
}

Referenced by VtkAddFilterDialog::VtkAddFilterDialog(), VtkVisPipeline::highlightGeoObject(), VtkVisPipeline::highlightMeshComponent(), VtkAddFilterDialog::on_buttonBox_accepted(), VtkAddFilterDialog::on_filterListWidget_currentRowChanged(), MeshLib::ElementSearch::searchByBoundingBox(), MeshLib::ElementSearch::searchByContent(), MeshLib::ElementSearch::searchByElementType(), and VtkVisPipeline::showMeshElementQuality().

findElementsConnectedToNodes()

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

(

Mesh const &

mesh

)

Definition at line 35 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())
    {
        unsigned const number_nodes(element->getNumberOfNodes());
        for (unsigned j = 0; j < number_nodes; ++j)
        {
            auto const node_id = element->getNode(j)->getID();
            elements_connected_to_nodes[node_id].push_back(element);
        }
    }
    return elements_connected_to_nodes;
}

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

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)
    {
        for (auto const& n : start_element_nodes)
        {
            if (MathLib::sqrDist(*test_node, n) <= radius_squared)
            {
                return true;
            }
        }
        return false;
    };
 
    // 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(), MeshLib::Element::getNumberOfNodes(), and MathLib::sqrDist().

Referenced by ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, 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, [](Node const* a, Node* b) {
        return a->getID() < b->getID();
    });
 
    return base_nodes;
}

References MathLib::LinAlg::copy(), MathLib::Point3dWithID::getID(), and 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(), ProcessLib::ThermoRichardsMechanics::ThermoRichardsMechanicsProcess< DisplacementDim >::constructDofTable(), and convertToLinearMesh().

getBulkElementPoint() [1/5]

MathLib::Point3d MeshLib::getBulkElementPoint	(	Hex const &	hex,
		std::size_t const	face_id,
		MathLib::WeightedPoint2D const &	wp
	)

Maps the given 2d boundary point wp of a quad face, given in local coordinates of the quad, to 3d point existing on a hexahedron face also in local coordinates.

Maps the given lower dimensional 2d boundary point wp of a quad or triangle element, given in local coordinates of the quad or triangle, to a 3d point existing on a tet face also in local coordinates.

Maps the given lower dimensional 2d boundary point wp of a quad or triangle element, given in local coordinates of the quad or triangle, to a 3d point existing on a prism face also in local coordinates.

Maps the given lower dimensional 2d boundary point wp of a quad or triangle element, given in local coordinates of the quad or triangle, to a 3d point existing on a pyramid face also in local coordinates.

Definition at line 57 of file MapBulkElementPoint.cpp.

{
    switch (face_id)
    {
        case 0:
            return MathLib::Point3d{
                std::array<double, 3>{{wp[1], wp[0], -1.0}}};
        case 1:
            return MathLib::Point3d{
                std::array<double, 3>{{wp[0], -1.0, wp[1]}}};
        case 2:
            return MathLib::Point3d{std::array<double, 3>{{1.0, wp[0], wp[1]}}};
        case 3:
            return MathLib::Point3d{
                std::array<double, 3>{{-wp[0], -1.0, wp[1]}}};
        case 4:
            return MathLib::Point3d{
                std::array<double, 3>{{-1.0, -wp[0], -wp[1]}}};
        case 5:
            return MathLib::Point3d{std::array<double, 3>{{wp[0], wp[1], 1.0}}};
        default:
            OGS_FATAL("Invalid face id '{:d}' for the hexahedron.", face_id);
    }
}

References OGS_FATAL.

getBulkElementPoint() [2/5]

MathLib::Point3d MeshLib::getBulkElementPoint	(	Mesh const &	,
		std::size_t	,
		std::size_t	,
		MathLib::WeightedPoint3D const &
	)

Definition at line 206 of file MapBulkElementPoint.cpp.

{
    return MathLib::ORIGIN;
}

References MathLib::ORIGIN.

getBulkElementPoint() [3/5]

MathLib::Point3d MeshLib::getBulkElementPoint	(	Mesh const &	mesh,
		std::size_t	bulk_element_id,
		std::size_t	bulk_face_id,
		MathLib::WeightedPoint2D const &	wp
	)

Maps the given 2d boundary point wp of a boundary element, given in local coordinates of the boundary element, to 3d point existing on a bulk element also in local coordinates.

Definition at line 175 of file MapBulkElementPoint.cpp.

{
    auto const* element = mesh.getElement(bulk_element_id);
    if (element->getCellType() == CellType::HEX8)
    {
        Hex const& hex = *static_cast<Hex const*>(element);
        return getBulkElementPoint(hex, bulk_face_id, wp);
    }
    if (element->getCellType() == CellType::PRISM6)
    {
        Prism const& prism = *static_cast<Prism const*>(element);
        return getBulkElementPoint(prism, bulk_face_id, wp);
    }
    if (element->getCellType() == CellType::PYRAMID5)
    {
        Pyramid const& pyramid = *static_cast<Pyramid const*>(element);
        return getBulkElementPoint(pyramid, bulk_face_id, wp);
    }
    if (element->getCellType() == CellType::TET4)
    {
        Tet const& tet = *static_cast<Tet const*>(element);
        return getBulkElementPoint(tet, bulk_face_id, wp);
    }
    OGS_FATAL("Wrong cell type '{:s}' or functionality not yet implemented.",
              CellType2String(element->getCellType()));
}

References CellType2String(), getBulkElementPoint(), MeshLib::Mesh::getElement(), HEX8, OGS_FATAL, PRISM6, PYRAMID5, and TET4.

getBulkElementPoint() [4/5]

MathLib::Point3d MeshLib::getBulkElementPoint	(	Mesh const &	mesh,
		std::size_t const	bulk_element_id,
		std::size_t const	bulk_face_id,
		MathLib::WeightedPoint1D const &	wp
	)

Maps the given 1d boundary point wp of a boundary element, given in local coordinates of the boundary element, to 3d point existing on a bulk element also in local coordinates.

Definition at line 155 of file MapBulkElementPoint.cpp.

{
    auto const* element = mesh.getElement(bulk_element_id);
    if (element->getCellType() == CellType::QUAD4)
    {
        Quad const& quad(*dynamic_cast<Quad const*>(element));
        return getBulkElementPoint(quad, bulk_face_id, wp);
    }
    if (element->getCellType() == CellType::TRI3)
    {
        Tri const& tri = *static_cast<Tri const*>(element);
        return getBulkElementPoint(tri, bulk_face_id, wp);
    }
    OGS_FATAL("Wrong cell type '{:s}' or functionality not yet implemented.",
              CellType2String(element->getCellType()));
}

References CellType2String(), getBulkElementPoint(), MeshLib::Mesh::getElement(), OGS_FATAL, QUAD4, and TRI3.

getBulkElementPoint() [5/5]

MathLib::Point3d MeshLib::getBulkElementPoint	(	Tri const &	tri,
		std::size_t const	face_id,
		MathLib::WeightedPoint1D const &	wp
	)

Maps the given lower dimensional boundary point wp of a line, i.e. the 1d integration point given in local coordinates of a line, to higher dimensional point of the triangle face (defined by the triangle element and the face id) also in local coordinates of the triangle element.

Parameters

tri	the triangle element
face_id	the id of the triangle face the point will be mapped on
wp	the integration point of the lower dimensional element

Returns

the mapped point

Maps the given lower dimensional boundary point wp of a line, i.e. the 1d integration point given in local coordinates of a line, to higher dimensional point of the quad face (defined by the quad element and the face id) also in local coordinates of the quad face.

Parameters

quad	the quad element
face_id	the id of the quad face the point will be mapped on
wp	the integration point of the lower dimensional element

Returns

the mapped point

Definition at line 17 of file MapBulkElementPoint.cpp.

{
    switch (face_id)
    {
        case 0:
            return MathLib::Point3d{std::array<double, 3>{{wp[0], 0.0, 0.0}}};
        case 1:
            return MathLib::Point3d{
                std::array<double, 3>{{1 - wp[0], wp[0], 0.0}}};
        case 2:
            return MathLib::Point3d{
                std::array<double, 3>{{0.0, 1 - wp[0], 0.0}}};
        default:
            OGS_FATAL("Invalid face id '{:d}' for the tri.", face_id);
    }
}

References OGS_FATAL.

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

getCenterOfGravity()

MeshLib::Node MeshLib::getCenterOfGravity

(

Element const &

element

)

Calculates the center of gravity for the mesh element.

Definition at line 126 of file Element.cpp.

{
    const unsigned nNodes(element.getNumberOfBaseNodes());
    MeshLib::Node center(0, 0, 0);
    for (unsigned i = 0; i < nNodes; ++i)
    {
        center[0] += (*element.getNode(i))[0];
        center[1] += (*element.getNode(i))[1];
        center[2] += (*element.getNode(i))[2];
    }
    center[0] /= nNodes;
    center[1] /= nNodes;
    center[2] /= nNodes;
    return center;
}

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

Referenced by ProcessLib::LIE::HydroMechanics::HydroMechanicsProcess< GlobalDim >::initializeConcreteProcess(), ProcessLib::LIE::SmallDeformation::SmallDeformationProcess< DisplacementDim >::initializeConcreteProcess(), main(), markFaults(), LayeredVolume::removeCongruentElements(), ProcessLib::LIE::setFractureProperty(), FileIO::FEFLOWMeshInterface::setMaterialIDs(), setMaterialIDs(), MeshLib::CellRule::testElementNodeOrder(), ProcessLib::ProcessVariable::updateDeactivatedSubdomains(), 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& 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::LiquidFlow::createLiquidFlowProcess().

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

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 212 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(), and MeshLib::MeshRevision::reduceHex().

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 225 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 MeshGeoToolsLib::BoundaryElementsAlongPolyline::BoundaryElementsAlongPolyline(), MeshGeoToolsLib::BoundaryElementsOnSurface::BoundaryElementsOnSurface(), ProcessLib::LIE::PostProcessTool::PostProcessTool(), anonymous_namespace{convertMeshToGeo.cpp}::addElementToSurface(), LayeredVolume::addLayerBoundaries(), LayeredVolume::addLayerToMesh(), MeshLib::MeshLayerMapper::addLayerToMesh(), ProcessLib::LIE::PostProcessTool::calculateTotalDisplacement(), MeshLib::RasterToMesh::convert(), createQuadraticOrderMesh(), FileIO::SwmmInterface::getLinkPointIds(), anonymous_namespace{IdentifySubdomainMesh.cpp}::identifySubdomainMeshElements(), MeshGeoToolsLib::BoundaryElementsAlongPolyline::includesAllEdgeNodeIDs(), NumLib::interpolateToHigherOrderNodes(), markUnusedNodes(), ProcessLib::LIE::HydroMechanics::LocalDataInitializer< LocalAssemblerInterface, LocalAssemblerDataMatrix, LocalAssemblerDataMatrixNearFracture, LocalAssemblerDataFracture, GlobalDim, ConstructorArgs >::operator()(), ProcessLib::LIE::SmallDeformation::LocalDataInitializer< LocalAssemblerInterface, LocalAssemblerDataMatrix, LocalAssemblerDataMatrixNearFracture, LocalAssemblerDataFracture, GlobalDim, ConstructorArgs >::operator()(), LayeredVolume::removeCongruentElements(), MeshLib::NodeSearch::searchNodesConnectedToOnlyGivenElements(), FileIO::FEFLOWMeshInterface::setMaterialIDs(), ProcessLib::LIE::HydroMechanics::HydroMechanicsLocalAssemblerMatrix< ShapeFunctionDisplacement, ShapeFunctionPressure, IntegrationMethod, GlobalDim >::setPressureOfInactiveNodes(), FileIO::TetGenInterface::writeElementToFacets(), and ApplicationUtils::writeMETIS().

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 234 of file Mesh.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, ApplicationUtils::NodeWiseMeshPartitioner::mesh(), 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 of a mesh is:

• 1, if the mesh is 1D and and the mesh is parallel either to \(x\), \(y\) or to \(z\) axis.
• 2, if the mesh is 1D but it contains inclined elements on the origin coordinate plane of \(x-y,\, y-z,\, \text{or }\, x-z\). That means the coordinates of all nodes are \((x, y, 0)\), \((x, 0, z)\) or \((0, y, z)\).
• 3, if the mesh is 1D and but it is not on any origin coordinate plane of \(x-y,\, y-z,\, \text{or }\, x-z\).
• 2, if the mesh is 2D and it is on the origin coordinate plane of \(x-y,\, y-z,\, \text{or }\, x-z\).
• 2, if the mesh is 2D and it is on vertical or horizontal plane that is parallel to the the origin coordinate plane of \(x-y,\, y-z,\, \text{or }\, x-z\) but with an offset.
• 3, if the mesh contains inclined 2D elements.
• 3, if the mesh contains 3D elements.

Definition at line 23 of file GetSpaceDimension.cpp.

{
    std::array x_magnitude = {0.0, 0.0, 0.0};
 
    double const* const x_ref = nodes[0]->getCoords();
    for (auto const& node : nodes)
    {
        auto const x = node->getCoords();
        for (int i = 0; i < 3; i++)
        {
            x_magnitude[i] += std::fabs(x[i] - x_ref[i]);
        }
    }
 
    return static_cast<int>(std::count_if(
        x_magnitude.begin(), x_magnitude.end(),
        [](const double x_i_magnitude)
        { return x_i_magnitude > std::numeric_limits<double>::epsilon(); }));
}

Referenced by 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 121 of file Element.cpp.

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

References MeshLib::Element::getContent().

Referenced by MeshLib::HexRule8::validate(), MeshLib::LineRule2::validate(), MeshLib::PointRule1::validate(), MeshLib::PrismRule6::validate(), MeshLib::PyramidRule5::validate(), MeshLib::QuadRule4::validate(), MeshLib::TetRule4::validate(), and MeshLib::TriRule3::validate().

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)->getCoords();
            auto const x2 = element->getNode(1)->getCoords();
            auto const x3 = element->getNode(2)->getCoords();
 
            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)->getCoords();
            auto const x2 = element->getNode(1)->getCoords();
            auto const x3 = element->getNode(2)->getCoords();
 
            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 370 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(), ApplicationUtils::findGhostNodesInPartition(), ApplicationUtils::findRegularNodesInPartition(), MeshLib::Mesh::getNumberOfBaseNodes(), NumLib::MeshComponentMap::getSubset(), MeshLib::NodePartitionedMesh::isGhostNode(), and ProcessLib::LIE::anonymous_namespace{MeshUtils.cpp}::IsCrackTip::operator()().

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 177 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 MeshLib::Mesh2MeshPropertyInterpolation::interpolatePropertiesForMesh().

markUnusedNodes()

std::vector< bool > MeshLib::markUnusedNodes	(	std::vector< Element * > const &	elements,
		std::vector< Node * > const &	nodes
	)

Marks nodes not used by any of the elements.

Definition at line 100 of file RemoveMeshComponents.cpp.

{
    std::vector<bool> unused_nodes(nodes.size(), true);
    for (auto e : elements)
    {
        for (unsigned i = 0; i < e->getNumberOfNodes(); i++)
        {
            unused_nodes[getNodeIndex(*e, i)] = false;
        }
    }
 
    return unused_nodes;
}

References getNodeIndex().

Referenced by createMeshFromElements(), and removeNodes().

materialIDs()

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();
    return properties.existsPropertyVector<int>("MaterialIDs",
                                                MeshLib::MeshItemType::Cell, 1)
               ? properties.getPropertyVector<int>(
                     "MaterialIDs", MeshLib::MeshItemType::Cell, 1)
               : nullptr;
}

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

Referenced by ProcessLib::HeatTransportBHE::HeatTransportBHEProcess::HeatTransportBHEProcess(), ProcessLib::LIE::HydroMechanics::HydroMechanicsProcess< GlobalDim >::HydroMechanicsProcess(), MeshGeoToolsLib::appendLinesAlongPolylines(), convertMeshToGeo(), ProcessLib::createDeactivatedSubdomain(), ProcessLib::createDeactivatedSubdomainMesh(), ProcessLib::LIE::HydroMechanics::createHydroMechanicsProcess(), ProcessLib::HydroMechanics::createHydroMechanicsProcess(), MaterialPropertyLib::createMaterialSpatialDistributionMap(), ProcessLib::PhaseField::createPhaseFieldProcess(), MaterialLib::PorousMedium::createPorousMediaProperties(), ProcessLib::RichardsMechanics::createRichardsMechanicsProcess(), ProcessLib::SmallDeformationNonlocal::createSmallDeformationNonlocalProcess(), ProcessLib::LIE::SmallDeformation::createSmallDeformationProcess(), ProcessLib::SmallDeformation::createSmallDeformationProcess(), ProcessLib::TH2M::createTH2MProcess(), ProcessLib::ThermalTwoPhaseFlowWithPP::createThermalTwoPhaseFlowWithPPProcess(), ProcessLib::ThermoHydroMechanics::createThermoHydroMechanicsProcess(), ProcessLib::ThermoMechanicalPhaseField::createThermoMechanicalPhaseFieldProcess(), ProcessLib::ThermoMechanics::createThermoMechanicsProcess(), ProcessLib::ThermoRichardsMechanics::createThermoRichardsMechanicsProcess(), ProcessLib::TwoPhaseFlowWithPP::createTwoPhaseFlowWithPPProcess(), ProcessLib::TwoPhaseFlowWithPrho::createTwoPhaseFlowWithPrhoProcess(), extractBoundaryMeshes(), ProcessLib::LIE::anonymous_namespace{MeshUtils.cpp}::findFracutreIntersections(), ProcessLib::HeatTransportBHE::getBHEDataInMesh(), ProcessLib::LIE::getFractureMatrixDataInMesh(), ProcessLib::LIE::HydroMechanics::HydroMechanicsProcess< GlobalDim >::initializeConcreteProcess(), main(), removeUnusedElements(), ElementTreeModel::setElement(), and ProcessLib::ProcessVariable::updateDeactivatedSubdomains().

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::setElement(), ElementTreeModel::setMesh(), and MeshLib::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.

Referenced by VtkVisPipeline::showMeshElementQuality(), and MeshLib::ElementQualityInterface::writeHistogram().

moveMeshNodes()

template<typename Iterator >

void MeshLib::moveMeshNodes	(	Iterator	begin,
		Iterator	end,
		MeshLib::Node const &	displacement
	)

Function that moves mesh nodes.

The function iterates over all mesh nodes between the begin and the end iterator and moves them using the given displacement.

Parameters

begin	begin iterator
end	end iterator
displacement	the displacement to use

Definition at line 32 of file moveMeshNodes.h.

{
    std::for_each(begin, end, [&displacement](MeshLib::Node* node)
        {
            (*node)[0] += displacement[0];
            (*node)[1] += displacement[1];
            (*node)[2] += displacement[2];
        }
    );
};

Referenced by main().

operator!=()

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

inline

Definition at line 171 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 89 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: { ";
    for (unsigned n = 0; n < nnodes; ++n)
    {
        os << nodes[n]->getID() << " @ " << nodes[n] << "  ";
    }
    os << "}\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 166 of file Mesh.h.

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

References MeshLib::Mesh::getID().

processPropertyVector()

template<typename T >

void MeshLib::processPropertyVector	(	MeshLib::PropertyVector< T > const &	property,
		std::vector< std::size_t > const &	id_map,
		MeshLib::Mesh &	sfc_mesh
	)

Definition at line 33 of file MeshSurfaceExtraction.cpp.

{
    auto const number_of_components = property.getNumberOfGlobalComponents();
 
    auto sfc_prop = getOrCreateMeshProperty<T>(
        sfc_mesh, property.getPropertyName(), property.getMeshItemType(),
        number_of_components);
    sfc_prop->clear();
    sfc_prop->reserve(id_map.size());
 
    for (auto bulk_id : id_map)
    {
        std::copy_n(&property.getComponent(bulk_id, 0 /*component_id*/),
                    number_of_components, back_inserter(*sfc_prop));
    }
}

References MeshLib::PropertyVector< PROP_VAL_TYPE >::getComponent(), MeshLib::PropertyVectorBase::getMeshItemType(), and MeshLib::PropertyVectorBase::getPropertyName().

Referenced by createSfcMeshProperties().

removeElements()

MeshLib::Mesh * MeshLib::removeElements	(	const MeshLib::Mesh &	mesh,
		const std::vector< std::size_t > &	removed_element_ids,
		const std::string &	new_mesh_name
	)

Removes mesh elements and returns a new mesh object. The original mesh is kept unchanged.

Parameters

mesh	an original mesh whose elements are removed
removed_element_ids	a vector of element indices to be removed
new_mesh_name	a new mesh name

Returns

a new mesh object

Definition at line 52 of file RemoveMeshComponents.cpp.

{
    if (removed_element_ids.empty())
    {
        INFO("No elements to remove");
        return nullptr;
    }
 
    INFO("Removing total {:d} elements...", removed_element_ids.size());
    std::vector<MeshLib::Element*> tmp_elems =
        details::excludeElementCopy(mesh.getElements(), removed_element_ids);
    INFO("{:d} elements remain in mesh.", tmp_elems.size());
 
    // copy node and element objects
    std::vector<MeshLib::Node*> new_nodes =
        MeshLib::copyNodeVector(mesh.getNodes());
    std::vector<MeshLib::Element*> new_elems =
        MeshLib::copyElementVector(tmp_elems, new_nodes);
 
    // delete unused nodes
    NodeSearch ns(mesh);
    ns.searchNodesConnectedToOnlyGivenElements(removed_element_ids);
    auto& removed_node_ids(ns.getSearchedNodeIDs());
    INFO("Removing total {:d} nodes...", removed_node_ids.size());
    for (auto nodeid : removed_node_ids)
    {
        delete new_nodes[nodeid];
        new_nodes[nodeid] = nullptr;
    }
    new_nodes.erase(std::remove(new_nodes.begin(), new_nodes.end(), nullptr),
                    new_nodes.end());
 
    if (!new_elems.empty())
    {
        MeshLib::Mesh* new_mesh =
            new MeshLib::Mesh(new_mesh_name, new_nodes, new_elems,
                              mesh.getProperties().excludeCopyProperties(
                                  removed_element_ids, removed_node_ids));
        return new_mesh;
    }
 
    INFO("Current selection removes all elements.");
    return nullptr;
}

References copyElementVector(), copyNodeVector(), MeshLib::Properties::excludeCopyProperties(), MeshLib::details::excludeElementCopy(), MeshLib::Mesh::getElements(), MeshLib::Mesh::getNodes(), MeshLib::Mesh::getProperties(), MeshLib::NodeSearch::getSearchedNodeIDs(), INFO(), and MeshLib::NodeSearch::searchNodesConnectedToOnlyGivenElements().

Referenced by MeshElementRemovalDialog::accept(), MeshLib::RasterToMesh::convert(), LayeredVolume::createRasterLayers(), extractMatGroup(), MeshLib::MeshGenerator::generateRegularPrismMesh(), main(), removeUnusedElements(), removeUnusedGridCells(), and writeBoundary().

removeMarkedNodes()

void MeshLib::removeMarkedNodes	(	std::vector< bool > const &	nodes_to_delete,
		std::vector< Node * > &	nodes
	)

Deallocates and removes nodes marked true.

Definition at line 115 of file RemoveMeshComponents.cpp.

{
    assert(nodes_to_delete.size() == nodes.size());
 
    for (std::size_t i = 0; i < nodes.size(); i++)
    {
        if (nodes_to_delete[i])
        {
            delete nodes[i];
            nodes[i] = nullptr;
        }
    }
    nodes.erase(remove(begin(nodes), end(nodes), nullptr), end(nodes));
}

Referenced by createMeshFromElements(), and removeNodes().

removeNodes()

MeshLib::Mesh * MeshLib::removeNodes	(	const MeshLib::Mesh &	mesh,
		const std::vector< std::size_t > &	del_nodes_idx,
		const std::string &	new_mesh_name
	)

Removes the mesh nodes (and connected elements) given in the nodes-list from the mesh.

Parameters

mesh	an original mesh whose elements are removed
del_nodes_idx	a vector of node indices to be removed
new_mesh_name	a new mesh name

Returns

a new mesh object

Definition at line 131 of file RemoveMeshComponents.cpp.

{
    if (del_nodes_idx.empty())
    {
        return nullptr;
    }
 
    // copy node and element objects
    std::vector<MeshLib::Node*> new_nodes =
        MeshLib::copyNodeVector(mesh.getNodes());
    std::vector<MeshLib::Element*> new_elems =
        MeshLib::copyElementVector(mesh.getElements(), new_nodes);
 
    // delete elements
    MeshLib::ElementSearch es(mesh);
    es.searchByNodeIDs(del_nodes_idx);
    auto& removed_element_ids = es.getSearchedElementIDs();
    for (auto eid : removed_element_ids)
    {
        delete new_elems[eid];
        new_elems[eid] = nullptr;
    }
    new_elems.erase(std::remove(new_elems.begin(), new_elems.end(), nullptr),
                    new_elems.end());
 
    // check unused nodes due to element deletion
    std::vector<bool> const node_delete_flag =
        markUnusedNodes(new_elems, new_nodes);
 
    // delete unused nodes
    removeMarkedNodes(node_delete_flag, new_nodes);
 
    if (!new_elems.empty())
    {
        MeshLib::Mesh* new_mesh =
            new MeshLib::Mesh(new_mesh_name, new_nodes, new_elems,
                              mesh.getProperties().excludeCopyProperties(
                                  removed_element_ids, del_nodes_idx));
        return new_mesh;
    }
 
    return nullptr;
}

References copyElementVector(), copyNodeVector(), MeshLib::Properties::excludeCopyProperties(), MeshLib::Mesh::getElements(), MeshLib::Mesh::getNodes(), MeshLib::Mesh::getProperties(), MeshLib::ElementSearch::getSearchedElementIDs(), markUnusedNodes(), removeMarkedNodes(), and MeshLib::ElementSearch::searchByNodeIDs().

Referenced by LayeredMeshGenerator::getMesh().

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 244 of file Mesh.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 20 of file SetMeshSpaceDimension.cpp.

{
    // Get the space dimension from the bulk mesh:
    auto const space_dimension = getSpaceDimension(meshes[0]->getNodes());
    for (auto& mesh : meshes)
    {
        auto elements = mesh->getElements();
        for (auto element : elements)
        {
            element->space_dimension_ = space_dimension;
        }
    }
}

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 MeshLib::IO::Legacy::MeshIO::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.

trackSurface()

static void MeshLib::trackSurface ( MeshLib::Element const *const  element, std::vector< unsigned > &  sfc_idx, unsigned const  current_index  )

static

Finds all surface elements that can be reached from element. All elements that are found in this way are marked in the global sfc_idx vector using the current_index.

Parameters

element	The mesh element from which the search is started
sfc_idx	The global index vector notifying to which surface elements belong
current_index	The index that all elements reachable from element will be assigned in sfc_idx

Definition at line 40 of file MeshValidation.cpp.

{
    std::stack<MeshLib::Element const*> elem_stack;
    elem_stack.push(element);
    while (!elem_stack.empty())
    {
        MeshLib::Element const* const elem = elem_stack.top();
        elem_stack.pop();
        sfc_idx[elem->getID()] = current_index;
        std::size_t const n_neighbors(elem->getNumberOfNeighbors());
        for (std::size_t i = 0; i < n_neighbors; ++i)
        {
            MeshLib::Element const* neighbor(elem->getNeighbor(i));
            if (neighbor != nullptr && sfc_idx[neighbor->getID()] ==
                                           std::numeric_limits<unsigned>::max())
            {
                elem_stack.push(neighbor);
            }
        }
    }
}

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

Referenced by MeshLib::MeshValidation::detectHoles().

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