Inheritance diagram for FEDD::RefinementFactory< SC, LO, GO, NO >:

[legend]

Public Types
typedef Mesh< SC, LO, GO, NO >	Mesh_Type

typedef MeshUnstructured< SC, LO, GO, NO >	MeshUnstr_Type

typedef Teuchos::RCP< MeshUnstructured< SC, LO, GO, NO > >	MeshUnstrPtr_Type

typedef std::vector< MeshUnstrPtr_Type >	MeshUnstrPtrArray_Type

typedef Mesh_Type::CommPtr_Type	CommPtr_Type

typedef Mesh_Type::CommConstPtr_Type	CommConstPtr_Type

typedef Elements	Elements_Type

typedef Teuchos::RCP< Elements_Type >	ElementsPtr_Type

typedef SurfaceElements	SurfaceElements_Type

typedef Teuchos::RCP< SurfaceElements_Type >	SurfaceElementsPtr_Type

typedef EdgeElements	EdgeElements_Type

typedef Teuchos::RCP< EdgeElements_Type >	EdgeElementsPtr_Type

typedef MeshInterface< SC, LO, GO, NO >	MeshInterface_Type

typedef Teuchos::RCP< MeshInterface_Type >	MeshInterfacePtr_Type

typedef Map< LO, GO, NO >	Map_Type

typedef Map_Type::MapPtr_Type	MapPtr_Type

typedef Map_Type::MapConstPtr_Type	MapConstPtr_Type

typedef MultiVector< SC, LO, GO, NO >	MultiVector_Type

typedef Teuchos::RCP< MultiVector_Type >	MultiVectorPtr_Type

typedef MultiVector< LO, LO, GO, NO >	MultiVectorLO_Type

typedef Teuchos::RCP< MultiVectorLO_Type >	MultiVectorLOPtr_Type

typedef MultiVector< GO, LO, GO, NO >	MultiVectorGO_Type

typedef Teuchos::RCP< MultiVectorGO_Type >	MultiVectorGOPtr_Type

typedef Teuchos::RCP< const MultiVector_Type >	MultiVectorPtrConst_Type

typedef Teuchos::OrdinalTraits< LO >	OTLO

typedef Matrix< SC, LO, GO, NO >	Matrix_Type

typedef Teuchos::RCP< Matrix_Type >	MatrixPtr_Type

Public Types inherited from FEDD::MeshUnstructured< default_sc, default_lo, default_go, default_no >
typedef Mesh< default_sc, default_lo, default_go, default_no >	Mesh_Type

typedef Teuchos::RCP< MeshUnstructured< default_sc, default_lo, default_go, default_no > >	MeshUnstrPtr_Type

typedef Teuchos::RCP< Mesh_Type >	MeshPtr_Type

typedef std::vector< MeshUnstrPtr_Type >	MeshUnstrPtrArray_Type

typedef Mesh_Type::CommPtr_Type	CommPtr_Type

typedef Mesh_Type::CommConstPtr_Type	CommConstPtr_Type

typedef Mesh_Type::Elements_Type	Elements_Type

typedef Mesh_Type::ElementsPtr_Type	ElementsPtr_Type

typedef EdgeElements	EdgeElements_Type

typedef Teuchos::RCP< EdgeElements_Type >	EdgeElementsPtr_Type

typedef SurfaceElements	SurfaceElements_Type

typedef Teuchos::RCP< SurfaceElements_Type >	SurfaceElementsPtr_Type

typedef MeshInterface< default_sc, default_lo, default_go, default_no >	MeshInterface_Type

typedef Teuchos::RCP< MeshInterface_Type >	MeshInterfacePtr_Type

typedef Map< default_lo, default_go, default_no >	Map_Type

typedef Map_Type::MapPtr_Type	MapPtr_Type

typedef Map_Type::MapConstPtr_Type	MapConstPtr_Type

typedef Teuchos::OrdinalTraits< default_lo >	OTLO

typedef MultiVector< default_sc, default_lo, default_go, default_no >	MultiVector_Type

typedef Teuchos::RCP< MultiVector_Type >	MultiVectorPtr_Type

typedef MultiVector< default_lo, default_lo, default_go, default_no >	MultiVectorLO_Type

typedef Teuchos::RCP< MultiVectorLO_Type >	MultiVectorLOPtr_Type

typedef Teuchos::RCP< const MultiVector_Type >	MultiVectorPtrConst_Type

typedef Matrix< default_sc, default_lo, default_go, default_no >	Matrix_Type

typedef Teuchos::RCP< Matrix_Type >	MatrixPtr_Type

Public Types inherited from FEDD::Mesh< default_sc, default_lo, default_go, default_no >
typedef Elements	Elements_Type

typedef FiniteElement	FiniteElement_Type

typedef Teuchos::RCP< FiniteElement_Type >	FiniteElementPtr_Type

typedef Teuchos::RCP< Elements_Type >	ElementsPtr_Type

typedef Teuchos::RCP< Mesh >	Mesh_ptr_Type

typedef Teuchos::RCP< Teuchos::Comm< int > >	CommPtr_Type

typedef Teuchos::RCP< const Teuchos::Comm< int > >	CommConstPtr_Type

typedef const CommConstPtr_Type	CommConstPtrConst_Type

typedef Map< default_lo, default_go, default_no >	Map_Type

typedef Teuchos::RCP< Map_Type >	MapPtr_Type

typedef Teuchos::RCP< const Map_Type >	MapConstPtr_Type

typedef Teuchos::RCP< const Map_Type >	MapConstPtrConst_Type

typedef MultiVector< default_sc, default_lo, default_go, default_no >	MultiVector_Type

typedef Teuchos::RCP< MultiVector_Type >	MultiVectorPtr_Type

typedef AABBTree< default_sc, default_lo, default_go, default_no >	AABBTree_Type

typedef Teuchos::RCP< AABBTree_Type >	AABBTreePtr_Type

Public Member Functions
	RefinementFactory (CommConstPtr_Type comm, int volumeID=10)
	Initiating RefinementFactory via MeshUnstructured.

	RefinementFactory (CommConstPtr_Type comm, int volumeID, ParameterListPtr_Type parameterListAll)
	Initiating RefinementFactory via MeshUnstructured with additional information for mesh refinement.

void	refineMesh (MeshUnstrPtr_Type meshP1, int iteration, MeshUnstrPtr_Type outputMesh, std::string refinementMode)
	Main function of RefinementFactory, performs one complete mesh refinement, according to red-green refinement (Verfuerth) or tetrahedral grid refinement (Bey).

void	refineRegular (EdgeElementsPtr_Type edgeElements, ElementsPtr_Type elements, int i, SurfaceElementsPtr_Type surfaceTriangleElements)
	2D and 3D regular refinement. Chosen by error estimator or otherwise elements are refined regular by connecting edge midpoints.

void	refineGreen (EdgeElementsPtr_Type edgeElements, ElementsPtr_Type elements, int i)
	2D green refinement: refining the element according to green scheme - connecting node on refined edge with the opposite node.

void	refineBlue (EdgeElementsPtr_Type edgeElements, ElementsPtr_Type elements, int i)
	2D blue refinement: refining element according to blue refinement scheme - connecting nodes of shorter edge with midpoint of longer tagged edge and connect that with opposite corner

void	refineRed (EdgeElementsPtr_Type edgeElements, ElementsPtr_Type elements, int i)
	2D red refinement: refining the element red by connecting all tagged edges midpoints. one element is refined into 4.

void	refineType1 (EdgeElementsPtr_Type edgeElements, ElementsPtr_Type elements, int indexElement, SurfaceElementsPtr_Type surfaceTriangleElements)
	3D Type(1) refinement as defined in "Tetrahedral Grid Refinement" by J. Bey 'Algorithm Regular Refinement' in Computing, Springer Verlag 1955

void	refineType2 (EdgeElementsPtr_Type edgeElements, ElementsPtr_Type elements, int indexElement, SurfaceElementsPtr_Type surfaceTriangleElements)
	3D Type(2) refinement as defined in "Tetrahedral Grid Refinement" by J. Bey 'Algorithm Regular Refinement' in Computing, Springer Verlag 1955

void	refineType3 (EdgeElementsPtr_Type edgeElements, ElementsPtr_Type elements, int indexElement, SurfaceElementsPtr_Type surfaceTriangleElements)
	3D Type(3) refinement as defined in "Tetrahedral Grid Refinement" by J. Bey 'Algorithm Regular Refinement' in Computing, Springer Verlag 1955

void	refineType4 (EdgeElementsPtr_Type edgeElements, ElementsPtr_Type elements, int indexElement, SurfaceElementsPtr_Type surfaceTriangleElements)
	3D Type(4) refinement as defined in "Tetrahedral Grid Refinement" by J. Bey 'Algorithm Regular Refinement' in Computing, Springer Verlag 1955

void	addMidpoint (EdgeElementsPtr_Type edgeElements, int i)
	Adding a Midpoint on an edge.

int	determineLongestEdge (EdgeElementsPtr_Type edgeElements, vec_int_Type edgeVec, vec2D_dbl_ptr_Type points)
	Eetermine longest edge in triangle.

void	buildEdgeMap (MapConstPtr_Type mapGlobalProc, MapConstPtr_Type mapProc)
	Building edgeMap after refinement.

void	buildNodeMap (EdgeElementsPtr_Type edgeElements, MapConstPtr_Type mapGlobalProc, MapConstPtr_Type mapProc, int newPoints, int newPointsRepeated)
	Building nodemap after refinement.

void	updateElementsOfEdgesLocalAndGlobal (int maxRank, MapConstPtr_Type edgeMap)
	Updating ElementsOfEdgesLocal and ElementsOfEdgesGlobal.

void	updateElementsOfSurfaceLocalAndGlobal (EdgeElementsPtr_Type edgeElements)

vec_bool_Type	checkInterfaceSurface (EdgeElementsPtr_Type edgeElements, vec_int_Type originFlag, vec_int_Type edgeNumbers, int indexElement)
	Checking if surfaces are part of the interface. Done by checking if all edges of a triangle are part of the interface and if both elements connected to the surface are on different processors.

void	refinementRestrictions (MeshUnstrPtr_Type meshP1, ElementsPtr_Type elements, EdgeElementsPtr_Type edgeElements, SurfaceElementsPtr_Type surfaceTriangleElements, int &newPoints, int &newPointsCommon, vec_GO_Type &globalInterfaceIDsTagged, MapConstPtr_Type mapInterfaceEdges, int &newElements)
	Refinement Restrictions.

void	refineMeshRegIreg (ElementsPtr_Type elements, EdgeElementsPtr_Type edgeElements, int &newElements, MapConstPtr_Type edgeMap, SurfaceElementsPtr_Type surfaceTriangleElements)
	Refinement performed according to the set of rules determined by Bey or Verfürth.

void	buildSurfaceTriangleElements (ElementsPtr_Type elements, EdgeElementsPtr_Type edgeElements, SurfaceElementsPtr_Type surfaceTriangleElements, MapConstPtr_Type edgeMap, MapConstPtr_Type elementMap)
	Building surface triangle elements, as they are not originally part of the mesh information provided by mesh partitioner.

void	setErrorEstimate (vec_dbl_Type errorElements)

vec_dbl_Type	getErrorEstimate ()

void	bisectEdges (EdgeElementsPtr_Type edgeElements, ElementsPtr_Type elements, int indexElement, SurfaceElementsPtr_Type surfaceTriangleElements, std::string mode="default")
	2D and 3D that bisects the edges of tagged Elements. Chosen by error estimator or otherwise elements are refined regular by connecting edge midpoints.

void	bisectElement3 (EdgeElementsPtr_Type edgeElements, ElementsPtr_Type elements, int indexElementp)
	2D refinement by bisection of tagged Elements with three tagged Edges.

Public Member Functions inherited from FEDD::MeshUnstructured< default_sc, default_lo, default_go, default_no >
	MeshUnstructured (CommConstPtr_Type comm, int volumeID=10)

void	buildP2ofP1MeshEdge (MeshUnstrPtr_Type meshP1)
	Function to build a P2 mesh of a P1 mesh.

void	setP2SurfaceElements (MeshUnstrPtr_Type meshP1)
	Adding the correct surface subelement to the new P2 Elements based on the P1 subelements.

void	setSurfaceP2 (FiniteElement &feP2, const FiniteElement &surfFeP1, const vec2D_int_Type &surfacePermutation, int dim)
	Helper function for setP2SurfaceElements. Adds the correct nodes to the meshP1 subelements. Based on sorted Elements.

void	addSurfaceP2Nodes (FiniteElement &feP2, const FiniteElement &surfFeP1, const vec2D_int_Type &surfacePermutation, int dim)
	Helper function for setP2SurfaceElements. Adds the correct nodes to the meshP1 subelements. Based on unsorted elements. Different approach than above. Based on edge Midpoints.

vec_int_Type	reorderP2SurfaceIndices (vec_int_Type &additionalP2IDs, vec_int_Type &index, bool track=false)
	Depending on the sorting of P1 surface nodes we have to adjust the new ordering of P2 edge midpoints for surfaces in 3D.

void	getLocalSurfaceIndices (vec2D_int_Type &surfacePermutation, int surfaceElementOrder)
	Get local Surface Indices.

void	getEdgeCombinations (vec2D_int_Type &edgeCombinations)
	Get edge combinations.

void	determinePositionInElementP2 (vec_int_Type &positions, vec_GO_Type &elementsGlobalOfEdge, default_lo p1ID, default_lo p2ID, MeshUnstrPtr_Type meshP1)
	Determine position of new P2 node in element, as all elements should follow the same structure.

int	determineFlagP2 (FiniteElement &fe, default_lo p1ID, default_lo p2ID, vec2D_int_Type &permutation)
	Essentially determine flag of an edge. Thus determine P2 Flag for building P2 mesh.

int	determineFlagP2 (default_lo p1ID, default_lo p2ID, default_lo localEdgeID, vec2D_LO_Type &markedPoint)
	Essentially determine flag of an edge. Thus determine P2 Flag for building P2 mesh. Longer version of other determineFlagP2 function. Also informs whether flag could be found or not (not always the case in parallel)

