Skip to content

File Meanmax.cu

FileList > src > Meanmax.cu

Go to the source code of this file

  • #include "Meanmax.h"

Public Functions

Type Name
void Calcmeanmax (Param XParam, Loop< T > & XLoop, Model< T > XModel, Model< T > XModel_g)
Calculate mean and/or max of requested variables on GPU/CPU.
template void Calcmeanmax< double > (Param XParam, Loop< double > & XLoop, Model< double > XModel, Model< double > XModel_g)
template void Calcmeanmax< float > (Param XParam, Loop< float > & XLoop, Model< float > XModel, Model< float > XModel_g)
void Initmeanmax (Param XParam, Loop< T > XLoop, Model< T > XModel, Model< T > XModel_g)
Initialize mean and max statistics at the start of the simulation.
template void Initmeanmax< double > (Param XParam, Loop< double > XLoop, Model< double > XModel, Model< double > XModel_g)
template void Initmeanmax< float > (Param XParam, Loop< float > XLoop, Model< float > XModel, Model< float > XModel_g)
__host__ void addUandhU_CPU (Param XParam, BlockP< T > XBlock, T * h, T * u, T * v, T * U, T * hU)
Compute velocity magnitude and hU product on the CPU.
__global__ void addUandhU_GPU (Param XParam, BlockP< T > XBlock, T * h, T * u, T * v, T * U, T * hU)
CUDA kernel to compute velocity magnitude and hU product.
__host__ void addavg_varCPU (Param XParam, BlockP< T > XBlock, T * Varmean, T * Var)
Accumulate mean values for a variable on the CPU.
__global__ void addavg_varGPU (Param XParam, BlockP< T > XBlock, T * Varmean, T * Var)
CUDA kernel to accumulate mean values for a variable.
__host__ void addwettime_CPU (Param XParam, BlockP< T > XBlock, T * wett, T * h, T thresold, T time)
Accumulate wet duration for each cell on the CPU.
__global__ void addwettime_GPU (Param XParam, BlockP< T > XBlock, T * wett, T * h, T thresold, T time)
CUDA kernel to accumulate wet duration for each cell.
__host__ void divavg_varCPU (Param XParam, BlockP< T > XBlock, T ntdiv, T * Varmean)
Divide mean values by the number of steps on the CPU.
__global__ void divavg_varGPU (Param XParam, BlockP< T > XBlock, T ntdiv, T * Varmean)
CUDA kernel to divide mean values by the number of steps.
__host__ void max_Norm_CPU (Param XParam, BlockP< T > XBlock, T * Varmax, T * Var1, T * Var2)
Compute max velocity magnitude on the CPU.
__global__ void max_Norm_GPU (Param XParam, BlockP< T > XBlock, T * Varmax, T * Var1, T * Var2)
CUDA kernel to compute max velocity magnitude.
__host__ void max_hU_CPU (Param XParam, BlockP< T > XBlock, T * Varmax, T * h, T * u, T * v)
Compute max hU value on the CPU.
__global__ void max_hU_GPU (Param XParam, BlockP< T > XBlock, T * Varmax, T * h, T * u, T * v)
CUDA kernel to compute max hU value.
__host__ void max_varCPU (Param XParam, BlockP< T > XBlock, T * Varmax, T * Var)
Compute max value for a variable on the CPU.
__global__ void max_varGPU (Param XParam, BlockP< T > XBlock, T * Varmax, T * Var)
CUDA kernel to compute max value for a variable.
void resetmaxCPU (Param XParam, Loop< T > XLoop, BlockP< T > XBlock, EvolvingP_M< T > & XEv)
Reset max statistics arrays on the CPU.
void resetmaxGPU (Param XParam, Loop< T > XLoop, BlockP< T > XBlock, EvolvingP_M< T > & XEv)
Reset max statistics arrays on the GPU.
void resetmeanCPU (Param XParam, Loop< T > XLoop, BlockP< T > XBlock, EvolvingP_M< T > & XEv)
Reset mean statistics arrays on the CPU.
template void resetmeanCPU< double > (Param XParam, Loop< double > XLoop, BlockP< double > XBlock, EvolvingP_M< double > & XEv)
template void resetmeanCPU< float > (Param XParam, Loop< float > XLoop, BlockP< float > XBlock, EvolvingP_M< float > & XEv)
void resetmeanGPU (Param XParam, Loop< T > XLoop, BlockP< T > XBlock, EvolvingP_M< T > & XEv)
Reset mean statistics arrays on the GPU.
template void resetmeanGPU< double > (Param XParam, Loop< double > XLoop, BlockP< double > XBlock, EvolvingP_M< double > & XEv)
template void resetmeanGPU< float > (Param XParam, Loop< float > XLoop, BlockP< float > XBlock, EvolvingP_M< float > & XEv)
void resetmeanmax (Param XParam, Loop< T > & XLoop, Model< T > XModel, Model< T > XModel_g)
Reset mean and/or max statistics at output steps.
template void resetmeanmax< double > (Param XParam, Loop< double > & XLoop, Model< double > XModel, Model< double > XModel_g)
template void resetmeanmax< float > (Param XParam, Loop< float > & XLoop, Model< float > XModel, Model< float > XModel_g)
void resetvalCPU (Param XParam, BlockP< T > XBlock, T *& var, T val)
Reset a variable array to a specified value on the CPU.
template void resetvalCPU< double > (Param XParam, BlockP< double > XBlock, double *& var, double val)
template void resetvalCPU< float > (Param XParam, BlockP< float > XBlock, float *& var, float val)
void resetvalGPU (Param XParam, BlockP< T > XBlock, T *& var, T val)
Reset a variable array to a specified value on the GPU.
template void resetvalGPU< double > (Param XParam, BlockP< double > XBlock, double *& var, double val)
template void resetvalGPU< float > (Param XParam, BlockP< float > XBlock, float *& var, float val)

