ParticleApproximation.h File Reference

#include "Module/ComputeModule.h"
#include "Kernel.h"

Include dependency graph for ParticleApproximation.h:

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

Go to the source code of this file.

Classes
class	dyno::ParticleApproximation< TDataType >

Namespaces
namespace	dyno
	This is an implementation of AdditiveCCD based on peridyno.

Macros
#define	cuIntegralAdh(size, type, scale, Func, ...)
#define	cuIntegral(size, type, scale, Func, ...)
#define	cuZerothOrder(size, type, scale, Func, ...)
#define	cuFirstOrder(size, type, scale, Func, ...)

Macro Definition Documentation

cuFirstOrder

#define cuFirstOrder	(		size,
			type,
			scale,
			Func,
			... )

Value:

        {                   \
        uint pDims = cudaGridSize((uint)size, BLOCK_SIZE);              \
        if (type == 0)                                          \
        {                                                               \
            auto lambdaFunc = [=] __device__(Real r, Real h, Real s) -> Real {      \
                return SmoothKernel<Real>::gradient(r, h, s);   \
            };                                                              \
            Func << <pDims, BLOCK_SIZE >> > (__VA_ARGS__, lambdaFunc, scale);   \
        }                                                               \
        else if (type == 1)                                     \
        {                                                               \
            auto lambdaFunc = [=] __device__(Real r, Real h, Real s) -> Real {      \
                return SpikyKernel<Real>::gradient(r, h, s);                    \
            };                                                          \
            Func << <pDims, BLOCK_SIZE >> > (__VA_ARGS__, lambdaFunc, scale);  \
        }                                                               \
        cuSynchronize();                                                \
    }

Definition at line 81 of file ParticleApproximation.h.

cuIntegral

#define cuIntegral	(		size,
			type,
			scale,
			Func,
			... )

Value:

        {                   \
        uint pDims = cudaGridSize((uint)size, BLOCK_SIZE);              \
        if (type == ParticleApproximation<TDataType>::KT_Smooth)        \
        {                                                               \
            auto lambdaFunc = [=] __device__(Real r, Real h, Real s) -> Real {      \
                return SmoothKernel<Real>::integral(r, h, s);   \
            };                                                              \
            Func << <pDims, BLOCK_SIZE >> > (__VA_ARGS__, lambdaFunc, ParticleApproximation<TDataType>::mScalingFactor);    \
        }                                                               \
        else if (type == ParticleApproximation<TDataType>::KT_Spiky)    \
        {                                                               \
            auto lambdaFunc = [=] __device__(Real r, Real h, Real s) -> Real {      \
                return SpikyKernel<Real>::integral(r, h, s);                    \
            };                                                          \
            Func << <pDims, BLOCK_SIZE >> > (__VA_ARGS__, lambdaFunc, ParticleApproximation<TDataType>::mScalingFactor);    \
        }                                                               \
        cuSynchronize();                                                \
    }

Definition at line 43 of file ParticleApproximation.h.

cuIntegralAdh

#define cuIntegralAdh	(		size,
			type,
			scale,
			Func,
			... )

Value:

        {                   \
        uint pDims = cudaGridSize((uint)size, BLOCK_SIZE);              \
        if (type == KT_Smooth)                                          \
        {                                                               \
            auto lambdaFunc = [=] __device__(Real r, Real h, Real s) -> Real {      \
                return SmoothKernel<Real>::integral(r, h, s);   \
            };                                                              \
            Func << <pDims, BLOCK_SIZE >> > (__VA_ARGS__, lambdaFunc, ParticleApproximation<TDataType>::mScalingFactor);    \
        }                                                               \
        else if (type == KT_Spiky)                                      \
        {                                                               \
            auto lambdaFunc = [=] __device__(Real r, Real h, Real s) -> Real {      \
                return SpikyKernel<Real>::integral(r, h, s);                    \
            };                                                          \
            Func << <pDims, BLOCK_SIZE >> > (__VA_ARGS__, lambdaFunc, ParticleApproximation<TDataType>::mScalingFactor);    \
        }                                                               \
        cuSynchronize();                                                \
    }

Definition at line 24 of file ParticleApproximation.h.

cuZerothOrder

#define cuZerothOrder	(		size,
			type,
			scale,
			Func,
			... )

Value:

        {                   \
        uint pDims = cudaGridSize((uint)size, BLOCK_SIZE);              \
        if (type == 0)                                          \
        {                                                               \
            auto lambdaFunc = [=] __device__(Real r, Real h, Real s) -> Real {      \
                return SmoothKernel<Real>::weight(r, h, s); \
            };                                                              \
            Func << <pDims, BLOCK_SIZE >> > (__VA_ARGS__, lambdaFunc, scale);   \
        }                                                               \
        else if (type == 1)                                     \
        {                                                               \
            auto lambdaFunc = [=] __device__(Real r, Real h, Real s) -> Real {      \
                return SpikyKernel<Real>::weight(r, h, s);                  \
            };                                                          \
            Func << <pDims, BLOCK_SIZE >> > (__VA_ARGS__, lambdaFunc, scale);  \
        }                                                               \
        cuSynchronize();                                                \
    }

Definition at line 62 of file ParticleApproximation.h.