void	getTriangles (int vertex1ID, int vertex2ID, vec_int_Type &vertices3ID)

SurfaceElementsPtr_Type	getSurfaceTriangleElements ()

void	findSurfaces (const vec_int_Type &elementNodeList, vec_int_Type numbering, vec2D_int_Type &localSurfaceNodeList_vec, vec_int_Type &locSurfaces, bool critical=false)

void	findEdges (const vec_int_Type &elementNodeList, vec_int_Type numbering, vec2D_int_Type &localEdgeNodeList_vec, vec_int_Type &locEdges)
	Determine which edges belong to an element.

MeshInterfacePtr_Type	getMeshInterface ()
	Get mesh interface.

void	buildMeshInterfaceParallelAndDistance (MeshUnstrPtr_Type mesh, vec_int_Type flag_vec, vec_dbl_ptr_Type &distancesToInterface)

void	partitionInterface ()

void	setEdgeElements (EdgeElementsPtr_Type edgeElements)
	setEdgeElements with external edges

EdgeElementsPtr_Type	getEdgeElements ()
	Get EdgeElements.

ElementsPtr_Type	getSurfaceEdgeElements ()
	Get SurfaceEdgeElements. Edges as only surface elements (i.e. when reading .mesh file). Used in mesh partitioner.

void	readMeshSize ()
	Reading mesh size.

void	readMeshEntity (std::string entityType)
	Reading the .mesh files entities.

void	setMeshFileName (std::string meshFileName, std::string delimiter)
	Set the .mesh file name.

int	getNumGlobalNodes ()
	Get global number of nodes.

void	assignEdgeFlags ()
	Assigning flags to all edges.

void	buildEdgeMap ()
	Building an edgemap from scratch when edges are already distributed parallel.

void	exportMesh (MapConstPtr_Type mapUnique, MapConstPtr_Type mapRep, bool exportEdges=false, bool exportSurface=false, std::string meshName="export.mesh")
	Exporting Mesh as .mesh file. For most detailed export we also write surfaces and edges. This can be useful/necessary.

void	exportNodeFlags ()

void	exportElementFlags ()

Public Member Functions inherited from FEDD::Mesh< default_sc, default_lo, default_go, default_no >
	Mesh (CommConstPtrConst_Type &comm)

void	deleteData ()

void	setParameterList (ParameterListPtr_Type &pL)
	Setting input parameterlist to be parameterlist here.

ParameterListConstPtr_Type	getParameterList () const
	Getter for paramaeterlist that is set here.

vec_int_ptr_Type	getElementsFlag () const
	Getter for element flags.

MapConstPtr_Type	getMapUnique () const
	Getter for unique node map.

MapConstPtr_Type	getMapRepeated () const
	Getter for repeated node mal.

MapConstPtr_Type	getElementMap () const
	Getter for element map.

MapConstPtr_Type	getEdgeMap ()
	Getter for edge map.

vec2D_dbl_ptr_Type	getPointsRepeated () const
	getter for list of repeated points with x,y,z coordinates in each row

vec2D_dbl_ptr_Type	getPointsUnique () const
	getter for list of unique points with x,y,z coordinates in each row

vec_int_ptr_Type	getBCFlagRepeated () const
	Getter for flags corresponting to repeated points.

vec_int_ptr_Type	getBCFlagUnique () const
	Getter for flags corresponting to unique points.

ElementsPtr_Type	getElementsC ()
	Returns element list as c-object.

ElementsPtr_Type	getSurfaceElements ()
	Getter for surface elements. Probably set in mesh partitioner. They are generally the dim-1 surface elements.

int	getDimension ()

default_go	getNumElementsGlobal ()
	Global number of elements.

default_lo	getNumElements ()
	Local number of elements.

default_lo	getNumPoints (std::string type="Unique")
	Get local (LO) number of points either in unique or repeated version.

int	getOrderElement ()

CommConstPtrConst_Type	getComm ()
	Communicator object.

int	setStructuredMeshFlags (int flags)
	This is done in meshStructured. Maybe we should move it here or delete this.

void	setElementFlags (std::string type="")
	Something for TPM. Can be deprecated soon.

void	setReferenceConfiguration ()
	Setting current coordinates as reference configuration. Should only be called once :D.

void	moveMesh (MultiVectorPtr_Type displacementUnique, MultiVectorPtr_Type displacementRepeated)
	Moving mesh according to displacement based on reference configuration.

int	getSurfaceElementOrder ()
	Get SurfaceElement order.

int	getEdgeElementOrder ()
	Get EdgeElement order.

void	create_AABBTree ()

vec_int_ptr_Type	findElemsForPoints (vec2D_dbl_ptr_Type query_points)