Public Functions Documentation

function Calcmeanmax

Calculate mean and/or max of requested variables on GPU/CPU. 

template<class T>
void Calcmeanmax (
    Param XParam,
    Loop < T > & XLoop,
    Model < T > XModel,
    Model < T > XModel_g
)

Computes mean, max, and wet duration statistics for evolving variables, handling both CPU and GPU execution paths.

Template parameters:

  • T Data type (float or double)

Parameters:

  • XParam Model parameters
  • XLoop Loop control structure
  • XModel Model state (CPU)
  • XModel_g Model state (GPU)

function Calcmeanmax< double >

template void Calcmeanmax< double > (
    Param XParam,
    Loop < double > & XLoop,
    Model < double > XModel,
    Model < double > XModel_g
)

function Calcmeanmax< float >

template void Calcmeanmax< float > (
    Param XParam,
    Loop < float > & XLoop,
    Model < float > XModel,
    Model < float > XModel_g
)

function Initmeanmax

Initialize mean and max statistics at the start of the simulation. 

template<class T>
void Initmeanmax (
    Param XParam,
    Loop < T > XLoop,
    Model < T > XModel,
    Model < T > XModel_g
)

Sets up/reset statistics arrays for the initial simulation step.

Template parameters:

  • T Data type (float or double)

Parameters:

  • XParam Model parameters
  • XLoop Loop control structure
  • XModel Model state (CPU)
  • XModel_g Model state (GPU)

function Initmeanmax< double >

template void Initmeanmax< double > (
    Param XParam,
    Loop < double > XLoop,
    Model < double > XModel,
    Model < double > XModel_g
)

function Initmeanmax< float >

template void Initmeanmax< float > (
    Param XParam,
    Loop < float > XLoop,
    Model < float > XModel,
    Model < float > XModel_g
)

function addUandhU_CPU

Compute velocity magnitude and hU product on the CPU. 

template<class T>
__host__ void addUandhU_CPU (
    Param XParam,
    BlockP < T > XBlock,
    T * h,
    T * u,
    T * v,
    T * U,
    T * hU
)

Calculates the velocity magnitude and its product with water depth for each cell on the CPU.

