Skip to content

File GridManip.cu

FileList > src > GridManip.cu

Go to the source code of this file

  • #include "GridManip.h"

Public Functions

Type Name
void Copy2CartCPU (int nx, int ny, T * dest, T * src)
Copy values from source to destination for a Cartesian grid.
template void Copy2CartCPU< bool > (int nx, int ny, bool * dest, bool * src)
template void Copy2CartCPU< double > (int nx, int ny, double * dest, double * src)
template void Copy2CartCPU< float > (int nx, int ny, float * dest, float * src)
template void Copy2CartCPU< int > (int nx, int ny, int * dest, int * src)
void CopyArrayBUQ (Param XParam, BlockP< F > XBlock, T * source, T *& dest)
Copy values from source array to destination array for all blocks.
void CopyArrayBUQ (Param XParam, BlockP< T > XBlock, EvolvingP< T > source, EvolvingP< T > & dest)
Copy all evolving variables from source to destination.
void CopyArrayBUQ (Param XParam, BlockP< T > XBlock, EvolvingP< T > source, EvolvingP_M< T > & dest)
Copy all evolving variables and compute derived quantities (U, hU).
template void CopyArrayBUQ< bool, double > (Param XParam, BlockP< double > XBlock, bool * source, bool *& dest)
template void CopyArrayBUQ< bool, float > (Param XParam, BlockP< float > XBlock, bool * source, bool *& dest)
template void CopyArrayBUQ< double > (Param XParam, BlockP< double > XBlock, EvolvingP< double > source, EvolvingP< double > & dest)
template void CopyArrayBUQ< double > (Param XParam, BlockP< double > XBlock, EvolvingP< double > source, EvolvingP_M< double > & dest)
template void CopyArrayBUQ< double, double > (Param XParam, BlockP< double > XBlock, double * source, double *& dest)
template void CopyArrayBUQ< double, float > (Param XParam, BlockP< float > XBlock, double * source, double *& dest)
template void CopyArrayBUQ< float > (Param XParam, BlockP< float > XBlock, EvolvingP< float > source, EvolvingP< float > & dest)
template void CopyArrayBUQ< float > (Param XParam, BlockP< float > XBlock, EvolvingP< float > source, EvolvingP_M< float > & dest)
template void CopyArrayBUQ< float, double > (Param XParam, BlockP< double > XBlock, float * source, float *& dest)
template void CopyArrayBUQ< float, float > (Param XParam, BlockP< float > XBlock, float * source, float *& dest)
template void CopyArrayBUQ< int, double > (Param XParam, BlockP< double > XBlock, int * source, int *& dest)
template void CopyArrayBUQ< int, float > (Param XParam, BlockP< float > XBlock, int * source, int *& dest)
void InitArrayBUQ (Param XParam, BlockP< F > XBlock, T initval, T *& Arr)
Initialize a block-structured array with a given value.
template void InitArrayBUQ< bool, double > (Param XParam, BlockP< double > XBlock, bool initval, bool *& Arr)
template void InitArrayBUQ< bool, float > (Param XParam, BlockP< float > XBlock, bool initval, bool *& Arr)
template void InitArrayBUQ< double, double > (Param XParam, BlockP< double > XBlock, double initval, double *& Arr)
template void InitArrayBUQ< double, float > (Param XParam, BlockP< float > XBlock, double initval, double *& Arr)
template void InitArrayBUQ< float, double > (Param XParam, BlockP< double > XBlock, float initval, float *& Arr)
template void InitArrayBUQ< float, float > (Param XParam, BlockP< float > XBlock, float initval, float *& Arr)
template void InitArrayBUQ< int, double > (Param XParam, BlockP< double > XBlock, int initval, int *& Arr)
template void InitArrayBUQ< int, float > (Param XParam, BlockP< float > XBlock, int initval, int *& Arr)
void InitBlkBUQ (Param XParam, BlockP< F > XBlock, T initval, T *& Arr)
Initialize a block-level array with a given value.
template void InitBlkBUQ< bool, double > (Param XParam, BlockP< double > XBlock, bool initval, bool *& Arr)
template void InitBlkBUQ< bool, float > (Param XParam, BlockP< float > XBlock, bool initval, bool *& Arr)
template void InitBlkBUQ< double, double > (Param XParam, BlockP< double > XBlock, double initval, double *& Arr)
template void InitBlkBUQ< double, float > (Param XParam, BlockP< float > XBlock, double initval, double *& Arr)
template void InitBlkBUQ< float, double > (Param XParam, BlockP< double > XBlock, float initval, float *& Arr)
template void InitBlkBUQ< float, float > (Param XParam, BlockP< float > XBlock, float initval, float *& Arr)
template void InitBlkBUQ< int, double > (Param XParam, BlockP< double > XBlock, int initval, int *& Arr)
template void InitBlkBUQ< int, float > (Param XParam, BlockP< float > XBlock, int initval, int *& Arr)
void InterpstepCPU (int nx, int ny, int hdstep, F totaltime, F hddt, T *& Ux, T * Uo, T * Un)
CPU routine for time interpolation of solution arrays.
template void InterpstepCPU< double, double > (int nx, int ny, int hdstep, double totaltime, double hddt, double *& Ux, double * Uo, double * Un)
template void InterpstepCPU< double, float > (int nx, int ny, int hdstep, float totaltime, float hddt, double *& Ux, double * Uo, double * Un)
template void InterpstepCPU< float, double > (int nx, int ny, int hdstep, double totaltime, double hddt, float *& Ux, float * Uo, float * Un)
template void InterpstepCPU< float, float > (int nx, int ny, int hdstep, float totaltime, float hddt, float *& Ux, float * Uo, float * Un)
template void InterpstepCPU< int, double > (int nx, int ny, int hdstep, double totaltime, double hddt, int *& Ux, int * Uo, int * Un)
template void InterpstepCPU< int, float > (int nx, int ny, int hdstep, float totaltime, float hddt, int *& Ux, int * Uo, int * Un)
__global__ void InterpstepGPU (int nx, int ny, T totaltime, T beforetime, T aftertime, T * Ux, T * Uo, T * Un)
GPU kernel for time interpolation of solution arrays.
template __global__ void InterpstepGPU< double > (int nx, int ny, double totaltime, double beforetime, double aftertime, double * Ux, double * Uo, double * Un)
template __global__ void InterpstepGPU< float > (int nx, int ny, float totaltime, float beforetime, float aftertime, float * Ux, float * Uo, float * Un)
T blockmean (T x, T y, T dx, F forcing)
Compute block mean value for (x, y) over grid spacing dx.
void interp2BUQ (Param XParam, BlockP< T > XBlock, F forcing, T *& z)
Interpolate values from forcing map to block array using bilinear interpolation.
void interp2BUQ (Param XParam, BlockP< T > XBlock, std::vector< StaticForcingP< float > > forcing, T * z)
Interpolate values from multiple forcing maps to block array using bilinear interpolation.
T interp2BUQ (T x, T y, T dx, F forcing)
Interpolate value at (x, y) using either bilinear or blockmean interpolation.
T interp2BUQ (T x, T y, F forcing)
Bilinear interpolation for value at (x, y) from forcing map.
template void interp2BUQ< double > (Param XParam, BlockP< double > XBlock, std::vector< StaticForcingP< float > > forcing, double * z)
template void interp2BUQ< double, DynForcingP< float > > (Param XParam, BlockP< double > XBlock, DynForcingP< float > forcing, double *& z)
template double interp2BUQ< double, DynForcingP< float > > (double x, double y, DynForcingP< float > forcing)
template void interp2BUQ< double, StaticForcingP< float > > (Param XParam, BlockP< double > XBlock, StaticForcingP< float > forcing, double *& z)
template double interp2BUQ< double, StaticForcingP< float > > (double x, double y, StaticForcingP< float > forcing)
template double interp2BUQ< double, StaticForcingP< int > > (double x, double y, StaticForcingP< int > forcing)
template void interp2BUQ< double, deformmap< float > > (Param XParam, BlockP< double > XBlock, deformmap< float > forcing, double *& z)
template double interp2BUQ< double, deformmap< float > > (double x, double y, deformmap< float > forcing)
template void interp2BUQ< float > (Param XParam, BlockP< float > XBlock, std::vector< StaticForcingP< float > > forcing, float * z)
template void interp2BUQ< float, DynForcingP< float > > (Param XParam, BlockP< float > XBlock, DynForcingP< float > forcing, float *& z)
template float interp2BUQ< float, DynForcingP< float > > (float x, float y, DynForcingP< float > forcing)
template void interp2BUQ< float, StaticForcingP< float > > (Param XParam, BlockP< float > XBlock, StaticForcingP< float > forcing, float *& z)
template float interp2BUQ< float, StaticForcingP< float > > (float x, float y, StaticForcingP< float > forcing)
template float interp2BUQ< float, StaticForcingP< int > > (float x, float y, StaticForcingP< int > forcing)
template void interp2BUQ< float, deformmap< float > > (Param XParam, BlockP< float > XBlock, deformmap< float > forcing, float *& z)
template float interp2BUQ< float, deformmap< float > > (float x, float y, deformmap< float > forcing)
void setedges (Param XParam, BlockP< T > XBlock, T *& zb)
Set edge values for bathymetry array at domain boundaries.
template void setedges< double > (Param XParam, BlockP< double > XBlock, double *& zb)
template void setedges< float > (Param XParam, BlockP< float > XBlock, float *& zb)
void setedgessideBT (Param XParam, int ib, int blkA, int blkB, int jread, int jwrite, T *& zb)
Set bottom/top edge values for bathymetry array.
void setedgessideLR (Param XParam, int ib, int blkA, int blkB, int iread, int iwrite, T *& zb)
Set left/right edge values for bathymetry array.

Public Functions Documentation

function Copy2CartCPU

Copy values from source to destination for a Cartesian grid. 

template<class T>
void Copy2CartCPU (
    int nx,
    int ny,
    T * dest,
    T * src
)

Copies all values from src to dest for a regular Cartesian grid.

Template parameters:

  • T Data type

Parameters:

  • nx Number of x grid points
  • ny Number of y grid points
  • dest Destination array
  • src Source array

function Copy2CartCPU< bool >

template void Copy2CartCPU< bool > (
    int nx,
    int ny,
    bool * dest,
    bool * src
)

function Copy2CartCPU< double >

template void Copy2CartCPU< double > (
    int nx,
    int ny,
    double * dest,
    double * src
)

function Copy2CartCPU< float >

template void Copy2CartCPU< float > (
    int nx,
    int ny,
    float * dest,
    float * src
)

function Copy2CartCPU< int >

template void Copy2CartCPU< int > (
    int nx,
    int ny,
    int * dest,
    int * src
)

function CopyArrayBUQ

Copy values from source array to destination array for all blocks. 

template<class T, class F>
void CopyArrayBUQ (
    Param XParam,
    BlockP < F > XBlock,
    T * source,
    T *& dest
)

Copies all elements for each active block from source to dest.

Template parameters:

  • T Data type
  • F Block type

Parameters:

  • XParam Simulation parameters
  • XBlock Block parameters
  • source Source array
  • dest Destination array

function CopyArrayBUQ

Copy all evolving variables from source to destination. 

template<class T>
void CopyArrayBUQ (
    Param XParam,
    BlockP < T > XBlock,
    EvolvingP < T > source,
    EvolvingP < T > & dest
)

Copies h, u, v, zs arrays for all blocks.

Template parameters:

  • T Data type

Parameters:

  • XParam Simulation parameters
  • XBlock Block parameters
  • source Source evolving variables
  • dest Destination evolving variables

function CopyArrayBUQ

Copy all evolving variables and compute derived quantities (U, hU). 

template<class T>
void CopyArrayBUQ (
    Param XParam,
    BlockP < T > XBlock,
    EvolvingP < T > source,
    EvolvingP_M < T > & dest
)

Copies h, u, v, zs arrays and computes U and hU for all blocks.

Template parameters:

  • T Data type

Parameters:

  • XParam Simulation parameters
  • XBlock Block parameters
  • source Source evolving variables
  • dest Destination evolving variables (with derived quantities)

function CopyArrayBUQ< bool, double >

template void CopyArrayBUQ< bool, double > (
    Param XParam,
    BlockP < double > XBlock,
    bool * source,
    bool *& dest
)

function CopyArrayBUQ< bool, float >

template void CopyArrayBUQ< bool, float > (
    Param XParam,
    BlockP < float > XBlock,
    bool * source,
    bool *& dest
)

function CopyArrayBUQ< double >

template void CopyArrayBUQ< double > (
    Param XParam,
    BlockP < double > XBlock,
    EvolvingP < double > source,
    EvolvingP < double > & dest
)

function CopyArrayBUQ< double >

template void CopyArrayBUQ< double > (
    Param XParam,
    BlockP < double > XBlock,
    EvolvingP < double > source,
    EvolvingP_M < double > & dest
)

function CopyArrayBUQ< double, double >

template void CopyArrayBUQ< double, double > (
    Param XParam,
    BlockP < double > XBlock,
    double * source,
    double *& dest
)

function CopyArrayBUQ< double, float >

template void CopyArrayBUQ< double, float > (
    Param XParam,
    BlockP < float > XBlock,
    double * source,
    double *& dest
)

function CopyArrayBUQ< float >

template void CopyArrayBUQ< float > (
    Param XParam,
    BlockP < float > XBlock,
    EvolvingP < float > source,
    EvolvingP < float > & dest
)

function CopyArrayBUQ< float >

template void CopyArrayBUQ< float > (
    Param XParam,
    BlockP < float > XBlock,
    EvolvingP < float > source,
    EvolvingP_M < float > & dest
)

function CopyArrayBUQ< float, double >

template void CopyArrayBUQ< float, double > (
    Param XParam,
    BlockP < double > XBlock,
    float * source,
    float *& dest
)

function CopyArrayBUQ< float, float >

template void CopyArrayBUQ< float, float > (
    Param XParam,
    BlockP < float > XBlock,
    float * source,
    float *& dest
)

function CopyArrayBUQ< int, double >

template void CopyArrayBUQ< int, double > (
    Param XParam,
    BlockP < double > XBlock,
    int * source,
    int *& dest
)

function CopyArrayBUQ< int, float >

template void CopyArrayBUQ< int, float > (
    Param XParam,
    BlockP < float > XBlock,
    int * source,
    int *& dest
)

function InitArrayBUQ

Initialize a block-structured array with a given value. 

template<class T, class F>
void InitArrayBUQ (
    Param XParam,
    BlockP < F > XBlock,
    T initval,
    T *& Arr
)

Sets all elements of Arr for each active block to initval.

Template parameters:

  • T Data type (float, double, int, bool)
  • F Block type

Parameters:

  • XParam Simulation parameters
  • XBlock Block parameters
  • initval Value to initialize
  • Arr Array to initialize

function InitArrayBUQ< bool, double >

template void InitArrayBUQ< bool, double > (
    Param XParam,
    BlockP < double > XBlock,
    bool initval,
    bool *& Arr
)

function InitArrayBUQ< bool, float >

template void InitArrayBUQ< bool, float > (
    Param XParam,
    BlockP < float > XBlock,
    bool initval,
    bool *& Arr
)

function InitArrayBUQ< double, double >

template void InitArrayBUQ< double, double > (
    Param XParam,
    BlockP < double > XBlock,
    double initval,
    double *& Arr
)

function InitArrayBUQ< double, float >

template void InitArrayBUQ< double, float > (
    Param XParam,
    BlockP < float > XBlock,
    double initval,
    double *& Arr
)

function InitArrayBUQ< float, double >

template void InitArrayBUQ< float, double > (
    Param XParam,
    BlockP < double > XBlock,
    float initval,
    float *& Arr
)

function InitArrayBUQ< float, float >

template void InitArrayBUQ< float, float > (
    Param XParam,
    BlockP < float > XBlock,
    float initval,
    float *& Arr
)

function InitArrayBUQ< int, double >

template void InitArrayBUQ< int, double > (
    Param XParam,
    BlockP < double > XBlock,
    int initval,
    int *& Arr
)

function InitArrayBUQ< int, float >

template void InitArrayBUQ< int, float > (
    Param XParam,
    BlockP < float > XBlock,
    int initval,
    int *& Arr
)

function InitBlkBUQ

Initialize a block-level array with a given value. 

template<class T, class F>
void InitBlkBUQ (
    Param XParam,
    BlockP < F > XBlock,
    T initval,
    T *& Arr
)

Sets each block's entry in Arr to initval.

Template parameters:

  • T Data type
  • F Block type

Parameters:

  • XParam Simulation parameters
  • XBlock Block parameters
  • initval Value to initialize
  • Arr Array to initialize

function InitBlkBUQ< bool, double >

template void InitBlkBUQ< bool, double > (
    Param XParam,
    BlockP < double > XBlock,
    bool initval,
    bool *& Arr
)

function InitBlkBUQ< bool, float >

template void InitBlkBUQ< bool, float > (
    Param XParam,
    BlockP < float > XBlock,
    bool initval,
    bool *& Arr
)

function InitBlkBUQ< double, double >

template void InitBlkBUQ< double, double > (
    Param XParam,
    BlockP < double > XBlock,
    double initval,
    double *& Arr
)

function InitBlkBUQ< double, float >

template void InitBlkBUQ< double, float > (
    Param XParam,
    BlockP < float > XBlock,
    double initval,
    double *& Arr
)

function InitBlkBUQ< float, double >

template void InitBlkBUQ< float, double > (
    Param XParam,
    BlockP < double > XBlock,
    float initval,
    float *& Arr
)

function InitBlkBUQ< float, float >

template void InitBlkBUQ< float, float > (
    Param XParam,
    BlockP < float > XBlock,
    float initval,
    float *& Arr
)

function InitBlkBUQ< int, double >

template void InitBlkBUQ< int, double > (
    Param XParam,
    BlockP < double > XBlock,
    int initval,
    int *& Arr
)

function InitBlkBUQ< int, float >

template void InitBlkBUQ< int, float > (
    Param XParam,
    BlockP < float > XBlock,
    int initval,
    int *& Arr
)

function InterpstepCPU

CPU routine for time interpolation of solution arrays. 

template<class T, class F>
void InterpstepCPU (
    int nx,
    int ny,
    int hdstep,
    F totaltime,
    F hddt,
    T *& Ux,
    T * Uo,
    T * Un
)

Interpolates between Uo and Un to compute Ux at a given time step.

Template parameters:

  • T Data type
  • F Time type

Parameters:

  • nx Number of x grid points
  • ny Number of y grid points
  • hdstep Time step index
  • totaltime Total simulation time
  • hddt Time step size
  • Ux Output array
  • Uo Previous solution array
  • Un Next solution array

function InterpstepCPU< double, double >

template void InterpstepCPU< double, double > (
    int nx,
    int ny,
    int hdstep,
    double totaltime,
    double hddt,
    double *& Ux,
    double * Uo,
    double * Un
)

function InterpstepCPU< double, float >

template void InterpstepCPU< double, float > (
    int nx,
    int ny,
    int hdstep,
    float totaltime,
    float hddt,
    double *& Ux,
    double * Uo,
    double * Un
)

function InterpstepCPU< float, double >

template void InterpstepCPU< float, double > (
    int nx,
    int ny,
    int hdstep,
    double totaltime,
    double hddt,
    float *& Ux,
    float * Uo,
    float * Un
)

function InterpstepCPU< float, float >

template void InterpstepCPU< float, float > (
    int nx,
    int ny,
    int hdstep,
    float totaltime,
    float hddt,
    float *& Ux,
    float * Uo,
    float * Un
)

function InterpstepCPU< int, double >

template void InterpstepCPU< int, double > (
    int nx,
    int ny,
    int hdstep,
    double totaltime,
    double hddt,
    int *& Ux,
    int * Uo,
    int * Un
)

function InterpstepCPU< int, float >

template void InterpstepCPU< int, float > (
    int nx,
    int ny,
    int hdstep,
    float totaltime,
    float hddt,
    int *& Ux,
    int * Uo,
    int * Un
)

function InterpstepGPU

GPU kernel for time interpolation of solution arrays. 

template<class T>
__global__ void InterpstepGPU (
    int nx,
    int ny,
    T totaltime,
    T beforetime,
    T aftertime,
    T * Ux,
    T * Uo,
    T * Un
)

Interpolates between Uo and Un to compute Ux at a given time using shared memory.

Template parameters:

  • T Data type

Parameters:

  • nx Number of x grid points
  • ny Number of y grid points
  • totaltime Total simulation time
  • beforetime Previous time
  • aftertime Next time
  • Ux Output array
  • Uo Previous solution array
  • Un Next solution array

function InterpstepGPU< double >

template __global__ void InterpstepGPU< double > (
    int nx,
    int ny,
    double totaltime,
    double beforetime,
    double aftertime,
    double * Ux,
    double * Uo,
    double * Un
)

function InterpstepGPU< float >

template __global__ void InterpstepGPU< float > (
    int nx,
    int ny,
    float totaltime,
    float beforetime,
    float aftertime,
    float * Ux,
    float * Uo,
    float * Un
)

function blockmean

Compute block mean value for (x, y) over grid spacing dx. 

template<class T, class F>
T blockmean (
    T x,
    T y,
    T dx,
    F forcing
)

Averages values in the forcing map over the block centered at (x, y).

Template parameters:

Parameters:

  • x X coordinate
  • y Y coordinate
  • dx Grid spacing
  • forcing Forcing map

Returns:

Block mean value

function interp2BUQ

Interpolate values from forcing map to block array using bilinear interpolation. 

template<class T, class F>
void interp2BUQ (
    Param XParam,
    BlockP < T > XBlock,
    F forcing,
    T *& z
)

Fills z array for each block using bilinear interpolation from forcing map(s).

Template parameters:

Parameters:

  • XParam Simulation parameters
  • XBlock Block parameters
  • forcing Forcing map(s)
  • z Output array

function interp2BUQ

Interpolate values from multiple forcing maps to block array using bilinear interpolation. 

template<class T>
void interp2BUQ (
    Param XParam,
    BlockP < T > XBlock,
    std::vector< StaticForcingP < float > > forcing,
    T * z
)

Fills z array for each block using bilinear interpolation from multiple forcing maps.

Template parameters:

  • T Data type

Parameters:

  • XParam Simulation parameters
  • XBlock Block parameters
  • forcing Vector of forcing maps
  • z Output array

function interp2BUQ

Interpolate value at (x, y) using either bilinear or blockmean interpolation. 

template<class T, class F>
T interp2BUQ (
    T x,
    T y,
    T dx,
    F forcing
)

Chooses interpolation method based on grid spacing dx.

Template parameters:

Parameters:

  • x X coordinate
  • y Y coordinate
  • dx Grid spacing
  • forcing Forcing map

Returns:

Interpolated value

function interp2BUQ

Bilinear interpolation for value at (x, y) from forcing map. 

template<class T, class F>
T interp2BUQ (
    T x,
    T y,
    F forcing
)

Performs bilinear interpolation using surrounding grid points in forcing map.

Template parameters:

Parameters:

  • x X coordinate
  • y Y coordinate
  • forcing Forcing map

Returns:

Interpolated value

function interp2BUQ< double >

template void interp2BUQ< double > (
    Param XParam,
    BlockP < double > XBlock,
    std::vector< StaticForcingP < float > > forcing,
    double * z
)

function interp2BUQ< double, DynForcingP< float > >

template void interp2BUQ< double, DynForcingP< float > > (
    Param XParam,
    BlockP < double > XBlock,
    DynForcingP < float > forcing,
    double *& z
)

function interp2BUQ< double, DynForcingP< float > >

template double interp2BUQ< double, DynForcingP< float > > (
    double x,
    double y,
    DynForcingP < float > forcing
)

function interp2BUQ< double, StaticForcingP< float > >

template void interp2BUQ< double, StaticForcingP< float > > (
    Param XParam,
    BlockP < double > XBlock,
    StaticForcingP < float > forcing,
    double *& z
)

function interp2BUQ< double, StaticForcingP< float > >

template double interp2BUQ< double, StaticForcingP< float > > (
    double x,
    double y,
    StaticForcingP < float > forcing
)

function interp2BUQ< double, StaticForcingP< int > >

template double interp2BUQ< double, StaticForcingP< int > > (
    double x,
    double y,
    StaticForcingP < int > forcing
)

function interp2BUQ< double, deformmap< float > >

template void interp2BUQ< double, deformmap< float > > (
    Param XParam,
    BlockP < double > XBlock,
    deformmap < float > forcing,
    double *& z
)

function interp2BUQ< double, deformmap< float > >

template double interp2BUQ< double, deformmap< float > > (
    double x,
    double y,
    deformmap < float > forcing
)

function interp2BUQ< float >

template void interp2BUQ< float > (
    Param XParam,
    BlockP < float > XBlock,
    std::vector< StaticForcingP < float > > forcing,
    float * z
)

function interp2BUQ< float, DynForcingP< float > >

template void interp2BUQ< float, DynForcingP< float > > (
    Param XParam,
    BlockP < float > XBlock,
    DynForcingP < float > forcing,
    float *& z
)

function interp2BUQ< float, DynForcingP< float > >

template float interp2BUQ< float, DynForcingP< float > > (
    float x,
    float y,
    DynForcingP < float > forcing
)

function interp2BUQ< float, StaticForcingP< float > >

template void interp2BUQ< float, StaticForcingP< float > > (
    Param XParam,
    BlockP < float > XBlock,
    StaticForcingP < float > forcing,
    float *& z
)

function interp2BUQ< float, StaticForcingP< float > >

template float interp2BUQ< float, StaticForcingP< float > > (
    float x,
    float y,
    StaticForcingP < float > forcing
)

function interp2BUQ< float, StaticForcingP< int > >

template float interp2BUQ< float, StaticForcingP< int > > (
    float x,
    float y,
    StaticForcingP < int > forcing
)

function interp2BUQ< float, deformmap< float > >

template void interp2BUQ< float, deformmap< float > > (
    Param XParam,
    BlockP < float > XBlock,
    deformmap < float > forcing,
    float *& z
)

function interp2BUQ< float, deformmap< float > >

template float interp2BUQ< float, deformmap< float > > (
    float x,
    float y,
    deformmap < float > forcing
)

function setedges

Set edge values for bathymetry array at domain boundaries. 

template<class T>
void setedges (
    Param XParam,
    BlockP < T > XBlock,
    T *& zb
)

Copies values from interior to boundary cells for blocks with no neighbor.

Template parameters:

  • T Data type

Parameters:

  • XParam Simulation parameters
  • XBlock Block parameters
  • zb Bathymetry array

function setedges< double >

template void setedges< double > (
    Param XParam,
    BlockP < double > XBlock,
    double *& zb
)

function setedges< float >

template void setedges< float > (
    Param XParam,
    BlockP < float > XBlock,
    float *& zb
)

function setedgessideBT

Set bottom/top edge values for bathymetry array. 

template<class T>
void setedgessideBT (
    Param XParam,
    int ib,
    int blkA,
    int blkB,
    int jread,
    int jwrite,
    T *& zb
)

Copies values from interior to boundary cells for bottom/top edges.

Template parameters:

  • T Data type

Parameters:

  • XParam Simulation parameters
  • ib Block index
  • blkA Neighbor block A
  • blkB Neighbor block B
  • jread Index to read from
  • jwrite Index to write to
  • zb Bathymetry array

function setedgessideLR

Set left/right edge values for bathymetry array. 

template<class T>
void setedgessideLR (
    Param XParam,
    int ib,
    int blkA,
    int blkB,
    int iread,
    int iwrite,
    T *& zb
)

Copies values from interior to boundary cells for left/right edges.

Template parameters:

  • T Data type

Parameters:

  • XParam Simulation parameters
  • ib Block index
  • blkA Neighbor block A
  • blkB Neighbor block B
  • iread Index to read from
  • iwrite Index to write to
  • zb Bathymetry array

The documentation for this class was generated from the following file src/GridManip.cu