vec_dbl_Type	getBaryCoords (vec_dbl_Type point, int element)

bool	isPointInElem (vec_dbl_Type point, int element)

tuple_intint_Type	getRankRange () const

void	deleteSurfaceElements ()
	Deleting surface elements, called after reading input mesh.

void	correctNormalDirections ()
	Correcting the normal direction of all surface normals set as subelements of volume elements to be outward normals.

void	correctElementOrientation ()
	Correct the element orientation of all elements to have positive volume / det when doint transformation.

vec2D_int_ptr_Type	getElements ()
	Returns elements as a vector type contrary to the C-object list.

Public Attributes
std::string	refinementRestriction_ = "none"

bool	writeRefinementTime_ = "true"

int	refinement3DDiagonal_ = 0

int	currentIter_ = 0

std::string	refinementMode_ = "Regular"

Public Attributes inherited from FEDD::MeshUnstructured< default_sc, default_lo, default_go, default_no >
MeshInterfacePtr_Type	meshInterface_

int	volumeID_

EdgeElementsPtr_Type	edgeElements_

ElementsPtr_Type	surfaceEdgeElements_

SurfaceElementsPtr_Type	surfaceTriangleElements_

std::string	meshFileName_

std::string	delimiter_

int	numSurfaces_

int	numEdges_

int	numNodes_

Public Attributes inherited from FEDD::Mesh< default_sc, default_lo, default_go, default_no >
int	dim_

long long	numElementsGlob_

std::string	FEType_

MapPtr_Type	mapUnique_

MapPtr_Type	mapRepeated_

vec2D_dbl_ptr_Type	pointsRep_

vec2D_dbl_ptr_Type	pointsUni_

vec_int_ptr_Type	bcFlagRep_

vec_int_ptr_Type	bcFlagUni_

ElementsPtr_Type	surfaceElements_

ElementsPtr_Type	elementsC_

MapPtr_Type	elementMap_

MapPtr_Type	edgeMap_

CommConstPtrConst_Type	comm_

vec2D_int_ptr_Type	elementsVec_

vec2D_dbl_ptr_Type	pointsRepRef_

vec2D_dbl_ptr_Type	pointsUniRef_

int	elementOrder_

int	surfaceElementOrder_

int	edgesElementOrder_

AABBTreePtr_Type	AABBTree_

tuple_intint_Type	rankRange_

Protected Attributes
vec_GO_Type	globalInterfaceIDs_

vec_dbl_Type	errorEstimation_

vec_dbl_Type	areaTriangles_

vec_dbl_Type	volTetraeders_

vec_dbl_Type	h_T_diam_E_

vec_dbl_Type	h_T_min_

MapConstPtr_Type	surfaceTriangleMap_

Constructor & Destructor Documentation

◆ RefinementFactory() [1/2]

template<class SC, class LO, class GO, class NO>

FEDD::RefinementFactory< SC, LO, GO, NO >::RefinementFactory	(	CommConstPtr_Type	comm,
		int	volumeID = 10 )

Initiating RefinementFactory via MeshUnstructured.

Parameters

[in]	comm	CommPtr.
[in]	volumeID	The flag ID of triangles in 2D or tetrahedra in 3D. Usually 10.

◆ RefinementFactory() [2/2]

template<class SC, class LO, class GO, class NO>

FEDD::RefinementFactory< SC, LO, GO, NO >::RefinementFactory	(	CommConstPtr_Type	comm,
		int	volumeID,
		ParameterListPtr_Type	parameterListAll )

Initiating RefinementFactory via MeshUnstructured with additional information for mesh refinement.

Parameters

[in]	comm	CommPtr
[in]	volumeID	The flag ID of triangles in 2D or tetrahedra in 3D. Usually 10.
[in]	refinementRestriction	Restriction for repeated refinement steps.
[in]	refinement3DDiagonal	3D diagonal pick for regular refinement

Member Function Documentation

◆ addMidpoint()

template<class SC, class LO, class GO, class NO>

void FEDD::RefinementFactory< SC, LO, GO, NO >::addMidpoint	(	EdgeElementsPtr_Type	edgeElements,
		int	edgeID )

Adding a Midpoint on an edge.

Parameters

[in]	edgeElements	Edges.
[in]	edgeID	Edge ids where the midpoints is added.

Here is the caller graph for this function:

◆ bisectEdges()

template<class SC, class LO, class GO, class NO>

void FEDD::RefinementFactory< SC, LO, GO, NO >::bisectEdges	(	EdgeElementsPtr_Type	edgeElements,
		ElementsPtr_Type	elements,
		int	indexElement,
		SurfaceElementsPtr_Type	surfaceTriangleElements,
		std::string	mode = "default" )

