Generate Lobatto node numbers for any degree. More...

#include <p4est_ghost.h>

Include dependency graph for p4est_lnodes.h:

This graph shows which files directly or indirectly include this file:

Data Structures
struct	p4est_lnodes
	Store a parallel numbering of Lobatto points of a given degree > 0. More...

struct	p4est_lnodes_rank
	The structure stored in the sharers array. More...

struct	p4est_lnodes_buffer
	p4est_lnodes_buffer_t handles the communication of data associated with nodes. More...

Typedefs
typedef int8_t	p4est_lnodes_code_t
	The face code encodes the configuration of a hanging quadrant.

typedef struct p4est_lnodes	p4est_lnodes_t
	Store a parallel numbering of Lobatto points of a given degree > 0. More...

typedef struct p4est_lnodes_rank	p4est_lnodes_rank_t
	The structure stored in the sharers array. More...

typedef struct p4est_lnodes_buffer	p4est_lnodes_buffer_t
	p4est_lnodes_buffer_t handles the communication of data associated with nodes. More...

Functions
p4est_lnodes_t *	p4est_lnodes_new (p4est_t p4est, p4est_ghost_t ghost_layer, int degree)
	Create a tensor-product Lobatto node structure for a given degree. More...

void	p4est_lnodes_destroy (p4est_lnodes_t *lnodes)
	Free all memory in a previously constructed lnodes structure. More...

void	p4est_ghost_support_lnodes (p4est_t p4est, p4est_lnodes_t lnodes, p4est_ghost_t *ghost)
	Expand the ghost layer to include the support of all nodes supported on the local partition. More...

void	p4est_ghost_expand_by_lnodes (p4est_t p4est, p4est_lnodes_t lnodes, p4est_ghost_t *ghost)
	Expand the ghost layer as in p4est_ghost_expand(), but use node support to define adjacency instead of geometric adjacency. More...

void	p4est_partition_lnodes (p4est_t p4est, p4est_ghost_t ghost, int degree, int partition_for_coarsening)
	Partition using weights based on the number of nodes assigned to each element in lnodes. More...

void	p4est_partition_lnodes_detailed (p4est_t p4est, p4est_ghost_t ghost, int nodes_per_volume, int nodes_per_face, int nodes_per_corner, int partition_for_coarsening)
	Partition using weights that are broken down by where they reside: in volumes, on faces, or on corners.

p4est_lnodes_buffer_t *	p4est_lnodes_share_owned_begin (sc_array_t node_data, p4est_lnodes_t lnodes)
	p4est_lnodes_share_owned_begin More...

void	p4est_lnodes_share_owned_end (p4est_lnodes_buffer_t *buffer)

void	p4est_lnodes_share_owned (sc_array_t node_data, p4est_lnodes_t lnodes)
	Equivalent to calling p4est_lnodes_share_owned_end directly after p4est_lnodes_share_owned_begin. More...

p4est_lnodes_buffer_t *	p4est_lnodes_share_all_begin (sc_array_t node_data, p4est_lnodes_t lnodes)
	p4est_lnodes_share_all_begin More...

void	p4est_lnodes_share_all_end (p4est_lnodes_buffer_t *buffer)

p4est_lnodes_buffer_t *	p4est_lnodes_share_all (sc_array_t node_data, p4est_lnodes_t lnodes)
	Equivalent to calling p4est_lnodes_share_all_end directly after p4est_lnodes_share_all_begin. More...

void	p4est_lnodes_buffer_destroy (p4est_lnodes_buffer_t *buffer)

Variables
const int	p4est_lnodes_corner_hanging [4]
	For each corner, the normal direction of the hanging face. More...

Detailed Description

Generate Lobatto node numbers for any degree.

Typedef Documentation

◆ p4est_lnodes_buffer_t

typedef struct p4est_lnodes_buffer p4est_lnodes_buffer_t

p4est_lnodes_buffer_t handles the communication of data associated with nodes.

send_buffers is an array of arrays: one buffer for each process to which the current process sends node-data. It should not be altered between a shared_*_begin and a shared_*_end call.

recv_buffers is an array of arrays that is used in lnodes_share_all_*. recv_buffers[j] corresponds with lnodes->sharers[j]: it is the same length as lnodes->sharers[j]->shared_nodes. At the completion of lnodes_share_all or lnodes_share_all_end, recv_buffers[j] contains the node-data from the process lnodes->sharers[j]->rank (unless j is the current rank, in which case recv_buffers[j] is empty).

◆ p4est_lnodes_rank_t

typedef struct p4est_lnodes_rank p4est_lnodes_rank_t

The structure stored in the sharers array.

