fast3d Module Reference

Fast diagonalization methods from NEKTON.

Functions/Subroutines
subroutine, public	fd_weights_full (xi, x, n, m, c)
	Compute finite-difference stencil weights for evaluating derivatives up to order \(m\) at a point.
subroutine, public	semhat (a, b, c, d, z, dgll, jgll, bgl, zgl, dgl, jgl, n, w)
	Generate matrices for single element, 1D operators: a = Laplacian b = diagonal mass matrix c = convection operator b*d d = derivative matrix dgll = derivative matrix, mapping from pressure nodes to velocity jgll = interpolation matrix, mapping from pressure nodes to velocity z = GLL points.
subroutine, public	setup_intp (jh, jht, z_to, z_from, n_to, n_from, derivative)
	Compute interpolation weights for points z_to using values at points z_from.

Function/Subroutine Documentation

fd_weights_full()

subroutine, public fast3d::fd_weights_full	(	real(kind=rp), intent(in)	xi,
		real(kind=rp), dimension(0:n), intent(in)	x,
		integer, intent(in)	n,
		integer, intent(in)	m,
		real(kind=rp), dimension(0:n,0:m), intent(out)	c
	)

This routine comes from the Appendix C of "A Practical Guide to Pseudospectral Methods" by B. Fornberg, Cambridge University Press, 1996.

Given gridpoints \( x_0, x_1, \dots x_n \) and some point \(\xi\) (not necessarily a grid point!) find weights \( c_{j, k} \), such that the expansions \( \frac{d^k f}{d x^k}|_{x=\xi} \approx \sum_{j=0}^n c_{j,k} f(x_j)\), \(k=0, \dots m\) are optimal. Note that finite-difference stencils are exactly such type of expansions. For the derivation of the algorithm, refer to 3.1 in the reference above.

Note

- Setting \(m=0\) makes this a polynomial interpolation routine. It is the fastest such routine possible for a single interpolation point, according to the above reference.

- The name _full refers to the fact that we use the values \(f(x_j)\) at all available nodes \(x\) to construct the expansion. So we always get the finite difference stencil of maximum order possible.

Warning

The calculation of the wieghts is numerically stable. But applying the weights to a function can be ill-conditioned in the case of high-order derivatives.

Parameters

	xi	Point at which the approximations are to be accurate
	x	The coordinates for the grid points
[in]	n	The size of x is n + 1
[in]	m	Highest order of derivative to be approximated
	c	The stencil weights. Row j corresponds to weight of \(f(x_j)\) and column k to the kth derivative

Definition at line 104 of file fast3d.f90.

Here is the caller graph for this function:

semhat()

subroutine, public fast3d::semhat	(	real(kind=rp), dimension(0:n,0:n), intent(inout)	a,
		real(kind=rp), dimension(0:n), intent(inout)	b,
		real(kind=rp), dimension(0:n,0:n), intent(inout)	c,
		real(kind=rp), dimension(0:n,0:n), intent(inout)	d,
		real(kind=rp), dimension(0:n), intent(inout)	z,
		real(kind=rp), dimension(0:n,1:n-1), intent(inout)	dgll,
		real(kind=rp), dimension(0:n,1:n-1), intent(inout)	jgll,
		real(kind=rp), dimension(1:n-1), intent(inout)	bgl,
		real(kind=rp), dimension(1:n-1), intent(inout)	zgl,
		real(kind=rp), dimension(1:n-1,0:n), intent(inout)	dgl,
		real(kind=rp), dimension(1:n-1,0:n), intent(inout)	jgl,
		integer, intent(in)	n,
		real(kind=rp), dimension(0:2*n+1), intent(inout)	w
	)

zgl = GL points bgl = diagonal mass matrix on GL dgl = derivative matrix, mapping from velocity nodes to pressure jgl = interpolation matrix, mapping from velocity nodes to pressure

n = polynomial degree (velocity space) w = work array of size 2*n+2

Currently, this is set up for pressure nodes on the interior GLL pts.

Definition at line 167 of file fast3d.f90.

Here is the call graph for this function:

Here is the caller graph for this function:

setup_intp()

subroutine, public fast3d::setup_intp	(	real(kind=rp), dimension(n_to, n_from), intent(inout)	jh,
		real(kind=rp), dimension(n_from, n_to), intent(inout)	jht,
		real(kind=rp), dimension(n_to), intent(inout)	z_to,
		real(kind=rp), dimension(n_from), intent(inout)	z_from,
		integer, intent(in)	n_to,
		integer, intent(in)	n_from,
		integer, intent(in)	derivative
	)

This is essentially a wrapper for calling fd_weights_full() for several points. For each point in z_to, we get a set of interpolation weights of size n_from. The result is thus a matrix of weights, each row corresponding to a point in z_to and each column the weight of a point in z_from.

This routine is used for interpolating between elements of different polynomial order. In other words, belonging to different space::space_t . The points are then GL, GLL, etc., depending on the space.

Parameters

jh	Matrix of the interpolation weights.
jht	Same as jh but transposed.
z_to	Target points for interpolation.
z_from	Quadrature points.
n_to	Number of points in z_to.
n_from	Number of points in z_from.
derivative	Specifies if we want the derivative interpolation instead, e.g. derivative = 1 refers to the first derivative etc.

Definition at line 242 of file fast3d.f90.

Here is the call graph for this function:

Here is the caller graph for this function: