milupHPC/particles_8cuh_source.html

#ifndef MILUPHPC_PARTICLES_CUH

#define MILUPHPC_PARTICLES_CUH


#include "parameter.h"

#include "cuda_utils/cuda_utilities.cuh"

#include <cmath>

#include <assert.h>


class Particles {


public:


    integer *numParticles;

    integer *numNodes;


    real *mass;

    real *x;

    real *vx;

    real *ax;

    real *ax_old;

#if DIM > 1

    real *y;

    real *vy;

    real *ay;

    real *ay_old;

#if DIM == 3

    real *z;

    real *vz;

    real *az;

    real *az_old;

#endif

#endif


    real *g_ax;

    real *g_ax_old;

#if DIM > 1

    real *g_ay;

    real *g_ay_old;

#if DIM == 3

    real *g_az;

    real *g_az_old;

#endif

#endif


    integer *nodeType;


    integer *level;


    idInteger *uid; // unique identifier (unsigned int/long?)

    integer *materialId; // material identfier (e.g.: ice, basalt, ...)

    real *sml; // smoothing length


    integer *nnl; // max(number of interactions)

    integer *noi; // number of interactions (alternatively initialize nnl with -1, ...)


    real *e; // internal energy

    real *dedt;


    real *u;


    real *cs; // soundspeed


    // simplest hydro

    real *rho; // density

    real *p; // pressure


    real *muijmax;


#if NAVIER_STOKES

    real *Tshear;

    real *eta;

#endif


//#if INTEGRATE_DENSITY

    // integrated density

    real *drhodt;

//#endif


#if VARIABLE_SML || INTEGRATE_SML

    // integrate/variable smoothing length

    real *dsmldt;

#endif


#if SML_CORRECTION

    real *sml_omega;

#endif


#if SOLID

    real *S; // deviatoric stress tensor (DIM * DIM)

    real *dSdt;

    real *localStrain; // local strain

#endif


#if BALSARA_SWITCH

    real *divv;

    real *curlv;

#endif


#if SOLID || NAVIER_STOKES

    real *sigma; // stress tensor (DIM * DIM)

#endif


#if ARTIFICIAL_STRESS

    real *R; // tensile instability, tensor for correction (DIM * DIM)

#endif


#if POROSITY

    real *pold;

    real *alpha_jutzi;

    real *alpha_jutzi_old;

    real *dalphadt;

    real *dalphadp;

    real *dp;

    real *dalphadrho;

    real *f;

    real *delpdelrho;

    real *delpdele;

        real *cs_old;


    real *alpha_epspor;

    real *dalpha_epspordt;

    real *epsilon_v;

    real *depsilon_vdt;

#endif


#if ZERO_CONSISTENCY

    real *shepardCorrection;

#endif


#if LINEAR_CONSISTENCY

    real *tensorialCorrectionMatrix;

#endif


#if FRAGMENTATION

    real *d;

    real *damage_total; // tensile damage + porous damage (directly, not DIM-root)

    real *dddt; // the time derivative of DIM-root of (tensile) damage

    integer *numFlaws; // the total number of flaws

    integer *maxNumFlaws; // the maximum number of flaws allowed per particle

    integer *numActiveFlaws; // the current number of activated flaws

    real *flaws; // the values for the strain for each flaw (array of size maxNumFlaws)

#if PALPHA_POROSITY

    real *damage_porjutzi; // DIM-root of porous damage

    real *ddamage_porjutzidt; // time derivative of DIM-root of porous damage

#endif

#endif


    CUDA_CALLABLE_MEMBER Particles();


    //TODO: constructors and setter only for specific dimension (#if , #else if, #else)

#if DIM == 1


    CUDA_CALLABLE_MEMBER Particles(integer *numParticles, integer *numNodes, real *mass, real *x, real *vx, real *ax,

                                   integer *level, idInteger *uid, integer *materialId, real *sml,

                                   integer *nnl, integer *noi, real *e, real *dedt, real *cs, real *rho, real *p);


    CUDA_CALLABLE_MEMBER void set(integer *numParticles, integer *numNodes, real *mass, real *x, real *vx, real *ax,

                                  integer *level, idInteger *uid, integer *materialId, real *sml,

                                  integer *nnl, integer *noi, real *e, real *dedt, real *cs, real *rho, real *p);

#elif DIM == 2


    CUDA_CALLABLE_MEMBER Particles(integer *numParticles, integer *numNodes, real *mass, real *x, real *y, real *vx,

                                   real *vy, real *ax, real *ay, idInteger *uid,

                                   integer *materialId, real *sml, integer *nnl, integer *noi, real *e, real *dedt,

                                   real *cs, real *rho, real *p);


