Halo.cu File Reference

#include "Halo.h"

Include dependency graph for Halo.cu:

Functions
template<class T >
void	fillHaloD (Param XParam, int ib, BlockP< T > XBlock, T *z)
	Wrapping function for calculating halos on CPU on every side of a block of a single variable. More...
template void	fillHaloD< double > (Param XParam, int ib, BlockP< double > XBlock, double *z)
template void	fillHaloD< float > (Param XParam, int ib, BlockP< float > XBlock, float *z)
template<class T >
void	fillHaloC (Param XParam, BlockP< T > XBlock, T *z)
	Wrapping function for calculating halos for each block of a single variable on CPU. More...
template void	fillHaloC< float > (Param XParam, BlockP< float > XBlock, float *z)
template void	fillHaloC< double > (Param XParam, BlockP< double > XBlock, double *z)
template<class T >
void	RecalculateZs (Param XParam, BlockP< T > XBlock, EvolvingP< T > Xev, T *zb)
	Recalculate water surface after recalculating the values on the halo on the CPU. More...
template void	RecalculateZs< float > (Param XParam, BlockP< float > XBlock, EvolvingP< float > Xev, float *zb)
template void	RecalculateZs< double > (Param XParam, BlockP< double > XBlock, EvolvingP< double > Xev, double *zb)
template<class T >
void	Recalculatehh (Param XParam, BlockP< T > XBlock, EvolvingP< T > Xev, T *zb)
template void	Recalculatehh< float > (Param XParam, BlockP< float > XBlock, EvolvingP< float > Xev, float *zb)
template void	Recalculatehh< double > (Param XParam, BlockP< double > XBlock, EvolvingP< double > Xev, double *zb)
template<class T >
__global__ void	RecalculateZsGPU (Param XParam, BlockP< T > XBlock, EvolvingP< T > Xev, T *zb)
template __global__ void	RecalculateZsGPU< float > (Param XParam, BlockP< float > XBlock, EvolvingP< float > Xev, float *zb)
template __global__ void	RecalculateZsGPU< double > (Param XParam, BlockP< double > XBlock, EvolvingP< double > Xev, double *zb)
template<class T >
void	fillHaloF (Param XParam, bool doProlongation, BlockP< T > XBlock, T *z)
	Wrapping function for calculating flux in the halos for a block and a single variable on CPU. More...
template void	fillHaloF< float > (Param XParam, bool doProlongation, BlockP< float > XBlock, float *z)
template void	fillHaloF< double > (Param XParam, bool doProlongation, BlockP< double > XBlock, double *z)
template<class T >
void	fillHaloGPU (Param XParam, BlockP< T > XBlock, cudaStream_t stream, T *z)
	Wrapping function for calculating halos for each block of a single variable on GPU. More...
template void	fillHaloGPU< double > (Param XParam, BlockP< double > XBlock, cudaStream_t stream, double *z)
template void	fillHaloGPU< float > (Param XParam, BlockP< float > XBlock, cudaStream_t stream, float *z)
template<class T >
void	fillHaloGPUnew (Param XParam, BlockP< T > XBlock, cudaStream_t stream, T *z)
template void	fillHaloGPUnew< double > (Param XParam, BlockP< double > XBlock, cudaStream_t stream, double *z)
template void	fillHaloGPUnew< float > (Param XParam, BlockP< float > XBlock, cudaStream_t stream, float *z)
template<class T >
void	fillHaloTopRightC (Param XParam, BlockP< T > XBlock, T *z)
	Wrapping function for calculating flux for halos for each block of a single variable on GPU. More...
