particle_handler.h

Go to the documentation of this file.

#ifndef MILUPHPC_PARTICLE_HANDLER_H
#define MILUPHPC_PARTICLE_HANDLER_H
 
#include "parameter.h"
#include "particles.cuh"
#include "utils/logger.h"
#include "cuda_utils/cuda_runtime.h"
 
class IntegratedParticleHandler;
 
class ParticleHandler {
 
public:
 
    bool leapfrog { false }; // TODO: how to change that?
 
    integer numParticles;
    integer numNodes;
 
    real *h_mass;
    real *h_x, *_h_x;
    real *h_vx, *_h_vx;
    real *h_ax, *_h_ax;
    real *h_g_ax;
    real *h_ax_old, *h_g_ax_old; // only for leapfrog integrator
#if DIM > 1
    real *h_y, *_h_y;
    real *h_vy, *_h_vy;
    real *h_ay, *_h_ay;
    real *h_g_ay;
    real *h_ay_old, *h_g_ay_old; // only for leapfrog integrator
#if DIM == 3
    real *h_z, *_h_z;
    real *h_vz, *_h_vz;
    real *h_az, *_h_az;
    real *h_g_az;
    real *h_az_old, *h_g_az_old; // only for leapfrog integrator
#endif
#endif
 
    integer *h_nodeType;
 
    integer *h_level;
    idInteger *h_uid, *_h_uid; // unique identifier (unsigned int/long?)
    integer *h_materialId; // material identfier (e.g.: ice, basalt, ...)
    real *h_sml, *_h_sml; // smoothing length
    integer *h_nnl; // max(number of interactions)
    integer *h_noi; // number of interactions (alternatively initialize nnl with -1, ...)
    real *h_e, *_h_e; // internal energy
    real *h_dedt, *_h_dedt;
    real *h_u;
    real *h_cs, *_h_cs; // soundspeed
    real *h_rho, *_h_rho; // density
    real *h_p, *_h_p; // pressure
    real *h_muijmax;
 
//#if INTEGRATE_DENSITY
    real *h_drhodt, *_h_drhodt;
//#endif
#if VARIABLE_SML || INTEGRATE_SML
    real *h_dsmldt, *_h_dsmldt;
#endif
#if SML_CORRECTION
    real *h_sml_omega;
#endif
#if NAVIER_STOKES
    real *h_Tshear;
    real *h_eta;
#endif
#if SOLID
    real *h_S;
    real *h_dSdt;
    real *h_localStrain;
#endif
#if SOLID || NAVIER_STOKES
    real *h_sigma;
#endif
#if ARTIFICIAL_STRESS
    real *h_R;
#endif
#if BALSARA_SWITCH
    real *h_divv;
    real *h_curlv;
#endif
#if POROSITY
    real *h_pold;
    real *h_alpha_jutzi;
    real *h_alpha_jutzi_old;
    real *h_dalphadt;
    real *h_dalphadp;
    real *h_dp;
    real *h_dalphadrho;
    real *h_f;
    real *h_delpdelrho;
    real *h_delpdele;
    real *h_cs_old;
    real *h_alpha_epspor;
    real *h_dalpha_epspordt;
    real *h_epsilon_v;
    real *h_depsilon_vdt;
#endif
#if ZERO_CONSISTENCY
    real *h_shepardCorrection;
#endif
#if LINEAR_CONSISTENCY
    real *h_tensorialCorrectionMatrix;
#endif
#if FRAGMENTATION
    real *h_d;
    real *h_damage_total;
    real *h_dddt;
    integer *h_numFlaws;
    integer *h_maxNumFlaws;
    integer *h_numActiveFlaws;
    real *h_flaws;
#if PALPHA_POROSITY
    real *h_damage_porjutzi;
    real *h_ddamage_porjutzidt;
#endif
#endif
 
    integer *d_numParticles;
    integer *d_numNodes;
 
    // device particle entries
    real *d_mass;
    real *d_x, *_d_x;
    real *d_vx, *_d_vx;
    real *d_ax, *_d_ax;
    real *d_g_ax;
    real *d_ax_old, *d_g_ax_old; // only for leapfrog integrator
#if DIM > 1
    real *d_y, *_d_y;
    real *d_vy, *_d_vy;
    real *d_ay, *_d_ay;
    real *d_g_ay;
    real *d_ay_old, *d_g_ay_old; // only for leapfrog integrator
#if DIM == 3
    real *d_z, *_d_z;
    real *d_vz, *_d_vz;
    real *d_az, *_d_az;
    real *d_g_az;
    real *d_az_old, *d_g_az_old; // only for leapfrog integrator
#endif
#endif
 