    CUDA_CALLABLE_MEMBER void set(integer *numParticles, integer *numNodes, real *mass, real *x, real *y, real *vx,

                                  real *vy, real *ax, real *ay, integer *level, idInteger *uid,

                                  integer *materialId, real *sml, integer *nnl, integer *noi, real *e, real *dedt,

                                  real *cs, real *rho, real *p);

#else


    CUDA_CALLABLE_MEMBER Particles(integer *numParticles, integer *numNodes, real *mass, real *x, real *y, real *z,

                                   real *vx, real *vy, real *vz, real *ax, real *ay, real *az,

                                   idInteger *uid, integer *materialId, real *sml,

                                   integer *nnl, integer *noi, real *e, real *dedt,

                                   real *cs, real *rho, real *p);


    CUDA_CALLABLE_MEMBER void set(integer *numParticles, integer *numNodes, real *mass, real *x, real *y, real *z,

                                  real *vx, real *vy, real *vz, real *ax, real *ay, real *az,

                                  integer *level, idInteger *uid, integer *materialId,

                                  real *sml, integer *nnl, integer *noi, real *e, real *dedt, real *cs,

                                  real *rho, real *p);

#endif


#if DIM == 1

    CUDA_CALLABLE_MEMBER void setGravity(real *g_ax);

#elif DIM == 2

    CUDA_CALLABLE_MEMBER void setGravity(real *g_ax, real *g_ay);

#else

    CUDA_CALLABLE_MEMBER void setGravity(real *g_ax, real *g_ay, real *g_az);

#endif


#if DIM == 1

    CUDA_CALLABLE_MEMBER void setLeapfrog(real *ax_old, real *g_ax_old);

#elif DIM == 2

    CUDA_CALLABLE_MEMBER void setLeapfrog(real *ax_old, real *ay_old, real *g_ax_old, real *g_ay_old);

#else


    CUDA_CALLABLE_MEMBER void setLeapfrog(real *ax_old, real *ay_old, real *az_old, real *g_ax_old, real *g_ay_old,

                                          real *g_az_old);

#endif


    CUDA_CALLABLE_MEMBER void setU(real *u);


    CUDA_CALLABLE_MEMBER void setNodeType(integer *nodeType);


    CUDA_CALLABLE_MEMBER void setArtificialViscosity(real *muijmax);


#if BALSARA_SWITCH

    CUDA_CALLABLE_MEMBER void setDivCurl(real *divv, real *curlv);

#endif


//#if INTEGRATE_DENSITY

    CUDA_CALLABLE_MEMBER void setIntegrateDensity(real *drhodt);

//#endif

#if VARIABLE_SML || INTEGRATE_SML

    CUDA_CALLABLE_MEMBER void setVariableSML(real *dsmldt);

#endif

#if SML_CORRECTION

    CUDA_CALLABLE_MEMBER void setSMLCorrection(real *sml_omega);

#endif

#if NAVIER_STOKES

    CUDA_CALLABLE_MEMBER void setNavierStokes(real *Tshear, real *eta);

#endif

#if SOLID

    CUDA_CALLABLE_MEMBER void setSolid(real *S, real *dSdt, real *localStrain);

#endif

#if SOLID || NAVIER_STOKES

    CUDA_CALLABLE_MEMBER void setSolidNavierStokes(real *sigma);

#endif

#if ARTIFICIAL_STRESS

    CUDA_CALLABLE_MEMBER void setArtificialStress(real *R);

#endif

#if POROSITY

    CUDA_CALLABLE_MEMBER void setPorosity(real *pold, real *alpha_jutzi, real *alpha_jutzi_old, real *dalphadt,

                                          real *dalphadp, real *dp, real *dalphadrho, real *f, real *delpdelrho,

                                          real *delpdele, real *cs_old, real *alpha_epspor, real *dalpha_epspordt,

                                          real *epsilon_v, real *depsilon_vdt);

#endif

#if ZERO_CONSISTENCY

    CUDA_CALLABLE_MEMBER void setZeroConsistency(real *shepardCorrection);

#endif

#if LINEAR_CONSISTENCY

    CUDA_CALLABLE_MEMBER void setLinearConsistency(real *tensorialCorrectionMatrix);

#endif

#if FRAGMENTATION

    CUDA_CALLABLE_MEMBER void setFragmentation(real *d, real *damage_total, real *dddt, integer *numFlaws,

                                               integer *maxNumFlaws, integer *numActiveFlaws, real *flaws);

#if PALPHA_POROSITY

    CUDA_CALLABLE_MEMBER void setPalphaPorosity(real *damage_porjutzi, real *ddamage_porjutzidt);

#endif

#endif


    CUDA_CALLABLE_MEMBER void reset(integer index);


    CUDA_CALLABLE_MEMBER real distance(integer index_1, integer index_2);