template void	fillHaloTopRightC< double > (Param XParam, BlockP< double > XBlock, double *z)
template void	fillHaloTopRightC< float > (Param XParam, BlockP< float > XBlock, float *z)
template<class T >
void	fillHaloLRFluxC (Param XParam, BlockP< T > XBlock, T *z)
template void	fillHaloLRFluxC< double > (Param XParam, BlockP< double > XBlock, double *z)
template void	fillHaloLRFluxC< float > (Param XParam, BlockP< float > XBlock, float *z)
template<class T >
void	fillHaloBTFluxC (Param XParam, BlockP< T > XBlock, T *z)
template void	fillHaloBTFluxC< double > (Param XParam, BlockP< double > XBlock, double *z)
template void	fillHaloBTFluxC< float > (Param XParam, BlockP< float > XBlock, float *z)
template<class T >
void	fillHaloTopRightGPU (Param XParam, BlockP< T > XBlock, cudaStream_t stream, T *z)
template void	fillHaloTopRightGPU< double > (Param XParam, BlockP< double > XBlock, cudaStream_t stream, double *z)
template void	fillHaloTopRightGPU< float > (Param XParam, BlockP< float > XBlock, cudaStream_t stream, float *z)
template<class T >
void	fillHaloLeftRightGPU (Param XParam, BlockP< T > XBlock, cudaStream_t stream, T *z)
template void	fillHaloLeftRightGPU< double > (Param XParam, BlockP< double > XBlock, cudaStream_t stream, double *z)
template void	fillHaloLeftRightGPU< float > (Param XParam, BlockP< float > XBlock, cudaStream_t stream, float *z)
template<class T >
void	fillHaloLeftRightGPUnew (Param XParam, BlockP< T > XBlock, cudaStream_t stream, T *z)
template void	fillHaloLeftRightGPUnew< double > (Param XParam, BlockP< double > XBlock, cudaStream_t stream, double *z)
template void	fillHaloLeftRightGPUnew< float > (Param XParam, BlockP< float > XBlock, cudaStream_t stream, float *z)
template<class T >
void	fillHaloBotTopGPU (Param XParam, BlockP< T > XBlock, cudaStream_t stream, T *z)
template void	fillHaloBotTopGPU< double > (Param XParam, BlockP< double > XBlock, cudaStream_t stream, double *z)
template void	fillHaloBotTopGPU< float > (Param XParam, BlockP< float > XBlock, cudaStream_t stream, float *z)
template<class T >
void	fillHaloBotTopGPUnew (Param XParam, BlockP< T > XBlock, cudaStream_t stream, T *z)
template void	fillHaloBotTopGPUnew< double > (Param XParam, BlockP< double > XBlock, cudaStream_t stream, double *z)
template void	fillHaloBotTopGPUnew< float > (Param XParam, BlockP< float > XBlock, cudaStream_t stream, float *z)
template<class T >
void	fillHalo (Param XParam, BlockP< T > XBlock, EvolvingP< T > Xev, T *zb)
template void	fillHalo< float > (Param XParam, BlockP< float > XBlock, EvolvingP< float > Xev, float *zb)
template void	fillHalo< double > (Param XParam, BlockP< double > XBlock, EvolvingP< double > Xev, double *zb)
template<class T >
void	fillHalo (Param XParam, BlockP< T > XBlock, EvolvingP< T > Xev)
template void	fillHalo< float > (Param XParam, BlockP< float > XBlock, EvolvingP< float > Xev)
template void	fillHalo< double > (Param XParam, BlockP< double > XBlock, EvolvingP< double > Xev)
template<class T >
void	fillHaloGPU (Param XParam, BlockP< T > XBlock, EvolvingP< T > Xev)
template void	fillHaloGPU< float > (Param XParam, BlockP< float > XBlock, EvolvingP< float > Xev)
template void	fillHaloGPU< double > (Param XParam, BlockP< double > XBlock, EvolvingP< double > Xev)
template<class T >
void	fillHaloGPU (Param XParam, BlockP< T > XBlock, EvolvingP< T > Xev, T *zb)
template void	fillHaloGPU< float > (Param XParam, BlockP< float > XBlock, EvolvingP< float > Xev, float *zb)
template void	fillHaloGPU< double > (Param XParam, BlockP< double > XBlock, EvolvingP< double > Xev, double *zb)
template<class T >
void	fillHalo (Param XParam, BlockP< T > XBlock, GradientsP< T > Grad)
template void	fillHalo< float > (Param XParam, BlockP< float > XBlock, GradientsP< float > Grad)
template void	fillHalo< double > (Param XParam, BlockP< double > XBlock, GradientsP< double > Grad)
template<class T >
void	fillHaloGPU (Param XParam, BlockP< T > XBlock, GradientsP< T > Grad)
template void	fillHaloGPU< float > (Param XParam, BlockP< float > XBlock, GradientsP< float > Grad)
template void	fillHaloGPU< double > (Param XParam, BlockP< double > XBlock, GradientsP< double > Grad)
template<class T >
void	fillHalo (Param XParam, BlockP< T > XBlock, FluxP< T > Flux)
template void	fillHalo< float > (Param XParam, BlockP< float > XBlock, FluxP< float > Flux)
template void	fillHalo< double > (Param XParam, BlockP< double > XBlock, FluxP< double > Flux)
template<class T >
void	fillHaloGPU (Param XParam, BlockP< T > XBlock, FluxP< T > Flux)
template void	fillHaloGPU< float > (Param XParam, BlockP< float > XBlock, FluxP< float > Flux)
template void	fillHaloGPU< double > (Param XParam, BlockP< double > XBlock, FluxP< double > Flux)
template<class T >
void	refine_linear_Left (Param XParam, int ib, BlockP< T > XBlock, T *z, T *dzdx, T *dzdy)
template void	refine_linear_Left< float > (Param XParam, int ib, BlockP< float > XBlock, float *z, float *dzdx, float *dzdy)
template void	refine_linear_Left< double > (Param XParam, int ib, BlockP< double > XBlock, double *z, double *dzdx, double *dzdy)
template<class T >
__global__ void	refine_linear_LeftGPU (Param XParam, BlockP< T > XBlock, T *z, T *dzdx, T *dzdy)
template __global__ void	refine_linear_LeftGPU< float > (Param XParam, BlockP< float > XBlock, float *z, float *dzdx, float *dzdy)
template __global__ void	refine_linear_LeftGPU< double > (Param XParam, BlockP< double > XBlock, double *z, double *dzdx, double *dzdy)
template<class T >
void	refine_linear_Right (Param XParam, int ib, BlockP< T > XBlock, T *z, T *dzdx, T *dzdy)
template void	refine_linear_Right< float > (Param XParam, int ib, BlockP< float > XBlock, float *z, float *dzdx, float *dzdy)
template void	refine_linear_Right< double > (Param XParam, int ib, BlockP< double > XBlock, double *z, double *dzdx, double *dzdy)
template<class T >
__global__ void	refine_linear_RightGPU (Param XParam, BlockP< T > XBlock, T *z, T *dzdx, T *dzdy)
template __global__ void	refine_linear_RightGPU< float > (Param XParam, BlockP< float > XBlock, float *z, float *dzdx, float *dzdy)
template __global__ void	refine_linear_RightGPU< double > (Param XParam, BlockP< double > XBlock, double *z, double *dzdx, double *dzdy)
template<class T >
void	refine_linear_Bot (Param XParam, int ib, BlockP< T > XBlock, T *z, T *dzdx, T *dzdy)
template void	refine_linear_Bot< float > (Param XParam, int ib, BlockP< float > XBlock, float *z, float *dzdx, float *dzdy)
template void	refine_linear_Bot< double > (Param XParam, int ib, BlockP< double > XBlock, double *z, double *dzdx, double *dzdy)
template<class T >
__global__ void	refine_linear_BotGPU (Param XParam, BlockP< T > XBlock, T *z, T *dzdx, T *dzdy)
template __global__ void	refine_linear_BotGPU< float > (Param XParam, BlockP< float > XBlock, float *z, float *dzdx, float *dzdy)
template __global__ void	refine_linear_BotGPU< double > (Param XParam, BlockP< double > XBlock, double *z, double *dzdx, double *dzdy)
template<class T >
void	refine_linear_Top (Param XParam, int ib, BlockP< T > XBlock, T *z, T *dzdx, T *dzdy)
template void	refine_linear_Top< float > (Param XParam, int ib, BlockP< float > XBlock, float *z, float *dzdx, float *dzdy)
template void	refine_linear_Top< double > (Param XParam, int ib, BlockP< double > XBlock, double *z, double *dzdx, double *dzdy)
template<class T >
__global__ void	refine_linear_TopGPU (Param XParam, BlockP< T > XBlock, T *z, T *dzdx, T *dzdy)
template __global__ void	refine_linear_TopGPU< float > (Param XParam, BlockP< float > XBlock, float *z, float *dzdx, float *dzdy)
template __global__ void	refine_linear_TopGPU< double > (Param XParam, BlockP< double > XBlock, double *z, double *dzdx, double *dzdy)
template<class T >
void	refine_linear (Param XParam, BlockP< T > XBlock, T *z, T *dzdx, T *dzdy)
template void	refine_linear< float > (Param XParam, BlockP< float > XBlock, float *z, float *dzdx, float *dzdy)
template void	refine_linear< double > (Param XParam, BlockP< double > XBlock, double *z, double *dzdx, double *dzdy)
template<class T >
void	refine_linearGPU (Param XParam, BlockP< T > XBlock, T *z, T *dzdx, T *dzdy)
template void	refine_linearGPU< float > (Param XParam, BlockP< float > XBlock, float *z, float *dzdx, float *dzdy)
template void	refine_linearGPU< double > (Param XParam, BlockP< double > XBlock, double *z, double *dzdx, double *dzdy)
template<class T >
void	HaloFluxCPULR (Param XParam, int ib, BlockP< T > XBlock, T *z)
template<class T >
__global__ void	HaloFluxGPULR (Param XParam, BlockP< T > XBlock, T *z)
template<class T >
__global__ void	HaloFluxGPULRnew (Param XParam, BlockP< T > XBlock, T *z)
template<class T >
void	HaloFluxCPUBT (Param XParam, int ib, BlockP< T > XBlock, T *z)
template<class T >
__global__ void	HaloFluxGPUBT (Param XParam, BlockP< T > XBlock, T *z)
template<class T >
__global__ void	HaloFluxGPUBTnew (Param XParam, BlockP< T > XBlock, T *z)
template<class T >
void	fillLeft (Param XParam, int ib, BlockP< T > XBlock, T *&z)
template<class T >
__global__ void	fillLeft (int halowidth, int *active, int *level, int *leftbot, int *lefttop, int *rightbot, int *botright, int *topright, T *a)
template __global__ void	fillLeft< float > (int halowidth, int *active, int *level, int *leftbot, int *lefttop, int *rightbot, int *botright, int *topright, float *a)
template __global__ void	fillLeft< double > (int halowidth, int *active, int *level, int *leftbot, int *lefttop, int *rightbot, int *botright, int *topright, double *a)
template<class T >
__global__ void	fillLeftnew (int halowidth, int nblk, int *active, int *level, int *leftbot, int *lefttop, int *rightbot, int *botright, int *topright, T *a)
template __global__ void	fillLeftnew< float > (int halowidth, int nblk, int *active, int *level, int *leftbot, int *lefttop, int *rightbot, int *botright, int *topright, float *a)
template __global__ void	fillLeftnew< double > (int halowidth, int nblk, int *active, int *level, int *leftbot, int *lefttop, int *rightbot, int *botright, int *topright, double *a)
template<class T >
void	fillLeftFlux (Param XParam, bool doProlongation, int ib, BlockP< T > XBlock, T *&z)
template<class T >
void	fillRight (Param XParam, int ib, BlockP< T > XBlock, T *&z)
template<class T >
__global__ void	fillRight (int halowidth, int *active, int *level, int *rightbot, int *righttop, int *leftbot, int *botleft, int *topleft, T *a)
template __global__ void	fillRight< float > (int halowidth, int *active, int *level, int *rightbot, int *righttop, int *leftbot, int *botleft, int *topleft, float *a)
template __global__ void	fillRight< double > (int halowidth, int *active, int *level, int *rightbot, int *righttop, int *leftbot, int *botleft, int *topleft, double *a)
template<class T >
__global__ void	fillRightnew (int halowidth, int nblk, int *active, int *level, int *rightbot, int *righttop, int *leftbot, int *botleft, int *topleft, T *a)
template __global__ void	fillRightnew< float > (int halowidth, int nblk, int *active, int *level, int *rightbot, int *righttop, int *leftbot, int *botleft, int *topleft, float *a)
template __global__ void	fillRightnew< double > (int halowidth, int nblk, int *active, int *level, int *rightbot, int *righttop, int *leftbot, int *botleft, int *topleft, double *a)
template<class T >
void	fillRightFlux (Param XParam, bool doProlongation, int ib, BlockP< T > XBlock, T *&z)
template void	fillRightFlux< float > (Param XParam, bool doProlongation, int ib, BlockP< float > XBlock, float *&z)
template void	fillRightFlux< double > (Param XParam, bool doProlongation, int ib, BlockP< double > XBlock, double *&z)
template<class T >
__global__ void	fillRightFlux (int halowidth, bool doProlongation, int *active, int *level, int *rightbot, int *righttop, int *leftbot, int *botleft, int *topleft, T *a)
template __global__ void	fillRightFlux< float > (int halowidth, bool doProlongation, int *active, int *level, int *rightbot, int *righttop, int *leftbot, int *botleft, int *topleft, float *a)
template __global__ void	fillRightFlux< double > (int halowidth, bool doProlongation, int *active, int *level, int *rightbot, int *righttop, int *leftbot, int *botleft, int *topleft, double *a)
template<class T >
void	fillBot (Param XParam, int ib, BlockP< T > XBlock, T *&z)
template<class T >
__global__ void	fillBot (int halowidth, int *active, int *level, int *botleft, int *botright, int *topleft, int *lefttop, int *righttop, T *a)
template __global__ void	fillBot< float > (int halowidth, int *active, int *level, int *botleft, int *botright, int *topleft, int *lefttop, int *righttop, float *a)
template __global__ void	fillBot< double > (int halowidth, int *active, int *level, int *botleft, int *botright, int *topleft, int *lefttop, int *righttop, double *a)
template<class T >
__global__ void	fillBotnew (int halowidth, int nblk, int *active, int *level, int *botleft, int *botright, int *topleft, int *lefttop, int *righttop, T *a)
template __global__ void	fillBotnew< float > (int halowidth, int nblk, int *active, int *level, int *botleft, int *botright, int *topleft, int *lefttop, int *righttop, float *a)
template __global__ void	fillBotnew< double > (int halowidth, int nblk, int *active, int *level, int *botleft, int *botright, int *topleft, int *lefttop, int *righttop, double *a)
template<class T >
void	fillBotFlux (Param XParam, bool doProlongation, int ib, BlockP< T > XBlock, T *&z)
template<class T >
void	fillTop (Param XParam, int ib, BlockP< T > XBlock, T *&z)
template<class T >
__global__ void	fillTop (int halowidth, int *active, int *level, int *topleft, int *topright, int *botleft, int *leftbot, int *rightbot, T *a)
template __global__ void	fillTop< float > (int halowidth, int *active, int *level, int *topleft, int *topright, int *botleft, int *leftbot, int *rightbot, float *a)
template __global__ void	fillTop< double > (int halowidth, int *active, int *level, int *topleft, int *topright, int *botleft, int *leftbot, int *rightbot, double *a)
template<class T >
__global__ void	fillTopnew (int halowidth, int nblk, int *active, int *level, int *topleft, int *topright, int *botleft, int *leftbot, int *rightbot, T *a)
template __global__ void	fillTopnew< float > (int halowidth, int nblk, int *active, int *level, int *topleft, int *topright, int *botleft, int *leftbot, int *rightbot, float *a)
template __global__ void	fillTopnew< double > (int halowidth, int nblk, int *active, int *level, int *topleft, int *topright, int *botleft, int *leftbot, int *rightbot, double *a)
template<class T >
void	fillTopFlux (Param XParam, bool doProlongation, int ib, BlockP< T > XBlock, T *&z)
template void	fillTopFlux< float > (Param XParam, bool doProlongation, int ib, BlockP< float > XBlock, float *&z)
template void	fillTopFlux< double > (Param XParam, bool doProlongation, int ib, BlockP< double > XBlock, double *&z)
template<class T >
__global__ void	fillTopFlux (int halowidth, bool doProlongation, int *active, int *level, int *topleft, int *topright, int *botleft, int *leftbot, int *rightbot, T *a)
template __global__ void	fillTopFlux< float > (int halowidth, bool doProlongation, int *active, int *level, int *topleft, int *topright, int *botleft, int *leftbot, int *rightbot, float *a)
template __global__ void	fillTopFlux< double > (int halowidth, bool doProlongation, int *active, int *level, int *topleft, int *topright, int *botleft, int *leftbot, int *rightbot, double *a)
template<class T >
void	fillCorners (Param XParam, BlockP< T > XBlock, T *&z)
template void	fillCorners< float > (Param XParam, BlockP< float > XBlock, float *&z)
template void	fillCorners< double > (Param XParam, BlockP< double > XBlock, double *&z)
template<class T >
void	fillCorners (Param XParam, BlockP< T > XBlock, EvolvingP< T > &Xev)
template void	fillCorners< float > (Param XParam, BlockP< float > XBlock, EvolvingP< float > &Xev)
template void	fillCorners< double > (Param XParam, BlockP< double > XBlock, EvolvingP< double > &Xev)
template<class T >
void	fillCorners (Param XParam, int ib, BlockP< T > XBlock, T *&z)
template void	fillCorners< float > (Param XParam, int ib, BlockP< float > XBlock, float *&z)
template void	fillCorners< double > (Param XParam, int ib, BlockP< double > XBlock, double *&z)

Function Documentation

fillBot() [1/2]

template<class T >

__global__ void fillBot	(	int	halowidth,
		int *	active,
		int *	level,
		int *	botleft,
		int *	botright,
		int *	topleft,
		int *	lefttop,
		int *	righttop,
		T *	a
	)

fillBot() [2/2]

template<class T >

void fillBot	(	Param	XParam,
		int	ib,
		BlockP< T >	XBlock,
		T *&	z
	)

fillBot< double >()

template __global__ void fillBot< double >	(	int	halowidth,
		int *	active,
		int *	level,
		int *	botleft,
		int *	botright,
		int *	topleft,
		int *	lefttop,
		int *	righttop,
		double *	a
	)

fillBot< float >()

template __global__ void fillBot< float >	(	int	halowidth,
		int *	active,
		int *	level,
		int *	botleft,
		int *	botright,
		int *	topleft,
		int *	lefttop,
		int *	righttop,
		float *	a
	)

fillBotFlux()

template<class T >

void fillBotFlux	(	Param	XParam,
		bool	doProlongation,
		int	ib,
		BlockP< T >	XBlock,
		T *&	z
	)

fillBotnew()

template<class T >

__global__ void fillBotnew	(	int	halowidth,
		int	nblk,
		int *	active,
		int *	level,
		int *	botleft,
		int *	botright,
		int *	topleft,
		int *	lefttop,
		int *	righttop,
		T *	a
	)