Template parameters:

  • T Data type (float or double)

Parameters:

  • XParam Model parameters
  • XBlock Block data
  • h Water depth array
  • u U-velocity array
  • v V-velocity array
  • U Output velocity magnitude array
  • hU Output hU product array

function addUandhU_GPU

CUDA kernel to compute velocity magnitude and hU product. 

template<class T>
__global__ void addUandhU_GPU (
    Param XParam,
    BlockP < T > XBlock,
    T * h,
    T * u,
    T * v,
    T * U,
    T * hU
)

Calculates the velocity magnitude and its product with water depth for each cell on the GPU.

Template parameters:

  • T Data type (float or double)

Parameters:

  • XParam Model parameters
  • XBlock Block data
  • h Water depth array
  • u U-velocity array
  • v V-velocity array
  • U Output velocity magnitude array
  • hU Output hU product array

function addavg_varCPU

Accumulate mean values for a variable on the CPU. 

template<class T>
__host__ void addavg_varCPU (
    Param XParam,
    BlockP < T > XBlock,
    T * Varmean,
    T * Var
)

Adds the current value to the running mean for each cell on the CPU.

Template parameters:

  • T Data type (float or double)

Parameters:

  • XParam Model parameters
  • XBlock Block data
  • Varmean Mean variable array
  • Var Source variable array

function addavg_varGPU

CUDA kernel to accumulate mean values for a variable. 

template<class T>
__global__ void addavg_varGPU (
    Param XParam,
    BlockP < T > XBlock,
    T * Varmean,
    T * Var
)

Adds the current value to the running mean for each cell on the GPU.

Template parameters:

  • T Data type (float or double)

Parameters:

  • XParam Model parameters
  • XBlock Block data
  • Varmean Mean variable array
  • Var Source variable array

function addwettime_CPU

Accumulate wet duration for each cell on the CPU. 

template<class T>
__host__ void addwettime_CPU (
    Param XParam,
    BlockP < T > XBlock,
    T * wett,
    T * h,
    T thresold,
    T time
)

Adds time to the wet duration for cells where water depth exceeds a threshold on the CPU.

Template parameters:

  • T Data type (float or double)

Parameters:

  • XParam Model parameters
  • XBlock Block data
  • wett Wet duration array
  • h Water depth array
  • thresold Wet threshold value
  • time Time increment

function addwettime_GPU

CUDA kernel to accumulate wet duration for each cell. 

template<class T>
__global__ void addwettime_GPU (
    Param XParam,
    BlockP < T > XBlock,
    T * wett,
    T * h,
    T thresold,
    T time
)

Adds time to the wet duration for cells where water depth exceeds a threshold on the GPU.

Template parameters:

  • T Data type (float or double)

Parameters:

  • XParam Model parameters
  • XBlock Block data
  • wett Wet duration array
  • h Water depth array
  • thresold Wet threshold value
  • time Time increment

function divavg_varCPU

Divide mean values by the number of steps on the CPU. 

template<class T>
__host__ void divavg_varCPU (
    Param XParam,
    BlockP < T > XBlock,
    T ntdiv,
    T * Varmean
)

Finalizes the mean calculation by dividing accumulated values by the number of time steps on the CPU.

Template parameters:

  • T Data type (float or double)

Parameters:

  • XParam Model parameters
  • XBlock Block data
  • ntdiv Number of time steps
  • Varmean Mean variable array

function divavg_varGPU

CUDA kernel to divide mean values by the number of steps. 

template<class T>
__global__ void divavg_varGPU (
    Param XParam,
    BlockP < T > XBlock,
    T ntdiv,
    T * Varmean
)

Finalizes the mean calculation by dividing accumulated values by the number of time steps on the GPU.

Template parameters:

  • T Data type (float or double)

Parameters:

  • XParam Model parameters
  • XBlock Block data
  • ntdiv Number of time steps
  • Varmean Mean variable array

function max_Norm_CPU

Compute max velocity magnitude on the CPU. 