    CUDA_CALLABLE_MEMBER real weightedEntry(integer index, Entry::Name entry);


    CUDA_CALLABLE_MEMBER ~Particles();


};


namespace ParticlesNS {


    namespace Kernel {


        __global__ void check4nans(Particles *particles, integer n);


        __global__ void info(Particles *particles, integer n, integer m, integer k);


        namespace Launch {


            real check4nans(Particles *particles, integer n);


            real info(Particles *particles, integer n, integer m, integer k);

        }


#if DIM == 1


        __global__ void set(Particles *particles, integer *numParticles, integer *numNodes, real *mass, real *x,

                            real *vx, real *ax, integer *level, idInteger *uid, integer *materialId,

                            real *sml, integer *nnl, integer *noi, real *e, real *dedt, real *cs, real *rho, real *p);


        namespace Launch {


            void set(Particles *particles, integer *numParticles, integer *numNodes, real *mass, real *x, real *vx,

                     real *ax, integer *level, idInteger *uid, integer *materialId, real *sml, integer *nnl,

                     integer *noi, real *e, real *dedt, real *cs, real *rho, real *p);

        }


#elif DIM == 2


        __global__ void set(Particles *particles, integer *numParticles, integer *numNodes, real *mass, real *x,

                            real *y, real *vx, real *vy, real *ax, real *ay, integer *level,

                            idInteger *uid, integer *materialId, real *sml, integer *nnl, integer *noi, real *e,

                            real *dedt, real *cs, real *rho, real *p);


        namespace Launch {


            void set(Particles *particles, integer *numParticles, integer *numNodes, real *mass, real *x, real *y,

                     real *vx, real *vy, real *ax, real *ay, integer *level, idInteger *id,

                     integer *materialId, real *sml, integer *nnl, integer *noi, real *e, real *dedt, real *cs,

                     real *rho, real *p);

        }


#else


        __global__ void set(Particles *particles, integer *numParticles, integer *numNodes, real *mass, real *x,

                            real *y, real *z, real *vx, real *vy, real *vz, real *ax, real *ay, real *az,

                            integer *level, idInteger *uid, integer *materialId, real *sml,

                            integer *nnl, integer *noi, real *e,

                            real *dedt, real *cs, real *rho, real *p);


        namespace Launch {


            void set(Particles *particles, integer *numParticles, integer *numNodes, real *mass, real *x, real *y,

                     real *z, real *vx, real *vy, real *vz, real *ax, real *ay, real *az,

                     integer *level, idInteger *uid, integer *materialId, real *sml,

                     integer *nnl, integer *noi, real *e, real *dedt, real *cs, real *rho, real *p);

        }


#endif


#if DIM == 1

        __global__ void setGravity(Particles *particles, real *g_ax);


        namespace Launch {

            void setGravity(Particles *particles, real *g_ax);

        }


#elif DIM == 2

        __global__ void setGravity(Particles *particles, real *g_ax, real *g_ay);


        namespace Launch {

            void setGravity(Particles *particles, real *g_ax, real *g_ay);

        }

#else

        __global__ void setGravity(Particles *particles, real *g_ax, real *g_ay, real *g_az);


        namespace Launch {

            void setGravity(Particles *particles, real *g_ax, real *g_ay, real *g_az);

        }

#endif


#if DIM == 1

        __global__ void setLeapfrog(Particles *particles, real *ax_old, real *g_ax_old);


        namespace Launch {

            void setLeapfrog(Particles *particles, real *ax_old, real *g_ax_old);

        }


#elif DIM == 2

        __global__ void setLeapfrog(Particles *particles, real *ax_old, real *ay_old, real *g_ax_old, real *g_ay_old);


        namespace Launch {

            void setLeapfrog(Particles *particles, real *ax_old, real *ay_old, real *g_ax_old, real *g_ay_old);

        }

#else

        __global__ void setLeapfrog(Particles *particles, real *ax_old, real *ay_old, real *az_old, real *g_ax_old,

                                    real *g_ay_old, real *g_az_old);


        namespace Launch {

            void setLeapfrog(Particles *particles, real *ax_old, real *ay_old, real *az_old, real *g_ax_old,

                             real *g_ay_old, real *g_az_old);

        }

#endif


        __global__ void setU(Particles *particles, real *u);

        namespace Launch {

            void setU(Particles *particles, real *u);

        }


        __global__ void setNodeType(Particles *particles, integer *nodeType);

        namespace Launch {

            void setNodeType(Particles *particles, integer *nodeType);

        }


        __global__ void setArtificialViscosity(Particles *particles, real *muijmax);

        namespace Launch {

            void setArtificialViscosity(Particles *particles, real *muijmax);

        }


#if BALSARA_SWITCH