fillBotnew< double >()

template __global__ void fillBotnew< double >	(	int	halowidth,
		int	nblk,
		int *	active,
		int *	level,
		int *	botleft,
		int *	botright,
		int *	topleft,
		int *	lefttop,
		int *	righttop,
		double *	a
	)

fillBotnew< float >()

template __global__ void fillBotnew< float >	(	int	halowidth,
		int	nblk,
		int *	active,
		int *	level,
		int *	botleft,
		int *	botright,
		int *	topleft,
		int *	lefttop,
		int *	righttop,
		float *	a
	)

fillCorners() [1/3]

template<class T >

void fillCorners	(	Param	XParam,
		BlockP< T >	XBlock,
		EvolvingP< T > &	Xev
	)

fillCorners() [2/3]

template<class T >

void fillCorners	(	Param	XParam,
		BlockP< T >	XBlock,
		T *&	z
	)

fillCorners() [3/3]

template<class T >

void fillCorners	(	Param	XParam,
		int	ib,
		BlockP< T >	XBlock,
		T *&	z
	)

fillCorners< double >() [1/3]

template void fillCorners< double >	(	Param	XParam,
		BlockP< double >	XBlock,
		double *&	z
	)

fillCorners< double >() [2/3]

template void fillCorners< double >	(	Param	XParam,
		BlockP< double >	XBlock,
		EvolvingP< double > &	Xev
	)

fillCorners< double >() [3/3]

template void fillCorners< double >	(	Param	XParam,
		int	ib,
		BlockP< double >	XBlock,
		double *&	z
	)

fillCorners< float >() [1/3]

template void fillCorners< float >	(	Param	XParam,
		BlockP< float >	XBlock,
		EvolvingP< float > &	Xev
	)

fillCorners< float >() [2/3]

template void fillCorners< float >	(	Param	XParam,
		BlockP< float >	XBlock,
		float *&	z
	)

fillCorners< float >() [3/3]

template void fillCorners< float >	(	Param	XParam,
		int	ib,
		BlockP< float >	XBlock,
		float *&	z
	)

fillHalo() [1/4]

template<class T >

void fillHalo	(	Param	XParam,
		BlockP< T >	XBlock,
		EvolvingP< T >	Xev
	)

fillHalo() [2/4]

template<class T >

void fillHalo	(	Param	XParam,
		BlockP< T >	XBlock,
		EvolvingP< T >	Xev,
		T *	zb
	)

fillHalo() [3/4]

template<class T >

void fillHalo	(	Param	XParam,
		BlockP< T >	XBlock,
		FluxP< T >	Flux
	)

fillHalo() [4/4]

template<class T >

void fillHalo	(	Param	XParam,
		BlockP< T >	XBlock,
		GradientsP< T >	Grad
	)

fillHalo< double >() [1/4]

template void fillHalo< double >	(	Param	XParam,
		BlockP< double >	XBlock,
		EvolvingP< double >	Xev
	)

fillHalo< double >() [2/4]

template void fillHalo< double >	(	Param	XParam,
		BlockP< double >	XBlock,
		EvolvingP< double >	Xev,
		double *	zb
	)

fillHalo< double >() [3/4]

template void fillHalo< double >	(	Param	XParam,
		BlockP< double >	XBlock,
		FluxP< double >	Flux
	)

fillHalo< double >() [4/4]

template void fillHalo< double >	(	Param	XParam,
		BlockP< double >	XBlock,
		GradientsP< double >	Grad
	)

fillHalo< float >() [1/4]

template void fillHalo< float >	(	Param	XParam,
		BlockP< float >	XBlock,
		EvolvingP< float >	Xev
	)

fillHalo< float >() [2/4]

template void fillHalo< float >	(	Param	XParam,
		BlockP< float >	XBlock,
		EvolvingP< float >	Xev,
		float *	zb
	)

fillHalo< float >() [3/4]

template void fillHalo< float >	(	Param	XParam,
		BlockP< float >	XBlock,
		FluxP< float >	Flux
	)

fillHalo< float >() [4/4]

template void fillHalo< float >	(	Param	XParam,
		BlockP< float >	XBlock,
		GradientsP< float >	Grad
	)

fillHaloBotTopGPU()

template<class T >

void fillHaloBotTopGPU	(	Param	XParam,
		BlockP< T >	XBlock,
		cudaStream_t	stream,
		T *	z
	)

fillHaloBotTopGPU< double >()

template void fillHaloBotTopGPU< double >	(	Param	XParam,
		BlockP< double >	XBlock,
		cudaStream_t	stream,
		double *	z
	)

fillHaloBotTopGPU< float >()

template void fillHaloBotTopGPU< float >	(	Param	XParam,
		BlockP< float >	XBlock,
		cudaStream_t	stream,
		float *	z
	)

fillHaloBotTopGPUnew()

template<class T >

void fillHaloBotTopGPUnew	(	Param	XParam,
		BlockP< T >	XBlock,
		cudaStream_t	stream,
		T *	z
	)

fillHaloBotTopGPUnew< double >()

template void fillHaloBotTopGPUnew< double >	(	Param	XParam,
		BlockP< double >	XBlock,
		cudaStream_t	stream,
		double *	z
	)

fillHaloBotTopGPUnew< float >()

template void fillHaloBotTopGPUnew< float >	(	Param	XParam,
		BlockP< float >	XBlock,
		cudaStream_t	stream,
		float *	z
	)