template<class T>
__host__ void max_Norm_CPU (
    Param XParam,
    BlockP < T > XBlock,
    T * Varmax,
    T * Var1,
    T * Var2
)

Updates the max velocity magnitude for each cell by comparing with the current value using CPU routines.

Template parameters:

  • T Data type (float or double)

Parameters:

  • XParam Model parameters
  • XBlock Block data
  • Varmax Max variable array
  • Var1 U-velocity array
  • Var2 V-velocity array

function max_Norm_GPU

CUDA kernel to compute max velocity magnitude. 

template<class T>
__global__ void max_Norm_GPU (
    Param XParam,
    BlockP < T > XBlock,
    T * Varmax,
    T * Var1,
    T * Var2
)

Updates the max velocity magnitude for each cell by comparing with the current value on the GPU.

Template parameters:

  • T Data type (float or double)

Parameters:

  • XParam Model parameters
  • XBlock Block data
  • Varmax Max variable array
  • Var1 U-velocity array
  • Var2 V-velocity array

function max_hU_CPU

Compute max hU value on the CPU. 

template<class T>
__host__ void max_hU_CPU (
    Param XParam,
    BlockP < T > XBlock,
    T * Varmax,
    T * h,
    T * u,
    T * v
)

Updates the max hU value for each cell by comparing with the current value using CPU routines.

Template parameters:

  • T Data type (float or double)

Parameters:

  • XParam Model parameters
  • XBlock Block data
  • Varmax Max variable array
  • h Water depth array
  • u U-velocity array
  • v V-velocity array

function max_hU_GPU

CUDA kernel to compute max hU value. 

template<class T>
__global__ void max_hU_GPU (
    Param XParam,
    BlockP < T > XBlock,
    T * Varmax,
    T * h,
    T * u,
    T * v
)

Updates the max hU value for each cell by comparing with the current value on the GPU.

Template parameters:

  • T Data type (float or double)

Parameters:

  • XParam Model parameters
  • XBlock Block data
  • Varmax Max variable array
  • h Water depth array
  • u U-velocity array
  • v V-velocity array

function max_varCPU

Compute max value for a variable on the CPU. 

template<class T>
__host__ void max_varCPU (
    Param XParam,
    BlockP < T > XBlock,
    T * Varmax,
    T * Var
)

Updates the max value for each cell by comparing with the current value using CPU routines.

Template parameters:

  • T Data type (float or double)

Parameters:

  • XParam Model parameters
  • XBlock Block data
  • Varmax Max variable array
  • Var Source variable array

function max_varGPU

CUDA kernel to compute max value for a variable. 

template<class T>
__global__ void max_varGPU (
    Param XParam,
    BlockP < T > XBlock,
    T * Varmax,
    T * Var
)

Updates the max value for each cell by comparing with the current value on the GPU.

Template parameters:

  • T Data type (float or double)

Parameters:

  • XParam Model parameters
  • XBlock Block data
  • Varmax Max variable array
  • Var Source variable array

function resetmaxCPU

Reset max statistics arrays on the CPU. 

template<class T>
void resetmaxCPU (
    Param XParam,
    Loop < T > XLoop,
    BlockP < T > XBlock,
    EvolvingP_M < T > & XEv
)

Sets all max arrays to a large negative value using CPU routines.

Template parameters:

  • T Data type (float or double)

Parameters:

  • XParam Model parameters
  • XLoop Loop control structure
  • XBlock Block data
  • XEv Max evolving variables

function resetmaxGPU

Reset max statistics arrays on the GPU. 

template<class T>
void resetmaxGPU (
    Param XParam,
    Loop < T > XLoop,
    BlockP < T > XBlock,
    EvolvingP_M < T > & XEv
)

Sets all max arrays to a large negative value using a CUDA kernel.

Template parameters:

  • T Data type (float or double)

Parameters:

  • XParam Model parameters
  • XLoop Loop control structure
  • XBlock Block data
  • XEv Max evolving variables

function resetmeanCPU

Reset mean statistics arrays on the CPU. 