shared_nodes is a sorted array of p4est_locidx_t that indexes into local nodes. The shared_nodes array has a contiguous (or empty) section of nodes owned by the current rank. shared_mine_offset and shared_mine_count identify this section by indexing the shared_nodes array, not the local nodes array. owned_offset and owned_count define the section of local nodes that is owned by the listed rank (the section may be empty). For the current process these coincide with those in p4est_lnodes_t.

◆ p4est_lnodes_t

typedef struct p4est_lnodes p4est_lnodes_t

Store a parallel numbering of Lobatto points of a given degree > 0.

Each element has degree+1 nodes per face and vnodes = (degree+1)^2 nodes per volume. num_local_elements is the number of local quadrants in the p4est. element_nodes is of dimension vnodes * num_local_elements and lists the nodes of each element in lexicographic yx-order (x varies fastest); so for degree == 2, this is the layout of nodes:

        f_3
 c_2           c_3
     6---7---8
     |       |
f_0  3   4   5  f_1
     |       |
     0---1---2
 c_0           c_1
        f_2

element_nodes indexes into the set of local nodes, layed out as follows:

local nodes = [<-----owned_count----->|<-----nonlocal_nodes----->]
            = [<----------------num_local_nodes----------------->]

nonlocal_nodes contains the globally unique numbers for independent nodes that are owned by other processes; for local nodes, the globally unique numbers are given by i + global_offset, where i is the local number. Hanging nodes are always local and don't have a global number. They index the geometrically corresponding independent nodes of a neighbor.

Whether nodes are hanging or not is decided based on the element faces. This information is encoded in face_code with one int8_t per element. If no faces are hanging, the value is zero, otherwise the face_code is interpreted by p4est_lnodes_decode.

Independent nodes can be shared by multiple MPI ranks. The owner rank of a node is the one from the lowest numbered element on the lowest numbered octree touching the node.

What is meant by touching? A quadrant is said to touch all faces/corners that are incident on it, and by extension all nodes that are contained in those faces/corners.

        X +-----------+
        o |           |
        o |           |
+-----+ o |     p     |
|  q  | o |           |
|     | o |           |
+-----+ O +-----------+

In this example degree = 6. There are 5 nodes that live on the face between q and p, and one at each corner of that face. The face is incident on q, so q owns the nodes on the face (provided q is from a lower tree or has a lower index than p). The lower corner is incident on q, so q owns it as well. The upper corner is not incident on q, so q cannot own it.

global_owned_count contains the number of independent nodes owned by each process.

The sharers array contains items of type p4est_lnodes_rank_t that hold the ranks that own or share independent local nodes. If there are no shared nodes on this processor, it is empty. Otherwise, it is sorted by rank and the current process is included.

degree < 0 indicates that the lnodes data structure is being used to number the quadrant boundary object (faces and corners) rather than the $C^0$ Lobatto nodes:

if degree == -1, then one node is assigned per face, and no nodes are assigned per volume or per corner: this numbering can be used for low-order Raviart-Thomas elements. In this case, vnodes == 4, and the nodes are listed in face-order:

        f_3
 c_2           c_3
     +---3---+
     |       |
f_0  0       1  f_1
     |       |
     +---2---+
 c_0           c_1
        f_2

if degree == -2, then one node is assigned per face and per corner and no nodes are assigned per volume. In this case, vnodes == 8, and the nodes are listed in face-order, followed by corner-order:

        f_3
 c_2           c_3
     6---3---7
     |       |
f_0  0       1  f_1
     |       |
     4---2---5
 c_0           c_1
        f_2

Function Documentation

◆ p4est_ghost_expand_by_lnodes()

void p4est_ghost_expand_by_lnodes	(	p4est_t *	p4est,
		p4est_lnodes_t *	lnodes,
		p4est_ghost_t *	ghost
	)

Expand the ghost layer as in p4est_ghost_expand(), but use node support to define adjacency instead of geometric adjacency.

Parameters

[in]	p4est	The forest from which the ghost layer was generated.
[in]	lnodes	The nodes to support.
[in,out]	ghost	The ghost layer to be expanded.

◆ p4est_ghost_support_lnodes()

void p4est_ghost_support_lnodes	(	p4est_t *	p4est,
		p4est_lnodes_t *	lnodes,
		p4est_ghost_t *	ghost
	)

Expand the ghost layer to include the support of all nodes supported on the local partition.

Parameters

[in]	p4est	The forest from which the ghost layer was generated.
[in]	lnodes	The nodes to support.
[in,out]	ghost	The ghost layer to be expanded.

◆ p4est_lnodes_destroy()

void p4est_lnodes_destroy ( p4est_lnodes_t * lnodes )

Free all memory in a previously constructed lnodes structure.

Parameters

[in] lnodes This pointer will be deep freed. Do no longer use once this function returns.

Examples: timings/timings2.c.

◆ p4est_lnodes_new()