fillHaloBTFluxC()

template<class T >

void fillHaloBTFluxC	(	Param	XParam,
		BlockP< T >	XBlock,
		T *	z
	)

fillHaloBTFluxC< double >()

template void fillHaloBTFluxC< double >	(	Param	XParam,
		BlockP< double >	XBlock,
		double *	z
	)

fillHaloBTFluxC< float >()

template void fillHaloBTFluxC< float >	(	Param	XParam,
		BlockP< float >	XBlock,
		float *	z
	)

fillHaloC()

template<class T >

void fillHaloC	(	Param	XParam,
		BlockP< T >	XBlock,
		T *	z
	)

Wrapping function for calculating halos for each block of a single variable on CPU.

Description

This function is a wraping fuction of the halo functions on CPU. It is called from the main Halo CPU function. This is layer 2 of 3 wrap so the candy doesn't stick too much.

fillHaloC< double >()

template void fillHaloC< double >	(	Param	XParam,
		BlockP< double >	XBlock,
		double *	z
	)

fillHaloC< float >()

template void fillHaloC< float >	(	Param	XParam,
		BlockP< float >	XBlock,
		float *	z
	)

fillHaloD()

template<class T >

void void fillHaloD	(	Param	XParam,
		int	ib,
		BlockP< T >	XBlock,
		T *	z
	)

Wrapping function for calculating halos on CPU on every side of a block of a single variable.

Description

This fuction is a wraping fuction of the halo functions for CPU. It is called from another wraping function to keep things clean. In a sense this is the third (and last) layer of wrapping

fillHaloD< double >()

template void fillHaloD< double >	(	Param	XParam,
		int	ib,
		BlockP< double >	XBlock,
		double *	z
	)

fillHaloD< float >()

template void fillHaloD< float >	(	Param	XParam,
		int	ib,
		BlockP< float >	XBlock,
		float *	z
	)

fillHaloF()

template<class T >

void fillHaloF	(	Param	XParam,
		bool	doProlongation,
		BlockP< T >	XBlock,
		T *	z
	)

Wrapping function for calculating flux in the halos for a block and a single variable on CPU.

Depreciated

This function is was never sucessful and will never be used. It is fundamentally flawed because is doesn't preserve the balance of fluxes on the restiction interface It should be deleted soon

Description

fillHaloF< double >()

template void fillHaloF< double >	(	Param	XParam,
		bool	doProlongation,
		BlockP< double >	XBlock,
		double *	z
	)

fillHaloF< float >()

template void fillHaloF< float >	(	Param	XParam,
		bool	doProlongation,
		BlockP< float >	XBlock,
		float *	z
	)

fillHaloGPU() [1/5]

template<class T >

void fillHaloGPU	(	Param	XParam,
		BlockP< T >	XBlock,
		cudaStream_t	stream,
		T *	z
	)

Wrapping function for calculating halos for each block of a single variable on GPU.

Description

This function is a wraping fuction of the halo functions on GPU. It is called from the main Halo GPU function. The present imnplementation is naive and slow one that calls the rather complex fillLeft type functions

fillHaloGPU() [2/5]

template<class T >

void fillHaloGPU	(	Param	XParam,
		BlockP< T >	XBlock,
		EvolvingP< T >	Xev
	)

fillHaloGPU() [3/5]

template<class T >

void fillHaloGPU	(	Param	XParam,
		BlockP< T >	XBlock,
		EvolvingP< T >	Xev,
		T *	zb
	)

fillHaloGPU() [4/5]

template<class T >

void fillHaloGPU	(	Param	XParam,
		BlockP< T >	XBlock,
		FluxP< T >	Flux
	)

fillHaloGPU() [5/5]

template<class T >

void fillHaloGPU	(	Param	XParam,
		BlockP< T >	XBlock,
		GradientsP< T >	Grad
	)

fillHaloGPU< double >() [1/5]

template void fillHaloGPU< double >	(	Param	XParam,
		BlockP< double >	XBlock,
		cudaStream_t	stream,
		double *	z
	)

fillHaloGPU< double >() [2/5]

template void fillHaloGPU< double >	(	Param	XParam,
		BlockP< double >	XBlock,
		EvolvingP< double >	Xev
	)

fillHaloGPU< double >() [3/5]

template void fillHaloGPU< double >	(	Param	XParam,
		BlockP< double >	XBlock,
		EvolvingP< double >	Xev,
		double *	zb
	)

fillHaloGPU< double >() [4/5]

template void fillHaloGPU< double >	(	Param	XParam,
		BlockP< double >	XBlock,
		FluxP< double >	Flux
	)

fillHaloGPU< double >() [5/5]

template void fillHaloGPU< double >	(	Param	XParam,
		BlockP< double >	XBlock,
		GradientsP< double >	Grad
	)

fillHaloGPU< float >() [1/5]

template void fillHaloGPU< float >	(	Param	XParam,
		BlockP< float >	XBlock,
		cudaStream_t	stream,
		float *	z
	)

fillHaloGPU< float >() [2/5]

template void fillHaloGPU< float >	(	Param	XParam,
		BlockP< float >	XBlock,
		EvolvingP< float >	Xev
	)

fillHaloGPU< float >() [3/5]

template void fillHaloGPU< float >	(	Param	XParam,
		BlockP< float >	XBlock,
		EvolvingP< float >	Xev,
		float *	zb
	)

fillHaloGPU< float >() [4/5]

template void fillHaloGPU< float >	(	Param	XParam,
		BlockP< float >	XBlock,
		FluxP< float >	Flux
	)

fillHaloGPU< float >() [5/5]

template void fillHaloGPU< float >	(	Param	XParam,
		BlockP< float >	XBlock,
		GradientsP< float >	Grad
	)

fillHaloGPUnew()

template<class T >

void fillHaloGPUnew	(	Param	XParam,
		BlockP< T >	XBlock,
		cudaStream_t	stream,
		T *	z
	)

fillHaloGPUnew< double >()

template void fillHaloGPUnew< double >	(	Param	XParam,
		BlockP< double >	XBlock,
		cudaStream_t	stream,
		double *	z
	)

fillHaloGPUnew< float >()

template void fillHaloGPUnew< float >	(	Param	XParam,
		BlockP< float >	XBlock,
		cudaStream_t	stream,
		float *	z
	)

fillHaloLeftRightGPU()

template<class T >

void fillHaloLeftRightGPU	(	Param	XParam,
		BlockP< T >	XBlock,
		cudaStream_t	stream,
		T *	z
	)

fillHaloLeftRightGPU< double >()

template void fillHaloLeftRightGPU< double >	(	Param	XParam,
		BlockP< double >	XBlock,
		cudaStream_t	stream,
		double *	z
	)

fillHaloLeftRightGPU< float >()

template void fillHaloLeftRightGPU< float >	(	Param	XParam,
		BlockP< float >	XBlock,
		cudaStream_t	stream,
		float *	z
	)

fillHaloLeftRightGPUnew()

template<class T >

void fillHaloLeftRightGPUnew	(	Param	XParam,
		BlockP< T >	XBlock,
		cudaStream_t	stream,
		T *	z
	)