2D and 3D that bisects the edges of tagged Elements. Chosen by error estimator or otherwise elements are refined regular by connecting edge midpoints.

Parameters

[in]	edgeElements	Edges.
[in]	elements	Elements.
[in]	indexELement	Element in question.
[in]	surfaceTriangleElements	Triangle elements.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bisectElement3()

template<class SC, class LO, class GO, class NO>

void FEDD::RefinementFactory< SC, LO, GO, NO >::bisectElement3	(	EdgeElementsPtr_Type	edgeElements,
		ElementsPtr_Type	elements,
		int	indexElement )

2D refinement by bisection of tagged Elements with three tagged Edges.

Parameters

[in]	edgeElements	Edges.
[in]	elements	Elements.
[in]	indexELement	Element in question.
[in]	surfaceTriangleElements	Triangle elements.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ buildEdgeMap()

template<class SC, class LO, class GO, class NO>

void FEDD::RefinementFactory< SC, LO, GO, NO >::buildEdgeMap	(	MapConstPtr_Type	mapGlobalProc,
		MapConstPtr_Type	mapProc )

Building edgeMap after refinement.

Parameters

[in]	mapGlobalProc	Map of global processor numbers
[in]	mapProc	Map of local processor number

Here is the caller graph for this function:

◆ buildNodeMap()

template<class SC, class LO, class GO, class NO>

void FEDD::RefinementFactory< SC, LO, GO, NO >::buildNodeMap	(	EdgeElementsPtr_Type	edgeElements,
		MapConstPtr_Type	mapGlobalProc,
		MapConstPtr_Type	mapProc,
		int	newPoints,
		int	newPointsRepeated )

Building nodemap after refinement.

Parameters

[in]	edgeElements	Edges.
[in]	mapGlobalProc	Map of global processor numbers.
[in]	mapProc	Map of local processor numbers.
[in]	newPoints	Number of new points per refinement iteration.
[in]	newPointsRepeated	Number of new repeated points per refinement iteration.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ buildSurfaceTriangleElements()

template<class SC, class LO, class GO, class NO>

void FEDD::RefinementFactory< SC, LO, GO, NO >::buildSurfaceTriangleElements	(	ElementsPtr_Type	elements,
		EdgeElementsPtr_Type	edgeElements,
		SurfaceElementsPtr_Type	surfaceTriangleElements,
		MapConstPtr_Type	edgeMap,
		MapConstPtr_Type	elementMap )

Building surface triangle elements, as they are not originally part of the mesh information provided by mesh partitioner.

Parameters

[in]	elements	Elements.
[in]	edgeElements	Edges.
[in]	surfaceTriangleElements	Pointer which will be filled with surfaceTriangleElements.
[in]	edgeMap	Global Mapping of edges
[in]	elementMap	Global Mapping of elements.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ checkInterfaceSurface()

template<class SC, class LO, class GO, class NO>

vec_bool_Type FEDD::RefinementFactory< SC, LO, GO, NO >::checkInterfaceSurface	(	EdgeElementsPtr_Type	edgeElements,
		vec_int_Type	originFlag,
		vec_int_Type	edgeNumbers,
		int	indexElement )

Checking if surfaces are part of the interface. Done by checking if all edges of a triangle are part of the interface and if both elements connected to the surface are on different processors.

Parameters

[in]	edgeElements	Edges.
[in]	originFlag	Flags of surfaces of indexElement.
[in]	edgeNumbers	Numbers of inserted surfaces edges.
[in]	indexElement	Index of element in question.

Here is the caller graph for this function:

◆ determineLongestEdge()

template<class SC, class LO, class GO, class NO>

int FEDD::RefinementFactory< SC, LO, GO, NO >::determineLongestEdge	(	EdgeElementsPtr_Type	edgeElements,
		vec_int_Type	edgeVec,
		vec2D_dbl_ptr_Type	points )

Eetermine longest edge in triangle.

Parameters

[in]	edgeElements	Edges.
[in]	edgeVec	Vector with edge ids of triangle.
[in]	points	Points.
[out]	Local	edgeID of the longest edge.

Here is the caller graph for this function:

◆ refineBlue()

template<class SC, class LO, class GO, class NO>

void FEDD::RefinementFactory< SC, LO, GO, NO >::refineBlue	(	EdgeElementsPtr_Type	edgeElements,
		ElementsPtr_Type	elements,
		int	indexElement )

2D blue refinement: refining element according to blue refinement scheme - connecting nodes of shorter edge with midpoint of longer tagged edge and connect that with opposite corner

Parameters

[in]	edgeElements	Edges
[in]	elements	Elements.
[in]	indexELement	Element in question.

Here is the caller graph for this function:

◆ refineGreen()

template<class SC, class LO, class GO, class NO>