p4est_lnodes_t* p4est_lnodes_new	(	p4est_t *	p4est,
		p4est_ghost_t *	ghost_layer,
		int	degree
	)

Create a tensor-product Lobatto node structure for a given degree.

Parameters

[in]	p4est	Valid forest.
[in]	ghost_layer	Valid full ghost layer, i. e. constructed by p4est_ghost_new with the same forest and argument P4EST_CONNECT_FULL.
[in]	degree	Degree >= 1 leads to N = degree + 1 nodes in every direction. Degrees -1 and -2 are legal for special constructions; see p4est_lnodes.

Returns: Fully initialized nodes structure.

Examples: timings/timings2.c.

◆ p4est_lnodes_share_all()

p4est_lnodes_buffer_t* p4est_lnodes_share_all	(	sc_array_t *	node_data,
		p4est_lnodes_t *	lnodes
	)

Equivalent to calling p4est_lnodes_share_all_end directly after p4est_lnodes_share_all_begin.

Use if there is no local work that can be done to mask the communication cost.

Returns: A fully initialized buffer that contains the received data. After processing this data, the buffer must be freed with p4est_lnodes_buffer_destroy.

◆ p4est_lnodes_share_all_begin()

p4est_lnodes_buffer_t* p4est_lnodes_share_all_begin	(	sc_array_t *	node_data,
		p4est_lnodes_t *	lnodes
	)

p4est_lnodes_share_all_begin

node_data is a user_defined array of arbitrary type, where each entry is associated with the lnodes local nodes entry of matching index. For every process that shares an entry with the current one, the value in the node_data array of that process is written into a buffer->recv_buffers entry as described above. The user can then perform some arbitrary work that requires the data from all processes that share a node (such as reduce, max, min, etc.). When the work concludes, the buffer should be destroyed with p4est_lnodes_buffer_destroy.

Values of node_data are not guaranteed to be sent, and buffer->recv_buffer entries are not guaranteed to be received until the buffer created by p4est_lnodes_share_all_begin is passed to p4est_lnodes_share_all_end.

◆ p4est_lnodes_share_owned()

void p4est_lnodes_share_owned	(	sc_array_t *	node_data,
		p4est_lnodes_t *	lnodes
	)

Equivalent to calling p4est_lnodes_share_owned_end directly after p4est_lnodes_share_owned_begin.

Use if there is no local work that can be done to mask the communication cost.

◆ p4est_lnodes_share_owned_begin()

p4est_lnodes_buffer_t* p4est_lnodes_share_owned_begin	(	sc_array_t *	node_data,
		p4est_lnodes_t *	lnodes
	)

p4est_lnodes_share_owned_begin

node_data is a user-defined array of arbitrary type, where each entry is associated with the lnodes local nodes entry of matching index. For every local nodes entry that is owned by a process other than the current one, the value in the node_data array of the owning process is written directly into the node_data array of the current process. Values of node_data are not guaranteed to be sent or received until the buffer created by p4est_lnodes_share_owned_begin is passed to p4est_lnodes_share_owned_end.

To be memory neutral, the buffer created by p4est_lnodes_share_owned_begin must be destroying with p4est_lnodes_buffer_destroy (it is not destroyed by p4est_lnodes_share_owned_end).

◆ p4est_partition_lnodes()

void p4est_partition_lnodes	(	p4est_t *	p4est,
		p4est_ghost_t *	ghost,
		int	degree,
		int	partition_for_coarsening
	)

Partition using weights based on the number of nodes assigned to each element in lnodes.

Parameters

[in,out]	p4est	the forest to be repartitioned
[in]	ghost	the ghost layer
[in]	degree	the degree that would be passed to p4est_lnodes_new()
[in]	partition_for_coarsening	whether the partition should allow coarsening (i.e. group siblings who might merge)

Examples: timings/timings2.c.

Variable Documentation

◆ p4est_lnodes_corner_hanging

const int p4est_lnodes_corner_hanging[4]

extern

For each corner, the normal direction of the hanging face.

The corner index is with respect to a zero child quadrant. Corners that may never hang store the value -1.

Data Structures

Typedefs

Functions

Variables

Detailed Description

Typedef Documentation

◆ p4est_lnodes_buffer_t

◆ p4est_lnodes_rank_t

◆ p4est_lnodes_t

Function Documentation

◆ p4est_ghost_expand_by_lnodes()

◆ p4est_ghost_support_lnodes()

◆ p4est_lnodes_destroy()

◆ p4est_lnodes_new()

◆ p4est_lnodes_share_all()

◆ p4est_lnodes_share_all_begin()

◆ p4est_lnodes_share_owned()

◆ p4est_lnodes_share_owned_begin()

◆ p4est_partition_lnodes()

Variable Documentation

◆ p4est_lnodes_corner_hanging