fillHaloLeftRightGPUnew< double >()

template void fillHaloLeftRightGPUnew< double >	(	Param	XParam,
		BlockP< double >	XBlock,
		cudaStream_t	stream,
		double *	z
	)

fillHaloLeftRightGPUnew< float >()

template void fillHaloLeftRightGPUnew< float >	(	Param	XParam,
		BlockP< float >	XBlock,
		cudaStream_t	stream,
		float *	z
	)

fillHaloLRFluxC()

template<class T >

void fillHaloLRFluxC	(	Param	XParam,
		BlockP< T >	XBlock,
		T *	z
	)

fillHaloLRFluxC< double >()

template void fillHaloLRFluxC< double >	(	Param	XParam,
		BlockP< double >	XBlock,
		double *	z
	)

fillHaloLRFluxC< float >()

template void fillHaloLRFluxC< float >	(	Param	XParam,
		BlockP< float >	XBlock,
		float *	z
	)

fillHaloTopRightC()

template<class T >

void fillHaloTopRightC	(	Param	XParam,
		BlockP< T >	XBlock,
		T *	z
	)

Wrapping function for calculating flux for halos for each block of a single variable on GPU.

Description

This function is a wraping function of the halo flux functions on GPU. It is called from the main Halo GPU function. The present imnplementation is naive and slow one that calls the rather complex fillLeft type functions

fillHaloTopRightC< double >()

template void fillHaloTopRightC< double >	(	Param	XParam,
		BlockP< double >	XBlock,
		double *	z
	)

fillHaloTopRightC< float >()

template void fillHaloTopRightC< float >	(	Param	XParam,
		BlockP< float >	XBlock,
		float *	z
	)

fillHaloTopRightGPU()

template<class T >

void fillHaloTopRightGPU	(	Param	XParam,
		BlockP< T >	XBlock,
		cudaStream_t	stream,
		T *	z
	)

fillHaloTopRightGPU< double >()

template void fillHaloTopRightGPU< double >	(	Param	XParam,
		BlockP< double >	XBlock,
		cudaStream_t	stream,
		double *	z
	)

fillHaloTopRightGPU< float >()

template void fillHaloTopRightGPU< float >	(	Param	XParam,
		BlockP< float >	XBlock,
		cudaStream_t	stream,
		float *	z
	)

fillLeft() [1/2]

template<class T >

__global__ void fillLeft	(	int	halowidth,
		int *	active,
		int *	level,
		int *	leftbot,
		int *	lefttop,
		int *	rightbot,
		int *	botright,
		int *	topright,
		T *	a
	)

fillLeft() [2/2]

template<class T >

void fillLeft	(	Param	XParam,
		int	ib,
		BlockP< T >	XBlock,
		T *&	z
	)

fillLeft< double >()

template __global__ void fillLeft< double >	(	int	halowidth,
		int *	active,
		int *	level,
		int *	leftbot,
		int *	lefttop,
		int *	rightbot,
		int *	botright,
		int *	topright,
		double *	a
	)

fillLeft< float >()

template __global__ void fillLeft< float >	(	int	halowidth,
		int *	active,
		int *	level,
		int *	leftbot,
		int *	lefttop,
		int *	rightbot,
		int *	botright,
		int *	topright,
		float *	a
	)

fillLeftFlux()

template<class T >

void fillLeftFlux	(	Param	XParam,
		bool	doProlongation,
		int	ib,
		BlockP< T >	XBlock,
		T *&	z
	)

fillLeftnew()

template<class T >

__global__ void fillLeftnew	(	int	halowidth,
		int	nblk,
		int *	active,
		int *	level,
		int *	leftbot,
		int *	lefttop,
		int *	rightbot,
		int *	botright,
		int *	topright,
		T *	a
	)

fillLeftnew< double >()

template __global__ void fillLeftnew< double >	(	int	halowidth,
		int	nblk,
		int *	active,
		int *	level,
		int *	leftbot,
		int *	lefttop,
		int *	rightbot,
		int *	botright,
		int *	topright,
		double *	a
	)

fillLeftnew< float >()

template __global__ void fillLeftnew< float >	(	int	halowidth,
		int	nblk,
		int *	active,
		int *	level,
		int *	leftbot,
		int *	lefttop,
		int *	rightbot,
		int *	botright,
		int *	topright,
		float *	a
	)

fillRight() [1/2]

template<class T >

__global__ void fillRight	(	int	halowidth,
		int *	active,
		int *	level,
		int *	rightbot,
		int *	righttop,
		int *	leftbot,
		int *	botleft,
		int *	topleft,
		T *	a
	)

fillRight() [2/2]

template<class T >

void fillRight	(	Param	XParam,
		int	ib,
		BlockP< T >	XBlock,
		T *&	z
	)

fillRight< double >()

template __global__ void fillRight< double >	(	int	halowidth,
		int *	active,
		int *	level,
		int *	rightbot,
		int *	righttop,
		int *	leftbot,
		int *	botleft,
		int *	topleft,
		double *	a
	)

fillRight< float >()

template __global__ void fillRight< float >	(	int	halowidth,
		int *	active,
		int *	level,
		int *	rightbot,
		int *	righttop,
		int *	leftbot,
		int *	botleft,
		int *	topleft,
		float *	a
	)

fillRightFlux() [1/2]

template<class T >

__global__ void fillRightFlux	(	int	halowidth,
		bool	doProlongation,
		int *	active,
		int *	level,
		int *	rightbot,
		int *	righttop,
		int *	leftbot,
		int *	botleft,
		int *	topleft,
		T *	a
	)

fillRightFlux() [2/2]

template<class T >

void fillRightFlux	(	Param	XParam,
		bool	doProlongation,
		int	ib,
		BlockP< T >	XBlock,
		T *&	z
	)

fillRightFlux< double >() [1/2]

template __global__ void fillRightFlux< double >	(	int	halowidth,
		bool	doProlongation,
		int *	active,
		int *	level,
		int *	rightbot,
		int *	righttop,
		int *	leftbot,
		int *	botleft,
		int *	topleft,
		double *	a
	)

fillRightFlux< double >() [2/2]

template void fillRightFlux< double >	(	Param	XParam,
		bool	doProlongation,
		int	ib,
		BlockP< double >	XBlock,
		double *&	z
	)

fillRightFlux< float >() [1/2]

template __global__ void fillRightFlux< float >	(	int	halowidth,
		bool	doProlongation,
		int *	active,
		int *	level,
		int *	rightbot,
		int *	righttop,
		int *	leftbot,
		int *	botleft,
		int *	topleft,
		float *	a
	)

fillRightFlux< float >() [2/2]

template void fillRightFlux< float >	(	Param	XParam,
		bool	doProlongation,
		int	ib,
		BlockP< float >	XBlock,
		float *&	z
	)

fillRightnew()

template<class T >

__global__ void fillRightnew	(	int	halowidth,
		int	nblk,
		int *	active,
		int *	level,
		int *	rightbot,
		int *	righttop,
		int *	leftbot,
		int *	botleft,
		int *	topleft,
		T *	a
	)

fillRightnew< double >()