        __global__ void setDivCurl(Particles *particles, real *divv, real *curlv);

        namespace Launch {

            void setDivCurl(Particles *particles, real *divv, real *curlv);

        }

#endif


//#if INTEGRATE_DENSITY

        __global__ void setIntegrateDensity(Particles *particles, real *drhodt);

        namespace Launch {

            void setIntegrateDensity(Particles *particles, real *drhodt);

        }

//#endif

#if VARIABLE_SML || INTEGRATE_SML

        __global__ void setVariableSML(Particles *particles, real *dsmldt);

        namespace Launch {

            void setVariableSML(Particles *particles, real *dsmldt);

        }

#endif

#if SML_CORRECTION

        __global__ void setSMLCorrection(Particles *particles, real *sml_omega);


        namespace Launch {

            void setSMLCorrection(Particles *particles, real *sml_omega);

        }

#endif

#if NAVIER_STOKES

        __global__ void setNavierStokes(Particles *particles, real *Tshear, real *eta);

        namespace Launch {

            void setNavierStokes(Particles *particles, real *Tshear, real *eta);

        }

#endif

#if SOLID

        __global__ void setSolid(Particles *particles, real *S, real *dSdt, real *localStrain);

        namespace Launch {

            void setSolid(Particles *particles, real *S, real *dSdt, real *localStrain);

        }

#endif

#if SOLID || NAVIER_STOKES

        __global__ void setSolidNavierStokes(Particles *particles, real *sigma);

        namespace Launch {

            void setSolidNavierStokes(Particles *particles, real *sigma);

        }

#endif

#if ARTIFICIAL_STRESS

        __global__ void setArtificialStress(Particles *particles, real *R);

        namespace Launch {

            void setArtificialStress(Particles *particles, real *R);

        }

#endif

#if POROSITY

        __global__ void setPorosity(Particles *particles, real *pold, real *alpha_jutzi, real *alpha_jutzi_old, real *dalphadt,

                                    real *dalphadp, real *dp, real *dalphadrho, real *f, real *delpdelrho,

                                    real *delpdele, real *cs_old, real *alpha_epspor, real *dalpha_epspordt,

                                    real *epsilon_v, real *depsilon_vdt);

        namespace Launch {

            void setPorosity(Particles *particles, real *pold, real *alpha_jutzi, real *alpha_jutzi_old, real *dalphadt,

                             real *dalphadp, real *dp, real *dalphadrho, real *f, real *delpdelrho,

                             real *delpdele, real *cs_old, real *alpha_epspor, real *dalpha_epspordt,

                             real *epsilon_v, real *depsilon_vdt);

        }

#endif

#if ZERO_CONSISTENCY

        __global__ void setZeroConsistency(Particles *particles, real *shepardCorrection);

        namespace Launch {

            void setZeroConsistency(Particles *particles, real *shepardCorrection);

        }

#endif

#if LINEAR_CONSISTENCY

        __global__ void setLinearConsistency(Particles *particles, real *tensorialCorrectionMatrix);

        namespace Launch {

            void setLinearConsistency(Particles *particles, real *tensorialCorrectionMatrix);

        }

#endif

#if FRAGMENTATION

        __global__ void setFragmentation(Particles *particles, real *d, real *damage_total, real *dddt, integer *numFlaws,

                                         integer *maxNumFlaws, integer *numActiveFlaws, real *flaws);

        namespace Launch {

            void setFragmentation(Particles *particles, real *d, real *damage_total, real *dddt, integer *numFlaws,

                                  integer *maxNumFlaws, integer *numActiveFlaws, real *flaws);

        }

#if PALPHA_POROSITY

        __global__ void setPalphaPorosity(Particles *particles, real *damage_porjutzi, real *ddamage_porjutzidt);

        namespace Launch {

            void setPalphaPorosity(Particles *particles, real *damage_porjutzi, real *ddamage_porjutzidt);

        }

#endif

#endif


        __global__ void test(Particles *particles);


        namespace Launch {

            real test(Particles *particles, bool time=false);

        }

    }


}


class IntegratedParticles {


public:


    idInteger *uid;


    real *x;

    real *vx;

    real *ax;

#if DIM > 1

    real *y;

    real *vy;

    real *ay;

#if DIM == 3

    real *z;

    real *vz;

    real *az;

#endif

#endif


    //integer *level;

    //integer *nodeType;


    real *rho;

    real *e;

    real *dedt;

    real *p;

    real *cs;


    real *sml;


//#if INTEGRATE_DENSITY

    real *drhodt;

//#endif


#if VARIABLE_SML || INTEGRATE_SML

    real *dsmldt;

#endif


    CUDA_CALLABLE_MEMBER IntegratedParticles();


#if DIM == 1


    CUDA_CALLABLE_MEMBER IntegratedParticles(idInteger *uid, real *rho, real *e, real *dedt, real *p, real *cs, real *x,

                                             real *vx, real *ax);


    CUDA_CALLABLE_MEMBER void set(idInteger *uid, real *rho, real *e, real *dedt, real *p, real *cs, real *x,

                                  real *vx, real *ax);


#elif DIM == 2


    CUDA_CALLABLE_MEMBER IntegratedParticles(idInteger *uid, real *rho, real *e, real *dedt, real *p, real *cs, real *x,

                                             real *y, real *vx, real *vy, real *ax, real *ay);


    CUDA_CALLABLE_MEMBER void set(integer *uid, real *rho, real *e, real *dedt, real *p, real *cs, real *x,

                                  real *y, real *vx, real *vy, real *ax, real *ay);


#else


    CUDA_CALLABLE_MEMBER IntegratedParticles(idInteger *uid, real *rho, real *e, real *dedt, real *p, real *cs, real *x,

                                             real *y, real *z, real *vx, real *vy, real *vz, real *ax,

                                             real *ay, real *az);


    CUDA_CALLABLE_MEMBER void set(idInteger *uid, real *rho, real *e, real *dedt, real *p, real *cs, real *x,

                                  real *y, real *z, real *vx, real *vy, real *vz, real *ax,

                                  real *ay, real *az);


#endif


    //CUDA_CALLABLE_MEMBER void setLevel(integer *level);

    //CUDA_CALLABLE_MEMBER void setNodeType(integer *nodeType);


    CUDA_CALLABLE_MEMBER void setSML(real *sml);


//#if INTEGRATE_DENSITY

    CUDA_CALLABLE_MEMBER void setIntegrateDensity(real *drhodt);

//#endif


#if VARIABLE_SML || INTEGRATE_SML

    CUDA_CALLABLE_MEMBER void setIntegrateSML(real *dsmldt);

#endif


    CUDA_CALLABLE_MEMBER void reset(integer index);


    CUDA_CALLABLE_MEMBER ~IntegratedParticles();


};


namespace IntegratedParticlesNS {


    namespace Kernel {


#if DIM == 1


        __global__ void set(IntegratedParticles *integratedParticles, idInteger *uid, real *rho, real *e, real *dedt,

                            real *p, real *cs, real *x, real *vx, real *ax);


        namespace Launch {


            void set(IntegratedParticles *integratedParticles, idInteger *uid, real *rho, real *e, real *dedt,

                     real *p, real *cs, real *x, real *vx, real *ax);

        }


#elif DIM == 2


        __global__ void set(IntegratedParticles *integratedParticles, idInteger *uid, real *rho, real *e, real *dedt,

                            real *p, real *cs, real *x, real *y, real *vx, real *vy, real *ax, real *ay);


        namespace Launch {


            void set(IntegratedParticles *integratedParticles, idInteger *uid, real *rho, real *e, real *dedt,

                     real *p, real *cs, real *x, real *y, real *vx, real *vy, real *ax, real *ay);

        }


#else


        __global__ void set(IntegratedParticles *integratedParticles, idInteger *uid, real *rho, real *e, real *dedt,

                            real *p, real *cs, real *x, real *y, real *z, real *vx, real *vy, real *vz, real *ax,

                            real *ay, real *az);


        namespace Launch {


            void set(IntegratedParticles *integratedParticles, idInteger *uid, real *rho, real *e, real *dedt,

                     real *p, real *cs, real *x, real *y, real *z, real *vx, real *vy, real *vz, real *ax,

                     real *ay, real *az);

        }


#endif


        //__global__ void setLevel(IntegratedParticles *integratedParticles, integer *level);

        //namespace Launch {

        //    void setLevel(IntegratedParticles *integratedParticles, integer *level);

        //}


        //__global__ void setNodeType(IntegratedParticles *integratedParticles, integer *nodeType);

        //namespace Launch {

        //    void setNodeType(IntegratedParticles *integratedParticles, integer *nodeType);

        //}


        __global__ void setSML(IntegratedParticles *integratedParticles, real *sml);


        namespace Launch {

            void setSML(IntegratedParticles *integratedParticles, real *sml);

        }


//#if INTEGRATE_DENSITY

        __global__ void setIntegrateDensity(IntegratedParticles *integratedParticles, real *drhodt);


        namespace Launch {


            void setIntegrateDensity(IntegratedParticles *integratedParticles, real *drhodt);


        }

//#endif


#if VARIABLE_SML || INTEGRATE_SML

        __global__ void setIntegrateSML(IntegratedParticles *integratedParticles, real *dsmldt);


        namespace Launch {

            void setIntegrateSML(IntegratedParticles *integratedParticles, real *dsmldt);

        }

#endif


    }

}