void FEDD::RefinementFactory< SC, LO, GO, NO >::refineGreen	(	EdgeElementsPtr_Type	edgeElements,
		ElementsPtr_Type	elements,
		int	indexElement )

2D green refinement: refining the element according to green scheme - connecting node on refined edge with the opposite node.

Parameters

[in]	edgeElements	Edges.
[in]	elements	Elements.
[in]	indexELement	Element in question.

Here is the caller graph for this function:

◆ refinementRestrictions()

template<class SC, class LO, class GO, class NO>

void FEDD::RefinementFactory< SC, LO, GO, NO >::refinementRestrictions	(	MeshUnstrPtr_Type	meshP1,
		ElementsPtr_Type	elements,
		EdgeElementsPtr_Type	edgeElements,
		SurfaceElementsPtr_Type	surfaceTriangleElements,
		int &	newPoints,
		int &	newPointsCommon,
		vec_GO_Type &	globalInterfaceIDsTagged,
		MapConstPtr_Type	mapInterfaceEdges,
		int &	newElements )

Refinement Restrictions.

In 2D we can add some Restrictions to the Mesh Refinement:

Bisection: this will keep the regularity of the Mesh by only refining whith a irregular strategy when the longest edge is involved. If not we add a node to the longest edge, whereby the irregular refinement strategy is changed.

GreenTags: this will only check tagged green Elements, if its irregular refinement tag from the previous refinement is 'green' and if so not refine it green again but add a node to the longest edge and thus refine it blue.

In the 3D Case we simply never refine an element irregularly twice, this strategy is called simply 'Bey'. If an element is refined regular, its refinement tag changes from eventually 'irregular' to regular. If those elements should still not be refined irregular we use the strategy 'BeyIrregular'.

Furthermore if there is no fitting irrregular refinement strategy (Type(1)-Type(4) don't fit) we refine regular instead.

Parameters

[in]	meshP1	P_1 Mesh.
[in]	elements	Element.
[in]	edgeElements	Edges.
[in]	iteration	Current iteration.
[in]	newPoints	Number of new unique points originating from restrictions.
[in]	newPointsCommon	Number of new repeated points originating from restrictions.
[in]	globalInterfaceIDsTagged	List of global IDs of tagged interface edges.
[in]	mapInterfaceEdges	Map of interface edges.
[in]	restriction	The kind of restriction we want to apply.
[in]	newElements	Number of new elements orginating from restrictions.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ refineMesh()

template<class SC, class LO, class GO, class NO>

void FEDD::RefinementFactory< SC, LO, GO, NO >::refineMesh	(	MeshUnstrPtr_Type	meshP1,
		int	iteration,
		MeshUnstrPtr_Type	outputMesh,
		std::string	refinementMode )

Main function of RefinementFactory, performs one complete mesh refinement, according to red-green refinement (Verfuerth) or tetrahedral grid refinement (Bey).

Parameters

[in]	meshP1	InputMesh P1.
[in]	iteration	Current Iteration.
[in]	refinementMode	In 2D we can choose between 'Regular' (red-green) or 'Bisection. In 3D only 'Regular' is possible, which is also the default mode.
[out]	outputMesh	Refined mesh.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ refineMeshRegIreg()

template<class SC, class LO, class GO, class NO>

void FEDD::RefinementFactory< SC, LO, GO, NO >::refineMeshRegIreg	(	ElementsPtr_Type	elements,
		EdgeElementsPtr_Type	edgeElements,
		int &	newElements,
		MapConstPtr_Type	edgeMap,
		SurfaceElementsPtr_Type	surfaceTriangleElements )

Refinement performed according to the set of rules determined by Bey or Verfürth.

Parameters

[in]	elements	Elements.
[in]	edgeElements	Edges.
[in]	newElements	Number of new elements originating from refinement.
[in]	edgeMap	Map of global edge ids.
[in]	surfaceTriangleElements	Triangle elements (3D case).

Here is the call graph for this function:

Here is the caller graph for this function:

◆ refineRed()

template<class SC, class LO, class GO, class NO>

void FEDD::RefinementFactory< SC, LO, GO, NO >::refineRed	(	EdgeElementsPtr_Type	edgeElements,
		ElementsPtr_Type	elements,
		int	indexElement )

2D red refinement: refining the element red by connecting all tagged edges midpoints. one element is refined into 4.

Parameters

[in]	edgeElements	Edges
[in]	elements	Elements.
[in]	indexELement	Element in question.

◆ refineRegular()

template<class SC, class LO, class GO, class NO>

void FEDD::RefinementFactory< SC, LO, GO, NO >::refineRegular	(	EdgeElementsPtr_Type	edgeElements,
		ElementsPtr_Type	elements,
		int	indexElement,
		SurfaceElementsPtr_Type	surfaceTriangleElements )

2D and 3D regular refinement. Chosen by error estimator or otherwise elements are refined regular by connecting edge midpoints.

3D regular refinement as defined in "Tetrahedral Grid Refinement" by J. Bey 'Algorithm Regular Refinement' in Computing, Springer Verlag 1955

Parameters

[in]	edgeElements	Edges.
[in]	elements	Elements.
[in]	indexELement	Element in question.
[in]	surfaceTriangleElements	Triangle elements.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ refineType1()

template<class SC, class LO, class GO, class NO>

void FEDD::RefinementFactory< SC, LO, GO, NO >::refineType1	(	EdgeElementsPtr_Type	edgeElements,
		ElementsPtr_Type	elements,
		int	indexElement,
		SurfaceElementsPtr_Type	surfaceTriangleElements )

3D Type(1) refinement as defined in "Tetrahedral Grid Refinement" by J. Bey 'Algorithm Regular Refinement' in Computing, Springer Verlag 1955

Parameters

[in]	edgeElements	Edges.
[in]	elements	Elements.
[in]	indexELement	Element in question.
[in]	surfaceTriangleElements	Triangle elements.

Here is the caller graph for this function:

◆ refineType2()

template<class SC, class LO, class GO, class NO>

void FEDD::RefinementFactory< SC, LO, GO, NO >::refineType2	(	EdgeElementsPtr_Type	edgeElements,
		ElementsPtr_Type	elements,
		int	indexElement,
		SurfaceElementsPtr_Type	surfaceTriangleElements )

3D Type(2) refinement as defined in "Tetrahedral Grid Refinement" by J. Bey 'Algorithm Regular Refinement' in Computing, Springer Verlag 1955

Parameters

[in]	edgeElements	Edges.
[in]	elements	Elements.
[in]	indexELement	Element in question.
[in]	surfaceTriangleElements	Triangle elements.

Here is the caller graph for this function:

◆ refineType3()

template<class SC, class LO, class GO, class NO>

void FEDD::RefinementFactory< SC, LO, GO, NO >::refineType3	(	EdgeElementsPtr_Type	edgeElements,
		ElementsPtr_Type	elements,
		int	indexElement,
		SurfaceElementsPtr_Type	surfaceTriangleElements )

3D Type(3) refinement as defined in "Tetrahedral Grid Refinement" by J. Bey 'Algorithm Regular Refinement' in Computing, Springer Verlag 1955

Parameters

[in]	edgeElements	Edges.
[in]	elements	Elements.
[in]	indexELement	Element in question.
[in]	surfaceTriangleElements	Triangle elements.

Here is the caller graph for this function:

◆ refineType4()

template<class SC, class LO, class GO, class NO>

void FEDD::RefinementFactory< SC, LO, GO, NO >::refineType4	(	EdgeElementsPtr_Type	edgeElements,
		ElementsPtr_Type	elements,
		int	indexElement,
		SurfaceElementsPtr_Type	surfaceTriangleElements )

3D Type(4) refinement as defined in "Tetrahedral Grid Refinement" by J. Bey 'Algorithm Regular Refinement' in Computing, Springer Verlag 1955

Parameters

[in]	edgeElements	Edges.
[in]	elements	Elements.
[in]	indexELement	Element in question.
[in]	surfaceTriangleElements	Triangle elements.

Here is the caller graph for this function:

◆ updateElementsOfEdgesLocalAndGlobal()

template<class SC, class LO, class GO, class NO>

void FEDD::RefinementFactory< SC, LO, GO, NO >::updateElementsOfEdgesLocalAndGlobal	(	int	maxRank,
		MapConstPtr_Type	edgeMap )

Updating ElementsOfEdgesLocal and ElementsOfEdgesGlobal.

Parameters

[in]	maxRank	The maximal processor rank.
[in]	edgeMap	Map of global edge ids.

Here is the caller graph for this function:

The documentation for this class was generated from the following files:

feddlib/amr/RefinementFactory_decl.hpp
feddlib/amr/RefinementFactory_def.hpp

Public Types

Public Member Functions

Public Attributes

Protected Attributes

Constructor & Destructor Documentation

◆ RefinementFactory() [1/2]

◆ RefinementFactory() [2/2]

Member Function Documentation

◆ addMidpoint()

◆ bisectEdges()

◆ bisectElement3()

◆ buildEdgeMap()

◆ buildNodeMap()

◆ buildSurfaceTriangleElements()

◆ checkInterfaceSurface()

◆ determineLongestEdge()

◆ refineBlue()

◆ refineGreen()

◆ refinementRestrictions()

◆ refineMesh()

◆ refineMeshRegIreg()

◆ refineRed()

◆ refineRegular()

◆ refineType1()

◆ refineType2()

◆ refineType3()

◆ refineType4()

◆ updateElementsOfEdgesLocalAndGlobal()