template __global__ void fillRightnew< double >	(	int	halowidth,
		int	nblk,
		int *	active,
		int *	level,
		int *	rightbot,
		int *	righttop,
		int *	leftbot,
		int *	botleft,
		int *	topleft,
		double *	a
	)

fillRightnew< float >()

template __global__ void fillRightnew< float >	(	int	halowidth,
		int	nblk,
		int *	active,
		int *	level,
		int *	rightbot,
		int *	righttop,
		int *	leftbot,
		int *	botleft,
		int *	topleft,
		float *	a
	)

fillTop() [1/2]

template<class T >

__global__ void fillTop	(	int	halowidth,
		int *	active,
		int *	level,
		int *	topleft,
		int *	topright,
		int *	botleft,
		int *	leftbot,
		int *	rightbot,
		T *	a
	)

fillTop() [2/2]

template<class T >

void fillTop	(	Param	XParam,
		int	ib,
		BlockP< T >	XBlock,
		T *&	z
	)

fillTop< double >()

template __global__ void fillTop< double >	(	int	halowidth,
		int *	active,
		int *	level,
		int *	topleft,
		int *	topright,
		int *	botleft,
		int *	leftbot,
		int *	rightbot,
		double *	a
	)

fillTop< float >()

template __global__ void fillTop< float >	(	int	halowidth,
		int *	active,
		int *	level,
		int *	topleft,
		int *	topright,
		int *	botleft,
		int *	leftbot,
		int *	rightbot,
		float *	a
	)

fillTopFlux() [1/2]

template<class T >

__global__ void fillTopFlux	(	int	halowidth,
		bool	doProlongation,
		int *	active,
		int *	level,
		int *	topleft,
		int *	topright,
		int *	botleft,
		int *	leftbot,
		int *	rightbot,
		T *	a
	)

fillTopFlux() [2/2]

template<class T >

void fillTopFlux	(	Param	XParam,
		bool	doProlongation,
		int	ib,
		BlockP< T >	XBlock,
		T *&	z
	)

fillTopFlux< double >() [1/2]

template __global__ void fillTopFlux< double >	(	int	halowidth,
		bool	doProlongation,
		int *	active,
		int *	level,
		int *	topleft,
		int *	topright,
		int *	botleft,
		int *	leftbot,
		int *	rightbot,
		double *	a
	)

fillTopFlux< double >() [2/2]

template void fillTopFlux< double >	(	Param	XParam,
		bool	doProlongation,
		int	ib,
		BlockP< double >	XBlock,
		double *&	z
	)

fillTopFlux< float >() [1/2]

template __global__ void fillTopFlux< float >	(	int	halowidth,
		bool	doProlongation,
		int *	active,
		int *	level,
		int *	topleft,
		int *	topright,
		int *	botleft,
		int *	leftbot,
		int *	rightbot,
		float *	a
	)

fillTopFlux< float >() [2/2]

template void fillTopFlux< float >	(	Param	XParam,
		bool	doProlongation,
		int	ib,
		BlockP< float >	XBlock,
		float *&	z
	)

fillTopnew()

template<class T >

__global__ void fillTopnew	(	int	halowidth,
		int	nblk,
		int *	active,
		int *	level,
		int *	topleft,
		int *	topright,
		int *	botleft,
		int *	leftbot,
		int *	rightbot,
		T *	a
	)

fillTopnew< double >()

template __global__ void fillTopnew< double >	(	int	halowidth,
		int	nblk,
		int *	active,
		int *	level,
		int *	topleft,
		int *	topright,
		int *	botleft,
		int *	leftbot,
		int *	rightbot,
		double *	a
	)

fillTopnew< float >()

template __global__ void fillTopnew< float >	(	int	halowidth,
		int	nblk,
		int *	active,
		int *	level,
		int *	topleft,
		int *	topright,
		int *	botleft,
		int *	leftbot,
		int *	rightbot,
		float *	a
	)

HaloFluxCPUBT()

template<class T >

void HaloFluxCPUBT	(	Param	XParam,
		int	ib,
		BlockP< T >	XBlock,
		T *	z
	)

HaloFluxCPULR()

template<class T >

void HaloFluxCPULR	(	Param	XParam,
		int	ib,
		BlockP< T >	XBlock,
		T *	z
	)

HaloFluxGPUBT()

template<class T >

__global__ void HaloFluxGPUBT	(	Param	XParam,
		BlockP< T >	XBlock,
		T *	z
	)

HaloFluxGPUBTnew()

template<class T >

__global__ void HaloFluxGPUBTnew	(	Param	XParam,
		BlockP< T >	XBlock,
		T *	z
	)

HaloFluxGPULR()

template<class T >

__global__ void HaloFluxGPULR	(	Param	XParam,
		BlockP< T >	XBlock,
		T *	z
	)

HaloFluxGPULRnew()

template<class T >

__global__ void HaloFluxGPULRnew	(	Param	XParam,
		BlockP< T >	XBlock,
		T *	z
	)

Recalculatehh()

template<class T >

void Recalculatehh	(	Param	XParam,
		BlockP< T >	XBlock,
		EvolvingP< T >	Xev,
		T *	zb
	)

Recalculatehh< double >()

template void Recalculatehh< double >	(	Param	XParam,
		BlockP< double >	XBlock,
		EvolvingP< double >	Xev,
		double *	zb
	)

Recalculatehh< float >()

template void Recalculatehh< float >	(	Param	XParam,
		BlockP< float >	XBlock,
		EvolvingP< float >	Xev,
		float *	zb
	)

RecalculateZs()

template<class T >

void RecalculateZs	(	Param	XParam,
		BlockP< T >	XBlock,
		EvolvingP< T >	Xev,
		T *	zb
	)

Recalculate water surface after recalculating the values on the halo on the CPU.

Recalculate water surface after recalculating the values on the halo on the GPU.

Description

Recalculate water surface after recalculating the values on the halo on the CPU. zb (bottom elevation) on each halo is calculated at the start of the loop or as part of the initial condition. When conserve-elevation is not required, only h is recalculated on the halo at ever 1/2 steps.
zs then needs to be recalculated to obtain a mass-conservative solution (if zs is conserved then mass conservation is not garanteed)

Warning

This function calculate zs everywhere in the block... this is a bit unecessary. Instead it should recalculate only where there is a prolongation or a restiction

Description

Recalculate water surface after recalculating the values on the halo on the CPU. zb (bottom elevation) on each halo is calculated at the start of the loop or as part of the initial condition. When conserve-elevation is not required, only h is recalculated on the halo at ever 1/2 steps. zs then needs to be recalculated to obtain a mass-conservative solution (if zs is conserved then mass conservation is not garanteed)

Warning

This function calculate zs everywhere in the block... this is a bit unecessary. Instead it should recalculate only where there is a prolongation or a restiction

RecalculateZs< double >()

template void RecalculateZs< double >	(	Param	XParam,
		BlockP< double >	XBlock,
		EvolvingP< double >	Xev,
		double *	zb
	)

RecalculateZs< float >()

template void RecalculateZs< float >	(	Param	XParam,
		BlockP< float >	XBlock,
		EvolvingP< float >	Xev,
		float *	zb
	)

RecalculateZsGPU()

template<class T >

__global__ void RecalculateZsGPU	(	Param	XParam,
		BlockP< T >	XBlock,
		EvolvingP< T >	Xev,
		T *	zb
	)

RecalculateZsGPU< double >()

template __global__ void RecalculateZsGPU< double >	(	Param	XParam,
		BlockP< double >	XBlock,
		EvolvingP< double >	Xev,
		double *	zb
	)

RecalculateZsGPU< float >()

template __global__ void RecalculateZsGPU< float >	(	Param	XParam,
		BlockP< float >	XBlock,
		EvolvingP< float >	Xev,
		float *	zb
	)

refine_linear()

template<class T >

void refine_linear	(	Param	XParam,
		BlockP< T >	XBlock,
		T *	z,
		T *	dzdx,
		T *	dzdy
	)

refine_linear< double >()

template void refine_linear< double >	(	Param	XParam,
		BlockP< double >	XBlock,
		double *	z,
		double *	dzdx,
		double *	dzdy
	)

refine_linear< float >()

template void refine_linear< float >	(	Param	XParam,
		BlockP< float >	XBlock,
		float *	z,
		float *	dzdx,
		float *	dzdy
	)

refine_linear_Bot()

template<class T >

void refine_linear_Bot	(	Param	XParam,
		int	ib,
		BlockP< T >	XBlock,
		T *	z,
		T *	dzdx,
		T *	dzdy
	)

refine_linear_Bot< double >()

template void refine_linear_Bot< double >	(	Param	XParam,
		int	ib,
		BlockP< double >	XBlock,
		double *	z,
		double *	dzdx,
		double *	dzdy
	)

refine_linear_Bot< float >()

template void refine_linear_Bot< float >	(	Param	XParam,
		int	ib,
		BlockP< float >	XBlock,
		float *	z,
		float *	dzdx,
		float *	dzdy
	)

refine_linear_BotGPU()

template<class T >

__global__ void refine_linear_BotGPU	(	Param	XParam,
		BlockP< T >	XBlock,
		T *	z,
		T *	dzdx,
		T *	dzdy
	)

refine_linear_BotGPU< double >()

template __global__ void refine_linear_BotGPU< double >	(	Param	XParam,
		BlockP< double >	XBlock,
		double *	z,
		double *	dzdx,
		double *	dzdy
	)

refine_linear_BotGPU< float >()

template __global__ void refine_linear_BotGPU< float >	(	Param	XParam,
		BlockP< float >	XBlock,
		float *	z,
		float *	dzdx,
		float *	dzdy
	)

refine_linear_Left()

template<class T >

void refine_linear_Left	(	Param	XParam,
		int	ib,
		BlockP< T >	XBlock,
		T *	z,
		T *	dzdx,
		T *	dzdy
	)

refine_linear_Left< double >()

template void refine_linear_Left< double >	(	Param	XParam,
		int	ib,
		BlockP< double >	XBlock,
		double *	z,
		double *	dzdx,
		double *	dzdy
	)

refine_linear_Left< float >()

template void refine_linear_Left< float >	(	Param	XParam,
		int	ib,
		BlockP< float >	XBlock,
		float *	z,
		float *	dzdx,
		float *	dzdy
	)

refine_linear_LeftGPU()

template<class T >

__global__ void refine_linear_LeftGPU	(	Param	XParam,
		BlockP< T >	XBlock,
		T *	z,
		T *	dzdx,
		T *	dzdy
	)

refine_linear_LeftGPU< double >()

template __global__ void refine_linear_LeftGPU< double >	(	Param	XParam,
		BlockP< double >	XBlock,
		double *	z,
		double *	dzdx,
		double *	dzdy
	)

refine_linear_LeftGPU< float >()

template __global__ void refine_linear_LeftGPU< float >	(	Param	XParam,
		BlockP< float >	XBlock,
		float *	z,
		float *	dzdx,
		float *	dzdy
	)

refine_linear_Right()

template<class T >

void refine_linear_Right	(	Param	XParam,
		int	ib,
		BlockP< T >	XBlock,
		T *	z,
		T *	dzdx,
		T *	dzdy
	)

refine_linear_Right< double >()

template void refine_linear_Right< double >	(	Param	XParam,
		int	ib,
		BlockP< double >	XBlock,
		double *	z,
		double *	dzdx,
		double *	dzdy
	)

refine_linear_Right< float >()

template void refine_linear_Right< float >	(	Param	XParam,
		int	ib,
		BlockP< float >	XBlock,
		float *	z,
		float *	dzdx,
		float *	dzdy
	)

refine_linear_RightGPU()

template<class T >

__global__ void refine_linear_RightGPU	(	Param	XParam,
		BlockP< T >	XBlock,
		T *	z,
		T *	dzdx,
		T *	dzdy
	)

refine_linear_RightGPU< double >()

template __global__ void refine_linear_RightGPU< double >	(	Param	XParam,
		BlockP< double >	XBlock,
		double *	z,
		double *	dzdx,
		double *	dzdy
	)

refine_linear_RightGPU< float >()

template __global__ void refine_linear_RightGPU< float >	(	Param	XParam,
		BlockP< float >	XBlock,
		float *	z,
		float *	dzdx,
		float *	dzdy
	)

refine_linear_Top()

template<class T >

void refine_linear_Top	(	Param	XParam,
		int	ib,
		BlockP< T >	XBlock,
		T *	z,
		T *	dzdx,
		T *	dzdy
	)

refine_linear_Top< double >()

template void refine_linear_Top< double >	(	Param	XParam,
		int	ib,
		BlockP< double >	XBlock,
		double *	z,
		double *	dzdx,
		double *	dzdy
	)

refine_linear_Top< float >()

template void refine_linear_Top< float >	(	Param	XParam,
		int	ib,
		BlockP< float >	XBlock,
		float *	z,
		float *	dzdx,
		float *	dzdy
	)

refine_linear_TopGPU()

template<class T >

__global__ void refine_linear_TopGPU	(	Param	XParam,
		BlockP< T >	XBlock,
		T *	z,
		T *	dzdx,
		T *	dzdy
	)

refine_linear_TopGPU< double >()

template __global__ void refine_linear_TopGPU< double >	(	Param	XParam,
		BlockP< double >	XBlock,
		double *	z,
		double *	dzdx,
		double *	dzdy
	)

refine_linear_TopGPU< float >()

template __global__ void refine_linear_TopGPU< float >	(	Param	XParam,
		BlockP< float >	XBlock,
		float *	z,
		float *	dzdx,
		float *	dzdy
	)

refine_linearGPU()

template<class T >

void refine_linearGPU	(	Param	XParam,
		BlockP< T >	XBlock,
		T *	z,
		T *	dzdx,
		T *	dzdy
	)

refine_linearGPU< double >()

template void refine_linearGPU< double >	(	Param	XParam,
		BlockP< double >	XBlock,
		double *	z,
		double *	dzdx,
		double *	dzdy
	)

refine_linearGPU< float >()

template void refine_linearGPU< float >	(	Param	XParam,
		BlockP< float >	XBlock,
		float *	z,
		float *	dzdx,
		float *	dzdy
	)