#endif //MILUPHPC_PARTICLES_CUH

IntegratedParticles
Definition: particles.cuh:979

IntegratedParticles::cs
real * cs
Definition: particles.cuh:1011

IntegratedParticles::y
real * y
Definition: particles.cuh:992

IntegratedParticles::ay
real * ay
Definition: particles.cuh:994

IntegratedParticles::rho
real * rho
Definition: particles.cuh:1007

IntegratedParticles::setSML
CUDA_CALLABLE_MEMBER void setSML(real *sml)
Definition: particles.cu:1033

IntegratedParticles::ax
real * ax
Definition: particles.cuh:989

IntegratedParticles::drhodt
real * drhodt
Definition: particles.cuh:1016

IntegratedParticles::vx
real * vx
Definition: particles.cuh:988

IntegratedParticles::IntegratedParticles
CUDA_CALLABLE_MEMBER IntegratedParticles()
Definition: particles.cu:939

IntegratedParticles::p
real * p
Definition: particles.cuh:1010

IntegratedParticles::~IntegratedParticles
CUDA_CALLABLE_MEMBER ~IntegratedParticles()
Definition: particles.cu:1078

IntegratedParticles::reset
CUDA_CALLABLE_MEMBER void reset(integer index)
Definition: particles.cu:1049

IntegratedParticles::uid
idInteger * uid
unique identifier
Definition: particles.cuh:984

IntegratedParticles::az
real * az
Definition: particles.cuh:999

IntegratedParticles::vz
real * vz
Definition: particles.cuh:998

IntegratedParticles::x
real * x
Definition: particles.cuh:987

IntegratedParticles::dedt
real * dedt
Definition: particles.cuh:1009

IntegratedParticles::sml
real * sml
Definition: particles.cuh:1013

IntegratedParticles::z
real * z
Definition: particles.cuh:997

IntegratedParticles::e
real * e
Definition: particles.cuh:1008

IntegratedParticles::vy
real * vy
Definition: particles.cuh:993

IntegratedParticles::setIntegrateDensity
CUDA_CALLABLE_MEMBER void setIntegrateDensity(real *drhodt)
Definition: particles.cu:1038

IntegratedParticles::set
CUDA_CALLABLE_MEMBER void set(idInteger *uid, real *rho, real *e, real *dedt, real *p, real *cs, real *x, real *y, real *z, real *vx, real *vy, real *vz, real *ax, real *ay, real *az)
Definition: particles.cu:1003

Particles
Particle(s) class based on SoA (Structur of Arrays).
Definition: particles.cuh:50

Particles::g_az_old
real * g_az_old
Definition: particles.cuh:97

Particles::noi
integer * noi
(pointer to) number of interactions (array)
Definition: particles.cuh:118

Particles::e
real * e
(pointer to) internal energy (array)
Definition: particles.cuh:121

Particles::ax_old
real * ax_old
Definition: particles.cuh:67

Particles::weightedEntry
CUDA_CALLABLE_MEMBER real weightedEntry(integer index, Entry::Name entry)
Definition: particles.cu:339

Particles::materialId
integer * materialId
(pointer to) material identifier (array)
Definition: particles.cuh:111

Particles::x
real * x
(pointer to) x position (array)
Definition: particles.cuh:62

Particles::rho
real * rho
(pointer to) density (array)
Definition: particles.cuh:133

Particles::level
integer * level
(pointer to) level of the (pseudo-)particles
Definition: particles.cuh:106

Particles::uid
idInteger * uid
(pointer to) unique identifier (array)
Definition: particles.cuh:109

Particles::drhodt
real * drhodt
(pointer to) time derivative of density (array)
Definition: particles.cuh:148

Particles::set
CUDA_CALLABLE_MEMBER void set(integer *numParticles, integer *numNodes, real *mass, real *x, real *y, real *z, real *vx, real *vy, real *vz, real *ax, real *ay, real *az, integer *level, idInteger *uid, integer *materialId, real *sml, integer *nnl, integer *noi, real *e, real *dedt, real *cs, real *rho, real *p)
Setter (DIM = 3) assigning variables to pointer members.
Definition: particles.cu:98

Particles::g_ax_old
real * g_ax_old
Definition: particles.cuh:89

Particles::g_ay
real * g_ay
(pointer to) y gravitational acceleration (array)
Definition: particles.cuh:92

Particles::ay
real * ay
(pointer to) y acceleration (array)
Definition: particles.cuh:74

Particles::nodeType
integer * nodeType
(pointer to) node type
Definition: particles.cuh:103

Particles::nnl
integer * nnl
(pointer to) near(est) neighbor list (array)
Definition: particles.cuh:116

Particles::az
real * az
(pointer to) z acceleration (array)
Definition: particles.cuh:82

Particles::ay_old
real * ay_old
Definition: particles.cuh:75

Particles::p
real * p
(pointer to) pressure (array)
Definition: particles.cuh:135

Particles::cs
real * cs
(pointer to) sound of speed (array)
Definition: particles.cuh:129

Particles::az_old
real * az_old
Definition: particles.cuh:83

Particles::y
real * y
(pointer to) y position (array)
Definition: particles.cuh:70

Particles::g_ay_old
real * g_ay_old
Definition: particles.cuh:93

Particles::ax
real * ax
(pointer to) x acceleration (array)
Definition: particles.cuh:66

Particles::reset
CUDA_CALLABLE_MEMBER void reset(integer index)
Reset (specific) entries.
Definition: particles.cu:279

Particles::u
real * u
energy (kinetic + gravitational for now)
Definition: particles.cuh:126

Particles::g_ax
real * g_ax
(pointer to) x gravitational acceleration (array)
Definition: particles.cuh:88

Particles::Particles
CUDA_CALLABLE_MEMBER Particles()
Definition: particles.cu:4

Particles::~Particles
CUDA_CALLABLE_MEMBER ~Particles()
Definition: particles.cu:361

Particles::sml
real * sml
(pointer to) smoothing length (array)
Definition: particles.cuh:113

Particles::dedt
real * dedt
(pointer to) time derivative of internal energy (array)
Definition: particles.cuh:123

Particles::mass
real * mass
(pointer to) mass (array)
Definition: particles.cuh:60

Particles::z
real * z
(pointer to) z position (array)
Definition: particles.cuh:78

Particles::numParticles
integer * numParticles
number of particles
Definition: particles.cuh:55

Particles::numNodes
integer * numNodes
number of nodes
Definition: particles.cuh:57

Particles::vz
real * vz
(pointer to) z velocity (array)
Definition: particles.cuh:80

Particles::distance
CUDA_CALLABLE_MEMBER real distance(integer index_1, integer index_2)
Distance of two particles.
Definition: particles.cu:292

Particles::setLeapfrog
CUDA_CALLABLE_MEMBER void setLeapfrog(real *ax_old, real *ay_old, real *az_old, real *g_ax_old, real *g_ay_old, real *g_az_old)
Definition: particles.cu:160

Particles::muijmax
real * muijmax
(pointer) to max(mu_ij) (array) needed for artificial viscosity and determining timestp
Definition: particles.cuh:138

Particles::setGravity
CUDA_CALLABLE_MEMBER void setGravity(real *g_ax, real *g_ay, real *g_az)
Constructor (DIM = 3) assigning gravitational acceleration to member variables.
Definition: particles.cu:139

Particles::g_az
real * g_az
(pointer to) z gravitational acceleration (array)
Definition: particles.cuh:96

Particles::vx
real * vx
(pointer to) x velocity (array)
Definition: particles.cuh:64

Particles::setNodeType
CUDA_CALLABLE_MEMBER void setNodeType(integer *nodeType)
Setter for node type.
Definition: particles.cu:175

Particles::vy
real * vy
(pointer to) y velocity (array)
Definition: particles.cuh:72

Particles::setArtificialViscosity
CUDA_CALLABLE_MEMBER void setArtificialViscosity(real *muijmax)
Setter for artificial viscosity (entry).
Definition: particles.cu:179

Particles::setIntegrateDensity
CUDA_CALLABLE_MEMBER void setIntegrateDensity(real *drhodt)
Setter in dependence of INTEGRATE_DENSITY.
Definition: particles.cu:191

Particles::setU
CUDA_CALLABLE_MEMBER void setU(real *u)
Setter for energy.
Definition: particles.cu:171

cuda_utilities.cuh
CUDA utilities.

CUDA_CALLABLE_MEMBER
#define CUDA_CALLABLE_MEMBER
Definition: cuda_utilities.cuh:30

IntegratedParticlesNS::Kernel::Launch::setSML
void setSML(IntegratedParticles *integratedParticles, real *sml)
Definition: particles.cu:1159

IntegratedParticlesNS::Kernel::Launch::setIntegrateDensity
void setIntegrateDensity(IntegratedParticles *integratedParticles, real *drhodt)
Definition: particles.cu:1173

IntegratedParticlesNS::Kernel::Launch::set
void set(IntegratedParticles *integratedParticles, idInteger *uid, real *rho, real *e, real *dedt, real *p, real *cs, real *x, real *y, real *z, real *vx, real *vy, real *vz, real *ax, real *ay, real *az)
Definition: particles.cu:1122

