ParticleApproximation.h

Go to the documentation of this file.

#pragma once
#include "Module/ComputeModule.h"
 
#include "Kernel.h"
 
namespace dyno
{
 
#define cuIntegralAdh(size, type, scale, Func,...){                 \
        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();                                                \
    }
 
#define cuIntegral(size, type, scale, Func,...){                    \
        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();                                                \
    }
 
#define cuZerothOrder(size, type, scale, Func,...){                 \
        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();                                                \
    }
 
#define cuFirstOrder(size, type, scale, Func,...){                  \
        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();                                                \
    }
 
    template<typename TDataType>
    class ParticleApproximation : public ComputeModule
    {
        DECLARE_TCLASS(ParticleApproximation, TDataType)
    public:
        typedef typename TDataType::Real Real;
 
        ParticleApproximation();
        virtual ~ParticleApproximation();
 
        DECLARE_ENUM(EKernelType,
            KT_Smooth = 0,
            KT_Spiky = 1);
 
        void compute() override {};
 
    public:
        DEF_VAR_IN(Real, SmoothingLength, "Smoothing Length");
        DEF_VAR_IN(Real, SamplingDistance, "Particle sampling distance");
 
        DEF_ENUM(EKernelType, KernelType, EKernelType::KT_Spiky, "Rendering mode");
 
    protected:
        Real mScalingFactor = Real(1);
 
    private:
        void calculateScalingFactor();
    };
}