template<class T>
void resetmeanCPU (
    Param XParam,
    Loop < T > XLoop,
    BlockP < T > XBlock,
    EvolvingP_M < T > & XEv
)

Sets all mean arrays to zero using CPU routines.

Template parameters:

  • T Data type (float or double)

Parameters:

  • XParam Model parameters
  • XLoop Loop control structure
  • XBlock Block data
  • XEv Mean evolving variables

function resetmeanCPU< double >

template void resetmeanCPU< double > (
    Param XParam,
    Loop < double > XLoop,
    BlockP < double > XBlock,
    EvolvingP_M < double > & XEv
)

function resetmeanCPU< float >

template void resetmeanCPU< float > (
    Param XParam,
    Loop < float > XLoop,
    BlockP < float > XBlock,
    EvolvingP_M < float > & XEv
)

function resetmeanGPU

Reset mean statistics arrays on the GPU. 

template<class T>
void resetmeanGPU (
    Param XParam,
    Loop < T > XLoop,
    BlockP < T > XBlock,
    EvolvingP_M < T > & XEv
)

Sets all mean arrays to zero using a CUDA kernel.

Template parameters:

  • T Data type (float or double)

Parameters:

  • XParam Model parameters
  • XLoop Loop control structure
  • XBlock Block data
  • XEv Mean evolving variables

function resetmeanGPU< double >

template void resetmeanGPU< double > (
    Param XParam,
    Loop < double > XLoop,
    BlockP < double > XBlock,
    EvolvingP_M < double > & XEv
)

function resetmeanGPU< float >

template void resetmeanGPU< float > (
    Param XParam,
    Loop < float > XLoop,
    BlockP < float > XBlock,
    EvolvingP_M < float > & XEv
)

function resetmeanmax

Reset mean and/or max statistics at output steps. 

template<class T>
void resetmeanmax (
    Param XParam,
    Loop < T > & XLoop,
    Model < T > XModel,
    Model < T > XModel_g
)

Resets mean, max, and wet duration arrays after output is produced, handling both CPU and GPU paths.

Template parameters:

  • T Data type (float or double)

Parameters:

  • XParam Model parameters
  • XLoop Loop control structure
  • XModel Model state (CPU)
  • XModel_g Model state (GPU)

function resetmeanmax< double >

template void resetmeanmax< double > (
    Param XParam,
    Loop < double > & XLoop,
    Model < double > XModel,
    Model < double > XModel_g
)

function resetmeanmax< float >

template void resetmeanmax< float > (
    Param XParam,
    Loop < float > & XLoop,
    Model < float > XModel,
    Model < float > XModel_g
)

function resetvalCPU

Reset a variable array to a specified value on the CPU. 

template<class T>
void resetvalCPU (
    Param XParam,
    BlockP < T > XBlock,
    T *& var,
    T val
)

Sets all elements of the array to the given value using CPU routines.

Template parameters:

  • T Data type (float or double)

Parameters:

  • XParam Model parameters
  • XBlock Block data
  • var Variable array to reset
  • val Value to set

function resetvalCPU< double >

template void resetvalCPU< double > (
    Param XParam,
    BlockP < double > XBlock,
    double *& var,
    double val
)

function resetvalCPU< float >

template void resetvalCPU< float > (
    Param XParam,
    BlockP < float > XBlock,
    float *& var,
    float val
)

function resetvalGPU

Reset a variable array to a specified value on the GPU. 

template<class T>
void resetvalGPU (
    Param XParam,
    BlockP < T > XBlock,
    T *& var,
    T val
)

Sets all elements of the array to the given value using a CUDA kernel.

Template parameters:

  • T Data type (float or double)

Parameters:

  • XParam Model parameters
  • XBlock Block data
  • var Variable array to reset
  • val Value to set

function resetvalGPU< double >

template void resetvalGPU< double > (
    Param XParam,
    BlockP < double > XBlock,
    double *& var,
    double val
)

function resetvalGPU< float >

template void resetvalGPU< float > (
    Param XParam,
    BlockP < float > XBlock,
    float *& var,
    float val
)

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