IntegratedParticlesNS::Kernel::set
__global__ void set(IntegratedParticles *integratedParticles, idInteger *uid, real *rho, real *e, real *dedt, real *p, real *cs, real *x, real *y, real *z, real *vx, real *vy, real *vz, real *ax, real *ay, real *az)
Definition: particles.cu:1116

IntegratedParticlesNS::Kernel::setSML
__global__ void setSML(IntegratedParticles *integratedParticles, real *sml)
Definition: particles.cu:1154

IntegratedParticlesNS::Kernel::setIntegrateDensity
__global__ void setIntegrateDensity(IntegratedParticles *integratedParticles, real *drhodt)
Definition: particles.cu:1167

IntegratedParticlesNS
Definition: particles.cuh:1083

Kernel
Definition: device_rhs.cuh:7

ParticlesNS::Kernel::Launch::setU
void setU(Particles *particles, real *u)
Definition: particles.cu:730

ParticlesNS::Kernel::Launch::setIntegrateDensity
void setIntegrateDensity(Particles *particles, real *drhodt)
Definition: particles.cu:774

ParticlesNS::Kernel::Launch::setGravity
void setGravity(Particles *particles, real *g_ax, real *g_ay, real *g_az)
Definition: particles.cu:676

ParticlesNS::Kernel::Launch::setLeapfrog
void setLeapfrog(Particles *particles, real *ax_old, real *ay_old, real *az_old, real *g_ax_old, real *g_ay_old, real *g_az_old)
Definition: particles.cu:716

ParticlesNS::Kernel::Launch::set
void set(Particles *particles, integer *numParticles, integer *numNodes, real *mass, real *x, real *y, real *z, real *vx, real *vy, real *vz, real *ax, real *ay, real *az, integer *level, idInteger *uid, integer *materialId, real *sml, integer *nnl, integer *noi, real *e, real *dedt, real *cs, real *rho, real *p)
Definition: particles.cu:631

ParticlesNS::Kernel::Launch::test
real test(Particles *particles, bool time=false)
Definition: particles.cu:930

ParticlesNS::Kernel::Launch::setNodeType
void setNodeType(Particles *particles, integer *nodeType)
Definition: particles.cu:740

ParticlesNS::Kernel::Launch::info
real info(Particles *particles, integer n, integer m, integer k)
Definition: particles.cu:568

ParticlesNS::Kernel::Launch::check4nans
real check4nans(Particles *particles, integer n)
Definition: particles.cu:563

ParticlesNS::Kernel::Launch::setArtificialViscosity
void setArtificialViscosity(Particles *particles, real *muijmax)
Definition: particles.cu:751

ParticlesNS::Kernel::set
__global__ void set(Particles *particles, integer *numParticles, integer *numNodes, real *mass, real *x, real *y, real *z, real *vx, real *vy, real *vz, real *ax, real *ay, real *az, integer *level, idInteger *uid, integer *materialId, real *sml, integer *nnl, integer *noi, real *e, real *dedt, real *cs, real *rho, real *p)
Definition: particles.cu:621

ParticlesNS::Kernel::setArtificialViscosity
__global__ void setArtificialViscosity(Particles *particles, real *muijmax)
Definition: particles.cu:746

ParticlesNS::Kernel::setNodeType
__global__ void setNodeType(Particles *particles, integer *nodeType)
Definition: particles.cu:736

ParticlesNS::Kernel::setIntegrateDensity
__global__ void setIntegrateDensity(Particles *particles, real *drhodt)
Definition: particles.cu:771

ParticlesNS::Kernel::setGravity
__global__ void setGravity(Particles *particles, real *g_ax, real *g_ay, real *g_az)
Definition: particles.cu:671

ParticlesNS::Kernel::info
__global__ void info(Particles *particles, integer n, integer m, integer k)
Definition: particles.cu:528

ParticlesNS::Kernel::setLeapfrog
__global__ void setLeapfrog(Particles *particles, real *ax_old, real *ay_old, real *az_old, real *g_ax_old, real *g_ay_old, real *g_az_old)
Definition: particles.cu:710

ParticlesNS::Kernel::check4nans
__global__ void check4nans(Particles *particles, integer n)
Definition: particles.cu:432

ParticlesNS::Kernel::setU
__global__ void setU(Particles *particles, real *u)
Definition: particles.cu:725

ParticlesNS::Kernel::test
__global__ void test(Particles *particles)
Definition: particles.cu:902

ParticlesNS
Particle class related functions and kernels.
Definition: particles.cuh:552

ProfilerIds::numParticles
const char *const numParticles
Definition: h5profiler.h:29

parameter.h
Settings via preprocessor directives, typedefs, constants, structs.

real
double real
Definition: parameter.h:15

integer
int integer
Definition: parameter.h:17

idInteger
int idInteger
Definition: parameter.h:19

Entry::Name
Name
Definition: parameter.h:255