    integer *d_nodeType;
 
    integer *d_level;
    idInteger *d_uid, *_d_uid; // unique identifier (unsigned int/long?)
    integer *d_materialId; // material identfier (e.g.: ice, basalt, ...)
    real *d_sml, *_d_sml; // smoothing length
    integer *d_nnl; // max(number of interactions)
    integer *d_noi; // number of interactions (alternatively initialize nnl with -1, ...)
    real *d_e, *_d_e; // internal energy
    real *d_dedt, *_d_dedt;
    real *d_u;
    real *d_cs, *_d_cs; // soundspeed
    real *d_rho, *_d_rho; // density
    real *d_p, *_d_p; // pressure
    real *d_muijmax;
 
//#if INTEGRATE_DENSITY
    real *d_drhodt, *_d_drhodt;
//#endif
#if VARIABLE_SML || INTEGRATE_SML
    real *d_dsmldt, *_d_dsmldt;
#endif
#if SML_CORRECTION
    real *d_sml_omega;
#endif
#if NAVIER_STOKES
    real *d_Tshear;
    real *d_eta;
#endif
#if SOLID
    real *d_S;
    real *d_dSdt;
    real *d_localStrain;
#endif
#if SOLID || NAVIER_STOKES
    real *d_sigma;
#endif
#if ARTIFICIAL_STRESS
    real *d_R;
#endif
#if BALSARA_SWITCH
    real *d_divv;
    real *d_curlv;
#endif
#if POROSITY
    real *d_pold;
    real *d_alpha_jutzi;
    real *d_alpha_jutzi_old;
    real *d_dalphadt;
    real *d_dalphadp;
    real *d_dp;
    real *d_dalphadrho;
    real *d_f;
    real *d_delpdelrho;
    real *d_delpdele;
    real *d_cs_old;
    real *d_alpha_epspor;
    real *d_dalpha_epspordt;
    real *d_epsilon_v;
    real *d_depsilon_vdt;
#endif
#if ZERO_CONSISTENCY
    real *d_shepardCorrection;
#endif
#if LINEAR_CONSISTENCY
    real *d_tensorialCorrectionMatrix;
#endif
#if FRAGMENTATION
    real *d_d;
    real *d_damage_total;
    real *d_dddt;
    integer *d_numFlaws;
    integer *d_maxNumFlaws;
    integer *d_numActiveFlaws;
    real *d_flaws;
#if PALPHA_POROSITY
    real *d_damage_porjutzi;
    real *d_ddamage_porjutzidt;
#endif
#endif
 
    Particles *h_particles;
    Particles *d_particles;
 
    ParticleHandler(integer numParticles, integer numNodes);
 
    void initLeapfrog();
    void freeLeapfrog();
 
    ~ParticleHandler();
 
    template <typename T>
    T*& getEntry(Entry::Name entry, Execution::Location location = Execution::device);
 
    void setPointer(IntegratedParticleHandler *integratedParticleHandler);
 
    void resetPointer();
 
    void copyMass(To::Target target=To::device, bool includePseudoParticles = false);
 
    void copyUid(To::Target target=To::device);
 
    void copyMatId(To::Target target=To::device);
 
    void copySML(To::Target target=To::device);
 
    void copyPosition(To::Target target=To::device, bool includePseudoParticles = false);
    void copyVelocity(To::Target target=To::device, bool includePseudoParticles = false);
    void copyAcceleration(To::Target target=To::device, bool includePseudoParticles = false);
    void copyDistribution(To::Target target=To::device, bool velocity=true, bool acceleration=true,
                          bool includePseudoParticles = false);
 
    void copySPH(To::Target target);
 
};
 
class IntegratedParticleHandler {
 
public:
 
    integer numParticles;
    integer numNodes;
 
    idInteger *d_uid;
 
    real *d_x;
    real *d_vx;
    real *d_ax;
#if DIM > 1
    real *d_y;
    real *d_vy;
    real *d_ay;
#if DIM == 3
    real *d_z;
    real *d_vz;
    real *d_az;
#endif
#endif
 
    real *d_rho;
    real *d_e;
    real *d_dedt;
    real *d_p;
    real *d_cs;
 
    real *d_sml;
 
//#if INTEGRATE_DENSITY
    real *d_drhodt;
//#endif
 
#if VARIABLE_SML || INTEGRATE_SML
    real *d_dsmldt;
#endif
 
    IntegratedParticles *d_integratedParticles;
 
    IntegratedParticleHandler(integer numParticles, integer numNodes);
 
    ~IntegratedParticleHandler();
 
};
 
#endif //MILUPHPC_PARTICLE_HANDLER_H